1 /******************************************************************************
2 * usbatm.c - Generic USB xDSL driver core
4 * Copyright (C) 2001, Alcatel
5 * Copyright (C) 2003, Duncan Sands, SolNegro, Josep Comas
6 * Copyright (C) 2004, David Woodhouse, Roman Kagan
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
13 * This program is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * You should have received a copy of the GNU General Public License along with
19 * this program; if not, write to the Free Software Foundation, Inc., 59
20 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 ******************************************************************************/
25 * Written by Johan Verrept, Duncan Sands (duncan.sands@free.fr) and David Woodhouse
27 * 1.7+: - See the check-in logs
29 * 1.6: - No longer opens a connection if the firmware is not loaded
30 * - Added support for the speedtouch 330
31 * - Removed the limit on the number of devices
32 * - Module now autoloads on device plugin
33 * - Merged relevant parts of sarlib
34 * - Replaced the kernel thread with a tasklet
35 * - New packet transmission code
36 * - Changed proc file contents
37 * - Fixed all known SMP races
38 * - Many fixes and cleanups
39 * - Various fixes by Oliver Neukum (oliver@neukum.name)
41 * 1.5A: - Version for inclusion in 2.5 series kernel
42 * - Modifications by Richard Purdie (rpurdie@rpsys.net)
43 * - made compatible with kernel 2.5.6 onwards by changing
44 * usbatm_usb_send_data_context->urb to a pointer and adding code
45 * to alloc and free it
46 * - remove_wait_queue() added to usbatm_atm_processqueue_thread()
48 * 1.5: - fixed memory leak when atmsar_decode_aal5 returned NULL.
49 * (reported by stephen.robinson@zen.co.uk)
51 * 1.4: - changed the spin_lock() under interrupt to spin_lock_irqsave()
52 * - unlink all active send urbs of a vcc that is being closed.
54 * 1.3.1: - added the version number
56 * 1.3: - Added multiple send urb support
57 * - fixed memory leak and vcc->tx_inuse starvation bug
58 * when not enough memory left in vcc.
60 * 1.2: - Fixed race condition in usbatm_usb_send_data()
61 * 1.1: - Turned off packet debugging
67 #include <asm/uaccess.h>
68 #include <linux/crc32.h>
69 #include <linux/errno.h>
70 #include <linux/init.h>
71 #include <linux/interrupt.h>
72 #include <linux/kernel.h>
73 #include <linux/module.h>
74 #include <linux/moduleparam.h>
75 #include <linux/netdevice.h>
76 #include <linux/proc_fs.h>
77 #include <linux/sched.h>
78 #include <linux/signal.h>
79 #include <linux/slab.h>
80 #include <linux/stat.h>
81 #include <linux/timer.h>
82 #include <linux/wait.h>
83 #include <linux/kthread.h>
84 #include <linux/ratelimit.h>
87 static int usbatm_print_packet(struct usbatm_data
*instance
, const unsigned char *data
, int len
);
88 #define PACKETDEBUG(arg...) usbatm_print_packet(arg)
89 #define vdbg(arg...) dev_dbg(arg)
91 #define PACKETDEBUG(arg...)
95 #define DRIVER_AUTHOR "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
96 #define DRIVER_VERSION "1.10"
97 #define DRIVER_DESC "Generic USB ATM/DSL I/O, version " DRIVER_VERSION
99 static const char usbatm_driver_name
[] = "usbatm";
101 #define UDSL_MAX_RCV_URBS 16
102 #define UDSL_MAX_SND_URBS 16
103 #define UDSL_MAX_BUF_SIZE 65536
104 #define UDSL_DEFAULT_RCV_URBS 4
105 #define UDSL_DEFAULT_SND_URBS 4
106 #define UDSL_DEFAULT_RCV_BUF_SIZE 3392 /* 64 * ATM_CELL_SIZE */
107 #define UDSL_DEFAULT_SND_BUF_SIZE 3392 /* 64 * ATM_CELL_SIZE */
109 #define ATM_CELL_HEADER (ATM_CELL_SIZE - ATM_CELL_PAYLOAD)
111 #define THROTTLE_MSECS 100 /* delay to recover processing after urb submission fails */
113 static unsigned int num_rcv_urbs
= UDSL_DEFAULT_RCV_URBS
;
114 static unsigned int num_snd_urbs
= UDSL_DEFAULT_SND_URBS
;
115 static unsigned int rcv_buf_bytes
= UDSL_DEFAULT_RCV_BUF_SIZE
;
116 static unsigned int snd_buf_bytes
= UDSL_DEFAULT_SND_BUF_SIZE
;
118 module_param(num_rcv_urbs
, uint
, S_IRUGO
);
119 MODULE_PARM_DESC(num_rcv_urbs
,
120 "Number of urbs used for reception (range: 0-"
121 __MODULE_STRING(UDSL_MAX_RCV_URBS
) ", default: "
122 __MODULE_STRING(UDSL_DEFAULT_RCV_URBS
) ")");
124 module_param(num_snd_urbs
, uint
, S_IRUGO
);
125 MODULE_PARM_DESC(num_snd_urbs
,
126 "Number of urbs used for transmission (range: 0-"
127 __MODULE_STRING(UDSL_MAX_SND_URBS
) ", default: "
128 __MODULE_STRING(UDSL_DEFAULT_SND_URBS
) ")");
130 module_param(rcv_buf_bytes
, uint
, S_IRUGO
);
131 MODULE_PARM_DESC(rcv_buf_bytes
,
132 "Size of the buffers used for reception, in bytes (range: 1-"
133 __MODULE_STRING(UDSL_MAX_BUF_SIZE
) ", default: "
134 __MODULE_STRING(UDSL_DEFAULT_RCV_BUF_SIZE
) ")");
136 module_param(snd_buf_bytes
, uint
, S_IRUGO
);
137 MODULE_PARM_DESC(snd_buf_bytes
,
138 "Size of the buffers used for transmission, in bytes (range: 1-"
139 __MODULE_STRING(UDSL_MAX_BUF_SIZE
) ", default: "
140 __MODULE_STRING(UDSL_DEFAULT_SND_BUF_SIZE
) ")");
145 struct usbatm_vcc_data
{
147 struct list_head list
;
152 /* raw cell reassembly */
153 struct sk_buff
*sarb
;
159 struct usbatm_control
{
160 struct atm_skb_data atm
;
165 #define UDSL_SKB(x) ((struct usbatm_control *)(x)->cb)
170 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
);
171 static int usbatm_atm_open(struct atm_vcc
*vcc
);
172 static void usbatm_atm_close(struct atm_vcc
*vcc
);
173 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
, void __user
* arg
);
174 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
175 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
* pos
, char *page
);
177 static struct atmdev_ops usbatm_atm_devops
= {
178 .dev_close
= usbatm_atm_dev_close
,
179 .open
= usbatm_atm_open
,
180 .close
= usbatm_atm_close
,
181 .ioctl
= usbatm_atm_ioctl
,
182 .send
= usbatm_atm_send
,
183 .proc_read
= usbatm_atm_proc_read
,
184 .owner
= THIS_MODULE
,
192 static inline unsigned int usbatm_pdu_length(unsigned int length
)
194 length
+= ATM_CELL_PAYLOAD
- 1 + ATM_AAL5_TRAILER
;
195 return length
- length
% ATM_CELL_PAYLOAD
;
198 static inline void usbatm_pop(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
203 dev_kfree_skb_any(skb
);
211 static struct urb
*usbatm_pop_urb(struct usbatm_channel
*channel
)
215 spin_lock_irq(&channel
->lock
);
216 if (list_empty(&channel
->list
)) {
217 spin_unlock_irq(&channel
->lock
);
221 urb
= list_entry(channel
->list
.next
, struct urb
, urb_list
);
222 list_del(&urb
->urb_list
);
223 spin_unlock_irq(&channel
->lock
);
228 static int usbatm_submit_urb(struct urb
*urb
)
230 struct usbatm_channel
*channel
= urb
->context
;
233 /* vdbg("%s: submitting urb 0x%p, size %u",
234 __func__, urb, urb->transfer_buffer_length); */
236 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
238 if (printk_ratelimit())
239 atm_warn(channel
->usbatm
, "%s: urb 0x%p submission failed (%d)!\n",
242 /* consider all errors transient and return the buffer back to the queue */
243 urb
->status
= -EAGAIN
;
244 spin_lock_irq(&channel
->lock
);
246 /* must add to the front when sending; doesn't matter when receiving */
247 list_add(&urb
->urb_list
, &channel
->list
);
249 spin_unlock_irq(&channel
->lock
);
251 /* make sure the channel doesn't stall */
252 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
258 static void usbatm_complete(struct urb
*urb
)
260 struct usbatm_channel
*channel
= urb
->context
;
262 int status
= urb
->status
;
264 /* vdbg("%s: urb 0x%p, status %d, actual_length %d",
265 __func__, urb, status, urb->actual_length); */
267 /* usually in_interrupt(), but not always */
268 spin_lock_irqsave(&channel
->lock
, flags
);
270 /* must add to the back when receiving; doesn't matter when sending */
271 list_add_tail(&urb
->urb_list
, &channel
->list
);
273 spin_unlock_irqrestore(&channel
->lock
, flags
);
275 if (unlikely(status
) &&
276 (!(channel
->usbatm
->flags
& UDSL_IGNORE_EILSEQ
) ||
277 status
!= -EILSEQ
)) {
278 if (status
== -ESHUTDOWN
)
281 if (printk_ratelimit())
282 atm_warn(channel
->usbatm
, "%s: urb 0x%p failed (%d)!\n",
283 __func__
, urb
, status
);
284 /* throttle processing in case of an error */
285 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
287 tasklet_schedule(&channel
->tasklet
);
295 static inline struct usbatm_vcc_data
*usbatm_find_vcc(struct usbatm_data
*instance
,
298 struct usbatm_vcc_data
*vcc_data
;
300 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
301 if ((vcc_data
->vci
== vci
) && (vcc_data
->vpi
== vpi
))
306 static void usbatm_extract_one_cell(struct usbatm_data
*instance
, unsigned char *source
)
309 struct sk_buff
*sarb
;
310 short vpi
= ((source
[0] & 0x0f) << 4) | (source
[1] >> 4);
311 int vci
= ((source
[1] & 0x0f) << 12) | (source
[2] << 4) | (source
[3] >> 4);
312 u8 pti
= ((source
[3] & 0xe) >> 1);
314 vdbg(&instance
->usb_intf
->dev
, "%s: vpi %hd, vci %d, pti %d", __func__
, vpi
, vci
, pti
);
316 if ((vci
!= instance
->cached_vci
) || (vpi
!= instance
->cached_vpi
)) {
317 instance
->cached_vpi
= vpi
;
318 instance
->cached_vci
= vci
;
320 instance
->cached_vcc
= usbatm_find_vcc(instance
, vpi
, vci
);
322 if (!instance
->cached_vcc
)
323 atm_rldbg(instance
, "%s: unknown vpi/vci (%hd/%d)!\n", __func__
, vpi
, vci
);
326 if (!instance
->cached_vcc
)
329 vcc
= instance
->cached_vcc
->vcc
;
331 /* OAM F5 end-to-end */
332 if (pti
== ATM_PTI_E2EF5
) {
333 if (printk_ratelimit())
334 atm_warn(instance
, "%s: OAM not supported (vpi %d, vci %d)!\n",
336 atomic_inc(&vcc
->stats
->rx_err
);
340 sarb
= instance
->cached_vcc
->sarb
;
342 if (sarb
->tail
+ ATM_CELL_PAYLOAD
> sarb
->end
) {
343 atm_rldbg(instance
, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
344 __func__
, sarb
->len
, vcc
);
345 /* discard cells already received */
347 UDSL_ASSERT(instance
, sarb
->tail
+ ATM_CELL_PAYLOAD
<= sarb
->end
);
350 memcpy(skb_tail_pointer(sarb
), source
+ ATM_CELL_HEADER
, ATM_CELL_PAYLOAD
);
351 __skb_put(sarb
, ATM_CELL_PAYLOAD
);
356 unsigned int pdu_length
;
358 length
= (source
[ATM_CELL_SIZE
- 6] << 8) + source
[ATM_CELL_SIZE
- 5];
360 /* guard against overflow */
361 if (length
> ATM_MAX_AAL5_PDU
) {
362 atm_rldbg(instance
, "%s: bogus length %u (vcc: 0x%p)!\n",
363 __func__
, length
, vcc
);
364 atomic_inc(&vcc
->stats
->rx_err
);
368 pdu_length
= usbatm_pdu_length(length
);
370 if (sarb
->len
< pdu_length
) {
371 atm_rldbg(instance
, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
372 __func__
, pdu_length
, sarb
->len
, vcc
);
373 atomic_inc(&vcc
->stats
->rx_err
);
377 if (crc32_be(~0, skb_tail_pointer(sarb
) - pdu_length
, pdu_length
) != 0xc704dd7b) {
378 atm_rldbg(instance
, "%s: packet failed crc check (vcc: 0x%p)!\n",
380 atomic_inc(&vcc
->stats
->rx_err
);
384 vdbg(&instance
->usb_intf
->dev
,
385 "%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)",
386 __func__
, length
, pdu_length
, vcc
);
388 if (!(skb
= dev_alloc_skb(length
))) {
389 if (printk_ratelimit())
390 atm_err(instance
, "%s: no memory for skb (length: %u)!\n",
392 atomic_inc(&vcc
->stats
->rx_drop
);
396 vdbg(&instance
->usb_intf
->dev
,
397 "%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)",
398 __func__
, skb
, skb
->truesize
);
400 if (!atm_charge(vcc
, skb
->truesize
)) {
401 atm_rldbg(instance
, "%s: failed atm_charge (skb->truesize: %u)!\n",
402 __func__
, skb
->truesize
);
403 dev_kfree_skb_any(skb
);
404 goto out
; /* atm_charge increments rx_drop */
407 skb_copy_to_linear_data(skb
,
408 skb_tail_pointer(sarb
) - pdu_length
,
410 __skb_put(skb
, length
);
412 vdbg(&instance
->usb_intf
->dev
,
413 "%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
414 __func__
, skb
, skb
->len
, skb
->truesize
);
416 PACKETDEBUG(instance
, skb
->data
, skb
->len
);
420 atomic_inc(&vcc
->stats
->rx
);
426 static void usbatm_extract_cells(struct usbatm_data
*instance
,
427 unsigned char *source
, unsigned int avail_data
)
429 unsigned int stride
= instance
->rx_channel
.stride
;
430 unsigned int buf_usage
= instance
->buf_usage
;
432 /* extract cells from incoming data, taking into account that
433 * the length of avail data may not be a multiple of stride */
436 /* we have a partially received atm cell */
437 unsigned char *cell_buf
= instance
->cell_buf
;
438 unsigned int space_left
= stride
- buf_usage
;
440 UDSL_ASSERT(instance
, buf_usage
<= stride
);
442 if (avail_data
>= space_left
) {
443 /* add new data and process cell */
444 memcpy(cell_buf
+ buf_usage
, source
, space_left
);
445 source
+= space_left
;
446 avail_data
-= space_left
;
447 usbatm_extract_one_cell(instance
, cell_buf
);
448 instance
->buf_usage
= 0;
450 /* not enough data to fill the cell */
451 memcpy(cell_buf
+ buf_usage
, source
, avail_data
);
452 instance
->buf_usage
= buf_usage
+ avail_data
;
457 for (; avail_data
>= stride
; avail_data
-= stride
, source
+= stride
)
458 usbatm_extract_one_cell(instance
, source
);
460 if (avail_data
> 0) {
461 /* length was not a multiple of stride -
462 * save remaining data for next call */
463 memcpy(instance
->cell_buf
, source
, avail_data
);
464 instance
->buf_usage
= avail_data
;
473 static unsigned int usbatm_write_cells(struct usbatm_data
*instance
,
475 u8
*target
, unsigned int avail_space
)
477 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
478 struct atm_vcc
*vcc
= ctrl
->atm
.vcc
;
479 unsigned int bytes_written
;
480 unsigned int stride
= instance
->tx_channel
.stride
;
482 vdbg(&instance
->usb_intf
->dev
, "%s: skb->len=%d, avail_space=%u",
483 __func__
, skb
->len
, avail_space
);
484 UDSL_ASSERT(instance
, !(avail_space
% stride
));
486 for (bytes_written
= 0; bytes_written
< avail_space
&& ctrl
->len
;
487 bytes_written
+= stride
, target
+= stride
) {
488 unsigned int data_len
= min_t(unsigned int, skb
->len
, ATM_CELL_PAYLOAD
);
489 unsigned int left
= ATM_CELL_PAYLOAD
- data_len
;
492 ptr
[0] = vcc
->vpi
>> 4;
493 ptr
[1] = (vcc
->vpi
<< 4) | (vcc
->vci
>> 12);
494 ptr
[2] = vcc
->vci
>> 4;
495 ptr
[3] = vcc
->vci
<< 4;
497 ptr
+= ATM_CELL_HEADER
;
499 skb_copy_from_linear_data(skb
, ptr
, data_len
);
501 __skb_pull(skb
, data_len
);
506 memset(ptr
, 0, left
);
508 if (left
>= ATM_AAL5_TRAILER
) { /* trailer will go in this cell */
509 u8
*trailer
= target
+ ATM_CELL_SIZE
- ATM_AAL5_TRAILER
;
510 /* trailer[0] = 0; UU = 0 */
511 /* trailer[1] = 0; CPI = 0 */
512 trailer
[2] = ctrl
->len
>> 8;
513 trailer
[3] = ctrl
->len
;
515 ctrl
->crc
= ~crc32_be(ctrl
->crc
, ptr
, left
- 4);
517 trailer
[4] = ctrl
->crc
>> 24;
518 trailer
[5] = ctrl
->crc
>> 16;
519 trailer
[6] = ctrl
->crc
>> 8;
520 trailer
[7] = ctrl
->crc
;
522 target
[3] |= 0x2; /* adjust PTI */
524 ctrl
->len
= 0; /* tag this skb finished */
526 ctrl
->crc
= crc32_be(ctrl
->crc
, ptr
, left
);
529 return bytes_written
;
537 static void usbatm_rx_process(unsigned long data
)
539 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
542 while ((urb
= usbatm_pop_urb(&instance
->rx_channel
))) {
543 vdbg(&instance
->usb_intf
->dev
,
544 "%s: processing urb 0x%p", __func__
, urb
);
546 if (usb_pipeisoc(urb
->pipe
)) {
547 unsigned char *merge_start
= NULL
;
548 unsigned int merge_length
= 0;
549 const unsigned int packet_size
= instance
->rx_channel
.packet_size
;
552 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
553 if (!urb
->iso_frame_desc
[i
].status
) {
554 unsigned int actual_length
= urb
->iso_frame_desc
[i
].actual_length
;
556 UDSL_ASSERT(instance
, actual_length
<= packet_size
);
559 merge_start
= (unsigned char *)urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
560 merge_length
+= actual_length
;
561 if (merge_length
&& (actual_length
< packet_size
)) {
562 usbatm_extract_cells(instance
, merge_start
, merge_length
);
566 atm_rldbg(instance
, "%s: status %d in frame %d!\n", __func__
, urb
->status
, i
);
568 usbatm_extract_cells(instance
, merge_start
, merge_length
);
570 instance
->buf_usage
= 0;
575 usbatm_extract_cells(instance
, merge_start
, merge_length
);
578 usbatm_extract_cells(instance
, urb
->transfer_buffer
, urb
->actual_length
);
580 instance
->buf_usage
= 0;
582 if (usbatm_submit_urb(urb
))
592 static void usbatm_tx_process(unsigned long data
)
594 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
595 struct sk_buff
*skb
= instance
->current_skb
;
596 struct urb
*urb
= NULL
;
597 const unsigned int buf_size
= instance
->tx_channel
.buf_size
;
598 unsigned int bytes_written
= 0;
602 skb
= skb_dequeue(&instance
->sndqueue
);
606 urb
= usbatm_pop_urb(&instance
->tx_channel
);
608 break; /* no more senders */
609 buffer
= urb
->transfer_buffer
;
610 bytes_written
= (urb
->status
== -EAGAIN
) ?
611 urb
->transfer_buffer_length
: 0;
614 bytes_written
+= usbatm_write_cells(instance
, skb
,
615 buffer
+ bytes_written
,
616 buf_size
- bytes_written
);
618 vdbg(&instance
->usb_intf
->dev
,
619 "%s: wrote %u bytes from skb 0x%p to urb 0x%p",
620 __func__
, bytes_written
, skb
, urb
);
622 if (!UDSL_SKB(skb
)->len
) {
623 struct atm_vcc
*vcc
= UDSL_SKB(skb
)->atm
.vcc
;
625 usbatm_pop(vcc
, skb
);
626 atomic_inc(&vcc
->stats
->tx
);
628 skb
= skb_dequeue(&instance
->sndqueue
);
631 if (bytes_written
== buf_size
|| (!skb
&& bytes_written
)) {
632 urb
->transfer_buffer_length
= bytes_written
;
634 if (usbatm_submit_urb(urb
))
640 instance
->current_skb
= skb
;
643 static void usbatm_cancel_send(struct usbatm_data
*instance
,
646 struct sk_buff
*skb
, *n
;
648 atm_dbg(instance
, "%s entered\n", __func__
);
649 spin_lock_irq(&instance
->sndqueue
.lock
);
650 skb_queue_walk_safe(&instance
->sndqueue
, skb
, n
) {
651 if (UDSL_SKB(skb
)->atm
.vcc
== vcc
) {
652 atm_dbg(instance
, "%s: popping skb 0x%p\n", __func__
, skb
);
653 __skb_unlink(skb
, &instance
->sndqueue
);
654 usbatm_pop(vcc
, skb
);
657 spin_unlock_irq(&instance
->sndqueue
.lock
);
659 tasklet_disable(&instance
->tx_channel
.tasklet
);
660 if ((skb
= instance
->current_skb
) && (UDSL_SKB(skb
)->atm
.vcc
== vcc
)) {
661 atm_dbg(instance
, "%s: popping current skb (0x%p)\n", __func__
, skb
);
662 instance
->current_skb
= NULL
;
663 usbatm_pop(vcc
, skb
);
665 tasklet_enable(&instance
->tx_channel
.tasklet
);
666 atm_dbg(instance
, "%s done\n", __func__
);
669 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
671 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
672 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
675 /* racy disconnection check - fine */
676 if (!instance
|| instance
->disconnected
) {
678 printk_ratelimited(KERN_DEBUG
"%s: %s!\n", __func__
, instance
? "disconnected" : "NULL instance");
684 vdbg(&instance
->usb_intf
->dev
, "%s called (skb 0x%p, len %u)", __func__
,
687 if (vcc
->qos
.aal
!= ATM_AAL5
) {
688 atm_rldbg(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
693 if (skb
->len
> ATM_MAX_AAL5_PDU
) {
694 atm_rldbg(instance
, "%s: packet too long (%d vs %d)!\n",
695 __func__
, skb
->len
, ATM_MAX_AAL5_PDU
);
700 PACKETDEBUG(instance
, skb
->data
, skb
->len
);
702 /* initialize the control block */
704 ctrl
->len
= skb
->len
;
705 ctrl
->crc
= crc32_be(~0, skb
->data
, skb
->len
);
707 skb_queue_tail(&instance
->sndqueue
, skb
);
708 tasklet_schedule(&instance
->tx_channel
.tasklet
);
713 usbatm_pop(vcc
, skb
);
718 /********************
720 ********************/
722 static void usbatm_destroy_instance(struct kref
*kref
)
724 struct usbatm_data
*instance
= container_of(kref
, struct usbatm_data
, refcount
);
726 usb_dbg(instance
, "%s\n", __func__
);
728 tasklet_kill(&instance
->rx_channel
.tasklet
);
729 tasklet_kill(&instance
->tx_channel
.tasklet
);
730 usb_put_dev(instance
->usb_dev
);
734 static void usbatm_get_instance(struct usbatm_data
*instance
)
736 usb_dbg(instance
, "%s\n", __func__
);
738 kref_get(&instance
->refcount
);
741 static void usbatm_put_instance(struct usbatm_data
*instance
)
743 usb_dbg(instance
, "%s\n", __func__
);
745 kref_put(&instance
->refcount
, usbatm_destroy_instance
);
753 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
)
755 struct usbatm_data
*instance
= atm_dev
->dev_data
;
760 usb_dbg(instance
, "%s\n", __func__
);
761 atm_dev
->dev_data
= NULL
; /* catch bugs */
762 usbatm_put_instance(instance
); /* taken in usbatm_atm_init */
765 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
* pos
, char *page
)
767 struct usbatm_data
*instance
= atm_dev
->dev_data
;
774 return sprintf(page
, "%s\n", instance
->description
);
777 return sprintf(page
, "MAC: %pM\n", atm_dev
->esi
);
781 "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
782 atomic_read(&atm_dev
->stats
.aal5
.tx
),
783 atomic_read(&atm_dev
->stats
.aal5
.tx_err
),
784 atomic_read(&atm_dev
->stats
.aal5
.rx
),
785 atomic_read(&atm_dev
->stats
.aal5
.rx_err
),
786 atomic_read(&atm_dev
->stats
.aal5
.rx_drop
));
789 if (instance
->disconnected
)
790 return sprintf(page
, "Disconnected\n");
792 switch (atm_dev
->signal
) {
793 case ATM_PHY_SIG_FOUND
:
794 return sprintf(page
, "Line up\n");
795 case ATM_PHY_SIG_LOST
:
796 return sprintf(page
, "Line down\n");
798 return sprintf(page
, "Line state unknown\n");
805 static int usbatm_atm_open(struct atm_vcc
*vcc
)
807 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
808 struct usbatm_vcc_data
*new = NULL
;
811 short vpi
= vcc
->vpi
;
816 atm_dbg(instance
, "%s: vpi %hd, vci %d\n", __func__
, vpi
, vci
);
818 /* only support AAL5 */
819 if ((vcc
->qos
.aal
!= ATM_AAL5
)) {
820 atm_warn(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
825 if ((vcc
->qos
.rxtp
.max_sdu
< 0) || (vcc
->qos
.rxtp
.max_sdu
> ATM_MAX_AAL5_PDU
)) {
826 atm_dbg(instance
, "%s: max_sdu %d out of range!\n", __func__
, vcc
->qos
.rxtp
.max_sdu
);
830 mutex_lock(&instance
->serialize
); /* vs self, usbatm_atm_close, usbatm_usb_disconnect */
832 if (instance
->disconnected
) {
833 atm_dbg(instance
, "%s: disconnected!\n", __func__
);
838 if (usbatm_find_vcc(instance
, vpi
, vci
)) {
839 atm_dbg(instance
, "%s: %hd/%d already in use!\n", __func__
, vpi
, vci
);
844 if (!(new = kzalloc(sizeof(struct usbatm_vcc_data
), GFP_KERNEL
))) {
845 atm_err(instance
, "%s: no memory for vcc_data!\n", __func__
);
854 new->sarb
= alloc_skb(usbatm_pdu_length(vcc
->qos
.rxtp
.max_sdu
), GFP_KERNEL
);
856 atm_err(instance
, "%s: no memory for SAR buffer!\n", __func__
);
863 tasklet_disable(&instance
->rx_channel
.tasklet
);
864 instance
->cached_vcc
= new;
865 instance
->cached_vpi
= vpi
;
866 instance
->cached_vci
= vci
;
867 list_add(&new->list
, &instance
->vcc_list
);
868 tasklet_enable(&instance
->rx_channel
.tasklet
);
870 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
871 set_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
872 set_bit(ATM_VF_READY
, &vcc
->flags
);
874 mutex_unlock(&instance
->serialize
);
876 atm_dbg(instance
, "%s: allocated vcc data 0x%p\n", __func__
, new);
882 mutex_unlock(&instance
->serialize
);
886 static void usbatm_atm_close(struct atm_vcc
*vcc
)
888 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
889 struct usbatm_vcc_data
*vcc_data
= vcc
->dev_data
;
891 if (!instance
|| !vcc_data
)
894 atm_dbg(instance
, "%s entered\n", __func__
);
896 atm_dbg(instance
, "%s: deallocating vcc 0x%p with vpi %d vci %d\n",
897 __func__
, vcc_data
, vcc_data
->vpi
, vcc_data
->vci
);
899 usbatm_cancel_send(instance
, vcc
);
901 mutex_lock(&instance
->serialize
); /* vs self, usbatm_atm_open, usbatm_usb_disconnect */
903 tasklet_disable(&instance
->rx_channel
.tasklet
);
904 if (instance
->cached_vcc
== vcc_data
) {
905 instance
->cached_vcc
= NULL
;
906 instance
->cached_vpi
= ATM_VPI_UNSPEC
;
907 instance
->cached_vci
= ATM_VCI_UNSPEC
;
909 list_del(&vcc_data
->list
);
910 tasklet_enable(&instance
->rx_channel
.tasklet
);
912 kfree_skb(vcc_data
->sarb
);
913 vcc_data
->sarb
= NULL
;
916 vcc
->dev_data
= NULL
;
918 vcc
->vpi
= ATM_VPI_UNSPEC
;
919 vcc
->vci
= ATM_VCI_UNSPEC
;
920 clear_bit(ATM_VF_READY
, &vcc
->flags
);
921 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
922 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
924 mutex_unlock(&instance
->serialize
);
926 atm_dbg(instance
, "%s successful\n", __func__
);
929 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
,
932 struct usbatm_data
*instance
= atm_dev
->dev_data
;
934 if (!instance
|| instance
->disconnected
)
939 return put_user(ATM_LM_NONE
, (int __user
*)arg
) ? -EFAULT
: 0;
945 static int usbatm_atm_init(struct usbatm_data
*instance
)
947 struct atm_dev
*atm_dev
;
950 /* ATM init. The ATM initialization scheme suffers from an intrinsic race
951 * condition: callbacks we register can be executed at once, before we have
952 * initialized the struct atm_dev. To protect against this, all callbacks
953 * abort if atm_dev->dev_data is NULL. */
954 atm_dev
= atm_dev_register(instance
->driver_name
,
955 &instance
->usb_intf
->dev
, &usbatm_atm_devops
,
958 usb_err(instance
, "%s: failed to register ATM device!\n", __func__
);
962 instance
->atm_dev
= atm_dev
;
964 atm_dev
->ci_range
.vpi_bits
= ATM_CI_MAX
;
965 atm_dev
->ci_range
.vci_bits
= ATM_CI_MAX
;
966 atm_dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
968 /* temp init ATM device, set to 128kbit */
969 atm_dev
->link_rate
= 128 * 1000 / 424;
971 if (instance
->driver
->atm_start
&& ((ret
= instance
->driver
->atm_start(instance
, atm_dev
)) < 0)) {
972 atm_err(instance
, "%s: atm_start failed: %d!\n", __func__
, ret
);
976 usbatm_get_instance(instance
); /* dropped in usbatm_atm_dev_close */
978 /* ready for ATM callbacks */
980 atm_dev
->dev_data
= instance
;
982 /* submit all rx URBs */
983 for (i
= 0; i
< num_rcv_urbs
; i
++)
984 usbatm_submit_urb(instance
->urbs
[i
]);
989 instance
->atm_dev
= NULL
;
990 atm_dev_deregister(atm_dev
); /* usbatm_atm_dev_close will eventually be called */
999 static int usbatm_do_heavy_init(void *arg
)
1001 struct usbatm_data
*instance
= arg
;
1004 allow_signal(SIGTERM
);
1005 complete(&instance
->thread_started
);
1007 ret
= instance
->driver
->heavy_init(instance
, instance
->usb_intf
);
1010 ret
= usbatm_atm_init(instance
);
1012 mutex_lock(&instance
->serialize
);
1013 instance
->thread
= NULL
;
1014 mutex_unlock(&instance
->serialize
);
1016 complete_and_exit(&instance
->thread_exited
, ret
);
1019 static int usbatm_heavy_init(struct usbatm_data
*instance
)
1021 struct task_struct
*t
;
1023 t
= kthread_create(usbatm_do_heavy_init
, instance
, "%s",
1024 instance
->driver
->driver_name
);
1026 usb_err(instance
, "%s: failed to create kernel_thread (%ld)!\n",
1027 __func__
, PTR_ERR(t
));
1031 instance
->thread
= t
;
1033 wait_for_completion(&instance
->thread_started
);
1038 static void usbatm_tasklet_schedule(unsigned long data
)
1040 tasklet_schedule((struct tasklet_struct
*) data
);
1043 static void usbatm_init_channel(struct usbatm_channel
*channel
)
1045 spin_lock_init(&channel
->lock
);
1046 INIT_LIST_HEAD(&channel
->list
);
1047 channel
->delay
.function
= usbatm_tasklet_schedule
;
1048 channel
->delay
.data
= (unsigned long) &channel
->tasklet
;
1049 init_timer(&channel
->delay
);
1052 int usbatm_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
,
1053 struct usbatm_driver
*driver
)
1055 struct device
*dev
= &intf
->dev
;
1056 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1057 struct usbatm_data
*instance
;
1059 int error
= -ENOMEM
;
1061 unsigned int maxpacket
, num_packets
;
1063 dev_dbg(dev
, "%s: trying driver %s with vendor=%04x, product=%04x, ifnum %2d\n",
1064 __func__
, driver
->driver_name
,
1065 le16_to_cpu(usb_dev
->descriptor
.idVendor
),
1066 le16_to_cpu(usb_dev
->descriptor
.idProduct
),
1067 intf
->altsetting
->desc
.bInterfaceNumber
);
1070 instance
= kzalloc(sizeof(*instance
) + sizeof(struct urb
*) * (num_rcv_urbs
+ num_snd_urbs
), GFP_KERNEL
);
1072 dev_err(dev
, "%s: no memory for instance data!\n", __func__
);
1078 instance
->driver
= driver
;
1079 strlcpy(instance
->driver_name
, driver
->driver_name
,
1080 sizeof(instance
->driver_name
));
1082 instance
->usb_dev
= usb_dev
;
1083 instance
->usb_intf
= intf
;
1085 buf
= instance
->description
;
1086 length
= sizeof(instance
->description
);
1088 if ((i
= usb_string(usb_dev
, usb_dev
->descriptor
.iProduct
, buf
, length
)) < 0)
1094 i
= scnprintf(buf
, length
, " (");
1098 if (length
<= 0 || (i
= usb_make_path(usb_dev
, buf
, length
)) < 0)
1104 snprintf(buf
, length
, ")");
1107 if (driver
->bind
&& (error
= driver
->bind(instance
, intf
, id
)) < 0) {
1108 dev_err(dev
, "%s: bind failed: %d!\n", __func__
, error
);
1112 /* private fields */
1114 kref_init(&instance
->refcount
); /* dropped in usbatm_usb_disconnect */
1115 mutex_init(&instance
->serialize
);
1117 instance
->thread
= NULL
;
1118 init_completion(&instance
->thread_started
);
1119 init_completion(&instance
->thread_exited
);
1121 INIT_LIST_HEAD(&instance
->vcc_list
);
1122 skb_queue_head_init(&instance
->sndqueue
);
1124 usbatm_init_channel(&instance
->rx_channel
);
1125 usbatm_init_channel(&instance
->tx_channel
);
1126 tasklet_init(&instance
->rx_channel
.tasklet
, usbatm_rx_process
, (unsigned long)instance
);
1127 tasklet_init(&instance
->tx_channel
.tasklet
, usbatm_tx_process
, (unsigned long)instance
);
1128 instance
->rx_channel
.stride
= ATM_CELL_SIZE
+ driver
->rx_padding
;
1129 instance
->tx_channel
.stride
= ATM_CELL_SIZE
+ driver
->tx_padding
;
1130 instance
->rx_channel
.usbatm
= instance
->tx_channel
.usbatm
= instance
;
1132 if ((instance
->flags
& UDSL_USE_ISOC
) && driver
->isoc_in
)
1133 instance
->rx_channel
.endpoint
= usb_rcvisocpipe(usb_dev
, driver
->isoc_in
);
1135 instance
->rx_channel
.endpoint
= usb_rcvbulkpipe(usb_dev
, driver
->bulk_in
);
1137 instance
->tx_channel
.endpoint
= usb_sndbulkpipe(usb_dev
, driver
->bulk_out
);
1139 /* tx buffer size must be a positive multiple of the stride */
1140 instance
->tx_channel
.buf_size
= max(instance
->tx_channel
.stride
,
1141 snd_buf_bytes
- (snd_buf_bytes
% instance
->tx_channel
.stride
));
1143 /* rx buffer size must be a positive multiple of the endpoint maxpacket */
1144 maxpacket
= usb_maxpacket(usb_dev
, instance
->rx_channel
.endpoint
, 0);
1146 if ((maxpacket
< 1) || (maxpacket
> UDSL_MAX_BUF_SIZE
)) {
1147 dev_err(dev
, "%s: invalid endpoint %02x!\n", __func__
,
1148 usb_pipeendpoint(instance
->rx_channel
.endpoint
));
1153 num_packets
= max(1U, (rcv_buf_bytes
+ maxpacket
/ 2) / maxpacket
); /* round */
1155 if (num_packets
* maxpacket
> UDSL_MAX_BUF_SIZE
)
1158 instance
->rx_channel
.buf_size
= num_packets
* maxpacket
;
1159 instance
->rx_channel
.packet_size
= maxpacket
;
1162 for (i
= 0; i
< 2; i
++) {
1163 struct usbatm_channel
*channel
= i
?
1164 &instance
->tx_channel
: &instance
->rx_channel
;
1166 dev_dbg(dev
, "%s: using %d byte buffer for %s channel 0x%p\n", __func__
, channel
->buf_size
, i
? "tx" : "rx", channel
);
1170 /* initialize urbs */
1172 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1174 struct usbatm_channel
*channel
= i
< num_rcv_urbs
?
1175 &instance
->rx_channel
: &instance
->tx_channel
;
1177 unsigned int iso_packets
= usb_pipeisoc(channel
->endpoint
) ? channel
->buf_size
/ channel
->packet_size
: 0;
1179 UDSL_ASSERT(instance
, !usb_pipeisoc(channel
->endpoint
) || usb_pipein(channel
->endpoint
));
1181 urb
= usb_alloc_urb(iso_packets
, GFP_KERNEL
);
1183 dev_err(dev
, "%s: no memory for urb %d!\n", __func__
, i
);
1188 instance
->urbs
[i
] = urb
;
1190 /* zero the tx padding to avoid leaking information */
1191 buffer
= kzalloc(channel
->buf_size
, GFP_KERNEL
);
1193 dev_err(dev
, "%s: no memory for buffer %d!\n", __func__
, i
);
1198 usb_fill_bulk_urb(urb
, instance
->usb_dev
, channel
->endpoint
,
1199 buffer
, channel
->buf_size
, usbatm_complete
, channel
);
1203 urb
->transfer_flags
= URB_ISO_ASAP
;
1204 urb
->number_of_packets
= iso_packets
;
1205 for (j
= 0; j
< iso_packets
; j
++) {
1206 urb
->iso_frame_desc
[j
].offset
= channel
->packet_size
* j
;
1207 urb
->iso_frame_desc
[j
].length
= channel
->packet_size
;
1211 /* put all tx URBs on the list of spares */
1212 if (i
>= num_rcv_urbs
)
1213 list_add_tail(&urb
->urb_list
, &channel
->list
);
1215 vdbg(&intf
->dev
, "%s: alloced buffer 0x%p buf size %u urb 0x%p",
1216 __func__
, urb
->transfer_buffer
, urb
->transfer_buffer_length
, urb
);
1219 instance
->cached_vpi
= ATM_VPI_UNSPEC
;
1220 instance
->cached_vci
= ATM_VCI_UNSPEC
;
1221 instance
->cell_buf
= kmalloc(instance
->rx_channel
.stride
, GFP_KERNEL
);
1223 if (!instance
->cell_buf
) {
1224 dev_err(dev
, "%s: no memory for cell buffer!\n", __func__
);
1229 if (!(instance
->flags
& UDSL_SKIP_HEAVY_INIT
) && driver
->heavy_init
) {
1230 error
= usbatm_heavy_init(instance
);
1232 complete(&instance
->thread_exited
); /* pretend that heavy_init was run */
1233 error
= usbatm_atm_init(instance
);
1239 usb_get_dev(usb_dev
);
1240 usb_set_intfdata(intf
, instance
);
1245 if (instance
->driver
->unbind
)
1246 instance
->driver
->unbind(instance
, intf
);
1248 kfree(instance
->cell_buf
);
1250 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1251 if (instance
->urbs
[i
])
1252 kfree(instance
->urbs
[i
]->transfer_buffer
);
1253 usb_free_urb(instance
->urbs
[i
]);
1260 EXPORT_SYMBOL_GPL(usbatm_usb_probe
);
1262 void usbatm_usb_disconnect(struct usb_interface
*intf
)
1264 struct device
*dev
= &intf
->dev
;
1265 struct usbatm_data
*instance
= usb_get_intfdata(intf
);
1266 struct usbatm_vcc_data
*vcc_data
;
1269 dev_dbg(dev
, "%s entered\n", __func__
);
1272 dev_dbg(dev
, "%s: NULL instance!\n", __func__
);
1276 usb_set_intfdata(intf
, NULL
);
1278 mutex_lock(&instance
->serialize
);
1279 instance
->disconnected
= 1;
1280 if (instance
->thread
!= NULL
)
1281 send_sig(SIGTERM
, instance
->thread
, 1);
1282 mutex_unlock(&instance
->serialize
);
1284 wait_for_completion(&instance
->thread_exited
);
1286 mutex_lock(&instance
->serialize
);
1287 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
1288 vcc_release_async(vcc_data
->vcc
, -EPIPE
);
1289 mutex_unlock(&instance
->serialize
);
1291 tasklet_disable(&instance
->rx_channel
.tasklet
);
1292 tasklet_disable(&instance
->tx_channel
.tasklet
);
1294 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++)
1295 usb_kill_urb(instance
->urbs
[i
]);
1297 del_timer_sync(&instance
->rx_channel
.delay
);
1298 del_timer_sync(&instance
->tx_channel
.delay
);
1300 /* turn usbatm_[rt]x_process into something close to a no-op */
1301 /* no need to take the spinlock */
1302 INIT_LIST_HEAD(&instance
->rx_channel
.list
);
1303 INIT_LIST_HEAD(&instance
->tx_channel
.list
);
1305 tasklet_enable(&instance
->rx_channel
.tasklet
);
1306 tasklet_enable(&instance
->tx_channel
.tasklet
);
1308 if (instance
->atm_dev
&& instance
->driver
->atm_stop
)
1309 instance
->driver
->atm_stop(instance
, instance
->atm_dev
);
1311 if (instance
->driver
->unbind
)
1312 instance
->driver
->unbind(instance
, intf
);
1314 instance
->driver_data
= NULL
;
1316 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1317 kfree(instance
->urbs
[i
]->transfer_buffer
);
1318 usb_free_urb(instance
->urbs
[i
]);
1321 kfree(instance
->cell_buf
);
1324 if (instance
->atm_dev
) {
1325 atm_dev_deregister(instance
->atm_dev
);
1326 instance
->atm_dev
= NULL
;
1329 usbatm_put_instance(instance
); /* taken in usbatm_usb_probe */
1331 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect
);
1338 static int __init
usbatm_usb_init(void)
1340 if (sizeof(struct usbatm_control
) > FIELD_SIZEOF(struct sk_buff
, cb
)) {
1341 printk(KERN_ERR
"%s unusable with this kernel!\n", usbatm_driver_name
);
1345 if ((num_rcv_urbs
> UDSL_MAX_RCV_URBS
)
1346 || (num_snd_urbs
> UDSL_MAX_SND_URBS
)
1347 || (rcv_buf_bytes
< 1)
1348 || (rcv_buf_bytes
> UDSL_MAX_BUF_SIZE
)
1349 || (snd_buf_bytes
< 1)
1350 || (snd_buf_bytes
> UDSL_MAX_BUF_SIZE
))
1355 module_init(usbatm_usb_init
);
1357 static void __exit
usbatm_usb_exit(void)
1360 module_exit(usbatm_usb_exit
);
1362 MODULE_AUTHOR(DRIVER_AUTHOR
);
1363 MODULE_DESCRIPTION(DRIVER_DESC
);
1364 MODULE_LICENSE("GPL");
1365 MODULE_VERSION(DRIVER_VERSION
);
1371 #ifdef VERBOSE_DEBUG
1372 static int usbatm_print_packet(struct usbatm_data
*instance
,
1373 const unsigned char *data
, int len
)
1375 unsigned char buffer
[256];
1378 for (i
= 0; i
< len
;) {
1380 sprintf(buffer
, "%.3d :", i
);
1381 for (j
= 0; (j
< 16) && (i
< len
); j
++, i
++)
1382 sprintf(buffer
, "%s %2.2x", buffer
, data
[i
]);
1383 dev_dbg(&instance
->usb_intf
->dev
, "%s", buffer
);