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.9"
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 64 * 1024 /* bytes */
103 #define UDSL_DEFAULT_RCV_URBS 4
104 #define UDSL_DEFAULT_SND_URBS 4
105 #define UDSL_DEFAULT_RCV_BUF_SIZE 64 * ATM_CELL_SIZE /* bytes */
106 #define UDSL_DEFAULT_SND_BUF_SIZE 64 * ATM_CELL_SIZE /* bytes */
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_SND_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 if (printk_ratelimit())
275 atm_warn(channel
->usbatm
, "%s: urb 0x%p failed (%d)!\n",
276 __func__
, urb
, urb
->status
);
277 /* throttle processing in case of an error */
278 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
280 tasklet_schedule(&channel
->tasklet
);
288 static inline struct usbatm_vcc_data
*usbatm_find_vcc(struct usbatm_data
*instance
,
291 struct usbatm_vcc_data
*vcc_data
;
293 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
294 if ((vcc_data
->vci
== vci
) && (vcc_data
->vpi
== vpi
))
299 static void usbatm_extract_cells(struct usbatm_data
*instance
,
300 unsigned char *source
, unsigned int avail_data
)
302 struct usbatm_vcc_data
*cached_vcc
= NULL
;
304 struct sk_buff
*sarb
;
305 unsigned int stride
= instance
->rx_channel
.stride
;
306 int vci
, cached_vci
= 0;
307 short vpi
, cached_vpi
= 0;
310 for (; avail_data
>= stride
; avail_data
-= stride
, source
+= stride
) {
311 vpi
= ((source
[0] & 0x0f) << 4) | (source
[1] >> 4);
312 vci
= ((source
[1] & 0x0f) << 12) | (source
[2] << 4) | (source
[3] >> 4);
313 pti
= ((source
[3] & 0xe) >> 1);
315 vdbg("%s: vpi %hd, vci %d, pti %d", __func__
, vpi
, vci
, pti
);
317 if ((vci
!= cached_vci
) || (vpi
!= cached_vpi
)) {
321 cached_vcc
= usbatm_find_vcc(instance
, vpi
, vci
);
324 atm_rldbg(instance
, "%s: unknown vpi/vci (%hd/%d)!\n", __func__
, vpi
, vci
);
330 vcc
= cached_vcc
->vcc
;
332 /* OAM F5 end-to-end */
333 if (pti
== ATM_PTI_E2EF5
) {
334 if (printk_ratelimit())
335 atm_warn(instance
, "%s: OAM not supported (vpi %d, vci %d)!\n",
337 atomic_inc(&vcc
->stats
->rx_err
);
341 sarb
= cached_vcc
->sarb
;
343 if (sarb
->tail
+ ATM_CELL_PAYLOAD
> sarb
->end
) {
344 atm_rldbg(instance
, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
345 __func__
, sarb
->len
, vcc
);
346 /* discard cells already received */
348 UDSL_ASSERT(sarb
->tail
+ ATM_CELL_PAYLOAD
<= sarb
->end
);
351 memcpy(sarb
->tail
, source
+ ATM_CELL_HEADER
, ATM_CELL_PAYLOAD
);
352 __skb_put(sarb
, ATM_CELL_PAYLOAD
);
357 unsigned int pdu_length
;
359 length
= (source
[ATM_CELL_SIZE
- 6] << 8) + source
[ATM_CELL_SIZE
- 5];
361 /* guard against overflow */
362 if (length
> ATM_MAX_AAL5_PDU
) {
363 atm_rldbg(instance
, "%s: bogus length %u (vcc: 0x%p)!\n",
364 __func__
, length
, vcc
);
365 atomic_inc(&vcc
->stats
->rx_err
);
369 pdu_length
= usbatm_pdu_length(length
);
371 if (sarb
->len
< pdu_length
) {
372 atm_rldbg(instance
, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
373 __func__
, pdu_length
, sarb
->len
, vcc
);
374 atomic_inc(&vcc
->stats
->rx_err
);
378 if (crc32_be(~0, sarb
->tail
- pdu_length
, pdu_length
) != 0xc704dd7b) {
379 atm_rldbg(instance
, "%s: packet failed crc check (vcc: 0x%p)!\n",
381 atomic_inc(&vcc
->stats
->rx_err
);
385 vdbg("%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", __func__
, length
, pdu_length
, vcc
);
387 if (!(skb
= dev_alloc_skb(length
))) {
388 if (printk_ratelimit())
389 atm_err(instance
, "%s: no memory for skb (length: %u)!\n",
391 atomic_inc(&vcc
->stats
->rx_drop
);
395 vdbg("%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", __func__
, skb
, skb
->truesize
);
397 if (!atm_charge(vcc
, skb
->truesize
)) {
398 atm_rldbg(instance
, "%s: failed atm_charge (skb->truesize: %u)!\n",
399 __func__
, skb
->truesize
);
400 dev_kfree_skb_any(skb
);
401 goto out
; /* atm_charge increments rx_drop */
404 memcpy(skb
->data
, sarb
->tail
- pdu_length
, length
);
405 __skb_put(skb
, length
);
407 vdbg("%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
408 __func__
, skb
, skb
->len
, skb
->truesize
);
410 PACKETDEBUG(skb
->data
, skb
->len
);
414 atomic_inc(&vcc
->stats
->rx
);
426 static unsigned int usbatm_write_cells(struct usbatm_data
*instance
,
428 u8
*target
, unsigned int avail_space
)
430 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
431 struct atm_vcc
*vcc
= ctrl
->atm
.vcc
;
432 unsigned int bytes_written
;
433 unsigned int stride
= instance
->tx_channel
.stride
;
435 vdbg("%s: skb->len=%d, avail_space=%u", __func__
, skb
->len
, avail_space
);
436 UDSL_ASSERT(!(avail_space
% stride
));
438 for (bytes_written
= 0; bytes_written
< avail_space
&& ctrl
->len
;
439 bytes_written
+= stride
, target
+= stride
) {
440 unsigned int data_len
= min_t(unsigned int, skb
->len
, ATM_CELL_PAYLOAD
);
441 unsigned int left
= ATM_CELL_PAYLOAD
- data_len
;
444 ptr
[0] = vcc
->vpi
>> 4;
445 ptr
[1] = (vcc
->vpi
<< 4) | (vcc
->vci
>> 12);
446 ptr
[2] = vcc
->vci
>> 4;
447 ptr
[3] = vcc
->vci
<< 4;
449 ptr
+= ATM_CELL_HEADER
;
451 memcpy(ptr
, skb
->data
, data_len
);
453 __skb_pull(skb
, data_len
);
458 memset(ptr
, 0, left
);
460 if (left
>= ATM_AAL5_TRAILER
) { /* trailer will go in this cell */
461 u8
*trailer
= target
+ ATM_CELL_SIZE
- ATM_AAL5_TRAILER
;
462 /* trailer[0] = 0; UU = 0 */
463 /* trailer[1] = 0; CPI = 0 */
464 trailer
[2] = ctrl
->len
>> 8;
465 trailer
[3] = ctrl
->len
;
467 ctrl
->crc
= ~ crc32_be(ctrl
->crc
, ptr
, left
- 4);
469 trailer
[4] = ctrl
->crc
>> 24;
470 trailer
[5] = ctrl
->crc
>> 16;
471 trailer
[6] = ctrl
->crc
>> 8;
472 trailer
[7] = ctrl
->crc
;
474 target
[3] |= 0x2; /* adjust PTI */
476 ctrl
->len
= 0; /* tag this skb finished */
479 ctrl
->crc
= crc32_be(ctrl
->crc
, ptr
, left
);
482 return bytes_written
;
490 static void usbatm_rx_process(unsigned long data
)
492 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
495 while ((urb
= usbatm_pop_urb(&instance
->rx_channel
))) {
496 vdbg("%s: processing urb 0x%p", __func__
, urb
);
498 if (usb_pipeisoc(urb
->pipe
)) {
500 for (i
= 0; i
< urb
->number_of_packets
; i
++)
501 if (!urb
->iso_frame_desc
[i
].status
)
502 usbatm_extract_cells(instance
,
503 (u8
*)urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
,
504 urb
->iso_frame_desc
[i
].actual_length
);
508 usbatm_extract_cells(instance
, urb
->transfer_buffer
, urb
->actual_length
);
510 if (usbatm_submit_urb(urb
))
520 static void usbatm_tx_process(unsigned long data
)
522 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
523 struct sk_buff
*skb
= instance
->current_skb
;
524 struct urb
*urb
= NULL
;
525 const unsigned int buf_size
= instance
->tx_channel
.buf_size
;
526 unsigned int bytes_written
= 0;
530 skb
= skb_dequeue(&instance
->sndqueue
);
534 urb
= usbatm_pop_urb(&instance
->tx_channel
);
536 break; /* no more senders */
537 buffer
= urb
->transfer_buffer
;
538 bytes_written
= (urb
->status
== -EAGAIN
) ?
539 urb
->transfer_buffer_length
: 0;
542 bytes_written
+= usbatm_write_cells(instance
, skb
,
543 buffer
+ bytes_written
,
544 buf_size
- bytes_written
);
546 vdbg("%s: wrote %u bytes from skb 0x%p to urb 0x%p",
547 __func__
, bytes_written
, skb
, urb
);
549 if (!UDSL_SKB(skb
)->len
) {
550 struct atm_vcc
*vcc
= UDSL_SKB(skb
)->atm
.vcc
;
552 usbatm_pop(vcc
, skb
);
553 atomic_inc(&vcc
->stats
->tx
);
555 skb
= skb_dequeue(&instance
->sndqueue
);
558 if (bytes_written
== buf_size
|| (!skb
&& bytes_written
)) {
559 urb
->transfer_buffer_length
= bytes_written
;
561 if (usbatm_submit_urb(urb
))
567 instance
->current_skb
= skb
;
570 static void usbatm_cancel_send(struct usbatm_data
*instance
,
573 struct sk_buff
*skb
, *n
;
575 atm_dbg(instance
, "%s entered\n", __func__
);
576 spin_lock_irq(&instance
->sndqueue
.lock
);
577 for (skb
= instance
->sndqueue
.next
, n
= skb
->next
;
578 skb
!= (struct sk_buff
*)&instance
->sndqueue
;
579 skb
= n
, n
= skb
->next
)
580 if (UDSL_SKB(skb
)->atm
.vcc
== vcc
) {
581 atm_dbg(instance
, "%s: popping skb 0x%p\n", __func__
, skb
);
582 __skb_unlink(skb
, &instance
->sndqueue
);
583 usbatm_pop(vcc
, skb
);
585 spin_unlock_irq(&instance
->sndqueue
.lock
);
587 tasklet_disable(&instance
->tx_channel
.tasklet
);
588 if ((skb
= instance
->current_skb
) && (UDSL_SKB(skb
)->atm
.vcc
== vcc
)) {
589 atm_dbg(instance
, "%s: popping current skb (0x%p)\n", __func__
, skb
);
590 instance
->current_skb
= NULL
;
591 usbatm_pop(vcc
, skb
);
593 tasklet_enable(&instance
->tx_channel
.tasklet
);
594 atm_dbg(instance
, "%s done\n", __func__
);
597 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
599 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
600 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
603 vdbg("%s called (skb 0x%p, len %u)", __func__
, skb
, skb
->len
);
605 /* racy disconnection check - fine */
606 if (!instance
|| instance
->disconnected
) {
608 if (printk_ratelimit())
609 printk(KERN_DEBUG
"%s: %s!\n", __func__
, instance
? "disconnected" : "NULL instance");
615 if (vcc
->qos
.aal
!= ATM_AAL5
) {
616 atm_rldbg(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
621 if (skb
->len
> ATM_MAX_AAL5_PDU
) {
622 atm_rldbg(instance
, "%s: packet too long (%d vs %d)!\n",
623 __func__
, skb
->len
, ATM_MAX_AAL5_PDU
);
628 PACKETDEBUG(skb
->data
, skb
->len
);
630 /* initialize the control block */
632 ctrl
->len
= skb
->len
;
633 ctrl
->crc
= crc32_be(~0, skb
->data
, skb
->len
);
635 skb_queue_tail(&instance
->sndqueue
, skb
);
636 tasklet_schedule(&instance
->tx_channel
.tasklet
);
641 usbatm_pop(vcc
, skb
);
646 /********************
648 ********************/
650 static void usbatm_destroy_instance(struct kref
*kref
)
652 struct usbatm_data
*instance
= container_of(kref
, struct usbatm_data
, refcount
);
656 tasklet_kill(&instance
->rx_channel
.tasklet
);
657 tasklet_kill(&instance
->tx_channel
.tasklet
);
658 usb_put_dev(instance
->usb_dev
);
662 static void usbatm_get_instance(struct usbatm_data
*instance
)
666 kref_get(&instance
->refcount
);
669 static void usbatm_put_instance(struct usbatm_data
*instance
)
673 kref_put(&instance
->refcount
, usbatm_destroy_instance
);
681 static void usbatm_atm_dev_close(struct atm_dev
*atm_dev
)
683 struct usbatm_data
*instance
= atm_dev
->dev_data
;
690 atm_dev
->dev_data
= NULL
; /* catch bugs */
691 usbatm_put_instance(instance
); /* taken in usbatm_atm_init */
694 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
* pos
, char *page
)
696 struct usbatm_data
*instance
= atm_dev
->dev_data
;
700 dbg("%s: NULL instance!", __func__
);
705 return sprintf(page
, "%s\n", instance
->description
);
708 return sprintf(page
, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
709 atm_dev
->esi
[0], atm_dev
->esi
[1],
710 atm_dev
->esi
[2], atm_dev
->esi
[3],
711 atm_dev
->esi
[4], atm_dev
->esi
[5]);
715 "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
716 atomic_read(&atm_dev
->stats
.aal5
.tx
),
717 atomic_read(&atm_dev
->stats
.aal5
.tx_err
),
718 atomic_read(&atm_dev
->stats
.aal5
.rx
),
719 atomic_read(&atm_dev
->stats
.aal5
.rx_err
),
720 atomic_read(&atm_dev
->stats
.aal5
.rx_drop
));
723 if (instance
->disconnected
)
724 return sprintf(page
, "Disconnected\n");
726 switch (atm_dev
->signal
) {
727 case ATM_PHY_SIG_FOUND
:
728 return sprintf(page
, "Line up\n");
729 case ATM_PHY_SIG_LOST
:
730 return sprintf(page
, "Line down\n");
732 return sprintf(page
, "Line state unknown\n");
739 static int usbatm_atm_open(struct atm_vcc
*vcc
)
741 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
742 struct usbatm_vcc_data
*new = NULL
;
745 short vpi
= vcc
->vpi
;
748 dbg("%s: NULL data!", __func__
);
752 atm_dbg(instance
, "%s: vpi %hd, vci %d\n", __func__
, vpi
, vci
);
754 /* only support AAL5 */
755 if ((vcc
->qos
.aal
!= ATM_AAL5
)) {
756 atm_warn(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
761 if ((vcc
->qos
.rxtp
.max_sdu
< 0) || (vcc
->qos
.rxtp
.max_sdu
> ATM_MAX_AAL5_PDU
)) {
762 atm_dbg(instance
, "%s: max_sdu %d out of range!\n", __func__
, vcc
->qos
.rxtp
.max_sdu
);
766 down(&instance
->serialize
); /* vs self, usbatm_atm_close, usbatm_usb_disconnect */
768 if (instance
->disconnected
) {
769 atm_dbg(instance
, "%s: disconnected!\n", __func__
);
774 if (usbatm_find_vcc(instance
, vpi
, vci
)) {
775 atm_dbg(instance
, "%s: %hd/%d already in use!\n", __func__
, vpi
, vci
);
780 if (!(new = kzalloc(sizeof(struct usbatm_vcc_data
), GFP_KERNEL
))) {
781 atm_err(instance
, "%s: no memory for vcc_data!\n", __func__
);
790 new->sarb
= alloc_skb(usbatm_pdu_length(vcc
->qos
.rxtp
.max_sdu
), GFP_KERNEL
);
792 atm_err(instance
, "%s: no memory for SAR buffer!\n", __func__
);
799 tasklet_disable(&instance
->rx_channel
.tasklet
);
800 list_add(&new->list
, &instance
->vcc_list
);
801 tasklet_enable(&instance
->rx_channel
.tasklet
);
803 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
804 set_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
805 set_bit(ATM_VF_READY
, &vcc
->flags
);
807 up(&instance
->serialize
);
809 atm_dbg(instance
, "%s: allocated vcc data 0x%p\n", __func__
, new);
815 up(&instance
->serialize
);
819 static void usbatm_atm_close(struct atm_vcc
*vcc
)
821 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
822 struct usbatm_vcc_data
*vcc_data
= vcc
->dev_data
;
824 if (!instance
|| !vcc_data
) {
825 dbg("%s: NULL data!", __func__
);
829 atm_dbg(instance
, "%s entered\n", __func__
);
831 atm_dbg(instance
, "%s: deallocating vcc 0x%p with vpi %d vci %d\n",
832 __func__
, vcc_data
, vcc_data
->vpi
, vcc_data
->vci
);
834 usbatm_cancel_send(instance
, vcc
);
836 down(&instance
->serialize
); /* vs self, usbatm_atm_open, usbatm_usb_disconnect */
838 tasklet_disable(&instance
->rx_channel
.tasklet
);
839 list_del(&vcc_data
->list
);
840 tasklet_enable(&instance
->rx_channel
.tasklet
);
842 kfree_skb(vcc_data
->sarb
);
843 vcc_data
->sarb
= NULL
;
846 vcc
->dev_data
= NULL
;
848 vcc
->vpi
= ATM_VPI_UNSPEC
;
849 vcc
->vci
= ATM_VCI_UNSPEC
;
850 clear_bit(ATM_VF_READY
, &vcc
->flags
);
851 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
852 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
854 up(&instance
->serialize
);
856 atm_dbg(instance
, "%s successful\n", __func__
);
859 static int usbatm_atm_ioctl(struct atm_dev
*atm_dev
, unsigned int cmd
,
862 struct usbatm_data
*instance
= atm_dev
->dev_data
;
864 if (!instance
|| instance
->disconnected
) {
865 dbg("%s: %s!", __func__
, instance
? "disconnected" : "NULL instance");
871 return put_user(ATM_LM_NONE
, (int __user
*)arg
) ? -EFAULT
: 0;
877 static int usbatm_atm_init(struct usbatm_data
*instance
)
879 struct atm_dev
*atm_dev
;
882 /* ATM init. The ATM initialization scheme suffers from an intrinsic race
883 * condition: callbacks we register can be executed at once, before we have
884 * initialized the struct atm_dev. To protect against this, all callbacks
885 * abort if atm_dev->dev_data is NULL. */
886 atm_dev
= atm_dev_register(instance
->driver_name
, &usbatm_atm_devops
, -1, NULL
);
888 usb_err(instance
, "%s: failed to register ATM device!\n", __func__
);
892 instance
->atm_dev
= atm_dev
;
894 atm_dev
->ci_range
.vpi_bits
= ATM_CI_MAX
;
895 atm_dev
->ci_range
.vci_bits
= ATM_CI_MAX
;
896 atm_dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
898 /* temp init ATM device, set to 128kbit */
899 atm_dev
->link_rate
= 128 * 1000 / 424;
901 if (instance
->driver
->atm_start
&& ((ret
= instance
->driver
->atm_start(instance
, atm_dev
)) < 0)) {
902 atm_err(instance
, "%s: atm_start failed: %d!\n", __func__
, ret
);
906 usbatm_get_instance(instance
); /* dropped in usbatm_atm_dev_close */
908 /* ready for ATM callbacks */
910 atm_dev
->dev_data
= instance
;
912 /* submit all rx URBs */
913 for (i
= 0; i
< num_rcv_urbs
; i
++)
914 usbatm_submit_urb(instance
->urbs
[i
]);
919 instance
->atm_dev
= NULL
;
920 atm_dev_deregister(atm_dev
); /* usbatm_atm_dev_close will eventually be called */
929 static int usbatm_do_heavy_init(void *arg
)
931 struct usbatm_data
*instance
= arg
;
934 daemonize(instance
->driver
->driver_name
);
935 allow_signal(SIGTERM
);
937 complete(&instance
->thread_started
);
939 ret
= instance
->driver
->heavy_init(instance
, instance
->usb_intf
);
942 ret
= usbatm_atm_init(instance
);
944 down(&instance
->serialize
);
945 instance
->thread_pid
= -1;
946 up(&instance
->serialize
);
948 complete_and_exit(&instance
->thread_exited
, ret
);
951 static int usbatm_heavy_init(struct usbatm_data
*instance
)
953 int ret
= kernel_thread(usbatm_do_heavy_init
, instance
, CLONE_KERNEL
);
956 usb_err(instance
, "%s: failed to create kernel_thread (%d)!\n", __func__
, ret
);
960 down(&instance
->serialize
);
961 instance
->thread_pid
= ret
;
962 up(&instance
->serialize
);
964 wait_for_completion(&instance
->thread_started
);
969 static void usbatm_tasklet_schedule(unsigned long data
)
971 tasklet_schedule((struct tasklet_struct
*) data
);
974 static inline void usbatm_init_channel(struct usbatm_channel
*channel
)
976 spin_lock_init(&channel
->lock
);
977 INIT_LIST_HEAD(&channel
->list
);
978 channel
->delay
.function
= usbatm_tasklet_schedule
;
979 channel
->delay
.data
= (unsigned long) &channel
->tasklet
;
980 init_timer(&channel
->delay
);
983 int usbatm_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
,
984 struct usbatm_driver
*driver
)
986 struct device
*dev
= &intf
->dev
;
987 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
988 struct usbatm_data
*instance
;
992 unsigned int maxpacket
, num_packets
;
994 dev_dbg(dev
, "%s: trying driver %s with vendor=%04x, product=%04x, ifnum %2d\n",
995 __func__
, driver
->driver_name
,
996 le16_to_cpu(usb_dev
->descriptor
.idVendor
),
997 le16_to_cpu(usb_dev
->descriptor
.idProduct
),
998 intf
->altsetting
->desc
.bInterfaceNumber
);
1001 instance
= kzalloc(sizeof(*instance
) + sizeof(struct urb
*) * (num_rcv_urbs
+ num_snd_urbs
), GFP_KERNEL
);
1003 dev_err(dev
, "%s: no memory for instance data!\n", __func__
);
1009 instance
->driver
= driver
;
1010 snprintf(instance
->driver_name
, sizeof(instance
->driver_name
), driver
->driver_name
);
1012 instance
->usb_dev
= usb_dev
;
1013 instance
->usb_intf
= intf
;
1015 buf
= instance
->description
;
1016 length
= sizeof(instance
->description
);
1018 if ((i
= usb_string(usb_dev
, usb_dev
->descriptor
.iProduct
, buf
, length
)) < 0)
1024 i
= scnprintf(buf
, length
, " (");
1028 if (length
<= 0 || (i
= usb_make_path(usb_dev
, buf
, length
)) < 0)
1034 snprintf(buf
, length
, ")");
1037 if (driver
->bind
&& (error
= driver
->bind(instance
, intf
, id
)) < 0) {
1038 dev_err(dev
, "%s: bind failed: %d!\n", __func__
, error
);
1042 /* private fields */
1044 kref_init(&instance
->refcount
); /* dropped in usbatm_usb_disconnect */
1045 init_MUTEX(&instance
->serialize
);
1047 instance
->thread_pid
= -1;
1048 init_completion(&instance
->thread_started
);
1049 init_completion(&instance
->thread_exited
);
1051 INIT_LIST_HEAD(&instance
->vcc_list
);
1052 skb_queue_head_init(&instance
->sndqueue
);
1054 usbatm_init_channel(&instance
->rx_channel
);
1055 usbatm_init_channel(&instance
->tx_channel
);
1056 tasklet_init(&instance
->rx_channel
.tasklet
, usbatm_rx_process
, (unsigned long)instance
);
1057 tasklet_init(&instance
->tx_channel
.tasklet
, usbatm_tx_process
, (unsigned long)instance
);
1058 instance
->rx_channel
.stride
= ATM_CELL_SIZE
+ driver
->rx_padding
;
1059 instance
->tx_channel
.stride
= ATM_CELL_SIZE
+ driver
->tx_padding
;
1060 instance
->rx_channel
.usbatm
= instance
->tx_channel
.usbatm
= instance
;
1062 if ((instance
->flags
& UDSL_USE_ISOC
) && driver
->isoc_in
)
1063 instance
->rx_channel
.endpoint
= usb_rcvisocpipe(usb_dev
, driver
->isoc_in
);
1065 instance
->rx_channel
.endpoint
= usb_rcvbulkpipe(usb_dev
, driver
->bulk_in
);
1067 instance
->tx_channel
.endpoint
= usb_sndbulkpipe(usb_dev
, driver
->bulk_out
);
1069 /* tx buffer size must be a positive multiple of the stride */
1070 instance
->tx_channel
.buf_size
= max (instance
->tx_channel
.stride
,
1071 snd_buf_bytes
- (snd_buf_bytes
% instance
->tx_channel
.stride
));
1073 /* rx buffer size must be a positive multiple of the endpoint maxpacket */
1074 maxpacket
= usb_maxpacket(usb_dev
, instance
->rx_channel
.endpoint
, 0);
1076 if ((maxpacket
< 1) || (maxpacket
> UDSL_MAX_BUF_SIZE
)) {
1077 dev_err(dev
, "%s: invalid endpoint %02x!\n", __func__
,
1078 usb_pipeendpoint(instance
->rx_channel
.endpoint
));
1083 num_packets
= max (1U, (rcv_buf_bytes
+ maxpacket
/ 2) / maxpacket
); /* round */
1085 if (num_packets
* maxpacket
> UDSL_MAX_BUF_SIZE
)
1088 instance
->rx_channel
.buf_size
= num_packets
* maxpacket
;
1089 instance
->rx_channel
.packet_size
= maxpacket
;
1092 for (i
= 0; i
< 2; i
++) {
1093 struct usbatm_channel
*channel
= i
?
1094 &instance
->tx_channel
: &instance
->rx_channel
;
1096 dev_dbg(dev
, "%s: using %d byte buffer for %s channel 0x%p\n", __func__
, channel
->buf_size
, i
? "tx" : "rx", channel
);
1100 /* initialize urbs */
1102 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1104 struct usbatm_channel
*channel
= i
< num_rcv_urbs
?
1105 &instance
->rx_channel
: &instance
->tx_channel
;
1107 unsigned int iso_packets
= usb_pipeisoc(channel
->endpoint
) ? channel
->buf_size
/ channel
->packet_size
: 0;
1109 UDSL_ASSERT(!usb_pipeisoc(channel
->endpoint
) || usb_pipein(channel
->endpoint
));
1111 urb
= usb_alloc_urb(iso_packets
, GFP_KERNEL
);
1113 dev_err(dev
, "%s: no memory for urb %d!\n", __func__
, i
);
1118 instance
->urbs
[i
] = urb
;
1120 /* zero the tx padding to avoid leaking information */
1121 buffer
= kzalloc(channel
->buf_size
, GFP_KERNEL
);
1123 dev_err(dev
, "%s: no memory for buffer %d!\n", __func__
, i
);
1128 usb_fill_bulk_urb(urb
, instance
->usb_dev
, channel
->endpoint
,
1129 buffer
, channel
->buf_size
, usbatm_complete
, channel
);
1133 urb
->transfer_flags
= URB_ISO_ASAP
;
1134 urb
->number_of_packets
= iso_packets
;
1135 for (j
= 0; j
< iso_packets
; j
++) {
1136 urb
->iso_frame_desc
[j
].offset
= channel
->packet_size
* j
;
1137 urb
->iso_frame_desc
[j
].length
= channel
->packet_size
;
1141 /* put all tx URBs on the list of spares */
1142 if (i
>= num_rcv_urbs
)
1143 list_add_tail(&urb
->urb_list
, &channel
->list
);
1145 vdbg("%s: alloced buffer 0x%p buf size %u urb 0x%p",
1146 __func__
, urb
->transfer_buffer
, urb
->transfer_buffer_length
, urb
);
1149 if (!(instance
->flags
& UDSL_SKIP_HEAVY_INIT
) && driver
->heavy_init
) {
1150 error
= usbatm_heavy_init(instance
);
1152 complete(&instance
->thread_exited
); /* pretend that heavy_init was run */
1153 error
= usbatm_atm_init(instance
);
1159 usb_get_dev(usb_dev
);
1160 usb_set_intfdata(intf
, instance
);
1165 if (instance
->driver
->unbind
)
1166 instance
->driver
->unbind(instance
, intf
);
1168 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1169 if (instance
->urbs
[i
])
1170 kfree(instance
->urbs
[i
]->transfer_buffer
);
1171 usb_free_urb(instance
->urbs
[i
]);
1178 EXPORT_SYMBOL_GPL(usbatm_usb_probe
);
1180 void usbatm_usb_disconnect(struct usb_interface
*intf
)
1182 struct device
*dev
= &intf
->dev
;
1183 struct usbatm_data
*instance
= usb_get_intfdata(intf
);
1184 struct usbatm_vcc_data
*vcc_data
;
1187 dev_dbg(dev
, "%s entered\n", __func__
);
1190 dev_dbg(dev
, "%s: NULL instance!\n", __func__
);
1194 usb_set_intfdata(intf
, NULL
);
1196 down(&instance
->serialize
);
1197 instance
->disconnected
= 1;
1198 if (instance
->thread_pid
>= 0)
1199 kill_proc(instance
->thread_pid
, SIGTERM
, 1);
1200 up(&instance
->serialize
);
1202 wait_for_completion(&instance
->thread_exited
);
1204 down(&instance
->serialize
);
1205 list_for_each_entry(vcc_data
, &instance
->vcc_list
, list
)
1206 vcc_release_async(vcc_data
->vcc
, -EPIPE
);
1207 up(&instance
->serialize
);
1209 tasklet_disable(&instance
->rx_channel
.tasklet
);
1210 tasklet_disable(&instance
->tx_channel
.tasklet
);
1212 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++)
1213 usb_kill_urb(instance
->urbs
[i
]);
1215 del_timer_sync(&instance
->rx_channel
.delay
);
1216 del_timer_sync(&instance
->tx_channel
.delay
);
1218 /* turn usbatm_[rt]x_process into something close to a no-op */
1219 /* no need to take the spinlock */
1220 INIT_LIST_HEAD(&instance
->rx_channel
.list
);
1221 INIT_LIST_HEAD(&instance
->tx_channel
.list
);
1223 tasklet_enable(&instance
->rx_channel
.tasklet
);
1224 tasklet_enable(&instance
->tx_channel
.tasklet
);
1226 if (instance
->atm_dev
&& instance
->driver
->atm_stop
)
1227 instance
->driver
->atm_stop(instance
, instance
->atm_dev
);
1229 if (instance
->driver
->unbind
)
1230 instance
->driver
->unbind(instance
, intf
);
1232 instance
->driver_data
= NULL
;
1234 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1235 kfree(instance
->urbs
[i
]->transfer_buffer
);
1236 usb_free_urb(instance
->urbs
[i
]);
1240 if (instance
->atm_dev
)
1241 atm_dev_deregister(instance
->atm_dev
);
1243 usbatm_put_instance(instance
); /* taken in usbatm_usb_probe */
1245 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect
);
1252 static int __init
usbatm_usb_init(void)
1254 dbg("%s: driver version %s", __func__
, DRIVER_VERSION
);
1256 if (sizeof(struct usbatm_control
) > sizeof(((struct sk_buff
*) 0)->cb
)) {
1257 printk(KERN_ERR
"%s unusable with this kernel!\n", usbatm_driver_name
);
1261 if ((num_rcv_urbs
> UDSL_MAX_RCV_URBS
)
1262 || (num_snd_urbs
> UDSL_MAX_SND_URBS
)
1263 || (rcv_buf_bytes
< 1)
1264 || (rcv_buf_bytes
> UDSL_MAX_BUF_SIZE
)
1265 || (snd_buf_bytes
< 1)
1266 || (snd_buf_bytes
> UDSL_MAX_BUF_SIZE
))
1271 module_init(usbatm_usb_init
);
1273 static void __exit
usbatm_usb_exit(void)
1275 dbg("%s", __func__
);
1277 module_exit(usbatm_usb_exit
);
1279 MODULE_AUTHOR(DRIVER_AUTHOR
);
1280 MODULE_DESCRIPTION(DRIVER_DESC
);
1281 MODULE_LICENSE("GPL");
1282 MODULE_VERSION(DRIVER_VERSION
);
1288 #ifdef VERBOSE_DEBUG
1289 static int usbatm_print_packet(const unsigned char *data
, int len
)
1291 unsigned char buffer
[256];
1294 for (i
= 0; i
< len
;) {
1296 sprintf(buffer
, "%.3d :", i
);
1297 for (j
= 0; (j
< 16) && (i
< len
); j
++, i
++) {
1298 sprintf(buffer
, "%s %2.2x", buffer
, data
[i
]);