1 // SPDX-License-Identifier: GPL-2.0+
2 /******************************************************************************
3 * usbatm.c - Generic USB xDSL driver core
5 * Copyright (C) 2001, Alcatel
6 * Copyright (C) 2003, Duncan Sands, SolNegro, Josep Comas
7 * Copyright (C) 2004, David Woodhouse, Roman Kagan
8 ******************************************************************************/
11 * Written by Johan Verrept, Duncan Sands (duncan.sands@free.fr) and David Woodhouse
13 * 1.7+: - See the check-in logs
15 * 1.6: - No longer opens a connection if the firmware is not loaded
16 * - Added support for the speedtouch 330
17 * - Removed the limit on the number of devices
18 * - Module now autoloads on device plugin
19 * - Merged relevant parts of sarlib
20 * - Replaced the kernel thread with a tasklet
21 * - New packet transmission code
22 * - Changed proc file contents
23 * - Fixed all known SMP races
24 * - Many fixes and cleanups
25 * - Various fixes by Oliver Neukum (oliver@neukum.name)
27 * 1.5A: - Version for inclusion in 2.5 series kernel
28 * - Modifications by Richard Purdie (rpurdie@rpsys.net)
29 * - made compatible with kernel 2.5.6 onwards by changing
30 * usbatm_usb_send_data_context->urb to a pointer and adding code
31 * to alloc and free it
32 * - remove_wait_queue() added to usbatm_atm_processqueue_thread()
34 * 1.5: - fixed memory leak when atmsar_decode_aal5 returned NULL.
35 * (reported by stephen.robinson@zen.co.uk)
37 * 1.4: - changed the spin_lock() under interrupt to spin_lock_irqsave()
38 * - unlink all active send urbs of a vcc that is being closed.
40 * 1.3.1: - added the version number
42 * 1.3: - Added multiple send urb support
43 * - fixed memory leak and vcc->tx_inuse starvation bug
44 * when not enough memory left in vcc.
46 * 1.2: - Fixed race condition in usbatm_usb_send_data()
47 * 1.1: - Turned off packet debugging
53 #include <linux/uaccess.h>
54 #include <linux/crc32.h>
55 #include <linux/errno.h>
56 #include <linux/init.h>
57 #include <linux/interrupt.h>
58 #include <linux/kernel.h>
59 #include <linux/module.h>
60 #include <linux/moduleparam.h>
61 #include <linux/netdevice.h>
62 #include <linux/proc_fs.h>
63 #include <linux/sched/signal.h>
64 #include <linux/signal.h>
65 #include <linux/slab.h>
66 #include <linux/stat.h>
67 #include <linux/timer.h>
68 #include <linux/wait.h>
69 #include <linux/kthread.h>
70 #include <linux/ratelimit.h>
73 static int usbatm_print_packet(struct usbatm_data
*instance
, const unsigned char *data
, int len
);
74 #define PACKETDEBUG(arg...) usbatm_print_packet(arg)
75 #define vdbg(arg...) dev_dbg(arg)
77 #define PACKETDEBUG(arg...)
81 #define DRIVER_AUTHOR "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
82 #define DRIVER_DESC "Generic USB ATM/DSL I/O"
84 static const char usbatm_driver_name
[] = "usbatm";
86 #define UDSL_MAX_RCV_URBS 16
87 #define UDSL_MAX_SND_URBS 16
88 #define UDSL_MAX_BUF_SIZE 65536
89 #define UDSL_DEFAULT_RCV_URBS 4
90 #define UDSL_DEFAULT_SND_URBS 4
91 #define UDSL_DEFAULT_RCV_BUF_SIZE 3392 /* 64 * ATM_CELL_SIZE */
92 #define UDSL_DEFAULT_SND_BUF_SIZE 3392 /* 64 * ATM_CELL_SIZE */
94 #define ATM_CELL_HEADER (ATM_CELL_SIZE - ATM_CELL_PAYLOAD)
96 #define THROTTLE_MSECS 100 /* delay to recover processing after urb submission fails */
98 static unsigned int num_rcv_urbs
= UDSL_DEFAULT_RCV_URBS
;
99 static unsigned int num_snd_urbs
= UDSL_DEFAULT_SND_URBS
;
100 static unsigned int rcv_buf_bytes
= UDSL_DEFAULT_RCV_BUF_SIZE
;
101 static unsigned int snd_buf_bytes
= UDSL_DEFAULT_SND_BUF_SIZE
;
103 module_param(num_rcv_urbs
, uint
, S_IRUGO
);
104 MODULE_PARM_DESC(num_rcv_urbs
,
105 "Number of urbs used for reception (range: 0-"
106 __MODULE_STRING(UDSL_MAX_RCV_URBS
) ", default: "
107 __MODULE_STRING(UDSL_DEFAULT_RCV_URBS
) ")");
109 module_param(num_snd_urbs
, uint
, S_IRUGO
);
110 MODULE_PARM_DESC(num_snd_urbs
,
111 "Number of urbs used for transmission (range: 0-"
112 __MODULE_STRING(UDSL_MAX_SND_URBS
) ", default: "
113 __MODULE_STRING(UDSL_DEFAULT_SND_URBS
) ")");
115 module_param(rcv_buf_bytes
, uint
, S_IRUGO
);
116 MODULE_PARM_DESC(rcv_buf_bytes
,
117 "Size of the buffers used for reception, in bytes (range: 1-"
118 __MODULE_STRING(UDSL_MAX_BUF_SIZE
) ", default: "
119 __MODULE_STRING(UDSL_DEFAULT_RCV_BUF_SIZE
) ")");
121 module_param(snd_buf_bytes
, uint
, S_IRUGO
);
122 MODULE_PARM_DESC(snd_buf_bytes
,
123 "Size of the buffers used for transmission, in bytes (range: 1-"
124 __MODULE_STRING(UDSL_MAX_BUF_SIZE
) ", default: "
125 __MODULE_STRING(UDSL_DEFAULT_SND_BUF_SIZE
) ")");
130 struct usbatm_vcc_data
{
132 struct list_head list
;
137 /* raw cell reassembly */
138 struct sk_buff
*sarb
;
144 struct usbatm_control
{
145 struct atm_skb_data atm
;
150 #define UDSL_SKB(x) ((struct usbatm_control *)(x)->cb)
155 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
);
156 static int usbatm_atm_open(struct atm_vcc
*vcc
);
157 static void usbatm_atm_close(struct atm_vcc
*vcc
);
158 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
, void __user
*arg
);
159 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
160 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
*pos
, char *page
);
162 static const struct atmdev_ops usbatm_atm_devops
= {
163 .dev_close
= usbatm_atm_dev_close
,
164 .open
= usbatm_atm_open
,
165 .close
= usbatm_atm_close
,
166 .ioctl
= usbatm_atm_ioctl
,
167 .send
= usbatm_atm_send
,
168 .proc_read
= usbatm_atm_proc_read
,
169 .owner
= THIS_MODULE
,
177 static inline unsigned int usbatm_pdu_length(unsigned int length
)
179 length
+= ATM_CELL_PAYLOAD
- 1 + ATM_AAL5_TRAILER
;
180 return length
- length
% ATM_CELL_PAYLOAD
;
183 static inline void usbatm_pop(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
188 dev_kfree_skb_any(skb
);
196 static struct urb
*usbatm_pop_urb(struct usbatm_channel
*channel
)
200 spin_lock_irq(&channel
->lock
);
201 if (list_empty(&channel
->list
)) {
202 spin_unlock_irq(&channel
->lock
);
206 urb
= list_entry(channel
->list
.next
, struct urb
, urb_list
);
207 list_del(&urb
->urb_list
);
208 spin_unlock_irq(&channel
->lock
);
213 static int usbatm_submit_urb(struct urb
*urb
)
215 struct usbatm_channel
*channel
= urb
->context
;
218 /* vdbg("%s: submitting urb 0x%p, size %u",
219 __func__, urb, urb->transfer_buffer_length); */
221 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
223 if (printk_ratelimit())
224 atm_warn(channel
->usbatm
, "%s: urb 0x%p submission failed (%d)!\n",
227 /* consider all errors transient and return the buffer back to the queue */
228 urb
->status
= -EAGAIN
;
229 spin_lock_irq(&channel
->lock
);
231 /* must add to the front when sending; doesn't matter when receiving */
232 list_add(&urb
->urb_list
, &channel
->list
);
234 spin_unlock_irq(&channel
->lock
);
236 /* make sure the channel doesn't stall */
237 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
243 static void usbatm_complete(struct urb
*urb
)
245 struct usbatm_channel
*channel
= urb
->context
;
247 int status
= urb
->status
;
249 /* vdbg("%s: urb 0x%p, status %d, actual_length %d",
250 __func__, urb, status, urb->actual_length); */
252 /* Can be invoked from task context, protect against interrupts */
253 spin_lock_irqsave(&channel
->lock
, flags
);
255 /* must add to the back when receiving; doesn't matter when sending */
256 list_add_tail(&urb
->urb_list
, &channel
->list
);
258 spin_unlock_irqrestore(&channel
->lock
, flags
);
260 if (unlikely(status
) &&
261 (!(channel
->usbatm
->flags
& UDSL_IGNORE_EILSEQ
) ||
262 status
!= -EILSEQ
)) {
263 if (status
== -ESHUTDOWN
)
266 if (printk_ratelimit())
267 atm_warn(channel
->usbatm
, "%s: urb 0x%p failed (%d)!\n",
268 __func__
, urb
, status
);
269 /* throttle processing in case of an error */
270 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
272 tasklet_schedule(&channel
->tasklet
);
280 static inline struct usbatm_vcc_data
*usbatm_find_vcc(struct usbatm_data
*instance
,
283 struct usbatm_vcc_data
*vcc_data
;
285 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
286 if ((vcc_data
->vci
== vci
) && (vcc_data
->vpi
== vpi
))
291 static void usbatm_extract_one_cell(struct usbatm_data
*instance
, unsigned char *source
)
294 struct sk_buff
*sarb
;
295 short vpi
= ((source
[0] & 0x0f) << 4) | (source
[1] >> 4);
296 int vci
= ((source
[1] & 0x0f) << 12) | (source
[2] << 4) | (source
[3] >> 4);
297 u8 pti
= ((source
[3] & 0xe) >> 1);
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
;
314 /* OAM F5 end-to-end */
315 if (pti
== ATM_PTI_E2EF5
) {
316 if (printk_ratelimit())
317 atm_warn(instance
, "%s: OAM not supported (vpi %d, vci %d)!\n",
319 atomic_inc(&vcc
->stats
->rx_err
);
323 sarb
= instance
->cached_vcc
->sarb
;
325 if (sarb
->tail
+ ATM_CELL_PAYLOAD
> sarb
->end
) {
326 atm_rldbg(instance
, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
327 __func__
, sarb
->len
, vcc
);
328 /* discard cells already received */
332 memcpy(skb_tail_pointer(sarb
), source
+ ATM_CELL_HEADER
, ATM_CELL_PAYLOAD
);
333 __skb_put(sarb
, ATM_CELL_PAYLOAD
);
338 unsigned int pdu_length
;
340 length
= (source
[ATM_CELL_SIZE
- 6] << 8) + source
[ATM_CELL_SIZE
- 5];
342 /* guard against overflow */
343 if (length
> ATM_MAX_AAL5_PDU
) {
344 atm_rldbg(instance
, "%s: bogus length %u (vcc: 0x%p)!\n",
345 __func__
, length
, vcc
);
346 atomic_inc(&vcc
->stats
->rx_err
);
350 pdu_length
= usbatm_pdu_length(length
);
352 if (sarb
->len
< pdu_length
) {
353 atm_rldbg(instance
, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
354 __func__
, pdu_length
, sarb
->len
, vcc
);
355 atomic_inc(&vcc
->stats
->rx_err
);
359 if (crc32_be(~0, skb_tail_pointer(sarb
) - pdu_length
, pdu_length
) != 0xc704dd7b) {
360 atm_rldbg(instance
, "%s: packet failed crc check (vcc: 0x%p)!\n",
362 atomic_inc(&vcc
->stats
->rx_err
);
366 vdbg(&instance
->usb_intf
->dev
,
367 "%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)",
368 __func__
, length
, pdu_length
, vcc
);
370 skb
= dev_alloc_skb(length
);
372 if (printk_ratelimit())
373 atm_err(instance
, "%s: no memory for skb (length: %u)!\n",
375 atomic_inc(&vcc
->stats
->rx_drop
);
379 vdbg(&instance
->usb_intf
->dev
,
380 "%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)",
381 __func__
, skb
, skb
->truesize
);
383 if (!atm_charge(vcc
, skb
->truesize
)) {
384 atm_rldbg(instance
, "%s: failed atm_charge (skb->truesize: %u)!\n",
385 __func__
, skb
->truesize
);
386 dev_kfree_skb_any(skb
);
387 goto out
; /* atm_charge increments rx_drop */
390 skb_copy_to_linear_data(skb
,
391 skb_tail_pointer(sarb
) - pdu_length
,
393 __skb_put(skb
, length
);
395 vdbg(&instance
->usb_intf
->dev
,
396 "%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
397 __func__
, skb
, skb
->len
, skb
->truesize
);
399 PACKETDEBUG(instance
, skb
->data
, skb
->len
);
403 atomic_inc(&vcc
->stats
->rx
);
409 static void usbatm_extract_cells(struct usbatm_data
*instance
,
410 unsigned char *source
, unsigned int avail_data
)
412 unsigned int stride
= instance
->rx_channel
.stride
;
413 unsigned int buf_usage
= instance
->buf_usage
;
415 /* extract cells from incoming data, taking into account that
416 * the length of avail data may not be a multiple of stride */
419 /* we have a partially received atm cell */
420 unsigned char *cell_buf
= instance
->cell_buf
;
421 unsigned int space_left
= stride
- buf_usage
;
423 if (avail_data
>= space_left
) {
424 /* add new data and process cell */
425 memcpy(cell_buf
+ buf_usage
, source
, space_left
);
426 source
+= space_left
;
427 avail_data
-= space_left
;
428 usbatm_extract_one_cell(instance
, cell_buf
);
429 instance
->buf_usage
= 0;
431 /* not enough data to fill the cell */
432 memcpy(cell_buf
+ buf_usage
, source
, avail_data
);
433 instance
->buf_usage
= buf_usage
+ avail_data
;
438 for (; avail_data
>= stride
; avail_data
-= stride
, source
+= stride
)
439 usbatm_extract_one_cell(instance
, source
);
441 if (avail_data
> 0) {
442 /* length was not a multiple of stride -
443 * save remaining data for next call */
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
,
456 u8
*target
, unsigned int avail_space
)
458 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
459 struct atm_vcc
*vcc
= ctrl
->atm
.vcc
;
460 unsigned int bytes_written
;
461 unsigned int stride
= instance
->tx_channel
.stride
;
463 for (bytes_written
= 0; bytes_written
< avail_space
&& ctrl
->len
;
464 bytes_written
+= stride
, target
+= stride
) {
465 unsigned int data_len
= min_t(unsigned int, skb
->len
, ATM_CELL_PAYLOAD
);
466 unsigned int left
= ATM_CELL_PAYLOAD
- data_len
;
469 ptr
[0] = vcc
->vpi
>> 4;
470 ptr
[1] = (vcc
->vpi
<< 4) | (vcc
->vci
>> 12);
471 ptr
[2] = vcc
->vci
>> 4;
472 ptr
[3] = vcc
->vci
<< 4;
474 ptr
+= ATM_CELL_HEADER
;
476 skb_copy_from_linear_data(skb
, ptr
, data_len
);
478 __skb_pull(skb
, data_len
);
483 memset(ptr
, 0, left
);
485 if (left
>= ATM_AAL5_TRAILER
) { /* trailer will go in this cell */
486 u8
*trailer
= target
+ ATM_CELL_SIZE
- ATM_AAL5_TRAILER
;
487 /* trailer[0] = 0; UU = 0 */
488 /* trailer[1] = 0; CPI = 0 */
489 trailer
[2] = ctrl
->len
>> 8;
490 trailer
[3] = ctrl
->len
;
492 ctrl
->crc
= ~crc32_be(ctrl
->crc
, ptr
, left
- 4);
494 trailer
[4] = ctrl
->crc
>> 24;
495 trailer
[5] = ctrl
->crc
>> 16;
496 trailer
[6] = ctrl
->crc
>> 8;
497 trailer
[7] = ctrl
->crc
;
499 target
[3] |= 0x2; /* adjust PTI */
501 ctrl
->len
= 0; /* tag this skb finished */
503 ctrl
->crc
= crc32_be(ctrl
->crc
, ptr
, left
);
506 return bytes_written
;
514 static void usbatm_rx_process(struct tasklet_struct
*t
)
516 struct usbatm_data
*instance
= from_tasklet(instance
, t
,
520 while ((urb
= usbatm_pop_urb(&instance
->rx_channel
))) {
521 vdbg(&instance
->usb_intf
->dev
,
522 "%s: processing urb 0x%p", __func__
, urb
);
524 if (usb_pipeisoc(urb
->pipe
)) {
525 unsigned char *merge_start
= NULL
;
526 unsigned int merge_length
= 0;
527 const unsigned int packet_size
= instance
->rx_channel
.packet_size
;
530 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
531 if (!urb
->iso_frame_desc
[i
].status
) {
532 unsigned int actual_length
= urb
->iso_frame_desc
[i
].actual_length
;
535 merge_start
= (unsigned char *)urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
536 merge_length
+= actual_length
;
537 if (merge_length
&& (actual_length
< 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;
558 if (usbatm_submit_urb(urb
))
568 static void usbatm_tx_process(struct tasklet_struct
*t
)
570 struct usbatm_data
*instance
= from_tasklet(instance
, t
,
572 struct sk_buff
*skb
= instance
->current_skb
;
573 struct urb
*urb
= NULL
;
574 const unsigned int buf_size
= instance
->tx_channel
.buf_size
;
575 unsigned int bytes_written
= 0;
579 skb
= skb_dequeue(&instance
->sndqueue
);
583 urb
= usbatm_pop_urb(&instance
->tx_channel
);
585 break; /* no more senders */
586 buffer
= urb
->transfer_buffer
;
587 bytes_written
= (urb
->status
== -EAGAIN
) ?
588 urb
->transfer_buffer_length
: 0;
591 bytes_written
+= usbatm_write_cells(instance
, skb
,
592 buffer
+ bytes_written
,
593 buf_size
- bytes_written
);
595 vdbg(&instance
->usb_intf
->dev
,
596 "%s: wrote %u bytes from skb 0x%p to urb 0x%p",
597 __func__
, bytes_written
, skb
, urb
);
599 if (!UDSL_SKB(skb
)->len
) {
600 struct atm_vcc
*vcc
= UDSL_SKB(skb
)->atm
.vcc
;
602 usbatm_pop(vcc
, skb
);
603 atomic_inc(&vcc
->stats
->tx
);
605 skb
= skb_dequeue(&instance
->sndqueue
);
608 if (bytes_written
== buf_size
|| (!skb
&& bytes_written
)) {
609 urb
->transfer_buffer_length
= bytes_written
;
611 if (usbatm_submit_urb(urb
))
617 instance
->current_skb
= skb
;
620 static void usbatm_cancel_send(struct usbatm_data
*instance
,
623 struct sk_buff
*skb
, *n
;
625 spin_lock_irq(&instance
->sndqueue
.lock
);
626 skb_queue_walk_safe(&instance
->sndqueue
, skb
, n
) {
627 if (UDSL_SKB(skb
)->atm
.vcc
== vcc
) {
628 atm_dbg(instance
, "%s: popping skb 0x%p\n", __func__
, skb
);
629 __skb_unlink(skb
, &instance
->sndqueue
);
630 usbatm_pop(vcc
, skb
);
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
;
639 usbatm_pop(vcc
, skb
);
641 tasklet_enable(&instance
->tx_channel
.tasklet
);
644 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
646 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
647 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
650 /* racy disconnection check - fine */
651 if (!instance
|| instance
->disconnected
) {
653 printk_ratelimited(KERN_DEBUG
"%s: %s!\n", __func__
, instance
? "disconnected" : "NULL instance");
659 if (vcc
->qos
.aal
!= ATM_AAL5
) {
660 atm_rldbg(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
665 if (skb
->len
> ATM_MAX_AAL5_PDU
) {
666 atm_rldbg(instance
, "%s: packet too long (%d vs %d)!\n",
667 __func__
, skb
->len
, ATM_MAX_AAL5_PDU
);
672 PACKETDEBUG(instance
, skb
->data
, skb
->len
);
674 /* initialize the control block */
676 ctrl
->len
= skb
->len
;
677 ctrl
->crc
= crc32_be(~0, skb
->data
, skb
->len
);
679 skb_queue_tail(&instance
->sndqueue
, skb
);
680 tasklet_schedule(&instance
->tx_channel
.tasklet
);
685 usbatm_pop(vcc
, skb
);
690 /********************
692 ********************/
694 static void usbatm_destroy_instance(struct kref
*kref
)
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
);
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
);
719 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
)
721 struct usbatm_data
*instance
= atm_dev
->dev_data
;
726 atm_dev
->dev_data
= NULL
; /* catch bugs */
727 usbatm_put_instance(instance
); /* taken in usbatm_atm_init */
730 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
*pos
, char *page
)
732 struct usbatm_data
*instance
= atm_dev
->dev_data
;
739 return sprintf(page
, "%s\n", instance
->description
);
742 return sprintf(page
, "MAC: %pM\n", atm_dev
->esi
);
746 "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
747 atomic_read(&atm_dev
->stats
.aal5
.tx
),
748 atomic_read(&atm_dev
->stats
.aal5
.tx_err
),
749 atomic_read(&atm_dev
->stats
.aal5
.rx
),
750 atomic_read(&atm_dev
->stats
.aal5
.rx_err
),
751 atomic_read(&atm_dev
->stats
.aal5
.rx_drop
));
754 if (instance
->disconnected
)
755 return sprintf(page
, "Disconnected\n");
757 switch (atm_dev
->signal
) {
758 case ATM_PHY_SIG_FOUND
:
759 return sprintf(page
, "Line up\n");
760 case ATM_PHY_SIG_LOST
:
761 return sprintf(page
, "Line down\n");
763 return sprintf(page
, "Line state unknown\n");
770 static int usbatm_atm_open(struct atm_vcc
*vcc
)
772 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
773 struct usbatm_vcc_data
*new = NULL
;
776 short vpi
= vcc
->vpi
;
781 /* only support AAL5 */
782 if ((vcc
->qos
.aal
!= ATM_AAL5
)) {
783 atm_warn(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
788 if ((vcc
->qos
.rxtp
.max_sdu
< 0) || (vcc
->qos
.rxtp
.max_sdu
> ATM_MAX_AAL5_PDU
)) {
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
);
807 new = kzalloc(sizeof(struct usbatm_vcc_data
), GFP_KERNEL
);
817 new->sarb
= alloc_skb(usbatm_pdu_length(vcc
->qos
.rxtp
.max_sdu
), GFP_KERNEL
);
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
);
833 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
834 set_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
835 set_bit(ATM_VF_READY
, &vcc
->flags
);
837 mutex_unlock(&instance
->serialize
);
839 atm_dbg(instance
, "%s: allocated vcc data 0x%p\n", __func__
, new);
845 mutex_unlock(&instance
->serialize
);
849 static void usbatm_atm_close(struct atm_vcc
*vcc
)
851 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
852 struct usbatm_vcc_data
*vcc_data
= vcc
->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
;
867 list_del(&vcc_data
->list
);
868 tasklet_enable(&instance
->rx_channel
.tasklet
);
870 kfree_skb(vcc_data
->sarb
);
871 vcc_data
->sarb
= NULL
;
874 vcc
->dev_data
= NULL
;
876 vcc
->vpi
= ATM_VPI_UNSPEC
;
877 vcc
->vci
= ATM_VCI_UNSPEC
;
878 clear_bit(ATM_VF_READY
, &vcc
->flags
);
879 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
880 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
882 mutex_unlock(&instance
->serialize
);
885 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
,
888 struct usbatm_data
*instance
= atm_dev
->dev_data
;
890 if (!instance
|| instance
->disconnected
)
895 return put_user(ATM_LM_NONE
, (int __user
*)arg
) ? -EFAULT
: 0;
901 static int usbatm_atm_init(struct usbatm_data
*instance
)
903 struct atm_dev
*atm_dev
;
906 /* ATM init. The ATM initialization scheme suffers from an intrinsic race
907 * condition: callbacks we register can be executed at once, before we have
908 * initialized the struct atm_dev. To protect against this, all callbacks
909 * abort if atm_dev->dev_data is NULL. */
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
;
920 atm_dev
->ci_range
.vpi_bits
= ATM_CI_MAX
;
921 atm_dev
->ci_range
.vci_bits
= ATM_CI_MAX
;
922 atm_dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
924 /* temp init ATM device, set to 128kbit */
925 atm_dev
->link_rate
= 128 * 1000 / 424;
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 */
934 /* ready for ATM callbacks */
936 atm_dev
->dev_data
= instance
;
938 /* submit all rx URBs */
939 for (i
= 0; i
< num_rcv_urbs
; i
++)
940 usbatm_submit_urb(instance
->urbs
[i
]);
945 instance
->atm_dev
= NULL
;
946 atm_dev_deregister(atm_dev
); /* usbatm_atm_dev_close will eventually be called */
955 static int usbatm_do_heavy_init(void *arg
)
957 struct usbatm_data
*instance
= arg
;
960 allow_signal(SIGTERM
);
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 complete_and_exit(&instance
->thread_exited
, ret
);
975 static int usbatm_heavy_init(struct usbatm_data
*instance
)
977 struct task_struct
*t
;
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",
983 __func__
, PTR_ERR(t
));
987 instance
->thread
= t
;
989 wait_for_completion(&instance
->thread_started
);
994 static void usbatm_tasklet_schedule(struct timer_list
*t
)
996 struct usbatm_channel
*channel
= from_timer(channel
, t
, delay
);
998 tasklet_schedule(&channel
->tasklet
);
1001 static void usbatm_init_channel(struct usbatm_channel
*channel
)
1003 spin_lock_init(&channel
->lock
);
1004 INIT_LIST_HEAD(&channel
->list
);
1005 timer_setup(&channel
->delay
, usbatm_tasklet_schedule
, 0);
1008 int usbatm_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
,
1009 struct usbatm_driver
*driver
)
1011 struct device
*dev
= &intf
->dev
;
1012 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1013 struct usbatm_data
*instance
;
1015 int error
= -ENOMEM
;
1017 unsigned int maxpacket
, num_packets
;
1020 instance
= kzalloc(sizeof(*instance
) + sizeof(struct urb
*) * (num_rcv_urbs
+ num_snd_urbs
), GFP_KERNEL
);
1026 instance
->driver
= driver
;
1027 strlcpy(instance
->driver_name
, driver
->driver_name
,
1028 sizeof(instance
->driver_name
));
1030 instance
->usb_dev
= usb_dev
;
1031 instance
->usb_intf
= intf
;
1033 buf
= instance
->description
;
1034 length
= sizeof(instance
->description
);
1036 if ((i
= usb_string(usb_dev
, usb_dev
->descriptor
.iProduct
, buf
, length
)) < 0)
1042 i
= scnprintf(buf
, length
, " (");
1046 if (length
<= 0 || (i
= usb_make_path(usb_dev
, buf
, length
)) < 0)
1052 snprintf(buf
, length
, ")");
1055 if (driver
->bind
&& (error
= driver
->bind(instance
, intf
, id
)) < 0) {
1056 dev_err(dev
, "%s: bind failed: %d!\n", __func__
, error
);
1060 /* private fields */
1062 kref_init(&instance
->refcount
); /* dropped in usbatm_usb_disconnect */
1063 mutex_init(&instance
->serialize
);
1065 instance
->thread
= NULL
;
1066 init_completion(&instance
->thread_started
);
1067 init_completion(&instance
->thread_exited
);
1069 INIT_LIST_HEAD(&instance
->vcc_list
);
1070 skb_queue_head_init(&instance
->sndqueue
);
1072 usbatm_init_channel(&instance
->rx_channel
);
1073 usbatm_init_channel(&instance
->tx_channel
);
1074 tasklet_setup(&instance
->rx_channel
.tasklet
, usbatm_rx_process
);
1075 tasklet_setup(&instance
->tx_channel
.tasklet
, usbatm_tx_process
);
1076 instance
->rx_channel
.stride
= ATM_CELL_SIZE
+ driver
->rx_padding
;
1077 instance
->tx_channel
.stride
= ATM_CELL_SIZE
+ driver
->tx_padding
;
1078 instance
->rx_channel
.usbatm
= instance
->tx_channel
.usbatm
= instance
;
1080 if ((instance
->flags
& UDSL_USE_ISOC
) && driver
->isoc_in
)
1081 instance
->rx_channel
.endpoint
= usb_rcvisocpipe(usb_dev
, driver
->isoc_in
);
1083 instance
->rx_channel
.endpoint
= usb_rcvbulkpipe(usb_dev
, driver
->bulk_in
);
1085 instance
->tx_channel
.endpoint
= usb_sndbulkpipe(usb_dev
, driver
->bulk_out
);
1087 /* tx buffer size must be a positive multiple of the stride */
1088 instance
->tx_channel
.buf_size
= max(instance
->tx_channel
.stride
,
1089 snd_buf_bytes
- (snd_buf_bytes
% instance
->tx_channel
.stride
));
1091 /* rx buffer size must be a positive multiple of the endpoint maxpacket */
1092 maxpacket
= usb_maxpacket(usb_dev
, instance
->rx_channel
.endpoint
, 0);
1094 if ((maxpacket
< 1) || (maxpacket
> UDSL_MAX_BUF_SIZE
)) {
1095 dev_err(dev
, "%s: invalid endpoint %02x!\n", __func__
,
1096 usb_pipeendpoint(instance
->rx_channel
.endpoint
));
1101 num_packets
= max(1U, (rcv_buf_bytes
+ maxpacket
/ 2) / maxpacket
); /* round */
1103 if (num_packets
* maxpacket
> UDSL_MAX_BUF_SIZE
)
1106 instance
->rx_channel
.buf_size
= num_packets
* maxpacket
;
1107 instance
->rx_channel
.packet_size
= maxpacket
;
1109 for (i
= 0; i
< 2; i
++) {
1110 struct usbatm_channel
*channel
= i
?
1111 &instance
->tx_channel
: &instance
->rx_channel
;
1113 dev_dbg(dev
, "%s: using %d byte buffer for %s channel 0x%p\n",
1114 __func__
, channel
->buf_size
, i
? "tx" : "rx", channel
);
1117 /* initialize urbs */
1119 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1121 struct usbatm_channel
*channel
= i
< num_rcv_urbs
?
1122 &instance
->rx_channel
: &instance
->tx_channel
;
1124 unsigned int iso_packets
= usb_pipeisoc(channel
->endpoint
) ? channel
->buf_size
/ channel
->packet_size
: 0;
1126 urb
= usb_alloc_urb(iso_packets
, GFP_KERNEL
);
1132 instance
->urbs
[i
] = urb
;
1134 /* zero the tx padding to avoid leaking information */
1135 buffer
= kzalloc(channel
->buf_size
, GFP_KERNEL
);
1141 usb_fill_bulk_urb(urb
, instance
->usb_dev
, channel
->endpoint
,
1142 buffer
, channel
->buf_size
, usbatm_complete
, channel
);
1146 urb
->transfer_flags
= URB_ISO_ASAP
;
1147 urb
->number_of_packets
= iso_packets
;
1148 for (j
= 0; j
< iso_packets
; j
++) {
1149 urb
->iso_frame_desc
[j
].offset
= channel
->packet_size
* j
;
1150 urb
->iso_frame_desc
[j
].length
= channel
->packet_size
;
1154 /* put all tx URBs on the list of spares */
1155 if (i
>= num_rcv_urbs
)
1156 list_add_tail(&urb
->urb_list
, &channel
->list
);
1158 vdbg(&intf
->dev
, "%s: alloced buffer 0x%p buf size %u urb 0x%p",
1159 __func__
, urb
->transfer_buffer
, urb
->transfer_buffer_length
, urb
);
1162 instance
->cached_vpi
= ATM_VPI_UNSPEC
;
1163 instance
->cached_vci
= ATM_VCI_UNSPEC
;
1164 instance
->cell_buf
= kmalloc(instance
->rx_channel
.stride
, GFP_KERNEL
);
1166 if (!instance
->cell_buf
) {
1171 if (!(instance
->flags
& UDSL_SKIP_HEAVY_INIT
) && driver
->heavy_init
) {
1172 error
= usbatm_heavy_init(instance
);
1174 complete(&instance
->thread_exited
); /* pretend that heavy_init was run */
1175 error
= usbatm_atm_init(instance
);
1181 usb_get_dev(usb_dev
);
1182 usb_set_intfdata(intf
, instance
);
1187 if (instance
->driver
->unbind
)
1188 instance
->driver
->unbind(instance
, intf
);
1190 kfree(instance
->cell_buf
);
1192 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1193 if (instance
->urbs
[i
])
1194 kfree(instance
->urbs
[i
]->transfer_buffer
);
1195 usb_free_urb(instance
->urbs
[i
]);
1202 EXPORT_SYMBOL_GPL(usbatm_usb_probe
);
1204 void usbatm_usb_disconnect(struct usb_interface
*intf
)
1206 struct device
*dev
= &intf
->dev
;
1207 struct usbatm_data
*instance
= usb_get_intfdata(intf
);
1208 struct usbatm_vcc_data
*vcc_data
;
1212 dev_dbg(dev
, "%s: NULL instance!\n", __func__
);
1216 usb_set_intfdata(intf
, NULL
);
1218 mutex_lock(&instance
->serialize
);
1219 instance
->disconnected
= 1;
1220 if (instance
->thread
!= NULL
)
1221 send_sig(SIGTERM
, instance
->thread
, 1);
1222 mutex_unlock(&instance
->serialize
);
1224 wait_for_completion(&instance
->thread_exited
);
1226 mutex_lock(&instance
->serialize
);
1227 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
1228 vcc_release_async(vcc_data
->vcc
, -EPIPE
);
1229 mutex_unlock(&instance
->serialize
);
1231 tasklet_disable(&instance
->rx_channel
.tasklet
);
1232 tasklet_disable(&instance
->tx_channel
.tasklet
);
1234 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++)
1235 usb_kill_urb(instance
->urbs
[i
]);
1237 del_timer_sync(&instance
->rx_channel
.delay
);
1238 del_timer_sync(&instance
->tx_channel
.delay
);
1240 /* turn usbatm_[rt]x_process into something close to a no-op */
1241 /* no need to take the spinlock */
1242 INIT_LIST_HEAD(&instance
->rx_channel
.list
);
1243 INIT_LIST_HEAD(&instance
->tx_channel
.list
);
1245 tasklet_enable(&instance
->rx_channel
.tasklet
);
1246 tasklet_enable(&instance
->tx_channel
.tasklet
);
1248 if (instance
->atm_dev
&& instance
->driver
->atm_stop
)
1249 instance
->driver
->atm_stop(instance
, instance
->atm_dev
);
1251 if (instance
->driver
->unbind
)
1252 instance
->driver
->unbind(instance
, intf
);
1254 instance
->driver_data
= NULL
;
1256 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1257 kfree(instance
->urbs
[i
]->transfer_buffer
);
1258 usb_free_urb(instance
->urbs
[i
]);
1261 kfree(instance
->cell_buf
);
1264 if (instance
->atm_dev
) {
1265 atm_dev_deregister(instance
->atm_dev
);
1266 instance
->atm_dev
= NULL
;
1269 usbatm_put_instance(instance
); /* taken in usbatm_usb_probe */
1271 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect
);
1278 static int __init
usbatm_usb_init(void)
1280 if (sizeof(struct usbatm_control
) > sizeof_field(struct sk_buff
, cb
)) {
1281 pr_err("%s unusable with this kernel!\n", usbatm_driver_name
);
1285 if ((num_rcv_urbs
> UDSL_MAX_RCV_URBS
)
1286 || (num_snd_urbs
> UDSL_MAX_SND_URBS
)
1287 || (rcv_buf_bytes
< 1)
1288 || (rcv_buf_bytes
> UDSL_MAX_BUF_SIZE
)
1289 || (snd_buf_bytes
< 1)
1290 || (snd_buf_bytes
> UDSL_MAX_BUF_SIZE
))
1295 module_init(usbatm_usb_init
);
1297 static void __exit
usbatm_usb_exit(void)
1300 module_exit(usbatm_usb_exit
);
1302 MODULE_AUTHOR(DRIVER_AUTHOR
);
1303 MODULE_DESCRIPTION(DRIVER_DESC
);
1304 MODULE_LICENSE("GPL");
1310 #ifdef VERBOSE_DEBUG
1311 static int usbatm_print_packet(struct usbatm_data
*instance
,
1312 const unsigned char *data
, int len
)
1314 unsigned char buffer
[256];
1317 for (i
= 0; i
< len
;) {
1319 sprintf(buffer
, "%.3d :", i
);
1320 for (j
= 0; (j
< 16) && (i
< len
); j
++, i
++)
1321 sprintf(buffer
, "%s %2.2x", buffer
, data
[i
]);
1322 dev_dbg(&instance
->usb_intf
->dev
, "%s", buffer
);