Merge branch 'ioat-md-accel-for-linus' of git://lost.foo-projects.org/~dwillia2/git/iop
[linux-2.6] / drivers / usb / serial / sierra.c
1 /*
2   USB Driver for Sierra Wireless
3
4   Copyright (C) 2006  Kevin Lloyd <linux@sierrawireless.com>
5
6   IMPORTANT DISCLAIMER: This driver is not commercially supported by
7   Sierra Wireless. Use at your own risk.
8
9   This driver is free software; you can redistribute it and/or modify
10   it under the terms of Version 2 of the GNU General Public License as
11   published by the Free Software Foundation.
12
13   Portions based on the option driver by Matthias Urlichs <smurf@smurf.noris.de>
14   Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org>
15
16 */
17
18 #define DRIVER_VERSION "v.1.0.6"
19 #define DRIVER_AUTHOR "Kevin Lloyd <linux@sierrawireless.com>"
20 #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
21
22 #include <linux/kernel.h>
23 #include <linux/jiffies.h>
24 #include <linux/errno.h>
25 #include <linux/tty.h>
26 #include <linux/tty_flip.h>
27 #include <linux/module.h>
28 #include <linux/usb.h>
29 #include <linux/usb/serial.h>
30
31
32 static struct usb_device_id id_table [] = {
33         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
34         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
35         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
36         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
37         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
38         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
39         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
40         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
41         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
42         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
43         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
44         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
45
46         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
47         { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
48         { }
49 };
50 MODULE_DEVICE_TABLE(usb, id_table);
51
52 static struct usb_device_id id_table_1port [] = {
53         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
54         { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
55         { }
56 };
57
58 static struct usb_device_id id_table_3port [] = {
59         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
60         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
61         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
62         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
63         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
64         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
65         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
66         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
67         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
68         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
69         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
70         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
71         { }
72 };
73
74 static struct usb_driver sierra_driver = {
75         .name       = "sierra",
76         .probe      = usb_serial_probe,
77         .disconnect = usb_serial_disconnect,
78         .id_table   = id_table,
79         .no_dynamic_id =        1,
80 };
81
82
83 static int debug;
84
85 /* per port private data */
86 #define N_IN_URB        4
87 #define N_OUT_URB       4
88 #define IN_BUFLEN       4096
89
90 struct sierra_port_private {
91         spinlock_t lock;        /* lock the structure */
92         int outstanding_urbs;   /* number of out urbs in flight */
93
94         /* Input endpoints and buffer for this port */
95         struct urb *in_urbs[N_IN_URB];
96         char in_buffer[N_IN_URB][IN_BUFLEN];
97
98         /* Settings for the port */
99         int rts_state;  /* Handshaking pins (outputs) */
100         int dtr_state;
101         int cts_state;  /* Handshaking pins (inputs) */
102         int dsr_state;
103         int dcd_state;
104         int ri_state;
105 };
106
107 static int sierra_send_setup(struct usb_serial_port *port)
108 {
109         struct usb_serial *serial = port->serial;
110         struct sierra_port_private *portdata;
111
112         dbg("%s", __FUNCTION__);
113
114         portdata = usb_get_serial_port_data(port);
115
116         if (port->tty) {
117                 int val = 0;
118                 if (portdata->dtr_state)
119                         val |= 0x01;
120                 if (portdata->rts_state)
121                         val |= 0x02;
122
123                 return usb_control_msg(serial->dev,
124                                 usb_rcvctrlpipe(serial->dev, 0),
125                                 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
126         }
127
128         return 0;
129 }
130
131 static void sierra_rx_throttle(struct usb_serial_port *port)
132 {
133         dbg("%s", __FUNCTION__);
134 }
135
136 static void sierra_rx_unthrottle(struct usb_serial_port *port)
137 {
138         dbg("%s", __FUNCTION__);
139 }
140
141 static void sierra_break_ctl(struct usb_serial_port *port, int break_state)
142 {
143         /* Unfortunately, I don't know how to send a break */
144         dbg("%s", __FUNCTION__);
145 }
146
147 static void sierra_set_termios(struct usb_serial_port *port,
148                         struct ktermios *old_termios)
149 {
150         dbg("%s", __FUNCTION__);
151
152         sierra_send_setup(port);
153 }
154
155 static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
156 {
157         unsigned int value;
158         struct sierra_port_private *portdata;
159
160         portdata = usb_get_serial_port_data(port);
161
162         value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
163                 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
164                 ((portdata->cts_state) ? TIOCM_CTS : 0) |
165                 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
166                 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
167                 ((portdata->ri_state) ? TIOCM_RNG : 0);
168
169         return value;
170 }
171
172 static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
173                         unsigned int set, unsigned int clear)
174 {
175         struct sierra_port_private *portdata;
176
177         portdata = usb_get_serial_port_data(port);
178
179         if (set & TIOCM_RTS)
180                 portdata->rts_state = 1;
181         if (set & TIOCM_DTR)
182                 portdata->dtr_state = 1;
183
184         if (clear & TIOCM_RTS)
185                 portdata->rts_state = 0;
186         if (clear & TIOCM_DTR)
187                 portdata->dtr_state = 0;
188         return sierra_send_setup(port);
189 }
190
191 static int sierra_ioctl(struct usb_serial_port *port, struct file *file,
192                         unsigned int cmd, unsigned long arg)
193 {
194         return -ENOIOCTLCMD;
195 }
196
197 static void sierra_outdat_callback(struct urb *urb)
198 {
199         struct usb_serial_port *port = urb->context;
200         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
201         int status = urb->status;
202         unsigned long flags;
203
204         dbg("%s - port %d", __FUNCTION__, port->number);
205
206         /* free up the transfer buffer, as usb_free_urb() does not do this */
207         kfree(urb->transfer_buffer);
208
209         if (status)
210                 dbg("%s - nonzero write bulk status received: %d",
211                     __FUNCTION__, status);
212
213         spin_lock_irqsave(&portdata->lock, flags);
214         --portdata->outstanding_urbs;
215         spin_unlock_irqrestore(&portdata->lock, flags);
216
217         usb_serial_port_softint(port);
218 }
219
220 /* Write */
221 static int sierra_write(struct usb_serial_port *port,
222                         const unsigned char *buf, int count)
223 {
224         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
225         struct usb_serial *serial = port->serial;
226         unsigned long flags;
227         unsigned char *buffer;
228         struct urb *urb;
229         int status;
230
231         portdata = usb_get_serial_port_data(port);
232
233         dbg("%s: write (%d chars)", __FUNCTION__, count);
234
235         spin_lock_irqsave(&portdata->lock, flags);
236         if (portdata->outstanding_urbs > N_OUT_URB) {
237                 spin_unlock_irqrestore(&portdata->lock, flags);
238                 dbg("%s - write limit hit\n", __FUNCTION__);
239                 return 0;
240         }
241         portdata->outstanding_urbs++;
242         spin_unlock_irqrestore(&portdata->lock, flags);
243
244         buffer = kmalloc(count, GFP_ATOMIC);
245         if (!buffer) {
246                 dev_err(&port->dev, "out of memory\n");
247                 count = -ENOMEM;
248                 goto error_no_buffer;
249         }
250
251         urb = usb_alloc_urb(0, GFP_ATOMIC);
252         if (!urb) {
253                 dev_err(&port->dev, "no more free urbs\n");
254                 count = -ENOMEM;
255                 goto error_no_urb;
256         }
257
258         memcpy(buffer, buf, count);
259
260         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, buffer);
261
262         usb_fill_bulk_urb(urb, serial->dev,
263                           usb_sndbulkpipe(serial->dev,
264                                           port->bulk_out_endpointAddress),
265                           buffer, count, sierra_outdat_callback, port);
266
267         /* send it down the pipe */
268         status = usb_submit_urb(urb, GFP_ATOMIC);
269         if (status) {
270                 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
271                         "with status = %d\n", __FUNCTION__, status);
272                 count = status;
273                 goto error;
274         }
275
276         /* we are done with this urb, so let the host driver
277          * really free it when it is finished with it */
278         usb_free_urb(urb);
279
280         return count;
281 error:
282         usb_free_urb(urb);
283 error_no_urb:
284         kfree(buffer);
285 error_no_buffer:
286         spin_lock_irqsave(&portdata->lock, flags);
287         --portdata->outstanding_urbs;
288         spin_unlock_irqrestore(&portdata->lock, flags);
289         return count;
290 }
291
292 static void sierra_indat_callback(struct urb *urb)
293 {
294         int err;
295         int endpoint;
296         struct usb_serial_port *port;
297         struct tty_struct *tty;
298         unsigned char *data = urb->transfer_buffer;
299         int status = urb->status;
300
301         dbg("%s: %p", __FUNCTION__, urb);
302
303         endpoint = usb_pipeendpoint(urb->pipe);
304         port = (struct usb_serial_port *) urb->context;
305
306         if (status) {
307                 dbg("%s: nonzero status: %d on endpoint %02x.",
308                     __FUNCTION__, status, endpoint);
309         } else {
310                 tty = port->tty;
311                 if (urb->actual_length) {
312                         tty_buffer_request_room(tty, urb->actual_length);
313                         tty_insert_flip_string(tty, data, urb->actual_length);
314                         tty_flip_buffer_push(tty);
315                 } else {
316                         dbg("%s: empty read urb received", __FUNCTION__);
317                 }
318
319                 /* Resubmit urb so we continue receiving */
320                 if (port->open_count && status != -ESHUTDOWN) {
321                         err = usb_submit_urb(urb, GFP_ATOMIC);
322                         if (err)
323                                 dev_err(&port->dev, "resubmit read urb failed."
324                                         "(%d)", err);
325                 }
326         }
327         return;
328 }
329
330 static void sierra_instat_callback(struct urb *urb)
331 {
332         int err;
333         int status = urb->status;
334         struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
335         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
336         struct usb_serial *serial = port->serial;
337
338         dbg("%s", __FUNCTION__);
339         dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
340
341         if (status == 0) {
342                 struct usb_ctrlrequest *req_pkt =
343                                 (struct usb_ctrlrequest *)urb->transfer_buffer;
344
345                 if (!req_pkt) {
346                         dbg("%s: NULL req_pkt\n", __FUNCTION__);
347                         return;
348                 }
349                 if ((req_pkt->bRequestType == 0xA1) &&
350                                 (req_pkt->bRequest == 0x20)) {
351                         int old_dcd_state;
352                         unsigned char signals = *((unsigned char *)
353                                         urb->transfer_buffer +
354                                         sizeof(struct usb_ctrlrequest));
355
356                         dbg("%s: signal x%x", __FUNCTION__, signals);
357
358                         old_dcd_state = portdata->dcd_state;
359                         portdata->cts_state = 1;
360                         portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
361                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
362                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
363
364                         if (port->tty && !C_CLOCAL(port->tty) &&
365                                         old_dcd_state && !portdata->dcd_state)
366                                 tty_hangup(port->tty);
367                 } else {
368                         dbg("%s: type %x req %x", __FUNCTION__,
369                                 req_pkt->bRequestType,req_pkt->bRequest);
370                 }
371         } else
372                 dbg("%s: error %d", __FUNCTION__, status);
373
374         /* Resubmit urb so we continue receiving IRQ data */
375         if (status != -ESHUTDOWN) {
376                 urb->dev = serial->dev;
377                 err = usb_submit_urb(urb, GFP_ATOMIC);
378                 if (err)
379                         dbg("%s: resubmit intr urb failed. (%d)",
380                                 __FUNCTION__, err);
381         }
382 }
383
384 static int sierra_write_room(struct usb_serial_port *port)
385 {
386         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
387         unsigned long flags;
388
389         dbg("%s - port %d", __FUNCTION__, port->number);
390
391         /* try to give a good number back based on if we have any free urbs at
392          * this point in time */
393         spin_lock_irqsave(&portdata->lock, flags);
394         if (portdata->outstanding_urbs > N_OUT_URB * 2 / 3) {
395                 spin_unlock_irqrestore(&portdata->lock, flags);
396                 dbg("%s - write limit hit\n", __FUNCTION__);
397                 return 0;
398         }
399         spin_unlock_irqrestore(&portdata->lock, flags);
400
401         return 2048;
402 }
403
404 static int sierra_chars_in_buffer(struct usb_serial_port *port)
405 {
406         dbg("%s - port %d", __FUNCTION__, port->number);
407
408         /*
409          * We can't really account for how much data we
410          * have sent out, but hasn't made it through to the
411          * device as we can't see the backend here, so just
412          * tell the tty layer that everything is flushed.
413          */
414         return 0;
415 }
416
417 static int sierra_open(struct usb_serial_port *port, struct file *filp)
418 {
419         struct sierra_port_private *portdata;
420         struct usb_serial *serial = port->serial;
421         int i;
422         struct urb *urb;
423         int result;
424         __u16 set_mode_dzero = 0x0000;
425
426         portdata = usb_get_serial_port_data(port);
427
428         dbg("%s", __FUNCTION__);
429
430         /* Set some sane defaults */
431         portdata->rts_state = 1;
432         portdata->dtr_state = 1;
433
434         /* Reset low level data toggle and start reading from endpoints */
435         for (i = 0; i < N_IN_URB; i++) {
436                 urb = portdata->in_urbs[i];
437                 if (!urb)
438                         continue;
439                 if (urb->dev != serial->dev) {
440                         dbg("%s: dev %p != %p", __FUNCTION__,
441                                 urb->dev, serial->dev);
442                         continue;
443                 }
444
445                 /*
446                  * make sure endpoint data toggle is synchronized with the
447                  * device
448                  */
449                 usb_clear_halt(urb->dev, urb->pipe);
450
451                 result = usb_submit_urb(urb, GFP_KERNEL);
452                 if (result) {
453                         dev_err(&port->dev, "submit urb %d failed (%d) %d",
454                                 i, result, urb->transfer_buffer_length);
455                 }
456         }
457
458         port->tty->low_latency = 1;
459
460         /* set mode to D0 */
461         result = usb_control_msg(serial->dev,
462                                  usb_rcvctrlpipe(serial->dev, 0),
463                                  0x00, 0x40, set_mode_dzero, 0, NULL,
464                                  0, USB_CTRL_SET_TIMEOUT);
465
466         sierra_send_setup(port);
467
468         /* start up the interrupt endpoint if we have one */
469         if (port->interrupt_in_urb) {
470                 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
471                 if (result)
472                         dev_err(&port->dev, "submit irq_in urb failed %d",
473                                 result);
474         }
475         return 0;
476 }
477
478 static void sierra_close(struct usb_serial_port *port, struct file *filp)
479 {
480         int i;
481         struct usb_serial *serial = port->serial;
482         struct sierra_port_private *portdata;
483
484         dbg("%s", __FUNCTION__);
485         portdata = usb_get_serial_port_data(port);
486
487         portdata->rts_state = 0;
488         portdata->dtr_state = 0;
489
490         if (serial->dev) {
491                 sierra_send_setup(port);
492
493                 /* Stop reading/writing urbs */
494                 for (i = 0; i < N_IN_URB; i++)
495                         usb_kill_urb(portdata->in_urbs[i]);
496         }
497
498         usb_kill_urb(port->interrupt_in_urb);
499
500         port->tty = NULL;
501 }
502
503 static int sierra_startup(struct usb_serial *serial)
504 {
505         struct usb_serial_port *port;
506         struct sierra_port_private *portdata;
507         struct urb *urb;
508         int i;
509         int j;
510
511         dbg("%s", __FUNCTION__);
512
513         /* Now setup per port private data */
514         for (i = 0; i < serial->num_ports; i++) {
515                 port = serial->port[i];
516                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
517                 if (!portdata) {
518                         dbg("%s: kmalloc for sierra_port_private (%d) failed!.",
519                                         __FUNCTION__, i);
520                         return -ENOMEM;
521                 }
522                 spin_lock_init(&portdata->lock);
523
524                 usb_set_serial_port_data(port, portdata);
525
526                 /* initialize the in urbs */
527                 for (j = 0; j < N_IN_URB; ++j) {
528                         urb = usb_alloc_urb(0, GFP_KERNEL);
529                         if (urb == NULL) {
530                                 dbg("%s: alloc for in port failed.",
531                                     __FUNCTION__);
532                                 continue;
533                         }
534                         /* Fill URB using supplied data. */
535                         usb_fill_bulk_urb(urb, serial->dev,
536                                           usb_rcvbulkpipe(serial->dev,
537                                                 port->bulk_in_endpointAddress),
538                                           portdata->in_buffer[j], IN_BUFLEN,
539                                           sierra_indat_callback, port);
540                         portdata->in_urbs[j] = urb;
541                 }
542         }
543
544         return 0;
545 }
546
547 static void sierra_shutdown(struct usb_serial *serial)
548 {
549         int i, j;
550         struct usb_serial_port *port;
551         struct sierra_port_private *portdata;
552
553         dbg("%s", __FUNCTION__);
554
555         for (i = 0; i < serial->num_ports; ++i) {
556                 port = serial->port[i];
557                 if (!port)
558                         continue;
559                 portdata = usb_get_serial_port_data(port);
560                 if (!portdata)
561                         continue;
562
563                 for (j = 0; j < N_IN_URB; j++) {
564                         usb_kill_urb(portdata->in_urbs[j]);
565                         usb_free_urb(portdata->in_urbs[j]);
566                         portdata->in_urbs[j] = NULL;
567                 }
568                 kfree(portdata);
569                 usb_set_serial_port_data(port, NULL);
570         }
571 }
572
573 static struct usb_serial_driver sierra_1port_device = {
574         .driver = {
575                 .owner =        THIS_MODULE,
576                 .name =         "sierra1",
577         },
578         .description       = "Sierra USB modem (1 port)",
579         .id_table          = id_table_1port,
580         .usb_driver        = &sierra_driver,
581         .num_interrupt_in  = NUM_DONT_CARE,
582         .num_bulk_in       = 1,
583         .num_bulk_out      = 1,
584         .num_ports         = 1,
585         .open              = sierra_open,
586         .close             = sierra_close,
587         .write             = sierra_write,
588         .write_room        = sierra_write_room,
589         .chars_in_buffer   = sierra_chars_in_buffer,
590         .throttle          = sierra_rx_throttle,
591         .unthrottle        = sierra_rx_unthrottle,
592         .ioctl             = sierra_ioctl,
593         .set_termios       = sierra_set_termios,
594         .break_ctl         = sierra_break_ctl,
595         .tiocmget          = sierra_tiocmget,
596         .tiocmset          = sierra_tiocmset,
597         .attach            = sierra_startup,
598         .shutdown          = sierra_shutdown,
599         .read_int_callback = sierra_instat_callback,
600 };
601
602 static struct usb_serial_driver sierra_3port_device = {
603         .driver = {
604                 .owner =        THIS_MODULE,
605                 .name =         "sierra3",
606         },
607         .description       = "Sierra USB modem (3 port)",
608         .id_table          = id_table_3port,
609         .usb_driver        = &sierra_driver,
610         .num_interrupt_in  = NUM_DONT_CARE,
611         .num_bulk_in       = 3,
612         .num_bulk_out      = 3,
613         .num_ports         = 3,
614         .open              = sierra_open,
615         .close             = sierra_close,
616         .write             = sierra_write,
617         .write_room        = sierra_write_room,
618         .chars_in_buffer   = sierra_chars_in_buffer,
619         .throttle          = sierra_rx_throttle,
620         .unthrottle        = sierra_rx_unthrottle,
621         .ioctl             = sierra_ioctl,
622         .set_termios       = sierra_set_termios,
623         .break_ctl         = sierra_break_ctl,
624         .tiocmget          = sierra_tiocmget,
625         .tiocmset          = sierra_tiocmset,
626         .attach            = sierra_startup,
627         .shutdown          = sierra_shutdown,
628         .read_int_callback = sierra_instat_callback,
629 };
630
631 /* Functions used by new usb-serial code. */
632 static int __init sierra_init(void)
633 {
634         int retval;
635         retval = usb_serial_register(&sierra_1port_device);
636         if (retval)
637                 goto failed_1port_device_register;
638         retval = usb_serial_register(&sierra_3port_device);
639         if (retval)
640                 goto failed_3port_device_register;
641
642
643         retval = usb_register(&sierra_driver);
644         if (retval)
645                 goto failed_driver_register;
646
647         info(DRIVER_DESC ": " DRIVER_VERSION);
648
649         return 0;
650
651 failed_driver_register:
652         usb_serial_deregister(&sierra_3port_device);
653 failed_3port_device_register:
654         usb_serial_deregister(&sierra_1port_device);
655 failed_1port_device_register:
656         return retval;
657 }
658
659 static void __exit sierra_exit(void)
660 {
661         usb_deregister (&sierra_driver);
662         usb_serial_deregister(&sierra_1port_device);
663         usb_serial_deregister(&sierra_3port_device);
664 }
665
666 module_init(sierra_init);
667 module_exit(sierra_exit);
668
669 MODULE_AUTHOR(DRIVER_AUTHOR);
670 MODULE_DESCRIPTION(DRIVER_DESC);
671 MODULE_VERSION(DRIVER_VERSION);
672 MODULE_LICENSE("GPL");
673
674 #ifdef CONFIG_USB_DEBUG
675 module_param(debug, bool, S_IRUGO | S_IWUSR);
676 MODULE_PARM_DESC(debug, "Debug messages");
677 #endif
678