rt2x00usb.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695
  1. /*
  2. Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
  3. <http://rt2x00.serialmonkey.com>
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the
  14. Free Software Foundation, Inc.,
  15. 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  16. */
  17. /*
  18. Module: rt2x00usb
  19. Abstract: rt2x00 generic usb device routines.
  20. */
  21. #include <linux/kernel.h>
  22. #include <linux/module.h>
  23. #include <linux/slab.h>
  24. #include <linux/usb.h>
  25. #include <linux/bug.h>
  26. #include "rt2x00.h"
  27. #include "rt2x00usb.h"
  28. /*
  29. * Interfacing with the HW.
  30. */
  31. int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
  32. const u8 request, const u8 requesttype,
  33. const u16 offset, const u16 value,
  34. void *buffer, const u16 buffer_length,
  35. const int timeout)
  36. {
  37. struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
  38. int status;
  39. unsigned int i;
  40. unsigned int pipe =
  41. (requesttype == USB_VENDOR_REQUEST_IN) ?
  42. usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0);
  43. if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
  44. return -ENODEV;
  45. for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
  46. status = usb_control_msg(usb_dev, pipe, request, requesttype,
  47. value, offset, buffer, buffer_length,
  48. timeout);
  49. if (status >= 0)
  50. return 0;
  51. /*
  52. * Check for errors
  53. * -ENODEV: Device has disappeared, no point continuing.
  54. * All other errors: Try again.
  55. */
  56. else if (status == -ENODEV) {
  57. clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
  58. break;
  59. }
  60. }
  61. ERROR(rt2x00dev,
  62. "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
  63. request, offset, status);
  64. return status;
  65. }
  66. EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request);
  67. int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
  68. const u8 request, const u8 requesttype,
  69. const u16 offset, void *buffer,
  70. const u16 buffer_length, const int timeout)
  71. {
  72. int status;
  73. BUG_ON(!mutex_is_locked(&rt2x00dev->csr_mutex));
  74. /*
  75. * Check for Cache availability.
  76. */
  77. if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) {
  78. ERROR(rt2x00dev, "CSR cache not available.\n");
  79. return -ENOMEM;
  80. }
  81. if (requesttype == USB_VENDOR_REQUEST_OUT)
  82. memcpy(rt2x00dev->csr.cache, buffer, buffer_length);
  83. status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype,
  84. offset, 0, rt2x00dev->csr.cache,
  85. buffer_length, timeout);
  86. if (!status && requesttype == USB_VENDOR_REQUEST_IN)
  87. memcpy(buffer, rt2x00dev->csr.cache, buffer_length);
  88. return status;
  89. }
  90. EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock);
  91. int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev,
  92. const u8 request, const u8 requesttype,
  93. const u16 offset, void *buffer,
  94. const u16 buffer_length, const int timeout)
  95. {
  96. int status = 0;
  97. unsigned char *tb;
  98. u16 off, len, bsize;
  99. mutex_lock(&rt2x00dev->csr_mutex);
  100. tb = (char *)buffer;
  101. off = offset;
  102. len = buffer_length;
  103. while (len && !status) {
  104. bsize = min_t(u16, CSR_CACHE_SIZE, len);
  105. status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
  106. requesttype, off, tb,
  107. bsize, timeout);
  108. tb += bsize;
  109. len -= bsize;
  110. off += bsize;
  111. }
  112. mutex_unlock(&rt2x00dev->csr_mutex);
  113. return status;
  114. }
  115. EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
  116. int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
  117. const unsigned int offset,
  118. const struct rt2x00_field32 field,
  119. u32 *reg)
  120. {
  121. unsigned int i;
  122. if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
  123. return -ENODEV;
  124. for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
  125. rt2x00usb_register_read_lock(rt2x00dev, offset, reg);
  126. if (!rt2x00_get_field32(*reg, field))
  127. return 1;
  128. udelay(REGISTER_BUSY_DELAY);
  129. }
  130. ERROR(rt2x00dev, "Indirect register access failed: "
  131. "offset=0x%.08x, value=0x%.08x\n", offset, *reg);
  132. *reg = ~0;
  133. return 0;
  134. }
  135. EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read);
  136. /*
  137. * TX data handlers.
  138. */
  139. static void rt2x00usb_interrupt_txdone(struct urb *urb)
  140. {
  141. struct queue_entry *entry = (struct queue_entry *)urb->context;
  142. struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
  143. struct txdone_entry_desc txdesc;
  144. if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
  145. !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
  146. return;
  147. /*
  148. * Obtain the status about this packet.
  149. * Note that when the status is 0 it does not mean the
  150. * frame was send out correctly. It only means the frame
  151. * was succesfully pushed to the hardware, we have no
  152. * way to determine the transmission status right now.
  153. * (Only indirectly by looking at the failed TX counters
  154. * in the register).
  155. */
  156. txdesc.flags = 0;
  157. if (!urb->status)
  158. __set_bit(TXDONE_UNKNOWN, &txdesc.flags);
  159. else
  160. __set_bit(TXDONE_FAILURE, &txdesc.flags);
  161. txdesc.retry = 0;
  162. rt2x00lib_txdone(entry, &txdesc);
  163. }
  164. static inline void rt2x00usb_kick_tx_entry(struct queue_entry *entry)
  165. {
  166. struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
  167. struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
  168. struct queue_entry_priv_usb *entry_priv = entry->priv_data;
  169. u32 length;
  170. if (test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags)) {
  171. /*
  172. * USB devices cannot blindly pass the skb->len as the
  173. * length of the data to usb_fill_bulk_urb. Pass the skb
  174. * to the driver to determine what the length should be.
  175. */
  176. length = rt2x00dev->ops->lib->get_tx_data_len(entry);
  177. usb_fill_bulk_urb(entry_priv->urb, usb_dev,
  178. usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint),
  179. entry->skb->data, length,
  180. rt2x00usb_interrupt_txdone, entry);
  181. usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
  182. }
  183. }
  184. void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
  185. const enum data_queue_qid qid)
  186. {
  187. struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
  188. unsigned long irqflags;
  189. unsigned int index;
  190. unsigned int index_done;
  191. unsigned int i;
  192. /*
  193. * Only protect the range we are going to loop over,
  194. * if during our loop a extra entry is set to pending
  195. * it should not be kicked during this run, since it
  196. * is part of another TX operation.
  197. */
  198. spin_lock_irqsave(&queue->lock, irqflags);
  199. index = queue->index[Q_INDEX];
  200. index_done = queue->index[Q_INDEX_DONE];
  201. spin_unlock_irqrestore(&queue->lock, irqflags);
  202. /*
  203. * Start from the TX done pointer, this guarentees that we will
  204. * send out all frames in the correct order.
  205. */
  206. if (index_done < index) {
  207. for (i = index_done; i < index; i++)
  208. rt2x00usb_kick_tx_entry(&queue->entries[i]);
  209. } else {
  210. for (i = index_done; i < queue->limit; i++)
  211. rt2x00usb_kick_tx_entry(&queue->entries[i]);
  212. for (i = 0; i < index; i++)
  213. rt2x00usb_kick_tx_entry(&queue->entries[i]);
  214. }
  215. }
  216. EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
  217. void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
  218. const enum data_queue_qid qid)
  219. {
  220. struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
  221. struct queue_entry_priv_usb *entry_priv;
  222. struct queue_entry_priv_usb_bcn *bcn_priv;
  223. unsigned int i;
  224. bool kill_guard;
  225. /*
  226. * When killing the beacon queue, we must also kill
  227. * the beacon guard byte.
  228. */
  229. kill_guard =
  230. (qid == QID_BEACON) &&
  231. (test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags));
  232. /*
  233. * Cancel all entries.
  234. */
  235. for (i = 0; i < queue->limit; i++) {
  236. entry_priv = queue->entries[i].priv_data;
  237. usb_kill_urb(entry_priv->urb);
  238. /*
  239. * Kill guardian urb (if required by driver).
  240. */
  241. if (kill_guard) {
  242. bcn_priv = queue->entries[i].priv_data;
  243. usb_kill_urb(bcn_priv->guardian_urb);
  244. }
  245. }
  246. }
  247. EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue);
  248. /*
  249. * RX data handlers.
  250. */
  251. static void rt2x00usb_interrupt_rxdone(struct urb *urb)
  252. {
  253. struct queue_entry *entry = (struct queue_entry *)urb->context;
  254. struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
  255. struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
  256. u8 rxd[32];
  257. if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
  258. !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
  259. return;
  260. /*
  261. * Check if the received data is simply too small
  262. * to be actually valid, or if the urb is signaling
  263. * a problem.
  264. */
  265. if (urb->actual_length < entry->queue->desc_size || urb->status) {
  266. set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
  267. usb_submit_urb(urb, GFP_ATOMIC);
  268. return;
  269. }
  270. /*
  271. * Fill in desc fields of the skb descriptor
  272. */
  273. skbdesc->desc = rxd;
  274. skbdesc->desc_len = entry->queue->desc_size;
  275. /*
  276. * Send the frame to rt2x00lib for further processing.
  277. */
  278. rt2x00lib_rxdone(rt2x00dev, entry);
  279. }
  280. /*
  281. * Radio handlers
  282. */
  283. void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
  284. {
  285. rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
  286. REGISTER_TIMEOUT);
  287. /*
  288. * The USB version of kill_tx_queue also works
  289. * on the RX queue.
  290. */
  291. rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, QID_RX);
  292. }
  293. EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
  294. /*
  295. * Device initialization handlers.
  296. */
  297. void rt2x00usb_clear_entry(struct queue_entry *entry)
  298. {
  299. struct usb_device *usb_dev =
  300. to_usb_device_intf(entry->queue->rt2x00dev->dev);
  301. struct queue_entry_priv_usb *entry_priv = entry->priv_data;
  302. int pipe;
  303. if (entry->queue->qid == QID_RX) {
  304. pipe = usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint);
  305. usb_fill_bulk_urb(entry_priv->urb, usb_dev, pipe,
  306. entry->skb->data, entry->skb->len,
  307. rt2x00usb_interrupt_rxdone, entry);
  308. set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
  309. usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
  310. } else {
  311. entry->flags = 0;
  312. }
  313. }
  314. EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry);
  315. static void rt2x00usb_assign_endpoint(struct data_queue *queue,
  316. struct usb_endpoint_descriptor *ep_desc)
  317. {
  318. struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev);
  319. int pipe;
  320. queue->usb_endpoint = usb_endpoint_num(ep_desc);
  321. if (queue->qid == QID_RX) {
  322. pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint);
  323. queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 0);
  324. } else {
  325. pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint);
  326. queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 1);
  327. }
  328. if (!queue->usb_maxpacket)
  329. queue->usb_maxpacket = 1;
  330. }
  331. static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
  332. {
  333. struct usb_interface *intf = to_usb_interface(rt2x00dev->dev);
  334. struct usb_host_interface *intf_desc = intf->cur_altsetting;
  335. struct usb_endpoint_descriptor *ep_desc;
  336. struct data_queue *queue = rt2x00dev->tx;
  337. struct usb_endpoint_descriptor *tx_ep_desc = NULL;
  338. unsigned int i;
  339. /*
  340. * Walk through all available endpoints to search for "bulk in"
  341. * and "bulk out" endpoints. When we find such endpoints collect
  342. * the information we need from the descriptor and assign it
  343. * to the queue.
  344. */
  345. for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
  346. ep_desc = &intf_desc->endpoint[i].desc;
  347. if (usb_endpoint_is_bulk_in(ep_desc)) {
  348. rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
  349. } else if (usb_endpoint_is_bulk_out(ep_desc) &&
  350. (queue != queue_end(rt2x00dev))) {
  351. rt2x00usb_assign_endpoint(queue, ep_desc);
  352. queue = queue_next(queue);
  353. tx_ep_desc = ep_desc;
  354. }
  355. }
  356. /*
  357. * At least 1 endpoint for RX and 1 endpoint for TX must be available.
  358. */
  359. if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) {
  360. ERROR(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
  361. return -EPIPE;
  362. }
  363. /*
  364. * It might be possible not all queues have a dedicated endpoint.
  365. * Loop through all TX queues and copy the endpoint information
  366. * which we have gathered from already assigned endpoints.
  367. */
  368. txall_queue_for_each(rt2x00dev, queue) {
  369. if (!queue->usb_endpoint)
  370. rt2x00usb_assign_endpoint(queue, tx_ep_desc);
  371. }
  372. return 0;
  373. }
  374. static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
  375. struct data_queue *queue)
  376. {
  377. struct queue_entry_priv_usb *entry_priv;
  378. struct queue_entry_priv_usb_bcn *bcn_priv;
  379. unsigned int i;
  380. for (i = 0; i < queue->limit; i++) {
  381. entry_priv = queue->entries[i].priv_data;
  382. entry_priv->urb = usb_alloc_urb(0, GFP_KERNEL);
  383. if (!entry_priv->urb)
  384. return -ENOMEM;
  385. }
  386. /*
  387. * If this is not the beacon queue or
  388. * no guardian byte was required for the beacon,
  389. * then we are done.
  390. */
  391. if (rt2x00dev->bcn != queue ||
  392. !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
  393. return 0;
  394. for (i = 0; i < queue->limit; i++) {
  395. bcn_priv = queue->entries[i].priv_data;
  396. bcn_priv->guardian_urb = usb_alloc_urb(0, GFP_KERNEL);
  397. if (!bcn_priv->guardian_urb)
  398. return -ENOMEM;
  399. }
  400. return 0;
  401. }
  402. static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
  403. struct data_queue *queue)
  404. {
  405. struct queue_entry_priv_usb *entry_priv;
  406. struct queue_entry_priv_usb_bcn *bcn_priv;
  407. unsigned int i;
  408. if (!queue->entries)
  409. return;
  410. for (i = 0; i < queue->limit; i++) {
  411. entry_priv = queue->entries[i].priv_data;
  412. usb_kill_urb(entry_priv->urb);
  413. usb_free_urb(entry_priv->urb);
  414. }
  415. /*
  416. * If this is not the beacon queue or
  417. * no guardian byte was required for the beacon,
  418. * then we are done.
  419. */
  420. if (rt2x00dev->bcn != queue ||
  421. !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
  422. return;
  423. for (i = 0; i < queue->limit; i++) {
  424. bcn_priv = queue->entries[i].priv_data;
  425. usb_kill_urb(bcn_priv->guardian_urb);
  426. usb_free_urb(bcn_priv->guardian_urb);
  427. }
  428. }
  429. int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
  430. {
  431. struct data_queue *queue;
  432. int status;
  433. /*
  434. * Find endpoints for each queue
  435. */
  436. status = rt2x00usb_find_endpoints(rt2x00dev);
  437. if (status)
  438. goto exit;
  439. /*
  440. * Allocate DMA
  441. */
  442. queue_for_each(rt2x00dev, queue) {
  443. status = rt2x00usb_alloc_urb(rt2x00dev, queue);
  444. if (status)
  445. goto exit;
  446. }
  447. return 0;
  448. exit:
  449. rt2x00usb_uninitialize(rt2x00dev);
  450. return status;
  451. }
  452. EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
  453. void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
  454. {
  455. struct data_queue *queue;
  456. queue_for_each(rt2x00dev, queue)
  457. rt2x00usb_free_urb(rt2x00dev, queue);
  458. }
  459. EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
  460. /*
  461. * USB driver handlers.
  462. */
  463. static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
  464. {
  465. kfree(rt2x00dev->rf);
  466. rt2x00dev->rf = NULL;
  467. kfree(rt2x00dev->eeprom);
  468. rt2x00dev->eeprom = NULL;
  469. kfree(rt2x00dev->csr.cache);
  470. rt2x00dev->csr.cache = NULL;
  471. }
  472. static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
  473. {
  474. rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
  475. if (!rt2x00dev->csr.cache)
  476. goto exit;
  477. rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
  478. if (!rt2x00dev->eeprom)
  479. goto exit;
  480. rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
  481. if (!rt2x00dev->rf)
  482. goto exit;
  483. return 0;
  484. exit:
  485. ERROR_PROBE("Failed to allocate registers.\n");
  486. rt2x00usb_free_reg(rt2x00dev);
  487. return -ENOMEM;
  488. }
  489. int rt2x00usb_probe(struct usb_interface *usb_intf,
  490. const struct usb_device_id *id)
  491. {
  492. struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
  493. struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info;
  494. struct ieee80211_hw *hw;
  495. struct rt2x00_dev *rt2x00dev;
  496. int retval;
  497. usb_dev = usb_get_dev(usb_dev);
  498. hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
  499. if (!hw) {
  500. ERROR_PROBE("Failed to allocate hardware.\n");
  501. retval = -ENOMEM;
  502. goto exit_put_device;
  503. }
  504. usb_set_intfdata(usb_intf, hw);
  505. rt2x00dev = hw->priv;
  506. rt2x00dev->dev = &usb_intf->dev;
  507. rt2x00dev->ops = ops;
  508. rt2x00dev->hw = hw;
  509. rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_USB);
  510. retval = rt2x00usb_alloc_reg(rt2x00dev);
  511. if (retval)
  512. goto exit_free_device;
  513. retval = rt2x00lib_probe_dev(rt2x00dev);
  514. if (retval)
  515. goto exit_free_reg;
  516. return 0;
  517. exit_free_reg:
  518. rt2x00usb_free_reg(rt2x00dev);
  519. exit_free_device:
  520. ieee80211_free_hw(hw);
  521. exit_put_device:
  522. usb_put_dev(usb_dev);
  523. usb_set_intfdata(usb_intf, NULL);
  524. return retval;
  525. }
  526. EXPORT_SYMBOL_GPL(rt2x00usb_probe);
  527. void rt2x00usb_disconnect(struct usb_interface *usb_intf)
  528. {
  529. struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
  530. struct rt2x00_dev *rt2x00dev = hw->priv;
  531. /*
  532. * Free all allocated data.
  533. */
  534. rt2x00lib_remove_dev(rt2x00dev);
  535. rt2x00usb_free_reg(rt2x00dev);
  536. ieee80211_free_hw(hw);
  537. /*
  538. * Free the USB device data.
  539. */
  540. usb_set_intfdata(usb_intf, NULL);
  541. usb_put_dev(interface_to_usbdev(usb_intf));
  542. }
  543. EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
  544. #ifdef CONFIG_PM
  545. int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
  546. {
  547. struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
  548. struct rt2x00_dev *rt2x00dev = hw->priv;
  549. int retval;
  550. retval = rt2x00lib_suspend(rt2x00dev, state);
  551. if (retval)
  552. return retval;
  553. /*
  554. * Decrease usbdev refcount.
  555. */
  556. usb_put_dev(interface_to_usbdev(usb_intf));
  557. return 0;
  558. }
  559. EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
  560. int rt2x00usb_resume(struct usb_interface *usb_intf)
  561. {
  562. struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
  563. struct rt2x00_dev *rt2x00dev = hw->priv;
  564. usb_get_dev(interface_to_usbdev(usb_intf));
  565. return rt2x00lib_resume(rt2x00dev);
  566. }
  567. EXPORT_SYMBOL_GPL(rt2x00usb_resume);
  568. #endif /* CONFIG_PM */
  569. /*
  570. * rt2x00usb module information.
  571. */
  572. MODULE_AUTHOR(DRV_PROJECT);
  573. MODULE_VERSION(DRV_VERSION);
  574. MODULE_DESCRIPTION("rt2x00 usb library");
  575. MODULE_LICENSE("GPL");