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 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20 #define _RTW_DEBUG_C_
21
22 #include <rtw_debug.h>
23 #include <usb_ops_linux.h>
24
proc_get_drv_version(char * page,char ** start,off_t offset,int count,int * eof,void * data)25 int proc_get_drv_version(char *page, char **start,
26 off_t offset, int count,
27 int *eof, void *data)
28 {
29 int len = 0;
30
31 len += snprintf(page + len, count - len, "%s\n", DRIVERVERSION);
32
33 *eof = 1;
34 return len;
35 }
36
proc_get_write_reg(char * page,char ** start,off_t offset,int count,int * eof,void * data)37 int proc_get_write_reg(char *page, char **start,
38 off_t offset, int count,
39 int *eof, void *data)
40 {
41 *eof = 1;
42 return 0;
43 }
44
proc_set_write_reg(struct file * file,const char __user * buffer,unsigned long count,void * data)45 int proc_set_write_reg(struct file *file, const char __user *buffer,
46 unsigned long count, void *data)
47 {
48 struct net_device *dev = data;
49 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
50 char tmp[32];
51 u32 addr, val, len;
52
53 if (count < 3) {
54 DBG_88E("argument size is less than 3\n");
55 return -EFAULT;
56 }
57
58 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
59 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
60
61 if (num != 3) {
62 DBG_88E("invalid write_reg parameter!\n");
63 return count;
64 }
65 switch (len) {
66 case 1:
67 usb_write8(padapter, addr, (u8)val);
68 break;
69 case 2:
70 usb_write16(padapter, addr, (u16)val);
71 break;
72 case 4:
73 usb_write32(padapter, addr, val);
74 break;
75 default:
76 DBG_88E("error write length =%d", len);
77 break;
78 }
79 }
80 return count;
81 }
82
83 static u32 proc_get_read_addr = 0xeeeeeeee;
84 static u32 proc_get_read_len = 0x4;
85
proc_get_read_reg(char * page,char ** start,off_t offset,int count,int * eof,void * data)86 int proc_get_read_reg(char *page, char **start,
87 off_t offset, int count,
88 int *eof, void *data)
89 {
90 struct net_device *dev = data;
91 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
92
93 int len = 0;
94
95 if (proc_get_read_addr == 0xeeeeeeee) {
96 *eof = 1;
97 return len;
98 }
99
100 switch (proc_get_read_len) {
101 case 1:
102 len += snprintf(page + len, count - len, "usb_read8(0x%x)=0x%x\n", proc_get_read_addr, usb_read8(padapter, proc_get_read_addr));
103 break;
104 case 2:
105 len += snprintf(page + len, count - len, "usb_read16(0x%x)=0x%x\n", proc_get_read_addr, usb_read16(padapter, proc_get_read_addr));
106 break;
107 case 4:
108 len += snprintf(page + len, count - len, "usb_read32(0x%x)=0x%x\n", proc_get_read_addr, usb_read32(padapter, proc_get_read_addr));
109 break;
110 default:
111 len += snprintf(page + len, count - len, "error read length=%d\n", proc_get_read_len);
112 break;
113 }
114
115 *eof = 1;
116 return len;
117 }
118
proc_set_read_reg(struct file * file,const char __user * buffer,unsigned long count,void * data)119 int proc_set_read_reg(struct file *file, const char __user *buffer,
120 unsigned long count, void *data)
121 {
122 char tmp[16];
123 u32 addr, len;
124
125 if (count < 2) {
126 DBG_88E("argument size is less than 2\n");
127 return -EFAULT;
128 }
129
130 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
131 int num = sscanf(tmp, "%x %x", &addr, &len);
132
133 if (num != 2) {
134 DBG_88E("invalid read_reg parameter!\n");
135 return count;
136 }
137
138 proc_get_read_addr = addr;
139
140 proc_get_read_len = len;
141 }
142
143 return count;
144 }
145
proc_get_fwstate(char * page,char ** start,off_t offset,int count,int * eof,void * data)146 int proc_get_fwstate(char *page, char **start,
147 off_t offset, int count,
148 int *eof, void *data)
149 {
150 struct net_device *dev = data;
151 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
152 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
153
154 int len = 0;
155
156 len += snprintf(page + len, count - len, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
157
158 *eof = 1;
159 return len;
160 }
161
proc_get_sec_info(char * page,char ** start,off_t offset,int count,int * eof,void * data)162 int proc_get_sec_info(char *page, char **start,
163 off_t offset, int count,
164 int *eof, void *data)
165 {
166 struct net_device *dev = data;
167 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
168 struct security_priv *psecuritypriv = &padapter->securitypriv;
169
170 int len = 0;
171
172 len += snprintf(page + len, count - len, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
173 psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm,
174 psecuritypriv->ndisauthtype, psecuritypriv->ndisencryptstatus);
175
176 *eof = 1;
177 return len;
178 }
179
proc_get_mlmext_state(char * page,char ** start,off_t offset,int count,int * eof,void * data)180 int proc_get_mlmext_state(char *page, char **start,
181 off_t offset, int count,
182 int *eof, void *data)
183 {
184 struct net_device *dev = data;
185 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
186 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
187 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
188
189 int len = 0;
190
191 len += snprintf(page + len, count - len, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
192
193 *eof = 1;
194 return len;
195 }
196
proc_get_qos_option(char * page,char ** start,off_t offset,int count,int * eof,void * data)197 int proc_get_qos_option(char *page, char **start,
198 off_t offset, int count,
199 int *eof, void *data)
200 {
201 struct net_device *dev = data;
202 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
203 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
204
205 int len = 0;
206
207 len += snprintf(page + len, count - len, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
208
209 *eof = 1;
210 return len;
211 }
212
proc_get_ht_option(char * page,char ** start,off_t offset,int count,int * eof,void * data)213 int proc_get_ht_option(char *page, char **start,
214 off_t offset, int count,
215 int *eof, void *data)
216 {
217 struct net_device *dev = data;
218 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
219 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
220
221 int len = 0;
222 len += snprintf(page + len, count - len, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
223 *eof = 1;
224 return len;
225 }
226
proc_get_rf_info(char * page,char ** start,off_t offset,int count,int * eof,void * data)227 int proc_get_rf_info(char *page, char **start,
228 off_t offset, int count,
229 int *eof, void *data)
230 {
231 struct net_device *dev = data;
232 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
233 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
234 int len = 0;
235
236 len += snprintf(page + len, count - len, "cur_ch=%d, cur_bw=%d, cur_ch_offset=%d\n",
237 pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
238 *eof = 1;
239 return len;
240 }
241
proc_get_ap_info(char * page,char ** start,off_t offset,int count,int * eof,void * data)242 int proc_get_ap_info(char *page, char **start,
243 off_t offset, int count,
244 int *eof, void *data)
245 {
246 struct sta_info *psta;
247 struct net_device *dev = data;
248 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
249 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
250 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
251 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
252 struct sta_priv *pstapriv = &padapter->stapriv;
253 int len = 0;
254
255 psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
256 if (psta) {
257 int i;
258 struct recv_reorder_ctrl *preorder_ctrl;
259
260 len += snprintf(page + len, count - len, "SSID=%s\n", cur_network->network.Ssid.Ssid);
261 len += snprintf(page + len, count - len, "sta's macaddr:%pM\n", psta->hwaddr);
262 len += snprintf(page + len, count - len, "cur_channel=%d, cur_bwmode=%d, cur_ch_offset=%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
263 len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
264 len += snprintf(page + len, count - len, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
265 len += snprintf(page + len, count - len, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
266 len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
267 len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
268 len += snprintf(page + len, count - len, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
269
270 for (i = 0; i < 16; i++) {
271 preorder_ctrl = &psta->recvreorder_ctrl[i];
272 if (preorder_ctrl->enable)
273 len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
274 }
275 } else {
276 len += snprintf(page + len, count - len, "can't get sta's macaddr, cur_network's macaddr: %pM\n", cur_network->network.MacAddress);
277 }
278
279 *eof = 1;
280 return len;
281 }
282
proc_get_adapter_state(char * page,char ** start,off_t offset,int count,int * eof,void * data)283 int proc_get_adapter_state(char *page, char **start,
284 off_t offset, int count,
285 int *eof, void *data)
286 {
287 struct net_device *dev = data;
288 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
289 int len = 0;
290
291 len += snprintf(page + len, count - len, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
292 padapter->bSurpriseRemoved, padapter->bDriverStopped);
293
294 *eof = 1;
295 return len;
296 }
297
proc_get_trx_info(char * page,char ** start,off_t offset,int count,int * eof,void * data)298 int proc_get_trx_info(char *page, char **start,
299 off_t offset, int count,
300 int *eof, void *data)
301 {
302 struct net_device *dev = data;
303 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
304 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
305 struct recv_priv *precvpriv = &padapter->recvpriv;
306 int len = 0;
307
308 len += snprintf(page + len, count - len, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d, free_ext_xmitbuf_cnt=%d, free_recvframe_cnt=%d\n",
309 pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmit_extbuf_cnt, precvpriv->free_recvframe_cnt);
310 len += snprintf(page + len, count - len, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
311
312 *eof = 1;
313 return len;
314 }
315
proc_get_mac_reg_dump1(char * page,char ** start,off_t offset,int count,int * eof,void * data)316 int proc_get_mac_reg_dump1(char *page, char **start,
317 off_t offset, int count,
318 int *eof, void *data)
319 {
320 struct net_device *dev = data;
321 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
322 int len = 0;
323 int i, j = 1;
324
325 len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
326
327 for (i = 0x0; i < 0x300; i += 4) {
328 if (j%4 == 1)
329 len += snprintf(page + len, count - len, "0x%02x", i);
330 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
331 if ((j++)%4 == 0)
332 len += snprintf(page + len, count - len, "\n");
333 }
334
335 *eof = 1;
336 return len;
337 }
338
proc_get_mac_reg_dump2(char * page,char ** start,off_t offset,int count,int * eof,void * data)339 int proc_get_mac_reg_dump2(char *page, char **start,
340 off_t offset, int count,
341 int *eof, void *data)
342 {
343 struct net_device *dev = data;
344 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
345 int len = 0;
346 int i, j = 1;
347
348 len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
349 memset(page, 0, count);
350 for (i = 0x300; i < 0x600; i += 4) {
351 if (j%4 == 1)
352 len += snprintf(page + len, count - len, "0x%02x", i);
353 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
354 if ((j++)%4 == 0)
355 len += snprintf(page + len, count - len, "\n");
356 }
357
358 *eof = 1;
359 return len;
360 }
361
proc_get_mac_reg_dump3(char * page,char ** start,off_t offset,int count,int * eof,void * data)362 int proc_get_mac_reg_dump3(char *page, char **start,
363 off_t offset, int count,
364 int *eof, void *data)
365 {
366 struct net_device *dev = data;
367 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
368 int len = 0;
369 int i, j = 1;
370
371 len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
372
373 for (i = 0x600; i < 0x800; i += 4) {
374 if (j%4 == 1)
375 len += snprintf(page + len, count - len, "0x%02x", i);
376 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
377 if ((j++)%4 == 0)
378 len += snprintf(page + len, count - len, "\n");
379 }
380
381 *eof = 1;
382 return len;
383 }
384
proc_get_bb_reg_dump1(char * page,char ** start,off_t offset,int count,int * eof,void * data)385 int proc_get_bb_reg_dump1(char *page, char **start,
386 off_t offset, int count,
387 int *eof, void *data)
388 {
389 struct net_device *dev = data;
390 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
391 int len = 0;
392 int i, j = 1;
393
394 len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
395 for (i = 0x800; i < 0xB00; i += 4) {
396 if (j%4 == 1)
397 len += snprintf(page + len, count - len, "0x%02x", i);
398 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
399 if ((j++)%4 == 0)
400 len += snprintf(page + len, count - len, "\n");
401 }
402 *eof = 1;
403 return len;
404 }
405
proc_get_bb_reg_dump2(char * page,char ** start,off_t offset,int count,int * eof,void * data)406 int proc_get_bb_reg_dump2(char *page, char **start,
407 off_t offset, int count,
408 int *eof, void *data)
409 {
410 struct net_device *dev = data;
411 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
412 int len = 0;
413 int i, j = 1;
414
415 len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
416 for (i = 0xB00; i < 0xE00; i += 4) {
417 if (j%4 == 1)
418 len += snprintf(page + len, count - len, "0x%02x", i);
419 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
420 if ((j++)%4 == 0)
421 len += snprintf(page + len, count - len, "\n");
422 }
423 *eof = 1;
424 return len;
425 }
426
proc_get_bb_reg_dump3(char * page,char ** start,off_t offset,int count,int * eof,void * data)427 int proc_get_bb_reg_dump3(char *page, char **start,
428 off_t offset, int count,
429 int *eof, void *data)
430 {
431 struct net_device *dev = data;
432 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
433 int len = 0;
434 int i, j = 1;
435
436 len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
437 for (i = 0xE00; i < 0x1000; i += 4) {
438 if (j%4 == 1)
439 len += snprintf(page + len, count - len, "0x%02x", i);
440 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
441 if ((j++)%4 == 0)
442 len += snprintf(page + len, count - len, "\n");
443 }
444 *eof = 1;
445 return len;
446 }
447
proc_get_rf_reg_dump1(char * page,char ** start,off_t offset,int count,int * eof,void * data)448 int proc_get_rf_reg_dump1(char *page, char **start,
449 off_t offset, int count,
450 int *eof, void *data)
451 {
452 struct net_device *dev = data;
453 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
454 int len = 0;
455 int i, j = 1, path;
456 u32 value;
457
458 len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
459 path = 1;
460 len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
461 for (i = 0; i < 0xC0; i++) {
462 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
463 if (j%4 == 1)
464 len += snprintf(page + len, count - len, "0x%02x ", i);
465 len += snprintf(page + len, count - len, " 0x%08x ", value);
466 if ((j++)%4 == 0)
467 len += snprintf(page + len, count - len, "\n");
468 }
469 *eof = 1;
470 return len;
471 }
472
proc_get_rf_reg_dump2(char * page,char ** start,off_t offset,int count,int * eof,void * data)473 int proc_get_rf_reg_dump2(char *page, char **start,
474 off_t offset, int count,
475 int *eof, void *data)
476 {
477 struct net_device *dev = data;
478 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
479 int len = 0;
480 int i, j = 1, path;
481 u32 value;
482
483 len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
484 path = 1;
485 len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
486 for (i = 0xC0; i < 0x100; i++) {
487 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
488 if (j%4 == 1)
489 len += snprintf(page + len, count - len, "0x%02x ", i);
490 len += snprintf(page + len, count - len, " 0x%08x ", value);
491 if ((j++)%4 == 0)
492 len += snprintf(page + len, count - len, "\n");
493 }
494 *eof = 1;
495 return len;
496 }
497
proc_get_rf_reg_dump3(char * page,char ** start,off_t offset,int count,int * eof,void * data)498 int proc_get_rf_reg_dump3(char *page, char **start,
499 off_t offset, int count,
500 int *eof, void *data)
501 {
502 struct net_device *dev = data;
503 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
504 int len = 0;
505 int i, j = 1, path;
506 u32 value;
507
508 len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
509 path = 2;
510 len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
511 for (i = 0; i < 0xC0; i++) {
512 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
513 if (j%4 == 1)
514 len += snprintf(page + len, count - len, "0x%02x ", i);
515 len += snprintf(page + len, count - len, " 0x%08x ", value);
516 if ((j++)%4 == 0)
517 len += snprintf(page + len, count - len, "\n");
518 }
519
520 *eof = 1;
521 return len;
522 }
523
524
proc_get_rf_reg_dump4(char * page,char ** start,off_t offset,int count,int * eof,void * data)525 int proc_get_rf_reg_dump4(char *page, char **start,
526 off_t offset, int count,
527 int *eof, void *data)
528 {
529 struct net_device *dev = data;
530 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
531 int len = 0;
532 int i, j = 1, path;
533 u32 value;
534
535 len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
536 path = 2;
537 len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
538 for (i = 0xC0; i < 0x100; i++) {
539 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
540 if (j%4 == 1)
541 len += snprintf(page + len, count - len, "0x%02x ", i);
542 len += snprintf(page + len, count - len, " 0x%08x ", value);
543 if ((j++)%4 == 0)
544 len += snprintf(page + len, count - len, "\n");
545 }
546 *eof = 1;
547 return len;
548 }
549
550
551
proc_get_rx_signal(char * page,char ** start,off_t offset,int count,int * eof,void * data)552 int proc_get_rx_signal(char *page, char **start,
553 off_t offset, int count,
554 int *eof, void *data)
555 {
556 struct net_device *dev = data;
557 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
558 int len = 0;
559
560 len = snprintf(page + len, count,
561 "rssi:%d\n"
562 "rxpwdb:%d\n"
563 "signal_strength:%u\n"
564 "signal_qual:%u\n"
565 "noise:%u\n",
566 padapter->recvpriv.rssi,
567 padapter->recvpriv.rxpwdb,
568 padapter->recvpriv.signal_strength,
569 padapter->recvpriv.signal_qual,
570 padapter->recvpriv.noise
571 );
572
573 *eof = 1;
574 return len;
575 }
576
proc_set_rx_signal(struct file * file,const char __user * buffer,unsigned long count,void * data)577 int proc_set_rx_signal(struct file *file, const char __user *buffer,
578 unsigned long count, void *data)
579 {
580 struct net_device *dev = data;
581 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
582 char tmp[32];
583 u32 is_signal_dbg;
584 s32 signal_strength;
585
586 if (count < 1)
587 return -EFAULT;
588
589 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
590 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
591 is_signal_dbg = is_signal_dbg == 0 ? 0 : 1;
592 if (is_signal_dbg && num != 2)
593 return count;
594
595 signal_strength = signal_strength > 100 ? 100 : signal_strength;
596 signal_strength = signal_strength < 0 ? 0 : signal_strength;
597
598 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
599 padapter->recvpriv.signal_strength_dbg = signal_strength;
600
601 if (is_signal_dbg)
602 DBG_88E("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
603 else
604 DBG_88E("set %s\n", "HW_SIGNAL_STRENGTH");
605 }
606 return count;
607 }
608
proc_get_ht_enable(char * page,char ** start,off_t offset,int count,int * eof,void * data)609 int proc_get_ht_enable(char *page, char **start,
610 off_t offset, int count,
611 int *eof, void *data)
612 {
613 struct net_device *dev = data;
614 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
615 struct registry_priv *pregpriv = &padapter->registrypriv;
616 int len = 0;
617
618 if (pregpriv)
619 len += snprintf(page + len, count - len,
620 "%d\n",
621 pregpriv->ht_enable
622 );
623 *eof = 1;
624 return len;
625 }
626
proc_set_ht_enable(struct file * file,const char __user * buffer,unsigned long count,void * data)627 int proc_set_ht_enable(struct file *file, const char __user *buffer,
628 unsigned long count, void *data)
629 {
630 struct net_device *dev = data;
631 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
632 struct registry_priv *pregpriv = &padapter->registrypriv;
633 char tmp[32];
634 s32 mode = 0;
635
636 if (count < 1)
637 return -EFAULT;
638
639 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
640 if (pregpriv) {
641 pregpriv->ht_enable = mode;
642 pr_info("ht_enable=%d\n", pregpriv->ht_enable);
643 }
644 }
645
646 return count;
647 }
648
proc_get_cbw40_enable(char * page,char ** start,off_t offset,int count,int * eof,void * data)649 int proc_get_cbw40_enable(char *page, char **start,
650 off_t offset, int count,
651 int *eof, void *data)
652 {
653 struct net_device *dev = data;
654 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
655 struct registry_priv *pregpriv = &padapter->registrypriv;
656
657 int len = 0;
658
659 if (pregpriv)
660 len += snprintf(page + len, count - len,
661 "%d\n",
662 pregpriv->cbw40_enable
663 );
664
665 *eof = 1;
666 return len;
667 }
668
proc_set_cbw40_enable(struct file * file,const char __user * buffer,unsigned long count,void * data)669 int proc_set_cbw40_enable(struct file *file, const char __user *buffer,
670 unsigned long count, void *data)
671 {
672 struct net_device *dev = data;
673 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
674 struct registry_priv *pregpriv = &padapter->registrypriv;
675 char tmp[32];
676 s32 mode = 0;
677
678 if (count < 1)
679 return -EFAULT;
680
681 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
682 if (pregpriv) {
683 pregpriv->cbw40_enable = mode;
684 pr_info("cbw40_enable=%d\n", mode);
685 }
686 }
687 return count;
688 }
689
proc_get_ampdu_enable(char * page,char ** start,off_t offset,int count,int * eof,void * data)690 int proc_get_ampdu_enable(char *page, char **start,
691 off_t offset, int count,
692 int *eof, void *data)
693 {
694 struct net_device *dev = data;
695 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
696 struct registry_priv *pregpriv = &padapter->registrypriv;
697
698 int len = 0;
699
700 if (pregpriv)
701 len += snprintf(page + len, count - len,
702 "%d\n",
703 pregpriv->ampdu_enable
704 );
705
706 *eof = 1;
707 return len;
708 }
709
proc_set_ampdu_enable(struct file * file,const char __user * buffer,unsigned long count,void * data)710 int proc_set_ampdu_enable(struct file *file, const char __user *buffer,
711 unsigned long count, void *data)
712 {
713 struct net_device *dev = data;
714 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
715 struct registry_priv *pregpriv = &padapter->registrypriv;
716 char tmp[32];
717 s32 mode = 0;
718
719 if (count < 1)
720 return -EFAULT;
721
722 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
723 if (pregpriv) {
724 pregpriv->ampdu_enable = mode;
725 pr_info("ampdu_enable=%d\n", mode);
726 }
727 }
728 return count;
729 }
730
proc_get_two_path_rssi(char * page,char ** start,off_t offset,int count,int * eof,void * data)731 int proc_get_two_path_rssi(char *page, char **start,
732 off_t offset, int count,
733 int *eof, void *data)
734 {
735 struct net_device *dev = data;
736 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
737
738 int len = 0;
739
740 if (padapter)
741 len += snprintf(page + len, count - len,
742 "%d %d\n",
743 padapter->recvpriv.RxRssi[0],
744 padapter->recvpriv.RxRssi[1]
745 );
746
747 *eof = 1;
748 return len;
749 }
750
proc_get_rx_stbc(char * page,char ** start,off_t offset,int count,int * eof,void * data)751 int proc_get_rx_stbc(char *page, char **start,
752 off_t offset, int count,
753 int *eof, void *data)
754 {
755 struct net_device *dev = data;
756 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
757 struct registry_priv *pregpriv = &padapter->registrypriv;
758
759 int len = 0;
760
761 if (pregpriv)
762 len += snprintf(page + len, count - len,
763 "%d\n",
764 pregpriv->rx_stbc
765 );
766
767 *eof = 1;
768 return len;
769 }
770
proc_set_rx_stbc(struct file * file,const char __user * buffer,unsigned long count,void * data)771 int proc_set_rx_stbc(struct file *file, const char __user *buffer,
772 unsigned long count, void *data)
773 {
774 struct net_device *dev = data;
775 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
776 struct registry_priv *pregpriv = &padapter->registrypriv;
777 char tmp[32];
778 u32 mode = 0;
779
780 if (count < 1)
781 return -EFAULT;
782
783 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
784 if (pregpriv) {
785 pregpriv->rx_stbc = mode;
786 netdev_info(dev, "rx_stbc=%d\n", mode);
787 }
788 }
789 return count;
790 }
791
proc_get_rssi_disp(char * page,char ** start,off_t offset,int count,int * eof,void * data)792 int proc_get_rssi_disp(char *page, char **start,
793 off_t offset, int count,
794 int *eof, void *data)
795 {
796 *eof = 1;
797 return 0;
798 }
799
proc_set_rssi_disp(struct file * file,const char __user * buffer,unsigned long count,void * data)800 int proc_set_rssi_disp(struct file *file, const char __user *buffer,
801 unsigned long count, void *data)
802 {
803 struct net_device *dev = data;
804 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
805 char tmp[32];
806 u32 enable = 0;
807
808 if (count < 1) {
809 DBG_88E("argument size is less than 1\n");
810 return -EFAULT;
811 }
812
813 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
814 int num = sscanf(tmp, "%x", &enable);
815
816 if (num != 1) {
817 DBG_88E("invalid set_rssi_disp parameter!\n");
818 return count;
819 }
820
821 if (enable) {
822 DBG_88E("Turn On Rx RSSI Display Function\n");
823 padapter->bRxRSSIDisplay = enable;
824 } else {
825 DBG_88E("Turn Off Rx RSSI Display Function\n");
826 padapter->bRxRSSIDisplay = 0;
827 }
828 }
829 return count;
830 }
831
832 #ifdef CONFIG_88EU_AP_MODE
833
proc_get_all_sta_info(char * page,char ** start,off_t offset,int count,int * eof,void * data)834 int proc_get_all_sta_info(char *page, char **start,
835 off_t offset, int count,
836 int *eof, void *data)
837 {
838 struct sta_info *psta;
839 struct net_device *dev = data;
840 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
841 struct sta_priv *pstapriv = &padapter->stapriv;
842 int i, j;
843 struct list_head *plist, *phead;
844 struct recv_reorder_ctrl *preorder_ctrl;
845 int len = 0;
846
847
848 len += snprintf(page + len, count - len, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
849
850 spin_lock_bh(&pstapriv->sta_hash_lock);
851
852 for (i = 0; i < NUM_STA; i++) {
853 phead = &(pstapriv->sta_hash[i]);
854 plist = phead->next;
855
856 while (phead != plist) {
857 psta = container_of(plist, struct sta_info, hash_list);
858
859 plist = plist->next;
860
861 len += snprintf(page + len, count - len, "sta's macaddr: %pM\n", psta->hwaddr);
862 len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
863 len += snprintf(page + len, count - len, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
864 len += snprintf(page + len, count - len, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
865 len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
866 len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
867 len += snprintf(page + len, count - len, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
868 len += snprintf(page + len, count - len, "sleepq_len=%d\n", psta->sleepq_len);
869 len += snprintf(page + len, count - len, "capability=0x%x\n", psta->capability);
870 len += snprintf(page + len, count - len, "flags=0x%x\n", psta->flags);
871 len += snprintf(page + len, count - len, "wpa_psk=0x%x\n", psta->wpa_psk);
872 len += snprintf(page + len, count - len, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
873 len += snprintf(page + len, count - len, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
874 len += snprintf(page + len, count - len, "qos_info=0x%x\n", psta->qos_info);
875 len += snprintf(page + len, count - len, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
876
877 for (j = 0; j < 16; j++) {
878 preorder_ctrl = &psta->recvreorder_ctrl[j];
879 if (preorder_ctrl->enable)
880 len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
881 }
882 }
883 }
884 spin_unlock_bh(&pstapriv->sta_hash_lock);
885
886 *eof = 1;
887 return len;
888 }
889 #endif
890
proc_get_best_channel(char * page,char ** start,off_t offset,int count,int * eof,void * data)891 int proc_get_best_channel(char *page, char **start,
892 off_t offset, int count,
893 int *eof, void *data)
894 {
895 struct net_device *dev = data;
896 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
897 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
898 int len = 0;
899 u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
900
901 for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
902 if (pmlmeext->channel_set[i].ChannelNum == 1)
903 index_24G = i;
904 if (pmlmeext->channel_set[i].ChannelNum == 36)
905 index_5G = i;
906 }
907
908 for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
909 /* 2.4G */
910 if (pmlmeext->channel_set[i].ChannelNum == 6) {
911 if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) {
912 index_24G = i;
913 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
914 }
915 }
916
917 /* 5G */
918 if (pmlmeext->channel_set[i].ChannelNum >= 36 &&
919 pmlmeext->channel_set[i].ChannelNum < 140) {
920 /* Find primary channel */
921 if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) &&
922 (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
923 index_5G = i;
924 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
925 }
926 }
927
928 if (pmlmeext->channel_set[i].ChannelNum >= 149 &&
929 pmlmeext->channel_set[i].ChannelNum < 165) {
930 /* find primary channel */
931 if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) &&
932 (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
933 index_5G = i;
934 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
935 }
936 }
937 /* debug */
938 len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n",
939 pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
940 }
941
942 len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G);
943 len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G);
944
945 *eof = 1;
946 return len;
947 }
948