1 // SPDX-License-Identifier: GPL-2.0
3 USB Driver layer for GSM modems
5 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de>
7 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
9 History: see the git log.
11 Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
13 This driver exists because the "normal" serial driver doesn't work too well
14 with GSM modems. Issues:
15 - data loss -- one single Receive URB is not nearly enough
16 - controlling the baud rate doesn't make sense
19 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
20 #define DRIVER_DESC "USB Driver for GSM modems"
22 #include <linux/kernel.h>
23 #include <linux/jiffies.h>
24 #include <linux/errno.h>
25 #include <linux/slab.h>
26 #include <linux/tty.h>
27 #include <linux/tty_flip.h>
28 #include <linux/module.h>
29 #include <linux/bitops.h>
30 #include <linux/uaccess.h>
31 #include <linux/usb.h>
32 #include <linux/usb/serial.h>
33 #include <linux/serial.h>
37 * Generate DTR/RTS signals on the port using the SET_CONTROL_LINE_STATE request
40 static int usb_wwan_send_setup(struct usb_serial_port *port)
42 struct usb_serial *serial = port->serial;
43 struct usb_wwan_port_private *portdata;
48 portdata = usb_get_serial_port_data(port);
50 if (portdata->dtr_state)
52 if (portdata->rts_state)
55 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
57 res = usb_autopm_get_interface(serial->interface);
61 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
62 0x22, 0x21, val, ifnum, NULL, 0,
63 USB_CTRL_SET_TIMEOUT);
65 usb_autopm_put_interface(port->serial->interface);
70 void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
72 struct usb_wwan_port_private *portdata;
73 struct usb_wwan_intf_private *intfdata;
75 intfdata = usb_get_serial_data(port->serial);
77 if (!intfdata->use_send_setup)
80 portdata = usb_get_serial_port_data(port);
82 portdata->rts_state = on;
83 portdata->dtr_state = on;
85 usb_wwan_send_setup(port);
87 EXPORT_SYMBOL(usb_wwan_dtr_rts);
89 int usb_wwan_tiocmget(struct tty_struct *tty)
91 struct usb_serial_port *port = tty->driver_data;
93 struct usb_wwan_port_private *portdata;
95 portdata = usb_get_serial_port_data(port);
97 value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
98 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
99 ((portdata->cts_state) ? TIOCM_CTS : 0) |
100 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
101 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
102 ((portdata->ri_state) ? TIOCM_RNG : 0);
106 EXPORT_SYMBOL(usb_wwan_tiocmget);
108 int usb_wwan_tiocmset(struct tty_struct *tty,
109 unsigned int set, unsigned int clear)
111 struct usb_serial_port *port = tty->driver_data;
112 struct usb_wwan_port_private *portdata;
113 struct usb_wwan_intf_private *intfdata;
115 portdata = usb_get_serial_port_data(port);
116 intfdata = usb_get_serial_data(port->serial);
118 if (!intfdata->use_send_setup)
121 /* FIXME: what locks portdata fields ? */
123 portdata->rts_state = 1;
125 portdata->dtr_state = 1;
127 if (clear & TIOCM_RTS)
128 portdata->rts_state = 0;
129 if (clear & TIOCM_DTR)
130 portdata->dtr_state = 0;
131 return usb_wwan_send_setup(port);
133 EXPORT_SYMBOL(usb_wwan_tiocmset);
135 static int get_serial_info(struct usb_serial_port *port,
136 struct serial_struct __user *retinfo)
138 struct serial_struct tmp;
140 memset(&tmp, 0, sizeof(tmp));
141 tmp.line = port->minor;
142 tmp.port = port->port_number;
143 tmp.baud_base = tty_get_baud_rate(port->port.tty);
144 tmp.close_delay = port->port.close_delay / 10;
145 tmp.closing_wait = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
146 ASYNC_CLOSING_WAIT_NONE :
147 port->port.closing_wait / 10;
149 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
154 static int set_serial_info(struct usb_serial_port *port,
155 struct serial_struct __user *newinfo)
157 struct serial_struct new_serial;
158 unsigned int closing_wait, close_delay;
161 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
164 close_delay = new_serial.close_delay * 10;
165 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
166 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
168 mutex_lock(&port->port.mutex);
170 if (!capable(CAP_SYS_ADMIN)) {
171 if ((close_delay != port->port.close_delay) ||
172 (closing_wait != port->port.closing_wait))
175 retval = -EOPNOTSUPP;
177 port->port.close_delay = close_delay;
178 port->port.closing_wait = closing_wait;
181 mutex_unlock(&port->port.mutex);
185 int usb_wwan_ioctl(struct tty_struct *tty,
186 unsigned int cmd, unsigned long arg)
188 struct usb_serial_port *port = tty->driver_data;
190 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
194 return get_serial_info(port,
195 (struct serial_struct __user *) arg);
197 return set_serial_info(port,
198 (struct serial_struct __user *) arg);
203 dev_dbg(&port->dev, "%s arg not supported\n", __func__);
207 EXPORT_SYMBOL(usb_wwan_ioctl);
209 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
210 const unsigned char *buf, int count)
212 struct usb_wwan_port_private *portdata;
213 struct usb_wwan_intf_private *intfdata;
216 struct urb *this_urb = NULL; /* spurious */
220 portdata = usb_get_serial_port_data(port);
221 intfdata = usb_get_serial_data(port->serial);
223 dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
227 for (i = 0; left > 0 && i < N_OUT_URB; i++) {
229 if (todo > OUT_BUFLEN)
232 this_urb = portdata->out_urbs[i];
233 if (test_and_set_bit(i, &portdata->out_busy)) {
234 if (time_before(jiffies,
235 portdata->tx_start_time[i] + 10 * HZ))
237 usb_unlink_urb(this_urb);
240 dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
241 usb_pipeendpoint(this_urb->pipe), i);
243 err = usb_autopm_get_interface_async(port->serial->interface);
245 clear_bit(i, &portdata->out_busy);
250 memcpy(this_urb->transfer_buffer, buf, todo);
251 this_urb->transfer_buffer_length = todo;
253 spin_lock_irqsave(&intfdata->susp_lock, flags);
254 if (intfdata->suspended) {
255 usb_anchor_urb(this_urb, &portdata->delayed);
256 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
258 intfdata->in_flight++;
259 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
260 err = usb_submit_urb(this_urb, GFP_ATOMIC);
263 "%s: submit urb %d failed: %d\n",
265 clear_bit(i, &portdata->out_busy);
266 spin_lock_irqsave(&intfdata->susp_lock, flags);
267 intfdata->in_flight--;
268 spin_unlock_irqrestore(&intfdata->susp_lock,
270 usb_autopm_put_interface_async(port->serial->interface);
275 portdata->tx_start_time[i] = jiffies;
281 dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
284 EXPORT_SYMBOL(usb_wwan_write);
286 static void usb_wwan_indat_callback(struct urb *urb)
290 struct usb_serial_port *port;
292 unsigned char *data = urb->transfer_buffer;
293 int status = urb->status;
295 endpoint = usb_pipeendpoint(urb->pipe);
300 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
301 __func__, status, endpoint);
303 /* don't resubmit on fatal errors */
304 if (status == -ESHUTDOWN || status == -ENOENT)
307 if (urb->actual_length) {
308 tty_insert_flip_string(&port->port, data,
310 tty_flip_buffer_push(&port->port);
312 dev_dbg(dev, "%s: empty read urb received\n", __func__);
314 /* Resubmit urb so we continue receiving */
315 err = usb_submit_urb(urb, GFP_ATOMIC);
317 if (err != -EPERM && err != -ENODEV) {
318 dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
320 /* busy also in error unless we are killed */
321 usb_mark_last_busy(port->serial->dev);
324 usb_mark_last_busy(port->serial->dev);
328 static void usb_wwan_outdat_callback(struct urb *urb)
330 struct usb_serial_port *port;
331 struct usb_wwan_port_private *portdata;
332 struct usb_wwan_intf_private *intfdata;
337 intfdata = usb_get_serial_data(port->serial);
339 usb_serial_port_softint(port);
340 usb_autopm_put_interface_async(port->serial->interface);
341 portdata = usb_get_serial_port_data(port);
342 spin_lock_irqsave(&intfdata->susp_lock, flags);
343 intfdata->in_flight--;
344 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
346 for (i = 0; i < N_OUT_URB; ++i) {
347 if (portdata->out_urbs[i] == urb) {
348 smp_mb__before_atomic();
349 clear_bit(i, &portdata->out_busy);
355 int usb_wwan_write_room(struct tty_struct *tty)
357 struct usb_serial_port *port = tty->driver_data;
358 struct usb_wwan_port_private *portdata;
361 struct urb *this_urb;
363 portdata = usb_get_serial_port_data(port);
365 for (i = 0; i < N_OUT_URB; i++) {
366 this_urb = portdata->out_urbs[i];
367 if (this_urb && !test_bit(i, &portdata->out_busy))
368 data_len += OUT_BUFLEN;
371 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
374 EXPORT_SYMBOL(usb_wwan_write_room);
376 int usb_wwan_chars_in_buffer(struct tty_struct *tty)
378 struct usb_serial_port *port = tty->driver_data;
379 struct usb_wwan_port_private *portdata;
382 struct urb *this_urb;
384 portdata = usb_get_serial_port_data(port);
386 for (i = 0; i < N_OUT_URB; i++) {
387 this_urb = portdata->out_urbs[i];
388 /* FIXME: This locking is insufficient as this_urb may
389 go unused during the test */
390 if (this_urb && test_bit(i, &portdata->out_busy))
391 data_len += this_urb->transfer_buffer_length;
393 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
396 EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
398 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
400 struct usb_wwan_port_private *portdata;
401 struct usb_wwan_intf_private *intfdata;
402 struct usb_serial *serial = port->serial;
406 portdata = usb_get_serial_port_data(port);
407 intfdata = usb_get_serial_data(serial);
409 if (port->interrupt_in_urb) {
410 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
412 dev_err(&port->dev, "%s: submit int urb failed: %d\n",
417 /* Start reading from the IN endpoint */
418 for (i = 0; i < N_IN_URB; i++) {
419 urb = portdata->in_urbs[i];
422 err = usb_submit_urb(urb, GFP_KERNEL);
425 "%s: submit read urb %d failed: %d\n",
430 spin_lock_irq(&intfdata->susp_lock);
431 if (++intfdata->open_ports == 1)
432 serial->interface->needs_remote_wakeup = 1;
433 spin_unlock_irq(&intfdata->susp_lock);
434 /* this balances a get in the generic USB serial code */
435 usb_autopm_put_interface(serial->interface);
439 EXPORT_SYMBOL(usb_wwan_open);
441 static void unbusy_queued_urb(struct urb *urb,
442 struct usb_wwan_port_private *portdata)
446 for (i = 0; i < N_OUT_URB; i++) {
447 if (urb == portdata->out_urbs[i]) {
448 clear_bit(i, &portdata->out_busy);
454 void usb_wwan_close(struct usb_serial_port *port)
457 struct usb_serial *serial = port->serial;
458 struct usb_wwan_port_private *portdata;
459 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
462 portdata = usb_get_serial_port_data(port);
465 * Need to take susp_lock to make sure port is not already being
466 * resumed, but no need to hold it due to the tty-port initialized
469 spin_lock_irq(&intfdata->susp_lock);
470 if (--intfdata->open_ports == 0)
471 serial->interface->needs_remote_wakeup = 0;
472 spin_unlock_irq(&intfdata->susp_lock);
475 urb = usb_get_from_anchor(&portdata->delayed);
478 unbusy_queued_urb(urb, portdata);
479 usb_autopm_put_interface_async(serial->interface);
482 for (i = 0; i < N_IN_URB; i++)
483 usb_kill_urb(portdata->in_urbs[i]);
484 for (i = 0; i < N_OUT_URB; i++)
485 usb_kill_urb(portdata->out_urbs[i]);
486 usb_kill_urb(port->interrupt_in_urb);
488 usb_autopm_get_interface_no_resume(serial->interface);
490 EXPORT_SYMBOL(usb_wwan_close);
492 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
494 int dir, void *ctx, char *buf, int len,
495 void (*callback) (struct urb *))
497 struct usb_serial *serial = port->serial;
498 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
501 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
505 usb_fill_bulk_urb(urb, serial->dev,
506 usb_sndbulkpipe(serial->dev, endpoint) | dir,
507 buf, len, callback, ctx);
509 if (intfdata->use_zlp && dir == USB_DIR_OUT)
510 urb->transfer_flags |= URB_ZERO_PACKET;
515 int usb_wwan_port_probe(struct usb_serial_port *port)
517 struct usb_wwan_port_private *portdata;
522 if (!port->bulk_in_size || !port->bulk_out_size)
525 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
529 init_usb_anchor(&portdata->delayed);
531 for (i = 0; i < N_IN_URB; i++) {
532 buffer = (u8 *)__get_free_page(GFP_KERNEL);
535 portdata->in_buffer[i] = buffer;
537 urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
540 usb_wwan_indat_callback);
541 portdata->in_urbs[i] = urb;
544 for (i = 0; i < N_OUT_URB; i++) {
545 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
547 goto bail_out_error2;
548 portdata->out_buffer[i] = buffer;
550 urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
553 usb_wwan_outdat_callback);
554 portdata->out_urbs[i] = urb;
557 usb_set_serial_port_data(port, portdata);
562 for (i = 0; i < N_OUT_URB; i++) {
563 usb_free_urb(portdata->out_urbs[i]);
564 kfree(portdata->out_buffer[i]);
567 for (i = 0; i < N_IN_URB; i++) {
568 usb_free_urb(portdata->in_urbs[i]);
569 free_page((unsigned long)portdata->in_buffer[i]);
575 EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
577 int usb_wwan_port_remove(struct usb_serial_port *port)
580 struct usb_wwan_port_private *portdata;
582 portdata = usb_get_serial_port_data(port);
583 usb_set_serial_port_data(port, NULL);
585 for (i = 0; i < N_IN_URB; i++) {
586 usb_free_urb(portdata->in_urbs[i]);
587 free_page((unsigned long)portdata->in_buffer[i]);
589 for (i = 0; i < N_OUT_URB; i++) {
590 usb_free_urb(portdata->out_urbs[i]);
591 kfree(portdata->out_buffer[i]);
598 EXPORT_SYMBOL(usb_wwan_port_remove);
601 static void stop_urbs(struct usb_serial *serial)
604 struct usb_serial_port *port;
605 struct usb_wwan_port_private *portdata;
607 for (i = 0; i < serial->num_ports; ++i) {
608 port = serial->port[i];
609 portdata = usb_get_serial_port_data(port);
612 for (j = 0; j < N_IN_URB; j++)
613 usb_kill_urb(portdata->in_urbs[j]);
614 for (j = 0; j < N_OUT_URB; j++)
615 usb_kill_urb(portdata->out_urbs[j]);
616 usb_kill_urb(port->interrupt_in_urb);
620 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
622 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
624 spin_lock_irq(&intfdata->susp_lock);
625 if (PMSG_IS_AUTO(message)) {
626 if (intfdata->in_flight) {
627 spin_unlock_irq(&intfdata->susp_lock);
631 intfdata->suspended = 1;
632 spin_unlock_irq(&intfdata->susp_lock);
638 EXPORT_SYMBOL(usb_wwan_suspend);
640 /* Caller must hold susp_lock. */
641 static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
643 struct usb_serial *serial = port->serial;
644 struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
645 struct usb_wwan_port_private *portdata;
650 portdata = usb_get_serial_port_data(port);
653 urb = usb_get_from_anchor(&portdata->delayed);
657 err = usb_submit_urb(urb, GFP_ATOMIC);
659 dev_err(&port->dev, "%s: submit urb failed: %d\n",
662 unbusy_queued_urb(urb, portdata);
663 usb_autopm_put_interface_async(serial->interface);
675 int usb_wwan_resume(struct usb_serial *serial)
678 struct usb_serial_port *port;
679 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
680 struct usb_wwan_port_private *portdata;
685 spin_lock_irq(&intfdata->susp_lock);
686 for (i = 0; i < serial->num_ports; i++) {
687 port = serial->port[i];
689 if (!tty_port_initialized(&port->port))
692 portdata = usb_get_serial_port_data(port);
694 if (port->interrupt_in_urb) {
695 err = usb_submit_urb(port->interrupt_in_urb,
699 "%s: submit int urb failed: %d\n",
705 err = usb_wwan_submit_delayed_urbs(port);
709 for (j = 0; j < N_IN_URB; j++) {
710 urb = portdata->in_urbs[j];
711 err = usb_submit_urb(urb, GFP_ATOMIC);
714 "%s: submit read urb %d failed: %d\n",
720 intfdata->suspended = 0;
721 spin_unlock_irq(&intfdata->susp_lock);
728 EXPORT_SYMBOL(usb_wwan_resume);
731 MODULE_AUTHOR(DRIVER_AUTHOR);
732 MODULE_DESCRIPTION(DRIVER_DESC);
733 MODULE_LICENSE("GPL v2");