1/*
   2 * cdc-acm.c
   3 *
   4 * Copyright (c) 1999 Armin Fuerst	<fuerst@in.tum.de>
   5 * Copyright (c) 1999 Pavel Machek	<pavel@ucw.cz>
   6 * Copyright (c) 1999 Johannes Erdfelt	<johannes@erdfelt.com>
   7 * Copyright (c) 2000 Vojtech Pavlik	<vojtech@suse.cz>
   8 * Copyright (c) 2004 Oliver Neukum	<oliver@neukum.name>
   9 * Copyright (c) 2005 David Kubicek	<dave@awk.cz>
  10 * Copyright (c) 2011 Johan Hovold	<jhovold@gmail.com>
  11 *
  12 * USB Abstract Control Model driver for USB modems and ISDN adapters
  13 *
  14 * Sponsored by SuSE
  15 *
  16 * This program is free software; you can redistribute it and/or modify
  17 * it under the terms of the GNU General Public License as published by
  18 * the Free Software Foundation; either version 2 of the License, or
  19 * (at your option) any later version.
  20 *
  21 * This program is distributed in the hope that it will be useful,
  22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 * GNU General Public License for more details.
  25 *
  26 * You should have received a copy of the GNU General Public License
  27 * along with this program; if not, write to the Free Software
  28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29 */
  30
  31#undef DEBUG
  32#undef VERBOSE_DEBUG
  33
  34#include <linux/kernel.h>
 
  35#include <linux/errno.h>
  36#include <linux/init.h>
  37#include <linux/slab.h>
 
  38#include <linux/tty.h>
  39#include <linux/serial.h>
  40#include <linux/tty_driver.h>
  41#include <linux/tty_flip.h>
  42#include <linux/serial.h>
  43#include <linux/module.h>
  44#include <linux/mutex.h>
  45#include <linux/uaccess.h>
  46#include <linux/usb.h>
  47#include <linux/usb/cdc.h>
  48#include <asm/byteorder.h>
  49#include <asm/unaligned.h>
 
  50#include <linux/list.h>
  51
  52#include "cdc-acm.h"
  53
  54
  55#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
  56#define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  57
  58static struct usb_driver acm_driver;
  59static struct tty_driver *acm_tty_driver;
  60static struct acm *acm_table[ACM_TTY_MINORS];
  61
  62static DEFINE_MUTEX(acm_table_lock);
 
 
 
 
  63
  64/*
  65 * acm_table accessors
  66 */
  67
  68/*
  69 * Look up an ACM structure by index. If found and not disconnected, increment
  70 * its refcount and return it with its mutex held.
  71 */
  72static struct acm *acm_get_by_index(unsigned index)
  73{
  74	struct acm *acm;
  75
  76	mutex_lock(&acm_table_lock);
  77	acm = acm_table[index];
  78	if (acm) {
  79		mutex_lock(&acm->mutex);
  80		if (acm->disconnected) {
  81			mutex_unlock(&acm->mutex);
  82			acm = NULL;
  83		} else {
  84			tty_port_get(&acm->port);
  85			mutex_unlock(&acm->mutex);
  86		}
  87	}
  88	mutex_unlock(&acm_table_lock);
  89	return acm;
  90}
  91
  92/*
  93 * Try to find an available minor number and if found, associate it with 'acm'.
  94 */
  95static int acm_alloc_minor(struct acm *acm)
  96{
  97	int minor;
  98
  99	mutex_lock(&acm_table_lock);
 100	for (minor = 0; minor < ACM_TTY_MINORS; minor++) {
 101		if (!acm_table[minor]) {
 102			acm_table[minor] = acm;
 103			break;
 104		}
 105	}
 106	mutex_unlock(&acm_table_lock);
 107
 108	return minor;
 109}
 110
 111/* Release the minor number associated with 'acm'.  */
 112static void acm_release_minor(struct acm *acm)
 113{
 114	mutex_lock(&acm_table_lock);
 115	acm_table[acm->minor] = NULL;
 116	mutex_unlock(&acm_table_lock);
 117}
 118
 119/*
 120 * Functions for ACM control messages.
 121 */
 122
 123static int acm_ctrl_msg(struct acm *acm, int request, int value,
 124							void *buf, int len)
 125{
 126	int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
 
 
 
 
 
 
 127		request, USB_RT_ACM, value,
 128		acm->control->altsetting[0].desc.bInterfaceNumber,
 129		buf, len, 5000);
 
 130	dev_dbg(&acm->control->dev,
 131			"%s - rq 0x%02x, val %#x, len %#x, result %d\n",
 132			__func__, request, value, len, retval);
 
 
 
 133	return retval < 0 ? retval : 0;
 134}
 135
 136/* devices aren't required to support these requests.
 137 * the cdc acm descriptor tells whether they do...
 138 */
 139#define acm_set_control(acm, control) \
 140	acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 
 
 
 
 
 
 
 141#define acm_set_line(acm, line) \
 142	acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 143#define acm_send_break(acm, ms) \
 144	acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 145
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 146/*
 147 * Write buffer management.
 148 * All of these assume proper locks taken by the caller.
 149 */
 150
 151static int acm_wb_alloc(struct acm *acm)
 152{
 153	int i, wbn;
 154	struct acm_wb *wb;
 155
 156	wbn = 0;
 157	i = 0;
 158	for (;;) {
 159		wb = &acm->wb[wbn];
 160		if (!wb->use) {
 161			wb->use = 1;
 
 162			return wbn;
 163		}
 164		wbn = (wbn + 1) % ACM_NW;
 165		if (++i >= ACM_NW)
 166			return -1;
 167	}
 168}
 169
 170static int acm_wb_is_avail(struct acm *acm)
 171{
 172	int i, n;
 173	unsigned long flags;
 174
 175	n = ACM_NW;
 176	spin_lock_irqsave(&acm->write_lock, flags);
 177	for (i = 0; i < ACM_NW; i++)
 178		n -= acm->wb[i].use;
 
 179	spin_unlock_irqrestore(&acm->write_lock, flags);
 180	return n;
 181}
 182
 183/*
 184 * Finish write. Caller must hold acm->write_lock
 185 */
 186static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 187{
 188	wb->use = 0;
 189	acm->transmitting--;
 190	usb_autopm_put_interface_async(acm->control);
 191}
 192
 193/*
 194 * Poke write.
 195 *
 196 * the caller is responsible for locking
 197 */
 198
 199static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 200{
 201	int rc;
 202
 203	acm->transmitting++;
 204
 205	wb->urb->transfer_buffer = wb->buf;
 206	wb->urb->transfer_dma = wb->dmah;
 207	wb->urb->transfer_buffer_length = wb->len;
 208	wb->urb->dev = acm->dev;
 209
 210	rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 211	if (rc < 0) {
 212		dev_err(&acm->data->dev,
 213			"%s - usb_submit_urb(write bulk) failed: %d\n",
 214			__func__, rc);
 
 215		acm_write_done(acm, wb);
 216	}
 217	return rc;
 218}
 219
 220static int acm_write_start(struct acm *acm, int wbn)
 221{
 222	unsigned long flags;
 223	struct acm_wb *wb = &acm->wb[wbn];
 224	int rc;
 225
 226	spin_lock_irqsave(&acm->write_lock, flags);
 227	if (!acm->dev) {
 228		wb->use = 0;
 229		spin_unlock_irqrestore(&acm->write_lock, flags);
 230		return -ENODEV;
 231	}
 232
 233	dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
 234							acm->susp_count);
 235	usb_autopm_get_interface_async(acm->control);
 236	if (acm->susp_count) {
 237		if (!acm->delayed_wb)
 238			acm->delayed_wb = wb;
 239		else
 240			usb_autopm_put_interface_async(acm->control);
 241		spin_unlock_irqrestore(&acm->write_lock, flags);
 242		return 0;	/* A white lie */
 243	}
 244	usb_mark_last_busy(acm->dev);
 245
 246	rc = acm_start_wb(acm, wb);
 247	spin_unlock_irqrestore(&acm->write_lock, flags);
 248
 249	return rc;
 250
 251}
 252/*
 253 * attributes exported through sysfs
 254 */
 255static ssize_t show_caps
 256(struct device *dev, struct device_attribute *attr, char *buf)
 257{
 258	struct usb_interface *intf = to_usb_interface(dev);
 259	struct acm *acm = usb_get_intfdata(intf);
 260
 261	return sprintf(buf, "%d", acm->ctrl_caps);
 262}
 263static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 264
 265static ssize_t show_country_codes
 266(struct device *dev, struct device_attribute *attr, char *buf)
 267{
 268	struct usb_interface *intf = to_usb_interface(dev);
 269	struct acm *acm = usb_get_intfdata(intf);
 270
 271	memcpy(buf, acm->country_codes, acm->country_code_size);
 272	return acm->country_code_size;
 273}
 274
 275static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 276
 277static ssize_t show_country_rel_date
 278(struct device *dev, struct device_attribute *attr, char *buf)
 279{
 280	struct usb_interface *intf = to_usb_interface(dev);
 281	struct acm *acm = usb_get_intfdata(intf);
 282
 283	return sprintf(buf, "%d", acm->country_rel_date);
 284}
 285
 286static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 287/*
 288 * Interrupt handlers for various ACM device responses
 289 */
 290
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 291/* control interface reports status changes with "interrupt" transfers */
 292static void acm_ctrl_irq(struct urb *urb)
 293{
 294	struct acm *acm = urb->context;
 295	struct usb_cdc_notification *dr = urb->transfer_buffer;
 296	struct tty_struct *tty;
 297	unsigned char *data;
 298	int newctrl;
 299	int retval;
 300	int status = urb->status;
 301
 302	switch (status) {
 303	case 0:
 304		/* success */
 305		break;
 306	case -ECONNRESET:
 307	case -ENOENT:
 308	case -ESHUTDOWN:
 309		/* this urb is terminated, clean up */
 310		dev_dbg(&acm->control->dev,
 311				"%s - urb shutting down with status: %d\n",
 312				__func__, status);
 313		return;
 314	default:
 315		dev_dbg(&acm->control->dev,
 316				"%s - nonzero urb status received: %d\n",
 317				__func__, status);
 318		goto exit;
 319	}
 320
 321	usb_mark_last_busy(acm->dev);
 322
 323	data = (unsigned char *)(dr + 1);
 324	switch (dr->bNotificationType) {
 325	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 326		dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
 327							__func__, dr->wValue);
 328		break;
 329
 330	case USB_CDC_NOTIFY_SERIAL_STATE:
 331		tty = tty_port_tty_get(&acm->port);
 332		newctrl = get_unaligned_le16(data);
 333
 334		if (tty) {
 335			if (!acm->clocal &&
 336				(acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 337				dev_dbg(&acm->control->dev,
 338					"%s - calling hangup\n", __func__);
 339				tty_hangup(tty);
 
 
 
 
 
 
 
 
 
 340			}
 341			tty_kref_put(tty);
 
 
 
 342		}
 343
 344		acm->ctrlin = newctrl;
 
 345
 346		dev_dbg(&acm->control->dev,
 347			"%s - input control lines: dcd%c dsr%c break%c "
 348			"ring%c framing%c parity%c overrun%c\n",
 349			__func__,
 350			acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
 351			acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 352			acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
 353			acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 354			acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
 355			acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 356			acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 357			break;
 358
 359	default:
 360		dev_dbg(&acm->control->dev,
 361			"%s - unknown notification %d received: index %d "
 362			"len %d data0 %d data1 %d\n",
 363			__func__,
 364			dr->bNotificationType, dr->wIndex,
 365			dr->wLength, data[0], data[1]);
 366		break;
 367	}
 
 368exit:
 369	retval = usb_submit_urb(urb, GFP_ATOMIC);
 370	if (retval)
 371		dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
 372							__func__, retval);
 
 
 
 373}
 374
 375static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
 376{
 377	int res;
 378
 379	if (!test_and_clear_bit(index, &acm->read_urbs_free))
 380		return 0;
 381
 382	dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
 383
 384	res = usb_submit_urb(acm->read_urbs[index], mem_flags);
 385	if (res) {
 386		if (res != -EPERM) {
 387			dev_err(&acm->data->dev,
 388					"%s - usb_submit_urb failed: %d\n",
 389					__func__, res);
 
 
 390		}
 391		set_bit(index, &acm->read_urbs_free);
 392		return res;
 
 
 393	}
 394
 395	return 0;
 396}
 397
 398static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
 399{
 400	int res;
 401	int i;
 402
 403	for (i = 0; i < acm->rx_buflimit; ++i) {
 404		res = acm_submit_read_urb(acm, i, mem_flags);
 405		if (res)
 406			return res;
 407	}
 408
 409	return 0;
 410}
 411
 412static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 413{
 414	struct tty_struct *tty;
 415
 416	if (!urb->actual_length)
 417		return;
 418
 419	tty = tty_port_tty_get(&acm->port);
 420	if (!tty)
 421		return;
 422
 423	tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
 424	tty_flip_buffer_push(tty);
 425
 426	tty_kref_put(tty);
 427}
 428
 429static void acm_read_bulk_callback(struct urb *urb)
 430{
 431	struct acm_rb *rb = urb->context;
 432	struct acm *acm = rb->instance;
 433	unsigned long flags;
 
 
 
 
 
 
 434
 435	dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
 436					rb->index, urb->actual_length);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 437	set_bit(rb->index, &acm->read_urbs_free);
 
 
 
 
 
 
 438
 439	if (!acm->dev) {
 440		dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
 
 
 
 441		return;
 442	}
 443	usb_mark_last_busy(acm->dev);
 444
 445	if (urb->status) {
 446		dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
 447							__func__, urb->status);
 448		return;
 449	}
 450	acm_process_read_urb(acm, urb);
 451
 452	/* throttle device if requested by tty */
 453	spin_lock_irqsave(&acm->read_lock, flags);
 454	acm->throttled = acm->throttle_req;
 455	if (!acm->throttled && !acm->susp_count) {
 456		spin_unlock_irqrestore(&acm->read_lock, flags);
 457		acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
 458	} else {
 459		spin_unlock_irqrestore(&acm->read_lock, flags);
 460	}
 461}
 462
 463/* data interface wrote those outgoing bytes */
 464static void acm_write_bulk(struct urb *urb)
 465{
 466	struct acm_wb *wb = urb->context;
 467	struct acm *acm = wb->instance;
 468	unsigned long flags;
 
 469
 470	if (urb->status	|| (urb->actual_length != urb->transfer_buffer_length))
 471		dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
 472			__func__,
 473			urb->actual_length,
 474			urb->transfer_buffer_length,
 475			urb->status);
 476
 477	spin_lock_irqsave(&acm->write_lock, flags);
 478	acm_write_done(acm, wb);
 479	spin_unlock_irqrestore(&acm->write_lock, flags);
 480	schedule_work(&acm->work);
 
 481}
 482
 483static void acm_softint(struct work_struct *work)
 484{
 485	struct acm *acm = container_of(work, struct acm, work);
 486	struct tty_struct *tty;
 487
 488	dev_vdbg(&acm->data->dev, "%s\n", __func__);
 
 
 
 
 
 
 
 
 
 489
 490	tty = tty_port_tty_get(&acm->port);
 491	if (!tty)
 492		return;
 493	tty_wakeup(tty);
 494	tty_kref_put(tty);
 
 
 
 495}
 496
 497/*
 498 * TTY handlers
 499 */
 500
 501static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 502{
 503	struct acm *acm;
 504	int retval;
 505
 506	dev_dbg(tty->dev, "%s\n", __func__);
 507
 508	acm = acm_get_by_index(tty->index);
 509	if (!acm)
 510		return -ENODEV;
 511
 512	retval = tty_standard_install(driver, tty);
 513	if (retval)
 514		goto error_init_termios;
 515
 
 
 
 
 
 
 
 516	tty->driver_data = acm;
 517
 518	return 0;
 519
 520error_init_termios:
 521	tty_port_put(&acm->port);
 522	return retval;
 523}
 524
 525static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 526{
 527	struct acm *acm = tty->driver_data;
 528
 529	dev_dbg(tty->dev, "%s\n", __func__);
 530
 531	return tty_port_open(&acm->port, tty, filp);
 532}
 533
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 534static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
 535{
 536	struct acm *acm = container_of(port, struct acm, port);
 537	int retval = -ENODEV;
 538
 539	dev_dbg(&acm->control->dev, "%s\n", __func__);
 540
 541	mutex_lock(&acm->mutex);
 542	if (acm->disconnected)
 543		goto disconnected;
 544
 545	retval = usb_autopm_get_interface(acm->control);
 546	if (retval)
 547		goto error_get_interface;
 548
 549	/*
 550	 * FIXME: Why do we need this? Allocating 64K of physically contiguous
 551	 * memory is really nasty...
 552	 */
 553	set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 554	acm->control->needs_remote_wakeup = 1;
 555
 556	acm->ctrlurb->dev = acm->dev;
 557	if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 
 558		dev_err(&acm->control->dev,
 559			"%s - usb_submit_urb(ctrl irq) failed\n", __func__);
 560		goto error_submit_urb;
 561	}
 562
 563	acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
 564	if (acm_set_control(acm, acm->ctrlout) < 0 &&
 565	    (acm->ctrl_caps & USB_CDC_CAP_LINE))
 566		goto error_set_control;
 567
 568	usb_autopm_put_interface(acm->control);
 569
 570	/*
 571	 * Unthrottle device in case the TTY was closed while throttled.
 572	 */
 573	spin_lock_irq(&acm->read_lock);
 574	acm->throttled = 0;
 575	acm->throttle_req = 0;
 576	spin_unlock_irq(&acm->read_lock);
 577
 578	if (acm_submit_read_urbs(acm, GFP_KERNEL))
 
 579		goto error_submit_read_urbs;
 580
 
 
 581	mutex_unlock(&acm->mutex);
 582
 583	return 0;
 584
 585error_submit_read_urbs:
 586	acm->ctrlout = 0;
 587	acm_set_control(acm, acm->ctrlout);
 588error_set_control:
 589	usb_kill_urb(acm->ctrlurb);
 590error_submit_urb:
 591	usb_autopm_put_interface(acm->control);
 592error_get_interface:
 593disconnected:
 594	mutex_unlock(&acm->mutex);
 595	return retval;
 
 596}
 597
 598static void acm_port_destruct(struct tty_port *port)
 599{
 600	struct acm *acm = container_of(port, struct acm, port);
 601
 602	dev_dbg(&acm->control->dev, "%s\n", __func__);
 603
 604	tty_unregister_device(acm_tty_driver, acm->minor);
 605	acm_release_minor(acm);
 606	usb_put_intf(acm->control);
 607	kfree(acm->country_codes);
 608	kfree(acm);
 609}
 610
 611static void acm_port_shutdown(struct tty_port *port)
 612{
 613	struct acm *acm = container_of(port, struct acm, port);
 614	int i;
 
 615
 616	dev_dbg(&acm->control->dev, "%s\n", __func__);
 
 
 
 
 
 
 617
 618	mutex_lock(&acm->mutex);
 619	if (!acm->disconnected) {
 620		usb_autopm_get_interface(acm->control);
 621		acm_set_control(acm, acm->ctrlout = 0);
 622		usb_kill_urb(acm->ctrlurb);
 623		for (i = 0; i < ACM_NW; i++)
 624			usb_kill_urb(acm->wb[i].urb);
 625		for (i = 0; i < acm->rx_buflimit; i++)
 626			usb_kill_urb(acm->read_urbs[i]);
 627		acm->control->needs_remote_wakeup = 0;
 628		usb_autopm_put_interface(acm->control);
 629	}
 630	mutex_unlock(&acm->mutex);
 
 
 631}
 632
 633static void acm_tty_cleanup(struct tty_struct *tty)
 634{
 635	struct acm *acm = tty->driver_data;
 636	dev_dbg(&acm->control->dev, "%s\n", __func__);
 637	tty_port_put(&acm->port);
 638}
 639
 640static void acm_tty_hangup(struct tty_struct *tty)
 641{
 642	struct acm *acm = tty->driver_data;
 643	dev_dbg(&acm->control->dev, "%s\n", __func__);
 644	tty_port_hangup(&acm->port);
 645}
 646
 647static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 648{
 649	struct acm *acm = tty->driver_data;
 650	dev_dbg(&acm->control->dev, "%s\n", __func__);
 651	tty_port_close(&acm->port, tty, filp);
 652}
 653
 654static int acm_tty_write(struct tty_struct *tty,
 655					const unsigned char *buf, int count)
 656{
 657	struct acm *acm = tty->driver_data;
 658	int stat;
 659	unsigned long flags;
 660	int wbn;
 661	struct acm_wb *wb;
 662
 663	if (!count)
 664		return 0;
 665
 666	dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
 667
 668	spin_lock_irqsave(&acm->write_lock, flags);
 669	wbn = acm_wb_alloc(acm);
 670	if (wbn < 0) {
 671		spin_unlock_irqrestore(&acm->write_lock, flags);
 672		return 0;
 673	}
 674	wb = &acm->wb[wbn];
 675
 
 
 
 
 
 
 676	count = (count > acm->writesize) ? acm->writesize : count;
 677	dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
 678	memcpy(wb->buf, buf, count);
 679	wb->len = count;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 680	spin_unlock_irqrestore(&acm->write_lock, flags);
 681
 682	stat = acm_write_start(acm, wbn);
 683	if (stat < 0)
 684		return stat;
 685	return count;
 686}
 687
 688static int acm_tty_write_room(struct tty_struct *tty)
 689{
 690	struct acm *acm = tty->driver_data;
 691	/*
 692	 * Do not let the line discipline to know that we have a reserve,
 693	 * or it might get too enthusiastic.
 694	 */
 695	return acm_wb_is_avail(acm) ? acm->writesize : 0;
 696}
 697
 698static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 699{
 700	struct acm *acm = tty->driver_data;
 701	/*
 702	 * if the device was unplugged then any remaining characters fell out
 703	 * of the connector ;)
 704	 */
 705	if (acm->disconnected)
 706		return 0;
 707	/*
 708	 * This is inaccurate (overcounts), but it works.
 709	 */
 710	return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 711}
 712
 713static void acm_tty_throttle(struct tty_struct *tty)
 714{
 715	struct acm *acm = tty->driver_data;
 716
 717	spin_lock_irq(&acm->read_lock);
 718	acm->throttle_req = 1;
 719	spin_unlock_irq(&acm->read_lock);
 720}
 721
 722static void acm_tty_unthrottle(struct tty_struct *tty)
 723{
 724	struct acm *acm = tty->driver_data;
 725	unsigned int was_throttled;
 726
 727	spin_lock_irq(&acm->read_lock);
 728	was_throttled = acm->throttled;
 729	acm->throttled = 0;
 730	acm->throttle_req = 0;
 731	spin_unlock_irq(&acm->read_lock);
 732
 733	if (was_throttled)
 734		acm_submit_read_urbs(acm, GFP_KERNEL);
 735}
 736
 737static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 738{
 739	struct acm *acm = tty->driver_data;
 740	int retval;
 741
 742	retval = acm_send_break(acm, state ? 0xffff : 0);
 743	if (retval < 0)
 744		dev_dbg(&acm->control->dev, "%s - send break failed\n",
 745								__func__);
 746	return retval;
 747}
 748
 749static int acm_tty_tiocmget(struct tty_struct *tty)
 750{
 751	struct acm *acm = tty->driver_data;
 752
 753	return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 754	       (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 755	       (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 756	       (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 757	       (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 758	       TIOCM_CTS;
 759}
 760
 761static int acm_tty_tiocmset(struct tty_struct *tty,
 762			    unsigned int set, unsigned int clear)
 763{
 764	struct acm *acm = tty->driver_data;
 765	unsigned int newctrl;
 766
 767	newctrl = acm->ctrlout;
 768	set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 769					(set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 770	clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 771					(clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 772
 773	newctrl = (newctrl & ~clear) | set;
 774
 775	if (acm->ctrlout == newctrl)
 776		return 0;
 777	return acm_set_control(acm, acm->ctrlout = newctrl);
 778}
 779
 780static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
 781{
 782	struct serial_struct tmp;
 783
 784	if (!info)
 785		return -EINVAL;
 
 
 
 
 
 786
 787	memset(&tmp, 0, sizeof(tmp));
 788	tmp.flags = ASYNC_LOW_LATENCY;
 789	tmp.xmit_fifo_size = acm->writesize;
 790	tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
 
 791
 792	if (copy_to_user(info, &tmp, sizeof(tmp)))
 793		return -EFAULT;
 794	else
 795		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 796}
 797
 798static int acm_tty_ioctl(struct tty_struct *tty,
 799					unsigned int cmd, unsigned long arg)
 800{
 801	struct acm *acm = tty->driver_data;
 802	int rv = -ENOIOCTLCMD;
 803
 804	switch (cmd) {
 805	case TIOCGSERIAL: /* gets serial port data */
 806		rv = get_serial_info(acm, (struct serial_struct __user *) arg);
 
 
 
 
 
 
 807		break;
 808	}
 809
 810	return rv;
 811}
 812
 813static const __u32 acm_tty_speed[] = {
 814	0, 50, 75, 110, 134, 150, 200, 300, 600,
 815	1200, 1800, 2400, 4800, 9600, 19200, 38400,
 816	57600, 115200, 230400, 460800, 500000, 576000,
 817	921600, 1000000, 1152000, 1500000, 2000000,
 818	2500000, 3000000, 3500000, 4000000
 819};
 820
 821static const __u8 acm_tty_size[] = {
 822	5, 6, 7, 8
 823};
 824
 825static void acm_tty_set_termios(struct tty_struct *tty,
 826						struct ktermios *termios_old)
 827{
 828	struct acm *acm = tty->driver_data;
 829	struct ktermios *termios = tty->termios;
 830	struct usb_cdc_line_coding newline;
 831	int newctrl = acm->ctrlout;
 832
 833	newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 834	newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 835	newline.bParityType = termios->c_cflag & PARENB ?
 836				(termios->c_cflag & PARODD ? 1 : 2) +
 837				(termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 838	newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 
 839	/* FIXME: Needs to clear unsupported bits in the termios */
 840	acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 841
 842	if (!newline.dwDTERate) {
 843		newline.dwDTERate = acm->line.dwDTERate;
 844		newctrl &= ~ACM_CTRL_DTR;
 845	} else
 846		newctrl |=  ACM_CTRL_DTR;
 
 847
 848	if (newctrl != acm->ctrlout)
 849		acm_set_control(acm, acm->ctrlout = newctrl);
 850
 851	if (memcmp(&acm->line, &newline, sizeof newline)) {
 852		memcpy(&acm->line, &newline, sizeof newline);
 853		dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
 854			__func__,
 855			le32_to_cpu(newline.dwDTERate),
 856			newline.bCharFormat, newline.bParityType,
 857			newline.bDataBits);
 858		acm_set_line(acm, &acm->line);
 859	}
 860}
 861
 862static const struct tty_port_operations acm_port_ops = {
 
 863	.shutdown = acm_port_shutdown,
 864	.activate = acm_port_activate,
 865	.destruct = acm_port_destruct,
 866};
 867
 868/*
 869 * USB probe and disconnect routines.
 870 */
 871
 872/* Little helpers: write/read buffers free */
 873static void acm_write_buffers_free(struct acm *acm)
 874{
 875	int i;
 876	struct acm_wb *wb;
 877	struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 878
 879	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 880		usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 881}
 882
 883static void acm_read_buffers_free(struct acm *acm)
 884{
 885	struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 886	int i;
 887
 888	for (i = 0; i < acm->rx_buflimit; i++)
 889		usb_free_coherent(usb_dev, acm->readsize,
 890			  acm->read_buffers[i].base, acm->read_buffers[i].dma);
 891}
 892
 893/* Little helper: write buffers allocate */
 894static int acm_write_buffers_alloc(struct acm *acm)
 895{
 896	int i;
 897	struct acm_wb *wb;
 898
 899	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 900		wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 901		    &wb->dmah);
 902		if (!wb->buf) {
 903			while (i != 0) {
 904				--i;
 905				--wb;
 906				usb_free_coherent(acm->dev, acm->writesize,
 907				    wb->buf, wb->dmah);
 908			}
 909			return -ENOMEM;
 910		}
 911	}
 912	return 0;
 913}
 914
 915static int acm_probe(struct usb_interface *intf,
 916		     const struct usb_device_id *id)
 917{
 918	struct usb_cdc_union_desc *union_header = NULL;
 919	struct usb_cdc_country_functional_desc *cfd = NULL;
 920	unsigned char *buffer = intf->altsetting->extra;
 921	int buflen = intf->altsetting->extralen;
 922	struct usb_interface *control_interface;
 923	struct usb_interface *data_interface;
 924	struct usb_endpoint_descriptor *epctrl = NULL;
 925	struct usb_endpoint_descriptor *epread = NULL;
 926	struct usb_endpoint_descriptor *epwrite = NULL;
 927	struct usb_device *usb_dev = interface_to_usbdev(intf);
 
 928	struct acm *acm;
 929	int minor;
 930	int ctrlsize, readsize;
 931	u8 *buf;
 932	u8 ac_management_function = 0;
 933	u8 call_management_function = 0;
 934	int call_interface_num = -1;
 935	int data_interface_num = -1;
 936	unsigned long quirks;
 937	int num_rx_buf;
 938	int i;
 939	int combined_interfaces = 0;
 
 
 
 940
 941	/* normal quirks */
 942	quirks = (unsigned long)id->driver_info;
 
 
 
 
 
 
 943	num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 944
 945	/* handle quirks deadly to normal probing*/
 946	if (quirks == NO_UNION_NORMAL) {
 947		data_interface = usb_ifnum_to_if(usb_dev, 1);
 948		control_interface = usb_ifnum_to_if(usb_dev, 0);
 
 
 
 949		goto skip_normal_probe;
 950	}
 951
 952	/* normal probing*/
 953	if (!buffer) {
 954		dev_err(&intf->dev, "Weird descriptor references\n");
 955		return -EINVAL;
 956	}
 957
 958	if (!buflen) {
 959		if (intf->cur_altsetting->endpoint &&
 960				intf->cur_altsetting->endpoint->extralen &&
 961				intf->cur_altsetting->endpoint->extra) {
 962			dev_dbg(&intf->dev,
 963				"Seeking extra descriptors on endpoint\n");
 964			buflen = intf->cur_altsetting->endpoint->extralen;
 965			buffer = intf->cur_altsetting->endpoint->extra;
 966		} else {
 967			dev_err(&intf->dev,
 968				"Zero length descriptor references\n");
 969			return -EINVAL;
 970		}
 971	}
 972
 973	while (buflen > 0) {
 974		if (buffer[1] != USB_DT_CS_INTERFACE) {
 975			dev_err(&intf->dev, "skipping garbage\n");
 976			goto next_desc;
 977		}
 978
 979		switch (buffer[2]) {
 980		case USB_CDC_UNION_TYPE: /* we've found it */
 981			if (union_header) {
 982				dev_err(&intf->dev, "More than one "
 983					"union descriptor, skipping ...\n");
 984				goto next_desc;
 985			}
 986			union_header = (struct usb_cdc_union_desc *)buffer;
 987			break;
 988		case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 989			cfd = (struct usb_cdc_country_functional_desc *)buffer;
 990			break;
 991		case USB_CDC_HEADER_TYPE: /* maybe check version */
 992			break; /* for now we ignore it */
 993		case USB_CDC_ACM_TYPE:
 994			ac_management_function = buffer[3];
 995			break;
 996		case USB_CDC_CALL_MANAGEMENT_TYPE:
 997			call_management_function = buffer[3];
 998			call_interface_num = buffer[4];
 999			if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1000				dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1001			break;
1002		default:
1003			/* there are LOTS more CDC descriptors that
1004			 * could legitimately be found here.
1005			 */
1006			dev_dbg(&intf->dev, "Ignoring descriptor: "
1007					"type %02x, length %d\n",
1008					buffer[2], buffer[0]);
1009			break;
1010		}
1011next_desc:
1012		buflen -= buffer[0];
1013		buffer += buffer[0];
1014	}
1015
1016	if (!union_header) {
1017		if (call_interface_num > 0) {
 
 
 
 
 
1018			dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1019			/* quirks for Droids MuIn LCD */
1020			if (quirks & NO_DATA_INTERFACE)
1021				data_interface = usb_ifnum_to_if(usb_dev, 0);
1022			else
1023				data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1024			control_interface = intf;
1025		} else {
1026			if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1027				dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1028				return -ENODEV;
1029			} else {
1030				dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1031				combined_interfaces = 1;
1032				control_interface = data_interface = intf;
1033				goto look_for_collapsed_interface;
1034			}
1035		}
1036	} else {
 
 
 
1037		control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1038		data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1039		if (!control_interface || !data_interface) {
1040			dev_dbg(&intf->dev, "no interfaces\n");
1041			return -ENODEV;
 
 
 
 
 
 
1042		}
1043	}
1044
1045	if (data_interface_num != call_interface_num)
 
 
 
 
 
1046		dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1047
1048	if (control_interface == data_interface) {
1049		/* some broken devices designed for windows work this way */
1050		dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1051		combined_interfaces = 1;
1052		/* a popular other OS doesn't use it */
1053		quirks |= NO_CAP_LINE;
1054		if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1055			dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1056			return -EINVAL;
1057		}
1058look_for_collapsed_interface:
1059		for (i = 0; i < 3; i++) {
1060			struct usb_endpoint_descriptor *ep;
1061			ep = &data_interface->cur_altsetting->endpoint[i].desc;
1062
1063			if (usb_endpoint_is_int_in(ep))
1064				epctrl = ep;
1065			else if (usb_endpoint_is_bulk_out(ep))
1066				epwrite = ep;
1067			else if (usb_endpoint_is_bulk_in(ep))
1068				epread = ep;
1069			else
1070				return -EINVAL;
1071		}
1072		if (!epctrl || !epread || !epwrite)
1073			return -ENODEV;
1074		else
1075			goto made_compressed_probe;
1076	}
1077
1078skip_normal_probe:
1079
1080	/*workaround for switched interfaces */
1081	if (data_interface->cur_altsetting->desc.bInterfaceClass
1082						!= CDC_DATA_INTERFACE_TYPE) {
1083		if (control_interface->cur_altsetting->desc.bInterfaceClass
1084						== CDC_DATA_INTERFACE_TYPE) {
1085			struct usb_interface *t;
1086			dev_dbg(&intf->dev,
1087				"Your device has switched interfaces.\n");
1088			t = control_interface;
1089			control_interface = data_interface;
1090			data_interface = t;
1091		} else {
1092			return -EINVAL;
1093		}
1094	}
1095
1096	/* Accept probe requests only for the control interface */
1097	if (!combined_interfaces && intf != control_interface)
1098		return -ENODEV;
1099
1100	if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1101		/* valid in this context */
1102		dev_dbg(&intf->dev, "The data interface isn't available\n");
1103		return -EBUSY;
1104	}
1105
1106
1107	if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1108	    control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1109		return -EINVAL;
1110
1111	epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1112	epread = &data_interface->cur_altsetting->endpoint[0].desc;
1113	epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1114
1115
1116	/* workaround for switched endpoints */
1117	if (!usb_endpoint_dir_in(epread)) {
1118		/* descriptors are swapped */
1119		struct usb_endpoint_descriptor *t;
1120		dev_dbg(&intf->dev,
1121			"The data interface has switched endpoints\n");
1122		t = epread;
1123		epread = epwrite;
1124		epwrite = t;
1125	}
1126made_compressed_probe:
1127	dev_dbg(&intf->dev, "interfaces are valid\n");
1128
1129	acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1130	if (acm == NULL) {
1131		dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1132		goto alloc_fail;
1133	}
1134
1135	minor = acm_alloc_minor(acm);
1136	if (minor == ACM_TTY_MINORS) {
1137		dev_err(&intf->dev, "no more free acm devices\n");
1138		kfree(acm);
1139		return -ENODEV;
1140	}
1141
1142	ctrlsize = usb_endpoint_maxp(epctrl);
1143	readsize = usb_endpoint_maxp(epread) *
1144				(quirks == SINGLE_RX_URB ? 1 : 2);
1145	acm->combined_interfaces = combined_interfaces;
1146	acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1147	acm->control = control_interface;
1148	acm->data = data_interface;
 
 
 
 
 
 
 
 
 
1149	acm->minor = minor;
1150	acm->dev = usb_dev;
1151	acm->ctrl_caps = ac_management_function;
 
1152	if (quirks & NO_CAP_LINE)
1153		acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1154	acm->ctrlsize = ctrlsize;
1155	acm->readsize = readsize;
1156	acm->rx_buflimit = num_rx_buf;
1157	INIT_WORK(&acm->work, acm_softint);
 
1158	spin_lock_init(&acm->write_lock);
1159	spin_lock_init(&acm->read_lock);
1160	mutex_init(&acm->mutex);
1161	acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1162	acm->is_int_ep = usb_endpoint_xfer_int(epread);
1163	if (acm->is_int_ep)
1164		acm->bInterval = epread->bInterval;
1165	tty_port_init(&acm->port);
1166	acm->port.ops = &acm_port_ops;
 
 
 
 
 
 
 
 
1167
1168	buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1169	if (!buf) {
1170		dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1171		goto alloc_fail2;
1172	}
1173	acm->ctrl_buffer = buf;
1174
1175	if (acm_write_buffers_alloc(acm) < 0) {
1176		dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1177		goto alloc_fail4;
1178	}
1179
1180	acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1181	if (!acm->ctrlurb) {
1182		dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1183		goto alloc_fail5;
1184	}
1185	for (i = 0; i < num_rx_buf; i++) {
1186		struct acm_rb *rb = &(acm->read_buffers[i]);
1187		struct urb *urb;
1188
1189		rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1190								&rb->dma);
1191		if (!rb->base) {
1192			dev_err(&intf->dev, "out of memory "
1193					"(read bufs usb_alloc_coherent)\n");
1194			goto alloc_fail6;
1195		}
1196		rb->index = i;
1197		rb->instance = acm;
1198
1199		urb = usb_alloc_urb(0, GFP_KERNEL);
1200		if (!urb) {
1201			dev_err(&intf->dev,
1202				"out of memory (read urbs usb_alloc_urb)\n");
1203			goto alloc_fail6;
1204		}
1205		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1206		urb->transfer_dma = rb->dma;
1207		if (acm->is_int_ep) {
1208			usb_fill_int_urb(urb, acm->dev,
1209					 acm->rx_endpoint,
1210					 rb->base,
1211					 acm->readsize,
1212					 acm_read_bulk_callback, rb,
1213					 acm->bInterval);
1214		} else {
1215			usb_fill_bulk_urb(urb, acm->dev,
1216					  acm->rx_endpoint,
1217					  rb->base,
1218					  acm->readsize,
1219					  acm_read_bulk_callback, rb);
1220		}
1221
1222		acm->read_urbs[i] = urb;
1223		__set_bit(i, &acm->read_urbs_free);
1224	}
1225	for (i = 0; i < ACM_NW; i++) {
1226		struct acm_wb *snd = &(acm->wb[i]);
1227
1228		snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1229		if (snd->urb == NULL) {
1230			dev_err(&intf->dev,
1231				"out of memory (write urbs usb_alloc_urb)\n");
1232			goto alloc_fail7;
1233		}
1234
1235		if (usb_endpoint_xfer_int(epwrite))
1236			usb_fill_int_urb(snd->urb, usb_dev,
1237				usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1238				NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1239		else
1240			usb_fill_bulk_urb(snd->urb, usb_dev,
1241				usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1242				NULL, acm->writesize, acm_write_bulk, snd);
1243		snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
 
1244		snd->instance = acm;
1245	}
1246
1247	usb_set_intfdata(intf, acm);
1248
1249	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1250	if (i < 0)
1251		goto alloc_fail7;
 
 
 
 
1252
1253	if (cfd) { /* export the country data */
1254		acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1255		if (!acm->country_codes)
1256			goto skip_countries;
1257		acm->country_code_size = cfd->bLength - 4;
1258		memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1259							cfd->bLength - 4);
1260		acm->country_rel_date = cfd->iCountryCodeRelDate;
1261
1262		i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1263		if (i < 0) {
1264			kfree(acm->country_codes);
1265			acm->country_codes = NULL;
1266			acm->country_code_size = 0;
1267			goto skip_countries;
1268		}
1269
1270		i = device_create_file(&intf->dev,
1271						&dev_attr_iCountryCodeRelDate);
1272		if (i < 0) {
1273			device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1274			kfree(acm->country_codes);
1275			acm->country_codes = NULL;
1276			acm->country_code_size = 0;
1277			goto skip_countries;
1278		}
1279	}
1280
1281skip_countries:
1282	usb_fill_int_urb(acm->ctrlurb, usb_dev,
1283			 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1284			 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1285			 /* works around buggy devices */
1286			 epctrl->bInterval ? epctrl->bInterval : 0xff);
1287	acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1288	acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1289
1290	dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1291
1292	acm_set_control(acm, acm->ctrlout);
1293
1294	acm->line.dwDTERate = cpu_to_le32(9600);
1295	acm->line.bDataBits = 8;
1296	acm_set_line(acm, &acm->line);
1297
1298	usb_driver_claim_interface(&acm_driver, data_interface, acm);
1299	usb_set_intfdata(data_interface, acm);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1300
1301	usb_get_intf(control_interface);
1302	tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1303
1304	return 0;
1305alloc_fail7:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1306	for (i = 0; i < ACM_NW; i++)
1307		usb_free_urb(acm->wb[i].urb);
1308alloc_fail6:
1309	for (i = 0; i < num_rx_buf; i++)
1310		usb_free_urb(acm->read_urbs[i]);
1311	acm_read_buffers_free(acm);
1312	usb_free_urb(acm->ctrlurb);
1313alloc_fail5:
1314	acm_write_buffers_free(acm);
1315alloc_fail4:
1316	usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1317alloc_fail2:
1318	acm_release_minor(acm);
1319	kfree(acm);
1320alloc_fail:
1321	return -ENOMEM;
1322}
1323
1324static void stop_data_traffic(struct acm *acm)
1325{
1326	int i;
1327
1328	dev_dbg(&acm->control->dev, "%s\n", __func__);
1329
1330	usb_kill_urb(acm->ctrlurb);
1331	for (i = 0; i < ACM_NW; i++)
1332		usb_kill_urb(acm->wb[i].urb);
1333	for (i = 0; i < acm->rx_buflimit; i++)
1334		usb_kill_urb(acm->read_urbs[i]);
1335
1336	cancel_work_sync(&acm->work);
1337}
1338
1339static void acm_disconnect(struct usb_interface *intf)
1340{
1341	struct acm *acm = usb_get_intfdata(intf);
1342	struct usb_device *usb_dev = interface_to_usbdev(intf);
1343	struct tty_struct *tty;
1344	int i;
1345
1346	dev_dbg(&intf->dev, "%s\n", __func__);
1347
1348	/* sibling interface is already cleaning up */
1349	if (!acm)
1350		return;
1351
1352	mutex_lock(&acm->mutex);
1353	acm->disconnected = true;
 
 
 
 
 
 
 
1354	if (acm->country_codes) {
1355		device_remove_file(&acm->control->dev,
1356				&dev_attr_wCountryCodes);
1357		device_remove_file(&acm->control->dev,
1358				&dev_attr_iCountryCodeRelDate);
1359	}
 
1360	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1361	usb_set_intfdata(acm->control, NULL);
1362	usb_set_intfdata(acm->data, NULL);
1363	mutex_unlock(&acm->mutex);
1364
1365	tty = tty_port_tty_get(&acm->port);
1366	if (tty) {
1367		tty_vhangup(tty);
1368		tty_kref_put(tty);
1369	}
1370
1371	stop_data_traffic(acm);
 
 
1372
1373	usb_free_urb(acm->ctrlurb);
1374	for (i = 0; i < ACM_NW; i++)
1375		usb_free_urb(acm->wb[i].urb);
1376	for (i = 0; i < acm->rx_buflimit; i++)
1377		usb_free_urb(acm->read_urbs[i]);
1378	acm_write_buffers_free(acm);
1379	usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1380	acm_read_buffers_free(acm);
1381
 
 
1382	if (!acm->combined_interfaces)
1383		usb_driver_release_interface(&acm_driver, intf == acm->control ?
1384					acm->data : acm->control);
1385
1386	tty_port_put(&acm->port);
1387}
1388
1389#ifdef CONFIG_PM
1390static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1391{
1392	struct acm *acm = usb_get_intfdata(intf);
1393	int cnt;
1394
 
1395	if (PMSG_IS_AUTO(message)) {
1396		int b;
1397
1398		spin_lock_irq(&acm->write_lock);
1399		b = acm->transmitting;
1400		spin_unlock_irq(&acm->write_lock);
1401		if (b)
1402			return -EBUSY;
 
1403	}
1404
1405	spin_lock_irq(&acm->read_lock);
1406	spin_lock(&acm->write_lock);
1407	cnt = acm->susp_count++;
1408	spin_unlock(&acm->write_lock);
1409	spin_unlock_irq(&acm->read_lock);
1410
1411	if (cnt)
1412		return 0;
1413
1414	if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1415		stop_data_traffic(acm);
 
1416
1417	return 0;
1418}
1419
1420static int acm_resume(struct usb_interface *intf)
1421{
1422	struct acm *acm = usb_get_intfdata(intf);
1423	struct acm_wb *wb;
1424	int rv = 0;
1425	int cnt;
1426
1427	spin_lock_irq(&acm->read_lock);
1428	acm->susp_count -= 1;
1429	cnt = acm->susp_count;
1430	spin_unlock_irq(&acm->read_lock);
1431
1432	if (cnt)
1433		return 0;
1434
1435	if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1436		rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1437
1438		spin_lock_irq(&acm->write_lock);
1439		if (acm->delayed_wb) {
1440			wb = acm->delayed_wb;
1441			acm->delayed_wb = NULL;
1442			spin_unlock_irq(&acm->write_lock);
1443			acm_start_wb(acm, wb);
1444		} else {
1445			spin_unlock_irq(&acm->write_lock);
 
1446		}
1447
1448		/*
1449		 * delayed error checking because we must
1450		 * do the write path at all cost
1451		 */
1452		if (rv < 0)
1453			goto err_out;
1454
1455		rv = acm_submit_read_urbs(acm, GFP_NOIO);
1456	}
 
 
1457
1458err_out:
1459	return rv;
1460}
1461
1462static int acm_reset_resume(struct usb_interface *intf)
1463{
1464	struct acm *acm = usb_get_intfdata(intf);
1465	struct tty_struct *tty;
1466
1467	if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1468		tty = tty_port_tty_get(&acm->port);
1469		if (tty) {
1470			tty_hangup(tty);
1471			tty_kref_put(tty);
1472		}
1473	}
1474
1475	return acm_resume(intf);
1476}
1477
1478#endif /* CONFIG_PM */
1479
 
 
 
 
 
 
 
 
 
 
1480#define NOKIA_PCSUITE_ACM_INFO(x) \
1481		USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1482		USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1483		USB_CDC_ACM_PROTO_VENDOR)
1484
1485#define SAMSUNG_PCSUITE_ACM_INFO(x) \
1486		USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1487		USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1488		USB_CDC_ACM_PROTO_VENDOR)
1489
1490/*
1491 * USB driver structure.
1492 */
1493
1494static const struct usb_device_id acm_ids[] = {
1495	/* quirky and broken devices */
 
 
 
 
 
 
1496	{ USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1497	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498	},
 
 
 
 
 
 
 
 
 
1499	{ USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1500	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501	},
 
 
 
1502	{ USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1503	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1504	},
1505	{ USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1506	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507	},
1508	{ USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1509	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1510	},
1511	{ USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1512	.driver_info = SINGLE_RX_URB,
1513	},
1514	{ USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1515	.driver_info = SINGLE_RX_URB, /* firmware bug */
1516	},
1517	{ USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1518	.driver_info = SINGLE_RX_URB, /* firmware bug */
1519	},
 
 
 
 
 
 
1520	{ USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1521	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522	},
1523	{ USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1524	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525	},
1526	{ USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1527	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1528	},
1529	{ USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1530	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1531	},
1532	{ USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1533	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1534	},
 
 
 
 
 
 
 
1535	{ USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1536	},
1537	/* Motorola H24 HSPA module: */
1538	{ USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1539	{ USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1540	{ USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1541	{ USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1542	{ USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1543	{ USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1544	{ USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1545	{ USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1546
1547	{ USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1548	.driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1549					   data interface instead of
1550					   communications interface.
1551					   Maybe we should define a new
1552					   quirk for this. */
1553	},
 
 
 
 
 
 
1554	{ USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1555	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1556	},
1557	{ USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1558	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1559	},
 
 
 
 
 
 
 
 
 
 
 
 
 
1560
1561	/* Nokia S60 phones expose two ACM channels. The first is
1562	 * a modem and is picked up by the standard AT-command
1563	 * information below. The second is 'vendor-specific' but
1564	 * is treated as a serial device at the S60 end, so we want
1565	 * to expose it on Linux too. */
1566	{ NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1567	{ NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1568	{ NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1569	{ NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1570	{ NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1571	{ NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1572	{ NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1573	{ NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1574	{ NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1575	{ NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1576	{ NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1577	{ NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1578	{ NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1579	{ NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1580	{ NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1581	{ NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1582	{ NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1583	{ NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1584	{ NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1585	{ NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1586	{ NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1587	{ NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1588	{ NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1589	{ NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1590	{ NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1591	{ NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1592	{ NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1593	{ NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1594	{ NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1595	{ NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1596	{ NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1597	{ NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1598	{ NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1599	{ NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1600	{ NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1601	{ NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1602	{ NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1603	{ NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1604	{ NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1605	{ NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1606	{ NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1607	{ NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1608	{ NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1609	{ NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1610	{ NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1611	{ NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1612	{ NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1613	{ NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1614	{ NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1615	{ NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1616	{ NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1617	{ NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1618	{ NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1619	{ NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1620	{ NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1621	{ NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1622	{ NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1623	{ SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1624
1625	/* Support for Owen devices */
1626	{ USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1627
1628	/* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1629
1630	/* Support Lego NXT using pbLua firmware */
1631	{ USB_DEVICE(0x0694, 0xff00),
1632	.driver_info = NOT_A_MODEM,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1633	},
1634
1635	/* Support for Droids MuIn LCD */
1636	{ USB_DEVICE(0x04d8, 0x000b),
1637	.driver_info = NO_DATA_INTERFACE,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1638	},
1639
1640	/* control interfaces without any protocol set */
1641	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1642		USB_CDC_PROTO_NONE) },
1643
1644	/* control interfaces with various AT-command sets */
1645	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1646		USB_CDC_ACM_PROTO_AT_V25TER) },
1647	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1648		USB_CDC_ACM_PROTO_AT_PCCA101) },
1649	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1650		USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1651	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1652		USB_CDC_ACM_PROTO_AT_GSM) },
1653	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1654		USB_CDC_ACM_PROTO_AT_3G) },
1655	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1656		USB_CDC_ACM_PROTO_AT_CDMA) },
1657
 
 
 
 
1658	{ }
1659};
1660
1661MODULE_DEVICE_TABLE(usb, acm_ids);
1662
1663static struct usb_driver acm_driver = {
1664	.name =		"cdc_acm",
1665	.probe =	acm_probe,
1666	.disconnect =	acm_disconnect,
1667#ifdef CONFIG_PM
1668	.suspend =	acm_suspend,
1669	.resume =	acm_resume,
1670	.reset_resume =	acm_reset_resume,
1671#endif
 
1672	.id_table =	acm_ids,
1673#ifdef CONFIG_PM
1674	.supports_autosuspend = 1,
1675#endif
1676	.disable_hub_initiated_lpm = 1,
1677};
1678
1679/*
1680 * TTY driver structures.
1681 */
1682
1683static const struct tty_operations acm_ops = {
1684	.install =		acm_tty_install,
1685	.open =			acm_tty_open,
1686	.close =		acm_tty_close,
1687	.cleanup =		acm_tty_cleanup,
1688	.hangup =		acm_tty_hangup,
1689	.write =		acm_tty_write,
1690	.write_room =		acm_tty_write_room,
1691	.ioctl =		acm_tty_ioctl,
1692	.throttle =		acm_tty_throttle,
1693	.unthrottle =		acm_tty_unthrottle,
1694	.chars_in_buffer =	acm_tty_chars_in_buffer,
1695	.break_ctl =		acm_tty_break_ctl,
1696	.set_termios =		acm_tty_set_termios,
1697	.tiocmget =		acm_tty_tiocmget,
1698	.tiocmset =		acm_tty_tiocmset,
 
 
 
1699};
1700
1701/*
1702 * Init / exit.
1703 */
1704
1705static int __init acm_init(void)
1706{
1707	int retval;
1708	acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1709	if (!acm_tty_driver)
1710		return -ENOMEM;
1711	acm_tty_driver->driver_name = "acm",
1712	acm_tty_driver->name = "ttyACM",
1713	acm_tty_driver->major = ACM_TTY_MAJOR,
1714	acm_tty_driver->minor_start = 0,
1715	acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1716	acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1717	acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1718	acm_tty_driver->init_termios = tty_std_termios;
1719	acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1720								HUPCL | CLOCAL;
1721	tty_set_operations(acm_tty_driver, &acm_ops);
1722
1723	retval = tty_register_driver(acm_tty_driver);
1724	if (retval) {
1725		put_tty_driver(acm_tty_driver);
1726		return retval;
1727	}
1728
1729	retval = usb_register(&acm_driver);
1730	if (retval) {
1731		tty_unregister_driver(acm_tty_driver);
1732		put_tty_driver(acm_tty_driver);
1733		return retval;
1734	}
1735
1736	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1737
1738	return 0;
1739}
1740
1741static void __exit acm_exit(void)
1742{
1743	usb_deregister(&acm_driver);
1744	tty_unregister_driver(acm_tty_driver);
1745	put_tty_driver(acm_tty_driver);
 
1746}
1747
1748module_init(acm_init);
1749module_exit(acm_exit);
1750
1751MODULE_AUTHOR(DRIVER_AUTHOR);
1752MODULE_DESCRIPTION(DRIVER_DESC);
1753MODULE_LICENSE("GPL");
1754MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);