dhd_csi.c - third_party/bcmdhd - Git at Google

 /*
  * Broadcom Dongle Host Driver (DHD)
  *
  * Copyright 1999-2016, Broadcom Corporation
  * All rights reserved,
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *    1. Redistributions of source code must retain the above copyright notice,
  *       this list of conditions and the following disclaimer.
  *    2. Redistributions in binary form must reproduce the above copyright notice,
  *       this list of conditions and the following disclaimer in the documentation
  *       and/or other materials provided with the distribution.
  *
  * This software is provided by the copyright holder "as is" and any express or
  * implied warranties, including, but not limited to, the implied warranties of
  * merchantability and fitness for a particular purpose are disclaimed. In no event
  * shall copyright holder be liable for any direct, indirect, incidental, special,
  * exemplary, or consequential damages (including, but not limited to, procurement
  * of substitute goods or services; loss of use, data, or profits; or business
  * interruption) however caused and on any theory of liability, whether in
  * contract, strict liability, or tort (including negligence or otherwise) arising
  * in any way out of the use of this software, even if advised of the possibility
  * of such damage
  *
  * $Id: dhd_csi.c 606280 2015-12-15 05:28:25Z $
  */
 #include <osl.h>

 #include <bcmutils.h>

 #include <bcmendian.h>
 #include <linuxver.h>
 #include <linux/list.h>
 #include <linux/sort.h>
 #include <dngl_stats.h>
 #include <wlioctl.h>

 #include <proto/bcmevent.h>
 #include <dhd.h>
 #include <dhd_dbg.h>
 #include <dhd_csi.h>

 #define NULL_CHECK(p, s, err)  \
 	do { \
 		if (!(p)) { \
 			printf("NULL POINTER (%s) : %s\n", __FUNCTION__, (s)); \
 			err = BCME_ERROR; \
 			return err; \
 		} \
 	} while (0)

 #define TIMESPEC_TO_US(ts)  (((uint64)(ts).tv_sec * USEC_PER_SEC) + \
 						(ts).tv_nsec / NSEC_PER_USEC)

 #define NULL_ADDR	"\x00\x00\x00\x00\x00\x00"

 int
 dhd_csi_event_handler(dhd_pub_t *dhd, wl_event_msg_t *event, void *event_data)
 {
 	int ret = BCME_OK, event_type;
 	bool is_new = TRUE;
 	struct timespec ts;
 	cfr_dump_data_t *p_event;
 	cfr_dump_list_t *ptr, *next, *new_res;
 	struct list_head * csi_list;
 	int ifidx = 0;

 	NULL_CHECK(dhd, "dhd is NULL", ret);

 	event_type = ntoh32_ua((void *)&event->event_type);

 	DHD_TRACE(("Enter %s\n", __FUNCTION__));

 	if (!event_data) {
 		DHD_ERROR(("%s: event_data is NULL\n", __FUNCTION__));
 		ret = BCME_ERROR;
 		return ret;
 	}
 	p_event = (cfr_dump_data_t *)event_data;

 	mutex_lock(&dhd->wl_csi_mutex);
 	ifidx = event->ifidx;
 	csi_list = get_dhd_csilist(dhd, ifidx);

 	if (!csi_list) {
 		DHD_ERROR(("%s: Can not get csi_list. ifidx %d\n", __FUNCTION__, ifidx));
 		ret = BCME_ERROR;
 		goto done;
 	}
 	/* check if this addr exist */
 	if (!list_empty(csi_list)) {
 		list_for_each_entry_safe(ptr, next, csi_list, list) {
 			if (bcmp(&ptr->entry.header.peer_macaddr, &p_event->header.peer_macaddr,
 				ETHER_ADDR_LEN) == 0) {
 				is_new = FALSE;
 				DHD_TRACE(("CSI data exist. Update to newest one.\n"));
 				/* update data to newest and success one and timestamp */
 				if ((p_event->header.cfr_capture_status == 0) &&
 					(p_event->header.cfr_dump_length <=
 					(MAXIMUM_CFR_DATA * (sizeof(unsigned int))))) {
 					bcopy(&p_event->header, &ptr->entry.header,
 						sizeof(cfr_dump_header_t));
 					get_monotonic_boottime(&ts);
 					ptr->entry.header.cfr_timestamp =
 						(uint64)TIMESPEC_TO_US(ts);
 					bcopy(&p_event->data, &ptr->entry.data,
 						p_event->header.cfr_dump_length);
 				}
 				else {
 					if (p_event->header.cfr_dump_length >
                                         	(MAXIMUM_CFR_DATA * (sizeof(unsigned int)))) {
 						DHD_ERROR(("data corrupted. No update.\n"));
 						ret = BCME_ERROR;
 					}
 				}
 				break;
 			}
 		}
 	}

 	if (is_new) {
 		new_res = (cfr_dump_list_t *)MALLOCZ(dhd->osh, sizeof(cfr_dump_list_t));
 		if (!new_res){
 			DHD_ERROR(("Malloc cfr dump list error\n"));
 			ret = BCME_NOMEM;
 			goto done;
 		}
 		if (p_event->header.cfr_dump_length <=
 			(MAXIMUM_CFR_DATA * (sizeof(unsigned int)))) {
 			bcopy(&p_event->header, &new_res->entry.header, sizeof(cfr_dump_header_t));
 			/* put the timestamp here */
 			get_monotonic_boottime(&ts);
 			new_res->entry.header.cfr_timestamp = (uint64)TIMESPEC_TO_US(ts);

 			bcopy(&p_event->data, &new_res->entry.data,
 				p_event->header.cfr_dump_length);
 		}
 		else {
 			DHD_ERROR(("data size is over limitation %d\n",
 				p_event->header.cfr_dump_length));
 			MFREE(dhd->osh, new_res, sizeof(cfr_dump_list_t));
 			ret = BCME_ERROR;
 			goto done;
 		}
 		DHD_TRACE(("New entry data size %d\n", p_event->header.cfr_dump_length));
 		INIT_LIST_HEAD(&(new_res->list));
 		list_add_tail(&(new_res->list), csi_list);

 		/* if never update before, send update uevent up */
 		if (!get_dhd_csiupdate(dhd, ifidx)) {
 			struct kobject *kobj = get_dhd_kobj(dhd);
 			if (kobj) {
 				int status = 0;
 				char event_string[UEVENT_LENGTH];
 				char *envp[] = { event_string, NULL };
 				snprintf(event_string, UEVENT_LENGTH, "IFACE=%s", dhd_ifname(dhd, ifidx));

 				/* Sent notification uevent */
 				status = kobject_uevent_env(kobj, KOBJ_ADD, envp);
 				if (status)
 					DHD_ERROR(("Send out uevent failed %d\n", status));
 				else
 					set_dhd_csiupdate(dhd, ifidx, 1);
 			} else {
 				DHD_ERROR(("Can not find dhd kobj.\n"));
 			}
 		}
 	}
 done:
 	mutex_unlock(&dhd->wl_csi_mutex);
 	return ret;
 }

 int
 dhd_csi_init(dhd_pub_t *dhd)
 {
 	int err = BCME_OK;
 	struct kobject *kobj = get_dhd_kobj(dhd);
 	struct list_head *csi_list;

 	NULL_CHECK(dhd, "dhd is NULL", err);
 	mutex_init(&dhd->wl_csi_mutex);

 	if (!kobj) {
 		err = BCME_ERROR;
 		DHD_ERROR(("%s: Can't get kobj.\n", __FUNCTION__));
 		return err;
 	}

 	dhd->dhd_kset = kset_create_and_add("kset", NULL, kobj);
 	if (!dhd->dhd_kset) {
 		err = BCME_NOMEM;
 		DHD_ERROR(("%s: Can't init kset.\n", __FUNCTION__));
 		return err;
 	}
 	kobj->kset = dhd->dhd_kset;

 	/* Init sysfs and csi list for wlan0 here. wlan0 is created before dhd_sysfs_init() */
 	csi_list = get_dhd_csilist(dhd, get_dhd_ifidx(dhd->info, "wlan0"));
 	set_dhd_csiupdate(dhd, get_dhd_ifidx(dhd->info, "wlan0"), 0);
 	if (csi_list) {
 		INIT_LIST_HEAD(csi_list);
 		err = create_sysfs_entry(dhd, "wlan0");
 	}
 	else {
 		DHD_ERROR(("%s Can't init CSI list.\n", __FUNCTION__));
 		err = BCME_ERROR;
 	}

 	return err;
 }

 int
 dhd_csi_deinit(dhd_pub_t *dhd)
 {
 	int err = BCME_OK;
 	struct kobject *kobj = get_dhd_kobj(dhd);
 	struct list_head *csi_list;
 	struct bin_attribute * bin_attr= NULL;

 	NULL_CHECK(dhd, "dhd is NULL", err);

 	/* remove wlan0 csi info here */
 	csi_list = get_dhd_csilist(dhd, get_dhd_ifidx(dhd->info, "wlan0"));
 	if (csi_list) {
 		remove_csi_list(dhd, csi_list);
 		bin_attr = get_dhd_binattr(dhd, get_dhd_ifidx(dhd->info, "wlan0"));
 		sysfs_remove_bin_file(kobj, bin_attr);
 	}

 	kset_unregister(dhd->dhd_kset);

 	return err;
 }

 int
 dhd_csi_dump_list(dhd_pub_t *dhd, char *buf, size_t count, int ifidx)
 {
 	int ret = BCME_OK;
 	cfr_dump_list_t *ptr, *next;
 	uint8 * pbuf = buf;
 	int num = 0;
 	int length = 0;
 	uint32 demarcation1 = 0xDADBEEAB;
 	uint32 demarcation2 = 0xBABEEDAD;
 	struct list_head *csi_list;

 	NULL_CHECK(dhd, "dhd is NULL", ret);

 	mutex_lock(&dhd->wl_csi_mutex);
 	csi_list = get_dhd_csilist(dhd, ifidx);

 	if (!csi_list) {
 		DHD_ERROR(("%s: Can not get csi_list. ifidx %d\n", __FUNCTION__, ifidx));
 		mutex_unlock(&dhd->wl_csi_mutex);
 		return BCME_ERROR;
 	}

 	/* check if csi record exists */
 	if (!list_empty(csi_list)) {
 		list_for_each_entry_safe(ptr, next, csi_list, list) {
 			/* if next record > buf count, just return */
 			if ((length + sizeof(cfr_dump_header_t) +
 				ptr->entry.header.cfr_dump_length) > count) {
 				DHD_ERROR(("Record over buffer size. Please read again.\n"));
 				mutex_unlock(&dhd->wl_csi_mutex);
 				return length;
 			}
 			/* add 4 bytes demarcation 0xDADBEEAB for csi data start */
 			bcopy(&demarcation1, pbuf, sizeof(unsigned int));
 			length += sizeof(unsigned int);
 			pbuf += sizeof(unsigned int);

 			bcopy(&ptr->entry.header, pbuf, sizeof(cfr_dump_header_t));
 			length += sizeof(cfr_dump_header_t);
 			pbuf += sizeof(cfr_dump_header_t);
 			DHD_TRACE(("Copy data size %d\n", ptr->entry.header.cfr_dump_length));
 			bcopy(&ptr->entry.data, pbuf, ptr->entry.header.cfr_dump_length);
 			length += ptr->entry.header.cfr_dump_length;
 			pbuf += ptr->entry.header.cfr_dump_length;
 			num++;
 			/* clean dumped list */
 			list_del(&ptr->list);
 			MFREE(dhd->osh, ptr, sizeof(cfr_dump_list_t));
 			/* add 4 bytes demarcation 0xBABEEDAD for csi data end */
 			bcopy(&demarcation2, pbuf, sizeof(unsigned int));
 			length += sizeof(unsigned int);
 			pbuf += sizeof(unsigned int);
 		}
 	}
 	DHD_TRACE(("dump %d record %d bytes\n", num, length));

 	/* Dump finished. Clear update flag */
 	set_dhd_csiupdate(dhd, ifidx, 0);
 	mutex_unlock(&dhd->wl_csi_mutex);
 	return length;
 }

 void remove_csi_list(dhd_pub_t *dhd, struct list_head *csi_list)
 {
 	cfr_dump_list_t *ptr, *next;
 	int num = 0;
 	if (!list_empty(csi_list)) {
 		list_for_each_entry_safe(ptr, next, csi_list, list) {
 			list_del(&ptr->list);
 			num++;
 			MFREE(dhd->osh, ptr, sizeof(cfr_dump_list_t));
 		}
 	}
 }
	/*
	* Broadcom Dongle Host Driver (DHD)
	*
	* Copyright 1999-2016, Broadcom Corporation
	* All rights reserved,
	*
	* Redistribution and use in source and binary forms, with or without modification,
	* are permitted provided that the following conditions are met:
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* This software is provided by the copyright holder "as is" and any express or
	* implied warranties, including, but not limited to, the implied warranties of
	* merchantability and fitness for a particular purpose are disclaimed. In no event
	* shall copyright holder be liable for any direct, indirect, incidental, special,
	* exemplary, or consequential damages (including, but not limited to, procurement
	* of substitute goods or services; loss of use, data, or profits; or business
	* interruption) however caused and on any theory of liability, whether in
	* contract, strict liability, or tort (including negligence or otherwise) arising
	* in any way out of the use of this software, even if advised of the possibility
	* of such damage
	*
	* $Id: dhd_csi.c 606280 2015-12-15 05:28:25Z $
	*/
	#include <osl.h>

	#include <bcmutils.h>

	#include <bcmendian.h>
	#include <linuxver.h>
	#include <linux/list.h>
	#include <linux/sort.h>
	#include <dngl_stats.h>
	#include <wlioctl.h>

	#include <proto/bcmevent.h>
	#include <dhd.h>
	#include <dhd_dbg.h>
	#include <dhd_csi.h>

	#define NULL_CHECK(p, s, err) \
	do { \
	if (!(p)) { \
	printf("NULL POINTER (%s) : %s\n", __FUNCTION__, (s)); \
	err = BCME_ERROR; \
	return err; \
	} \
	} while (0)

	#define TIMESPEC_TO_US(ts) (((uint64)(ts).tv_sec * USEC_PER_SEC) + \
	(ts).tv_nsec / NSEC_PER_USEC)

	#define NULL_ADDR "\x00\x00\x00\x00\x00\x00"

	int
	dhd_csi_event_handler(dhd_pub_t dhd, wl_event_msg_t event, void *event_data)
	{
	int ret = BCME_OK, event_type;
	bool is_new = TRUE;
	struct timespec ts;
	cfr_dump_data_t *p_event;
	cfr_dump_list_t ptr, next, *new_res;
	struct list_head * csi_list;
	int ifidx = 0;

	NULL_CHECK(dhd, "dhd is NULL", ret);

	event_type = ntoh32_ua((void *)&event->event_type);

	DHD_TRACE(("Enter %s\n", __FUNCTION__));

	if (!event_data) {
	DHD_ERROR(("%s: event_data is NULL\n", __FUNCTION__));
	ret = BCME_ERROR;
	return ret;
	}
	p_event = (cfr_dump_data_t *)event_data;

	mutex_lock(&dhd->wl_csi_mutex);
	ifidx = event->ifidx;
	csi_list = get_dhd_csilist(dhd, ifidx);

	if (!csi_list) {
	DHD_ERROR(("%s: Can not get csi_list. ifidx %d\n", __FUNCTION__, ifidx));
	ret = BCME_ERROR;
	goto done;
	}
	/* check if this addr exist */
	if (!list_empty(csi_list)) {
	list_for_each_entry_safe(ptr, next, csi_list, list) {
	if (bcmp(&ptr->entry.header.peer_macaddr, &p_event->header.peer_macaddr,
	ETHER_ADDR_LEN) == 0) {
	is_new = FALSE;
	DHD_TRACE(("CSI data exist. Update to newest one.\n"));
	/* update data to newest and success one and timestamp */
	if ((p_event->header.cfr_capture_status == 0) &&
	(p_event->header.cfr_dump_length <=
	(MAXIMUM_CFR_DATA * (sizeof(unsigned int))))) {
	bcopy(&p_event->header, &ptr->entry.header,
	sizeof(cfr_dump_header_t));
	get_monotonic_boottime(&ts);
	ptr->entry.header.cfr_timestamp =
	(uint64)TIMESPEC_TO_US(ts);
	bcopy(&p_event->data, &ptr->entry.data,
	p_event->header.cfr_dump_length);
	}
	else {
	if (p_event->header.cfr_dump_length >
	(MAXIMUM_CFR_DATA * (sizeof(unsigned int)))) {
	DHD_ERROR(("data corrupted. No update.\n"));
	ret = BCME_ERROR;
	}
	}
	break;
	}
	}
	}

	if (is_new) {
	new_res = (cfr_dump_list_t *)MALLOCZ(dhd->osh, sizeof(cfr_dump_list_t));
	if (!new_res){
	DHD_ERROR(("Malloc cfr dump list error\n"));
	ret = BCME_NOMEM;
	goto done;
	}
	if (p_event->header.cfr_dump_length <=
	(MAXIMUM_CFR_DATA * (sizeof(unsigned int)))) {
	bcopy(&p_event->header, &new_res->entry.header, sizeof(cfr_dump_header_t));
	/* put the timestamp here */
	get_monotonic_boottime(&ts);
	new_res->entry.header.cfr_timestamp = (uint64)TIMESPEC_TO_US(ts);

	bcopy(&p_event->data, &new_res->entry.data,
	p_event->header.cfr_dump_length);
	}
	else {
	DHD_ERROR(("data size is over limitation %d\n",
	p_event->header.cfr_dump_length));
	MFREE(dhd->osh, new_res, sizeof(cfr_dump_list_t));
	ret = BCME_ERROR;
	goto done;
	}
	DHD_TRACE(("New entry data size %d\n", p_event->header.cfr_dump_length));
	INIT_LIST_HEAD(&(new_res->list));
	list_add_tail(&(new_res->list), csi_list);

	/* if never update before, send update uevent up */
	if (!get_dhd_csiupdate(dhd, ifidx)) {
	struct kobject *kobj = get_dhd_kobj(dhd);
	if (kobj) {
	int status = 0;
	char event_string[UEVENT_LENGTH];
	char *envp[] = { event_string, NULL };
	snprintf(event_string, UEVENT_LENGTH, "IFACE=%s", dhd_ifname(dhd, ifidx));

	/* Sent notification uevent */
	status = kobject_uevent_env(kobj, KOBJ_ADD, envp);
	if (status)
	DHD_ERROR(("Send out uevent failed %d\n", status));
	else
	set_dhd_csiupdate(dhd, ifidx, 1);
	} else {
	DHD_ERROR(("Can not find dhd kobj.\n"));
	}
	}
	}
	done:
	mutex_unlock(&dhd->wl_csi_mutex);
	return ret;
	}

	int
	dhd_csi_init(dhd_pub_t *dhd)
	{
	int err = BCME_OK;
	struct kobject *kobj = get_dhd_kobj(dhd);
	struct list_head *csi_list;

	NULL_CHECK(dhd, "dhd is NULL", err);
	mutex_init(&dhd->wl_csi_mutex);

	if (!kobj) {
	err = BCME_ERROR;
	DHD_ERROR(("%s: Can't get kobj.\n", __FUNCTION__));
	return err;
	}

	dhd->dhd_kset = kset_create_and_add("kset", NULL, kobj);
	if (!dhd->dhd_kset) {
	err = BCME_NOMEM;
	DHD_ERROR(("%s: Can't init kset.\n", __FUNCTION__));
	return err;
	}
	kobj->kset = dhd->dhd_kset;

	/* Init sysfs and csi list for wlan0 here. wlan0 is created before dhd_sysfs_init() */
	csi_list = get_dhd_csilist(dhd, get_dhd_ifidx(dhd->info, "wlan0"));
	set_dhd_csiupdate(dhd, get_dhd_ifidx(dhd->info, "wlan0"), 0);
	if (csi_list) {
	INIT_LIST_HEAD(csi_list);
	err = create_sysfs_entry(dhd, "wlan0");
	}
	else {
	DHD_ERROR(("%s Can't init CSI list.\n", __FUNCTION__));
	err = BCME_ERROR;
	}

	return err;
	}

	int
	dhd_csi_deinit(dhd_pub_t *dhd)
	{
	int err = BCME_OK;
	struct kobject *kobj = get_dhd_kobj(dhd);
	struct list_head *csi_list;
	struct bin_attribute * bin_attr= NULL;

	NULL_CHECK(dhd, "dhd is NULL", err);

	/* remove wlan0 csi info here */
	csi_list = get_dhd_csilist(dhd, get_dhd_ifidx(dhd->info, "wlan0"));
	if (csi_list) {
	remove_csi_list(dhd, csi_list);
	bin_attr = get_dhd_binattr(dhd, get_dhd_ifidx(dhd->info, "wlan0"));
	sysfs_remove_bin_file(kobj, bin_attr);
	}

	kset_unregister(dhd->dhd_kset);

	return err;
	}

	int
	dhd_csi_dump_list(dhd_pub_t dhd, char buf, size_t count, int ifidx)
	{
	int ret = BCME_OK;
	cfr_dump_list_t ptr, next;
	uint8 * pbuf = buf;
	int num = 0;
	int length = 0;
	uint32 demarcation1 = 0xDADBEEAB;
	uint32 demarcation2 = 0xBABEEDAD;
	struct list_head *csi_list;

	NULL_CHECK(dhd, "dhd is NULL", ret);

	mutex_lock(&dhd->wl_csi_mutex);
	csi_list = get_dhd_csilist(dhd, ifidx);

	if (!csi_list) {
	DHD_ERROR(("%s: Can not get csi_list. ifidx %d\n", __FUNCTION__, ifidx));
	mutex_unlock(&dhd->wl_csi_mutex);
	return BCME_ERROR;
	}

	/* check if csi record exists */
	if (!list_empty(csi_list)) {
	list_for_each_entry_safe(ptr, next, csi_list, list) {
	/* if next record > buf count, just return */
	if ((length + sizeof(cfr_dump_header_t) +
	ptr->entry.header.cfr_dump_length) > count) {
	DHD_ERROR(("Record over buffer size. Please read again.\n"));
	mutex_unlock(&dhd->wl_csi_mutex);
	return length;
	}
	/* add 4 bytes demarcation 0xDADBEEAB for csi data start */
	bcopy(&demarcation1, pbuf, sizeof(unsigned int));
	length += sizeof(unsigned int);
	pbuf += sizeof(unsigned int);

	bcopy(&ptr->entry.header, pbuf, sizeof(cfr_dump_header_t));
	length += sizeof(cfr_dump_header_t);
	pbuf += sizeof(cfr_dump_header_t);
	DHD_TRACE(("Copy data size %d\n", ptr->entry.header.cfr_dump_length));
	bcopy(&ptr->entry.data, pbuf, ptr->entry.header.cfr_dump_length);
	length += ptr->entry.header.cfr_dump_length;
	pbuf += ptr->entry.header.cfr_dump_length;
	num++;
	/* clean dumped list */
	list_del(&ptr->list);
	MFREE(dhd->osh, ptr, sizeof(cfr_dump_list_t));
	/* add 4 bytes demarcation 0xBABEEDAD for csi data end */
	bcopy(&demarcation2, pbuf, sizeof(unsigned int));
	length += sizeof(unsigned int);
	pbuf += sizeof(unsigned int);
	}
	}
	DHD_TRACE(("dump %d record %d bytes\n", num, length));

	/* Dump finished. Clear update flag */
	set_dhd_csiupdate(dhd, ifidx, 0);
	mutex_unlock(&dhd->wl_csi_mutex);
	return length;
	}

	void remove_csi_list(dhd_pub_t dhd, struct list_head csi_list)
	{
	cfr_dump_list_t ptr, next;
	int num = 0;
	if (!list_empty(csi_list)) {
	list_for_each_entry_safe(ptr, next, csi_list, list) {
	list_del(&ptr->list);
	num++;
	MFREE(dhd->osh, ptr, sizeof(cfr_dump_list_t));
	}
	}
	}