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

Commit ad3c02f8 authored by James Carr's avatar James Carr Committed by Dmitry Shmidt
Browse files

ANDROID: Implement memory_state_time, used by qcom,cpubw 



New driver memory_state_time tracks time spent in different DDR
frequency and bandwidth states.

Memory drivers such as qcom,cpubw can post updated state to the driver
after registering a callback. Processed by a workqueue

Bandwidth buckets are read in from device tree in the relevant qualcomm
section, can be defined in any quantity and spacing.

The data is exposed at /sys/kernel/memory_state_time, able to be read by
the Android framework.

Functionality is behind a config option CONFIG_MEMORY_STATE_TIME

Change-Id: I4fee165571cb975fb9eacbc9aada5e6d7dd748f0
Signed-off-by: default avatarJames Carr <carrja@google.com>
parent c5b8dcde

Documentation/devicetree/bindings/misc/memory-state-time.txt

0 → 100644
+8 −0
Original line number Diff line number Diff line 
Memory bandwidth and frequency state tracking



Required properties:

- compatible : should be:

       "memory-state-time"

- freq-tbl: Should contain entries with each frequency in Hz.

- bw-buckets: Should contain upper-bound limits for each bandwidth bucket in Mbps.

       Must match the framework power_profile.xml for the device.

drivers/misc/Kconfig

+6 −0
Original line number Diff line number Diff line
@@ -772,6 +772,12 @@ config UID_CPUTIME 
	help

	  Per UID based cpu time statistics exported to /proc/uid_cputime



config MEMORY_STATE_TIME

	tristate "Memory freq/bandwidth time statistics"

	depends on PROFILING

	help

	  Memory time statistics exported to /sys/kernel/memory_state_time



source "drivers/misc/c2port/Kconfig"

source "drivers/misc/eeprom/Kconfig"

source "drivers/misc/cb710/Kconfig"

drivers/misc/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -55,6 +55,7 @@ obj-$(CONFIG_CXL_BASE) += cxl/ 
obj-$(CONFIG_PANEL)             += panel.o



obj-$(CONFIG_UID_CPUTIME)	+= uid_cputime.o

obj-$(CONFIG_MEMORY_STATE_TIME)	+= memory_state_time.o



lkdtm-$(CONFIG_LKDTM)		+= lkdtm_core.o

lkdtm-$(CONFIG_LKDTM)		+= lkdtm_bugs.o

drivers/misc/memory_state_time.c

0 → 100644
+454 −0
Original line number Diff line number Diff line 
/* drivers/misc/memory_state_time.c

 *

 * Copyright (C) 2016 Google, Inc.

 *

 * 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 <linux/device.h>

#include <linux/err.h>

#include <linux/errno.h>

#include <linux/hashtable.h>

#include <linux/kconfig.h>

#include <linux/kernel.h>

#include <linux/kobject.h>

#include <linux/memory-state-time.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/of_platform.h>

#include <linux/slab.h>

#include <linux/sysfs.h>

#include <linux/time.h>

#include <linux/timekeeping.h>

#include <linux/workqueue.h>



#define KERNEL_ATTR_RO(_name) \

static struct kobj_attribute _name##_attr = __ATTR_RO(_name)



#define KERNEL_ATTR_RW(_name) \

static struct kobj_attribute _name##_attr = \

	__ATTR(_name, 0644, _name##_show, _name##_store)



#define FREQ_HASH_BITS 4

DECLARE_HASHTABLE(freq_hash_table, FREQ_HASH_BITS);



static DEFINE_MUTEX(mem_lock);



#define TAG "memory_state_time"

#define BW_NODE "/soc/memory-state-time"

#define FREQ_TBL "freq-tbl"

#define BW_TBL "bw-buckets"

#define NUM_SOURCES "num-sources"



#define LOWEST_FREQ 2



static int curr_bw;

static int curr_freq;

static u32 *bw_buckets;

static u32 *freq_buckets;

static int num_freqs;

static int num_buckets;

static int registered_bw_sources;

static u64 last_update;

static bool init_success;

static struct workqueue_struct *memory_wq;

static u32 num_sources = 10;

static int *bandwidths;



struct freq_entry {

	int freq;

	u64 *buckets; /* Bandwidth buckets. */

	struct hlist_node hash;

};



struct queue_container {

	struct work_struct update_state;

	int value;

	u64 time_now;

	int id;

	struct mutex *lock;

};



static int find_bucket(int bw)

{

	int i;



	if (bw_buckets != NULL) {

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

			if (bw_buckets[i] > bw) {

				pr_debug("Found bucket %d for bandwidth %d\n",

					i, bw);

				return i;

			}

		}

		return num_buckets - 1;

	}

	return 0;

}



static u64 get_time_diff(u64 time_now)

{

	u64 ms;



	ms = time_now - last_update;

	last_update = time_now;

	return ms;

}



static ssize_t show_stat_show(struct kobject *kobj,

		struct kobj_attribute *attr, char *buf)

{

	int i, j;

	int len = 0;

	struct freq_entry *freq_entry;



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

		hash_for_each_possible(freq_hash_table, freq_entry, hash,

				freq_buckets[i]) {

			if (freq_entry->freq == freq_buckets[i]) {

				len += scnprintf(buf + len, PAGE_SIZE - len,

						"%d ", freq_buckets[i]);

				if (len >= PAGE_SIZE)

					break;

				for (j = 0; j < num_buckets; j++) {

					len += scnprintf(buf + len,

							PAGE_SIZE - len,

							"%llu ",

							freq_entry->buckets[j]);

				}

				len += scnprintf(buf + len, PAGE_SIZE - len,

						"\n");

			}

		}

	}

	pr_debug("Current Time: %llu\n", ktime_get_boot_ns());

	return len;

}

KERNEL_ATTR_RO(show_stat);



static void update_table(u64 time_now)

{

	struct freq_entry *freq_entry;



	pr_debug("Last known bw %d freq %d\n", curr_bw, curr_freq);

	hash_for_each_possible(freq_hash_table, freq_entry, hash, curr_freq) {

		if (curr_freq == freq_entry->freq) {

			freq_entry->buckets[find_bucket(curr_bw)]

					+= get_time_diff(time_now);

			break;

		}

	}

}



static bool freq_exists(int freq)

{

	int i;



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

		if (freq == freq_buckets[i])

			return true;

	}

	return false;

}



static int calculate_total_bw(int bw, int index)

{

	int i;

	int total_bw = 0;



	pr_debug("memory_state_time New bw %d for id %d\n", bw, index);

	bandwidths[index] = bw;

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

		total_bw += bandwidths[i];

	return total_bw;

}



static void freq_update_do_work(struct work_struct *work)

{

	struct queue_container *freq_state_update

			= container_of(work, struct queue_container,

			update_state);

	if (freq_state_update) {

		mutex_lock(&mem_lock);

		update_table(freq_state_update->time_now);

		curr_freq = freq_state_update->value;

		mutex_unlock(&mem_lock);

		kfree(freq_state_update);

	}

}



static void bw_update_do_work(struct work_struct *work)

{

	struct queue_container *bw_state_update

			= container_of(work, struct queue_container,

			update_state);

	if (bw_state_update) {

		mutex_lock(&mem_lock);

		update_table(bw_state_update->time_now);

		curr_bw = calculate_total_bw(bw_state_update->value,

				bw_state_update->id);

		mutex_unlock(&mem_lock);

		kfree(bw_state_update);

	}

}



static void memory_state_freq_update(struct memory_state_update_block *ub,

		int value)

{

	if (IS_ENABLED(CONFIG_MEMORY_STATE_TIME)) {

		if (freq_exists(value) && init_success) {

			struct queue_container *freq_container

				= kmalloc(sizeof(struct queue_container),

				GFP_KERNEL);

			if (!freq_container)

				return;

			INIT_WORK(&freq_container->update_state,

					freq_update_do_work);

			freq_container->time_now = ktime_get_boot_ns();

			freq_container->value = value;

			pr_debug("Scheduling freq update in work queue\n");

			queue_work(memory_wq, &freq_container->update_state);

		} else {

			pr_debug("Freq does not exist.\n");

		}

	}

}



static void memory_state_bw_update(struct memory_state_update_block *ub,

		int value)

{

	if (IS_ENABLED(CONFIG_MEMORY_STATE_TIME)) {

		if (init_success) {

			struct queue_container *bw_container

				= kmalloc(sizeof(struct queue_container),

				GFP_KERNEL);

			if (!bw_container)

				return;

			INIT_WORK(&bw_container->update_state,

					bw_update_do_work);

			bw_container->time_now = ktime_get_boot_ns();

			bw_container->value = value;

			bw_container->id = ub->id;

			pr_debug("Scheduling bandwidth update in work queue\n");

			queue_work(memory_wq, &bw_container->update_state);

		}

	}

}



struct memory_state_update_block *memory_state_register_frequency_source(void)

{

	struct memory_state_update_block *block;



	if (IS_ENABLED(CONFIG_MEMORY_STATE_TIME)) {

		pr_debug("Allocating frequency source\n");

		block = kmalloc(sizeof(struct memory_state_update_block),

					GFP_KERNEL);

		if (!block)

			return NULL;

		block->update_call = memory_state_freq_update;

		return block;

	}

	pr_err("Config option disabled.\n");

	return NULL;

}

EXPORT_SYMBOL_GPL(memory_state_register_frequency_source);



struct memory_state_update_block *memory_state_register_bandwidth_source(void)

{

	struct memory_state_update_block *block;



	if (IS_ENABLED(CONFIG_MEMORY_STATE_TIME)) {

		pr_debug("Allocating bandwidth source %d\n",

				registered_bw_sources);

		block = kmalloc(sizeof(struct memory_state_update_block),

					GFP_KERNEL);

		if (!block)

			return NULL;

		block->update_call = memory_state_bw_update;

		if (registered_bw_sources < num_sources) {

			block->id = registered_bw_sources++;

		} else {

			pr_err("Unable to allocate source; max number reached\n");

			kfree(block);

			return NULL;

		}

		return block;

	}

	pr_err("Config option disabled.\n");

	return NULL;

}

EXPORT_SYMBOL_GPL(memory_state_register_bandwidth_source);



/* Buckets are designated by their maximum.

 * Returns the buckets decided by the capability of the device.

 */

static int get_bw_buckets(struct device *dev)

{

	int ret, lenb;

	struct device_node *node = dev->of_node;



	of_property_read_u32(node, NUM_SOURCES, &num_sources);

	if (of_find_property(node, BW_TBL, &lenb)) {

		bandwidths = devm_kzalloc(dev,

				sizeof(*bandwidths) * num_sources, GFP_KERNEL);

		if (!bandwidths)

			return -ENOMEM;

		lenb /= sizeof(*bw_buckets);

		bw_buckets = devm_kzalloc(dev, lenb * sizeof(*bw_buckets),

				GFP_KERNEL);

		if (!bw_buckets) {

			devm_kfree(dev, bandwidths);

			return -ENOMEM;

		}

		ret = of_property_read_u32_array(node, BW_TBL, bw_buckets,

				lenb);

		if (ret < 0) {

			devm_kfree(dev, bandwidths);

			devm_kfree(dev, bw_buckets);

			pr_err("Unable to read bandwidth table from device tree.\n");

			return ret;

		}

	}

	curr_bw = 0;

	num_buckets = lenb;

	return 0;

}



/* Adds struct freq_entry nodes to the hashtable for each compatible frequency.

 * Returns the supported number of frequencies.

 */

static int freq_buckets_init(struct device *dev)

{

	struct freq_entry *freq_entry;

	int i;

	int ret, lenf;

	struct device_node *node = dev->of_node;



	if (of_find_property(node, FREQ_TBL, &lenf)) {

		lenf /= sizeof(*freq_buckets);

		freq_buckets = devm_kzalloc(dev, lenf * sizeof(*freq_buckets),

				GFP_KERNEL);

		if (!freq_buckets)

			return -ENOMEM;

		pr_debug("freqs found len %d\n", lenf);

		ret = of_property_read_u32_array(node, FREQ_TBL, freq_buckets,

				lenf);

		if (ret < 0) {

			devm_kfree(dev, freq_buckets);

			pr_err("Unable to read frequency table from device tree.\n");

			return ret;

		}

		pr_debug("ret freq %d\n", ret);

	}

	num_freqs = lenf;

	curr_freq = freq_buckets[LOWEST_FREQ];



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

		freq_entry = devm_kzalloc(dev, sizeof(struct freq_entry),

				GFP_KERNEL);

		if (!freq_entry)

			return -ENOMEM;

		freq_entry->buckets = devm_kzalloc(dev, sizeof(u64)*num_buckets,

				GFP_KERNEL);

		if (!freq_entry->buckets) {

			devm_kfree(dev, freq_entry);

			return -ENOMEM;

		}

		pr_debug("memory_state_time Adding freq to ht %d\n",

				freq_buckets[i]);

		freq_entry->freq = freq_buckets[i];

		hash_add(freq_hash_table, &freq_entry->hash, freq_buckets[i]);

	}

	return 0;

}



struct kobject *memory_kobj;

EXPORT_SYMBOL_GPL(memory_kobj);



static struct attribute *memory_attrs[] = {

	&show_stat_attr.attr,

	NULL

};



static struct attribute_group memory_attr_group = {

	.attrs = memory_attrs,

};



static int memory_state_time_probe(struct platform_device *pdev)

{

	int error;



	error = get_bw_buckets(&pdev->dev);

	if (error)

		return error;

	error = freq_buckets_init(&pdev->dev);

	if (error)

		return error;

	last_update = ktime_get_boot_ns();

	init_success = true;



	pr_debug("memory_state_time initialized with num_freqs %d\n",

			num_freqs);

	return 0;

}



static const struct of_device_id match_table[] = {

	{ .compatible = "memory-state-time" },

	{}

};



static struct platform_driver memory_state_time_driver = {

	.probe = memory_state_time_probe,

	.driver = {

		.name = "memory-state-time",

		.of_match_table = match_table,

		.owner = THIS_MODULE,

	},

};



static int __init memory_state_time_init(void)

{

	int error;



	hash_init(freq_hash_table);

	memory_wq = create_singlethread_workqueue("memory_wq");

	if (!memory_wq) {

		pr_err("Unable to create workqueue.\n");

		return -EINVAL;

	}

	/*

	 * Create sys/kernel directory for memory_state_time.

	 */

	memory_kobj = kobject_create_and_add(TAG, kernel_kobj);

	if (!memory_kobj) {

		pr_err("Unable to allocate memory_kobj for sysfs directory.\n");

		error = -ENOMEM;

		goto wq;

	}

	error = sysfs_create_group(memory_kobj, &memory_attr_group);

	if (error) {

		pr_err("Unable to create sysfs folder.\n");

		goto kobj;

	}



	error = platform_driver_register(&memory_state_time_driver);

	if (error) {

		pr_err("Unable to register memory_state_time platform driver.\n");

		goto group;

	}

	return 0;



group:	sysfs_remove_group(memory_kobj, &memory_attr_group);

kobj:	kobject_put(memory_kobj);

wq:	destroy_workqueue(memory_wq);

	return error;

}

module_init(memory_state_time_init);

include/linux/memory-state-time.h

0 → 100644
+42 −0
Original line number Diff line number Diff line 
/* include/linux/memory-state-time.h

 *

 * Copyright (C) 2016 Google, Inc.

 *

 * 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 <linux/workqueue.h>



#define UPDATE_MEMORY_STATE(BLOCK, VALUE) BLOCK->update_call(BLOCK, VALUE)



struct memory_state_update_block;



typedef void (*memory_state_update_fn_t)(struct memory_state_update_block *ub,

		int value);



/* This struct is populated when you pass it to a memory_state_register*

 * function. The update_call function is used for an update and defined in the

 * typedef memory_state_update_fn_t

 */

struct memory_state_update_block {

	memory_state_update_fn_t update_call;

	int id;

};



/* Register a frequency struct memory_state_update_block to provide updates to

 * memory_state_time about frequency changes using its update_call function.

 */

struct memory_state_update_block *memory_state_register_frequency_source(void);



/* Register a bandwidth struct memory_state_update_block to provide updates to

 * memory_state_time about bandwidth changes using its update_call function.

 */

struct memory_state_update_block *memory_state_register_bandwidth_source(void);