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