rt2800pci.c 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239
  1. /*
  2. Copyright (C) 2009 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
  3. Copyright (C) 2009 Alban Browaeys <prahal@yahoo.com>
  4. Copyright (C) 2009 Felix Fietkau <nbd@openwrt.org>
  5. Copyright (C) 2009 Luis Correia <luis.f.correia@gmail.com>
  6. Copyright (C) 2009 Mattias Nissler <mattias.nissler@gmx.de>
  7. Copyright (C) 2009 Mark Asselstine <asselsm@gmail.com>
  8. Copyright (C) 2009 Xose Vazquez Perez <xose.vazquez@gmail.com>
  9. Copyright (C) 2009 Bart Zolnierkiewicz <bzolnier@gmail.com>
  10. <http://rt2x00.serialmonkey.com>
  11. This program is free software; you can redistribute it and/or modify
  12. it under the terms of the GNU General Public License as published by
  13. the Free Software Foundation; either version 2 of the License, or
  14. (at your option) any later version.
  15. This program is distributed in the hope that it will be useful,
  16. but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. GNU General Public License for more details.
  19. You should have received a copy of the GNU General Public License
  20. along with this program; if not, write to the
  21. Free Software Foundation, Inc.,
  22. 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. */
  24. /*
  25. Module: rt2800pci
  26. Abstract: rt2800pci device specific routines.
  27. Supported chipsets: RT2800E & RT2800ED.
  28. */
  29. #include <linux/delay.h>
  30. #include <linux/etherdevice.h>
  31. #include <linux/init.h>
  32. #include <linux/kernel.h>
  33. #include <linux/module.h>
  34. #include <linux/pci.h>
  35. #include <linux/platform_device.h>
  36. #include <linux/eeprom_93cx6.h>
  37. #include "rt2x00.h"
  38. #include "rt2x00pci.h"
  39. #include "rt2x00soc.h"
  40. #include "rt2800lib.h"
  41. #include "rt2800.h"
  42. #include "rt2800pci.h"
  43. /*
  44. * Allow hardware encryption to be disabled.
  45. */
  46. static bool modparam_nohwcrypt = false;
  47. module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
  48. MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
  49. static void rt2800pci_mcu_status(struct rt2x00_dev *rt2x00dev, const u8 token)
  50. {
  51. unsigned int i;
  52. u32 reg;
  53. /*
  54. * SOC devices don't support MCU requests.
  55. */
  56. if (rt2x00_is_soc(rt2x00dev))
  57. return;
  58. for (i = 0; i < 200; i++) {
  59. rt2x00pci_register_read(rt2x00dev, H2M_MAILBOX_CID, &reg);
  60. if ((rt2x00_get_field32(reg, H2M_MAILBOX_CID_CMD0) == token) ||
  61. (rt2x00_get_field32(reg, H2M_MAILBOX_CID_CMD1) == token) ||
  62. (rt2x00_get_field32(reg, H2M_MAILBOX_CID_CMD2) == token) ||
  63. (rt2x00_get_field32(reg, H2M_MAILBOX_CID_CMD3) == token))
  64. break;
  65. udelay(REGISTER_BUSY_DELAY);
  66. }
  67. if (i == 200)
  68. ERROR(rt2x00dev, "MCU request failed, no response from hardware\n");
  69. rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0);
  70. rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0);
  71. }
  72. #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT305X)
  73. static void rt2800pci_read_eeprom_soc(struct rt2x00_dev *rt2x00dev)
  74. {
  75. void __iomem *base_addr = ioremap(0x1F040000, EEPROM_SIZE);
  76. memcpy_fromio(rt2x00dev->eeprom, base_addr, EEPROM_SIZE);
  77. iounmap(base_addr);
  78. }
  79. #else
  80. static inline void rt2800pci_read_eeprom_soc(struct rt2x00_dev *rt2x00dev)
  81. {
  82. }
  83. #endif /* CONFIG_RALINK_RT288X || CONFIG_RALINK_RT305X */
  84. #ifdef CONFIG_PCI
  85. static void rt2800pci_eepromregister_read(struct eeprom_93cx6 *eeprom)
  86. {
  87. struct rt2x00_dev *rt2x00dev = eeprom->data;
  88. u32 reg;
  89. rt2x00pci_register_read(rt2x00dev, E2PROM_CSR, &reg);
  90. eeprom->reg_data_in = !!rt2x00_get_field32(reg, E2PROM_CSR_DATA_IN);
  91. eeprom->reg_data_out = !!rt2x00_get_field32(reg, E2PROM_CSR_DATA_OUT);
  92. eeprom->reg_data_clock =
  93. !!rt2x00_get_field32(reg, E2PROM_CSR_DATA_CLOCK);
  94. eeprom->reg_chip_select =
  95. !!rt2x00_get_field32(reg, E2PROM_CSR_CHIP_SELECT);
  96. }
  97. static void rt2800pci_eepromregister_write(struct eeprom_93cx6 *eeprom)
  98. {
  99. struct rt2x00_dev *rt2x00dev = eeprom->data;
  100. u32 reg = 0;
  101. rt2x00_set_field32(&reg, E2PROM_CSR_DATA_IN, !!eeprom->reg_data_in);
  102. rt2x00_set_field32(&reg, E2PROM_CSR_DATA_OUT, !!eeprom->reg_data_out);
  103. rt2x00_set_field32(&reg, E2PROM_CSR_DATA_CLOCK,
  104. !!eeprom->reg_data_clock);
  105. rt2x00_set_field32(&reg, E2PROM_CSR_CHIP_SELECT,
  106. !!eeprom->reg_chip_select);
  107. rt2x00pci_register_write(rt2x00dev, E2PROM_CSR, reg);
  108. }
  109. static void rt2800pci_read_eeprom_pci(struct rt2x00_dev *rt2x00dev)
  110. {
  111. struct eeprom_93cx6 eeprom;
  112. u32 reg;
  113. rt2x00pci_register_read(rt2x00dev, E2PROM_CSR, &reg);
  114. eeprom.data = rt2x00dev;
  115. eeprom.register_read = rt2800pci_eepromregister_read;
  116. eeprom.register_write = rt2800pci_eepromregister_write;
  117. switch (rt2x00_get_field32(reg, E2PROM_CSR_TYPE))
  118. {
  119. case 0:
  120. eeprom.width = PCI_EEPROM_WIDTH_93C46;
  121. break;
  122. case 1:
  123. eeprom.width = PCI_EEPROM_WIDTH_93C66;
  124. break;
  125. default:
  126. eeprom.width = PCI_EEPROM_WIDTH_93C86;
  127. break;
  128. }
  129. eeprom.reg_data_in = 0;
  130. eeprom.reg_data_out = 0;
  131. eeprom.reg_data_clock = 0;
  132. eeprom.reg_chip_select = 0;
  133. eeprom_93cx6_multiread(&eeprom, EEPROM_BASE, rt2x00dev->eeprom,
  134. EEPROM_SIZE / sizeof(u16));
  135. }
  136. static int rt2800pci_efuse_detect(struct rt2x00_dev *rt2x00dev)
  137. {
  138. return rt2800_efuse_detect(rt2x00dev);
  139. }
  140. static inline void rt2800pci_read_eeprom_efuse(struct rt2x00_dev *rt2x00dev)
  141. {
  142. rt2800_read_eeprom_efuse(rt2x00dev);
  143. }
  144. #else
  145. static inline void rt2800pci_read_eeprom_pci(struct rt2x00_dev *rt2x00dev)
  146. {
  147. }
  148. static inline int rt2800pci_efuse_detect(struct rt2x00_dev *rt2x00dev)
  149. {
  150. return 0;
  151. }
  152. static inline void rt2800pci_read_eeprom_efuse(struct rt2x00_dev *rt2x00dev)
  153. {
  154. }
  155. #endif /* CONFIG_PCI */
  156. /*
  157. * Queue handlers.
  158. */
  159. static void rt2800pci_start_queue(struct data_queue *queue)
  160. {
  161. struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
  162. u32 reg;
  163. switch (queue->qid) {
  164. case QID_RX:
  165. rt2x00pci_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
  166. rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 1);
  167. rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
  168. break;
  169. case QID_BEACON:
  170. rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
  171. rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1);
  172. rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1);
  173. rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 1);
  174. rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg);
  175. rt2x00pci_register_read(rt2x00dev, INT_TIMER_EN, &reg);
  176. rt2x00_set_field32(&reg, INT_TIMER_EN_PRE_TBTT_TIMER, 1);
  177. rt2x00pci_register_write(rt2x00dev, INT_TIMER_EN, reg);
  178. break;
  179. default:
  180. break;
  181. }
  182. }
  183. static void rt2800pci_kick_queue(struct data_queue *queue)
  184. {
  185. struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
  186. struct queue_entry *entry;
  187. switch (queue->qid) {
  188. case QID_AC_VO:
  189. case QID_AC_VI:
  190. case QID_AC_BE:
  191. case QID_AC_BK:
  192. entry = rt2x00queue_get_entry(queue, Q_INDEX);
  193. rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX(queue->qid),
  194. entry->entry_idx);
  195. break;
  196. case QID_MGMT:
  197. entry = rt2x00queue_get_entry(queue, Q_INDEX);
  198. rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX(5),
  199. entry->entry_idx);
  200. break;
  201. default:
  202. break;
  203. }
  204. }
  205. static void rt2800pci_stop_queue(struct data_queue *queue)
  206. {
  207. struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
  208. u32 reg;
  209. switch (queue->qid) {
  210. case QID_RX:
  211. rt2x00pci_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
  212. rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 0);
  213. rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
  214. break;
  215. case QID_BEACON:
  216. rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
  217. rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0);
  218. rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0);
  219. rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0);
  220. rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg);
  221. rt2x00pci_register_read(rt2x00dev, INT_TIMER_EN, &reg);
  222. rt2x00_set_field32(&reg, INT_TIMER_EN_PRE_TBTT_TIMER, 0);
  223. rt2x00pci_register_write(rt2x00dev, INT_TIMER_EN, reg);
  224. /*
  225. * Wait for current invocation to finish. The tasklet
  226. * won't be scheduled anymore afterwards since we disabled
  227. * the TBTT and PRE TBTT timer.
  228. */
  229. tasklet_kill(&rt2x00dev->tbtt_tasklet);
  230. tasklet_kill(&rt2x00dev->pretbtt_tasklet);
  231. break;
  232. default:
  233. break;
  234. }
  235. }
  236. /*
  237. * Firmware functions
  238. */
  239. static char *rt2800pci_get_firmware_name(struct rt2x00_dev *rt2x00dev)
  240. {
  241. return FIRMWARE_RT2860;
  242. }
  243. static int rt2800pci_write_firmware(struct rt2x00_dev *rt2x00dev,
  244. const u8 *data, const size_t len)
  245. {
  246. u32 reg;
  247. /*
  248. * enable Host program ram write selection
  249. */
  250. reg = 0;
  251. rt2x00_set_field32(&reg, PBF_SYS_CTRL_HOST_RAM_WRITE, 1);
  252. rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, reg);
  253. /*
  254. * Write firmware to device.
  255. */
  256. rt2x00pci_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE,
  257. data, len);
  258. rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000);
  259. rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00001);
  260. rt2x00pci_register_write(rt2x00dev, H2M_BBP_AGENT, 0);
  261. rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0);
  262. return 0;
  263. }
  264. /*
  265. * Initialization functions.
  266. */
  267. static bool rt2800pci_get_entry_state(struct queue_entry *entry)
  268. {
  269. struct queue_entry_priv_pci *entry_priv = entry->priv_data;
  270. u32 word;
  271. if (entry->queue->qid == QID_RX) {
  272. rt2x00_desc_read(entry_priv->desc, 1, &word);
  273. return (!rt2x00_get_field32(word, RXD_W1_DMA_DONE));
  274. } else {
  275. rt2x00_desc_read(entry_priv->desc, 1, &word);
  276. return (!rt2x00_get_field32(word, TXD_W1_DMA_DONE));
  277. }
  278. }
  279. static void rt2800pci_clear_entry(struct queue_entry *entry)
  280. {
  281. struct queue_entry_priv_pci *entry_priv = entry->priv_data;
  282. struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
  283. struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
  284. u32 word;
  285. if (entry->queue->qid == QID_RX) {
  286. rt2x00_desc_read(entry_priv->desc, 0, &word);
  287. rt2x00_set_field32(&word, RXD_W0_SDP0, skbdesc->skb_dma);
  288. rt2x00_desc_write(entry_priv->desc, 0, word);
  289. rt2x00_desc_read(entry_priv->desc, 1, &word);
  290. rt2x00_set_field32(&word, RXD_W1_DMA_DONE, 0);
  291. rt2x00_desc_write(entry_priv->desc, 1, word);
  292. /*
  293. * Set RX IDX in register to inform hardware that we have
  294. * handled this entry and it is available for reuse again.
  295. */
  296. rt2x00pci_register_write(rt2x00dev, RX_CRX_IDX,
  297. entry->entry_idx);
  298. } else {
  299. rt2x00_desc_read(entry_priv->desc, 1, &word);
  300. rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 1);
  301. rt2x00_desc_write(entry_priv->desc, 1, word);
  302. }
  303. }
  304. static int rt2800pci_init_queues(struct rt2x00_dev *rt2x00dev)
  305. {
  306. struct queue_entry_priv_pci *entry_priv;
  307. u32 reg;
  308. /*
  309. * Initialize registers.
  310. */
  311. entry_priv = rt2x00dev->tx[0].entries[0].priv_data;
  312. rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR0, entry_priv->desc_dma);
  313. rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT0,
  314. rt2x00dev->tx[0].limit);
  315. rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX0, 0);
  316. rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX0, 0);
  317. entry_priv = rt2x00dev->tx[1].entries[0].priv_data;
  318. rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR1, entry_priv->desc_dma);
  319. rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT1,
  320. rt2x00dev->tx[1].limit);
  321. rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX1, 0);
  322. rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX1, 0);
  323. entry_priv = rt2x00dev->tx[2].entries[0].priv_data;
  324. rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR2, entry_priv->desc_dma);
  325. rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT2,
  326. rt2x00dev->tx[2].limit);
  327. rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX2, 0);
  328. rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX2, 0);
  329. entry_priv = rt2x00dev->tx[3].entries[0].priv_data;
  330. rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR3, entry_priv->desc_dma);
  331. rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT3,
  332. rt2x00dev->tx[3].limit);
  333. rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX3, 0);
  334. rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX3, 0);
  335. entry_priv = rt2x00dev->rx->entries[0].priv_data;
  336. rt2x00pci_register_write(rt2x00dev, RX_BASE_PTR, entry_priv->desc_dma);
  337. rt2x00pci_register_write(rt2x00dev, RX_MAX_CNT,
  338. rt2x00dev->rx[0].limit);
  339. rt2x00pci_register_write(rt2x00dev, RX_CRX_IDX,
  340. rt2x00dev->rx[0].limit - 1);
  341. rt2x00pci_register_write(rt2x00dev, RX_DRX_IDX, 0);
  342. /*
  343. * Enable global DMA configuration
  344. */
  345. rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg);
  346. rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0);
  347. rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0);
  348. rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1);
  349. rt2x00pci_register_write(rt2x00dev, WPDMA_GLO_CFG, reg);
  350. rt2x00pci_register_write(rt2x00dev, DELAY_INT_CFG, 0);
  351. return 0;
  352. }
  353. /*
  354. * Device state switch handlers.
  355. */
  356. static void rt2800pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
  357. enum dev_state state)
  358. {
  359. u32 reg;
  360. unsigned long flags;
  361. /*
  362. * When interrupts are being enabled, the interrupt registers
  363. * should clear the register to assure a clean state.
  364. */
  365. if (state == STATE_RADIO_IRQ_ON) {
  366. rt2x00pci_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);
  367. rt2x00pci_register_write(rt2x00dev, INT_SOURCE_CSR, reg);
  368. }
  369. spin_lock_irqsave(&rt2x00dev->irqmask_lock, flags);
  370. reg = 0;
  371. if (state == STATE_RADIO_IRQ_ON) {
  372. rt2x00_set_field32(&reg, INT_MASK_CSR_RX_DONE, 1);
  373. rt2x00_set_field32(&reg, INT_MASK_CSR_TBTT, 1);
  374. rt2x00_set_field32(&reg, INT_MASK_CSR_PRE_TBTT, 1);
  375. rt2x00_set_field32(&reg, INT_MASK_CSR_TX_FIFO_STATUS, 1);
  376. rt2x00_set_field32(&reg, INT_MASK_CSR_AUTO_WAKEUP, 1);
  377. }
  378. rt2x00pci_register_write(rt2x00dev, INT_MASK_CSR, reg);
  379. spin_unlock_irqrestore(&rt2x00dev->irqmask_lock, flags);
  380. if (state == STATE_RADIO_IRQ_OFF) {
  381. /*
  382. * Wait for possibly running tasklets to finish.
  383. */
  384. tasklet_kill(&rt2x00dev->txstatus_tasklet);
  385. tasklet_kill(&rt2x00dev->rxdone_tasklet);
  386. tasklet_kill(&rt2x00dev->autowake_tasklet);
  387. tasklet_kill(&rt2x00dev->tbtt_tasklet);
  388. tasklet_kill(&rt2x00dev->pretbtt_tasklet);
  389. }
  390. }
  391. static int rt2800pci_init_registers(struct rt2x00_dev *rt2x00dev)
  392. {
  393. u32 reg;
  394. /*
  395. * Reset DMA indexes
  396. */
  397. rt2x00pci_register_read(rt2x00dev, WPDMA_RST_IDX, &reg);
  398. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX0, 1);
  399. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX1, 1);
  400. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX2, 1);
  401. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX3, 1);
  402. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX4, 1);
  403. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX5, 1);
  404. rt2x00_set_field32(&reg, WPDMA_RST_IDX_DRX_IDX0, 1);
  405. rt2x00pci_register_write(rt2x00dev, WPDMA_RST_IDX, reg);
  406. rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e1f);
  407. rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e00);
  408. if (rt2x00_is_pcie(rt2x00dev) &&
  409. (rt2x00_rt(rt2x00dev, RT3572) ||
  410. rt2x00_rt(rt2x00dev, RT5390) ||
  411. rt2x00_rt(rt2x00dev, RT5392))) {
  412. rt2x00pci_register_read(rt2x00dev, AUX_CTRL, &reg);
  413. rt2x00_set_field32(&reg, AUX_CTRL_FORCE_PCIE_CLK, 1);
  414. rt2x00_set_field32(&reg, AUX_CTRL_WAKE_PCIE_EN, 1);
  415. rt2x00pci_register_write(rt2x00dev, AUX_CTRL, reg);
  416. }
  417. rt2x00pci_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003);
  418. reg = 0;
  419. rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_CSR, 1);
  420. rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_BBP, 1);
  421. rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
  422. rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000);
  423. return 0;
  424. }
  425. static int rt2800pci_enable_radio(struct rt2x00_dev *rt2x00dev)
  426. {
  427. if (unlikely(rt2800_wait_wpdma_ready(rt2x00dev) ||
  428. rt2800pci_init_queues(rt2x00dev)))
  429. return -EIO;
  430. return rt2800_enable_radio(rt2x00dev);
  431. }
  432. static void rt2800pci_disable_radio(struct rt2x00_dev *rt2x00dev)
  433. {
  434. if (rt2x00_is_soc(rt2x00dev)) {
  435. rt2800_disable_radio(rt2x00dev);
  436. rt2x00pci_register_write(rt2x00dev, PWR_PIN_CFG, 0);
  437. rt2x00pci_register_write(rt2x00dev, TX_PIN_CFG, 0);
  438. }
  439. }
  440. static int rt2800pci_set_state(struct rt2x00_dev *rt2x00dev,
  441. enum dev_state state)
  442. {
  443. if (state == STATE_AWAKE) {
  444. rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, TOKEN_WAKEUP,
  445. 0, 0x02);
  446. rt2800pci_mcu_status(rt2x00dev, TOKEN_WAKEUP);
  447. } else if (state == STATE_SLEEP) {
  448. rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_STATUS,
  449. 0xffffffff);
  450. rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CID,
  451. 0xffffffff);
  452. rt2800_mcu_request(rt2x00dev, MCU_SLEEP, TOKEN_SLEEP,
  453. 0xff, 0x01);
  454. }
  455. return 0;
  456. }
  457. static int rt2800pci_set_device_state(struct rt2x00_dev *rt2x00dev,
  458. enum dev_state state)
  459. {
  460. int retval = 0;
  461. switch (state) {
  462. case STATE_RADIO_ON:
  463. /*
  464. * Before the radio can be enabled, the device first has
  465. * to be woken up. After that it needs a bit of time
  466. * to be fully awake and then the radio can be enabled.
  467. */
  468. rt2800pci_set_state(rt2x00dev, STATE_AWAKE);
  469. msleep(1);
  470. retval = rt2800pci_enable_radio(rt2x00dev);
  471. break;
  472. case STATE_RADIO_OFF:
  473. /*
  474. * After the radio has been disabled, the device should
  475. * be put to sleep for powersaving.
  476. */
  477. rt2800pci_disable_radio(rt2x00dev);
  478. rt2800pci_set_state(rt2x00dev, STATE_SLEEP);
  479. break;
  480. case STATE_RADIO_IRQ_ON:
  481. case STATE_RADIO_IRQ_OFF:
  482. rt2800pci_toggle_irq(rt2x00dev, state);
  483. break;
  484. case STATE_DEEP_SLEEP:
  485. case STATE_SLEEP:
  486. case STATE_STANDBY:
  487. case STATE_AWAKE:
  488. retval = rt2800pci_set_state(rt2x00dev, state);
  489. break;
  490. default:
  491. retval = -ENOTSUPP;
  492. break;
  493. }
  494. if (unlikely(retval))
  495. ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
  496. state, retval);
  497. return retval;
  498. }
  499. /*
  500. * TX descriptor initialization
  501. */
  502. static __le32 *rt2800pci_get_txwi(struct queue_entry *entry)
  503. {
  504. return (__le32 *) entry->skb->data;
  505. }
  506. static void rt2800pci_write_tx_desc(struct queue_entry *entry,
  507. struct txentry_desc *txdesc)
  508. {
  509. struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
  510. struct queue_entry_priv_pci *entry_priv = entry->priv_data;
  511. __le32 *txd = entry_priv->desc;
  512. u32 word;
  513. /*
  514. * The buffers pointed by SD_PTR0/SD_LEN0 and SD_PTR1/SD_LEN1
  515. * must contains a TXWI structure + 802.11 header + padding + 802.11
  516. * data. We choose to have SD_PTR0/SD_LEN0 only contains TXWI and
  517. * SD_PTR1/SD_LEN1 contains 802.11 header + padding + 802.11
  518. * data. It means that LAST_SEC0 is always 0.
  519. */
  520. /*
  521. * Initialize TX descriptor
  522. */
  523. word = 0;
  524. rt2x00_set_field32(&word, TXD_W0_SD_PTR0, skbdesc->skb_dma);
  525. rt2x00_desc_write(txd, 0, word);
  526. word = 0;
  527. rt2x00_set_field32(&word, TXD_W1_SD_LEN1, entry->skb->len);
  528. rt2x00_set_field32(&word, TXD_W1_LAST_SEC1,
  529. !test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags));
  530. rt2x00_set_field32(&word, TXD_W1_BURST,
  531. test_bit(ENTRY_TXD_BURST, &txdesc->flags));
  532. rt2x00_set_field32(&word, TXD_W1_SD_LEN0, TXWI_DESC_SIZE);
  533. rt2x00_set_field32(&word, TXD_W1_LAST_SEC0, 0);
  534. rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 0);
  535. rt2x00_desc_write(txd, 1, word);
  536. word = 0;
  537. rt2x00_set_field32(&word, TXD_W2_SD_PTR1,
  538. skbdesc->skb_dma + TXWI_DESC_SIZE);
  539. rt2x00_desc_write(txd, 2, word);
  540. word = 0;
  541. rt2x00_set_field32(&word, TXD_W3_WIV,
  542. !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags));
  543. rt2x00_set_field32(&word, TXD_W3_QSEL, 2);
  544. rt2x00_desc_write(txd, 3, word);
  545. /*
  546. * Register descriptor details in skb frame descriptor.
  547. */
  548. skbdesc->desc = txd;
  549. skbdesc->desc_len = TXD_DESC_SIZE;
  550. }
  551. /*
  552. * RX control handlers
  553. */
  554. static void rt2800pci_fill_rxdone(struct queue_entry *entry,
  555. struct rxdone_entry_desc *rxdesc)
  556. {
  557. struct queue_entry_priv_pci *entry_priv = entry->priv_data;
  558. __le32 *rxd = entry_priv->desc;
  559. u32 word;
  560. rt2x00_desc_read(rxd, 3, &word);
  561. if (rt2x00_get_field32(word, RXD_W3_CRC_ERROR))
  562. rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC;
  563. /*
  564. * Unfortunately we don't know the cipher type used during
  565. * decryption. This prevents us from correct providing
  566. * correct statistics through debugfs.
  567. */
  568. rxdesc->cipher_status = rt2x00_get_field32(word, RXD_W3_CIPHER_ERROR);
  569. if (rt2x00_get_field32(word, RXD_W3_DECRYPTED)) {
  570. /*
  571. * Hardware has stripped IV/EIV data from 802.11 frame during
  572. * decryption. Unfortunately the descriptor doesn't contain
  573. * any fields with the EIV/IV data either, so they can't
  574. * be restored by rt2x00lib.
  575. */
  576. rxdesc->flags |= RX_FLAG_IV_STRIPPED;
  577. /*
  578. * The hardware has already checked the Michael Mic and has
  579. * stripped it from the frame. Signal this to mac80211.
  580. */
  581. rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
  582. if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS)
  583. rxdesc->flags |= RX_FLAG_DECRYPTED;
  584. else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC)
  585. rxdesc->flags |= RX_FLAG_MMIC_ERROR;
  586. }
  587. if (rt2x00_get_field32(word, RXD_W3_MY_BSS))
  588. rxdesc->dev_flags |= RXDONE_MY_BSS;
  589. if (rt2x00_get_field32(word, RXD_W3_L2PAD))
  590. rxdesc->dev_flags |= RXDONE_L2PAD;
  591. /*
  592. * Process the RXWI structure that is at the start of the buffer.
  593. */
  594. rt2800_process_rxwi(entry, rxdesc);
  595. }
  596. /*
  597. * Interrupt functions.
  598. */
  599. static void rt2800pci_wakeup(struct rt2x00_dev *rt2x00dev)
  600. {
  601. struct ieee80211_conf conf = { .flags = 0 };
  602. struct rt2x00lib_conf libconf = { .conf = &conf };
  603. rt2800_config(rt2x00dev, &libconf, IEEE80211_CONF_CHANGE_PS);
  604. }
  605. static bool rt2800pci_txdone(struct rt2x00_dev *rt2x00dev)
  606. {
  607. struct data_queue *queue;
  608. struct queue_entry *entry;
  609. u32 status;
  610. u8 qid;
  611. int max_tx_done = 16;
  612. while (kfifo_get(&rt2x00dev->txstatus_fifo, &status)) {
  613. qid = rt2x00_get_field32(status, TX_STA_FIFO_PID_QUEUE);
  614. if (unlikely(qid >= QID_RX)) {
  615. /*
  616. * Unknown queue, this shouldn't happen. Just drop
  617. * this tx status.
  618. */
  619. WARNING(rt2x00dev, "Got TX status report with "
  620. "unexpected pid %u, dropping\n", qid);
  621. break;
  622. }
  623. queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
  624. if (unlikely(queue == NULL)) {
  625. /*
  626. * The queue is NULL, this shouldn't happen. Stop
  627. * processing here and drop the tx status
  628. */
  629. WARNING(rt2x00dev, "Got TX status for an unavailable "
  630. "queue %u, dropping\n", qid);
  631. break;
  632. }
  633. if (unlikely(rt2x00queue_empty(queue))) {
  634. /*
  635. * The queue is empty. Stop processing here
  636. * and drop the tx status.
  637. */
  638. WARNING(rt2x00dev, "Got TX status for an empty "
  639. "queue %u, dropping\n", qid);
  640. break;
  641. }
  642. entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
  643. rt2800_txdone_entry(entry, status, rt2800pci_get_txwi(entry));
  644. if (--max_tx_done == 0)
  645. break;
  646. }
  647. return !max_tx_done;
  648. }
  649. static inline void rt2800pci_enable_interrupt(struct rt2x00_dev *rt2x00dev,
  650. struct rt2x00_field32 irq_field)
  651. {
  652. u32 reg;
  653. /*
  654. * Enable a single interrupt. The interrupt mask register
  655. * access needs locking.
  656. */
  657. spin_lock_irq(&rt2x00dev->irqmask_lock);
  658. rt2x00pci_register_read(rt2x00dev, INT_MASK_CSR, &reg);
  659. rt2x00_set_field32(&reg, irq_field, 1);
  660. rt2x00pci_register_write(rt2x00dev, INT_MASK_CSR, reg);
  661. spin_unlock_irq(&rt2x00dev->irqmask_lock);
  662. }
  663. static void rt2800pci_txstatus_tasklet(unsigned long data)
  664. {
  665. struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
  666. if (rt2800pci_txdone(rt2x00dev))
  667. tasklet_schedule(&rt2x00dev->txstatus_tasklet);
  668. /*
  669. * No need to enable the tx status interrupt here as we always
  670. * leave it enabled to minimize the possibility of a tx status
  671. * register overflow. See comment in interrupt handler.
  672. */
  673. }
  674. static void rt2800pci_pretbtt_tasklet(unsigned long data)
  675. {
  676. struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
  677. rt2x00lib_pretbtt(rt2x00dev);
  678. if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
  679. rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_PRE_TBTT);
  680. }
  681. static void rt2800pci_tbtt_tasklet(unsigned long data)
  682. {
  683. struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
  684. rt2x00lib_beacondone(rt2x00dev);
  685. if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
  686. rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_TBTT);
  687. }
  688. static void rt2800pci_rxdone_tasklet(unsigned long data)
  689. {
  690. struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
  691. if (rt2x00pci_rxdone(rt2x00dev))
  692. tasklet_schedule(&rt2x00dev->rxdone_tasklet);
  693. else if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
  694. rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_RX_DONE);
  695. }
  696. static void rt2800pci_autowake_tasklet(unsigned long data)
  697. {
  698. struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
  699. rt2800pci_wakeup(rt2x00dev);
  700. if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
  701. rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_AUTO_WAKEUP);
  702. }
  703. static void rt2800pci_txstatus_interrupt(struct rt2x00_dev *rt2x00dev)
  704. {
  705. u32 status;
  706. int i;
  707. /*
  708. * The TX_FIFO_STATUS interrupt needs special care. We should
  709. * read TX_STA_FIFO but we should do it immediately as otherwise
  710. * the register can overflow and we would lose status reports.
  711. *
  712. * Hence, read the TX_STA_FIFO register and copy all tx status
  713. * reports into a kernel FIFO which is handled in the txstatus
  714. * tasklet. We use a tasklet to process the tx status reports
  715. * because we can schedule the tasklet multiple times (when the
  716. * interrupt fires again during tx status processing).
  717. *
  718. * Furthermore we don't disable the TX_FIFO_STATUS
  719. * interrupt here but leave it enabled so that the TX_STA_FIFO
  720. * can also be read while the tx status tasklet gets executed.
  721. *
  722. * Since we have only one producer and one consumer we don't
  723. * need to lock the kfifo.
  724. */
  725. for (i = 0; i < rt2x00dev->ops->tx->entry_num; i++) {
  726. rt2x00pci_register_read(rt2x00dev, TX_STA_FIFO, &status);
  727. if (!rt2x00_get_field32(status, TX_STA_FIFO_VALID))
  728. break;
  729. if (!kfifo_put(&rt2x00dev->txstatus_fifo, &status)) {
  730. WARNING(rt2x00dev, "TX status FIFO overrun,"
  731. "drop tx status report.\n");
  732. break;
  733. }
  734. }
  735. /* Schedule the tasklet for processing the tx status. */
  736. tasklet_schedule(&rt2x00dev->txstatus_tasklet);
  737. }
  738. static irqreturn_t rt2800pci_interrupt(int irq, void *dev_instance)
  739. {
  740. struct rt2x00_dev *rt2x00dev = dev_instance;
  741. u32 reg, mask;
  742. /* Read status and ACK all interrupts */
  743. rt2x00pci_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);
  744. rt2x00pci_register_write(rt2x00dev, INT_SOURCE_CSR, reg);
  745. if (!reg)
  746. return IRQ_NONE;
  747. if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
  748. return IRQ_HANDLED;
  749. /*
  750. * Since INT_MASK_CSR and INT_SOURCE_CSR use the same bits
  751. * for interrupts and interrupt masks we can just use the value of
  752. * INT_SOURCE_CSR to create the interrupt mask.
  753. */
  754. mask = ~reg;
  755. if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TX_FIFO_STATUS)) {
  756. rt2800pci_txstatus_interrupt(rt2x00dev);
  757. /*
  758. * Never disable the TX_FIFO_STATUS interrupt.
  759. */
  760. rt2x00_set_field32(&mask, INT_MASK_CSR_TX_FIFO_STATUS, 1);
  761. }
  762. if (rt2x00_get_field32(reg, INT_SOURCE_CSR_PRE_TBTT))
  763. tasklet_hi_schedule(&rt2x00dev->pretbtt_tasklet);
  764. if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TBTT))
  765. tasklet_hi_schedule(&rt2x00dev->tbtt_tasklet);
  766. if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE))
  767. tasklet_schedule(&rt2x00dev->rxdone_tasklet);
  768. if (rt2x00_get_field32(reg, INT_SOURCE_CSR_AUTO_WAKEUP))
  769. tasklet_schedule(&rt2x00dev->autowake_tasklet);
  770. /*
  771. * Disable all interrupts for which a tasklet was scheduled right now,
  772. * the tasklet will reenable the appropriate interrupts.
  773. */
  774. spin_lock(&rt2x00dev->irqmask_lock);
  775. rt2x00pci_register_read(rt2x00dev, INT_MASK_CSR, &reg);
  776. reg &= mask;
  777. rt2x00pci_register_write(rt2x00dev, INT_MASK_CSR, reg);
  778. spin_unlock(&rt2x00dev->irqmask_lock);
  779. return IRQ_HANDLED;
  780. }
  781. /*
  782. * Device probe functions.
  783. */
  784. static int rt2800pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
  785. {
  786. /*
  787. * Read EEPROM into buffer
  788. */
  789. if (rt2x00_is_soc(rt2x00dev))
  790. rt2800pci_read_eeprom_soc(rt2x00dev);
  791. else if (rt2800pci_efuse_detect(rt2x00dev))
  792. rt2800pci_read_eeprom_efuse(rt2x00dev);
  793. else
  794. rt2800pci_read_eeprom_pci(rt2x00dev);
  795. return rt2800_validate_eeprom(rt2x00dev);
  796. }
  797. static int rt2800pci_probe_hw(struct rt2x00_dev *rt2x00dev)
  798. {
  799. int retval;
  800. /*
  801. * Allocate eeprom data.
  802. */
  803. retval = rt2800pci_validate_eeprom(rt2x00dev);
  804. if (retval)
  805. return retval;
  806. retval = rt2800_init_eeprom(rt2x00dev);
  807. if (retval)
  808. return retval;
  809. /*
  810. * Initialize hw specifications.
  811. */
  812. retval = rt2800_probe_hw_mode(rt2x00dev);
  813. if (retval)
  814. return retval;
  815. /*
  816. * This device has multiple filters for control frames
  817. * and has a separate filter for PS Poll frames.
  818. */
  819. __set_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags);
  820. __set_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags);
  821. /*
  822. * This device has a pre tbtt interrupt and thus fetches
  823. * a new beacon directly prior to transmission.
  824. */
  825. __set_bit(CAPABILITY_PRE_TBTT_INTERRUPT, &rt2x00dev->cap_flags);
  826. /*
  827. * This device requires firmware.
  828. */
  829. if (!rt2x00_is_soc(rt2x00dev))
  830. __set_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags);
  831. __set_bit(REQUIRE_DMA, &rt2x00dev->cap_flags);
  832. __set_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags);
  833. __set_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags);
  834. __set_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags);
  835. if (!modparam_nohwcrypt)
  836. __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
  837. __set_bit(CAPABILITY_LINK_TUNING, &rt2x00dev->cap_flags);
  838. __set_bit(REQUIRE_HT_TX_DESC, &rt2x00dev->cap_flags);
  839. /*
  840. * Set the rssi offset.
  841. */
  842. rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET;
  843. return 0;
  844. }
  845. static const struct ieee80211_ops rt2800pci_mac80211_ops = {
  846. .tx = rt2x00mac_tx,
  847. .start = rt2x00mac_start,
  848. .stop = rt2x00mac_stop,
  849. .add_interface = rt2x00mac_add_interface,
  850. .remove_interface = rt2x00mac_remove_interface,
  851. .config = rt2x00mac_config,
  852. .configure_filter = rt2x00mac_configure_filter,
  853. .set_key = rt2x00mac_set_key,
  854. .sw_scan_start = rt2x00mac_sw_scan_start,
  855. .sw_scan_complete = rt2x00mac_sw_scan_complete,
  856. .get_stats = rt2x00mac_get_stats,
  857. .get_tkip_seq = rt2800_get_tkip_seq,
  858. .set_rts_threshold = rt2800_set_rts_threshold,
  859. .sta_add = rt2x00mac_sta_add,
  860. .sta_remove = rt2x00mac_sta_remove,
  861. .bss_info_changed = rt2x00mac_bss_info_changed,
  862. .conf_tx = rt2800_conf_tx,
  863. .get_tsf = rt2800_get_tsf,
  864. .rfkill_poll = rt2x00mac_rfkill_poll,
  865. .ampdu_action = rt2800_ampdu_action,
  866. .flush = rt2x00mac_flush,
  867. .get_survey = rt2800_get_survey,
  868. .get_ringparam = rt2x00mac_get_ringparam,
  869. .tx_frames_pending = rt2x00mac_tx_frames_pending,
  870. };
  871. static const struct rt2800_ops rt2800pci_rt2800_ops = {
  872. .register_read = rt2x00pci_register_read,
  873. .register_read_lock = rt2x00pci_register_read, /* same for PCI */
  874. .register_write = rt2x00pci_register_write,
  875. .register_write_lock = rt2x00pci_register_write, /* same for PCI */
  876. .register_multiread = rt2x00pci_register_multiread,
  877. .register_multiwrite = rt2x00pci_register_multiwrite,
  878. .regbusy_read = rt2x00pci_regbusy_read,
  879. .drv_write_firmware = rt2800pci_write_firmware,
  880. .drv_init_registers = rt2800pci_init_registers,
  881. .drv_get_txwi = rt2800pci_get_txwi,
  882. };
  883. static const struct rt2x00lib_ops rt2800pci_rt2x00_ops = {
  884. .irq_handler = rt2800pci_interrupt,
  885. .txstatus_tasklet = rt2800pci_txstatus_tasklet,
  886. .pretbtt_tasklet = rt2800pci_pretbtt_tasklet,
  887. .tbtt_tasklet = rt2800pci_tbtt_tasklet,
  888. .rxdone_tasklet = rt2800pci_rxdone_tasklet,
  889. .autowake_tasklet = rt2800pci_autowake_tasklet,
  890. .probe_hw = rt2800pci_probe_hw,
  891. .get_firmware_name = rt2800pci_get_firmware_name,
  892. .check_firmware = rt2800_check_firmware,
  893. .load_firmware = rt2800_load_firmware,
  894. .initialize = rt2x00pci_initialize,
  895. .uninitialize = rt2x00pci_uninitialize,
  896. .get_entry_state = rt2800pci_get_entry_state,
  897. .clear_entry = rt2800pci_clear_entry,
  898. .set_device_state = rt2800pci_set_device_state,
  899. .rfkill_poll = rt2800_rfkill_poll,
  900. .link_stats = rt2800_link_stats,
  901. .reset_tuner = rt2800_reset_tuner,
  902. .link_tuner = rt2800_link_tuner,
  903. .gain_calibration = rt2800_gain_calibration,
  904. .vco_calibration = rt2800_vco_calibration,
  905. .start_queue = rt2800pci_start_queue,
  906. .kick_queue = rt2800pci_kick_queue,
  907. .stop_queue = rt2800pci_stop_queue,
  908. .flush_queue = rt2x00pci_flush_queue,
  909. .write_tx_desc = rt2800pci_write_tx_desc,
  910. .write_tx_data = rt2800_write_tx_data,
  911. .write_beacon = rt2800_write_beacon,
  912. .clear_beacon = rt2800_clear_beacon,
  913. .fill_rxdone = rt2800pci_fill_rxdone,
  914. .config_shared_key = rt2800_config_shared_key,
  915. .config_pairwise_key = rt2800_config_pairwise_key,
  916. .config_filter = rt2800_config_filter,
  917. .config_intf = rt2800_config_intf,
  918. .config_erp = rt2800_config_erp,
  919. .config_ant = rt2800_config_ant,
  920. .config = rt2800_config,
  921. .sta_add = rt2800_sta_add,
  922. .sta_remove = rt2800_sta_remove,
  923. };
  924. static const struct data_queue_desc rt2800pci_queue_rx = {
  925. .entry_num = 128,
  926. .data_size = AGGREGATION_SIZE,
  927. .desc_size = RXD_DESC_SIZE,
  928. .priv_size = sizeof(struct queue_entry_priv_pci),
  929. };
  930. static const struct data_queue_desc rt2800pci_queue_tx = {
  931. .entry_num = 64,
  932. .data_size = AGGREGATION_SIZE,
  933. .desc_size = TXD_DESC_SIZE,
  934. .priv_size = sizeof(struct queue_entry_priv_pci),
  935. };
  936. static const struct data_queue_desc rt2800pci_queue_bcn = {
  937. .entry_num = 8,
  938. .data_size = 0, /* No DMA required for beacons */
  939. .desc_size = TXWI_DESC_SIZE,
  940. .priv_size = sizeof(struct queue_entry_priv_pci),
  941. };
  942. static const struct rt2x00_ops rt2800pci_ops = {
  943. .name = KBUILD_MODNAME,
  944. .drv_data_size = sizeof(struct rt2800_drv_data),
  945. .max_sta_intf = 1,
  946. .max_ap_intf = 8,
  947. .eeprom_size = EEPROM_SIZE,
  948. .rf_size = RF_SIZE,
  949. .tx_queues = NUM_TX_QUEUES,
  950. .extra_tx_headroom = TXWI_DESC_SIZE,
  951. .rx = &rt2800pci_queue_rx,
  952. .tx = &rt2800pci_queue_tx,
  953. .bcn = &rt2800pci_queue_bcn,
  954. .lib = &rt2800pci_rt2x00_ops,
  955. .drv = &rt2800pci_rt2800_ops,
  956. .hw = &rt2800pci_mac80211_ops,
  957. #ifdef CONFIG_RT2X00_LIB_DEBUGFS
  958. .debugfs = &rt2800_rt2x00debug,
  959. #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
  960. };
  961. /*
  962. * RT2800pci module information.
  963. */
  964. #ifdef CONFIG_PCI
  965. static DEFINE_PCI_DEVICE_TABLE(rt2800pci_device_table) = {
  966. { PCI_DEVICE(0x1814, 0x0601) },
  967. { PCI_DEVICE(0x1814, 0x0681) },
  968. { PCI_DEVICE(0x1814, 0x0701) },
  969. { PCI_DEVICE(0x1814, 0x0781) },
  970. { PCI_DEVICE(0x1814, 0x3090) },
  971. { PCI_DEVICE(0x1814, 0x3091) },
  972. { PCI_DEVICE(0x1814, 0x3092) },
  973. { PCI_DEVICE(0x1432, 0x7708) },
  974. { PCI_DEVICE(0x1432, 0x7727) },
  975. { PCI_DEVICE(0x1432, 0x7728) },
  976. { PCI_DEVICE(0x1432, 0x7738) },
  977. { PCI_DEVICE(0x1432, 0x7748) },
  978. { PCI_DEVICE(0x1432, 0x7758) },
  979. { PCI_DEVICE(0x1432, 0x7768) },
  980. { PCI_DEVICE(0x1462, 0x891a) },
  981. { PCI_DEVICE(0x1a3b, 0x1059) },
  982. #ifdef CONFIG_RT2800PCI_RT33XX
  983. { PCI_DEVICE(0x1814, 0x3390) },
  984. #endif
  985. #ifdef CONFIG_RT2800PCI_RT35XX
  986. { PCI_DEVICE(0x1432, 0x7711) },
  987. { PCI_DEVICE(0x1432, 0x7722) },
  988. { PCI_DEVICE(0x1814, 0x3060) },
  989. { PCI_DEVICE(0x1814, 0x3062) },
  990. { PCI_DEVICE(0x1814, 0x3562) },
  991. { PCI_DEVICE(0x1814, 0x3592) },
  992. { PCI_DEVICE(0x1814, 0x3593) },
  993. #endif
  994. #ifdef CONFIG_RT2800PCI_RT53XX
  995. { PCI_DEVICE(0x1814, 0x5390) },
  996. { PCI_DEVICE(0x1814, 0x539a) },
  997. { PCI_DEVICE(0x1814, 0x539f) },
  998. #endif
  999. { 0, }
  1000. };
  1001. #endif /* CONFIG_PCI */
  1002. MODULE_AUTHOR(DRV_PROJECT);
  1003. MODULE_VERSION(DRV_VERSION);
  1004. MODULE_DESCRIPTION("Ralink RT2800 PCI & PCMCIA Wireless LAN driver.");
  1005. MODULE_SUPPORTED_DEVICE("Ralink RT2860 PCI & PCMCIA chipset based cards");
  1006. #ifdef CONFIG_PCI
  1007. MODULE_FIRMWARE(FIRMWARE_RT2860);
  1008. MODULE_DEVICE_TABLE(pci, rt2800pci_device_table);
  1009. #endif /* CONFIG_PCI */
  1010. MODULE_LICENSE("GPL");
  1011. #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT305X)
  1012. static int rt2800soc_probe(struct platform_device *pdev)
  1013. {
  1014. return rt2x00soc_probe(pdev, &rt2800pci_ops);
  1015. }
  1016. static struct platform_driver rt2800soc_driver = {
  1017. .driver = {
  1018. .name = "rt2800_wmac",
  1019. .owner = THIS_MODULE,
  1020. .mod_name = KBUILD_MODNAME,
  1021. },
  1022. .probe = rt2800soc_probe,
  1023. .remove = __devexit_p(rt2x00soc_remove),
  1024. .suspend = rt2x00soc_suspend,
  1025. .resume = rt2x00soc_resume,
  1026. };
  1027. #endif /* CONFIG_RALINK_RT288X || CONFIG_RALINK_RT305X */
  1028. #ifdef CONFIG_PCI
  1029. static int rt2800pci_probe(struct pci_dev *pci_dev,
  1030. const struct pci_device_id *id)
  1031. {
  1032. return rt2x00pci_probe(pci_dev, &rt2800pci_ops);
  1033. }
  1034. static struct pci_driver rt2800pci_driver = {
  1035. .name = KBUILD_MODNAME,
  1036. .id_table = rt2800pci_device_table,
  1037. .probe = rt2800pci_probe,
  1038. .remove = __devexit_p(rt2x00pci_remove),
  1039. .suspend = rt2x00pci_suspend,
  1040. .resume = rt2x00pci_resume,
  1041. };
  1042. #endif /* CONFIG_PCI */
  1043. static int __init rt2800pci_init(void)
  1044. {
  1045. int ret = 0;
  1046. #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT305X)
  1047. ret = platform_driver_register(&rt2800soc_driver);
  1048. if (ret)
  1049. return ret;
  1050. #endif
  1051. #ifdef CONFIG_PCI
  1052. ret = pci_register_driver(&rt2800pci_driver);
  1053. if (ret) {
  1054. #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT305X)
  1055. platform_driver_unregister(&rt2800soc_driver);
  1056. #endif
  1057. return ret;
  1058. }
  1059. #endif
  1060. return ret;
  1061. }
  1062. static void __exit rt2800pci_exit(void)
  1063. {
  1064. #ifdef CONFIG_PCI
  1065. pci_unregister_driver(&rt2800pci_driver);
  1066. #endif
  1067. #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT305X)
  1068. platform_driver_unregister(&rt2800soc_driver);
  1069. #endif
  1070. }
  1071. module_init(rt2800pci_init);
  1072. module_exit(rt2800pci_exit);