2 USB Driver layer for GSM modems
4 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de>
6 This driver is free software; you can redistribute it and/or modify
7 it under the terms of Version 2 of the GNU General Public License as
8 published by the Free Software Foundation.
10 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
12 History: see the git log.
14 Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
16 This driver exists because the "normal" serial driver doesn't work too well
17 with GSM modems. Issues:
18 - data loss -- one single Receive URB is not nearly enough
19 - controlling the baud rate doesn't make sense
22 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
23 #define DRIVER_DESC "USB Driver for GSM modems"
25 #include <linux/kernel.h>
26 #include <linux/jiffies.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/tty.h>
30 #include <linux/tty_flip.h>
31 #include <linux/module.h>
32 #include <linux/bitops.h>
33 #include <linux/uaccess.h>
34 #include <linux/usb.h>
35 #include <linux/usb/serial.h>
36 #include <linux/serial.h>
40 * Generate DTR/RTS signals on the port using the SET_CONTROL_LINE_STATE request
43 static int usb_wwan_send_setup(struct usb_serial_port *port)
45 struct usb_serial *serial = port->serial;
46 struct usb_wwan_port_private *portdata;
51 portdata = usb_get_serial_port_data(port);
53 if (portdata->dtr_state)
55 if (portdata->rts_state)
58 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
60 res = usb_autopm_get_interface(serial->interface);
64 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
65 0x22, 0x21, val, ifnum, NULL, 0,
66 USB_CTRL_SET_TIMEOUT);
68 usb_autopm_put_interface(port->serial->interface);
73 void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
75 struct usb_wwan_port_private *portdata;
76 struct usb_wwan_intf_private *intfdata;
78 intfdata = usb_get_serial_data(port->serial);
80 if (!intfdata->use_send_setup)
83 portdata = usb_get_serial_port_data(port);
85 portdata->rts_state = on;
86 portdata->dtr_state = on;
88 usb_wwan_send_setup(port);
90 EXPORT_SYMBOL(usb_wwan_dtr_rts);
92 int usb_wwan_tiocmget(struct tty_struct *tty)
94 struct usb_serial_port *port = tty->driver_data;
96 struct usb_wwan_port_private *portdata;
98 portdata = usb_get_serial_port_data(port);
100 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
101 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
102 ((portdata->cts_state) ? TIOCM_CTS : 0) |
103 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
104 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
105 ((portdata->ri_state) ? TIOCM_RNG : 0);
109 EXPORT_SYMBOL(usb_wwan_tiocmget);
111 int usb_wwan_tiocmset(struct tty_struct *tty,
112 unsigned int set, unsigned int clear)
114 struct usb_serial_port *port = tty->driver_data;
115 struct usb_wwan_port_private *portdata;
116 struct usb_wwan_intf_private *intfdata;
118 portdata = usb_get_serial_port_data(port);
119 intfdata = usb_get_serial_data(port->serial);
121 if (!intfdata->use_send_setup)
124 /* FIXME: what locks portdata fields ? */
126 portdata->rts_state = 1;
128 portdata->dtr_state = 1;
130 if (clear & TIOCM_RTS)
131 portdata->rts_state = 0;
132 if (clear & TIOCM_DTR)
133 portdata->dtr_state = 0;
134 return usb_wwan_send_setup(port);
136 EXPORT_SYMBOL(usb_wwan_tiocmset);
138 static int get_serial_info(struct usb_serial_port *port,
139 struct serial_struct __user *retinfo)
141 struct serial_struct tmp;
146 memset(&tmp, 0, sizeof(tmp));
147 tmp.line = port->minor;
148 tmp.port = port->port_number;
149 tmp.baud_base = tty_get_baud_rate(port->port.tty);
150 tmp.close_delay = port->port.close_delay / 10;
151 tmp.closing_wait = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
152 ASYNC_CLOSING_WAIT_NONE :
153 port->port.closing_wait / 10;
155 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
160 static int set_serial_info(struct usb_serial_port *port,
161 struct serial_struct __user *newinfo)
163 struct serial_struct new_serial;
164 unsigned int closing_wait, close_delay;
167 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
170 close_delay = new_serial.close_delay * 10;
171 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
172 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
174 mutex_lock(&port->port.mutex);
176 if (!capable(CAP_SYS_ADMIN)) {
177 if ((close_delay != port->port.close_delay) ||
178 (closing_wait != port->port.closing_wait))
181 retval = -EOPNOTSUPP;
183 port->port.close_delay = close_delay;
184 port->port.closing_wait = closing_wait;
187 mutex_unlock(&port->port.mutex);
191 int usb_wwan_ioctl(struct tty_struct *tty,
192 unsigned int cmd, unsigned long arg)
194 struct usb_serial_port *port = tty->driver_data;
196 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
200 return get_serial_info(port,
201 (struct serial_struct __user *) arg);
203 return set_serial_info(port,
204 (struct serial_struct __user *) arg);
209 dev_dbg(&port->dev, "%s arg not supported\n", __func__);
213 EXPORT_SYMBOL(usb_wwan_ioctl);
215 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
216 const unsigned char *buf, int count)
218 struct usb_wwan_port_private *portdata;
219 struct usb_wwan_intf_private *intfdata;
222 struct urb *this_urb = NULL; /* spurious */
226 portdata = usb_get_serial_port_data(port);
227 intfdata = usb_get_serial_data(port->serial);
229 dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
233 for (i = 0; left > 0 && i < N_OUT_URB; i++) {
235 if (todo > OUT_BUFLEN)
238 this_urb = portdata->out_urbs[i];
239 if (test_and_set_bit(i, &portdata->out_busy)) {
240 if (time_before(jiffies,
241 portdata->tx_start_time[i] + 10 * HZ))
243 usb_unlink_urb(this_urb);
246 dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
247 usb_pipeendpoint(this_urb->pipe), i);
249 err = usb_autopm_get_interface_async(port->serial->interface);
251 clear_bit(i, &portdata->out_busy);
256 memcpy(this_urb->transfer_buffer, buf, todo);
257 this_urb->transfer_buffer_length = todo;
259 spin_lock_irqsave(&intfdata->susp_lock, flags);
260 if (intfdata->suspended) {
261 usb_anchor_urb(this_urb, &portdata->delayed);
262 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
264 intfdata->in_flight++;
265 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
266 err = usb_submit_urb(this_urb, GFP_ATOMIC);
269 "%s: submit urb %d failed: %d\n",
271 clear_bit(i, &portdata->out_busy);
272 spin_lock_irqsave(&intfdata->susp_lock, flags);
273 intfdata->in_flight--;
274 spin_unlock_irqrestore(&intfdata->susp_lock,
276 usb_autopm_put_interface_async(port->serial->interface);
281 portdata->tx_start_time[i] = jiffies;
287 dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
290 EXPORT_SYMBOL(usb_wwan_write);
292 static void usb_wwan_indat_callback(struct urb *urb)
296 struct usb_serial_port *port;
298 unsigned char *data = urb->transfer_buffer;
299 int status = urb->status;
301 endpoint = usb_pipeendpoint(urb->pipe);
306 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
307 __func__, status, endpoint);
309 /* don't resubmit on fatal errors */
310 if (status == -ESHUTDOWN || status == -ENOENT)
313 if (urb->actual_length) {
314 tty_insert_flip_string(&port->port, data,
316 tty_flip_buffer_push(&port->port);
318 dev_dbg(dev, "%s: empty read urb received\n", __func__);
320 /* Resubmit urb so we continue receiving */
321 err = usb_submit_urb(urb, GFP_ATOMIC);
323 if (err != -EPERM && err != -ENODEV) {
324 dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
326 /* busy also in error unless we are killed */
327 usb_mark_last_busy(port->serial->dev);
330 usb_mark_last_busy(port->serial->dev);
334 static void usb_wwan_outdat_callback(struct urb *urb)
336 struct usb_serial_port *port;
337 struct usb_wwan_port_private *portdata;
338 struct usb_wwan_intf_private *intfdata;
342 intfdata = usb_get_serial_data(port->serial);
344 usb_serial_port_softint(port);
345 usb_autopm_put_interface_async(port->serial->interface);
346 portdata = usb_get_serial_port_data(port);
347 spin_lock(&intfdata->susp_lock);
348 intfdata->in_flight--;
349 spin_unlock(&intfdata->susp_lock);
351 for (i = 0; i < N_OUT_URB; ++i) {
352 if (portdata->out_urbs[i] == urb) {
353 smp_mb__before_atomic();
354 clear_bit(i, &portdata->out_busy);
360 int usb_wwan_write_room(struct tty_struct *tty)
362 struct usb_serial_port *port = tty->driver_data;
363 struct usb_wwan_port_private *portdata;
366 struct urb *this_urb;
368 portdata = usb_get_serial_port_data(port);
370 for (i = 0; i < N_OUT_URB; i++) {
371 this_urb = portdata->out_urbs[i];
372 if (this_urb && !test_bit(i, &portdata->out_busy))
373 data_len += OUT_BUFLEN;
376 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
379 EXPORT_SYMBOL(usb_wwan_write_room);
381 int usb_wwan_chars_in_buffer(struct tty_struct *tty)
383 struct usb_serial_port *port = tty->driver_data;
384 struct usb_wwan_port_private *portdata;
387 struct urb *this_urb;
389 portdata = usb_get_serial_port_data(port);
391 for (i = 0; i < N_OUT_URB; i++) {
392 this_urb = portdata->out_urbs[i];
393 /* FIXME: This locking is insufficient as this_urb may
394 go unused during the test */
395 if (this_urb && test_bit(i, &portdata->out_busy))
396 data_len += this_urb->transfer_buffer_length;
398 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
401 EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
403 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
405 struct usb_wwan_port_private *portdata;
406 struct usb_wwan_intf_private *intfdata;
407 struct usb_serial *serial = port->serial;
411 portdata = usb_get_serial_port_data(port);
412 intfdata = usb_get_serial_data(serial);
414 if (port->interrupt_in_urb) {
415 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
417 dev_err(&port->dev, "%s: submit int urb failed: %d\n",
422 /* Start reading from the IN endpoint */
423 for (i = 0; i < N_IN_URB; i++) {
424 urb = portdata->in_urbs[i];
427 err = usb_submit_urb(urb, GFP_KERNEL);
430 "%s: submit read urb %d failed: %d\n",
435 spin_lock_irq(&intfdata->susp_lock);
436 if (++intfdata->open_ports == 1)
437 serial->interface->needs_remote_wakeup = 1;
438 spin_unlock_irq(&intfdata->susp_lock);
439 /* this balances a get in the generic USB serial code */
440 usb_autopm_put_interface(serial->interface);
444 EXPORT_SYMBOL(usb_wwan_open);
446 static void unbusy_queued_urb(struct urb *urb,
447 struct usb_wwan_port_private *portdata)
451 for (i = 0; i < N_OUT_URB; i++) {
452 if (urb == portdata->out_urbs[i]) {
453 clear_bit(i, &portdata->out_busy);
459 void usb_wwan_close(struct usb_serial_port *port)
462 struct usb_serial *serial = port->serial;
463 struct usb_wwan_port_private *portdata;
464 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
467 portdata = usb_get_serial_port_data(port);
470 * Need to take susp_lock to make sure port is not already being
471 * resumed, but no need to hold it due to initialized
473 spin_lock_irq(&intfdata->susp_lock);
474 if (--intfdata->open_ports == 0)
475 serial->interface->needs_remote_wakeup = 0;
476 spin_unlock_irq(&intfdata->susp_lock);
479 urb = usb_get_from_anchor(&portdata->delayed);
482 unbusy_queued_urb(urb, portdata);
483 usb_autopm_put_interface_async(serial->interface);
486 for (i = 0; i < N_IN_URB; i++)
487 usb_kill_urb(portdata->in_urbs[i]);
488 for (i = 0; i < N_OUT_URB; i++)
489 usb_kill_urb(portdata->out_urbs[i]);
490 usb_kill_urb(port->interrupt_in_urb);
492 usb_autopm_get_interface_no_resume(serial->interface);
494 EXPORT_SYMBOL(usb_wwan_close);
496 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
498 int dir, void *ctx, char *buf, int len,
499 void (*callback) (struct urb *))
501 struct usb_serial *serial = port->serial;
502 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
505 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
509 usb_fill_bulk_urb(urb, serial->dev,
510 usb_sndbulkpipe(serial->dev, endpoint) | dir,
511 buf, len, callback, ctx);
513 if (intfdata->use_zlp && dir == USB_DIR_OUT)
514 urb->transfer_flags |= URB_ZERO_PACKET;
519 int usb_wwan_port_probe(struct usb_serial_port *port)
521 struct usb_wwan_port_private *portdata;
526 if (!port->bulk_in_size || !port->bulk_out_size)
529 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
533 init_usb_anchor(&portdata->delayed);
535 for (i = 0; i < N_IN_URB; i++) {
536 buffer = (u8 *)__get_free_page(GFP_KERNEL);
539 portdata->in_buffer[i] = buffer;
541 urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
544 usb_wwan_indat_callback);
545 portdata->in_urbs[i] = urb;
548 for (i = 0; i < N_OUT_URB; i++) {
549 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
551 goto bail_out_error2;
552 portdata->out_buffer[i] = buffer;
554 urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
557 usb_wwan_outdat_callback);
558 portdata->out_urbs[i] = urb;
561 usb_set_serial_port_data(port, portdata);
566 for (i = 0; i < N_OUT_URB; i++) {
567 usb_free_urb(portdata->out_urbs[i]);
568 kfree(portdata->out_buffer[i]);
571 for (i = 0; i < N_IN_URB; i++) {
572 usb_free_urb(portdata->in_urbs[i]);
573 free_page((unsigned long)portdata->in_buffer[i]);
579 EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
581 int usb_wwan_port_remove(struct usb_serial_port *port)
584 struct usb_wwan_port_private *portdata;
586 portdata = usb_get_serial_port_data(port);
587 usb_set_serial_port_data(port, NULL);
589 for (i = 0; i < N_IN_URB; i++) {
590 usb_free_urb(portdata->in_urbs[i]);
591 free_page((unsigned long)portdata->in_buffer[i]);
593 for (i = 0; i < N_OUT_URB; i++) {
594 usb_free_urb(portdata->out_urbs[i]);
595 kfree(portdata->out_buffer[i]);
602 EXPORT_SYMBOL(usb_wwan_port_remove);
605 static void stop_urbs(struct usb_serial *serial)
608 struct usb_serial_port *port;
609 struct usb_wwan_port_private *portdata;
611 for (i = 0; i < serial->num_ports; ++i) {
612 port = serial->port[i];
613 portdata = usb_get_serial_port_data(port);
616 for (j = 0; j < N_IN_URB; j++)
617 usb_kill_urb(portdata->in_urbs[j]);
618 for (j = 0; j < N_OUT_URB; j++)
619 usb_kill_urb(portdata->out_urbs[j]);
620 usb_kill_urb(port->interrupt_in_urb);
624 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
626 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
628 spin_lock_irq(&intfdata->susp_lock);
629 if (PMSG_IS_AUTO(message)) {
630 if (intfdata->in_flight) {
631 spin_unlock_irq(&intfdata->susp_lock);
635 intfdata->suspended = 1;
636 spin_unlock_irq(&intfdata->susp_lock);
642 EXPORT_SYMBOL(usb_wwan_suspend);
644 /* Caller must hold susp_lock. */
645 static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
647 struct usb_serial *serial = port->serial;
648 struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
649 struct usb_wwan_port_private *portdata;
654 portdata = usb_get_serial_port_data(port);
657 urb = usb_get_from_anchor(&portdata->delayed);
661 err = usb_submit_urb(urb, GFP_ATOMIC);
663 dev_err(&port->dev, "%s: submit urb failed: %d\n",
666 unbusy_queued_urb(urb, portdata);
667 usb_autopm_put_interface_async(serial->interface);
679 int usb_wwan_resume(struct usb_serial *serial)
682 struct usb_serial_port *port;
683 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
684 struct usb_wwan_port_private *portdata;
689 spin_lock_irq(&intfdata->susp_lock);
690 for (i = 0; i < serial->num_ports; i++) {
691 port = serial->port[i];
693 if (!tty_port_initialized(&port->port))
696 portdata = usb_get_serial_port_data(port);
698 if (port->interrupt_in_urb) {
699 err = usb_submit_urb(port->interrupt_in_urb,
703 "%s: submit int urb failed: %d\n",
709 err = usb_wwan_submit_delayed_urbs(port);
713 for (j = 0; j < N_IN_URB; j++) {
714 urb = portdata->in_urbs[j];
715 err = usb_submit_urb(urb, GFP_ATOMIC);
718 "%s: submit read urb %d failed: %d\n",
724 intfdata->suspended = 0;
725 spin_unlock_irq(&intfdata->susp_lock);
732 EXPORT_SYMBOL(usb_wwan_resume);
735 MODULE_AUTHOR(DRIVER_AUTHOR);
736 MODULE_DESCRIPTION(DRIVER_DESC);
737 MODULE_LICENSE("GPL");