Advertisement
Guest User

linux 4.8 ath3k.c

a guest
Jan 1st, 2017
161
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.44 KB
  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
Advertisement
Advertisement
RAW Paste Data Copied
Advertisement