debug.c 55 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952
  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. #include <linux/slab.h>
  17. #include <linux/vmalloc.h>
  18. #include <linux/export.h>
  19. #include <linux/relay.h>
  20. #include <asm/unaligned.h>
  21. #include "ath9k.h"
  22. #define REG_WRITE_D(_ah, _reg, _val) \
  23. ath9k_hw_common(_ah)->ops->write((_ah), (_val), (_reg))
  24. #define REG_READ_D(_ah, _reg) \
  25. ath9k_hw_common(_ah)->ops->read((_ah), (_reg))
  26. static ssize_t ath9k_debugfs_read_buf(struct file *file, char __user *user_buf,
  27. size_t count, loff_t *ppos)
  28. {
  29. u8 *buf = file->private_data;
  30. return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
  31. }
  32. static int ath9k_debugfs_release_buf(struct inode *inode, struct file *file)
  33. {
  34. vfree(file->private_data);
  35. return 0;
  36. }
  37. #ifdef CONFIG_ATH_DEBUG
  38. static ssize_t read_file_debug(struct file *file, char __user *user_buf,
  39. size_t count, loff_t *ppos)
  40. {
  41. struct ath_softc *sc = file->private_data;
  42. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  43. char buf[32];
  44. unsigned int len;
  45. len = sprintf(buf, "0x%08x\n", common->debug_mask);
  46. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  47. }
  48. static ssize_t write_file_debug(struct file *file, const char __user *user_buf,
  49. size_t count, loff_t *ppos)
  50. {
  51. struct ath_softc *sc = file->private_data;
  52. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  53. unsigned long mask;
  54. char buf[32];
  55. ssize_t len;
  56. len = min(count, sizeof(buf) - 1);
  57. if (copy_from_user(buf, user_buf, len))
  58. return -EFAULT;
  59. buf[len] = '\0';
  60. if (kstrtoul(buf, 0, &mask))
  61. return -EINVAL;
  62. common->debug_mask = mask;
  63. return count;
  64. }
  65. static const struct file_operations fops_debug = {
  66. .read = read_file_debug,
  67. .write = write_file_debug,
  68. .open = simple_open,
  69. .owner = THIS_MODULE,
  70. .llseek = default_llseek,
  71. };
  72. #endif
  73. #define DMA_BUF_LEN 1024
  74. static ssize_t read_file_tx_chainmask(struct file *file, char __user *user_buf,
  75. size_t count, loff_t *ppos)
  76. {
  77. struct ath_softc *sc = file->private_data;
  78. struct ath_hw *ah = sc->sc_ah;
  79. char buf[32];
  80. unsigned int len;
  81. len = sprintf(buf, "0x%08x\n", ah->txchainmask);
  82. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  83. }
  84. static ssize_t write_file_tx_chainmask(struct file *file, const char __user *user_buf,
  85. size_t count, loff_t *ppos)
  86. {
  87. struct ath_softc *sc = file->private_data;
  88. struct ath_hw *ah = sc->sc_ah;
  89. unsigned long mask;
  90. char buf[32];
  91. ssize_t len;
  92. len = min(count, sizeof(buf) - 1);
  93. if (copy_from_user(buf, user_buf, len))
  94. return -EFAULT;
  95. buf[len] = '\0';
  96. if (kstrtoul(buf, 0, &mask))
  97. return -EINVAL;
  98. ah->txchainmask = mask;
  99. ah->caps.tx_chainmask = mask;
  100. return count;
  101. }
  102. static const struct file_operations fops_tx_chainmask = {
  103. .read = read_file_tx_chainmask,
  104. .write = write_file_tx_chainmask,
  105. .open = simple_open,
  106. .owner = THIS_MODULE,
  107. .llseek = default_llseek,
  108. };
  109. static ssize_t read_file_rx_chainmask(struct file *file, char __user *user_buf,
  110. size_t count, loff_t *ppos)
  111. {
  112. struct ath_softc *sc = file->private_data;
  113. struct ath_hw *ah = sc->sc_ah;
  114. char buf[32];
  115. unsigned int len;
  116. len = sprintf(buf, "0x%08x\n", ah->rxchainmask);
  117. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  118. }
  119. static ssize_t write_file_rx_chainmask(struct file *file, const char __user *user_buf,
  120. size_t count, loff_t *ppos)
  121. {
  122. struct ath_softc *sc = file->private_data;
  123. struct ath_hw *ah = sc->sc_ah;
  124. unsigned long mask;
  125. char buf[32];
  126. ssize_t len;
  127. len = min(count, sizeof(buf) - 1);
  128. if (copy_from_user(buf, user_buf, len))
  129. return -EFAULT;
  130. buf[len] = '\0';
  131. if (kstrtoul(buf, 0, &mask))
  132. return -EINVAL;
  133. ah->rxchainmask = mask;
  134. ah->caps.rx_chainmask = mask;
  135. return count;
  136. }
  137. static const struct file_operations fops_rx_chainmask = {
  138. .read = read_file_rx_chainmask,
  139. .write = write_file_rx_chainmask,
  140. .open = simple_open,
  141. .owner = THIS_MODULE,
  142. .llseek = default_llseek,
  143. };
  144. static ssize_t read_file_ani(struct file *file, char __user *user_buf,
  145. size_t count, loff_t *ppos)
  146. {
  147. struct ath_softc *sc = file->private_data;
  148. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  149. struct ath_hw *ah = sc->sc_ah;
  150. unsigned int len = 0, size = 1024;
  151. ssize_t retval = 0;
  152. char *buf;
  153. buf = kzalloc(size, GFP_KERNEL);
  154. if (buf == NULL)
  155. return -ENOMEM;
  156. if (common->disable_ani) {
  157. len += snprintf(buf + len, size - len, "%s: %s\n",
  158. "ANI", "DISABLED");
  159. goto exit;
  160. }
  161. len += snprintf(buf + len, size - len, "%15s: %s\n",
  162. "ANI", "ENABLED");
  163. len += snprintf(buf + len, size - len, "%15s: %u\n",
  164. "ANI RESET", ah->stats.ast_ani_reset);
  165. len += snprintf(buf + len, size - len, "%15s: %u\n",
  166. "SPUR UP", ah->stats.ast_ani_spurup);
  167. len += snprintf(buf + len, size - len, "%15s: %u\n",
  168. "SPUR DOWN", ah->stats.ast_ani_spurup);
  169. len += snprintf(buf + len, size - len, "%15s: %u\n",
  170. "OFDM WS-DET ON", ah->stats.ast_ani_ofdmon);
  171. len += snprintf(buf + len, size - len, "%15s: %u\n",
  172. "OFDM WS-DET OFF", ah->stats.ast_ani_ofdmoff);
  173. len += snprintf(buf + len, size - len, "%15s: %u\n",
  174. "MRC-CCK ON", ah->stats.ast_ani_ccklow);
  175. len += snprintf(buf + len, size - len, "%15s: %u\n",
  176. "MRC-CCK OFF", ah->stats.ast_ani_cckhigh);
  177. len += snprintf(buf + len, size - len, "%15s: %u\n",
  178. "FIR-STEP UP", ah->stats.ast_ani_stepup);
  179. len += snprintf(buf + len, size - len, "%15s: %u\n",
  180. "FIR-STEP DOWN", ah->stats.ast_ani_stepdown);
  181. len += snprintf(buf + len, size - len, "%15s: %u\n",
  182. "INV LISTENTIME", ah->stats.ast_ani_lneg_or_lzero);
  183. len += snprintf(buf + len, size - len, "%15s: %u\n",
  184. "OFDM ERRORS", ah->stats.ast_ani_ofdmerrs);
  185. len += snprintf(buf + len, size - len, "%15s: %u\n",
  186. "CCK ERRORS", ah->stats.ast_ani_cckerrs);
  187. exit:
  188. if (len > size)
  189. len = size;
  190. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  191. kfree(buf);
  192. return retval;
  193. }
  194. static ssize_t write_file_ani(struct file *file,
  195. const char __user *user_buf,
  196. size_t count, loff_t *ppos)
  197. {
  198. struct ath_softc *sc = file->private_data;
  199. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  200. unsigned long ani;
  201. char buf[32];
  202. ssize_t len;
  203. len = min(count, sizeof(buf) - 1);
  204. if (copy_from_user(buf, user_buf, len))
  205. return -EFAULT;
  206. buf[len] = '\0';
  207. if (kstrtoul(buf, 0, &ani))
  208. return -EINVAL;
  209. if (ani < 0 || ani > 1)
  210. return -EINVAL;
  211. common->disable_ani = !ani;
  212. if (common->disable_ani) {
  213. clear_bit(SC_OP_ANI_RUN, &sc->sc_flags);
  214. ath_stop_ani(sc);
  215. } else {
  216. ath_check_ani(sc);
  217. }
  218. return count;
  219. }
  220. static const struct file_operations fops_ani = {
  221. .read = read_file_ani,
  222. .write = write_file_ani,
  223. .open = simple_open,
  224. .owner = THIS_MODULE,
  225. .llseek = default_llseek,
  226. };
  227. #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
  228. static ssize_t read_file_bt_ant_diversity(struct file *file,
  229. char __user *user_buf,
  230. size_t count, loff_t *ppos)
  231. {
  232. struct ath_softc *sc = file->private_data;
  233. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  234. char buf[32];
  235. unsigned int len;
  236. len = sprintf(buf, "%d\n", common->bt_ant_diversity);
  237. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  238. }
  239. static ssize_t write_file_bt_ant_diversity(struct file *file,
  240. const char __user *user_buf,
  241. size_t count, loff_t *ppos)
  242. {
  243. struct ath_softc *sc = file->private_data;
  244. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  245. struct ath9k_hw_capabilities *pCap = &sc->sc_ah->caps;
  246. unsigned long bt_ant_diversity;
  247. char buf[32];
  248. ssize_t len;
  249. len = min(count, sizeof(buf) - 1);
  250. if (copy_from_user(buf, user_buf, len))
  251. return -EFAULT;
  252. if (!(pCap->hw_caps & ATH9K_HW_CAP_BT_ANT_DIV))
  253. goto exit;
  254. buf[len] = '\0';
  255. if (kstrtoul(buf, 0, &bt_ant_diversity))
  256. return -EINVAL;
  257. common->bt_ant_diversity = !!bt_ant_diversity;
  258. ath9k_ps_wakeup(sc);
  259. ath9k_hw_set_bt_ant_diversity(sc->sc_ah, common->bt_ant_diversity);
  260. ath_dbg(common, CONFIG, "Enable WLAN/BT RX Antenna diversity: %d\n",
  261. common->bt_ant_diversity);
  262. ath9k_ps_restore(sc);
  263. exit:
  264. return count;
  265. }
  266. static const struct file_operations fops_bt_ant_diversity = {
  267. .read = read_file_bt_ant_diversity,
  268. .write = write_file_bt_ant_diversity,
  269. .open = simple_open,
  270. .owner = THIS_MODULE,
  271. .llseek = default_llseek,
  272. };
  273. #endif
  274. void ath9k_debug_stat_ant(struct ath_softc *sc,
  275. struct ath_hw_antcomb_conf *div_ant_conf,
  276. int main_rssi_avg, int alt_rssi_avg)
  277. {
  278. struct ath_antenna_stats *as_main = &sc->debug.stats.ant_stats[ANT_MAIN];
  279. struct ath_antenna_stats *as_alt = &sc->debug.stats.ant_stats[ANT_ALT];
  280. as_main->lna_attempt_cnt[div_ant_conf->main_lna_conf]++;
  281. as_alt->lna_attempt_cnt[div_ant_conf->alt_lna_conf]++;
  282. as_main->rssi_avg = main_rssi_avg;
  283. as_alt->rssi_avg = alt_rssi_avg;
  284. }
  285. static ssize_t read_file_antenna_diversity(struct file *file,
  286. char __user *user_buf,
  287. size_t count, loff_t *ppos)
  288. {
  289. struct ath_softc *sc = file->private_data;
  290. struct ath_hw *ah = sc->sc_ah;
  291. struct ath9k_hw_capabilities *pCap = &ah->caps;
  292. struct ath_antenna_stats *as_main = &sc->debug.stats.ant_stats[ANT_MAIN];
  293. struct ath_antenna_stats *as_alt = &sc->debug.stats.ant_stats[ANT_ALT];
  294. struct ath_hw_antcomb_conf div_ant_conf;
  295. unsigned int len = 0, size = 1024;
  296. ssize_t retval = 0;
  297. char *buf;
  298. char *lna_conf_str[4] = {"LNA1_MINUS_LNA2",
  299. "LNA2",
  300. "LNA1",
  301. "LNA1_PLUS_LNA2"};
  302. buf = kzalloc(size, GFP_KERNEL);
  303. if (buf == NULL)
  304. return -ENOMEM;
  305. if (!(pCap->hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)) {
  306. len += snprintf(buf + len, size - len, "%s\n",
  307. "Antenna Diversity Combining is disabled");
  308. goto exit;
  309. }
  310. ath9k_ps_wakeup(sc);
  311. ath9k_hw_antdiv_comb_conf_get(ah, &div_ant_conf);
  312. len += snprintf(buf + len, size - len, "Current MAIN config : %s\n",
  313. lna_conf_str[div_ant_conf.main_lna_conf]);
  314. len += snprintf(buf + len, size - len, "Current ALT config : %s\n",
  315. lna_conf_str[div_ant_conf.alt_lna_conf]);
  316. len += snprintf(buf + len, size - len, "Average MAIN RSSI : %d\n",
  317. as_main->rssi_avg);
  318. len += snprintf(buf + len, size - len, "Average ALT RSSI : %d\n\n",
  319. as_alt->rssi_avg);
  320. ath9k_ps_restore(sc);
  321. len += snprintf(buf + len, size - len, "Packet Receive Cnt:\n");
  322. len += snprintf(buf + len, size - len, "-------------------\n");
  323. len += snprintf(buf + len, size - len, "%30s%15s\n",
  324. "MAIN", "ALT");
  325. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  326. "TOTAL COUNT",
  327. as_main->recv_cnt,
  328. as_alt->recv_cnt);
  329. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  330. "LNA1",
  331. as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1],
  332. as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1]);
  333. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  334. "LNA2",
  335. as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA2],
  336. as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA2]);
  337. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  338. "LNA1 + LNA2",
  339. as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2],
  340. as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2]);
  341. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  342. "LNA1 - LNA2",
  343. as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2],
  344. as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2]);
  345. len += snprintf(buf + len, size - len, "\nLNA Config Attempts:\n");
  346. len += snprintf(buf + len, size - len, "--------------------\n");
  347. len += snprintf(buf + len, size - len, "%30s%15s\n",
  348. "MAIN", "ALT");
  349. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  350. "LNA1",
  351. as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1],
  352. as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1]);
  353. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  354. "LNA2",
  355. as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA2],
  356. as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA2]);
  357. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  358. "LNA1 + LNA2",
  359. as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2],
  360. as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2]);
  361. len += snprintf(buf + len, size - len, "%-14s:%15d%15d\n",
  362. "LNA1 - LNA2",
  363. as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2],
  364. as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2]);
  365. exit:
  366. if (len > size)
  367. len = size;
  368. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  369. kfree(buf);
  370. return retval;
  371. }
  372. static const struct file_operations fops_antenna_diversity = {
  373. .read = read_file_antenna_diversity,
  374. .open = simple_open,
  375. .owner = THIS_MODULE,
  376. .llseek = default_llseek,
  377. };
  378. static ssize_t read_file_dma(struct file *file, char __user *user_buf,
  379. size_t count, loff_t *ppos)
  380. {
  381. struct ath_softc *sc = file->private_data;
  382. struct ath_hw *ah = sc->sc_ah;
  383. char *buf;
  384. int retval;
  385. unsigned int len = 0;
  386. u32 val[ATH9K_NUM_DMA_DEBUG_REGS];
  387. int i, qcuOffset = 0, dcuOffset = 0;
  388. u32 *qcuBase = &val[0], *dcuBase = &val[4];
  389. buf = kmalloc(DMA_BUF_LEN, GFP_KERNEL);
  390. if (!buf)
  391. return -ENOMEM;
  392. ath9k_ps_wakeup(sc);
  393. REG_WRITE_D(ah, AR_MACMISC,
  394. ((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) |
  395. (AR_MACMISC_MISC_OBS_BUS_1 <<
  396. AR_MACMISC_MISC_OBS_BUS_MSB_S)));
  397. len += snprintf(buf + len, DMA_BUF_LEN - len,
  398. "Raw DMA Debug values:\n");
  399. for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) {
  400. if (i % 4 == 0)
  401. len += snprintf(buf + len, DMA_BUF_LEN - len, "\n");
  402. val[i] = REG_READ_D(ah, AR_DMADBG_0 + (i * sizeof(u32)));
  403. len += snprintf(buf + len, DMA_BUF_LEN - len, "%d: %08x ",
  404. i, val[i]);
  405. }
  406. len += snprintf(buf + len, DMA_BUF_LEN - len, "\n\n");
  407. len += snprintf(buf + len, DMA_BUF_LEN - len,
  408. "Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");
  409. for (i = 0; i < ATH9K_NUM_QUEUES; i++, qcuOffset += 4, dcuOffset += 5) {
  410. if (i == 8) {
  411. qcuOffset = 0;
  412. qcuBase++;
  413. }
  414. if (i == 6) {
  415. dcuOffset = 0;
  416. dcuBase++;
  417. }
  418. len += snprintf(buf + len, DMA_BUF_LEN - len,
  419. "%2d %2x %1x %2x %2x\n",
  420. i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset,
  421. (*qcuBase & (0x8 << qcuOffset)) >> (qcuOffset + 3),
  422. val[2] & (0x7 << (i * 3)) >> (i * 3),
  423. (*dcuBase & (0x1f << dcuOffset)) >> dcuOffset);
  424. }
  425. len += snprintf(buf + len, DMA_BUF_LEN - len, "\n");
  426. len += snprintf(buf + len, DMA_BUF_LEN - len,
  427. "qcu_stitch state: %2x qcu_fetch state: %2x\n",
  428. (val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22);
  429. len += snprintf(buf + len, DMA_BUF_LEN - len,
  430. "qcu_complete state: %2x dcu_complete state: %2x\n",
  431. (val[3] & 0x1c000000) >> 26, (val[6] & 0x3));
  432. len += snprintf(buf + len, DMA_BUF_LEN - len,
  433. "dcu_arb state: %2x dcu_fp state: %2x\n",
  434. (val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27);
  435. len += snprintf(buf + len, DMA_BUF_LEN - len,
  436. "chan_idle_dur: %3d chan_idle_dur_valid: %1d\n",
  437. (val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10);
  438. len += snprintf(buf + len, DMA_BUF_LEN - len,
  439. "txfifo_valid_0: %1d txfifo_valid_1: %1d\n",
  440. (val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12);
  441. len += snprintf(buf + len, DMA_BUF_LEN - len,
  442. "txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n",
  443. (val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17);
  444. len += snprintf(buf + len, DMA_BUF_LEN - len, "pcu observe: 0x%x\n",
  445. REG_READ_D(ah, AR_OBS_BUS_1));
  446. len += snprintf(buf + len, DMA_BUF_LEN - len,
  447. "AR_CR: 0x%x\n", REG_READ_D(ah, AR_CR));
  448. ath9k_ps_restore(sc);
  449. if (len > DMA_BUF_LEN)
  450. len = DMA_BUF_LEN;
  451. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  452. kfree(buf);
  453. return retval;
  454. }
  455. static const struct file_operations fops_dma = {
  456. .read = read_file_dma,
  457. .open = simple_open,
  458. .owner = THIS_MODULE,
  459. .llseek = default_llseek,
  460. };
  461. void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status)
  462. {
  463. if (status)
  464. sc->debug.stats.istats.total++;
  465. if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
  466. if (status & ATH9K_INT_RXLP)
  467. sc->debug.stats.istats.rxlp++;
  468. if (status & ATH9K_INT_RXHP)
  469. sc->debug.stats.istats.rxhp++;
  470. if (status & ATH9K_INT_BB_WATCHDOG)
  471. sc->debug.stats.istats.bb_watchdog++;
  472. } else {
  473. if (status & ATH9K_INT_RX)
  474. sc->debug.stats.istats.rxok++;
  475. }
  476. if (status & ATH9K_INT_RXEOL)
  477. sc->debug.stats.istats.rxeol++;
  478. if (status & ATH9K_INT_RXORN)
  479. sc->debug.stats.istats.rxorn++;
  480. if (status & ATH9K_INT_TX)
  481. sc->debug.stats.istats.txok++;
  482. if (status & ATH9K_INT_TXURN)
  483. sc->debug.stats.istats.txurn++;
  484. if (status & ATH9K_INT_RXPHY)
  485. sc->debug.stats.istats.rxphyerr++;
  486. if (status & ATH9K_INT_RXKCM)
  487. sc->debug.stats.istats.rx_keycache_miss++;
  488. if (status & ATH9K_INT_SWBA)
  489. sc->debug.stats.istats.swba++;
  490. if (status & ATH9K_INT_BMISS)
  491. sc->debug.stats.istats.bmiss++;
  492. if (status & ATH9K_INT_BNR)
  493. sc->debug.stats.istats.bnr++;
  494. if (status & ATH9K_INT_CST)
  495. sc->debug.stats.istats.cst++;
  496. if (status & ATH9K_INT_GTT)
  497. sc->debug.stats.istats.gtt++;
  498. if (status & ATH9K_INT_TIM)
  499. sc->debug.stats.istats.tim++;
  500. if (status & ATH9K_INT_CABEND)
  501. sc->debug.stats.istats.cabend++;
  502. if (status & ATH9K_INT_DTIMSYNC)
  503. sc->debug.stats.istats.dtimsync++;
  504. if (status & ATH9K_INT_DTIM)
  505. sc->debug.stats.istats.dtim++;
  506. if (status & ATH9K_INT_TSFOOR)
  507. sc->debug.stats.istats.tsfoor++;
  508. if (status & ATH9K_INT_MCI)
  509. sc->debug.stats.istats.mci++;
  510. if (status & ATH9K_INT_GENTIMER)
  511. sc->debug.stats.istats.gen_timer++;
  512. }
  513. static ssize_t read_file_interrupt(struct file *file, char __user *user_buf,
  514. size_t count, loff_t *ppos)
  515. {
  516. struct ath_softc *sc = file->private_data;
  517. unsigned int len = 0;
  518. int rv;
  519. int mxlen = 4000;
  520. char *buf = kmalloc(mxlen, GFP_KERNEL);
  521. if (!buf)
  522. return -ENOMEM;
  523. #define PR_IS(a, s) \
  524. do { \
  525. len += snprintf(buf + len, mxlen - len, \
  526. "%21s: %10u\n", a, \
  527. sc->debug.stats.istats.s); \
  528. } while (0)
  529. if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
  530. PR_IS("RXLP", rxlp);
  531. PR_IS("RXHP", rxhp);
  532. PR_IS("WATHDOG", bb_watchdog);
  533. } else {
  534. PR_IS("RX", rxok);
  535. }
  536. PR_IS("RXEOL", rxeol);
  537. PR_IS("RXORN", rxorn);
  538. PR_IS("TX", txok);
  539. PR_IS("TXURN", txurn);
  540. PR_IS("MIB", mib);
  541. PR_IS("RXPHY", rxphyerr);
  542. PR_IS("RXKCM", rx_keycache_miss);
  543. PR_IS("SWBA", swba);
  544. PR_IS("BMISS", bmiss);
  545. PR_IS("BNR", bnr);
  546. PR_IS("CST", cst);
  547. PR_IS("GTT", gtt);
  548. PR_IS("TIM", tim);
  549. PR_IS("CABEND", cabend);
  550. PR_IS("DTIMSYNC", dtimsync);
  551. PR_IS("DTIM", dtim);
  552. PR_IS("TSFOOR", tsfoor);
  553. PR_IS("MCI", mci);
  554. PR_IS("GENTIMER", gen_timer);
  555. PR_IS("TOTAL", total);
  556. len += snprintf(buf + len, mxlen - len,
  557. "SYNC_CAUSE stats:\n");
  558. PR_IS("Sync-All", sync_cause_all);
  559. PR_IS("RTC-IRQ", sync_rtc_irq);
  560. PR_IS("MAC-IRQ", sync_mac_irq);
  561. PR_IS("EEPROM-Illegal-Access", eeprom_illegal_access);
  562. PR_IS("APB-Timeout", apb_timeout);
  563. PR_IS("PCI-Mode-Conflict", pci_mode_conflict);
  564. PR_IS("HOST1-Fatal", host1_fatal);
  565. PR_IS("HOST1-Perr", host1_perr);
  566. PR_IS("TRCV-FIFO-Perr", trcv_fifo_perr);
  567. PR_IS("RADM-CPL-EP", radm_cpl_ep);
  568. PR_IS("RADM-CPL-DLLP-Abort", radm_cpl_dllp_abort);
  569. PR_IS("RADM-CPL-TLP-Abort", radm_cpl_tlp_abort);
  570. PR_IS("RADM-CPL-ECRC-Err", radm_cpl_ecrc_err);
  571. PR_IS("RADM-CPL-Timeout", radm_cpl_timeout);
  572. PR_IS("Local-Bus-Timeout", local_timeout);
  573. PR_IS("PM-Access", pm_access);
  574. PR_IS("MAC-Awake", mac_awake);
  575. PR_IS("MAC-Asleep", mac_asleep);
  576. PR_IS("MAC-Sleep-Access", mac_sleep_access);
  577. if (len > mxlen)
  578. len = mxlen;
  579. rv = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  580. kfree(buf);
  581. return rv;
  582. }
  583. static const struct file_operations fops_interrupt = {
  584. .read = read_file_interrupt,
  585. .open = simple_open,
  586. .owner = THIS_MODULE,
  587. .llseek = default_llseek,
  588. };
  589. static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
  590. size_t count, loff_t *ppos)
  591. {
  592. struct ath_softc *sc = file->private_data;
  593. char *buf;
  594. unsigned int len = 0, size = 2048;
  595. ssize_t retval = 0;
  596. buf = kzalloc(size, GFP_KERNEL);
  597. if (buf == NULL)
  598. return -ENOMEM;
  599. len += sprintf(buf, "%30s %10s%10s%10s\n\n",
  600. "BE", "BK", "VI", "VO");
  601. PR("MPDUs Queued: ", queued);
  602. PR("MPDUs Completed: ", completed);
  603. PR("MPDUs XRetried: ", xretries);
  604. PR("Aggregates: ", a_aggr);
  605. PR("AMPDUs Queued HW:", a_queued_hw);
  606. PR("AMPDUs Queued SW:", a_queued_sw);
  607. PR("AMPDUs Completed:", a_completed);
  608. PR("AMPDUs Retried: ", a_retries);
  609. PR("AMPDUs XRetried: ", a_xretries);
  610. PR("TXERR Filtered: ", txerr_filtered);
  611. PR("FIFO Underrun: ", fifo_underrun);
  612. PR("TXOP Exceeded: ", xtxop);
  613. PR("TXTIMER Expiry: ", timer_exp);
  614. PR("DESC CFG Error: ", desc_cfg_err);
  615. PR("DATA Underrun: ", data_underrun);
  616. PR("DELIM Underrun: ", delim_underrun);
  617. PR("TX-Pkts-All: ", tx_pkts_all);
  618. PR("TX-Bytes-All: ", tx_bytes_all);
  619. PR("HW-put-tx-buf: ", puttxbuf);
  620. PR("HW-tx-start: ", txstart);
  621. PR("HW-tx-proc-desc: ", txprocdesc);
  622. PR("TX-Failed: ", txfailed);
  623. if (len > size)
  624. len = size;
  625. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  626. kfree(buf);
  627. return retval;
  628. }
  629. static ssize_t print_queue(struct ath_softc *sc, struct ath_txq *txq,
  630. char *buf, ssize_t size)
  631. {
  632. ssize_t len = 0;
  633. ath_txq_lock(sc, txq);
  634. len += snprintf(buf + len, size - len, "%s: %d ",
  635. "qnum", txq->axq_qnum);
  636. len += snprintf(buf + len, size - len, "%s: %2d ",
  637. "qdepth", txq->axq_depth);
  638. len += snprintf(buf + len, size - len, "%s: %2d ",
  639. "ampdu-depth", txq->axq_ampdu_depth);
  640. len += snprintf(buf + len, size - len, "%s: %3d ",
  641. "pending", txq->pending_frames);
  642. len += snprintf(buf + len, size - len, "%s: %d\n",
  643. "stopped", txq->stopped);
  644. ath_txq_unlock(sc, txq);
  645. return len;
  646. }
  647. static ssize_t read_file_queues(struct file *file, char __user *user_buf,
  648. size_t count, loff_t *ppos)
  649. {
  650. struct ath_softc *sc = file->private_data;
  651. struct ath_txq *txq;
  652. char *buf;
  653. unsigned int len = 0, size = 1024;
  654. ssize_t retval = 0;
  655. int i;
  656. char *qname[4] = {"VO", "VI", "BE", "BK"};
  657. buf = kzalloc(size, GFP_KERNEL);
  658. if (buf == NULL)
  659. return -ENOMEM;
  660. for (i = 0; i < IEEE80211_NUM_ACS; i++) {
  661. txq = sc->tx.txq_map[i];
  662. len += snprintf(buf + len, size - len, "(%s): ", qname[i]);
  663. len += print_queue(sc, txq, buf + len, size - len);
  664. }
  665. len += snprintf(buf + len, size - len, "(CAB): ");
  666. len += print_queue(sc, sc->beacon.cabq, buf + len, size - len);
  667. if (len > size)
  668. len = size;
  669. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  670. kfree(buf);
  671. return retval;
  672. }
  673. static ssize_t read_file_misc(struct file *file, char __user *user_buf,
  674. size_t count, loff_t *ppos)
  675. {
  676. struct ath_softc *sc = file->private_data;
  677. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  678. struct ieee80211_hw *hw = sc->hw;
  679. struct ath9k_vif_iter_data iter_data;
  680. char buf[512];
  681. unsigned int len = 0;
  682. ssize_t retval = 0;
  683. unsigned int reg;
  684. u32 rxfilter;
  685. len += snprintf(buf + len, sizeof(buf) - len,
  686. "BSSID: %pM\n", common->curbssid);
  687. len += snprintf(buf + len, sizeof(buf) - len,
  688. "BSSID-MASK: %pM\n", common->bssidmask);
  689. len += snprintf(buf + len, sizeof(buf) - len,
  690. "OPMODE: %s\n", ath_opmode_to_string(sc->sc_ah->opmode));
  691. ath9k_ps_wakeup(sc);
  692. rxfilter = ath9k_hw_getrxfilter(sc->sc_ah);
  693. ath9k_ps_restore(sc);
  694. len += snprintf(buf + len, sizeof(buf) - len,
  695. "RXFILTER: 0x%x", rxfilter);
  696. if (rxfilter & ATH9K_RX_FILTER_UCAST)
  697. len += snprintf(buf + len, sizeof(buf) - len, " UCAST");
  698. if (rxfilter & ATH9K_RX_FILTER_MCAST)
  699. len += snprintf(buf + len, sizeof(buf) - len, " MCAST");
  700. if (rxfilter & ATH9K_RX_FILTER_BCAST)
  701. len += snprintf(buf + len, sizeof(buf) - len, " BCAST");
  702. if (rxfilter & ATH9K_RX_FILTER_CONTROL)
  703. len += snprintf(buf + len, sizeof(buf) - len, " CONTROL");
  704. if (rxfilter & ATH9K_RX_FILTER_BEACON)
  705. len += snprintf(buf + len, sizeof(buf) - len, " BEACON");
  706. if (rxfilter & ATH9K_RX_FILTER_PROM)
  707. len += snprintf(buf + len, sizeof(buf) - len, " PROM");
  708. if (rxfilter & ATH9K_RX_FILTER_PROBEREQ)
  709. len += snprintf(buf + len, sizeof(buf) - len, " PROBEREQ");
  710. if (rxfilter & ATH9K_RX_FILTER_PHYERR)
  711. len += snprintf(buf + len, sizeof(buf) - len, " PHYERR");
  712. if (rxfilter & ATH9K_RX_FILTER_MYBEACON)
  713. len += snprintf(buf + len, sizeof(buf) - len, " MYBEACON");
  714. if (rxfilter & ATH9K_RX_FILTER_COMP_BAR)
  715. len += snprintf(buf + len, sizeof(buf) - len, " COMP_BAR");
  716. if (rxfilter & ATH9K_RX_FILTER_PSPOLL)
  717. len += snprintf(buf + len, sizeof(buf) - len, " PSPOLL");
  718. if (rxfilter & ATH9K_RX_FILTER_PHYRADAR)
  719. len += snprintf(buf + len, sizeof(buf) - len, " PHYRADAR");
  720. if (rxfilter & ATH9K_RX_FILTER_MCAST_BCAST_ALL)
  721. len += snprintf(buf + len, sizeof(buf) - len, " MCAST_BCAST_ALL");
  722. if (rxfilter & ATH9K_RX_FILTER_CONTROL_WRAPPER)
  723. len += snprintf(buf + len, sizeof(buf) - len, " CONTROL_WRAPPER");
  724. len += snprintf(buf + len, sizeof(buf) - len, "\n");
  725. reg = sc->sc_ah->imask;
  726. len += snprintf(buf + len, sizeof(buf) - len, "INTERRUPT-MASK: 0x%x", reg);
  727. if (reg & ATH9K_INT_SWBA)
  728. len += snprintf(buf + len, sizeof(buf) - len, " SWBA");
  729. if (reg & ATH9K_INT_BMISS)
  730. len += snprintf(buf + len, sizeof(buf) - len, " BMISS");
  731. if (reg & ATH9K_INT_CST)
  732. len += snprintf(buf + len, sizeof(buf) - len, " CST");
  733. if (reg & ATH9K_INT_RX)
  734. len += snprintf(buf + len, sizeof(buf) - len, " RX");
  735. if (reg & ATH9K_INT_RXHP)
  736. len += snprintf(buf + len, sizeof(buf) - len, " RXHP");
  737. if (reg & ATH9K_INT_RXLP)
  738. len += snprintf(buf + len, sizeof(buf) - len, " RXLP");
  739. if (reg & ATH9K_INT_BB_WATCHDOG)
  740. len += snprintf(buf + len, sizeof(buf) - len, " BB_WATCHDOG");
  741. len += snprintf(buf + len, sizeof(buf) - len, "\n");
  742. ath9k_calculate_iter_data(hw, NULL, &iter_data);
  743. len += snprintf(buf + len, sizeof(buf) - len,
  744. "VIF-COUNTS: AP: %i STA: %i MESH: %i WDS: %i"
  745. " ADHOC: %i TOTAL: %hi BEACON-VIF: %hi\n",
  746. iter_data.naps, iter_data.nstations, iter_data.nmeshes,
  747. iter_data.nwds, iter_data.nadhocs,
  748. sc->nvifs, sc->nbcnvifs);
  749. if (len > sizeof(buf))
  750. len = sizeof(buf);
  751. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  752. return retval;
  753. }
  754. static ssize_t read_file_reset(struct file *file, char __user *user_buf,
  755. size_t count, loff_t *ppos)
  756. {
  757. struct ath_softc *sc = file->private_data;
  758. char buf[512];
  759. unsigned int len = 0;
  760. len += snprintf(buf + len, sizeof(buf) - len,
  761. "%17s: %2d\n", "Baseband Hang",
  762. sc->debug.stats.reset[RESET_TYPE_BB_HANG]);
  763. len += snprintf(buf + len, sizeof(buf) - len,
  764. "%17s: %2d\n", "Baseband Watchdog",
  765. sc->debug.stats.reset[RESET_TYPE_BB_WATCHDOG]);
  766. len += snprintf(buf + len, sizeof(buf) - len,
  767. "%17s: %2d\n", "Fatal HW Error",
  768. sc->debug.stats.reset[RESET_TYPE_FATAL_INT]);
  769. len += snprintf(buf + len, sizeof(buf) - len,
  770. "%17s: %2d\n", "TX HW error",
  771. sc->debug.stats.reset[RESET_TYPE_TX_ERROR]);
  772. len += snprintf(buf + len, sizeof(buf) - len,
  773. "%17s: %2d\n", "TX Path Hang",
  774. sc->debug.stats.reset[RESET_TYPE_TX_HANG]);
  775. len += snprintf(buf + len, sizeof(buf) - len,
  776. "%17s: %2d\n", "PLL RX Hang",
  777. sc->debug.stats.reset[RESET_TYPE_PLL_HANG]);
  778. len += snprintf(buf + len, sizeof(buf) - len,
  779. "%17s: %2d\n", "MCI Reset",
  780. sc->debug.stats.reset[RESET_TYPE_MCI]);
  781. if (len > sizeof(buf))
  782. len = sizeof(buf);
  783. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  784. }
  785. void ath_debug_stat_tx(struct ath_softc *sc, struct ath_buf *bf,
  786. struct ath_tx_status *ts, struct ath_txq *txq,
  787. unsigned int flags)
  788. {
  789. int qnum = txq->axq_qnum;
  790. TX_STAT_INC(qnum, tx_pkts_all);
  791. sc->debug.stats.txstats[qnum].tx_bytes_all += bf->bf_mpdu->len;
  792. if (bf_isampdu(bf)) {
  793. if (flags & ATH_TX_ERROR)
  794. TX_STAT_INC(qnum, a_xretries);
  795. else
  796. TX_STAT_INC(qnum, a_completed);
  797. } else {
  798. if (ts->ts_status & ATH9K_TXERR_XRETRY)
  799. TX_STAT_INC(qnum, xretries);
  800. else
  801. TX_STAT_INC(qnum, completed);
  802. }
  803. if (ts->ts_status & ATH9K_TXERR_FILT)
  804. TX_STAT_INC(qnum, txerr_filtered);
  805. if (ts->ts_status & ATH9K_TXERR_FIFO)
  806. TX_STAT_INC(qnum, fifo_underrun);
  807. if (ts->ts_status & ATH9K_TXERR_XTXOP)
  808. TX_STAT_INC(qnum, xtxop);
  809. if (ts->ts_status & ATH9K_TXERR_TIMER_EXPIRED)
  810. TX_STAT_INC(qnum, timer_exp);
  811. if (ts->ts_flags & ATH9K_TX_DESC_CFG_ERR)
  812. TX_STAT_INC(qnum, desc_cfg_err);
  813. if (ts->ts_flags & ATH9K_TX_DATA_UNDERRUN)
  814. TX_STAT_INC(qnum, data_underrun);
  815. if (ts->ts_flags & ATH9K_TX_DELIM_UNDERRUN)
  816. TX_STAT_INC(qnum, delim_underrun);
  817. }
  818. static const struct file_operations fops_xmit = {
  819. .read = read_file_xmit,
  820. .open = simple_open,
  821. .owner = THIS_MODULE,
  822. .llseek = default_llseek,
  823. };
  824. static const struct file_operations fops_queues = {
  825. .read = read_file_queues,
  826. .open = simple_open,
  827. .owner = THIS_MODULE,
  828. .llseek = default_llseek,
  829. };
  830. static const struct file_operations fops_misc = {
  831. .read = read_file_misc,
  832. .open = simple_open,
  833. .owner = THIS_MODULE,
  834. .llseek = default_llseek,
  835. };
  836. static const struct file_operations fops_reset = {
  837. .read = read_file_reset,
  838. .open = simple_open,
  839. .owner = THIS_MODULE,
  840. .llseek = default_llseek,
  841. };
  842. static ssize_t read_file_recv(struct file *file, char __user *user_buf,
  843. size_t count, loff_t *ppos)
  844. {
  845. #define PHY_ERR(s, p) \
  846. len += snprintf(buf + len, size - len, "%22s : %10u\n", s, \
  847. sc->debug.stats.rxstats.phy_err_stats[p]);
  848. #define RXS_ERR(s, e) \
  849. do { \
  850. len += snprintf(buf + len, size - len, \
  851. "%22s : %10u\n", s, \
  852. sc->debug.stats.rxstats.e); \
  853. } while (0)
  854. struct ath_softc *sc = file->private_data;
  855. char *buf;
  856. unsigned int len = 0, size = 1600;
  857. ssize_t retval = 0;
  858. buf = kzalloc(size, GFP_KERNEL);
  859. if (buf == NULL)
  860. return -ENOMEM;
  861. RXS_ERR("CRC ERR", crc_err);
  862. RXS_ERR("DECRYPT CRC ERR", decrypt_crc_err);
  863. RXS_ERR("PHY ERR", phy_err);
  864. RXS_ERR("MIC ERR", mic_err);
  865. RXS_ERR("PRE-DELIM CRC ERR", pre_delim_crc_err);
  866. RXS_ERR("POST-DELIM CRC ERR", post_delim_crc_err);
  867. RXS_ERR("DECRYPT BUSY ERR", decrypt_busy_err);
  868. RXS_ERR("RX-LENGTH-ERR", rx_len_err);
  869. RXS_ERR("RX-OOM-ERR", rx_oom_err);
  870. RXS_ERR("RX-RATE-ERR", rx_rate_err);
  871. RXS_ERR("RX-TOO-MANY-FRAGS", rx_too_many_frags_err);
  872. PHY_ERR("UNDERRUN ERR", ATH9K_PHYERR_UNDERRUN);
  873. PHY_ERR("TIMING ERR", ATH9K_PHYERR_TIMING);
  874. PHY_ERR("PARITY ERR", ATH9K_PHYERR_PARITY);
  875. PHY_ERR("RATE ERR", ATH9K_PHYERR_RATE);
  876. PHY_ERR("LENGTH ERR", ATH9K_PHYERR_LENGTH);
  877. PHY_ERR("RADAR ERR", ATH9K_PHYERR_RADAR);
  878. PHY_ERR("SERVICE ERR", ATH9K_PHYERR_SERVICE);
  879. PHY_ERR("TOR ERR", ATH9K_PHYERR_TOR);
  880. PHY_ERR("OFDM-TIMING ERR", ATH9K_PHYERR_OFDM_TIMING);
  881. PHY_ERR("OFDM-SIGNAL-PARITY ERR", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
  882. PHY_ERR("OFDM-RATE ERR", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
  883. PHY_ERR("OFDM-LENGTH ERR", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
  884. PHY_ERR("OFDM-POWER-DROP ERR", ATH9K_PHYERR_OFDM_POWER_DROP);
  885. PHY_ERR("OFDM-SERVICE ERR", ATH9K_PHYERR_OFDM_SERVICE);
  886. PHY_ERR("OFDM-RESTART ERR", ATH9K_PHYERR_OFDM_RESTART);
  887. PHY_ERR("FALSE-RADAR-EXT ERR", ATH9K_PHYERR_FALSE_RADAR_EXT);
  888. PHY_ERR("CCK-TIMING ERR", ATH9K_PHYERR_CCK_TIMING);
  889. PHY_ERR("CCK-HEADER-CRC ERR", ATH9K_PHYERR_CCK_HEADER_CRC);
  890. PHY_ERR("CCK-RATE ERR", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
  891. PHY_ERR("CCK-SERVICE ERR", ATH9K_PHYERR_CCK_SERVICE);
  892. PHY_ERR("CCK-RESTART ERR", ATH9K_PHYERR_CCK_RESTART);
  893. PHY_ERR("CCK-LENGTH ERR", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
  894. PHY_ERR("CCK-POWER-DROP ERR", ATH9K_PHYERR_CCK_POWER_DROP);
  895. PHY_ERR("HT-CRC ERR", ATH9K_PHYERR_HT_CRC_ERROR);
  896. PHY_ERR("HT-LENGTH ERR", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
  897. PHY_ERR("HT-RATE ERR", ATH9K_PHYERR_HT_RATE_ILLEGAL);
  898. RXS_ERR("RX-Pkts-All", rx_pkts_all);
  899. RXS_ERR("RX-Bytes-All", rx_bytes_all);
  900. RXS_ERR("RX-Beacons", rx_beacons);
  901. RXS_ERR("RX-Frags", rx_frags);
  902. RXS_ERR("RX-Spectral", rx_spectral);
  903. if (len > size)
  904. len = size;
  905. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  906. kfree(buf);
  907. return retval;
  908. #undef RXS_ERR
  909. #undef PHY_ERR
  910. }
  911. void ath_debug_stat_rx(struct ath_softc *sc, struct ath_rx_status *rs)
  912. {
  913. #define RX_PHY_ERR_INC(c) sc->debug.stats.rxstats.phy_err_stats[c]++
  914. RX_STAT_INC(rx_pkts_all);
  915. sc->debug.stats.rxstats.rx_bytes_all += rs->rs_datalen;
  916. if (rs->rs_status & ATH9K_RXERR_CRC)
  917. RX_STAT_INC(crc_err);
  918. if (rs->rs_status & ATH9K_RXERR_DECRYPT)
  919. RX_STAT_INC(decrypt_crc_err);
  920. if (rs->rs_status & ATH9K_RXERR_MIC)
  921. RX_STAT_INC(mic_err);
  922. if (rs->rs_status & ATH9K_RX_DELIM_CRC_PRE)
  923. RX_STAT_INC(pre_delim_crc_err);
  924. if (rs->rs_status & ATH9K_RX_DELIM_CRC_POST)
  925. RX_STAT_INC(post_delim_crc_err);
  926. if (rs->rs_status & ATH9K_RX_DECRYPT_BUSY)
  927. RX_STAT_INC(decrypt_busy_err);
  928. if (rs->rs_status & ATH9K_RXERR_PHY) {
  929. RX_STAT_INC(phy_err);
  930. if (rs->rs_phyerr < ATH9K_PHYERR_MAX)
  931. RX_PHY_ERR_INC(rs->rs_phyerr);
  932. }
  933. #undef RX_PHY_ERR_INC
  934. }
  935. static const struct file_operations fops_recv = {
  936. .read = read_file_recv,
  937. .open = simple_open,
  938. .owner = THIS_MODULE,
  939. .llseek = default_llseek,
  940. };
  941. static ssize_t read_file_spec_scan_ctl(struct file *file, char __user *user_buf,
  942. size_t count, loff_t *ppos)
  943. {
  944. struct ath_softc *sc = file->private_data;
  945. char *mode = "";
  946. unsigned int len;
  947. switch (sc->spectral_mode) {
  948. case SPECTRAL_DISABLED:
  949. mode = "disable";
  950. break;
  951. case SPECTRAL_BACKGROUND:
  952. mode = "background";
  953. break;
  954. case SPECTRAL_CHANSCAN:
  955. mode = "chanscan";
  956. break;
  957. case SPECTRAL_MANUAL:
  958. mode = "manual";
  959. break;
  960. }
  961. len = strlen(mode);
  962. return simple_read_from_buffer(user_buf, count, ppos, mode, len);
  963. }
  964. static ssize_t write_file_spec_scan_ctl(struct file *file,
  965. const char __user *user_buf,
  966. size_t count, loff_t *ppos)
  967. {
  968. struct ath_softc *sc = file->private_data;
  969. struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  970. char buf[32];
  971. ssize_t len;
  972. len = min(count, sizeof(buf) - 1);
  973. if (copy_from_user(buf, user_buf, len))
  974. return -EFAULT;
  975. buf[len] = '\0';
  976. if (strncmp("trigger", buf, 7) == 0) {
  977. ath9k_spectral_scan_trigger(sc->hw);
  978. } else if (strncmp("background", buf, 9) == 0) {
  979. ath9k_spectral_scan_config(sc->hw, SPECTRAL_BACKGROUND);
  980. ath_dbg(common, CONFIG, "spectral scan: background mode enabled\n");
  981. } else if (strncmp("chanscan", buf, 8) == 0) {
  982. ath9k_spectral_scan_config(sc->hw, SPECTRAL_CHANSCAN);
  983. ath_dbg(common, CONFIG, "spectral scan: channel scan mode enabled\n");
  984. } else if (strncmp("manual", buf, 6) == 0) {
  985. ath9k_spectral_scan_config(sc->hw, SPECTRAL_MANUAL);
  986. ath_dbg(common, CONFIG, "spectral scan: manual mode enabled\n");
  987. } else if (strncmp("disable", buf, 7) == 0) {
  988. ath9k_spectral_scan_config(sc->hw, SPECTRAL_DISABLED);
  989. ath_dbg(common, CONFIG, "spectral scan: disabled\n");
  990. } else {
  991. return -EINVAL;
  992. }
  993. return count;
  994. }
  995. static const struct file_operations fops_spec_scan_ctl = {
  996. .read = read_file_spec_scan_ctl,
  997. .write = write_file_spec_scan_ctl,
  998. .open = simple_open,
  999. .owner = THIS_MODULE,
  1000. .llseek = default_llseek,
  1001. };
  1002. static ssize_t read_file_spectral_short_repeat(struct file *file,
  1003. char __user *user_buf,
  1004. size_t count, loff_t *ppos)
  1005. {
  1006. struct ath_softc *sc = file->private_data;
  1007. char buf[32];
  1008. unsigned int len;
  1009. len = sprintf(buf, "%d\n", sc->spec_config.short_repeat);
  1010. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1011. }
  1012. static ssize_t write_file_spectral_short_repeat(struct file *file,
  1013. const char __user *user_buf,
  1014. size_t count, loff_t *ppos)
  1015. {
  1016. struct ath_softc *sc = file->private_data;
  1017. unsigned long val;
  1018. char buf[32];
  1019. ssize_t len;
  1020. len = min(count, sizeof(buf) - 1);
  1021. if (copy_from_user(buf, user_buf, len))
  1022. return -EFAULT;
  1023. buf[len] = '\0';
  1024. if (kstrtoul(buf, 0, &val))
  1025. return -EINVAL;
  1026. if (val < 0 || val > 1)
  1027. return -EINVAL;
  1028. sc->spec_config.short_repeat = val;
  1029. return count;
  1030. }
  1031. static const struct file_operations fops_spectral_short_repeat = {
  1032. .read = read_file_spectral_short_repeat,
  1033. .write = write_file_spectral_short_repeat,
  1034. .open = simple_open,
  1035. .owner = THIS_MODULE,
  1036. .llseek = default_llseek,
  1037. };
  1038. static ssize_t read_file_spectral_count(struct file *file,
  1039. char __user *user_buf,
  1040. size_t count, loff_t *ppos)
  1041. {
  1042. struct ath_softc *sc = file->private_data;
  1043. char buf[32];
  1044. unsigned int len;
  1045. len = sprintf(buf, "%d\n", sc->spec_config.count);
  1046. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1047. }
  1048. static ssize_t write_file_spectral_count(struct file *file,
  1049. const char __user *user_buf,
  1050. size_t count, loff_t *ppos)
  1051. {
  1052. struct ath_softc *sc = file->private_data;
  1053. unsigned long val;
  1054. char buf[32];
  1055. ssize_t len;
  1056. len = min(count, sizeof(buf) - 1);
  1057. if (copy_from_user(buf, user_buf, len))
  1058. return -EFAULT;
  1059. buf[len] = '\0';
  1060. if (kstrtoul(buf, 0, &val))
  1061. return -EINVAL;
  1062. if (val < 0 || val > 255)
  1063. return -EINVAL;
  1064. sc->spec_config.count = val;
  1065. return count;
  1066. }
  1067. static const struct file_operations fops_spectral_count = {
  1068. .read = read_file_spectral_count,
  1069. .write = write_file_spectral_count,
  1070. .open = simple_open,
  1071. .owner = THIS_MODULE,
  1072. .llseek = default_llseek,
  1073. };
  1074. static ssize_t read_file_spectral_period(struct file *file,
  1075. char __user *user_buf,
  1076. size_t count, loff_t *ppos)
  1077. {
  1078. struct ath_softc *sc = file->private_data;
  1079. char buf[32];
  1080. unsigned int len;
  1081. len = sprintf(buf, "%d\n", sc->spec_config.period);
  1082. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1083. }
  1084. static ssize_t write_file_spectral_period(struct file *file,
  1085. const char __user *user_buf,
  1086. size_t count, loff_t *ppos)
  1087. {
  1088. struct ath_softc *sc = file->private_data;
  1089. unsigned long val;
  1090. char buf[32];
  1091. ssize_t len;
  1092. len = min(count, sizeof(buf) - 1);
  1093. if (copy_from_user(buf, user_buf, len))
  1094. return -EFAULT;
  1095. buf[len] = '\0';
  1096. if (kstrtoul(buf, 0, &val))
  1097. return -EINVAL;
  1098. if (val < 0 || val > 255)
  1099. return -EINVAL;
  1100. sc->spec_config.period = val;
  1101. return count;
  1102. }
  1103. static const struct file_operations fops_spectral_period = {
  1104. .read = read_file_spectral_period,
  1105. .write = write_file_spectral_period,
  1106. .open = simple_open,
  1107. .owner = THIS_MODULE,
  1108. .llseek = default_llseek,
  1109. };
  1110. static ssize_t read_file_spectral_fft_period(struct file *file,
  1111. char __user *user_buf,
  1112. size_t count, loff_t *ppos)
  1113. {
  1114. struct ath_softc *sc = file->private_data;
  1115. char buf[32];
  1116. unsigned int len;
  1117. len = sprintf(buf, "%d\n", sc->spec_config.fft_period);
  1118. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1119. }
  1120. static ssize_t write_file_spectral_fft_period(struct file *file,
  1121. const char __user *user_buf,
  1122. size_t count, loff_t *ppos)
  1123. {
  1124. struct ath_softc *sc = file->private_data;
  1125. unsigned long val;
  1126. char buf[32];
  1127. ssize_t len;
  1128. len = min(count, sizeof(buf) - 1);
  1129. if (copy_from_user(buf, user_buf, len))
  1130. return -EFAULT;
  1131. buf[len] = '\0';
  1132. if (kstrtoul(buf, 0, &val))
  1133. return -EINVAL;
  1134. if (val < 0 || val > 15)
  1135. return -EINVAL;
  1136. sc->spec_config.fft_period = val;
  1137. return count;
  1138. }
  1139. static const struct file_operations fops_spectral_fft_period = {
  1140. .read = read_file_spectral_fft_period,
  1141. .write = write_file_spectral_fft_period,
  1142. .open = simple_open,
  1143. .owner = THIS_MODULE,
  1144. .llseek = default_llseek,
  1145. };
  1146. static struct dentry *create_buf_file_handler(const char *filename,
  1147. struct dentry *parent,
  1148. umode_t mode,
  1149. struct rchan_buf *buf,
  1150. int *is_global)
  1151. {
  1152. struct dentry *buf_file;
  1153. buf_file = debugfs_create_file(filename, mode, parent, buf,
  1154. &relay_file_operations);
  1155. *is_global = 1;
  1156. return buf_file;
  1157. }
  1158. static int remove_buf_file_handler(struct dentry *dentry)
  1159. {
  1160. debugfs_remove(dentry);
  1161. return 0;
  1162. }
  1163. void ath_debug_send_fft_sample(struct ath_softc *sc,
  1164. struct fft_sample_tlv *fft_sample_tlv)
  1165. {
  1166. int length;
  1167. if (!sc->rfs_chan_spec_scan)
  1168. return;
  1169. length = __be16_to_cpu(fft_sample_tlv->length) +
  1170. sizeof(*fft_sample_tlv);
  1171. relay_write(sc->rfs_chan_spec_scan, fft_sample_tlv, length);
  1172. }
  1173. static struct rchan_callbacks rfs_spec_scan_cb = {
  1174. .create_buf_file = create_buf_file_handler,
  1175. .remove_buf_file = remove_buf_file_handler,
  1176. };
  1177. static ssize_t read_file_regidx(struct file *file, char __user *user_buf,
  1178. size_t count, loff_t *ppos)
  1179. {
  1180. struct ath_softc *sc = file->private_data;
  1181. char buf[32];
  1182. unsigned int len;
  1183. len = sprintf(buf, "0x%08x\n", sc->debug.regidx);
  1184. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1185. }
  1186. static ssize_t write_file_regidx(struct file *file, const char __user *user_buf,
  1187. size_t count, loff_t *ppos)
  1188. {
  1189. struct ath_softc *sc = file->private_data;
  1190. unsigned long regidx;
  1191. char buf[32];
  1192. ssize_t len;
  1193. len = min(count, sizeof(buf) - 1);
  1194. if (copy_from_user(buf, user_buf, len))
  1195. return -EFAULT;
  1196. buf[len] = '\0';
  1197. if (kstrtoul(buf, 0, &regidx))
  1198. return -EINVAL;
  1199. sc->debug.regidx = regidx;
  1200. return count;
  1201. }
  1202. static const struct file_operations fops_regidx = {
  1203. .read = read_file_regidx,
  1204. .write = write_file_regidx,
  1205. .open = simple_open,
  1206. .owner = THIS_MODULE,
  1207. .llseek = default_llseek,
  1208. };
  1209. static ssize_t read_file_regval(struct file *file, char __user *user_buf,
  1210. size_t count, loff_t *ppos)
  1211. {
  1212. struct ath_softc *sc = file->private_data;
  1213. struct ath_hw *ah = sc->sc_ah;
  1214. char buf[32];
  1215. unsigned int len;
  1216. u32 regval;
  1217. ath9k_ps_wakeup(sc);
  1218. regval = REG_READ_D(ah, sc->debug.regidx);
  1219. ath9k_ps_restore(sc);
  1220. len = sprintf(buf, "0x%08x\n", regval);
  1221. return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1222. }
  1223. static ssize_t write_file_regval(struct file *file, const char __user *user_buf,
  1224. size_t count, loff_t *ppos)
  1225. {
  1226. struct ath_softc *sc = file->private_data;
  1227. struct ath_hw *ah = sc->sc_ah;
  1228. unsigned long regval;
  1229. char buf[32];
  1230. ssize_t len;
  1231. len = min(count, sizeof(buf) - 1);
  1232. if (copy_from_user(buf, user_buf, len))
  1233. return -EFAULT;
  1234. buf[len] = '\0';
  1235. if (kstrtoul(buf, 0, &regval))
  1236. return -EINVAL;
  1237. ath9k_ps_wakeup(sc);
  1238. REG_WRITE_D(ah, sc->debug.regidx, regval);
  1239. ath9k_ps_restore(sc);
  1240. return count;
  1241. }
  1242. static const struct file_operations fops_regval = {
  1243. .read = read_file_regval,
  1244. .write = write_file_regval,
  1245. .open = simple_open,
  1246. .owner = THIS_MODULE,
  1247. .llseek = default_llseek,
  1248. };
  1249. #define REGDUMP_LINE_SIZE 20
  1250. static int open_file_regdump(struct inode *inode, struct file *file)
  1251. {
  1252. struct ath_softc *sc = inode->i_private;
  1253. unsigned int len = 0;
  1254. u8 *buf;
  1255. int i;
  1256. unsigned long num_regs, regdump_len, max_reg_offset;
  1257. max_reg_offset = AR_SREV_9300_20_OR_LATER(sc->sc_ah) ? 0x16bd4 : 0xb500;
  1258. num_regs = max_reg_offset / 4 + 1;
  1259. regdump_len = num_regs * REGDUMP_LINE_SIZE + 1;
  1260. buf = vmalloc(regdump_len);
  1261. if (!buf)
  1262. return -ENOMEM;
  1263. ath9k_ps_wakeup(sc);
  1264. for (i = 0; i < num_regs; i++)
  1265. len += scnprintf(buf + len, regdump_len - len,
  1266. "0x%06x 0x%08x\n", i << 2, REG_READ(sc->sc_ah, i << 2));
  1267. ath9k_ps_restore(sc);
  1268. file->private_data = buf;
  1269. return 0;
  1270. }
  1271. static const struct file_operations fops_regdump = {
  1272. .open = open_file_regdump,
  1273. .read = ath9k_debugfs_read_buf,
  1274. .release = ath9k_debugfs_release_buf,
  1275. .owner = THIS_MODULE,
  1276. .llseek = default_llseek,/* read accesses f_pos */
  1277. };
  1278. static ssize_t read_file_dump_nfcal(struct file *file, char __user *user_buf,
  1279. size_t count, loff_t *ppos)
  1280. {
  1281. struct ath_softc *sc = file->private_data;
  1282. struct ath_hw *ah = sc->sc_ah;
  1283. struct ath9k_nfcal_hist *h = sc->caldata.nfCalHist;
  1284. struct ath_common *common = ath9k_hw_common(ah);
  1285. struct ieee80211_conf *conf = &common->hw->conf;
  1286. u32 len = 0, size = 1500;
  1287. u32 i, j;
  1288. ssize_t retval = 0;
  1289. char *buf;
  1290. u8 chainmask = (ah->rxchainmask << 3) | ah->rxchainmask;
  1291. u8 nread;
  1292. buf = kzalloc(size, GFP_KERNEL);
  1293. if (!buf)
  1294. return -ENOMEM;
  1295. len += snprintf(buf + len, size - len,
  1296. "Channel Noise Floor : %d\n", ah->noise);
  1297. len += snprintf(buf + len, size - len,
  1298. "Chain | privNF | # Readings | NF Readings\n");
  1299. for (i = 0; i < NUM_NF_READINGS; i++) {
  1300. if (!(chainmask & (1 << i)) ||
  1301. ((i >= AR5416_MAX_CHAINS) && !conf_is_ht40(conf)))
  1302. continue;
  1303. nread = AR_PHY_CCA_FILTERWINDOW_LENGTH - h[i].invalidNFcount;
  1304. len += snprintf(buf + len, size - len, " %d\t %d\t %d\t\t",
  1305. i, h[i].privNF, nread);
  1306. for (j = 0; j < nread; j++)
  1307. len += snprintf(buf + len, size - len,
  1308. " %d", h[i].nfCalBuffer[j]);
  1309. len += snprintf(buf + len, size - len, "\n");
  1310. }
  1311. if (len > size)
  1312. len = size;
  1313. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1314. kfree(buf);
  1315. return retval;
  1316. }
  1317. static const struct file_operations fops_dump_nfcal = {
  1318. .read = read_file_dump_nfcal,
  1319. .open = simple_open,
  1320. .owner = THIS_MODULE,
  1321. .llseek = default_llseek,
  1322. };
  1323. static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf,
  1324. size_t count, loff_t *ppos)
  1325. {
  1326. struct ath_softc *sc = file->private_data;
  1327. struct ath_hw *ah = sc->sc_ah;
  1328. u32 len = 0, size = 1500;
  1329. ssize_t retval = 0;
  1330. char *buf;
  1331. buf = kzalloc(size, GFP_KERNEL);
  1332. if (!buf)
  1333. return -ENOMEM;
  1334. len = ah->eep_ops->dump_eeprom(ah, true, buf, len, size);
  1335. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1336. kfree(buf);
  1337. return retval;
  1338. }
  1339. static const struct file_operations fops_base_eeprom = {
  1340. .read = read_file_base_eeprom,
  1341. .open = simple_open,
  1342. .owner = THIS_MODULE,
  1343. .llseek = default_llseek,
  1344. };
  1345. static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf,
  1346. size_t count, loff_t *ppos)
  1347. {
  1348. struct ath_softc *sc = file->private_data;
  1349. struct ath_hw *ah = sc->sc_ah;
  1350. u32 len = 0, size = 6000;
  1351. char *buf;
  1352. size_t retval;
  1353. buf = kzalloc(size, GFP_KERNEL);
  1354. if (buf == NULL)
  1355. return -ENOMEM;
  1356. len = ah->eep_ops->dump_eeprom(ah, false, buf, len, size);
  1357. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1358. kfree(buf);
  1359. return retval;
  1360. }
  1361. static const struct file_operations fops_modal_eeprom = {
  1362. .read = read_file_modal_eeprom,
  1363. .open = simple_open,
  1364. .owner = THIS_MODULE,
  1365. .llseek = default_llseek,
  1366. };
  1367. #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
  1368. static ssize_t read_file_btcoex(struct file *file, char __user *user_buf,
  1369. size_t count, loff_t *ppos)
  1370. {
  1371. struct ath_softc *sc = file->private_data;
  1372. u32 len = 0, size = 1500;
  1373. char *buf;
  1374. size_t retval;
  1375. buf = kzalloc(size, GFP_KERNEL);
  1376. if (buf == NULL)
  1377. return -ENOMEM;
  1378. if (!sc->sc_ah->common.btcoex_enabled) {
  1379. len = snprintf(buf, size, "%s\n",
  1380. "BTCOEX is disabled");
  1381. goto exit;
  1382. }
  1383. len = ath9k_dump_btcoex(sc, buf, size);
  1384. exit:
  1385. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1386. kfree(buf);
  1387. return retval;
  1388. }
  1389. static const struct file_operations fops_btcoex = {
  1390. .read = read_file_btcoex,
  1391. .open = simple_open,
  1392. .owner = THIS_MODULE,
  1393. .llseek = default_llseek,
  1394. };
  1395. #endif
  1396. static ssize_t read_file_node_stat(struct file *file, char __user *user_buf,
  1397. size_t count, loff_t *ppos)
  1398. {
  1399. struct ath_node *an = file->private_data;
  1400. struct ath_softc *sc = an->sc;
  1401. struct ath_atx_tid *tid;
  1402. struct ath_atx_ac *ac;
  1403. struct ath_txq *txq;
  1404. u32 len = 0, size = 4096;
  1405. char *buf;
  1406. size_t retval;
  1407. int tidno, acno;
  1408. buf = kzalloc(size, GFP_KERNEL);
  1409. if (buf == NULL)
  1410. return -ENOMEM;
  1411. if (!an->sta->ht_cap.ht_supported) {
  1412. len = snprintf(buf, size, "%s\n",
  1413. "HT not supported");
  1414. goto exit;
  1415. }
  1416. len = snprintf(buf, size, "Max-AMPDU: %d\n",
  1417. an->maxampdu);
  1418. len += snprintf(buf + len, size - len, "MPDU Density: %d\n\n",
  1419. an->mpdudensity);
  1420. len += snprintf(buf + len, size - len,
  1421. "%2s%7s\n", "AC", "SCHED");
  1422. for (acno = 0, ac = &an->ac[acno];
  1423. acno < IEEE80211_NUM_ACS; acno++, ac++) {
  1424. txq = ac->txq;
  1425. ath_txq_lock(sc, txq);
  1426. len += snprintf(buf + len, size - len,
  1427. "%2d%7d\n",
  1428. acno, ac->sched);
  1429. ath_txq_unlock(sc, txq);
  1430. }
  1431. len += snprintf(buf + len, size - len,
  1432. "\n%3s%11s%10s%10s%10s%10s%9s%6s%8s\n",
  1433. "TID", "SEQ_START", "SEQ_NEXT", "BAW_SIZE",
  1434. "BAW_HEAD", "BAW_TAIL", "BAR_IDX", "SCHED", "PAUSED");
  1435. for (tidno = 0, tid = &an->tid[tidno];
  1436. tidno < IEEE80211_NUM_TIDS; tidno++, tid++) {
  1437. txq = tid->ac->txq;
  1438. ath_txq_lock(sc, txq);
  1439. len += snprintf(buf + len, size - len,
  1440. "%3d%11d%10d%10d%10d%10d%9d%6d%8d\n",
  1441. tid->tidno, tid->seq_start, tid->seq_next,
  1442. tid->baw_size, tid->baw_head, tid->baw_tail,
  1443. tid->bar_index, tid->sched, tid->paused);
  1444. ath_txq_unlock(sc, txq);
  1445. }
  1446. exit:
  1447. retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
  1448. kfree(buf);
  1449. return retval;
  1450. }
  1451. static const struct file_operations fops_node_stat = {
  1452. .read = read_file_node_stat,
  1453. .open = simple_open,
  1454. .owner = THIS_MODULE,
  1455. .llseek = default_llseek,
  1456. };
  1457. void ath9k_sta_add_debugfs(struct ieee80211_hw *hw,
  1458. struct ieee80211_vif *vif,
  1459. struct ieee80211_sta *sta,
  1460. struct dentry *dir)
  1461. {
  1462. struct ath_node *an = (struct ath_node *)sta->drv_priv;
  1463. debugfs_create_file("node_stat", S_IRUGO, dir, an, &fops_node_stat);
  1464. }
  1465. /* Ethtool support for get-stats */
  1466. #define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
  1467. static const char ath9k_gstrings_stats[][ETH_GSTRING_LEN] = {
  1468. "tx_pkts_nic",
  1469. "tx_bytes_nic",
  1470. "rx_pkts_nic",
  1471. "rx_bytes_nic",
  1472. AMKSTR(d_tx_pkts),
  1473. AMKSTR(d_tx_bytes),
  1474. AMKSTR(d_tx_mpdus_queued),
  1475. AMKSTR(d_tx_mpdus_completed),
  1476. AMKSTR(d_tx_mpdu_xretries),
  1477. AMKSTR(d_tx_aggregates),
  1478. AMKSTR(d_tx_ampdus_queued_hw),
  1479. AMKSTR(d_tx_ampdus_queued_sw),
  1480. AMKSTR(d_tx_ampdus_completed),
  1481. AMKSTR(d_tx_ampdu_retries),
  1482. AMKSTR(d_tx_ampdu_xretries),
  1483. AMKSTR(d_tx_fifo_underrun),
  1484. AMKSTR(d_tx_op_exceeded),
  1485. AMKSTR(d_tx_timer_expiry),
  1486. AMKSTR(d_tx_desc_cfg_err),
  1487. AMKSTR(d_tx_data_underrun),
  1488. AMKSTR(d_tx_delim_underrun),
  1489. "d_rx_crc_err",
  1490. "d_rx_decrypt_crc_err",
  1491. "d_rx_phy_err",
  1492. "d_rx_mic_err",
  1493. "d_rx_pre_delim_crc_err",
  1494. "d_rx_post_delim_crc_err",
  1495. "d_rx_decrypt_busy_err",
  1496. "d_rx_phyerr_radar",
  1497. "d_rx_phyerr_ofdm_timing",
  1498. "d_rx_phyerr_cck_timing",
  1499. };
  1500. #define ATH9K_SSTATS_LEN ARRAY_SIZE(ath9k_gstrings_stats)
  1501. void ath9k_get_et_strings(struct ieee80211_hw *hw,
  1502. struct ieee80211_vif *vif,
  1503. u32 sset, u8 *data)
  1504. {
  1505. if (sset == ETH_SS_STATS)
  1506. memcpy(data, *ath9k_gstrings_stats,
  1507. sizeof(ath9k_gstrings_stats));
  1508. }
  1509. int ath9k_get_et_sset_count(struct ieee80211_hw *hw,
  1510. struct ieee80211_vif *vif, int sset)
  1511. {
  1512. if (sset == ETH_SS_STATS)
  1513. return ATH9K_SSTATS_LEN;
  1514. return 0;
  1515. }
  1516. #define AWDATA(elem) \
  1517. do { \
  1518. data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BE)].elem; \
  1519. data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BK)].elem; \
  1520. data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VI)].elem; \
  1521. data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VO)].elem; \
  1522. } while (0)
  1523. #define AWDATA_RX(elem) \
  1524. do { \
  1525. data[i++] = sc->debug.stats.rxstats.elem; \
  1526. } while (0)
  1527. void ath9k_get_et_stats(struct ieee80211_hw *hw,
  1528. struct ieee80211_vif *vif,
  1529. struct ethtool_stats *stats, u64 *data)
  1530. {
  1531. struct ath_softc *sc = hw->priv;
  1532. int i = 0;
  1533. data[i++] = (sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BE)].tx_pkts_all +
  1534. sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BK)].tx_pkts_all +
  1535. sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VI)].tx_pkts_all +
  1536. sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VO)].tx_pkts_all);
  1537. data[i++] = (sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BE)].tx_bytes_all +
  1538. sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BK)].tx_bytes_all +
  1539. sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VI)].tx_bytes_all +
  1540. sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VO)].tx_bytes_all);
  1541. AWDATA_RX(rx_pkts_all);
  1542. AWDATA_RX(rx_bytes_all);
  1543. AWDATA(tx_pkts_all);
  1544. AWDATA(tx_bytes_all);
  1545. AWDATA(queued);
  1546. AWDATA(completed);
  1547. AWDATA(xretries);
  1548. AWDATA(a_aggr);
  1549. AWDATA(a_queued_hw);
  1550. AWDATA(a_queued_sw);
  1551. AWDATA(a_completed);
  1552. AWDATA(a_retries);
  1553. AWDATA(a_xretries);
  1554. AWDATA(fifo_underrun);
  1555. AWDATA(xtxop);
  1556. AWDATA(timer_exp);
  1557. AWDATA(desc_cfg_err);
  1558. AWDATA(data_underrun);
  1559. AWDATA(delim_underrun);
  1560. AWDATA_RX(crc_err);
  1561. AWDATA_RX(decrypt_crc_err);
  1562. AWDATA_RX(phy_err);
  1563. AWDATA_RX(mic_err);
  1564. AWDATA_RX(pre_delim_crc_err);
  1565. AWDATA_RX(post_delim_crc_err);
  1566. AWDATA_RX(decrypt_busy_err);
  1567. AWDATA_RX(phy_err_stats[ATH9K_PHYERR_RADAR]);
  1568. AWDATA_RX(phy_err_stats[ATH9K_PHYERR_OFDM_TIMING]);
  1569. AWDATA_RX(phy_err_stats[ATH9K_PHYERR_CCK_TIMING]);
  1570. WARN_ON(i != ATH9K_SSTATS_LEN);
  1571. }
  1572. void ath9k_deinit_debug(struct ath_softc *sc)
  1573. {
  1574. if (config_enabled(CONFIG_ATH9K_DEBUGFS) && sc->rfs_chan_spec_scan) {
  1575. relay_close(sc->rfs_chan_spec_scan);
  1576. sc->rfs_chan_spec_scan = NULL;
  1577. }
  1578. }
  1579. int ath9k_init_debug(struct ath_hw *ah)
  1580. {
  1581. struct ath_common *common = ath9k_hw_common(ah);
  1582. struct ath_softc *sc = (struct ath_softc *) common->priv;
  1583. sc->debug.debugfs_phy = debugfs_create_dir("ath9k",
  1584. sc->hw->wiphy->debugfsdir);
  1585. if (!sc->debug.debugfs_phy)
  1586. return -ENOMEM;
  1587. #ifdef CONFIG_ATH_DEBUG
  1588. debugfs_create_file("debug", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1589. sc, &fops_debug);
  1590. #endif
  1591. ath9k_dfs_init_debug(sc);
  1592. debugfs_create_file("dma", S_IRUSR, sc->debug.debugfs_phy, sc,
  1593. &fops_dma);
  1594. debugfs_create_file("interrupt", S_IRUSR, sc->debug.debugfs_phy, sc,
  1595. &fops_interrupt);
  1596. debugfs_create_file("xmit", S_IRUSR, sc->debug.debugfs_phy, sc,
  1597. &fops_xmit);
  1598. debugfs_create_file("queues", S_IRUSR, sc->debug.debugfs_phy, sc,
  1599. &fops_queues);
  1600. debugfs_create_u32("qlen_bk", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1601. &sc->tx.txq_max_pending[IEEE80211_AC_BK]);
  1602. debugfs_create_u32("qlen_be", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1603. &sc->tx.txq_max_pending[IEEE80211_AC_BE]);
  1604. debugfs_create_u32("qlen_vi", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1605. &sc->tx.txq_max_pending[IEEE80211_AC_VI]);
  1606. debugfs_create_u32("qlen_vo", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1607. &sc->tx.txq_max_pending[IEEE80211_AC_VO]);
  1608. debugfs_create_file("misc", S_IRUSR, sc->debug.debugfs_phy, sc,
  1609. &fops_misc);
  1610. debugfs_create_file("reset", S_IRUSR, sc->debug.debugfs_phy, sc,
  1611. &fops_reset);
  1612. debugfs_create_file("recv", S_IRUSR, sc->debug.debugfs_phy, sc,
  1613. &fops_recv);
  1614. debugfs_create_file("rx_chainmask", S_IRUSR | S_IWUSR,
  1615. sc->debug.debugfs_phy, sc, &fops_rx_chainmask);
  1616. debugfs_create_file("tx_chainmask", S_IRUSR | S_IWUSR,
  1617. sc->debug.debugfs_phy, sc, &fops_tx_chainmask);
  1618. debugfs_create_file("ani", S_IRUSR | S_IWUSR,
  1619. sc->debug.debugfs_phy, sc, &fops_ani);
  1620. debugfs_create_bool("paprd", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1621. &sc->sc_ah->config.enable_paprd);
  1622. debugfs_create_file("regidx", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1623. sc, &fops_regidx);
  1624. debugfs_create_file("regval", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
  1625. sc, &fops_regval);
  1626. debugfs_create_bool("ignore_extcca", S_IRUSR | S_IWUSR,
  1627. sc->debug.debugfs_phy,
  1628. &ah->config.cwm_ignore_extcca);
  1629. debugfs_create_file("regdump", S_IRUSR, sc->debug.debugfs_phy, sc,
  1630. &fops_regdump);
  1631. debugfs_create_file("dump_nfcal", S_IRUSR, sc->debug.debugfs_phy, sc,
  1632. &fops_dump_nfcal);
  1633. debugfs_create_file("base_eeprom", S_IRUSR, sc->debug.debugfs_phy, sc,
  1634. &fops_base_eeprom);
  1635. debugfs_create_file("modal_eeprom", S_IRUSR, sc->debug.debugfs_phy, sc,
  1636. &fops_modal_eeprom);
  1637. sc->rfs_chan_spec_scan = relay_open("spectral_scan",
  1638. sc->debug.debugfs_phy,
  1639. 1024, 256, &rfs_spec_scan_cb,
  1640. NULL);
  1641. debugfs_create_file("spectral_scan_ctl", S_IRUSR | S_IWUSR,
  1642. sc->debug.debugfs_phy, sc,
  1643. &fops_spec_scan_ctl);
  1644. debugfs_create_file("spectral_short_repeat", S_IRUSR | S_IWUSR,
  1645. sc->debug.debugfs_phy, sc,
  1646. &fops_spectral_short_repeat);
  1647. debugfs_create_file("spectral_count", S_IRUSR | S_IWUSR,
  1648. sc->debug.debugfs_phy, sc, &fops_spectral_count);
  1649. debugfs_create_file("spectral_period", S_IRUSR | S_IWUSR,
  1650. sc->debug.debugfs_phy, sc, &fops_spectral_period);
  1651. debugfs_create_file("spectral_fft_period", S_IRUSR | S_IWUSR,
  1652. sc->debug.debugfs_phy, sc,
  1653. &fops_spectral_fft_period);
  1654. debugfs_create_u32("gpio_mask", S_IRUSR | S_IWUSR,
  1655. sc->debug.debugfs_phy, &sc->sc_ah->gpio_mask);
  1656. debugfs_create_u32("gpio_val", S_IRUSR | S_IWUSR,
  1657. sc->debug.debugfs_phy, &sc->sc_ah->gpio_val);
  1658. debugfs_create_file("antenna_diversity", S_IRUSR,
  1659. sc->debug.debugfs_phy, sc, &fops_antenna_diversity);
  1660. #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
  1661. debugfs_create_file("bt_ant_diversity", S_IRUSR | S_IWUSR,
  1662. sc->debug.debugfs_phy, sc, &fops_bt_ant_diversity);
  1663. debugfs_create_file("btcoex", S_IRUSR, sc->debug.debugfs_phy, sc,
  1664. &fops_btcoex);
  1665. #endif
  1666. return 0;
  1667. }