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 | * | |
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> | |
e73fd15e | 23 | #include <usb_ops_linux.h> |
06a05884 LF |
24 | |
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 | ||
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 | ||
45 | int proc_set_write_reg(struct file *file, const char __user *buffer, | |
46 | unsigned long count, void *data) | |
47 | { | |
60c89911 | 48 | struct net_device *dev = data; |
06a05884 LF |
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: | |
e76484d0 | 67 | usb_write8(padapter, addr, (u8)val); |
06a05884 LF |
68 | break; |
69 | case 2: | |
9764ed04 | 70 | usb_write16(padapter, addr, (u16)val); |
06a05884 LF |
71 | break; |
72 | case 4: | |
fc158079 | 73 | usb_write32(padapter, addr, val); |
06a05884 LF |
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 | ||
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: | |
c7b2e995 | 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)); |
06a05884 LF |
103 | break; |
104 | case 2: | |
551a3972 | 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)); |
06a05884 LF |
106 | break; |
107 | case 4: | |
99ecfb06 | 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)); |
06a05884 LF |
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 | ||
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 | ||
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 | ||
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 | ||
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 | ||
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 | ||
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; | |
be3d2e0f | 222 | |
06a05884 LF |
223 | len += snprintf(page + len, count - len, "ht_option=%d\n", pmlmepriv->htpriv.ht_option); |
224 | *eof = 1; | |
225 | return len; | |
226 | } | |
227 | ||
228 | int proc_get_rf_info(char *page, char **start, | |
229 | off_t offset, int count, | |
230 | int *eof, void *data) | |
231 | { | |
232 | struct net_device *dev = data; | |
233 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
234 | struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; | |
235 | int len = 0; | |
236 | ||
40a46d8b | 237 | len += snprintf(page + len, count - len, "cur_ch=%d, cur_bw=%d, cur_ch_offset=%d\n", |
06a05884 LF |
238 | pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset); |
239 | *eof = 1; | |
240 | return len; | |
241 | } | |
242 | ||
243 | int proc_get_ap_info(char *page, char **start, | |
244 | off_t offset, int count, | |
245 | int *eof, void *data) | |
246 | { | |
247 | struct sta_info *psta; | |
248 | struct net_device *dev = data; | |
249 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
250 | struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); | |
251 | struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; | |
252 | struct wlan_network *cur_network = &(pmlmepriv->cur_network); | |
253 | struct sta_priv *pstapriv = &padapter->stapriv; | |
254 | int len = 0; | |
255 | ||
256 | psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress); | |
257 | if (psta) { | |
258 | int i; | |
259 | struct recv_reorder_ctrl *preorder_ctrl; | |
260 | ||
261 | len += snprintf(page + len, count - len, "SSID=%s\n", cur_network->network.Ssid.Ssid); | |
262 | len += snprintf(page + len, count - len, "sta's macaddr:%pM\n", psta->hwaddr); | |
263 | 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); | |
264 | len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self); | |
265 | 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); | |
266 | 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); | |
267 | len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi); | |
268 | len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable); | |
269 | 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); | |
270 | ||
271 | for (i = 0; i < 16; i++) { | |
272 | preorder_ctrl = &psta->recvreorder_ctrl[i]; | |
273 | if (preorder_ctrl->enable) | |
274 | len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq); | |
275 | } | |
276 | } else { | |
277 | len += snprintf(page + len, count - len, "can't get sta's macaddr, cur_network's macaddr: %pM\n", cur_network->network.MacAddress); | |
278 | } | |
279 | ||
280 | *eof = 1; | |
281 | return len; | |
282 | } | |
283 | ||
284 | int proc_get_adapter_state(char *page, char **start, | |
285 | off_t offset, int count, | |
286 | int *eof, void *data) | |
287 | { | |
288 | struct net_device *dev = data; | |
289 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
290 | int len = 0; | |
291 | ||
292 | len += snprintf(page + len, count - len, "bSurpriseRemoved=%d, bDriverStopped=%d\n", | |
293 | padapter->bSurpriseRemoved, padapter->bDriverStopped); | |
294 | ||
295 | *eof = 1; | |
296 | return len; | |
297 | } | |
298 | ||
299 | int proc_get_trx_info(char *page, char **start, | |
300 | off_t offset, int count, | |
301 | int *eof, void *data) | |
302 | { | |
303 | struct net_device *dev = data; | |
304 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
305 | struct xmit_priv *pxmitpriv = &padapter->xmitpriv; | |
306 | struct recv_priv *precvpriv = &padapter->recvpriv; | |
307 | int len = 0; | |
308 | ||
309 | len += snprintf(page + len, count - len, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d, free_ext_xmitbuf_cnt=%d, free_recvframe_cnt=%d\n", | |
310 | pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmit_extbuf_cnt, precvpriv->free_recvframe_cnt); | |
311 | len += snprintf(page + len, count - len, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt); | |
312 | ||
313 | *eof = 1; | |
314 | return len; | |
315 | } | |
316 | ||
317 | int proc_get_mac_reg_dump1(char *page, char **start, | |
318 | off_t offset, int count, | |
319 | int *eof, void *data) | |
320 | { | |
321 | struct net_device *dev = data; | |
322 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
323 | int len = 0; | |
324 | int i, j = 1; | |
325 | ||
326 | len += snprintf(page + len, count - len, "\n======= MAC REG =======\n"); | |
327 | ||
328 | for (i = 0x0; i < 0x300; i += 4) { | |
329 | if (j%4 == 1) | |
330 | len += snprintf(page + len, count - len, "0x%02x", i); | |
99ecfb06 | 331 | len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i)); |
06a05884 LF |
332 | if ((j++)%4 == 0) |
333 | len += snprintf(page + len, count - len, "\n"); | |
334 | } | |
335 | ||
336 | *eof = 1; | |
337 | return len; | |
338 | } | |
339 | ||
340 | int proc_get_mac_reg_dump2(char *page, char **start, | |
341 | off_t offset, int count, | |
342 | int *eof, void *data) | |
343 | { | |
344 | struct net_device *dev = data; | |
345 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
346 | int len = 0; | |
347 | int i, j = 1; | |
348 | ||
349 | len += snprintf(page + len, count - len, "\n======= MAC REG =======\n"); | |
350 | memset(page, 0, count); | |
351 | for (i = 0x300; i < 0x600; i += 4) { | |
352 | if (j%4 == 1) | |
353 | len += snprintf(page + len, count - len, "0x%02x", i); | |
99ecfb06 | 354 | len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i)); |
06a05884 LF |
355 | if ((j++)%4 == 0) |
356 | len += snprintf(page + len, count - len, "\n"); | |
357 | } | |
358 | ||
359 | *eof = 1; | |
360 | return len; | |
361 | } | |
362 | ||
363 | int proc_get_mac_reg_dump3(char *page, char **start, | |
364 | off_t offset, int count, | |
365 | int *eof, void *data) | |
366 | { | |
367 | struct net_device *dev = data; | |
368 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
369 | int len = 0; | |
370 | int i, j = 1; | |
371 | ||
372 | len += snprintf(page + len, count - len, "\n======= MAC REG =======\n"); | |
373 | ||
374 | for (i = 0x600; i < 0x800; i += 4) { | |
375 | if (j%4 == 1) | |
376 | len += snprintf(page + len, count - len, "0x%02x", i); | |
99ecfb06 | 377 | len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i)); |
06a05884 LF |
378 | if ((j++)%4 == 0) |
379 | len += snprintf(page + len, count - len, "\n"); | |
380 | } | |
381 | ||
382 | *eof = 1; | |
383 | return len; | |
384 | } | |
385 | ||
386 | int proc_get_bb_reg_dump1(char *page, char **start, | |
387 | off_t offset, int count, | |
388 | int *eof, void *data) | |
389 | { | |
390 | struct net_device *dev = data; | |
391 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
392 | int len = 0; | |
393 | int i, j = 1; | |
394 | ||
395 | len += snprintf(page + len, count - len, "\n======= BB REG =======\n"); | |
396 | for (i = 0x800; i < 0xB00; i += 4) { | |
397 | if (j%4 == 1) | |
398 | len += snprintf(page + len, count - len, "0x%02x", i); | |
99ecfb06 | 399 | len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i)); |
06a05884 LF |
400 | if ((j++)%4 == 0) |
401 | len += snprintf(page + len, count - len, "\n"); | |
402 | } | |
403 | *eof = 1; | |
404 | return len; | |
405 | } | |
406 | ||
407 | int proc_get_bb_reg_dump2(char *page, char **start, | |
408 | off_t offset, int count, | |
409 | int *eof, void *data) | |
410 | { | |
411 | struct net_device *dev = data; | |
412 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
413 | int len = 0; | |
414 | int i, j = 1; | |
415 | ||
416 | len += snprintf(page + len, count - len, "\n======= BB REG =======\n"); | |
417 | for (i = 0xB00; i < 0xE00; i += 4) { | |
418 | if (j%4 == 1) | |
419 | len += snprintf(page + len, count - len, "0x%02x", i); | |
99ecfb06 | 420 | len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i)); |
06a05884 LF |
421 | if ((j++)%4 == 0) |
422 | len += snprintf(page + len, count - len, "\n"); | |
423 | } | |
424 | *eof = 1; | |
425 | return len; | |
426 | } | |
427 | ||
428 | int proc_get_bb_reg_dump3(char *page, char **start, | |
429 | off_t offset, int count, | |
430 | int *eof, void *data) | |
431 | { | |
432 | struct net_device *dev = data; | |
433 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
434 | int len = 0; | |
435 | int i, j = 1; | |
436 | ||
437 | len += snprintf(page + len, count - len, "\n======= BB REG =======\n"); | |
438 | for (i = 0xE00; i < 0x1000; i += 4) { | |
439 | if (j%4 == 1) | |
440 | len += snprintf(page + len, count - len, "0x%02x", i); | |
99ecfb06 | 441 | len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i)); |
06a05884 LF |
442 | if ((j++)%4 == 0) |
443 | len += snprintf(page + len, count - len, "\n"); | |
444 | } | |
445 | *eof = 1; | |
446 | return len; | |
447 | } | |
448 | ||
449 | int proc_get_rf_reg_dump1(char *page, char **start, | |
450 | off_t offset, int count, | |
451 | int *eof, void *data) | |
452 | { | |
453 | struct net_device *dev = data; | |
454 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
455 | int len = 0; | |
456 | int i, j = 1, path; | |
457 | u32 value; | |
458 | ||
459 | len += snprintf(page + len, count - len, "\n======= RF REG =======\n"); | |
460 | path = 1; | |
461 | len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path); | |
462 | for (i = 0; i < 0xC0; i++) { | |
463 | value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); | |
464 | if (j%4 == 1) | |
465 | len += snprintf(page + len, count - len, "0x%02x ", i); | |
466 | len += snprintf(page + len, count - len, " 0x%08x ", value); | |
467 | if ((j++)%4 == 0) | |
468 | len += snprintf(page + len, count - len, "\n"); | |
469 | } | |
470 | *eof = 1; | |
471 | return len; | |
472 | } | |
473 | ||
474 | int proc_get_rf_reg_dump2(char *page, char **start, | |
475 | off_t offset, int count, | |
476 | int *eof, void *data) | |
477 | { | |
478 | struct net_device *dev = data; | |
479 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
480 | int len = 0; | |
481 | int i, j = 1, path; | |
482 | u32 value; | |
483 | ||
484 | len += snprintf(page + len, count - len, "\n======= RF REG =======\n"); | |
485 | path = 1; | |
486 | len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path); | |
487 | for (i = 0xC0; i < 0x100; i++) { | |
488 | value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); | |
489 | if (j%4 == 1) | |
490 | len += snprintf(page + len, count - len, "0x%02x ", i); | |
491 | len += snprintf(page + len, count - len, " 0x%08x ", value); | |
492 | if ((j++)%4 == 0) | |
493 | len += snprintf(page + len, count - len, "\n"); | |
494 | } | |
495 | *eof = 1; | |
496 | return len; | |
497 | } | |
498 | ||
499 | int proc_get_rf_reg_dump3(char *page, char **start, | |
500 | off_t offset, int count, | |
501 | int *eof, void *data) | |
502 | { | |
503 | struct net_device *dev = data; | |
504 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
505 | int len = 0; | |
506 | int i, j = 1, path; | |
507 | u32 value; | |
508 | ||
509 | len += snprintf(page + len, count - len, "\n======= RF REG =======\n"); | |
510 | path = 2; | |
511 | len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path); | |
512 | for (i = 0; i < 0xC0; i++) { | |
513 | value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); | |
514 | if (j%4 == 1) | |
515 | len += snprintf(page + len, count - len, "0x%02x ", i); | |
516 | len += snprintf(page + len, count - len, " 0x%08x ", value); | |
517 | if ((j++)%4 == 0) | |
518 | len += snprintf(page + len, count - len, "\n"); | |
519 | } | |
520 | ||
521 | *eof = 1; | |
522 | return len; | |
523 | } | |
524 | ||
525 | ||
526 | int proc_get_rf_reg_dump4(char *page, char **start, | |
527 | off_t offset, int count, | |
528 | int *eof, void *data) | |
529 | { | |
530 | struct net_device *dev = data; | |
531 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
532 | int len = 0; | |
533 | int i, j = 1, path; | |
534 | u32 value; | |
535 | ||
536 | len += snprintf(page + len, count - len, "\n======= RF REG =======\n"); | |
537 | path = 2; | |
538 | len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path); | |
539 | for (i = 0xC0; i < 0x100; i++) { | |
540 | value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); | |
541 | if (j%4 == 1) | |
542 | len += snprintf(page + len, count - len, "0x%02x ", i); | |
543 | len += snprintf(page + len, count - len, " 0x%08x ", value); | |
544 | if ((j++)%4 == 0) | |
545 | len += snprintf(page + len, count - len, "\n"); | |
546 | } | |
547 | *eof = 1; | |
548 | return len; | |
549 | } | |
550 | ||
551 | ||
552 | ||
553 | int proc_get_rx_signal(char *page, char **start, | |
554 | off_t offset, int count, | |
555 | int *eof, void *data) | |
556 | { | |
557 | struct net_device *dev = data; | |
558 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
559 | int len = 0; | |
560 | ||
561 | len = snprintf(page + len, count, | |
562 | "rssi:%d\n" | |
563 | "rxpwdb:%d\n" | |
564 | "signal_strength:%u\n" | |
565 | "signal_qual:%u\n" | |
566 | "noise:%u\n", | |
567 | padapter->recvpriv.rssi, | |
568 | padapter->recvpriv.rxpwdb, | |
569 | padapter->recvpriv.signal_strength, | |
570 | padapter->recvpriv.signal_qual, | |
571 | padapter->recvpriv.noise | |
572 | ); | |
573 | ||
574 | *eof = 1; | |
575 | return len; | |
576 | } | |
577 | ||
578 | int proc_set_rx_signal(struct file *file, const char __user *buffer, | |
579 | unsigned long count, void *data) | |
580 | { | |
60c89911 | 581 | struct net_device *dev = data; |
06a05884 LF |
582 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); |
583 | char tmp[32]; | |
584 | u32 is_signal_dbg; | |
585 | s32 signal_strength; | |
586 | ||
587 | if (count < 1) | |
588 | return -EFAULT; | |
589 | ||
590 | if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { | |
591 | int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength); | |
be3d2e0f | 592 | |
06a05884 LF |
593 | is_signal_dbg = is_signal_dbg == 0 ? 0 : 1; |
594 | if (is_signal_dbg && num != 2) | |
595 | return count; | |
596 | ||
597 | signal_strength = signal_strength > 100 ? 100 : signal_strength; | |
598 | signal_strength = signal_strength < 0 ? 0 : signal_strength; | |
599 | ||
600 | padapter->recvpriv.is_signal_dbg = is_signal_dbg; | |
601 | padapter->recvpriv.signal_strength_dbg = signal_strength; | |
602 | ||
603 | if (is_signal_dbg) | |
604 | DBG_88E("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength); | |
605 | else | |
606 | DBG_88E("set %s\n", "HW_SIGNAL_STRENGTH"); | |
607 | } | |
608 | return count; | |
609 | } | |
610 | ||
611 | int proc_get_ht_enable(char *page, char **start, | |
612 | off_t offset, int count, | |
613 | int *eof, void *data) | |
614 | { | |
615 | struct net_device *dev = data; | |
616 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
617 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
618 | int len = 0; | |
619 | ||
620 | if (pregpriv) | |
621 | len += snprintf(page + len, count - len, | |
622 | "%d\n", | |
623 | pregpriv->ht_enable | |
624 | ); | |
625 | *eof = 1; | |
626 | return len; | |
627 | } | |
628 | ||
629 | int proc_set_ht_enable(struct file *file, const char __user *buffer, | |
630 | unsigned long count, void *data) | |
631 | { | |
60c89911 | 632 | struct net_device *dev = data; |
06a05884 LF |
633 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); |
634 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
635 | char tmp[32]; | |
636 | s32 mode = 0; | |
637 | ||
638 | if (count < 1) | |
639 | return -EFAULT; | |
640 | ||
641 | if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { | |
642 | if (pregpriv) { | |
643 | pregpriv->ht_enable = mode; | |
644 | pr_info("ht_enable=%d\n", pregpriv->ht_enable); | |
645 | } | |
646 | } | |
647 | ||
648 | return count; | |
649 | } | |
650 | ||
651 | int proc_get_cbw40_enable(char *page, char **start, | |
652 | off_t offset, int count, | |
653 | int *eof, void *data) | |
654 | { | |
655 | struct net_device *dev = data; | |
656 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
657 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
658 | ||
659 | int len = 0; | |
660 | ||
661 | if (pregpriv) | |
662 | len += snprintf(page + len, count - len, | |
663 | "%d\n", | |
664 | pregpriv->cbw40_enable | |
665 | ); | |
666 | ||
667 | *eof = 1; | |
668 | return len; | |
669 | } | |
670 | ||
671 | int proc_set_cbw40_enable(struct file *file, const char __user *buffer, | |
672 | unsigned long count, void *data) | |
673 | { | |
60c89911 | 674 | struct net_device *dev = data; |
06a05884 LF |
675 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); |
676 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
677 | char tmp[32]; | |
678 | s32 mode = 0; | |
679 | ||
680 | if (count < 1) | |
681 | return -EFAULT; | |
682 | ||
683 | if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { | |
684 | if (pregpriv) { | |
685 | pregpriv->cbw40_enable = mode; | |
686 | pr_info("cbw40_enable=%d\n", mode); | |
687 | } | |
688 | } | |
689 | return count; | |
690 | } | |
691 | ||
692 | int proc_get_ampdu_enable(char *page, char **start, | |
693 | off_t offset, int count, | |
694 | int *eof, void *data) | |
695 | { | |
696 | struct net_device *dev = data; | |
697 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
698 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
699 | ||
700 | int len = 0; | |
701 | ||
702 | if (pregpriv) | |
703 | len += snprintf(page + len, count - len, | |
704 | "%d\n", | |
705 | pregpriv->ampdu_enable | |
706 | ); | |
707 | ||
708 | *eof = 1; | |
709 | return len; | |
710 | } | |
711 | ||
712 | int proc_set_ampdu_enable(struct file *file, const char __user *buffer, | |
713 | unsigned long count, void *data) | |
714 | { | |
60c89911 | 715 | struct net_device *dev = data; |
06a05884 LF |
716 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); |
717 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
718 | char tmp[32]; | |
719 | s32 mode = 0; | |
720 | ||
721 | if (count < 1) | |
722 | return -EFAULT; | |
723 | ||
724 | if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { | |
725 | if (pregpriv) { | |
726 | pregpriv->ampdu_enable = mode; | |
727 | pr_info("ampdu_enable=%d\n", mode); | |
728 | } | |
729 | } | |
730 | return count; | |
731 | } | |
732 | ||
733 | int proc_get_two_path_rssi(char *page, char **start, | |
734 | off_t offset, int count, | |
735 | int *eof, void *data) | |
736 | { | |
737 | struct net_device *dev = data; | |
738 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
739 | ||
740 | int len = 0; | |
741 | ||
742 | if (padapter) | |
743 | len += snprintf(page + len, count - len, | |
744 | "%d %d\n", | |
745 | padapter->recvpriv.RxRssi[0], | |
746 | padapter->recvpriv.RxRssi[1] | |
747 | ); | |
748 | ||
749 | *eof = 1; | |
750 | return len; | |
751 | } | |
752 | ||
753 | int proc_get_rx_stbc(char *page, char **start, | |
754 | off_t offset, int count, | |
755 | int *eof, void *data) | |
756 | { | |
757 | struct net_device *dev = data; | |
758 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
759 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
760 | ||
761 | int len = 0; | |
762 | ||
763 | if (pregpriv) | |
764 | len += snprintf(page + len, count - len, | |
765 | "%d\n", | |
766 | pregpriv->rx_stbc | |
767 | ); | |
768 | ||
769 | *eof = 1; | |
770 | return len; | |
771 | } | |
772 | ||
773 | int proc_set_rx_stbc(struct file *file, const char __user *buffer, | |
774 | unsigned long count, void *data) | |
775 | { | |
60c89911 | 776 | struct net_device *dev = data; |
06a05884 LF |
777 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); |
778 | struct registry_priv *pregpriv = &padapter->registrypriv; | |
779 | char tmp[32]; | |
780 | u32 mode = 0; | |
781 | ||
782 | if (count < 1) | |
783 | return -EFAULT; | |
784 | ||
785 | if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { | |
786 | if (pregpriv) { | |
787 | pregpriv->rx_stbc = mode; | |
1bdbd758 | 788 | netdev_info(dev, "rx_stbc=%d\n", mode); |
06a05884 LF |
789 | } |
790 | } | |
791 | return count; | |
792 | } | |
793 | ||
794 | int proc_get_rssi_disp(char *page, char **start, | |
795 | off_t offset, int count, | |
796 | int *eof, void *data) | |
797 | { | |
798 | *eof = 1; | |
799 | return 0; | |
800 | } | |
801 | ||
802 | int proc_set_rssi_disp(struct file *file, const char __user *buffer, | |
803 | unsigned long count, void *data) | |
804 | { | |
60c89911 | 805 | struct net_device *dev = data; |
06a05884 LF |
806 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); |
807 | char tmp[32]; | |
808 | u32 enable = 0; | |
809 | ||
810 | if (count < 1) { | |
811 | DBG_88E("argument size is less than 1\n"); | |
812 | return -EFAULT; | |
813 | } | |
814 | ||
815 | if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { | |
816 | int num = sscanf(tmp, "%x", &enable); | |
817 | ||
818 | if (num != 1) { | |
819 | DBG_88E("invalid set_rssi_disp parameter!\n"); | |
820 | return count; | |
821 | } | |
822 | ||
823 | if (enable) { | |
824 | DBG_88E("Turn On Rx RSSI Display Function\n"); | |
2275d2b7 | 825 | padapter->bRxRSSIDisplay = enable; |
06a05884 LF |
826 | } else { |
827 | DBG_88E("Turn Off Rx RSSI Display Function\n"); | |
828 | padapter->bRxRSSIDisplay = 0; | |
829 | } | |
830 | } | |
831 | return count; | |
832 | } | |
833 | ||
834 | #ifdef CONFIG_88EU_AP_MODE | |
835 | ||
836 | int proc_get_all_sta_info(char *page, char **start, | |
837 | off_t offset, int count, | |
838 | int *eof, void *data) | |
839 | { | |
06a05884 LF |
840 | struct sta_info *psta; |
841 | struct net_device *dev = data; | |
842 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
843 | struct sta_priv *pstapriv = &padapter->stapriv; | |
844 | int i, j; | |
845 | struct list_head *plist, *phead; | |
846 | struct recv_reorder_ctrl *preorder_ctrl; | |
847 | int len = 0; | |
848 | ||
849 | ||
850 | len += snprintf(page + len, count - len, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap); | |
851 | ||
7057dcb3 | 852 | spin_lock_bh(&pstapriv->sta_hash_lock); |
06a05884 LF |
853 | |
854 | for (i = 0; i < NUM_STA; i++) { | |
855 | phead = &(pstapriv->sta_hash[i]); | |
c44e5e39 | 856 | plist = phead->next; |
06a05884 | 857 | |
84660700 | 858 | while (phead != plist) { |
bea88100 | 859 | psta = container_of(plist, struct sta_info, hash_list); |
06a05884 | 860 | |
c44e5e39 | 861 | plist = plist->next; |
06a05884 LF |
862 | |
863 | len += snprintf(page + len, count - len, "sta's macaddr: %pM\n", psta->hwaddr); | |
864 | len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self); | |
865 | 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); | |
866 | 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); | |
867 | len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi); | |
868 | len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable); | |
869 | 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); | |
870 | len += snprintf(page + len, count - len, "sleepq_len=%d\n", psta->sleepq_len); | |
871 | len += snprintf(page + len, count - len, "capability=0x%x\n", psta->capability); | |
872 | len += snprintf(page + len, count - len, "flags=0x%x\n", psta->flags); | |
873 | len += snprintf(page + len, count - len, "wpa_psk=0x%x\n", psta->wpa_psk); | |
874 | len += snprintf(page + len, count - len, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher); | |
875 | len += snprintf(page + len, count - len, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher); | |
876 | len += snprintf(page + len, count - len, "qos_info=0x%x\n", psta->qos_info); | |
877 | len += snprintf(page + len, count - len, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy); | |
878 | ||
879 | for (j = 0; j < 16; j++) { | |
880 | preorder_ctrl = &psta->recvreorder_ctrl[j]; | |
881 | if (preorder_ctrl->enable) | |
882 | len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq); | |
883 | } | |
884 | } | |
885 | } | |
e02bcf61 | 886 | spin_unlock_bh(&pstapriv->sta_hash_lock); |
06a05884 LF |
887 | |
888 | *eof = 1; | |
889 | return len; | |
890 | } | |
891 | #endif | |
892 | ||
893 | int proc_get_best_channel(char *page, char **start, | |
894 | off_t offset, int count, | |
895 | int *eof, void *data) | |
896 | { | |
897 | struct net_device *dev = data; | |
898 | struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); | |
899 | struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; | |
900 | int len = 0; | |
901 | u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0; | |
902 | ||
903 | for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) { | |
904 | if (pmlmeext->channel_set[i].ChannelNum == 1) | |
905 | index_24G = i; | |
906 | if (pmlmeext->channel_set[i].ChannelNum == 36) | |
907 | index_5G = i; | |
908 | } | |
909 | ||
910 | for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) { | |
911 | /* 2.4G */ | |
912 | if (pmlmeext->channel_set[i].ChannelNum == 6) { | |
913 | if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) { | |
914 | index_24G = i; | |
915 | best_channel_24G = pmlmeext->channel_set[i].ChannelNum; | |
916 | } | |
917 | } | |
918 | ||
919 | /* 5G */ | |
920 | if (pmlmeext->channel_set[i].ChannelNum >= 36 && | |
921 | pmlmeext->channel_set[i].ChannelNum < 140) { | |
4e0fa71c | 922 | /* Find primary channel */ |
06a05884 LF |
923 | if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) && |
924 | (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) { | |
925 | index_5G = i; | |
926 | best_channel_5G = pmlmeext->channel_set[i].ChannelNum; | |
927 | } | |
928 | } | |
929 | ||
930 | if (pmlmeext->channel_set[i].ChannelNum >= 149 && | |
931 | pmlmeext->channel_set[i].ChannelNum < 165) { | |
4e0fa71c | 932 | /* find primary channel */ |
06a05884 LF |
933 | if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) && |
934 | (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) { | |
935 | index_5G = i; | |
936 | best_channel_5G = pmlmeext->channel_set[i].ChannelNum; | |
937 | } | |
938 | } | |
939 | /* debug */ | |
940 | len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n", | |
941 | pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count); | |
942 | } | |
943 | ||
944 | len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G); | |
945 | len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G); | |
946 | ||
947 | *eof = 1; | |
948 | return len; | |
949 | } |