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