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/smp_lock.h>
81 #include <linux/stat.h>
82 #include <linux/timer.h>
83 #include <linux/wait.h>
86 static int usbatm_print_packet(const unsigned char *data
, int len
);
87 #define PACKETDEBUG(arg...) usbatm_print_packet (arg)
88 #define vdbg(arg...) dbg (arg)
90 #define PACKETDEBUG(arg...)
94 #define DRIVER_AUTHOR "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
95 #define DRIVER_VERSION "1.10"
96 #define DRIVER_DESC "Generic USB ATM/DSL I/O, version " DRIVER_VERSION
98 static const char usbatm_driver_name
[] = "usbatm";
100 #define UDSL_MAX_RCV_URBS 16
101 #define UDSL_MAX_SND_URBS 16
102 #define UDSL_MAX_BUF_SIZE 65536
103 #define UDSL_DEFAULT_RCV_URBS 4
104 #define UDSL_DEFAULT_SND_URBS 4
105 #define UDSL_DEFAULT_RCV_BUF_SIZE 3392 /* 64 * ATM_CELL_SIZE */
106 #define UDSL_DEFAULT_SND_BUF_SIZE 3392 /* 64 * ATM_CELL_SIZE */
108 #define ATM_CELL_HEADER (ATM_CELL_SIZE - ATM_CELL_PAYLOAD)
110 #define THROTTLE_MSECS 100 /* delay to recover processing after urb submission fails */
112 static unsigned int num_rcv_urbs
= UDSL_DEFAULT_RCV_URBS
;
113 static unsigned int num_snd_urbs
= UDSL_DEFAULT_SND_URBS
;
114 static unsigned int rcv_buf_bytes
= UDSL_DEFAULT_RCV_BUF_SIZE
;
115 static unsigned int snd_buf_bytes
= UDSL_DEFAULT_SND_BUF_SIZE
;
117 module_param(num_rcv_urbs
, uint
, S_IRUGO
);
118 MODULE_PARM_DESC(num_rcv_urbs
,
119 "Number of urbs used for reception (range: 0-"
120 __MODULE_STRING(UDSL_MAX_RCV_URBS
) ", default: "
121 __MODULE_STRING(UDSL_DEFAULT_RCV_URBS
) ")");
123 module_param(num_snd_urbs
, uint
, S_IRUGO
);
124 MODULE_PARM_DESC(num_snd_urbs
,
125 "Number of urbs used for transmission (range: 0-"
126 __MODULE_STRING(UDSL_MAX_SND_URBS
) ", default: "
127 __MODULE_STRING(UDSL_DEFAULT_SND_URBS
) ")");
129 module_param(rcv_buf_bytes
, uint
, S_IRUGO
);
130 MODULE_PARM_DESC(rcv_buf_bytes
,
131 "Size of the buffers used for reception, in bytes (range: 1-"
132 __MODULE_STRING(UDSL_MAX_BUF_SIZE
) ", default: "
133 __MODULE_STRING(UDSL_DEFAULT_RCV_BUF_SIZE
) ")");
135 module_param(snd_buf_bytes
, uint
, S_IRUGO
);
136 MODULE_PARM_DESC(snd_buf_bytes
,
137 "Size of the buffers used for transmission, in bytes (range: 1-"
138 __MODULE_STRING(UDSL_MAX_BUF_SIZE
) ", default: "
139 __MODULE_STRING(UDSL_DEFAULT_SND_BUF_SIZE
) ")");
144 struct usbatm_vcc_data
{
146 struct list_head list
;
151 /* raw cell reassembly */
152 struct sk_buff
*sarb
;
158 struct usbatm_control
{
159 struct atm_skb_data atm
;
164 #define UDSL_SKB(x) ((struct usbatm_control *)(x)->cb)
169 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
);
170 static int usbatm_atm_open(struct atm_vcc
*vcc
);
171 static void usbatm_atm_close(struct atm_vcc
*vcc
);
172 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
, void __user
* arg
);
173 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
);
174 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
* pos
, char *page
);
176 static struct atmdev_ops usbatm_atm_devops
= {
177 .dev_close
= usbatm_atm_dev_close
,
178 .open
= usbatm_atm_open
,
179 .close
= usbatm_atm_close
,
180 .ioctl
= usbatm_atm_ioctl
,
181 .send
= usbatm_atm_send
,
182 .proc_read
= usbatm_atm_proc_read
,
183 .owner
= THIS_MODULE
,
191 static inline unsigned int usbatm_pdu_length(unsigned int length
)
193 length
+= ATM_CELL_PAYLOAD
- 1 + ATM_AAL5_TRAILER
;
194 return length
- length
% ATM_CELL_PAYLOAD
;
197 static inline void usbatm_pop(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
202 dev_kfree_skb_any(skb
);
210 static struct urb
*usbatm_pop_urb(struct usbatm_channel
*channel
)
214 spin_lock_irq(&channel
->lock
);
215 if (list_empty(&channel
->list
)) {
216 spin_unlock_irq(&channel
->lock
);
220 urb
= list_entry(channel
->list
.next
, struct urb
, urb_list
);
221 list_del(&urb
->urb_list
);
222 spin_unlock_irq(&channel
->lock
);
227 static int usbatm_submit_urb(struct urb
*urb
)
229 struct usbatm_channel
*channel
= urb
->context
;
232 vdbg("%s: submitting urb 0x%p, size %u",
233 __func__
, urb
, urb
->transfer_buffer_length
);
235 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
237 if (printk_ratelimit())
238 atm_warn(channel
->usbatm
, "%s: urb 0x%p submission failed (%d)!\n",
241 /* consider all errors transient and return the buffer back to the queue */
242 urb
->status
= -EAGAIN
;
243 spin_lock_irq(&channel
->lock
);
245 /* must add to the front when sending; doesn't matter when receiving */
246 list_add(&urb
->urb_list
, &channel
->list
);
248 spin_unlock_irq(&channel
->lock
);
250 /* make sure the channel doesn't stall */
251 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
257 static void usbatm_complete(struct urb
*urb
, struct pt_regs
*regs
)
259 struct usbatm_channel
*channel
= urb
->context
;
262 vdbg("%s: urb 0x%p, status %d, actual_length %d",
263 __func__
, urb
, urb
->status
, urb
->actual_length
);
265 /* usually in_interrupt(), but not always */
266 spin_lock_irqsave(&channel
->lock
, flags
);
268 /* must add to the back when receiving; doesn't matter when sending */
269 list_add_tail(&urb
->urb_list
, &channel
->list
);
271 spin_unlock_irqrestore(&channel
->lock
, flags
);
273 if (unlikely(urb
->status
) &&
274 (!(channel
->usbatm
->flags
& UDSL_IGNORE_EILSEQ
) ||
275 urb
->status
!= -EILSEQ
))
277 if (printk_ratelimit())
278 atm_warn(channel
->usbatm
, "%s: urb 0x%p failed (%d)!\n",
279 __func__
, urb
, urb
->status
);
280 /* throttle processing in case of an error */
281 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
283 tasklet_schedule(&channel
->tasklet
);
291 static inline struct usbatm_vcc_data
*usbatm_find_vcc(struct usbatm_data
*instance
,
294 struct usbatm_vcc_data
*vcc_data
;
296 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
297 if ((vcc_data
->vci
== vci
) && (vcc_data
->vpi
== vpi
))
302 static void usbatm_extract_one_cell(struct usbatm_data
*instance
, unsigned char *source
)
305 struct sk_buff
*sarb
;
306 short vpi
= ((source
[0] & 0x0f) << 4) | (source
[1] >> 4);
307 int vci
= ((source
[1] & 0x0f) << 12) | (source
[2] << 4) | (source
[3] >> 4);
308 u8 pti
= ((source
[3] & 0xe) >> 1);
310 vdbg("%s: vpi %hd, vci %d, pti %d", __func__
, vpi
, vci
, pti
);
312 if ((vci
!= instance
->cached_vci
) || (vpi
!= instance
->cached_vpi
)) {
313 instance
->cached_vpi
= vpi
;
314 instance
->cached_vci
= vci
;
316 instance
->cached_vcc
= usbatm_find_vcc(instance
, vpi
, vci
);
318 if (!instance
->cached_vcc
)
319 atm_rldbg(instance
, "%s: unknown vpi/vci (%hd/%d)!\n", __func__
, vpi
, vci
);
322 if (!instance
->cached_vcc
)
325 vcc
= instance
->cached_vcc
->vcc
;
327 /* OAM F5 end-to-end */
328 if (pti
== ATM_PTI_E2EF5
) {
329 if (printk_ratelimit())
330 atm_warn(instance
, "%s: OAM not supported (vpi %d, vci %d)!\n",
332 atomic_inc(&vcc
->stats
->rx_err
);
336 sarb
= instance
->cached_vcc
->sarb
;
338 if (sarb
->tail
+ ATM_CELL_PAYLOAD
> sarb
->end
) {
339 atm_rldbg(instance
, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
340 __func__
, sarb
->len
, vcc
);
341 /* discard cells already received */
343 UDSL_ASSERT(sarb
->tail
+ ATM_CELL_PAYLOAD
<= sarb
->end
);
346 memcpy(sarb
->tail
, source
+ ATM_CELL_HEADER
, ATM_CELL_PAYLOAD
);
347 __skb_put(sarb
, ATM_CELL_PAYLOAD
);
352 unsigned int pdu_length
;
354 length
= (source
[ATM_CELL_SIZE
- 6] << 8) + source
[ATM_CELL_SIZE
- 5];
356 /* guard against overflow */
357 if (length
> ATM_MAX_AAL5_PDU
) {
358 atm_rldbg(instance
, "%s: bogus length %u (vcc: 0x%p)!\n",
359 __func__
, length
, vcc
);
360 atomic_inc(&vcc
->stats
->rx_err
);
364 pdu_length
= usbatm_pdu_length(length
);
366 if (sarb
->len
< pdu_length
) {
367 atm_rldbg(instance
, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
368 __func__
, pdu_length
, sarb
->len
, vcc
);
369 atomic_inc(&vcc
->stats
->rx_err
);
373 if (crc32_be(~0, sarb
->tail
- pdu_length
, pdu_length
) != 0xc704dd7b) {
374 atm_rldbg(instance
, "%s: packet failed crc check (vcc: 0x%p)!\n",
376 atomic_inc(&vcc
->stats
->rx_err
);
380 vdbg("%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", __func__
, length
, pdu_length
, vcc
);
382 if (!(skb
= dev_alloc_skb(length
))) {
383 if (printk_ratelimit())
384 atm_err(instance
, "%s: no memory for skb (length: %u)!\n",
386 atomic_inc(&vcc
->stats
->rx_drop
);
390 vdbg("%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", __func__
, skb
, skb
->truesize
);
392 if (!atm_charge(vcc
, skb
->truesize
)) {
393 atm_rldbg(instance
, "%s: failed atm_charge (skb->truesize: %u)!\n",
394 __func__
, skb
->truesize
);
395 dev_kfree_skb_any(skb
);
396 goto out
; /* atm_charge increments rx_drop */
399 memcpy(skb
->data
, sarb
->tail
- pdu_length
, length
);
400 __skb_put(skb
, length
);
402 vdbg("%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
403 __func__
, skb
, skb
->len
, skb
->truesize
);
405 PACKETDEBUG(skb
->data
, skb
->len
);
409 atomic_inc(&vcc
->stats
->rx
);
415 static void usbatm_extract_cells(struct usbatm_data
*instance
,
416 unsigned char *source
, unsigned int avail_data
)
418 unsigned int stride
= instance
->rx_channel
.stride
;
419 unsigned int buf_usage
= instance
->buf_usage
;
421 /* extract cells from incoming data, taking into account that
422 * the length of avail data may not be a multiple of stride */
425 /* we have a partially received atm cell */
426 unsigned char *cell_buf
= instance
->cell_buf
;
427 unsigned int space_left
= stride
- buf_usage
;
429 UDSL_ASSERT(buf_usage
<= stride
);
431 if (avail_data
>= space_left
) {
432 /* add new data and process cell */
433 memcpy(cell_buf
+ buf_usage
, source
, space_left
);
434 source
+= space_left
;
435 avail_data
-= space_left
;
436 usbatm_extract_one_cell(instance
, cell_buf
);
437 instance
->buf_usage
= 0;
439 /* not enough data to fill the cell */
440 memcpy(cell_buf
+ buf_usage
, source
, avail_data
);
441 instance
->buf_usage
= buf_usage
+ avail_data
;
446 for (; avail_data
>= stride
; avail_data
-= stride
, source
+= stride
)
447 usbatm_extract_one_cell(instance
, source
);
449 if (avail_data
> 0) {
450 /* length was not a multiple of stride -
451 * save remaining data for next call */
452 memcpy(instance
->cell_buf
, source
, avail_data
);
453 instance
->buf_usage
= avail_data
;
462 static unsigned int usbatm_write_cells(struct usbatm_data
*instance
,
464 u8
*target
, unsigned int avail_space
)
466 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
467 struct atm_vcc
*vcc
= ctrl
->atm
.vcc
;
468 unsigned int bytes_written
;
469 unsigned int stride
= instance
->tx_channel
.stride
;
471 vdbg("%s: skb->len=%d, avail_space=%u", __func__
, skb
->len
, avail_space
);
472 UDSL_ASSERT(!(avail_space
% stride
));
474 for (bytes_written
= 0; bytes_written
< avail_space
&& ctrl
->len
;
475 bytes_written
+= stride
, target
+= stride
) {
476 unsigned int data_len
= min_t(unsigned int, skb
->len
, ATM_CELL_PAYLOAD
);
477 unsigned int left
= ATM_CELL_PAYLOAD
- data_len
;
480 ptr
[0] = vcc
->vpi
>> 4;
481 ptr
[1] = (vcc
->vpi
<< 4) | (vcc
->vci
>> 12);
482 ptr
[2] = vcc
->vci
>> 4;
483 ptr
[3] = vcc
->vci
<< 4;
485 ptr
+= ATM_CELL_HEADER
;
487 memcpy(ptr
, skb
->data
, data_len
);
489 __skb_pull(skb
, data_len
);
494 memset(ptr
, 0, left
);
496 if (left
>= ATM_AAL5_TRAILER
) { /* trailer will go in this cell */
497 u8
*trailer
= target
+ ATM_CELL_SIZE
- ATM_AAL5_TRAILER
;
498 /* trailer[0] = 0; UU = 0 */
499 /* trailer[1] = 0; CPI = 0 */
500 trailer
[2] = ctrl
->len
>> 8;
501 trailer
[3] = ctrl
->len
;
503 ctrl
->crc
= ~ crc32_be(ctrl
->crc
, ptr
, left
- 4);
505 trailer
[4] = ctrl
->crc
>> 24;
506 trailer
[5] = ctrl
->crc
>> 16;
507 trailer
[6] = ctrl
->crc
>> 8;
508 trailer
[7] = ctrl
->crc
;
510 target
[3] |= 0x2; /* adjust PTI */
512 ctrl
->len
= 0; /* tag this skb finished */
515 ctrl
->crc
= crc32_be(ctrl
->crc
, ptr
, left
);
518 return bytes_written
;
526 static void usbatm_rx_process(unsigned long data
)
528 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
531 while ((urb
= usbatm_pop_urb(&instance
->rx_channel
))) {
532 vdbg("%s: processing urb 0x%p", __func__
, urb
);
534 if (usb_pipeisoc(urb
->pipe
)) {
535 unsigned char *merge_start
= NULL
;
536 unsigned int merge_length
= 0;
537 const unsigned int packet_size
= instance
->rx_channel
.packet_size
;
540 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
541 if (!urb
->iso_frame_desc
[i
].status
) {
542 unsigned int actual_length
= urb
->iso_frame_desc
[i
].actual_length
;
544 UDSL_ASSERT(actual_length
<= packet_size
);
547 merge_start
= (unsigned char *)urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
548 merge_length
+= actual_length
;
549 if (merge_length
&& (actual_length
< packet_size
)) {
550 usbatm_extract_cells(instance
, merge_start
, merge_length
);
554 atm_rldbg(instance
, "%s: status %d in frame %d!\n", __func__
, urb
->status
, i
);
556 usbatm_extract_cells(instance
, merge_start
, merge_length
);
558 instance
->buf_usage
= 0;
563 usbatm_extract_cells(instance
, merge_start
, merge_length
);
566 usbatm_extract_cells(instance
, urb
->transfer_buffer
, urb
->actual_length
);
568 instance
->buf_usage
= 0;
570 if (usbatm_submit_urb(urb
))
580 static void usbatm_tx_process(unsigned long data
)
582 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
583 struct sk_buff
*skb
= instance
->current_skb
;
584 struct urb
*urb
= NULL
;
585 const unsigned int buf_size
= instance
->tx_channel
.buf_size
;
586 unsigned int bytes_written
= 0;
590 skb
= skb_dequeue(&instance
->sndqueue
);
594 urb
= usbatm_pop_urb(&instance
->tx_channel
);
596 break; /* no more senders */
597 buffer
= urb
->transfer_buffer
;
598 bytes_written
= (urb
->status
== -EAGAIN
) ?
599 urb
->transfer_buffer_length
: 0;
602 bytes_written
+= usbatm_write_cells(instance
, skb
,
603 buffer
+ bytes_written
,
604 buf_size
- bytes_written
);
606 vdbg("%s: wrote %u bytes from skb 0x%p to urb 0x%p",
607 __func__
, bytes_written
, skb
, urb
);
609 if (!UDSL_SKB(skb
)->len
) {
610 struct atm_vcc
*vcc
= UDSL_SKB(skb
)->atm
.vcc
;
612 usbatm_pop(vcc
, skb
);
613 atomic_inc(&vcc
->stats
->tx
);
615 skb
= skb_dequeue(&instance
->sndqueue
);
618 if (bytes_written
== buf_size
|| (!skb
&& bytes_written
)) {
619 urb
->transfer_buffer_length
= bytes_written
;
621 if (usbatm_submit_urb(urb
))
627 instance
->current_skb
= skb
;
630 static void usbatm_cancel_send(struct usbatm_data
*instance
,
633 struct sk_buff
*skb
, *n
;
635 atm_dbg(instance
, "%s entered\n", __func__
);
636 spin_lock_irq(&instance
->sndqueue
.lock
);
637 for (skb
= instance
->sndqueue
.next
, n
= skb
->next
;
638 skb
!= (struct sk_buff
*)&instance
->sndqueue
;
639 skb
= n
, n
= skb
->next
)
640 if (UDSL_SKB(skb
)->atm
.vcc
== vcc
) {
641 atm_dbg(instance
, "%s: popping skb 0x%p\n", __func__
, skb
);
642 __skb_unlink(skb
, &instance
->sndqueue
);
643 usbatm_pop(vcc
, skb
);
645 spin_unlock_irq(&instance
->sndqueue
.lock
);
647 tasklet_disable(&instance
->tx_channel
.tasklet
);
648 if ((skb
= instance
->current_skb
) && (UDSL_SKB(skb
)->atm
.vcc
== vcc
)) {
649 atm_dbg(instance
, "%s: popping current skb (0x%p)\n", __func__
, skb
);
650 instance
->current_skb
= NULL
;
651 usbatm_pop(vcc
, skb
);
653 tasklet_enable(&instance
->tx_channel
.tasklet
);
654 atm_dbg(instance
, "%s done\n", __func__
);
657 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
659 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
660 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
663 vdbg("%s called (skb 0x%p, len %u)", __func__
, skb
, skb
->len
);
665 /* racy disconnection check - fine */
666 if (!instance
|| instance
->disconnected
) {
668 if (printk_ratelimit())
669 printk(KERN_DEBUG
"%s: %s!\n", __func__
, instance
? "disconnected" : "NULL instance");
675 if (vcc
->qos
.aal
!= ATM_AAL5
) {
676 atm_rldbg(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
681 if (skb
->len
> ATM_MAX_AAL5_PDU
) {
682 atm_rldbg(instance
, "%s: packet too long (%d vs %d)!\n",
683 __func__
, skb
->len
, ATM_MAX_AAL5_PDU
);
688 PACKETDEBUG(skb
->data
, skb
->len
);
690 /* initialize the control block */
692 ctrl
->len
= skb
->len
;
693 ctrl
->crc
= crc32_be(~0, skb
->data
, skb
->len
);
695 skb_queue_tail(&instance
->sndqueue
, skb
);
696 tasklet_schedule(&instance
->tx_channel
.tasklet
);
701 usbatm_pop(vcc
, skb
);
706 /********************
708 ********************/
710 static void usbatm_destroy_instance(struct kref
*kref
)
712 struct usbatm_data
*instance
= container_of(kref
, struct usbatm_data
, refcount
);
716 tasklet_kill(&instance
->rx_channel
.tasklet
);
717 tasklet_kill(&instance
->tx_channel
.tasklet
);
718 usb_put_dev(instance
->usb_dev
);
722 static void usbatm_get_instance(struct usbatm_data
*instance
)
726 kref_get(&instance
->refcount
);
729 static void usbatm_put_instance(struct usbatm_data
*instance
)
733 kref_put(&instance
->refcount
, usbatm_destroy_instance
);
741 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
)
743 struct usbatm_data
*instance
= atm_dev
->dev_data
;
750 atm_dev
->dev_data
= NULL
; /* catch bugs */
751 usbatm_put_instance(instance
); /* taken in usbatm_atm_init */
754 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
* pos
, char *page
)
756 struct usbatm_data
*instance
= atm_dev
->dev_data
;
760 dbg("%s: NULL instance!", __func__
);
765 return sprintf(page
, "%s\n", instance
->description
);
768 return sprintf(page
, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
769 atm_dev
->esi
[0], atm_dev
->esi
[1],
770 atm_dev
->esi
[2], atm_dev
->esi
[3],
771 atm_dev
->esi
[4], atm_dev
->esi
[5]);
775 "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
776 atomic_read(&atm_dev
->stats
.aal5
.tx
),
777 atomic_read(&atm_dev
->stats
.aal5
.tx_err
),
778 atomic_read(&atm_dev
->stats
.aal5
.rx
),
779 atomic_read(&atm_dev
->stats
.aal5
.rx_err
),
780 atomic_read(&atm_dev
->stats
.aal5
.rx_drop
));
783 if (instance
->disconnected
)
784 return sprintf(page
, "Disconnected\n");
786 switch (atm_dev
->signal
) {
787 case ATM_PHY_SIG_FOUND
:
788 return sprintf(page
, "Line up\n");
789 case ATM_PHY_SIG_LOST
:
790 return sprintf(page
, "Line down\n");
792 return sprintf(page
, "Line state unknown\n");
799 static int usbatm_atm_open(struct atm_vcc
*vcc
)
801 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
802 struct usbatm_vcc_data
*new = NULL
;
805 short vpi
= vcc
->vpi
;
808 dbg("%s: NULL data!", __func__
);
812 atm_dbg(instance
, "%s: vpi %hd, vci %d\n", __func__
, vpi
, vci
);
814 /* only support AAL5 */
815 if ((vcc
->qos
.aal
!= ATM_AAL5
)) {
816 atm_warn(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
821 if ((vcc
->qos
.rxtp
.max_sdu
< 0) || (vcc
->qos
.rxtp
.max_sdu
> ATM_MAX_AAL5_PDU
)) {
822 atm_dbg(instance
, "%s: max_sdu %d out of range!\n", __func__
, vcc
->qos
.rxtp
.max_sdu
);
826 mutex_lock(&instance
->serialize
); /* vs self, usbatm_atm_close, usbatm_usb_disconnect */
828 if (instance
->disconnected
) {
829 atm_dbg(instance
, "%s: disconnected!\n", __func__
);
834 if (usbatm_find_vcc(instance
, vpi
, vci
)) {
835 atm_dbg(instance
, "%s: %hd/%d already in use!\n", __func__
, vpi
, vci
);
840 if (!(new = kzalloc(sizeof(struct usbatm_vcc_data
), GFP_KERNEL
))) {
841 atm_err(instance
, "%s: no memory for vcc_data!\n", __func__
);
850 new->sarb
= alloc_skb(usbatm_pdu_length(vcc
->qos
.rxtp
.max_sdu
), GFP_KERNEL
);
852 atm_err(instance
, "%s: no memory for SAR buffer!\n", __func__
);
859 tasklet_disable(&instance
->rx_channel
.tasklet
);
860 instance
->cached_vcc
= new;
861 instance
->cached_vpi
= vpi
;
862 instance
->cached_vci
= vci
;
863 list_add(&new->list
, &instance
->vcc_list
);
864 tasklet_enable(&instance
->rx_channel
.tasklet
);
866 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
867 set_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
868 set_bit(ATM_VF_READY
, &vcc
->flags
);
870 mutex_unlock(&instance
->serialize
);
872 atm_dbg(instance
, "%s: allocated vcc data 0x%p\n", __func__
, new);
878 mutex_unlock(&instance
->serialize
);
882 static void usbatm_atm_close(struct atm_vcc
*vcc
)
884 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
885 struct usbatm_vcc_data
*vcc_data
= vcc
->dev_data
;
887 if (!instance
|| !vcc_data
) {
888 dbg("%s: NULL data!", __func__
);
892 atm_dbg(instance
, "%s entered\n", __func__
);
894 atm_dbg(instance
, "%s: deallocating vcc 0x%p with vpi %d vci %d\n",
895 __func__
, vcc_data
, vcc_data
->vpi
, vcc_data
->vci
);
897 usbatm_cancel_send(instance
, vcc
);
899 mutex_lock(&instance
->serialize
); /* vs self, usbatm_atm_open, usbatm_usb_disconnect */
901 tasklet_disable(&instance
->rx_channel
.tasklet
);
902 if (instance
->cached_vcc
== vcc_data
) {
903 instance
->cached_vcc
= NULL
;
904 instance
->cached_vpi
= ATM_VPI_UNSPEC
;
905 instance
->cached_vci
= ATM_VCI_UNSPEC
;
907 list_del(&vcc_data
->list
);
908 tasklet_enable(&instance
->rx_channel
.tasklet
);
910 kfree_skb(vcc_data
->sarb
);
911 vcc_data
->sarb
= NULL
;
914 vcc
->dev_data
= NULL
;
916 vcc
->vpi
= ATM_VPI_UNSPEC
;
917 vcc
->vci
= ATM_VCI_UNSPEC
;
918 clear_bit(ATM_VF_READY
, &vcc
->flags
);
919 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
920 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
922 mutex_unlock(&instance
->serialize
);
924 atm_dbg(instance
, "%s successful\n", __func__
);
927 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
,
930 struct usbatm_data
*instance
= atm_dev
->dev_data
;
932 if (!instance
|| instance
->disconnected
) {
933 dbg("%s: %s!", __func__
, instance
? "disconnected" : "NULL instance");
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
, &usbatm_atm_devops
, -1, NULL
);
956 usb_err(instance
, "%s: failed to register ATM device!\n", __func__
);
960 instance
->atm_dev
= atm_dev
;
962 atm_dev
->ci_range
.vpi_bits
= ATM_CI_MAX
;
963 atm_dev
->ci_range
.vci_bits
= ATM_CI_MAX
;
964 atm_dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
966 /* temp init ATM device, set to 128kbit */
967 atm_dev
->link_rate
= 128 * 1000 / 424;
969 if (instance
->driver
->atm_start
&& ((ret
= instance
->driver
->atm_start(instance
, atm_dev
)) < 0)) {
970 atm_err(instance
, "%s: atm_start failed: %d!\n", __func__
, ret
);
974 usbatm_get_instance(instance
); /* dropped in usbatm_atm_dev_close */
976 /* ready for ATM callbacks */
978 atm_dev
->dev_data
= instance
;
980 /* submit all rx URBs */
981 for (i
= 0; i
< num_rcv_urbs
; i
++)
982 usbatm_submit_urb(instance
->urbs
[i
]);
987 instance
->atm_dev
= NULL
;
988 atm_dev_deregister(atm_dev
); /* usbatm_atm_dev_close will eventually be called */
997 static int usbatm_do_heavy_init(void *arg
)
999 struct usbatm_data
*instance
= arg
;
1002 daemonize(instance
->driver
->driver_name
);
1003 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_pid
= -1;
1014 mutex_unlock(&instance
->serialize
);
1016 complete_and_exit(&instance
->thread_exited
, ret
);
1019 static int usbatm_heavy_init(struct usbatm_data
*instance
)
1021 int ret
= kernel_thread(usbatm_do_heavy_init
, instance
, CLONE_KERNEL
);
1024 usb_err(instance
, "%s: failed to create kernel_thread (%d)!\n", __func__
, ret
);
1028 mutex_lock(&instance
->serialize
);
1029 instance
->thread_pid
= ret
;
1030 mutex_unlock(&instance
->serialize
);
1032 wait_for_completion(&instance
->thread_started
);
1037 static void usbatm_tasklet_schedule(unsigned long data
)
1039 tasklet_schedule((struct tasklet_struct
*) data
);
1042 static inline void usbatm_init_channel(struct usbatm_channel
*channel
)
1044 spin_lock_init(&channel
->lock
);
1045 INIT_LIST_HEAD(&channel
->list
);
1046 channel
->delay
.function
= usbatm_tasklet_schedule
;
1047 channel
->delay
.data
= (unsigned long) &channel
->tasklet
;
1048 init_timer(&channel
->delay
);
1051 int usbatm_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
,
1052 struct usbatm_driver
*driver
)
1054 struct device
*dev
= &intf
->dev
;
1055 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1056 struct usbatm_data
*instance
;
1058 int error
= -ENOMEM
;
1060 unsigned int maxpacket
, num_packets
;
1062 dev_dbg(dev
, "%s: trying driver %s with vendor=%04x, product=%04x, ifnum %2d\n",
1063 __func__
, driver
->driver_name
,
1064 le16_to_cpu(usb_dev
->descriptor
.idVendor
),
1065 le16_to_cpu(usb_dev
->descriptor
.idProduct
),
1066 intf
->altsetting
->desc
.bInterfaceNumber
);
1069 instance
= kzalloc(sizeof(*instance
) + sizeof(struct urb
*) * (num_rcv_urbs
+ num_snd_urbs
), GFP_KERNEL
);
1071 dev_err(dev
, "%s: no memory for instance data!\n", __func__
);
1077 instance
->driver
= driver
;
1078 snprintf(instance
->driver_name
, sizeof(instance
->driver_name
), driver
->driver_name
);
1080 instance
->usb_dev
= usb_dev
;
1081 instance
->usb_intf
= intf
;
1083 buf
= instance
->description
;
1084 length
= sizeof(instance
->description
);
1086 if ((i
= usb_string(usb_dev
, usb_dev
->descriptor
.iProduct
, buf
, length
)) < 0)
1092 i
= scnprintf(buf
, length
, " (");
1096 if (length
<= 0 || (i
= usb_make_path(usb_dev
, buf
, length
)) < 0)
1102 snprintf(buf
, length
, ")");
1105 if (driver
->bind
&& (error
= driver
->bind(instance
, intf
, id
)) < 0) {
1106 dev_err(dev
, "%s: bind failed: %d!\n", __func__
, error
);
1110 /* private fields */
1112 kref_init(&instance
->refcount
); /* dropped in usbatm_usb_disconnect */
1113 mutex_init(&instance
->serialize
);
1115 instance
->thread_pid
= -1;
1116 init_completion(&instance
->thread_started
);
1117 init_completion(&instance
->thread_exited
);
1119 INIT_LIST_HEAD(&instance
->vcc_list
);
1120 skb_queue_head_init(&instance
->sndqueue
);
1122 usbatm_init_channel(&instance
->rx_channel
);
1123 usbatm_init_channel(&instance
->tx_channel
);
1124 tasklet_init(&instance
->rx_channel
.tasklet
, usbatm_rx_process
, (unsigned long)instance
);
1125 tasklet_init(&instance
->tx_channel
.tasklet
, usbatm_tx_process
, (unsigned long)instance
);
1126 instance
->rx_channel
.stride
= ATM_CELL_SIZE
+ driver
->rx_padding
;
1127 instance
->tx_channel
.stride
= ATM_CELL_SIZE
+ driver
->tx_padding
;
1128 instance
->rx_channel
.usbatm
= instance
->tx_channel
.usbatm
= instance
;
1130 if ((instance
->flags
& UDSL_USE_ISOC
) && driver
->isoc_in
)
1131 instance
->rx_channel
.endpoint
= usb_rcvisocpipe(usb_dev
, driver
->isoc_in
);
1133 instance
->rx_channel
.endpoint
= usb_rcvbulkpipe(usb_dev
, driver
->bulk_in
);
1135 instance
->tx_channel
.endpoint
= usb_sndbulkpipe(usb_dev
, driver
->bulk_out
);
1137 /* tx buffer size must be a positive multiple of the stride */
1138 instance
->tx_channel
.buf_size
= max (instance
->tx_channel
.stride
,
1139 snd_buf_bytes
- (snd_buf_bytes
% instance
->tx_channel
.stride
));
1141 /* rx buffer size must be a positive multiple of the endpoint maxpacket */
1142 maxpacket
= usb_maxpacket(usb_dev
, instance
->rx_channel
.endpoint
, 0);
1144 if ((maxpacket
< 1) || (maxpacket
> UDSL_MAX_BUF_SIZE
)) {
1145 dev_err(dev
, "%s: invalid endpoint %02x!\n", __func__
,
1146 usb_pipeendpoint(instance
->rx_channel
.endpoint
));
1151 num_packets
= max (1U, (rcv_buf_bytes
+ maxpacket
/ 2) / maxpacket
); /* round */
1153 if (num_packets
* maxpacket
> UDSL_MAX_BUF_SIZE
)
1156 instance
->rx_channel
.buf_size
= num_packets
* maxpacket
;
1157 instance
->rx_channel
.packet_size
= maxpacket
;
1160 for (i
= 0; i
< 2; i
++) {
1161 struct usbatm_channel
*channel
= i
?
1162 &instance
->tx_channel
: &instance
->rx_channel
;
1164 dev_dbg(dev
, "%s: using %d byte buffer for %s channel 0x%p\n", __func__
, channel
->buf_size
, i
? "tx" : "rx", channel
);
1168 /* initialize urbs */
1170 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1172 struct usbatm_channel
*channel
= i
< num_rcv_urbs
?
1173 &instance
->rx_channel
: &instance
->tx_channel
;
1175 unsigned int iso_packets
= usb_pipeisoc(channel
->endpoint
) ? channel
->buf_size
/ channel
->packet_size
: 0;
1177 UDSL_ASSERT(!usb_pipeisoc(channel
->endpoint
) || usb_pipein(channel
->endpoint
));
1179 urb
= usb_alloc_urb(iso_packets
, GFP_KERNEL
);
1181 dev_err(dev
, "%s: no memory for urb %d!\n", __func__
, i
);
1186 instance
->urbs
[i
] = urb
;
1188 /* zero the tx padding to avoid leaking information */
1189 buffer
= kzalloc(channel
->buf_size
, GFP_KERNEL
);
1191 dev_err(dev
, "%s: no memory for buffer %d!\n", __func__
, i
);
1196 usb_fill_bulk_urb(urb
, instance
->usb_dev
, channel
->endpoint
,
1197 buffer
, channel
->buf_size
, usbatm_complete
, channel
);
1201 urb
->transfer_flags
= URB_ISO_ASAP
;
1202 urb
->number_of_packets
= iso_packets
;
1203 for (j
= 0; j
< iso_packets
; j
++) {
1204 urb
->iso_frame_desc
[j
].offset
= channel
->packet_size
* j
;
1205 urb
->iso_frame_desc
[j
].length
= channel
->packet_size
;
1209 /* put all tx URBs on the list of spares */
1210 if (i
>= num_rcv_urbs
)
1211 list_add_tail(&urb
->urb_list
, &channel
->list
);
1213 vdbg("%s: alloced buffer 0x%p buf size %u urb 0x%p",
1214 __func__
, urb
->transfer_buffer
, urb
->transfer_buffer_length
, urb
);
1217 instance
->cached_vpi
= ATM_VPI_UNSPEC
;
1218 instance
->cached_vci
= ATM_VCI_UNSPEC
;
1219 instance
->cell_buf
= kmalloc(instance
->rx_channel
.stride
, GFP_KERNEL
);
1221 if (!instance
->cell_buf
) {
1222 dev_err(dev
, "%s: no memory for cell buffer!\n", __func__
);
1227 if (!(instance
->flags
& UDSL_SKIP_HEAVY_INIT
) && driver
->heavy_init
) {
1228 error
= usbatm_heavy_init(instance
);
1230 complete(&instance
->thread_exited
); /* pretend that heavy_init was run */
1231 error
= usbatm_atm_init(instance
);
1237 usb_get_dev(usb_dev
);
1238 usb_set_intfdata(intf
, instance
);
1243 if (instance
->driver
->unbind
)
1244 instance
->driver
->unbind(instance
, intf
);
1246 kfree(instance
->cell_buf
);
1248 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1249 if (instance
->urbs
[i
])
1250 kfree(instance
->urbs
[i
]->transfer_buffer
);
1251 usb_free_urb(instance
->urbs
[i
]);
1258 EXPORT_SYMBOL_GPL(usbatm_usb_probe
);
1260 void usbatm_usb_disconnect(struct usb_interface
*intf
)
1262 struct device
*dev
= &intf
->dev
;
1263 struct usbatm_data
*instance
= usb_get_intfdata(intf
);
1264 struct usbatm_vcc_data
*vcc_data
;
1267 dev_dbg(dev
, "%s entered\n", __func__
);
1270 dev_dbg(dev
, "%s: NULL instance!\n", __func__
);
1274 usb_set_intfdata(intf
, NULL
);
1276 mutex_lock(&instance
->serialize
);
1277 instance
->disconnected
= 1;
1278 if (instance
->thread_pid
>= 0)
1279 kill_proc(instance
->thread_pid
, SIGTERM
, 1);
1280 mutex_unlock(&instance
->serialize
);
1282 wait_for_completion(&instance
->thread_exited
);
1284 mutex_lock(&instance
->serialize
);
1285 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
1286 vcc_release_async(vcc_data
->vcc
, -EPIPE
);
1287 mutex_unlock(&instance
->serialize
);
1289 tasklet_disable(&instance
->rx_channel
.tasklet
);
1290 tasklet_disable(&instance
->tx_channel
.tasklet
);
1292 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++)
1293 usb_kill_urb(instance
->urbs
[i
]);
1295 del_timer_sync(&instance
->rx_channel
.delay
);
1296 del_timer_sync(&instance
->tx_channel
.delay
);
1298 /* turn usbatm_[rt]x_process into something close to a no-op */
1299 /* no need to take the spinlock */
1300 INIT_LIST_HEAD(&instance
->rx_channel
.list
);
1301 INIT_LIST_HEAD(&instance
->tx_channel
.list
);
1303 tasklet_enable(&instance
->rx_channel
.tasklet
);
1304 tasklet_enable(&instance
->tx_channel
.tasklet
);
1306 if (instance
->atm_dev
&& instance
->driver
->atm_stop
)
1307 instance
->driver
->atm_stop(instance
, instance
->atm_dev
);
1309 if (instance
->driver
->unbind
)
1310 instance
->driver
->unbind(instance
, intf
);
1312 instance
->driver_data
= NULL
;
1314 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1315 kfree(instance
->urbs
[i
]->transfer_buffer
);
1316 usb_free_urb(instance
->urbs
[i
]);
1319 kfree(instance
->cell_buf
);
1322 if (instance
->atm_dev
)
1323 atm_dev_deregister(instance
->atm_dev
);
1325 usbatm_put_instance(instance
); /* taken in usbatm_usb_probe */
1327 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect
);
1334 static int __init
usbatm_usb_init(void)
1336 dbg("%s: driver version %s", __func__
, DRIVER_VERSION
);
1338 if (sizeof(struct usbatm_control
) > sizeof(((struct sk_buff
*) 0)->cb
)) {
1339 printk(KERN_ERR
"%s unusable with this kernel!\n", usbatm_driver_name
);
1343 if ((num_rcv_urbs
> UDSL_MAX_RCV_URBS
)
1344 || (num_snd_urbs
> UDSL_MAX_SND_URBS
)
1345 || (rcv_buf_bytes
< 1)
1346 || (rcv_buf_bytes
> UDSL_MAX_BUF_SIZE
)
1347 || (snd_buf_bytes
< 1)
1348 || (snd_buf_bytes
> UDSL_MAX_BUF_SIZE
))
1353 module_init(usbatm_usb_init
);
1355 static void __exit
usbatm_usb_exit(void)
1357 dbg("%s", __func__
);
1359 module_exit(usbatm_usb_exit
);
1361 MODULE_AUTHOR(DRIVER_AUTHOR
);
1362 MODULE_DESCRIPTION(DRIVER_DESC
);
1363 MODULE_LICENSE("GPL");
1364 MODULE_VERSION(DRIVER_VERSION
);
1370 #ifdef VERBOSE_DEBUG
1371 static int usbatm_print_packet(const unsigned char *data
, int len
)
1373 unsigned char buffer
[256];
1376 for (i
= 0; i
< len
;) {
1378 sprintf(buffer
, "%.3d :", i
);
1379 for (j
= 0; (j
< 16) && (i
< len
); j
++, i
++) {
1380 sprintf(buffer
, "%s %2.2x", buffer
, data
[i
]);