cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

usb_wwan.c (16175B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3  USB Driver layer for GSM modems
      4
      5  Copyright (C) 2005  Matthias Urlichs <smurf@smurf.noris.de>
      6
      7  Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
      8
      9  History: see the git log.
     10
     11  Work sponsored by: Sigos GmbH, Germany <info@sigos.de>
     12
     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
     17*/
     18
     19#define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
     20#define DRIVER_DESC "USB Driver for GSM modems"
     21
     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>
     34#include "usb-wwan.h"
     35
     36/*
     37 * Generate DTR/RTS signals on the port using the SET_CONTROL_LINE_STATE request
     38 * in CDC ACM.
     39 */
     40static int usb_wwan_send_setup(struct usb_serial_port *port)
     41{
     42	struct usb_serial *serial = port->serial;
     43	struct usb_wwan_port_private *portdata;
     44	int val = 0;
     45	int ifnum;
     46	int res;
     47
     48	portdata = usb_get_serial_port_data(port);
     49
     50	if (portdata->dtr_state)
     51		val |= 0x01;
     52	if (portdata->rts_state)
     53		val |= 0x02;
     54
     55	ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
     56
     57	res = usb_autopm_get_interface(serial->interface);
     58	if (res)
     59		return res;
     60
     61	res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
     62				0x22, 0x21, val, ifnum, NULL, 0,
     63				USB_CTRL_SET_TIMEOUT);
     64
     65	usb_autopm_put_interface(port->serial->interface);
     66
     67	return res;
     68}
     69
     70void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
     71{
     72	struct usb_wwan_port_private *portdata;
     73	struct usb_wwan_intf_private *intfdata;
     74
     75	intfdata = usb_get_serial_data(port->serial);
     76
     77	if (!intfdata->use_send_setup)
     78		return;
     79
     80	portdata = usb_get_serial_port_data(port);
     81	/* FIXME: locking */
     82	portdata->rts_state = on;
     83	portdata->dtr_state = on;
     84
     85	usb_wwan_send_setup(port);
     86}
     87EXPORT_SYMBOL(usb_wwan_dtr_rts);
     88
     89int usb_wwan_tiocmget(struct tty_struct *tty)
     90{
     91	struct usb_serial_port *port = tty->driver_data;
     92	unsigned int value;
     93	struct usb_wwan_port_private *portdata;
     94
     95	portdata = usb_get_serial_port_data(port);
     96
     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);
    103
    104	return value;
    105}
    106EXPORT_SYMBOL(usb_wwan_tiocmget);
    107
    108int usb_wwan_tiocmset(struct tty_struct *tty,
    109		      unsigned int set, unsigned int clear)
    110{
    111	struct usb_serial_port *port = tty->driver_data;
    112	struct usb_wwan_port_private *portdata;
    113	struct usb_wwan_intf_private *intfdata;
    114
    115	portdata = usb_get_serial_port_data(port);
    116	intfdata = usb_get_serial_data(port->serial);
    117
    118	if (!intfdata->use_send_setup)
    119		return -EINVAL;
    120
    121	/* FIXME: what locks portdata fields ? */
    122	if (set & TIOCM_RTS)
    123		portdata->rts_state = 1;
    124	if (set & TIOCM_DTR)
    125		portdata->dtr_state = 1;
    126
    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);
    132}
    133EXPORT_SYMBOL(usb_wwan_tiocmset);
    134
    135int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
    136		   const unsigned char *buf, int count)
    137{
    138	struct usb_wwan_port_private *portdata;
    139	struct usb_wwan_intf_private *intfdata;
    140	int i;
    141	int left, todo;
    142	struct urb *this_urb = NULL;	/* spurious */
    143	int err;
    144	unsigned long flags;
    145
    146	portdata = usb_get_serial_port_data(port);
    147	intfdata = usb_get_serial_data(port->serial);
    148
    149	dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
    150
    151	left = count;
    152	for (i = 0; left > 0 && i < N_OUT_URB; i++) {
    153		todo = left;
    154		if (todo > OUT_BUFLEN)
    155			todo = OUT_BUFLEN;
    156
    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))
    161				continue;
    162			usb_unlink_urb(this_urb);
    163			continue;
    164		}
    165		dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
    166			usb_pipeendpoint(this_urb->pipe), i);
    167
    168		err = usb_autopm_get_interface_async(port->serial->interface);
    169		if (err < 0) {
    170			clear_bit(i, &portdata->out_busy);
    171			break;
    172		}
    173
    174		/* send the data */
    175		memcpy(this_urb->transfer_buffer, buf, todo);
    176		this_urb->transfer_buffer_length = todo;
    177
    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);
    182		} else {
    183			intfdata->in_flight++;
    184			spin_unlock_irqrestore(&intfdata->susp_lock, flags);
    185			err = usb_submit_urb(this_urb, GFP_ATOMIC);
    186			if (err) {
    187				dev_err(&port->dev,
    188					"%s: submit urb %d failed: %d\n",
    189					__func__, i, err);
    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,
    194						       flags);
    195				usb_autopm_put_interface_async(port->serial->interface);
    196				break;
    197			}
    198		}
    199
    200		portdata->tx_start_time[i] = jiffies;
    201		buf += todo;
    202		left -= todo;
    203	}
    204
    205	count -= left;
    206	dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
    207	return count;
    208}
    209EXPORT_SYMBOL(usb_wwan_write);
    210
    211static void usb_wwan_indat_callback(struct urb *urb)
    212{
    213	int err;
    214	int endpoint;
    215	struct usb_serial_port *port;
    216	struct device *dev;
    217	unsigned char *data = urb->transfer_buffer;
    218	int status = urb->status;
    219
    220	endpoint = usb_pipeendpoint(urb->pipe);
    221	port = urb->context;
    222	dev = &port->dev;
    223
    224	if (status) {
    225		dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
    226			__func__, status, endpoint);
    227
    228		/* don't resubmit on fatal errors */
    229		if (status == -ESHUTDOWN || status == -ENOENT)
    230			return;
    231	} else {
    232		if (urb->actual_length) {
    233			tty_insert_flip_string(&port->port, data,
    234					urb->actual_length);
    235			tty_flip_buffer_push(&port->port);
    236		} else
    237			dev_dbg(dev, "%s: empty read urb received\n", __func__);
    238	}
    239	/* Resubmit urb so we continue receiving */
    240	err = usb_submit_urb(urb, GFP_ATOMIC);
    241	if (err) {
    242		if (err != -EPERM && err != -ENODEV) {
    243			dev_err(dev, "%s: resubmit read urb failed. (%d)\n",
    244				__func__, err);
    245			/* busy also in error unless we are killed */
    246			usb_mark_last_busy(port->serial->dev);
    247		}
    248	} else {
    249		usb_mark_last_busy(port->serial->dev);
    250	}
    251}
    252
    253static void usb_wwan_outdat_callback(struct urb *urb)
    254{
    255	struct usb_serial_port *port;
    256	struct usb_wwan_port_private *portdata;
    257	struct usb_wwan_intf_private *intfdata;
    258	unsigned long flags;
    259	int i;
    260
    261	port = urb->context;
    262	intfdata = usb_get_serial_data(port->serial);
    263
    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);
    270
    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);
    275			break;
    276		}
    277	}
    278}
    279
    280unsigned int usb_wwan_write_room(struct tty_struct *tty)
    281{
    282	struct usb_serial_port *port = tty->driver_data;
    283	struct usb_wwan_port_private *portdata;
    284	int i;
    285	unsigned int data_len = 0;
    286	struct urb *this_urb;
    287
    288	portdata = usb_get_serial_port_data(port);
    289
    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;
    294	}
    295
    296	dev_dbg(&port->dev, "%s: %u\n", __func__, data_len);
    297	return data_len;
    298}
    299EXPORT_SYMBOL(usb_wwan_write_room);
    300
    301unsigned int usb_wwan_chars_in_buffer(struct tty_struct *tty)
    302{
    303	struct usb_serial_port *port = tty->driver_data;
    304	struct usb_wwan_port_private *portdata;
    305	int i;
    306	unsigned int data_len = 0;
    307	struct urb *this_urb;
    308
    309	portdata = usb_get_serial_port_data(port);
    310
    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;
    317	}
    318	dev_dbg(&port->dev, "%s: %u\n", __func__, data_len);
    319	return data_len;
    320}
    321EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
    322
    323int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
    324{
    325	struct usb_wwan_port_private *portdata;
    326	struct usb_wwan_intf_private *intfdata;
    327	struct usb_serial *serial = port->serial;
    328	int i, err;
    329	struct urb *urb;
    330
    331	portdata = usb_get_serial_port_data(port);
    332	intfdata = usb_get_serial_data(serial);
    333
    334	if (port->interrupt_in_urb) {
    335		err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
    336		if (err) {
    337			dev_err(&port->dev, "%s: submit int urb failed: %d\n",
    338				__func__, err);
    339		}
    340	}
    341
    342	/* Start reading from the IN endpoint */
    343	for (i = 0; i < N_IN_URB; i++) {
    344		urb = portdata->in_urbs[i];
    345		if (!urb)
    346			continue;
    347		err = usb_submit_urb(urb, GFP_KERNEL);
    348		if (err) {
    349			dev_err(&port->dev,
    350				"%s: submit read urb %d failed: %d\n",
    351				__func__, i, err);
    352		}
    353	}
    354
    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);
    361
    362	return 0;
    363}
    364EXPORT_SYMBOL(usb_wwan_open);
    365
    366static void unbusy_queued_urb(struct urb *urb,
    367					struct usb_wwan_port_private *portdata)
    368{
    369	int i;
    370
    371	for (i = 0; i < N_OUT_URB; i++) {
    372		if (urb == portdata->out_urbs[i]) {
    373			clear_bit(i, &portdata->out_busy);
    374			break;
    375		}
    376	}
    377}
    378
    379void usb_wwan_close(struct usb_serial_port *port)
    380{
    381	int i;
    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);
    385	struct urb *urb;
    386
    387	portdata = usb_get_serial_port_data(port);
    388
    389	/*
    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
    392	 */
    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);
    397
    398	for (;;) {
    399		urb = usb_get_from_anchor(&portdata->delayed);
    400		if (!urb)
    401			break;
    402		unbusy_queued_urb(urb, portdata);
    403		usb_autopm_put_interface_async(serial->interface);
    404	}
    405
    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);
    411
    412	usb_autopm_get_interface_no_resume(serial->interface);
    413}
    414EXPORT_SYMBOL(usb_wwan_close);
    415
    416static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
    417				      int endpoint,
    418				      int dir, void *ctx, char *buf, int len,
    419				      void (*callback) (struct urb *))
    420{
    421	struct usb_serial *serial = port->serial;
    422	struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
    423	struct urb *urb;
    424
    425	urb = usb_alloc_urb(0, GFP_KERNEL);	/* No ISO */
    426	if (!urb)
    427		return NULL;
    428
    429	usb_fill_bulk_urb(urb, serial->dev,
    430			  usb_sndbulkpipe(serial->dev, endpoint) | dir,
    431			  buf, len, callback, ctx);
    432
    433	if (intfdata->use_zlp && dir == USB_DIR_OUT)
    434		urb->transfer_flags |= URB_ZERO_PACKET;
    435
    436	return urb;
    437}
    438
    439int usb_wwan_port_probe(struct usb_serial_port *port)
    440{
    441	struct usb_wwan_port_private *portdata;
    442	struct urb *urb;
    443	u8 *buffer;
    444	int i;
    445
    446	if (!port->bulk_in_size || !port->bulk_out_size)
    447		return -ENODEV;
    448
    449	portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
    450	if (!portdata)
    451		return -ENOMEM;
    452
    453	init_usb_anchor(&portdata->delayed);
    454
    455	for (i = 0; i < N_IN_URB; i++) {
    456		buffer = (u8 *)__get_free_page(GFP_KERNEL);
    457		if (!buffer)
    458			goto bail_out_error;
    459		portdata->in_buffer[i] = buffer;
    460
    461		urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress,
    462						USB_DIR_IN, port,
    463						buffer, IN_BUFLEN,
    464						usb_wwan_indat_callback);
    465		portdata->in_urbs[i] = urb;
    466	}
    467
    468	for (i = 0; i < N_OUT_URB; i++) {
    469		buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
    470		if (!buffer)
    471			goto bail_out_error2;
    472		portdata->out_buffer[i] = buffer;
    473
    474		urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress,
    475						USB_DIR_OUT, port,
    476						buffer, OUT_BUFLEN,
    477						usb_wwan_outdat_callback);
    478		portdata->out_urbs[i] = urb;
    479	}
    480
    481	usb_set_serial_port_data(port, portdata);
    482
    483	return 0;
    484
    485bail_out_error2:
    486	for (i = 0; i < N_OUT_URB; i++) {
    487		usb_free_urb(portdata->out_urbs[i]);
    488		kfree(portdata->out_buffer[i]);
    489	}
    490bail_out_error:
    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]);
    494	}
    495	kfree(portdata);
    496
    497	return -ENOMEM;
    498}
    499EXPORT_SYMBOL_GPL(usb_wwan_port_probe);
    500
    501void usb_wwan_port_remove(struct usb_serial_port *port)
    502{
    503	int i;
    504	struct usb_wwan_port_private *portdata;
    505
    506	portdata = usb_get_serial_port_data(port);
    507	usb_set_serial_port_data(port, NULL);
    508
    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]);
    512	}
    513	for (i = 0; i < N_OUT_URB; i++) {
    514		usb_free_urb(portdata->out_urbs[i]);
    515		kfree(portdata->out_buffer[i]);
    516	}
    517
    518	kfree(portdata);
    519}
    520EXPORT_SYMBOL(usb_wwan_port_remove);
    521
    522#ifdef CONFIG_PM
    523static void stop_urbs(struct usb_serial *serial)
    524{
    525	int i, j;
    526	struct usb_serial_port *port;
    527	struct usb_wwan_port_private *portdata;
    528
    529	for (i = 0; i < serial->num_ports; ++i) {
    530		port = serial->port[i];
    531		portdata = usb_get_serial_port_data(port);
    532		if (!portdata)
    533			continue;
    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);
    539	}
    540}
    541
    542int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
    543{
    544	struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
    545
    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);
    550			return -EBUSY;
    551		}
    552	}
    553	intfdata->suspended = 1;
    554	spin_unlock_irq(&intfdata->susp_lock);
    555
    556	stop_urbs(serial);
    557
    558	return 0;
    559}
    560EXPORT_SYMBOL(usb_wwan_suspend);
    561
    562/* Caller must hold susp_lock. */
    563static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
    564{
    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;
    568	struct urb *urb;
    569	int err_count = 0;
    570	int err;
    571
    572	portdata = usb_get_serial_port_data(port);
    573
    574	for (;;) {
    575		urb = usb_get_from_anchor(&portdata->delayed);
    576		if (!urb)
    577			break;
    578
    579		err = usb_submit_urb(urb, GFP_ATOMIC);
    580		if (err) {
    581			dev_err(&port->dev, "%s: submit urb failed: %d\n",
    582					__func__, err);
    583			err_count++;
    584			unbusy_queued_urb(urb, portdata);
    585			usb_autopm_put_interface_async(serial->interface);
    586			continue;
    587		}
    588		data->in_flight++;
    589	}
    590
    591	if (err_count)
    592		return -EIO;
    593
    594	return 0;
    595}
    596
    597int usb_wwan_resume(struct usb_serial *serial)
    598{
    599	int i, j;
    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;
    603	struct urb *urb;
    604	int err;
    605	int err_count = 0;
    606
    607	spin_lock_irq(&intfdata->susp_lock);
    608	for (i = 0; i < serial->num_ports; i++) {
    609		port = serial->port[i];
    610
    611		if (!tty_port_initialized(&port->port))
    612			continue;
    613
    614		portdata = usb_get_serial_port_data(port);
    615
    616		if (port->interrupt_in_urb) {
    617			err = usb_submit_urb(port->interrupt_in_urb,
    618					GFP_ATOMIC);
    619			if (err) {
    620				dev_err(&port->dev,
    621					"%s: submit int urb failed: %d\n",
    622					__func__, err);
    623				err_count++;
    624			}
    625		}
    626
    627		err = usb_wwan_submit_delayed_urbs(port);
    628		if (err)
    629			err_count++;
    630
    631		for (j = 0; j < N_IN_URB; j++) {
    632			urb = portdata->in_urbs[j];
    633			err = usb_submit_urb(urb, GFP_ATOMIC);
    634			if (err < 0) {
    635				dev_err(&port->dev,
    636					"%s: submit read urb %d failed: %d\n",
    637					__func__, i, err);
    638				err_count++;
    639			}
    640		}
    641	}
    642	intfdata->suspended = 0;
    643	spin_unlock_irq(&intfdata->susp_lock);
    644
    645	if (err_count)
    646		return -EIO;
    647
    648	return 0;
    649}
    650EXPORT_SYMBOL(usb_wwan_resume);
    651#endif
    652
    653MODULE_AUTHOR(DRIVER_AUTHOR);
    654MODULE_DESCRIPTION(DRIVER_DESC);
    655MODULE_LICENSE("GPL v2");