Lines Matching full:acm
3 * cdc-acm.c
42 #include "cdc-acm.h"
62 * Look up an ACM structure by minor. If found and not disconnected, increment
65 static struct acm *acm_get_by_minor(unsigned int minor)
67 struct acm *acm;
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;
77 tty_port_get(&acm->port);
78 mutex_unlock(&acm->mutex);
82 return acm;
86 * Try to find an available minor number and if found, associate it with 'acm'.
88 static int acm_alloc_minor(struct acm *acm)
93 minor = idr_alloc(&acm_minors, acm, 0, ACM_TTY_MINORS, GFP_KERNEL);
99 /* Release the minor number associated with 'acm'. */
100 static void acm_release_minor(struct acm *acm)
103 idr_remove(&acm_minors, acm->minor);
108 * Functions for ACM control messages.
111 static int acm_ctrl_msg(struct acm *acm, int request, int value,
116 retval = usb_autopm_get_interface(acm->control);
120 retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
122 acm->control->altsetting[0].desc.bInterfaceNumber,
125 dev_dbg(&acm->control->dev,
129 usb_autopm_put_interface(acm->control);
135 * the cdc acm descriptor tells whether they do...
137 static inline int acm_set_control(struct acm *acm, int control)
139 if (acm->quirks & QUIRK_CONTROL_LINE_STATE)
142 return acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE,
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)
151 static void acm_poison_urbs(struct acm *acm)
155 usb_poison_urb(acm->ctrlurb);
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]);
162 static void acm_unpoison_urbs(struct acm *acm)
166 for (i = 0; i < acm->rx_buflimit; i++)
167 usb_unpoison_urb(acm->read_urbs[i]);
169 usb_unpoison_urb(acm->wb[i].urb);
170 usb_unpoison_urb(acm->ctrlurb);
179 static int acm_wb_alloc(struct acm *acm)
187 wb = &acm->wb[wbn];
199 static int acm_wb_is_avail(struct acm *acm)
205 spin_lock_irqsave(&acm->write_lock, flags);
207 if(acm->wb[i].use)
209 spin_unlock_irqrestore(&acm->write_lock, flags);
214 * Finish write. Caller must hold acm->write_lock
216 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
219 acm->transmitting--;
220 usb_autopm_put_interface_async(acm->control);
229 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
233 acm->transmitting++;
238 wb->urb->dev = acm->dev;
243 dev_err(&acm->data->dev,
246 acm_write_done(acm, wb);
258 struct acm *acm = usb_get_intfdata(intf);
260 return sprintf(buf, "%d", acm->ctrl_caps);
268 struct acm *acm = usb_get_intfdata(intf);
270 memcpy(buf, acm->country_codes, acm->country_code_size);
271 return acm->country_code_size;
280 struct acm *acm = usb_get_intfdata(intf);
282 return sprintf(buf, "%d", acm->country_rel_date);
287 * Interrupt handlers for various ACM device responses
290 static void acm_process_notification(struct acm *acm, unsigned char *buf)
300 dev_dbg(&acm->control->dev,
306 dev_dbg(&acm->control->dev,
312 dev_dbg(&acm->control->dev,
315 if (!acm->clocal && (acm->ctrlin & ~newctrl & USB_CDC_SERIAL_STATE_DCD)) {
316 dev_dbg(&acm->control->dev,
318 tty_port_tty_hangup(&acm->port, false);
321 difference = acm->ctrlin ^ newctrl;
323 if ((difference & USB_CDC_SERIAL_STATE_DCD) && acm->port.tty) {
324 struct tty_ldisc *ld = tty_ldisc_ref(acm->port.tty);
327 ld->ops->dcd_change(acm->port.tty, newctrl & USB_CDC_SERIAL_STATE_DCD);
332 spin_lock_irqsave(&acm->read_lock, flags);
333 acm->ctrlin = newctrl;
334 acm->oldcount = acm->iocount;
337 acm->iocount.dsr++;
339 acm->iocount.dcd++;
341 acm->iocount.brk++;
342 tty_insert_flip_char(&acm->port, 0, TTY_BREAK);
345 acm->iocount.rng++;
347 acm->iocount.frame++;
349 acm->iocount.parity++;
351 acm->iocount.overrun++;
352 spin_unlock_irqrestore(&acm->read_lock, flags);
355 tty_flip_buffer_push(&acm->port);
358 wake_up_all(&acm->wioctl);
363 dev_dbg(&acm->control->dev,
373 struct acm *acm = urb->context;
388 dev_dbg(&acm->control->dev,
393 dev_dbg(&acm->control->dev,
399 usb_mark_last_busy(acm->dev);
401 if (acm->nb_index == 0) {
408 dev_dbg(&acm->control->dev, "urb too short\n");
413 dr = (struct usb_cdc_notification *)acm->notification_buffer;
419 if (acm->nb_index != 0 || current_size < expected_size) {
421 if (acm->nb_size < expected_size) {
425 new_buffer = krealloc(acm->notification_buffer,
428 acm->nb_index = 0;
432 acm->notification_buffer = new_buffer;
433 acm->nb_size = alloc_size;
434 dr = (struct usb_cdc_notification *)acm->notification_buffer;
438 expected_size - acm->nb_index);
440 memcpy(&acm->notification_buffer[acm->nb_index],
442 acm->nb_index += copy_size;
443 current_size = acm->nb_index;
448 acm_process_notification(acm, (unsigned char *)dr);
449 acm->nb_index = 0;
455 dev_err(&acm->control->dev,
458 dev_vdbg(&acm->control->dev,
462 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
466 if (!test_and_clear_bit(index, &acm->read_urbs_free))
469 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
472 dev_err(&acm->data->dev,
476 dev_vdbg(&acm->data->dev, "intended failure %d\n", res);
478 set_bit(index, &acm->read_urbs_free);
481 dev_vdbg(&acm->data->dev, "submitted urb %d\n", index);
487 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
492 for (i = 0; i < acm->rx_buflimit; ++i) {
493 res = acm_submit_read_urb(acm, i, mem_flags);
501 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
508 spin_lock_irqsave(&acm->read_lock, flags);
509 tty_insert_flip_string(&acm->port, urb->transfer_buffer,
511 spin_unlock_irqrestore(&acm->read_lock, flags);
513 tty_flip_buffer_push(&acm->port);
519 struct acm *acm = rb->instance;
525 dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
530 usb_mark_last_busy(acm->dev);
531 acm_process_read_urb(acm, urb);
534 set_bit(EVENT_RX_STALL, &acm->flags);
540 dev_dbg(&acm->data->dev,
547 dev_dbg(&acm->data->dev,
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);
555 dev_dbg(&acm->data->dev,
567 set_bit(rb->index, &acm->read_urbs_free);
577 schedule_delayed_work(&acm->dwork, 0);
579 schedule_delayed_work(&acm->dwork, HZ / 2);
583 if (test_bit(ACM_THROTTLED, &acm->flags))
586 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
593 struct acm *acm = wb->instance;
598 dev_vdbg(&acm->data->dev, "wrote len %d/%d, status %d\n",
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);
613 struct acm *acm = container_of(work, struct acm, dwork.work);
615 if (test_bit(EVENT_RX_STALL, &acm->flags)) {
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);
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);
632 if (test_and_clear_bit(EVENT_TTY_WAKEUP, &acm->flags))
633 tty_port_tty_wakeup(&acm->port);
642 struct acm *acm;
645 acm = acm_get_by_minor(tty->index);
646 if (!acm)
655 * immediately after acm driver has been installed.
657 if (acm->quirks & DISABLE_ECHO)
660 tty->driver_data = acm;
665 tty_port_put(&acm->port);
671 struct acm *acm = tty->driver_data;
673 return tty_port_open(&acm->port, tty, filp);
678 struct acm *acm = container_of(port, struct acm, port);
688 acm->ctrlout = val;
690 res = acm_set_control(acm, val);
691 if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
693 dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
698 struct acm *acm = container_of(port, struct acm, port);
702 mutex_lock(&acm->mutex);
703 if (acm->disconnected)
706 retval = usb_autopm_get_interface(acm->control);
711 acm->control->needs_remote_wakeup = 1;
713 acm->ctrlurb->dev = acm->dev;
714 retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
716 dev_err(&acm->control->dev,
726 clear_bit(ACM_THROTTLED, &acm->flags);
728 retval = acm_submit_read_urbs(acm, GFP_KERNEL);
732 usb_autopm_put_interface(acm->control);
734 mutex_unlock(&acm->mutex);
739 for (i = 0; i < acm->rx_buflimit; i++)
740 usb_kill_urb(acm->read_urbs[i]);
741 usb_kill_urb(acm->ctrlurb);
743 usb_autopm_put_interface(acm->control);
746 mutex_unlock(&acm->mutex);
753 struct acm *acm = container_of(port, struct acm, port);
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);
764 struct acm *acm = container_of(port, struct acm, port);
772 acm_poison_urbs(acm);
773 spin_lock_irq(&acm->write_lock);
774 spin_unlock_irq(&acm->write_lock);
776 usb_autopm_get_interface_no_resume(acm->control);
777 acm->control->needs_remote_wakeup = 0;
778 usb_autopm_put_interface(acm->control);
781 urb = usb_get_from_anchor(&acm->delayed);
786 usb_autopm_put_interface_async(acm->control);
789 acm_unpoison_urbs(acm);
795 struct acm *acm = tty->driver_data;
797 tty_port_put(&acm->port);
802 struct acm *acm = tty->driver_data;
804 tty_port_hangup(&acm->port);
809 struct acm *acm = tty->driver_data;
811 tty_port_close(&acm->port, tty, filp);
817 struct acm *acm = tty->driver_data;
826 dev_vdbg(&acm->data->dev, "%zu bytes from tty layer\n", count);
828 spin_lock_irqsave(&acm->write_lock, flags);
829 wbn = acm_wb_alloc(acm);
831 spin_unlock_irqrestore(&acm->write_lock, flags);
834 wb = &acm->wb[wbn];
836 if (!acm->dev) {
838 spin_unlock_irqrestore(&acm->write_lock, flags);
842 count = (count > acm->writesize) ? acm->writesize : count;
843 dev_vdbg(&acm->data->dev, "writing %zu bytes\n", count);
847 stat = usb_autopm_get_interface_async(acm->control);
850 spin_unlock_irqrestore(&acm->write_lock, flags);
854 if (acm->susp_count) {
855 usb_anchor_urb(wb->urb, &acm->delayed);
856 spin_unlock_irqrestore(&acm->write_lock, flags);
860 stat = acm_start_wb(acm, wb);
861 spin_unlock_irqrestore(&acm->write_lock, flags);
870 struct acm *acm = tty->driver_data;
875 return acm_wb_is_avail(acm) ? acm->writesize : 0;
880 struct acm *acm = tty->driver_data;
884 spin_lock_irqsave(&acm->write_lock, flags);
886 if (acm->wb[i].use)
887 usb_unlink_urb(acm->wb[i].urb);
888 spin_unlock_irqrestore(&acm->write_lock, flags);
893 struct acm *acm = tty->driver_data;
898 if (acm->disconnected)
903 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
908 struct acm *acm = tty->driver_data;
910 set_bit(ACM_THROTTLED, &acm->flags);
915 struct acm *acm = tty->driver_data;
917 clear_bit(ACM_THROTTLED, &acm->flags);
922 acm_submit_read_urbs(acm, GFP_KERNEL);
927 struct acm *acm = tty->driver_data;
930 if (!(acm->ctrl_caps & USB_CDC_CAP_BRK))
933 retval = acm_send_break(acm, state ? 0xffff : 0);
935 dev_dbg(&acm->control->dev,
942 struct acm *acm = tty->driver_data;
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) |
955 struct acm *acm = tty->driver_data;
958 newctrl = acm->ctrlout;
966 if (acm->ctrlout == newctrl)
968 return acm_set_control(acm, acm->ctrlout = newctrl);
973 struct acm *acm = tty->driver_data;
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 ?
980 jiffies_to_msecs(acm->port.closing_wait) / 10;
981 mutex_unlock(&acm->port.mutex);
987 struct acm *acm = tty->driver_data;
996 mutex_lock(&acm->port.mutex);
999 if ((close_delay != acm->port.close_delay) ||
1000 (closing_wait != acm->port.closing_wait))
1003 acm->port.close_delay = close_delay;
1004 acm->port.closing_wait = closing_wait;
1007 mutex_unlock(&acm->port.mutex);
1011 static int wait_serial_change(struct acm *acm, unsigned long arg)
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);
1034 add_wait_queue(&acm->wioctl, &wait);
1037 remove_wait_queue(&acm->wioctl, &wait);
1038 if (acm->disconnected) {
1057 struct acm *acm = tty->driver_data;
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;
1073 struct acm *acm = tty->driver_data;
1078 rv = usb_autopm_get_interface(acm->control);
1083 rv = wait_serial_change(acm, arg);
1084 usb_autopm_put_interface(acm->control);
1094 struct acm *acm = tty->driver_data;
1097 int newctrl = acm->ctrlout;
1107 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
1110 newline.dwDTERate = acm->line.dwDTERate;
1116 if (newctrl != acm->ctrlout)
1117 acm_set_control(acm, acm->ctrlout = newctrl);
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",
1126 acm_set_line(acm, &acm->line);
1142 static void acm_write_buffers_free(struct acm *acm)
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);
1151 static void acm_read_buffers_free(struct acm *acm)
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);
1161 static int acm_write_buffers_alloc(struct acm *acm)
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,
1173 usb_free_coherent(acm->dev, acm->writesize,
1196 struct acm *acm;
1353 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1354 if (!acm)
1357 tty_port_init(&acm->port);
1358 acm->port.ops = &acm_port_ops;
1363 acm->combined_interfaces = combined_interfaces;
1364 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1365 acm->control = control_interface;
1366 acm->data = data_interface;
1368 usb_get_intf(acm->control); /* undone in destruct() */
1370 minor = acm_alloc_minor(acm);
1372 acm->minor = ACM_MINOR_INVALID;
1376 acm->minor = minor;
1377 acm->dev = usb_dev;
1379 acm->ctrl_caps = h.usb_cdc_acm_descriptor->bmCapabilities;
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);
1391 acm->bInterval = epread->bInterval;
1392 acm->in = usb_rcvintpipe(usb_dev, epread->bEndpointAddress);
1394 acm->in = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1397 acm->out = usb_sndintpipe(usb_dev, epwrite->bEndpointAddress);
1399 acm->out = usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress);
1400 init_usb_anchor(&acm->delayed);
1401 acm->quirks = quirks;
1403 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1406 acm->ctrl_buffer = buf;
1408 if (acm_write_buffers_alloc(acm) < 0)
1411 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1412 if (!acm->ctrlurb)
1416 struct acm_rb *rb = &(acm->read_buffers[i]);
1419 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1424 rb->instance = acm;
1433 usb_fill_int_urb(urb, acm->dev, acm->in, rb->base,
1434 acm->readsize,
1436 acm->bInterval);
1438 usb_fill_bulk_urb(urb, acm->dev, acm->in, rb->base,
1439 acm->readsize,
1442 acm->read_urbs[i] = urb;
1443 __set_bit(i, &acm->read_urbs_free);
1446 struct acm_wb *snd = &(acm->wb[i]);
1453 usb_fill_int_urb(snd->urb, usb_dev, acm->out,
1454 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1456 usb_fill_bulk_urb(snd->urb, usb_dev, acm->out,
1457 NULL, acm->writesize, acm_write_bulk, snd);
1461 snd->instance = acm;
1464 usb_set_intfdata(intf, acm);
1474 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1475 if (!acm->country_codes)
1477 acm->country_code_size = cfd->bLength - 4;
1478 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1480 acm->country_rel_date = cfd->iCountryCodeRelDate;
1484 kfree(acm->country_codes);
1485 acm->country_codes = NULL;
1486 acm->country_code_size = 0;
1494 kfree(acm->country_codes);
1495 acm->country_codes = NULL;
1496 acm->country_code_size = 0;
1502 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1504 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
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;
1513 acm->line.dwDTERate = cpu_to_le32(9600);
1514 acm->line.bDataBits = 8;
1515 acm_set_line(acm, &acm->line);
1517 if (!acm->combined_interfaces) {
1518 rv = usb_driver_claim_interface(&acm_driver, data_interface, acm);
1523 tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
1531 usb_clear_halt(usb_dev, acm->in);
1532 usb_clear_halt(usb_dev, acm->out);
1535 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1540 if (!acm->combined_interfaces) {
1546 if (acm->country_codes) {
1547 device_remove_file(&acm->control->dev,
1549 device_remove_file(&acm->control->dev,
1552 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1555 usb_free_urb(acm->wb[i].urb);
1558 usb_free_urb(acm->read_urbs[i]);
1559 acm_read_buffers_free(acm);
1560 usb_free_urb(acm->ctrlurb);
1562 acm_write_buffers_free(acm);
1564 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1566 tty_port_put(&acm->port);
1573 struct acm *acm = usb_get_intfdata(intf);
1578 if (!acm)
1581 acm->disconnected = true;
1587 acm_poison_urbs(acm);
1588 mutex_lock(&acm->mutex);
1589 if (acm->country_codes) {
1590 device_remove_file(&acm->control->dev,
1592 device_remove_file(&acm->control->dev,
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);
1601 tty = tty_port_tty_get(&acm->port);
1607 cancel_delayed_work_sync(&acm->dwork);
1609 tty_unregister_device(acm_tty_driver, acm->minor);
1611 usb_free_urb(acm->ctrlurb);
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);
1620 kfree(acm->notification_buffer);
1622 if (!acm->combined_interfaces)
1623 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1624 acm->data : acm->control);
1626 tty_port_put(&acm->port);
1632 struct acm *acm = usb_get_intfdata(intf);
1635 spin_lock_irq(&acm->write_lock);
1637 if (acm->transmitting) {
1638 spin_unlock_irq(&acm->write_lock);
1642 cnt = acm->susp_count++;
1643 spin_unlock_irq(&acm->write_lock);
1648 acm_poison_urbs(acm);
1649 cancel_delayed_work_sync(&acm->dwork);
1650 acm->urbs_in_error_delay = 0;
1657 struct acm *acm = usb_get_intfdata(intf);
1661 spin_lock_irq(&acm->write_lock);
1663 if (--acm->susp_count)
1666 acm_unpoison_urbs(acm);
1668 if (tty_port_initialized(&acm->port)) {
1669 rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1672 urb = usb_get_from_anchor(&acm->delayed);
1676 acm_start_wb(acm, urb->context);
1686 rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1689 spin_unlock_irq(&acm->write_lock);
1696 struct acm *acm = usb_get_intfdata(intf);
1698 if (tty_port_initialized(&acm->port))
1699 tty_port_tty_hangup(&acm->port, false);
1708 struct acm *acm = usb_get_intfdata(intf);
1710 clear_bit(EVENT_RX_STALL, &acm->flags);
1711 acm->nb_index = 0; /* pending control transfers are lost */
1870 /* Nokia S60 phones expose two ACM channels. The first is
1936 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1992 { USB_DEVICE(0x1bc7, 0x0021), /* Telit 3G ACM only composition */
1995 { USB_DEVICE(0x1bc7, 0x0023), /* Telit 3G ACM + ECM composition */
2090 acm_tty_driver->driver_name = "acm",