?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / usb / misc / auerswald.c
blobdf7e1ecc810a18acf4f41d8e6d11746fc88873b5
1 /*****************************************************************************/
2 /*
3 * auerswald.c -- Auerswald PBX/System Telephone usb driver.
4 *
5 * Copyright (C) 2001 Wolfgang Mües (wolfgang@iksw-muees.de)
6 *
7 * Very much code of this driver is borrowed from dabusb.c (Deti Fliegl)
8 * and from the USB Skeleton driver (Greg Kroah-Hartman). Thank you.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24 /*****************************************************************************/
25
26 /* Standard Linux module include files */
27 #include <asm/uaccess.h>
28 #include <asm/byteorder.h>
29 #include <linux/slab.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/wait.h>
33 #include <linux/usb.h>
34
35 /*-------------------------------------------------------------------*/
36 /* Debug support */
37 #ifdef DEBUG
38 #define dump( adr, len) \
39 do { \
40 unsigned int u; \
41 printk (KERN_DEBUG); \
42 for (u = 0; u < len; u++) \
43 printk (" %02X", adr[u] & 0xFF); \
44 printk ("\n"); \
45 } while (0)
46 #else
47 #define dump( adr, len)
48 #endif
49
50 /*-------------------------------------------------------------------*/
51 /* Version Information */
52 #define DRIVER_VERSION "0.9.11"
53 #define DRIVER_AUTHOR "Wolfgang Mües <wolfgang@iksw-muees.de>"
54 #define DRIVER_DESC "Auerswald PBX/System Telephone usb driver"
55
56 /*-------------------------------------------------------------------*/
57 /* Private declarations for Auerswald USB driver */
58
59 /* Auerswald Vendor ID */
60 #define ID_AUERSWALD 0x09BF
61
62 #define AUER_MINOR_BASE 112 /* auerswald driver minor number */
63
64 /* we can have up to this number of device plugged in at once */
65 #define AUER_MAX_DEVICES 16
66
67
68 /* Number of read buffers for each device */
69 #define AU_RBUFFERS 10
70
71 /* Number of chain elements for each control chain */
72 #define AUCH_ELEMENTS 20
73
74 /* Number of retries in communication */
75 #define AU_RETRIES 10
76
77 /*-------------------------------------------------------------------*/
78 /* vendor specific protocol */
79 /* Header Byte */
80 #define AUH_INDIRMASK 0x80 /* mask for direct/indirect bit */
81 #define AUH_DIRECT 0x00 /* data is for USB device */
82 #define AUH_INDIRECT 0x80 /* USB device is relay */
83
84 #define AUH_SPLITMASK 0x40 /* mask for split bit */
85 #define AUH_UNSPLIT 0x00 /* data block is full-size */
86 #define AUH_SPLIT 0x40 /* data block is part of a larger one,
87 split-byte follows */
88
89 #define AUH_TYPEMASK 0x3F /* mask for type of data transfer */
90 #define AUH_TYPESIZE 0x40 /* different types */
91 #define AUH_DCHANNEL 0x00 /* D channel data */
92 #define AUH_B1CHANNEL 0x01 /* B1 channel transparent */
93 #define AUH_B2CHANNEL 0x02 /* B2 channel transparent */
94 /* 0x03..0x0F reserved for driver internal use */
95 #define AUH_COMMAND 0x10 /* Command channel */
96 #define AUH_BPROT 0x11 /* Configuration block protocol */
97 #define AUH_DPROTANA 0x12 /* D channel protocol analyzer */
98 #define AUH_TAPI 0x13 /* telephone api data (ATD) */
99 /* 0x14..0x3F reserved for other protocols */
100 #define AUH_UNASSIGNED 0xFF /* if char device has no assigned service */
101 #define AUH_FIRSTUSERCH 0x11 /* first channel which is available for driver users */
102
103 #define AUH_SIZE 1 /* Size of Header Byte */
104
105 /* Split Byte. Only present if split bit in header byte set.*/
106 #define AUS_STARTMASK 0x80 /* mask for first block of splitted frame */
107 #define AUS_FIRST 0x80 /* first block */
108 #define AUS_FOLLOW 0x00 /* following block */
109
110 #define AUS_ENDMASK 0x40 /* mask for last block of splitted frame */
111 #define AUS_END 0x40 /* last block */
112 #define AUS_NOEND 0x00 /* not the last block */
113
114 #define AUS_LENMASK 0x3F /* mask for block length information */
115
116 /* Request types */
117 #define AUT_RREQ (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER) /* Read Request */
118 #define AUT_WREQ (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER) /* Write Request */
119
120 /* Vendor Requests */
121 #define AUV_GETINFO 0x00 /* GetDeviceInfo */
122 #define AUV_WBLOCK 0x01 /* Write Block */
123 #define AUV_RBLOCK 0x02 /* Read Block */
124 #define AUV_CHANNELCTL 0x03 /* Channel Control */
125 #define AUV_DUMMY 0x04 /* Dummy Out for retry */
126
127 /* Device Info Types */
128 #define AUDI_NUMBCH 0x0000 /* Number of supported B channels */
129 #define AUDI_OUTFSIZE 0x0001 /* Size of OUT B channel fifos */
130 #define AUDI_MBCTRANS 0x0002 /* max. Blocklength of control transfer */
131
132 /* Interrupt endpoint definitions */
133 #define AU_IRQENDP 1 /* Endpoint number */
134 #define AU_IRQCMDID 16 /* Command-block ID */
135 #define AU_BLOCKRDY 0 /* Command: Block data ready on ctl endpoint */
136 #define AU_IRQMINSIZE 5 /* Nr. of bytes decoded in this driver */
137
138 /* Device String Descriptors */
139 #define AUSI_VENDOR 1 /* "Auerswald GmbH & Co. KG" */
140 #define AUSI_DEVICE 2 /* Name of the Device */
141 #define AUSI_SERIALNR 3 /* Serial Number */
142 #define AUSI_MSN 4 /* "MSN ..." (first) Multiple Subscriber Number */
143
144 #define AUSI_DLEN 100 /* Max. Length of Device Description */
145
146 #define AUV_RETRY 0x101 /* First Firmware version which can do control retries */
147
148 /*-------------------------------------------------------------------*/
149 /* External data structures / Interface */
150 typedef struct
151 {
152 char __user *buf; /* return buffer for string contents */
153 unsigned int bsize; /* size of return buffer */
154 } audevinfo_t,*paudevinfo_t;
155
156 /* IO controls */
157 #define IOCTL_AU_SLEN _IOR( 'U', 0xF0, int) /* return the max. string descriptor length */
158 #define IOCTL_AU_DEVINFO _IOWR('U', 0xF1, audevinfo_t) /* get name of a specific device */
159 #define IOCTL_AU_SERVREQ _IOW( 'U', 0xF2, int) /* request a service channel */
160 #define IOCTL_AU_BUFLEN _IOR( 'U', 0xF3, int) /* return the max. buffer length for the device */
161 #define IOCTL_AU_RXAVAIL _IOR( 'U', 0xF4, int) /* return != 0 if Receive Data available */
162 #define IOCTL_AU_CONNECT _IOR( 'U', 0xF5, int) /* return != 0 if connected to a service channel */
163 #define IOCTL_AU_TXREADY _IOR( 'U', 0xF6, int) /* return != 0 if Transmitt channel ready to send */
164 /* 'U' 0xF7..0xFF reseved */
165
166 /*-------------------------------------------------------------------*/
167 /* Internal data structures */
168
169 /* ..................................................................*/
170 /* urb chain element */
171 struct auerchain; /* forward for circular reference */
172 typedef struct
173 {
174 struct auerchain *chain; /* pointer to the chain to which this element belongs */
175 struct urb * urbp; /* pointer to attached urb */
176 void *context; /* saved URB context */
177 usb_complete_t complete; /* saved URB completion function */
178 struct list_head list; /* to include element into a list */
179 } auerchainelement_t,*pauerchainelement_t;
180
181 /* urb chain */
182 typedef struct auerchain
183 {
184 pauerchainelement_t active; /* element which is submitted to urb */
185 spinlock_t lock; /* protection agains interrupts */
186 struct list_head waiting_list; /* list of waiting elements */
187 struct list_head free_list; /* list of available elements */
188 } auerchain_t,*pauerchain_t;
189
190 /* urb blocking completion helper struct */
191 typedef struct
192 {
193 wait_queue_head_t wqh; /* wait for completion */
194 unsigned int done; /* completion flag */
195 } auerchain_chs_t,*pauerchain_chs_t;
196
197 /* ...................................................................*/
198 /* buffer element */
199 struct auerbufctl; /* forward */
200 typedef struct
201 {
202 char *bufp; /* reference to allocated data buffer */
203 unsigned int len; /* number of characters in data buffer */
204 unsigned int retries; /* for urb retries */
205 struct usb_ctrlrequest *dr; /* for setup data in control messages */
206 struct urb * urbp; /* USB urb */
207 struct auerbufctl *list; /* pointer to list */
208 struct list_head buff_list; /* reference to next buffer in list */
209 } auerbuf_t,*pauerbuf_t;
210
211 /* buffer list control block */
212 typedef struct auerbufctl
213 {
214 spinlock_t lock; /* protection in interrupt */
215 struct list_head free_buff_list;/* free buffers */
216 struct list_head rec_buff_list; /* buffers with receive data */
217 } auerbufctl_t,*pauerbufctl_t;
218
219 /* ...................................................................*/
220 /* service context */
221 struct auerscon; /* forward */
222 typedef void (*auer_dispatch_t)(struct auerscon*, pauerbuf_t);
223 typedef void (*auer_disconn_t) (struct auerscon*);
224 typedef struct auerscon
225 {
226 unsigned int id; /* protocol service id AUH_xxxx */
227 auer_dispatch_t dispatch; /* dispatch read buffer */
228 auer_disconn_t disconnect; /* disconnect from device, wake up all char readers */
229 } auerscon_t,*pauerscon_t;
230
231 /* ...................................................................*/
232 /* USB device context */
233 typedef struct
234 {
235 struct semaphore mutex; /* protection in user context */
236 char name[20]; /* name of the /dev/usb entry */
237 unsigned int dtindex; /* index in the device table */
238 struct usb_device * usbdev; /* USB device handle */
239 int open_count; /* count the number of open character channels */
240 char dev_desc[AUSI_DLEN];/* for storing a textual description */
241 unsigned int maxControlLength; /* max. Length of control paket (without header) */
242 struct urb * inturbp; /* interrupt urb */
243 char * intbufp; /* data buffer for interrupt urb */
244 unsigned int irqsize; /* size of interrupt endpoint 1 */
245 struct auerchain controlchain; /* for chaining of control messages */
246 auerbufctl_t bufctl; /* Buffer control for control transfers */
247 pauerscon_t services[AUH_TYPESIZE];/* context pointers for each service */
248 unsigned int version; /* Version of the device */
249 wait_queue_head_t bufferwait; /* wait for a control buffer */
250 } auerswald_t,*pauerswald_t;
251
252 /* ................................................................... */
253 /* character device context */
254 typedef struct
255 {
256 struct semaphore mutex; /* protection in user context */
257 pauerswald_t auerdev; /* context pointer of assigned device */
258 auerbufctl_t bufctl; /* controls the buffer chain */
259 auerscon_t scontext; /* service context */
260 wait_queue_head_t readwait; /* for synchronous reading */
261 struct semaphore readmutex; /* protection against multiple reads */
262 pauerbuf_t readbuf; /* buffer held for partial reading */
263 unsigned int readoffset; /* current offset in readbuf */
264 unsigned int removed; /* is != 0 if device is removed */
265 } auerchar_t,*pauerchar_t;
266
267
268 /*-------------------------------------------------------------------*/
269 /* Forwards */
270 static void auerswald_ctrlread_complete (struct urb * urb);
271 static void auerswald_removeservice (pauerswald_t cp, pauerscon_t scp);
272 static struct usb_driver auerswald_driver;
273
274
275 /*-------------------------------------------------------------------*/
276 /* USB chain helper functions */
277 /* -------------------------- */
278
279 /* completion function for chained urbs */
280 static void auerchain_complete (struct urb * urb)
281 {
282 unsigned long flags;
283 int result;
284
285 /* get pointer to element and to chain */
286 pauerchainelement_t acep = (pauerchainelement_t) urb->context;
287 pauerchain_t acp = acep->chain;
288
289 /* restore original entries in urb */
290 urb->context = acep->context;
291 urb->complete = acep->complete;
292
293 dbg ("auerchain_complete called");
294
295 /* call original completion function
296 NOTE: this function may lead to more urbs submitted into the chain.
297 (no chain lock at calling complete()!)
298 acp->active != NULL is protecting us against recursion.*/
299 urb->complete (urb);
300
301 /* detach element from chain data structure */
302 spin_lock_irqsave (&acp->lock, flags);
303 if (acp->active != acep) /* paranoia debug check */
304 dbg ("auerchain_complete: completion on non-active element called!");
305 else
306 acp->active = NULL;
307
308 /* add the used chain element to the list of free elements */
309 list_add_tail (&acep->list, &acp->free_list);
310 acep = NULL;
311
312 /* is there a new element waiting in the chain? */
313 if (!acp->active && !list_empty (&acp->waiting_list)) {
314 /* yes: get the entry */
315 struct list_head *tmp = acp->waiting_list.next;
316 list_del (tmp);
317 acep = list_entry (tmp, auerchainelement_t, list);
318 acp->active = acep;
319 }
320 spin_unlock_irqrestore (&acp->lock, flags);
321
322 /* submit the new urb */
323 if (acep) {
324 urb = acep->urbp;
325 dbg ("auerchain_complete: submitting next urb from chain");
326 urb->status = 0; /* needed! */
327 result = usb_submit_urb(urb, GFP_ATOMIC);
328
329 /* check for submit errors */
330 if (result) {
331 urb->status = result;
332 dbg("auerchain_complete: usb_submit_urb with error code %d", result);
333 /* and do error handling via *this* completion function (recursive) */
334 auerchain_complete( urb);
335 }
336 } else {
337 /* simple return without submitting a new urb.
338 The empty chain is detected with acp->active == NULL. */
339 };
340 }
341
342
343 /* submit function for chained urbs
344 this function may be called from completion context or from user space!
345 early = 1 -> submit in front of chain
346 */
347 static int auerchain_submit_urb_list (pauerchain_t acp, struct urb * urb, int early)
348 {
349 int result;
350 unsigned long flags;
351 pauerchainelement_t acep = NULL;
352
353 dbg ("auerchain_submit_urb called");
354
355 /* try to get a chain element */
356 spin_lock_irqsave (&acp->lock, flags);
357 if (!list_empty (&acp->free_list)) {
358 /* yes: get the entry */
359 struct list_head *tmp = acp->free_list.next;
360 list_del (tmp);
361 acep = list_entry (tmp, auerchainelement_t, list);
362 }
363 spin_unlock_irqrestore (&acp->lock, flags);
364
365 /* if no chain element available: return with error */
366 if (!acep) {
367 return -ENOMEM;
368 }
369
370 /* fill in the new chain element values */
371 acep->chain = acp;
372 acep->context = urb->context;
373 acep->complete = urb->complete;
374 acep->urbp = urb;
375 INIT_LIST_HEAD (&acep->list);
376
377 /* modify urb */
378 urb->context = acep;
379 urb->complete = auerchain_complete;
380 urb->status = -EINPROGRESS; /* usb_submit_urb does this, too */
381
382 /* add element to chain - or start it immediately */
383 spin_lock_irqsave (&acp->lock, flags);
384 if (acp->active) {
385 /* there is traffic in the chain, simple add element to chain */
386 if (early) {
387 dbg ("adding new urb to head of chain");
388 list_add (&acep->list, &acp->waiting_list);
389 } else {
390 dbg ("adding new urb to end of chain");
391 list_add_tail (&acep->list, &acp->waiting_list);
392 }
393 acep = NULL;
394 } else {
395 /* the chain is empty. Prepare restart */
396 acp->active = acep;
397 }
398 /* Spin has to be removed before usb_submit_urb! */
399 spin_unlock_irqrestore (&acp->lock, flags);
400
401 /* Submit urb if immediate restart */
402 if (acep) {
403 dbg("submitting urb immediate");
404 urb->status = 0; /* needed! */
405 result = usb_submit_urb(urb, GFP_ATOMIC);
406 /* check for submit errors */
407 if (result) {
408 urb->status = result;
409 dbg("auerchain_submit_urb: usb_submit_urb with error code %d", result);
410 /* and do error handling via completion function */
411 auerchain_complete( urb);
412 }
413 }
414
415 return 0;
416 }
417
418 /* submit function for chained urbs
419 this function may be called from completion context or from user space!
420 */
421 static int auerchain_submit_urb (pauerchain_t acp, struct urb * urb)
422 {
423 return auerchain_submit_urb_list (acp, urb, 0);
424 }
425
426 /* cancel an urb which is submitted to the chain
427 the result is 0 if the urb is cancelled, or -EINPROGRESS if
428 the function is successfully started.
429 */
430 static int auerchain_unlink_urb (pauerchain_t acp, struct urb * urb)
431 {
432 unsigned long flags;
433 struct urb * urbp;
434 pauerchainelement_t acep;
435 struct list_head *tmp;
436
437 dbg ("auerchain_unlink_urb called");
438
439 /* search the chain of waiting elements */
440 spin_lock_irqsave (&acp->lock, flags);
441 list_for_each (tmp, &acp->waiting_list) {
442 acep = list_entry (tmp, auerchainelement_t, list);
443 if (acep->urbp == urb) {
444 list_del (tmp);
445 urb->context = acep->context;
446 urb->complete = acep->complete;
447 list_add_tail (&acep->list, &acp->free_list);
448 spin_unlock_irqrestore (&acp->lock, flags);
449 dbg ("unlink waiting urb");
450 urb->status = -ENOENT;
451 urb->complete (urb);
452 return 0;
453 }
454 }
455 /* not found. */
456 spin_unlock_irqrestore (&acp->lock, flags);
457
458 /* get the active urb */
459 acep = acp->active;
460 if (acep) {
461 urbp = acep->urbp;
462
463 /* check if we have to cancel the active urb */
464 if (urbp == urb) {
465 /* note that there is a race condition between the check above
466 and the unlink() call because of no lock. This race is harmless,
467 because the usb module will detect the unlink() after completion.
468 We can't use the acp->lock here because the completion function
469 wants to grab it.
470 */
471 dbg ("unlink active urb");
472 return usb_unlink_urb (urbp);
473 }
474 }
475
476 /* not found anyway
477 ... is some kind of success
478 */
479 dbg ("urb to unlink not found in chain");
480 return 0;
481 }
482
483 /* cancel all urbs which are in the chain.
484 this function must not be called from interrupt or completion handler.
485 */
486 static void auerchain_unlink_all (pauerchain_t acp)
487 {
488 unsigned long flags;
489 struct urb * urbp;
490 pauerchainelement_t acep;
491
492 dbg ("auerchain_unlink_all called");
493
494 /* clear the chain of waiting elements */
495 spin_lock_irqsave (&acp->lock, flags);
496 while (!list_empty (&acp->waiting_list)) {
497 /* get the next entry */
498 struct list_head *tmp = acp->waiting_list.next;
499 list_del (tmp);
500 acep = list_entry (tmp, auerchainelement_t, list);
501 urbp = acep->urbp;
502 urbp->context = acep->context;
503 urbp->complete = acep->complete;
504 list_add_tail (&acep->list, &acp->free_list);
505 spin_unlock_irqrestore (&acp->lock, flags);
506 dbg ("unlink waiting urb");
507 urbp->status = -ENOENT;
508 urbp->complete (urbp);
509 spin_lock_irqsave (&acp->lock, flags);
510 }
511 spin_unlock_irqrestore (&acp->lock, flags);
512
513 /* clear the active urb */
514 acep = acp->active;
515 if (acep) {
516 urbp = acep->urbp;
517 dbg ("unlink active urb");
518 usb_kill_urb (urbp);
519 }
520 }
521
522
523 /* free the chain.
524 this function must not be called from interrupt or completion handler.
525 */
526 static void auerchain_free (pauerchain_t acp)
527 {
528 unsigned long flags;
529 pauerchainelement_t acep;
530
531 dbg ("auerchain_free called");
532
533 /* first, cancel all pending urbs */
534 auerchain_unlink_all (acp);
535
536 /* free the elements */
537 spin_lock_irqsave (&acp->lock, flags);
538 while (!list_empty (&acp->free_list)) {
539 /* get the next entry */
540 struct list_head *tmp = acp->free_list.next;
541 list_del (tmp);
542 spin_unlock_irqrestore (&acp->lock, flags);
543 acep = list_entry (tmp, auerchainelement_t, list);
544 kfree (acep);
545 spin_lock_irqsave (&acp->lock, flags);
546 }
547 spin_unlock_irqrestore (&acp->lock, flags);
548 }
549
550
551 /* Init the chain control structure */
552 static void auerchain_init (pauerchain_t acp)
553 {
554 /* init the chain data structure */
555 acp->active = NULL;
556 spin_lock_init (&acp->lock);
557 INIT_LIST_HEAD (&acp->waiting_list);
558 INIT_LIST_HEAD (&acp->free_list);
559 }
560
561 /* setup a chain.
562 It is assumed that there is no concurrency while setting up the chain
563 requirement: auerchain_init()
564 */
565 static int auerchain_setup (pauerchain_t acp, unsigned int numElements)
566 {
567 pauerchainelement_t acep;
568
569 dbg ("auerchain_setup called with %d elements", numElements);
570
571 /* fill the list of free elements */
572 for (;numElements; numElements--) {
573 acep = kzalloc(sizeof(auerchainelement_t), GFP_KERNEL);
574 if (!acep)
575 goto ac_fail;
576 INIT_LIST_HEAD (&acep->list);
577 list_add_tail (&acep->list, &acp->free_list);
578 }
579 return 0;
580
581 ac_fail:/* free the elements */
582 while (!list_empty (&acp->free_list)) {
583 /* get the next entry */
584 struct list_head *tmp = acp->free_list.next;
585 list_del (tmp);
586 acep = list_entry (tmp, auerchainelement_t, list);
587 kfree (acep);
588 }
589 return -ENOMEM;
590 }
591
592
593 /* completion handler for synchronous chained URBs */
594 static void auerchain_blocking_completion (struct urb *urb)
595 {
596 pauerchain_chs_t pchs = (pauerchain_chs_t)urb->context;
597 pchs->done = 1;
598 wmb();
599 wake_up (&pchs->wqh);
600 }
601
602
603 /* Starts chained urb and waits for completion or timeout */
604 static int auerchain_start_wait_urb (pauerchain_t acp, struct urb *urb, int timeout, int* actual_length)
605 {
606 auerchain_chs_t chs;
607 int status;
608
609 dbg ("auerchain_start_wait_urb called");
610 init_waitqueue_head (&chs.wqh);
611 chs.done = 0;
612
613 urb->context = &chs;
614 status = auerchain_submit_urb (acp, urb);
615 if (status)
616 /* something went wrong */
617 return status;
618
619 timeout = wait_event_timeout(chs.wqh, chs.done, timeout);
620
621 if (!timeout && !chs.done) {
622 if (urb->status != -EINPROGRESS) { /* No callback?!! */
623 dbg ("auerchain_start_wait_urb: raced timeout");
624 status = urb->status;
625 } else {
626 dbg ("auerchain_start_wait_urb: timeout");
627 auerchain_unlink_urb (acp, urb); /* remove urb safely */
628 status = -ETIMEDOUT;
629 }
630 } else
631 status = urb->status;
632
633 if (status >= 0)
634 *actual_length = urb->actual_length;
635
636 return status;
637 }
638
639
640 /* auerchain_control_msg - Builds a control urb, sends it off and waits for completion
641 acp: pointer to the auerchain
642 dev: pointer to the usb device to send the message to
643 pipe: endpoint "pipe" to send the message to
644 request: USB message request value
645 requesttype: USB message request type value
646 value: USB message value
647 index: USB message index value
648 data: pointer to the data to send
649 size: length in bytes of the data to send
650 timeout: time to wait for the message to complete before timing out (if 0 the wait is forever)
651
652 This function sends a simple control message to a specified endpoint
653 and waits for the message to complete, or timeout.
654
655 If successful, it returns the transferred length, otherwise a negative error number.
656
657 Don't use this function from within an interrupt context, like a
658 bottom half handler. If you need an asynchronous message, or need to send
659 a message from within interrupt context, use auerchain_submit_urb()
660 */
661 static int auerchain_control_msg (pauerchain_t acp, struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype,
662 __u16 value, __u16 index, void *data, __u16 size, int timeout)
663 {
664 int ret;
665 struct usb_ctrlrequest *dr;
666 struct urb *urb;
667 int uninitialized_var(length);
668
669 dbg ("auerchain_control_msg");
670 dr = kmalloc (sizeof (struct usb_ctrlrequest), GFP_KERNEL);
671 if (!dr)
672 return -ENOMEM;
673 urb = usb_alloc_urb (0, GFP_KERNEL);
674 if (!urb) {
675 kfree (dr);
676 return -ENOMEM;
677 }
678
679 dr->bRequestType = requesttype;
680 dr->bRequest = request;
681 dr->wValue = cpu_to_le16 (value);
682 dr->wIndex = cpu_to_le16 (index);
683 dr->wLength = cpu_to_le16 (size);
684
685 usb_fill_control_urb (urb, dev, pipe, (unsigned char*)dr, data, size, /* build urb */
686 auerchain_blocking_completion, NULL);
687 ret = auerchain_start_wait_urb (acp, urb, timeout, &length);
688
689 usb_free_urb (urb);
690 kfree (dr);
691
692 if (ret < 0)
693 return ret;
694 else
695 return length;
696 }
697
698
699 /*-------------------------------------------------------------------*/
700 /* Buffer List helper functions */
701
702 /* free a single auerbuf */
703 static void auerbuf_free (pauerbuf_t bp)
704 {
705 kfree(bp->bufp);
706 kfree(bp->dr);
707 usb_free_urb(bp->urbp);
708 kfree(bp);
709 }
710
711 /* free the buffers from an auerbuf list */
712 static void auerbuf_free_list (struct list_head *q)
713 {
714 struct list_head *tmp;
715 struct list_head *p;
716 pauerbuf_t bp;
717
718 dbg ("auerbuf_free_list");
719 for (p = q->next; p != q;) {
720 bp = list_entry (p, auerbuf_t, buff_list);
721 tmp = p->next;
722 list_del (p);
723 p = tmp;
724 auerbuf_free (bp);
725 }
726 }
727
728 /* init the members of a list control block */
729 static void auerbuf_init (pauerbufctl_t bcp)
730 {
731 dbg ("auerbuf_init");
732 spin_lock_init (&bcp->lock);
733 INIT_LIST_HEAD (&bcp->free_buff_list);
734 INIT_LIST_HEAD (&bcp->rec_buff_list);
735 }
736
737 /* free all buffers from an auerbuf chain */
738 static void auerbuf_free_buffers (pauerbufctl_t bcp)
739 {
740 unsigned long flags;
741 dbg ("auerbuf_free_buffers");
742
743 spin_lock_irqsave (&bcp->lock, flags);
744
745 auerbuf_free_list (&bcp->free_buff_list);
746 auerbuf_free_list (&bcp->rec_buff_list);
747
748 spin_unlock_irqrestore (&bcp->lock, flags);
749 }
750
751 /* setup a list of buffers */
752 /* requirement: auerbuf_init() */
753 static int auerbuf_setup (pauerbufctl_t bcp, unsigned int numElements, unsigned int bufsize)
754 {
755 pauerbuf_t bep = NULL;
756
757 dbg ("auerbuf_setup called with %d elements of %d bytes", numElements, bufsize);
758
759 /* fill the list of free elements */
760 for (;numElements; numElements--) {
761 bep = kzalloc(sizeof(auerbuf_t), GFP_KERNEL);
762 if (!bep)
763 goto bl_fail;
764 bep->list = bcp;
765 INIT_LIST_HEAD (&bep->buff_list);
766 bep->bufp = kmalloc (bufsize, GFP_KERNEL);
767 if (!bep->bufp)
768 goto bl_fail;
769 bep->dr = kmalloc(sizeof (struct usb_ctrlrequest), GFP_KERNEL);
770 if (!bep->dr)
771 goto bl_fail;
772 bep->urbp = usb_alloc_urb (0, GFP_KERNEL);
773 if (!bep->urbp)
774 goto bl_fail;
775 list_add_tail (&bep->buff_list, &bcp->free_buff_list);
776 }
777 return 0;
778
779 bl_fail:/* not enough memory. Free allocated elements */
780 dbg ("auerbuf_setup: no more memory");
781 auerbuf_free(bep);
782 auerbuf_free_buffers (bcp);
783 return -ENOMEM;
784 }
785
786 /* insert a used buffer into the free list */
787 static void auerbuf_releasebuf( pauerbuf_t bp)
788 {
789 unsigned long flags;
790 pauerbufctl_t bcp = bp->list;
791 bp->retries = 0;
792
793 dbg ("auerbuf_releasebuf called");
794 spin_lock_irqsave (&bcp->lock, flags);
795 list_add_tail (&bp->buff_list, &bcp->free_buff_list);
796 spin_unlock_irqrestore (&bcp->lock, flags);
797 }
798
799
800 /*-------------------------------------------------------------------*/
801 /* Completion handlers */
802
803 /* Values of urb->status or results of usb_submit_urb():
804 0 Initial, OK
805 -EINPROGRESS during submission until end
806 -ENOENT if urb is unlinked
807 -ETIME Device did not respond
808 -ENOMEM Memory Overflow
809 -ENODEV Specified USB-device or bus doesn't exist
810 -ENXIO URB already queued
811 -EINVAL a) Invalid transfer type specified (or not supported)
812 b) Invalid interrupt interval (0n256)
813 -EAGAIN a) Specified ISO start frame too early
814 b) (using ISO-ASAP) Too much scheduled for the future wait some time and try again.
815 -EFBIG Too much ISO frames requested (currently uhci900)
816 -EPIPE Specified pipe-handle/Endpoint is already stalled
817 -EMSGSIZE Endpoint message size is zero, do interface/alternate setting
818 -EPROTO a) Bitstuff error
819 b) Unknown USB error
820 -EILSEQ CRC mismatch
821 -ENOSR Buffer error
822 -EREMOTEIO Short packet detected
823 -EXDEV ISO transfer only partially completed look at individual frame status for details
824 -EINVAL ISO madness, if this happens: Log off and go home
825 -EOVERFLOW babble
826 */
827
828 /* check if a status code allows a retry */
829 static int auerswald_status_retry (int status)
830 {
831 switch (status) {
832 case 0:
833 case -ETIME:
834 case -EOVERFLOW:
835 case -EAGAIN:
836 case -EPIPE:
837 case -EPROTO:
838 case -EILSEQ:
839 case -ENOSR:
840 case -EREMOTEIO:
841 return 1; /* do a retry */
842 }
843 return 0; /* no retry possible */
844 }
845
846 /* Completion of asynchronous write block */
847 static void auerchar_ctrlwrite_complete (struct urb * urb)
848 {
849 pauerbuf_t bp = (pauerbuf_t) urb->context;
850 pauerswald_t cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
851 dbg ("auerchar_ctrlwrite_complete called");
852
853 /* reuse the buffer */
854 auerbuf_releasebuf (bp);
855 /* Wake up all processes waiting for a buffer */
856 wake_up (&cp->bufferwait);
857 }
858
859 /* Completion handler for dummy retry packet */
860 static void auerswald_ctrlread_wretcomplete (struct urb * urb)
861 {
862 pauerbuf_t bp = (pauerbuf_t) urb->context;
863 pauerswald_t cp;
864 int ret;
865 int status = urb->status;
866
867 dbg ("auerswald_ctrlread_wretcomplete called");
868 dbg ("complete with status: %d", status);
869 cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
870
871 /* check if it is possible to advance */
872 if (!auerswald_status_retry(status) || !cp->usbdev) {
873 /* reuse the buffer */
874 err ("control dummy: transmission error %d, can not retry", status);
875 auerbuf_releasebuf (bp);
876 /* Wake up all processes waiting for a buffer */
877 wake_up (&cp->bufferwait);
878 return;
879 }
880
881 /* fill the control message */
882 bp->dr->bRequestType = AUT_RREQ;
883 bp->dr->bRequest = AUV_RBLOCK;
884 bp->dr->wLength = bp->dr->wValue; /* temporary stored */
885 bp->dr->wValue = cpu_to_le16 (1); /* Retry Flag */
886 /* bp->dr->index = channel id; remains */
887 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
888 (unsigned char*)bp->dr, bp->bufp, le16_to_cpu (bp->dr->wLength),
889 auerswald_ctrlread_complete,bp);
890
891 /* submit the control msg as next paket */
892 ret = auerchain_submit_urb_list (&cp->controlchain, bp->urbp, 1);
893 if (ret) {
894 dbg ("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
895 bp->urbp->status = ret;
896 auerswald_ctrlread_complete (bp->urbp);
897 }
898 }
899
900 /* completion handler for receiving of control messages */
901 static void auerswald_ctrlread_complete (struct urb * urb)
902 {
903 unsigned int serviceid;
904 pauerswald_t cp;
905 pauerscon_t scp;
906 pauerbuf_t bp = (pauerbuf_t) urb->context;
907 int status = urb->status;
908 int ret;
909
910 dbg ("auerswald_ctrlread_complete called");
911
912 cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
913
914 /* check if there is valid data in this urb */
915 if (status) {
916 dbg ("complete with non-zero status: %d", status);
917 /* should we do a retry? */
918 if (!auerswald_status_retry(status)
919 || !cp->usbdev
920 || (cp->version < AUV_RETRY)
921 || (bp->retries >= AU_RETRIES)) {
922 /* reuse the buffer */
923 err ("control read: transmission error %d, can not retry", status);
924 auerbuf_releasebuf (bp);
925 /* Wake up all processes waiting for a buffer */
926 wake_up (&cp->bufferwait);
927 return;
928 }
929 bp->retries++;
930 dbg ("Retry count = %d", bp->retries);
931 /* send a long dummy control-write-message to allow device firmware to react */
932 bp->dr->bRequestType = AUT_WREQ;
933 bp->dr->bRequest = AUV_DUMMY;
934 bp->dr->wValue = bp->dr->wLength; /* temporary storage */
935 // bp->dr->wIndex channel ID remains
936 bp->dr->wLength = cpu_to_le16 (32); /* >= 8 bytes */
937 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
938 (unsigned char*)bp->dr, bp->bufp, 32,
939 auerswald_ctrlread_wretcomplete,bp);
940
941 /* submit the control msg as next paket */
942 ret = auerchain_submit_urb_list (&cp->controlchain, bp->urbp, 1);
943 if (ret) {
944 dbg ("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
945 bp->urbp->status = ret;
946 auerswald_ctrlread_wretcomplete (bp->urbp);
947 }
948 return;
949 }
950
951 /* get the actual bytecount (incl. headerbyte) */
952 bp->len = urb->actual_length;
953 serviceid = bp->bufp[0] & AUH_TYPEMASK;
954 dbg ("Paket with serviceid %d and %d bytes received", serviceid, bp->len);
955
956 /* dispatch the paket */
957 scp = cp->services[serviceid];
958 if (scp) {
959 /* look, Ma, a listener! */
960 scp->dispatch (scp, bp);
961 }
962
963 /* release the paket */
964 auerbuf_releasebuf (bp);
965 /* Wake up all processes waiting for a buffer */
966 wake_up (&cp->bufferwait);
967 }
968
969 /*-------------------------------------------------------------------*/
970 /* Handling of Interrupt Endpoint */
971 /* This interrupt Endpoint is used to inform the host about waiting
972 messages from the USB device.
973 */
974 /* int completion handler. */
975 static void auerswald_int_complete (struct urb * urb)
976 {
977 unsigned long flags;
978 unsigned int channelid;
979 unsigned int bytecount;
980 int ret;
981 int status = urb->status;
982 pauerbuf_t bp = NULL;
983 pauerswald_t cp = (pauerswald_t) urb->context;
984
985 dbg ("%s called", __FUNCTION__);
986
987 switch (status) {
988 case 0:
989 /* success */
990 break;
991 case -ECONNRESET:
992 case -ENOENT:
993 case -ESHUTDOWN:
994 /* this urb is terminated, clean up */
995 dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
996 return;
997 default:
998 dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
999 goto exit;
1000 }
1001
1002 /* check if all needed data was received */
1003 if (urb->actual_length < AU_IRQMINSIZE) {
1004 dbg ("invalid data length received: %d bytes", urb->actual_length);
1005 goto exit;
1006 }
1007
1008 /* check the command code */
1009 if (cp->intbufp[0] != AU_IRQCMDID) {
1010 dbg ("invalid command received: %d", cp->intbufp[0]);
1011 goto exit;
1012 }
1013
1014 /* check the command type */
1015 if (cp->intbufp[1] != AU_BLOCKRDY) {
1016 dbg ("invalid command type received: %d", cp->intbufp[1]);
1017 goto exit;
1018 }
1019
1020 /* now extract the information */
1021 channelid = cp->intbufp[2];
1022 bytecount = (unsigned char)cp->intbufp[3];
1023 bytecount |= (unsigned char)cp->intbufp[4] << 8;
1024
1025 /* check the channel id */
1026 if (channelid >= AUH_TYPESIZE) {
1027 dbg ("invalid channel id received: %d", channelid);
1028 goto exit;
1029 }
1030
1031 /* check the byte count */
1032 if (bytecount > (cp->maxControlLength+AUH_SIZE)) {
1033 dbg ("invalid byte count received: %d", bytecount);
1034 goto exit;
1035 }
1036 dbg ("Service Channel = %d", channelid);
1037 dbg ("Byte Count = %d", bytecount);
1038
1039 /* get a buffer for the next data paket */
1040 spin_lock_irqsave (&cp->bufctl.lock, flags);
1041 if (!list_empty (&cp->bufctl.free_buff_list)) {
1042 /* yes: get the entry */
1043 struct list_head *tmp = cp->bufctl.free_buff_list.next;
1044 list_del (tmp);
1045 bp = list_entry (tmp, auerbuf_t, buff_list);
1046 }
1047 spin_unlock_irqrestore (&cp->bufctl.lock, flags);
1048
1049 /* if no buffer available: skip it */
1050 if (!bp) {
1051 dbg ("auerswald_int_complete: no data buffer available");
1052 /* can we do something more?
1053 This is a big problem: if this int packet is ignored, the
1054 device will wait forever and not signal any more data.
1055 The only real solution is: having enough buffers!
1056 Or perhaps temporary disabling the int endpoint?
1057 */
1058 goto exit;
1059 }
1060
1061 /* fill the control message */
1062 bp->dr->bRequestType = AUT_RREQ;
1063 bp->dr->bRequest = AUV_RBLOCK;
1064 bp->dr->wValue = cpu_to_le16 (0);
1065 bp->dr->wIndex = cpu_to_le16 (channelid | AUH_DIRECT | AUH_UNSPLIT);
1066 bp->dr->wLength = cpu_to_le16 (bytecount);
1067 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
1068 (unsigned char*)bp->dr, bp->bufp, bytecount,
1069 auerswald_ctrlread_complete,bp);
1070
1071 /* submit the control msg */
1072 ret = auerchain_submit_urb (&cp->controlchain, bp->urbp);
1073 if (ret) {
1074 dbg ("auerswald_int_complete: nonzero result of auerchain_submit_urb %d", ret);
1075 bp->urbp->status = ret;
1076 auerswald_ctrlread_complete( bp->urbp);
1077 /* here applies the same problem as above: device locking! */
1078 }
1079 exit:
1080 ret = usb_submit_urb (urb, GFP_ATOMIC);
1081 if (ret)
1082 err ("%s - usb_submit_urb failed with result %d",
1083 __FUNCTION__, ret);
1084 }
1085
1086 /* int memory deallocation
1087 NOTE: no mutex please!
1088 */
1089 static void auerswald_int_free (pauerswald_t cp)
1090 {
1091 if (cp->inturbp) {
1092 usb_free_urb(cp->inturbp);
1093 cp->inturbp = NULL;
1094 }
1095 kfree(cp->intbufp);
1096 cp->intbufp = NULL;
1097 }
1098
1099 /* This function is called to activate the interrupt
1100 endpoint. This function returns 0 if successful or an error code.
1101 NOTE: no mutex please!
1102 */
1103 static int auerswald_int_open (pauerswald_t cp)
1104 {
1105 int ret;
1106 struct usb_host_endpoint *ep;
1107 int irqsize;
1108 dbg ("auerswald_int_open");
1109
1110 ep = cp->usbdev->ep_in[AU_IRQENDP];
1111 if (!ep) {
1112 ret = -EFAULT;
1113 goto intoend;
1114 }
1115 irqsize = le16_to_cpu(ep->desc.wMaxPacketSize);
1116 cp->irqsize = irqsize;
1117
1118 /* allocate the urb and data buffer */
1119 if (!cp->inturbp) {
1120 cp->inturbp = usb_alloc_urb (0, GFP_KERNEL);
1121 if (!cp->inturbp) {
1122 ret = -ENOMEM;
1123 goto intoend;
1124 }
1125 }
1126 if (!cp->intbufp) {
1127 cp->intbufp = kmalloc (irqsize, GFP_KERNEL);
1128 if (!cp->intbufp) {
1129 ret = -ENOMEM;
1130 goto intoend;
1131 }
1132 }
1133 /* setup urb */
1134 usb_fill_int_urb (cp->inturbp, cp->usbdev,
1135 usb_rcvintpipe (cp->usbdev,AU_IRQENDP), cp->intbufp,
1136 irqsize, auerswald_int_complete, cp, ep->desc.bInterval);
1137 /* start the urb */
1138 cp->inturbp->status = 0; /* needed! */
1139 ret = usb_submit_urb (cp->inturbp, GFP_KERNEL);
1140
1141 intoend:
1142 if (ret < 0) {
1143 /* activation of interrupt endpoint has failed. Now clean up. */
1144 dbg ("auerswald_int_open: activation of int endpoint failed");
1145
1146 /* deallocate memory */
1147 auerswald_int_free (cp);
1148 }
1149 return ret;
1150 }
1151
1152 /* This function is called to deactivate the interrupt
1153 endpoint. This function returns 0 if successful or an error code.
1154 NOTE: no mutex please!
1155 */
1156 static void auerswald_int_release (pauerswald_t cp)
1157 {
1158 dbg ("auerswald_int_release");
1159
1160 /* stop the int endpoint */
1161 usb_kill_urb (cp->inturbp);
1162
1163 /* deallocate memory */
1164 auerswald_int_free (cp);
1165 }
1166
1167 /* --------------------------------------------------------------------- */
1168 /* Helper functions */
1169
1170 /* wake up waiting readers */
1171 static void auerchar_disconnect (pauerscon_t scp)
1172 {
1173 pauerchar_t ccp = ((pauerchar_t)((char *)(scp)-(unsigned long)(&((pauerchar_t)0)->scontext)));
1174 dbg ("auerchar_disconnect called");
1175 ccp->removed = 1;
1176 wake_up (&ccp->readwait);
1177 }
1178
1179
1180 /* dispatch a read paket to a waiting character device */
1181 static void auerchar_ctrlread_dispatch (pauerscon_t scp, pauerbuf_t bp)
1182 {
1183 unsigned long flags;
1184 pauerchar_t ccp;
1185 pauerbuf_t newbp = NULL;
1186 char * charp;
1187 dbg ("auerchar_ctrlread_dispatch called");
1188 ccp = ((pauerchar_t)((char *)(scp)-(unsigned long)(&((pauerchar_t)0)->scontext)));
1189
1190 /* get a read buffer from character device context */
1191 spin_lock_irqsave (&ccp->bufctl.lock, flags);
1192 if (!list_empty (&ccp->bufctl.free_buff_list)) {
1193 /* yes: get the entry */
1194 struct list_head *tmp = ccp->bufctl.free_buff_list.next;
1195 list_del (tmp);
1196 newbp = list_entry (tmp, auerbuf_t, buff_list);
1197 }
1198 spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1199
1200 if (!newbp) {
1201 dbg ("No read buffer available, discard paket!");
1202 return; /* no buffer, no dispatch */
1203 }
1204
1205 /* copy information to new buffer element
1206 (all buffers have the same length) */
1207 charp = newbp->bufp;
1208 newbp->bufp = bp->bufp;
1209 bp->bufp = charp;
1210 newbp->len = bp->len;
1211
1212 /* insert new buffer in read list */
1213 spin_lock_irqsave (&ccp->bufctl.lock, flags);
1214 list_add_tail (&newbp->buff_list, &ccp->bufctl.rec_buff_list);
1215 spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1216 dbg ("read buffer appended to rec_list");
1217
1218 /* wake up pending synchronous reads */
1219 wake_up (&ccp->readwait);
1220 }
1221
1222
1223 /* Delete an auerswald driver context */
1224 static void auerswald_delete( pauerswald_t cp)
1225 {
1226 dbg( "auerswald_delete");
1227 if (cp == NULL)
1228 return;
1229
1230 /* Wake up all processes waiting for a buffer */
1231 wake_up (&cp->bufferwait);
1232
1233 /* Cleaning up */
1234 auerswald_int_release (cp);
1235 auerchain_free (&cp->controlchain);
1236 auerbuf_free_buffers (&cp->bufctl);
1237
1238 /* release the memory */
1239 kfree( cp);
1240 }
1241
1242
1243 /* Delete an auerswald character context */
1244 static void auerchar_delete( pauerchar_t ccp)
1245 {
1246 dbg ("auerchar_delete");
1247 if (ccp == NULL)
1248 return;
1249
1250 /* wake up pending synchronous reads */
1251 ccp->removed = 1;
1252 wake_up (&ccp->readwait);
1253
1254 /* remove the read buffer */
1255 if (ccp->readbuf) {
1256 auerbuf_releasebuf (ccp->readbuf);
1257 ccp->readbuf = NULL;
1258 }
1259
1260 /* remove the character buffers */
1261 auerbuf_free_buffers (&ccp->bufctl);
1262
1263 /* release the memory */
1264 kfree( ccp);
1265 }
1266
1267
1268 /* add a new service to the device
1269 scp->id must be set!
1270 return: 0 if OK, else error code
1271 */
1272 static int auerswald_addservice (pauerswald_t cp, pauerscon_t scp)
1273 {
1274 int ret;
1275
1276 /* is the device available? */
1277 if (!cp->usbdev) {
1278 dbg ("usbdev == NULL");
1279 return -EIO; /*no: can not add a service, sorry*/
1280 }
1281
1282 /* is the service available? */
1283 if (cp->services[scp->id]) {
1284 dbg ("service is busy");
1285 return -EBUSY;
1286 }
1287
1288 /* device is available, service is free */
1289 cp->services[scp->id] = scp;
1290
1291 /* register service in device */
1292 ret = auerchain_control_msg(
1293 &cp->controlchain, /* pointer to control chain */
1294 cp->usbdev, /* pointer to device */
1295 usb_sndctrlpipe (cp->usbdev, 0), /* pipe to control endpoint */
1296 AUV_CHANNELCTL, /* USB message request value */
1297 AUT_WREQ, /* USB message request type value */
1298 0x01, /* open USB message value */
1299 scp->id, /* USB message index value */
1300 NULL, /* pointer to the data to send */
1301 0, /* length in bytes of the data to send */
1302 HZ * 2); /* time to wait for the message to complete before timing out */
1303 if (ret < 0) {
1304 dbg ("auerswald_addservice: auerchain_control_msg returned error code %d", ret);
1305 /* undo above actions */
1306 cp->services[scp->id] = NULL;
1307 return ret;
1308 }
1309
1310 dbg ("auerswald_addservice: channel open OK");
1311 return 0;
1312 }
1313
1314
1315 /* remove a service from the device
1316 scp->id must be set! */
1317 static void auerswald_removeservice (pauerswald_t cp, pauerscon_t scp)
1318 {
1319 dbg ("auerswald_removeservice called");
1320
1321 /* check if we have a service allocated */
1322 if (scp->id == AUH_UNASSIGNED)
1323 return;
1324
1325 /* If there is a device: close the channel */
1326 if (cp->usbdev) {
1327 /* Close the service channel inside the device */
1328 int ret = auerchain_control_msg(
1329 &cp->controlchain, /* pointer to control chain */
1330 cp->usbdev, /* pointer to device */
1331 usb_sndctrlpipe (cp->usbdev, 0), /* pipe to control endpoint */
1332 AUV_CHANNELCTL, /* USB message request value */
1333 AUT_WREQ, /* USB message request type value */
1334 0x00, // close /* USB message value */
1335 scp->id, /* USB message index value */
1336 NULL, /* pointer to the data to send */
1337 0, /* length in bytes of the data to send */
1338 HZ * 2); /* time to wait for the message to complete before timing out */
1339 if (ret < 0) {
1340 dbg ("auerswald_removeservice: auerchain_control_msg returned error code %d", ret);
1341 }
1342 else {
1343 dbg ("auerswald_removeservice: channel close OK");
1344 }
1345 }
1346
1347 /* remove the service from the device */
1348 cp->services[scp->id] = NULL;
1349 scp->id = AUH_UNASSIGNED;
1350 }
1351
1352
1353 /* --------------------------------------------------------------------- */
1354 /* Char device functions */
1355
1356 /* Open a new character device */
1357 static int auerchar_open (struct inode *inode, struct file *file)
1358 {
1359 int dtindex = iminor(inode);
1360 pauerswald_t cp = NULL;
1361 pauerchar_t ccp = NULL;
1362 struct usb_interface *intf;
1363 int ret;
1364
1365 /* minor number in range? */
1366 if (dtindex < 0) {
1367 return -ENODEV;
1368 }
1369 intf = usb_find_interface(&auerswald_driver, dtindex);
1370 if (!intf) {
1371 return -ENODEV;
1372 }
1373
1374 /* usb device available? */
1375 cp = usb_get_intfdata (intf);
1376 if (cp == NULL) {
1377 return -ENODEV;
1378 }
1379 if (down_interruptible (&cp->mutex)) {
1380 return -ERESTARTSYS;
1381 }
1382
1383 /* we have access to the device. Now lets allocate memory */
1384 ccp = kzalloc(sizeof(auerchar_t), GFP_KERNEL);
1385 if (ccp == NULL) {
1386 err ("out of memory");
1387 ret = -ENOMEM;
1388 goto ofail;
1389 }
1390
1391 /* Initialize device descriptor */
1392 init_MUTEX( &ccp->mutex);
1393 init_MUTEX( &ccp->readmutex);
1394 auerbuf_init (&ccp->bufctl);
1395 ccp->scontext.id = AUH_UNASSIGNED;
1396 ccp->scontext.dispatch = auerchar_ctrlread_dispatch;
1397 ccp->scontext.disconnect = auerchar_disconnect;
1398 init_waitqueue_head (&ccp->readwait);
1399
1400 ret = auerbuf_setup (&ccp->bufctl, AU_RBUFFERS, cp->maxControlLength+AUH_SIZE);
1401 if (ret) {
1402 goto ofail;
1403 }
1404
1405 cp->open_count++;
1406 ccp->auerdev = cp;
1407 dbg("open %s as /dev/%s", cp->dev_desc, cp->name);
1408 up (&cp->mutex);
1409
1410 /* file IO stuff */
1411 file->f_pos = 0;
1412 file->private_data = ccp;
1413 return nonseekable_open(inode, file);
1414
1415 /* Error exit */
1416 ofail: up (&cp->mutex);
1417 auerchar_delete (ccp);
1418 return ret;
1419 }
1420
1421
1422 /* IOCTL functions */
1423 static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1424 {
1425 pauerchar_t ccp = (pauerchar_t) file->private_data;
1426 int ret = 0;
1427 audevinfo_t devinfo;
1428 pauerswald_t cp = NULL;
1429 unsigned int u;
1430 unsigned int __user *user_arg = (unsigned int __user *)arg;
1431
1432 dbg ("ioctl");
1433
1434 /* get the mutexes */
1435 if (down_interruptible (&ccp->mutex)) {
1436 return -ERESTARTSYS;
1437 }
1438 cp = ccp->auerdev;
1439 if (!cp) {
1440 up (&ccp->mutex);
1441 return -ENODEV;
1442 }
1443 if (down_interruptible (&cp->mutex)) {
1444 up(&ccp->mutex);
1445 return -ERESTARTSYS;
1446 }
1447
1448 /* Check for removal */
1449 if (!cp->usbdev) {
1450 up(&cp->mutex);
1451 up(&ccp->mutex);
1452 return -ENODEV;
1453 }
1454
1455 switch (cmd) {
1456
1457 /* return != 0 if Transmitt channel ready to send */
1458 case IOCTL_AU_TXREADY:
1459 dbg ("IOCTL_AU_TXREADY");
1460 u = ccp->auerdev
1461 && (ccp->scontext.id != AUH_UNASSIGNED)
1462 && !list_empty (&cp->bufctl.free_buff_list);
1463 ret = put_user (u, user_arg);
1464 break;
1465
1466 /* return != 0 if connected to a service channel */
1467 case IOCTL_AU_CONNECT:
1468 dbg ("IOCTL_AU_CONNECT");
1469 u = (ccp->scontext.id != AUH_UNASSIGNED);
1470 ret = put_user (u, user_arg);
1471 break;
1472
1473 /* return != 0 if Receive Data available */
1474 case IOCTL_AU_RXAVAIL:
1475 dbg ("IOCTL_AU_RXAVAIL");
1476 if (ccp->scontext.id == AUH_UNASSIGNED) {
1477 ret = -EIO;
1478 break;
1479 }
1480 u = 0; /* no data */
1481 if (ccp->readbuf) {
1482 int restlen = ccp->readbuf->len - ccp->readoffset;
1483 if (restlen > 0)
1484 u = 1;
1485 }
1486 if (!u) {
1487 if (!list_empty (&ccp->bufctl.rec_buff_list)) {
1488 u = 1;
1489 }
1490 }
1491 ret = put_user (u, user_arg);
1492 break;
1493
1494 /* return the max. buffer length for the device */
1495 case IOCTL_AU_BUFLEN:
1496 dbg ("IOCTL_AU_BUFLEN");
1497 u = cp->maxControlLength;
1498 ret = put_user (u, user_arg);
1499 break;
1500
1501 /* requesting a service channel */
1502 case IOCTL_AU_SERVREQ:
1503 dbg ("IOCTL_AU_SERVREQ");
1504 /* requesting a service means: release the previous one first */
1505 auerswald_removeservice (cp, &ccp->scontext);
1506 /* get the channel number */
1507 ret = get_user (u, user_arg);
1508 if (ret) {
1509 break;
1510 }
1511 if ((u < AUH_FIRSTUSERCH) || (u >= AUH_TYPESIZE)) {
1512 ret = -EIO;
1513 break;
1514 }
1515 dbg ("auerchar service request parameters are ok");
1516 ccp->scontext.id = u;
1517
1518 /* request the service now */
1519 ret = auerswald_addservice (cp, &ccp->scontext);
1520 if (ret) {
1521 /* no: revert service entry */
1522 ccp->scontext.id = AUH_UNASSIGNED;
1523 }
1524 break;
1525
1526 /* get a string descriptor for the device */
1527 case IOCTL_AU_DEVINFO:
1528 dbg ("IOCTL_AU_DEVINFO");
1529 if (copy_from_user (&devinfo, (void __user *) arg, sizeof (audevinfo_t))) {
1530 ret = -EFAULT;
1531 break;
1532 }
1533 u = strlen(cp->dev_desc)+1;
1534 if (u > devinfo.bsize) {
1535 u = devinfo.bsize;
1536 }
1537 ret = copy_to_user(devinfo.buf, cp->dev_desc, u) ? -EFAULT : 0;
1538 break;
1539
1540 /* get the max. string descriptor length */
1541 case IOCTL_AU_SLEN:
1542 dbg ("IOCTL_AU_SLEN");
1543 u = AUSI_DLEN;
1544 ret = put_user (u, user_arg);
1545 break;
1546
1547 default:
1548 dbg ("IOCTL_AU_UNKNOWN");
1549 ret = -ENOIOCTLCMD;
1550 break;
1551 }
1552 /* release the mutexes */
1553 up(&cp->mutex);
1554 up(&ccp->mutex);
1555 return ret;
1556 }
1557
1558 /* Read data from the device */
1559 static ssize_t auerchar_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
1560 {
1561 unsigned long flags;
1562 pauerchar_t ccp = (pauerchar_t) file->private_data;
1563 pauerbuf_t bp = NULL;
1564 wait_queue_t wait;
1565
1566 dbg ("auerchar_read");
1567
1568 /* Error checking */
1569 if (!ccp)
1570 return -EIO;
1571 if (*ppos)
1572 return -ESPIPE;
1573 if (count == 0)
1574 return 0;
1575
1576 /* get the mutex */
1577 if (down_interruptible (&ccp->mutex))
1578 return -ERESTARTSYS;
1579
1580 /* Can we expect to read something? */
1581 if (ccp->scontext.id == AUH_UNASSIGNED) {
1582 up (&ccp->mutex);
1583 return -EIO;
1584 }
1585
1586 /* only one reader per device allowed */
1587 if (down_interruptible (&ccp->readmutex)) {
1588 up (&ccp->mutex);
1589 return -ERESTARTSYS;
1590 }
1591
1592 /* read data from readbuf, if available */
1593 doreadbuf:
1594 bp = ccp->readbuf;
1595 if (bp) {
1596 /* read the maximum bytes */
1597 int restlen = bp->len - ccp->readoffset;
1598 if (restlen < 0)
1599 restlen = 0;
1600 if (count > restlen)
1601 count = restlen;
1602 if (count) {
1603 if (copy_to_user (buf, bp->bufp+ccp->readoffset, count)) {
1604 dbg ("auerswald_read: copy_to_user failed");
1605 up (&ccp->readmutex);
1606 up (&ccp->mutex);
1607 return -EFAULT;
1608 }
1609 }
1610 /* advance the read offset */
1611 ccp->readoffset += count;
1612 restlen -= count;
1613 // reuse the read buffer
1614 if (restlen <= 0) {
1615 auerbuf_releasebuf (bp);
1616 ccp->readbuf = NULL;
1617 }
1618 /* return with number of bytes read */
1619 if (count) {
1620 up (&ccp->readmutex);
1621 up (&ccp->mutex);
1622 return count;
1623 }
1624 }
1625
1626 /* a read buffer is not available. Try to get the next data block. */
1627 doreadlist:
1628 /* Preparing for sleep */
1629 init_waitqueue_entry (&wait, current);
1630 set_current_state (TASK_INTERRUPTIBLE);
1631 add_wait_queue (&ccp->readwait, &wait);
1632
1633 bp = NULL;
1634 spin_lock_irqsave (&ccp->bufctl.lock, flags);
1635 if (!list_empty (&ccp->bufctl.rec_buff_list)) {
1636 /* yes: get the entry */
1637 struct list_head *tmp = ccp->bufctl.rec_buff_list.next;
1638 list_del (tmp);
1639 bp = list_entry (tmp, auerbuf_t, buff_list);
1640 }
1641 spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1642
1643 /* have we got data? */
1644 if (bp) {
1645 ccp->readbuf = bp;
1646 ccp->readoffset = AUH_SIZE; /* for headerbyte */
1647 set_current_state (TASK_RUNNING);
1648 remove_wait_queue (&ccp->readwait, &wait);
1649 goto doreadbuf; /* now we can read! */
1650 }
1651
1652 /* no data available. Should we wait? */
1653 if (file->f_flags & O_NONBLOCK) {
1654 dbg ("No read buffer available, returning -EAGAIN");
1655 set_current_state (TASK_RUNNING);
1656 remove_wait_queue (&ccp->readwait, &wait);
1657 up (&ccp->readmutex);
1658 up (&ccp->mutex);
1659 return -EAGAIN; /* nonblocking, no data available */
1660 }
1661
1662 /* yes, we should wait! */
1663 up (&ccp->mutex); /* allow other operations while we wait */
1664 schedule();
1665 remove_wait_queue (&ccp->readwait, &wait);
1666 if (signal_pending (current)) {
1667 /* waked up by a signal */
1668 up (&ccp->readmutex);
1669 return -ERESTARTSYS;
1670 }
1671
1672 /* Anything left to read? */
1673 if ((ccp->scontext.id == AUH_UNASSIGNED) || ccp->removed) {
1674 up (&ccp->readmutex);
1675 return -EIO;
1676 }
1677
1678 if (down_interruptible (&ccp->mutex)) {
1679 up (&ccp->readmutex);
1680 return -ERESTARTSYS;
1681 }
1682
1683 /* try to read the incoming data again */
1684 goto doreadlist;
1685 }
1686
1687
1688 /* Write a data block into the right service channel of the device */
1689 static ssize_t auerchar_write (struct file *file, const char __user *buf, size_t len, loff_t *ppos)
1690 {
1691 pauerchar_t ccp = (pauerchar_t) file->private_data;
1692 pauerswald_t cp = NULL;
1693 pauerbuf_t bp;
1694 unsigned long flags;
1695 int ret;
1696 wait_queue_t wait;
1697
1698 dbg ("auerchar_write %zd bytes", len);
1699
1700 /* Error checking */
1701 if (!ccp)
1702 return -EIO;
1703 if (*ppos)
1704 return -ESPIPE;
1705 if (len == 0)
1706 return 0;
1707
1708 write_again:
1709 /* get the mutex */
1710 if (down_interruptible (&ccp->mutex))
1711 return -ERESTARTSYS;
1712
1713 /* Can we expect to write something? */
1714 if (ccp->scontext.id == AUH_UNASSIGNED) {
1715 up (&ccp->mutex);
1716 return -EIO;
1717 }
1718
1719 cp = ccp->auerdev;
1720 if (!cp) {
1721 up (&ccp->mutex);
1722 return -ERESTARTSYS;
1723 }
1724 if (down_interruptible (&cp->mutex)) {
1725 up (&ccp->mutex);
1726 return -ERESTARTSYS;
1727 }
1728 if (!cp->usbdev) {
1729 up (&cp->mutex);
1730 up (&ccp->mutex);
1731 return -EIO;
1732 }
1733 /* Prepare for sleep */
1734 init_waitqueue_entry (&wait, current);
1735 set_current_state (TASK_INTERRUPTIBLE);
1736 add_wait_queue (&cp->bufferwait, &wait);
1737
1738 /* Try to get a buffer from the device pool.
1739 We can't use a buffer from ccp->bufctl because the write
1740 command will last beond a release() */
1741 bp = NULL;
1742 spin_lock_irqsave (&cp->bufctl.lock, flags);
1743 if (!list_empty (&cp->bufctl.free_buff_list)) {
1744 /* yes: get the entry */
1745 struct list_head *tmp = cp->bufctl.free_buff_list.next;
1746 list_del (tmp);
1747 bp = list_entry (tmp, auerbuf_t, buff_list);
1748 }
1749 spin_unlock_irqrestore (&cp->bufctl.lock, flags);
1750
1751 /* are there any buffers left? */
1752 if (!bp) {
1753 up (&cp->mutex);
1754 up (&ccp->mutex);
1755
1756 /* NONBLOCK: don't wait */
1757 if (file->f_flags & O_NONBLOCK) {
1758 set_current_state (TASK_RUNNING);
1759 remove_wait_queue (&cp->bufferwait, &wait);
1760 return -EAGAIN;
1761 }
1762
1763 /* BLOCKING: wait */
1764 schedule();
1765 remove_wait_queue (&cp->bufferwait, &wait);
1766 if (signal_pending (current)) {
1767 /* waked up by a signal */
1768 return -ERESTARTSYS;
1769 }
1770 goto write_again;
1771 } else {
1772 set_current_state (TASK_RUNNING);
1773 remove_wait_queue (&cp->bufferwait, &wait);
1774 }
1775
1776 /* protect against too big write requests */
1777 if (len > cp->maxControlLength)
1778 len = cp->maxControlLength;
1779
1780 /* Fill the buffer */
1781 if (copy_from_user ( bp->bufp+AUH_SIZE, buf, len)) {
1782 dbg ("copy_from_user failed");
1783 auerbuf_releasebuf (bp);
1784 /* Wake up all processes waiting for a buffer */
1785 wake_up (&cp->bufferwait);
1786 up (&cp->mutex);
1787 up (&ccp->mutex);
1788 return -EFAULT;
1789 }
1790
1791 /* set the header byte */
1792 *(bp->bufp) = ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT;
1793
1794 /* Set the transfer Parameters */
1795 bp->len = len+AUH_SIZE;
1796 bp->dr->bRequestType = AUT_WREQ;
1797 bp->dr->bRequest = AUV_WBLOCK;
1798 bp->dr->wValue = cpu_to_le16 (0);
1799 bp->dr->wIndex = cpu_to_le16 (ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT);
1800 bp->dr->wLength = cpu_to_le16 (len+AUH_SIZE);
1801 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
1802 (unsigned char*)bp->dr, bp->bufp, len+AUH_SIZE,
1803 auerchar_ctrlwrite_complete, bp);
1804 /* up we go */
1805 ret = auerchain_submit_urb (&cp->controlchain, bp->urbp);
1806 up (&cp->mutex);
1807 if (ret) {
1808 dbg ("auerchar_write: nonzero result of auerchain_submit_urb %d", ret);
1809 auerbuf_releasebuf (bp);
1810 /* Wake up all processes waiting for a buffer */
1811 wake_up (&cp->bufferwait);
1812 up (&ccp->mutex);
1813 return -EIO;
1814 }
1815 else {
1816 dbg ("auerchar_write: Write OK");
1817 up (&ccp->mutex);
1818 return len;
1819 }
1820 }
1821
1822
1823 /* Close a character device */
1824 static int auerchar_release (struct inode *inode, struct file *file)
1825 {
1826 pauerchar_t ccp = (pauerchar_t) file->private_data;
1827 pauerswald_t cp;
1828 dbg("release");
1829
1830 down(&ccp->mutex);
1831 cp = ccp->auerdev;
1832 if (cp) {
1833 down(&cp->mutex);
1834 /* remove an open service */
1835 auerswald_removeservice (cp, &ccp->scontext);
1836 /* detach from device */
1837 if ((--cp->open_count <= 0) && (cp->usbdev == NULL)) {
1838 /* usb device waits for removal */
1839 up (&cp->mutex);
1840 auerswald_delete (cp);
1841 } else {
1842 up (&cp->mutex);
1843 }
1844 cp = NULL;
1845 ccp->auerdev = NULL;
1846 }
1847 up (&ccp->mutex);
1848 auerchar_delete (ccp);
1849
1850 return 0;
1851 }
1852
1853
1854 /*----------------------------------------------------------------------*/
1855 /* File operation structure */
1856 static const struct file_operations auerswald_fops =
1857 {
1858 .owner = THIS_MODULE,
1859 .llseek = no_llseek,
1860 .read = auerchar_read,
1861 .write = auerchar_write,
1862 .ioctl = auerchar_ioctl,
1863 .open = auerchar_open,
1864 .release = auerchar_release,
1865 };
1866
1867 static struct usb_class_driver auerswald_class = {
1868 .name = "auer%d",
1869 .fops = &auerswald_fops,
1870 .minor_base = AUER_MINOR_BASE,
1871 };
1872
1873
1874 /* --------------------------------------------------------------------- */
1875 /* Special USB driver functions */
1876
1877 /* Probe if this driver wants to serve an USB device
1878
1879 This entry point is called whenever a new device is attached to the bus.
1880 Then the device driver has to create a new instance of its internal data
1881 structures for the new device.
1882
1883 The dev argument specifies the device context, which contains pointers
1884 to all USB descriptors. The interface argument specifies the interface
1885 number. If a USB driver wants to bind itself to a particular device and
1886 interface it has to return a pointer. This pointer normally references
1887 the device driver's context structure.
1888
1889 Probing normally is done by checking the vendor and product identifications
1890 or the class and subclass definitions. If they match the interface number
1891 is compared with the ones supported by the driver. When probing is done
1892 class based it might be necessary to parse some more USB descriptors because
1893 the device properties can differ in a wide range.
1894 */
1895 static int auerswald_probe (struct usb_interface *intf,
1896 const struct usb_device_id *id)
1897 {
1898 struct usb_device *usbdev = interface_to_usbdev(intf);
1899 pauerswald_t cp = NULL;
1900 unsigned int u = 0;
1901 __le16 *pbuf;
1902 int ret;
1903
1904 dbg ("probe: vendor id 0x%x, device id 0x%x",
1905 le16_to_cpu(usbdev->descriptor.idVendor),
1906 le16_to_cpu(usbdev->descriptor.idProduct));
1907
1908 /* we use only the first -and only- interface */
1909 if (intf->altsetting->desc.bInterfaceNumber != 0)
1910 return -ENODEV;
1911
1912 /* allocate memory for our device and initialize it */
1913 cp = kzalloc (sizeof(auerswald_t), GFP_KERNEL);
1914 if (cp == NULL) {
1915 err ("out of memory");
1916 goto pfail;
1917 }
1918
1919 /* Initialize device descriptor */
1920 init_MUTEX (&cp->mutex);
1921 cp->usbdev = usbdev;
1922 auerchain_init (&cp->controlchain);
1923 auerbuf_init (&cp->bufctl);
1924 init_waitqueue_head (&cp->bufferwait);
1925
1926 ret = usb_register_dev(intf, &auerswald_class);
1927 if (ret) {
1928 err ("Not able to get a minor for this device.");
1929 goto pfail;
1930 }
1931
1932 /* Give the device a name */
1933 sprintf (cp->name, "usb/auer%d", intf->minor);
1934
1935 /* Store the index */
1936 cp->dtindex = intf->minor;
1937
1938 /* Get the usb version of the device */
1939 cp->version = le16_to_cpu(cp->usbdev->descriptor.bcdDevice);
1940 dbg ("Version is %X", cp->version);
1941
1942 /* allow some time to settle the device */
1943 msleep(334);
1944
1945 /* Try to get a suitable textual description of the device */
1946 /* Device name:*/
1947 ret = usb_string( cp->usbdev, AUSI_DEVICE, cp->dev_desc, AUSI_DLEN-1);
1948 if (ret >= 0) {
1949 u += ret;
1950 /* Append Serial Number */
1951 memcpy(&cp->dev_desc[u], ",Ser# ", 6);
1952 u += 6;
1953 ret = usb_string( cp->usbdev, AUSI_SERIALNR, &cp->dev_desc[u], AUSI_DLEN-u-1);
1954 if (ret >= 0) {
1955 u += ret;
1956 /* Append subscriber number */
1957 memcpy(&cp->dev_desc[u], ", ", 2);
1958 u += 2;
1959 ret = usb_string( cp->usbdev, AUSI_MSN, &cp->dev_desc[u], AUSI_DLEN-u-1);
1960 if (ret >= 0) {
1961 u += ret;
1962 }
1963 }
1964 }
1965 cp->dev_desc[u] = '\0';
1966 info("device is a %s", cp->dev_desc);
1967
1968 /* get the maximum allowed control transfer length */
1969 pbuf = kmalloc(2, GFP_KERNEL); /* use an allocated buffer because of urb target */
1970 if (!pbuf) {
1971 err( "out of memory");
1972 goto pfail;
1973 }
1974 ret = usb_control_msg(cp->usbdev, /* pointer to device */
1975 usb_rcvctrlpipe( cp->usbdev, 0 ), /* pipe to control endpoint */
1976 AUV_GETINFO, /* USB message request value */
1977 AUT_RREQ, /* USB message request type value */
1978 0, /* USB message value */
1979 AUDI_MBCTRANS, /* USB message index value */
1980 pbuf, /* pointer to the receive buffer */
1981 2, /* length of the buffer */
1982 2000); /* time to wait for the message to complete before timing out */
1983 if (ret == 2) {
1984 cp->maxControlLength = le16_to_cpup(pbuf);
1985 kfree(pbuf);
1986 dbg("setup: max. allowed control transfersize is %d bytes", cp->maxControlLength);
1987 } else {
1988 kfree(pbuf);
1989 err("setup: getting max. allowed control transfer length failed with error %d", ret);
1990 goto pfail;
1991 }
1992
1993 /* allocate a chain for the control messages */
1994 if (auerchain_setup (&cp->controlchain, AUCH_ELEMENTS)) {
1995 err ("out of memory");
1996 goto pfail;
1997 }
1998
1999 /* allocate buffers for control messages */
2000 if (auerbuf_setup (&cp->bufctl, AU_RBUFFERS, cp->maxControlLength+AUH_SIZE)) {
2001 err ("out of memory");
2002 goto pfail;
2003 }
2004
2005 /* start the interrupt endpoint */
2006 if (auerswald_int_open (cp)) {
2007 err ("int endpoint failed");
2008 goto pfail;
2009 }
2010
2011 /* all OK */
2012 usb_set_intfdata (intf, cp);
2013 return 0;
2014
2015 /* Error exit: clean up the memory */
2016 pfail: auerswald_delete (cp);
2017 return -EIO;
2018 }
2019
2020
2021 /* Disconnect driver from a served device
2022
2023 This function is called whenever a device which was served by this driver
2024 is disconnected.
2025
2026 The argument dev specifies the device context and the driver_context
2027 returns a pointer to the previously registered driver_context of the
2028 probe function. After returning from the disconnect function the USB
2029 framework completely deallocates all data structures associated with
2030 this device. So especially the usb_device structure must not be used
2031 any longer by the usb driver.
2032 */
2033 static void auerswald_disconnect (struct usb_interface *intf)
2034 {
2035 pauerswald_t cp = usb_get_intfdata (intf);
2036 unsigned int u;
2037
2038 usb_set_intfdata (intf, NULL);
2039 if (!cp)
2040 return;
2041
2042 /* give back our USB minor number */
2043 usb_deregister_dev(intf, &auerswald_class);
2044
2045 down (&cp->mutex);
2046 info ("device /dev/%s now disconnecting", cp->name);
2047
2048 /* Stop the interrupt endpoint */
2049 auerswald_int_release (cp);
2050
2051 /* remove the control chain allocated in auerswald_probe
2052 This has the benefit of
2053 a) all pending (a)synchronous urbs are unlinked
2054 b) all buffers dealing with urbs are reclaimed
2055 */
2056 auerchain_free (&cp->controlchain);
2057
2058 if (cp->open_count == 0) {
2059 /* nobody is using this device. So we can clean up now */
2060 up (&cp->mutex);/* up() is possible here because no other task
2061 can open the device (see above). I don't want
2062 to kfree() a locked mutex. */
2063 auerswald_delete (cp);
2064 } else {
2065 /* device is used. Remove the pointer to the
2066 usb device (it's not valid any more). The last
2067 release() will do the clean up */
2068 cp->usbdev = NULL;
2069 up (&cp->mutex);
2070 /* Terminate waiting writers */
2071 wake_up (&cp->bufferwait);
2072 /* Inform all waiting readers */
2073 for ( u = 0; u < AUH_TYPESIZE; u++) {
2074 pauerscon_t scp = cp->services[u];
2075 if (scp)
2076 scp->disconnect( scp);
2077 }
2078 }
2079 }
2080
2081 /* Descriptor for the devices which are served by this driver.
2082 NOTE: this struct is parsed by the usbmanager install scripts.
2083 Don't change without caution!
2084 */
2085 static struct usb_device_id auerswald_ids [] = {
2086 { USB_DEVICE (ID_AUERSWALD, 0x00C0) }, /* COMpact 2104 USB */
2087 { USB_DEVICE (ID_AUERSWALD, 0x00DB) }, /* COMpact 4410/2206 USB */
2088 { USB_DEVICE (ID_AUERSWALD, 0x00DC) }, /* COMpact 4406 DSL */
2089 { USB_DEVICE (ID_AUERSWALD, 0x00DD) }, /* COMpact 2204 USB */
2090 { USB_DEVICE (ID_AUERSWALD, 0x00F1) }, /* Comfort 2000 System Telephone */
2091 { USB_DEVICE (ID_AUERSWALD, 0x00F2) }, /* Comfort 1200 System Telephone */
2092 { } /* Terminating entry */
2093 };
2094
2095 /* Standard module device table */
2096 MODULE_DEVICE_TABLE (usb, auerswald_ids);
2097
2098 /* Standard usb driver struct */
2099 static struct usb_driver auerswald_driver = {
2100 .name = "auerswald",
2101 .probe = auerswald_probe,
2102 .disconnect = auerswald_disconnect,
2103 .id_table = auerswald_ids,
2104 };
2105
2106
2107 /* --------------------------------------------------------------------- */
2108 /* Module loading/unloading */
2109
2110 /* Driver initialisation. Called after module loading.
2111 NOTE: there is no concurrency at _init
2112 */
2113 static int __init auerswald_init (void)
2114 {
2115 int result;
2116 dbg ("init");
2117
2118 /* register driver at the USB subsystem */
2119 result = usb_register (&auerswald_driver);
2120 if (result < 0) {
2121 err ("driver could not be registered");
2122 return -1;
2123 }
2124 return 0;
2125 }
2126
2127 /* Driver deinit. Called before module removal.
2128 NOTE: there is no concurrency at _cleanup
2129 */
2130 static void __exit auerswald_cleanup (void)
2131 {
2132 dbg ("cleanup");
2133 usb_deregister (&auerswald_driver);
2134 }
2135
2136 /* --------------------------------------------------------------------- */
2137 /* Linux device driver module description */
2138
2139 MODULE_AUTHOR (DRIVER_AUTHOR);
2140 MODULE_DESCRIPTION (DRIVER_DESC);
2141 MODULE_LICENSE ("GPL");
2142
2143 module_init (auerswald_init);
2144 module_exit (auerswald_cleanup);
2145
2146 /* --------------------------------------------------------------------- */
2147
WRT350N Kernel Patches