1 /******************************************************************************
2 * speedtouch.c - Alcatel SpeedTouch USB xDSL modem driver
4 * Copyright (C) 2001, Alcatel
5 * Copyright (C) 2003, Duncan Sands
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59
19 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 ******************************************************************************/
24 * Written by Johan Verrept, maintained by Duncan Sands (duncan.sands@free.fr)
26 * 1.7+: - See the check-in logs
28 * 1.6: - No longer opens a connection if the firmware is not loaded
29 * - Added support for the speedtouch 330
30 * - Removed the limit on the number of devices
31 * - Module now autoloads on device plugin
32 * - Merged relevant parts of sarlib
33 * - Replaced the kernel thread with a tasklet
34 * - New packet transmission code
35 * - Changed proc file contents
36 * - Fixed all known SMP races
37 * - Many fixes and cleanups
38 * - Various fixes by Oliver Neukum (oliver@neukum.name)
40 * 1.5A: - Version for inclusion in 2.5 series kernel
41 * - Modifications by Richard Purdie (rpurdie@rpsys.net)
42 * - made compatible with kernel 2.5.6 onwards by changing
43 * udsl_usb_send_data_context->urb to a pointer and adding code
44 * to alloc and free it
45 * - remove_wait_queue() added to udsl_atm_processqueue_thread()
47 * 1.5: - fixed memory leak when atmsar_decode_aal5 returned NULL.
48 * (reported by stephen.robinson@zen.co.uk)
50 * 1.4: - changed the spin_lock() under interrupt to spin_lock_irqsave()
51 * - unlink all active send urbs of a vcc that is being closed.
53 * 1.3.1: - added the version number
55 * 1.3: - Added multiple send urb support
56 * - fixed memory leak and vcc->tx_inuse starvation bug
57 * when not enough memory left in vcc.
59 * 1.2: - Fixed race condition in udsl_usb_send_data()
60 * 1.1: - Turned off packet debugging
64 #include <asm/semaphore.h>
65 #include <linux/module.h>
66 #include <linux/moduleparam.h>
67 #include <linux/kernel.h>
68 #include <linux/sched.h>
69 #include <linux/timer.h>
70 #include <linux/errno.h>
71 #include <linux/proc_fs.h>
72 #include <linux/slab.h>
73 #include <linux/list.h>
74 #include <asm/uaccess.h>
75 #include <linux/smp_lock.h>
76 #include <linux/interrupt.h>
77 #include <linux/atm.h>
78 #include <linux/atmdev.h>
79 #include <linux/crc32.h>
80 #include <linux/init.h>
87 #if !defined (DEBUG) && defined (CONFIG_USB_DEBUG)
91 #include <linux/usb.h>
94 #define DEBUG_ON(x) BUG_ON(x)
96 #define DEBUG_ON(x) do { if (x); } while (0)
100 static int udsl_print_packet (const unsigned char *data, int len);
101 #define PACKETDEBUG(arg...) udsl_print_packet (arg)
102 #define vdbg(arg...) dbg (arg)
104 #define PACKETDEBUG(arg...)
108 #define DRIVER_AUTHOR "Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
109 #define DRIVER_VERSION "1.8"
110 #define DRIVER_DESC "Alcatel SpeedTouch USB driver version " DRIVER_VERSION
112 static const char udsl_driver_name [] = "speedtch";
114 #define SPEEDTOUCH_VENDORID 0x06b9
115 #define SPEEDTOUCH_PRODUCTID 0x4061
117 #define UDSL_MAX_RCV_URBS 4
118 #define UDSL_MAX_SND_URBS 4
119 #define UDSL_MAX_RCV_BUFS 8
120 #define UDSL_MAX_SND_BUFS 8
121 #define UDSL_MAX_RCV_BUF_SIZE 1024 /* ATM cells */
122 #define UDSL_MAX_SND_BUF_SIZE 1024 /* ATM cells */
123 #define UDSL_DEFAULT_RCV_URBS 2
124 #define UDSL_DEFAULT_SND_URBS 2
125 #define UDSL_DEFAULT_RCV_BUFS 4
126 #define UDSL_DEFAULT_SND_BUFS 4
127 #define UDSL_DEFAULT_RCV_BUF_SIZE 64 /* ATM cells */
128 #define UDSL_DEFAULT_SND_BUF_SIZE 64 /* ATM cells */
130 static unsigned int num_rcv_urbs = UDSL_DEFAULT_RCV_URBS;
131 static unsigned int num_snd_urbs = UDSL_DEFAULT_SND_URBS;
132 static unsigned int num_rcv_bufs = UDSL_DEFAULT_RCV_BUFS;
133 static unsigned int num_snd_bufs = UDSL_DEFAULT_SND_BUFS;
134 static unsigned int rcv_buf_size = UDSL_DEFAULT_RCV_BUF_SIZE;
135 static unsigned int snd_buf_size = UDSL_DEFAULT_SND_BUF_SIZE;
137 module_param (num_rcv_urbs, uint, 0444);
138 MODULE_PARM_DESC (num_rcv_urbs, "Number of urbs used for reception (range: 0-" __MODULE_STRING (UDSL_MAX_RCV_URBS) ", default: " __MODULE_STRING (UDSL_DEFAULT_RCV_URBS) ")");
140 module_param (num_snd_urbs, uint, 0444);
141 MODULE_PARM_DESC (num_snd_urbs, "Number of urbs used for transmission (range: 0-" __MODULE_STRING (UDSL_MAX_SND_URBS) ", default: " __MODULE_STRING (UDSL_DEFAULT_SND_URBS) ")");
143 module_param (num_rcv_bufs, uint, 0444);
144 MODULE_PARM_DESC (num_rcv_bufs, "Number of buffers used for reception (range: 0-" __MODULE_STRING (UDSL_MAX_RCV_BUFS) ", default: " __MODULE_STRING (UDSL_DEFAULT_RCV_BUFS) ")");
146 module_param (num_snd_bufs, uint, 0444);
147 MODULE_PARM_DESC (num_snd_bufs, "Number of buffers used for transmission (range: 0-" __MODULE_STRING (UDSL_MAX_SND_BUFS) ", default: " __MODULE_STRING (UDSL_DEFAULT_SND_BUFS) ")");
149 module_param (rcv_buf_size, uint, 0444);
150 MODULE_PARM_DESC (rcv_buf_size, "Size of the buffers used for reception (range: 0-" __MODULE_STRING (UDSL_MAX_RCV_BUF_SIZE) ", default: " __MODULE_STRING (UDSL_DEFAULT_RCV_BUF_SIZE) ")");
152 module_param (snd_buf_size, uint, 0444);
153 MODULE_PARM_DESC (snd_buf_size, "Size of the buffers used for transmission (range: 0-" __MODULE_STRING (UDSL_MAX_SND_BUF_SIZE) ", default: " __MODULE_STRING (UDSL_DEFAULT_SND_BUF_SIZE) ")");
155 #define UDSL_IOCTL_LINE_UP 1
156 #define UDSL_IOCTL_LINE_DOWN 2
158 #define UDSL_ENDPOINT_DATA_OUT 0x07
159 #define UDSL_ENDPOINT_DATA_IN 0x87
161 #define ATM_CELL_HEADER (ATM_CELL_SIZE - ATM_CELL_PAYLOAD)
162 #define UDSL_NUM_CELLS(x) (((x) + ATM_AAL5_TRAILER + ATM_CELL_PAYLOAD - 1) / ATM_CELL_PAYLOAD)
164 #define hex2int(c) ( (c >= '0') && (c <= '9') ? (c - '0') : ((c & 0xf) + 9) )
166 static struct usb_device_id udsl_usb_ids [] = {
167 { USB_DEVICE (SPEEDTOUCH_VENDORID, SPEEDTOUCH_PRODUCTID) },
171 MODULE_DEVICE_TABLE (usb, udsl_usb_ids);
175 struct udsl_receive_buffer {
176 struct list_head list;
178 unsigned int filled_cells;
181 struct udsl_receiver {
182 struct list_head list;
183 struct udsl_receive_buffer *buffer;
185 struct udsl_instance_data *instance;
188 struct udsl_vcc_data {
190 struct list_head list;
195 /* raw cell reassembly */
196 struct sk_buff *sarb;
201 struct udsl_send_buffer {
202 struct list_head list;
204 unsigned char *free_start;
205 unsigned int free_cells;
209 struct list_head list;
210 struct udsl_send_buffer *buffer;
212 struct udsl_instance_data *instance;
215 struct udsl_control {
216 struct atm_skb_data atm_data;
217 unsigned int num_cells;
218 unsigned int num_entire;
219 unsigned int pdu_padding;
220 unsigned char cell_header [ATM_CELL_HEADER];
221 unsigned char aal5_trailer [ATM_AAL5_TRAILER];
224 #define UDSL_SKB(x) ((struct udsl_control *)(x)->cb)
226 /* main driver data */
228 struct udsl_instance_data {
229 struct semaphore serialize;
231 /* USB device part */
232 struct usb_device *usb_dev;
233 char description [64];
236 /* ATM device part */
237 struct atm_dev *atm_dev;
238 struct list_head vcc_list;
241 struct udsl_receiver receivers [UDSL_MAX_RCV_URBS];
242 struct udsl_receive_buffer receive_buffers [UDSL_MAX_RCV_BUFS];
244 spinlock_t receive_lock;
245 struct list_head spare_receivers;
246 struct list_head filled_receive_buffers;
248 struct tasklet_struct receive_tasklet;
249 struct list_head spare_receive_buffers;
252 struct udsl_sender senders [UDSL_MAX_SND_URBS];
253 struct udsl_send_buffer send_buffers [UDSL_MAX_SND_BUFS];
255 struct sk_buff_head sndqueue;
257 spinlock_t send_lock;
258 struct list_head spare_senders;
259 struct list_head spare_send_buffers;
261 struct tasklet_struct send_tasklet;
262 struct sk_buff *current_skb; /* being emptied */
263 struct udsl_send_buffer *current_buffer; /* being filled */
264 struct list_head filled_send_buffers;
269 static void udsl_atm_dev_close (struct atm_dev *dev);
270 static int udsl_atm_open (struct atm_vcc *vcc);
271 static void udsl_atm_close (struct atm_vcc *vcc);
272 static int udsl_atm_ioctl (struct atm_dev *dev, unsigned int cmd, void __user *arg);
273 static int udsl_atm_send (struct atm_vcc *vcc, struct sk_buff *skb);
274 static int udsl_atm_proc_read (struct atm_dev *atm_dev, loff_t *pos, char *page);
276 static struct atmdev_ops udsl_atm_devops = {
277 .dev_close = udsl_atm_dev_close,
278 .open = udsl_atm_open,
279 .close = udsl_atm_close,
280 .ioctl = udsl_atm_ioctl,
281 .send = udsl_atm_send,
282 .proc_read = udsl_atm_proc_read,
283 .owner = THIS_MODULE,
288 static int udsl_usb_probe (struct usb_interface *intf, const struct usb_device_id *id);
289 static void udsl_usb_disconnect (struct usb_interface *intf);
290 static int udsl_usb_ioctl (struct usb_interface *intf, unsigned int code, void *user_data);
292 static struct usb_driver udsl_usb_driver = {
293 .owner = THIS_MODULE,
294 .name = udsl_driver_name,
295 .probe = udsl_usb_probe,
296 .disconnect = udsl_usb_disconnect,
297 .ioctl = udsl_usb_ioctl,
298 .id_table = udsl_usb_ids,
306 static inline void udsl_pop (struct atm_vcc *vcc, struct sk_buff *skb)
319 static inline struct udsl_vcc_data *udsl_find_vcc (struct udsl_instance_data *instance, short vpi, int vci)
321 struct udsl_vcc_data *vcc;
323 list_for_each_entry (vcc, &instance->vcc_list, list)
324 if ((vcc->vci == vci) && (vcc->vpi == vpi))
329 static void udsl_extract_cells (struct udsl_instance_data *instance, unsigned char *source, unsigned int howmany)
331 struct udsl_vcc_data *cached_vcc = NULL;
333 struct sk_buff *sarb;
334 struct udsl_vcc_data *vcc_data;
339 short cached_vpi = 0;
342 for (i = 0; i < howmany; i++, source += ATM_CELL_SIZE) {
343 vpi = ((source [0] & 0x0f) << 4) | (source [1] >> 4);
344 vci = ((source [1] & 0x0f) << 12) | (source [2] << 4) | (source [3] >> 4);
345 pti = (source [3] & 0x2) != 0;
347 vdbg ("udsl_extract_cells: vpi %hd, vci %d, pti %d", vpi, vci, pti);
349 if (cached_vcc && (vci == cached_vci) && (vpi == cached_vpi))
350 vcc_data = cached_vcc;
351 else if ((vcc_data = udsl_find_vcc (instance, vpi, vci))) {
352 cached_vcc = vcc_data;
356 dbg ("udsl_extract_cells: unknown vpi/vci (%hd/%d)!", vpi, vci);
361 sarb = vcc_data->sarb;
363 if (sarb->tail + ATM_CELL_PAYLOAD > sarb->end) {
364 dbg ("udsl_extract_cells: buffer overrun (sarb->len %u, vcc: 0x%p)!", sarb->len, vcc);
365 /* discard cells already received */
369 memcpy (sarb->tail, source + ATM_CELL_HEADER, ATM_CELL_PAYLOAD);
370 __skb_put (sarb, ATM_CELL_PAYLOAD);
375 unsigned int pdu_length;
377 length = (source [ATM_CELL_SIZE - 6] << 8) + source [ATM_CELL_SIZE - 5];
379 /* guard against overflow */
380 if (length > ATM_MAX_AAL5_PDU) {
381 dbg ("udsl_extract_cells: bogus length %u (vcc: 0x%p)!", length, vcc);
382 atomic_inc (&vcc->stats->rx_err);
386 pdu_length = UDSL_NUM_CELLS (length) * ATM_CELL_PAYLOAD;
388 if (sarb->len < pdu_length) {
389 dbg ("udsl_extract_cells: bogus pdu_length %u (sarb->len: %u, vcc: 0x%p)!", pdu_length, sarb->len, vcc);
390 atomic_inc (&vcc->stats->rx_err);
394 if (crc32_be (~0, sarb->tail - pdu_length, pdu_length) != 0xc704dd7b) {
395 dbg ("udsl_extract_cells: packet failed crc check (vcc: 0x%p)!", vcc);
396 atomic_inc (&vcc->stats->rx_err);
400 vdbg ("udsl_extract_cells: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", length, pdu_length, vcc);
402 if (!(skb = dev_alloc_skb (length))) {
403 dbg ("udsl_extract_cells: no memory for skb (length: %u)!", length);
404 atomic_inc (&vcc->stats->rx_drop);
408 vdbg ("udsl_extract_cells: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", skb, skb->truesize);
410 if (!atm_charge (vcc, skb->truesize)) {
411 dbg ("udsl_extract_cells: failed atm_charge (skb->truesize: %u)!", skb->truesize);
413 goto out; /* atm_charge increments rx_drop */
416 memcpy (skb->data, sarb->tail - pdu_length, length);
417 __skb_put (skb, length);
419 vdbg ("udsl_extract_cells: sending skb 0x%p, skb->len %u, skb->truesize %u", skb, skb->len, skb->truesize);
421 PACKETDEBUG (skb->data, skb->len);
423 vcc->push (vcc, skb);
425 atomic_inc (&vcc->stats->rx);
437 static const unsigned char zeros [ATM_CELL_PAYLOAD];
439 static void udsl_groom_skb (struct atm_vcc *vcc, struct sk_buff *skb)
441 struct udsl_control *ctrl = UDSL_SKB (skb);
442 unsigned int zero_padding;
445 ctrl->atm_data.vcc = vcc;
446 ctrl->cell_header [0] = vcc->vpi >> 4;
447 ctrl->cell_header [1] = (vcc->vpi << 4) | (vcc->vci >> 12);
448 ctrl->cell_header [2] = vcc->vci >> 4;
449 ctrl->cell_header [3] = vcc->vci << 4;
450 ctrl->cell_header [4] = 0xec;
452 ctrl->num_cells = UDSL_NUM_CELLS (skb->len);
453 ctrl->num_entire = skb->len / ATM_CELL_PAYLOAD;
455 zero_padding = ctrl->num_cells * ATM_CELL_PAYLOAD - skb->len - ATM_AAL5_TRAILER;
457 if (ctrl->num_entire + 1 < ctrl->num_cells)
458 ctrl->pdu_padding = zero_padding - (ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
460 ctrl->pdu_padding = zero_padding;
462 ctrl->aal5_trailer [0] = 0; /* UU = 0 */
463 ctrl->aal5_trailer [1] = 0; /* CPI = 0 */
464 ctrl->aal5_trailer [2] = skb->len >> 8;
465 ctrl->aal5_trailer [3] = skb->len;
467 crc = crc32_be (~0, skb->data, skb->len);
468 crc = crc32_be (crc, zeros, zero_padding);
469 crc = crc32_be (crc, ctrl->aal5_trailer, 4);
472 ctrl->aal5_trailer [4] = crc >> 24;
473 ctrl->aal5_trailer [5] = crc >> 16;
474 ctrl->aal5_trailer [6] = crc >> 8;
475 ctrl->aal5_trailer [7] = crc;
478 static unsigned int udsl_write_cells (unsigned int howmany, struct sk_buff *skb, unsigned char **target_p)
480 struct udsl_control *ctrl = UDSL_SKB (skb);
481 unsigned char *target = *target_p;
482 unsigned int nc, ne, i;
484 vdbg ("udsl_write_cells: howmany=%u, skb->len=%d, num_cells=%u, num_entire=%u, pdu_padding=%u", howmany, skb->len, ctrl->num_cells, ctrl->num_entire, ctrl->pdu_padding);
486 nc = ctrl->num_cells;
487 ne = min (howmany, ctrl->num_entire);
489 for (i = 0; i < ne; i++) {
490 memcpy (target, ctrl->cell_header, ATM_CELL_HEADER);
491 target += ATM_CELL_HEADER;
492 memcpy (target, skb->data, ATM_CELL_PAYLOAD);
493 target += ATM_CELL_PAYLOAD;
494 __skb_pull (skb, ATM_CELL_PAYLOAD);
497 ctrl->num_entire -= ne;
499 if (!(ctrl->num_cells -= ne) || !(howmany -= ne))
502 memcpy (target, ctrl->cell_header, ATM_CELL_HEADER);
503 target += ATM_CELL_HEADER;
504 memcpy (target, skb->data, skb->len);
506 __skb_pull (skb, skb->len);
507 memset (target, 0, ctrl->pdu_padding);
508 target += ctrl->pdu_padding;
510 if (--ctrl->num_cells) {
512 ctrl->pdu_padding = ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER;
516 memcpy (target, ctrl->cell_header, ATM_CELL_HEADER);
517 target += ATM_CELL_HEADER;
518 memset (target, 0, ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER);
519 target += ATM_CELL_PAYLOAD - ATM_AAL5_TRAILER;
521 DEBUG_ON (--ctrl->num_cells);
524 memcpy (target, ctrl->aal5_trailer, ATM_AAL5_TRAILER);
525 target += ATM_AAL5_TRAILER;
526 /* set pti bit in last cell */
527 *(target + 3 - ATM_CELL_SIZE) |= 0x2;
531 return nc - ctrl->num_cells;
539 static void udsl_complete_receive (struct urb *urb, struct pt_regs *regs)
541 struct udsl_receive_buffer *buf;
542 struct udsl_instance_data *instance;
543 struct udsl_receiver *rcv;
546 if (!urb || !(rcv = urb->context)) {
547 dbg ("udsl_complete_receive: bad urb!");
551 instance = rcv->instance;
554 buf->filled_cells = urb->actual_length / ATM_CELL_SIZE;
556 vdbg ("udsl_complete_receive: urb 0x%p, status %d, actual_length %d, filled_cells %u, rcv 0x%p, buf 0x%p", urb, urb->status, urb->actual_length, buf->filled_cells, rcv, buf);
558 DEBUG_ON (buf->filled_cells > rcv_buf_size);
560 /* may not be in_interrupt() */
561 spin_lock_irqsave (&instance->receive_lock, flags);
562 list_add (&rcv->list, &instance->spare_receivers);
563 list_add_tail (&buf->list, &instance->filled_receive_buffers);
564 if (likely (!urb->status))
565 tasklet_schedule (&instance->receive_tasklet);
566 spin_unlock_irqrestore (&instance->receive_lock, flags);
569 static void udsl_process_receive (unsigned long data)
571 struct udsl_receive_buffer *buf;
572 struct udsl_instance_data *instance = (struct udsl_instance_data *) data;
573 struct udsl_receiver *rcv;
577 while (!list_empty (&instance->spare_receive_buffers)) {
578 spin_lock_irq (&instance->receive_lock);
579 if (list_empty (&instance->spare_receivers)) {
580 spin_unlock_irq (&instance->receive_lock);
583 rcv = list_entry (instance->spare_receivers.next, struct udsl_receiver, list);
584 list_del (&rcv->list);
585 spin_unlock_irq (&instance->receive_lock);
587 buf = list_entry (instance->spare_receive_buffers.next, struct udsl_receive_buffer, list);
588 list_del (&buf->list);
592 usb_fill_bulk_urb (rcv->urb,
594 usb_rcvbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_IN),
596 rcv_buf_size * ATM_CELL_SIZE,
597 udsl_complete_receive,
600 vdbg ("udsl_process_receive: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
602 if ((err = usb_submit_urb(rcv->urb, GFP_ATOMIC)) < 0) {
603 dbg ("udsl_process_receive: urb submission failed (%d)!", err);
604 list_add (&buf->list, &instance->spare_receive_buffers);
605 spin_lock_irq (&instance->receive_lock);
606 list_add (&rcv->list, &instance->spare_receivers);
607 spin_unlock_irq (&instance->receive_lock);
612 spin_lock_irq (&instance->receive_lock);
613 if (list_empty (&instance->filled_receive_buffers)) {
614 spin_unlock_irq (&instance->receive_lock);
615 return; /* done - no more buffers */
617 buf = list_entry (instance->filled_receive_buffers.next, struct udsl_receive_buffer, list);
618 list_del (&buf->list);
619 spin_unlock_irq (&instance->receive_lock);
620 vdbg ("udsl_process_receive: processing buf 0x%p", buf);
621 udsl_extract_cells (instance, buf->base, buf->filled_cells);
622 list_add (&buf->list, &instance->spare_receive_buffers);
631 static void udsl_complete_send (struct urb *urb, struct pt_regs *regs)
633 struct udsl_instance_data *instance;
634 struct udsl_sender *snd;
637 if (!urb || !(snd = urb->context) || !(instance = snd->instance)) {
638 dbg ("udsl_complete_send: bad urb!");
642 vdbg ("udsl_complete_send: urb 0x%p, status %d, snd 0x%p, buf 0x%p", urb, urb->status, snd, snd->buffer);
644 /* may not be in_interrupt() */
645 spin_lock_irqsave (&instance->send_lock, flags);
646 list_add (&snd->list, &instance->spare_senders);
647 list_add (&snd->buffer->list, &instance->spare_send_buffers);
648 tasklet_schedule (&instance->send_tasklet);
649 spin_unlock_irqrestore (&instance->send_lock, flags);
652 static void udsl_process_send (unsigned long data)
654 struct udsl_send_buffer *buf;
655 struct udsl_instance_data *instance = (struct udsl_instance_data *) data;
657 struct udsl_sender *snd;
659 unsigned int num_written;
662 spin_lock_irq (&instance->send_lock);
663 while (!list_empty (&instance->spare_senders)) {
664 if (!list_empty (&instance->filled_send_buffers)) {
665 buf = list_entry (instance->filled_send_buffers.next, struct udsl_send_buffer, list);
666 list_del (&buf->list);
667 } else if ((buf = instance->current_buffer)) {
668 instance->current_buffer = NULL;
669 } else /* all buffers empty */
672 snd = list_entry (instance->spare_senders.next, struct udsl_sender, list);
673 list_del (&snd->list);
674 spin_unlock_irq (&instance->send_lock);
677 usb_fill_bulk_urb (snd->urb,
679 usb_sndbulkpipe (instance->usb_dev, UDSL_ENDPOINT_DATA_OUT),
681 (snd_buf_size - buf->free_cells) * ATM_CELL_SIZE,
685 vdbg ("udsl_process_send: submitting urb 0x%p (%d cells), snd 0x%p, buf 0x%p", snd->urb, snd_buf_size - buf->free_cells, snd, buf);
687 if ((err = usb_submit_urb(snd->urb, GFP_ATOMIC)) < 0) {
688 dbg ("udsl_process_send: urb submission failed (%d)!", err);
689 spin_lock_irq (&instance->send_lock);
690 list_add (&snd->list, &instance->spare_senders);
691 spin_unlock_irq (&instance->send_lock);
692 list_add (&buf->list, &instance->filled_send_buffers);
693 return; /* bail out */
696 spin_lock_irq (&instance->send_lock);
698 spin_unlock_irq (&instance->send_lock);
700 if (!instance->current_skb && !(instance->current_skb = skb_dequeue (&instance->sndqueue)))
701 return; /* done - no more skbs */
703 skb = instance->current_skb;
705 if (!(buf = instance->current_buffer)) {
706 spin_lock_irq (&instance->send_lock);
707 if (list_empty (&instance->spare_send_buffers)) {
708 instance->current_buffer = NULL;
709 spin_unlock_irq (&instance->send_lock);
710 return; /* done - no more buffers */
712 buf = list_entry (instance->spare_send_buffers.next, struct udsl_send_buffer, list);
713 list_del (&buf->list);
714 spin_unlock_irq (&instance->send_lock);
716 buf->free_start = buf->base;
717 buf->free_cells = snd_buf_size;
719 instance->current_buffer = buf;
722 num_written = udsl_write_cells (buf->free_cells, skb, &buf->free_start);
724 vdbg ("udsl_process_send: wrote %u cells from skb 0x%p to buffer 0x%p", num_written, skb, buf);
726 if (!(buf->free_cells -= num_written)) {
727 list_add_tail (&buf->list, &instance->filled_send_buffers);
728 instance->current_buffer = NULL;
731 vdbg ("udsl_process_send: buffer contains %d cells, %d left", snd_buf_size - buf->free_cells, buf->free_cells);
733 if (!UDSL_SKB (skb)->num_cells) {
734 struct atm_vcc *vcc = UDSL_SKB (skb)->atm_data.vcc;
737 instance->current_skb = NULL;
739 atomic_inc (&vcc->stats->tx);
745 static void udsl_cancel_send (struct udsl_instance_data *instance, struct atm_vcc *vcc)
747 struct sk_buff *skb, *n;
749 dbg ("udsl_cancel_send entered");
750 spin_lock_irq (&instance->sndqueue.lock);
751 for (skb = instance->sndqueue.next, n = skb->next; skb != (struct sk_buff *)&instance->sndqueue; skb = n, n = skb->next)
752 if (UDSL_SKB (skb)->atm_data.vcc == vcc) {
753 dbg ("udsl_cancel_send: popping skb 0x%p", skb);
754 __skb_unlink (skb, &instance->sndqueue);
757 spin_unlock_irq (&instance->sndqueue.lock);
759 tasklet_disable (&instance->send_tasklet);
760 if ((skb = instance->current_skb) && (UDSL_SKB (skb)->atm_data.vcc == vcc)) {
761 dbg ("udsl_cancel_send: popping current skb (0x%p)", skb);
762 instance->current_skb = NULL;
765 tasklet_enable (&instance->send_tasklet);
766 dbg ("udsl_cancel_send done");
769 static int udsl_atm_send (struct atm_vcc *vcc, struct sk_buff *skb)
771 struct udsl_instance_data *instance = vcc->dev->dev_data;
774 vdbg ("udsl_atm_send called (skb 0x%p, len %u)", skb, skb->len);
776 if (!instance || !instance->usb_dev) {
777 dbg ("udsl_atm_send: NULL data!");
782 if (vcc->qos.aal != ATM_AAL5) {
783 dbg ("udsl_atm_send: unsupported ATM type %d!", vcc->qos.aal);
788 if (skb->len > ATM_MAX_AAL5_PDU) {
789 dbg ("udsl_atm_send: packet too long (%d vs %d)!", skb->len, ATM_MAX_AAL5_PDU);
794 PACKETDEBUG (skb->data, skb->len);
796 udsl_groom_skb (vcc, skb);
797 skb_queue_tail (&instance->sndqueue, skb);
798 tasklet_schedule (&instance->send_tasklet);
812 static void udsl_atm_dev_close (struct atm_dev *dev)
814 struct udsl_instance_data *instance = dev->dev_data;
817 dbg ("udsl_atm_dev_close: NULL instance!");
821 dbg ("udsl_atm_dev_close: queue has %u elements", instance->sndqueue.qlen);
823 tasklet_kill (&instance->receive_tasklet);
824 tasklet_kill (&instance->send_tasklet);
826 dev->dev_data = NULL;
829 static int udsl_atm_proc_read (struct atm_dev *atm_dev, loff_t *pos, char *page)
831 struct udsl_instance_data *instance = atm_dev->dev_data;
835 dbg ("udsl_atm_proc_read: NULL instance!");
840 return sprintf (page, "%s\n", instance->description);
843 return sprintf (page, "MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
844 atm_dev->esi [0], atm_dev->esi [1], atm_dev->esi [2],
845 atm_dev->esi [3], atm_dev->esi [4], atm_dev->esi [5]);
848 return sprintf (page, "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
849 atomic_read (&atm_dev->stats.aal5.tx),
850 atomic_read (&atm_dev->stats.aal5.tx_err),
851 atomic_read (&atm_dev->stats.aal5.rx),
852 atomic_read (&atm_dev->stats.aal5.rx_err),
853 atomic_read (&atm_dev->stats.aal5.rx_drop));
856 switch (atm_dev->signal) {
857 case ATM_PHY_SIG_FOUND:
858 sprintf (page, "Line up");
860 case ATM_PHY_SIG_LOST:
861 sprintf (page, "Line down");
864 sprintf (page, "Line state unknown");
868 if (instance->usb_dev) {
869 if (!instance->firmware_loaded)
870 strcat (page, ", no firmware\n");
872 strcat (page, ", firmware loaded\n");
874 strcat (page, ", disconnected\n");
876 return strlen (page);
882 static int udsl_atm_open (struct atm_vcc *vcc)
884 struct udsl_instance_data *instance = vcc->dev->dev_data;
885 struct udsl_vcc_data *new;
886 unsigned int max_pdu;
888 short vpi = vcc->vpi;
890 dbg ("udsl_atm_open: vpi %hd, vci %d", vpi, vci);
892 if (!instance || !instance->usb_dev) {
893 dbg ("udsl_atm_open: NULL data!");
897 /* only support AAL5 */
898 if ((vcc->qos.aal != ATM_AAL5) || (vcc->qos.rxtp.max_sdu < 0) || (vcc->qos.rxtp.max_sdu > ATM_MAX_AAL5_PDU)) {
899 dbg ("udsl_atm_open: unsupported ATM type %d!", vcc->qos.aal);
903 if (!instance->firmware_loaded) {
904 dbg ("udsl_atm_open: firmware not loaded!");
908 down (&instance->serialize); /* vs self, udsl_atm_close */
910 if (udsl_find_vcc (instance, vpi, vci)) {
911 dbg ("udsl_atm_open: %hd/%d already in use!", vpi, vci);
912 up (&instance->serialize);
916 if (!(new = kmalloc (sizeof (struct udsl_vcc_data), GFP_KERNEL))) {
917 dbg ("udsl_atm_open: no memory for vcc_data!");
918 up (&instance->serialize);
922 memset (new, 0, sizeof (struct udsl_vcc_data));
927 /* udsl_extract_cells requires at least one cell */
928 max_pdu = max (1, UDSL_NUM_CELLS (vcc->qos.rxtp.max_sdu)) * ATM_CELL_PAYLOAD;
929 if (!(new->sarb = alloc_skb (max_pdu, GFP_KERNEL))) {
930 dbg ("udsl_atm_open: no memory for SAR buffer!");
932 up (&instance->serialize);
938 tasklet_disable (&instance->receive_tasklet);
939 list_add (&new->list, &instance->vcc_list);
940 tasklet_enable (&instance->receive_tasklet);
942 set_bit (ATM_VF_ADDR, &vcc->flags);
943 set_bit (ATM_VF_PARTIAL, &vcc->flags);
944 set_bit (ATM_VF_READY, &vcc->flags);
946 up (&instance->serialize);
948 tasklet_schedule (&instance->receive_tasklet);
950 dbg ("udsl_atm_open: allocated vcc data 0x%p (max_pdu: %u)", new, max_pdu);
955 static void udsl_atm_close (struct atm_vcc *vcc)
957 struct udsl_instance_data *instance = vcc->dev->dev_data;
958 struct udsl_vcc_data *vcc_data = vcc->dev_data;
960 dbg ("udsl_atm_close called");
962 if (!instance || !vcc_data) {
963 dbg ("udsl_atm_close: NULL data!");
967 dbg ("udsl_atm_close: deallocating vcc 0x%p with vpi %d vci %d", vcc_data, vcc_data->vpi, vcc_data->vci);
969 udsl_cancel_send (instance, vcc);
971 down (&instance->serialize); /* vs self, udsl_atm_open */
973 tasklet_disable (&instance->receive_tasklet);
974 list_del (&vcc_data->list);
975 tasklet_enable (&instance->receive_tasklet);
977 kfree_skb (vcc_data->sarb);
978 vcc_data->sarb = NULL;
981 vcc->dev_data = NULL;
983 vcc->vpi = ATM_VPI_UNSPEC;
984 vcc->vci = ATM_VCI_UNSPEC;
985 clear_bit (ATM_VF_READY, &vcc->flags);
986 clear_bit (ATM_VF_PARTIAL, &vcc->flags);
987 clear_bit (ATM_VF_ADDR, &vcc->flags);
989 up (&instance->serialize);
991 dbg ("udsl_atm_close successful");
994 static int udsl_atm_ioctl (struct atm_dev *dev, unsigned int cmd, void __user *arg)
998 return put_user (ATM_LM_NONE, (int __user *)arg) ? -EFAULT : 0;
1000 return -ENOIOCTLCMD;
1009 static int udsl_set_alternate (struct udsl_instance_data *instance)
1011 down (&instance->serialize); /* vs self */
1012 if (!instance->firmware_loaded) {
1015 if ((ret = usb_set_interface (instance->usb_dev, 1, 1)) < 0) {
1016 dbg ("udsl_set_alternate: usb_set_interface returned %d!", ret);
1017 up (&instance->serialize);
1020 instance->firmware_loaded = 1;
1022 up (&instance->serialize);
1024 tasklet_schedule (&instance->receive_tasklet);
1029 static int udsl_usb_ioctl (struct usb_interface *intf, unsigned int code, void *user_data)
1031 struct udsl_instance_data *instance = usb_get_intfdata (intf);
1033 dbg ("udsl_usb_ioctl entered");
1036 dbg ("udsl_usb_ioctl: NULL instance!");
1041 case UDSL_IOCTL_LINE_UP:
1042 instance->atm_dev->signal = ATM_PHY_SIG_FOUND;
1043 return udsl_set_alternate (instance);
1044 case UDSL_IOCTL_LINE_DOWN:
1045 instance->atm_dev->signal = ATM_PHY_SIG_LOST;
1052 static int udsl_usb_probe (struct usb_interface *intf, const struct usb_device_id *id)
1054 struct usb_device *dev = interface_to_usbdev(intf);
1055 int ifnum = intf->altsetting->desc.bInterfaceNumber;
1056 struct udsl_instance_data *instance;
1057 unsigned char mac_str [13];
1061 dbg ("udsl_usb_probe: trying device with vendor=0x%x, product=0x%x, ifnum %d",
1062 dev->descriptor.idVendor, dev->descriptor.idProduct, ifnum);
1064 if ((dev->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) ||
1065 (dev->descriptor.idVendor != SPEEDTOUCH_VENDORID) ||
1066 (dev->descriptor.idProduct != SPEEDTOUCH_PRODUCTID) || (ifnum != 1))
1069 dbg ("udsl_usb_probe: device accepted");
1072 if (!(instance = kmalloc (sizeof (struct udsl_instance_data), GFP_KERNEL))) {
1073 dbg ("udsl_usb_probe: no memory for instance data!");
1077 memset (instance, 0, sizeof (struct udsl_instance_data));
1079 init_MUTEX (&instance->serialize);
1081 instance->usb_dev = dev;
1083 INIT_LIST_HEAD (&instance->vcc_list);
1085 spin_lock_init (&instance->receive_lock);
1086 INIT_LIST_HEAD (&instance->spare_receivers);
1087 INIT_LIST_HEAD (&instance->filled_receive_buffers);
1089 tasklet_init (&instance->receive_tasklet, udsl_process_receive, (unsigned long) instance);
1090 INIT_LIST_HEAD (&instance->spare_receive_buffers);
1092 skb_queue_head_init (&instance->sndqueue);
1094 spin_lock_init (&instance->send_lock);
1095 INIT_LIST_HEAD (&instance->spare_senders);
1096 INIT_LIST_HEAD (&instance->spare_send_buffers);
1098 tasklet_init (&instance->send_tasklet, udsl_process_send, (unsigned long) instance);
1099 INIT_LIST_HEAD (&instance->filled_send_buffers);
1102 for (i = 0; i < num_rcv_urbs; i++) {
1103 struct udsl_receiver *rcv = &(instance->receivers [i]);
1105 if (!(rcv->urb = usb_alloc_urb (0, GFP_KERNEL))) {
1106 dbg ("udsl_usb_probe: no memory for receive urb %d!", i);
1110 rcv->instance = instance;
1112 list_add (&rcv->list, &instance->spare_receivers);
1115 for (i = 0; i < num_rcv_bufs; i++) {
1116 struct udsl_receive_buffer *buf = &(instance->receive_buffers [i]);
1118 if (!(buf->base = kmalloc (rcv_buf_size * ATM_CELL_SIZE, GFP_KERNEL))) {
1119 dbg ("udsl_usb_probe: no memory for receive buffer %d!", i);
1123 list_add (&buf->list, &instance->spare_receive_buffers);
1127 for (i = 0; i < num_snd_urbs; i++) {
1128 struct udsl_sender *snd = &(instance->senders [i]);
1130 if (!(snd->urb = usb_alloc_urb (0, GFP_KERNEL))) {
1131 dbg ("udsl_usb_probe: no memory for send urb %d!", i);
1135 snd->instance = instance;
1137 list_add (&snd->list, &instance->spare_senders);
1140 for (i = 0; i < num_snd_bufs; i++) {
1141 struct udsl_send_buffer *buf = &(instance->send_buffers [i]);
1143 if (!(buf->base = kmalloc (snd_buf_size * ATM_CELL_SIZE, GFP_KERNEL))) {
1144 dbg ("udsl_usb_probe: no memory for send buffer %d!", i);
1148 list_add (&buf->list, &instance->spare_send_buffers);
1152 if (!(instance->atm_dev = atm_dev_register (udsl_driver_name, &udsl_atm_devops, -1, NULL))) {
1153 dbg ("udsl_usb_probe: failed to register ATM device!");
1157 instance->atm_dev->ci_range.vpi_bits = ATM_CI_MAX;
1158 instance->atm_dev->ci_range.vci_bits = ATM_CI_MAX;
1159 instance->atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
1161 /* temp init ATM device, set to 128kbit */
1162 instance->atm_dev->link_rate = 128 * 1000 / 424;
1164 /* set MAC address, it is stored in the serial number */
1165 memset (instance->atm_dev->esi, 0, sizeof (instance->atm_dev->esi));
1166 if (usb_string (dev, dev->descriptor.iSerialNumber, mac_str, sizeof (mac_str)) == 12)
1167 for (i = 0; i < 6; i++)
1168 instance->atm_dev->esi [i] = (hex2int (mac_str [i * 2]) * 16) + (hex2int (mac_str [i * 2 + 1]));
1170 /* device description */
1171 buf = instance->description;
1172 length = sizeof (instance->description);
1174 if ((i = usb_string (dev, dev->descriptor.iProduct, buf, length)) < 0)
1180 i = scnprintf (buf, length, " (");
1184 if (length <= 0 || (i = usb_make_path (dev, buf, length)) < 0)
1190 snprintf (buf, length, ")");
1193 /* ready for ATM callbacks */
1195 instance->atm_dev->dev_data = instance;
1197 usb_set_intfdata (intf, instance);
1202 for (i = 0; i < num_snd_bufs; i++)
1203 kfree (instance->send_buffers [i].base);
1205 for (i = 0; i < num_snd_urbs; i++)
1206 usb_free_urb (instance->senders [i].urb);
1208 for (i = 0; i < num_rcv_bufs; i++)
1209 kfree (instance->receive_buffers [i].base);
1211 for (i = 0; i < num_rcv_urbs; i++)
1212 usb_free_urb (instance->receivers [i].urb);
1219 static void udsl_usb_disconnect (struct usb_interface *intf)
1221 struct udsl_instance_data *instance = usb_get_intfdata (intf);
1222 struct list_head *pos;
1226 dbg ("udsl_usb_disconnect entered");
1228 usb_set_intfdata (intf, NULL);
1231 dbg ("udsl_usb_disconnect: NULL instance!");
1235 /* receive finalize */
1236 tasklet_disable (&instance->receive_tasklet);
1238 for (i = 0; i < num_rcv_urbs; i++)
1239 if ((result = usb_unlink_urb (instance->receivers [i].urb)) < 0)
1240 dbg ("udsl_usb_disconnect: usb_unlink_urb on receive urb %d returned %d!", i, result);
1242 /* wait for completion handlers to finish */
1245 spin_lock_irq (&instance->receive_lock);
1246 list_for_each (pos, &instance->spare_receivers)
1247 DEBUG_ON (++count > num_rcv_urbs);
1248 spin_unlock_irq (&instance->receive_lock);
1250 dbg ("udsl_usb_disconnect: found %u spare receivers", count);
1252 if (count == num_rcv_urbs)
1255 set_current_state (TASK_RUNNING);
1259 /* no need to take the spinlock */
1260 INIT_LIST_HEAD (&instance->filled_receive_buffers);
1261 INIT_LIST_HEAD (&instance->spare_receive_buffers);
1263 tasklet_enable (&instance->receive_tasklet);
1265 for (i = 0; i < num_rcv_urbs; i++)
1266 usb_free_urb (instance->receivers [i].urb);
1268 for (i = 0; i < num_rcv_bufs; i++)
1269 kfree (instance->receive_buffers [i].base);
1272 tasklet_disable (&instance->send_tasklet);
1274 for (i = 0; i < num_snd_urbs; i++)
1275 if ((result = usb_unlink_urb (instance->senders [i].urb)) < 0)
1276 dbg ("udsl_usb_disconnect: usb_unlink_urb on send urb %d returned %d!", i, result);
1278 /* wait for completion handlers to finish */
1281 spin_lock_irq (&instance->send_lock);
1282 list_for_each (pos, &instance->spare_senders)
1283 DEBUG_ON (++count > num_snd_urbs);
1284 spin_unlock_irq (&instance->send_lock);
1286 dbg ("udsl_usb_disconnect: found %u spare senders", count);
1288 if (count == num_snd_urbs)
1291 set_current_state (TASK_RUNNING);
1295 /* no need to take the spinlock */
1296 INIT_LIST_HEAD (&instance->spare_senders);
1297 INIT_LIST_HEAD (&instance->spare_send_buffers);
1298 instance->current_buffer = NULL;
1300 tasklet_enable (&instance->send_tasklet);
1302 for (i = 0; i < num_snd_urbs; i++)
1303 usb_free_urb (instance->senders [i].urb);
1305 for (i = 0; i < num_snd_bufs; i++)
1306 kfree (instance->send_buffers [i].base);
1309 instance->usb_dev = NULL;
1312 shutdown_atm_dev (instance->atm_dev); /* frees instance, kills tasklets */
1320 static int __init udsl_usb_init (void)
1322 dbg ("udsl_usb_init: driver version " DRIVER_VERSION);
1324 if (sizeof (struct udsl_control) > sizeof (((struct sk_buff *)0)->cb)) {
1325 printk (KERN_ERR __FILE__ ": unusable with this kernel!\n");
1329 if ((num_rcv_urbs > UDSL_MAX_RCV_URBS) || (num_snd_urbs > UDSL_MAX_SND_URBS) ||
1330 (num_rcv_bufs > UDSL_MAX_RCV_BUFS) || (num_snd_bufs > UDSL_MAX_SND_BUFS) ||
1331 (rcv_buf_size > UDSL_MAX_RCV_BUF_SIZE) || (snd_buf_size > UDSL_MAX_SND_BUF_SIZE))
1334 return usb_register (&udsl_usb_driver);
1337 static void __exit udsl_usb_cleanup (void)
1339 dbg ("udsl_usb_cleanup entered");
1341 usb_deregister (&udsl_usb_driver);
1344 module_init (udsl_usb_init);
1345 module_exit (udsl_usb_cleanup);
1347 MODULE_AUTHOR (DRIVER_AUTHOR);
1348 MODULE_DESCRIPTION (DRIVER_DESC);
1349 MODULE_LICENSE ("GPL");
1350 MODULE_VERSION (DRIVER_VERSION);
1357 #ifdef VERBOSE_DEBUG
1358 static int udsl_print_packet (const unsigned char *data, int len)
1360 unsigned char buffer [256];
1363 for (i = 0; i < len;) {
1365 sprintf (buffer, "%.3d :", i);
1366 for (j = 0; (j < 16) && (i < len); j++, i++) {
1367 sprintf (buffer, "%s %2.2x", buffer, data [i]);