[deliverable/linux.git] / drivers / staging / rtl8188eu / core / rtw_debug.c

/******************************************************************************
 *
 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * 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.
 *
 ******************************************************************************/
#define _RTW_DEBUG_C_

#include <rtw_debug.h>
#include <usb_ops_linux.h>

int proc_get_drv_version(char *page, char **start,
			  off_t offset, int count,
			  int *eof, void *data)
{
	int len = 0;

	len += snprintf(page + len, count - len, "%s\n", DRIVERVERSION);

	*eof = 1;
	return len;
}

int proc_get_write_reg(char *page, char **start,
			  off_t offset, int count,
			  int *eof, void *data)
{
	*eof = 1;
	return 0;
}

int proc_set_write_reg(struct file *file, const char __user *buffer,
		unsigned long count, void *data)
{
	struct net_device *dev = data;
	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
	char tmp[32];
	u32 addr, val, len;

	if (count < 3) {
		DBG_88E("argument size is less than 3\n");
		return -EFAULT;
	}

	if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
		int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);

		if (num !=  3) {
			DBG_88E("invalid write_reg parameter!\n");
			return count;
		}
		switch (len) {
		case 1:
			usb_write8(padapter, addr, (u8)val);
			break;
		case 2:
			usb_write16(padapter, addr, (u16)val);
			break;
		case 4:
			usb_write32(padapter, addr, val);
			break;
		default:
			DBG_88E("error write length =%d", len);
			break;
		}
	}
	return count;
}

static u32 proc_get_read_addr = 0xeeeeeeee;
static u32 proc_get_read_len = 0x4;

int proc_get_read_reg(char *page, char **start,
			  off_t offset, int count,
			  int *eof, void *data)
{
	struct net_device *dev = data;
	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);

	int len = 0;

	if (proc_get_read_addr == 0xeeeeeeee) {
		*eof = 1;
		return len;
	}

	switch (proc_get_read_len) {
	case 1:
		len += snprintf(page + len, count - len, "usb_read8(0x%x)=0x%x\n", proc_get_read_addr, usb_read8(padapter, proc_get_read_addr));
		break;
	case 2:
		len += snprintf(page + len, count - len, "usb_read16(0x%x)=0x%x\n", proc_get_read_addr, usb_read16(padapter, proc_get_read_addr));
		break;
	case 4:
		len += snprintf(page + len, count - len, "usb_read32(0x%x)=0x%x\n", proc_get_read_addr, usb_read32(padapter, proc_get_read_addr));
		break;
	default:
		len += snprintf(page + len, count - len, "error read length=%d\n", proc_get_read_len);
		break;
	}

	*eof = 1;
	return len;
}

int proc_set_read_reg(struct file *file, const char __user *buffer,
		unsigned long count, void *data)
{
	char tmp[16];
	u32 addr, len;

	if (count < 2) {
		DBG_88E("argument size is less than 2\n");
		return -EFAULT;
	}

	if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
		int num = sscanf(tmp, "%x %x", &addr, &len);

		if (num !=  2) {
			DBG_88E("invalid read_reg parameter!\n");
			return count;
		}

		proc_get_read_addr = addr;

		proc_get_read_len = len;
	}

	return count;
}

int proc_get_adapter_state(char *page, char **start,
			  off_t offset, int count,
			  int *eof, void *data)
{
	struct net_device *dev = data;
	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
	int len = 0;

	len += snprintf(page + len, count - len, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
						padapter->bSurpriseRemoved, padapter->bDriverStopped);

	*eof = 1;
	return len;
}

int proc_get_best_channel(char *page, char **start,
			  off_t offset, int count,
			  int *eof, void *data)
{
	struct net_device *dev = data;
	struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
	int len = 0;
	u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;

	for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
		if (pmlmeext->channel_set[i].ChannelNum == 1)
			index_24G = i;
		if (pmlmeext->channel_set[i].ChannelNum == 36)
			index_5G = i;
	}

	for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
		/*  2.4G */
		if (pmlmeext->channel_set[i].ChannelNum == 6) {
			if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) {
				index_24G = i;
				best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
			}
		}

		/*  5G */
		if (pmlmeext->channel_set[i].ChannelNum >= 36 &&
		    pmlmeext->channel_set[i].ChannelNum < 140) {
			/*  Find primary channel */
			if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) &&
			    (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
				index_5G = i;
				best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
			}
		}

		if (pmlmeext->channel_set[i].ChannelNum >= 149 &&
		    pmlmeext->channel_set[i].ChannelNum < 165) {
			/*  find primary channel */
			if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) &&
			    (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
				index_5G = i;
				best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
			}
		}
		/*  debug */
		len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n",
					pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
	}

	len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G);
	len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G);

	*eof = 1;
	return len;
}
Commit	Line	Data
06a05884 LF	1	/******************************************************************************
	2	*
	3	* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of version 2 of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
06a05884 LF	14	******************************************************************************/
	15	#define _RTW_DEBUG_C_
	16
	17	#include <rtw_debug.h>
e73fd15e	18	#include <usb_ops_linux.h>
06a05884 LF	19
	20	int proc_get_drv_version(char page, char *start,
	21	off_t offset, int count,
	22	int eof, void data)
	23	{
	24	int len = 0;
	25
	26	len += snprintf(page + len, count - len, "%s\n", DRIVERVERSION);
	27
	28	*eof = 1;
	29	return len;
	30	}
	31
	32	int proc_get_write_reg(char page, char *start,
	33	off_t offset, int count,
	34	int eof, void data)
	35	{
	36	*eof = 1;
	37	return 0;
	38	}
	39
	40	int proc_set_write_reg(struct file file, const char __user buffer,
	41	unsigned long count, void *data)
	42	{
60c89911	43	struct net_device *dev = data;
06a05884 LF	44	struct adapter padapter = (struct adapter )rtw_netdev_priv(dev);
	45	char tmp[32];
	46	u32 addr, val, len;
	47
	48	if (count < 3) {
	49	DBG_88E("argument size is less than 3\n");
	50	return -EFAULT;
	51	}
	52
	53	if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
	54	int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
	55
	56	if (num != 3) {
	57	DBG_88E("invalid write_reg parameter!\n");
	58	return count;
	59	}
	60	switch (len) {
	61	case 1:
e76484d0	62	usb_write8(padapter, addr, (u8)val);
06a05884 LF	63	break;
06a05884 LF	64	case 2:
9764ed04	65	usb_write16(padapter, addr, (u16)val);
06a05884 LF	66	break;
06a05884 LF	67	case 4:
fc158079	68	usb_write32(padapter, addr, val);
06a05884 LF	69	break;
	70	default:
	71	DBG_88E("error write length =%d", len);
	72	break;
	73	}
	74	}
	75	return count;
	76	}
	77
	78	static u32 proc_get_read_addr = 0xeeeeeeee;
	79	static u32 proc_get_read_len = 0x4;
	80
	81	int proc_get_read_reg(char page, char *start,
	82	off_t offset, int count,
	83	int eof, void data)
	84	{
	85	struct net_device *dev = data;
	86	struct adapter padapter = (struct adapter )rtw_netdev_priv(dev);
	87
	88	int len = 0;
	89
	90	if (proc_get_read_addr == 0xeeeeeeee) {
	91	*eof = 1;
	92	return len;
	93	}
	94
	95	switch (proc_get_read_len) {
	96	case 1:
c7b2e995	97	len += snprintf(page + len, count - len, "usb_read8(0x%x)=0x%x\n", proc_get_read_addr, usb_read8(padapter, proc_get_read_addr));
06a05884 LF	98	break;
06a05884 LF	99	case 2:
551a3972	100	len += snprintf(page + len, count - len, "usb_read16(0x%x)=0x%x\n", proc_get_read_addr, usb_read16(padapter, proc_get_read_addr));
06a05884 LF	101	break;
06a05884 LF	102	case 4:
99ecfb06	103	len += snprintf(page + len, count - len, "usb_read32(0x%x)=0x%x\n", proc_get_read_addr, usb_read32(padapter, proc_get_read_addr));
06a05884 LF	104	break;
	105	default:
	106	len += snprintf(page + len, count - len, "error read length=%d\n", proc_get_read_len);
	107	break;
	108	}
	109
	110	*eof = 1;
	111	return len;
	112	}
	113
	114	int proc_set_read_reg(struct file file, const char __user buffer,
	115	unsigned long count, void *data)
	116	{
	117	char tmp[16];
	118	u32 addr, len;
	119
	120	if (count < 2) {
	121	DBG_88E("argument size is less than 2\n");
	122	return -EFAULT;
	123	}
	124
	125	if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
	126	int num = sscanf(tmp, "%x %x", &addr, &len);
	127
	128	if (num != 2) {
	129	DBG_88E("invalid read_reg parameter!\n");
	130	return count;
	131	}
	132
	133	proc_get_read_addr = addr;
	134
	135	proc_get_read_len = len;
	136	}
	137
	138	return count;
	139	}
	140
06a05884 LF	141	int proc_get_adapter_state(char page, char *start,
	142	off_t offset, int count,
	143	int eof, void data)
	144	{
	145	struct net_device *dev = data;
	146	struct adapter padapter = (struct adapter )rtw_netdev_priv(dev);
	147	int len = 0;
	148
	149	len += snprintf(page + len, count - len, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
	150	padapter->bSurpriseRemoved, padapter->bDriverStopped);
	151
	152	*eof = 1;
	153	return len;
	154	}
	155
06a05884 LF	156	int proc_get_best_channel(char page, char *start,
	157	off_t offset, int count,
	158	int eof, void data)
	159	{
	160	struct net_device *dev = data;
	161	struct adapter padapter = (struct adapter )rtw_netdev_priv(dev);
	162	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
	163	int len = 0;
	164	u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
	165
	166	for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
	167	if (pmlmeext->channel_set[i].ChannelNum == 1)
	168	index_24G = i;
	169	if (pmlmeext->channel_set[i].ChannelNum == 36)
	170	index_5G = i;
	171	}
	172
	173	for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
	174	/* 2.4G */
	175	if (pmlmeext->channel_set[i].ChannelNum == 6) {
	176	if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) {
	177	index_24G = i;
	178	best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
	179	}
	180	}
	181
	182	/* 5G */
	183	if (pmlmeext->channel_set[i].ChannelNum >= 36 &&
	184	pmlmeext->channel_set[i].ChannelNum < 140) {
4e0fa71c	185	/* Find primary channel */
06a05884 LF	186	if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) &&
	187	(pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
	188	index_5G = i;
	189	best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
	190	}
	191	}
	192
	193	if (pmlmeext->channel_set[i].ChannelNum >= 149 &&
	194	pmlmeext->channel_set[i].ChannelNum < 165) {
4e0fa71c	195	/* find primary channel */
06a05884 LF	196	if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) &&
	197	(pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
	198	index_5G = i;
	199	best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
	200	}
	201	}
	202	/* debug */
	203	len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n",
	204	pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
	205	}
	206
	207	len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G);
	208	len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G);
	209
	210	*eof = 1;
	211	return len;
	212	}