API tools faq
paste
Advertisement
Guest User

linux 4.8 ath3k.c

a guest
Jan 1st, 2017
224
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.44 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * Copyright (c) 2008-2009 Atheros Communications Inc.
  3.  *
  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.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  *
  18.  */
  19.  
  20.  
  21. #include <linux/module.h>
  22. #include <linux/kernel.h>
  23. #include <linux/init.h>
  24. #include <linux/slab.h>
  25. #include <linux/types.h>
  26. #include <linux/errno.h>
  27. #include <linux/device.h>
  28. #include <linux/firmware.h>
  29. #include <linux/usb.h>
  30. #include <asm/unaligned.h>
  31. #include <net/bluetooth/bluetooth.h>
  32.  
  33. #define VERSION "1.0"
  34. #define ATH3K_FIRMWARE  "ath3k-1.fw"
  35.  
  36. #define ATH3K_DNLOAD                0x01
  37. #define ATH3K_GETSTATE              0x05
  38. #define ATH3K_SET_NORMAL_MODE           0x07
  39. #define ATH3K_GETVERSION            0x09
  40. #define USB_REG_SWITCH_VID_PID          0x0a
  41.  
  42. #define ATH3K_MODE_MASK             0x3F
  43. #define ATH3K_NORMAL_MODE           0x0E
  44.  
  45. #define ATH3K_PATCH_UPDATE          0x80
  46. #define ATH3K_SYSCFG_UPDATE         0x40
  47.  
  48. #define ATH3K_XTAL_FREQ_26M         0x00
  49. #define ATH3K_XTAL_FREQ_40M         0x01
  50. #define ATH3K_XTAL_FREQ_19P2            0x02
  51. #define ATH3K_NAME_LEN              0xFF
  52.  
  53. struct ath3k_version {
  54.     __le32  rom_version;
  55.     __le32  build_version;
  56.     __le32  ram_version;
  57.     __u8    ref_clock;
  58.     __u8    reserved[7];
  59. } __packed;
  60.  
  61. static const struct usb_device_id ath3k_table[] = {
  62.     /* Atheros AR3011 */
  63.     { USB_DEVICE(0x0CF3, 0x3000) },
  64.  
  65.     /* Atheros AR3011 with sflash firmware*/
  66.     { USB_DEVICE(0x0489, 0xE027) },
  67.     { USB_DEVICE(0x0489, 0xE03D) },
  68.     { USB_DEVICE(0x04F2, 0xAFF1) },
  69.     { USB_DEVICE(0x0930, 0x0215) },
  70.     { USB_DEVICE(0x0CF3, 0x3002) },
  71.     { USB_DEVICE(0x0CF3, 0xE019) },
  72.     { USB_DEVICE(0x13d3, 0x3304) },
  73.  
  74.     /* Atheros AR9285 Malbec with sflash firmware */
  75.     { USB_DEVICE(0x03F0, 0x311D) },
  76.  
  77.     /* Atheros AR3012 with sflash firmware*/
  78.     { USB_DEVICE(0x0489, 0xe04d) },
  79.     { USB_DEVICE(0x0489, 0xe04e) },
  80.     { USB_DEVICE(0x0489, 0xe057) },
  81.     { USB_DEVICE(0x0489, 0xe056) },
  82.     { USB_DEVICE(0x0489, 0xe05f) },
  83.     { USB_DEVICE(0x0489, 0xe076) },
  84.     { USB_DEVICE(0x0489, 0xe078) },
  85.     { USB_DEVICE(0x0489, 0xe095) },
  86.     { USB_DEVICE(0x04c5, 0x1330) },
  87.     { USB_DEVICE(0x04CA, 0x3004) },
  88.     { USB_DEVICE(0x04CA, 0x3005) },
  89.     { USB_DEVICE(0x04CA, 0x3006) },
  90.     { USB_DEVICE(0x04CA, 0x3007) },
  91.     { USB_DEVICE(0x04CA, 0x3008) },
  92.     { USB_DEVICE(0x04CA, 0x300b) },
  93.     { USB_DEVICE(0x04CA, 0x300d) },
  94.     { USB_DEVICE(0x04CA, 0x300f) },
  95.     { USB_DEVICE(0x04CA, 0x3010) },
  96.     { USB_DEVICE(0x04CA, 0x3014) },
  97.     { USB_DEVICE(0x0930, 0x0219) },
  98.     { USB_DEVICE(0x0930, 0x021c) },
  99.     { USB_DEVICE(0x0930, 0x0220) },
  100.     { USB_DEVICE(0x0930, 0x0227) },
  101.     { USB_DEVICE(0x0b05, 0x17d0) },
  102.     { USB_DEVICE(0x0CF3, 0x0036) },
  103.     { USB_DEVICE(0x0CF3, 0x3004) },
  104.     { USB_DEVICE(0x0CF3, 0x3008) },
  105.     { USB_DEVICE(0x0CF3, 0x311D) },
  106.     { USB_DEVICE(0x0CF3, 0x311E) },
  107.     { USB_DEVICE(0x0CF3, 0x311F) },
  108.     { USB_DEVICE(0x0cf3, 0x3121) },
  109.     { USB_DEVICE(0x0CF3, 0x817a) },
  110.     { USB_DEVICE(0x0CF3, 0x817b) },
  111.     { USB_DEVICE(0x0cf3, 0xe003) },
  112.     { USB_DEVICE(0x0CF3, 0xE004) },
  113.     { USB_DEVICE(0x0CF3, 0xE005) },
  114.     { USB_DEVICE(0x0CF3, 0xE006) },
  115.     { USB_DEVICE(0x13d3, 0x3362) },
  116.     { USB_DEVICE(0x13d3, 0x3375) },
  117.     { USB_DEVICE(0x13d3, 0x3393) },
  118.     { USB_DEVICE(0x13d3, 0x3395) },
  119.     { USB_DEVICE(0x13d3, 0x3402) },
  120.     { USB_DEVICE(0x13d3, 0x3408) },
  121.     { USB_DEVICE(0x13d3, 0x3423) },
  122.     { USB_DEVICE(0x13d3, 0x3432) },
  123.     { USB_DEVICE(0x13d3, 0x3472) },
  124.     { USB_DEVICE(0x13d3, 0x3474) },
  125.     { USB_DEVICE(0x13d3, 0x3487) },
  126.     { USB_DEVICE(0x13d3, 0x3490) },
  127.  
  128.     /* Atheros AR5BBU12 with sflash firmware */
  129.     { USB_DEVICE(0x0489, 0xE02C) },
  130.  
  131.     /* Atheros AR5BBU22 with sflash firmware */
  132.     { USB_DEVICE(0x0489, 0xE036) },
  133.     { USB_DEVICE(0x0489, 0xE03C) },
  134.  
  135.     { } /* Terminating entry */
  136. };
  137.  
  138. MODULE_DEVICE_TABLE(usb, ath3k_table);
  139.  
  140. #define BTUSB_ATH3012       0x80
  141. /* This table is to load patch and sysconfig files
  142.  * for AR3012 */
  143. static const struct usb_device_id ath3k_blist_tbl[] = {
  144.  
  145.     /* Atheros AR3012 with sflash firmware*/
  146.     { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
  147.     { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
  148.     { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
  149.     { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
  150.     { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
  151.     { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },
  152.     { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },
  153.     { USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },
  154.     { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
  155.     { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
  156.     { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
  157.     { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
  158.     { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },
  159.     { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
  160.     { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
  161.     { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },
  162.     { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },
  163.     { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },
  164.     { USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },
  165.     { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
  166.     { USB_DEVICE(0x0930, 0x021c), .driver_info = BTUSB_ATH3012 },
  167.     { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },
  168.     { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
  169.     { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
  170.     { USB_DEVICE(0x0CF3, 0x0036), .driver_info = BTUSB_ATH3012 },
  171.     { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
  172.     { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
  173.     { USB_DEVICE(0x0cf3, 0x311D), .driver_info = BTUSB_ATH3012 },
  174.     { USB_DEVICE(0x0cf3, 0x311E), .driver_info = BTUSB_ATH3012 },
  175.     { USB_DEVICE(0x0cf3, 0x311F), .driver_info = BTUSB_ATH3012 },
  176.     { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
  177.     { USB_DEVICE(0x0CF3, 0x817a), .driver_info = BTUSB_ATH3012 },
  178.     { USB_DEVICE(0x0CF3, 0x817b), .driver_info = BTUSB_ATH3012 },
  179.     { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
  180.     { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
  181.     { USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },
  182.     { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
  183.     { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
  184.     { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
  185.     { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
  186.     { USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },
  187.     { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
  188.     { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },
  189.     { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },
  190.     { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },
  191.     { USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },
  192.     { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },
  193.     { USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },
  194.     { USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },
  195.  
  196.     /* Atheros AR5BBU22 with sflash firmware */
  197.     { USB_DEVICE(0x0489, 0xE036), .driver_info = BTUSB_ATH3012 },
  198.     { USB_DEVICE(0x0489, 0xE03C), .driver_info = BTUSB_ATH3012 },
  199.  
  200.     { } /* Terminating entry */
  201. };
  202.  
  203. #define USB_REQ_DFU_DNLOAD  1
  204. #define BULK_SIZE       4096
  205. #define FW_HDR_SIZE     20
  206. #define TIMEGAP_USEC_MIN    50
  207. #define TIMEGAP_USEC_MAX    100
  208.  
  209. static int ath3k_load_firmware(struct usb_device *udev,
  210.                 const struct firmware *firmware)
  211. {
  212.     u8 *send_buf;
  213.     int len = 0;
  214.     int err, pipe, size, sent = 0;
  215.     int count = firmware->size;
  216.  
  217.     BT_DBG("udev %p", udev);
  218.  
  219.     pipe = usb_sndctrlpipe(udev, 0);
  220.  
  221.     send_buf = kmalloc(BULK_SIZE, GFP_KERNEL);
  222.     if (!send_buf) {
  223.         BT_ERR("Can't allocate memory chunk for firmware");
  224.         return -ENOMEM;
  225.     }
  226.  
  227.     memcpy(send_buf, firmware->data, 20);
  228.     err = usb_control_msg(udev, pipe, USB_REQ_DFU_DNLOAD, USB_TYPE_VENDOR,
  229.                   0, 0, send_buf, 20, USB_CTRL_SET_TIMEOUT);
  230.     if (err < 0) {
  231.         BT_ERR("Can't change to loading configuration err");
  232.         goto error;
  233.     }
  234.     sent += 20;
  235.     count -= 20;
  236.  
  237.     pipe = usb_sndbulkpipe(udev, 0x02);
  238.  
  239.     while (count) {
  240.         /* workaround the compatibility issue with xHCI controller*/
  241.         usleep_range(TIMEGAP_USEC_MIN, TIMEGAP_USEC_MAX);
  242.  
  243.         size = min_t(uint, count, BULK_SIZE);
  244.         memcpy(send_buf, firmware->data + sent, size);
  245.  
  246.         err = usb_bulk_msg(udev, pipe, send_buf, size,
  247.                     &len, 3000);
  248.  
  249.         if (err || (len != size)) {
  250.             BT_ERR("Error in firmware loading err = %d,"
  251.                 "len = %d, size = %d", err, len, size);
  252.             goto error;
  253.         }
  254.  
  255.         sent  += size;
  256.         count -= size;
  257.     }
  258.  
  259. error:
  260.     kfree(send_buf);
  261.     return err;
  262. }
  263.  
  264. static int ath3k_get_state(struct usb_device *udev, unsigned char *state)
  265. {
  266.     int ret, pipe = 0;
  267.     char *buf;
  268.  
  269.     buf = kmalloc(sizeof(*buf), GFP_KERNEL);
  270.     if (!buf)
  271.         return -ENOMEM;
  272.  
  273.     pipe = usb_rcvctrlpipe(udev, 0);
  274.     ret = usb_control_msg(udev, pipe, ATH3K_GETSTATE,
  275.                   USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
  276.                   buf, sizeof(*buf), USB_CTRL_SET_TIMEOUT);
  277.  
  278.     *state = *buf;
  279.     kfree(buf);
  280.  
  281.     return ret;
  282. }
  283.  
  284. static int ath3k_get_version(struct usb_device *udev,
  285.             struct ath3k_version *version)
  286. {
  287.     int ret, pipe = 0;
  288.     struct ath3k_version *buf;
  289.     const int size = sizeof(*buf);
  290.  
  291.     buf = kmalloc(size, GFP_KERNEL);
  292.     if (!buf)
  293.         return -ENOMEM;
  294.  
  295.     pipe = usb_rcvctrlpipe(udev, 0);
  296.     ret = usb_control_msg(udev, pipe, ATH3K_GETVERSION,
  297.                   USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
  298.                   buf, size, USB_CTRL_SET_TIMEOUT);
  299.  
  300.     memcpy(version, buf, size);
  301.     kfree(buf);
  302.  
  303.     return ret;
  304. }
  305.  
  306. static int ath3k_load_fwfile(struct usb_device *udev,
  307.         const struct firmware *firmware)
  308. {
  309.     u8 *send_buf;
  310.     int len = 0;
  311.     int err, pipe, size, count, sent = 0;
  312.     int ret;
  313.  
  314.     count = firmware->size;
  315.  
  316.     send_buf = kmalloc(BULK_SIZE, GFP_KERNEL);
  317.     if (!send_buf) {
  318.         BT_ERR("Can't allocate memory chunk for firmware");
  319.         return -ENOMEM;
  320.     }
  321.  
  322.     size = min_t(uint, count, FW_HDR_SIZE);
  323.     memcpy(send_buf, firmware->data, size);
  324.  
  325.     pipe = usb_sndctrlpipe(udev, 0);
  326.     ret = usb_control_msg(udev, pipe, ATH3K_DNLOAD,
  327.             USB_TYPE_VENDOR, 0, 0, send_buf,
  328.             size, USB_CTRL_SET_TIMEOUT);
  329.     if (ret < 0) {
  330.         BT_ERR("Can't change to loading configuration err");
  331.         kfree(send_buf);
  332.         return ret;
  333.     }
  334.  
  335.     sent += size;
  336.     count -= size;
  337.  
  338.     pipe = usb_sndbulkpipe(udev, 0x02);
  339.  
  340.     while (count) {
  341.         /* workaround the compatibility issue with xHCI controller*/
  342.         usleep_range(TIMEGAP_USEC_MIN, TIMEGAP_USEC_MAX);
  343.  
  344.         size = min_t(uint, count, BULK_SIZE);
  345.         memcpy(send_buf, firmware->data + sent, size);
  346.  
  347.         err = usb_bulk_msg(udev, pipe, send_buf, size,
  348.                     &len, 3000);
  349.         if (err || (len != size)) {
  350.             BT_ERR("Error in firmware loading err = %d,"
  351.                 "len = %d, size = %d", err, len, size);
  352.             kfree(send_buf);
  353.             return err;
  354.         }
  355.         sent  += size;
  356.         count -= size;
  357.     }
  358.  
  359.     kfree(send_buf);
  360.     return 0;
  361. }
  362.  
  363. static int ath3k_switch_pid(struct usb_device *udev)
  364. {
  365.     int pipe = 0;
  366.  
  367.     pipe = usb_sndctrlpipe(udev, 0);
  368.     return usb_control_msg(udev, pipe, USB_REG_SWITCH_VID_PID,
  369.             USB_TYPE_VENDOR, 0, 0,
  370.             NULL, 0, USB_CTRL_SET_TIMEOUT);
  371. }
  372.  
  373. static int ath3k_set_normal_mode(struct usb_device *udev)
  374. {
  375.     unsigned char fw_state;
  376.     int pipe = 0, ret;
  377.  
  378.     ret = ath3k_get_state(udev, &fw_state);
  379.     if (ret < 0) {
  380.         BT_ERR("Can't get state to change to normal mode err");
  381.         return ret;
  382.     }
  383.  
  384.     if ((fw_state & ATH3K_MODE_MASK) == ATH3K_NORMAL_MODE) {
  385.         BT_DBG("firmware was already in normal mode");
  386.         return 0;
  387.     }
  388.  
  389.     pipe = usb_sndctrlpipe(udev, 0);
  390.     return usb_control_msg(udev, pipe, ATH3K_SET_NORMAL_MODE,
  391.             USB_TYPE_VENDOR, 0, 0,
  392.             NULL, 0, USB_CTRL_SET_TIMEOUT);
  393. }
  394.  
  395. static int ath3k_load_patch(struct usb_device *udev)
  396. {
  397.     unsigned char fw_state;
  398.     char filename[ATH3K_NAME_LEN] = {0};
  399.     const struct firmware *firmware;
  400.     struct ath3k_version fw_version;
  401.     __u32 pt_rom_version, pt_build_version;
  402.     int ret;
  403.  
  404.     ret = ath3k_get_state(udev, &fw_state);
  405.     if (ret < 0) {
  406.         BT_ERR("Can't get state to change to load ram patch err");
  407.         return ret;
  408.     }
  409.  
  410.     if (fw_state & ATH3K_PATCH_UPDATE) {
  411.         BT_DBG("Patch was already downloaded");
  412.         return 0;
  413.     }
  414.  
  415.     ret = ath3k_get_version(udev, &fw_version);
  416.     if (ret < 0) {
  417.         BT_ERR("Can't get version to change to load ram patch err");
  418.         return ret;
  419.     }
  420.  
  421.     snprintf(filename, ATH3K_NAME_LEN, "ar3k/AthrBT_0x%08x.dfu",
  422.          le32_to_cpu(fw_version.rom_version));
  423.  
  424.     ret = request_firmware(&firmware, filename, &udev->dev);
  425.     if (ret < 0) {
  426.         BT_ERR("Patch file not found %s", filename);
  427.         return ret;
  428.     }
  429.  
  430.     pt_rom_version = get_unaligned_le32(firmware->data +
  431.                         firmware->size - 8);
  432.     pt_build_version = get_unaligned_le32(firmware->data +
  433.                           firmware->size - 4);
  434.  
  435.     if (pt_rom_version != le32_to_cpu(fw_version.rom_version) ||
  436.         pt_build_version <= le32_to_cpu(fw_version.build_version)) {
  437.         BT_ERR("Patch file version did not match with firmware");
  438.         release_firmware(firmware);
  439.         return -EINVAL;
  440.     }
  441.  
  442.     ret = ath3k_load_fwfile(udev, firmware);
  443.     release_firmware(firmware);
  444.  
  445.     return ret;
  446. }
  447.  
  448. static int ath3k_load_syscfg(struct usb_device *udev)
  449. {
  450.     unsigned char fw_state;
  451.     char filename[ATH3K_NAME_LEN] = {0};
  452.     const struct firmware *firmware;
  453.     struct ath3k_version fw_version;
  454.     int clk_value, ret;
  455.  
  456.     ret = ath3k_get_state(udev, &fw_state);
  457.     if (ret < 0) {
  458.         BT_ERR("Can't get state to change to load configuration err");
  459.         return -EBUSY;
  460.     }
  461.  
  462.     ret = ath3k_get_version(udev, &fw_version);
  463.     if (ret < 0) {
  464.         BT_ERR("Can't get version to change to load ram patch err");
  465.         return ret;
  466.     }
  467.  
  468.     switch (fw_version.ref_clock) {
  469.  
  470.     case ATH3K_XTAL_FREQ_26M:
  471.         clk_value = 26;
  472.         break;
  473.     case ATH3K_XTAL_FREQ_40M:
  474.         clk_value = 40;
  475.         break;
  476.     case ATH3K_XTAL_FREQ_19P2:
  477.         clk_value = 19;
  478.         break;
  479.     default:
  480.         clk_value = 0;
  481.         break;
  482.     }
  483.  
  484.     snprintf(filename, ATH3K_NAME_LEN, "ar3k/ramps_0x%08x_%d%s",
  485.         le32_to_cpu(fw_version.rom_version), clk_value, ".dfu");
  486.  
  487.     ret = request_firmware(&firmware, filename, &udev->dev);
  488.     if (ret < 0) {
  489.         BT_ERR("Configuration file not found %s", filename);
  490.         return ret;
  491.     }
  492.  
  493.     ret = ath3k_load_fwfile(udev, firmware);
  494.     release_firmware(firmware);
  495.  
  496.     return ret;
  497. }
  498.  
  499. static int ath3k_probe(struct usb_interface *intf,
  500.             const struct usb_device_id *id)
  501. {
  502.     const struct firmware *firmware;
  503.     struct usb_device *udev = interface_to_usbdev(intf);
  504.     int ret;
  505.  
  506.     BT_DBG("intf %p id %p", intf, id);
  507.  
  508.     if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
  509.         return -ENODEV;
  510.  
  511.     /* match device ID in ath3k blacklist table */
  512.     if (!id->driver_info) {
  513.         const struct usb_device_id *match;
  514.  
  515.         match = usb_match_id(intf, ath3k_blist_tbl);
  516.         if (match)
  517.             id = match;
  518.     }
  519.  
  520.     /* load patch and sysconfig files for AR3012 */
  521.     if (id->driver_info & BTUSB_ATH3012) {
  522.  
  523.         /* New firmware with patch and sysconfig files already loaded */
  524.         if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x0001)
  525.             return -ENODEV;
  526.  
  527.         ret = ath3k_load_patch(udev);
  528.         if (ret < 0) {
  529.             BT_ERR("Loading patch file failed");
  530.             return ret;
  531.         }
  532.         ret = ath3k_load_syscfg(udev);
  533.         if (ret < 0) {
  534.             BT_ERR("Loading sysconfig file failed");
  535.             return ret;
  536.         }
  537.         ret = ath3k_set_normal_mode(udev);
  538.         if (ret < 0) {
  539.             BT_ERR("Set normal mode failed");
  540.             return ret;
  541.         }
  542.         ath3k_switch_pid(udev);
  543.         return 0;
  544.     }
  545.  
  546.     ret = request_firmware(&firmware, ATH3K_FIRMWARE, &udev->dev);
  547.     if (ret < 0) {
  548.         if (ret == -ENOENT)
  549.             BT_ERR("Firmware file \"%s\" not found",
  550.                             ATH3K_FIRMWARE);
  551.         else
  552.             BT_ERR("Firmware file \"%s\" request failed (err=%d)",
  553.                             ATH3K_FIRMWARE, ret);
  554.         return ret;
  555.     }
  556.  
  557.     ret = ath3k_load_firmware(udev, firmware);
  558.     release_firmware(firmware);
  559.  
  560.     return ret;
  561. }
  562.  
  563. static void ath3k_disconnect(struct usb_interface *intf)
  564. {
  565.     BT_DBG("ath3k_disconnect intf %p", intf);
  566. }
  567.  
  568. static struct usb_driver ath3k_driver = {
  569.     .name       = "ath3k",
  570.     .probe      = ath3k_probe,
  571.     .disconnect = ath3k_disconnect,
  572.     .id_table   = ath3k_table,
  573.     .disable_hub_initiated_lpm = 1,
  574. };
  575.  
  576. module_usb_driver(ath3k_driver);
  577.  
  578. MODULE_AUTHOR("Atheros Communications");
  579. MODULE_DESCRIPTION("Atheros AR30xx firmware driver");
  580. MODULE_VERSION(VERSION);
  581. MODULE_LICENSE("GPL");
  582. MODULE_FIRMWARE(ATH3K_FIRMWARE);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!