Lines Matching refs:instance
73 static int usbatm_print_packet(struct usbatm_data *instance, const unsigned char *data, int len);
280 static inline struct usbatm_vcc_data *usbatm_find_vcc(struct usbatm_data *instance,
285 list_for_each_entry(vcc_data, &instance->vcc_list, list)
291 static void usbatm_extract_one_cell(struct usbatm_data *instance, unsigned char *source)
299 if ((vci != instance->cached_vci) || (vpi != instance->cached_vpi)) {
300 instance->cached_vpi = vpi;
301 instance->cached_vci = vci;
303 instance->cached_vcc = usbatm_find_vcc(instance, vpi, vci);
305 if (!instance->cached_vcc)
306 atm_rldbg(instance, "%s: unknown vpi/vci (%hd/%d)!\n", __func__, vpi, vci);
309 if (!instance->cached_vcc)
312 vcc = instance->cached_vcc->vcc;
317 atm_warn(instance, "%s: OAM not supported (vpi %d, vci %d)!\n",
323 sarb = instance->cached_vcc->sarb;
326 atm_rldbg(instance, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
344 atm_rldbg(instance, "%s: bogus length %u (vcc: 0x%p)!\n",
353 atm_rldbg(instance, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
360 atm_rldbg(instance, "%s: packet failed crc check (vcc: 0x%p)!\n",
366 vdbg(&instance->usb_intf->dev,
373 atm_err(instance, "%s: no memory for skb (length: %u)!\n",
379 vdbg(&instance->usb_intf->dev,
384 atm_rldbg(instance, "%s: failed atm_charge (skb->truesize: %u)!\n",
395 vdbg(&instance->usb_intf->dev,
399 PACKETDEBUG(instance, skb->data, skb->len);
409 static void usbatm_extract_cells(struct usbatm_data *instance,
412 unsigned int stride = instance->rx_channel.stride;
413 unsigned int buf_usage = instance->buf_usage;
420 unsigned char *cell_buf = instance->cell_buf;
428 usbatm_extract_one_cell(instance, cell_buf);
429 instance->buf_usage = 0;
433 instance->buf_usage = buf_usage + avail_data;
439 usbatm_extract_one_cell(instance, source);
444 memcpy(instance->cell_buf, source, avail_data);
445 instance->buf_usage = avail_data;
454 static unsigned int usbatm_write_cells(struct usbatm_data *instance,
461 unsigned int stride = instance->tx_channel.stride;
516 struct usbatm_data *instance = from_tasklet(instance, t,
520 while ((urb = usbatm_pop_urb(&instance->rx_channel))) {
521 vdbg(&instance->usb_intf->dev,
527 const unsigned int packet_size = instance->rx_channel.packet_size;
538 usbatm_extract_cells(instance, merge_start, merge_length);
542 atm_rldbg(instance, "%s: status %d in frame %d!\n", __func__, urb->status, i);
544 usbatm_extract_cells(instance, merge_start, merge_length);
546 instance->buf_usage = 0;
551 usbatm_extract_cells(instance, merge_start, merge_length);
554 usbatm_extract_cells(instance, urb->transfer_buffer, urb->actual_length);
556 instance->buf_usage = 0;
570 struct usbatm_data *instance = from_tasklet(instance, t,
572 struct sk_buff *skb = instance->current_skb;
574 const unsigned int buf_size = instance->tx_channel.buf_size;
579 skb = skb_dequeue(&instance->sndqueue);
583 urb = usbatm_pop_urb(&instance->tx_channel);
591 bytes_written += usbatm_write_cells(instance, skb,
595 vdbg(&instance->usb_intf->dev,
605 skb = skb_dequeue(&instance->sndqueue);
617 instance->current_skb = skb;
620 static void usbatm_cancel_send(struct usbatm_data *instance,
625 spin_lock_irq(&instance->sndqueue.lock);
626 skb_queue_walk_safe(&instance->sndqueue, skb, n) {
628 atm_dbg(instance, "%s: popping skb 0x%p\n", __func__, skb);
629 __skb_unlink(skb, &instance->sndqueue);
633 spin_unlock_irq(&instance->sndqueue.lock);
635 tasklet_disable(&instance->tx_channel.tasklet);
636 if ((skb = instance->current_skb) && (UDSL_SKB(skb)->atm.vcc == vcc)) {
637 atm_dbg(instance, "%s: popping current skb (0x%p)\n", __func__, skb);
638 instance->current_skb = NULL;
641 tasklet_enable(&instance->tx_channel.tasklet);
646 struct usbatm_data *instance = vcc->dev->dev_data;
651 if (!instance || instance->disconnected) {
653 printk_ratelimited(KERN_DEBUG "%s: %s!\n", __func__, instance ? "disconnected" : "NULL instance");
660 atm_rldbg(instance, "%s: unsupported ATM type %d!\n", __func__, vcc->qos.aal);
666 atm_rldbg(instance, "%s: packet too long (%d vs %d)!\n",
672 PACKETDEBUG(instance, skb->data, skb->len);
679 skb_queue_tail(&instance->sndqueue, skb);
680 tasklet_schedule(&instance->tx_channel.tasklet);
696 struct usbatm_data *instance = container_of(kref, struct usbatm_data, refcount);
698 tasklet_kill(&instance->rx_channel.tasklet);
699 tasklet_kill(&instance->tx_channel.tasklet);
700 usb_put_dev(instance->usb_dev);
701 kfree(instance);
704 static void usbatm_get_instance(struct usbatm_data *instance)
706 kref_get(&instance->refcount);
709 static void usbatm_put_instance(struct usbatm_data *instance)
711 kref_put(&instance->refcount, usbatm_destroy_instance);
721 struct usbatm_data *instance = atm_dev->dev_data;
723 if (!instance)
727 usbatm_put_instance(instance); /* taken in usbatm_atm_init */
732 struct usbatm_data *instance = atm_dev->dev_data;
735 if (!instance)
739 return sprintf(page, "%s\n", instance->description);
754 if (instance->disconnected)
772 struct usbatm_data *instance = vcc->dev->dev_data;
778 if (!instance)
783 atm_warn(instance, "%s: unsupported ATM type %d!\n", __func__, vcc->qos.aal);
789 atm_dbg(instance, "%s: max_sdu %d out of range!\n", __func__, vcc->qos.rxtp.max_sdu);
793 mutex_lock(&instance->serialize); /* vs self, usbatm_atm_close, usbatm_usb_disconnect */
795 if (instance->disconnected) {
796 atm_dbg(instance, "%s: disconnected!\n", __func__);
801 if (usbatm_find_vcc(instance, vpi, vci)) {
802 atm_dbg(instance, "%s: %hd/%d already in use!\n", __func__, vpi, vci);
819 atm_err(instance, "%s: no memory for SAR buffer!\n", __func__);
826 tasklet_disable(&instance->rx_channel.tasklet);
827 instance->cached_vcc = new;
828 instance->cached_vpi = vpi;
829 instance->cached_vci = vci;
830 list_add(&new->list, &instance->vcc_list);
831 tasklet_enable(&instance->rx_channel.tasklet);
837 mutex_unlock(&instance->serialize);
839 atm_dbg(instance, "%s: allocated vcc data 0x%p\n", __func__, new);
845 mutex_unlock(&instance->serialize);
851 struct usbatm_data *instance = vcc->dev->dev_data;
854 if (!instance || !vcc_data)
857 usbatm_cancel_send(instance, vcc);
859 mutex_lock(&instance->serialize); /* vs self, usbatm_atm_open, usbatm_usb_disconnect */
861 tasklet_disable(&instance->rx_channel.tasklet);
862 if (instance->cached_vcc == vcc_data) {
863 instance->cached_vcc = NULL;
864 instance->cached_vpi = ATM_VPI_UNSPEC;
865 instance->cached_vci = ATM_VCI_UNSPEC;
868 tasklet_enable(&instance->rx_channel.tasklet);
882 mutex_unlock(&instance->serialize);
888 struct usbatm_data *instance = atm_dev->dev_data;
890 if (!instance || instance->disconnected)
901 static int usbatm_atm_init(struct usbatm_data *instance)
910 atm_dev = atm_dev_register(instance->driver_name,
911 &instance->usb_intf->dev, &usbatm_atm_devops,
914 usb_err(instance, "%s: failed to register ATM device!\n", __func__);
918 instance->atm_dev = atm_dev;
927 if (instance->driver->atm_start && ((ret = instance->driver->atm_start(instance, atm_dev)) < 0)) {
928 atm_err(instance, "%s: atm_start failed: %d!\n", __func__, ret);
932 usbatm_get_instance(instance); /* dropped in usbatm_atm_dev_close */
936 atm_dev->dev_data = instance;
940 usbatm_submit_urb(instance->urbs[i]);
945 instance->atm_dev = NULL;
957 struct usbatm_data *instance = arg;
961 complete(&instance->thread_started);
963 ret = instance->driver->heavy_init(instance, instance->usb_intf);
966 ret = usbatm_atm_init(instance);
968 mutex_lock(&instance->serialize);
969 instance->thread = NULL;
970 mutex_unlock(&instance->serialize);
972 kthread_complete_and_exit(&instance->thread_exited, ret);
975 static int usbatm_heavy_init(struct usbatm_data *instance)
979 t = kthread_create(usbatm_do_heavy_init, instance, "%s",
980 instance->driver->driver_name);
982 usb_err(instance, "%s: failed to create kernel_thread (%ld)!\n",
987 instance->thread = t;
989 wait_for_completion(&instance->thread_started);
1013 struct usbatm_data *instance;
1020 /* instance init */
1021 size = struct_size(instance, urbs,
1023 instance = kzalloc(size, GFP_KERNEL);
1024 if (!instance)
1029 instance->driver = driver;
1030 strscpy(instance->driver_name, driver->driver_name,
1031 sizeof(instance->driver_name));
1033 instance->usb_dev = usb_dev;
1034 instance->usb_intf = intf;
1036 buf = instance->description;
1037 length = sizeof(instance->description);
1058 if (driver->bind && (error = driver->bind(instance, intf, id)) < 0) {
1065 kref_init(&instance->refcount); /* dropped in usbatm_usb_disconnect */
1066 mutex_init(&instance->serialize);
1068 instance->thread = NULL;
1069 init_completion(&instance->thread_started);
1070 init_completion(&instance->thread_exited);
1072 INIT_LIST_HEAD(&instance->vcc_list);
1073 skb_queue_head_init(&instance->sndqueue);
1075 usbatm_init_channel(&instance->rx_channel);
1076 usbatm_init_channel(&instance->tx_channel);
1077 tasklet_setup(&instance->rx_channel.tasklet, usbatm_rx_process);
1078 tasklet_setup(&instance->tx_channel.tasklet, usbatm_tx_process);
1079 instance->rx_channel.stride = ATM_CELL_SIZE + driver->rx_padding;
1080 instance->tx_channel.stride = ATM_CELL_SIZE + driver->tx_padding;
1081 instance->rx_channel.usbatm = instance->tx_channel.usbatm = instance;
1083 if ((instance->flags & UDSL_USE_ISOC) && driver->isoc_in)
1084 instance->rx_channel.endpoint = usb_rcvisocpipe(usb_dev, driver->isoc_in);
1086 instance->rx_channel.endpoint = usb_rcvbulkpipe(usb_dev, driver->bulk_in);
1088 instance->tx_channel.endpoint = usb_sndbulkpipe(usb_dev, driver->bulk_out);
1091 instance->tx_channel.buf_size = max(instance->tx_channel.stride,
1092 snd_buf_bytes - (snd_buf_bytes % instance->tx_channel.stride));
1095 maxpacket = usb_maxpacket(usb_dev, instance->rx_channel.endpoint);
1099 usb_pipeendpoint(instance->rx_channel.endpoint));
1109 instance->rx_channel.buf_size = num_packets * maxpacket;
1110 instance->rx_channel.packet_size = maxpacket;
1114 &instance->tx_channel : &instance->rx_channel;
1125 &instance->rx_channel : &instance->tx_channel;
1135 instance->urbs[i] = urb;
1144 usb_fill_bulk_urb(urb, instance->usb_dev, channel->endpoint,
1165 instance->cached_vpi = ATM_VPI_UNSPEC;
1166 instance->cached_vci = ATM_VCI_UNSPEC;
1167 instance->cell_buf = kmalloc(instance->rx_channel.stride, GFP_KERNEL);
1169 if (!instance->cell_buf) {
1174 if (!(instance->flags & UDSL_SKIP_HEAVY_INIT) && driver->heavy_init) {
1175 error = usbatm_heavy_init(instance);
1177 complete(&instance->thread_exited); /* pretend that heavy_init was run */
1178 error = usbatm_atm_init(instance);
1185 usb_set_intfdata(intf, instance);
1190 if (instance->driver->unbind)
1191 instance->driver->unbind(instance, intf);
1193 kfree(instance->cell_buf);
1196 if (instance->urbs[i])
1197 kfree(instance->urbs[i]->transfer_buffer);
1198 usb_free_urb(instance->urbs[i]);
1201 kfree(instance);
1210 struct usbatm_data *instance = usb_get_intfdata(intf);
1214 if (!instance) {
1215 dev_dbg(dev, "%s: NULL instance!\n", __func__);
1221 mutex_lock(&instance->serialize);
1222 instance->disconnected = 1;
1223 if (instance->thread != NULL)
1224 send_sig(SIGTERM, instance->thread, 1);
1225 mutex_unlock(&instance->serialize);
1227 wait_for_completion(&instance->thread_exited);
1229 mutex_lock(&instance->serialize);
1230 list_for_each_entry(vcc_data, &instance->vcc_list, list)
1232 mutex_unlock(&instance->serialize);
1234 tasklet_disable(&instance->rx_channel.tasklet);
1235 tasklet_disable(&instance->tx_channel.tasklet);
1238 usb_kill_urb(instance->urbs[i]);
1240 timer_delete_sync(&instance->rx_channel.delay);
1241 timer_delete_sync(&instance->tx_channel.delay);
1245 INIT_LIST_HEAD(&instance->rx_channel.list);
1246 INIT_LIST_HEAD(&instance->tx_channel.list);
1248 tasklet_enable(&instance->rx_channel.tasklet);
1249 tasklet_enable(&instance->tx_channel.tasklet);
1251 if (instance->atm_dev && instance->driver->atm_stop)
1252 instance->driver->atm_stop(instance, instance->atm_dev);
1254 if (instance->driver->unbind)
1255 instance->driver->unbind(instance, intf);
1257 instance->driver_data = NULL;
1260 kfree(instance->urbs[i]->transfer_buffer);
1261 usb_free_urb(instance->urbs[i]);
1264 kfree(instance->cell_buf);
1267 if (instance->atm_dev) {
1268 atm_dev_deregister(instance->atm_dev);
1269 instance->atm_dev = NULL;
1272 usbatm_put_instance(instance); /* taken in usbatm_usb_probe */
1314 static int usbatm_print_packet(struct usbatm_data *instance,
1325 dev_dbg(&instance->usb_intf->dev, "%s", buffer);