1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * cdc-acm.c
   4 *
   5 * Copyright (c) 1999 Armin Fuerst	<fuerst@in.tum.de>
   6 * Copyright (c) 1999 Pavel Machek	<pavel@ucw.cz>
   7 * Copyright (c) 1999 Johannes Erdfelt	<johannes@erdfelt.com>
   8 * Copyright (c) 2000 Vojtech Pavlik	<vojtech@suse.cz>
   9 * Copyright (c) 2004 Oliver Neukum	<oliver@neukum.name>
  10 * Copyright (c) 2005 David Kubicek	<dave@awk.cz>
  11 * Copyright (c) 2011 Johan Hovold	<jhovold@gmail.com>
  12 *
  13 * USB Abstract Control Model driver for USB modems and ISDN adapters
  14 *
  15 * Sponsored by SuSE
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  16 */
  17
  18#undef DEBUG
  19#undef VERBOSE_DEBUG
  20
  21#include <linux/kernel.h>
  22#include <linux/sched/signal.h>
  23#include <linux/errno.h>
  24#include <linux/init.h>
  25#include <linux/slab.h>
  26#include <linux/log2.h>
  27#include <linux/tty.h>
  28#include <linux/serial.h>
  29#include <linux/tty_driver.h>
  30#include <linux/tty_flip.h>
  31#include <linux/tty_ldisc.h>
  32#include <linux/module.h>
  33#include <linux/mutex.h>
  34#include <linux/uaccess.h>
  35#include <linux/usb.h>
  36#include <linux/usb/cdc.h>
  37#include <asm/byteorder.h>
  38#include <linux/unaligned.h>
  39#include <linux/idr.h>
  40#include <linux/list.h>
  41
  42#include "cdc-acm.h"
  43
  44
  45#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
  46#define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  47
  48static struct usb_driver acm_driver;
  49static struct tty_driver *acm_tty_driver;
 
  50
  51static DEFINE_IDR(acm_minors);
  52static DEFINE_MUTEX(acm_minors_lock);
  53
  54static void acm_tty_set_termios(struct tty_struct *tty,
  55				const struct ktermios *termios_old);
  56
  57/*
  58 * acm_minors accessors
  59 */
  60
  61/*
  62 * Look up an ACM structure by minor. If found and not disconnected, increment
  63 * its refcount and return it with its mutex held.
  64 */
  65static struct acm *acm_get_by_minor(unsigned int minor)
  66{
  67	struct acm *acm;
  68
  69	mutex_lock(&acm_minors_lock);
  70	acm = idr_find(&acm_minors, minor);
  71	if (acm) {
  72		mutex_lock(&acm->mutex);
  73		if (acm->disconnected) {
  74			mutex_unlock(&acm->mutex);
  75			acm = NULL;
  76		} else {
  77			tty_port_get(&acm->port);
  78			mutex_unlock(&acm->mutex);
  79		}
  80	}
  81	mutex_unlock(&acm_minors_lock);
  82	return acm;
  83}
  84
  85/*
  86 * Try to find an available minor number and if found, associate it with 'acm'.
  87 */
  88static int acm_alloc_minor(struct acm *acm)
  89{
  90	int minor;
  91
  92	mutex_lock(&acm_minors_lock);
  93	minor = idr_alloc(&acm_minors, acm, 0, ACM_TTY_MINORS, GFP_KERNEL);
  94	mutex_unlock(&acm_minors_lock);
 
 
 
 
 
  95
  96	return minor;
  97}
  98
  99/* Release the minor number associated with 'acm'.  */
 100static void acm_release_minor(struct acm *acm)
 101{
 102	mutex_lock(&acm_minors_lock);
 103	idr_remove(&acm_minors, acm->minor);
 104	mutex_unlock(&acm_minors_lock);
 105}
 106
 107/*
 108 * Functions for ACM control messages.
 109 */
 110
 111static int acm_ctrl_msg(struct acm *acm, int request, int value,
 112							void *buf, int len)
 113{
 114	int retval;
 115
 116	retval = usb_autopm_get_interface(acm->control);
 117	if (retval)
 118		return retval;
 119
 120	retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
 121		request, USB_RT_ACM, value,
 122		acm->control->altsetting[0].desc.bInterfaceNumber,
 123		buf, len, USB_CTRL_SET_TIMEOUT);
 124
 125	dev_dbg(&acm->control->dev,
 126		"%s - rq 0x%02x, val %#x, len %#x, result %d\n",
 127		__func__, request, value, len, retval);
 128
 129	usb_autopm_put_interface(acm->control);
 130
 131	return retval < 0 ? retval : 0;
 132}
 133
 134/* devices aren't required to support these requests.
 135 * the cdc acm descriptor tells whether they do...
 136 */
 137static inline int acm_set_control(struct acm *acm, int control)
 138{
 139	if (acm->quirks & QUIRK_CONTROL_LINE_STATE)
 140		return -EOPNOTSUPP;
 141
 142	return acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE,
 143			control, NULL, 0);
 144}
 145
 146#define acm_set_line(acm, line) \
 147	acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 148#define acm_send_break(acm, ms) \
 149	acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 150
 151static void acm_poison_urbs(struct acm *acm)
 152{
 153	int i;
 154
 155	usb_poison_urb(acm->ctrlurb);
 156	for (i = 0; i < ACM_NW; i++)
 157		usb_poison_urb(acm->wb[i].urb);
 158	for (i = 0; i < acm->rx_buflimit; i++)
 159		usb_poison_urb(acm->read_urbs[i]);
 160}
 161
 162static void acm_unpoison_urbs(struct acm *acm)
 163{
 164	int i;
 165
 166	for (i = 0; i < acm->rx_buflimit; i++)
 167		usb_unpoison_urb(acm->read_urbs[i]);
 168	for (i = 0; i < ACM_NW; i++)
 169		usb_unpoison_urb(acm->wb[i].urb);
 170	usb_unpoison_urb(acm->ctrlurb);
 171}
 172
 173
 174/*
 175 * Write buffer management.
 176 * All of these assume proper locks taken by the caller.
 177 */
 178
 179static int acm_wb_alloc(struct acm *acm)
 180{
 181	int i, wbn;
 182	struct acm_wb *wb;
 183
 184	wbn = 0;
 185	i = 0;
 186	for (;;) {
 187		wb = &acm->wb[wbn];
 188		if (!wb->use) {
 189			wb->use = true;
 190			wb->len = 0;
 191			return wbn;
 192		}
 193		wbn = (wbn + 1) % ACM_NW;
 194		if (++i >= ACM_NW)
 195			return -1;
 196	}
 197}
 198
 199static int acm_wb_is_avail(struct acm *acm)
 200{
 201	int i, n;
 202	unsigned long flags;
 203
 204	n = ACM_NW;
 205	spin_lock_irqsave(&acm->write_lock, flags);
 206	for (i = 0; i < ACM_NW; i++)
 207		if(acm->wb[i].use)
 208			n--;
 209	spin_unlock_irqrestore(&acm->write_lock, flags);
 210	return n;
 211}
 212
 213/*
 214 * Finish write. Caller must hold acm->write_lock
 215 */
 216static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 217{
 218	wb->use = false;
 219	acm->transmitting--;
 220	usb_autopm_put_interface_async(acm->control);
 221}
 222
 223/*
 224 * Poke write.
 225 *
 226 * the caller is responsible for locking
 227 */
 228
 229static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 230{
 231	int rc;
 232
 233	acm->transmitting++;
 234
 235	wb->urb->transfer_buffer = wb->buf;
 236	wb->urb->transfer_dma = wb->dmah;
 237	wb->urb->transfer_buffer_length = wb->len;
 238	wb->urb->dev = acm->dev;
 239
 240	rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 241	if (rc < 0) {
 242		if (rc != -EPERM)
 243			dev_err(&acm->data->dev,
 244				"%s - usb_submit_urb(write bulk) failed: %d\n",
 245				__func__, rc);
 246		acm_write_done(acm, wb);
 247	}
 248	return rc;
 249}
 250
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 251/*
 252 * attributes exported through sysfs
 253 */
 254static ssize_t bmCapabilities_show
 255(struct device *dev, struct device_attribute *attr, char *buf)
 256{
 257	struct usb_interface *intf = to_usb_interface(dev);
 258	struct acm *acm = usb_get_intfdata(intf);
 259
 260	return sprintf(buf, "%d", acm->ctrl_caps);
 261}
 262static DEVICE_ATTR_RO(bmCapabilities);
 263
 264static ssize_t wCountryCodes_show
 265(struct device *dev, struct device_attribute *attr, char *buf)
 266{
 267	struct usb_interface *intf = to_usb_interface(dev);
 268	struct acm *acm = usb_get_intfdata(intf);
 269
 270	memcpy(buf, acm->country_codes, acm->country_code_size);
 271	return acm->country_code_size;
 272}
 273
 274static DEVICE_ATTR_RO(wCountryCodes);
 275
 276static ssize_t iCountryCodeRelDate_show
 277(struct device *dev, struct device_attribute *attr, char *buf)
 278{
 279	struct usb_interface *intf = to_usb_interface(dev);
 280	struct acm *acm = usb_get_intfdata(intf);
 281
 282	return sprintf(buf, "%d", acm->country_rel_date);
 283}
 284
 285static DEVICE_ATTR_RO(iCountryCodeRelDate);
 286/*
 287 * Interrupt handlers for various ACM device responses
 288 */
 289
 290static void acm_process_notification(struct acm *acm, unsigned char *buf)
 291{
 292	int newctrl;
 293	int difference;
 294	unsigned long flags;
 295	struct usb_cdc_notification *dr = (struct usb_cdc_notification *)buf;
 296	unsigned char *data = buf + sizeof(struct usb_cdc_notification);
 297
 298	switch (dr->bNotificationType) {
 299	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 300		dev_dbg(&acm->control->dev,
 301			"%s - network connection: %d\n", __func__, dr->wValue);
 302		break;
 303
 304	case USB_CDC_NOTIFY_SERIAL_STATE:
 305		if (le16_to_cpu(dr->wLength) != 2) {
 306			dev_dbg(&acm->control->dev,
 307				"%s - malformed serial state\n", __func__);
 308			break;
 309		}
 310
 311		newctrl = get_unaligned_le16(data);
 312		dev_dbg(&acm->control->dev,
 313			"%s - serial state: 0x%x\n", __func__, newctrl);
 314
 315		if (!acm->clocal && (acm->ctrlin & ~newctrl & USB_CDC_SERIAL_STATE_DCD)) {
 316			dev_dbg(&acm->control->dev,
 317				"%s - calling hangup\n", __func__);
 318			tty_port_tty_hangup(&acm->port, false);
 319		}
 320
 321		difference = acm->ctrlin ^ newctrl;
 322
 323		if ((difference & USB_CDC_SERIAL_STATE_DCD) && acm->port.tty) {
 324			struct tty_ldisc *ld = tty_ldisc_ref(acm->port.tty);
 325			if (ld) {
 326				if (ld->ops->dcd_change)
 327					ld->ops->dcd_change(acm->port.tty, newctrl & USB_CDC_SERIAL_STATE_DCD);
 328				tty_ldisc_deref(ld);
 329			}
 330		}
 331
 332		spin_lock_irqsave(&acm->read_lock, flags);
 333		acm->ctrlin = newctrl;
 334		acm->oldcount = acm->iocount;
 335
 336		if (difference & USB_CDC_SERIAL_STATE_DSR)
 337			acm->iocount.dsr++;
 338		if (difference & USB_CDC_SERIAL_STATE_DCD)
 339			acm->iocount.dcd++;
 340		if (newctrl & USB_CDC_SERIAL_STATE_BREAK) {
 341			acm->iocount.brk++;
 342			tty_insert_flip_char(&acm->port, 0, TTY_BREAK);
 343		}
 344		if (newctrl & USB_CDC_SERIAL_STATE_RING_SIGNAL)
 345			acm->iocount.rng++;
 346		if (newctrl & USB_CDC_SERIAL_STATE_FRAMING)
 347			acm->iocount.frame++;
 348		if (newctrl & USB_CDC_SERIAL_STATE_PARITY)
 349			acm->iocount.parity++;
 350		if (newctrl & USB_CDC_SERIAL_STATE_OVERRUN)
 351			acm->iocount.overrun++;
 352		spin_unlock_irqrestore(&acm->read_lock, flags);
 353
 354		if (newctrl & USB_CDC_SERIAL_STATE_BREAK)
 355			tty_flip_buffer_push(&acm->port);
 356
 357		if (difference)
 358			wake_up_all(&acm->wioctl);
 359
 360		break;
 361
 362	default:
 363		dev_dbg(&acm->control->dev,
 364			"%s - unknown notification %d received: index %d len %d\n",
 365			__func__,
 366			dr->bNotificationType, dr->wIndex, dr->wLength);
 367	}
 368}
 369
 370/* control interface reports status changes with "interrupt" transfers */
 371static void acm_ctrl_irq(struct urb *urb)
 372{
 373	struct acm *acm = urb->context;
 374	struct usb_cdc_notification *dr;
 375	unsigned int current_size = urb->actual_length;
 376	unsigned int expected_size, copy_size, alloc_size;
 
 377	int retval;
 378	int status = urb->status;
 379
 380	switch (status) {
 381	case 0:
 382		/* success */
 383		break;
 384	case -ECONNRESET:
 385	case -ENOENT:
 386	case -ESHUTDOWN:
 387		/* this urb is terminated, clean up */
 388		dev_dbg(&acm->control->dev,
 389			"%s - urb shutting down with status: %d\n",
 390			__func__, status);
 391		return;
 392	default:
 393		dev_dbg(&acm->control->dev,
 394			"%s - nonzero urb status received: %d\n",
 395			__func__, status);
 396		goto exit;
 397	}
 398
 399	usb_mark_last_busy(acm->dev);
 400
 401	if (acm->nb_index == 0) {
 402		/*
 403		 * The first chunk of a message must contain at least the
 404		 * notification header with the length field, otherwise we
 405		 * can't get an expected_size.
 406		 */
 407		if (current_size < sizeof(struct usb_cdc_notification)) {
 408			dev_dbg(&acm->control->dev, "urb too short\n");
 409			goto exit;
 410		}
 411		dr = urb->transfer_buffer;
 412	} else {
 413		dr = (struct usb_cdc_notification *)acm->notification_buffer;
 414	}
 415	/* size = notification-header + (optional) data */
 416	expected_size = sizeof(struct usb_cdc_notification) +
 417					le16_to_cpu(dr->wLength);
 418
 419	if (acm->nb_index != 0 || current_size < expected_size) {
 420		/* notification is transmitted fragmented, reassemble */
 421		if (acm->nb_size < expected_size) {
 422			u8 *new_buffer;
 423			alloc_size = roundup_pow_of_two(expected_size);
 424			/* Final freeing is done on disconnect. */
 425			new_buffer = krealloc(acm->notification_buffer,
 426					      alloc_size, GFP_ATOMIC);
 427			if (!new_buffer) {
 428				acm->nb_index = 0;
 429				goto exit;
 430			}
 431
 432			acm->notification_buffer = new_buffer;
 433			acm->nb_size = alloc_size;
 434			dr = (struct usb_cdc_notification *)acm->notification_buffer;
 
 
 
 
 
 
 
 
 
 435		}
 436
 437		copy_size = min(current_size,
 438				expected_size - acm->nb_index);
 439
 440		memcpy(&acm->notification_buffer[acm->nb_index],
 441		       urb->transfer_buffer, copy_size);
 442		acm->nb_index += copy_size;
 443		current_size = acm->nb_index;
 444	}
 
 
 
 
 
 
 
 445
 446	if (current_size >= expected_size) {
 447		/* notification complete */
 448		acm_process_notification(acm, (unsigned char *)dr);
 449		acm->nb_index = 0;
 
 
 
 
 450	}
 451
 452exit:
 453	retval = usb_submit_urb(urb, GFP_ATOMIC);
 454	if (retval && retval != -EPERM && retval != -ENODEV)
 455		dev_err(&acm->control->dev,
 456			"%s - usb_submit_urb failed: %d\n", __func__, retval);
 457	else
 458		dev_vdbg(&acm->control->dev,
 459			"control resubmission terminated %d\n", retval);
 460}
 461
 462static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
 463{
 464	int res;
 465
 466	if (!test_and_clear_bit(index, &acm->read_urbs_free))
 467		return 0;
 468
 
 
 469	res = usb_submit_urb(acm->read_urbs[index], mem_flags);
 470	if (res) {
 471		if (res != -EPERM && res != -ENODEV) {
 472			dev_err(&acm->data->dev,
 473				"urb %d failed submission with %d\n",
 474				index, res);
 475		} else {
 476			dev_vdbg(&acm->data->dev, "intended failure %d\n", res);
 477		}
 478		set_bit(index, &acm->read_urbs_free);
 479		return res;
 480	} else {
 481		dev_vdbg(&acm->data->dev, "submitted urb %d\n", index);
 482	}
 483
 484	return 0;
 485}
 486
 487static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
 488{
 489	int res;
 490	int i;
 491
 492	for (i = 0; i < acm->rx_buflimit; ++i) {
 493		res = acm_submit_read_urb(acm, i, mem_flags);
 494		if (res)
 495			return res;
 496	}
 497
 498	return 0;
 499}
 500
 501static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 502{
 503	unsigned long flags;
 504
 505	if (!urb->actual_length)
 506		return;
 507
 508	spin_lock_irqsave(&acm->read_lock, flags);
 509	tty_insert_flip_string(&acm->port, urb->transfer_buffer,
 510			urb->actual_length);
 511	spin_unlock_irqrestore(&acm->read_lock, flags);
 
 
 512
 513	tty_flip_buffer_push(&acm->port);
 514}
 515
 516static void acm_read_bulk_callback(struct urb *urb)
 517{
 518	struct acm_rb *rb = urb->context;
 519	struct acm *acm = rb->instance;
 520	int status = urb->status;
 521	bool stopped = false;
 522	bool stalled = false;
 523	bool cooldown = false;
 524
 525	dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
 526		rb->index, urb->actual_length, status);
 527
 528	switch (status) {
 529	case 0:
 530		usb_mark_last_busy(acm->dev);
 531		acm_process_read_urb(acm, urb);
 532		break;
 533	case -EPIPE:
 534		set_bit(EVENT_RX_STALL, &acm->flags);
 535		stalled = true;
 536		break;
 537	case -ENOENT:
 538	case -ECONNRESET:
 539	case -ESHUTDOWN:
 540		dev_dbg(&acm->data->dev,
 541			"%s - urb shutting down with status: %d\n",
 542			__func__, status);
 543		stopped = true;
 544		break;
 545	case -EOVERFLOW:
 546	case -EPROTO:
 547		dev_dbg(&acm->data->dev,
 548			"%s - cooling babbling device\n", __func__);
 549		usb_mark_last_busy(acm->dev);
 550		set_bit(rb->index, &acm->urbs_in_error_delay);
 551		set_bit(ACM_ERROR_DELAY, &acm->flags);
 552		cooldown = true;
 553		break;
 554	default:
 555		dev_dbg(&acm->data->dev,
 556			"%s - nonzero urb status received: %d\n",
 557			__func__, status);
 558		break;
 559	}
 560
 561	/*
 562	 * Make sure URB processing is done before marking as free to avoid
 563	 * racing with unthrottle() on another CPU. Matches the barriers
 564	 * implied by the test_and_clear_bit() in acm_submit_read_urb().
 565	 */
 566	smp_mb__before_atomic();
 567	set_bit(rb->index, &acm->read_urbs_free);
 568	/*
 569	 * Make sure URB is marked as free before checking the throttled flag
 570	 * to avoid racing with unthrottle() on another CPU. Matches the
 571	 * smp_mb() in unthrottle().
 572	 */
 573	smp_mb__after_atomic();
 574
 575	if (stopped || stalled || cooldown) {
 576		if (stalled)
 577			schedule_delayed_work(&acm->dwork, 0);
 578		else if (cooldown)
 579			schedule_delayed_work(&acm->dwork, HZ / 2);
 580		return;
 581	}
 
 582
 583	if (test_bit(ACM_THROTTLED, &acm->flags))
 
 
 584		return;
 
 
 585
 586	acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
 
 
 
 
 
 
 
 
 587}
 588
 589/* data interface wrote those outgoing bytes */
 590static void acm_write_bulk(struct urb *urb)
 591{
 592	struct acm_wb *wb = urb->context;
 593	struct acm *acm = wb->instance;
 594	unsigned long flags;
 595	int status = urb->status;
 596
 597	if (status || (urb->actual_length != urb->transfer_buffer_length))
 598		dev_vdbg(&acm->data->dev, "wrote len %d/%d, status %d\n",
 
 599			urb->actual_length,
 600			urb->transfer_buffer_length,
 601			status);
 602
 603	spin_lock_irqsave(&acm->write_lock, flags);
 604	acm_write_done(acm, wb);
 605	spin_unlock_irqrestore(&acm->write_lock, flags);
 606	set_bit(EVENT_TTY_WAKEUP, &acm->flags);
 607	schedule_delayed_work(&acm->dwork, 0);
 608}
 609
 610static void acm_softint(struct work_struct *work)
 611{
 612	int i;
 613	struct acm *acm = container_of(work, struct acm, dwork.work);
 614
 615	if (test_bit(EVENT_RX_STALL, &acm->flags)) {
 616		smp_mb(); /* against acm_suspend() */
 617		if (!acm->susp_count) {
 618			for (i = 0; i < acm->rx_buflimit; i++)
 619				usb_kill_urb(acm->read_urbs[i]);
 620			usb_clear_halt(acm->dev, acm->in);
 621			acm_submit_read_urbs(acm, GFP_KERNEL);
 622			clear_bit(EVENT_RX_STALL, &acm->flags);
 623		}
 624	}
 625
 626	if (test_and_clear_bit(ACM_ERROR_DELAY, &acm->flags)) {
 627		for (i = 0; i < acm->rx_buflimit; i++)
 628			if (test_and_clear_bit(i, &acm->urbs_in_error_delay))
 629				acm_submit_read_urb(acm, i, GFP_KERNEL);
 630	}
 631
 632	if (test_and_clear_bit(EVENT_TTY_WAKEUP, &acm->flags))
 633		tty_port_tty_wakeup(&acm->port);
 
 
 
 634}
 635
 636/*
 637 * TTY handlers
 638 */
 639
 640static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 641{
 642	struct acm *acm;
 643	int retval;
 644
 645	acm = acm_get_by_minor(tty->index);
 
 
 646	if (!acm)
 647		return -ENODEV;
 648
 649	retval = tty_standard_install(driver, tty);
 650	if (retval)
 651		goto error_init_termios;
 652
 653	/*
 654	 * Suppress initial echoing for some devices which might send data
 655	 * immediately after acm driver has been installed.
 656	 */
 657	if (acm->quirks & DISABLE_ECHO)
 658		tty->termios.c_lflag &= ~ECHO;
 659
 660	tty->driver_data = acm;
 661
 662	return 0;
 663
 664error_init_termios:
 665	tty_port_put(&acm->port);
 666	return retval;
 667}
 668
 669static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 670{
 671	struct acm *acm = tty->driver_data;
 672
 673	return tty_port_open(&acm->port, tty, filp);
 674}
 675
 676static void acm_port_dtr_rts(struct tty_port *port, bool active)
 677{
 678	struct acm *acm = container_of(port, struct acm, port);
 679	int val;
 680	int res;
 681
 682	if (active)
 683		val = USB_CDC_CTRL_DTR | USB_CDC_CTRL_RTS;
 684	else
 685		val = 0;
 686
 687	/* FIXME: add missing ctrlout locking throughout driver */
 688	acm->ctrlout = val;
 689
 690	res = acm_set_control(acm, val);
 691	if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
 692		/* This is broken in too many devices to spam the logs */
 693		dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
 694}
 695
 696static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
 697{
 698	struct acm *acm = container_of(port, struct acm, port);
 699	int retval = -ENODEV;
 700	int i;
 
 701
 702	mutex_lock(&acm->mutex);
 703	if (acm->disconnected)
 704		goto disconnected;
 705
 706	retval = usb_autopm_get_interface(acm->control);
 707	if (retval)
 708		goto error_get_interface;
 709
 
 
 
 
 710	set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 711	acm->control->needs_remote_wakeup = 1;
 712
 713	acm->ctrlurb->dev = acm->dev;
 714	retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
 715	if (retval) {
 716		dev_err(&acm->control->dev,
 717			"%s - usb_submit_urb(ctrl irq) failed\n", __func__);
 718		goto error_submit_urb;
 719	}
 720
 721	acm_tty_set_termios(tty, NULL);
 
 
 
 
 
 722
 723	/*
 724	 * Unthrottle device in case the TTY was closed while throttled.
 725	 */
 726	clear_bit(ACM_THROTTLED, &acm->flags);
 
 
 
 727
 728	retval = acm_submit_read_urbs(acm, GFP_KERNEL);
 729	if (retval)
 730		goto error_submit_read_urbs;
 731
 732	usb_autopm_put_interface(acm->control);
 733
 734	mutex_unlock(&acm->mutex);
 735
 736	return 0;
 737
 738error_submit_read_urbs:
 739	for (i = 0; i < acm->rx_buflimit; i++)
 740		usb_kill_urb(acm->read_urbs[i]);
 
 741	usb_kill_urb(acm->ctrlurb);
 742error_submit_urb:
 743	usb_autopm_put_interface(acm->control);
 744error_get_interface:
 745disconnected:
 746	mutex_unlock(&acm->mutex);
 747
 748	return usb_translate_errors(retval);
 749}
 750
 751static void acm_port_destruct(struct tty_port *port)
 752{
 753	struct acm *acm = container_of(port, struct acm, port);
 754
 755	if (acm->minor != ACM_MINOR_INVALID)
 756		acm_release_minor(acm);
 
 
 757	usb_put_intf(acm->control);
 758	kfree(acm->country_codes);
 759	kfree(acm);
 760}
 761
 762static void acm_port_shutdown(struct tty_port *port)
 763{
 764	struct acm *acm = container_of(port, struct acm, port);
 765	struct urb *urb;
 766	struct acm_wb *wb;
 767
 768	/*
 769	 * Need to grab write_lock to prevent race with resume, but no need to
 770	 * hold it due to the tty-port initialised flag.
 771	 */
 772	acm_poison_urbs(acm);
 773	spin_lock_irq(&acm->write_lock);
 774	spin_unlock_irq(&acm->write_lock);
 775
 776	usb_autopm_get_interface_no_resume(acm->control);
 777	acm->control->needs_remote_wakeup = 0;
 778	usb_autopm_put_interface(acm->control);
 779
 780	for (;;) {
 781		urb = usb_get_from_anchor(&acm->delayed);
 782		if (!urb)
 783			break;
 784		wb = urb->context;
 785		wb->use = false;
 786		usb_autopm_put_interface_async(acm->control);
 787	}
 788
 789	acm_unpoison_urbs(acm);
 790
 791}
 792
 793static void acm_tty_cleanup(struct tty_struct *tty)
 794{
 795	struct acm *acm = tty->driver_data;
 796
 797	tty_port_put(&acm->port);
 798}
 799
 800static void acm_tty_hangup(struct tty_struct *tty)
 801{
 802	struct acm *acm = tty->driver_data;
 803
 804	tty_port_hangup(&acm->port);
 805}
 806
 807static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 808{
 809	struct acm *acm = tty->driver_data;
 810
 811	tty_port_close(&acm->port, tty, filp);
 812}
 813
 814static ssize_t acm_tty_write(struct tty_struct *tty, const u8 *buf,
 815			     size_t count)
 816{
 817	struct acm *acm = tty->driver_data;
 818	int stat;
 819	unsigned long flags;
 820	int wbn;
 821	struct acm_wb *wb;
 822
 823	if (!count)
 824		return 0;
 825
 826	dev_vdbg(&acm->data->dev, "%zu bytes from tty layer\n", count);
 827
 828	spin_lock_irqsave(&acm->write_lock, flags);
 829	wbn = acm_wb_alloc(acm);
 830	if (wbn < 0) {
 831		spin_unlock_irqrestore(&acm->write_lock, flags);
 832		return 0;
 833	}
 834	wb = &acm->wb[wbn];
 835
 836	if (!acm->dev) {
 837		wb->use = false;
 838		spin_unlock_irqrestore(&acm->write_lock, flags);
 839		return -ENODEV;
 840	}
 841
 842	count = (count > acm->writesize) ? acm->writesize : count;
 843	dev_vdbg(&acm->data->dev, "writing %zu bytes\n", count);
 844	memcpy(wb->buf, buf, count);
 845	wb->len = count;
 846
 847	stat = usb_autopm_get_interface_async(acm->control);
 848	if (stat) {
 849		wb->use = false;
 850		spin_unlock_irqrestore(&acm->write_lock, flags);
 851		return stat;
 852	}
 853
 854	if (acm->susp_count) {
 855		usb_anchor_urb(wb->urb, &acm->delayed);
 856		spin_unlock_irqrestore(&acm->write_lock, flags);
 857		return count;
 858	}
 859
 860	stat = acm_start_wb(acm, wb);
 861	spin_unlock_irqrestore(&acm->write_lock, flags);
 862
 
 863	if (stat < 0)
 864		return stat;
 865	return count;
 866}
 867
 868static unsigned int acm_tty_write_room(struct tty_struct *tty)
 869{
 870	struct acm *acm = tty->driver_data;
 871	/*
 872	 * Do not let the line discipline to know that we have a reserve,
 873	 * or it might get too enthusiastic.
 874	 */
 875	return acm_wb_is_avail(acm) ? acm->writesize : 0;
 876}
 877
 878static void acm_tty_flush_buffer(struct tty_struct *tty)
 879{
 880	struct acm *acm = tty->driver_data;
 881	unsigned long flags;
 882	int i;
 883
 884	spin_lock_irqsave(&acm->write_lock, flags);
 885	for (i = 0; i < ACM_NW; i++)
 886		if (acm->wb[i].use)
 887			usb_unlink_urb(acm->wb[i].urb);
 888	spin_unlock_irqrestore(&acm->write_lock, flags);
 889}
 890
 891static unsigned int acm_tty_chars_in_buffer(struct tty_struct *tty)
 892{
 893	struct acm *acm = tty->driver_data;
 894	/*
 895	 * if the device was unplugged then any remaining characters fell out
 896	 * of the connector ;)
 897	 */
 898	if (acm->disconnected)
 899		return 0;
 900	/*
 901	 * This is inaccurate (overcounts), but it works.
 902	 */
 903	return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 904}
 905
 906static void acm_tty_throttle(struct tty_struct *tty)
 907{
 908	struct acm *acm = tty->driver_data;
 909
 910	set_bit(ACM_THROTTLED, &acm->flags);
 
 
 911}
 912
 913static void acm_tty_unthrottle(struct tty_struct *tty)
 914{
 915	struct acm *acm = tty->driver_data;
 
 916
 917	clear_bit(ACM_THROTTLED, &acm->flags);
 
 
 
 
 918
 919	/* Matches the smp_mb__after_atomic() in acm_read_bulk_callback(). */
 920	smp_mb();
 921
 922	acm_submit_read_urbs(acm, GFP_KERNEL);
 923}
 924
 925static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 926{
 927	struct acm *acm = tty->driver_data;
 928	int retval;
 929
 930	if (!(acm->ctrl_caps & USB_CDC_CAP_BRK))
 931		return -EOPNOTSUPP;
 932
 933	retval = acm_send_break(acm, state ? 0xffff : 0);
 934	if (retval < 0)
 935		dev_dbg(&acm->control->dev,
 936			"%s - send break failed\n", __func__);
 937	return retval;
 938}
 939
 940static int acm_tty_tiocmget(struct tty_struct *tty)
 941{
 942	struct acm *acm = tty->driver_data;
 943
 944	return (acm->ctrlout & USB_CDC_CTRL_DTR ? TIOCM_DTR : 0) |
 945	       (acm->ctrlout & USB_CDC_CTRL_RTS ? TIOCM_RTS : 0) |
 946	       (acm->ctrlin  & USB_CDC_SERIAL_STATE_DSR ? TIOCM_DSR : 0) |
 947	       (acm->ctrlin  & USB_CDC_SERIAL_STATE_RING_SIGNAL ? TIOCM_RI : 0) |
 948	       (acm->ctrlin  & USB_CDC_SERIAL_STATE_DCD ? TIOCM_CD : 0) |
 949	       TIOCM_CTS;
 950}
 951
 952static int acm_tty_tiocmset(struct tty_struct *tty,
 953			    unsigned int set, unsigned int clear)
 954{
 955	struct acm *acm = tty->driver_data;
 956	unsigned int newctrl;
 957
 958	newctrl = acm->ctrlout;
 959	set = (set & TIOCM_DTR ? USB_CDC_CTRL_DTR : 0) |
 960	      (set & TIOCM_RTS ? USB_CDC_CTRL_RTS : 0);
 961	clear = (clear & TIOCM_DTR ? USB_CDC_CTRL_DTR : 0) |
 962		(clear & TIOCM_RTS ? USB_CDC_CTRL_RTS : 0);
 963
 964	newctrl = (newctrl & ~clear) | set;
 965
 966	if (acm->ctrlout == newctrl)
 967		return 0;
 968	return acm_set_control(acm, acm->ctrlout = newctrl);
 969}
 970
 971static int get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
 972{
 973	struct acm *acm = tty->driver_data;
 974
 975	ss->line = acm->minor;
 976	mutex_lock(&acm->port.mutex);
 977	ss->close_delay	= jiffies_to_msecs(acm->port.close_delay) / 10;
 978	ss->closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 979				ASYNC_CLOSING_WAIT_NONE :
 980				jiffies_to_msecs(acm->port.closing_wait) / 10;
 981	mutex_unlock(&acm->port.mutex);
 982	return 0;
 983}
 984
 985static int set_serial_info(struct tty_struct *tty, struct serial_struct *ss)
 986{
 987	struct acm *acm = tty->driver_data;
 988	unsigned int closing_wait, close_delay;
 989	int retval = 0;
 990
 991	close_delay = msecs_to_jiffies(ss->close_delay * 10);
 992	closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 993			ASYNC_CLOSING_WAIT_NONE :
 994			msecs_to_jiffies(ss->closing_wait * 10);
 995
 996	mutex_lock(&acm->port.mutex);
 997
 998	if (!capable(CAP_SYS_ADMIN)) {
 999		if ((close_delay != acm->port.close_delay) ||
1000		    (closing_wait != acm->port.closing_wait))
1001			retval = -EPERM;
1002	} else {
1003		acm->port.close_delay  = close_delay;
1004		acm->port.closing_wait = closing_wait;
1005	}
1006
1007	mutex_unlock(&acm->port.mutex);
1008	return retval;
1009}
1010
1011static int wait_serial_change(struct acm *acm, unsigned long arg)
1012{
1013	int rv = 0;
1014	DECLARE_WAITQUEUE(wait, current);
1015	struct async_icount old, new;
1016
1017	do {
1018		spin_lock_irq(&acm->read_lock);
1019		old = acm->oldcount;
1020		new = acm->iocount;
1021		acm->oldcount = new;
1022		spin_unlock_irq(&acm->read_lock);
1023
1024		if ((arg & TIOCM_DSR) &&
1025			old.dsr != new.dsr)
1026			break;
1027		if ((arg & TIOCM_CD)  &&
1028			old.dcd != new.dcd)
1029			break;
1030		if ((arg & TIOCM_RI) &&
1031			old.rng != new.rng)
1032			break;
1033
1034		add_wait_queue(&acm->wioctl, &wait);
1035		set_current_state(TASK_INTERRUPTIBLE);
1036		schedule();
1037		remove_wait_queue(&acm->wioctl, &wait);
1038		if (acm->disconnected) {
1039			if (arg & TIOCM_CD)
1040				break;
1041			else
1042				rv = -ENODEV;
1043		} else {
1044			if (signal_pending(current))
1045				rv = -ERESTARTSYS;
1046		}
1047	} while (!rv);
1048
1049	
1050
1051	return rv;
1052}
1053
1054static int acm_tty_get_icount(struct tty_struct *tty,
1055					struct serial_icounter_struct *icount)
1056{
1057	struct acm *acm = tty->driver_data;
1058
1059	icount->dsr = acm->iocount.dsr;
1060	icount->rng = acm->iocount.rng;
1061	icount->dcd = acm->iocount.dcd;
1062	icount->frame = acm->iocount.frame;
1063	icount->overrun = acm->iocount.overrun;
1064	icount->parity = acm->iocount.parity;
1065	icount->brk = acm->iocount.brk;
1066
1067	return 0;
 
 
 
1068}
1069
1070static int acm_tty_ioctl(struct tty_struct *tty,
1071					unsigned int cmd, unsigned long arg)
1072{
1073	struct acm *acm = tty->driver_data;
1074	int rv = -ENOIOCTLCMD;
1075
1076	switch (cmd) {
1077	case TIOCMIWAIT:
1078		rv = usb_autopm_get_interface(acm->control);
1079		if (rv < 0) {
1080			rv = -EIO;
1081			break;
1082		}
1083		rv = wait_serial_change(acm, arg);
1084		usb_autopm_put_interface(acm->control);
1085		break;
1086	}
1087
1088	return rv;
1089}
1090
 
 
 
 
 
 
 
 
 
 
 
 
1091static void acm_tty_set_termios(struct tty_struct *tty,
1092				const struct ktermios *termios_old)
1093{
1094	struct acm *acm = tty->driver_data;
1095	struct ktermios *termios = &tty->termios;
1096	struct usb_cdc_line_coding newline;
1097	int newctrl = acm->ctrlout;
1098
1099	newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
1100	newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
1101	newline.bParityType = termios->c_cflag & PARENB ?
1102				(termios->c_cflag & PARODD ? 1 : 2) +
1103				(termios->c_cflag & CMSPAR ? 2 : 0) : 0;
1104	newline.bDataBits = tty_get_char_size(termios->c_cflag);
1105
1106	/* FIXME: Needs to clear unsupported bits in the termios */
1107	acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
1108
1109	if (C_BAUD(tty) == B0) {
1110		newline.dwDTERate = acm->line.dwDTERate;
1111		newctrl &= ~USB_CDC_CTRL_DTR;
1112	} else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
1113		newctrl |=  USB_CDC_CTRL_DTR;
1114	}
1115
1116	if (newctrl != acm->ctrlout)
1117		acm_set_control(acm, acm->ctrlout = newctrl);
1118
1119	if (memcmp(&acm->line, &newline, sizeof newline)) {
1120		memcpy(&acm->line, &newline, sizeof newline);
1121		dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
1122			__func__,
1123			le32_to_cpu(newline.dwDTERate),
1124			newline.bCharFormat, newline.bParityType,
1125			newline.bDataBits);
1126		acm_set_line(acm, &acm->line);
1127	}
1128}
1129
1130static const struct tty_port_operations acm_port_ops = {
1131	.dtr_rts = acm_port_dtr_rts,
1132	.shutdown = acm_port_shutdown,
1133	.activate = acm_port_activate,
1134	.destruct = acm_port_destruct,
1135};
1136
1137/*
1138 * USB probe and disconnect routines.
1139 */
1140
1141/* Little helpers: write/read buffers free */
1142static void acm_write_buffers_free(struct acm *acm)
1143{
1144	int i;
1145	struct acm_wb *wb;
 
1146
1147	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
1148		usb_free_coherent(acm->dev, acm->writesize, wb->buf, wb->dmah);
1149}
1150
1151static void acm_read_buffers_free(struct acm *acm)
1152{
 
1153	int i;
1154
1155	for (i = 0; i < acm->rx_buflimit; i++)
1156		usb_free_coherent(acm->dev, acm->readsize,
1157			  acm->read_buffers[i].base, acm->read_buffers[i].dma);
1158}
1159
1160/* Little helper: write buffers allocate */
1161static int acm_write_buffers_alloc(struct acm *acm)
1162{
1163	int i;
1164	struct acm_wb *wb;
1165
1166	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
1167		wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
1168		    &wb->dmah);
1169		if (!wb->buf) {
1170			while (i != 0) {
1171				--i;
1172				--wb;
1173				usb_free_coherent(acm->dev, acm->writesize,
1174				    wb->buf, wb->dmah);
1175			}
1176			return -ENOMEM;
1177		}
1178	}
1179	return 0;
1180}
1181
1182static int acm_probe(struct usb_interface *intf,
1183		     const struct usb_device_id *id)
1184{
1185	struct usb_cdc_union_desc *union_header = NULL;
1186	struct usb_cdc_call_mgmt_descriptor *cmgmd = NULL;
1187	unsigned char *buffer = intf->altsetting->extra;
1188	int buflen = intf->altsetting->extralen;
1189	struct usb_interface *control_interface;
1190	struct usb_interface *data_interface;
1191	struct usb_endpoint_descriptor *epctrl = NULL;
1192	struct usb_endpoint_descriptor *epread = NULL;
1193	struct usb_endpoint_descriptor *epwrite = NULL;
1194	struct usb_device *usb_dev = interface_to_usbdev(intf);
1195	struct usb_cdc_parsed_header h;
1196	struct acm *acm;
1197	int minor;
1198	int ctrlsize, readsize;
1199	u8 *buf;
1200	int call_intf_num = -1;
1201	int data_intf_num = -1;
 
 
1202	unsigned long quirks;
1203	int num_rx_buf;
1204	int i;
1205	int combined_interfaces = 0;
1206	struct device *tty_dev;
1207	int rv = -ENOMEM;
1208	int res;
1209
1210	/* normal quirks */
1211	quirks = (unsigned long)id->driver_info;
1212
1213	if (quirks == IGNORE_DEVICE)
1214		return -ENODEV;
1215
1216	memset(&h, 0x00, sizeof(struct usb_cdc_parsed_header));
1217
1218	num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
1219
1220	/* handle quirks deadly to normal probing*/
1221	if (quirks == NO_UNION_NORMAL) {
1222		data_interface = usb_ifnum_to_if(usb_dev, 1);
1223		control_interface = usb_ifnum_to_if(usb_dev, 0);
1224		/* we would crash */
1225		if (!data_interface || !control_interface)
1226			return -ENODEV;
1227		goto skip_normal_probe;
1228	}
1229
1230	/* normal probing*/
1231	if (!buffer) {
1232		dev_err(&intf->dev, "Weird descriptor references\n");
1233		return -EINVAL;
1234	}
1235
1236	if (!buflen) {
1237		if (intf->cur_altsetting->endpoint &&
1238				intf->cur_altsetting->endpoint->extralen &&
1239				intf->cur_altsetting->endpoint->extra) {
1240			dev_dbg(&intf->dev,
1241				"Seeking extra descriptors on endpoint\n");
1242			buflen = intf->cur_altsetting->endpoint->extralen;
1243			buffer = intf->cur_altsetting->endpoint->extra;
1244		} else {
1245			dev_err(&intf->dev,
1246				"Zero length descriptor references\n");
1247			return -EINVAL;
1248		}
1249	}
1250
1251	cdc_parse_cdc_header(&h, intf, buffer, buflen);
1252	union_header = h.usb_cdc_union_desc;
1253	cmgmd = h.usb_cdc_call_mgmt_descriptor;
1254	if (cmgmd)
1255		call_intf_num = cmgmd->bDataInterface;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1256
1257	if (!union_header) {
1258		if (intf->cur_altsetting->desc.bNumEndpoints == 3) {
1259			dev_dbg(&intf->dev, "No union descriptor, assuming single interface\n");
1260			combined_interfaces = 1;
1261			control_interface = data_interface = intf;
1262			goto look_for_collapsed_interface;
1263		} else if (call_intf_num > 0) {
1264			dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1265			data_intf_num = call_intf_num;
1266			data_interface = usb_ifnum_to_if(usb_dev, data_intf_num);
 
 
 
1267			control_interface = intf;
1268		} else {
1269			dev_dbg(&intf->dev, "No union descriptor, giving up\n");
1270			return -ENODEV;
 
 
 
 
 
 
 
1271		}
1272	} else {
1273		int class = -1;
1274
1275		data_intf_num = union_header->bSlaveInterface0;
1276		control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1277		data_interface = usb_ifnum_to_if(usb_dev, data_intf_num);
1278
1279		if (control_interface)
1280			class = control_interface->cur_altsetting->desc.bInterfaceClass;
1281
1282		if (class != USB_CLASS_COMM && class != USB_CLASS_CDC_DATA) {
1283			dev_dbg(&intf->dev, "Broken union descriptor, assuming single interface\n");
1284			combined_interfaces = 1;
1285			control_interface = data_interface = intf;
1286			goto look_for_collapsed_interface;
1287		}
1288	}
1289
1290	if (!control_interface || !data_interface) {
1291		dev_dbg(&intf->dev, "no interfaces\n");
1292		return -ENODEV;
1293	}
1294
1295	if (data_intf_num != call_intf_num)
1296		dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1297
1298	if (control_interface == data_interface) {
1299		/* some broken devices designed for windows work this way */
1300		dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1301		combined_interfaces = 1;
1302		/* a popular other OS doesn't use it */
1303		quirks |= NO_CAP_LINE;
1304		if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1305			dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1306			return -EINVAL;
1307		}
1308look_for_collapsed_interface:
1309		res = usb_find_common_endpoints(data_interface->cur_altsetting,
1310				&epread, &epwrite, &epctrl, NULL);
1311		if (res)
1312			return res;
1313
1314		goto made_compressed_probe;
 
 
 
 
 
 
 
 
 
 
 
1315	}
1316
1317skip_normal_probe:
1318
1319	/*workaround for switched interfaces */
1320	if (data_interface->cur_altsetting->desc.bInterfaceClass != USB_CLASS_CDC_DATA) {
1321		if (control_interface->cur_altsetting->desc.bInterfaceClass == USB_CLASS_CDC_DATA) {
 
 
 
1322			dev_dbg(&intf->dev,
1323				"Your device has switched interfaces.\n");
1324			swap(control_interface, data_interface);
 
 
1325		} else {
1326			return -EINVAL;
1327		}
1328	}
1329
1330	/* Accept probe requests only for the control interface */
1331	if (!combined_interfaces && intf != control_interface)
1332		return -ENODEV;
1333
 
 
 
 
 
 
 
1334	if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1335	    control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1336		return -EINVAL;
1337
1338	epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1339	epread = &data_interface->cur_altsetting->endpoint[0].desc;
1340	epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1341
1342
1343	/* workaround for switched endpoints */
1344	if (!usb_endpoint_dir_in(epread)) {
1345		/* descriptors are swapped */
 
1346		dev_dbg(&intf->dev,
1347			"The data interface has switched endpoints\n");
1348		swap(epread, epwrite);
 
 
1349	}
1350made_compressed_probe:
1351	dev_dbg(&intf->dev, "interfaces are valid\n");
1352
1353	acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1354	if (!acm)
1355		return -ENOMEM;
 
 
1356
1357	tty_port_init(&acm->port);
1358	acm->port.ops = &acm_port_ops;
 
 
 
 
1359
1360	ctrlsize = usb_endpoint_maxp(epctrl);
1361	readsize = usb_endpoint_maxp(epread) *
1362				(quirks == SINGLE_RX_URB ? 1 : 2);
1363	acm->combined_interfaces = combined_interfaces;
1364	acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1365	acm->control = control_interface;
1366	acm->data = data_interface;
1367
1368	usb_get_intf(acm->control); /* undone in destruct() */
1369
1370	minor = acm_alloc_minor(acm);
1371	if (minor < 0) {
1372		acm->minor = ACM_MINOR_INVALID;
1373		goto err_put_port;
1374	}
1375
1376	acm->minor = minor;
1377	acm->dev = usb_dev;
1378	if (h.usb_cdc_acm_descriptor)
1379		acm->ctrl_caps = h.usb_cdc_acm_descriptor->bmCapabilities;
1380	if (quirks & NO_CAP_LINE)
1381		acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1382	acm->ctrlsize = ctrlsize;
1383	acm->readsize = readsize;
1384	acm->rx_buflimit = num_rx_buf;
1385	INIT_DELAYED_WORK(&acm->dwork, acm_softint);
1386	init_waitqueue_head(&acm->wioctl);
1387	spin_lock_init(&acm->write_lock);
1388	spin_lock_init(&acm->read_lock);
1389	mutex_init(&acm->mutex);
1390	if (usb_endpoint_xfer_int(epread)) {
 
 
1391		acm->bInterval = epread->bInterval;
1392		acm->in = usb_rcvintpipe(usb_dev, epread->bEndpointAddress);
1393	} else {
1394		acm->in = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1395	}
1396	if (usb_endpoint_xfer_int(epwrite))
1397		acm->out = usb_sndintpipe(usb_dev, epwrite->bEndpointAddress);
1398	else
1399		acm->out = usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress);
1400	init_usb_anchor(&acm->delayed);
1401	acm->quirks = quirks;
1402
1403	buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1404	if (!buf)
1405		goto err_put_port;
 
 
1406	acm->ctrl_buffer = buf;
1407
1408	if (acm_write_buffers_alloc(acm) < 0)
1409		goto err_free_ctrl_buffer;
 
 
1410
1411	acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1412	if (!acm->ctrlurb)
1413		goto err_free_write_buffers;
1414
 
1415	for (i = 0; i < num_rx_buf; i++) {
1416		struct acm_rb *rb = &(acm->read_buffers[i]);
1417		struct urb *urb;
1418
1419		rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1420								&rb->dma);
1421		if (!rb->base)
1422			goto err_free_read_urbs;
 
 
 
1423		rb->index = i;
1424		rb->instance = acm;
1425
1426		urb = usb_alloc_urb(0, GFP_KERNEL);
1427		if (!urb)
1428			goto err_free_read_urbs;
1429
 
 
1430		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1431		urb->transfer_dma = rb->dma;
1432		if (usb_endpoint_xfer_int(epread))
1433			usb_fill_int_urb(urb, acm->dev, acm->in, rb->base,
 
 
1434					 acm->readsize,
1435					 acm_read_bulk_callback, rb,
1436					 acm->bInterval);
1437		else
1438			usb_fill_bulk_urb(urb, acm->dev, acm->in, rb->base,
 
 
1439					  acm->readsize,
1440					  acm_read_bulk_callback, rb);
 
1441
1442		acm->read_urbs[i] = urb;
1443		__set_bit(i, &acm->read_urbs_free);
1444	}
1445	for (i = 0; i < ACM_NW; i++) {
1446		struct acm_wb *snd = &(acm->wb[i]);
1447
1448		snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1449		if (!snd->urb)
1450			goto err_free_write_urbs;
 
 
 
1451
1452		if (usb_endpoint_xfer_int(epwrite))
1453			usb_fill_int_urb(snd->urb, usb_dev, acm->out,
 
1454				NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1455		else
1456			usb_fill_bulk_urb(snd->urb, usb_dev, acm->out,
 
1457				NULL, acm->writesize, acm_write_bulk, snd);
1458		snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1459		if (quirks & SEND_ZERO_PACKET)
1460			snd->urb->transfer_flags |= URB_ZERO_PACKET;
1461		snd->instance = acm;
1462	}
1463
1464	usb_set_intfdata(intf, acm);
1465
1466	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1467	if (i < 0)
1468		goto err_free_write_urbs;
1469
1470	if (h.usb_cdc_country_functional_desc) { /* export the country data */
1471		struct usb_cdc_country_functional_desc * cfd =
1472					h.usb_cdc_country_functional_desc;
1473
 
1474		acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1475		if (!acm->country_codes)
1476			goto skip_countries;
1477		acm->country_code_size = cfd->bLength - 4;
1478		memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1479							cfd->bLength - 4);
1480		acm->country_rel_date = cfd->iCountryCodeRelDate;
1481
1482		i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1483		if (i < 0) {
1484			kfree(acm->country_codes);
1485			acm->country_codes = NULL;
1486			acm->country_code_size = 0;
1487			goto skip_countries;
1488		}
1489
1490		i = device_create_file(&intf->dev,
1491						&dev_attr_iCountryCodeRelDate);
1492		if (i < 0) {
1493			device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1494			kfree(acm->country_codes);
1495			acm->country_codes = NULL;
1496			acm->country_code_size = 0;
1497			goto skip_countries;
1498		}
1499	}
1500
1501skip_countries:
1502	usb_fill_int_urb(acm->ctrlurb, usb_dev,
1503			 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1504			 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1505			 /* works around buggy devices */
1506			 epctrl->bInterval ? epctrl->bInterval : 16);
1507	acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1508	acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1509	acm->notification_buffer = NULL;
1510	acm->nb_index = 0;
1511	acm->nb_size = 0;
 
1512
1513	acm->line.dwDTERate = cpu_to_le32(9600);
1514	acm->line.bDataBits = 8;
1515	acm_set_line(acm, &acm->line);
1516
1517	if (!acm->combined_interfaces) {
1518		rv = usb_driver_claim_interface(&acm_driver, data_interface, acm);
1519		if (rv)
1520			goto err_remove_files;
1521	}
1522
1523	tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
1524			&control_interface->dev);
1525	if (IS_ERR(tty_dev)) {
1526		rv = PTR_ERR(tty_dev);
1527		goto err_release_data_interface;
1528	}
1529
1530	if (quirks & CLEAR_HALT_CONDITIONS) {
1531		usb_clear_halt(usb_dev, acm->in);
1532		usb_clear_halt(usb_dev, acm->out);
1533	}
1534
1535	dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 
1536
1537	return 0;
1538
1539err_release_data_interface:
1540	if (!acm->combined_interfaces) {
1541		/* Clear driver data so that disconnect() returns early. */
1542		usb_set_intfdata(data_interface, NULL);
1543		usb_driver_release_interface(&acm_driver, data_interface);
1544	}
1545err_remove_files:
1546	if (acm->country_codes) {
1547		device_remove_file(&acm->control->dev,
1548				&dev_attr_wCountryCodes);
1549		device_remove_file(&acm->control->dev,
1550				&dev_attr_iCountryCodeRelDate);
1551	}
1552	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1553err_free_write_urbs:
1554	for (i = 0; i < ACM_NW; i++)
1555		usb_free_urb(acm->wb[i].urb);
1556err_free_read_urbs:
1557	for (i = 0; i < num_rx_buf; i++)
1558		usb_free_urb(acm->read_urbs[i]);
1559	acm_read_buffers_free(acm);
1560	usb_free_urb(acm->ctrlurb);
1561err_free_write_buffers:
1562	acm_write_buffers_free(acm);
1563err_free_ctrl_buffer:
1564	usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1565err_put_port:
1566	tty_port_put(&acm->port);
 
 
 
 
1567
1568	return rv;
 
 
 
 
 
 
 
 
 
 
 
 
1569}
1570
1571static void acm_disconnect(struct usb_interface *intf)
1572{
1573	struct acm *acm = usb_get_intfdata(intf);
 
1574	struct tty_struct *tty;
1575	int i;
1576
 
 
1577	/* sibling interface is already cleaning up */
1578	if (!acm)
1579		return;
1580
1581	acm->disconnected = true;
1582	/*
1583	 * there is a circular dependency. acm_softint() can resubmit
1584	 * the URBs in error handling so we need to block any
1585	 * submission right away
1586	 */
1587	acm_poison_urbs(acm);
1588	mutex_lock(&acm->mutex);
 
1589	if (acm->country_codes) {
1590		device_remove_file(&acm->control->dev,
1591				&dev_attr_wCountryCodes);
1592		device_remove_file(&acm->control->dev,
1593				&dev_attr_iCountryCodeRelDate);
1594	}
1595	wake_up_all(&acm->wioctl);
1596	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1597	usb_set_intfdata(acm->control, NULL);
1598	usb_set_intfdata(acm->data, NULL);
1599	mutex_unlock(&acm->mutex);
1600
1601	tty = tty_port_tty_get(&acm->port);
1602	if (tty) {
1603		tty_vhangup(tty);
1604		tty_kref_put(tty);
1605	}
1606
1607	cancel_delayed_work_sync(&acm->dwork);
1608
1609	tty_unregister_device(acm_tty_driver, acm->minor);
1610
1611	usb_free_urb(acm->ctrlurb);
1612	for (i = 0; i < ACM_NW; i++)
1613		usb_free_urb(acm->wb[i].urb);
1614	for (i = 0; i < acm->rx_buflimit; i++)
1615		usb_free_urb(acm->read_urbs[i]);
1616	acm_write_buffers_free(acm);
1617	usb_free_coherent(acm->dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1618	acm_read_buffers_free(acm);
1619
1620	kfree(acm->notification_buffer);
1621
1622	if (!acm->combined_interfaces)
1623		usb_driver_release_interface(&acm_driver, intf == acm->control ?
1624					acm->data : acm->control);
1625
1626	tty_port_put(&acm->port);
1627}
1628
1629#ifdef CONFIG_PM
1630static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1631{
1632	struct acm *acm = usb_get_intfdata(intf);
1633	int cnt;
1634
1635	spin_lock_irq(&acm->write_lock);
1636	if (PMSG_IS_AUTO(message)) {
1637		if (acm->transmitting) {
1638			spin_unlock_irq(&acm->write_lock);
 
 
 
 
1639			return -EBUSY;
1640		}
1641	}
 
 
 
1642	cnt = acm->susp_count++;
1643	spin_unlock_irq(&acm->write_lock);
 
1644
1645	if (cnt)
1646		return 0;
1647
1648	acm_poison_urbs(acm);
1649	cancel_delayed_work_sync(&acm->dwork);
1650	acm->urbs_in_error_delay = 0;
1651
1652	return 0;
1653}
1654
1655static int acm_resume(struct usb_interface *intf)
1656{
1657	struct acm *acm = usb_get_intfdata(intf);
1658	struct urb *urb;
1659	int rv = 0;
 
1660
1661	spin_lock_irq(&acm->write_lock);
1662
1663	if (--acm->susp_count)
1664		goto out;
1665
1666	acm_unpoison_urbs(acm);
1667
1668	if (tty_port_initialized(&acm->port)) {
1669		rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1670
1671		for (;;) {
1672			urb = usb_get_from_anchor(&acm->delayed);
1673			if (!urb)
1674				break;
1675
1676			acm_start_wb(acm, urb->context);
 
 
 
 
 
 
 
1677		}
1678
1679		/*
1680		 * delayed error checking because we must
1681		 * do the write path at all cost
1682		 */
1683		if (rv < 0)
1684			goto out;
1685
1686		rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1687	}
1688out:
1689	spin_unlock_irq(&acm->write_lock);
1690
 
1691	return rv;
1692}
1693
1694static int acm_reset_resume(struct usb_interface *intf)
1695{
1696	struct acm *acm = usb_get_intfdata(intf);
 
1697
1698	if (tty_port_initialized(&acm->port))
1699		tty_port_tty_hangup(&acm->port, false);
 
 
 
 
 
1700
1701	return acm_resume(intf);
1702}
1703
1704#endif /* CONFIG_PM */
1705
1706static int acm_pre_reset(struct usb_interface *intf)
1707{
1708	struct acm *acm = usb_get_intfdata(intf);
1709
1710	clear_bit(EVENT_RX_STALL, &acm->flags);
1711	acm->nb_index = 0; /* pending control transfers are lost */
1712
1713	return 0;
1714}
1715
1716#define NOKIA_PCSUITE_ACM_INFO(x) \
1717		USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1718		USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1719		USB_CDC_ACM_PROTO_VENDOR)
1720
1721#define SAMSUNG_PCSUITE_ACM_INFO(x) \
1722		USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1723		USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1724		USB_CDC_ACM_PROTO_VENDOR)
1725
1726/*
1727 * USB driver structure.
1728 */
1729
1730static const struct usb_device_id acm_ids[] = {
1731	/* quirky and broken devices */
1732	{ USB_DEVICE(0x0424, 0x274e), /* Microchip Technology, Inc. (formerly SMSC) */
1733	  .driver_info = DISABLE_ECHO, }, /* DISABLE ECHO in termios flag */
1734	{ USB_DEVICE(0x076d, 0x0006), /* Denso Cradle CU-321 */
1735	.driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1736	{ USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
1737	.driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1738	{ USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1739	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1740	},
1741	{ USB_DEVICE(0x045b, 0x023c),	/* Renesas R-Car H3 USB Download mode */
1742	.driver_info = DISABLE_ECHO,	/* Don't echo banner */
1743	},
1744	{ USB_DEVICE(0x045b, 0x0247),	/* Renesas R-Car D3 USB Download mode */
1745	.driver_info = DISABLE_ECHO,	/* Don't echo banner */
1746	},
1747	{ USB_DEVICE(0x045b, 0x0248),	/* Renesas R-Car M3-N USB Download mode */
1748	.driver_info = DISABLE_ECHO,	/* Don't echo banner */
1749	},
1750	{ USB_DEVICE(0x045b, 0x024D),	/* Renesas R-Car E3 USB Download mode */
1751	.driver_info = DISABLE_ECHO,	/* Don't echo banner */
1752	},
1753	{ USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1754	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1755	},
1756	{ USB_DEVICE(0x0e8d, 0x2000), /* MediaTek Inc Preloader */
1757	.driver_info = DISABLE_ECHO, /* DISABLE ECHO in termios flag */
1758	},
1759	{ USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1760	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1761	},
1762	{ USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1763	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1764	},
1765	{ USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1766	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1767	},
1768	{ USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1769	.driver_info = SINGLE_RX_URB,
1770	},
1771	{ USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1772	.driver_info = SINGLE_RX_URB, /* firmware bug */
1773	},
1774	{ USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1775	.driver_info = SINGLE_RX_URB, /* firmware bug */
1776	},
1777	{ USB_DEVICE(0x11ca, 0x0201), /* VeriFone Mx870 Gadget Serial */
1778	.driver_info = SINGLE_RX_URB,
1779	},
1780	{ USB_DEVICE(0x1901, 0x0006), /* GE Healthcare Patient Monitor UI Controller */
1781	.driver_info = DISABLE_ECHO, /* DISABLE ECHO in termios flag */
1782	},
1783	{ USB_DEVICE(0x1965, 0x0018), /* Uniden UBC125XLT */
1784	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1785	},
1786	{ USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1787	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1788	},
1789	{ USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1790	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1791	},
1792	{ USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1793	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1794	},
1795	{ USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1796	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1797	},
1798	{ USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1799	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1800	},
1801	{ USB_DEVICE(0x0572, 0x1349), /* Hiro (Conexant) USB MODEM H50228 */
1802	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1803	},
1804	{ USB_DEVICE(0x20df, 0x0001), /* Simtec Electronics Entropy Key */
1805	.driver_info = QUIRK_CONTROL_LINE_STATE, },
1806	{ USB_DEVICE(0x2184, 0x001c) },	/* GW Instek AFG-2225 */
1807	{ USB_DEVICE(0x2184, 0x0036) },	/* GW Instek AFG-125 */
1808	{ USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1809	},
1810	/* Motorola H24 HSPA module: */
1811	{ USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1812	{ USB_DEVICE(0x22b8, 0x2d92),   /* modem           + diagnostics        */
1813	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1814	},
1815	{ USB_DEVICE(0x22b8, 0x2d93),   /* modem + AT port                      */
1816	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1817	},
1818	{ USB_DEVICE(0x22b8, 0x2d95),   /* modem + AT port + diagnostics        */
1819	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1820	},
1821	{ USB_DEVICE(0x22b8, 0x2d96),   /* modem                         + NMEA */
1822	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1823	},
1824	{ USB_DEVICE(0x22b8, 0x2d97),   /* modem           + diagnostics + NMEA */
1825	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1826	},
1827	{ USB_DEVICE(0x22b8, 0x2d99),   /* modem + AT port               + NMEA */
1828	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1829	},
1830	{ USB_DEVICE(0x22b8, 0x2d9a),   /* modem + AT port + diagnostics + NMEA */
1831	.driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1832	},
1833
1834	{ USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1835	.driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1836					   data interface instead of
1837					   communications interface.
1838					   Maybe we should define a new
1839					   quirk for this. */
1840	},
1841	{ USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1842	.driver_info = NO_UNION_NORMAL,
1843	},
1844	{ USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1845	.driver_info = NO_UNION_NORMAL,
1846	},
1847	{ USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1848	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1849	},
1850	{ USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1851	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1852	},
1853	{ USB_DEVICE(0xfff0, 0x0100), /* DATECS FP-2000 */
1854	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1855	},
1856	{ USB_DEVICE(0x09d8, 0x0320), /* Elatec GmbH TWN3 */
1857	.driver_info = NO_UNION_NORMAL, /* has misplaced union descriptor */
1858	},
1859	{ USB_DEVICE(0x0c26, 0x0020), /* Icom ICF3400 Serie */
1860	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1861	},
1862	{ USB_DEVICE(0x0ca6, 0xa050), /* Castles VEGA3000 */
1863	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1864	},
1865
1866	{ USB_DEVICE(0x2912, 0x0001), /* ATOL FPrint */
1867	.driver_info = CLEAR_HALT_CONDITIONS,
1868	},
1869
1870	/* Nokia S60 phones expose two ACM channels. The first is
1871	 * a modem and is picked up by the standard AT-command
1872	 * information below. The second is 'vendor-specific' but
1873	 * is treated as a serial device at the S60 end, so we want
1874	 * to expose it on Linux too. */
1875	{ NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1876	{ NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1877	{ NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1878	{ NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1879	{ NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1880	{ NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1881	{ NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1882	{ NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1883	{ NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1884	{ NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1885	{ NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1886	{ NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1887	{ NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1888	{ NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1889	{ NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1890	{ NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1891	{ NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1892	{ NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1893	{ NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1894	{ NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1895	{ NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1896	{ NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1897	{ NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1898	{ NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1899	{ NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1900	{ NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1901	{ NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1902	{ NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1903	{ NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1904	{ NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1905	{ NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1906	{ NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
 
1907	{ NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1908	{ NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1909	{ NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1910	{ NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1911	{ NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1912	{ NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1913	{ NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1914	{ NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1915	{ NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1916	{ NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1917	{ NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1918	{ NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1919	{ NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1920	{ NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1921	{ NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1922	{ NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1923	{ NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1924	{ NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1925	{ NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1926	{ NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1927	{ NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1928	{ NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1929	{ NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1930	{ NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1931	{ SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1932
1933	/* Support for Owen devices */
1934	{ USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1935
1936	/* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1937
1938#if IS_ENABLED(CONFIG_INPUT_IMS_PCU)
1939	{ USB_DEVICE(0x04d8, 0x0082),	/* Application mode */
1940	.driver_info = IGNORE_DEVICE,
1941	},
1942	{ USB_DEVICE(0x04d8, 0x0083),	/* Bootloader mode */
1943	.driver_info = IGNORE_DEVICE,
1944	},
1945#endif
1946
1947#if IS_ENABLED(CONFIG_IR_TOY)
1948	{ USB_DEVICE(0x04d8, 0xfd08),
1949	.driver_info = IGNORE_DEVICE,
1950	},
1951
1952	{ USB_DEVICE(0x04d8, 0xf58b),
1953	.driver_info = IGNORE_DEVICE,
1954	},
1955#endif
1956
1957#if IS_ENABLED(CONFIG_USB_SERIAL_XR)
1958	{ USB_DEVICE(0x04e2, 0x1400), .driver_info = IGNORE_DEVICE },
1959	{ USB_DEVICE(0x04e2, 0x1401), .driver_info = IGNORE_DEVICE },
1960	{ USB_DEVICE(0x04e2, 0x1402), .driver_info = IGNORE_DEVICE },
1961	{ USB_DEVICE(0x04e2, 0x1403), .driver_info = IGNORE_DEVICE },
1962	{ USB_DEVICE(0x04e2, 0x1410), .driver_info = IGNORE_DEVICE },
1963	{ USB_DEVICE(0x04e2, 0x1411), .driver_info = IGNORE_DEVICE },
1964	{ USB_DEVICE(0x04e2, 0x1412), .driver_info = IGNORE_DEVICE },
1965	{ USB_DEVICE(0x04e2, 0x1414), .driver_info = IGNORE_DEVICE },
1966	{ USB_DEVICE(0x04e2, 0x1420), .driver_info = IGNORE_DEVICE },
1967	{ USB_DEVICE(0x04e2, 0x1422), .driver_info = IGNORE_DEVICE },
1968	{ USB_DEVICE(0x04e2, 0x1424), .driver_info = IGNORE_DEVICE },
1969#endif
1970
1971	/*Samsung phone in firmware update mode */
1972	{ USB_DEVICE(0x04e8, 0x685d),
1973	.driver_info = IGNORE_DEVICE,
1974	},
1975
1976	/* Exclude Infineon Flash Loader utility */
1977	{ USB_DEVICE(0x058b, 0x0041),
1978	.driver_info = IGNORE_DEVICE,
1979	},
1980
1981	/* Exclude ETAS ES58x */
1982	{ USB_DEVICE(0x108c, 0x0159), /* ES581.4 */
1983	.driver_info = IGNORE_DEVICE,
1984	},
1985	{ USB_DEVICE(0x108c, 0x0168), /* ES582.1 */
1986	.driver_info = IGNORE_DEVICE,
1987	},
1988	{ USB_DEVICE(0x108c, 0x0169), /* ES584.1 */
1989	.driver_info = IGNORE_DEVICE,
1990	},
1991
1992	{ USB_DEVICE(0x1bc7, 0x0021), /* Telit 3G ACM only composition */
1993	.driver_info = SEND_ZERO_PACKET,
1994	},
1995	{ USB_DEVICE(0x1bc7, 0x0023), /* Telit 3G ACM + ECM composition */
1996	.driver_info = SEND_ZERO_PACKET,
1997	},
1998
1999	/* Exclude Goodix Fingerprint Reader */
2000	{ USB_DEVICE(0x27c6, 0x5395),
2001	.driver_info = IGNORE_DEVICE,
2002	},
2003
2004	/* Exclude Heimann Sensor GmbH USB appset demo */
2005	{ USB_DEVICE(0x32a7, 0x0000),
2006	.driver_info = IGNORE_DEVICE,
2007	},
2008
2009	/* control interfaces without any protocol set */
2010	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2011		USB_CDC_PROTO_NONE) },
2012
2013	/* control interfaces with various AT-command sets */
2014	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2015		USB_CDC_ACM_PROTO_AT_V25TER) },
2016	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2017		USB_CDC_ACM_PROTO_AT_PCCA101) },
2018	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2019		USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
2020	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2021		USB_CDC_ACM_PROTO_AT_GSM) },
2022	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2023		USB_CDC_ACM_PROTO_AT_3G) },
2024	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2025		USB_CDC_ACM_PROTO_AT_CDMA) },
2026
2027	{ USB_DEVICE(0x1519, 0x0452), /* Intel 7260 modem */
2028	.driver_info = SEND_ZERO_PACKET,
2029	},
2030
2031	{ }
2032};
2033
2034MODULE_DEVICE_TABLE(usb, acm_ids);
2035
2036static struct usb_driver acm_driver = {
2037	.name =		"cdc_acm",
2038	.probe =	acm_probe,
2039	.disconnect =	acm_disconnect,
2040#ifdef CONFIG_PM
2041	.suspend =	acm_suspend,
2042	.resume =	acm_resume,
2043	.reset_resume =	acm_reset_resume,
2044#endif
2045	.pre_reset =	acm_pre_reset,
2046	.id_table =	acm_ids,
2047#ifdef CONFIG_PM
2048	.supports_autosuspend = 1,
2049#endif
2050	.disable_hub_initiated_lpm = 1,
2051};
2052
2053/*
2054 * TTY driver structures.
2055 */
2056
2057static const struct tty_operations acm_ops = {
2058	.install =		acm_tty_install,
2059	.open =			acm_tty_open,
2060	.close =		acm_tty_close,
2061	.cleanup =		acm_tty_cleanup,
2062	.hangup =		acm_tty_hangup,
2063	.write =		acm_tty_write,
2064	.write_room =		acm_tty_write_room,
2065	.flush_buffer =		acm_tty_flush_buffer,
2066	.ioctl =		acm_tty_ioctl,
2067	.throttle =		acm_tty_throttle,
2068	.unthrottle =		acm_tty_unthrottle,
2069	.chars_in_buffer =	acm_tty_chars_in_buffer,
2070	.break_ctl =		acm_tty_break_ctl,
2071	.set_termios =		acm_tty_set_termios,
2072	.tiocmget =		acm_tty_tiocmget,
2073	.tiocmset =		acm_tty_tiocmset,
2074	.get_serial =		get_serial_info,
2075	.set_serial =		set_serial_info,
2076	.get_icount =		acm_tty_get_icount,
2077};
2078
2079/*
2080 * Init / exit.
2081 */
2082
2083static int __init acm_init(void)
2084{
2085	int retval;
2086	acm_tty_driver = tty_alloc_driver(ACM_TTY_MINORS, TTY_DRIVER_REAL_RAW |
2087			TTY_DRIVER_DYNAMIC_DEV);
2088	if (IS_ERR(acm_tty_driver))
2089		return PTR_ERR(acm_tty_driver);
2090	acm_tty_driver->driver_name = "acm",
2091	acm_tty_driver->name = "ttyACM",
2092	acm_tty_driver->major = ACM_TTY_MAJOR,
2093	acm_tty_driver->minor_start = 0,
2094	acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
2095	acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
 
2096	acm_tty_driver->init_termios = tty_std_termios;
2097	acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
2098								HUPCL | CLOCAL;
2099	tty_set_operations(acm_tty_driver, &acm_ops);
2100
2101	retval = tty_register_driver(acm_tty_driver);
2102	if (retval) {
2103		tty_driver_kref_put(acm_tty_driver);
2104		return retval;
2105	}
2106
2107	retval = usb_register(&acm_driver);
2108	if (retval) {
2109		tty_unregister_driver(acm_tty_driver);
2110		tty_driver_kref_put(acm_tty_driver);
2111		return retval;
2112	}
2113
2114	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
2115
2116	return 0;
2117}
2118
2119static void __exit acm_exit(void)
2120{
2121	usb_deregister(&acm_driver);
2122	tty_unregister_driver(acm_tty_driver);
2123	tty_driver_kref_put(acm_tty_driver);
2124	idr_destroy(&acm_minors);
2125}
2126
2127module_init(acm_init);
2128module_exit(acm_exit);
2129
2130MODULE_AUTHOR(DRIVER_AUTHOR);
2131MODULE_DESCRIPTION(DRIVER_DESC);
2132MODULE_LICENSE("GPL");
2133MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);