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