Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5182c1a5 authored by Yakir Yang's avatar Yakir Yang Committed by Sean Paul
Browse files

drm/rockchip: add an common abstracted PSR driver 



The PSR driver have exported four symbols for specific device driver, and
it's safe to call them in interrupt context:
- rockchip_drm_psr_register()
- rockchip_drm_psr_unregister()
- rockchip_drm_psr_enable()
- rockchip_drm_psr_disable()
- rockchip_drm_psr_flush()

Encoder driver should call the register/unregister interfaces to hook
itself into common PSR driver, encoder have implement the 'psr_set'
callback which use the set PSR state in hardware side.

Crtc driver would call the enable/disable interfaces when vblank is
enable/disable, after that the common PSR driver would call the encoder
registered callback to set the PSR state.

Fb driver would call the flush interface in 'fb->dirty' callback, this
helper function would force all PSR enabled encoders to exit from PSR
for 3 seconds.

Signed-off-by: default avatarYakir Yang <ykk@rock-chips.com>
[seanpaul removed leftover psr_enabled/psr_work kruft from drm_vop.c]
Signed-off-by: default avatarSean Paul <seanpaul@chromium.org>
parent 69c34e41

drivers/gpu/drm/rockchip/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ 
# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.



rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_fb.o \

		rockchip_drm_gem.o rockchip_drm_vop.o

		rockchip_drm_gem.o rockchip_drm_psr.o rockchip_drm_vop.o

rockchipdrm-$(CONFIG_DRM_FBDEV_EMULATION) += rockchip_drm_fbdev.o



obj-$(CONFIG_ROCKCHIP_ANALOGIX_DP) += analogix_dp-rockchip.o

drivers/gpu/drm/rockchip/rockchip_drm_drv.c

+3 −0
Original line number Diff line number Diff line
@@ -156,6 +156,9 @@ static int rockchip_drm_bind(struct device *dev) 


	drm_dev->dev_private = private;



	INIT_LIST_HEAD(&private->psr_list);

	mutex_init(&private->psr_list_mutex);



	drm_mode_config_init(drm_dev);



	rockchip_drm_mode_config_init(drm_dev);

drivers/gpu/drm/rockchip/rockchip_drm_drv.h

+3 −0
Original line number Diff line number Diff line
@@ -61,6 +61,9 @@ struct rockchip_drm_private { 
	struct drm_gem_object *fbdev_bo;

	const struct rockchip_crtc_funcs *crtc_funcs[ROCKCHIP_MAX_CRTC];

	struct drm_atomic_state *state;



	struct list_head psr_list;

	struct mutex psr_list_mutex;

};



int rockchip_register_crtc_funcs(struct drm_crtc *crtc,

drivers/gpu/drm/rockchip/rockchip_drm_fb.c

+12 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include "rockchip_drm_drv.h"

#include "rockchip_drm_fb.h"

#include "rockchip_drm_gem.h"

#include "rockchip_drm_psr.h"



#define to_rockchip_fb(x) container_of(x, struct rockchip_drm_fb, fb)
@@ -63,9 +64,20 @@ static int rockchip_drm_fb_create_handle(struct drm_framebuffer *fb, 
				     rockchip_fb->obj[0], handle);

}



static int rockchip_drm_fb_dirty(struct drm_framebuffer *fb,

				 struct drm_file *file,

				 unsigned int flags, unsigned int color,

				 struct drm_clip_rect *clips,

				 unsigned int num_clips)

{

	rockchip_drm_psr_flush(fb->dev);

	return 0;

}



static const struct drm_framebuffer_funcs rockchip_drm_fb_funcs = {

	.destroy	= rockchip_drm_fb_destroy,

	.create_handle	= rockchip_drm_fb_create_handle,

	.dirty		= rockchip_drm_fb_dirty,

};



static struct rockchip_drm_fb *

drivers/gpu/drm/rockchip/rockchip_drm_psr.c

0 → 100644
+249 −0
Original line number Diff line number Diff line 
/*

 * 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(3000) /* 3 seconds */

#define PSR_SET_DELAY_TIME	msecs_to_jiffies(10)



enum psr_state {

	PSR_FLUSH,

	PSR_ENABLE,

	PSR_DISABLE,

};



struct psr_drv {

	struct list_head	list;

	struct drm_encoder	*encoder;



	enum psr_state		request_state;

	enum psr_state		state;



	struct delayed_work	state_work;



	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;



	list_for_each_entry(psr, &drm_drv->psr_list, list)

		if (psr->encoder->crtc == crtc)

			return psr;



	return ERR_PTR(-ENODEV);

}



static void psr_state_work(struct work_struct *work)

{

	struct psr_drv *psr = container_of(work, typeof(*psr), state_work.work);

	enum psr_state request_state = psr->request_state;



	/*

	 * Allowed finite state machine:

	 *

	 *   PSR_ENABLE  < = = = = = >  PSR_FLUSH

	  *      | ^                        |

	  *      | |                        |

	  *      v |                        |

	 *   PSR_DISABLE < - - - - - - - - -

	 */



	/* Forbid no state change */

	if (request_state == psr->state)

		return;



	/* Forbid DISABLE change to FLUSH */

	if (request_state == PSR_FLUSH && psr->state == PSR_DISABLE)

		return;



	/* Allow but no need hardware change, just need assign the state */

	if (request_state == PSR_DISABLE && psr->state == PSR_FLUSH) {

		psr->state = request_state;

		return;

	}



	/* Only wrote in this work, no need lock protection */

	psr->state = request_state;



	/* Refact to hardware state change */

	switch (request_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)

{

	psr->request_state = state;



	schedule_delayed_work(&psr->state_work, PSR_SET_DELAY_TIME);

}



static void psr_flush_handler(unsigned long data)

{

	struct psr_drv *psr = (struct psr_drv *)data;



	if (!psr)

		return;



	/* State changed between flush time, then keep it */

	if (psr->request_state != PSR_FLUSH)

		return;



	psr_set_state(psr, PSR_ENABLE);

}



/**

 * rockchip_drm_psr_enable - enable the encoder PSR which bind to given CRTC

 * @crtc: CRTC to obtain the PSR encoder

 *

 * Returns:

 * Zero on success, negative errno on failure.

 */

int rockchip_drm_psr_enable(struct drm_crtc *crtc)

{

	struct psr_drv *psr = find_psr_by_crtc(crtc);



	if (IS_ERR(psr))

		return PTR_ERR(psr);



	psr_set_state(psr, PSR_ENABLE);

	return 0;

}

EXPORT_SYMBOL(rockchip_drm_psr_enable);



/**

 * rockchip_drm_psr_disable - disable the encoder PSR which bind to given CRTC

 * @crtc: CRTC to obtain the PSR encoder

 *

 * Returns:

 * Zero on success, negative errno on failure.

 */

int rockchip_drm_psr_disable(struct drm_crtc *crtc)

{

	struct psr_drv *psr = find_psr_by_crtc(crtc);



	if (IS_ERR(psr))

		return PTR_ERR(psr);



	psr_set_state(psr, PSR_DISABLE);

	return 0;

}

EXPORT_SYMBOL(rockchip_drm_psr_disable);



/**

 * rockchip_drm_psr_flush - 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(struct drm_device *dev)

{

	struct rockchip_drm_private *drm_drv = dev->dev_private;

	struct psr_drv *psr;



	list_for_each_entry(psr, &drm_drv->psr_list, list) {

		if (psr->request_state == PSR_DISABLE)

			continue;



		mod_timer(&psr->flush_timer,

			  round_jiffies_up(jiffies + PSR_FLUSH_TIMEOUT));



		psr_set_state(psr, PSR_FLUSH);

	}

}

EXPORT_SYMBOL(rockchip_drm_psr_flush);



/**

 * 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;



	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);



	INIT_DELAYED_WORK(&psr->state_work, psr_state_work);



	psr->state = PSR_DISABLE;

	psr->encoder = encoder;

	psr->set = psr_set;



	mutex_lock(&drm_drv->psr_list_mutex);

	list_add_tail(&psr->list, &drm_drv->psr_list);

	mutex_unlock(&drm_drv->psr_list_mutex);



	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;



	mutex_lock(&drm_drv->psr_list_mutex);

	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);

		}

	}

	mutex_unlock(&drm_drv->psr_list_mutex);

}

EXPORT_SYMBOL(rockchip_drm_psr_unregister);