Lines Matching defs:acm
2 * cdc-acm.c
19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
21 * v0.14 - sized down struct acm
70 #include "cdc-acm.h"
81 static struct acm *acm_table[ACM_TTY_MINORS];
85 #define ACM_READY(acm) (acm && acm->dev && acm->used)
91 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
93 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
95 acm->control->altsetting[0].desc.bInterfaceNumber,
102 * the cdc acm descriptor tells whether they do...
104 #define acm_set_control(acm, control) \
105 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
106 #define acm_set_line(acm, line) \
107 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
108 #define acm_send_break(acm, ms) \
109 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
116 static int acm_wb_alloc(struct acm *acm)
121 wbn = acm->write_current;
124 wb = &acm->wb[wbn];
135 static void acm_wb_free(struct acm *acm, int wbn)
137 acm->wb[wbn].use = 0;
140 static int acm_wb_is_avail(struct acm *acm)
146 n -= acm->wb[i].use;
151 static inline int acm_wb_is_used(struct acm *acm, int wbn)
153 return acm->wb[wbn].use;
159 static void acm_write_done(struct acm *acm)
164 spin_lock_irqsave(&acm->write_lock, flags);
165 acm->write_ready = 1;
166 wbn = acm->write_current;
167 acm_wb_free(acm, wbn);
168 acm->write_current = (wbn + 1) % ACM_NW;
169 spin_unlock_irqrestore(&acm->write_lock, flags);
175 static int acm_write_start(struct acm *acm)
182 spin_lock_irqsave(&acm->write_lock, flags);
183 if (!acm->dev) {
184 spin_unlock_irqrestore(&acm->write_lock, flags);
188 if (!acm->write_ready) {
189 spin_unlock_irqrestore(&acm->write_lock, flags);
193 wbn = acm->write_current;
194 if (!acm_wb_is_used(acm, wbn)) {
195 spin_unlock_irqrestore(&acm->write_lock, flags);
198 wb = &acm->wb[wbn];
200 acm->write_ready = 0;
201 spin_unlock_irqrestore(&acm->write_lock, flags);
203 acm->writeurb->transfer_buffer = wb->buf;
204 acm->writeurb->transfer_dma = wb->dmah;
205 acm->writeurb->transfer_buffer_length = wb->len;
206 acm->writeurb->dev = acm->dev;
208 if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
210 acm_write_done(acm);
221 struct acm *acm = usb_get_intfdata(intf);
223 return sprintf(buf, "%d", acm->ctrl_caps);
231 struct acm *acm = usb_get_intfdata(intf);
233 memcpy(buf, acm->country_codes, acm->country_code_size);
234 return acm->country_code_size;
243 struct acm *acm = usb_get_intfdata(intf);
245 return sprintf(buf, "%d", acm->country_rel_date);
256 struct acm *acm = urb->context;
277 if (!ACM_READY(acm))
292 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
294 tty_hangup(acm->tty);
297 acm->ctrlin = newctrl;
300 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
301 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
302 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
303 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
325 struct acm *acm = rcv->instance;
329 if (!ACM_READY(acm))
333 dev_dbg(&acm->data->dev, "bulk rx status %d", status);
339 spin_lock(&acm->read_lock);
340 list_add_tail(&rcv->list, &acm->spare_read_urbs);
341 list_add_tail(&buf->list, &acm->filled_read_bufs);
342 spin_unlock(&acm->read_lock);
345 spin_lock(&acm->read_lock);
346 list_add_tail(&rcv->list, &acm->spare_read_urbs);
347 list_add(&buf->list, &acm->spare_read_bufs);
348 spin_unlock(&acm->read_lock);
352 tasklet_schedule(&acm->urb_task);
357 struct acm *acm = (void *)_acm;
359 struct tty_struct *tty = acm->tty;
365 if (!ACM_READY(acm))
368 spin_lock_irqsave(&acm->throttle_lock, flags);
369 throttled = acm->throttle;
370 spin_unlock_irqrestore(&acm->throttle_lock, flags);
375 spin_lock_irqsave(&acm->read_lock, flags);
376 if (list_empty(&acm->filled_read_bufs)) {
377 spin_unlock_irqrestore(&acm->read_lock, flags);
380 buf = list_entry(acm->filled_read_bufs.next,
383 spin_unlock_irqrestore(&acm->read_lock, flags);
388 spin_lock_irqsave(&acm->throttle_lock, flags);
389 throttled = acm->throttle;
390 spin_unlock_irqrestore(&acm->throttle_lock, flags);
397 spin_lock_irqsave(&acm->read_lock, flags);
398 list_add(&buf->list, &acm->filled_read_bufs);
399 spin_unlock_irqrestore(&acm->read_lock, flags);
403 spin_lock_irqsave(&acm->read_lock, flags);
404 list_add(&buf->list, &acm->spare_read_bufs);
405 spin_unlock_irqrestore(&acm->read_lock, flags);
409 while (!list_empty(&acm->spare_read_bufs)) {
410 spin_lock_irqsave(&acm->read_lock, flags);
411 if (list_empty(&acm->spare_read_urbs)) {
412 spin_unlock_irqrestore(&acm->read_lock, flags);
415 rcv = list_entry(acm->spare_read_urbs.next,
418 spin_unlock_irqrestore(&acm->read_lock, flags);
420 buf = list_entry(acm->spare_read_bufs.next,
426 usb_fill_bulk_urb(rcv->urb, acm->dev,
427 acm->rx_endpoint,
429 acm->readsize,
439 list_add(&buf->list, &acm->spare_read_bufs);
440 spin_lock_irqsave(&acm->read_lock, flags);
441 list_add(&rcv->list, &acm->spare_read_urbs);
442 spin_unlock_irqrestore(&acm->read_lock, flags);
451 struct acm *acm = (struct acm *)urb->context;
455 acm_write_done(acm);
456 acm_write_start(acm);
457 if (ACM_READY(acm))
458 schedule_work(&acm->work);
463 struct acm *acm = container_of(work, struct acm, work);
466 if (!ACM_READY(acm))
468 tty_wakeup(acm->tty);
477 struct acm *acm;
484 acm = acm_table[tty->index];
485 if (!acm || !acm->dev)
490 tty->driver_data = acm;
491 acm->tty = tty;
497 if (acm->used++) {
501 acm->ctrlurb->dev = acm->dev;
502 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
507 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
508 (acm->ctrl_caps & USB_CDC_CAP_LINE))
511 INIT_LIST_HEAD(&acm->spare_read_urbs);
512 INIT_LIST_HEAD(&acm->spare_read_bufs);
513 INIT_LIST_HEAD(&acm->filled_read_bufs);
514 for (i = 0; i < acm->rx_buflimit; i++) {
515 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
517 for (i = 0; i < acm->rx_buflimit; i++) {
518 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
521 acm->throttle = 0;
523 tasklet_schedule(&acm->urb_task);
531 usb_kill_urb(acm->ctrlurb);
533 acm->used--;
538 static void acm_tty_unregister(struct acm *acm)
542 nr = acm->rx_buflimit;
543 tty_unregister_device(acm_tty_driver, acm->minor);
544 usb_put_intf(acm->control);
545 acm_table[acm->minor] = NULL;
546 usb_free_urb(acm->ctrlurb);
547 usb_free_urb(acm->writeurb);
549 usb_free_urb(acm->ru[i].urb);
550 kfree(acm->country_codes);
551 kfree(acm);
556 struct acm *acm = tty->driver_data;
559 if (!acm || !acm->used)
562 nr = acm->rx_buflimit;
564 if (!--acm->used) {
565 if (acm->dev) {
566 acm_set_control(acm, acm->ctrlout = 0);
567 usb_kill_urb(acm->ctrlurb);
568 usb_kill_urb(acm->writeurb);
570 usb_kill_urb(acm->ru[i].urb);
572 acm_tty_unregister(acm);
579 struct acm *acm = tty->driver_data;
587 if (!ACM_READY(acm))
592 spin_lock_irqsave(&acm->write_lock, flags);
593 if ((wbn = acm_wb_alloc(acm)) < 0) {
594 spin_unlock_irqrestore(&acm->write_lock, flags);
595 acm_write_start(acm);
598 wb = &acm->wb[wbn];
600 count = (count > acm->writesize) ? acm->writesize : count;
604 spin_unlock_irqrestore(&acm->write_lock, flags);
606 if ((stat = acm_write_start(acm)) < 0)
613 struct acm *acm = tty->driver_data;
614 if (!ACM_READY(acm))
620 return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
625 struct acm *acm = tty->driver_data;
626 if (!ACM_READY(acm))
631 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
636 struct acm *acm = tty->driver_data;
637 if (!ACM_READY(acm))
639 spin_lock_bh(&acm->throttle_lock);
640 acm->throttle = 1;
641 spin_unlock_bh(&acm->throttle_lock);
646 struct acm *acm = tty->driver_data;
647 if (!ACM_READY(acm))
649 spin_lock_bh(&acm->throttle_lock);
650 acm->throttle = 0;
651 spin_unlock_bh(&acm->throttle_lock);
652 tasklet_schedule(&acm->urb_task);
657 struct acm *acm = tty->driver_data;
658 if (!ACM_READY(acm))
660 if (acm_send_break(acm, state ? 0xffff : 0))
666 struct acm *acm = tty->driver_data;
668 if (!ACM_READY(acm))
671 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
672 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
673 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
674 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
675 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
682 struct acm *acm = tty->driver_data;
685 if (!ACM_READY(acm))
688 newctrl = acm->ctrlout;
694 if (acm->ctrlout == newctrl)
696 return acm_set_control(acm, acm->ctrlout = newctrl);
701 struct acm *acm = tty->driver_data;
703 if (!ACM_READY(acm))
723 struct acm *acm = tty->driver_data;
726 int newctrl = acm->ctrlout;
728 if (!ACM_READY(acm))
738 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
741 newline.dwDTERate = acm->line.dwDTERate;
745 if (newctrl != acm->ctrlout)
746 acm_set_control(acm, acm->ctrlout = newctrl);
748 if (memcmp(&acm->line, &newline, sizeof newline)) {
749 memcpy(&acm->line, &newline, sizeof newline);
753 acm_set_line(acm, &acm->line);
762 static void acm_write_buffers_free(struct acm *acm)
767 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
768 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
773 static int acm_write_buffers_alloc(struct acm *acm)
778 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
779 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
785 usb_buffer_free(acm->dev, acm->writesize,
807 struct acm *acm;
949 err("no more free acm devices");
953 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
954 dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
960 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
961 acm->control = control_interface;
962 acm->data = data_interface;
963 acm->minor = minor;
964 acm->dev = usb_dev;
965 acm->ctrl_caps = ac_management_function;
966 acm->ctrlsize = ctrlsize;
967 acm->readsize = readsize;
968 acm->rx_buflimit = num_rx_buf;
969 acm->urb_task.func = acm_rx_tasklet;
970 acm->urb_task.data = (unsigned long) acm;
971 INIT_WORK(&acm->work, acm_softint);
972 spin_lock_init(&acm->throttle_lock);
973 spin_lock_init(&acm->write_lock);
974 spin_lock_init(&acm->read_lock);
975 acm->write_ready = 1;
976 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
978 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
983 acm->ctrl_buffer = buf;
985 if (acm_write_buffers_alloc(acm) < 0) {
990 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
991 if (!acm->ctrlurb) {
996 struct acm_ru *rcv = &(acm->ru[i]);
1004 rcv->instance = acm;
1007 struct acm_rb *buf = &(acm->rb[i]);
1009 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
1014 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
1015 if (!acm->writeurb) {
1020 usb_set_intfdata (intf, acm);
1027 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1028 if (!acm->country_codes)
1030 acm->country_code_size = cfd->bLength - 4;
1031 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1032 acm->country_rel_date = cfd->iCountryCodeRelDate;
1036 kfree(acm->country_codes);
1042 kfree(acm->country_codes);
1048 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1049 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1050 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1051 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1053 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1054 NULL, acm->writesize, acm_write_bulk, acm);
1055 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
1059 acm_set_control(acm, acm->ctrlout);
1061 acm->line.dwDTERate = cpu_to_le32(9600);
1062 acm->line.bDataBits = 8;
1063 acm_set_line(acm, &acm->line);
1065 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1070 acm_table[minor] = acm;
1074 usb_free_urb(acm->writeurb);
1077 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1079 usb_free_urb(acm->ru[i].urb);
1080 usb_free_urb(acm->ctrlurb);
1082 acm_write_buffers_free(acm);
1084 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1086 kfree(acm);
1093 struct acm *acm = usb_get_intfdata(intf);
1097 if (!acm || !acm->dev) {
1107 if (acm->country_codes){
1112 acm->dev = NULL;
1113 usb_set_intfdata(acm->control, NULL);
1114 usb_set_intfdata(acm->data, NULL);
1116 tasklet_disable(&acm->urb_task);
1118 usb_kill_urb(acm->ctrlurb);
1119 usb_kill_urb(acm->writeurb);
1120 for (i = 0; i < acm->rx_buflimit; i++)
1121 usb_kill_urb(acm->ru[i].urb);
1123 INIT_LIST_HEAD(&acm->filled_read_bufs);
1124 INIT_LIST_HEAD(&acm->spare_read_bufs);
1126 tasklet_enable(&acm->urb_task);
1130 acm_write_buffers_free(acm);
1131 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1132 for (i = 0; i < acm->rx_buflimit; i++)
1133 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1135 usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1137 if (!acm->used) {
1138 acm_tty_unregister(acm);
1145 if (acm->tty)
1146 tty_hangup(acm->tty);
1231 acm_tty_driver->driver_name = "acm",