?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cris: add arch/cris/include/asm/serial.h
[linux-2.6/next.git] / drivers / net / wireless / ath / ath9k / htc_drv_debug.c
blobd3ff33c71aa5bbd2074d4d64c2a92c41ab144c91
1 /*
2 * Copyright (c) 2010-2011 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include "htc.h"
18
19 static int ath9k_debugfs_open(struct inode *inode, struct file *file)
20 {
21 file->private_data = inode->i_private;
22 return 0;
23 }
24
25 static ssize_t read_file_tgt_int_stats(struct file *file, char __user *user_buf,
26 size_t count, loff_t *ppos)
27 {
28 struct ath9k_htc_priv *priv = file->private_data;
29 struct ath9k_htc_target_int_stats cmd_rsp;
30 char buf[512];
31 unsigned int len = 0;
32 int ret = 0;
33
34 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
35
36 ath9k_htc_ps_wakeup(priv);
37
38 WMI_CMD(WMI_INT_STATS_CMDID);
39 if (ret) {
40 ath9k_htc_ps_restore(priv);
41 return -EINVAL;
42 }
43
44 ath9k_htc_ps_restore(priv);
45
46 len += snprintf(buf + len, sizeof(buf) - len,
47 "%20s : %10u\n", "RX",
48 be32_to_cpu(cmd_rsp.rx));
49
50 len += snprintf(buf + len, sizeof(buf) - len,
51 "%20s : %10u\n", "RXORN",
52 be32_to_cpu(cmd_rsp.rxorn));
53
54 len += snprintf(buf + len, sizeof(buf) - len,
55 "%20s : %10u\n", "RXEOL",
56 be32_to_cpu(cmd_rsp.rxeol));
57
58 len += snprintf(buf + len, sizeof(buf) - len,
59 "%20s : %10u\n", "TXURN",
60 be32_to_cpu(cmd_rsp.txurn));
61
62 len += snprintf(buf + len, sizeof(buf) - len,
63 "%20s : %10u\n", "TXTO",
64 be32_to_cpu(cmd_rsp.txto));
65
66 len += snprintf(buf + len, sizeof(buf) - len,
67 "%20s : %10u\n", "CST",
68 be32_to_cpu(cmd_rsp.cst));
69
70 if (len > sizeof(buf))
71 len = sizeof(buf);
72
73 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
74 }
75
76 static const struct file_operations fops_tgt_int_stats = {
77 .read = read_file_tgt_int_stats,
78 .open = ath9k_debugfs_open,
79 .owner = THIS_MODULE,
80 .llseek = default_llseek,
81 };
82
83 static ssize_t read_file_tgt_tx_stats(struct file *file, char __user *user_buf,
84 size_t count, loff_t *ppos)
85 {
86 struct ath9k_htc_priv *priv = file->private_data;
87 struct ath9k_htc_target_tx_stats cmd_rsp;
88 char buf[512];
89 unsigned int len = 0;
90 int ret = 0;
91
92 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
93
94 ath9k_htc_ps_wakeup(priv);
95
96 WMI_CMD(WMI_TX_STATS_CMDID);
97 if (ret) {
98 ath9k_htc_ps_restore(priv);
99 return -EINVAL;
100 }
101
102 ath9k_htc_ps_restore(priv);
103
104 len += snprintf(buf + len, sizeof(buf) - len,
105 "%20s : %10u\n", "Xretries",
106 be32_to_cpu(cmd_rsp.xretries));
107
108 len += snprintf(buf + len, sizeof(buf) - len,
109 "%20s : %10u\n", "FifoErr",
110 be32_to_cpu(cmd_rsp.fifoerr));
111
112 len += snprintf(buf + len, sizeof(buf) - len,
113 "%20s : %10u\n", "Filtered",
114 be32_to_cpu(cmd_rsp.filtered));
115
116 len += snprintf(buf + len, sizeof(buf) - len,
117 "%20s : %10u\n", "TimerExp",
118 be32_to_cpu(cmd_rsp.timer_exp));
119
120 len += snprintf(buf + len, sizeof(buf) - len,
121 "%20s : %10u\n", "ShortRetries",
122 be32_to_cpu(cmd_rsp.shortretries));
123
124 len += snprintf(buf + len, sizeof(buf) - len,
125 "%20s : %10u\n", "LongRetries",
126 be32_to_cpu(cmd_rsp.longretries));
127
128 len += snprintf(buf + len, sizeof(buf) - len,
129 "%20s : %10u\n", "QueueNull",
130 be32_to_cpu(cmd_rsp.qnull));
131
132 len += snprintf(buf + len, sizeof(buf) - len,
133 "%20s : %10u\n", "EncapFail",
134 be32_to_cpu(cmd_rsp.encap_fail));
135
136 len += snprintf(buf + len, sizeof(buf) - len,
137 "%20s : %10u\n", "NoBuf",
138 be32_to_cpu(cmd_rsp.nobuf));
139
140 if (len > sizeof(buf))
141 len = sizeof(buf);
142
143 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
144 }
145
146 static const struct file_operations fops_tgt_tx_stats = {
147 .read = read_file_tgt_tx_stats,
148 .open = ath9k_debugfs_open,
149 .owner = THIS_MODULE,
150 .llseek = default_llseek,
151 };
152
153 static ssize_t read_file_tgt_rx_stats(struct file *file, char __user *user_buf,
154 size_t count, loff_t *ppos)
155 {
156 struct ath9k_htc_priv *priv = file->private_data;
157 struct ath9k_htc_target_rx_stats cmd_rsp;
158 char buf[512];
159 unsigned int len = 0;
160 int ret = 0;
161
162 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
163
164 ath9k_htc_ps_wakeup(priv);
165
166 WMI_CMD(WMI_RX_STATS_CMDID);
167 if (ret) {
168 ath9k_htc_ps_restore(priv);
169 return -EINVAL;
170 }
171
172 ath9k_htc_ps_restore(priv);
173
174 len += snprintf(buf + len, sizeof(buf) - len,
175 "%20s : %10u\n", "NoBuf",
176 be32_to_cpu(cmd_rsp.nobuf));
177
178 len += snprintf(buf + len, sizeof(buf) - len,
179 "%20s : %10u\n", "HostSend",
180 be32_to_cpu(cmd_rsp.host_send));
181
182 len += snprintf(buf + len, sizeof(buf) - len,
183 "%20s : %10u\n", "HostDone",
184 be32_to_cpu(cmd_rsp.host_done));
185
186 if (len > sizeof(buf))
187 len = sizeof(buf);
188
189 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
190 }
191
192 static const struct file_operations fops_tgt_rx_stats = {
193 .read = read_file_tgt_rx_stats,
194 .open = ath9k_debugfs_open,
195 .owner = THIS_MODULE,
196 .llseek = default_llseek,
197 };
198
199 static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
200 size_t count, loff_t *ppos)
201 {
202 struct ath9k_htc_priv *priv = file->private_data;
203 char buf[512];
204 unsigned int len = 0;
205
206 len += snprintf(buf + len, sizeof(buf) - len,
207 "%20s : %10u\n", "Buffers queued",
208 priv->debug.tx_stats.buf_queued);
209 len += snprintf(buf + len, sizeof(buf) - len,
210 "%20s : %10u\n", "Buffers completed",
211 priv->debug.tx_stats.buf_completed);
212 len += snprintf(buf + len, sizeof(buf) - len,
213 "%20s : %10u\n", "SKBs queued",
214 priv->debug.tx_stats.skb_queued);
215 len += snprintf(buf + len, sizeof(buf) - len,
216 "%20s : %10u\n", "SKBs success",
217 priv->debug.tx_stats.skb_success);
218 len += snprintf(buf + len, sizeof(buf) - len,
219 "%20s : %10u\n", "SKBs failed",
220 priv->debug.tx_stats.skb_failed);
221 len += snprintf(buf + len, sizeof(buf) - len,
222 "%20s : %10u\n", "CAB queued",
223 priv->debug.tx_stats.cab_queued);
224
225 len += snprintf(buf + len, sizeof(buf) - len,
226 "%20s : %10u\n", "BE queued",
227 priv->debug.tx_stats.queue_stats[WME_AC_BE]);
228 len += snprintf(buf + len, sizeof(buf) - len,
229 "%20s : %10u\n", "BK queued",
230 priv->debug.tx_stats.queue_stats[WME_AC_BK]);
231 len += snprintf(buf + len, sizeof(buf) - len,
232 "%20s : %10u\n", "VI queued",
233 priv->debug.tx_stats.queue_stats[WME_AC_VI]);
234 len += snprintf(buf + len, sizeof(buf) - len,
235 "%20s : %10u\n", "VO queued",
236 priv->debug.tx_stats.queue_stats[WME_AC_VO]);
237
238 if (len > sizeof(buf))
239 len = sizeof(buf);
240
241 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
242 }
243
244 static const struct file_operations fops_xmit = {
245 .read = read_file_xmit,
246 .open = ath9k_debugfs_open,
247 .owner = THIS_MODULE,
248 .llseek = default_llseek,
249 };
250
251 void ath9k_htc_err_stat_rx(struct ath9k_htc_priv *priv,
252 struct ath_htc_rx_status *rxs)
253 {
254 #define RX_PHY_ERR_INC(c) priv->debug.rx_stats.err_phy_stats[c]++
255
256 if (rxs->rs_status & ATH9K_RXERR_CRC)
257 priv->debug.rx_stats.err_crc++;
258 if (rxs->rs_status & ATH9K_RXERR_DECRYPT)
259 priv->debug.rx_stats.err_decrypt_crc++;
260 if (rxs->rs_status & ATH9K_RXERR_MIC)
261 priv->debug.rx_stats.err_mic++;
262 if (rxs->rs_status & ATH9K_RX_DELIM_CRC_PRE)
263 priv->debug.rx_stats.err_pre_delim++;
264 if (rxs->rs_status & ATH9K_RX_DELIM_CRC_POST)
265 priv->debug.rx_stats.err_post_delim++;
266 if (rxs->rs_status & ATH9K_RX_DECRYPT_BUSY)
267 priv->debug.rx_stats.err_decrypt_busy++;
268
269 if (rxs->rs_status & ATH9K_RXERR_PHY) {
270 priv->debug.rx_stats.err_phy++;
271 if (rxs->rs_phyerr < ATH9K_PHYERR_MAX)
272 RX_PHY_ERR_INC(rxs->rs_phyerr);
273 }
274
275 #undef RX_PHY_ERR_INC
276 }
277
278 static ssize_t read_file_recv(struct file *file, char __user *user_buf,
279 size_t count, loff_t *ppos)
280 {
281 #define PHY_ERR(s, p) \
282 len += snprintf(buf + len, size - len, "%20s : %10u\n", s, \
283 priv->debug.rx_stats.err_phy_stats[p]);
284
285 struct ath9k_htc_priv *priv = file->private_data;
286 char *buf;
287 unsigned int len = 0, size = 1500;
288 ssize_t retval = 0;
289
290 buf = kzalloc(size, GFP_KERNEL);
291 if (buf == NULL)
292 return -ENOMEM;
293
294 len += snprintf(buf + len, size - len,
295 "%20s : %10u\n", "SKBs allocated",
296 priv->debug.rx_stats.skb_allocated);
297 len += snprintf(buf + len, size - len,
298 "%20s : %10u\n", "SKBs completed",
299 priv->debug.rx_stats.skb_completed);
300 len += snprintf(buf + len, size - len,
301 "%20s : %10u\n", "SKBs Dropped",
302 priv->debug.rx_stats.skb_dropped);
303
304 len += snprintf(buf + len, size - len,
305 "%20s : %10u\n", "CRC ERR",
306 priv->debug.rx_stats.err_crc);
307 len += snprintf(buf + len, size - len,
308 "%20s : %10u\n", "DECRYPT CRC ERR",
309 priv->debug.rx_stats.err_decrypt_crc);
310 len += snprintf(buf + len, size - len,
311 "%20s : %10u\n", "MIC ERR",
312 priv->debug.rx_stats.err_mic);
313 len += snprintf(buf + len, size - len,
314 "%20s : %10u\n", "PRE-DELIM CRC ERR",
315 priv->debug.rx_stats.err_pre_delim);
316 len += snprintf(buf + len, size - len,
317 "%20s : %10u\n", "POST-DELIM CRC ERR",
318 priv->debug.rx_stats.err_post_delim);
319 len += snprintf(buf + len, size - len,
320 "%20s : %10u\n", "DECRYPT BUSY ERR",
321 priv->debug.rx_stats.err_decrypt_busy);
322 len += snprintf(buf + len, size - len,
323 "%20s : %10u\n", "TOTAL PHY ERR",
324 priv->debug.rx_stats.err_phy);
325
326
327 PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN);
328 PHY_ERR("TIMING", ATH9K_PHYERR_TIMING);
329 PHY_ERR("PARITY", ATH9K_PHYERR_PARITY);
330 PHY_ERR("RATE", ATH9K_PHYERR_RATE);
331 PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH);
332 PHY_ERR("RADAR", ATH9K_PHYERR_RADAR);
333 PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE);
334 PHY_ERR("TOR", ATH9K_PHYERR_TOR);
335 PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING);
336 PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
337 PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
338 PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
339 PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP);
340 PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE);
341 PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART);
342 PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT);
343 PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING);
344 PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC);
345 PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
346 PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE);
347 PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART);
348 PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
349 PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP);
350 PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR);
351 PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
352 PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL);
353
354 if (len > size)
355 len = size;
356
357 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
358 kfree(buf);
359
360 return retval;
361
362 #undef PHY_ERR
363 }
364
365 static const struct file_operations fops_recv = {
366 .read = read_file_recv,
367 .open = ath9k_debugfs_open,
368 .owner = THIS_MODULE,
369 .llseek = default_llseek,
370 };
371
372 static ssize_t read_file_slot(struct file *file, char __user *user_buf,
373 size_t count, loff_t *ppos)
374 {
375 struct ath9k_htc_priv *priv = file->private_data;
376 char buf[512];
377 unsigned int len = 0;
378
379 spin_lock_bh(&priv->tx.tx_lock);
380
381 len += snprintf(buf + len, sizeof(buf) - len, "TX slot bitmap : ");
382
383 len += bitmap_scnprintf(buf + len, sizeof(buf) - len,
384 priv->tx.tx_slot, MAX_TX_BUF_NUM);
385
386 len += snprintf(buf + len, sizeof(buf) - len, "\n");
387
388 len += snprintf(buf + len, sizeof(buf) - len,
389 "Used slots : %d\n",
390 bitmap_weight(priv->tx.tx_slot, MAX_TX_BUF_NUM));
391
392 spin_unlock_bh(&priv->tx.tx_lock);
393
394 if (len > sizeof(buf))
395 len = sizeof(buf);
396
397 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
398 }
399
400 static const struct file_operations fops_slot = {
401 .read = read_file_slot,
402 .open = ath9k_debugfs_open,
403 .owner = THIS_MODULE,
404 .llseek = default_llseek,
405 };
406
407 static ssize_t read_file_queue(struct file *file, char __user *user_buf,
408 size_t count, loff_t *ppos)
409 {
410 struct ath9k_htc_priv *priv = file->private_data;
411 char buf[512];
412 unsigned int len = 0;
413
414 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
415 "Mgmt endpoint", skb_queue_len(&priv->tx.mgmt_ep_queue));
416
417 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
418 "Cab endpoint", skb_queue_len(&priv->tx.cab_ep_queue));
419
420 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
421 "Data BE endpoint", skb_queue_len(&priv->tx.data_be_queue));
422
423 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
424 "Data BK endpoint", skb_queue_len(&priv->tx.data_bk_queue));
425
426 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
427 "Data VI endpoint", skb_queue_len(&priv->tx.data_vi_queue));
428
429 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
430 "Data VO endpoint", skb_queue_len(&priv->tx.data_vo_queue));
431
432 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
433 "Failed queue", skb_queue_len(&priv->tx.tx_failed));
434
435 spin_lock_bh(&priv->tx.tx_lock);
436 len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
437 "Queued count", priv->tx.queued_cnt);
438 spin_unlock_bh(&priv->tx.tx_lock);
439
440 if (len > sizeof(buf))
441 len = sizeof(buf);
442
443 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
444
445 }
446
447 static const struct file_operations fops_queue = {
448 .read = read_file_queue,
449 .open = ath9k_debugfs_open,
450 .owner = THIS_MODULE,
451 .llseek = default_llseek,
452 };
453
454 static ssize_t read_file_debug(struct file *file, char __user *user_buf,
455 size_t count, loff_t *ppos)
456 {
457 struct ath9k_htc_priv *priv = file->private_data;
458 struct ath_common *common = ath9k_hw_common(priv->ah);
459 char buf[32];
460 unsigned int len;
461
462 len = sprintf(buf, "0x%08x\n", common->debug_mask);
463 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
464 }
465
466 static ssize_t write_file_debug(struct file *file, const char __user *user_buf,
467 size_t count, loff_t *ppos)
468 {
469 struct ath9k_htc_priv *priv = file->private_data;
470 struct ath_common *common = ath9k_hw_common(priv->ah);
471 unsigned long mask;
472 char buf[32];
473 ssize_t len;
474
475 len = min(count, sizeof(buf) - 1);
476 if (copy_from_user(buf, user_buf, len))
477 return -EFAULT;
478
479 buf[len] = '\0';
480 if (strict_strtoul(buf, 0, &mask))
481 return -EINVAL;
482
483 common->debug_mask = mask;
484 return count;
485 }
486
487 static const struct file_operations fops_debug = {
488 .read = read_file_debug,
489 .write = write_file_debug,
490 .open = ath9k_debugfs_open,
491 .owner = THIS_MODULE,
492 .llseek = default_llseek,
493 };
494
495 static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf,
496 size_t count, loff_t *ppos)
497 {
498 struct ath9k_htc_priv *priv = file->private_data;
499 struct ath_common *common = ath9k_hw_common(priv->ah);
500 struct base_eep_header *pBase = NULL;
501 unsigned int len = 0, size = 1500;
502 ssize_t retval = 0;
503 char *buf;
504
505 /*
506 * This can be done since all the 3 EEPROM families have the
507 * same base header upto a certain point, and we are interested in
508 * the data only upto that point.
509 */
510
511 if (AR_SREV_9271(priv->ah))
512 pBase = (struct base_eep_header *)
513 &priv->ah->eeprom.map4k.baseEepHeader;
514 else if (priv->ah->hw_version.usbdev == AR9280_USB)
515 pBase = (struct base_eep_header *)
516 &priv->ah->eeprom.def.baseEepHeader;
517 else if (priv->ah->hw_version.usbdev == AR9287_USB)
518 pBase = (struct base_eep_header *)
519 &priv->ah->eeprom.map9287.baseEepHeader;
520
521 if (pBase == NULL) {
522 ath_err(common, "Unknown EEPROM type\n");
523 return 0;
524 }
525
526 buf = kzalloc(size, GFP_KERNEL);
527 if (buf == NULL)
528 return -ENOMEM;
529
530 len += snprintf(buf + len, size - len,
531 "%20s : %10d\n", "Major Version",
532 pBase->version >> 12);
533 len += snprintf(buf + len, size - len,
534 "%20s : %10d\n", "Minor Version",
535 pBase->version & 0xFFF);
536 len += snprintf(buf + len, size - len,
537 "%20s : %10d\n", "Checksum",
538 pBase->checksum);
539 len += snprintf(buf + len, size - len,
540 "%20s : %10d\n", "Length",
541 pBase->length);
542 len += snprintf(buf + len, size - len,
543 "%20s : %10d\n", "RegDomain1",
544 pBase->regDmn[0]);
545 len += snprintf(buf + len, size - len,
546 "%20s : %10d\n", "RegDomain2",
547 pBase->regDmn[1]);
548 len += snprintf(buf + len, size - len,
549 "%20s : %10d\n",
550 "TX Mask", pBase->txMask);
551 len += snprintf(buf + len, size - len,
552 "%20s : %10d\n",
553 "RX Mask", pBase->rxMask);
554 len += snprintf(buf + len, size - len,
555 "%20s : %10d\n",
556 "Allow 5GHz",
557 !!(pBase->opCapFlags & AR5416_OPFLAGS_11A));
558 len += snprintf(buf + len, size - len,
559 "%20s : %10d\n",
560 "Allow 2GHz",
561 !!(pBase->opCapFlags & AR5416_OPFLAGS_11G));
562 len += snprintf(buf + len, size - len,
563 "%20s : %10d\n",
564 "Disable 2GHz HT20",
565 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT20));
566 len += snprintf(buf + len, size - len,
567 "%20s : %10d\n",
568 "Disable 2GHz HT40",
569 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT40));
570 len += snprintf(buf + len, size - len,
571 "%20s : %10d\n",
572 "Disable 5Ghz HT20",
573 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT20));
574 len += snprintf(buf + len, size - len,
575 "%20s : %10d\n",
576 "Disable 5Ghz HT40",
577 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT40));
578 len += snprintf(buf + len, size - len,
579 "%20s : %10d\n",
580 "Big Endian",
581 !!(pBase->eepMisc & 0x01));
582 len += snprintf(buf + len, size - len,
583 "%20s : %10d\n",
584 "Cal Bin Major Ver",
585 (pBase->binBuildNumber >> 24) & 0xFF);
586 len += snprintf(buf + len, size - len,
587 "%20s : %10d\n",
588 "Cal Bin Minor Ver",
589 (pBase->binBuildNumber >> 16) & 0xFF);
590 len += snprintf(buf + len, size - len,
591 "%20s : %10d\n",
592 "Cal Bin Build",
593 (pBase->binBuildNumber >> 8) & 0xFF);
594
595 /*
596 * UB91 specific data.
597 */
598 if (AR_SREV_9271(priv->ah)) {
599 struct base_eep_header_4k *pBase4k =
600 &priv->ah->eeprom.map4k.baseEepHeader;
601
602 len += snprintf(buf + len, size - len,
603 "%20s : %10d\n",
604 "TX Gain type",
605 pBase4k->txGainType);
606 }
607
608 /*
609 * UB95 specific data.
610 */
611 if (priv->ah->hw_version.usbdev == AR9287_USB) {
612 struct base_eep_ar9287_header *pBase9287 =
613 &priv->ah->eeprom.map9287.baseEepHeader;
614
615 len += snprintf(buf + len, size - len,
616 "%20s : %10ddB\n",
617 "Power Table Offset",
618 pBase9287->pwrTableOffset);
619
620 len += snprintf(buf + len, size - len,
621 "%20s : %10d\n",
622 "OpenLoop Power Ctrl",
623 pBase9287->openLoopPwrCntl);
624 }
625
626 len += snprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress",
627 pBase->macAddr);
628 if (len > size)
629 len = size;
630
631 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
632 kfree(buf);
633
634 return retval;
635 }
636
637 static const struct file_operations fops_base_eeprom = {
638 .read = read_file_base_eeprom,
639 .open = ath9k_debugfs_open,
640 .owner = THIS_MODULE,
641 .llseek = default_llseek,
642 };
643
644 static ssize_t read_4k_modal_eeprom(struct file *file,
645 char __user *user_buf,
646 size_t count, loff_t *ppos)
647 {
648 #define PR_EEP(_s, _val) \
649 do { \
650 len += snprintf(buf + len, size - len, "%20s : %10d\n", \
651 _s, (_val)); \
652 } while (0)
653
654 struct ath9k_htc_priv *priv = file->private_data;
655 struct modal_eep_4k_header *pModal = &priv->ah->eeprom.map4k.modalHeader;
656 unsigned int len = 0, size = 2048;
657 ssize_t retval = 0;
658 char *buf;
659
660 buf = kzalloc(size, GFP_KERNEL);
661 if (buf == NULL)
662 return -ENOMEM;
663
664 PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
665 PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
666 PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
667 PR_EEP("Switch Settle", pModal->switchSettling);
668 PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
669 PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
670 PR_EEP("ADC Desired size", pModal->adcDesiredSize);
671 PR_EEP("PGA Desired size", pModal->pgaDesiredSize);
672 PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]);
673 PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
674 PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
675 PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
676 PR_EEP("CCA Threshold)", pModal->thresh62);
677 PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
678 PR_EEP("xpdGain", pModal->xpdGain);
679 PR_EEP("External PD", pModal->xpd);
680 PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
681 PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
682 PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
683 PR_EEP("O/D Bias Version", pModal->version);
684 PR_EEP("CCK OutputBias", pModal->ob_0);
685 PR_EEP("BPSK OutputBias", pModal->ob_1);
686 PR_EEP("QPSK OutputBias", pModal->ob_2);
687 PR_EEP("16QAM OutputBias", pModal->ob_3);
688 PR_EEP("64QAM OutputBias", pModal->ob_4);
689 PR_EEP("CCK Driver1_Bias", pModal->db1_0);
690 PR_EEP("BPSK Driver1_Bias", pModal->db1_1);
691 PR_EEP("QPSK Driver1_Bias", pModal->db1_2);
692 PR_EEP("16QAM Driver1_Bias", pModal->db1_3);
693 PR_EEP("64QAM Driver1_Bias", pModal->db1_4);
694 PR_EEP("CCK Driver2_Bias", pModal->db2_0);
695 PR_EEP("BPSK Driver2_Bias", pModal->db2_1);
696 PR_EEP("QPSK Driver2_Bias", pModal->db2_2);
697 PR_EEP("16QAM Driver2_Bias", pModal->db2_3);
698 PR_EEP("64QAM Driver2_Bias", pModal->db2_4);
699 PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
700 PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
701 PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
702 PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
703 PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
704 PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
705 PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
706 PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]);
707 PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]);
708 PR_EEP("Ant. Diversity ctl1", pModal->antdiv_ctl1);
709 PR_EEP("Ant. Diversity ctl2", pModal->antdiv_ctl2);
710 PR_EEP("TX Diversity", pModal->tx_diversity);
711
712 if (len > size)
713 len = size;
714
715 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
716 kfree(buf);
717
718 return retval;
719
720 #undef PR_EEP
721 }
722
723 static ssize_t read_def_modal_eeprom(struct file *file,
724 char __user *user_buf,
725 size_t count, loff_t *ppos)
726 {
727 #define PR_EEP(_s, _val) \
728 do { \
729 if (pBase->opCapFlags & AR5416_OPFLAGS_11G) { \
730 pModal = &priv->ah->eeprom.def.modalHeader[1]; \
731 len += snprintf(buf + len, size - len, "%20s : %8d%7s", \
732 _s, (_val), "|"); \
733 } \
734 if (pBase->opCapFlags & AR5416_OPFLAGS_11A) { \
735 pModal = &priv->ah->eeprom.def.modalHeader[0]; \
736 len += snprintf(buf + len, size - len, "%9d\n", \
737 (_val)); \
738 } \
739 } while (0)
740
741 struct ath9k_htc_priv *priv = file->private_data;
742 struct base_eep_header *pBase = &priv->ah->eeprom.def.baseEepHeader;
743 struct modal_eep_header *pModal = NULL;
744 unsigned int len = 0, size = 3500;
745 ssize_t retval = 0;
746 char *buf;
747
748 buf = kzalloc(size, GFP_KERNEL);
749 if (buf == NULL)
750 return -ENOMEM;
751
752 len += snprintf(buf + len, size - len,
753 "%31s %15s\n", "2G", "5G");
754 len += snprintf(buf + len, size - len,
755 "%32s %16s\n", "====", "====\n");
756
757 PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
758 PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]);
759 PR_EEP("Chain2 Ant. Control", pModal->antCtrlChain[2]);
760 PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
761 PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
762 PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]);
763 PR_EEP("Chain2 Ant. Gain", pModal->antennaGainCh[2]);
764 PR_EEP("Switch Settle", pModal->switchSettling);
765 PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
766 PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]);
767 PR_EEP("Chain2 TxRxAtten", pModal->txRxAttenCh[2]);
768 PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
769 PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]);
770 PR_EEP("Chain2 RxTxMargin", pModal->rxTxMarginCh[2]);
771 PR_EEP("ADC Desired size", pModal->adcDesiredSize);
772 PR_EEP("PGA Desired size", pModal->pgaDesiredSize);
773 PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]);
774 PR_EEP("Chain1 xlna Gain", pModal->xlnaGainCh[1]);
775 PR_EEP("Chain2 xlna Gain", pModal->xlnaGainCh[2]);
776 PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
777 PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
778 PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
779 PR_EEP("CCA Threshold)", pModal->thresh62);
780 PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
781 PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]);
782 PR_EEP("Chain2 NF Threshold", pModal->noiseFloorThreshCh[2]);
783 PR_EEP("xpdGain", pModal->xpdGain);
784 PR_EEP("External PD", pModal->xpd);
785 PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
786 PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]);
787 PR_EEP("Chain2 I Coefficient", pModal->iqCalICh[2]);
788 PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
789 PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]);
790 PR_EEP("Chain2 Q Coefficient", pModal->iqCalQCh[2]);
791 PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
792 PR_EEP("Chain0 OutputBias", pModal->ob);
793 PR_EEP("Chain0 DriverBias", pModal->db);
794 PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
795 PR_EEP("2chain pwr decrease", pModal->pwrDecreaseFor2Chain);
796 PR_EEP("3chain pwr decrease", pModal->pwrDecreaseFor3Chain);
797 PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
798 PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
799 PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
800 PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
801 PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]);
802 PR_EEP("Chain2 bswAtten", pModal->bswAtten[2]);
803 PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
804 PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]);
805 PR_EEP("Chain2 bswMargin", pModal->bswMargin[2]);
806 PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
807 PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]);
808 PR_EEP("Chain1 xatten2Db", pModal->xatten2Db[1]);
809 PR_EEP("Chain2 xatten2Db", pModal->xatten2Db[2]);
810 PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]);
811 PR_EEP("Chain1 xatten2Margin", pModal->xatten2Margin[1]);
812 PR_EEP("Chain2 xatten2Margin", pModal->xatten2Margin[2]);
813 PR_EEP("Chain1 OutputBias", pModal->ob_ch1);
814 PR_EEP("Chain1 DriverBias", pModal->db_ch1);
815 PR_EEP("LNA Control", pModal->lna_ctl);
816 PR_EEP("XPA Bias Freq0", pModal->xpaBiasLvlFreq[0]);
817 PR_EEP("XPA Bias Freq1", pModal->xpaBiasLvlFreq[1]);
818 PR_EEP("XPA Bias Freq2", pModal->xpaBiasLvlFreq[2]);
819
820 if (len > size)
821 len = size;
822
823 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
824 kfree(buf);
825
826 return retval;
827
828 #undef PR_EEP
829 }
830
831 static ssize_t read_9287_modal_eeprom(struct file *file,
832 char __user *user_buf,
833 size_t count, loff_t *ppos)
834 {
835 #define PR_EEP(_s, _val) \
836 do { \
837 len += snprintf(buf + len, size - len, "%20s : %10d\n", \
838 _s, (_val)); \
839 } while (0)
840
841 struct ath9k_htc_priv *priv = file->private_data;
842 struct modal_eep_ar9287_header *pModal = &priv->ah->eeprom.map9287.modalHeader;
843 unsigned int len = 0, size = 3000;
844 ssize_t retval = 0;
845 char *buf;
846
847 buf = kzalloc(size, GFP_KERNEL);
848 if (buf == NULL)
849 return -ENOMEM;
850
851 PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
852 PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]);
853 PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
854 PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
855 PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]);
856 PR_EEP("Switch Settle", pModal->switchSettling);
857 PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
858 PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]);
859 PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
860 PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]);
861 PR_EEP("ADC Desired size", pModal->adcDesiredSize);
862 PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
863 PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
864 PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
865 PR_EEP("CCA Threshold)", pModal->thresh62);
866 PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
867 PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]);
868 PR_EEP("xpdGain", pModal->xpdGain);
869 PR_EEP("External PD", pModal->xpd);
870 PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
871 PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]);
872 PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
873 PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]);
874 PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
875 PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
876 PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
877 PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
878 PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
879 PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
880 PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]);
881 PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
882 PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]);
883 PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
884 PR_EEP("AR92x7 Version", pModal->version);
885 PR_EEP("DriverBias1", pModal->db1);
886 PR_EEP("DriverBias2", pModal->db1);
887 PR_EEP("CCK OutputBias", pModal->ob_cck);
888 PR_EEP("PSK OutputBias", pModal->ob_psk);
889 PR_EEP("QAM OutputBias", pModal->ob_qam);
890 PR_EEP("PAL_OFF OutputBias", pModal->ob_pal_off);
891
892 if (len > size)
893 len = size;
894
895 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
896 kfree(buf);
897
898 return retval;
899
900 #undef PR_EEP
901 }
902
903 static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf,
904 size_t count, loff_t *ppos)
905 {
906 struct ath9k_htc_priv *priv = file->private_data;
907
908 if (AR_SREV_9271(priv->ah))
909 return read_4k_modal_eeprom(file, user_buf, count, ppos);
910 else if (priv->ah->hw_version.usbdev == AR9280_USB)
911 return read_def_modal_eeprom(file, user_buf, count, ppos);
912 else if (priv->ah->hw_version.usbdev == AR9287_USB)
913 return read_9287_modal_eeprom(file, user_buf, count, ppos);
914
915 return 0;
916 }
917
918 static const struct file_operations fops_modal_eeprom = {
919 .read = read_file_modal_eeprom,
920 .open = ath9k_debugfs_open,
921 .owner = THIS_MODULE,
922 .llseek = default_llseek,
923 };
924
925 int ath9k_htc_init_debug(struct ath_hw *ah)
926 {
927 struct ath_common *common = ath9k_hw_common(ah);
928 struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *) common->priv;
929
930 priv->debug.debugfs_phy = debugfs_create_dir(KBUILD_MODNAME,
931 priv->hw->wiphy->debugfsdir);
932 if (!priv->debug.debugfs_phy)
933 return -ENOMEM;
934
935 debugfs_create_file("tgt_int_stats", S_IRUSR, priv->debug.debugfs_phy,
936 priv, &fops_tgt_int_stats);
937 debugfs_create_file("tgt_tx_stats", S_IRUSR, priv->debug.debugfs_phy,
938 priv, &fops_tgt_tx_stats);
939 debugfs_create_file("tgt_rx_stats", S_IRUSR, priv->debug.debugfs_phy,
940 priv, &fops_tgt_rx_stats);
941 debugfs_create_file("xmit", S_IRUSR, priv->debug.debugfs_phy,
942 priv, &fops_xmit);
943 debugfs_create_file("recv", S_IRUSR, priv->debug.debugfs_phy,
944 priv, &fops_recv);
945 debugfs_create_file("slot", S_IRUSR, priv->debug.debugfs_phy,
946 priv, &fops_slot);
947 debugfs_create_file("queue", S_IRUSR, priv->debug.debugfs_phy,
948 priv, &fops_queue);
949 debugfs_create_file("debug", S_IRUSR | S_IWUSR, priv->debug.debugfs_phy,
950 priv, &fops_debug);
951 debugfs_create_file("base_eeprom", S_IRUSR, priv->debug.debugfs_phy,
952 priv, &fops_base_eeprom);
953 debugfs_create_file("modal_eeprom", S_IRUSR, priv->debug.debugfs_phy,
954 priv, &fops_modal_eeprom);
955
956 return 0;
957 }
linux-next