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 */
23 MODULE_DEVICE_TABLE(usb, id_table);
25 #define URB_TRANSFER_BUFFER_SIZE 4096
26 #define NUM_READ_URBS 4
27 #define NUM_WRITE_URBS 4
28 #define NUM_BULK_EPS 3
29 #define MAX_BULK_EPS 6
31 /* if overridden by the user, then use their value for the size of the
32 * read and write urbs, and the number of endpoints */
33 static int buffer_size = URB_TRANSFER_BUFFER_SIZE;
34 static int endpoints = NUM_BULK_EPS;
36 struct airprime_private {
40 struct urb *read_urbp[NUM_READ_URBS];
42 /* Settings for the port */
43 int rts_state; /* Handshaking pins (outputs) */
45 int cts_state; /* Handshaking pins (inputs) */
51 static int airprime_send_setup(struct usb_serial_port *port)
53 struct usb_serial *serial = port->serial;
54 struct airprime_private *priv;
58 if (port->number != 0)
61 priv = usb_get_serial_port_data(port);
70 return usb_control_msg(serial->dev,
71 usb_rcvctrlpipe(serial->dev, 0),
72 0x22, 0x21, val, 0, NULL, 0,
73 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;
85 int status = urb->status;
87 dbg("%s - port %d", __func__, port->number);
90 dbg("%s - nonzero read bulk status received: %d",
94 usb_serial_debug_data(debug, &port->dev, __func__,
95 urb->actual_length, data);
98 if (tty && urb->actual_length) {
99 tty_insert_flip_string(tty, data, urb->actual_length);
100 tty_flip_buffer_push(tty);
103 result = usb_submit_urb(urb, GFP_ATOMIC);
106 "%s - failed resubmitting read urb, error %d\n",
111 static void airprime_write_bulk_callback(struct urb *urb)
113 struct usb_serial_port *port = urb->context;
114 struct airprime_private *priv = usb_get_serial_port_data(port);
115 int status = urb->status;
118 dbg("%s - port %d", __func__, port->number);
120 /* free up the transfer buffer, as usb_free_urb() does not do this */
121 kfree(urb->transfer_buffer);
124 dbg("%s - nonzero write bulk status received: %d",
126 spin_lock_irqsave(&priv->lock, flags);
127 --priv->outstanding_urbs;
128 spin_unlock_irqrestore(&priv->lock, flags);
130 usb_serial_port_softint(port);
133 static int airprime_open(struct tty_struct *tty, struct usb_serial_port *port,
136 struct airprime_private *priv = usb_get_serial_port_data(port);
137 struct usb_serial *serial = port->serial;
143 dbg("%s - port %d", __func__, port->number);
145 /* initialize our private data structure if it isn't already created */
147 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
152 spin_lock_init(&priv->lock);
153 usb_set_serial_port_data(port, priv);
156 /* Set some sane defaults */
160 for (i = 0; i < NUM_READ_URBS; ++i) {
161 buffer = kmalloc(buffer_size, GFP_KERNEL);
163 dev_err(&port->dev, "%s - out of memory.\n",
168 urb = usb_alloc_urb(0, GFP_KERNEL);
171 dev_err(&port->dev, "%s - no more urbs?\n",
176 usb_fill_bulk_urb(urb, serial->dev,
177 usb_rcvbulkpipe(serial->dev,
178 port->bulk_out_endpointAddress),
180 airprime_read_bulk_callback, port);
181 result = usb_submit_urb(urb, GFP_KERNEL);
186 "%s - failed submitting read urb %d for port %d, error %d\n",
187 __func__, i, port->number, result);
190 /* remember this urb so we can kill it when the
192 priv->read_urbp[i] = urb;
195 airprime_send_setup(port);
200 /* some error happened, cancel any submitted urbs and clean up
201 anything that got allocated successfully */
204 urb = priv->read_urbp[i];
205 buffer = urb->transfer_buffer;
215 static void airprime_close(struct tty_struct *tty,
216 struct usb_serial_port *port, struct file *filp)
218 struct airprime_private *priv = usb_get_serial_port_data(port);
221 dbg("%s - port %d", __func__, port->number);
226 mutex_lock(&port->serial->disc_mutex);
227 if (!port->serial->disconnected)
228 airprime_send_setup(port);
229 mutex_unlock(&port->serial->disc_mutex);
231 for (i = 0; i < NUM_READ_URBS; ++i) {
232 usb_kill_urb(priv->read_urbp[i]);
233 kfree(priv->read_urbp[i]->transfer_buffer);
234 usb_free_urb(priv->read_urbp[i]);
237 /* free up private structure */
239 usb_set_serial_port_data(port, NULL);
242 static int airprime_write(struct tty_struct *tty, struct usb_serial_port *port,
243 const unsigned char *buf, int count)
245 struct airprime_private *priv = usb_get_serial_port_data(port);
246 struct usb_serial *serial = port->serial;
248 unsigned char *buffer;
251 dbg("%s - port %d", __func__, port->number);
253 spin_lock_irqsave(&priv->lock, flags);
254 if (priv->outstanding_urbs > NUM_WRITE_URBS) {
255 spin_unlock_irqrestore(&priv->lock, flags);
256 dbg("%s - write limit hit\n", __func__);
259 spin_unlock_irqrestore(&priv->lock, flags);
260 buffer = kmalloc(count, GFP_ATOMIC);
262 dev_err(&port->dev, "out of memory\n");
265 urb = usb_alloc_urb(0, GFP_ATOMIC);
267 dev_err(&port->dev, "no more free urbs\n");
271 memcpy(buffer, buf, count);
273 usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
275 usb_fill_bulk_urb(urb, serial->dev,
276 usb_sndbulkpipe(serial->dev,
277 port->bulk_out_endpointAddress),
279 airprime_write_bulk_callback, port);
281 /* send it down the pipe */
282 status = usb_submit_urb(urb, GFP_ATOMIC);
285 "%s - usb_submit_urb(write bulk) failed with status = %d\n",
290 spin_lock_irqsave(&priv->lock, flags);
291 ++priv->outstanding_urbs;
292 spin_unlock_irqrestore(&priv->lock, flags);
294 /* we are done with this urb, so let the host driver
295 * really free it when it is finished with it */
300 static struct usb_driver airprime_driver = {
302 .probe = usb_serial_probe,
303 .disconnect = usb_serial_disconnect,
304 .id_table = id_table,
308 static struct usb_serial_driver airprime_device = {
310 .owner = THIS_MODULE,
313 .usb_driver = &airprime_driver,
314 .id_table = id_table,
315 .open = airprime_open,
316 .close = airprime_close,
317 .write = airprime_write,
320 static int __init airprime_init(void)
324 airprime_device.num_ports = endpoints;
325 if (endpoints < 0 || endpoints >= MAX_BULK_EPS)
326 airprime_device.num_ports = NUM_BULK_EPS;
328 retval = usb_serial_register(&airprime_device);
331 retval = usb_register(&airprime_driver);
333 usb_serial_deregister(&airprime_device);
337 static void __exit airprime_exit(void)
341 usb_deregister(&airprime_driver);
342 usb_serial_deregister(&airprime_device);
345 module_init(airprime_init);
346 module_exit(airprime_exit);
347 MODULE_LICENSE("GPL");
349 module_param(debug, bool, S_IRUGO | S_IWUSR);
350 MODULE_PARM_DESC(debug, "Debug enabled");
351 module_param(buffer_size, int, 0);
352 MODULE_PARM_DESC(buffer_size,
353 "Size of the transfer buffers in bytes (default 4096)");
354 module_param(endpoints, int, 0);
355 MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");