Lines Matching defs:acm
3 * cdc-acm.c
42 #include "cdc-acm.h"
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);
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);
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)
402 dr = (struct usb_cdc_notification *)acm->notification_buffer;
410 if (acm->nb_size < expected_size) {
414 new_buffer = krealloc(acm->notification_buffer,
417 acm->nb_index = 0;
421 acm->notification_buffer = new_buffer;
422 acm->nb_size = alloc_size;
423 dr = (struct usb_cdc_notification *)acm->notification_buffer;
427 expected_size - acm->nb_index);
429 memcpy(&acm->notification_buffer[acm->nb_index],
431 acm->nb_index += copy_size;
432 current_size = acm->nb_index;
437 acm_process_notification(acm, (unsigned char *)dr);
438 acm->nb_index = 0;
444 dev_err(&acm->control->dev,
447 dev_vdbg(&acm->control->dev,
451 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
455 if (!test_and_clear_bit(index, &acm->read_urbs_free))
458 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
461 dev_err(&acm->data->dev,
465 dev_vdbg(&acm->data->dev, "intended failure %d\n", res);
467 set_bit(index, &acm->read_urbs_free);
470 dev_vdbg(&acm->data->dev, "submitted urb %d\n", index);
476 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
481 for (i = 0; i < acm->rx_buflimit; ++i) {
482 res = acm_submit_read_urb(acm, i, mem_flags);
490 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
497 spin_lock_irqsave(&acm->read_lock, flags);
498 tty_insert_flip_string(&acm->port, urb->transfer_buffer,
500 spin_unlock_irqrestore(&acm->read_lock, flags);
502 tty_flip_buffer_push(&acm->port);
508 struct acm *acm = rb->instance;
514 dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
519 usb_mark_last_busy(acm->dev);
520 acm_process_read_urb(acm, urb);
523 set_bit(EVENT_RX_STALL, &acm->flags);
529 dev_dbg(&acm->data->dev,
536 dev_dbg(&acm->data->dev,
538 usb_mark_last_busy(acm->dev);
539 set_bit(rb->index, &acm->urbs_in_error_delay);
540 set_bit(ACM_ERROR_DELAY, &acm->flags);
544 dev_dbg(&acm->data->dev,
556 set_bit(rb->index, &acm->read_urbs_free);
566 schedule_delayed_work(&acm->dwork, 0);
568 schedule_delayed_work(&acm->dwork, HZ / 2);
572 if (test_bit(ACM_THROTTLED, &acm->flags))
575 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
582 struct acm *acm = wb->instance;
587 dev_vdbg(&acm->data->dev, "wrote len %d/%d, status %d\n",
592 spin_lock_irqsave(&acm->write_lock, flags);
593 acm_write_done(acm, wb);
594 spin_unlock_irqrestore(&acm->write_lock, flags);
595 set_bit(EVENT_TTY_WAKEUP, &acm->flags);
596 schedule_delayed_work(&acm->dwork, 0);
602 struct acm *acm = container_of(work, struct acm, dwork.work);
604 if (test_bit(EVENT_RX_STALL, &acm->flags)) {
606 if (!acm->susp_count) {
607 for (i = 0; i < acm->rx_buflimit; i++)
608 usb_kill_urb(acm->read_urbs[i]);
609 usb_clear_halt(acm->dev, acm->in);
610 acm_submit_read_urbs(acm, GFP_KERNEL);
611 clear_bit(EVENT_RX_STALL, &acm->flags);
615 if (test_and_clear_bit(ACM_ERROR_DELAY, &acm->flags)) {
616 for (i = 0; i < acm->rx_buflimit; i++)
617 if (test_and_clear_bit(i, &acm->urbs_in_error_delay))
618 acm_submit_read_urb(acm, i, GFP_KERNEL);
621 if (test_and_clear_bit(EVENT_TTY_WAKEUP, &acm->flags))
622 tty_port_tty_wakeup(&acm->port);
631 struct acm *acm;
634 acm = acm_get_by_minor(tty->index);
635 if (!acm)
644 * immediately after acm driver has been installed.
646 if (acm->quirks & DISABLE_ECHO)
649 tty->driver_data = acm;
654 tty_port_put(&acm->port);
660 struct acm *acm = tty->driver_data;
662 return tty_port_open(&acm->port, tty, filp);
667 struct acm *acm = container_of(port, struct acm, port);
677 acm->ctrlout = val;
679 res = acm_set_control(acm, val);
680 if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
682 dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
687 struct acm *acm = container_of(port, struct acm, port);
691 mutex_lock(&acm->mutex);
692 if (acm->disconnected)
695 retval = usb_autopm_get_interface(acm->control);
700 acm->control->needs_remote_wakeup = 1;
702 acm->ctrlurb->dev = acm->dev;
703 retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
705 dev_err(&acm->control->dev,
715 clear_bit(ACM_THROTTLED, &acm->flags);
717 retval = acm_submit_read_urbs(acm, GFP_KERNEL);
721 usb_autopm_put_interface(acm->control);
723 mutex_unlock(&acm->mutex);
728 for (i = 0; i < acm->rx_buflimit; i++)
729 usb_kill_urb(acm->read_urbs[i]);
730 usb_kill_urb(acm->ctrlurb);
732 usb_autopm_put_interface(acm->control);
735 mutex_unlock(&acm->mutex);
742 struct acm *acm = container_of(port, struct acm, port);
744 if (acm->minor != ACM_MINOR_INVALID)
745 acm_release_minor(acm);
746 usb_put_intf(acm->control);
747 kfree(acm->country_codes);
748 kfree(acm);
753 struct acm *acm = container_of(port, struct acm, port);
761 acm_poison_urbs(acm);
762 spin_lock_irq(&acm->write_lock);
763 spin_unlock_irq(&acm->write_lock);
765 usb_autopm_get_interface_no_resume(acm->control);
766 acm->control->needs_remote_wakeup = 0;
767 usb_autopm_put_interface(acm->control);
770 urb = usb_get_from_anchor(&acm->delayed);
775 usb_autopm_put_interface_async(acm->control);
778 acm_unpoison_urbs(acm);
784 struct acm *acm = tty->driver_data;
786 tty_port_put(&acm->port);
791 struct acm *acm = tty->driver_data;
793 tty_port_hangup(&acm->port);
798 struct acm *acm = tty->driver_data;
800 tty_port_close(&acm->port, tty, filp);
806 struct acm *acm = tty->driver_data;
815 dev_vdbg(&acm->data->dev, "%zu bytes from tty layer\n", count);
817 spin_lock_irqsave(&acm->write_lock, flags);
818 wbn = acm_wb_alloc(acm);
820 spin_unlock_irqrestore(&acm->write_lock, flags);
823 wb = &acm->wb[wbn];
825 if (!acm->dev) {
827 spin_unlock_irqrestore(&acm->write_lock, flags);
831 count = (count > acm->writesize) ? acm->writesize : count;
832 dev_vdbg(&acm->data->dev, "writing %zu bytes\n", count);
836 stat = usb_autopm_get_interface_async(acm->control);
839 spin_unlock_irqrestore(&acm->write_lock, flags);
843 if (acm->susp_count) {
844 usb_anchor_urb(wb->urb, &acm->delayed);
845 spin_unlock_irqrestore(&acm->write_lock, flags);
849 stat = acm_start_wb(acm, wb);
850 spin_unlock_irqrestore(&acm->write_lock, flags);
859 struct acm *acm = tty->driver_data;
864 return acm_wb_is_avail(acm) ? acm->writesize : 0;
869 struct acm *acm = tty->driver_data;
873 spin_lock_irqsave(&acm->write_lock, flags);
875 if (acm->wb[i].use)
876 usb_unlink_urb(acm->wb[i].urb);
877 spin_unlock_irqrestore(&acm->write_lock, flags);
882 struct acm *acm = tty->driver_data;
887 if (acm->disconnected)
892 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
897 struct acm *acm = tty->driver_data;
899 set_bit(ACM_THROTTLED, &acm->flags);
904 struct acm *acm = tty->driver_data;
906 clear_bit(ACM_THROTTLED, &acm->flags);
911 acm_submit_read_urbs(acm, GFP_KERNEL);
916 struct acm *acm = tty->driver_data;
919 if (!(acm->ctrl_caps & USB_CDC_CAP_BRK))
922 retval = acm_send_break(acm, state ? 0xffff : 0);
924 dev_dbg(&acm->control->dev,
931 struct acm *acm = tty->driver_data;
933 return (acm->ctrlout & USB_CDC_CTRL_DTR ? TIOCM_DTR : 0) |
934 (acm->ctrlout & USB_CDC_CTRL_RTS ? TIOCM_RTS : 0) |
935 (acm->ctrlin & USB_CDC_SERIAL_STATE_DSR ? TIOCM_DSR : 0) |
936 (acm->ctrlin & USB_CDC_SERIAL_STATE_RING_SIGNAL ? TIOCM_RI : 0) |
937 (acm->ctrlin & USB_CDC_SERIAL_STATE_DCD ? TIOCM_CD : 0) |
944 struct acm *acm = tty->driver_data;
947 newctrl = acm->ctrlout;
955 if (acm->ctrlout == newctrl)
957 return acm_set_control(acm, acm->ctrlout = newctrl);
962 struct acm *acm = tty->driver_data;
964 ss->line = acm->minor;
965 ss->close_delay = jiffies_to_msecs(acm->port.close_delay) / 10;
966 ss->closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
968 jiffies_to_msecs(acm->port.closing_wait) / 10;
974 struct acm *acm = tty->driver_data;
983 mutex_lock(&acm->port.mutex);
986 if ((close_delay != acm->port.close_delay) ||
987 (closing_wait != acm->port.closing_wait))
990 acm->port.close_delay = close_delay;
991 acm->port.closing_wait = closing_wait;
994 mutex_unlock(&acm->port.mutex);
998 static int wait_serial_change(struct acm *acm, unsigned long arg)
1005 spin_lock_irq(&acm->read_lock);
1006 old = acm->oldcount;
1007 new = acm->iocount;
1008 acm->oldcount = new;
1009 spin_unlock_irq(&acm->read_lock);
1021 add_wait_queue(&acm->wioctl, &wait);
1024 remove_wait_queue(&acm->wioctl, &wait);
1025 if (acm->disconnected) {
1044 struct acm *acm = tty->driver_data;
1046 icount->dsr = acm->iocount.dsr;
1047 icount->rng = acm->iocount.rng;
1048 icount->dcd = acm->iocount.dcd;
1049 icount->frame = acm->iocount.frame;
1050 icount->overrun = acm->iocount.overrun;
1051 icount->parity = acm->iocount.parity;
1052 icount->brk = acm->iocount.brk;
1060 struct acm *acm = tty->driver_data;
1065 rv = usb_autopm_get_interface(acm->control);
1070 rv = wait_serial_change(acm, arg);
1071 usb_autopm_put_interface(acm->control);
1081 struct acm *acm = tty->driver_data;
1084 int newctrl = acm->ctrlout;
1094 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
1097 newline.dwDTERate = acm->line.dwDTERate;
1103 if (newctrl != acm->ctrlout)
1104 acm_set_control(acm, acm->ctrlout = newctrl);
1106 if (memcmp(&acm->line, &newline, sizeof newline)) {
1107 memcpy(&acm->line, &newline, sizeof newline);
1108 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
1113 acm_set_line(acm, &acm->line);
1129 static void acm_write_buffers_free(struct acm *acm)
1134 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
1135 usb_free_coherent(acm->dev, acm->writesize, wb->buf, wb->dmah);
1138 static void acm_read_buffers_free(struct acm *acm)
1142 for (i = 0; i < acm->rx_buflimit; i++)
1143 usb_free_coherent(acm->dev, acm->readsize,
1144 acm->read_buffers[i].base, acm->read_buffers[i].dma);
1148 static int acm_write_buffers_alloc(struct acm *acm)
1153 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
1154 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
1160 usb_free_coherent(acm->dev, acm->writesize,
1183 struct acm *acm;
1340 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1341 if (!acm)
1344 tty_port_init(&acm->port);
1345 acm->port.ops = &acm_port_ops;
1350 acm->combined_interfaces = combined_interfaces;
1351 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1352 acm->control = control_interface;
1353 acm->data = data_interface;
1355 usb_get_intf(acm->control); /* undone in destruct() */
1357 minor = acm_alloc_minor(acm);
1359 acm->minor = ACM_MINOR_INVALID;
1363 acm->minor = minor;
1364 acm->dev = usb_dev;
1366 acm->ctrl_caps = h.usb_cdc_acm_descriptor->bmCapabilities;
1368 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1369 acm->ctrlsize = ctrlsize;
1370 acm->readsize = readsize;
1371 acm->rx_buflimit = num_rx_buf;
1372 INIT_DELAYED_WORK(&acm->dwork, acm_softint);
1373 init_waitqueue_head(&acm->wioctl);
1374 spin_lock_init(&acm->write_lock);
1375 spin_lock_init(&acm->read_lock);
1376 mutex_init(&acm->mutex);
1378 acm->bInterval = epread->bInterval;
1379 acm->in = usb_rcvintpipe(usb_dev, epread->bEndpointAddress);
1381 acm->in = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1384 acm->out = usb_sndintpipe(usb_dev, epwrite->bEndpointAddress);
1386 acm->out = usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress);
1387 init_usb_anchor(&acm->delayed);
1388 acm->quirks = quirks;
1390 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1393 acm->ctrl_buffer = buf;
1395 if (acm_write_buffers_alloc(acm) < 0)
1398 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1399 if (!acm->ctrlurb)
1403 struct acm_rb *rb = &(acm->read_buffers[i]);
1406 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1411 rb->instance = acm;
1420 usb_fill_int_urb(urb, acm->dev, acm->in, rb->base,
1421 acm->readsize,
1423 acm->bInterval);
1425 usb_fill_bulk_urb(urb, acm->dev, acm->in, rb->base,
1426 acm->readsize,
1429 acm->read_urbs[i] = urb;
1430 __set_bit(i, &acm->read_urbs_free);
1433 struct acm_wb *snd = &(acm->wb[i]);
1440 usb_fill_int_urb(snd->urb, usb_dev, acm->out,
1441 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1443 usb_fill_bulk_urb(snd->urb, usb_dev, acm->out,
1444 NULL, acm->writesize, acm_write_bulk, snd);
1448 snd->instance = acm;
1451 usb_set_intfdata(intf, acm);
1461 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1462 if (!acm->country_codes)
1464 acm->country_code_size = cfd->bLength - 4;
1465 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1467 acm->country_rel_date = cfd->iCountryCodeRelDate;
1471 kfree(acm->country_codes);
1472 acm->country_codes = NULL;
1473 acm->country_code_size = 0;
1481 kfree(acm->country_codes);
1482 acm->country_codes = NULL;
1483 acm->country_code_size = 0;
1489 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1491 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1494 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1495 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1496 acm->notification_buffer = NULL;
1497 acm->nb_index = 0;
1498 acm->nb_size = 0;
1500 acm->line.dwDTERate = cpu_to_le32(9600);
1501 acm->line.bDataBits = 8;
1502 acm_set_line(acm, &acm->line);
1504 if (!acm->combined_interfaces) {
1505 rv = usb_driver_claim_interface(&acm_driver, data_interface, acm);
1510 tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
1518 usb_clear_halt(usb_dev, acm->in);
1519 usb_clear_halt(usb_dev, acm->out);
1527 if (!acm->combined_interfaces) {
1533 if (acm->country_codes) {
1534 device_remove_file(&acm->control->dev,
1536 device_remove_file(&acm->control->dev,
1539 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1542 usb_free_urb(acm->wb[i].urb);
1545 usb_free_urb(acm->read_urbs[i]);
1546 acm_read_buffers_free(acm);
1547 usb_free_urb(acm->ctrlurb);
1549 acm_write_buffers_free(acm);
1551 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1553 tty_port_put(&acm->port);
1560 struct acm *acm = usb_get_intfdata(intf);
1565 if (!acm)
1568 acm->disconnected = true;
1574 acm_poison_urbs(acm);
1575 mutex_lock(&acm->mutex);
1576 if (acm->country_codes) {
1577 device_remove_file(&acm->control->dev,
1579 device_remove_file(&acm->control->dev,
1582 wake_up_all(&acm->wioctl);
1583 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1584 usb_set_intfdata(acm->control, NULL);
1585 usb_set_intfdata(acm->data, NULL);
1586 mutex_unlock(&acm->mutex);
1588 tty = tty_port_tty_get(&acm->port);
1594 cancel_delayed_work_sync(&acm->dwork);
1596 tty_unregister_device(acm_tty_driver, acm->minor);
1598 usb_free_urb(acm->ctrlurb);
1600 usb_free_urb(acm->wb[i].urb);
1601 for (i = 0; i < acm->rx_buflimit; i++)
1602 usb_free_urb(acm->read_urbs[i]);
1603 acm_write_buffers_free(acm);
1604 usb_free_coherent(acm->dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1605 acm_read_buffers_free(acm);
1607 kfree(acm->notification_buffer);
1609 if (!acm->combined_interfaces)
1610 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1611 acm->data : acm->control);
1613 tty_port_put(&acm->port);
1619 struct acm *acm = usb_get_intfdata(intf);
1622 spin_lock_irq(&acm->write_lock);
1624 if (acm->transmitting) {
1625 spin_unlock_irq(&acm->write_lock);
1629 cnt = acm->susp_count++;
1630 spin_unlock_irq(&acm->write_lock);
1635 acm_poison_urbs(acm);
1636 cancel_delayed_work_sync(&acm->dwork);
1637 acm->urbs_in_error_delay = 0;
1644 struct acm *acm = usb_get_intfdata(intf);
1648 spin_lock_irq(&acm->write_lock);
1650 if (--acm->susp_count)
1653 acm_unpoison_urbs(acm);
1655 if (tty_port_initialized(&acm->port)) {
1656 rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1659 urb = usb_get_from_anchor(&acm->delayed);
1663 acm_start_wb(acm, urb->context);
1673 rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1676 spin_unlock_irq(&acm->write_lock);
1683 struct acm *acm = usb_get_intfdata(intf);
1685 if (tty_port_initialized(&acm->port))
1686 tty_port_tty_hangup(&acm->port, false);
1695 struct acm *acm = usb_get_intfdata(intf);
1697 clear_bit(EVENT_RX_STALL, &acm->flags);
1698 acm->nb_index = 0; /* pending control transfers are lost */
2071 acm_tty_driver->driver_name = "acm",