Commit | Line | Data |
---|---|---|
f2c3c952 OR |
1 | /* |
2 | * Copyright (c) 2008-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 "common.h" | |
18 | ||
19 | static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf, | |
20 | size_t count, loff_t *ppos) | |
21 | { | |
22 | struct ath_hw *ah = file->private_data; | |
23 | u32 len = 0, size = 6000; | |
24 | char *buf; | |
25 | size_t retval; | |
26 | ||
27 | buf = kzalloc(size, GFP_KERNEL); | |
28 | if (buf == NULL) | |
29 | return -ENOMEM; | |
30 | ||
31 | len = ah->eep_ops->dump_eeprom(ah, false, buf, len, size); | |
32 | ||
33 | retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
34 | kfree(buf); | |
35 | ||
36 | return retval; | |
37 | } | |
38 | ||
39 | static const struct file_operations fops_modal_eeprom = { | |
40 | .read = read_file_modal_eeprom, | |
41 | .open = simple_open, | |
42 | .owner = THIS_MODULE, | |
43 | .llseek = default_llseek, | |
44 | }; | |
45 | ||
46 | ||
47 | void ath9k_cmn_debug_modal_eeprom(struct dentry *debugfs_phy, | |
48 | struct ath_hw *ah) | |
49 | { | |
50 | debugfs_create_file("modal_eeprom", S_IRUSR, debugfs_phy, ah, | |
51 | &fops_modal_eeprom); | |
52 | } | |
53 | EXPORT_SYMBOL(ath9k_cmn_debug_modal_eeprom); | |
29bf801e OR |
54 | |
55 | static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf, | |
56 | size_t count, loff_t *ppos) | |
57 | { | |
58 | struct ath_hw *ah = file->private_data; | |
59 | u32 len = 0, size = 1500; | |
60 | ssize_t retval = 0; | |
61 | char *buf; | |
62 | ||
63 | buf = kzalloc(size, GFP_KERNEL); | |
64 | if (!buf) | |
65 | return -ENOMEM; | |
66 | ||
67 | len = ah->eep_ops->dump_eeprom(ah, true, buf, len, size); | |
68 | ||
69 | retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
70 | kfree(buf); | |
71 | ||
72 | return retval; | |
73 | } | |
74 | ||
75 | static const struct file_operations fops_base_eeprom = { | |
76 | .read = read_file_base_eeprom, | |
77 | .open = simple_open, | |
78 | .owner = THIS_MODULE, | |
79 | .llseek = default_llseek, | |
80 | }; | |
81 | ||
82 | void ath9k_cmn_debug_base_eeprom(struct dentry *debugfs_phy, | |
83 | struct ath_hw *ah) | |
84 | { | |
85 | debugfs_create_file("base_eeprom", S_IRUSR, debugfs_phy, ah, | |
86 | &fops_base_eeprom); | |
87 | } | |
88 | EXPORT_SYMBOL(ath9k_cmn_debug_base_eeprom); | |
b5a0c86a OR |
89 | |
90 | void ath9k_cmn_debug_stat_rx(struct ath_rx_stats *rxstats, | |
91 | struct ath_rx_status *rs) | |
92 | { | |
93 | #define RX_PHY_ERR_INC(c) rxstats->phy_err_stats[c]++ | |
94 | #define RX_CMN_STAT_INC(c) (rxstats->c++) | |
95 | ||
96 | RX_CMN_STAT_INC(rx_pkts_all); | |
97 | rxstats->rx_bytes_all += rs->rs_datalen; | |
98 | ||
99 | if (rs->rs_status & ATH9K_RXERR_CRC) | |
100 | RX_CMN_STAT_INC(crc_err); | |
101 | if (rs->rs_status & ATH9K_RXERR_DECRYPT) | |
102 | RX_CMN_STAT_INC(decrypt_crc_err); | |
103 | if (rs->rs_status & ATH9K_RXERR_MIC) | |
104 | RX_CMN_STAT_INC(mic_err); | |
105 | if (rs->rs_status & ATH9K_RX_DELIM_CRC_PRE) | |
106 | RX_CMN_STAT_INC(pre_delim_crc_err); | |
107 | if (rs->rs_status & ATH9K_RX_DELIM_CRC_POST) | |
108 | RX_CMN_STAT_INC(post_delim_crc_err); | |
109 | if (rs->rs_status & ATH9K_RX_DECRYPT_BUSY) | |
110 | RX_CMN_STAT_INC(decrypt_busy_err); | |
111 | ||
112 | if (rs->rs_status & ATH9K_RXERR_PHY) { | |
113 | RX_CMN_STAT_INC(phy_err); | |
114 | if (rs->rs_phyerr < ATH9K_PHYERR_MAX) | |
115 | RX_PHY_ERR_INC(rs->rs_phyerr); | |
116 | } | |
117 | ||
118 | #undef RX_CMN_STAT_INC | |
119 | #undef RX_PHY_ERR_INC | |
120 | } | |
121 | EXPORT_SYMBOL(ath9k_cmn_debug_stat_rx); | |
87ea9b0b OR |
122 | |
123 | static ssize_t read_file_recv(struct file *file, char __user *user_buf, | |
124 | size_t count, loff_t *ppos) | |
125 | { | |
126 | #define RXS_ERR(s, e) \ | |
127 | do { \ | |
128 | len += scnprintf(buf + len, size - len, \ | |
129 | "%18s : %10u\n", s, \ | |
130 | rxstats->e); \ | |
131 | } while (0) | |
132 | ||
133 | struct ath_rx_stats *rxstats = file->private_data; | |
134 | char *buf; | |
135 | unsigned int len = 0, size = 1600; | |
136 | ssize_t retval = 0; | |
137 | ||
138 | buf = kzalloc(size, GFP_KERNEL); | |
139 | if (buf == NULL) | |
140 | return -ENOMEM; | |
141 | ||
142 | RXS_ERR("PKTS-ALL", rx_pkts_all); | |
143 | RXS_ERR("BYTES-ALL", rx_bytes_all); | |
144 | RXS_ERR("BEACONS", rx_beacons); | |
145 | RXS_ERR("FRAGS", rx_frags); | |
146 | RXS_ERR("SPECTRAL", rx_spectral); | |
147 | ||
148 | RXS_ERR("CRC ERR", crc_err); | |
149 | RXS_ERR("DECRYPT CRC ERR", decrypt_crc_err); | |
150 | RXS_ERR("PHY ERR", phy_err); | |
151 | RXS_ERR("MIC ERR", mic_err); | |
152 | RXS_ERR("PRE-DELIM CRC ERR", pre_delim_crc_err); | |
153 | RXS_ERR("POST-DELIM CRC ERR", post_delim_crc_err); | |
154 | RXS_ERR("DECRYPT BUSY ERR", decrypt_busy_err); | |
155 | RXS_ERR("LENGTH-ERR", rx_len_err); | |
156 | RXS_ERR("OOM-ERR", rx_oom_err); | |
157 | RXS_ERR("RATE-ERR", rx_rate_err); | |
158 | RXS_ERR("TOO-MANY-FRAGS", rx_too_many_frags_err); | |
159 | ||
160 | if (len > size) | |
161 | len = size; | |
162 | ||
163 | retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
164 | kfree(buf); | |
165 | ||
166 | return retval; | |
167 | ||
168 | #undef RXS_ERR | |
169 | } | |
170 | ||
171 | static const struct file_operations fops_recv = { | |
172 | .read = read_file_recv, | |
173 | .open = simple_open, | |
174 | .owner = THIS_MODULE, | |
175 | .llseek = default_llseek, | |
176 | }; | |
177 | ||
178 | void ath9k_cmn_debug_recv(struct dentry *debugfs_phy, | |
179 | struct ath_rx_stats *rxstats) | |
180 | { | |
181 | debugfs_create_file("recv", S_IRUSR, debugfs_phy, rxstats, | |
182 | &fops_recv); | |
183 | } | |
184 | EXPORT_SYMBOL(ath9k_cmn_debug_recv); | |
e02912cd OR |
185 | |
186 | static ssize_t read_file_phy_err(struct file *file, char __user *user_buf, | |
187 | size_t count, loff_t *ppos) | |
188 | { | |
189 | #define PHY_ERR(s, p) \ | |
190 | len += scnprintf(buf + len, size - len, "%22s : %10u\n", s, \ | |
191 | rxstats->phy_err_stats[p]); | |
192 | ||
193 | struct ath_rx_stats *rxstats = file->private_data; | |
194 | char *buf; | |
195 | unsigned int len = 0, size = 1600; | |
196 | ssize_t retval = 0; | |
197 | ||
198 | buf = kzalloc(size, GFP_KERNEL); | |
199 | if (buf == NULL) | |
200 | return -ENOMEM; | |
201 | ||
202 | PHY_ERR("UNDERRUN ERR", ATH9K_PHYERR_UNDERRUN); | |
203 | PHY_ERR("TIMING ERR", ATH9K_PHYERR_TIMING); | |
204 | PHY_ERR("PARITY ERR", ATH9K_PHYERR_PARITY); | |
205 | PHY_ERR("RATE ERR", ATH9K_PHYERR_RATE); | |
206 | PHY_ERR("LENGTH ERR", ATH9K_PHYERR_LENGTH); | |
207 | PHY_ERR("RADAR ERR", ATH9K_PHYERR_RADAR); | |
208 | PHY_ERR("SERVICE ERR", ATH9K_PHYERR_SERVICE); | |
209 | PHY_ERR("TOR ERR", ATH9K_PHYERR_TOR); | |
56bae464 | 210 | |
e02912cd OR |
211 | PHY_ERR("OFDM-TIMING ERR", ATH9K_PHYERR_OFDM_TIMING); |
212 | PHY_ERR("OFDM-SIGNAL-PARITY ERR", ATH9K_PHYERR_OFDM_SIGNAL_PARITY); | |
213 | PHY_ERR("OFDM-RATE ERR", ATH9K_PHYERR_OFDM_RATE_ILLEGAL); | |
214 | PHY_ERR("OFDM-LENGTH ERR", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL); | |
215 | PHY_ERR("OFDM-POWER-DROP ERR", ATH9K_PHYERR_OFDM_POWER_DROP); | |
216 | PHY_ERR("OFDM-SERVICE ERR", ATH9K_PHYERR_OFDM_SERVICE); | |
217 | PHY_ERR("OFDM-RESTART ERR", ATH9K_PHYERR_OFDM_RESTART); | |
56bae464 ZK |
218 | |
219 | PHY_ERR("CCK-BLOCKER ERR", ATH9K_PHYERR_CCK_BLOCKER); | |
e02912cd OR |
220 | PHY_ERR("CCK-TIMING ERR", ATH9K_PHYERR_CCK_TIMING); |
221 | PHY_ERR("CCK-HEADER-CRC ERR", ATH9K_PHYERR_CCK_HEADER_CRC); | |
222 | PHY_ERR("CCK-RATE ERR", ATH9K_PHYERR_CCK_RATE_ILLEGAL); | |
e02912cd OR |
223 | PHY_ERR("CCK-LENGTH ERR", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL); |
224 | PHY_ERR("CCK-POWER-DROP ERR", ATH9K_PHYERR_CCK_POWER_DROP); | |
56bae464 ZK |
225 | PHY_ERR("CCK-SERVICE ERR", ATH9K_PHYERR_CCK_SERVICE); |
226 | PHY_ERR("CCK-RESTART ERR", ATH9K_PHYERR_CCK_RESTART); | |
227 | ||
e02912cd OR |
228 | PHY_ERR("HT-CRC ERR", ATH9K_PHYERR_HT_CRC_ERROR); |
229 | PHY_ERR("HT-LENGTH ERR", ATH9K_PHYERR_HT_LENGTH_ILLEGAL); | |
230 | PHY_ERR("HT-RATE ERR", ATH9K_PHYERR_HT_RATE_ILLEGAL); | |
56bae464 ZK |
231 | PHY_ERR("HT-ZLF ERR", ATH9K_PHYERR_HT_ZLF); |
232 | ||
233 | PHY_ERR("FALSE-RADAR-EXT ERR", ATH9K_PHYERR_FALSE_RADAR_EXT); | |
234 | PHY_ERR("GREEN-FIELD ERR", ATH9K_PHYERR_GREEN_FIELD); | |
235 | PHY_ERR("SPECTRAL ERR", ATH9K_PHYERR_SPECTRAL); | |
e02912cd OR |
236 | |
237 | if (len > size) | |
238 | len = size; | |
239 | ||
240 | retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
241 | kfree(buf); | |
242 | ||
243 | return retval; | |
244 | ||
245 | #undef PHY_ERR | |
246 | } | |
247 | ||
248 | static const struct file_operations fops_phy_err = { | |
249 | .read = read_file_phy_err, | |
250 | .open = simple_open, | |
251 | .owner = THIS_MODULE, | |
252 | .llseek = default_llseek, | |
253 | }; | |
254 | ||
255 | void ath9k_cmn_debug_phy_err(struct dentry *debugfs_phy, | |
256 | struct ath_rx_stats *rxstats) | |
257 | { | |
258 | debugfs_create_file("phy_err", S_IRUSR, debugfs_phy, rxstats, | |
259 | &fops_phy_err); | |
260 | } | |
261 | EXPORT_SYMBOL(ath9k_cmn_debug_phy_err); |