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