Merge "adreno_tz: Remove partner devfreq management" (062f02af) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/devfreq/governor.h

+0 −3

Original line number	Diff line number	Diff line
		@@ -54,9 +54,6 @@ struct devfreq_governor {
		unsigned int event, void *data);
		};

		/* Caution: devfreq->lock must be locked before calling update_devfreq */
		extern int update_devfreq(struct devfreq *devfreq);

		extern void devfreq_monitor_start(struct devfreq *devfreq);
		extern void devfreq_monitor_stop(struct devfreq *devfreq);
		extern void devfreq_monitor_suspend(struct devfreq *devfreq);

drivers/devfreq/governor_msm_adreno_tz.c

+2 −120

Original line number	Diff line number	Diff line
		/* Copyright (c) 2010-2018, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2010-2019, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -62,14 +62,6 @@ static u64 suspend_time;
		static u64 suspend_start;
		static unsigned long acc_total, acc_relative_busy;

		static struct msm_adreno_extended_profile *partner_gpu_profile;
		static void do_partner_start_event(struct work_struct *work);
		static void do_partner_stop_event(struct work_struct *work);
		static void do_partner_suspend_event(struct work_struct *work);
		static void do_partner_resume_event(struct work_struct *work);

		static struct workqueue_struct *workqueue;

		/*
		* Returns GPU suspend time in millisecond.
		*/
		@@ -415,32 +407,6 @@ static int tz_get_target_freq(struct devfreq devfreq, unsigned long freq)
		return 0;
		}

		static int tz_notify(struct notifier_block nb, unsigned long type, void devp)
		{
		int result = 0;
		struct devfreq *devfreq = devp;

		switch (type) {
		case ADRENO_DEVFREQ_NOTIFY_IDLE:
		case ADRENO_DEVFREQ_NOTIFY_RETIRE:
		mutex_lock(&devfreq->lock);
		result = update_devfreq(devfreq);
		mutex_unlock(&devfreq->lock);
		/* Nofifying partner bus governor if any */
		if (partner_gpu_profile && partner_gpu_profile->bus_devfreq) {
		mutex_lock(&partner_gpu_profile->bus_devfreq->lock);
		update_devfreq(partner_gpu_profile->bus_devfreq);
		mutex_unlock(&partner_gpu_profile->bus_devfreq->lock);
		}
		break;
		/* ignored by this governor */
		case ADRENO_DEVFREQ_NOTIFY_SUBMIT:
		default:
		break;
		}
		return notifier_from_errno(result);
		}

		static int tz_start(struct devfreq *devfreq)
		{
		struct devfreq_msm_adreno_tz_data *priv;
		@@ -460,10 +426,8 @@ static int tz_start(struct devfreq *devfreq)
		* from the container of the device profile
		*/
		devfreq->data = gpu_profile->private_data;
		partner_gpu_profile = gpu_profile;

		priv = devfreq->data;
		priv->nb.notifier_call = tz_notify;

		out = 1;
		if (devfreq->profile->max_state < MSM_ADRENO_MAX_PWRLEVELS) {
		@@ -475,15 +439,6 @@ static int tz_start(struct devfreq *devfreq)
		return -EINVAL;
		}

		INIT_WORK(&gpu_profile->partner_start_event_ws,
		do_partner_start_event);
		INIT_WORK(&gpu_profile->partner_stop_event_ws,
		do_partner_stop_event);
		INIT_WORK(&gpu_profile->partner_suspend_event_ws,
		do_partner_suspend_event);
		INIT_WORK(&gpu_profile->partner_resume_event_ws,
		do_partner_resume_event);

		ret = tz_init(priv, tz_pwrlevels, sizeof(tz_pwrlevels), &version,
		sizeof(version));
		if (ret != 0 \|\| version > MAX_TZ_VERSION) {
		@@ -494,24 +449,18 @@ static int tz_start(struct devfreq *devfreq)
		for (i = 0; adreno_tz_attr_list[i] != NULL; i++)
		device_create_file(&devfreq->dev, adreno_tz_attr_list[i]);

		return kgsl_devfreq_add_notifier(devfreq->dev.parent, &priv->nb);
		return 0;
		}

		static int tz_stop(struct devfreq *devfreq)
		{
		int i;
		struct devfreq_msm_adreno_tz_data *priv = devfreq->data;

		kgsl_devfreq_del_notifier(devfreq->dev.parent, &priv->nb);

		for (i = 0; adreno_tz_attr_list[i] != NULL; i++)
		device_remove_file(&devfreq->dev, adreno_tz_attr_list[i]);

		flush_workqueue(workqueue);

		/* leaving the governor and cleaning the pointer to private data */
		devfreq->data = NULL;
		partner_gpu_profile = NULL;
		return 0;
		}

		@@ -531,21 +480,12 @@ static int tz_handler(struct devfreq devfreq, unsigned int event, void data)
		{
		int result;

		struct msm_adreno_extended_profile *gpu_profile = container_of(
		(devfreq->profile),
		struct msm_adreno_extended_profile,
		profile);

		switch (event) {
		case DEVFREQ_GOV_START:
		result = tz_start(devfreq);
		break;

		case DEVFREQ_GOV_STOP:
		/* Queue the stop work before the TZ is stopped */
		if (partner_gpu_profile && partner_gpu_profile->bus_devfreq)
		queue_work(workqueue,
		&gpu_profile->partner_stop_event_ws);
		spin_lock(&suspend_lock);
		suspend_start = 0;
		spin_unlock(&suspend_lock);
		@@ -576,60 +516,9 @@ static int tz_handler(struct devfreq devfreq, unsigned int event, void data)
		break;
		}

		if (partner_gpu_profile && partner_gpu_profile->bus_devfreq)
		switch (event) {
		case DEVFREQ_GOV_START:
		queue_work(workqueue,
		&gpu_profile->partner_start_event_ws);
		break;
		case DEVFREQ_GOV_SUSPEND:
		queue_work(workqueue,
		&gpu_profile->partner_suspend_event_ws);
		break;
		case DEVFREQ_GOV_RESUME:
		queue_work(workqueue,
		&gpu_profile->partner_resume_event_ws);
		break;
		}

		return result;
		}

		static void _do_partner_event(struct work_struct *work, unsigned int event)
		{
		struct devfreq *bus_devfreq;

		if (partner_gpu_profile == NULL)
		return;

		bus_devfreq = partner_gpu_profile->bus_devfreq;

		if (bus_devfreq != NULL &&
		bus_devfreq->governor &&
		bus_devfreq->governor->event_handler)
		bus_devfreq->governor->event_handler(bus_devfreq, event, NULL);
		}

		static void do_partner_start_event(struct work_struct *work)
		{
		_do_partner_event(work, DEVFREQ_GOV_START);
		}

		static void do_partner_stop_event(struct work_struct *work)
		{
		_do_partner_event(work, DEVFREQ_GOV_STOP);
		}

		static void do_partner_suspend_event(struct work_struct *work)
		{
		_do_partner_event(work, DEVFREQ_GOV_SUSPEND);
		}

		static void do_partner_resume_event(struct work_struct *work)
		{
		_do_partner_event(work, DEVFREQ_GOV_RESUME);
		}


		static struct devfreq_governor msm_adreno_tz = {
		.name = "msm-adreno-tz",
		@@ -639,11 +528,6 @@ static struct devfreq_governor msm_adreno_tz = {

		static int __init msm_adreno_tz_init(void)
		{
		workqueue = create_freezable_workqueue("governor_msm_adreno_tz_wq");

		if (workqueue == NULL)
		return -ENOMEM;

		return devfreq_add_governor(&msm_adreno_tz);
		}
		subsys_initcall(msm_adreno_tz_init);
		@@ -655,8 +539,6 @@ static void __exit msm_adreno_tz_exit(void)
		if (ret)
		pr_err(TAG "failed to remove governor %d\n", ret);

		if (workqueue != NULL)
		destroy_workqueue(workqueue);
		}

		module_exit(msm_adreno_tz_exit);

drivers/gpu/msm/kgsl_pwrscale.c

+21 −14

Original line number	Diff line number	Diff line
		/* Copyright (c) 2010-2018, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2010-2019, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -198,7 +198,7 @@ void kgsl_pwrscale_update(struct kgsl_device *device)
		device->pwrscale.next_governor_call = ktime_add_us(t,
		KGSL_GOVERNOR_CALL_INTERVAL);

		/* to call srcu_notifier_call_chain() from a kernel thread */
		/* to call update_devfreq() from a kernel thread */
		if (device->state != KGSL_STATE_SLUMBER)
		queue_work(device->pwrscale.devfreq_wq,
		&device->pwrscale.devfreq_notify_ws);
		@@ -935,7 +935,6 @@ int kgsl_pwrscale_init(struct device dev, const char governor)
		struct kgsl_pwrscale *pwrscale;
		struct kgsl_pwrctrl *pwr;
		struct devfreq *devfreq;
		struct devfreq *bus_devfreq;
		struct msm_adreno_extended_profile *gpu_profile;
		struct devfreq_dev_profile *profile;
		struct devfreq_msm_adreno_tz_data *data;
		@@ -1039,17 +1038,16 @@ int kgsl_pwrscale_init(struct device dev, const char governor)
		if (IS_ERR(pwrscale->cooling_dev))
		pwrscale->cooling_dev = NULL;

		pwrscale->gpu_profile.bus_devfreq = NULL;
		if (data->bus.num) {
		pwrscale->bus_profile.profile.max_state
		= pwr->num_pwrlevels - 1;
		pwrscale->bus_profile.profile.freq_table
		= pwrscale->freq_table;

		bus_devfreq = devfreq_add_device(device->busmondev,
		pwrscale->bus_devfreq = devfreq_add_device(device->busmondev,
		&pwrscale->bus_profile.profile, "gpubw_mon", NULL);
		if (!IS_ERR(bus_devfreq))
		pwrscale->gpu_profile.bus_devfreq = bus_devfreq;
		if (IS_ERR(pwrscale->bus_devfreq))
		pwrscale->bus_devfreq = NULL;
		}

		ret = sysfs_create_link(&device->dev->kobj,
		@@ -1109,8 +1107,10 @@ void kgsl_pwrscale_close(struct kgsl_device *device)
		flush_workqueue(pwrscale->devfreq_wq);
		destroy_workqueue(pwrscale->devfreq_wq);
		devfreq_remove_device(device->pwrscale.devfreqptr);
		devfreq_remove_device(pwrscale->bus_devfreq);
		kfree(kgsl_midframe);
		kgsl_midframe = NULL;
		device->pwrscale.bus_devfreq = NULL;
		device->pwrscale.devfreqptr = NULL;
		srcu_cleanup_notifier_head(&device->pwrscale.nh);
		dev_pm_opp_unregister_notifier(&device->pdev->dev, &pwr->nb);
		@@ -1123,18 +1123,18 @@ static void do_devfreq_suspend(struct work_struct *work)
		{
		struct kgsl_pwrscale *pwrscale = container_of(work,
		struct kgsl_pwrscale, devfreq_suspend_ws);
		struct devfreq *devfreq = pwrscale->devfreqptr;

		devfreq_suspend_device(devfreq);
		devfreq_suspend_device(pwrscale->devfreqptr);
		devfreq_suspend_device(pwrscale->bus_devfreq);
		}

		static void do_devfreq_resume(struct work_struct *work)
		{
		struct kgsl_pwrscale *pwrscale = container_of(work,
		struct kgsl_pwrscale, devfreq_resume_ws);
		struct devfreq *devfreq = pwrscale->devfreqptr;

		devfreq_resume_device(devfreq);
		devfreq_resume_device(pwrscale->devfreqptr);
		devfreq_resume_device(pwrscale->bus_devfreq);
		}

		static void do_devfreq_notify(struct work_struct *work)
		@@ -1142,8 +1142,15 @@ static void do_devfreq_notify(struct work_struct *work)
		struct kgsl_pwrscale *pwrscale = container_of(work,
		struct kgsl_pwrscale, devfreq_notify_ws);
		struct devfreq *devfreq = pwrscale->devfreqptr;
		struct devfreq *bus_devfreq = pwrscale->bus_devfreq;

		srcu_notifier_call_chain(&pwrscale->nh,
		ADRENO_DEVFREQ_NOTIFY_RETIRE,
		devfreq);
		mutex_lock(&devfreq->lock);
		update_devfreq(devfreq);
		mutex_unlock(&devfreq->lock);

		if (bus_devfreq) {
		mutex_lock(&bus_devfreq->lock);
		update_devfreq(bus_devfreq);
		mutex_unlock(&bus_devfreq->lock);
		}
		}

drivers/gpu/msm/kgsl_pwrscale.h

+3 −1

Original line number	Diff line number	Diff line
		/* Copyright (c) 2010-2018, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2010-2019, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -71,6 +71,7 @@ struct kgsl_pwr_history {
		/**
		* struct kgsl_pwrscale - Power scaling settings for a KGSL device
		* @devfreqptr - Pointer to the devfreq device
		* @bus_devfreq - Pointer to the bus devfreq device
		* @gpu_profile - GPU profile data for the devfreq device
		* @bus_profile - Bus specific data for the bus devfreq device
		* @freq_table - GPU frequencies for the DCVS algorithm
		@@ -99,6 +100,7 @@ struct kgsl_pwr_history {
		*/
		struct kgsl_pwrscale {
		struct devfreq *devfreqptr;
		struct devfreq *bus_devfreq;
		struct msm_adreno_extended_profile gpu_profile;
		struct msm_busmon_extended_profile bus_profile;
		unsigned long freq_table[KGSL_MAX_PWRLEVELS];

include/linux/devfreq.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -188,6 +188,14 @@ extern void devm_devfreq_remove_device(struct device *dev,
		extern int devfreq_suspend_device(struct devfreq *devfreq);
		extern int devfreq_resume_device(struct devfreq *devfreq);

		/**
		* update_devfreq() - Reevaluate the device and configure frequency
		* @devfreq: the devfreq device
		*
		* Note: devfreq->lock must be held
		*/
		extern int update_devfreq(struct devfreq *devfreq);

		/* Helper functions for devfreq user device driver with OPP. */
		extern struct dev_pm_opp devfreq_recommended_opp(struct device dev,
		unsigned long *freq, u32 flags);