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