Commit 19969707 authored by Martin Blumenstingl's avatar Martin Blumenstingl Committed by Qiang Yu
Browse files

drm/lima: Add optional devfreq and cooling device support 



Most platforms with a Mali-400 or Mali-450 GPU also have support for
changing the GPU clock frequency. Add devfreq support so the GPU clock
rate is updated based on the actual GPU usage when the
"operating-points-v2" property is present in the board.dts.

The actual devfreq code is taken from panfrost_devfreq.c and modified so
it matches what the lima hardware needs:
- a call to dev_pm_opp_set_clkname() during initialization because there
  are two clocks on Mali-4x0 IPs. "core" is the one that actually clocks
  the GPU so we need to control it using devfreq.
- locking when reading or writing the devfreq statistics because (unlike
  than panfrost) we have multiple PP and GP IRQs which may finish jobs
  concurrently.

Signed-off-by: default avatarMartin Blumenstingl <martin.blumenstingl@googlemail.com>
Signed-off-by: default avatarQiang Yu <yuq825@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20200319203427.2259891-3-martin.blumenstingl@googlemail.com
parent 6bb0942e

drivers/gpu/drm/lima/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -10,5 +10,7 @@ config DRM_LIMA 
       depends on OF

       select DRM_SCHED

       select DRM_GEM_SHMEM_HELPER

       select PM_DEVFREQ

       select DEVFREQ_GOV_SIMPLE_ONDEMAND

       help

	 DRM driver for ARM Mali 400/450 GPUs.

drivers/gpu/drm/lima/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ lima-y := \ 
	lima_ctx.o \

	lima_dlbu.o \

	lima_bcast.o \

	lima_trace.o

	lima_trace.o \

	lima_devfreq.o



obj-$(CONFIG_DRM_LIMA) += lima.o

drivers/gpu/drm/lima/lima_devfreq.c

0 → 100644
+234 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright 2020 Martin Blumenstingl <martin.blumenstingl@googlemail.com>

 *

 * Based on panfrost_devfreq.c:

 *   Copyright 2019 Collabora ltd.

 */

#include <linux/clk.h>

#include <linux/devfreq.h>

#include <linux/devfreq_cooling.h>

#include <linux/device.h>

#include <linux/platform_device.h>

#include <linux/pm_opp.h>

#include <linux/property.h>



#include "lima_device.h"

#include "lima_devfreq.h"



static void lima_devfreq_update_utilization(struct lima_devfreq *devfreq)

{

	ktime_t now, last;



	now = ktime_get();

	last = devfreq->time_last_update;



	if (devfreq->busy_count > 0)

		devfreq->busy_time += ktime_sub(now, last);

	else

		devfreq->idle_time += ktime_sub(now, last);



	devfreq->time_last_update = now;

}



static int lima_devfreq_target(struct device *dev, unsigned long *freq,

			       u32 flags)

{

	struct dev_pm_opp *opp;

	int err;



	opp = devfreq_recommended_opp(dev, freq, flags);

	if (IS_ERR(opp))

		return PTR_ERR(opp);

	dev_pm_opp_put(opp);



	err = dev_pm_opp_set_rate(dev, *freq);

	if (err)

		return err;



	return 0;

}



static void lima_devfreq_reset(struct lima_devfreq *devfreq)

{

	devfreq->busy_time = 0;

	devfreq->idle_time = 0;

	devfreq->time_last_update = ktime_get();

}



static int lima_devfreq_get_dev_status(struct device *dev,

				       struct devfreq_dev_status *status)

{

	struct lima_device *ldev = dev_get_drvdata(dev);

	struct lima_devfreq *devfreq = &ldev->devfreq;

	unsigned long irqflags;



	status->current_frequency = clk_get_rate(ldev->clk_gpu);



	spin_lock_irqsave(&devfreq->lock, irqflags);



	lima_devfreq_update_utilization(devfreq);



	status->total_time = ktime_to_ns(ktime_add(devfreq->busy_time,

						   devfreq->idle_time));

	status->busy_time = ktime_to_ns(devfreq->busy_time);



	lima_devfreq_reset(devfreq);



	spin_unlock_irqrestore(&devfreq->lock, irqflags);



	dev_dbg(ldev->dev, "busy %lu total %lu %lu %% freq %lu MHz\n",

		status->busy_time, status->total_time,

		status->busy_time / (status->total_time / 100),

		status->current_frequency / 1000 / 1000);



	return 0;

}



static struct devfreq_dev_profile lima_devfreq_profile = {

	.polling_ms = 50, /* ~3 frames */

	.target = lima_devfreq_target,

	.get_dev_status = lima_devfreq_get_dev_status,

};



void lima_devfreq_fini(struct lima_device *ldev)

{

	struct lima_devfreq *devfreq = &ldev->devfreq;



	if (devfreq->cooling) {

		devfreq_cooling_unregister(devfreq->cooling);

		devfreq->cooling = NULL;

	}



	if (devfreq->devfreq) {

		devm_devfreq_remove_device(&ldev->pdev->dev,

					   devfreq->devfreq);

		devfreq->devfreq = NULL;

	}



	if (devfreq->opp_of_table_added) {

		dev_pm_opp_of_remove_table(&ldev->pdev->dev);

		devfreq->opp_of_table_added = false;

	}



	if (devfreq->regulators_opp_table) {

		dev_pm_opp_put_regulators(devfreq->regulators_opp_table);

		devfreq->regulators_opp_table = NULL;

	}



	if (devfreq->clkname_opp_table) {

		dev_pm_opp_put_clkname(devfreq->clkname_opp_table);

		devfreq->clkname_opp_table = NULL;

	}

}



int lima_devfreq_init(struct lima_device *ldev)

{

	struct thermal_cooling_device *cooling;

	struct device *dev = &ldev->pdev->dev;

	struct opp_table *opp_table;

	struct devfreq *devfreq;

	struct lima_devfreq *ldevfreq = &ldev->devfreq;

	struct dev_pm_opp *opp;

	unsigned long cur_freq;

	int ret;



	if (!device_property_present(dev, "operating-points-v2"))

		/* Optional, continue without devfreq */

		return 0;



	spin_lock_init(&ldevfreq->lock);



	opp_table = dev_pm_opp_set_clkname(dev, "core");

	if (IS_ERR(opp_table)) {

		ret = PTR_ERR(opp_table);

		goto err_fini;

	}



	ldevfreq->clkname_opp_table = opp_table;



	opp_table = dev_pm_opp_set_regulators(dev,

					      (const char *[]){ "mali" },

					      1);

	if (IS_ERR(opp_table)) {

		ret = PTR_ERR(opp_table);



		/* Continue if the optional regulator is missing */

		if (ret != -ENODEV)

			goto err_fini;

	} else {

		ldevfreq->regulators_opp_table = opp_table;

	}



	ret = dev_pm_opp_of_add_table(dev);

	if (ret)

		goto err_fini;

	ldevfreq->opp_of_table_added = true;



	lima_devfreq_reset(ldevfreq);



	cur_freq = clk_get_rate(ldev->clk_gpu);



	opp = devfreq_recommended_opp(dev, &cur_freq, 0);

	if (IS_ERR(opp)) {

		ret = PTR_ERR(opp);

		goto err_fini;

	}



	lima_devfreq_profile.initial_freq = cur_freq;

	dev_pm_opp_put(opp);



	devfreq = devm_devfreq_add_device(dev, &lima_devfreq_profile,

					  DEVFREQ_GOV_SIMPLE_ONDEMAND, NULL);

	if (IS_ERR(devfreq)) {

		dev_err(dev, "Couldn't initialize GPU devfreq\n");

		ret = PTR_ERR(devfreq);

		goto err_fini;

	}



	ldevfreq->devfreq = devfreq;



	cooling = of_devfreq_cooling_register(dev->of_node, devfreq);

	if (IS_ERR(cooling))

		dev_info(dev, "Failed to register cooling device\n");

	else

		ldevfreq->cooling = cooling;



	return 0;



err_fini:

	lima_devfreq_fini(ldev);

	return ret;

}



void lima_devfreq_record_busy(struct lima_devfreq *devfreq)

{

	unsigned long irqflags;



	if (!devfreq->devfreq)

		return;



	spin_lock_irqsave(&devfreq->lock, irqflags);



	lima_devfreq_update_utilization(devfreq);



	devfreq->busy_count++;



	spin_unlock_irqrestore(&devfreq->lock, irqflags);

}



void lima_devfreq_record_idle(struct lima_devfreq *devfreq)

{

	unsigned long irqflags;



	if (!devfreq->devfreq)

		return;



	spin_lock_irqsave(&devfreq->lock, irqflags);



	lima_devfreq_update_utilization(devfreq);



	WARN_ON(--devfreq->busy_count < 0);



	spin_unlock_irqrestore(&devfreq->lock, irqflags);

}

drivers/gpu/drm/lima/lima_devfreq.h

0 → 100644
+41 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/* Copyright 2020 Martin Blumenstingl <martin.blumenstingl@googlemail.com> */



#ifndef __LIMA_DEVFREQ_H__

#define __LIMA_DEVFREQ_H__



#include <linux/spinlock.h>

#include <linux/ktime.h>



struct devfreq;

struct opp_table;

struct thermal_cooling_device;



struct lima_device;



struct lima_devfreq {

	struct devfreq *devfreq;

	struct opp_table *clkname_opp_table;

	struct opp_table *regulators_opp_table;

	struct thermal_cooling_device *cooling;

	bool opp_of_table_added;



	ktime_t busy_time;

	ktime_t idle_time;

	ktime_t time_last_update;

	int busy_count;

	/*

	 * Protect busy_time, idle_time, time_last_update and busy_count

	 * because these can be updated concurrently, for example by the GP

	 * and PP interrupts.

	 */

	spinlock_t lock;

};



int lima_devfreq_init(struct lima_device *ldev);

void lima_devfreq_fini(struct lima_device *ldev);



void lima_devfreq_record_busy(struct lima_devfreq *devfreq);

void lima_devfreq_record_idle(struct lima_devfreq *devfreq);



#endif

drivers/gpu/drm/lima/lima_device.c

+4 −0
Original line number Diff line number Diff line
@@ -214,6 +214,8 @@ static int lima_init_gp_pipe(struct lima_device *dev) 
	struct lima_sched_pipe *pipe = dev->pipe + lima_pipe_gp;

	int err;



	pipe->ldev = dev;



	err = lima_sched_pipe_init(pipe, "gp");

	if (err)

		return err;
@@ -244,6 +246,8 @@ static int lima_init_pp_pipe(struct lima_device *dev) 
	struct lima_sched_pipe *pipe = dev->pipe + lima_pipe_pp;

	int err, i;



	pipe->ldev = dev;



	err = lima_sched_pipe_init(pipe, "pp");

	if (err)

		return err;

CRA Git | Maintained and supported by SUSTech CRA and CCSE