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

Commit 60450b0d authored by Yuanyuan Liu's avatar Yuanyuan Liu Committed by Gerrit - the friendly Code Review server
Browse files

net: cnss_prealloc: Add snapshot of cnss_prealloc driver 



This is a snapshot of cnss_prealloc driver and associated files as of
msm-4.19 commit 94d53f998edd
("cnss_prealloc: Update prealloc memory table").

Change-Id: Ic6e853bf651e2a0e2b672bc68d42929c3b55ef93
CRs-Fixed: 2500800
Signed-off-by: default avatarYuanyuan Liu <yuanliu@codeaurora.org>
parent b75bba1a

drivers/net/wireless/Kconfig

+14 −0
Original line number Diff line number Diff line
@@ -122,8 +122,22 @@ config VIRT_WIFI 
	  This option adds support for ethernet connections to appear as if they

	  are wifi connections through a special rtnetlink device.



config CLD_LL_CORE

	tristate "QTI core WLAN driver for QCA6174 chipset"

	select NL80211_TESTMODE

	select WEXT_CORE

	select WEXT_PRIV

	select WEXT_SPY

	select WIRELESS_EXT

	help

	  This section contains the necessary modules needed to enable the

	  core WLAN driver for QTI QCA6174 chipset.

	  Select Y to compile the driver in order to have WLAN functionality

	  support.



source "drivers/net/wireless/cnss2/Kconfig"

source "drivers/net/wireless/cnss_utils/Kconfig"

source "drivers/net/wireless/cnss_genl/Kconfig"

source "drivers/net/wireless/cnss_prealloc/Kconfig"



endif # WLAN

drivers/net/wireless/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -33,3 +33,4 @@ obj-$(CONFIG_VIRT_WIFI) += virt_wifi.o 
obj-$(CONFIG_CNSS2) += cnss2/

obj-$(CONFIG_CNSS_UTILS) += cnss_utils/

obj-$(CONFIG_CNSS_GENL) += cnss_genl/

obj-$(CONFIG_WCNSS_MEM_PRE_ALLOC) += cnss_prealloc/

drivers/net/wireless/cnss_prealloc/Kconfig

0 → 100644
+9 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only



config WCNSS_MEM_PRE_ALLOC

	tristate "WCNSS pre-alloc memory support"

	help

	  Pre-allocate memory for the WLAN driver module.

	  This feature enable cld wlan driver to use pre allocated memory

	  for it's internal usage and release it to back to pre allocated pool.

	  This memory is allocated at the cold boot time.

drivers/net/wireless/cnss_prealloc/Makefile

0 → 100644
+3 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only



obj-$(CONFIG_WCNSS_MEM_PRE_ALLOC) += cnss_prealloc.o

drivers/net/wireless/cnss_prealloc/cnss_prealloc.c

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

/* Copyright (c) 2012,2014-2017,2019 The Linux Foundation. All rights reserved. */



#include <linux/module.h>

#include <linux/slab.h>

#include <linux/seq_file.h>

#include <linux/err.h>

#include <linux/stacktrace.h>

#include <linux/spinlock.h>

#include <linux/debugfs.h>

#ifdef CONFIG_WCNSS_SKB_PRE_ALLOC

#include <linux/skbuff.h>

#endif

#include <net/cnss_prealloc.h>



static DEFINE_SPINLOCK(alloc_lock);



#ifdef CONFIG_SLUB_DEBUG

#define WCNSS_MAX_STACK_TRACE			64

#endif



#define PRE_ALLOC_DEBUGFS_DIR		"cnss-prealloc"

#define PRE_ALLOC_DEBUGFS_FILE_OBJ	"status"



static struct dentry *debug_base;



struct wcnss_prealloc {

	int occupied;

	size_t size;

	void *ptr;

#ifdef CONFIG_SLUB_DEBUG

	unsigned long stack_trace[WCNSS_MAX_STACK_TRACE];

	struct stack_trace trace;

#endif

};



/* pre-alloced mem for WLAN driver */

static struct wcnss_prealloc wcnss_allocs[] = {

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 8  * 1024, NULL},

	{0, 16 * 1024, NULL},

	{0, 16 * 1024, NULL},

	{0, 16 * 1024, NULL},

	{0, 16 * 1024, NULL},

	{0, 16 * 1024, NULL},

	{0, 16 * 1024, NULL},

	{0, 32 * 1024, NULL},

	{0, 32 * 1024, NULL},

	{0, 32 * 1024, NULL},

	{0, 32 * 1024, NULL},

	{0, 32 * 1024, NULL},

	{0, 32 * 1024, NULL},

	{0, 64 * 1024, NULL},

	{0, 64 * 1024, NULL},

	{0, 64 * 1024, NULL},

	{0, 64 * 1024, NULL},

};



int wcnss_prealloc_init(void)

{

	int i;



	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		wcnss_allocs[i].occupied = 0;

		wcnss_allocs[i].ptr = kmalloc(wcnss_allocs[i].size, GFP_KERNEL);

		if (!wcnss_allocs[i].ptr)

			return -ENOMEM;

	}



	return 0;

}



void wcnss_prealloc_deinit(void)

{

	int i = 0;



	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		kfree(wcnss_allocs[i].ptr);

		wcnss_allocs[i].ptr = NULL;

	}

}



#ifdef CONFIG_SLUB_DEBUG

static void wcnss_prealloc_save_stack_trace(struct wcnss_prealloc *entry)

{

	struct stack_trace *trace = &entry->trace;



	memset(&entry->stack_trace, 0, sizeof(entry->stack_trace));

	trace->nr_entries = 0;

	trace->max_entries = WCNSS_MAX_STACK_TRACE;

	trace->entries = entry->stack_trace;

	trace->skip = 2;



	save_stack_trace(trace);

}

#else

static inline

void wcnss_prealloc_save_stack_trace(struct wcnss_prealloc *entry) {}

#endif



void *wcnss_prealloc_get(size_t size)

{

	int i = 0;

	unsigned long flags;



	spin_lock_irqsave(&alloc_lock, flags);

	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		if (wcnss_allocs[i].occupied)

			continue;



		if (wcnss_allocs[i].size >= size) {

			/* we found the slot */

			wcnss_allocs[i].occupied = 1;

			spin_unlock_irqrestore(&alloc_lock, flags);

			wcnss_prealloc_save_stack_trace(&wcnss_allocs[i]);

			return wcnss_allocs[i].ptr;

		}

	}

	spin_unlock_irqrestore(&alloc_lock, flags);



	return NULL;

}

EXPORT_SYMBOL(wcnss_prealloc_get);



int wcnss_prealloc_put(void *ptr)

{

	int i = 0;

	unsigned long flags;



	spin_lock_irqsave(&alloc_lock, flags);

	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		if (wcnss_allocs[i].ptr == ptr) {

			wcnss_allocs[i].occupied = 0;

			spin_unlock_irqrestore(&alloc_lock, flags);

			return 1;

		}

	}

	spin_unlock_irqrestore(&alloc_lock, flags);



	return 0;

}

EXPORT_SYMBOL(wcnss_prealloc_put);



#ifdef CONFIG_SLUB_DEBUG

void wcnss_prealloc_check_memory_leak(void)

{

	int i, j = 0;



	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		if (!wcnss_allocs[i].occupied)

			continue;



		if (j == 0) {

			pr_err("wcnss_prealloc: Memory leak detected\n");

			j++;

		}



		pr_err("Size: %zu, addr: %pK, backtrace:\n",

		       wcnss_allocs[i].size, wcnss_allocs[i].ptr);

		print_stack_trace(&wcnss_allocs[i].trace, 1);

	}

}

#else

void wcnss_prealloc_check_memory_leak(void) {}

#endif

EXPORT_SYMBOL(wcnss_prealloc_check_memory_leak);



int wcnss_pre_alloc_reset(void)

{

	int i, n = 0;



	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		if (!wcnss_allocs[i].occupied)

			continue;



		wcnss_allocs[i].occupied = 0;

		n++;

	}



	return n;

}

EXPORT_SYMBOL(wcnss_pre_alloc_reset);



static int prealloc_memory_stats_show(struct seq_file *fp, void *data)

{

	int i = 0;

	int used_slots = 0, free_slots = 0;

	unsigned int tsize = 0, tused = 0, size = 0;



	seq_puts(fp, "\nSlot_Size(Kb)\t\t[Used : Free]\n");

	for (i = 0; i < ARRAY_SIZE(wcnss_allocs); i++) {

		tsize += wcnss_allocs[i].size;

		if (size != wcnss_allocs[i].size) {

			if (size) {

				seq_printf(fp, "[%d : %d]\n",

					   used_slots, free_slots);

			}



			size = wcnss_allocs[i].size;

			used_slots = 0;

			free_slots = 0;

			seq_printf(fp, "%d Kb\t\t\t", size / 1024);

		}



		if (wcnss_allocs[i].occupied) {

			tused += wcnss_allocs[i].size;

			++used_slots;

		} else {

			++free_slots;

		}

	}

	seq_printf(fp, "[%d : %d]\n", used_slots, free_slots);



	/* Convert byte to Kb */

	if (tsize)

		tsize = tsize / 1024;

	if (tused)

		tused = tused / 1024;

	seq_printf(fp, "\nMemory Status:\nTotal Memory: %dKb\n", tsize);

	seq_printf(fp, "Used: %dKb\nFree: %dKb\n", tused, tsize - tused);



	return 0;

}



static int prealloc_memory_stats_open(struct inode *inode, struct file *file)

{

	return single_open(file, prealloc_memory_stats_show, NULL);

}



static const struct file_operations prealloc_memory_stats_fops = {

	.owner = THIS_MODULE,

	.open = prealloc_memory_stats_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static int __init wcnss_pre_alloc_init(void)

{

	int ret;



	ret = wcnss_prealloc_init();

	if (ret) {

		pr_err("%s: Failed to init the prealloc pool\n", __func__);

		return ret;

	}



	debug_base = debugfs_create_dir(PRE_ALLOC_DEBUGFS_DIR, NULL);

	if (IS_ERR_OR_NULL(debug_base)) {

		pr_err("%s: Failed to create debugfs dir\n", __func__);

	} else if (IS_ERR_OR_NULL(debugfs_create_file

				  (PRE_ALLOC_DEBUGFS_FILE_OBJ,

				   0644, debug_base, NULL,

				   &prealloc_memory_stats_fops))) {

		pr_err("%s: Failed to create debugfs file\n", __func__);

		debugfs_remove_recursive(debug_base);

	}



	return ret;

}



static void __exit wcnss_pre_alloc_exit(void)

{

	wcnss_prealloc_deinit();

	debugfs_remove_recursive(debug_base);

}



module_init(wcnss_pre_alloc_init);

module_exit(wcnss_pre_alloc_exit);



MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("WCNSS Prealloc Driver");