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