drivers/bluetooth/ath3k.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) 2008-2009 Atheros Communications Inc.
0004  */
0005
0006
0007 #include <linux/module.h>
0008 #include <linux/kernel.h>
0009 #include <linux/init.h>
0010 #include <linux/slab.h>
0011 #include <linux/types.h>
0012 #include <linux/errno.h>
0013 #include <linux/firmware.h>
0014 #include <linux/usb.h>
0015 #include <asm/unaligned.h>
0016 #include <net/bluetooth/bluetooth.h>
0017
0018 #define VERSION "1.0"
0019 #define ATH3K_FIRMWARE  "ath3k-1.fw"
0020
0021 #define ATH3K_DNLOAD                0x01
0022 #define ATH3K_GETSTATE              0x05
0023 #define ATH3K_SET_NORMAL_MODE           0x07
0024 #define ATH3K_GETVERSION            0x09
0025 #define USB_REG_SWITCH_VID_PID          0x0a
0026
0027 #define ATH3K_MODE_MASK             0x3F
0028 #define ATH3K_NORMAL_MODE           0x0E
0029
0030 #define ATH3K_PATCH_UPDATE          0x80
0031 #define ATH3K_SYSCFG_UPDATE         0x40
0032
0033 #define ATH3K_XTAL_FREQ_26M         0x00
0034 #define ATH3K_XTAL_FREQ_40M         0x01
0035 #define ATH3K_XTAL_FREQ_19P2            0x02
0036 #define ATH3K_NAME_LEN              0xFF
0037
0038 struct ath3k_version {
0039     __le32  rom_version;
0040     __le32  build_version;
0041     __le32  ram_version;
0042     __u8    ref_clock;
0043     __u8    reserved[7];
0044 } __packed;
0045
0046 static const struct usb_device_id ath3k_table[] = {
0047     /* Atheros AR3011 */
0048     { USB_DEVICE(0x0CF3, 0x3000) },
0049
0050     /* Atheros AR3011 with sflash firmware*/
0051     { USB_DEVICE(0x0489, 0xE027) },
0052     { USB_DEVICE(0x0489, 0xE03D) },
0053     { USB_DEVICE(0x04F2, 0xAFF1) },
0054     { USB_DEVICE(0x0930, 0x0215) },
0055     { USB_DEVICE(0x0CF3, 0x3002) },
0056     { USB_DEVICE(0x0CF3, 0xE019) },
0057     { USB_DEVICE(0x13d3, 0x3304) },
0058
0059     /* Atheros AR9285 Malbec with sflash firmware */
0060     { USB_DEVICE(0x03F0, 0x311D) },
0061
0062     /* Atheros AR3012 with sflash firmware*/
0063     { USB_DEVICE(0x0489, 0xe04d) },
0064     { USB_DEVICE(0x0489, 0xe04e) },
0065     { USB_DEVICE(0x0489, 0xe057) },
0066     { USB_DEVICE(0x0489, 0xe056) },
0067     { USB_DEVICE(0x0489, 0xe05f) },
0068     { USB_DEVICE(0x0489, 0xe076) },
0069     { USB_DEVICE(0x0489, 0xe078) },
0070     { USB_DEVICE(0x0489, 0xe095) },
0071     { USB_DEVICE(0x04c5, 0x1330) },
0072     { USB_DEVICE(0x04CA, 0x3004) },
0073     { USB_DEVICE(0x04CA, 0x3005) },
0074     { USB_DEVICE(0x04CA, 0x3006) },
0075     { USB_DEVICE(0x04CA, 0x3007) },
0076     { USB_DEVICE(0x04CA, 0x3008) },
0077     { USB_DEVICE(0x04CA, 0x300b) },
0078     { USB_DEVICE(0x04CA, 0x300d) },
0079     { USB_DEVICE(0x04CA, 0x300f) },
0080     { USB_DEVICE(0x04CA, 0x3010) },
0081     { USB_DEVICE(0x04CA, 0x3014) },
0082     { USB_DEVICE(0x04CA, 0x3018) },
0083     { USB_DEVICE(0x0930, 0x0219) },
0084     { USB_DEVICE(0x0930, 0x021c) },
0085     { USB_DEVICE(0x0930, 0x0220) },
0086     { USB_DEVICE(0x0930, 0x0227) },
0087     { USB_DEVICE(0x0b05, 0x17d0) },
0088     { USB_DEVICE(0x0CF3, 0x0036) },
0089     { USB_DEVICE(0x0CF3, 0x3004) },
0090     { USB_DEVICE(0x0CF3, 0x3008) },
0091     { USB_DEVICE(0x0CF3, 0x311D) },
0092     { USB_DEVICE(0x0CF3, 0x311E) },
0093     { USB_DEVICE(0x0CF3, 0x311F) },
0094     { USB_DEVICE(0x0cf3, 0x3121) },
0095     { USB_DEVICE(0x0CF3, 0x817a) },
0096     { USB_DEVICE(0x0CF3, 0x817b) },
0097     { USB_DEVICE(0x0cf3, 0xe003) },
0098     { USB_DEVICE(0x0CF3, 0xE004) },
0099     { USB_DEVICE(0x0CF3, 0xE005) },
0100     { USB_DEVICE(0x0CF3, 0xE006) },
0101     { USB_DEVICE(0x13d3, 0x3362) },
0102     { USB_DEVICE(0x13d3, 0x3375) },
0103     { USB_DEVICE(0x13d3, 0x3393) },
0104     { USB_DEVICE(0x13d3, 0x3395) },
0105     { USB_DEVICE(0x13d3, 0x3402) },
0106     { USB_DEVICE(0x13d3, 0x3408) },
0107     { USB_DEVICE(0x13d3, 0x3423) },
0108     { USB_DEVICE(0x13d3, 0x3432) },
0109     { USB_DEVICE(0x13d3, 0x3472) },
0110     { USB_DEVICE(0x13d3, 0x3474) },
0111     { USB_DEVICE(0x13d3, 0x3487) },
0112     { USB_DEVICE(0x13d3, 0x3490) },
0113
0114     /* Atheros AR5BBU12 with sflash firmware */
0115     { USB_DEVICE(0x0489, 0xE02C) },
0116
0117     /* Atheros AR5BBU22 with sflash firmware */
0118     { USB_DEVICE(0x0489, 0xE036) },
0119     { USB_DEVICE(0x0489, 0xE03C) },
0120
0121     { } /* Terminating entry */
0122 };
0123
0124 MODULE_DEVICE_TABLE(usb, ath3k_table);
0125
0126 #define BTUSB_ATH3012       0x80
0127 /* This table is to load patch and sysconfig files
0128  * for AR3012
0129  */
0130 static const struct usb_device_id ath3k_blist_tbl[] = {
0131
0132     /* Atheros AR3012 with sflash firmware*/
0133     { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
0134     { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
0135     { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
0136     { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
0137     { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
0138     { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },
0139     { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },
0140     { USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },
0141     { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
0142     { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
0143     { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
0144     { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
0145     { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },
0146     { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
0147     { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
0148     { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },
0149     { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },
0150     { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },
0151     { USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },
0152     { USB_DEVICE(0x04ca, 0x3018), .driver_info = BTUSB_ATH3012 },
0153     { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
0154     { USB_DEVICE(0x0930, 0x021c), .driver_info = BTUSB_ATH3012 },
0155     { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },
0156     { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
0157     { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
0158     { USB_DEVICE(0x0CF3, 0x0036), .driver_info = BTUSB_ATH3012 },
0159     { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
0160     { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
0161     { USB_DEVICE(0x0cf3, 0x311D), .driver_info = BTUSB_ATH3012 },
0162     { USB_DEVICE(0x0cf3, 0x311E), .driver_info = BTUSB_ATH3012 },
0163     { USB_DEVICE(0x0cf3, 0x311F), .driver_info = BTUSB_ATH3012 },
0164     { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
0165     { USB_DEVICE(0x0CF3, 0x817a), .driver_info = BTUSB_ATH3012 },
0166     { USB_DEVICE(0x0CF3, 0x817b), .driver_info = BTUSB_ATH3012 },
0167     { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
0168     { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
0169     { USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },
0170     { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
0171     { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
0172     { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
0173     { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
0174     { USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },
0175     { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
0176     { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },
0177     { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },
0178     { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },
0179     { USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },
0180     { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },
0181     { USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },
0182     { USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },
0183
0184     /* Atheros AR5BBU22 with sflash firmware */
0185     { USB_DEVICE(0x0489, 0xE036), .driver_info = BTUSB_ATH3012 },
0186     { USB_DEVICE(0x0489, 0xE03C), .driver_info = BTUSB_ATH3012 },
0187
0188     { } /* Terminating entry */
0189 };
0190
0191 static inline void ath3k_log_failed_loading(int err, int len, int size,
0192                         int count)
0193 {
0194     BT_ERR("Firmware loading err = %d, len = %d, size = %d, count = %d",
0195            err, len, size, count);
0196 }
0197
0198 #define USB_REQ_DFU_DNLOAD  1
0199 #define BULK_SIZE       4096
0200 #define FW_HDR_SIZE     20
0201 #define TIMEGAP_USEC_MIN    50
0202 #define TIMEGAP_USEC_MAX    100
0203
0204 static int ath3k_load_firmware(struct usb_device *udev,
0205                 const struct firmware *firmware)
0206 {
0207     u8 *send_buf;
0208     int len = 0;
0209     int err, pipe, size, sent = 0;
0210     int count = firmware->size;
0211
0212     BT_DBG("udev %p", udev);
0213
0214     send_buf = kmalloc(BULK_SIZE, GFP_KERNEL);
0215     if (!send_buf) {
0216         BT_ERR("Can't allocate memory chunk for firmware");
0217         return -ENOMEM;
0218     }
0219
0220     err = usb_control_msg_send(udev, 0, USB_REQ_DFU_DNLOAD, USB_TYPE_VENDOR,
0221                    0, 0, firmware->data, FW_HDR_SIZE,
0222                    USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
0223     if (err) {
0224         BT_ERR("Can't change to loading configuration err");
0225         goto error;
0226     }
0227     sent += FW_HDR_SIZE;
0228     count -= FW_HDR_SIZE;
0229
0230     pipe = usb_sndbulkpipe(udev, 0x02);
0231
0232     while (count) {
0233         /* workaround the compatibility issue with xHCI controller*/
0234         usleep_range(TIMEGAP_USEC_MIN, TIMEGAP_USEC_MAX);
0235
0236         size = min_t(uint, count, BULK_SIZE);
0237         memcpy(send_buf, firmware->data + sent, size);
0238
0239         err = usb_bulk_msg(udev, pipe, send_buf, size,
0240                     &len, 3000);
0241
0242         if (err || (len != size)) {
0243             ath3k_log_failed_loading(err, len, size, count);
0244             goto error;
0245         }
0246
0247         sent  += size;
0248         count -= size;
0249     }
0250
0251 error:
0252     kfree(send_buf);
0253     return err;
0254 }
0255
0256 static int ath3k_get_state(struct usb_device *udev, unsigned char *state)
0257 {
0258     return usb_control_msg_recv(udev, 0, ATH3K_GETSTATE,
0259                     USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
0260                     state, 1, USB_CTRL_SET_TIMEOUT,
0261                     GFP_KERNEL);
0262 }
0263
0264 static int ath3k_get_version(struct usb_device *udev,
0265             struct ath3k_version *version)
0266 {
0267     return usb_control_msg_recv(udev, 0, ATH3K_GETVERSION,
0268                     USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
0269                     version, sizeof(*version), USB_CTRL_SET_TIMEOUT,
0270                     GFP_KERNEL);
0271 }
0272
0273 static int ath3k_load_fwfile(struct usb_device *udev,
0274         const struct firmware *firmware)
0275 {
0276     u8 *send_buf;
0277     int len = 0;
0278     int err, pipe, size, count, sent = 0;
0279     int ret;
0280
0281     count = firmware->size;
0282
0283     send_buf = kmalloc(BULK_SIZE, GFP_KERNEL);
0284     if (!send_buf) {
0285         BT_ERR("Can't allocate memory chunk for firmware");
0286         return -ENOMEM;
0287     }
0288
0289     size = min_t(uint, count, FW_HDR_SIZE);
0290
0291     ret = usb_control_msg_send(udev, 0, ATH3K_DNLOAD, USB_TYPE_VENDOR, 0, 0,
0292                    firmware->data, size, USB_CTRL_SET_TIMEOUT,
0293                    GFP_KERNEL);
0294     if (ret) {
0295         BT_ERR("Can't change to loading configuration err");
0296         kfree(send_buf);
0297         return ret;
0298     }
0299
0300     sent += size;
0301     count -= size;
0302
0303     pipe = usb_sndbulkpipe(udev, 0x02);
0304
0305     while (count) {
0306         /* workaround the compatibility issue with xHCI controller*/
0307         usleep_range(TIMEGAP_USEC_MIN, TIMEGAP_USEC_MAX);
0308
0309         size = min_t(uint, count, BULK_SIZE);
0310         memcpy(send_buf, firmware->data + sent, size);
0311
0312         err = usb_bulk_msg(udev, pipe, send_buf, size,
0313                     &len, 3000);
0314         if (err || (len != size)) {
0315             ath3k_log_failed_loading(err, len, size, count);
0316             kfree(send_buf);
0317             return err;
0318         }
0319         sent  += size;
0320         count -= size;
0321     }
0322
0323     kfree(send_buf);
0324     return 0;
0325 }
0326
0327 static void ath3k_switch_pid(struct usb_device *udev)
0328 {
0329     usb_control_msg_send(udev, 0, USB_REG_SWITCH_VID_PID, USB_TYPE_VENDOR,
0330                  0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
0331 }
0332
0333 static int ath3k_set_normal_mode(struct usb_device *udev)
0334 {
0335     unsigned char fw_state;
0336     int ret;
0337
0338     ret = ath3k_get_state(udev, &fw_state);
0339     if (ret) {
0340         BT_ERR("Can't get state to change to normal mode err");
0341         return ret;
0342     }
0343
0344     if ((fw_state & ATH3K_MODE_MASK) == ATH3K_NORMAL_MODE) {
0345         BT_DBG("firmware was already in normal mode");
0346         return 0;
0347     }
0348
0349     return usb_control_msg_send(udev, 0, ATH3K_SET_NORMAL_MODE,
0350                     USB_TYPE_VENDOR, 0, 0, NULL, 0,
0351                     USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
0352 }
0353
0354 static int ath3k_load_patch(struct usb_device *udev)
0355 {
0356     unsigned char fw_state;
0357     char filename[ATH3K_NAME_LEN];
0358     const struct firmware *firmware;
0359     struct ath3k_version fw_version;
0360     __u32 pt_rom_version, pt_build_version;
0361     int ret;
0362
0363     ret = ath3k_get_state(udev, &fw_state);
0364     if (ret) {
0365         BT_ERR("Can't get state to change to load ram patch err");
0366         return ret;
0367     }
0368
0369     if (fw_state & ATH3K_PATCH_UPDATE) {
0370         BT_DBG("Patch was already downloaded");
0371         return 0;
0372     }
0373
0374     ret = ath3k_get_version(udev, &fw_version);
0375     if (ret) {
0376         BT_ERR("Can't get version to change to load ram patch err");
0377         return ret;
0378     }
0379
0380     snprintf(filename, ATH3K_NAME_LEN, "ar3k/AthrBT_0x%08x.dfu",
0381          le32_to_cpu(fw_version.rom_version));
0382
0383     ret = request_firmware(&firmware, filename, &udev->dev);
0384     if (ret < 0) {
0385         BT_ERR("Patch file not found %s", filename);
0386         return ret;
0387     }
0388
0389     pt_rom_version = get_unaligned_le32(firmware->data +
0390                         firmware->size - 8);
0391     pt_build_version = get_unaligned_le32(firmware->data +
0392                           firmware->size - 4);
0393
0394     if (pt_rom_version != le32_to_cpu(fw_version.rom_version) ||
0395         pt_build_version <= le32_to_cpu(fw_version.build_version)) {
0396         BT_ERR("Patch file version did not match with firmware");
0397         release_firmware(firmware);
0398         return -EINVAL;
0399     }
0400
0401     ret = ath3k_load_fwfile(udev, firmware);
0402     release_firmware(firmware);
0403
0404     return ret;
0405 }
0406
0407 static int ath3k_load_syscfg(struct usb_device *udev)
0408 {
0409     unsigned char fw_state;
0410     char filename[ATH3K_NAME_LEN];
0411     const struct firmware *firmware;
0412     struct ath3k_version fw_version;
0413     int clk_value, ret;
0414
0415     ret = ath3k_get_state(udev, &fw_state);
0416     if (ret) {
0417         BT_ERR("Can't get state to change to load configuration err");
0418         return -EBUSY;
0419     }
0420
0421     ret = ath3k_get_version(udev, &fw_version);
0422     if (ret) {
0423         BT_ERR("Can't get version to change to load ram patch err");
0424         return ret;
0425     }
0426
0427     switch (fw_version.ref_clock) {
0428
0429     case ATH3K_XTAL_FREQ_26M:
0430         clk_value = 26;
0431         break;
0432     case ATH3K_XTAL_FREQ_40M:
0433         clk_value = 40;
0434         break;
0435     case ATH3K_XTAL_FREQ_19P2:
0436         clk_value = 19;
0437         break;
0438     default:
0439         clk_value = 0;
0440         break;
0441     }
0442
0443     snprintf(filename, ATH3K_NAME_LEN, "ar3k/ramps_0x%08x_%d%s",
0444         le32_to_cpu(fw_version.rom_version), clk_value, ".dfu");
0445
0446     ret = request_firmware(&firmware, filename, &udev->dev);
0447     if (ret < 0) {
0448         BT_ERR("Configuration file not found %s", filename);
0449         return ret;
0450     }
0451
0452     ret = ath3k_load_fwfile(udev, firmware);
0453     release_firmware(firmware);
0454
0455     return ret;
0456 }
0457
0458 static int ath3k_probe(struct usb_interface *intf,
0459             const struct usb_device_id *id)
0460 {
0461     const struct firmware *firmware;
0462     struct usb_device *udev = interface_to_usbdev(intf);
0463     int ret;
0464
0465     BT_DBG("intf %p id %p", intf, id);
0466
0467     if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
0468         return -ENODEV;
0469
0470     /* match device ID in ath3k blacklist table */
0471     if (!id->driver_info) {
0472         const struct usb_device_id *match;
0473
0474         match = usb_match_id(intf, ath3k_blist_tbl);
0475         if (match)
0476             id = match;
0477     }
0478
0479     /* load patch and sysconfig files for AR3012 */
0480     if (id->driver_info & BTUSB_ATH3012) {
0481         /* New firmware with patch and sysconfig files already loaded */
0482         if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x0001)
0483             return -ENODEV;
0484
0485         ret = ath3k_load_patch(udev);
0486         if (ret < 0) {
0487             BT_ERR("Loading patch file failed");
0488             return ret;
0489         }
0490         ret = ath3k_load_syscfg(udev);
0491         if (ret < 0) {
0492             BT_ERR("Loading sysconfig file failed");
0493             return ret;
0494         }
0495         ret = ath3k_set_normal_mode(udev);
0496         if (ret) {
0497             BT_ERR("Set normal mode failed");
0498             return ret;
0499         }
0500         ath3k_switch_pid(udev);
0501         return 0;
0502     }
0503
0504     ret = request_firmware(&firmware, ATH3K_FIRMWARE, &udev->dev);
0505     if (ret < 0) {
0506         if (ret == -ENOENT)
0507             BT_ERR("Firmware file \"%s\" not found",
0508                             ATH3K_FIRMWARE);
0509         else
0510             BT_ERR("Firmware file \"%s\" request failed (err=%d)",
0511                             ATH3K_FIRMWARE, ret);
0512         return ret;
0513     }
0514
0515     ret = ath3k_load_firmware(udev, firmware);
0516     release_firmware(firmware);
0517
0518     return ret;
0519 }
0520
0521 static void ath3k_disconnect(struct usb_interface *intf)
0522 {
0523     BT_DBG("%s intf %p", __func__, intf);
0524 }
0525
0526 static struct usb_driver ath3k_driver = {
0527     .name       = "ath3k",
0528     .probe      = ath3k_probe,
0529     .disconnect = ath3k_disconnect,
0530     .id_table   = ath3k_table,
0531     .disable_hub_initiated_lpm = 1,
0532 };
0533
0534 module_usb_driver(ath3k_driver);
0535
0536 MODULE_AUTHOR("Atheros Communications");
0537 MODULE_DESCRIPTION("Atheros AR30xx firmware driver");
0538 MODULE_VERSION(VERSION);
0539 MODULE_LICENSE("GPL");
0540 MODULE_FIRMWARE(ATH3K_FIRMWARE);