2 USB Driver for Sierra Wireless
4 Copyright (C) 2006, 2007, 2008 Kevin Lloyd <linux@sierrawireless.com>
6 IMPORTANT DISCLAIMER: This driver is not commercially supported by
7 Sierra Wireless. Use at your own risk.
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.
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>
17 #define DRIVER_VERSION "v.1.2.8"
18 #define DRIVER_AUTHOR "Kevin Lloyd <linux@sierrawireless.com>"
19 #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
21 #include <linux/kernel.h>
22 #include <linux/jiffies.h>
23 #include <linux/errno.h>
24 #include <linux/tty.h>
25 #include <linux/tty_flip.h>
26 #include <linux/module.h>
27 #include <linux/usb.h>
28 #include <linux/usb/serial.h>
29 #include <linux/usb/ch9.h>
31 #define SWIMS_USB_REQUEST_SetPower 0x00
32 #define SWIMS_USB_REQUEST_SetNmea 0x07
33 #define SWIMS_USB_REQUEST_SetMode 0x0B
34 #define SWIMS_USB_REQUEST_TYPE_VSC_SET 0x40
35 #define SWIMS_SET_MODE_Modem 0x0001
37 /* per port private data */
40 #define IN_BUFLEN 4096
44 static int truinstall
= 1;
52 static int sierra_set_power_state(struct usb_device
*udev
, __u16 swiState
)
55 dev_dbg(&udev
->dev
, "%s", "SET POWER STATE\n");
56 result
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
57 SWIMS_USB_REQUEST_SetPower
, /* __u8 request */
58 SWIMS_USB_REQUEST_TYPE_VSC_SET
, /* __u8 request type */
59 swiState
, /* __u16 value */
61 NULL
, /* void *data */
63 USB_CTRL_SET_TIMEOUT
); /* int timeout */
67 static int sierra_set_ms_mode(struct usb_device
*udev
, __u16 eSWocMode
)
70 dev_dbg(&udev
->dev
, "%s", "DEVICE MODE SWITCH\n");
71 result
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
72 SWIMS_USB_REQUEST_SetMode
, /* __u8 request */
73 SWIMS_USB_REQUEST_TYPE_VSC_SET
, /* __u8 request type */
74 eSWocMode
, /* __u16 value */
75 0x0000, /* __u16 index */
76 NULL
, /* void *data */
78 USB_CTRL_SET_TIMEOUT
); /* int timeout */
82 static int sierra_vsc_set_nmea(struct usb_device
*udev
, __u16 enable
)
85 dev_dbg(&udev
->dev
, "%s", "NMEA Enable sent\n");
86 result
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
87 SWIMS_USB_REQUEST_SetNmea
, /* __u8 request */
88 SWIMS_USB_REQUEST_TYPE_VSC_SET
, /* __u8 request type */
89 enable
, /* __u16 value */
90 0x0000, /* __u16 index */
91 NULL
, /* void *data */
93 USB_CTRL_SET_TIMEOUT
); /* int timeout */
97 static int sierra_calc_num_ports(struct usb_serial
*serial
)
100 int *num_ports
= usb_get_serial_data(serial
);
106 usb_set_serial_data(serial
, NULL
);
112 static int sierra_probe(struct usb_serial
*serial
,
113 const struct usb_device_id
*id
)
116 struct usb_device
*udev
;
120 num_ports
= kmalloc(sizeof(*num_ports
), GFP_KERNEL
);
124 ifnum
= serial
->interface
->cur_altsetting
->desc
.bInterfaceNumber
;
127 /* Check if in installer mode */
128 if (truinstall
&& id
->driver_info
== DEVICE_INSTALLER
) {
129 dev_dbg(&udev
->dev
, "%s", "FOUND TRU-INSTALL DEVICE(SW)\n");
130 result
= sierra_set_ms_mode(udev
, SWIMS_SET_MODE_Modem
);
131 /* Don't bind to the device when in installer mode */
134 } else if (id
->driver_info
== DEVICE_1_PORT
)
136 else if (ifnum
== 0x99)
141 * save off our num_ports info so that we can use it in the
142 * calc_num_ports callback
144 usb_set_serial_data(serial
, (void *)num_ports
);
149 static struct usb_device_id id_table
[] = {
150 { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
151 { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
152 { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
153 { USB_DEVICE(0x0f30, 0x1b1d) }, /* Sierra Wireless MC5720 */
154 { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
155 { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
156 { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
157 { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
158 { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */
159 { USB_DEVICE(0x1199, 0x0023) }, /* Sierra Wireless AirCard */
161 { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
162 { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
163 { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
164 { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
165 { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 (Thinkpad internal) */
166 { USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */
167 { USB_DEVICE(0x03f0, 0x1e1d) }, /* HP hs2300 a.k.a MC8775 */
168 { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
169 { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780*/
170 { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781*/
171 { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
172 { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
173 { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
174 { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
175 { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */
176 { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */
178 { USB_DEVICE(0x1199, 0x6468) }, /* Sierra Wireless MP3G - EVDO */
179 { USB_DEVICE(0x1199, 0x6469) }, /* Sierra Wireless MP3G - UMTS/HSPA */
181 { USB_DEVICE(0x1199, 0x0112), .driver_info
= DEVICE_1_PORT
}, /* Sierra Wireless AirCard 580 */
182 { USB_DEVICE(0x0F3D, 0x0112), .driver_info
= DEVICE_1_PORT
}, /* Airprime/Sierra PC 5220 */
184 { USB_DEVICE(0x1199, 0x0FFF), .driver_info
= DEVICE_INSTALLER
},
187 MODULE_DEVICE_TABLE(usb
, id_table
);
189 static struct usb_driver sierra_driver
= {
191 .probe
= usb_serial_probe
,
192 .disconnect
= usb_serial_disconnect
,
193 .id_table
= id_table
,
197 struct sierra_port_private
{
198 spinlock_t lock
; /* lock the structure */
199 int outstanding_urbs
; /* number of out urbs in flight */
201 /* Input endpoints and buffers for this port */
202 struct urb
*in_urbs
[N_IN_URB
];
203 char *in_buffer
[N_IN_URB
];
205 /* Settings for the port */
206 int rts_state
; /* Handshaking pins (outputs) */
208 int cts_state
; /* Handshaking pins (inputs) */
214 static int sierra_send_setup(struct usb_serial_port
*port
)
216 struct usb_serial
*serial
= port
->serial
;
217 struct sierra_port_private
*portdata
;
220 dbg("%s", __FUNCTION__
);
222 portdata
= usb_get_serial_port_data(port
);
226 if (portdata
->dtr_state
)
228 if (portdata
->rts_state
)
231 /* Determine which port is targeted */
232 if (port
->bulk_out_endpointAddress
== 2)
234 else if (port
->bulk_out_endpointAddress
== 4)
236 else if (port
->bulk_out_endpointAddress
== 5)
239 return usb_control_msg(serial
->dev
,
240 usb_rcvctrlpipe(serial
->dev
, 0),
241 0x22, 0x21, val
, interface
,
242 NULL
, 0, USB_CTRL_SET_TIMEOUT
);
248 static void sierra_rx_throttle(struct usb_serial_port
*port
)
250 dbg("%s", __FUNCTION__
);
253 static void sierra_rx_unthrottle(struct usb_serial_port
*port
)
255 dbg("%s", __FUNCTION__
);
258 static void sierra_break_ctl(struct usb_serial_port
*port
, int break_state
)
260 /* Unfortunately, I don't know how to send a break */
261 dbg("%s", __FUNCTION__
);
264 static void sierra_set_termios(struct usb_serial_port
*port
,
265 struct ktermios
*old_termios
)
267 dbg("%s", __FUNCTION__
);
268 tty_termios_copy_hw(port
->tty
->termios
, old_termios
);
269 sierra_send_setup(port
);
272 static int sierra_tiocmget(struct usb_serial_port
*port
, struct file
*file
)
275 struct sierra_port_private
*portdata
;
277 portdata
= usb_get_serial_port_data(port
);
279 value
= ((portdata
->rts_state
) ? TIOCM_RTS
: 0) |
280 ((portdata
->dtr_state
) ? TIOCM_DTR
: 0) |
281 ((portdata
->cts_state
) ? TIOCM_CTS
: 0) |
282 ((portdata
->dsr_state
) ? TIOCM_DSR
: 0) |
283 ((portdata
->dcd_state
) ? TIOCM_CAR
: 0) |
284 ((portdata
->ri_state
) ? TIOCM_RNG
: 0);
289 static int sierra_tiocmset(struct usb_serial_port
*port
, struct file
*file
,
290 unsigned int set
, unsigned int clear
)
292 struct sierra_port_private
*portdata
;
294 portdata
= usb_get_serial_port_data(port
);
297 portdata
->rts_state
= 1;
299 portdata
->dtr_state
= 1;
301 if (clear
& TIOCM_RTS
)
302 portdata
->rts_state
= 0;
303 if (clear
& TIOCM_DTR
)
304 portdata
->dtr_state
= 0;
305 return sierra_send_setup(port
);
308 static int sierra_ioctl(struct usb_serial_port
*port
, struct file
*file
,
309 unsigned int cmd
, unsigned long arg
)
314 static void sierra_outdat_callback(struct urb
*urb
)
316 struct usb_serial_port
*port
= urb
->context
;
317 struct sierra_port_private
*portdata
= usb_get_serial_port_data(port
);
318 int status
= urb
->status
;
321 dbg("%s - port %d", __FUNCTION__
, port
->number
);
323 /* free up the transfer buffer, as usb_free_urb() does not do this */
324 kfree(urb
->transfer_buffer
);
327 dbg("%s - nonzero write bulk status received: %d",
328 __FUNCTION__
, status
);
330 spin_lock_irqsave(&portdata
->lock
, flags
);
331 --portdata
->outstanding_urbs
;
332 spin_unlock_irqrestore(&portdata
->lock
, flags
);
334 usb_serial_port_softint(port
);
338 static int sierra_write(struct usb_serial_port
*port
,
339 const unsigned char *buf
, int count
)
341 struct sierra_port_private
*portdata
= usb_get_serial_port_data(port
);
342 struct usb_serial
*serial
= port
->serial
;
344 unsigned char *buffer
;
348 portdata
= usb_get_serial_port_data(port
);
350 dbg("%s: write (%d chars)", __FUNCTION__
, count
);
352 spin_lock_irqsave(&portdata
->lock
, flags
);
353 if (portdata
->outstanding_urbs
> N_OUT_URB
) {
354 spin_unlock_irqrestore(&portdata
->lock
, flags
);
355 dbg("%s - write limit hit\n", __FUNCTION__
);
358 portdata
->outstanding_urbs
++;
359 spin_unlock_irqrestore(&portdata
->lock
, flags
);
361 buffer
= kmalloc(count
, GFP_ATOMIC
);
363 dev_err(&port
->dev
, "out of memory\n");
365 goto error_no_buffer
;
368 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
370 dev_err(&port
->dev
, "no more free urbs\n");
375 memcpy(buffer
, buf
, count
);
377 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, count
, buffer
);
379 usb_fill_bulk_urb(urb
, serial
->dev
,
380 usb_sndbulkpipe(serial
->dev
,
381 port
->bulk_out_endpointAddress
),
382 buffer
, count
, sierra_outdat_callback
, port
);
384 /* send it down the pipe */
385 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
387 dev_err(&port
->dev
, "%s - usb_submit_urb(write bulk) failed "
388 "with status = %d\n", __FUNCTION__
, status
);
393 /* we are done with this urb, so let the host driver
394 * really free it when it is finished with it */
403 spin_lock_irqsave(&portdata
->lock
, flags
);
404 --portdata
->outstanding_urbs
;
405 spin_unlock_irqrestore(&portdata
->lock
, flags
);
409 static void sierra_indat_callback(struct urb
*urb
)
413 struct usb_serial_port
*port
;
414 struct tty_struct
*tty
;
415 unsigned char *data
= urb
->transfer_buffer
;
416 int status
= urb
->status
;
418 dbg("%s: %p", __FUNCTION__
, urb
);
420 endpoint
= usb_pipeendpoint(urb
->pipe
);
421 port
= (struct usb_serial_port
*) urb
->context
;
424 dbg("%s: nonzero status: %d on endpoint %02x.",
425 __FUNCTION__
, status
, endpoint
);
428 if (urb
->actual_length
) {
429 tty_buffer_request_room(tty
, urb
->actual_length
);
430 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
431 tty_flip_buffer_push(tty
);
433 dbg("%s: empty read urb received", __FUNCTION__
);
436 /* Resubmit urb so we continue receiving */
437 if (port
->open_count
&& status
!= -ESHUTDOWN
) {
438 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
440 dev_err(&port
->dev
, "resubmit read urb failed."
447 static void sierra_instat_callback(struct urb
*urb
)
450 int status
= urb
->status
;
451 struct usb_serial_port
*port
= (struct usb_serial_port
*) urb
->context
;
452 struct sierra_port_private
*portdata
= usb_get_serial_port_data(port
);
453 struct usb_serial
*serial
= port
->serial
;
455 dbg("%s", __FUNCTION__
);
456 dbg("%s: urb %p port %p has data %p", __FUNCTION__
,urb
,port
,portdata
);
459 struct usb_ctrlrequest
*req_pkt
=
460 (struct usb_ctrlrequest
*)urb
->transfer_buffer
;
463 dbg("%s: NULL req_pkt\n", __FUNCTION__
);
466 if ((req_pkt
->bRequestType
== 0xA1) &&
467 (req_pkt
->bRequest
== 0x20)) {
469 unsigned char signals
= *((unsigned char *)
470 urb
->transfer_buffer
+
471 sizeof(struct usb_ctrlrequest
));
473 dbg("%s: signal x%x", __FUNCTION__
, signals
);
475 old_dcd_state
= portdata
->dcd_state
;
476 portdata
->cts_state
= 1;
477 portdata
->dcd_state
= ((signals
& 0x01) ? 1 : 0);
478 portdata
->dsr_state
= ((signals
& 0x02) ? 1 : 0);
479 portdata
->ri_state
= ((signals
& 0x08) ? 1 : 0);
481 if (port
->tty
&& !C_CLOCAL(port
->tty
) &&
482 old_dcd_state
&& !portdata
->dcd_state
)
483 tty_hangup(port
->tty
);
485 dbg("%s: type %x req %x", __FUNCTION__
,
486 req_pkt
->bRequestType
,req_pkt
->bRequest
);
489 dbg("%s: error %d", __FUNCTION__
, status
);
491 /* Resubmit urb so we continue receiving IRQ data */
492 if (status
!= -ESHUTDOWN
) {
493 urb
->dev
= serial
->dev
;
494 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
496 dbg("%s: resubmit intr urb failed. (%d)",
501 static int sierra_write_room(struct usb_serial_port
*port
)
503 struct sierra_port_private
*portdata
= usb_get_serial_port_data(port
);
506 dbg("%s - port %d", __FUNCTION__
, port
->number
);
508 /* try to give a good number back based on if we have any free urbs at
509 * this point in time */
510 spin_lock_irqsave(&portdata
->lock
, flags
);
511 if (portdata
->outstanding_urbs
> N_OUT_URB
* 2 / 3) {
512 spin_unlock_irqrestore(&portdata
->lock
, flags
);
513 dbg("%s - write limit hit\n", __FUNCTION__
);
516 spin_unlock_irqrestore(&portdata
->lock
, flags
);
521 static int sierra_chars_in_buffer(struct usb_serial_port
*port
)
523 dbg("%s - port %d", __FUNCTION__
, port
->number
);
526 * We can't really account for how much data we
527 * have sent out, but hasn't made it through to the
528 * device as we can't see the backend here, so just
529 * tell the tty layer that everything is flushed.
534 static int sierra_open(struct usb_serial_port
*port
, struct file
*filp
)
536 struct sierra_port_private
*portdata
;
537 struct usb_serial
*serial
= port
->serial
;
542 portdata
= usb_get_serial_port_data(port
);
544 dbg("%s", __FUNCTION__
);
546 /* Set some sane defaults */
547 portdata
->rts_state
= 1;
548 portdata
->dtr_state
= 1;
550 /* Reset low level data toggle and start reading from endpoints */
551 for (i
= 0; i
< N_IN_URB
; i
++) {
552 urb
= portdata
->in_urbs
[i
];
555 if (urb
->dev
!= serial
->dev
) {
556 dbg("%s: dev %p != %p", __FUNCTION__
,
557 urb
->dev
, serial
->dev
);
562 * make sure endpoint data toggle is synchronized with the
565 usb_clear_halt(urb
->dev
, urb
->pipe
);
567 result
= usb_submit_urb(urb
, GFP_KERNEL
);
569 dev_err(&port
->dev
, "submit urb %d failed (%d) %d\n",
570 i
, result
, urb
->transfer_buffer_length
);
574 port
->tty
->low_latency
= 1;
576 sierra_send_setup(port
);
578 /* start up the interrupt endpoint if we have one */
579 if (port
->interrupt_in_urb
) {
580 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
582 dev_err(&port
->dev
, "submit irq_in urb failed %d\n",
588 static void sierra_close(struct usb_serial_port
*port
, struct file
*filp
)
591 struct usb_serial
*serial
= port
->serial
;
592 struct sierra_port_private
*portdata
;
594 dbg("%s", __FUNCTION__
);
595 portdata
= usb_get_serial_port_data(port
);
597 portdata
->rts_state
= 0;
598 portdata
->dtr_state
= 0;
601 mutex_lock(&serial
->disc_mutex
);
602 if (!serial
->disconnected
)
603 sierra_send_setup(port
);
604 mutex_unlock(&serial
->disc_mutex
);
606 /* Stop reading/writing urbs */
607 for (i
= 0; i
< N_IN_URB
; i
++)
608 usb_kill_urb(portdata
->in_urbs
[i
]);
611 usb_kill_urb(port
->interrupt_in_urb
);
616 static int sierra_startup(struct usb_serial
*serial
)
618 struct usb_serial_port
*port
;
619 struct sierra_port_private
*portdata
;
624 dbg("%s", __FUNCTION__
);
626 /* Set Device mode to D0 */
627 sierra_set_power_state(serial
->dev
, 0x0000);
629 /* Check NMEA and set */
631 sierra_vsc_set_nmea(serial
->dev
, 1);
633 /* Now setup per port private data */
634 for (i
= 0; i
< serial
->num_ports
; i
++) {
635 port
= serial
->port
[i
];
636 portdata
= kzalloc(sizeof(*portdata
), GFP_KERNEL
);
638 dbg("%s: kmalloc for sierra_port_private (%d) failed!.",
642 spin_lock_init(&portdata
->lock
);
643 for (j
= 0; j
< N_IN_URB
; j
++) {
644 portdata
->in_buffer
[j
] = kmalloc(IN_BUFLEN
, GFP_KERNEL
);
645 if (!portdata
->in_buffer
[j
]) {
646 for (--j
; j
>= 0; j
--)
647 kfree(portdata
->in_buffer
[j
]);
653 usb_set_serial_port_data(port
, portdata
);
655 /* initialize the in urbs */
656 for (j
= 0; j
< N_IN_URB
; ++j
) {
657 urb
= usb_alloc_urb(0, GFP_KERNEL
);
659 dbg("%s: alloc for in port failed.",
663 /* Fill URB using supplied data. */
664 usb_fill_bulk_urb(urb
, serial
->dev
,
665 usb_rcvbulkpipe(serial
->dev
,
666 port
->bulk_in_endpointAddress
),
667 portdata
->in_buffer
[j
], IN_BUFLEN
,
668 sierra_indat_callback
, port
);
669 portdata
->in_urbs
[j
] = urb
;
676 static void sierra_shutdown(struct usb_serial
*serial
)
679 struct usb_serial_port
*port
;
680 struct sierra_port_private
*portdata
;
682 dbg("%s", __FUNCTION__
);
684 for (i
= 0; i
< serial
->num_ports
; ++i
) {
685 port
= serial
->port
[i
];
688 portdata
= usb_get_serial_port_data(port
);
692 for (j
= 0; j
< N_IN_URB
; j
++) {
693 usb_kill_urb(portdata
->in_urbs
[j
]);
694 usb_free_urb(portdata
->in_urbs
[j
]);
695 kfree(portdata
->in_buffer
[j
]);
698 usb_set_serial_port_data(port
, NULL
);
702 static struct usb_serial_driver sierra_device
= {
704 .owner
= THIS_MODULE
,
707 .description
= "Sierra USB modem",
708 .id_table
= id_table
,
709 .usb_driver
= &sierra_driver
,
710 .num_interrupt_in
= NUM_DONT_CARE
,
711 .num_bulk_in
= NUM_DONT_CARE
,
712 .num_bulk_out
= NUM_DONT_CARE
,
713 .calc_num_ports
= sierra_calc_num_ports
,
714 .probe
= sierra_probe
,
716 .close
= sierra_close
,
717 .write
= sierra_write
,
718 .write_room
= sierra_write_room
,
719 .chars_in_buffer
= sierra_chars_in_buffer
,
720 .throttle
= sierra_rx_throttle
,
721 .unthrottle
= sierra_rx_unthrottle
,
722 .ioctl
= sierra_ioctl
,
723 .set_termios
= sierra_set_termios
,
724 .break_ctl
= sierra_break_ctl
,
725 .tiocmget
= sierra_tiocmget
,
726 .tiocmset
= sierra_tiocmset
,
727 .attach
= sierra_startup
,
728 .shutdown
= sierra_shutdown
,
729 .read_int_callback
= sierra_instat_callback
,
732 /* Functions used by new usb-serial code. */
733 static int __init
sierra_init(void)
736 retval
= usb_serial_register(&sierra_device
);
738 goto failed_device_register
;
741 retval
= usb_register(&sierra_driver
);
743 goto failed_driver_register
;
745 info(DRIVER_DESC
": " DRIVER_VERSION
);
749 failed_driver_register
:
750 usb_serial_deregister(&sierra_device
);
751 failed_device_register
:
755 static void __exit
sierra_exit(void)
757 usb_deregister (&sierra_driver
);
758 usb_serial_deregister(&sierra_device
);
761 module_init(sierra_init
);
762 module_exit(sierra_exit
);
764 MODULE_AUTHOR(DRIVER_AUTHOR
);
765 MODULE_DESCRIPTION(DRIVER_DESC
);
766 MODULE_VERSION(DRIVER_VERSION
);
767 MODULE_LICENSE("GPL");
769 module_param(truinstall
, bool, 0);
770 MODULE_PARM_DESC(truinstall
, "TRU-Install support");
772 module_param(nmea
, bool, 0);
773 MODULE_PARM_DESC(nmea
, "NMEA streaming");
775 #ifdef CONFIG_USB_DEBUG
776 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
777 MODULE_PARM_DESC(debug
, "Debug messages");