usb.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748
  1. /*
  2. * Atheros AR9170 driver
  3. *
  4. * USB - frontend
  5. *
  6. * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
  7. * Copyright 2009, Christian Lamparter <chunkeey@web.de>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; see the file COPYING. If not, see
  21. * http://www.gnu.org/licenses/.
  22. *
  23. * This file incorporates work covered by the following copyright and
  24. * permission notice:
  25. * Copyright (c) 2007-2008 Atheros Communications, Inc.
  26. *
  27. * Permission to use, copy, modify, and/or distribute this software for any
  28. * purpose with or without fee is hereby granted, provided that the above
  29. * copyright notice and this permission notice appear in all copies.
  30. *
  31. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  32. * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  33. * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  34. * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  35. * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  36. * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  37. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  38. */
  39. #include <linux/module.h>
  40. #include <linux/usb.h>
  41. #include <linux/firmware.h>
  42. #include <linux/etherdevice.h>
  43. #include <net/mac80211.h>
  44. #include "ar9170.h"
  45. #include "cmd.h"
  46. #include "hw.h"
  47. #include "usb.h"
  48. MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
  49. MODULE_AUTHOR("Christian Lamparter <chunkeey@web.de>");
  50. MODULE_LICENSE("GPL");
  51. MODULE_DESCRIPTION("Atheros AR9170 802.11n USB wireless");
  52. MODULE_FIRMWARE("ar9170-1.fw");
  53. MODULE_FIRMWARE("ar9170-2.fw");
  54. static struct usb_device_id ar9170_usb_ids[] = {
  55. /* Atheros 9170 */
  56. { USB_DEVICE(0x0cf3, 0x9170) },
  57. /* Atheros TG121N */
  58. { USB_DEVICE(0x0cf3, 0x1001) },
  59. /* D-Link DWA 160A */
  60. { USB_DEVICE(0x07d1, 0x3c10) },
  61. /* Netgear WNDA3100 */
  62. { USB_DEVICE(0x0846, 0x9010) },
  63. /* Netgear WN111 v2 */
  64. { USB_DEVICE(0x0846, 0x9001) },
  65. /* Zydas ZD1221 */
  66. { USB_DEVICE(0x0ace, 0x1221) },
  67. /* Z-Com UB81 BG */
  68. { USB_DEVICE(0x0cde, 0x0023) },
  69. /* Z-Com UB82 ABG */
  70. { USB_DEVICE(0x0cde, 0x0026) },
  71. /* Arcadyan WN7512 */
  72. { USB_DEVICE(0x083a, 0xf522) },
  73. /* Planex GWUS300 */
  74. { USB_DEVICE(0x2019, 0x5304) },
  75. /* IO-Data WNGDNUS2 */
  76. { USB_DEVICE(0x04bb, 0x093f) },
  77. /* terminate */
  78. {}
  79. };
  80. MODULE_DEVICE_TABLE(usb, ar9170_usb_ids);
  81. static void ar9170_usb_tx_urb_complete_free(struct urb *urb)
  82. {
  83. struct sk_buff *skb = urb->context;
  84. struct ar9170_usb *aru = (struct ar9170_usb *)
  85. usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
  86. if (!aru) {
  87. dev_kfree_skb_irq(skb);
  88. return ;
  89. }
  90. ar9170_handle_tx_status(&aru->common, skb, false,
  91. AR9170_TX_STATUS_COMPLETE);
  92. }
  93. static void ar9170_usb_tx_urb_complete(struct urb *urb)
  94. {
  95. }
  96. static void ar9170_usb_irq_completed(struct urb *urb)
  97. {
  98. struct ar9170_usb *aru = urb->context;
  99. switch (urb->status) {
  100. /* everything is fine */
  101. case 0:
  102. break;
  103. /* disconnect */
  104. case -ENOENT:
  105. case -ECONNRESET:
  106. case -ENODEV:
  107. case -ESHUTDOWN:
  108. goto free;
  109. default:
  110. goto resubmit;
  111. }
  112. print_hex_dump_bytes("ar9170 irq: ", DUMP_PREFIX_OFFSET,
  113. urb->transfer_buffer, urb->actual_length);
  114. resubmit:
  115. usb_anchor_urb(urb, &aru->rx_submitted);
  116. if (usb_submit_urb(urb, GFP_ATOMIC)) {
  117. usb_unanchor_urb(urb);
  118. goto free;
  119. }
  120. return;
  121. free:
  122. usb_buffer_free(aru->udev, 64, urb->transfer_buffer, urb->transfer_dma);
  123. }
  124. static void ar9170_usb_rx_completed(struct urb *urb)
  125. {
  126. struct sk_buff *skb = urb->context;
  127. struct ar9170_usb *aru = (struct ar9170_usb *)
  128. usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
  129. int err;
  130. if (!aru)
  131. goto free;
  132. switch (urb->status) {
  133. /* everything is fine */
  134. case 0:
  135. break;
  136. /* disconnect */
  137. case -ENOENT:
  138. case -ECONNRESET:
  139. case -ENODEV:
  140. case -ESHUTDOWN:
  141. goto free;
  142. default:
  143. goto resubmit;
  144. }
  145. skb_put(skb, urb->actual_length);
  146. ar9170_rx(&aru->common, skb);
  147. resubmit:
  148. skb_reset_tail_pointer(skb);
  149. skb_trim(skb, 0);
  150. usb_anchor_urb(urb, &aru->rx_submitted);
  151. err = usb_submit_urb(urb, GFP_ATOMIC);
  152. if (err) {
  153. usb_unanchor_urb(urb);
  154. dev_kfree_skb_irq(skb);
  155. }
  156. return ;
  157. free:
  158. dev_kfree_skb_irq(skb);
  159. return;
  160. }
  161. static int ar9170_usb_prep_rx_urb(struct ar9170_usb *aru,
  162. struct urb *urb, gfp_t gfp)
  163. {
  164. struct sk_buff *skb;
  165. skb = __dev_alloc_skb(AR9170_MAX_RX_BUFFER_SIZE + 32, gfp);
  166. if (!skb)
  167. return -ENOMEM;
  168. /* reserve some space for mac80211's radiotap */
  169. skb_reserve(skb, 32);
  170. usb_fill_bulk_urb(urb, aru->udev,
  171. usb_rcvbulkpipe(aru->udev, AR9170_EP_RX),
  172. skb->data, min(skb_tailroom(skb),
  173. AR9170_MAX_RX_BUFFER_SIZE),
  174. ar9170_usb_rx_completed, skb);
  175. return 0;
  176. }
  177. static int ar9170_usb_alloc_rx_irq_urb(struct ar9170_usb *aru)
  178. {
  179. struct urb *urb = NULL;
  180. void *ibuf;
  181. int err = -ENOMEM;
  182. /* initialize interrupt endpoint */
  183. urb = usb_alloc_urb(0, GFP_KERNEL);
  184. if (!urb)
  185. goto out;
  186. ibuf = usb_buffer_alloc(aru->udev, 64, GFP_KERNEL, &urb->transfer_dma);
  187. if (!ibuf)
  188. goto out;
  189. usb_fill_int_urb(urb, aru->udev,
  190. usb_rcvintpipe(aru->udev, AR9170_EP_IRQ), ibuf,
  191. 64, ar9170_usb_irq_completed, aru, 1);
  192. urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  193. usb_anchor_urb(urb, &aru->rx_submitted);
  194. err = usb_submit_urb(urb, GFP_KERNEL);
  195. if (err) {
  196. usb_unanchor_urb(urb);
  197. usb_buffer_free(aru->udev, 64, urb->transfer_buffer,
  198. urb->transfer_dma);
  199. }
  200. out:
  201. usb_free_urb(urb);
  202. return err;
  203. }
  204. static int ar9170_usb_alloc_rx_bulk_urbs(struct ar9170_usb *aru)
  205. {
  206. struct urb *urb;
  207. int i;
  208. int err = -EINVAL;
  209. for (i = 0; i < AR9170_NUM_RX_URBS; i++) {
  210. err = -ENOMEM;
  211. urb = usb_alloc_urb(0, GFP_KERNEL);
  212. if (!urb)
  213. goto err_out;
  214. err = ar9170_usb_prep_rx_urb(aru, urb, GFP_KERNEL);
  215. if (err) {
  216. usb_free_urb(urb);
  217. goto err_out;
  218. }
  219. usb_anchor_urb(urb, &aru->rx_submitted);
  220. err = usb_submit_urb(urb, GFP_KERNEL);
  221. if (err) {
  222. usb_unanchor_urb(urb);
  223. dev_kfree_skb_any((void *) urb->transfer_buffer);
  224. usb_free_urb(urb);
  225. goto err_out;
  226. }
  227. usb_free_urb(urb);
  228. }
  229. /* the device now waiting for a firmware. */
  230. aru->common.state = AR9170_IDLE;
  231. return 0;
  232. err_out:
  233. usb_kill_anchored_urbs(&aru->rx_submitted);
  234. return err;
  235. }
  236. static void ar9170_usb_cancel_urbs(struct ar9170_usb *aru)
  237. {
  238. int ret;
  239. aru->common.state = AR9170_UNKNOWN_STATE;
  240. usb_unlink_anchored_urbs(&aru->tx_submitted);
  241. /* give the LED OFF command and the deauth frame a chance to air. */
  242. ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
  243. msecs_to_jiffies(100));
  244. if (ret == 0)
  245. dev_err(&aru->udev->dev, "kill pending tx urbs.\n");
  246. usb_poison_anchored_urbs(&aru->tx_submitted);
  247. usb_poison_anchored_urbs(&aru->rx_submitted);
  248. }
  249. static int ar9170_usb_exec_cmd(struct ar9170 *ar, enum ar9170_cmd cmd,
  250. unsigned int plen, void *payload,
  251. unsigned int outlen, void *out)
  252. {
  253. struct ar9170_usb *aru = (void *) ar;
  254. struct urb *urb = NULL;
  255. unsigned long flags;
  256. int err = -ENOMEM;
  257. if (unlikely(!IS_ACCEPTING_CMD(ar)))
  258. return -EPERM;
  259. if (WARN_ON(plen > AR9170_MAX_CMD_LEN - 4))
  260. return -EINVAL;
  261. urb = usb_alloc_urb(0, GFP_ATOMIC);
  262. if (unlikely(!urb))
  263. goto err_free;
  264. ar->cmdbuf[0] = cpu_to_le32(plen);
  265. ar->cmdbuf[0] |= cpu_to_le32(cmd << 8);
  266. /* writing multiple regs fills this buffer already */
  267. if (plen && payload != (u8 *)(&ar->cmdbuf[1]))
  268. memcpy(&ar->cmdbuf[1], payload, plen);
  269. spin_lock_irqsave(&aru->common.cmdlock, flags);
  270. aru->readbuf = (u8 *)out;
  271. aru->readlen = outlen;
  272. spin_unlock_irqrestore(&aru->common.cmdlock, flags);
  273. usb_fill_int_urb(urb, aru->udev,
  274. usb_sndbulkpipe(aru->udev, AR9170_EP_CMD),
  275. aru->common.cmdbuf, plen + 4,
  276. ar9170_usb_tx_urb_complete, NULL, 1);
  277. usb_anchor_urb(urb, &aru->tx_submitted);
  278. err = usb_submit_urb(urb, GFP_ATOMIC);
  279. if (err) {
  280. usb_unanchor_urb(urb);
  281. usb_free_urb(urb);
  282. goto err_unbuf;
  283. }
  284. usb_free_urb(urb);
  285. err = wait_for_completion_timeout(&aru->cmd_wait, HZ);
  286. if (err == 0) {
  287. err = -ETIMEDOUT;
  288. goto err_unbuf;
  289. }
  290. if (outlen >= 0 && aru->readlen != outlen) {
  291. err = -EMSGSIZE;
  292. goto err_unbuf;
  293. }
  294. return 0;
  295. err_unbuf:
  296. /* Maybe the device was removed in the second we were waiting? */
  297. if (IS_STARTED(ar)) {
  298. dev_err(&aru->udev->dev, "no command feedback "
  299. "received (%d).\n", err);
  300. /* provide some maybe useful debug information */
  301. print_hex_dump_bytes("ar9170 cmd: ", DUMP_PREFIX_NONE,
  302. aru->common.cmdbuf, plen + 4);
  303. dump_stack();
  304. }
  305. /* invalidate to avoid completing the next prematurely */
  306. spin_lock_irqsave(&aru->common.cmdlock, flags);
  307. aru->readbuf = NULL;
  308. aru->readlen = 0;
  309. spin_unlock_irqrestore(&aru->common.cmdlock, flags);
  310. err_free:
  311. return err;
  312. }
  313. static int ar9170_usb_tx(struct ar9170 *ar, struct sk_buff *skb,
  314. bool txstatus_needed, unsigned int extra_len)
  315. {
  316. struct ar9170_usb *aru = (struct ar9170_usb *) ar;
  317. struct urb *urb;
  318. int err;
  319. if (unlikely(!IS_STARTED(ar))) {
  320. /* Seriously, what were you drink... err... thinking!? */
  321. return -EPERM;
  322. }
  323. urb = usb_alloc_urb(0, GFP_ATOMIC);
  324. if (unlikely(!urb))
  325. return -ENOMEM;
  326. usb_fill_bulk_urb(urb, aru->udev,
  327. usb_sndbulkpipe(aru->udev, AR9170_EP_TX),
  328. skb->data, skb->len + extra_len, (txstatus_needed ?
  329. ar9170_usb_tx_urb_complete :
  330. ar9170_usb_tx_urb_complete_free), skb);
  331. urb->transfer_flags |= URB_ZERO_PACKET;
  332. usb_anchor_urb(urb, &aru->tx_submitted);
  333. err = usb_submit_urb(urb, GFP_ATOMIC);
  334. if (unlikely(err))
  335. usb_unanchor_urb(urb);
  336. usb_free_urb(urb);
  337. return err;
  338. }
  339. static void ar9170_usb_callback_cmd(struct ar9170 *ar, u32 len , void *buffer)
  340. {
  341. struct ar9170_usb *aru = (void *) ar;
  342. unsigned long flags;
  343. u32 in, out;
  344. if (!buffer)
  345. return ;
  346. in = le32_to_cpup((__le32 *)buffer);
  347. out = le32_to_cpu(ar->cmdbuf[0]);
  348. /* mask off length byte */
  349. out &= ~0xFF;
  350. if (aru->readlen >= 0) {
  351. /* add expected length */
  352. out |= aru->readlen;
  353. } else {
  354. /* add obtained length */
  355. out |= in & 0xFF;
  356. }
  357. /*
  358. * Some commands (e.g: AR9170_CMD_FREQUENCY) have a variable response
  359. * length and we cannot predict the correct length in advance.
  360. * So we only check if we provided enough space for the data.
  361. */
  362. if (unlikely(out < in)) {
  363. dev_warn(&aru->udev->dev, "received invalid command response "
  364. "got %d bytes, instead of %d bytes "
  365. "and the resp length is %d bytes\n",
  366. in, out, len);
  367. print_hex_dump_bytes("ar9170 invalid resp: ",
  368. DUMP_PREFIX_OFFSET, buffer, len);
  369. /*
  370. * Do not complete, then the command times out,
  371. * and we get a stack trace from there.
  372. */
  373. return ;
  374. }
  375. spin_lock_irqsave(&aru->common.cmdlock, flags);
  376. if (aru->readbuf && len > 0) {
  377. memcpy(aru->readbuf, buffer + 4, len - 4);
  378. aru->readbuf = NULL;
  379. }
  380. complete(&aru->cmd_wait);
  381. spin_unlock_irqrestore(&aru->common.cmdlock, flags);
  382. }
  383. static int ar9170_usb_upload(struct ar9170_usb *aru, const void *data,
  384. size_t len, u32 addr, bool complete)
  385. {
  386. int transfer, err;
  387. u8 *buf = kmalloc(4096, GFP_KERNEL);
  388. if (!buf)
  389. return -ENOMEM;
  390. while (len) {
  391. transfer = min_t(int, len, 4096);
  392. memcpy(buf, data, transfer);
  393. err = usb_control_msg(aru->udev, usb_sndctrlpipe(aru->udev, 0),
  394. 0x30 /* FW DL */, 0x40 | USB_DIR_OUT,
  395. addr >> 8, 0, buf, transfer, 1000);
  396. if (err < 0) {
  397. kfree(buf);
  398. return err;
  399. }
  400. len -= transfer;
  401. data += transfer;
  402. addr += transfer;
  403. }
  404. kfree(buf);
  405. if (complete) {
  406. err = usb_control_msg(aru->udev, usb_sndctrlpipe(aru->udev, 0),
  407. 0x31 /* FW DL COMPLETE */,
  408. 0x40 | USB_DIR_OUT, 0, 0, NULL, 0, 5000);
  409. }
  410. return 0;
  411. }
  412. static int ar9170_usb_request_firmware(struct ar9170_usb *aru)
  413. {
  414. int err = 0;
  415. err = request_firmware(&aru->init_values, "ar9170-1.fw",
  416. &aru->udev->dev);
  417. if (err) {
  418. dev_err(&aru->udev->dev, "file with init values not found.\n");
  419. return err;
  420. }
  421. err = request_firmware(&aru->firmware, "ar9170-2.fw", &aru->udev->dev);
  422. if (err) {
  423. release_firmware(aru->init_values);
  424. dev_err(&aru->udev->dev, "firmware file not found.\n");
  425. return err;
  426. }
  427. return err;
  428. }
  429. static int ar9170_usb_reset(struct ar9170_usb *aru)
  430. {
  431. int ret, lock = (aru->intf->condition != USB_INTERFACE_BINDING);
  432. if (lock) {
  433. ret = usb_lock_device_for_reset(aru->udev, aru->intf);
  434. if (ret < 0) {
  435. dev_err(&aru->udev->dev, "unable to lock device "
  436. "for reset (%d).\n", ret);
  437. return ret;
  438. }
  439. }
  440. ret = usb_reset_device(aru->udev);
  441. if (lock)
  442. usb_unlock_device(aru->udev);
  443. /* let it rest - for a second - */
  444. msleep(1000);
  445. return ret;
  446. }
  447. static int ar9170_usb_upload_firmware(struct ar9170_usb *aru)
  448. {
  449. int err;
  450. /* First, upload initial values to device RAM */
  451. err = ar9170_usb_upload(aru, aru->init_values->data,
  452. aru->init_values->size, 0x102800, false);
  453. if (err) {
  454. dev_err(&aru->udev->dev, "firmware part 1 "
  455. "upload failed (%d).\n", err);
  456. return err;
  457. }
  458. /* Then, upload the firmware itself and start it */
  459. return ar9170_usb_upload(aru, aru->firmware->data, aru->firmware->size,
  460. 0x200000, true);
  461. }
  462. static int ar9170_usb_init_transport(struct ar9170_usb *aru)
  463. {
  464. struct ar9170 *ar = (void *) &aru->common;
  465. int err;
  466. ar9170_regwrite_begin(ar);
  467. /* Set USB Rx stream mode MAX packet number to 2 */
  468. ar9170_regwrite(AR9170_USB_REG_MAX_AGG_UPLOAD, 0x4);
  469. /* Set USB Rx stream mode timeout to 10us */
  470. ar9170_regwrite(AR9170_USB_REG_UPLOAD_TIME_CTL, 0x80);
  471. ar9170_regwrite_finish();
  472. err = ar9170_regwrite_result();
  473. if (err)
  474. dev_err(&aru->udev->dev, "USB setup failed (%d).\n", err);
  475. return err;
  476. }
  477. static void ar9170_usb_stop(struct ar9170 *ar)
  478. {
  479. struct ar9170_usb *aru = (void *) ar;
  480. int ret;
  481. if (IS_ACCEPTING_CMD(ar))
  482. aru->common.state = AR9170_STOPPED;
  483. /* lets wait a while until the tx - queues are dried out */
  484. ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
  485. msecs_to_jiffies(1000));
  486. if (ret == 0)
  487. dev_err(&aru->udev->dev, "kill pending tx urbs.\n");
  488. usb_poison_anchored_urbs(&aru->tx_submitted);
  489. /*
  490. * Note:
  491. * So far we freed all tx urbs, but we won't dare to touch any rx urbs.
  492. * Else we would end up with a unresponsive device...
  493. */
  494. }
  495. static int ar9170_usb_open(struct ar9170 *ar)
  496. {
  497. struct ar9170_usb *aru = (void *) ar;
  498. int err;
  499. usb_unpoison_anchored_urbs(&aru->tx_submitted);
  500. err = ar9170_usb_init_transport(aru);
  501. if (err) {
  502. usb_poison_anchored_urbs(&aru->tx_submitted);
  503. return err;
  504. }
  505. aru->common.state = AR9170_IDLE;
  506. return 0;
  507. }
  508. static int ar9170_usb_probe(struct usb_interface *intf,
  509. const struct usb_device_id *id)
  510. {
  511. struct ar9170_usb *aru;
  512. struct ar9170 *ar;
  513. struct usb_device *udev;
  514. int err;
  515. aru = ar9170_alloc(sizeof(*aru));
  516. if (IS_ERR(aru)) {
  517. err = PTR_ERR(aru);
  518. goto out;
  519. }
  520. udev = interface_to_usbdev(intf);
  521. usb_get_dev(udev);
  522. aru->udev = udev;
  523. aru->intf = intf;
  524. ar = &aru->common;
  525. usb_set_intfdata(intf, aru);
  526. SET_IEEE80211_DEV(ar->hw, &udev->dev);
  527. init_usb_anchor(&aru->rx_submitted);
  528. init_usb_anchor(&aru->tx_submitted);
  529. init_completion(&aru->cmd_wait);
  530. aru->common.stop = ar9170_usb_stop;
  531. aru->common.open = ar9170_usb_open;
  532. aru->common.tx = ar9170_usb_tx;
  533. aru->common.exec_cmd = ar9170_usb_exec_cmd;
  534. aru->common.callback_cmd = ar9170_usb_callback_cmd;
  535. err = ar9170_usb_reset(aru);
  536. if (err)
  537. goto err_unlock;
  538. err = ar9170_usb_request_firmware(aru);
  539. if (err)
  540. goto err_unlock;
  541. err = ar9170_usb_alloc_rx_irq_urb(aru);
  542. if (err)
  543. goto err_freefw;
  544. err = ar9170_usb_alloc_rx_bulk_urbs(aru);
  545. if (err)
  546. goto err_unrx;
  547. err = ar9170_usb_upload_firmware(aru);
  548. if (err) {
  549. err = ar9170_echo_test(&aru->common, 0x60d43110);
  550. if (err) {
  551. /* force user invention, by disabling the device */
  552. err = usb_driver_set_configuration(aru->udev, -1);
  553. dev_err(&aru->udev->dev, "device is in a bad state. "
  554. "please reconnect it!\n");
  555. goto err_unrx;
  556. }
  557. }
  558. err = ar9170_usb_open(ar);
  559. if (err)
  560. goto err_unrx;
  561. err = ar9170_register(ar, &udev->dev);
  562. ar9170_usb_stop(ar);
  563. if (err)
  564. goto err_unrx;
  565. return 0;
  566. err_unrx:
  567. ar9170_usb_cancel_urbs(aru);
  568. err_freefw:
  569. release_firmware(aru->init_values);
  570. release_firmware(aru->firmware);
  571. err_unlock:
  572. usb_set_intfdata(intf, NULL);
  573. usb_put_dev(udev);
  574. ieee80211_free_hw(ar->hw);
  575. out:
  576. return err;
  577. }
  578. static void ar9170_usb_disconnect(struct usb_interface *intf)
  579. {
  580. struct ar9170_usb *aru = usb_get_intfdata(intf);
  581. if (!aru)
  582. return;
  583. aru->common.state = AR9170_IDLE;
  584. ar9170_unregister(&aru->common);
  585. ar9170_usb_cancel_urbs(aru);
  586. release_firmware(aru->init_values);
  587. release_firmware(aru->firmware);
  588. usb_put_dev(aru->udev);
  589. usb_set_intfdata(intf, NULL);
  590. ieee80211_free_hw(aru->common.hw);
  591. }
  592. static struct usb_driver ar9170_driver = {
  593. .name = "ar9170usb",
  594. .probe = ar9170_usb_probe,
  595. .disconnect = ar9170_usb_disconnect,
  596. .id_table = ar9170_usb_ids,
  597. .soft_unbind = 1,
  598. };
  599. static int __init ar9170_init(void)
  600. {
  601. return usb_register(&ar9170_driver);
  602. }
  603. static void __exit ar9170_exit(void)
  604. {
  605. usb_deregister(&ar9170_driver);
  606. }
  607. module_init(ar9170_init);
  608. module_exit(ar9170_exit);