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

Commit 4f984b5c authored by Lucille Sylvester's avatar Lucille Sylvester
Browse files

msm: kgsl: Rework the gpubusy and gputop sysfs variables 



Remove gputop as the devfreq sysfs files make it redundant.
Update gpubusy to reflect the busy counter used by GPU DCVS
rather than the SW controled clock gating.  Users expect gpubusy
to reflect the GPU's running frequency.

Change-Id: I55bf9a8e7aee1b37410a90906be3bb3bd661052e
Signed-off-by: default avatarLucille Sylvester <lsylvest@codeaurora.org>
parent bc89b16c

drivers/gpu/msm/kgsl_pwrctrl.c

+23 −119
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ 
#define KGSL_PWRFLAGS_IRQ_ON   3



#define UPDATE_BUSY_VAL		1000000

#define UPDATE_BUSY		50



/*

 * Expected delay for post-interrupt processing on A3xx.
@@ -78,30 +77,6 @@ static struct clk_pair clks[KGSL_MAX_CLKS] = { 
static void kgsl_pwrctrl_axi(struct kgsl_device *device, int state);

static void kgsl_pwrctrl_pwrrail(struct kgsl_device *device, int state);



/* Update the elapsed time at a particular clock level

 * if the device is active(on_time = true).Otherwise

 * store it as sleep time.

 */

static void update_clk_statistics(struct kgsl_device *device,

				bool on_time)

{

	struct kgsl_pwrctrl *pwr = &device->pwrctrl;

	struct kgsl_clk_stats *clkstats = &pwr->clk_stats;

	ktime_t elapsed;

	int elapsed_us;

	if (clkstats->start.tv64 == 0)

		clkstats->start = ktime_get();

	clkstats->stop = ktime_get();

	elapsed = ktime_sub(clkstats->stop, clkstats->start);

	elapsed_us = ktime_to_us(elapsed);

	clkstats->elapsed += elapsed_us;

	if (on_time)

		clkstats->clock_time[pwr->active_pwrlevel] += elapsed_us;

	else

		clkstats->clock_time[pwr->num_pwrlevels - 1] += elapsed_us;

	clkstats->start = ktime_get();

}



/*

 * Given a requested power level do bounds checking on the constraints and

 * return the nearest possible level
@@ -159,8 +134,6 @@ void kgsl_pwrctrl_pwrlevel_change(struct kgsl_device *device, 
	if (new_level == pwr->active_pwrlevel)

		return;



	update_clk_statistics(device, true);



	/*

	 * Set the active powerlevel first in case the clocks are off - if we

	 * don't do this then the pwrlevel change won't take effect when the
@@ -542,49 +515,20 @@ static ssize_t kgsl_pwrctrl_gpubusy_show(struct device *dev, 
{

	int ret;

	struct kgsl_device *device = kgsl_device_from_dev(dev);

	struct kgsl_clk_stats *clkstats;

	struct kgsl_clk_stats *stats;



	if (device == NULL)

		return 0;

	clkstats = &device->pwrctrl.clk_stats;

	stats = &device->pwrctrl.clk_stats;

	ret = snprintf(buf, PAGE_SIZE, "%7d %7d\n",

			clkstats->on_time_old, clkstats->elapsed_old);

			stats->busy_old, stats->total_old);

	if (!test_bit(KGSL_PWRFLAGS_AXI_ON, &device->pwrctrl.power_flags)) {

		clkstats->on_time_old = 0;

		clkstats->elapsed_old = 0;

		stats->busy_old = 0;

		stats->total_old = 0;

	}

	return ret;

}



static ssize_t kgsl_pwrctrl_gputop_show(struct device *dev,

					struct device_attribute *attr,

					char *buf)

{

	int ret;

	struct kgsl_device *device = kgsl_device_from_dev(dev);

	struct kgsl_clk_stats *clkstats;

	int i = 0;

	char *ptr = buf;



	if (device == NULL)

		return 0;

	clkstats = &device->pwrctrl.clk_stats;

	ret = snprintf(buf, PAGE_SIZE, "%7d %7d ", clkstats->on_time_old,

					clkstats->elapsed_old);

	for (i = 0, ptr += ret; i < device->pwrctrl.num_pwrlevels;

							i++, ptr += ret)

		ret = snprintf(ptr, PAGE_SIZE, "%7d ",

						clkstats->old_clock_time[i]);



	if (!test_bit(KGSL_PWRFLAGS_AXI_ON, &device->pwrctrl.power_flags)) {

		clkstats->on_time_old = 0;

		clkstats->elapsed_old = 0;

		for (i = 0; i < KGSL_MAX_PWRLEVELS ; i++)

			clkstats->old_clock_time[i] = 0;

	}

	return (unsigned int) (ptr - buf);

}



static ssize_t kgsl_pwrctrl_gpu_available_frequencies_show(

					struct device *dev,

					struct device_attribute *attr,
@@ -752,8 +696,6 @@ static DEVICE_ATTR(idle_timer, 0644, kgsl_pwrctrl_idle_timer_show, 
	kgsl_pwrctrl_idle_timer_store);

static DEVICE_ATTR(gpubusy, 0444, kgsl_pwrctrl_gpubusy_show,

	NULL);

static DEVICE_ATTR(gputop, 0444, kgsl_pwrctrl_gputop_show,

	NULL);

static DEVICE_ATTR(gpu_available_frequencies, 0444,

	kgsl_pwrctrl_gpu_available_frequencies_show,

	NULL);
@@ -793,7 +735,6 @@ static const struct device_attribute *pwrctrl_attr_list[] = { 
	&dev_attr_max_gpuclk,

	&dev_attr_idle_timer,

	&dev_attr_gpubusy,

	&dev_attr_gputop,

	&dev_attr_gpu_available_frequencies,

	&dev_attr_max_pwrlevel,

	&dev_attr_min_pwrlevel,
@@ -818,41 +759,26 @@ void kgsl_pwrctrl_uninit_sysfs(struct kgsl_device *device) 
	kgsl_remove_device_sysfs_files(device->dev, pwrctrl_attr_list);

}



static void update_statistics(struct kgsl_device *device)

{

	struct kgsl_clk_stats *clkstats = &device->pwrctrl.clk_stats;

	unsigned int on_time = 0;

	int i;

	int num_pwrlevels = device->pwrctrl.num_pwrlevels - 1;

	/*PER CLK TIME*/

	for (i = 0; i < num_pwrlevels; i++) {

		clkstats->old_clock_time[i] = clkstats->clock_time[i];

		on_time += clkstats->clock_time[i];

		clkstats->clock_time[i] = 0;

	}

	clkstats->old_clock_time[num_pwrlevels] =

				clkstats->clock_time[num_pwrlevels];

	clkstats->clock_time[num_pwrlevels] = 0;

	clkstats->on_time_old = on_time;

	clkstats->elapsed_old = clkstats->elapsed;

	clkstats->elapsed = 0;



	trace_kgsl_gpubusy(device, clkstats->on_time_old,

		clkstats->elapsed_old);

}



/* Track the amount of time the gpu is on vs the total system time. *

 * Regularly update the percentage of busy time displayed by sysfs. */

static void kgsl_pwrctrl_busy_time(struct kgsl_device *device, bool on_time)

void kgsl_pwrctrl_busy_time(struct kgsl_device *device, u64 time, u64 busy)

{

	struct kgsl_clk_stats *clkstats = &device->pwrctrl.clk_stats;

	update_clk_statistics(device, on_time);

	struct kgsl_clk_stats *stats = &device->pwrctrl.clk_stats;

	stats->total += time;

	stats->busy += busy;



	if (stats->total < UPDATE_BUSY_VAL)

		return;



	/* Update the output regularly and reset the counters. */

	if ((clkstats->elapsed > UPDATE_BUSY_VAL) ||

		!test_bit(KGSL_PWRFLAGS_AXI_ON, &device->pwrctrl.power_flags)) {

		update_statistics(device);

	}

	stats->total_old = stats->total;

	stats->busy_old = stats->busy;

	stats->total = 0;

	stats->busy = 0;



	trace_kgsl_gpubusy(device, stats->busy_old, stats->total_old);

}

EXPORT_SYMBOL(kgsl_pwrctrl_busy_time);



void kgsl_pwrctrl_clk(struct kgsl_device *device, int state,

					  int requested_state)
@@ -880,7 +806,6 @@ void kgsl_pwrctrl_clk(struct kgsl_device *device, int state, 
					pwr->pwrlevels[pwr->num_pwrlevels - 1].

					gpu_freq);

			}

			kgsl_pwrctrl_busy_time(device, true);

		} else if (requested_state == KGSL_STATE_SLEEP) {

			/* High latency clock maintenance. */

			for (i = KGSL_MAX_CLKS - 1; i > 0; i--)
@@ -911,7 +836,6 @@ void kgsl_pwrctrl_clk(struct kgsl_device *device, int state, 
			for (i = KGSL_MAX_CLKS - 1; i > 0; i--)

				if (pwr->grp_clks[i])

					clk_enable(pwr->grp_clks[i]);

			kgsl_pwrctrl_busy_time(device, false);

		}

	}

}
@@ -1217,21 +1141,10 @@ void kgsl_idle_check(struct work_struct *work) 
			kgsl_pwrctrl_sleep(device);



		kgsl_pwrctrl_request_state(device, KGSL_STATE_NONE);

		if (device->state == KGSL_STATE_ACTIVE) {

		if (device->state == KGSL_STATE_ACTIVE)

			mod_timer(&device->idle_timer,

					jiffies +

					device->pwrctrl.interval_timeout);

			/*

			 * If the GPU has been too busy to sleep, make sure

			 * that is acurately reflected in the % busy numbers.

			 */

			device->pwrctrl.clk_stats.no_nap_cnt++;

			if (device->pwrctrl.clk_stats.no_nap_cnt >

							 UPDATE_BUSY) {

				kgsl_pwrctrl_busy_time(device, true);

				device->pwrctrl.clk_stats.no_nap_cnt = 0;

			}

		}

	}



	mutex_unlock(&device->mutex);
@@ -1312,15 +1225,6 @@ _nap(struct kgsl_device *device) 
	return 0;

}



static void

_sleep_accounting(struct kgsl_device *device)

{

	kgsl_pwrctrl_busy_time(device, false);

	device->pwrctrl.clk_stats.start = ktime_set(0, 0);



	kgsl_pwrscale_sleep(device);

}



static int

_sleep(struct kgsl_device *device)

{
@@ -1334,7 +1238,7 @@ _sleep(struct kgsl_device *device) 
	case KGSL_STATE_NAP:

		kgsl_pwrctrl_irq(device, KGSL_PWRFLAGS_OFF);

		kgsl_pwrctrl_axi(device, KGSL_PWRFLAGS_OFF);

		_sleep_accounting(device);

		kgsl_pwrscale_sleep(device);

		kgsl_pwrctrl_clk(device, KGSL_PWRFLAGS_OFF, KGSL_STATE_SLEEP);

		kgsl_pwrctrl_set_state(device, KGSL_STATE_SLEEP);

		pm_qos_update_request(&device->pwrctrl.pm_qos_req_dma,
@@ -1369,7 +1273,7 @@ _slumber(struct kgsl_device *device) 
		kgsl_pwrctrl_enable(device);

		device->ftbl->suspend_context(device);

		device->ftbl->stop(device);

		_sleep_accounting(device);

		kgsl_pwrscale_sleep(device);

		kgsl_pwrctrl_set_state(device, KGSL_STATE_SLUMBER);

		pm_qos_update_request(&device->pwrctrl.pm_qos_req_dma,

						PM_QOS_DEFAULT_VALUE);

drivers/gpu/msm/kgsl_pwrctrl.h

+5 −8
Original line number Diff line number Diff line
@@ -33,14 +33,10 @@ 
struct platform_device;



struct kgsl_clk_stats {

	unsigned int old_clock_time[KGSL_MAX_PWRLEVELS];

	unsigned int clock_time[KGSL_MAX_PWRLEVELS];

	unsigned int on_time_old;

	ktime_t start;

	ktime_t stop;

	unsigned int no_nap_cnt;

	unsigned int elapsed;

	unsigned int elapsed_old;

	unsigned int busy;

	unsigned int total;

	unsigned int busy_old;

	unsigned int total_old;

};



struct kgsl_pwr_constraint {
@@ -158,5 +154,6 @@ int kgsl_active_count_wait(struct kgsl_device *device, int count); 
void kgsl_pwrctrl_clk(struct kgsl_device *device, int state,

				int requested_state);

int kgsl_pwrctrl_slumber(struct kgsl_device *device);

void kgsl_pwrctrl_busy_time(struct kgsl_device *device, u64 time, u64 busy);



#endif /* __KGSL_PWRCTRL_H */

drivers/gpu/msm/kgsl_pwrscale.c

+1 −0
Original line number Diff line number Diff line
@@ -317,6 +317,7 @@ int kgsl_devfreq_get_dev_status(struct device *dev, 
		b->mod = device->pwrctrl.bus_mod;

	}



	kgsl_pwrctrl_busy_time(device, stat->total_time, stat->busy_time);

	trace_kgsl_pwrstats(device, stat->total_time, &pwrscale->accum_stats);

	memset(&pwrscale->accum_stats, 0, sizeof(pwrscale->accum_stats));