Release 4.18 drivers/gpu/drm/rockchip/rockchip_drm_psr.c

/*
 * 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_MS	100


struct psr_drv {
	
struct list_head	list;
	
struct drm_encoder	*encoder;

	
struct mutex		lock;
	
int			inhibit_count;
	
bool			enabled;

	
struct delayed_work	flush_work;

	
int (*set)(struct drm_encoder *encoder, bool enable);
};



static struct psr_drv *find_psr_by_encoder(struct drm_encoder *encoder)
{
	struct rockchip_drm_private *drm_drv = encoder->dev->dev_private;
	struct psr_drv *psr;

	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:
	mutex_unlock(&drm_drv->psr_list_lock);
	return psr;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Zain Wang
77
97.47%
1
50.00%
Sean Paul
2
2.53%
1
50.00%
Total
79
100.00%
2
100.00%



static int psr_set_state_locked(struct psr_drv *psr, bool enable)
{
	int ret;

	if (psr->inhibit_count > 0)
		return -EINVAL;

	if (enable == psr->enabled)
		return 0;

	ret = psr->set(psr->encoder, enable);
	if (ret)
		return ret;

	psr->enabled = enable;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Tomasz Figa
30
43.48%
2
28.57%
Yakir Yang
26
37.68%
1
14.29%
Sean Paul
7
10.14%
3
42.86%
Zain Wang
6
8.70%
1
14.29%
Total
69
100.00%
7
100.00%



static void psr_flush_handler(struct work_struct *work)
{
	struct psr_drv *psr = container_of(to_delayed_work(work),
					   struct psr_drv, flush_work);

	mutex_lock(&psr->lock);
	psr_set_state_locked(psr, true);
	mutex_unlock(&psr->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Sean Paul
27
51.92%
2
40.00%
Yakir Yang
18
34.62%
1
20.00%
Kees Cook
6
11.54%
1
20.00%
Tomasz Figa
1
1.92%
1
20.00%
Total
52
100.00%
5
100.00%

/**
 * rockchip_drm_psr_inhibit_put - release PSR inhibit on given encoder
 * @encoder: encoder to obtain the PSR encoder
 *
 * Decrements PSR inhibit count on given encoder. Should be called only
 * for a PSR inhibit count increment done before. If PSR inhibit counter
 * reaches zero, PSR flush work is scheduled to make the hardware enter
 * PSR mode in PSR_FLUSH_TIMEOUT_MS.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */


int rockchip_drm_psr_inhibit_put(struct drm_encoder *encoder)
{
	struct psr_drv *psr = find_psr_by_encoder(encoder);

	if (IS_ERR(psr))
		return PTR_ERR(psr);

	mutex_lock(&psr->lock);
	--psr->inhibit_count;
	WARN_ON(psr->inhibit_count < 0);
	if (!psr->inhibit_count)
		mod_delayed_work(system_wq, &psr->flush_work,
				 PSR_FLUSH_TIMEOUT_MS);
	mutex_unlock(&psr->lock);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Yakir Yang
35
41.18%
1
20.00%
Tomasz Figa
31
36.47%
1
20.00%
Sean Paul
15
17.65%
2
40.00%
Zain Wang
4
4.71%
1
20.00%
Total
85
100.00%
5
100.00%

EXPORT_SYMBOL(rockchip_drm_psr_inhibit_put);

/**
 * rockchip_drm_psr_inhibit_get - acquire PSR inhibit on given encoder
 * @encoder: encoder to obtain the PSR encoder
 *
 * Increments PSR inhibit count on given encoder. This function guarantees
 * that after it returns PSR is turned off on given encoder and no PSR-related
 * hardware state change occurs at least until a matching call to
 * rockchip_drm_psr_inhibit_put() is done.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */


int rockchip_drm_psr_inhibit_get(struct drm_encoder *encoder)
{
	struct psr_drv *psr = find_psr_by_encoder(encoder);

	if (IS_ERR(psr))
		return PTR_ERR(psr);

	mutex_lock(&psr->lock);
	psr_set_state_locked(psr, false);
	++psr->inhibit_count;
	mutex_unlock(&psr->lock);
	cancel_delayed_work_sync(&psr->flush_work);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Sean Paul
31
43.06%
2
33.33%
Yakir Yang
27
37.50%
1
16.67%
Tomasz Figa
10
13.89%
2
33.33%
Zain Wang
4
5.56%
1
16.67%
Total
72
100.00%
6
100.00%

EXPORT_SYMBOL(rockchip_drm_psr_inhibit_get);



static void rockchip_drm_do_flush(struct psr_drv *psr)
{
	cancel_delayed_work_sync(&psr->flush_work);

	mutex_lock(&psr->lock);
	if (!psr_set_state_locked(psr, false))
		mod_delayed_work(system_wq, &psr->flush_work,
				 PSR_FLUSH_TIMEOUT_MS);
	mutex_unlock(&psr->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Tomasz Figa
30
52.63%
1
25.00%
Sean Paul
24
42.11%
2
50.00%
Yakir Yang
3
5.26%
1
25.00%
Total
57
100.00%
4
100.00%

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

	mutex_lock(&drm_drv->psr_list_lock);
	list_for_each_entry(psr, &drm_drv->psr_list, list)
		rockchip_drm_do_flush(psr);
	mutex_unlock(&drm_drv->psr_list_lock);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Yakir Yang
35
66.04%
1
25.00%
Sean Paul
18
33.96%
3
75.00%
Total
53
100.00%
4
100.00%

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
 *
 * The function returns with PSR inhibit counter initialized with one
 * and the caller (typically encoder driver) needs to call
 * rockchip_drm_psr_inhibit_put() when it becomes ready to accept PSR
 * enable request.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */


int rockchip_drm_psr_register(struct drm_encoder *encoder,
			int (*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;

	INIT_DELAYED_WORK(&psr->flush_work, psr_flush_handler);
	mutex_init(&psr->lock);

	psr->inhibit_count = 1;
	psr->enabled = false;
	psr->encoder = encoder;
	psr->set = psr_set;

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

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Yakir Yang
125
84.46%
1
12.50%
Sean Paul
18
12.16%
4
50.00%
Tomasz Figa
4
2.70%
2
25.00%
Zain Wang
1
0.68%
1
12.50%
Total
148
100.00%
8
100.00%

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
 *
 * It is expected that the PSR inhibit counter is 1 when this function is
 * called, which corresponds to a state when related encoder has been
 * disconnected from any CRTCs and its driver called
 * rockchip_drm_psr_inhibit_get() to stop the PSR logic.
 *
 * 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_lock);
	list_for_each_entry_safe(psr, n, &drm_drv->psr_list, list) {
		if (psr->encoder == encoder) {
			/*
                         * Any other value would mean that the encoder
                         * is still in use.
                         */
			WARN_ON(psr->inhibit_count != 1);

			list_del(&psr->list);
			kfree(psr);
		}
	}
	mutex_unlock(&drm_drv->psr_list_lock);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Yakir Yang
81
90.00%
1
25.00%
Tomasz Figa
5
5.56%
1
25.00%
Sean Paul
4
4.44%
2
50.00%
Total
90
100.00%
4
100.00%

EXPORT_SYMBOL(rockchip_drm_psr_unregister);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Yakir Yang
414
52.08%
1
8.33%
Sean Paul
161
20.25%
6
50.00%
Tomasz Figa
121
15.22%
2
16.67%
Zain Wang
93
11.70%
2
16.67%
Kees Cook
6
0.75%
1
8.33%
Total
795
100.00%
12
100.00%
Directory: drivers/gpu/drm/rockchip

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.