?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PARISC] fix "ENTRY" macro redefinition
[wrt350n-kernel.git] / drivers / usb / serial / sierra.c
blob644607de4c11a69f3e0e4a8d22b97e5f9fbcf473
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, 0x0021) }, /* Sierra Wireless AirCard 597E */
39 { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
40 { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
41 { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
42 { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
43 { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
44
45 { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
46 { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
47 { }
48 };
49 MODULE_DEVICE_TABLE(usb, id_table);
50
51 static struct usb_device_id id_table_1port [] = {
52 { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
53 { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
54 { }
55 };
56
57 static struct usb_device_id id_table_3port [] = {
58 { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
59 { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
60 { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
61 { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
62 { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
63 { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
64 { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
65 { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
66 { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
67 { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
68 { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
69 { }
70 };
71
72 static struct usb_driver sierra_driver = {
73 .name = "sierra",
74 .probe = usb_serial_probe,
75 .disconnect = usb_serial_disconnect,
76 .id_table = id_table,
77 .no_dynamic_id = 1,
78 };
79
80
81 static int debug;
82
83 /* per port private data */
84 #define N_IN_URB 4
85 #define N_OUT_URB 4
86 #define IN_BUFLEN 4096
87 #define OUT_BUFLEN 128
88
89 struct sierra_port_private {
90 /* Input endpoints and buffer for this port */
91 struct urb *in_urbs[N_IN_URB];
92 char in_buffer[N_IN_URB][IN_BUFLEN];
93 /* Output endpoints and buffer for this port */
94 struct urb *out_urbs[N_OUT_URB];
95 char out_buffer[N_OUT_URB][OUT_BUFLEN];
96
97 /* Settings for the port */
98 int rts_state; /* Handshaking pins (outputs) */
99 int dtr_state;
100 int cts_state; /* Handshaking pins (inputs) */
101 int dsr_state;
102 int dcd_state;
103 int ri_state;
104
105 unsigned long tx_start_time[N_OUT_URB];
106 };
107
108 static int sierra_send_setup(struct usb_serial_port *port)
109 {
110 struct usb_serial *serial = port->serial;
111 struct sierra_port_private *portdata;
112
113 dbg("%s", __FUNCTION__);
114
115 portdata = usb_get_serial_port_data(port);
116
117 if (port->tty) {
118 int val = 0;
119 if (portdata->dtr_state)
120 val |= 0x01;
121 if (portdata->rts_state)
122 val |= 0x02;
123
124 return usb_control_msg(serial->dev,
125 usb_rcvctrlpipe(serial->dev, 0),
126 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
127 }
128
129 return 0;
130 }
131
132 static void sierra_rx_throttle(struct usb_serial_port *port)
133 {
134 dbg("%s", __FUNCTION__);
135 }
136
137 static void sierra_rx_unthrottle(struct usb_serial_port *port)
138 {
139 dbg("%s", __FUNCTION__);
140 }
141
142 static void sierra_break_ctl(struct usb_serial_port *port, int break_state)
143 {
144 /* Unfortunately, I don't know how to send a break */
145 dbg("%s", __FUNCTION__);
146 }
147
148 static void sierra_set_termios(struct usb_serial_port *port,
149 struct ktermios *old_termios)
150 {
151 dbg("%s", __FUNCTION__);
152
153 sierra_send_setup(port);
154 }
155
156 static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
157 {
158 unsigned int value;
159 struct sierra_port_private *portdata;
160
161 portdata = usb_get_serial_port_data(port);
162
163 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
164 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
165 ((portdata->cts_state) ? TIOCM_CTS : 0) |
166 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
167 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
168 ((portdata->ri_state) ? TIOCM_RNG : 0);
169
170 return value;
171 }
172
173 static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
174 unsigned int set, unsigned int clear)
175 {
176 struct sierra_port_private *portdata;
177
178 portdata = usb_get_serial_port_data(port);
179
180 if (set & TIOCM_RTS)
181 portdata->rts_state = 1;
182 if (set & TIOCM_DTR)
183 portdata->dtr_state = 1;
184
185 if (clear & TIOCM_RTS)
186 portdata->rts_state = 0;
187 if (clear & TIOCM_DTR)
188 portdata->dtr_state = 0;
189 return sierra_send_setup(port);
190 }
191
192 static int sierra_ioctl(struct usb_serial_port *port, struct file *file,
193 unsigned int cmd, unsigned long arg)
194 {
195 return -ENOIOCTLCMD;
196 }
197
198 /* Write */
199 static int sierra_write(struct usb_serial_port *port,
200 const unsigned char *buf, int count)
201 {
202 struct sierra_port_private *portdata;
203 int i;
204 int left, todo;
205 struct urb *this_urb = NULL; /* spurious */
206 int err;
207
208 portdata = usb_get_serial_port_data(port);
209
210 dbg("%s: write (%d chars)", __FUNCTION__, count);
211
212 i = 0;
213 left = count;
214 for (i=0; left > 0 && i < N_OUT_URB; i++) {
215 todo = left;
216 if (todo > OUT_BUFLEN)
217 todo = OUT_BUFLEN;
218
219 this_urb = portdata->out_urbs[i];
220 if (this_urb->status == -EINPROGRESS) {
221 if (time_before(jiffies,
222 portdata->tx_start_time[i] + 10 * HZ))
223 continue;
224 usb_unlink_urb(this_urb);
225 continue;
226 }
227 if (this_urb->status != 0)
228 dbg("usb_write %p failed (err=%d)",
229 this_urb, this_urb->status);
230
231 dbg("%s: endpoint %d buf %d", __FUNCTION__,
232 usb_pipeendpoint(this_urb->pipe), i);
233
234 /* send the data */
235 memcpy (this_urb->transfer_buffer, buf, todo);
236 this_urb->transfer_buffer_length = todo;
237
238 this_urb->dev = port->serial->dev;
239 err = usb_submit_urb(this_urb, GFP_ATOMIC);
240 if (err) {
241 dbg("usb_submit_urb %p (write bulk) failed "
242 "(%d, has %d)", this_urb,
243 err, this_urb->status);
244 continue;
245 }
246 portdata->tx_start_time[i] = jiffies;
247 buf += todo;
248 left -= todo;
249 }
250
251 count -= left;
252 dbg("%s: wrote (did %d)", __FUNCTION__, count);
253 return count;
254 }
255
256 static void sierra_indat_callback(struct urb *urb)
257 {
258 int err;
259 int endpoint;
260 struct usb_serial_port *port;
261 struct tty_struct *tty;
262 unsigned char *data = urb->transfer_buffer;
263
264 dbg("%s: %p", __FUNCTION__, urb);
265
266 endpoint = usb_pipeendpoint(urb->pipe);
267 port = (struct usb_serial_port *) urb->context;
268
269 if (urb->status) {
270 dbg("%s: nonzero status: %d on endpoint %02x.",
271 __FUNCTION__, urb->status, endpoint);
272 } else {
273 tty = port->tty;
274 if (urb->actual_length) {
275 tty_buffer_request_room(tty, urb->actual_length);
276 tty_insert_flip_string(tty, data, urb->actual_length);
277 tty_flip_buffer_push(tty);
278 } else {
279 dbg("%s: empty read urb received", __FUNCTION__);
280 }
281
282 /* Resubmit urb so we continue receiving */
283 if (port->open_count && urb->status != -ESHUTDOWN) {
284 err = usb_submit_urb(urb, GFP_ATOMIC);
285 if (err)
286 printk(KERN_ERR "%s: resubmit read urb failed. "
287 "(%d)", __FUNCTION__, err);
288 }
289 }
290 return;
291 }
292
293 static void sierra_outdat_callback(struct urb *urb)
294 {
295 struct usb_serial_port *port;
296
297 dbg("%s", __FUNCTION__);
298
299 port = (struct usb_serial_port *) urb->context;
300
301 usb_serial_port_softint(port);
302 }
303
304 static void sierra_instat_callback(struct urb *urb)
305 {
306 int err;
307 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
308 struct sierra_port_private *portdata = usb_get_serial_port_data(port);
309 struct usb_serial *serial = port->serial;
310
311 dbg("%s", __FUNCTION__);
312 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
313
314 if (urb->status == 0) {
315 struct usb_ctrlrequest *req_pkt =
316 (struct usb_ctrlrequest *)urb->transfer_buffer;
317
318 if (!req_pkt) {
319 dbg("%s: NULL req_pkt\n", __FUNCTION__);
320 return;
321 }
322 if ((req_pkt->bRequestType == 0xA1) &&
323 (req_pkt->bRequest == 0x20)) {
324 int old_dcd_state;
325 unsigned char signals = *((unsigned char *)
326 urb->transfer_buffer +
327 sizeof(struct usb_ctrlrequest));
328
329 dbg("%s: signal x%x", __FUNCTION__, signals);
330
331 old_dcd_state = portdata->dcd_state;
332 portdata->cts_state = 1;
333 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
334 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
335 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
336
337 if (port->tty && !C_CLOCAL(port->tty) &&
338 old_dcd_state && !portdata->dcd_state)
339 tty_hangup(port->tty);
340 } else {
341 dbg("%s: type %x req %x", __FUNCTION__,
342 req_pkt->bRequestType,req_pkt->bRequest);
343 }
344 } else
345 dbg("%s: error %d", __FUNCTION__, urb->status);
346
347 /* Resubmit urb so we continue receiving IRQ data */
348 if (urb->status != -ESHUTDOWN) {
349 urb->dev = serial->dev;
350 err = usb_submit_urb(urb, GFP_ATOMIC);
351 if (err)
352 dbg("%s: resubmit intr urb failed. (%d)",
353 __FUNCTION__, err);
354 }
355 }
356
357 static int sierra_write_room(struct usb_serial_port *port)
358 {
359 struct sierra_port_private *portdata;
360 int i;
361 int data_len = 0;
362 struct urb *this_urb;
363
364 portdata = usb_get_serial_port_data(port);
365
366 for (i=0; i < N_OUT_URB; i++) {
367 this_urb = portdata->out_urbs[i];
368 if (this_urb && this_urb->status != -EINPROGRESS)
369 data_len += OUT_BUFLEN;
370 }
371
372 dbg("%s: %d", __FUNCTION__, data_len);
373 return data_len;
374 }
375
376 static int sierra_chars_in_buffer(struct usb_serial_port *port)
377 {
378 struct sierra_port_private *portdata;
379 int i;
380 int data_len = 0;
381 struct urb *this_urb;
382
383 portdata = usb_get_serial_port_data(port);
384
385 for (i=0; i < N_OUT_URB; i++) {
386 this_urb = portdata->out_urbs[i];
387 if (this_urb && this_urb->status == -EINPROGRESS)
388 data_len += this_urb->transfer_buffer_length;
389 }
390 dbg("%s: %d", __FUNCTION__, data_len);
391 return data_len;
392 }
393
394 static int sierra_open(struct usb_serial_port *port, struct file *filp)
395 {
396 struct sierra_port_private *portdata;
397 struct usb_serial *serial = port->serial;
398 int i, err;
399 struct urb *urb;
400 int result;
401 __u16 set_mode_dzero = 0x0000;
402
403 portdata = usb_get_serial_port_data(port);
404
405 dbg("%s", __FUNCTION__);
406
407 /* Set some sane defaults */
408 portdata->rts_state = 1;
409 portdata->dtr_state = 1;
410
411 /* Reset low level data toggle and start reading from endpoints */
412 for (i = 0; i < N_IN_URB; i++) {
413 urb = portdata->in_urbs[i];
414 if (! urb)
415 continue;
416 if (urb->dev != serial->dev) {
417 dbg("%s: dev %p != %p", __FUNCTION__,
418 urb->dev, serial->dev);
419 continue;
420 }
421
422 /*
423 * make sure endpoint data toggle is synchronized with the
424 * device
425 */
426 usb_clear_halt(urb->dev, urb->pipe);
427
428 err = usb_submit_urb(urb, GFP_KERNEL);
429 if (err) {
430 dbg("%s: submit urb %d failed (%d) %d",
431 __FUNCTION__, i, err,
432 urb->transfer_buffer_length);
433 }
434 }
435
436 /* Reset low level data toggle on out endpoints */
437 for (i = 0; i < N_OUT_URB; i++) {
438 urb = portdata->out_urbs[i];
439 if (! urb)
440 continue;
441 urb->dev = serial->dev;
442 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
443 usb_pipeout(urb->pipe), 0); */
444 }
445
446 port->tty->low_latency = 1;
447
448 /* set mode to D0 */
449 result = usb_control_msg(serial->dev,
450 usb_rcvctrlpipe(serial->dev, 0),
451 0x00, 0x40, set_mode_dzero, 0, NULL,
452 0, USB_CTRL_SET_TIMEOUT);
453
454 sierra_send_setup(port);
455
456 return (0);
457 }
458
459 static void sierra_close(struct usb_serial_port *port, struct file *filp)
460 {
461 int i;
462 struct usb_serial *serial = port->serial;
463 struct sierra_port_private *portdata;
464
465 dbg("%s", __FUNCTION__);
466 portdata = usb_get_serial_port_data(port);
467
468 portdata->rts_state = 0;
469 portdata->dtr_state = 0;
470
471 if (serial->dev) {
472 sierra_send_setup(port);
473
474 /* Stop reading/writing urbs */
475 for (i = 0; i < N_IN_URB; i++)
476 usb_unlink_urb(portdata->in_urbs[i]);
477 for (i = 0; i < N_OUT_URB; i++)
478 usb_unlink_urb(portdata->out_urbs[i]);
479 }
480 port->tty = NULL;
481 }
482
483 /* Helper functions used by sierra_setup_urbs */
484 static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
485 int dir, void *ctx, char *buf, int len,
486 usb_complete_t callback)
487 {
488 struct urb *urb;
489
490 if (endpoint == -1)
491 return NULL; /* endpoint not needed */
492
493 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
494 if (urb == NULL) {
495 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
496 return NULL;
497 }
498
499 /* Fill URB using supplied data. */
500 usb_fill_bulk_urb(urb, serial->dev,
501 usb_sndbulkpipe(serial->dev, endpoint) | dir,
502 buf, len, callback, ctx);
503
504 return urb;
505 }
506
507 /* Setup urbs */
508 static void sierra_setup_urbs(struct usb_serial *serial)
509 {
510 int i,j;
511 struct usb_serial_port *port;
512 struct sierra_port_private *portdata;
513
514 dbg("%s", __FUNCTION__);
515
516 for (i = 0; i < serial->num_ports; i++) {
517 port = serial->port[i];
518 portdata = usb_get_serial_port_data(port);
519
520 /* Do indat endpoints first */
521 for (j = 0; j < N_IN_URB; ++j) {
522 portdata->in_urbs[j] = sierra_setup_urb (serial,
523 port->bulk_in_endpointAddress, USB_DIR_IN, port,
524 portdata->in_buffer[j], IN_BUFLEN, sierra_indat_callback);
525 }
526
527 /* outdat endpoints */
528 for (j = 0; j < N_OUT_URB; ++j) {
529 portdata->out_urbs[j] = sierra_setup_urb (serial,
530 port->bulk_out_endpointAddress, USB_DIR_OUT, port,
531 portdata->out_buffer[j], OUT_BUFLEN, sierra_outdat_callback);
532 }
533 }
534 }
535
536 static int sierra_startup(struct usb_serial *serial)
537 {
538 int i, err;
539 struct usb_serial_port *port;
540 struct sierra_port_private *portdata;
541
542 dbg("%s", __FUNCTION__);
543
544 /* Now setup per port private data */
545 for (i = 0; i < serial->num_ports; i++) {
546 port = serial->port[i];
547 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
548 if (!portdata) {
549 dbg("%s: kmalloc for sierra_port_private (%d) failed!.",
550 __FUNCTION__, i);
551 return (1);
552 }
553
554 usb_set_serial_port_data(port, portdata);
555
556 if (! port->interrupt_in_urb)
557 continue;
558 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
559 if (err)
560 dbg("%s: submit irq_in urb failed %d",
561 __FUNCTION__, err);
562 }
563
564 sierra_setup_urbs(serial);
565
566 return (0);
567 }
568
569 static void sierra_shutdown(struct usb_serial *serial)
570 {
571 int i, j;
572 struct usb_serial_port *port;
573 struct sierra_port_private *portdata;
574
575 dbg("%s", __FUNCTION__);
576
577 /* Stop reading/writing urbs */
578 for (i = 0; i < serial->num_ports; ++i) {
579 port = serial->port[i];
580 if (!port)
581 continue;
582 portdata = usb_get_serial_port_data(port);
583 if (!portdata)
584 continue;
585
586 for (j = 0; j < N_IN_URB; j++)
587 usb_unlink_urb(portdata->in_urbs[j]);
588 for (j = 0; j < N_OUT_URB; j++)
589 usb_unlink_urb(portdata->out_urbs[j]);
590 }
591
592 /* Now free them */
593 for (i = 0; i < serial->num_ports; ++i) {
594 port = serial->port[i];
595 if (!port)
596 continue;
597 portdata = usb_get_serial_port_data(port);
598 if (!portdata)
599 continue;
600
601 for (j = 0; j < N_IN_URB; j++) {
602 if (portdata->in_urbs[j]) {
603 usb_free_urb(portdata->in_urbs[j]);
604 portdata->in_urbs[j] = NULL;
605 }
606 }
607 for (j = 0; j < N_OUT_URB; j++) {
608 if (portdata->out_urbs[j]) {
609 usb_free_urb(portdata->out_urbs[j]);
610 portdata->out_urbs[j] = NULL;
611 }
612 }
613 }
614
615 /* Now free per port private data */
616 for (i = 0; i < serial->num_ports; i++) {
617 port = serial->port[i];
618 if (!port)
619 continue;
620 kfree(usb_get_serial_port_data(port));
621 }
622 }
623
624 static struct usb_serial_driver sierra_1port_device = {
625 .driver = {
626 .owner = THIS_MODULE,
627 .name = "sierra1",
628 },
629 .description = "Sierra USB modem (1 port)",
630 .id_table = id_table_1port,
631 .usb_driver = &sierra_driver,
632 .num_interrupt_in = NUM_DONT_CARE,
633 .num_bulk_in = 1,
634 .num_bulk_out = 1,
635 .num_ports = 1,
636 .open = sierra_open,
637 .close = sierra_close,
638 .write = sierra_write,
639 .write_room = sierra_write_room,
640 .chars_in_buffer = sierra_chars_in_buffer,
641 .throttle = sierra_rx_throttle,
642 .unthrottle = sierra_rx_unthrottle,
643 .ioctl = sierra_ioctl,
644 .set_termios = sierra_set_termios,
645 .break_ctl = sierra_break_ctl,
646 .tiocmget = sierra_tiocmget,
647 .tiocmset = sierra_tiocmset,
648 .attach = sierra_startup,
649 .shutdown = sierra_shutdown,
650 .read_int_callback = sierra_instat_callback,
651 };
652
653 static struct usb_serial_driver sierra_3port_device = {
654 .driver = {
655 .owner = THIS_MODULE,
656 .name = "sierra3",
657 },
658 .description = "Sierra USB modem (3 port)",
659 .id_table = id_table_3port,
660 .usb_driver = &sierra_driver,
661 .num_interrupt_in = NUM_DONT_CARE,
662 .num_bulk_in = 3,
663 .num_bulk_out = 3,
664 .num_ports = 3,
665 .open = sierra_open,
666 .close = sierra_close,
667 .write = sierra_write,
668 .write_room = sierra_write_room,
669 .chars_in_buffer = sierra_chars_in_buffer,
670 .throttle = sierra_rx_throttle,
671 .unthrottle = sierra_rx_unthrottle,
672 .ioctl = sierra_ioctl,
673 .set_termios = sierra_set_termios,
674 .break_ctl = sierra_break_ctl,
675 .tiocmget = sierra_tiocmget,
676 .tiocmset = sierra_tiocmset,
677 .attach = sierra_startup,
678 .shutdown = sierra_shutdown,
679 .read_int_callback = sierra_instat_callback,
680 };
681
682 /* Functions used by new usb-serial code. */
683 static int __init sierra_init(void)
684 {
685 int retval;
686 retval = usb_serial_register(&sierra_1port_device);
687 if (retval)
688 goto failed_1port_device_register;
689 retval = usb_serial_register(&sierra_3port_device);
690 if (retval)
691 goto failed_3port_device_register;
692
693
694 retval = usb_register(&sierra_driver);
695 if (retval)
696 goto failed_driver_register;
697
698 info(DRIVER_DESC ": " DRIVER_VERSION);
699
700 return 0;
701
702 failed_driver_register:
703 usb_serial_deregister(&sierra_3port_device);
704 failed_3port_device_register:
705 usb_serial_deregister(&sierra_1port_device);
706 failed_1port_device_register:
707 return retval;
708 }
709
710 static void __exit sierra_exit(void)
711 {
712 usb_deregister (&sierra_driver);
713 usb_serial_deregister(&sierra_1port_device);
714 usb_serial_deregister(&sierra_3port_device);
715 }
716
717 module_init(sierra_init);
718 module_exit(sierra_exit);
719
720 MODULE_AUTHOR(DRIVER_AUTHOR);
721 MODULE_DESCRIPTION(DRIVER_DESC);
722 MODULE_VERSION(DRIVER_VERSION);
723 MODULE_LICENSE("GPL");
724
725 #ifdef CONFIG_USB_DEBUG
726 module_param(debug, bool, S_IRUGO | S_IWUSR);
727 MODULE_PARM_DESC(debug, "Debug messages");
728 #endif
729
WRT350N Kernel Patches