ath3k.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (c) 2008-2009 Atheros Communications Inc.
  4. */
  5. #include <linux/module.h>
  6. #include <linux/kernel.h>
  7. #include <linux/init.h>
  8. #include <linux/slab.h>
  9. #include <linux/types.h>
  10. #include <linux/errno.h>
  11. #include <linux/firmware.h>
  12. #include <linux/usb.h>
  13. #include <asm/unaligned.h>
  14. #include <net/bluetooth/bluetooth.h>
  15. #define VERSION "1.0"
  16. #define ATH3K_FIRMWARE "ath3k-1.fw"
  17. #define ATH3K_DNLOAD 0x01
  18. #define ATH3K_GETSTATE 0x05
  19. #define ATH3K_SET_NORMAL_MODE 0x07
  20. #define ATH3K_GETVERSION 0x09
  21. #define USB_REG_SWITCH_VID_PID 0x0a
  22. #define ATH3K_MODE_MASK 0x3F
  23. #define ATH3K_NORMAL_MODE 0x0E
  24. #define ATH3K_PATCH_UPDATE 0x80
  25. #define ATH3K_SYSCFG_UPDATE 0x40
  26. #define ATH3K_XTAL_FREQ_26M 0x00
  27. #define ATH3K_XTAL_FREQ_40M 0x01
  28. #define ATH3K_XTAL_FREQ_19P2 0x02
  29. #define ATH3K_NAME_LEN 0xFF
  30. struct ath3k_version {
  31. __le32 rom_version;
  32. __le32 build_version;
  33. __le32 ram_version;
  34. __u8 ref_clock;
  35. __u8 reserved[7];
  36. } __packed;
  37. static const struct usb_device_id ath3k_table[] = {
  38. /* Atheros AR3011 */
  39. { USB_DEVICE(0x0CF3, 0x3000) },
  40. /* Atheros AR3011 with sflash firmware*/
  41. { USB_DEVICE(0x0489, 0xE027) },
  42. { USB_DEVICE(0x0489, 0xE03D) },
  43. { USB_DEVICE(0x04F2, 0xAFF1) },
  44. { USB_DEVICE(0x0930, 0x0215) },
  45. { USB_DEVICE(0x0CF3, 0x3002) },
  46. { USB_DEVICE(0x0CF3, 0xE019) },
  47. { USB_DEVICE(0x13d3, 0x3304) },
  48. /* Atheros AR9285 Malbec with sflash firmware */
  49. { USB_DEVICE(0x03F0, 0x311D) },
  50. /* Atheros AR3012 with sflash firmware*/
  51. { USB_DEVICE(0x0489, 0xe04d) },
  52. { USB_DEVICE(0x0489, 0xe04e) },
  53. { USB_DEVICE(0x0489, 0xe057) },
  54. { USB_DEVICE(0x0489, 0xe056) },
  55. { USB_DEVICE(0x0489, 0xe05f) },
  56. { USB_DEVICE(0x0489, 0xe076) },
  57. { USB_DEVICE(0x0489, 0xe078) },
  58. { USB_DEVICE(0x0489, 0xe095) },
  59. { USB_DEVICE(0x04c5, 0x1330) },
  60. { USB_DEVICE(0x04CA, 0x3004) },
  61. { USB_DEVICE(0x04CA, 0x3005) },
  62. { USB_DEVICE(0x04CA, 0x3006) },
  63. { USB_DEVICE(0x04CA, 0x3007) },
  64. { USB_DEVICE(0x04CA, 0x3008) },
  65. { USB_DEVICE(0x04CA, 0x300b) },
  66. { USB_DEVICE(0x04CA, 0x300d) },
  67. { USB_DEVICE(0x04CA, 0x300f) },
  68. { USB_DEVICE(0x04CA, 0x3010) },
  69. { USB_DEVICE(0x04CA, 0x3014) },
  70. { USB_DEVICE(0x04CA, 0x3018) },
  71. { USB_DEVICE(0x0930, 0x0219) },
  72. { USB_DEVICE(0x0930, 0x021c) },
  73. { USB_DEVICE(0x0930, 0x0220) },
  74. { USB_DEVICE(0x0930, 0x0227) },
  75. { USB_DEVICE(0x0b05, 0x17d0) },
  76. { USB_DEVICE(0x0CF3, 0x0036) },
  77. { USB_DEVICE(0x0CF3, 0x3004) },
  78. { USB_DEVICE(0x0CF3, 0x3008) },
  79. { USB_DEVICE(0x0CF3, 0x311D) },
  80. { USB_DEVICE(0x0CF3, 0x311E) },
  81. { USB_DEVICE(0x0CF3, 0x311F) },
  82. { USB_DEVICE(0x0cf3, 0x3121) },
  83. { USB_DEVICE(0x0CF3, 0x817a) },
  84. { USB_DEVICE(0x0CF3, 0x817b) },
  85. { USB_DEVICE(0x0cf3, 0xe003) },
  86. { USB_DEVICE(0x0CF3, 0xE004) },
  87. { USB_DEVICE(0x0CF3, 0xE005) },
  88. { USB_DEVICE(0x0CF3, 0xE006) },
  89. { USB_DEVICE(0x13d3, 0x3362) },
  90. { USB_DEVICE(0x13d3, 0x3375) },
  91. { USB_DEVICE(0x13d3, 0x3393) },
  92. { USB_DEVICE(0x13d3, 0x3395) },
  93. { USB_DEVICE(0x13d3, 0x3402) },
  94. { USB_DEVICE(0x13d3, 0x3408) },
  95. { USB_DEVICE(0x13d3, 0x3423) },
  96. { USB_DEVICE(0x13d3, 0x3432) },
  97. { USB_DEVICE(0x13d3, 0x3472) },
  98. { USB_DEVICE(0x13d3, 0x3474) },
  99. { USB_DEVICE(0x13d3, 0x3487) },
  100. { USB_DEVICE(0x13d3, 0x3490) },
  101. /* Atheros AR5BBU12 with sflash firmware */
  102. { USB_DEVICE(0x0489, 0xE02C) },
  103. /* Atheros AR5BBU22 with sflash firmware */
  104. { USB_DEVICE(0x0489, 0xE036) },
  105. { USB_DEVICE(0x0489, 0xE03C) },
  106. { } /* Terminating entry */
  107. };
  108. MODULE_DEVICE_TABLE(usb, ath3k_table);
  109. #define BTUSB_ATH3012 0x80
  110. /* This table is to load patch and sysconfig files
  111. * for AR3012
  112. */
  113. static const struct usb_device_id ath3k_blist_tbl[] = {
  114. /* Atheros AR3012 with sflash firmware*/
  115. { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
  116. { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
  117. { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
  118. { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
  119. { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
  120. { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },
  121. { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },
  122. { USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },
  123. { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
  124. { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
  125. { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
  126. { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
  127. { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },
  128. { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
  129. { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
  130. { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },
  131. { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },
  132. { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },
  133. { USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },
  134. { USB_DEVICE(0x04ca, 0x3018), .driver_info = BTUSB_ATH3012 },
  135. { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
  136. { USB_DEVICE(0x0930, 0x021c), .driver_info = BTUSB_ATH3012 },
  137. { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },
  138. { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
  139. { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
  140. { USB_DEVICE(0x0CF3, 0x0036), .driver_info = BTUSB_ATH3012 },
  141. { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
  142. { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
  143. { USB_DEVICE(0x0cf3, 0x311D), .driver_info = BTUSB_ATH3012 },
  144. { USB_DEVICE(0x0cf3, 0x311E), .driver_info = BTUSB_ATH3012 },
  145. { USB_DEVICE(0x0cf3, 0x311F), .driver_info = BTUSB_ATH3012 },
  146. { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
  147. { USB_DEVICE(0x0CF3, 0x817a), .driver_info = BTUSB_ATH3012 },
  148. { USB_DEVICE(0x0CF3, 0x817b), .driver_info = BTUSB_ATH3012 },
  149. { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
  150. { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
  151. { USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },
  152. { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
  153. { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
  154. { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
  155. { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
  156. { USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },
  157. { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
  158. { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },
  159. { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },
  160. { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },
  161. { USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },
  162. { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },
  163. { USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },
  164. { USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },
  165. /* Atheros AR5BBU22 with sflash firmware */
  166. { USB_DEVICE(0x0489, 0xE036), .driver_info = BTUSB_ATH3012 },
  167. { USB_DEVICE(0x0489, 0xE03C), .driver_info = BTUSB_ATH3012 },
  168. { } /* Terminating entry */
  169. };
  170. static inline void ath3k_log_failed_loading(int err, int len, int size,
  171. int count)
  172. {
  173. BT_ERR("Firmware loading err = %d, len = %d, size = %d, count = %d",
  174. err, len, size, count);
  175. }
  176. #define USB_REQ_DFU_DNLOAD 1
  177. #define BULK_SIZE 4096
  178. #define FW_HDR_SIZE 20
  179. #define TIMEGAP_USEC_MIN 50
  180. #define TIMEGAP_USEC_MAX 100
  181. static int ath3k_load_firmware(struct usb_device *udev,
  182. const struct firmware *firmware)
  183. {
  184. u8 *send_buf;
  185. int len = 0;
  186. int err, pipe, size, sent = 0;
  187. int count = firmware->size;
  188. BT_DBG("udev %p", udev);
  189. send_buf = kmalloc(BULK_SIZE, GFP_KERNEL);
  190. if (!send_buf) {
  191. BT_ERR("Can't allocate memory chunk for firmware");
  192. return -ENOMEM;
  193. }
  194. err = usb_control_msg_send(udev, 0, USB_REQ_DFU_DNLOAD, USB_TYPE_VENDOR,
  195. 0, 0, firmware->data, FW_HDR_SIZE,
  196. USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
  197. if (err) {
  198. BT_ERR("Can't change to loading configuration err");
  199. goto error;
  200. }
  201. sent += FW_HDR_SIZE;
  202. count -= FW_HDR_SIZE;
  203. pipe = usb_sndbulkpipe(udev, 0x02);
  204. while (count) {
  205. /* workaround the compatibility issue with xHCI controller*/
  206. usleep_range(TIMEGAP_USEC_MIN, TIMEGAP_USEC_MAX);
  207. size = min_t(uint, count, BULK_SIZE);
  208. memcpy(send_buf, firmware->data + sent, size);
  209. err = usb_bulk_msg(udev, pipe, send_buf, size,
  210. &len, 3000);
  211. if (err || (len != size)) {
  212. ath3k_log_failed_loading(err, len, size, count);
  213. goto error;
  214. }
  215. sent += size;
  216. count -= size;
  217. }
  218. error:
  219. kfree(send_buf);
  220. return err;
  221. }
  222. static int ath3k_get_state(struct usb_device *udev, unsigned char *state)
  223. {
  224. return usb_control_msg_recv(udev, 0, ATH3K_GETSTATE,
  225. USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
  226. state, 1, USB_CTRL_SET_TIMEOUT,
  227. GFP_KERNEL);
  228. }
  229. static int ath3k_get_version(struct usb_device *udev,
  230. struct ath3k_version *version)
  231. {
  232. return usb_control_msg_recv(udev, 0, ATH3K_GETVERSION,
  233. USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
  234. version, sizeof(*version), USB_CTRL_SET_TIMEOUT,
  235. GFP_KERNEL);
  236. }
  237. static int ath3k_load_fwfile(struct usb_device *udev,
  238. const struct firmware *firmware)
  239. {
  240. u8 *send_buf;
  241. int len = 0;
  242. int err, pipe, size, count, sent = 0;
  243. int ret;
  244. count = firmware->size;
  245. send_buf = kmalloc(BULK_SIZE, GFP_KERNEL);
  246. if (!send_buf) {
  247. BT_ERR("Can't allocate memory chunk for firmware");
  248. return -ENOMEM;
  249. }
  250. size = min_t(uint, count, FW_HDR_SIZE);
  251. ret = usb_control_msg_send(udev, 0, ATH3K_DNLOAD, USB_TYPE_VENDOR, 0, 0,
  252. firmware->data, size, USB_CTRL_SET_TIMEOUT,
  253. GFP_KERNEL);
  254. if (ret) {
  255. BT_ERR("Can't change to loading configuration err");
  256. kfree(send_buf);
  257. return ret;
  258. }
  259. sent += size;
  260. count -= size;
  261. pipe = usb_sndbulkpipe(udev, 0x02);
  262. while (count) {
  263. /* workaround the compatibility issue with xHCI controller*/
  264. usleep_range(TIMEGAP_USEC_MIN, TIMEGAP_USEC_MAX);
  265. size = min_t(uint, count, BULK_SIZE);
  266. memcpy(send_buf, firmware->data + sent, size);
  267. err = usb_bulk_msg(udev, pipe, send_buf, size,
  268. &len, 3000);
  269. if (err || (len != size)) {
  270. ath3k_log_failed_loading(err, len, size, count);
  271. kfree(send_buf);
  272. return err;
  273. }
  274. sent += size;
  275. count -= size;
  276. }
  277. kfree(send_buf);
  278. return 0;
  279. }
  280. static void ath3k_switch_pid(struct usb_device *udev)
  281. {
  282. usb_control_msg_send(udev, 0, USB_REG_SWITCH_VID_PID, USB_TYPE_VENDOR,
  283. 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
  284. }
  285. static int ath3k_set_normal_mode(struct usb_device *udev)
  286. {
  287. unsigned char fw_state;
  288. int ret;
  289. ret = ath3k_get_state(udev, &fw_state);
  290. if (ret) {
  291. BT_ERR("Can't get state to change to normal mode err");
  292. return ret;
  293. }
  294. if ((fw_state & ATH3K_MODE_MASK) == ATH3K_NORMAL_MODE) {
  295. BT_DBG("firmware was already in normal mode");
  296. return 0;
  297. }
  298. return usb_control_msg_send(udev, 0, ATH3K_SET_NORMAL_MODE,
  299. USB_TYPE_VENDOR, 0, 0, NULL, 0,
  300. USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
  301. }
  302. static int ath3k_load_patch(struct usb_device *udev)
  303. {
  304. unsigned char fw_state;
  305. char filename[ATH3K_NAME_LEN];
  306. const struct firmware *firmware;
  307. struct ath3k_version fw_version;
  308. __u32 pt_rom_version, pt_build_version;
  309. int ret;
  310. ret = ath3k_get_state(udev, &fw_state);
  311. if (ret) {
  312. BT_ERR("Can't get state to change to load ram patch err");
  313. return ret;
  314. }
  315. if (fw_state & ATH3K_PATCH_UPDATE) {
  316. BT_DBG("Patch was already downloaded");
  317. return 0;
  318. }
  319. ret = ath3k_get_version(udev, &fw_version);
  320. if (ret) {
  321. BT_ERR("Can't get version to change to load ram patch err");
  322. return ret;
  323. }
  324. snprintf(filename, ATH3K_NAME_LEN, "ar3k/AthrBT_0x%08x.dfu",
  325. le32_to_cpu(fw_version.rom_version));
  326. ret = request_firmware(&firmware, filename, &udev->dev);
  327. if (ret < 0) {
  328. BT_ERR("Patch file not found %s", filename);
  329. return ret;
  330. }
  331. pt_rom_version = get_unaligned_le32(firmware->data +
  332. firmware->size - 8);
  333. pt_build_version = get_unaligned_le32(firmware->data +
  334. firmware->size - 4);
  335. if (pt_rom_version != le32_to_cpu(fw_version.rom_version) ||
  336. pt_build_version <= le32_to_cpu(fw_version.build_version)) {
  337. BT_ERR("Patch file version did not match with firmware");
  338. release_firmware(firmware);
  339. return -EINVAL;
  340. }
  341. ret = ath3k_load_fwfile(udev, firmware);
  342. release_firmware(firmware);
  343. return ret;
  344. }
  345. static int ath3k_load_syscfg(struct usb_device *udev)
  346. {
  347. unsigned char fw_state;
  348. char filename[ATH3K_NAME_LEN];
  349. const struct firmware *firmware;
  350. struct ath3k_version fw_version;
  351. int clk_value, ret;
  352. ret = ath3k_get_state(udev, &fw_state);
  353. if (ret) {
  354. BT_ERR("Can't get state to change to load configuration err");
  355. return -EBUSY;
  356. }
  357. ret = ath3k_get_version(udev, &fw_version);
  358. if (ret) {
  359. BT_ERR("Can't get version to change to load ram patch err");
  360. return ret;
  361. }
  362. switch (fw_version.ref_clock) {
  363. case ATH3K_XTAL_FREQ_26M:
  364. clk_value = 26;
  365. break;
  366. case ATH3K_XTAL_FREQ_40M:
  367. clk_value = 40;
  368. break;
  369. case ATH3K_XTAL_FREQ_19P2:
  370. clk_value = 19;
  371. break;
  372. default:
  373. clk_value = 0;
  374. break;
  375. }
  376. snprintf(filename, ATH3K_NAME_LEN, "ar3k/ramps_0x%08x_%d%s",
  377. le32_to_cpu(fw_version.rom_version), clk_value, ".dfu");
  378. ret = request_firmware(&firmware, filename, &udev->dev);
  379. if (ret < 0) {
  380. BT_ERR("Configuration file not found %s", filename);
  381. return ret;
  382. }
  383. ret = ath3k_load_fwfile(udev, firmware);
  384. release_firmware(firmware);
  385. return ret;
  386. }
  387. static int ath3k_probe(struct usb_interface *intf,
  388. const struct usb_device_id *id)
  389. {
  390. const struct firmware *firmware;
  391. struct usb_device *udev = interface_to_usbdev(intf);
  392. int ret;
  393. BT_DBG("intf %p id %p", intf, id);
  394. if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
  395. return -ENODEV;
  396. /* match device ID in ath3k blacklist table */
  397. if (!id->driver_info) {
  398. const struct usb_device_id *match;
  399. match = usb_match_id(intf, ath3k_blist_tbl);
  400. if (match)
  401. id = match;
  402. }
  403. /* load patch and sysconfig files for AR3012 */
  404. if (id->driver_info & BTUSB_ATH3012) {
  405. /* New firmware with patch and sysconfig files already loaded */
  406. if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x0001)
  407. return -ENODEV;
  408. ret = ath3k_load_patch(udev);
  409. if (ret < 0) {
  410. BT_ERR("Loading patch file failed");
  411. return ret;
  412. }
  413. ret = ath3k_load_syscfg(udev);
  414. if (ret < 0) {
  415. BT_ERR("Loading sysconfig file failed");
  416. return ret;
  417. }
  418. ret = ath3k_set_normal_mode(udev);
  419. if (ret) {
  420. BT_ERR("Set normal mode failed");
  421. return ret;
  422. }
  423. ath3k_switch_pid(udev);
  424. return 0;
  425. }
  426. ret = request_firmware(&firmware, ATH3K_FIRMWARE, &udev->dev);
  427. if (ret < 0) {
  428. if (ret == -ENOENT)
  429. BT_ERR("Firmware file \"%s\" not found",
  430. ATH3K_FIRMWARE);
  431. else
  432. BT_ERR("Firmware file \"%s\" request failed (err=%d)",
  433. ATH3K_FIRMWARE, ret);
  434. return ret;
  435. }
  436. ret = ath3k_load_firmware(udev, firmware);
  437. release_firmware(firmware);
  438. return ret;
  439. }
  440. static void ath3k_disconnect(struct usb_interface *intf)
  441. {
  442. BT_DBG("%s intf %p", __func__, intf);
  443. }
  444. static struct usb_driver ath3k_driver = {
  445. .name = "ath3k",
  446. .probe = ath3k_probe,
  447. .disconnect = ath3k_disconnect,
  448. .id_table = ath3k_table,
  449. .disable_hub_initiated_lpm = 1,
  450. };
  451. module_usb_driver(ath3k_driver);
  452. MODULE_AUTHOR("Atheros Communications");
  453. MODULE_DESCRIPTION("Atheros AR30xx firmware driver");
  454. MODULE_VERSION(VERSION);
  455. MODULE_LICENSE("GPL");
  456. MODULE_FIRMWARE(ATH3K_FIRMWARE);