blob: 040040a267d970ff0fe97b057fb1eb7cb8f6df33 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * USB Keyspan PDA / Xircom / Entregra Converter driver
3 *
4 * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com>
5 * Copyright (C) 1999, 2000 Brian Warner <warner@lothar.com>
6 * Copyright (C) 2000 Al Borchers <borchers@steinerpoint.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
Alan Cox9e70f312008-07-22 11:13:42 +010013 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
15 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * (09/07/2001) gkh
17 * cleaned up the Xircom support. Added ids for Entregra device which is
18 * the same as the Xircom device. Enabled the code to be compiled for
19 * either Xircom or Keyspan devices.
20 *
21 * (08/11/2001) Cristian M. Craciunescu
22 * support for Xircom PGSDB9
23 *
24 * (05/31/2001) gkh
Alan Cox9e70f312008-07-22 11:13:42 +010025 * switched from using spinlock to a semaphore, which fixes lots of
26 * problems.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 *
28 * (04/08/2001) gb
29 * Identify version on module load.
Alan Cox9e70f312008-07-22 11:13:42 +010030 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 * (11/01/2000) Adam J. Richter
32 * usb_device_id table support
Alan Cox9e70f312008-07-22 11:13:42 +010033 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 * (10/05/2000) gkh
35 * Fixed bug with urb->dev not being set properly, now that the usb
36 * core needs it.
Alan Cox9e70f312008-07-22 11:13:42 +010037 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * (08/28/2000) gkh
39 * Added locks for SMP safeness.
Alan Cox9e70f312008-07-22 11:13:42 +010040 * Fixed MOD_INC and MOD_DEC logic and the ability to open a port more
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * than once.
Alan Cox9e70f312008-07-22 11:13:42 +010042 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * (07/20/2000) borchers
44 * - keyspan_pda_write no longer sleeps if it is called on interrupt time;
45 * PPP and the line discipline with stty echo on can call write on
46 * interrupt time and this would cause an oops if write slept
47 * - if keyspan_pda_write is in an interrupt, it will not call
48 * usb_control_msg (which sleeps) to query the room in the device
49 * buffer, it simply uses the current room value it has
50 * - if the urb is busy or if it is throttled keyspan_pda_write just
51 * returns 0, rather than sleeping to wait for this to change; the
52 * write_chan code in n_tty.c will sleep if needed before calling
53 * keyspan_pda_write again
54 * - if the device needs to be unthrottled, write now queues up the
55 * call to usb_control_msg (which sleeps) to unthrottle the device
56 * - the wakeups from keyspan_pda_write_bulk_callback are queued rather
57 * than done directly from the callback to avoid the race in write_chan
58 * - keyspan_pda_chars_in_buffer also indicates its buffer is full if the
59 * urb status is -EINPROGRESS, meaning it cannot write at the moment
Alan Cox9e70f312008-07-22 11:13:42 +010060 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 * (07/19/2000) gkh
62 * Added module_init and module_exit functions to handle the fact that this
63 * driver is a loadable module now.
64 *
65 * (03/26/2000) gkh
66 * Split driver up into device specific pieces.
Alan Cox9e70f312008-07-22 11:13:42 +010067 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 */
69
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <linux/kernel.h>
72#include <linux/errno.h>
73#include <linux/init.h>
74#include <linux/slab.h>
75#include <linux/tty.h>
76#include <linux/tty_driver.h>
77#include <linux/tty_flip.h>
78#include <linux/module.h>
79#include <linux/spinlock.h>
80#include <linux/workqueue.h>
David Woodhouse3edbf982008-05-30 15:15:13 +030081#include <linux/firmware.h>
82#include <linux/ihex.h>
Alan Cox9e70f312008-07-22 11:13:42 +010083#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070085#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87static int debug;
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089/* make a simple define to handle if we are compiling keyspan_pda or xircom support */
90#if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
91 #define KEYSPAN
92#else
93 #undef KEYSPAN
94#endif
95#if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
96 #define XIRCOM
97#else
98 #undef XIRCOM
99#endif
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101/*
102 * Version Information
103 */
104#define DRIVER_VERSION "v1.1"
105#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
106#define DRIVER_DESC "USB Keyspan PDA Converter driver"
107
108struct keyspan_pda_private {
109 int tx_room;
110 int tx_throttled;
111 struct work_struct wakeup_work;
112 struct work_struct unthrottle_work;
David Howellsc4028952006-11-22 14:57:56 +0000113 struct usb_serial *serial;
114 struct usb_serial_port *port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115};
116
117
118#define KEYSPAN_VENDOR_ID 0x06cd
119#define KEYSPAN_PDA_FAKE_ID 0x0103
120#define KEYSPAN_PDA_ID 0x0104 /* no clue */
121
122/* For Xircom PGSDB9 and older Entregra version of the same device */
123#define XIRCOM_VENDOR_ID 0x085a
124#define XIRCOM_FAKE_ID 0x8027
125#define ENTREGRA_VENDOR_ID 0x1645
126#define ENTREGRA_FAKE_ID 0x8093
127
128static struct usb_device_id id_table_combined [] = {
129#ifdef KEYSPAN
130 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
131#endif
132#ifdef XIRCOM
133 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
134 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
135#endif
136 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
137 { } /* Terminating entry */
138};
139
Alan Cox9e70f312008-07-22 11:13:42 +0100140MODULE_DEVICE_TABLE(usb, id_table_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
142static struct usb_driver keyspan_pda_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 .name = "keyspan_pda",
144 .probe = usb_serial_probe,
145 .disconnect = usb_serial_disconnect,
146 .id_table = id_table_combined,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800147 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148};
149
150static struct usb_device_id id_table_std [] = {
151 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
152 { } /* Terminating entry */
153};
154
155#ifdef KEYSPAN
156static struct usb_device_id id_table_fake [] = {
157 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
158 { } /* Terminating entry */
159};
160#endif
161
162#ifdef XIRCOM
163static struct usb_device_id id_table_fake_xircom [] = {
Alan Cox9e70f312008-07-22 11:13:42 +0100164 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
165 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
166 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167};
168#endif
169
David Howellsc4028952006-11-22 14:57:56 +0000170static void keyspan_pda_wakeup_write(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
David Howellsc4028952006-11-22 14:57:56 +0000172 struct keyspan_pda_private *priv =
173 container_of(work, struct keyspan_pda_private, wakeup_work);
174 struct usb_serial_port *port = priv->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Alan Cox95da3102008-07-22 11:09:07 +0100176 tty_wakeup(port->port.tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177}
178
David Howellsc4028952006-11-22 14:57:56 +0000179static void keyspan_pda_request_unthrottle(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
David Howellsc4028952006-11-22 14:57:56 +0000181 struct keyspan_pda_private *priv =
182 container_of(work, struct keyspan_pda_private, unthrottle_work);
183 struct usb_serial *serial = priv->serial;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 int result;
185
186 dbg(" request_unthrottle");
187 /* ask the device to tell us when the tx buffer becomes
188 sufficiently empty */
Alan Cox9e70f312008-07-22 11:13:42 +0100189 result = usb_control_msg(serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 usb_sndctrlpipe(serial->dev, 0),
191 7, /* request_unthrottle */
192 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
193 | USB_DIR_OUT,
194 16, /* value: threshold */
195 0, /* index */
196 NULL,
197 0,
198 2000);
199 if (result < 0)
Alan Cox9e70f312008-07-22 11:13:42 +0100200 dbg("%s - error %d from usb_control_msg",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800201 __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
204
Alan Cox9e70f312008-07-22 11:13:42 +0100205static void keyspan_pda_rx_interrupt(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
Ming Leicdc97792008-02-24 18:41:47 +0800207 struct usb_serial_port *port = urb->context;
Alan Cox9e70f312008-07-22 11:13:42 +0100208 struct tty_struct *tty = port->port.tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700210 int retval;
211 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 struct keyspan_pda_private *priv;
213 priv = usb_get_serial_port_data(port);
214
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700215 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 case 0:
217 /* success */
218 break;
219 case -ECONNRESET:
220 case -ENOENT:
221 case -ESHUTDOWN:
222 /* this urb is terminated, clean up */
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700223 dbg("%s - urb shutting down with status: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800224 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 return;
226 default:
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700227 dbg("%s - nonzero urb status received: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800228 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 goto exit;
230 }
231
Alan Cox9e70f312008-07-22 11:13:42 +0100232 /* see if the message is data or a status interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 switch (data[0]) {
234 case 0:
235 /* rest of message is rx data */
236 if (urb->actual_length) {
Alan Cox8dd03a52008-07-22 11:13:51 +0100237 tty_insert_flip_string(tty, data + 1,
238 urb->actual_length - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 tty_flip_buffer_push(tty);
240 }
241 break;
242 case 1:
243 /* status interrupt */
244 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
245 switch (data[1]) {
246 case 1: /* modemline change */
247 break;
248 case 2: /* tx unthrottle interrupt */
249 priv->tx_throttled = 0;
250 /* queue up a wakeup at scheduler time */
251 schedule_work(&priv->wakeup_work);
252 break;
253 default:
254 break;
255 }
256 break;
257 default:
258 break;
259 }
260
261exit:
Alan Cox9e70f312008-07-22 11:13:42 +0100262 retval = usb_submit_urb(urb, GFP_ATOMIC);
Greg Kroah-Hartman23189ae2007-06-15 15:44:13 -0700263 if (retval)
Alan Cox9e70f312008-07-22 11:13:42 +0100264 err("%s - usb_submit_urb failed with result %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800265 __func__, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266}
267
268
Alan Cox95da3102008-07-22 11:09:07 +0100269static void keyspan_pda_rx_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270{
271 /* stop receiving characters. We just turn off the URB request, and
272 let chars pile up in the device. If we're doing hardware
273 flowcontrol, the device will signal the other end when its buffer
274 fills up. If we're doing XON/XOFF, this would be a good time to
275 send an XOFF, although it might make sense to foist that off
276 upon the device too. */
Alan Cox95da3102008-07-22 11:09:07 +0100277 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 dbg("keyspan_pda_rx_throttle port %d", port->number);
279 usb_kill_urb(port->interrupt_in_urb);
280}
281
282
Alan Cox95da3102008-07-22 11:09:07 +0100283static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
Alan Cox95da3102008-07-22 11:09:07 +0100285 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 /* just restart the receive interrupt URB */
287 dbg("keyspan_pda_rx_unthrottle port %d", port->number);
288 port->interrupt_in_urb->dev = port->serial->dev;
289 if (usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC))
290 dbg(" usb_submit_urb(read urb) failed");
291 return;
292}
293
294
Alan Cox9e70f312008-07-22 11:13:42 +0100295static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{
297 int rc;
298 int bindex;
299
Alan Cox9e70f312008-07-22 11:13:42 +0100300 switch (baud) {
301 case 110:
302 bindex = 0;
303 break;
304 case 300:
305 bindex = 1;
306 break;
307 case 1200:
308 bindex = 2;
309 break;
310 case 2400:
311 bindex = 3;
312 break;
313 case 4800:
314 bindex = 4;
315 break;
316 case 9600:
317 bindex = 5;
318 break;
319 case 19200:
320 bindex = 6;
321 break;
322 case 38400:
323 bindex = 7;
324 break;
325 case 57600:
326 bindex = 8;
327 break;
328 case 115200:
329 bindex = 9;
330 break;
331 default:
332 bindex = 5; /* Default to 9600 */
333 baud = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 }
335
336 /* rather than figure out how to sleep while waiting for this
337 to complete, I just use the "legacy" API. */
338 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
339 0, /* set baud */
Alan Cox9e70f312008-07-22 11:13:42 +0100340 USB_TYPE_VENDOR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 | USB_RECIP_INTERFACE
342 | USB_DIR_OUT, /* type */
343 bindex, /* value */
344 0, /* index */
345 NULL, /* &data */
346 0, /* size */
347 2000); /* timeout */
Alan Coxe7806e32007-12-13 16:15:28 -0800348 if (rc < 0)
349 return 0;
350 return baud;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
353
Alan Cox95da3102008-07-22 11:09:07 +0100354static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
Alan Cox95da3102008-07-22 11:09:07 +0100356 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 struct usb_serial *serial = port->serial;
358 int value;
359 int result;
360
361 if (break_state == -1)
362 value = 1; /* start break */
363 else
364 value = 0; /* clear break */
365 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
Alan Cox9e70f312008-07-22 11:13:42 +0100366 4, /* set break */
367 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
368 value, 0, NULL, 0, 2000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (result < 0)
Alan Cox9e70f312008-07-22 11:13:42 +0100370 dbg("%s - error %d from usb_control_msg",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800371 __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 /* there is something funky about this.. the TCSBRK that 'cu' performs
373 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
374 seconds apart, but it feels like the break sent isn't as long as it
375 is on /dev/ttyS0 */
376}
377
378
Alan Cox95da3102008-07-22 11:09:07 +0100379static void keyspan_pda_set_termios(struct tty_struct *tty,
380 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
382 struct usb_serial *serial = port->serial;
Alan Coxe7806e32007-12-13 16:15:28 -0800383 speed_t speed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 /* cflag specifies lots of stuff: number of stop bits, parity, number
386 of data bits, baud. What can the device actually handle?:
387 CSTOPB (1 stop bit or 2)
388 PARENB (parity)
389 CSIZE (5bit .. 8bit)
390 There is minimal hw support for parity (a PSW bit seems to hold the
391 parity of whatever is in the accumulator). The UART either deals
392 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
393 1 special, stop). So, with firmware changes, we could do:
394 8N1: 10 bit
395 8N2: 11 bit, extra bit always (mark?)
396 8[EOMS]1: 11 bit, extra bit is parity
397 7[EOMS]1: 10 bit, b0/b7 is parity
398 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
399
400 HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
401 bit.
402
403 For now, just do baud. */
404
Alan Cox95da3102008-07-22 11:09:07 +0100405 speed = tty_get_baud_rate(tty);
Alan Coxe7806e32007-12-13 16:15:28 -0800406 speed = keyspan_pda_setbaud(serial, speed);
407
408 if (speed == 0) {
409 dbg("can't handle requested baud rate");
410 /* It hasn't changed so.. */
411 speed = tty_termios_baud_rate(old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
Alan Coxe7806e32007-12-13 16:15:28 -0800413 /* Only speed can change so copy the old h/w parameters
414 then encode the new speed */
Alan Cox95da3102008-07-22 11:09:07 +0100415 tty_termios_copy_hw(tty->termios, old_termios);
416 tty_encode_baud_rate(tty, speed, speed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417}
418
419
420/* modem control pins: DTR and RTS are outputs and can be controlled.
421 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
422 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
423
424static int keyspan_pda_get_modem_info(struct usb_serial *serial,
425 unsigned char *value)
426{
427 int rc;
428 unsigned char data;
429 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
430 3, /* get pins */
431 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
432 0, 0, &data, 1, 2000);
Benny Halevy3b36a8f2008-06-27 12:22:32 +0300433 if (rc >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 *value = data;
435 return rc;
436}
437
438
439static int keyspan_pda_set_modem_info(struct usb_serial *serial,
440 unsigned char value)
441{
442 int rc;
443 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
444 3, /* set pins */
445 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
446 value, 0, NULL, 0, 2000);
447 return rc;
448}
449
Alan Cox95da3102008-07-22 11:09:07 +0100450static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Alan Cox95da3102008-07-22 11:09:07 +0100452 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 struct usb_serial *serial = port->serial;
454 int rc;
455 unsigned char status;
456 int value;
457
458 rc = keyspan_pda_get_modem_info(serial, &status);
459 if (rc < 0)
460 return rc;
461 value =
462 ((status & (1<<7)) ? TIOCM_DTR : 0) |
463 ((status & (1<<6)) ? TIOCM_CAR : 0) |
464 ((status & (1<<5)) ? TIOCM_RNG : 0) |
465 ((status & (1<<4)) ? TIOCM_DSR : 0) |
466 ((status & (1<<3)) ? TIOCM_CTS : 0) |
467 ((status & (1<<2)) ? TIOCM_RTS : 0);
468 return value;
469}
470
Alan Cox95da3102008-07-22 11:09:07 +0100471static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 unsigned int set, unsigned int clear)
473{
Alan Cox95da3102008-07-22 11:09:07 +0100474 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 struct usb_serial *serial = port->serial;
476 int rc;
477 unsigned char status;
478
479 rc = keyspan_pda_get_modem_info(serial, &status);
480 if (rc < 0)
481 return rc;
482
483 if (set & TIOCM_RTS)
484 status |= (1<<2);
485 if (set & TIOCM_DTR)
486 status |= (1<<7);
487
488 if (clear & TIOCM_RTS)
489 status &= ~(1<<2);
490 if (clear & TIOCM_DTR)
491 status &= ~(1<<7);
492 rc = keyspan_pda_set_modem_info(serial, status);
493 return rc;
494}
495
Alan Cox95da3102008-07-22 11:09:07 +0100496static int keyspan_pda_write(struct tty_struct *tty,
497 struct usb_serial_port *port, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
499 struct usb_serial *serial = port->serial;
500 int request_unthrottle = 0;
501 int rc = 0;
502 struct keyspan_pda_private *priv;
503
504 priv = usb_get_serial_port_data(port);
505 /* guess how much room is left in the device's ring buffer, and if we
506 want to send more than that, check first, updating our notion of
507 what is left. If our write will result in no room left, ask the
508 device to give us an interrupt when the room available rises above
509 a threshold, and hold off all writers (eventually, those using
510 select() or poll() too) until we receive that unthrottle interrupt.
511 Block if we can't write anything at all, otherwise write as much as
512 we can. */
Alan Cox9e70f312008-07-22 11:13:42 +0100513 dbg("keyspan_pda_write(%d)", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if (count == 0) {
515 dbg(" write request of 0 bytes");
Alan Cox9e70f312008-07-22 11:13:42 +0100516 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 }
518
519 /* we might block because of:
520 the TX urb is in-flight (wait until it completes)
521 the device is full (wait until it says there is room)
522 */
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200523 spin_lock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700524 if (port->write_urb_busy || priv->tx_throttled) {
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200525 spin_unlock_bh(&port->lock);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700526 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 }
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700528 port->write_urb_busy = 1;
Peter Zijlstrae81ee632006-09-25 12:51:41 +0200529 spin_unlock_bh(&port->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
531 /* At this point the URB is in our control, nobody else can submit it
532 again (the only sudden transition was the one from EINPROGRESS to
533 finished). Also, the tx process is not throttled. So we are
534 ready to write. */
535
536 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
537
538 /* Check if we might overrun the Tx buffer. If so, ask the
539 device how much room it really has. This is done only on
540 scheduler time, since usb_control_msg() sleeps. */
541 if (count > priv->tx_room && !in_interrupt()) {
542 unsigned char room;
Alan Cox9e70f312008-07-22 11:13:42 +0100543 rc = usb_control_msg(serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 usb_rcvctrlpipe(serial->dev, 0),
545 6, /* write_room */
546 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
547 | USB_DIR_IN,
548 0, /* value: 0 means "remaining room" */
549 0, /* index */
550 &room,
551 1,
552 2000);
553 if (rc < 0) {
554 dbg(" roomquery failed");
555 goto exit;
556 }
557 if (rc == 0) {
558 dbg(" roomquery returned 0 bytes");
559 rc = -EIO; /* device didn't return any data */
560 goto exit;
561 }
562 dbg(" roomquery says %d", room);
563 priv->tx_room = room;
564 }
565 if (count > priv->tx_room) {
566 /* we're about to completely fill the Tx buffer, so
567 we'll be throttled afterwards. */
568 count = priv->tx_room;
569 request_unthrottle = 1;
570 }
571
572 if (count) {
573 /* now transfer data */
Alan Cox9e70f312008-07-22 11:13:42 +0100574 memcpy(port->write_urb->transfer_buffer, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 /* send the data out the bulk port */
576 port->write_urb->transfer_buffer_length = count;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 priv->tx_room -= count;
579
580 port->write_urb->dev = port->serial->dev;
581 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
582 if (rc) {
583 dbg(" usb_submit_urb(write bulk) failed");
584 goto exit;
585 }
Alan Cox9e70f312008-07-22 11:13:42 +0100586 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 /* There wasn't any room left, so we are throttled until
588 the buffer empties a bit */
589 request_unthrottle = 1;
590 }
591
592 if (request_unthrottle) {
593 priv->tx_throttled = 1; /* block writers */
594 schedule_work(&priv->unthrottle_work);
595 }
596
597 rc = count;
598exit:
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700599 if (rc < 0)
600 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return rc;
602}
603
604
Alan Cox9e70f312008-07-22 11:13:42 +0100605static void keyspan_pda_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606{
Ming Leicdc97792008-02-24 18:41:47 +0800607 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 struct keyspan_pda_private *priv;
609
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700610 port->write_urb_busy = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 priv = usb_get_serial_port_data(port);
612
613 /* queue up a wakeup at scheduler time */
614 schedule_work(&priv->wakeup_work);
615}
616
617
Alan Cox95da3102008-07-22 11:09:07 +0100618static int keyspan_pda_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619{
Alan Cox95da3102008-07-22 11:09:07 +0100620 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 struct keyspan_pda_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 /* used by n_tty.c for processing of tabs and such. Giving it our
624 conservative guess is probably good enough, but needs testing by
625 running a console through the device. */
Alan Cox9e70f312008-07-22 11:13:42 +0100626 return priv->tx_room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627}
628
629
Alan Cox95da3102008-07-22 11:09:07 +0100630static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Alan Cox95da3102008-07-22 11:09:07 +0100632 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 struct keyspan_pda_private *priv;
Alan Coxa5b6f602008-04-08 17:16:06 +0100634 unsigned long flags;
635 int ret = 0;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 priv = usb_get_serial_port_data(port);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
640 n_tty.c:normal_poll() ) that we're not writeable. */
Alan Coxa5b6f602008-04-08 17:16:06 +0100641
642 spin_lock_irqsave(&port->lock, flags);
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700643 if (port->write_urb_busy || priv->tx_throttled)
Alan Coxa5b6f602008-04-08 17:16:06 +0100644 ret = 256;
645 spin_unlock_irqrestore(&port->lock, flags);
646 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647}
648
649
Alan Cox95da3102008-07-22 11:09:07 +0100650static int keyspan_pda_open(struct tty_struct *tty,
651 struct usb_serial_port *port, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
653 struct usb_serial *serial = port->serial;
654 unsigned char room;
655 int rc = 0;
656 struct keyspan_pda_private *priv;
657
658 /* find out how much room is in the Tx ring */
659 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
660 6, /* write_room */
661 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
662 | USB_DIR_IN,
663 0, /* value */
664 0, /* index */
665 &room,
666 1,
667 2000);
668 if (rc < 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800669 dbg("%s - roomquery failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 goto error;
671 }
672 if (rc == 0) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800673 dbg("%s - roomquery returned 0 bytes", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 rc = -EIO;
675 goto error;
676 }
677 priv = usb_get_serial_port_data(port);
678 priv->tx_room = room;
679 priv->tx_throttled = room ? 0 : 1;
680
681 /* the normal serial device seems to always turn on DTR and RTS here,
682 so do the same */
Alan Cox95da3102008-07-22 11:09:07 +0100683 if (tty && (tty->termios->c_cflag & CBAUD))
Alan Cox9e70f312008-07-22 11:13:42 +0100684 keyspan_pda_set_modem_info(serial, (1<<7) | (1<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 else
686 keyspan_pda_set_modem_info(serial, 0);
687
688 /*Start reading from the device*/
689 port->interrupt_in_urb->dev = serial->dev;
690 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
691 if (rc) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800692 dbg("%s - usb_submit_urb(read int) failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 goto error;
694 }
695
696error:
697 return rc;
698}
699
700
Alan Cox95da3102008-07-22 11:09:07 +0100701static void keyspan_pda_close(struct tty_struct *tty,
702 struct usb_serial_port *port, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
704 struct usb_serial *serial = port->serial;
705
706 if (serial->dev) {
Alan Cox9e70f312008-07-22 11:13:42 +0100707 /* the normal serial device seems to always shut
708 off DTR and RTS now */
Alan Cox95da3102008-07-22 11:09:07 +0100709 if (tty->termios->c_cflag & HUPCL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 keyspan_pda_set_modem_info(serial, 0);
711
712 /* shutdown our bulk reads and writes */
713 usb_kill_urb(port->write_urb);
714 usb_kill_urb(port->interrupt_in_urb);
715 }
716}
717
718
719/* download the firmware to a "fake" device (pre-renumeration) */
Alan Cox9e70f312008-07-22 11:13:42 +0100720static int keyspan_pda_fake_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
722 int response;
David Woodhouse3edbf982008-05-30 15:15:13 +0300723 const char *fw_name;
724 const struct ihex_binrec *record;
725 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
727 /* download the firmware here ... */
728 response = ezusb_set_reset(serial, 1);
729
David Woodhouse3edbf982008-05-30 15:15:13 +0300730 if (0) { ; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731#ifdef KEYSPAN
David Woodhouse3edbf982008-05-30 15:15:13 +0300732 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
733 fw_name = "keyspan_pda/keyspan_pda.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734#endif
735#ifdef XIRCOM
David Woodhouse3edbf982008-05-30 15:15:13 +0300736 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
737 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
738 fw_name = "keyspan_pda/xircom_pgs.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739#endif
David Woodhouse3edbf982008-05-30 15:15:13 +0300740 else {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800741 err("%s: unknown vendor, aborting.", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return -ENODEV;
743 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300744 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
745 err("failed to load firmware \"%s\"\n", fw_name);
746 return -ENOENT;
747 }
748 record = (const struct ihex_binrec *)fw->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
David Woodhouse3edbf982008-05-30 15:15:13 +0300750 while (record) {
751 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 (unsigned char *)record->data,
David Woodhouse3edbf982008-05-30 15:15:13 +0300753 be16_to_cpu(record->len), 0xa0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 if (response < 0) {
755 err("ezusb_writememory failed for Keyspan PDA "
756 "firmware (%d %04X %p %d)",
David Woodhouse3edbf982008-05-30 15:15:13 +0300757 response, be32_to_cpu(record->addr),
758 record->data, be16_to_cpu(record->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 break;
760 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300761 record = ihex_next_binrec(record);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 }
David Woodhouse3edbf982008-05-30 15:15:13 +0300763 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 /* bring device out of reset. Renumeration will occur in a moment
765 and the new device will bind to the real driver */
766 response = ezusb_set_reset(serial, 0);
767
768 /* we want this device to fail to have a driver assigned to it. */
Alan Cox9e70f312008-07-22 11:13:42 +0100769 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770}
771
Alan Cox9e70f312008-07-22 11:13:42 +0100772static int keyspan_pda_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
774
775 struct keyspan_pda_private *priv;
776
777 /* allocate the private data structures for all ports. Well, for all
778 one ports. */
779
780 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
781 if (!priv)
Alan Cox9e70f312008-07-22 11:13:42 +0100782 return 1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 usb_set_serial_port_data(serial->port[0], priv);
784 init_waitqueue_head(&serial->port[0]->write_wait);
David Howellsc4028952006-11-22 14:57:56 +0000785 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
786 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
787 priv->serial = serial;
788 priv->port = serial->port[0];
Alan Cox9e70f312008-07-22 11:13:42 +0100789 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
Alan Cox9e70f312008-07-22 11:13:42 +0100792static void keyspan_pda_shutdown(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800794 dbg("%s", __func__);
Alan Cox9e70f312008-07-22 11:13:42 +0100795
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 kfree(usb_get_serial_port_data(serial->port[0]));
797}
798
799#ifdef KEYSPAN
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700800static struct usb_serial_driver keyspan_pda_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700801 .driver = {
802 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700803 .name = "keyspan_pda_pre",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700804 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700805 .description = "Keyspan PDA - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100806 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 .id_table = id_table_fake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 .num_ports = 1,
809 .attach = keyspan_pda_fake_startup,
810};
811#endif
812
813#ifdef XIRCOM
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700814static struct usb_serial_driver xircom_pgs_fake_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700815 .driver = {
816 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700817 .name = "xircom_no_firm",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700818 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700819 .description = "Xircom / Entregra PGS - (prerenumeration)",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100820 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 .id_table = id_table_fake_xircom,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 .num_ports = 1,
823 .attach = keyspan_pda_fake_startup,
824};
825#endif
826
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700827static struct usb_serial_driver keyspan_pda_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700828 .driver = {
829 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700830 .name = "keyspan_pda",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700831 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700832 .description = "Keyspan PDA",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100833 .usb_driver = &keyspan_pda_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 .id_table = id_table_std,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 .num_ports = 1,
836 .open = keyspan_pda_open,
837 .close = keyspan_pda_close,
838 .write = keyspan_pda_write,
839 .write_room = keyspan_pda_write_room,
840 .write_bulk_callback = keyspan_pda_write_bulk_callback,
841 .read_int_callback = keyspan_pda_rx_interrupt,
842 .chars_in_buffer = keyspan_pda_chars_in_buffer,
843 .throttle = keyspan_pda_rx_throttle,
844 .unthrottle = keyspan_pda_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 .set_termios = keyspan_pda_set_termios,
846 .break_ctl = keyspan_pda_break_ctl,
847 .tiocmget = keyspan_pda_tiocmget,
848 .tiocmset = keyspan_pda_tiocmset,
849 .attach = keyspan_pda_startup,
850 .shutdown = keyspan_pda_shutdown,
851};
852
853
Alan Cox9e70f312008-07-22 11:13:42 +0100854static int __init keyspan_pda_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
856 int retval;
857 retval = usb_serial_register(&keyspan_pda_device);
858 if (retval)
859 goto failed_pda_register;
860#ifdef KEYSPAN
861 retval = usb_serial_register(&keyspan_pda_fake_device);
862 if (retval)
863 goto failed_pda_fake_register;
864#endif
865#ifdef XIRCOM
866 retval = usb_serial_register(&xircom_pgs_fake_device);
867 if (retval)
868 goto failed_xircom_register;
869#endif
870 retval = usb_register(&keyspan_pda_driver);
871 if (retval)
872 goto failed_usb_register;
873 info(DRIVER_DESC " " DRIVER_VERSION);
874 return 0;
Alan Cox9e70f312008-07-22 11:13:42 +0100875failed_usb_register:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876#ifdef XIRCOM
877 usb_serial_deregister(&xircom_pgs_fake_device);
878failed_xircom_register:
879#endif /* XIRCOM */
880#ifdef KEYSPAN
881 usb_serial_deregister(&keyspan_pda_fake_device);
882#endif
883#ifdef KEYSPAN
884failed_pda_fake_register:
885#endif
886 usb_serial_deregister(&keyspan_pda_device);
887failed_pda_register:
888 return retval;
889}
890
891
Alan Cox9e70f312008-07-22 11:13:42 +0100892static void __exit keyspan_pda_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
Alan Cox9e70f312008-07-22 11:13:42 +0100894 usb_deregister(&keyspan_pda_driver);
895 usb_serial_deregister(&keyspan_pda_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896#ifdef KEYSPAN
Alan Cox9e70f312008-07-22 11:13:42 +0100897 usb_serial_deregister(&keyspan_pda_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898#endif
899#ifdef XIRCOM
Alan Cox9e70f312008-07-22 11:13:42 +0100900 usb_serial_deregister(&xircom_pgs_fake_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901#endif
902}
903
904
905module_init(keyspan_pda_init);
906module_exit(keyspan_pda_exit);
907
Alan Cox9e70f312008-07-22 11:13:42 +0100908MODULE_AUTHOR(DRIVER_AUTHOR);
909MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910MODULE_LICENSE("GPL");
911
912module_param(debug, bool, S_IRUGO | S_IWUSR);
913MODULE_PARM_DESC(debug, "Debug enabled or not");
914