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 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
136 const unsigned char *buf, int count)
138 struct usb_wwan_port_private *portdata;
139 struct usb_wwan_intf_private *intfdata;
142 struct urb *this_urb = NULL; /* spurious */
146 portdata = usb_get_serial_port_data(port);
147 intfdata = usb_get_serial_data(port->serial);
149 dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
152 for (i = 0; left > 0 && i < N_OUT_URB; i++) {
154 if (todo > OUT_BUFLEN)
157 this_urb = portdata->out_urbs[i];
158 if (test_and_set_bit(i, &portdata->out_busy)) {
159 if (time_before(jiffies,
160 portdata->tx_start_time[i] + 10 * HZ))
162 usb_unlink_urb(this_urb);
165 dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
166 usb_pipeendpoint(this_urb->pipe), i);
168 err = usb_autopm_get_interface_async(port->serial->interface);
170 clear_bit(i, &portdata->out_busy);
175 memcpy(this_urb->transfer_buffer, buf, todo);
176 this_urb->transfer_buffer_length = todo;
178 spin_lock_irqsave(&intfdata->susp_lock, flags);
179 if (intfdata->suspended) {
180 usb_anchor_urb(this_urb, &portdata->delayed);
181 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
183 intfdata->in_flight++;
184 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
185 err = usb_submit_urb(this_urb, GFP_ATOMIC);
188 "%s: submit urb %d failed: %d\n",
190 clear_bit(i, &portdata->out_busy);
191 spin_lock_irqsave(&intfdata->susp_lock, flags);
192 intfdata->in_flight--;
193 spin_unlock_irqrestore(&intfdata->susp_lock,
195 usb_autopm_put_interface_async(port->serial->interface);
200 portdata->tx_start_time[i] = jiffies;
206 dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
209 EXPORT_SYMBOL(usb_wwan_write);
211 static void usb_wwan_indat_callback(struct urb *urb)
215 struct usb_serial_port *port;
217 unsigned char *data = urb->transfer_buffer;
218 int status = urb->status;
220 endpoint = usb_pipeendpoint(urb->pipe);
225 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
226 __func__, status, endpoint);
228 /* don't resubmit on fatal errors */
229 if (status == -ESHUTDOWN || status == -ENOENT)
232 if (urb->actual_length) {
233 tty_insert_flip_string(&port->port, data,
235 tty_flip_buffer_push(&port->port);
237 dev_dbg(dev, "%s: empty read urb received\n", __func__);
239 /* Resubmit urb so we continue receiving */
240 err = usb_submit_urb(urb, GFP_ATOMIC);
242 if (err != -EPERM && err != -ENODEV) {
243 dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
245 /* busy also in error unless we are killed */
246 usb_mark_last_busy(port->serial->dev);
249 usb_mark_last_busy(port->serial->dev);
253 static void usb_wwan_outdat_callback(struct urb *urb)
255 struct usb_serial_port *port;
256 struct usb_wwan_port_private *portdata;
257 struct usb_wwan_intf_private *intfdata;
262 intfdata = usb_get_serial_data(port->serial);
264 usb_serial_port_softint(port);
265 usb_autopm_put_interface_async(port->serial->interface);
266 portdata = usb_get_serial_port_data(port);
267 spin_lock_irqsave(&intfdata->susp_lock, flags);
268 intfdata->in_flight--;
269 spin_unlock_irqrestore(&intfdata->susp_lock, flags);
271 for (i = 0; i < N_OUT_URB; ++i) {
272 if (portdata->out_urbs[i] == urb) {
273 smp_mb__before_atomic();
274 clear_bit(i, &portdata->out_busy);
280 unsigned int usb_wwan_write_room(struct tty_struct *tty)
282 struct usb_serial_port *port = tty->driver_data;
283 struct usb_wwan_port_private *portdata;
285 unsigned int data_len = 0;
286 struct urb *this_urb;
288 portdata = usb_get_serial_port_data(port);
290 for (i = 0; i < N_OUT_URB; i++) {
291 this_urb = portdata->out_urbs[i];
292 if (this_urb && !test_bit(i, &portdata->out_busy))
293 data_len += OUT_BUFLEN;
296 dev_dbg(&port->dev, "%s: %u\n", __func__, data_len);
299 EXPORT_SYMBOL(usb_wwan_write_room);
301 unsigned int usb_wwan_chars_in_buffer(struct tty_struct *tty)
303 struct usb_serial_port *port = tty->driver_data;
304 struct usb_wwan_port_private *portdata;
306 unsigned int data_len = 0;
307 struct urb *this_urb;
309 portdata = usb_get_serial_port_data(port);
311 for (i = 0; i < N_OUT_URB; i++) {
312 this_urb = portdata->out_urbs[i];
313 /* FIXME: This locking is insufficient as this_urb may
314 go unused during the test */
315 if (this_urb && test_bit(i, &portdata->out_busy))
316 data_len += this_urb->transfer_buffer_length;
318 dev_dbg(&port->dev, "%s: %u\n", __func__, data_len);
321 EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
323 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
325 struct usb_wwan_port_private *portdata;
326 struct usb_wwan_intf_private *intfdata;
327 struct usb_serial *serial = port->serial;
331 portdata = usb_get_serial_port_data(port);
332 intfdata = usb_get_serial_data(serial);
334 if (port->interrupt_in_urb) {
335 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
337 dev_err(&port->dev, "%s: submit int urb failed: %d\n",
342 /* Start reading from the IN endpoint */
343 for (i = 0; i < N_IN_URB; i++) {
344 urb = portdata->in_urbs[i];
347 err = usb_submit_urb(urb, GFP_KERNEL);
350 "%s: submit read urb %d failed: %d\n",
355 spin_lock_irq(&intfdata->susp_lock);
356 if (++intfdata->open_ports == 1)
357 serial->interface->needs_remote_wakeup = 1;
358 spin_unlock_irq(&intfdata->susp_lock);
359 /* this balances a get in the generic USB serial code */
360 usb_autopm_put_interface(serial->interface);
364 EXPORT_SYMBOL(usb_wwan_open);
366 static void unbusy_queued_urb(struct urb *urb,
367 struct usb_wwan_port_private *portdata)
371 for (i = 0; i < N_OUT_URB; i++) {
372 if (urb == portdata->out_urbs[i]) {
373 clear_bit(i, &portdata->out_busy);
379 void usb_wwan_close(struct usb_serial_port *port)
382 struct usb_serial *serial = port->serial;
383 struct usb_wwan_port_private *portdata;
384 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
387 portdata = usb_get_serial_port_data(port);
390 * Need to take susp_lock to make sure port is not already being
391 * resumed, but no need to hold it due to initialized
393 spin_lock_irq(&intfdata->susp_lock);
394 if (--intfdata->open_ports == 0)
395 serial->interface->needs_remote_wakeup = 0;
396 spin_unlock_irq(&intfdata->susp_lock);
399 urb = usb_get_from_anchor(&portdata->delayed);
402 unbusy_queued_urb(urb, portdata);
403 usb_autopm_put_interface_async(serial->interface);
406 for (i = 0; i < N_IN_URB; i++)
407 usb_kill_urb(portdata->in_urbs[i]);
408 for (i = 0; i < N_OUT_URB; i++)
409 usb_kill_urb(portdata->out_urbs[i]);
410 usb_kill_urb(port->interrupt_in_urb);
412 usb_autopm_get_interface_no_resume(serial->interface);
414 EXPORT_SYMBOL(usb_wwan_close);
416 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
418 int dir, void *ctx, char *buf, int len,
419 void (*callback) (struct urb *))
421 struct usb_serial *serial = port->serial;
422 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
425 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
429 usb_fill_bulk_urb(urb, serial->dev,
430 usb_sndbulkpipe(serial->dev, endpoint) | dir,
431 buf, len, callback, ctx);
433 if (intfdata->use_zlp && dir == USB_DIR_OUT)
434 urb->transfer_flags |= URB_ZERO_PACKET;
439 int usb_wwan_port_probe(struct usb_serial_port *port)
441 struct usb_wwan_port_private *portdata;
446 if (!port->bulk_in_size || !port->bulk_out_size)
449 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
453 init_usb_anchor(&portdata->delayed);
455 for (i = 0; i < N_IN_URB; i++) {
456 buffer = (u8 *)__get_free_page(GFP_KERNEL);
459 portdata->in_buffer[i] = buffer;
461 urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
464 usb_wwan_indat_callback);
465 portdata->in_urbs[i] = urb;
468 for (i = 0; i < N_OUT_URB; i++) {
469 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
471 goto bail_out_error2;
472 portdata->out_buffer[i] = buffer;
474 urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
477 usb_wwan_outdat_callback);
478 portdata->out_urbs[i] = urb;
481 usb_set_serial_port_data(port, portdata);
486 for (i = 0; i < N_OUT_URB; i++) {
487 usb_free_urb(portdata->out_urbs[i]);
488 kfree(portdata->out_buffer[i]);
491 for (i = 0; i < N_IN_URB; i++) {
492 usb_free_urb(portdata->in_urbs[i]);
493 free_page((unsigned long)portdata->in_buffer[i]);
499 EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
501 void usb_wwan_port_remove(struct usb_serial_port *port)
504 struct usb_wwan_port_private *portdata;
506 portdata = usb_get_serial_port_data(port);
507 usb_set_serial_port_data(port, NULL);
509 for (i = 0; i < N_IN_URB; i++) {
510 usb_free_urb(portdata->in_urbs[i]);
511 free_page((unsigned long)portdata->in_buffer[i]);
513 for (i = 0; i < N_OUT_URB; i++) {
514 usb_free_urb(portdata->out_urbs[i]);
515 kfree(portdata->out_buffer[i]);
520 EXPORT_SYMBOL(usb_wwan_port_remove);
523 static void stop_urbs(struct usb_serial *serial)
526 struct usb_serial_port *port;
527 struct usb_wwan_port_private *portdata;
529 for (i = 0; i < serial->num_ports; ++i) {
530 port = serial->port[i];
531 portdata = usb_get_serial_port_data(port);
534 for (j = 0; j < N_IN_URB; j++)
535 usb_kill_urb(portdata->in_urbs[j]);
536 for (j = 0; j < N_OUT_URB; j++)
537 usb_kill_urb(portdata->out_urbs[j]);
538 usb_kill_urb(port->interrupt_in_urb);
542 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
544 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
546 spin_lock_irq(&intfdata->susp_lock);
547 if (PMSG_IS_AUTO(message)) {
548 if (intfdata->in_flight) {
549 spin_unlock_irq(&intfdata->susp_lock);
553 intfdata->suspended = 1;
554 spin_unlock_irq(&intfdata->susp_lock);
560 EXPORT_SYMBOL(usb_wwan_suspend);
562 /* Caller must hold susp_lock. */
563 static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
565 struct usb_serial *serial = port->serial;
566 struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
567 struct usb_wwan_port_private *portdata;
572 portdata = usb_get_serial_port_data(port);
575 urb = usb_get_from_anchor(&portdata->delayed);
579 err = usb_submit_urb(urb, GFP_ATOMIC);
581 dev_err(&port->dev, "%s: submit urb failed: %d\n",
584 unbusy_queued_urb(urb, portdata);
585 usb_autopm_put_interface_async(serial->interface);
597 int usb_wwan_resume(struct usb_serial *serial)
600 struct usb_serial_port *port;
601 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
602 struct usb_wwan_port_private *portdata;
607 spin_lock_irq(&intfdata->susp_lock);
608 for (i = 0; i < serial->num_ports; i++) {
609 port = serial->port[i];
611 if (!tty_port_initialized(&port->port))
614 portdata = usb_get_serial_port_data(port);
616 if (port->interrupt_in_urb) {
617 err = usb_submit_urb(port->interrupt_in_urb,
621 "%s: submit int urb failed: %d\n",
627 err = usb_wwan_submit_delayed_urbs(port);
631 for (j = 0; j < N_IN_URB; j++) {
632 urb = portdata->in_urbs[j];
633 err = usb_submit_urb(urb, GFP_ATOMIC);
636 "%s: submit read urb %d failed: %d\n",
642 intfdata->suspended = 0;
643 spin_unlock_irq(&intfdata->susp_lock);
650 EXPORT_SYMBOL(usb_wwan_resume);
653 MODULE_AUTHOR(DRIVER_AUTHOR);
654 MODULE_DESCRIPTION(DRIVER_DESC);
655 MODULE_LICENSE("GPL v2");