diff --git a/drivers/devfreq/Makefile b/drivers/devfreq/Makefile index 91e44523..754bc8e8 100644 --- a/drivers/devfreq/Makefile +++ b/drivers/devfreq/Makefile @@ -1,5 +1,16 @@ ccflags-y += -I$(srctree)/drivers/devfreq -obj-$(CONFIG_DEVFREQ_GOV_POD_SCALING) += governor_pod_scaling.o -obj-$(CONFIG_DEVFREQ_GOV_POD_SCALING_V2) += governor_pod_scaling_v2.o + obj-$(CONFIG_DEVFREQ_GOV_WMARK_SIMPLE) += governor_wmark_simple.o obj-$(CONFIG_DEVFREQ_GOV_WMARK_ACTIVE) += governor_wmark_active.o + +ifneq ($(findstring 4.9,$(NV_BUILD_KERNEL_OPTIONS)),) + obj-$(CONFIG_DEVFREQ_GOV_POD_SCALING) += governor_pod_scaling.o + obj-$(CONFIG_DEVFREQ_GOV_POD_SCALING_V2) += governor_pod_scaling_v2.o +else ifneq ($(findstring 5.10,$(NV_BUILD_KERNEL_OPTIONS)),) + obj-$(CONFIG_DEVFREQ_GOV_POD_SCALING) += governor_pod_scaling.o + obj-$(CONFIG_DEVFREQ_GOV_POD_SCALING_V2) += governor_pod_scaling_v2.o +else ifneq ($(findstring stable,$(NV_BUILD_KERNEL_OPTIONS)),) + ccflags-y += -I$(srctree.nvidia)/include + ccflags-y += -DGOVERNOR_POD_SCALING_V2_MODULE + obj-m += governor_pod_scaling_v2.o +endif diff --git a/drivers/devfreq/governor_pod_scaling_v2.c b/drivers/devfreq/governor_pod_scaling_v2.c index 98d9472f..31adc484 100644 --- a/drivers/devfreq/governor_pod_scaling_v2.c +++ b/drivers/devfreq/governor_pod_scaling_v2.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2020, NVIDIA CORPORATION. All rights reserved. + * Copyright (c) 2012-2022, NVIDIA CORPORATION. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, @@ -32,11 +32,15 @@ #include #include #include - +#include #define CREATE_TRACE_POINTS #include +#ifndef GOVERNOR_POD_SCALING_V2_MODULE #include "governor.h" +#else +#include "governor_v2.h" +#endif // GOVERNOR_POD_SCALING_V2_MODULE #include #include @@ -121,6 +125,45 @@ enum podgov_adjustment_type { #define HZ_PER_KHZ 1000 +#ifdef GOVERNOR_POD_SCALING_V2_MODULE +static void get_freq_range(struct devfreq *devfreq, + unsigned long *min_freq, + unsigned long *max_freq) +{ + unsigned long *freq_table = devfreq->profile->freq_table; + + lockdep_assert_held(&devfreq->lock); + + if (freq_table[0] < freq_table[devfreq->profile->max_state - 1]) { + *min_freq = freq_table[0]; + *max_freq = freq_table[devfreq->profile->max_state - 1]; + } else { + *min_freq = freq_table[devfreq->profile->max_state - 1]; + *max_freq = freq_table[0]; + } + + /* Apply constraints from OPP interface */ + *min_freq = max(*min_freq, devfreq->scaling_min_freq); + *max_freq = min(*max_freq, devfreq->scaling_max_freq); + + if (*min_freq > *max_freq) + *min_freq = *max_freq; +} + +static void get_min_freq_limit(struct devfreq *df, unsigned long *min_freq_hz) +{ + unsigned long max_freq_hz; + + get_freq_range(df, min_freq_hz, &max_freq_hz); +} + +static void get_max_freq_limit(struct devfreq *df, unsigned long *max_freq_hz) +{ + unsigned long min_freq_hz; + + get_freq_range(df, &min_freq_hz, max_freq_hz); +} +#else static void get_min_freq_limit(struct devfreq *df, unsigned long *min_freq_hz) { s32 qos_min_freq = 0; @@ -142,6 +185,7 @@ static void get_max_freq_limit(struct devfreq *df, unsigned long *max_freq_hz) *max_freq_hz = (unsigned long)HZ_PER_KHZ * qos_max_freq; } +#endif // GOVERNOR_POD_SCALING_V2_MODULE /******************************************************************************* * scaling_limit(df, freq) diff --git a/drivers/devfreq/governor_v2.h b/drivers/devfreq/governor_v2.h new file mode 100644 index 00000000..70ecf3e5 --- /dev/null +++ b/drivers/devfreq/governor_v2.h @@ -0,0 +1,100 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * governor.h - internal header for devfreq governors. + * + * Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. + * Copyright (C) 2011 Samsung Electronics + * MyungJoo Ham + * + * This header is for devfreq governors in drivers/devfreq/ + */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 11, 0) && LINUX_VERSION_CODE < KERNEL_VERSION(5, 18, 0) +#ifndef _GOVERNOR_H +#define _GOVERNOR_H +#include + +#define DEVFREQ_NAME_LEN 16 + +#define to_devfreq(DEV) container_of((DEV), struct devfreq, dev) + +/* Devfreq events */ +#define DEVFREQ_GOV_START 0x1 +#define DEVFREQ_GOV_STOP 0x2 +#define DEVFREQ_GOV_UPDATE_INTERVAL 0x3 +#define DEVFREQ_GOV_SUSPEND 0x4 +#define DEVFREQ_GOV_RESUME 0x5 + +#define DEVFREQ_MIN_FREQ 0 +#define DEVFREQ_MAX_FREQ ULONG_MAX + +/* + * Definition of the governor feature flags + * - DEVFREQ_GOV_FLAG_IMMUTABLE + * : This governor is never changeable to other governors. + * - DEVFREQ_GOV_FLAG_IRQ_DRIVEN + * : The devfreq won't schedule the work for this governor. + */ +#define DEVFREQ_GOV_FLAG_IMMUTABLE BIT(0) +#define DEVFREQ_GOV_FLAG_IRQ_DRIVEN BIT(1) + +/* + * Definition of governor attribute flags except for common sysfs attributes + * - DEVFREQ_GOV_ATTR_POLLING_INTERVAL + * : Indicate polling_interval sysfs attribute + * - DEVFREQ_GOV_ATTR_TIMER + * : Indicate timer sysfs attribute + */ +#define DEVFREQ_GOV_ATTR_POLLING_INTERVAL BIT(0) +#define DEVFREQ_GOV_ATTR_TIMER BIT(1) + +/** + * struct devfreq_governor - Devfreq policy governor + * @node: list node - contains registered devfreq governors + * @name: Governor's name + * @attrs: Governor's sysfs attribute flags + * @flags: Governor's feature flags + * @get_target_freq: Returns desired operating frequency for the device. + * Basically, get_target_freq will run + * devfreq_dev_profile.get_dev_status() to get the + * status of the device (load = busy_time / total_time). + * @event_handler: Callback for devfreq core framework to notify events + * to governors. Events include per device governor + * init and exit, opp changes out of devfreq, suspend + * and resume of per device devfreq during device idle. + * + * Note that the callbacks are called with devfreq->lock locked by devfreq. + */ +struct devfreq_governor { + struct list_head node; + + const char name[DEVFREQ_NAME_LEN]; + const u64 attrs; + const u64 flags; + int (*get_target_freq)(struct devfreq *this, unsigned long *freq); + int (*event_handler)(struct devfreq *devfreq, + unsigned int event, void *data); +}; + +void devfreq_monitor_start(struct devfreq *devfreq); +void devfreq_monitor_stop(struct devfreq *devfreq); +void devfreq_monitor_suspend(struct devfreq *devfreq); +void devfreq_monitor_resume(struct devfreq *devfreq); +void devfreq_update_interval(struct devfreq *devfreq, unsigned int *delay); + +int devfreq_add_governor(struct devfreq_governor *governor); +int devfreq_remove_governor(struct devfreq_governor *governor); + +int devfreq_update_status(struct devfreq *devfreq, unsigned long freq); +int devfreq_update_target(struct devfreq *devfreq, unsigned long freq); +void devfreq_get_freq_range(struct devfreq *devfreq, unsigned long *min_freq, + unsigned long *max_freq); + +static inline int devfreq_update_stats(struct devfreq *df) +{ + if (!df->profile->get_dev_status) + return -EINVAL; + + return df->profile->get_dev_status(df->dev.parent, &df->last_status); +} +#endif /* _GOVERNOR_H */ +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 11, 0) && LINUX_VERSION_CODE < KERNEL_VERSION(5, 18, 0) */