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