blob: 2f6f1523ec56b5462461fbf1a6c1e260513919d9 [file] [log] [blame]
Kevin Lloyd69de51f2006-06-30 11:17:55 -07001/*
Kevin Lloyd033a3fb2006-10-13 23:53:21 -07002 USB Driver for Sierra Wireless
3
Kevin Lloydf3564de2008-03-28 10:05:08 -07004 Copyright (C) 2006, 2007, 2008 Kevin Lloyd <klloyd@sierrawireless.com>
Kevin Lloyd033a3fb2006-10-13 23:53:21 -07005
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>
Kevin Lloyd033a3fb2006-10-13 23:53:21 -070015*/
16
Kevin Lloydf3564de2008-03-28 10:05:08 -070017#define DRIVER_VERSION "v.1.2.9c"
18#define DRIVER_AUTHOR "Kevin Lloyd <klloyd@sierrawireless.com>"
Kevin Lloyd033a3fb2006-10-13 23:53:21 -070019#define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
Kevin Lloyd69de51f2006-06-30 11:17:55 -070020
21#include <linux/kernel.h>
Kevin Lloyd033a3fb2006-10-13 23:53:21 -070022#include <linux/jiffies.h>
23#include <linux/errno.h>
Kevin Lloyd69de51f2006-06-30 11:17:55 -070024#include <linux/tty.h>
Kevin Lloyd033a3fb2006-10-13 23:53:21 -070025#include <linux/tty_flip.h>
Kevin Lloyd69de51f2006-06-30 11:17:55 -070026#include <linux/module.h>
27#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070028#include <linux/usb/serial.h>
Kevin Lloyd228426e2008-01-10 11:11:04 -080029#include <linux/usb/ch9.h>
Kevin Lloyd69de51f2006-06-30 11:17:55 -070030
Kevin Lloyd228426e2008-01-10 11:11:04 -080031#define SWIMS_USB_REQUEST_SetPower 0x00
32#define SWIMS_USB_REQUEST_SetNmea 0x07
Kevin Lloyd112225b2007-07-16 13:49:27 -070033#define SWIMS_USB_REQUEST_SetMode 0x0B
Kevin Lloyd112225b2007-07-16 13:49:27 -070034#define SWIMS_SET_MODE_Modem 0x0001
35
36/* per port private data */
37#define N_IN_URB 4
38#define N_OUT_URB 4
39#define IN_BUFLEN 4096
40
41static int debug;
Kevin Lloyd228426e2008-01-10 11:11:04 -080042static int nmea;
43static int truinstall = 1;
Kevin Lloyd112225b2007-07-16 13:49:27 -070044
45enum devicetype {
46 DEVICE_3_PORT = 0,
47 DEVICE_1_PORT = 1,
48 DEVICE_INSTALLER = 2,
49};
50
Adrian Bunk82a24e62007-07-29 16:59:02 +020051static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
Kevin Lloyd112225b2007-07-16 13:49:27 -070052{
53 int result;
Joe Perches898eb712007-10-18 03:06:30 -070054 dev_dbg(&udev->dev, "%s", "SET POWER STATE\n");
Kevin Lloyd112225b2007-07-16 13:49:27 -070055 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
Kevin Lloyd228426e2008-01-10 11:11:04 -080056 SWIMS_USB_REQUEST_SetPower, /* __u8 request */
Kevin Lloydf3564de2008-03-28 10:05:08 -070057 USB_TYPE_VENDOR, /* __u8 request type */
Kevin Lloyd228426e2008-01-10 11:11:04 -080058 swiState, /* __u16 value */
59 0, /* __u16 index */
60 NULL, /* void *data */
61 0, /* __u16 size */
62 USB_CTRL_SET_TIMEOUT); /* int timeout */
Kevin Lloyd112225b2007-07-16 13:49:27 -070063 return result;
64}
65
Kevin Lloyd228426e2008-01-10 11:11:04 -080066static int sierra_set_ms_mode(struct usb_device *udev, __u16 eSWocMode)
Kevin Lloyd112225b2007-07-16 13:49:27 -070067{
68 int result;
Joe Perches898eb712007-10-18 03:06:30 -070069 dev_dbg(&udev->dev, "%s", "DEVICE MODE SWITCH\n");
Kevin Lloyd112225b2007-07-16 13:49:27 -070070 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
71 SWIMS_USB_REQUEST_SetMode, /* __u8 request */
Kevin Lloydf3564de2008-03-28 10:05:08 -070072 USB_TYPE_VENDOR, /* __u8 request type */
Kevin Lloyd228426e2008-01-10 11:11:04 -080073 eSWocMode, /* __u16 value */
74 0x0000, /* __u16 index */
Kevin Lloyd112225b2007-07-16 13:49:27 -070075 NULL, /* void *data */
76 0, /* __u16 size */
77 USB_CTRL_SET_TIMEOUT); /* int timeout */
78 return result;
79}
80
Kevin Lloyd228426e2008-01-10 11:11:04 -080081static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable)
Kevin Lloyd112225b2007-07-16 13:49:27 -070082{
83 int result;
Kevin Lloyd228426e2008-01-10 11:11:04 -080084 dev_dbg(&udev->dev, "%s", "NMEA Enable sent\n");
85 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
86 SWIMS_USB_REQUEST_SetNmea, /* __u8 request */
Kevin Lloydf3564de2008-03-28 10:05:08 -070087 USB_TYPE_VENDOR, /* __u8 request type */
Kevin Lloyd228426e2008-01-10 11:11:04 -080088 enable, /* __u16 value */
89 0x0000, /* __u16 index */
90 NULL, /* void *data */
91 0, /* __u16 size */
92 USB_CTRL_SET_TIMEOUT); /* int timeout */
93 return result;
94}
Kevin Lloyd112225b2007-07-16 13:49:27 -070095
Kevin Lloyd228426e2008-01-10 11:11:04 -080096static int sierra_calc_num_ports(struct usb_serial *serial)
97{
98 int result;
99 int *num_ports = usb_get_serial_data(serial);
Kevin Lloyd112225b2007-07-16 13:49:27 -0700100
Kevin Lloyd228426e2008-01-10 11:11:04 -0800101 result = *num_ports;
102
103 if (result) {
104 kfree(num_ports);
105 usb_set_serial_data(serial, NULL);
Kevin Lloyd112225b2007-07-16 13:49:27 -0700106 }
107
Kevin Lloyd228426e2008-01-10 11:11:04 -0800108 return result;
109}
110
Kevin Lloyd71069672008-04-02 11:24:56 -0700111static int sierra_calc_interface(struct usb_serial *serial)
112{
113 int interface;
114 struct usb_interface *p_interface;
115 struct usb_host_interface *p_host_interface;
116
117 /* Get the interface structure pointer from the serial struct */
118 p_interface = serial->interface;
119
120 /* Get a pointer to the host interface structure */
121 p_host_interface = p_interface->cur_altsetting;
122
123 /* read the interface descriptor for this active altsetting
124 * to find out the interface number we are on
125 */
126 interface = p_host_interface->desc.bInterfaceNumber;
127
128 return interface;
129}
130
Kevin Lloyd228426e2008-01-10 11:11:04 -0800131static int sierra_probe(struct usb_serial *serial,
132 const struct usb_device_id *id)
133{
134 int result = 0;
135 struct usb_device *udev;
136 int *num_ports;
137 u8 ifnum;
138
139 num_ports = kmalloc(sizeof(*num_ports), GFP_KERNEL);
140 if (!num_ports)
141 return -ENOMEM;
142
143 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
144 udev = serial->dev;
145
Kevin Lloyd71069672008-04-02 11:24:56 -0700146 /* Figure out the interface number from the serial structure */
147 ifnum = sierra_calc_interface(serial);
148
149 /*
150 * If this interface supports more than 1 alternate
151 * select the 2nd one
152 */
153 if (serial->interface->num_altsetting == 2) {
154 dev_dbg(&udev->dev,
155 "Selecting alt setting for interface %d\n",
156 ifnum);
157
158 /* We know the alternate setting is 1 for the MC8785 */
159 usb_set_interface(udev, ifnum, 1);
160 }
161
Kevin Lloyd228426e2008-01-10 11:11:04 -0800162 /* Check if in installer mode */
163 if (truinstall && id->driver_info == DEVICE_INSTALLER) {
164 dev_dbg(&udev->dev, "%s", "FOUND TRU-INSTALL DEVICE(SW)\n");
165 result = sierra_set_ms_mode(udev, SWIMS_SET_MODE_Modem);
166 /* Don't bind to the device when in installer mode */
167 kfree(num_ports);
168 return -EIO;
169 } else if (id->driver_info == DEVICE_1_PORT)
170 *num_ports = 1;
171 else if (ifnum == 0x99)
172 *num_ports = 0;
173 else
174 *num_ports = 3;
175 /*
176 * save off our num_ports info so that we can use it in the
177 * calc_num_ports callback
178 */
179 usb_set_serial_data(serial, (void *)num_ports);
180
181 return result;
Kevin Lloyd112225b2007-07-16 13:49:27 -0700182}
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700183
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700184static struct usb_device_id id_table [] = {
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700185 { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
Kevin Lloyde43062d2007-01-17 16:04:18 -0800186 { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
Greg Kroah-Hartman90ac3c82002-04-09 12:14:34 -0700187 { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
Kevin Lloyd9454c462007-07-16 13:49:29 -0700188 { USB_DEVICE(0x0f30, 0x1b1d) }, /* Sierra Wireless MC5720 */
Kevin Lloyde43062d2007-01-17 16:04:18 -0800189 { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
agilmore@wirelessbeehive.comb9e13ac2007-12-04 11:37:12 -0700190 { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
Kevin Lloyde43062d2007-01-17 16:04:18 -0800191 { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
192 { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
Kevin Lloyd9454c462007-07-16 13:49:29 -0700193 { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */
Kevin Lloyd69a90f82008-03-31 10:20:54 -0700194 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0023, 0xFF, 0xFF, 0xFF) }, /* Sierra Wireless C597 */
Kevin Lloyd9454c462007-07-16 13:49:29 -0700195
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700196 { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
Kevin Lloyde43062d2007-01-17 16:04:18 -0800197 { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700198 { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
Kevin Lloyd9454c462007-07-16 13:49:29 -0700199 { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
Kevin R Pageed0ccdb2007-12-13 01:10:48 +0000200 { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 (Thinkpad internal) */
Kevin Lloyd7f170a62008-03-14 00:53:24 -0700201 { USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */
Stefan Seyfried8f7f85e2008-04-17 07:47:34 +0200202 { USB_DEVICE(0x03f0, 0x1e1d) }, /* HP hs2300 a.k.a MC8775 */
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700203 { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
Kevin Lloyd71069672008-04-02 11:24:56 -0700204 { USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */
Kevin Lloyd9454c462007-07-16 13:49:29 -0700205 { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780*/
206 { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781*/
Kevin Lloyd71069672008-04-02 11:24:56 -0700207 { USB_DEVICE(0x1199, 0x683B), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless MC8785 Composite*/
Kevin Lloyd9454c462007-07-16 13:49:29 -0700208 { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
209 { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
210 { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
211 { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
Kevin Lloyd6835b322008-01-10 11:11:04 -0800212 { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */
Jessica L. Blank62aad3a2007-12-30 20:11:35 -0600213 { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */
Kevin Lloyd71069672008-04-02 11:24:56 -0700214 { USB_DEVICE(0x1199, 0x6859), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless AirCard 885 E */
215 { USB_DEVICE(0x1199, 0x685A), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless AirCard 885 E */
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700216
Kevin Lloyd6835b322008-01-10 11:11:04 -0800217 { USB_DEVICE(0x1199, 0x6468) }, /* Sierra Wireless MP3G - EVDO */
218 { USB_DEVICE(0x1199, 0x6469) }, /* Sierra Wireless MP3G - UMTS/HSPA */
219
Kevin Lloyd112225b2007-07-16 13:49:27 -0700220 { USB_DEVICE(0x1199, 0x0112), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless AirCard 580 */
221 { USB_DEVICE(0x0F3D, 0x0112), .driver_info = DEVICE_1_PORT }, /* Airprime/Sierra PC 5220 */
222
223 { USB_DEVICE(0x1199, 0x0FFF), .driver_info = DEVICE_INSTALLER},
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700224 { }
225};
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700226MODULE_DEVICE_TABLE(usb, id_table);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700227
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700228static struct usb_driver sierra_driver = {
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700229 .name = "sierra",
Kevin Lloyd228426e2008-01-10 11:11:04 -0800230 .probe = usb_serial_probe,
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700231 .disconnect = usb_serial_disconnect,
232 .id_table = id_table,
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700233 .no_dynamic_id = 1,
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700234};
235
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700236struct sierra_port_private {
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900237 spinlock_t lock; /* lock the structure */
238 int outstanding_urbs; /* number of out urbs in flight */
239
Oliver Neukum4f4f9c52008-03-14 00:53:24 -0700240 /* Input endpoints and buffers for this port */
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700241 struct urb *in_urbs[N_IN_URB];
Oliver Neukum4f4f9c52008-03-14 00:53:24 -0700242 char *in_buffer[N_IN_URB];
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700243
244 /* Settings for the port */
245 int rts_state; /* Handshaking pins (outputs) */
246 int dtr_state;
247 int cts_state; /* Handshaking pins (inputs) */
248 int dsr_state;
249 int dcd_state;
250 int ri_state;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700251};
252
Alan Cox95da3102008-07-22 11:09:07 +0100253static int sierra_send_setup(struct tty_struct *tty,
254 struct usb_serial_port *port)
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700255{
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700256 struct usb_serial *serial = port->serial;
257 struct sierra_port_private *portdata;
Kevin Lloyd228426e2008-01-10 11:11:04 -0800258 __u16 interface = 0;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700259
Harvey Harrison441b62c2008-03-03 16:08:34 -0800260 dbg("%s", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700261
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700262 portdata = usb_get_serial_port_data(port);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700263
Alan Cox95da3102008-07-22 11:09:07 +0100264 if (tty) {
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700265 int val = 0;
266 if (portdata->dtr_state)
267 val |= 0x01;
268 if (portdata->rts_state)
269 val |= 0x02;
270
Kevin Lloyd228426e2008-01-10 11:11:04 -0800271 /* Determine which port is targeted */
272 if (port->bulk_out_endpointAddress == 2)
273 interface = 0;
274 else if (port->bulk_out_endpointAddress == 4)
275 interface = 1;
276 else if (port->bulk_out_endpointAddress == 5)
277 interface = 2;
278
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700279 return usb_control_msg(serial->dev,
280 usb_rcvctrlpipe(serial->dev, 0),
Kevin Lloyd228426e2008-01-10 11:11:04 -0800281 0x22, 0x21, val, interface,
282 NULL, 0, USB_CTRL_SET_TIMEOUT);
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700283 }
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700284
285 return 0;
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700286}
287
Alan Cox95da3102008-07-22 11:09:07 +0100288static void sierra_set_termios(struct tty_struct *tty,
289 struct usb_serial_port *port, struct ktermios *old_termios)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700290{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800291 dbg("%s", __func__);
Alan Cox95da3102008-07-22 11:09:07 +0100292 tty_termios_copy_hw(tty->termios, old_termios);
293 sierra_send_setup(tty, port);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700294}
295
Alan Cox95da3102008-07-22 11:09:07 +0100296static int sierra_tiocmget(struct tty_struct *tty, struct file *file)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700297{
Alan Cox95da3102008-07-22 11:09:07 +0100298 struct usb_serial_port *port = tty->driver_data;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700299 unsigned int value;
300 struct sierra_port_private *portdata;
301
302 portdata = usb_get_serial_port_data(port);
303
304 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
305 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
306 ((portdata->cts_state) ? TIOCM_CTS : 0) |
307 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
308 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
309 ((portdata->ri_state) ? TIOCM_RNG : 0);
310
311 return value;
312}
313
Alan Cox95da3102008-07-22 11:09:07 +0100314static int sierra_tiocmset(struct tty_struct *tty, struct file *file,
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700315 unsigned int set, unsigned int clear)
316{
Alan Cox95da3102008-07-22 11:09:07 +0100317 struct usb_serial_port *port = tty->driver_data;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700318 struct sierra_port_private *portdata;
319
320 portdata = usb_get_serial_port_data(port);
321
322 if (set & TIOCM_RTS)
323 portdata->rts_state = 1;
324 if (set & TIOCM_DTR)
325 portdata->dtr_state = 1;
326
327 if (clear & TIOCM_RTS)
328 portdata->rts_state = 0;
329 if (clear & TIOCM_DTR)
330 portdata->dtr_state = 0;
Alan Cox95da3102008-07-22 11:09:07 +0100331 return sierra_send_setup(tty, port);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700332}
333
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900334static void sierra_outdat_callback(struct urb *urb)
335{
336 struct usb_serial_port *port = urb->context;
337 struct sierra_port_private *portdata = usb_get_serial_port_data(port);
338 int status = urb->status;
339 unsigned long flags;
340
Harvey Harrison441b62c2008-03-03 16:08:34 -0800341 dbg("%s - port %d", __func__, port->number);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900342
343 /* free up the transfer buffer, as usb_free_urb() does not do this */
344 kfree(urb->transfer_buffer);
345
346 if (status)
347 dbg("%s - nonzero write bulk status received: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800348 __func__, status);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900349
350 spin_lock_irqsave(&portdata->lock, flags);
351 --portdata->outstanding_urbs;
352 spin_unlock_irqrestore(&portdata->lock, flags);
353
354 usb_serial_port_softint(port);
355}
356
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700357/* Write */
Alan Cox95da3102008-07-22 11:09:07 +0100358static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
359 const unsigned char *buf, int count)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700360{
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900361 struct sierra_port_private *portdata = usb_get_serial_port_data(port);
362 struct usb_serial *serial = port->serial;
363 unsigned long flags;
364 unsigned char *buffer;
365 struct urb *urb;
366 int status;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700367
368 portdata = usb_get_serial_port_data(port);
369
Harvey Harrison441b62c2008-03-03 16:08:34 -0800370 dbg("%s: write (%d chars)", __func__, count);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700371
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900372 spin_lock_irqsave(&portdata->lock, flags);
373 if (portdata->outstanding_urbs > N_OUT_URB) {
374 spin_unlock_irqrestore(&portdata->lock, flags);
Harvey Harrison441b62c2008-03-03 16:08:34 -0800375 dbg("%s - write limit hit\n", __func__);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900376 return 0;
377 }
378 portdata->outstanding_urbs++;
379 spin_unlock_irqrestore(&portdata->lock, flags);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700380
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900381 buffer = kmalloc(count, GFP_ATOMIC);
382 if (!buffer) {
383 dev_err(&port->dev, "out of memory\n");
384 count = -ENOMEM;
385 goto error_no_buffer;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700386 }
387
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900388 urb = usb_alloc_urb(0, GFP_ATOMIC);
389 if (!urb) {
390 dev_err(&port->dev, "no more free urbs\n");
391 count = -ENOMEM;
392 goto error_no_urb;
393 }
394
395 memcpy(buffer, buf, count);
396
Harvey Harrison441b62c2008-03-03 16:08:34 -0800397 usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900398
399 usb_fill_bulk_urb(urb, serial->dev,
400 usb_sndbulkpipe(serial->dev,
401 port->bulk_out_endpointAddress),
402 buffer, count, sierra_outdat_callback, port);
403
404 /* send it down the pipe */
405 status = usb_submit_urb(urb, GFP_ATOMIC);
406 if (status) {
407 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
Harvey Harrison441b62c2008-03-03 16:08:34 -0800408 "with status = %d\n", __func__, status);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900409 count = status;
410 goto error;
411 }
412
413 /* we are done with this urb, so let the host driver
414 * really free it when it is finished with it */
415 usb_free_urb(urb);
416
417 return count;
418error:
419 usb_free_urb(urb);
420error_no_urb:
421 kfree(buffer);
422error_no_buffer:
423 spin_lock_irqsave(&portdata->lock, flags);
424 --portdata->outstanding_urbs;
425 spin_unlock_irqrestore(&portdata->lock, flags);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700426 return count;
427}
428
429static void sierra_indat_callback(struct urb *urb)
430{
431 int err;
432 int endpoint;
433 struct usb_serial_port *port;
434 struct tty_struct *tty;
435 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman17dd2212007-06-15 15:44:13 -0700436 int status = urb->status;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700437
Harvey Harrison441b62c2008-03-03 16:08:34 -0800438 dbg("%s: %p", __func__, urb);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700439
440 endpoint = usb_pipeendpoint(urb->pipe);
Ming Leicdc97792008-02-24 18:41:47 +0800441 port = urb->context;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700442
Greg Kroah-Hartman17dd2212007-06-15 15:44:13 -0700443 if (status) {
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700444 dbg("%s: nonzero status: %d on endpoint %02x.",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800445 __func__, status, endpoint);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700446 } else {
Alan Cox95da3102008-07-22 11:09:07 +0100447 tty = port->port.tty;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700448 if (urb->actual_length) {
449 tty_buffer_request_room(tty, urb->actual_length);
450 tty_insert_flip_string(tty, data, urb->actual_length);
451 tty_flip_buffer_push(tty);
452 } else {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800453 dbg("%s: empty read urb received", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700454 }
455
456 /* Resubmit urb so we continue receiving */
Alan Cox95da3102008-07-22 11:09:07 +0100457 if (port->port.count && status != -ESHUTDOWN) {
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700458 err = usb_submit_urb(urb, GFP_ATOMIC);
459 if (err)
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900460 dev_err(&port->dev, "resubmit read urb failed."
Joe Perches898eb712007-10-18 03:06:30 -0700461 "(%d)\n", err);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700462 }
463 }
464 return;
465}
466
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700467static void sierra_instat_callback(struct urb *urb)
468{
469 int err;
Greg Kroah-Hartman17dd2212007-06-15 15:44:13 -0700470 int status = urb->status;
Ming Leicdc97792008-02-24 18:41:47 +0800471 struct usb_serial_port *port = urb->context;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700472 struct sierra_port_private *portdata = usb_get_serial_port_data(port);
473 struct usb_serial *serial = port->serial;
474
Harvey Harrison441b62c2008-03-03 16:08:34 -0800475 dbg("%s", __func__);
476 dbg("%s: urb %p port %p has data %p", __func__, urb, port, portdata);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700477
Greg Kroah-Hartman17dd2212007-06-15 15:44:13 -0700478 if (status == 0) {
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700479 struct usb_ctrlrequest *req_pkt =
480 (struct usb_ctrlrequest *)urb->transfer_buffer;
481
482 if (!req_pkt) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800483 dbg("%s: NULL req_pkt\n", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700484 return;
485 }
486 if ((req_pkt->bRequestType == 0xA1) &&
487 (req_pkt->bRequest == 0x20)) {
488 int old_dcd_state;
489 unsigned char signals = *((unsigned char *)
490 urb->transfer_buffer +
491 sizeof(struct usb_ctrlrequest));
492
Harvey Harrison441b62c2008-03-03 16:08:34 -0800493 dbg("%s: signal x%x", __func__, signals);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700494
495 old_dcd_state = portdata->dcd_state;
496 portdata->cts_state = 1;
497 portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
498 portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
499 portdata->ri_state = ((signals & 0x08) ? 1 : 0);
500
Alan Cox95da3102008-07-22 11:09:07 +0100501 if (port->port.tty && !C_CLOCAL(port->port.tty) &&
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700502 old_dcd_state && !portdata->dcd_state)
Alan Cox95da3102008-07-22 11:09:07 +0100503 tty_hangup(port->port.tty);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700504 } else {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800505 dbg("%s: type %x req %x", __func__,
Kevin Lloydf3564de2008-03-28 10:05:08 -0700506 req_pkt->bRequestType, req_pkt->bRequest);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700507 }
508 } else
Harvey Harrison441b62c2008-03-03 16:08:34 -0800509 dbg("%s: error %d", __func__, status);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700510
511 /* Resubmit urb so we continue receiving IRQ data */
Greg Kroah-Hartman17dd2212007-06-15 15:44:13 -0700512 if (status != -ESHUTDOWN) {
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700513 urb->dev = serial->dev;
514 err = usb_submit_urb(urb, GFP_ATOMIC);
515 if (err)
516 dbg("%s: resubmit intr urb failed. (%d)",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800517 __func__, err);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700518 }
519}
520
Alan Cox95da3102008-07-22 11:09:07 +0100521static int sierra_write_room(struct tty_struct *tty)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700522{
Alan Cox95da3102008-07-22 11:09:07 +0100523 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900524 struct sierra_port_private *portdata = usb_get_serial_port_data(port);
525 unsigned long flags;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700526
Harvey Harrison441b62c2008-03-03 16:08:34 -0800527 dbg("%s - port %d", __func__, port->number);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700528
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900529 /* try to give a good number back based on if we have any free urbs at
530 * this point in time */
531 spin_lock_irqsave(&portdata->lock, flags);
532 if (portdata->outstanding_urbs > N_OUT_URB * 2 / 3) {
533 spin_unlock_irqrestore(&portdata->lock, flags);
Harvey Harrison441b62c2008-03-03 16:08:34 -0800534 dbg("%s - write limit hit\n", __func__);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900535 return 0;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700536 }
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900537 spin_unlock_irqrestore(&portdata->lock, flags);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700538
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900539 return 2048;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700540}
541
Alan Cox95da3102008-07-22 11:09:07 +0100542static int sierra_open(struct tty_struct *tty,
543 struct usb_serial_port *port, struct file *filp)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700544{
545 struct sierra_port_private *portdata;
546 struct usb_serial *serial = port->serial;
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900547 int i;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700548 struct urb *urb;
Kevin Lloyde43062d2007-01-17 16:04:18 -0800549 int result;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700550
551 portdata = usb_get_serial_port_data(port);
552
Harvey Harrison441b62c2008-03-03 16:08:34 -0800553 dbg("%s", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700554
555 /* Set some sane defaults */
556 portdata->rts_state = 1;
557 portdata->dtr_state = 1;
558
559 /* Reset low level data toggle and start reading from endpoints */
560 for (i = 0; i < N_IN_URB; i++) {
561 urb = portdata->in_urbs[i];
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900562 if (!urb)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700563 continue;
564 if (urb->dev != serial->dev) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800565 dbg("%s: dev %p != %p", __func__,
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700566 urb->dev, serial->dev);
567 continue;
568 }
569
570 /*
571 * make sure endpoint data toggle is synchronized with the
572 * device
573 */
574 usb_clear_halt(urb->dev, urb->pipe);
575
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900576 result = usb_submit_urb(urb, GFP_KERNEL);
577 if (result) {
Joe Perches898eb712007-10-18 03:06:30 -0700578 dev_err(&port->dev, "submit urb %d failed (%d) %d\n",
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900579 i, result, urb->transfer_buffer_length);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700580 }
581 }
582
Alan Cox95da3102008-07-22 11:09:07 +0100583 if (tty)
584 tty->low_latency = 1;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700585
Alan Cox95da3102008-07-22 11:09:07 +0100586 sierra_send_setup(tty, port);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700587
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900588 /* start up the interrupt endpoint if we have one */
589 if (port->interrupt_in_urb) {
590 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
591 if (result)
Joe Perches898eb712007-10-18 03:06:30 -0700592 dev_err(&port->dev, "submit irq_in urb failed %d\n",
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900593 result);
594 }
595 return 0;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700596}
597
Alan Cox95da3102008-07-22 11:09:07 +0100598static void sierra_close(struct tty_struct *tty,
599 struct usb_serial_port *port, struct file *filp)
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700600{
601 int i;
602 struct usb_serial *serial = port->serial;
603 struct sierra_port_private *portdata;
604
Harvey Harrison441b62c2008-03-03 16:08:34 -0800605 dbg("%s", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700606 portdata = usb_get_serial_port_data(port);
607
608 portdata->rts_state = 0;
609 portdata->dtr_state = 0;
610
611 if (serial->dev) {
Oliver Neukume33fe4d2008-01-21 17:44:10 +0100612 mutex_lock(&serial->disc_mutex);
613 if (!serial->disconnected)
Alan Cox95da3102008-07-22 11:09:07 +0100614 sierra_send_setup(tty, port);
Oliver Neukume33fe4d2008-01-21 17:44:10 +0100615 mutex_unlock(&serial->disc_mutex);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700616
617 /* Stop reading/writing urbs */
618 for (i = 0; i < N_IN_URB; i++)
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900619 usb_kill_urb(portdata->in_urbs[i]);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700620 }
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900621
622 usb_kill_urb(port->interrupt_in_urb);
623
Alan Cox95da3102008-07-22 11:09:07 +0100624 port->port.tty = NULL; /* FIXME */
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700625}
626
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700627static int sierra_startup(struct usb_serial *serial)
628{
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700629 struct usb_serial_port *port;
630 struct sierra_port_private *portdata;
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900631 struct urb *urb;
632 int i;
633 int j;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700634
Harvey Harrison441b62c2008-03-03 16:08:34 -0800635 dbg("%s", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700636
Kevin Lloyd228426e2008-01-10 11:11:04 -0800637 /* Set Device mode to D0 */
Kevin Lloyd112225b2007-07-16 13:49:27 -0700638 sierra_set_power_state(serial->dev, 0x0000);
639
Kevin Lloyd228426e2008-01-10 11:11:04 -0800640 /* Check NMEA and set */
641 if (nmea)
642 sierra_vsc_set_nmea(serial->dev, 1);
643
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700644 /* Now setup per port private data */
645 for (i = 0; i < serial->num_ports; i++) {
646 port = serial->port[i];
647 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
648 if (!portdata) {
649 dbg("%s: kmalloc for sierra_port_private (%d) failed!.",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800650 __func__, i);
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900651 return -ENOMEM;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700652 }
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900653 spin_lock_init(&portdata->lock);
Oliver Neukum4f4f9c52008-03-14 00:53:24 -0700654 for (j = 0; j < N_IN_URB; j++) {
655 portdata->in_buffer[j] = kmalloc(IN_BUFLEN, GFP_KERNEL);
656 if (!portdata->in_buffer[j]) {
657 for (--j; j >= 0; j--)
658 kfree(portdata->in_buffer[j]);
659 kfree(portdata);
660 return -ENOMEM;
661 }
662 }
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700663
664 usb_set_serial_port_data(port, portdata);
665
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900666 /* initialize the in urbs */
667 for (j = 0; j < N_IN_URB; ++j) {
668 urb = usb_alloc_urb(0, GFP_KERNEL);
669 if (urb == NULL) {
670 dbg("%s: alloc for in port failed.",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800671 __func__);
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900672 continue;
673 }
674 /* Fill URB using supplied data. */
675 usb_fill_bulk_urb(urb, serial->dev,
676 usb_rcvbulkpipe(serial->dev,
677 port->bulk_in_endpointAddress),
678 portdata->in_buffer[j], IN_BUFLEN,
679 sierra_indat_callback, port);
680 portdata->in_urbs[j] = urb;
681 }
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700682 }
683
Greg Kroah-Hartman17c23272007-06-20 14:22:23 +0900684 return 0;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700685}
686
687static void sierra_shutdown(struct usb_serial *serial)
688{
689 int i, j;
690 struct usb_serial_port *port;
691 struct sierra_port_private *portdata;
692
Harvey Harrison441b62c2008-03-03 16:08:34 -0800693 dbg("%s", __func__);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700694
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700695 for (i = 0; i < serial->num_ports; ++i) {
696 port = serial->port[i];
Greg Kroah-Hartmanf094e4f2007-04-26 00:12:01 -0700697 if (!port)
698 continue;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700699 portdata = usb_get_serial_port_data(port);
Greg Kroah-Hartmanf094e4f2007-04-26 00:12:01 -0700700 if (!portdata)
701 continue;
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700702
703 for (j = 0; j < N_IN_URB; j++) {
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900704 usb_kill_urb(portdata->in_urbs[j]);
705 usb_free_urb(portdata->in_urbs[j]);
Oliver Neukum4f4f9c52008-03-14 00:53:24 -0700706 kfree(portdata->in_buffer[j]);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700707 }
Greg Kroah-Hartman9e85c5f2007-06-20 14:22:23 +0900708 kfree(portdata);
709 usb_set_serial_port_data(port, NULL);
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700710 }
711}
712
Kevin Lloyd228426e2008-01-10 11:11:04 -0800713static struct usb_serial_driver sierra_device = {
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700714 .driver = {
715 .owner = THIS_MODULE,
716 .name = "sierra1",
717 },
Kevin Lloyd228426e2008-01-10 11:11:04 -0800718 .description = "Sierra USB modem",
719 .id_table = id_table,
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100720 .usb_driver = &sierra_driver,
Kevin Lloyd228426e2008-01-10 11:11:04 -0800721 .calc_num_ports = sierra_calc_num_ports,
722 .probe = sierra_probe,
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700723 .open = sierra_open,
724 .close = sierra_close,
725 .write = sierra_write,
726 .write_room = sierra_write_room,
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700727 .set_termios = sierra_set_termios,
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700728 .tiocmget = sierra_tiocmget,
729 .tiocmset = sierra_tiocmset,
730 .attach = sierra_startup,
731 .shutdown = sierra_shutdown,
732 .read_int_callback = sierra_instat_callback,
733};
734
735/* Functions used by new usb-serial code. */
736static int __init sierra_init(void)
737{
738 int retval;
Kevin Lloyd228426e2008-01-10 11:11:04 -0800739 retval = usb_serial_register(&sierra_device);
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700740 if (retval)
Kevin Lloyd228426e2008-01-10 11:11:04 -0800741 goto failed_device_register;
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700742
743
744 retval = usb_register(&sierra_driver);
745 if (retval)
746 goto failed_driver_register;
747
748 info(DRIVER_DESC ": " DRIVER_VERSION);
749
750 return 0;
751
752failed_driver_register:
Kevin Lloyd228426e2008-01-10 11:11:04 -0800753 usb_serial_deregister(&sierra_device);
754failed_device_register:
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700755 return retval;
756}
757
758static void __exit sierra_exit(void)
759{
Alan Cox9660ea32008-07-22 11:14:59 +0100760 usb_deregister(&sierra_driver);
Kevin Lloyd228426e2008-01-10 11:11:04 -0800761 usb_serial_deregister(&sierra_device);
Greg Kroah-Hartman964ee1d2006-10-17 10:17:58 -0700762}
763
764module_init(sierra_init);
765module_exit(sierra_exit);
766
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700767MODULE_AUTHOR(DRIVER_AUTHOR);
768MODULE_DESCRIPTION(DRIVER_DESC);
769MODULE_VERSION(DRIVER_VERSION);
Kevin Lloyd69de51f2006-06-30 11:17:55 -0700770MODULE_LICENSE("GPL");
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700771
Kevin Lloyd228426e2008-01-10 11:11:04 -0800772module_param(truinstall, bool, 0);
773MODULE_PARM_DESC(truinstall, "TRU-Install support");
774
775module_param(nmea, bool, 0);
776MODULE_PARM_DESC(nmea, "NMEA streaming");
777
Kevin Lloyd033a3fb2006-10-13 23:53:21 -0700778#ifdef CONFIG_USB_DEBUG
779module_param(debug, bool, S_IRUGO | S_IWUSR);
780MODULE_PARM_DESC(debug, "Debug messages");
781#endif
782