Merge upstream ieee80211.h with us (us == branch 'ieee80211' of netdev-2.6)
[linux-2.6] / drivers / usb / atm / speedtch.c
1 /******************************************************************************
2  *  speedtch.c  -  Alcatel SpeedTouch USB xDSL modem driver
3  *
4  *  Copyright (C) 2001, Alcatel
5  *  Copyright (C) 2003, Duncan Sands
6  *  Copyright (C) 2004, David Woodhouse
7  *
8  *  Based on "modem_run.c", copyright (C) 2001, Benoit Papillault
9  *
10  *  This program is free software; you can redistribute it and/or modify it
11  *  under the terms of the GNU General Public License as published by the Free
12  *  Software Foundation; either version 2 of the License, or (at your option)
13  *  any later version.
14  *
15  *  This program is distributed in the hope that it will be useful, but WITHOUT
16  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18  *  more details.
19  *
20  *  You should have received a copy of the GNU General Public License along with
21  *  this program; if not, write to the Free Software Foundation, Inc., 59
22  *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  ******************************************************************************/
25
26 #include <asm/page.h>
27 #include <linux/device.h>
28 #include <linux/errno.h>
29 #include <linux/firmware.h>
30 #include <linux/gfp.h>
31 #include <linux/init.h>
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/moduleparam.h>
35 #include <linux/slab.h>
36 #include <linux/stat.h>
37 #include <linux/timer.h>
38 #include <linux/workqueue.h>
39
40 #include "usbatm.h"
41
42 #define DRIVER_AUTHOR   "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
43 #define DRIVER_VERSION  "1.9"
44 #define DRIVER_DESC     "Alcatel SpeedTouch USB driver version " DRIVER_VERSION
45
46 static const char speedtch_driver_name[] = "speedtch";
47
48 #define CTRL_TIMEOUT 2000       /* milliseconds */
49 #define DATA_TIMEOUT 2000       /* milliseconds */
50
51 #define OFFSET_7        0               /* size 1 */
52 #define OFFSET_b        1               /* size 8 */
53 #define OFFSET_d        9               /* size 4 */
54 #define OFFSET_e        13              /* size 1 */
55 #define OFFSET_f        14              /* size 1 */
56 #define TOTAL           15
57
58 #define SIZE_7          1
59 #define SIZE_b          8
60 #define SIZE_d          4
61 #define SIZE_e          1
62 #define SIZE_f          1
63
64 #define MIN_POLL_DELAY          5000    /* milliseconds */
65 #define MAX_POLL_DELAY          60000   /* milliseconds */
66
67 #define RESUBMIT_DELAY          1000    /* milliseconds */
68
69 #define DEFAULT_ALTSETTING      1
70 #define DEFAULT_DL_512_FIRST    0
71 #define DEFAULT_SW_BUFFERING    0
72
73 static int altsetting = DEFAULT_ALTSETTING;
74 static int dl_512_first = DEFAULT_DL_512_FIRST;
75 static int sw_buffering = DEFAULT_SW_BUFFERING;
76
77 module_param(altsetting, int, S_IRUGO | S_IWUSR);
78 MODULE_PARM_DESC(altsetting,
79                  "Alternative setting for data interface (default: "
80                  __MODULE_STRING(DEFAULT_ALTSETTING) ")");
81
82 module_param(dl_512_first, bool, S_IRUGO | S_IWUSR);
83 MODULE_PARM_DESC(dl_512_first,
84                  "Read 512 bytes before sending firmware (default: "
85                  __MODULE_STRING(DEFAULT_DL_512_FIRST) ")");
86
87 module_param(sw_buffering, bool, S_IRUGO | S_IWUSR);
88 MODULE_PARM_DESC(sw_buffering,
89                  "Enable software buffering (default: "
90                  __MODULE_STRING(DEFAULT_SW_BUFFERING) ")");
91
92 #define ENDPOINT_INT            0x81
93 #define ENDPOINT_DATA           0x07
94 #define ENDPOINT_FIRMWARE       0x05
95
96 #define hex2int(c) ( (c >= '0') && (c <= '9') ? (c - '0') : ((c & 0xf) + 9) )
97
98 struct speedtch_instance_data {
99         struct usbatm_data *usbatm;
100
101         struct work_struct status_checker;
102
103         int poll_delay; /* milliseconds */
104
105         struct timer_list resubmit_timer;
106         struct urb *int_urb;
107         unsigned char int_data[16];
108
109         unsigned char scratch_buffer[TOTAL];
110 };
111
112 /***************
113 **  firmware  **
114 ***************/
115
116 static void speedtch_set_swbuff(struct speedtch_instance_data *instance, int state)
117 {
118         struct usbatm_data *usbatm = instance->usbatm;
119         struct usb_device *usb_dev = usbatm->usb_dev;
120         int ret;
121
122         ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
123                               0x32, 0x40, state ? 0x01 : 0x00, 0x00, NULL, 0, CTRL_TIMEOUT);
124         if (ret < 0)
125                 usb_warn(usbatm,
126                          "%sabling SW buffering: usb_control_msg returned %d\n",
127                          state ? "En" : "Dis", ret);
128         else
129                 dbg("speedtch_set_swbuff: %sbled SW buffering", state ? "En" : "Dis");
130 }
131
132 static void speedtch_test_sequence(struct speedtch_instance_data *instance)
133 {
134         struct usbatm_data *usbatm = instance->usbatm;
135         struct usb_device *usb_dev = usbatm->usb_dev;
136         unsigned char *buf = instance->scratch_buffer;
137         int ret;
138
139         /* URB 147 */
140         buf[0] = 0x1c;
141         buf[1] = 0x50;
142         ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
143                               0x01, 0x40, 0x0b, 0x00, buf, 2, CTRL_TIMEOUT);
144         if (ret < 0)
145                 usb_warn(usbatm, "%s failed on URB147: %d\n", __func__, ret);
146
147         /* URB 148 */
148         buf[0] = 0x32;
149         buf[1] = 0x00;
150         ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
151                               0x01, 0x40, 0x02, 0x00, buf, 2, CTRL_TIMEOUT);
152         if (ret < 0)
153                 usb_warn(usbatm, "%s failed on URB148: %d\n", __func__, ret);
154
155         /* URB 149 */
156         buf[0] = 0x01;
157         buf[1] = 0x00;
158         buf[2] = 0x01;
159         ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
160                               0x01, 0x40, 0x03, 0x00, buf, 3, CTRL_TIMEOUT);
161         if (ret < 0)
162                 usb_warn(usbatm, "%s failed on URB149: %d\n", __func__, ret);
163
164         /* URB 150 */
165         buf[0] = 0x01;
166         buf[1] = 0x00;
167         buf[2] = 0x01;
168         ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
169                               0x01, 0x40, 0x04, 0x00, buf, 3, CTRL_TIMEOUT);
170         if (ret < 0)
171                 usb_warn(usbatm, "%s failed on URB150: %d\n", __func__, ret);
172 }
173
174 static int speedtch_upload_firmware(struct speedtch_instance_data *instance,
175                                      const struct firmware *fw1,
176                                      const struct firmware *fw2)
177 {
178         unsigned char *buffer;
179         struct usbatm_data *usbatm = instance->usbatm;
180         struct usb_interface *intf;
181         struct usb_device *usb_dev = usbatm->usb_dev;
182         int actual_length;
183         int ret = 0;
184         int offset;
185
186         usb_dbg(usbatm, "%s entered\n", __func__);
187
188         if (!(buffer = (unsigned char *)__get_free_page(GFP_KERNEL))) {
189                 ret = -ENOMEM;
190                 usb_dbg(usbatm, "%s: no memory for buffer!\n", __func__);
191                 goto out;
192         }
193
194         if (!(intf = usb_ifnum_to_if(usb_dev, 2))) {
195                 ret = -ENODEV;
196                 usb_dbg(usbatm, "%s: interface not found!\n", __func__);
197                 goto out_free;
198         }
199
200         /* URB 7 */
201         if (dl_512_first) {     /* some modems need a read before writing the firmware */
202                 ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
203                                    buffer, 0x200, &actual_length, 2000);
204
205                 if (ret < 0 && ret != -ETIMEDOUT)
206                         usb_dbg(usbatm, "%s: read BLOCK0 from modem failed (%d)!\n", __func__, ret);
207                 else
208                         usb_dbg(usbatm, "%s: BLOCK0 downloaded (%d bytes)\n", __func__, ret);
209         }
210
211         /* URB 8 : both leds are static green */
212         for (offset = 0; offset < fw1->size; offset += PAGE_SIZE) {
213                 int thislen = min_t(int, PAGE_SIZE, fw1->size - offset);
214                 memcpy(buffer, fw1->data + offset, thislen);
215
216                 ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
217                                    buffer, thislen, &actual_length, DATA_TIMEOUT);
218
219                 if (ret < 0) {
220                         usb_dbg(usbatm, "%s: write BLOCK1 to modem failed (%d)!\n", __func__, ret);
221                         goto out_free;
222                 }
223                 usb_dbg(usbatm, "%s: BLOCK1 uploaded (%zu bytes)\n", __func__, fw1->size);
224         }
225
226         /* USB led blinking green, ADSL led off */
227
228         /* URB 11 */
229         ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
230                            buffer, 0x200, &actual_length, DATA_TIMEOUT);
231
232         if (ret < 0) {
233                 usb_dbg(usbatm, "%s: read BLOCK2 from modem failed (%d)!\n", __func__, ret);
234                 goto out_free;
235         }
236         usb_dbg(usbatm, "%s: BLOCK2 downloaded (%d bytes)\n", __func__, actual_length);
237
238         /* URBs 12 to 139 - USB led blinking green, ADSL led off */
239         for (offset = 0; offset < fw2->size; offset += PAGE_SIZE) {
240                 int thislen = min_t(int, PAGE_SIZE, fw2->size - offset);
241                 memcpy(buffer, fw2->data + offset, thislen);
242
243                 ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
244                                    buffer, thislen, &actual_length, DATA_TIMEOUT);
245
246                 if (ret < 0) {
247                         usb_dbg(usbatm, "%s: write BLOCK3 to modem failed (%d)!\n", __func__, ret);
248                         goto out_free;
249                 }
250         }
251         usb_dbg(usbatm, "%s: BLOCK3 uploaded (%zu bytes)\n", __func__, fw2->size);
252
253         /* USB led static green, ADSL led static red */
254
255         /* URB 142 */
256         ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
257                            buffer, 0x200, &actual_length, DATA_TIMEOUT);
258
259         if (ret < 0) {
260                 usb_dbg(usbatm, "%s: read BLOCK4 from modem failed (%d)!\n", __func__, ret);
261                 goto out_free;
262         }
263
264         /* success */
265         usb_dbg(usbatm, "%s: BLOCK4 downloaded (%d bytes)\n", __func__, actual_length);
266
267         /* Delay to allow firmware to start up. We can do this here
268            because we're in our own kernel thread anyway. */
269         msleep_interruptible(1000);
270
271         /* Enable software buffering, if requested */
272         if (sw_buffering)
273                 speedtch_set_swbuff(instance, 1);
274
275         /* Magic spell; don't ask us what this does */
276         speedtch_test_sequence(instance);
277
278         ret = 0;
279
280 out_free:
281         free_page((unsigned long)buffer);
282 out:
283         return ret;
284 }
285
286 static int speedtch_find_firmware(struct usb_interface *intf, int phase,
287                                   const struct firmware **fw_p)
288 {
289         struct device *dev = &intf->dev;
290         const u16 bcdDevice = le16_to_cpu(interface_to_usbdev(intf)->descriptor.bcdDevice);
291         const u8 major_revision = bcdDevice >> 8;
292         const u8 minor_revision = bcdDevice & 0xff;
293         char buf[24];
294
295         sprintf(buf, "speedtch-%d.bin.%x.%02x", phase, major_revision, minor_revision);
296         dev_dbg(dev, "%s: looking for %s\n", __func__, buf);
297
298         if (request_firmware(fw_p, buf, dev)) {
299                 sprintf(buf, "speedtch-%d.bin.%x", phase, major_revision);
300                 dev_dbg(dev, "%s: looking for %s\n", __func__, buf);
301
302                 if (request_firmware(fw_p, buf, dev)) {
303                         sprintf(buf, "speedtch-%d.bin", phase);
304                         dev_dbg(dev, "%s: looking for %s\n", __func__, buf);
305
306                         if (request_firmware(fw_p, buf, dev)) {
307                                 dev_warn(dev, "no stage %d firmware found!\n", phase);
308                                 return -ENOENT;
309                         }
310                 }
311         }
312
313         dev_info(dev, "found stage %d firmware %s\n", phase, buf);
314
315         return 0;
316 }
317
318 static int speedtch_heavy_init(struct usbatm_data *usbatm, struct usb_interface *intf)
319 {
320         const struct firmware *fw1, *fw2;
321         struct speedtch_instance_data *instance = usbatm->driver_data;
322         int ret;
323
324         if ((ret = speedtch_find_firmware(intf, 1, &fw1)) < 0)
325                         return ret;
326
327         if ((ret = speedtch_find_firmware(intf, 2, &fw2)) < 0) {
328                 release_firmware(fw1);
329                 return ret;
330         }
331
332         ret = speedtch_upload_firmware(instance, fw1, fw2);
333
334         release_firmware(fw2);
335         release_firmware(fw1);
336
337         return ret;
338 }
339
340
341 /**********
342 **  ATM  **
343 **********/
344
345 static int speedtch_read_status(struct speedtch_instance_data *instance)
346 {
347         struct usbatm_data *usbatm = instance->usbatm;
348         struct usb_device *usb_dev = usbatm->usb_dev;
349         unsigned char *buf = instance->scratch_buffer;
350         int ret;
351
352         memset(buf, 0, TOTAL);
353
354         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
355                               0x12, 0xc0, 0x07, 0x00, buf + OFFSET_7, SIZE_7,
356                               CTRL_TIMEOUT);
357         if (ret < 0) {
358                 atm_dbg(usbatm, "%s: MSG 7 failed\n", __func__);
359                 return ret;
360         }
361
362         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
363                               0x12, 0xc0, 0x0b, 0x00, buf + OFFSET_b, SIZE_b,
364                               CTRL_TIMEOUT);
365         if (ret < 0) {
366                 atm_dbg(usbatm, "%s: MSG B failed\n", __func__);
367                 return ret;
368         }
369
370         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
371                               0x12, 0xc0, 0x0d, 0x00, buf + OFFSET_d, SIZE_d,
372                               CTRL_TIMEOUT);
373         if (ret < 0) {
374                 atm_dbg(usbatm, "%s: MSG D failed\n", __func__);
375                 return ret;
376         }
377
378         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
379                               0x01, 0xc0, 0x0e, 0x00, buf + OFFSET_e, SIZE_e,
380                               CTRL_TIMEOUT);
381         if (ret < 0) {
382                 atm_dbg(usbatm, "%s: MSG E failed\n", __func__);
383                 return ret;
384         }
385
386         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
387                               0x01, 0xc0, 0x0f, 0x00, buf + OFFSET_f, SIZE_f,
388                               CTRL_TIMEOUT);
389         if (ret < 0) {
390                 atm_dbg(usbatm, "%s: MSG F failed\n", __func__);
391                 return ret;
392         }
393
394         return 0;
395 }
396
397 static int speedtch_start_synchro(struct speedtch_instance_data *instance)
398 {
399         struct usbatm_data *usbatm = instance->usbatm;
400         struct usb_device *usb_dev = usbatm->usb_dev;
401         unsigned char *buf = instance->scratch_buffer;
402         int ret;
403
404         atm_dbg(usbatm, "%s entered\n", __func__);
405
406         memset(buf, 0, 2);
407
408         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
409                               0x12, 0xc0, 0x04, 0x00,
410                               buf, 2, CTRL_TIMEOUT);
411
412         if (ret < 0)
413                 atm_warn(usbatm, "failed to start ADSL synchronisation: %d\n", ret);
414         else
415                 atm_dbg(usbatm, "%s: modem prodded. %d bytes returned: %02x %02x\n",
416                         __func__, ret, buf[0], buf[1]);
417
418         return ret;
419 }
420
421 static void speedtch_check_status(struct speedtch_instance_data *instance)
422 {
423         struct usbatm_data *usbatm = instance->usbatm;
424         struct atm_dev *atm_dev = usbatm->atm_dev;
425         unsigned char *buf = instance->scratch_buffer;
426         int ret;
427
428         atm_dbg(usbatm, "%s entered\n", __func__);
429
430         ret = speedtch_read_status(instance);
431         if (ret < 0) {
432                 atm_warn(usbatm, "error %d fetching device status\n", ret);
433                 if (instance->poll_delay < MAX_POLL_DELAY)
434                         instance->poll_delay *= 2;
435                 return;
436         }
437
438         if (instance->poll_delay > MIN_POLL_DELAY)
439                 instance->poll_delay /= 2;
440
441         atm_dbg(usbatm, "%s: line state %02x\n", __func__, buf[OFFSET_7]);
442
443         switch (buf[OFFSET_7]) {
444         case 0:
445                 if (atm_dev->signal != ATM_PHY_SIG_LOST) {
446                         atm_dev->signal = ATM_PHY_SIG_LOST;
447                         atm_info(usbatm, "ADSL line is down\n");
448                         /* It'll never resync again unless we ask it to... */
449                         ret = speedtch_start_synchro(instance);
450                 }
451                 break;
452
453         case 0x08:
454                 if (atm_dev->signal != ATM_PHY_SIG_UNKNOWN) {
455                         atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
456                         atm_info(usbatm, "ADSL line is blocked?\n");
457                 }
458                 break;
459
460         case 0x10:
461                 if (atm_dev->signal != ATM_PHY_SIG_LOST) {
462                         atm_dev->signal = ATM_PHY_SIG_LOST;
463                         atm_info(usbatm, "ADSL line is synchronising\n");
464                 }
465                 break;
466
467         case 0x20:
468                 if (atm_dev->signal != ATM_PHY_SIG_FOUND) {
469                         int down_speed = buf[OFFSET_b] | (buf[OFFSET_b + 1] << 8)
470                                 | (buf[OFFSET_b + 2] << 16) | (buf[OFFSET_b + 3] << 24);
471                         int up_speed = buf[OFFSET_b + 4] | (buf[OFFSET_b + 5] << 8)
472                                 | (buf[OFFSET_b + 6] << 16) | (buf[OFFSET_b + 7] << 24);
473
474                         if (!(down_speed & 0x0000ffff) && !(up_speed & 0x0000ffff)) {
475                                 down_speed >>= 16;
476                                 up_speed >>= 16;
477                         }
478
479                         atm_dev->link_rate = down_speed * 1000 / 424;
480                         atm_dev->signal = ATM_PHY_SIG_FOUND;
481
482                         atm_info(usbatm,
483                                  "ADSL line is up (%d Kib/s down | %d Kib/s up)\n",
484                                  down_speed, up_speed);
485                 }
486                 break;
487
488         default:
489                 if (atm_dev->signal != ATM_PHY_SIG_UNKNOWN) {
490                         atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
491                         atm_info(usbatm, "Unknown line state %02x\n", buf[OFFSET_7]);
492                 }
493                 break;
494         }
495 }
496
497 static void speedtch_status_poll(unsigned long data)
498 {
499         struct speedtch_instance_data *instance = (void *)data;
500
501         schedule_work(&instance->status_checker);
502
503         /* The following check is racy, but the race is harmless */
504         if (instance->poll_delay < MAX_POLL_DELAY)
505                 mod_timer(&instance->status_checker.timer, jiffies + msecs_to_jiffies(instance->poll_delay));
506         else
507                 atm_warn(instance->usbatm, "Too many failures - disabling line status polling\n");
508 }
509
510 static void speedtch_resubmit_int(unsigned long data)
511 {
512         struct speedtch_instance_data *instance = (void *)data;
513         struct urb *int_urb = instance->int_urb;
514         int ret;
515
516         atm_dbg(instance->usbatm, "%s entered\n", __func__);
517
518         if (int_urb) {
519                 ret = usb_submit_urb(int_urb, GFP_ATOMIC);
520                 if (!ret)
521                         schedule_work(&instance->status_checker);
522                 else {
523                         atm_dbg(instance->usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
524                         mod_timer(&instance->resubmit_timer, jiffies + msecs_to_jiffies(RESUBMIT_DELAY));
525                 }
526         }
527 }
528
529 static void speedtch_handle_int(struct urb *int_urb, struct pt_regs *regs)
530 {
531         struct speedtch_instance_data *instance = int_urb->context;
532         struct usbatm_data *usbatm = instance->usbatm;
533         unsigned int count = int_urb->actual_length;
534         int ret = int_urb->status;
535
536         /* The magic interrupt for "up state" */
537         const static unsigned char up_int[6]   = { 0xa1, 0x00, 0x01, 0x00, 0x00, 0x00 };
538         /* The magic interrupt for "down state" */
539         const static unsigned char down_int[6] = { 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00 };
540
541         atm_dbg(usbatm, "%s entered\n", __func__);
542
543         if (ret < 0) {
544                 atm_dbg(usbatm, "%s: nonzero urb status %d!\n", __func__, ret);
545                 goto fail;
546         }
547
548         if ((count == 6) && !memcmp(up_int, instance->int_data, 6)) {
549                 del_timer(&instance->status_checker.timer);
550                 atm_info(usbatm, "DSL line goes up\n");
551         } else if ((count == 6) && !memcmp(down_int, instance->int_data, 6)) {
552                 atm_info(usbatm, "DSL line goes down\n");
553         } else {
554                 int i;
555
556                 atm_dbg(usbatm, "%s: unknown interrupt packet of length %d:", __func__, count);
557                 for (i = 0; i < count; i++)
558                         printk(" %02x", instance->int_data[i]);
559                 printk("\n");
560                 goto fail;
561         }
562
563         if ((int_urb = instance->int_urb)) {
564                 ret = usb_submit_urb(int_urb, GFP_ATOMIC);
565                 schedule_work(&instance->status_checker);
566                 if (ret < 0) {
567                         atm_dbg(usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
568                         goto fail;
569                 }
570         }
571
572         return;
573
574 fail:
575         if ((int_urb = instance->int_urb))
576                 mod_timer(&instance->resubmit_timer, jiffies + msecs_to_jiffies(RESUBMIT_DELAY));
577 }
578
579 static int speedtch_atm_start(struct usbatm_data *usbatm, struct atm_dev *atm_dev)
580 {
581         struct usb_device *usb_dev = usbatm->usb_dev;
582         struct speedtch_instance_data *instance = usbatm->driver_data;
583         int i, ret;
584         unsigned char mac_str[13];
585
586         atm_dbg(usbatm, "%s entered\n", __func__);
587
588         if ((ret = usb_set_interface(usb_dev, 1, altsetting)) < 0) {
589                 atm_dbg(usbatm, "%s: usb_set_interface returned %d!\n", __func__, ret);
590                 return ret;
591         }
592
593         /* Set MAC address, it is stored in the serial number */
594         memset(atm_dev->esi, 0, sizeof(atm_dev->esi));
595         if (usb_string(usb_dev, usb_dev->descriptor.iSerialNumber, mac_str, sizeof(mac_str)) == 12) {
596                 for (i = 0; i < 6; i++)
597                         atm_dev->esi[i] = (hex2int(mac_str[i * 2]) * 16) + (hex2int(mac_str[i * 2 + 1]));
598         }
599
600         /* Start modem synchronisation */
601         ret = speedtch_start_synchro(instance);
602
603         /* Set up interrupt endpoint */
604         if (instance->int_urb) {
605                 ret = usb_submit_urb(instance->int_urb, GFP_KERNEL);
606                 if (ret < 0) {
607                         /* Doesn't matter; we'll poll anyway */
608                         atm_dbg(usbatm, "%s: submission of interrupt URB failed (%d)!\n", __func__, ret);
609                         usb_free_urb(instance->int_urb);
610                         instance->int_urb = NULL;
611                 }
612         }
613
614         /* Start status polling */
615         mod_timer(&instance->status_checker.timer, jiffies + msecs_to_jiffies(1000));
616
617         return 0;
618 }
619
620 static void speedtch_atm_stop(struct usbatm_data *usbatm, struct atm_dev *atm_dev)
621 {
622         struct speedtch_instance_data *instance = usbatm->driver_data;
623         struct urb *int_urb = instance->int_urb;
624
625         atm_dbg(usbatm, "%s entered\n", __func__);
626
627         del_timer_sync(&instance->status_checker.timer);
628
629         /*
630          * Since resubmit_timer and int_urb can schedule themselves and
631          * each other, shutting them down correctly takes some care
632          */
633         instance->int_urb = NULL; /* signal shutdown */
634         mb();
635         usb_kill_urb(int_urb);
636         del_timer_sync(&instance->resubmit_timer);
637         /*
638          * At this point, speedtch_handle_int and speedtch_resubmit_int
639          * can run or be running, but instance->int_urb == NULL means that
640          * they will not reschedule
641          */
642         usb_kill_urb(int_urb);
643         del_timer_sync(&instance->resubmit_timer);
644         usb_free_urb(int_urb);
645
646         flush_scheduled_work();
647 }
648
649
650 /**********
651 **  USB  **
652 **********/
653
654 static struct usb_device_id speedtch_usb_ids[] = {
655         {USB_DEVICE(0x06b9, 0x4061)},
656         {}
657 };
658
659 MODULE_DEVICE_TABLE(usb, speedtch_usb_ids);
660
661 static int speedtch_usb_probe(struct usb_interface *, const struct usb_device_id *);
662
663 static struct usb_driver speedtch_usb_driver = {
664         .owner          = THIS_MODULE,
665         .name           = speedtch_driver_name,
666         .probe          = speedtch_usb_probe,
667         .disconnect     = usbatm_usb_disconnect,
668         .id_table       = speedtch_usb_ids
669 };
670
671 static void speedtch_release_interfaces(struct usb_device *usb_dev, int num_interfaces) {
672         struct usb_interface *cur_intf;
673         int i;
674
675         for(i = 0; i < num_interfaces; i++)
676                 if ((cur_intf = usb_ifnum_to_if(usb_dev, i))) {
677                         usb_set_intfdata(cur_intf, NULL);
678                         usb_driver_release_interface(&speedtch_usb_driver, cur_intf);
679                 }
680 }
681
682 static int speedtch_bind(struct usbatm_data *usbatm,
683                          struct usb_interface *intf,
684                          const struct usb_device_id *id,
685                          int *need_heavy_init)
686 {
687         struct usb_device *usb_dev = interface_to_usbdev(intf);
688         struct usb_interface *cur_intf;
689         struct speedtch_instance_data *instance;
690         int ifnum = intf->altsetting->desc.bInterfaceNumber;
691         int num_interfaces = usb_dev->actconfig->desc.bNumInterfaces;
692         int i, ret;
693
694         usb_dbg(usbatm, "%s entered\n", __func__);
695
696         if (usb_dev->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) {
697                 usb_dbg(usbatm, "%s: wrong device class %d\n", __func__, usb_dev->descriptor.bDeviceClass);
698                 return -ENODEV;
699         }
700
701         /* claim all interfaces */
702
703         for (i=0; i < num_interfaces; i++) {
704                 cur_intf = usb_ifnum_to_if(usb_dev, i);
705
706                 if ((i != ifnum) && cur_intf) {
707                         ret = usb_driver_claim_interface(&speedtch_usb_driver, cur_intf, usbatm);
708
709                         if (ret < 0) {
710                                 usb_dbg(usbatm, "%s: failed to claim interface %d (%d)\n", __func__, i, ret);
711                                 speedtch_release_interfaces(usb_dev, i);
712                                 return ret;
713                         }
714                 }
715         }
716
717         instance = kmalloc(sizeof(*instance), GFP_KERNEL);
718
719         if (!instance) {
720                 usb_dbg(usbatm, "%s: no memory for instance data!\n", __func__);
721                 ret = -ENOMEM;
722                 goto fail_release;
723         }
724
725         memset(instance, 0, sizeof(struct speedtch_instance_data));
726
727         instance->usbatm = usbatm;
728
729         INIT_WORK(&instance->status_checker, (void *)speedtch_check_status, instance);
730
731         instance->status_checker.timer.function = speedtch_status_poll;
732         instance->status_checker.timer.data = (unsigned long)instance;
733         instance->poll_delay = MIN_POLL_DELAY;
734
735         init_timer(&instance->resubmit_timer);
736         instance->resubmit_timer.function = speedtch_resubmit_int;
737         instance->resubmit_timer.data = (unsigned long)instance;
738
739         instance->int_urb = usb_alloc_urb(0, GFP_KERNEL);
740
741         if (instance->int_urb)
742                 usb_fill_int_urb(instance->int_urb, usb_dev,
743                                  usb_rcvintpipe(usb_dev, ENDPOINT_INT),
744                                  instance->int_data, sizeof(instance->int_data),
745                                  speedtch_handle_int, instance, 50);
746         else
747                 usb_dbg(usbatm, "%s: no memory for interrupt urb!\n", __func__);
748
749         /* check whether the modem already seems to be alive */
750         ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
751                               0x12, 0xc0, 0x07, 0x00,
752                               instance->scratch_buffer + OFFSET_7, SIZE_7, 500);
753
754         *need_heavy_init = (ret != SIZE_7);
755
756         usb_dbg(usbatm, "%s: firmware %s loaded\n", __func__, need_heavy_init ? "not" : "already");
757
758         if (*need_heavy_init)
759                 if ((ret = usb_reset_device(usb_dev)) < 0)
760                         goto fail_free;
761
762         usbatm->driver_data = instance;
763
764         return 0;
765
766 fail_free:
767         usb_free_urb(instance->int_urb);
768         kfree(instance);
769 fail_release:
770         speedtch_release_interfaces(usb_dev, num_interfaces);
771         return ret;
772 }
773
774 static void speedtch_unbind(struct usbatm_data *usbatm, struct usb_interface *intf)
775 {
776         struct usb_device *usb_dev = interface_to_usbdev(intf);
777         struct speedtch_instance_data *instance = usbatm->driver_data;
778
779         usb_dbg(usbatm, "%s entered\n", __func__);
780
781         speedtch_release_interfaces(usb_dev, usb_dev->actconfig->desc.bNumInterfaces);
782         usb_free_urb(instance->int_urb);
783         kfree(instance);
784 }
785
786
787 /***********
788 **  init  **
789 ***********/
790
791 static struct usbatm_driver speedtch_usbatm_driver = {
792         .owner          = THIS_MODULE,
793         .driver_name    = speedtch_driver_name,
794         .bind           = speedtch_bind,
795         .heavy_init     = speedtch_heavy_init,
796         .unbind         = speedtch_unbind,
797         .atm_start      = speedtch_atm_start,
798         .atm_stop       = speedtch_atm_stop,
799         .in             = ENDPOINT_DATA,
800         .out            = ENDPOINT_DATA
801 };
802
803 static int speedtch_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
804 {
805         return usbatm_usb_probe(intf, id, &speedtch_usbatm_driver);
806 }
807
808 static int __init speedtch_usb_init(void)
809 {
810         dbg("%s: driver version %s", __func__, DRIVER_VERSION);
811
812         return usb_register(&speedtch_usb_driver);
813 }
814
815 static void __exit speedtch_usb_cleanup(void)
816 {
817         dbg("%s", __func__);
818
819         usb_deregister(&speedtch_usb_driver);
820 }
821
822 module_init(speedtch_usb_init);
823 module_exit(speedtch_usb_cleanup);
824
825 MODULE_AUTHOR(DRIVER_AUTHOR);
826 MODULE_DESCRIPTION(DRIVER_DESC);
827 MODULE_LICENSE("GPL");
828 MODULE_VERSION(DRIVER_VERSION);