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/proc_fs.h>
76 #include <linux/sched.h>
77 #include <linux/signal.h>
78 #include <linux/slab.h>
79 #include <linux/smp_lock.h>
80 #include <linux/stat.h>
81 #include <linux/timer.h>
82 #include <linux/wait.h>
85 static int usbatm_print_packet(const unsigned char *data
, int len
);
86 #define PACKETDEBUG(arg...) usbatm_print_packet (arg)
87 #define vdbg(arg...) dbg (arg)
89 #define PACKETDEBUG(arg...)
93 #define DRIVER_AUTHOR "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
94 #define DRIVER_VERSION "1.9"
95 #define DRIVER_DESC "Generic USB ATM/DSL I/O, version " DRIVER_VERSION
97 static const char usbatm_driver_name
[] = "usbatm";
99 #define UDSL_MAX_RCV_URBS 16
100 #define UDSL_MAX_SND_URBS 16
101 #define UDSL_MAX_RCV_BUF_SIZE 1024 /* ATM cells */
102 #define UDSL_MAX_SND_BUF_SIZE 1024 /* ATM cells */
103 #define UDSL_DEFAULT_RCV_URBS 4
104 #define UDSL_DEFAULT_SND_URBS 4
105 #define UDSL_DEFAULT_RCV_BUF_SIZE 64 /* ATM cells */
106 #define UDSL_DEFAULT_SND_BUF_SIZE 64 /* ATM cells */
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_size
= UDSL_DEFAULT_RCV_BUF_SIZE
;
115 static unsigned int snd_buf_size
= 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_size
, uint
, S_IRUGO
);
130 MODULE_PARM_DESC(rcv_buf_size
,
131 "Size of the buffers used for reception in ATM cells (range: 1-"
132 __MODULE_STRING(UDSL_MAX_RCV_BUF_SIZE
) ", default: "
133 __MODULE_STRING(UDSL_DEFAULT_RCV_BUF_SIZE
) ")");
135 module_param(snd_buf_size
, uint
, S_IRUGO
);
136 MODULE_PARM_DESC(snd_buf_size
,
137 "Size of the buffers used for transmission in ATM cells (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
*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
*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
)
210 static inline 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 inline 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 atm_dbg(channel
->usbatm
, "%s: urb 0x%p submission failed (%d)!\n",
240 /* consider all errors transient and return the buffer back to the queue */
241 urb
->status
= -EAGAIN
;
242 spin_lock_irq(&channel
->lock
);
244 /* must add to the front when sending; doesn't matter when receiving */
245 list_add(&urb
->urb_list
, &channel
->list
);
247 spin_unlock_irq(&channel
->lock
);
249 /* make sure the channel doesn't stall */
250 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
256 static void usbatm_complete(struct urb
*urb
, struct pt_regs
*regs
)
258 struct usbatm_channel
*channel
= urb
->context
;
261 vdbg("%s: urb 0x%p, status %d, actual_length %d",
262 __func__
, urb
, urb
->status
, urb
->actual_length
);
264 /* usually in_interrupt(), but not always */
265 spin_lock_irqsave(&channel
->lock
, flags
);
267 /* must add to the back when receiving; doesn't matter when sending */
268 list_add_tail(&urb
->urb_list
, &channel
->list
);
270 spin_unlock_irqrestore(&channel
->lock
, flags
);
272 if (unlikely(urb
->status
))
273 /* throttle processing in case of an error */
274 mod_timer(&channel
->delay
, jiffies
+ msecs_to_jiffies(THROTTLE_MSECS
));
276 tasklet_schedule(&channel
->tasklet
);
284 static inline struct usbatm_vcc_data
*usbatm_find_vcc(struct usbatm_data
*instance
,
287 struct usbatm_vcc_data
*vcc
;
289 list_for_each_entry(vcc
, &instance
->vcc_list
, list
)
290 if ((vcc
->vci
== vci
) && (vcc
->vpi
== vpi
))
295 static void usbatm_extract_cells(struct usbatm_data
*instance
,
296 unsigned char *source
, unsigned int avail_data
)
298 struct usbatm_vcc_data
*cached_vcc
= NULL
;
300 struct sk_buff
*sarb
;
301 unsigned int stride
= instance
->rx_channel
.stride
;
302 int vci
, cached_vci
= 0;
303 short vpi
, cached_vpi
= 0;
306 for (; avail_data
>= stride
; avail_data
-= stride
, source
+= stride
) {
307 vpi
= ((source
[0] & 0x0f) << 4) | (source
[1] >> 4);
308 vci
= ((source
[1] & 0x0f) << 12) | (source
[2] << 4) | (source
[3] >> 4);
309 pti
= ((source
[3] & 0xe) >> 1);
311 vdbg("%s: vpi %hd, vci %d, pti %d", __func__
, vpi
, vci
, pti
);
313 if ((vci
!= cached_vci
) || (vpi
!= cached_vpi
)) {
317 cached_vcc
= usbatm_find_vcc(instance
, vpi
, vci
);
320 atm_dbg(instance
, "%s: unknown vpi/vci (%hd/%d)!\n", __func__
, vpi
, vci
);
326 vcc
= cached_vcc
->vcc
;
328 /* OAM F5 end-to-end */
329 if (pti
== ATM_PTI_E2EF5
) {
330 atm_warn(instance
, "%s: OAM not supported (vpi %d, vci %d)!\n", __func__
, vpi
, vci
);
331 atomic_inc(&vcc
->stats
->rx_err
);
335 sarb
= cached_vcc
->sarb
;
337 if (sarb
->tail
+ ATM_CELL_PAYLOAD
> sarb
->end
) {
338 atm_dbg(instance
, "%s: buffer overrun (sarb->len %u, vcc: 0x%p)!\n",
339 __func__
, sarb
->len
, vcc
);
340 /* discard cells already received */
342 UDSL_ASSERT(sarb
->tail
+ ATM_CELL_PAYLOAD
<= sarb
->end
);
345 memcpy(sarb
->tail
, source
+ ATM_CELL_HEADER
, ATM_CELL_PAYLOAD
);
346 __skb_put(sarb
, ATM_CELL_PAYLOAD
);
351 unsigned int pdu_length
;
353 length
= (source
[ATM_CELL_SIZE
- 6] << 8) + source
[ATM_CELL_SIZE
- 5];
355 /* guard against overflow */
356 if (length
> ATM_MAX_AAL5_PDU
) {
357 atm_dbg(instance
, "%s: bogus length %u (vcc: 0x%p)!\n",
358 __func__
, length
, vcc
);
359 atomic_inc(&vcc
->stats
->rx_err
);
363 pdu_length
= usbatm_pdu_length(length
);
365 if (sarb
->len
< pdu_length
) {
366 atm_dbg(instance
, "%s: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!\n",
367 __func__
, pdu_length
, sarb
->len
, vcc
);
368 atomic_inc(&vcc
->stats
->rx_err
);
372 if (crc32_be(~0, sarb
->tail
- pdu_length
, pdu_length
) != 0xc704dd7b) {
373 atm_dbg(instance
, "%s: packet failed crc check (vcc: 0x%p)!\n",
375 atomic_inc(&vcc
->stats
->rx_err
);
379 vdbg("%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", __func__
, length
, pdu_length
, vcc
);
381 if (!(skb
= dev_alloc_skb(length
))) {
382 atm_dbg(instance
, "%s: no memory for skb (length: %u)!\n", __func__
, length
);
383 atomic_inc(&vcc
->stats
->rx_drop
);
387 vdbg("%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", __func__
, skb
, skb
->truesize
);
389 if (!atm_charge(vcc
, skb
->truesize
)) {
390 atm_dbg(instance
, "%s: failed atm_charge (skb->truesize: %u)!\n", __func__
, skb
->truesize
);
392 goto out
; /* atm_charge increments rx_drop */
395 memcpy(skb
->data
, sarb
->tail
- pdu_length
, length
);
396 __skb_put(skb
, length
);
398 vdbg("%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
399 __func__
, skb
, skb
->len
, skb
->truesize
);
401 PACKETDEBUG(skb
->data
, skb
->len
);
405 atomic_inc(&vcc
->stats
->rx
);
417 static unsigned int usbatm_write_cells(struct usbatm_data
*instance
,
419 u8
*target
, unsigned int avail_space
)
421 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
422 struct atm_vcc
*vcc
= ctrl
->atm
.vcc
;
423 unsigned int num_written
;
424 unsigned int stride
= instance
->tx_channel
.stride
;
426 vdbg("%s: skb->len=%d, avail_space=%u", __func__
, skb
->len
, avail_space
);
427 UDSL_ASSERT(!(avail_space
% stride
));
429 for (num_written
= 0; num_written
< avail_space
&& ctrl
->len
;
430 num_written
+= stride
, target
+= stride
) {
431 unsigned int data_len
= min_t(unsigned int, skb
->len
, ATM_CELL_PAYLOAD
);
432 unsigned int left
= ATM_CELL_PAYLOAD
- data_len
;
435 ptr
[0] = vcc
->vpi
>> 4;
436 ptr
[1] = (vcc
->vpi
<< 4) | (vcc
->vci
>> 12);
437 ptr
[2] = vcc
->vci
>> 4;
438 ptr
[3] = vcc
->vci
<< 4;
440 ptr
+= ATM_CELL_HEADER
;
442 memcpy(ptr
, skb
->data
, data_len
);
444 __skb_pull(skb
, data_len
);
449 memset(ptr
, 0, left
);
451 if (left
>= ATM_AAL5_TRAILER
) { /* trailer will go in this cell */
452 u8
*trailer
= target
+ ATM_CELL_SIZE
- ATM_AAL5_TRAILER
;
453 /* trailer[0] = 0; UU = 0 */
454 /* trailer[1] = 0; CPI = 0 */
455 trailer
[2] = ctrl
->len
>> 8;
456 trailer
[3] = ctrl
->len
;
458 ctrl
->crc
= ~ crc32_be(ctrl
->crc
, ptr
, left
- 4);
460 trailer
[4] = ctrl
->crc
>> 24;
461 trailer
[5] = ctrl
->crc
>> 16;
462 trailer
[6] = ctrl
->crc
>> 8;
463 trailer
[7] = ctrl
->crc
;
465 target
[3] |= 0x2; /* adjust PTI */
467 ctrl
->len
= 0; /* tag this skb finished */
470 ctrl
->crc
= crc32_be(ctrl
->crc
, ptr
, left
);
481 static void usbatm_rx_process(unsigned long data
)
483 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
486 while ((urb
= usbatm_pop_urb(&instance
->rx_channel
))) {
487 vdbg("%s: processing urb 0x%p", __func__
, urb
);
489 if (usb_pipeisoc(urb
->pipe
)) {
491 for (i
= 0; i
< urb
->number_of_packets
; i
++)
492 if (!urb
->iso_frame_desc
[i
].status
)
493 usbatm_extract_cells(instance
,
494 (u8
*)urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
,
495 urb
->iso_frame_desc
[i
].actual_length
);
499 usbatm_extract_cells(instance
, urb
->transfer_buffer
, urb
->actual_length
);
501 if (usbatm_submit_urb(urb
))
511 static void usbatm_tx_process(unsigned long data
)
513 struct usbatm_data
*instance
= (struct usbatm_data
*)data
;
514 struct sk_buff
*skb
= instance
->current_skb
;
515 struct urb
*urb
= NULL
;
516 const unsigned int buf_size
= instance
->tx_channel
.buf_size
;
517 unsigned int num_written
= 0;
521 skb
= skb_dequeue(&instance
->sndqueue
);
525 urb
= usbatm_pop_urb(&instance
->tx_channel
);
527 break; /* no more senders */
528 buffer
= urb
->transfer_buffer
;
529 num_written
= (urb
->status
== -EAGAIN
) ?
530 urb
->transfer_buffer_length
: 0;
533 num_written
+= usbatm_write_cells(instance
, skb
,
534 buffer
+ num_written
,
535 buf_size
- num_written
);
537 vdbg("%s: wrote %u bytes from skb 0x%p to urb 0x%p",
538 __func__
, num_written
, skb
, urb
);
540 if (!UDSL_SKB(skb
)->len
) {
541 struct atm_vcc
*vcc
= UDSL_SKB(skb
)->atm
.vcc
;
543 usbatm_pop(vcc
, skb
);
544 atomic_inc(&vcc
->stats
->tx
);
546 skb
= skb_dequeue(&instance
->sndqueue
);
549 if (num_written
== buf_size
|| (!skb
&& num_written
)) {
550 urb
->transfer_buffer_length
= num_written
;
552 if (usbatm_submit_urb(urb
))
558 instance
->current_skb
= skb
;
561 static void usbatm_cancel_send(struct usbatm_data
*instance
,
564 struct sk_buff
*skb
, *n
;
566 atm_dbg(instance
, "%s entered\n", __func__
);
567 spin_lock_irq(&instance
->sndqueue
.lock
);
568 for (skb
= instance
->sndqueue
.next
, n
= skb
->next
;
569 skb
!= (struct sk_buff
*)&instance
->sndqueue
;
570 skb
= n
, n
= skb
->next
)
571 if (UDSL_SKB(skb
)->atm
.vcc
== vcc
) {
572 atm_dbg(instance
, "%s: popping skb 0x%p\n", __func__
, skb
);
573 __skb_unlink(skb
, &instance
->sndqueue
);
574 usbatm_pop(vcc
, skb
);
576 spin_unlock_irq(&instance
->sndqueue
.lock
);
578 tasklet_disable(&instance
->tx_channel
.tasklet
);
579 if ((skb
= instance
->current_skb
) && (UDSL_SKB(skb
)->atm
.vcc
== vcc
)) {
580 atm_dbg(instance
, "%s: popping current skb (0x%p)\n", __func__
, skb
);
581 instance
->current_skb
= NULL
;
582 usbatm_pop(vcc
, skb
);
584 tasklet_enable(&instance
->tx_channel
.tasklet
);
585 atm_dbg(instance
, "%s done\n", __func__
);
588 static int usbatm_atm_send(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
590 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
591 struct usbatm_control
*ctrl
= UDSL_SKB(skb
);
594 vdbg("%s called (skb 0x%p, len %u)", __func__
, skb
, skb
->len
);
597 dbg("%s: NULL data!", __func__
);
602 if (vcc
->qos
.aal
!= ATM_AAL5
) {
603 atm_dbg(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
608 if (skb
->len
> ATM_MAX_AAL5_PDU
) {
609 atm_dbg(instance
, "%s: packet too long (%d vs %d)!\n",
610 __func__
, skb
->len
, ATM_MAX_AAL5_PDU
);
615 PACKETDEBUG(skb
->data
, skb
->len
);
617 /* initialize the control block */
619 ctrl
->len
= skb
->len
;
620 ctrl
->crc
= crc32_be(~0, skb
->data
, skb
->len
);
622 skb_queue_tail(&instance
->sndqueue
, skb
);
623 tasklet_schedule(&instance
->tx_channel
.tasklet
);
628 usbatm_pop(vcc
, skb
);
633 /********************
635 ********************/
637 static void usbatm_destroy_instance(struct kref
*kref
)
639 struct usbatm_data
*instance
= container_of(kref
, struct usbatm_data
, refcount
);
643 tasklet_kill(&instance
->rx_channel
.tasklet
);
644 tasklet_kill(&instance
->tx_channel
.tasklet
);
645 usb_put_dev(instance
->usb_dev
);
649 static void usbatm_get_instance(struct usbatm_data
*instance
)
653 kref_get(&instance
->refcount
);
656 static void usbatm_put_instance(struct usbatm_data
*instance
)
660 kref_put(&instance
->refcount
, usbatm_destroy_instance
);
668 static void usbatm_atm_dev_close(struct atm_dev
*dev
)
670 struct usbatm_data
*instance
= dev
->dev_data
;
677 dev
->dev_data
= NULL
;
678 usbatm_put_instance(instance
); /* taken in usbatm_atm_init */
681 static int usbatm_atm_proc_read(struct atm_dev
*atm_dev
, loff_t
* pos
, char *page
)
683 struct usbatm_data
*instance
= atm_dev
->dev_data
;
687 dbg("%s: NULL instance!", __func__
);
692 return sprintf(page
, "%s\n", instance
->description
);
695 return sprintf(page
, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
696 atm_dev
->esi
[0], atm_dev
->esi
[1],
697 atm_dev
->esi
[2], atm_dev
->esi
[3],
698 atm_dev
->esi
[4], atm_dev
->esi
[5]);
702 "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
703 atomic_read(&atm_dev
->stats
.aal5
.tx
),
704 atomic_read(&atm_dev
->stats
.aal5
.tx_err
),
705 atomic_read(&atm_dev
->stats
.aal5
.rx
),
706 atomic_read(&atm_dev
->stats
.aal5
.rx_err
),
707 atomic_read(&atm_dev
->stats
.aal5
.rx_drop
));
710 switch (atm_dev
->signal
) {
711 case ATM_PHY_SIG_FOUND
:
712 return sprintf(page
, "Line up\n");
713 case ATM_PHY_SIG_LOST
:
714 return sprintf(page
, "Line down\n");
716 return sprintf(page
, "Line state unknown\n");
722 static int usbatm_atm_open(struct atm_vcc
*vcc
)
724 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
725 struct usbatm_vcc_data
*new = NULL
;
728 short vpi
= vcc
->vpi
;
731 dbg("%s: NULL data!", __func__
);
735 atm_dbg(instance
, "%s: vpi %hd, vci %d\n", __func__
, vpi
, vci
);
737 /* only support AAL5 */
738 if ((vcc
->qos
.aal
!= ATM_AAL5
) || (vcc
->qos
.rxtp
.max_sdu
< 0)
739 || (vcc
->qos
.rxtp
.max_sdu
> ATM_MAX_AAL5_PDU
)) {
740 atm_dbg(instance
, "%s: unsupported ATM type %d!\n", __func__
, vcc
->qos
.aal
);
744 down(&instance
->serialize
); /* vs self, usbatm_atm_close */
746 if (usbatm_find_vcc(instance
, vpi
, vci
)) {
747 atm_dbg(instance
, "%s: %hd/%d already in use!\n", __func__
, vpi
, vci
);
752 if (!(new = kmalloc(sizeof(struct usbatm_vcc_data
), GFP_KERNEL
))) {
753 atm_dbg(instance
, "%s: no memory for vcc_data!\n", __func__
);
758 memset(new, 0, sizeof(struct usbatm_vcc_data
));
763 new->sarb
= alloc_skb(usbatm_pdu_length(vcc
->qos
.rxtp
.max_sdu
), GFP_KERNEL
);
765 atm_dbg(instance
, "%s: no memory for SAR buffer!\n", __func__
);
772 tasklet_disable(&instance
->rx_channel
.tasklet
);
773 list_add(&new->list
, &instance
->vcc_list
);
774 tasklet_enable(&instance
->rx_channel
.tasklet
);
776 set_bit(ATM_VF_ADDR
, &vcc
->flags
);
777 set_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
778 set_bit(ATM_VF_READY
, &vcc
->flags
);
780 up(&instance
->serialize
);
782 atm_dbg(instance
, "%s: allocated vcc data 0x%p\n", __func__
, new);
788 up(&instance
->serialize
);
792 static void usbatm_atm_close(struct atm_vcc
*vcc
)
794 struct usbatm_data
*instance
= vcc
->dev
->dev_data
;
795 struct usbatm_vcc_data
*vcc_data
= vcc
->dev_data
;
797 if (!instance
|| !vcc_data
) {
798 dbg("%s: NULL data!", __func__
);
802 atm_dbg(instance
, "%s entered\n", __func__
);
804 atm_dbg(instance
, "%s: deallocating vcc 0x%p with vpi %d vci %d\n",
805 __func__
, vcc_data
, vcc_data
->vpi
, vcc_data
->vci
);
807 usbatm_cancel_send(instance
, vcc
);
809 down(&instance
->serialize
); /* vs self, usbatm_atm_open */
811 tasklet_disable(&instance
->rx_channel
.tasklet
);
812 list_del(&vcc_data
->list
);
813 tasklet_enable(&instance
->rx_channel
.tasklet
);
815 kfree_skb(vcc_data
->sarb
);
816 vcc_data
->sarb
= NULL
;
819 vcc
->dev_data
= NULL
;
821 vcc
->vpi
= ATM_VPI_UNSPEC
;
822 vcc
->vci
= ATM_VCI_UNSPEC
;
823 clear_bit(ATM_VF_READY
, &vcc
->flags
);
824 clear_bit(ATM_VF_PARTIAL
, &vcc
->flags
);
825 clear_bit(ATM_VF_ADDR
, &vcc
->flags
);
827 up(&instance
->serialize
);
829 atm_dbg(instance
, "%s successful\n", __func__
);
832 static int usbatm_atm_ioctl(struct atm_dev
*dev
, unsigned int cmd
,
837 return put_user(ATM_LM_NONE
, (int __user
*)arg
) ? -EFAULT
: 0;
843 static int usbatm_atm_init(struct usbatm_data
*instance
)
845 struct atm_dev
*atm_dev
;
849 atm_dev
= atm_dev_register(instance
->driver_name
, &usbatm_atm_devops
, -1, NULL
);
851 usb_dbg(instance
, "%s: failed to register ATM device!\n", __func__
);
855 instance
->atm_dev
= atm_dev
;
857 atm_dev
->ci_range
.vpi_bits
= ATM_CI_MAX
;
858 atm_dev
->ci_range
.vci_bits
= ATM_CI_MAX
;
859 atm_dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
861 /* temp init ATM device, set to 128kbit */
862 atm_dev
->link_rate
= 128 * 1000 / 424;
864 if (instance
->driver
->atm_start
&& ((ret
= instance
->driver
->atm_start(instance
, atm_dev
)) < 0)) {
865 atm_dbg(instance
, "%s: atm_start failed: %d!\n", __func__
, ret
);
869 /* ready for ATM callbacks */
870 usbatm_get_instance(instance
); /* dropped in usbatm_atm_dev_close */
872 atm_dev
->dev_data
= instance
;
874 /* submit all rx URBs */
875 for (i
= 0; i
< num_rcv_urbs
; i
++)
876 usbatm_submit_urb(instance
->urbs
[i
]);
881 instance
->atm_dev
= NULL
;
882 atm_dev_deregister(atm_dev
); /* usbatm_atm_dev_close will eventually be called */
891 static int usbatm_do_heavy_init(void *arg
)
893 struct usbatm_data
*instance
= arg
;
896 daemonize(instance
->driver
->driver_name
);
897 allow_signal(SIGTERM
);
899 complete(&instance
->thread_started
);
901 ret
= instance
->driver
->heavy_init(instance
, instance
->usb_intf
);
904 ret
= usbatm_atm_init(instance
);
906 down(&instance
->serialize
);
907 instance
->thread_pid
= -1;
908 up(&instance
->serialize
);
910 complete_and_exit(&instance
->thread_exited
, ret
);
913 static int usbatm_heavy_init(struct usbatm_data
*instance
)
915 int ret
= kernel_thread(usbatm_do_heavy_init
, instance
, CLONE_KERNEL
);
918 usb_dbg(instance
, "%s: failed to create kernel_thread (%d)!\n", __func__
, ret
);
922 down(&instance
->serialize
);
923 instance
->thread_pid
= ret
;
924 up(&instance
->serialize
);
926 wait_for_completion(&instance
->thread_started
);
931 static void usbatm_tasklet_schedule(unsigned long data
)
933 tasklet_schedule((struct tasklet_struct
*) data
);
936 static inline void usbatm_init_channel(struct usbatm_channel
*channel
)
938 spin_lock_init(&channel
->lock
);
939 INIT_LIST_HEAD(&channel
->list
);
940 channel
->delay
.function
= usbatm_tasklet_schedule
;
941 channel
->delay
.data
= (unsigned long) &channel
->tasklet
;
942 init_timer(&channel
->delay
);
945 int usbatm_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
,
946 struct usbatm_driver
*driver
)
948 struct device
*dev
= &intf
->dev
;
949 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
950 struct usbatm_data
*instance
;
956 dev_dbg(dev
, "%s: trying driver %s with vendor=0x%x, product=0x%x, ifnum %d\n",
957 __func__
, driver
->driver_name
,
958 le16_to_cpu(usb_dev
->descriptor
.idVendor
),
959 le16_to_cpu(usb_dev
->descriptor
.idProduct
),
960 intf
->altsetting
->desc
.bInterfaceNumber
);
963 instance
= kzalloc(sizeof(*instance
) + sizeof(struct urb
*) * (num_rcv_urbs
+ num_snd_urbs
), GFP_KERNEL
);
965 dev_dbg(dev
, "%s: no memory for instance data!\n", __func__
);
971 instance
->driver
= driver
;
972 snprintf(instance
->driver_name
, sizeof(instance
->driver_name
), driver
->driver_name
);
974 instance
->usb_dev
= usb_dev
;
975 instance
->usb_intf
= intf
;
977 buf
= instance
->description
;
978 length
= sizeof(instance
->description
);
980 if ((i
= usb_string(usb_dev
, usb_dev
->descriptor
.iProduct
, buf
, length
)) < 0)
986 i
= scnprintf(buf
, length
, " (");
990 if (length
<= 0 || (i
= usb_make_path(usb_dev
, buf
, length
)) < 0)
996 snprintf(buf
, length
, ")");
1000 if (driver
->bind
&& (error
= driver
->bind(instance
, intf
, id
, &need_heavy
)) < 0) {
1001 dev_dbg(dev
, "%s: bind failed: %d!\n", __func__
, error
);
1005 /* private fields */
1007 kref_init(&instance
->refcount
); /* dropped in usbatm_usb_disconnect */
1008 init_MUTEX(&instance
->serialize
);
1010 instance
->thread_pid
= -1;
1011 init_completion(&instance
->thread_started
);
1012 init_completion(&instance
->thread_exited
);
1014 INIT_LIST_HEAD(&instance
->vcc_list
);
1016 usbatm_init_channel(&instance
->rx_channel
);
1017 usbatm_init_channel(&instance
->tx_channel
);
1018 tasklet_init(&instance
->rx_channel
.tasklet
, usbatm_rx_process
, (unsigned long)instance
);
1019 tasklet_init(&instance
->tx_channel
.tasklet
, usbatm_tx_process
, (unsigned long)instance
);
1020 instance
->rx_channel
.endpoint
= usb_rcvbulkpipe(usb_dev
, driver
->in
);
1021 instance
->tx_channel
.endpoint
= usb_sndbulkpipe(usb_dev
, driver
->out
);
1022 instance
->rx_channel
.stride
= ATM_CELL_SIZE
+ driver
->rx_padding
;
1023 instance
->tx_channel
.stride
= ATM_CELL_SIZE
+ driver
->tx_padding
;
1024 instance
->rx_channel
.buf_size
= rcv_buf_size
* instance
->rx_channel
.stride
;
1025 instance
->tx_channel
.buf_size
= snd_buf_size
* instance
->tx_channel
.stride
;
1026 instance
->rx_channel
.usbatm
= instance
->tx_channel
.usbatm
= instance
;
1028 skb_queue_head_init(&instance
->sndqueue
);
1030 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1033 unsigned int iso_packets
= 0, iso_size
= 0;
1034 struct usbatm_channel
*channel
= i
< num_rcv_urbs
?
1035 &instance
->rx_channel
: &instance
->tx_channel
;
1037 if (usb_pipeisoc(channel
->endpoint
)) {
1038 /* don't expect iso out endpoints */
1039 iso_size
= usb_maxpacket(instance
->usb_dev
, channel
->endpoint
, 0);
1040 iso_size
-= iso_size
% channel
->stride
; /* alignment */
1042 iso_packets
= (channel
->buf_size
- 1) / iso_size
+ 1;
1045 urb
= usb_alloc_urb(iso_packets
, GFP_KERNEL
);
1047 dev_dbg(dev
, "%s: no memory for urb %d!\n", __func__
, i
);
1051 instance
->urbs
[i
] = urb
;
1053 buffer
= kmalloc(channel
->buf_size
, GFP_KERNEL
);
1055 dev_dbg(dev
, "%s: no memory for buffer %d!\n", __func__
, i
);
1058 memset(buffer
, 0, channel
->buf_size
);
1060 usb_fill_bulk_urb(urb
, instance
->usb_dev
, channel
->endpoint
,
1061 buffer
, channel
->buf_size
, usbatm_complete
, channel
);
1065 urb
->transfer_flags
= URB_ISO_ASAP
;
1066 urb
->number_of_packets
= iso_packets
;
1067 for (j
= 0; j
< iso_packets
; j
++) {
1068 urb
->iso_frame_desc
[j
].offset
= iso_size
* j
;
1069 urb
->iso_frame_desc
[j
].length
= min_t(int, iso_size
,
1070 channel
->buf_size
- urb
->iso_frame_desc
[j
].offset
);
1074 /* put all tx URBs on the list of spares */
1075 if (i
>= num_rcv_urbs
)
1076 list_add_tail(&urb
->urb_list
, &channel
->list
);
1078 vdbg("%s: alloced buffer 0x%p buf size %u urb 0x%p",
1079 __func__
, urb
->transfer_buffer
, urb
->transfer_buffer_length
, urb
);
1082 if (need_heavy
&& driver
->heavy_init
) {
1083 error
= usbatm_heavy_init(instance
);
1085 complete(&instance
->thread_exited
); /* pretend that heavy_init was run */
1086 error
= usbatm_atm_init(instance
);
1092 usb_get_dev(usb_dev
);
1093 usb_set_intfdata(intf
, instance
);
1098 if (instance
->driver
->unbind
)
1099 instance
->driver
->unbind(instance
, intf
);
1101 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1102 if (instance
->urbs
[i
])
1103 kfree(instance
->urbs
[i
]->transfer_buffer
);
1104 usb_free_urb(instance
->urbs
[i
]);
1111 EXPORT_SYMBOL_GPL(usbatm_usb_probe
);
1113 void usbatm_usb_disconnect(struct usb_interface
*intf
)
1115 struct device
*dev
= &intf
->dev
;
1116 struct usbatm_data
*instance
= usb_get_intfdata(intf
);
1119 dev_dbg(dev
, "%s entered\n", __func__
);
1122 dev_dbg(dev
, "%s: NULL instance!\n", __func__
);
1126 usb_set_intfdata(intf
, NULL
);
1128 down(&instance
->serialize
);
1129 if (instance
->thread_pid
>= 0)
1130 kill_proc(instance
->thread_pid
, SIGTERM
, 1);
1131 up(&instance
->serialize
);
1133 wait_for_completion(&instance
->thread_exited
);
1135 tasklet_disable(&instance
->rx_channel
.tasklet
);
1136 tasklet_disable(&instance
->tx_channel
.tasklet
);
1138 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++)
1139 usb_kill_urb(instance
->urbs
[i
]);
1141 del_timer_sync(&instance
->rx_channel
.delay
);
1142 del_timer_sync(&instance
->tx_channel
.delay
);
1144 if (instance
->atm_dev
&& instance
->driver
->atm_stop
)
1145 instance
->driver
->atm_stop(instance
, instance
->atm_dev
);
1147 if (instance
->driver
->unbind
)
1148 instance
->driver
->unbind(instance
, intf
);
1150 instance
->driver_data
= NULL
;
1152 /* turn usbatm_[rt]x_process into noop */
1153 /* no need to take the spinlock */
1154 INIT_LIST_HEAD(&instance
->rx_channel
.list
);
1155 INIT_LIST_HEAD(&instance
->tx_channel
.list
);
1157 tasklet_enable(&instance
->rx_channel
.tasklet
);
1158 tasklet_enable(&instance
->tx_channel
.tasklet
);
1160 for (i
= 0; i
< num_rcv_urbs
+ num_snd_urbs
; i
++) {
1161 kfree(instance
->urbs
[i
]->transfer_buffer
);
1162 usb_free_urb(instance
->urbs
[i
]);
1166 if (instance
->atm_dev
)
1167 atm_dev_deregister(instance
->atm_dev
);
1169 usbatm_put_instance(instance
); /* taken in usbatm_usb_probe */
1171 EXPORT_SYMBOL_GPL(usbatm_usb_disconnect
);
1178 static int __init
usbatm_usb_init(void)
1180 dbg("%s: driver version %s", __func__
, DRIVER_VERSION
);
1182 if (sizeof(struct usbatm_control
) > sizeof(((struct sk_buff
*) 0)->cb
)) {
1183 printk(KERN_ERR
"%s unusable with this kernel!\n", usbatm_driver_name
);
1187 if ((num_rcv_urbs
> UDSL_MAX_RCV_URBS
)
1188 || (num_snd_urbs
> UDSL_MAX_SND_URBS
)
1189 || (rcv_buf_size
< 1)
1190 || (rcv_buf_size
> UDSL_MAX_RCV_BUF_SIZE
)
1191 || (snd_buf_size
< 1)
1192 || (snd_buf_size
> UDSL_MAX_SND_BUF_SIZE
))
1197 module_init(usbatm_usb_init
);
1199 static void __exit
usbatm_usb_exit(void)
1201 dbg("%s", __func__
);
1203 module_exit(usbatm_usb_exit
);
1205 MODULE_AUTHOR(DRIVER_AUTHOR
);
1206 MODULE_DESCRIPTION(DRIVER_DESC
);
1207 MODULE_LICENSE("GPL");
1208 MODULE_VERSION(DRIVER_VERSION
);
1214 #ifdef VERBOSE_DEBUG
1215 static int usbatm_print_packet(const unsigned char *data
, int len
)
1217 unsigned char buffer
[256];
1220 for (i
= 0; i
< len
;) {
1222 sprintf(buffer
, "%.3d :", i
);
1223 for (j
= 0; (j
< 16) && (i
< len
); j
++, i
++) {
1224 sprintf(buffer
, "%s %2.2x", buffer
, data
[i
]);