qca-nss-drv/nss_project.c - manifest_repos/sdk - Git at Google

 /*
  **************************************************************************
  * Copyright (c) 2017-2018, 2020, The Linux Foundation. All rights reserved.
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
  * above copyright notice and this permission notice appear in all copies.
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  **************************************************************************
  */

 /*
  * @file nss_project.h
  *	NSS project APIs.
  */
 #include "nss_tx_rx_common.h"

 static int nss_project_wt_stats_enable;

 /*
  * nss_project_free_wt_stats()
  *	Frees a number of allocated worker thread statistics.
  */
 static void nss_project_free_wt_stats(struct nss_worker_thread_stats *wt_stats, int num_alloc)
 {
 	int i;

 	if (!wt_stats) {
 		return;
 	}

 	for (i = 0; i < num_alloc; i++) {
 		kfree(wt_stats[i].irq_stats);
 	}
 	kfree(wt_stats);
 }

 /*
  * nss_project_alloc_wt_stats()
  * 	Allocates worker thread stats for a given  number of threads and IRQs.
  */
 static struct nss_worker_thread_stats *nss_project_alloc_wt_stats(uint32_t thread_count, uint32_t irq_count)
 {
 	struct nss_worker_thread_stats *wt_stats;
 	int i;

 	wt_stats = kzalloc(thread_count * sizeof(struct nss_worker_thread_stats), GFP_ATOMIC);
 	if (unlikely(!wt_stats)) {
 		return NULL;
 	}

 	for (i = 0; i < thread_count; i++) {
 		wt_stats[i].irq_stats =
 			kzalloc(irq_count * sizeof(struct nss_project_irq_stats), GFP_ATOMIC);
 		if (unlikely(!wt_stats[i].irq_stats)) {
 			nss_project_free_wt_stats(wt_stats, i);
 			return NULL;
 		}
 	}

 	return wt_stats;
 }

 /*
  * nss_project_wt_stats_enable_callback()
  *	Callback function for wt stats enable messages
  */
 static void nss_project_wt_stats_enable_callback(void *app_data, struct nss_project_msg *msg)
 {
 	struct nss_ctx_instance *nss_ctx = (struct nss_ctx_instance *)app_data;
 	struct nss_project_msg_wt_stats_enable *stats_enable = &msg->msg.wt_stats_enable;
 	struct nss_worker_thread_stats *stats_temp;

 	NSS_VERIFY_CTX_MAGIC(nss_ctx);
 	if (msg->cm.response != NSS_CMN_RESPONSE_ACK) {
 		return;
 	}

 	nss_info("%px: Received response ACK for worker thread stats enable msg.\n", nss_ctx);

 	/*
 	 * If statistics have already been allocated, nothing else to do.
 	 */
 	if (nss_ctx->wt_stats) {
 		return;
 	}

 	stats_temp = nss_project_alloc_wt_stats(stats_enable->worker_thread_count,
 						stats_enable->irq_count);
 	if (unlikely(!stats_temp)) {
 		nss_warning("%px: Unable to allocate worker thread statistics.\n", nss_ctx);
 		return;
 	}

 	spin_lock_bh(&nss_ctx->nss_top->stats_lock);
 	nss_ctx->wt_stats = stats_temp;
 	nss_ctx->worker_thread_count = stats_enable->worker_thread_count;
 	nss_ctx->irq_count = stats_enable->irq_count;
 	spin_unlock_bh(&nss_ctx->nss_top->stats_lock);
 }

 /*
  * nss_project_wt_stats_send_enable()
  *	Sends message to firmware to enable or disable worker_thread statistics collection.
  */
 static nss_tx_status_t nss_project_wt_stats_send_enable(struct nss_ctx_instance *nss_ctx, bool enable)
 {
 	struct nss_project_msg *npm;
 	struct nss_cmn_msg *ncm;
 	nss_tx_status_t ret;

 	npm = kzalloc(sizeof(*npm), GFP_KERNEL);
 	if (!npm) {
 		nss_warning("%px: Failed to allocate buffer for message\n", nss_ctx);
 		return NSS_TX_FAILURE;
 	}

 	/*
 	 * Populate the message
 	 */
 	ncm = &npm->cm;
 	nss_cmn_msg_init(ncm, NSS_PROJECT_INTERFACE,
 		NSS_PROJECT_MSG_WT_STATS_ENABLE,
 		sizeof(struct nss_project_msg_wt_stats_enable),
 		(void *)nss_project_wt_stats_enable_callback,
 		(void *)nss_ctx);
 	npm->msg.wt_stats_enable.enable = enable;

 	ret = nss_core_send_cmd(nss_ctx, npm, sizeof(*npm), NSS_NBUF_PAYLOAD_SIZE);
 	kfree(npm);
 	return ret;
 }

 /*
  * nss_project_wt_stats_update()
  *	Updates stored statistics with the data found in the notify.
  */
 static void nss_project_wt_stats_update(struct nss_ctx_instance *nss_ctx,
 			struct nss_project_msg_wt_stats_notify *stats_notify)
 {
 	struct nss_worker_thread_stats *wt_stats;
 	int i;

 	if (unlikely(!nss_ctx->wt_stats)) {
 		nss_warning("%px: Worker thread statistics not yet allocated.\n", nss_ctx);
 		return;
 	}

 	if (unlikely(stats_notify->threadno >= nss_ctx->worker_thread_count)) {
 		nss_warning("%px: Invalid WT number %d\n", nss_ctx, stats_notify->threadno);
 		return;
 	}

 	if (unlikely(stats_notify->stats_written > NSS_PROJECT_IRQS_PER_MESSAGE)) {
 		nss_warning("%px: Invalid worker thread stats written count %d\n",
 				nss_ctx, stats_notify->stats_written);
 		return;
 	}

 	wt_stats = &(nss_ctx->wt_stats[stats_notify->threadno]);

 	if (unlikely(!wt_stats->irq_stats)) {
 		nss_warning("%px: Worker thread statistics not allocated for thread %d\n",
 				nss_ctx, stats_notify->threadno);
 		return;
 	}

 	spin_lock_bh(&nss_ctx->nss_top->stats_lock);
 	for (i = 0; i < stats_notify->stats_written; ++i) {
 		int irq = stats_notify->stats[i].irq;
 		if (unlikely(irq >= nss_ctx->irq_count)) {
 			nss_warning("%px: Invalid IRQ number %d\n", nss_ctx, irq);
 			continue;
 		}

 		wt_stats->irq_stats[irq] = stats_notify->stats[i];
 	}
 	spin_unlock_bh(&nss_ctx->nss_top->stats_lock);
 }

 /*
  * nss_project_msg_handler()
  *	Handles metadata messages on the project interface.
  */
 static void nss_project_msg_handler(struct nss_ctx_instance *nss_ctx,
 	struct nss_cmn_msg *ncm, __attribute__((unused))void *app_data)
 {
 	struct nss_project_msg *npm = (struct nss_project_msg *)ncm;
 	nss_project_msg_callback_t cb;

 	/*
 	 * Sanity checks on message
 	 */
 	if (npm->cm.type >= NSS_PROJECT_MSG_MAX) {
 		nss_warning("%px: message type out of range: %d\n", nss_ctx, npm->cm.type);
 		return;
 	}

 	if (nss_cmn_get_msg_len(&(npm->cm)) > sizeof(struct nss_project_msg)) {
 		nss_warning("%px: message length is invalid: %d\n", nss_ctx, nss_cmn_get_msg_len(&(npm->cm)));
 		return;
 	}

 	switch (npm->cm.type) {
 	case NSS_PROJECT_MSG_WT_STATS_NOTIFY:
 		nss_project_wt_stats_update(nss_ctx, &(npm->msg.wt_stats_notify));
 		return;
 	}

 	nss_core_log_msg_failures(nss_ctx, ncm);

 	if (!ncm->cb) {
 		return;
 	}

 	cb = (nss_project_msg_callback_t)ncm->cb;
 	cb((void *)nss_ctx, npm);
 }

 /*
  * nss_project_wt_stats_handler()
  *	Sysctl handler for wt_stats.
  *
  * Uses proc_dointvec to process data. For a write operation, also sends worker
  * thread stats enable messages containing the new value to each NSS core.
  */
 static int nss_project_wt_stats_handler(struct ctl_table *ctl, int write,
 	void __user *buffer, size_t *lenp, loff_t *ppos)
 {
 	int ret;
 	int i;

 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);

 	/*
 	 * In case of error, stop now.
 	 */
 	if (ret) {
 		return ret;
 	}

 	/*
 	 * No additional behavior necessary for a read operation.
 	 */
 	if (!write) {
 		return ret;
 	}

 	/*
 	 * If a value was written, send a message containing that value to each
 	 * NSS core.
 	 */
 	for (i = 0; i < nss_top_main.num_nss; ++i) {
 		nss_project_wt_stats_send_enable(&(nss_top_main.nss[i]),
 			nss_project_wt_stats_enable);
 	}
 	return ret;

 }

 /*
  * Tree of ctl_tables used to put the wt_stats proc node in the correct place in
  * the file system. Allows the command $ echo 1 > proc/sys/dev/nss/project/wt_stats
  * to enable worker thread statistics (echoing 0 into the same target will disable).
  */
 static struct ctl_table nss_project_table[] = {
 	{
 		.procname		= "wt_stats",
 		.data			= &nss_project_wt_stats_enable,
 		.maxlen			= sizeof(int),
 		.mode			= 0644,
 		.proc_handler		= &nss_project_wt_stats_handler,
 	},
 	{ }
 };

 static struct ctl_table nss_project_dir[] = {
 	{
 		.procname		= "project",
 		.mode			= 0555,
 		.child			= nss_project_table,
 	},
 	{ }
 };

 static struct ctl_table nss_project_root_dir[] = {
 	{
 		.procname		= "nss",
 		.mode			= 0555,
 		.child			= nss_project_dir,
 	},
 	{ }
 };

 static struct ctl_table nss_project_root[] = {
 	{
 		.procname		= "dev",
 		.mode			= 0555,
 		.child			= nss_project_root_dir,
 	},
 	{ }
 };

 static struct ctl_table_header *nss_project_header;

 /*
  * nss_project_register_sysctl()
  *	Registers any sysctl handlers for the project.
  */
 void nss_project_register_sysctl(void)
 {
 	nss_project_header = register_sysctl_table(nss_project_root);
 }

 /*
  * nss_project_unregister_sysctl()
  *	De-registers any sysctl handlers for the project.
  */
 void nss_project_unregister_sysctl(void)
 {
 	if (nss_project_header) {
 		unregister_sysctl_table(nss_project_header);
 	}
 }

 /*
  * nss_project_register_handler()
  *	Registers the handler for NSS->HLOS messages
  */
 void nss_project_register_handler(struct nss_ctx_instance *nss_ctx)
 {
 	nss_core_register_handler(nss_ctx, NSS_PROJECT_INTERFACE, nss_project_msg_handler, NULL);
 }
	/*
	**************************************************************************
	* Copyright (c) 2017-2018, 2020, The Linux Foundation. All rights reserved.
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all copies.
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	**************************************************************************
	*/

	/*
	* @file nss_project.h
	* NSS project APIs.
	*/
	#include "nss_tx_rx_common.h"

	static int nss_project_wt_stats_enable;

	/*
	* nss_project_free_wt_stats()
	* Frees a number of allocated worker thread statistics.
	*/
	static void nss_project_free_wt_stats(struct nss_worker_thread_stats *wt_stats, int num_alloc)
	{
	int i;

	if (!wt_stats) {
	return;
	}

	for (i = 0; i < num_alloc; i++) {
	kfree(wt_stats[i].irq_stats);
	}
	kfree(wt_stats);
	}

	/*
	* nss_project_alloc_wt_stats()
	* Allocates worker thread stats for a given number of threads and IRQs.
	*/
	static struct nss_worker_thread_stats *nss_project_alloc_wt_stats(uint32_t thread_count, uint32_t irq_count)
	{
	struct nss_worker_thread_stats *wt_stats;
	int i;

	wt_stats = kzalloc(thread_count * sizeof(struct nss_worker_thread_stats), GFP_ATOMIC);
	if (unlikely(!wt_stats)) {
	return NULL;
	}

	for (i = 0; i < thread_count; i++) {
	wt_stats[i].irq_stats =
	kzalloc(irq_count * sizeof(struct nss_project_irq_stats), GFP_ATOMIC);
	if (unlikely(!wt_stats[i].irq_stats)) {
	nss_project_free_wt_stats(wt_stats, i);
	return NULL;
	}
	}

	return wt_stats;
	}

	/*
	* nss_project_wt_stats_enable_callback()
	* Callback function for wt stats enable messages
	*/
	static void nss_project_wt_stats_enable_callback(void app_data, struct nss_project_msg msg)
	{
	struct nss_ctx_instance nss_ctx = (struct nss_ctx_instance )app_data;
	struct nss_project_msg_wt_stats_enable *stats_enable = &msg->msg.wt_stats_enable;
	struct nss_worker_thread_stats *stats_temp;

	NSS_VERIFY_CTX_MAGIC(nss_ctx);
	if (msg->cm.response != NSS_CMN_RESPONSE_ACK) {
	return;
	}

	nss_info("%px: Received response ACK for worker thread stats enable msg.\n", nss_ctx);

	/*
	* If statistics have already been allocated, nothing else to do.
	*/
	if (nss_ctx->wt_stats) {
	return;
	}

	stats_temp = nss_project_alloc_wt_stats(stats_enable->worker_thread_count,
	stats_enable->irq_count);
	if (unlikely(!stats_temp)) {
	nss_warning("%px: Unable to allocate worker thread statistics.\n", nss_ctx);
	return;
	}

	spin_lock_bh(&nss_ctx->nss_top->stats_lock);
	nss_ctx->wt_stats = stats_temp;
	nss_ctx->worker_thread_count = stats_enable->worker_thread_count;
	nss_ctx->irq_count = stats_enable->irq_count;
	spin_unlock_bh(&nss_ctx->nss_top->stats_lock);
	}

	/*
	* nss_project_wt_stats_send_enable()
	* Sends message to firmware to enable or disable worker_thread statistics collection.
	*/
	static nss_tx_status_t nss_project_wt_stats_send_enable(struct nss_ctx_instance *nss_ctx, bool enable)
	{
	struct nss_project_msg *npm;
	struct nss_cmn_msg *ncm;
	nss_tx_status_t ret;

	npm = kzalloc(sizeof(*npm), GFP_KERNEL);
	if (!npm) {
	nss_warning("%px: Failed to allocate buffer for message\n", nss_ctx);
	return NSS_TX_FAILURE;
	}

	/*
	* Populate the message
	*/
	ncm = &npm->cm;
	nss_cmn_msg_init(ncm, NSS_PROJECT_INTERFACE,
	NSS_PROJECT_MSG_WT_STATS_ENABLE,
	sizeof(struct nss_project_msg_wt_stats_enable),
	(void *)nss_project_wt_stats_enable_callback,
	(void *)nss_ctx);
	npm->msg.wt_stats_enable.enable = enable;

	ret = nss_core_send_cmd(nss_ctx, npm, sizeof(*npm), NSS_NBUF_PAYLOAD_SIZE);
	kfree(npm);
	return ret;
	}

	/*
	* nss_project_wt_stats_update()
	* Updates stored statistics with the data found in the notify.
	*/
	static void nss_project_wt_stats_update(struct nss_ctx_instance *nss_ctx,
	struct nss_project_msg_wt_stats_notify *stats_notify)
	{
	struct nss_worker_thread_stats *wt_stats;
	int i;

	if (unlikely(!nss_ctx->wt_stats)) {
	nss_warning("%px: Worker thread statistics not yet allocated.\n", nss_ctx);
	return;
	}

	if (unlikely(stats_notify->threadno >= nss_ctx->worker_thread_count)) {
	nss_warning("%px: Invalid WT number %d\n", nss_ctx, stats_notify->threadno);
	return;
	}

	if (unlikely(stats_notify->stats_written > NSS_PROJECT_IRQS_PER_MESSAGE)) {
	nss_warning("%px: Invalid worker thread stats written count %d\n",
	nss_ctx, stats_notify->stats_written);
	return;
	}

	wt_stats = &(nss_ctx->wt_stats[stats_notify->threadno]);

	if (unlikely(!wt_stats->irq_stats)) {
	nss_warning("%px: Worker thread statistics not allocated for thread %d\n",
	nss_ctx, stats_notify->threadno);
	return;
	}

	spin_lock_bh(&nss_ctx->nss_top->stats_lock);
	for (i = 0; i < stats_notify->stats_written; ++i) {
	int irq = stats_notify->stats[i].irq;
	if (unlikely(irq >= nss_ctx->irq_count)) {
	nss_warning("%px: Invalid IRQ number %d\n", nss_ctx, irq);
	continue;
	}

	wt_stats->irq_stats[irq] = stats_notify->stats[i];
	}
	spin_unlock_bh(&nss_ctx->nss_top->stats_lock);
	}

	/*
	* nss_project_msg_handler()
	* Handles metadata messages on the project interface.
	*/
	static void nss_project_msg_handler(struct nss_ctx_instance *nss_ctx,
	struct nss_cmn_msg ncm, __attribute__((unused))void app_data)
	{
	struct nss_project_msg npm = (struct nss_project_msg )ncm;
	nss_project_msg_callback_t cb;

	/*
	* Sanity checks on message
	*/
	if (npm->cm.type >= NSS_PROJECT_MSG_MAX) {
	nss_warning("%px: message type out of range: %d\n", nss_ctx, npm->cm.type);
	return;
	}

	if (nss_cmn_get_msg_len(&(npm->cm)) > sizeof(struct nss_project_msg)) {
	nss_warning("%px: message length is invalid: %d\n", nss_ctx, nss_cmn_get_msg_len(&(npm->cm)));
	return;
	}

	switch (npm->cm.type) {
	case NSS_PROJECT_MSG_WT_STATS_NOTIFY:
	nss_project_wt_stats_update(nss_ctx, &(npm->msg.wt_stats_notify));
	return;
	}

	nss_core_log_msg_failures(nss_ctx, ncm);

	if (!ncm->cb) {
	return;
	}

	cb = (nss_project_msg_callback_t)ncm->cb;
	cb((void *)nss_ctx, npm);
	}

	/*
	* nss_project_wt_stats_handler()
	* Sysctl handler for wt_stats.
	*
	* Uses proc_dointvec to process data. For a write operation, also sends worker
	* thread stats enable messages containing the new value to each NSS core.
	*/
	static int nss_project_wt_stats_handler(struct ctl_table *ctl, int write,
	void __user buffer, size_t lenp, loff_t *ppos)
	{
	int ret;
	int i;

	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);

	/*
	* In case of error, stop now.
	*/
	if (ret) {
	return ret;
	}

	/*
	* No additional behavior necessary for a read operation.
	*/
	if (!write) {
	return ret;
	}

	/*
	* If a value was written, send a message containing that value to each
	* NSS core.
	*/
	for (i = 0; i < nss_top_main.num_nss; ++i) {
	nss_project_wt_stats_send_enable(&(nss_top_main.nss[i]),
	nss_project_wt_stats_enable);
	}
	return ret;

	}

	/*
	* Tree of ctl_tables used to put the wt_stats proc node in the correct place in
	* the file system. Allows the command $ echo 1 > proc/sys/dev/nss/project/wt_stats
	* to enable worker thread statistics (echoing 0 into the same target will disable).
	*/
	static struct ctl_table nss_project_table[] = {
	{
	.procname = "wt_stats",
	.data = &nss_project_wt_stats_enable,
	.maxlen = sizeof(int),
	.mode = 0644,
	.proc_handler = &nss_project_wt_stats_handler,
	},
	{ }
	};

	static struct ctl_table nss_project_dir[] = {
	{
	.procname = "project",
	.mode = 0555,
	.child = nss_project_table,
	},
	{ }
	};

	static struct ctl_table nss_project_root_dir[] = {
	{
	.procname = "nss",
	.mode = 0555,
	.child = nss_project_dir,
	},
	{ }
	};

	static struct ctl_table nss_project_root[] = {
	{
	.procname = "dev",
	.mode = 0555,
	.child = nss_project_root_dir,
	},
	{ }
	};

	static struct ctl_table_header *nss_project_header;

	/*
	* nss_project_register_sysctl()
	* Registers any sysctl handlers for the project.
	*/
	void nss_project_register_sysctl(void)
	{
	nss_project_header = register_sysctl_table(nss_project_root);
	}

	/*
	* nss_project_unregister_sysctl()
	* De-registers any sysctl handlers for the project.
	*/
	void nss_project_unregister_sysctl(void)
	{
	if (nss_project_header) {
	unregister_sysctl_table(nss_project_header);
	}
	}

	/*
	* nss_project_register_handler()
	* Registers the handler for NSS->HLOS messages
	*/
	void nss_project_register_handler(struct nss_ctx_instance *nss_ctx)
	{
	nss_core_register_handler(nss_ctx, NSS_PROJECT_INTERFACE, nss_project_msg_handler, NULL);
	}