Lines Matching refs:acm
2 * cdc-acm.c
19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm
22 * v0.14 - sized down struct acm
74 #include "cdc-acm.h"
88 static struct acm *acm_table[ACM_TTY_MINORS];
92 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
107 static int acm_ctrl_msg(struct acm *acm, int request, int value,
110 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
112 acm->control->altsetting[0].desc.bInterfaceNumber,
120 * the cdc acm descriptor tells whether they do...
122 #define acm_set_control(acm, control) \
123 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
124 #define acm_set_line(acm, line) \
125 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
126 #define acm_send_break(acm, ms) \
127 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
134 static int acm_wb_alloc(struct acm *acm)
142 wb = &acm->wb[wbn];
153 static int acm_wb_is_avail(struct acm *acm)
159 spin_lock_irqsave(&acm->write_lock, flags);
161 n -= acm->wb[i].use;
162 spin_unlock_irqrestore(&acm->write_lock, flags);
167 * Finish write. Caller must hold acm->write_lock
169 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
172 acm->transmitting--;
173 usb_autopm_put_interface_async(acm->control);
182 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
186 acm->transmitting++;
191 wb->urb->dev = acm->dev;
196 acm_write_done(acm, wb);
201 static int acm_write_start(struct acm *acm, int wbn)
204 struct acm_wb *wb = &acm->wb[wbn];
207 spin_lock_irqsave(&acm->write_lock, flags);
208 if (!acm->dev) {
210 spin_unlock_irqrestore(&acm->write_lock, flags);
214 dbg("%s susp_count: %d", __func__, acm->susp_count);
215 usb_autopm_get_interface_async(acm->control);
216 if (acm->susp_count) {
217 if (!acm->delayed_wb)
218 acm->delayed_wb = wb;
220 usb_autopm_put_interface_async(acm->control);
221 spin_unlock_irqrestore(&acm->write_lock, flags);
224 usb_mark_last_busy(acm->dev);
226 rc = acm_start_wb(acm, wb);
227 spin_unlock_irqrestore(&acm->write_lock, flags);
239 struct acm *acm = usb_get_intfdata(intf);
241 return sprintf(buf, "%d", acm->ctrl_caps);
249 struct acm *acm = usb_get_intfdata(intf);
251 memcpy(buf, acm->country_codes, acm->country_code_size);
252 return acm->country_code_size;
261 struct acm *acm = usb_get_intfdata(intf);
263 return sprintf(buf, "%d", acm->country_rel_date);
274 struct acm *acm = urb->context;
297 if (!ACM_READY(acm))
308 tty = tty_port_tty_get(&acm->port);
312 if (!acm->clocal &&
313 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
320 acm->ctrlin = newctrl;
323 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
325 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
326 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
327 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
328 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
329 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
339 usb_mark_last_busy(acm->dev);
351 struct acm *acm = rcv->instance;
356 if (!ACM_READY(acm)) {
357 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
360 usb_mark_last_busy(acm->dev);
363 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
369 spin_lock(&acm->read_lock);
370 acm->processing++;
371 list_add_tail(&rcv->list, &acm->spare_read_urbs);
372 list_add_tail(&buf->list, &acm->filled_read_bufs);
373 spin_unlock(&acm->read_lock);
376 spin_lock(&acm->read_lock);
377 list_add_tail(&rcv->list, &acm->spare_read_urbs);
378 list_add(&buf->list, &acm->spare_read_bufs);
379 spin_unlock(&acm->read_lock);
383 if (likely(!acm->susp_count))
384 tasklet_schedule(&acm->urb_task);
389 struct acm *acm = (void *)_acm;
398 if (!ACM_READY(acm)) {
403 spin_lock_irqsave(&acm->throttle_lock, flags);
404 throttled = acm->throttle;
405 spin_unlock_irqrestore(&acm->throttle_lock, flags);
411 tty = tty_port_tty_get(&acm->port);
414 spin_lock_irqsave(&acm->read_lock, flags);
415 if (list_empty(&acm->filled_read_bufs)) {
416 spin_unlock_irqrestore(&acm->read_lock, flags);
419 buf = list_entry(acm->filled_read_bufs.next,
422 spin_unlock_irqrestore(&acm->read_lock, flags);
427 spin_lock_irqsave(&acm->throttle_lock, flags);
428 throttled = acm->throttle;
429 spin_unlock_irqrestore(&acm->throttle_lock, flags);
436 spin_lock_irqsave(&acm->read_lock, flags);
437 list_add(&buf->list, &acm->filled_read_bufs);
438 spin_unlock_irqrestore(&acm->read_lock, flags);
443 spin_lock_irqsave(&acm->read_lock, flags);
444 list_add(&buf->list, &acm->spare_read_bufs);
445 spin_unlock_irqrestore(&acm->read_lock, flags);
451 while (!list_empty(&acm->spare_read_bufs)) {
452 spin_lock_irqsave(&acm->read_lock, flags);
453 if (list_empty(&acm->spare_read_urbs)) {
454 acm->processing = 0;
455 spin_unlock_irqrestore(&acm->read_lock, flags);
458 rcv = list_entry(acm->spare_read_urbs.next,
461 spin_unlock_irqrestore(&acm->read_lock, flags);
463 buf = list_entry(acm->spare_read_bufs.next,
469 if (acm->is_int_ep)
470 usb_fill_int_urb(rcv->urb, acm->dev,
471 acm->rx_endpoint,
473 acm->readsize,
474 acm_read_bulk, rcv, acm->bInterval);
476 usb_fill_bulk_urb(rcv->urb, acm->dev,
477 acm->rx_endpoint,
479 acm->readsize,
486 spin_lock_irqsave(&acm->read_lock, flags);
487 if (acm->susp_count ||
489 list_add(&buf->list, &acm->spare_read_bufs);
490 list_add(&rcv->list, &acm->spare_read_urbs);
491 acm->processing = 0;
492 spin_unlock_irqrestore(&acm->read_lock, flags);
495 spin_unlock_irqrestore(&acm->read_lock, flags);
499 spin_lock_irqsave(&acm->read_lock, flags);
500 acm->processing = 0;
501 spin_unlock_irqrestore(&acm->read_lock, flags);
508 struct acm *acm = wb->instance;
513 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
518 spin_lock_irqsave(&acm->write_lock, flags);
519 acm_write_done(acm, wb);
520 spin_unlock_irqrestore(&acm->write_lock, flags);
521 if (ACM_READY(acm))
522 schedule_work(&acm->work);
524 wake_up_interruptible(&acm->drain_wait);
529 struct acm *acm = container_of(work, struct acm, work);
532 dev_vdbg(&acm->data->dev, "tx work\n");
533 if (!ACM_READY(acm))
535 tty = tty_port_tty_get(&acm->port);
546 struct acm *acm;
553 acm = acm_table[tty->index];
554 if (!acm || !acm->dev)
561 tty->driver_data = acm;
562 tty_port_tty_set(&acm->port, tty);
564 if (usb_autopm_get_interface(acm->control) < 0)
567 acm->control->needs_remote_wakeup = 1;
569 mutex_lock(&acm->mutex);
570 if (acm->port.count++) {
571 mutex_unlock(&acm->mutex);
572 usb_autopm_put_interface(acm->control);
576 acm->ctrlurb->dev = acm->dev;
577 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
582 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
583 (acm->ctrl_caps & USB_CDC_CAP_LINE))
586 usb_autopm_put_interface(acm->control);
588 INIT_LIST_HEAD(&acm->spare_read_urbs);
589 INIT_LIST_HEAD(&acm->spare_read_bufs);
590 INIT_LIST_HEAD(&acm->filled_read_bufs);
592 for (i = 0; i < acm->rx_buflimit; i++)
593 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
594 for (i = 0; i < acm->rx_buflimit; i++)
595 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
597 acm->throttle = 0;
599 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
600 rv = tty_port_block_til_ready(&acm->port, tty, filp);
601 tasklet_schedule(&acm->urb_task);
603 mutex_unlock(&acm->mutex);
609 usb_kill_urb(acm->ctrlurb);
611 acm->port.count--;
612 mutex_unlock(&acm->mutex);
613 usb_autopm_put_interface(acm->control);
616 tty_port_tty_set(&acm->port, NULL);
620 static void acm_tty_unregister(struct acm *acm)
624 nr = acm->rx_buflimit;
625 tty_unregister_device(acm_tty_driver, acm->minor);
626 usb_put_intf(acm->control);
627 acm_table[acm->minor] = NULL;
628 usb_free_urb(acm->ctrlurb);
630 usb_free_urb(acm->wb[i].urb);
632 usb_free_urb(acm->ru[i].urb);
633 kfree(acm->country_codes);
634 kfree(acm);
639 static void acm_port_down(struct acm *acm)
641 int i, nr = acm->rx_buflimit;
643 if (acm->dev) {
644 usb_autopm_get_interface(acm->control);
645 acm_set_control(acm, acm->ctrlout = 0);
646 usb_kill_urb(acm->ctrlurb);
648 usb_kill_urb(acm->wb[i].urb);
650 usb_kill_urb(acm->ru[i].urb);
651 acm->control->needs_remote_wakeup = 0;
652 usb_autopm_put_interface(acm->control);
659 struct acm *acm = tty->driver_data;
660 tty_port_hangup(&acm->port);
661 acm_port_down(acm);
666 struct acm *acm = tty->driver_data;
670 if (!acm)
672 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
674 if (!acm->dev) {
675 tty_port_tty_set(&acm->port, NULL);
676 acm_tty_unregister(acm);
682 acm_port_down(acm);
683 tty_port_close_end(&acm->port, tty);
684 tty_port_tty_set(&acm->port, NULL);
690 struct acm *acm = tty->driver_data;
698 if (!ACM_READY(acm))
703 spin_lock_irqsave(&acm->write_lock, flags);
704 wbn = acm_wb_alloc(acm);
706 spin_unlock_irqrestore(&acm->write_lock, flags);
709 wb = &acm->wb[wbn];
711 count = (count > acm->writesize) ? acm->writesize : count;
715 spin_unlock_irqrestore(&acm->write_lock, flags);
717 stat = acm_write_start(acm, wbn);
725 struct acm *acm = tty->driver_data;
726 if (!ACM_READY(acm))
732 return acm_wb_is_avail(acm) ? acm->writesize : 0;
737 struct acm *acm = tty->driver_data;
738 if (!ACM_READY(acm))
743 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
748 struct acm *acm = tty->driver_data;
749 if (!ACM_READY(acm))
751 spin_lock_bh(&acm->throttle_lock);
752 acm->throttle = 1;
753 spin_unlock_bh(&acm->throttle_lock);
758 struct acm *acm = tty->driver_data;
759 if (!ACM_READY(acm))
761 spin_lock_bh(&acm->throttle_lock);
762 acm->throttle = 0;
763 spin_unlock_bh(&acm->throttle_lock);
764 tasklet_schedule(&acm->urb_task);
769 struct acm *acm = tty->driver_data;
771 if (!ACM_READY(acm))
773 retval = acm_send_break(acm, state ? 0xffff : 0);
781 struct acm *acm = tty->driver_data;
783 if (!ACM_READY(acm))
786 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
787 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
788 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
789 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
790 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
797 struct acm *acm = tty->driver_data;
800 if (!ACM_READY(acm))
803 newctrl = acm->ctrlout;
811 if (acm->ctrlout == newctrl)
813 return acm_set_control(acm, acm->ctrlout = newctrl);
819 struct acm *acm = tty->driver_data;
821 if (!ACM_READY(acm))
842 struct acm *acm = tty->driver_data;
845 int newctrl = acm->ctrlout;
847 if (!ACM_READY(acm))
856 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
859 newline.dwDTERate = acm->line.dwDTERate;
864 if (newctrl != acm->ctrlout)
865 acm_set_control(acm, acm->ctrlout = newctrl);
867 if (memcmp(&acm->line, &newline, sizeof newline)) {
868 memcpy(&acm->line, &newline, sizeof newline);
872 acm_set_line(acm, &acm->line);
881 static void acm_write_buffers_free(struct acm *acm)
885 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
887 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
888 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
891 static void acm_read_buffers_free(struct acm *acm)
893 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
894 int i, n = acm->rx_buflimit;
897 usb_free_coherent(usb_dev, acm->readsize,
898 acm->rb[i].base, acm->rb[i].dma);
902 static int acm_write_buffers_alloc(struct acm *acm)
907 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
908 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
914 usb_free_coherent(acm->dev, acm->writesize,
936 struct acm *acm;
1132 dev_err(&intf->dev, "no more free acm devices\n");
1136 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1137 if (acm == NULL) {
1138 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1145 acm->combined_interfaces = combined_interfaces;
1146 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 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;
1153 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1154 acm->ctrlsize = ctrlsize;
1155 acm->readsize = readsize;
1156 acm->rx_buflimit = num_rx_buf;
1157 acm->urb_task.func = acm_rx_tasklet;
1158 acm->urb_task.data = (unsigned long) acm;
1159 INIT_WORK(&acm->work, acm_softint);
1160 init_waitqueue_head(&acm->drain_wait);
1161 spin_lock_init(&acm->throttle_lock);
1162 spin_lock_init(&acm->write_lock);
1163 spin_lock_init(&acm->read_lock);
1164 mutex_init(&acm->mutex);
1165 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1166 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1167 if (acm->is_int_ep)
1168 acm->bInterval = epread->bInterval;
1169 tty_port_init(&acm->port);
1170 acm->port.ops = &acm_port_ops;
1172 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1177 acm->ctrl_buffer = buf;
1179 if (acm_write_buffers_alloc(acm) < 0) {
1184 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1185 if (!acm->ctrlurb) {
1190 struct acm_ru *rcv = &(acm->ru[i]);
1200 rcv->instance = acm;
1203 struct acm_rb *rb = &(acm->rb[i]);
1205 rb->base = usb_alloc_coherent(acm->dev, readsize,
1214 struct acm_wb *snd = &(acm->wb[i]);
1226 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1230 NULL, acm->writesize, acm_write_bulk, snd);
1232 snd->instance = acm;
1235 usb_set_intfdata(intf, acm);
1242 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1243 if (!acm->country_codes)
1245 acm->country_code_size = cfd->bLength - 4;
1246 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1248 acm->country_rel_date = cfd->iCountryCodeRelDate;
1252 kfree(acm->country_codes);
1260 kfree(acm->country_codes);
1266 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1268 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1271 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1272 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1276 acm_set_control(acm, acm->ctrlout);
1278 acm->line.dwDTERate = cpu_to_le32(9600);
1279 acm->line.bDataBits = 8;
1280 acm_set_line(acm, &acm->line);
1282 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1283 usb_set_intfdata(data_interface, acm);
1288 acm_table[minor] = acm;
1293 usb_free_urb(acm->wb[i].urb);
1295 acm_read_buffers_free(acm);
1298 usb_free_urb(acm->ru[i].urb);
1299 usb_free_urb(acm->ctrlurb);
1301 acm_write_buffers_free(acm);
1303 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1305 kfree(acm);
1310 static void stop_data_traffic(struct acm *acm)
1315 tasklet_disable(&acm->urb_task);
1317 usb_kill_urb(acm->ctrlurb);
1319 usb_kill_urb(acm->wb[i].urb);
1320 for (i = 0; i < acm->rx_buflimit; i++)
1321 usb_kill_urb(acm->ru[i].urb);
1323 tasklet_enable(&acm->urb_task);
1325 cancel_work_sync(&acm->work);
1330 struct acm *acm = usb_get_intfdata(intf);
1335 if (!acm)
1339 if (acm->country_codes) {
1340 device_remove_file(&acm->control->dev,
1342 device_remove_file(&acm->control->dev,
1345 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1346 acm->dev = NULL;
1347 usb_set_intfdata(acm->control, NULL);
1348 usb_set_intfdata(acm->data, NULL);
1350 stop_data_traffic(acm);
1352 acm_write_buffers_free(acm);
1353 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1354 acm->ctrl_dma);
1355 acm_read_buffers_free(acm);
1357 if (!acm->combined_interfaces)
1358 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1359 acm->data : acm->control);
1361 if (acm->port.count == 0) {
1362 acm_tty_unregister(acm);
1368 tty = tty_port_tty_get(&acm->port);
1378 struct acm *acm = usb_get_intfdata(intf);
1384 spin_lock_irq(&acm->read_lock);
1385 spin_lock(&acm->write_lock);
1386 b = acm->processing + acm->transmitting;
1387 spin_unlock(&acm->write_lock);
1388 spin_unlock_irq(&acm->read_lock);
1393 spin_lock_irq(&acm->read_lock);
1394 spin_lock(&acm->write_lock);
1395 cnt = acm->susp_count++;
1396 spin_unlock(&acm->write_lock);
1397 spin_unlock_irq(&acm->read_lock);
1405 mutex_lock(&acm->mutex);
1407 if (acm->port.count)
1408 stop_data_traffic(acm);
1410 mutex_unlock(&acm->mutex);
1416 struct acm *acm = usb_get_intfdata(intf);
1421 spin_lock_irq(&acm->read_lock);
1422 acm->susp_count -= 1;
1423 cnt = acm->susp_count;
1424 spin_unlock_irq(&acm->read_lock);
1429 mutex_lock(&acm->mutex);
1430 if (acm->port.count) {
1431 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1433 spin_lock_irq(&acm->write_lock);
1434 if (acm->delayed_wb) {
1435 wb = acm->delayed_wb;
1436 acm->delayed_wb = NULL;
1437 spin_unlock_irq(&acm->write_lock);
1438 acm_start_wb(acm, wb);
1440 spin_unlock_irq(&acm->write_lock);
1450 tasklet_schedule(&acm->urb_task);
1454 mutex_unlock(&acm->mutex);
1460 struct acm *acm = usb_get_intfdata(intf);
1463 mutex_lock(&acm->mutex);
1464 if (acm->port.count) {
1465 tty = tty_port_tty_get(&acm->port);
1471 mutex_unlock(&acm->mutex);
1686 acm_tty_driver->driver_name = "acm",