2 * AirPrime CDMA Wireless Serial USB driver
4 * Copyright (C) 2005-2006 Greg Kroah-Hartman <gregkh@suse.de>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/tty.h>
14 #include <linux/tty_flip.h>
15 #include <linux/module.h>
16 #include <linux/usb.h>
17 #include <linux/usb/serial.h>
19 static struct usb_device_id id_table [] = {
20 { USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera Wireless KPC650/Passport */
21 { USB_DEVICE(0x413c, 0x8115) }, /* Dell Wireless HSDPA 5500 */
24 MODULE_DEVICE_TABLE(usb, id_table);
26 #define URB_TRANSFER_BUFFER_SIZE 4096
27 #define NUM_READ_URBS 4
28 #define NUM_WRITE_URBS 4
29 #define NUM_BULK_EPS 3
30 #define MAX_BULK_EPS 6
32 /* if overridden by the user, then use their value for the size of the
33 * read and write urbs, and the number of endpoints */
34 static int buffer_size = URB_TRANSFER_BUFFER_SIZE;
35 static int endpoints = NUM_BULK_EPS;
37 struct airprime_private {
41 struct urb *read_urbp[NUM_READ_URBS];
43 /* Settings for the port */
44 int rts_state; /* Handshaking pins (outputs) */
46 int cts_state; /* Handshaking pins (inputs) */
52 static int airprime_send_setup(struct usb_serial_port *port)
54 struct usb_serial *serial = port->serial;
55 struct airprime_private *priv;
57 dbg("%s", __FUNCTION__);
59 if (port->number != 0)
62 priv = usb_get_serial_port_data(port);
71 return usb_control_msg(serial->dev,
72 usb_rcvctrlpipe(serial->dev, 0),
73 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
79 static void airprime_read_bulk_callback(struct urb *urb)
81 struct usb_serial_port *port = urb->context;
82 unsigned char *data = urb->transfer_buffer;
83 struct tty_struct *tty;
86 dbg("%s - port %d", __FUNCTION__, port->number);
89 dbg("%s - nonzero read bulk status received: %d",
90 __FUNCTION__, urb->status);
93 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
96 if (tty && urb->actual_length) {
97 tty_insert_flip_string (tty, data, urb->actual_length);
98 tty_flip_buffer_push (tty);
101 result = usb_submit_urb (urb, GFP_ATOMIC);
103 dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
104 __FUNCTION__, result);
108 static void airprime_write_bulk_callback(struct urb *urb)
110 struct usb_serial_port *port = urb->context;
111 struct airprime_private *priv = usb_get_serial_port_data(port);
114 dbg("%s - port %d", __FUNCTION__, port->number);
116 /* free up the transfer buffer, as usb_free_urb() does not do this */
117 kfree (urb->transfer_buffer);
120 dbg("%s - nonzero write bulk status received: %d",
121 __FUNCTION__, urb->status);
122 spin_lock_irqsave(&priv->lock, flags);
123 --priv->outstanding_urbs;
124 spin_unlock_irqrestore(&priv->lock, flags);
126 usb_serial_port_softint(port);
129 static int airprime_open(struct usb_serial_port *port, struct file *filp)
131 struct airprime_private *priv = usb_get_serial_port_data(port);
132 struct usb_serial *serial = port->serial;
138 dbg("%s - port %d", __FUNCTION__, port->number);
140 /* initialize our private data structure if it isn't already created */
142 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
147 spin_lock_init(&priv->lock);
148 usb_set_serial_port_data(port, priv);
151 /* Set some sane defaults */
155 for (i = 0; i < NUM_READ_URBS; ++i) {
156 buffer = kmalloc(buffer_size, GFP_KERNEL);
158 dev_err(&port->dev, "%s - out of memory.\n",
163 urb = usb_alloc_urb(0, GFP_KERNEL);
166 dev_err(&port->dev, "%s - no more urbs?\n",
171 usb_fill_bulk_urb(urb, serial->dev,
172 usb_rcvbulkpipe(serial->dev,
173 port->bulk_out_endpointAddress),
175 airprime_read_bulk_callback, port);
176 result = usb_submit_urb(urb, GFP_KERNEL);
181 "%s - failed submitting read urb %d for port %d, error %d\n",
182 __FUNCTION__, i, port->number, result);
185 /* remember this urb so we can kill it when the port is closed */
186 priv->read_urbp[i] = urb;
189 airprime_send_setup(port);
194 /* some error happened, cancel any submitted urbs and clean up anything that
195 got allocated successfully */
198 urb = priv->read_urbp[i];
199 buffer = urb->transfer_buffer;
209 static void airprime_close(struct usb_serial_port *port, struct file * filp)
211 struct airprime_private *priv = usb_get_serial_port_data(port);
214 dbg("%s - port %d", __FUNCTION__, port->number);
219 airprime_send_setup(port);
221 for (i = 0; i < NUM_READ_URBS; ++i) {
222 usb_kill_urb (priv->read_urbp[i]);
223 kfree (priv->read_urbp[i]->transfer_buffer);
224 usb_free_urb (priv->read_urbp[i]);
227 /* free up private structure */
229 usb_set_serial_port_data(port, NULL);
232 static int airprime_write(struct usb_serial_port *port,
233 const unsigned char *buf, int count)
235 struct airprime_private *priv = usb_get_serial_port_data(port);
236 struct usb_serial *serial = port->serial;
238 unsigned char *buffer;
241 dbg("%s - port %d", __FUNCTION__, port->number);
243 spin_lock_irqsave(&priv->lock, flags);
244 if (priv->outstanding_urbs > NUM_WRITE_URBS) {
245 spin_unlock_irqrestore(&priv->lock, flags);
246 dbg("%s - write limit hit\n", __FUNCTION__);
249 spin_unlock_irqrestore(&priv->lock, flags);
250 buffer = kmalloc(count, GFP_ATOMIC);
252 dev_err(&port->dev, "out of memory\n");
255 urb = usb_alloc_urb(0, GFP_ATOMIC);
257 dev_err(&port->dev, "no more free urbs\n");
261 memcpy (buffer, buf, count);
263 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, buffer);
265 usb_fill_bulk_urb(urb, serial->dev,
266 usb_sndbulkpipe(serial->dev,
267 port->bulk_out_endpointAddress),
269 airprime_write_bulk_callback, port);
271 /* send it down the pipe */
272 status = usb_submit_urb(urb, GFP_ATOMIC);
275 "%s - usb_submit_urb(write bulk) failed with status = %d\n",
276 __FUNCTION__, status);
280 spin_lock_irqsave(&priv->lock, flags);
281 ++priv->outstanding_urbs;
282 spin_unlock_irqrestore(&priv->lock, flags);
284 /* we are done with this urb, so let the host driver
285 * really free it when it is finished with it */
290 static struct usb_driver airprime_driver = {
292 .probe = usb_serial_probe,
293 .disconnect = usb_serial_disconnect,
294 .id_table = id_table,
298 static struct usb_serial_driver airprime_device = {
300 .owner = THIS_MODULE,
303 .usb_driver = &airprime_driver,
304 .id_table = id_table,
305 .num_interrupt_in = NUM_DONT_CARE,
306 .num_bulk_in = NUM_DONT_CARE,
307 .num_bulk_out = NUM_DONT_CARE,
308 .open = airprime_open,
309 .close = airprime_close,
310 .write = airprime_write,
313 static int __init airprime_init(void)
317 airprime_device.num_ports =
318 (endpoints > 0 && endpoints <= MAX_BULK_EPS) ? endpoints : NUM_BULK_EPS;
319 retval = usb_serial_register(&airprime_device);
322 retval = usb_register(&airprime_driver);
324 usb_serial_deregister(&airprime_device);
328 static void __exit airprime_exit(void)
330 dbg("%s", __FUNCTION__);
332 usb_deregister(&airprime_driver);
333 usb_serial_deregister(&airprime_device);
336 module_init(airprime_init);
337 module_exit(airprime_exit);
338 MODULE_LICENSE("GPL");
340 module_param(debug, bool, S_IRUGO | S_IWUSR);
341 MODULE_PARM_DESC(debug, "Debug enabled");
342 module_param(buffer_size, int, 0);
343 MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers in bytes (default 4096)");
344 module_param(endpoints, int, 0);
345 MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");