| /* | |
| * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd | |
| * Author: Yakir Yang <ykk@rock-chips.com> | |
| * | |
| * This software is licensed under the terms of the GNU General Public | |
| * License version 2, as published by the Free Software Foundation, and | |
| * may be copied, distributed, and modified under those terms. | |
| * | |
| * This program is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| * GNU General Public License for more details. | |
| */ | |
| #include <drm/drmP.h> | |
| #include <drm/drm_crtc_helper.h> | |
| #include "rockchip_drm_drv.h" | |
| #include "rockchip_drm_psr.h" | |
| #define PSR_FLUSH_TIMEOUT msecs_to_jiffies(100) | |
| enum psr_state { | |
| PSR_FLUSH, | |
| PSR_ENABLE, | |
| PSR_DISABLE, | |
| }; | |
| struct psr_drv { | |
| struct list_head list; | |
| struct drm_encoder *encoder; | |
| spinlock_t lock; | |
| bool active; | |
| enum psr_state state; | |
| struct timer_list flush_timer; | |
| void (*set)(struct drm_encoder *encoder, bool enable); | |
| }; | |
| static struct psr_drv *find_psr_by_crtc(struct drm_crtc *crtc) | |
| { | |
| 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); | |
| 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); | |
| return psr; | |
| } | |
| static void psr_set_state_locked(struct psr_drv *psr, enum psr_state state) | |
| { | |
| /* | |
| * Allowed finite state machine: | |
| * | |
| * PSR_ENABLE < = = = = = > PSR_FLUSH | |
| * | ^ | | |
| * | | | | |
| * v | | | |
| * PSR_DISABLE < - - - - - - - - - | |
| */ | |
| if (state == psr->state || !psr->active) | |
| return; | |
| /* Already disabled in flush, change the state, but not the hardware */ | |
| if (state == PSR_DISABLE && psr->state == PSR_FLUSH) { | |
| psr->state = state; | |
| return; | |
| } | |
| psr->state = state; | |
| /* Actually commit the state change to hardware */ | |
| switch (psr->state) { | |
| case PSR_ENABLE: | |
| psr->set(psr->encoder, true); | |
| break; | |
| case PSR_DISABLE: | |
| case PSR_FLUSH: | |
| psr->set(psr->encoder, false); | |
| break; | |
| } | |
| } | |
| static void psr_set_state(struct psr_drv *psr, enum psr_state state) | |
| { | |
| unsigned long flags; | |
| spin_lock_irqsave(&psr->lock, flags); | |
| psr_set_state_locked(psr, state); | |
| spin_unlock_irqrestore(&psr->lock, flags); | |
| } | |
| static void psr_flush_handler(unsigned long data) | |
| { | |
| struct psr_drv *psr = (struct psr_drv *)data; | |
| unsigned long flags; | |
| /* If the state has changed since we initiated the flush, do nothing */ | |
| spin_lock_irqsave(&psr->lock, flags); | |
| if (psr->state == PSR_FLUSH) | |
| psr_set_state_locked(psr, PSR_ENABLE); | |
| spin_unlock_irqrestore(&psr->lock, flags); | |
| } | |
| /** | |
| * rockchip_drm_psr_activate - activate PSR on the given pipe | |
| * @crtc: CRTC to obtain the PSR encoder | |
| * | |
| * Returns: | |
| * Zero on success, negative errno on failure. | |
| */ | |
| int rockchip_drm_psr_activate(struct drm_crtc *crtc) | |
| { | |
| struct psr_drv *psr = find_psr_by_crtc(crtc); | |
| unsigned long flags; | |
| if (IS_ERR(psr)) | |
| return PTR_ERR(psr); | |
| spin_lock_irqsave(&psr->lock, flags); | |
| psr->active = true; | |
| spin_unlock_irqrestore(&psr->lock, flags); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(rockchip_drm_psr_activate); | |
| /** | |
| * rockchip_drm_psr_deactivate - deactivate PSR on the given pipe | |
| * @crtc: CRTC to obtain the PSR encoder | |
| * | |
| * Returns: | |
| * Zero on success, negative errno on failure. | |
| */ | |
| int rockchip_drm_psr_deactivate(struct drm_crtc *crtc) | |
| { | |
| struct psr_drv *psr = find_psr_by_crtc(crtc); | |
| unsigned long flags; | |
| if (IS_ERR(psr)) | |
| return PTR_ERR(psr); | |
| spin_lock_irqsave(&psr->lock, flags); | |
| psr->active = false; | |
| spin_unlock_irqrestore(&psr->lock, flags); | |
| del_timer_sync(&psr->flush_timer); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(rockchip_drm_psr_deactivate); | |
| 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); | |
| } | |
| /** | |
| * rockchip_drm_psr_flush - flush a single pipe | |
| * @crtc: CRTC of the pipe to flush | |
| * | |
| * Returns: | |
| * 0 on success, -errno on fail | |
| */ | |
| int rockchip_drm_psr_flush(struct drm_crtc *crtc) | |
| { | |
| struct psr_drv *psr = find_psr_by_crtc(crtc); | |
| if (IS_ERR(psr)) | |
| return PTR_ERR(psr); | |
| rockchip_drm_do_flush(psr); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(rockchip_drm_psr_flush); | |
| /** | |
| * rockchip_drm_psr_flush_all - force to flush all registered PSR encoders | |
| * @dev: drm device | |
| * | |
| * Disable the PSR function for all registered encoders, and then enable the | |
| * PSR function back after PSR_FLUSH_TIMEOUT. If encoder PSR state have been | |
| * changed during flush time, then keep the state no change after flush | |
| * timeout. | |
| * | |
| * Returns: | |
| * Zero on success, negative errno on failure. | |
| */ | |
| void rockchip_drm_psr_flush_all(struct drm_device *dev) | |
| { | |
| 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); | |
| list_for_each_entry(psr, &drm_drv->psr_list, list) | |
| rockchip_drm_do_flush(psr); | |
| spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags); | |
| } | |
| EXPORT_SYMBOL(rockchip_drm_psr_flush_all); | |
| /** | |
| * rockchip_drm_psr_register - register encoder to psr driver | |
| * @encoder: encoder that obtain the PSR function | |
| * @psr_set: call back to set PSR state | |
| * | |
| * Returns: | |
| * Zero on success, negative errno on failure. | |
| */ | |
| int rockchip_drm_psr_register(struct drm_encoder *encoder, | |
| void (*psr_set)(struct drm_encoder *, bool enable)) | |
| { | |
| struct rockchip_drm_private *drm_drv = encoder->dev->dev_private; | |
| struct psr_drv *psr; | |
| unsigned long flags; | |
| if (!encoder || !psr_set) | |
| return -EINVAL; | |
| psr = kzalloc(sizeof(struct psr_drv), GFP_KERNEL); | |
| if (!psr) | |
| return -ENOMEM; | |
| setup_timer(&psr->flush_timer, psr_flush_handler, (unsigned long)psr); | |
| spin_lock_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); | |
| list_add_tail(&psr->list, &drm_drv->psr_list); | |
| spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(rockchip_drm_psr_register); | |
| /** | |
| * rockchip_drm_psr_unregister - unregister encoder to psr driver | |
| * @encoder: encoder that obtain the PSR function | |
| * @psr_set: call back to set PSR state | |
| * | |
| * Returns: | |
| * Zero on success, negative errno on failure. | |
| */ | |
| void rockchip_drm_psr_unregister(struct drm_encoder *encoder) | |
| { | |
| 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); | |
| list_for_each_entry_safe(psr, n, &drm_drv->psr_list, list) { | |
| if (psr->encoder == encoder) { | |
| del_timer(&psr->flush_timer); | |
| list_del(&psr->list); | |
| kfree(psr); | |
| } | |
| } | |
| spin_unlock_irqrestore(&drm_drv->psr_list_lock, flags); | |
| } | |
| EXPORT_SYMBOL(rockchip_drm_psr_unregister); |