drm/rockchip: Don't use atomic constructs for psr

Instead of using timer and spinlocks, use delayed_work and mutexes for rockchip psr. This allows us to make blocking calls when enabling/disabling psr (which is sort of important given we're talking over dpcd to the display).

Sean Paul committed 8 years ago

Commit 60beecc1 parent 7f3c1913 files · +31 −41Browse files

Unified · Split

3 files

drivers/gpu/drm/rockchip/rockchip_drm_drv.c +1 −1
drivers/gpu/drm/rockchip/rockchip_drm_drv.h +1 −1
drivers/gpu/drm/rockchip/rockchip_drm_psr.c +29 −39

drivers/gpu/drm/rockchip/rockchip_drm_drv.c+1−1

@@ -134,7 +134,7 @@ static int rockchip_drm_bind(struct device *dev) · 133 unmodified lines
134	drm_dev->dev_private = private;	134	drm_dev->dev_private = private;
135		135
136	INIT_LIST_HEAD(&private->psr_list);	136	INIT_LIST_HEAD(&private->psr_list);
137	spin_lock_init(&private->psr_list_lock);	137	mutex_init(&private->psr_list_lock);
138		138
139	ret = rockchip_drm_init_iommu(drm_dev);	139	ret = rockchip_drm_init_iommu(drm_dev);
140	if (ret)	140	if (ret)

drivers/gpu/drm/rockchip/rockchip_drm_drv.h+1−1

@@ -55,7 +55,7 @@ struct rockchip_drm_private { · 54 unmodified lines
55	struct mutex mm_lock;	55	struct mutex mm_lock;
56	struct drm_mm mm;	56	struct drm_mm mm;
57	struct list_head psr_list;	57	struct list_head psr_list;
58	spinlock_t psr_list_lock;	58	struct mutex psr_list_lock;
59	};	59	};
60		60
61	int rockchip_drm_dma_attach_device(struct drm_device *drm_dev,	61	int rockchip_drm_dma_attach_device(struct drm_device *drm_dev,

drivers/gpu/drm/rockchip/rockchip_drm_psr.c+29−39

 #include "rockchip_drm_drv.h"
 #include "rockchip_drm_psr.h"
-#define PSR_FLUSH_TIMEOUT	msecs_to_jiffies(100)
+#define PSR_FLUSH_TIMEOUT_MS	100
 enum psr_state {
 	PSR_FLUSH,
 	struct list_head	list;
 	struct drm_encoder	*encoder;
-	spinlock_t		lock;
+	struct mutex		lock;
 	bool			active;
 	enum psr_state		state;
-	struct timer_list	flush_timer;
+	struct delayed_work	flush_work;
 	void (*set)(struct drm_encoder *encoder, bool enable);
 };
 {
 	struct rockchip_drm_private *drm_drv = crtc->dev->dev_private;
 	struct psr_drv *psr;
-	unsigned long flags;
-	spin_lock_irqsave(&drm_drv->psr_list_lock, flags);
+	mutex_lock(&drm_drv->psr_list_lock);
 	list_for_each_entry(psr, &drm_drv->psr_list, list) {
 		if (psr->encoder->crtc == crtc)
 			goto out;
 	psr = ERR_PTR(-ENODEV);
 out:
-	spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags);
+	mutex_unlock(&drm_drv->psr_list_lock);
 	return psr;
 }
 {
 	struct rockchip_drm_private *drm_drv = encoder->dev->dev_private;
 	struct psr_drv *psr;
-	unsigned long flags;
-	spin_lock_irqsave(&drm_drv->psr_list_lock, flags);
+	mutex_lock(&drm_drv->psr_list_lock);
 	list_for_each_entry(psr, &drm_drv->psr_list, list) {
 		if (psr->encoder == encoder)
 			goto out;
 	psr = ERR_PTR(-ENODEV);
 out:
-	spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags);
+	mutex_unlock(&drm_drv->psr_list_lock);
 	return psr;
 }
 static void psr_set_state(struct psr_drv *psr, enum psr_state state)
 {
-	unsigned long flags;
+	mutex_lock(&psr->lock);
-	spin_lock_irqsave(&psr->lock, flags);
 	psr_set_state_locked(psr, state);
-	spin_unlock_irqrestore(&psr->lock, flags);
+	mutex_unlock(&psr->lock);
 }
-static void psr_flush_handler(struct timer_list *t)
+static void psr_flush_handler(struct work_struct *work)
 {
-	struct psr_drv *psr = from_timer(psr, t, flush_timer);
+	struct psr_drv *psr = container_of(to_delayed_work(work),
-	unsigned long flags;
+					   struct psr_drv, flush_work);
 	/* If the state has changed since we initiated the flush, do nothing */
-	spin_lock_irqsave(&psr->lock, flags);
+	mutex_lock(&psr->lock);
 	if (psr->state == PSR_FLUSH)
 		psr_set_state_locked(psr, PSR_ENABLE);
-	spin_unlock_irqrestore(&psr->lock, flags);
+	mutex_unlock(&psr->lock);
 }
 /**
 int rockchip_drm_psr_activate(struct drm_encoder *encoder)
 {
 	struct psr_drv *psr = find_psr_by_encoder(encoder);
-	unsigned long flags;
 	if (IS_ERR(psr))
 		return PTR_ERR(psr);
-	spin_lock_irqsave(&psr->lock, flags);
+	mutex_lock(&psr->lock);
 	psr->active = true;
-	spin_unlock_irqrestore(&psr->lock, flags);
+	mutex_unlock(&psr->lock);
 	return 0;
 }
 int rockchip_drm_psr_deactivate(struct drm_encoder *encoder)
 {
 	struct psr_drv *psr = find_psr_by_encoder(encoder);
-	unsigned long flags;
 	if (IS_ERR(psr))
 		return PTR_ERR(psr);
-	spin_lock_irqsave(&psr->lock, flags);
+	mutex_lock(&psr->lock);
 	psr->active = false;
-	spin_unlock_irqrestore(&psr->lock, flags);
+	mutex_unlock(&psr->lock);
-	del_timer_sync(&psr->flush_timer);
+	cancel_delayed_work_sync(&psr->flush_work);
 	return 0;
 }
 static void rockchip_drm_do_flush(struct psr_drv *psr)
 {
-	mod_timer(&psr->flush_timer,
-		  round_jiffies_up(jiffies + PSR_FLUSH_TIMEOUT));
 	psr_set_state(psr, PSR_FLUSH);
+	mod_delayed_work(system_wq, &psr->flush_work, PSR_FLUSH_TIMEOUT_MS);
 }
 /**
 {
 	struct rockchip_drm_private *drm_drv = dev->dev_private;
 	struct psr_drv *psr;
-	unsigned long flags;
-	spin_lock_irqsave(&drm_drv->psr_list_lock, flags);
+	mutex_lock(&drm_drv->psr_list_lock);
 	list_for_each_entry(psr, &drm_drv->psr_list, list)
 		rockchip_drm_do_flush(psr);
-	spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags);
+	mutex_unlock(&drm_drv->psr_list_lock);
 }
 EXPORT_SYMBOL(rockchip_drm_psr_flush_all);
 {
 	struct rockchip_drm_private *drm_drv = encoder->dev->dev_private;
 	struct psr_drv *psr;
-	unsigned long flags;
 	if (!encoder || !psr_set)
 		return -EINVAL;
 	if (!psr)
 		return -ENOMEM;
-	timer_setup(&psr->flush_timer, psr_flush_handler, 0);
+	INIT_DELAYED_WORK(&psr->flush_work, psr_flush_handler);
-	spin_lock_init(&psr->lock);
+	mutex_init(&psr->lock);
 	psr->active = true;
 	psr->state = PSR_DISABLE;
 	psr->encoder = encoder;
 	psr->set = psr_set;
-	spin_lock_irqsave(&drm_drv->psr_list_lock, flags);
+	mutex_lock(&drm_drv->psr_list_lock);
 	list_add_tail(&psr->list, &drm_drv->psr_list);
-	spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags);
+	mutex_unlock(&drm_drv->psr_list_lock);
 	return 0;
 }
 {
 	struct rockchip_drm_private *drm_drv = encoder->dev->dev_private;
 	struct psr_drv *psr, *n;
-	unsigned long flags;
-	spin_lock_irqsave(&drm_drv->psr_list_lock, flags);
+	mutex_lock(&drm_drv->psr_list_lock);
 	list_for_each_entry_safe(psr, n, &drm_drv->psr_list, list) {
 		if (psr->encoder == encoder) {
-			del_timer(&psr->flush_timer);
+			cancel_delayed_work_sync(&psr->flush_work);
 			list_del(&psr->list);
 			kfree(psr);
 		}
 	}
-	spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags);
+	mutex_unlock(&drm_drv->psr_list_lock);
 }
 EXPORT_SYMBOL(rockchip_drm_psr_unregister);

drm/rockchip: Don't use atomic constructs for psr

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code