?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / drivers / usb / misc / auerswald.c
blobc4bebdacda5c3abed047d8e59e838a29fa591d4a
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 #undef DEBUG /* include debug macros until it's done */
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, struct pt_regs *regs);
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, struct pt_regs *regs)
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, regs);
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, NULL);
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, NULL);
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 URB_ASYNC_UNLINK is set and 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, NULL);
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, NULL);
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 urbp->transfer_flags &= ~URB_ASYNC_UNLINK;
518 dbg ("unlink active urb");
519 usb_unlink_urb (urbp);
520 }
521 }
522
523
524 /* free the chain.
525 this function must not be called from interrupt or completion handler.
526 */
527 static void auerchain_free (pauerchain_t acp)
528 {
529 unsigned long flags;
530 pauerchainelement_t acep;
531
532 dbg ("auerchain_free called");
533
534 /* first, cancel all pending urbs */
535 auerchain_unlink_all (acp);
536
537 /* free the elements */
538 spin_lock_irqsave (&acp->lock, flags);
539 while (!list_empty (&acp->free_list)) {
540 /* get the next entry */
541 struct list_head *tmp = acp->free_list.next;
542 list_del (tmp);
543 spin_unlock_irqrestore (&acp->lock, flags);
544 acep = list_entry (tmp, auerchainelement_t, list);
545 kfree (acep);
546 spin_lock_irqsave (&acp->lock, flags);
547 }
548 spin_unlock_irqrestore (&acp->lock, flags);
549 }
550
551
552 /* Init the chain control structure */
553 static void auerchain_init (pauerchain_t acp)
554 {
555 /* init the chain data structure */
556 acp->active = NULL;
557 spin_lock_init (&acp->lock);
558 INIT_LIST_HEAD (&acp->waiting_list);
559 INIT_LIST_HEAD (&acp->free_list);
560 }
561
562 /* setup a chain.
563 It is assumed that there is no concurrency while setting up the chain
564 requirement: auerchain_init()
565 */
566 static int auerchain_setup (pauerchain_t acp, unsigned int numElements)
567 {
568 pauerchainelement_t acep;
569
570 dbg ("auerchain_setup called with %d elements", numElements);
571
572 /* fill the list of free elements */
573 for (;numElements; numElements--) {
574 acep = (pauerchainelement_t) kmalloc (sizeof (auerchainelement_t), GFP_KERNEL);
575 if (!acep)
576 goto ac_fail;
577 memset (acep, 0, sizeof (auerchainelement_t));
578 INIT_LIST_HEAD (&acep->list);
579 list_add_tail (&acep->list, &acp->free_list);
580 }
581 return 0;
582
583 ac_fail:/* free the elements */
584 while (!list_empty (&acp->free_list)) {
585 /* get the next entry */
586 struct list_head *tmp = acp->free_list.next;
587 list_del (tmp);
588 acep = list_entry (tmp, auerchainelement_t, list);
589 kfree (acep);
590 }
591 return -ENOMEM;
592 }
593
594
595 /* completion handler for synchronous chained URBs */
596 static void auerchain_blocking_completion (struct urb *urb, struct pt_regs *regs)
597 {
598 pauerchain_chs_t pchs = (pauerchain_chs_t)urb->context;
599 pchs->done = 1;
600 wmb();
601 wake_up (&pchs->wqh);
602 }
603
604
605 /* Starts chained urb and waits for completion or timeout */
606 static int auerchain_start_wait_urb (pauerchain_t acp, struct urb *urb, int timeout, int* actual_length)
607 {
608 DECLARE_WAITQUEUE (wait, current);
609 auerchain_chs_t chs;
610 int status;
611
612 dbg ("auerchain_start_wait_urb called");
613 init_waitqueue_head (&chs.wqh);
614 chs.done = 0;
615
616 set_current_state (TASK_UNINTERRUPTIBLE);
617 add_wait_queue (&chs.wqh, &wait);
618 urb->context = &chs;
619 status = auerchain_submit_urb (acp, urb);
620 if (status) {
621 /* something went wrong */
622 set_current_state (TASK_RUNNING);
623 remove_wait_queue (&chs.wqh, &wait);
624 return status;
625 }
626
627 while (timeout && !chs.done)
628 {
629 timeout = schedule_timeout (timeout);
630 set_current_state(TASK_UNINTERRUPTIBLE);
631 rmb();
632 }
633
634 set_current_state (TASK_RUNNING);
635 remove_wait_queue (&chs.wqh, &wait);
636
637 if (!timeout && !chs.done) {
638 if (urb->status != -EINPROGRESS) { /* No callback?!! */
639 dbg ("auerchain_start_wait_urb: raced timeout");
640 status = urb->status;
641 } else {
642 dbg ("auerchain_start_wait_urb: timeout");
643 auerchain_unlink_urb (acp, urb); /* remove urb safely */
644 status = -ETIMEDOUT;
645 }
646 } else
647 status = urb->status;
648
649 if (actual_length)
650 *actual_length = urb->actual_length;
651
652 return status;
653 }
654
655
656 /* auerchain_control_msg - Builds a control urb, sends it off and waits for completion
657 acp: pointer to the auerchain
658 dev: pointer to the usb device to send the message to
659 pipe: endpoint "pipe" to send the message to
660 request: USB message request value
661 requesttype: USB message request type value
662 value: USB message value
663 index: USB message index value
664 data: pointer to the data to send
665 size: length in bytes of the data to send
666 timeout: time to wait for the message to complete before timing out (if 0 the wait is forever)
667
668 This function sends a simple control message to a specified endpoint
669 and waits for the message to complete, or timeout.
670
671 If successful, it returns the transferred length, otherwise a negative error number.
672
673 Don't use this function from within an interrupt context, like a
674 bottom half handler. If you need an asynchronous message, or need to send
675 a message from within interrupt context, use auerchain_submit_urb()
676 */
677 static int auerchain_control_msg (pauerchain_t acp, struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype,
678 __u16 value, __u16 index, void *data, __u16 size, int timeout)
679 {
680 int ret;
681 struct usb_ctrlrequest *dr;
682 struct urb *urb;
683 int length;
684
685 dbg ("auerchain_control_msg");
686 dr = kmalloc (sizeof (struct usb_ctrlrequest), GFP_KERNEL);
687 if (!dr)
688 return -ENOMEM;
689 urb = usb_alloc_urb (0, GFP_KERNEL);
690 if (!urb) {
691 kfree (dr);
692 return -ENOMEM;
693 }
694
695 dr->bRequestType = requesttype;
696 dr->bRequest = request;
697 dr->wValue = cpu_to_le16 (value);
698 dr->wIndex = cpu_to_le16 (index);
699 dr->wLength = cpu_to_le16 (size);
700
701 usb_fill_control_urb (urb, dev, pipe, (unsigned char*)dr, data, size, /* build urb */
702 auerchain_blocking_completion, NULL);
703 ret = auerchain_start_wait_urb (acp, urb, timeout, &length);
704
705 usb_free_urb (urb);
706 kfree (dr);
707
708 if (ret < 0)
709 return ret;
710 else
711 return length;
712 }
713
714
715 /*-------------------------------------------------------------------*/
716 /* Buffer List helper functions */
717
718 /* free a single auerbuf */
719 static void auerbuf_free (pauerbuf_t bp)
720 {
721 if (bp->bufp) {
722 kfree (bp->bufp);
723 }
724 if (bp->dr) {
725 kfree (bp->dr);
726 }
727 if (bp->urbp) {
728 usb_free_urb (bp->urbp);
729 }
730 kfree (bp);
731 }
732
733 /* free the buffers from an auerbuf list */
734 static void auerbuf_free_list (struct list_head *q)
735 {
736 struct list_head *tmp;
737 struct list_head *p;
738 pauerbuf_t bp;
739
740 dbg ("auerbuf_free_list");
741 for (p = q->next; p != q;) {
742 bp = list_entry (p, auerbuf_t, buff_list);
743 tmp = p->next;
744 list_del (p);
745 p = tmp;
746 auerbuf_free (bp);
747 }
748 }
749
750 /* init the members of a list control block */
751 static void auerbuf_init (pauerbufctl_t bcp)
752 {
753 dbg ("auerbuf_init");
754 spin_lock_init (&bcp->lock);
755 INIT_LIST_HEAD (&bcp->free_buff_list);
756 INIT_LIST_HEAD (&bcp->rec_buff_list);
757 }
758
759 /* free all buffers from an auerbuf chain */
760 static void auerbuf_free_buffers (pauerbufctl_t bcp)
761 {
762 unsigned long flags;
763 dbg ("auerbuf_free_buffers");
764
765 spin_lock_irqsave (&bcp->lock, flags);
766
767 auerbuf_free_list (&bcp->free_buff_list);
768 auerbuf_free_list (&bcp->rec_buff_list);
769
770 spin_unlock_irqrestore (&bcp->lock, flags);
771 }
772
773 /* setup a list of buffers */
774 /* requirement: auerbuf_init() */
775 static int auerbuf_setup (pauerbufctl_t bcp, unsigned int numElements, unsigned int bufsize)
776 {
777 pauerbuf_t bep = NULL;
778
779 dbg ("auerbuf_setup called with %d elements of %d bytes", numElements, bufsize);
780
781 /* fill the list of free elements */
782 for (;numElements; numElements--) {
783 bep = (pauerbuf_t) kmalloc (sizeof (auerbuf_t), GFP_KERNEL);
784 if (!bep)
785 goto bl_fail;
786 memset (bep, 0, sizeof (auerbuf_t));
787 bep->list = bcp;
788 INIT_LIST_HEAD (&bep->buff_list);
789 bep->bufp = (char *) kmalloc (bufsize, GFP_KERNEL);
790 if (!bep->bufp)
791 goto bl_fail;
792 bep->dr = (struct usb_ctrlrequest *) kmalloc (sizeof (struct usb_ctrlrequest), GFP_KERNEL);
793 if (!bep->dr)
794 goto bl_fail;
795 bep->urbp = usb_alloc_urb (0, GFP_KERNEL);
796 if (!bep->urbp)
797 goto bl_fail;
798 list_add_tail (&bep->buff_list, &bcp->free_buff_list);
799 }
800 return 0;
801
802 bl_fail:/* not enough memory. Free allocated elements */
803 dbg ("auerbuf_setup: no more memory");
804 kfree(bep);
805 auerbuf_free_buffers (bcp);
806 return -ENOMEM;
807 }
808
809 /* insert a used buffer into the free list */
810 static void auerbuf_releasebuf( pauerbuf_t bp)
811 {
812 unsigned long flags;
813 pauerbufctl_t bcp = bp->list;
814 bp->retries = 0;
815
816 dbg ("auerbuf_releasebuf called");
817 spin_lock_irqsave (&bcp->lock, flags);
818 list_add_tail (&bp->buff_list, &bcp->free_buff_list);
819 spin_unlock_irqrestore (&bcp->lock, flags);
820 }
821
822
823 /*-------------------------------------------------------------------*/
824 /* Completion handlers */
825
826 /* Values of urb->status or results of usb_submit_urb():
827 0 Initial, OK
828 -EINPROGRESS during submission until end
829 -ENOENT if urb is unlinked
830 -ETIMEDOUT Transfer timed out, NAK
831 -ENOMEM Memory Overflow
832 -ENODEV Specified USB-device or bus doesn't exist
833 -ENXIO URB already queued
834 -EINVAL a) Invalid transfer type specified (or not supported)
835 b) Invalid interrupt interval (0n256)
836 -EAGAIN a) Specified ISO start frame too early
837 b) (using ISO-ASAP) Too much scheduled for the future wait some time and try again.
838 -EFBIG Too much ISO frames requested (currently uhci900)
839 -EPIPE Specified pipe-handle/Endpoint is already stalled
840 -EMSGSIZE Endpoint message size is zero, do interface/alternate setting
841 -EPROTO a) Bitstuff error
842 b) Unknown USB error
843 -EILSEQ CRC mismatch
844 -ENOSR Buffer error
845 -EREMOTEIO Short packet detected
846 -EXDEV ISO transfer only partially completed look at individual frame status for details
847 -EINVAL ISO madness, if this happens: Log off and go home
848 -EOVERFLOW babble
849 */
850
851 /* check if a status code allows a retry */
852 static int auerswald_status_retry (int status)
853 {
854 switch (status) {
855 case 0:
856 case -ETIMEDOUT:
857 case -EOVERFLOW:
858 case -EAGAIN:
859 case -EPIPE:
860 case -EPROTO:
861 case -EILSEQ:
862 case -ENOSR:
863 case -EREMOTEIO:
864 return 1; /* do a retry */
865 }
866 return 0; /* no retry possible */
867 }
868
869 /* Completion of asynchronous write block */
870 static void auerchar_ctrlwrite_complete (struct urb * urb, struct pt_regs *regs)
871 {
872 pauerbuf_t bp = (pauerbuf_t) urb->context;
873 pauerswald_t cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
874 dbg ("auerchar_ctrlwrite_complete called");
875
876 /* reuse the buffer */
877 auerbuf_releasebuf (bp);
878 /* Wake up all processes waiting for a buffer */
879 wake_up (&cp->bufferwait);
880 }
881
882 /* Completion handler for dummy retry packet */
883 static void auerswald_ctrlread_wretcomplete (struct urb * urb, struct pt_regs *regs)
884 {
885 pauerbuf_t bp = (pauerbuf_t) urb->context;
886 pauerswald_t cp;
887 int ret;
888 dbg ("auerswald_ctrlread_wretcomplete called");
889 dbg ("complete with status: %d", urb->status);
890 cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
891
892 /* check if it is possible to advance */
893 if (!auerswald_status_retry (urb->status) || !cp->usbdev) {
894 /* reuse the buffer */
895 err ("control dummy: transmission error %d, can not retry", urb->status);
896 auerbuf_releasebuf (bp);
897 /* Wake up all processes waiting for a buffer */
898 wake_up (&cp->bufferwait);
899 return;
900 }
901
902 /* fill the control message */
903 bp->dr->bRequestType = AUT_RREQ;
904 bp->dr->bRequest = AUV_RBLOCK;
905 bp->dr->wLength = bp->dr->wValue; /* temporary stored */
906 bp->dr->wValue = cpu_to_le16 (1); /* Retry Flag */
907 /* bp->dr->index = channel id; remains */
908 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
909 (unsigned char*)bp->dr, bp->bufp, le16_to_cpu (bp->dr->wLength),
910 auerswald_ctrlread_complete,bp);
911
912 /* submit the control msg as next paket */
913 ret = auerchain_submit_urb_list (&cp->controlchain, bp->urbp, 1);
914 if (ret) {
915 dbg ("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
916 bp->urbp->status = ret;
917 auerswald_ctrlread_complete (bp->urbp, NULL);
918 }
919 }
920
921 /* completion handler for receiving of control messages */
922 static void auerswald_ctrlread_complete (struct urb * urb, struct pt_regs *regs)
923 {
924 unsigned int serviceid;
925 pauerswald_t cp;
926 pauerscon_t scp;
927 pauerbuf_t bp = (pauerbuf_t) urb->context;
928 int ret;
929 dbg ("auerswald_ctrlread_complete called");
930
931 cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
932
933 /* check if there is valid data in this urb */
934 if (urb->status) {
935 dbg ("complete with non-zero status: %d", urb->status);
936 /* should we do a retry? */
937 if (!auerswald_status_retry (urb->status)
938 || !cp->usbdev
939 || (cp->version < AUV_RETRY)
940 || (bp->retries >= AU_RETRIES)) {
941 /* reuse the buffer */
942 err ("control read: transmission error %d, can not retry", urb->status);
943 auerbuf_releasebuf (bp);
944 /* Wake up all processes waiting for a buffer */
945 wake_up (&cp->bufferwait);
946 return;
947 }
948 bp->retries++;
949 dbg ("Retry count = %d", bp->retries);
950 /* send a long dummy control-write-message to allow device firmware to react */
951 bp->dr->bRequestType = AUT_WREQ;
952 bp->dr->bRequest = AUV_DUMMY;
953 bp->dr->wValue = bp->dr->wLength; /* temporary storage */
954 // bp->dr->wIndex channel ID remains
955 bp->dr->wLength = cpu_to_le16 (32); /* >= 8 bytes */
956 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
957 (unsigned char*)bp->dr, bp->bufp, 32,
958 auerswald_ctrlread_wretcomplete,bp);
959
960 /* submit the control msg as next paket */
961 ret = auerchain_submit_urb_list (&cp->controlchain, bp->urbp, 1);
962 if (ret) {
963 dbg ("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
964 bp->urbp->status = ret;
965 auerswald_ctrlread_wretcomplete (bp->urbp, regs);
966 }
967 return;
968 }
969
970 /* get the actual bytecount (incl. headerbyte) */
971 bp->len = urb->actual_length;
972 serviceid = bp->bufp[0] & AUH_TYPEMASK;
973 dbg ("Paket with serviceid %d and %d bytes received", serviceid, bp->len);
974
975 /* dispatch the paket */
976 scp = cp->services[serviceid];
977 if (scp) {
978 /* look, Ma, a listener! */
979 scp->dispatch (scp, bp);
980 }
981
982 /* release the paket */
983 auerbuf_releasebuf (bp);
984 /* Wake up all processes waiting for a buffer */
985 wake_up (&cp->bufferwait);
986 }
987
988 /*-------------------------------------------------------------------*/
989 /* Handling of Interrupt Endpoint */
990 /* This interrupt Endpoint is used to inform the host about waiting
991 messages from the USB device.
992 */
993 /* int completion handler. */
994 static void auerswald_int_complete (struct urb * urb, struct pt_regs *regs)
995 {
996 unsigned long flags;
997 unsigned int channelid;
998 unsigned int bytecount;
999 int ret;
1000 pauerbuf_t bp = NULL;
1001 pauerswald_t cp = (pauerswald_t) urb->context;
1002
1003 dbg ("%s called", __FUNCTION__);
1004
1005 switch (urb->status) {
1006 case 0:
1007 /* success */
1008 break;
1009 case -ECONNRESET:
1010 case -ENOENT:
1011 case -ESHUTDOWN:
1012 /* this urb is terminated, clean up */
1013 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
1014 return;
1015 default:
1016 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
1017 goto exit;
1018 }
1019
1020 /* check if all needed data was received */
1021 if (urb->actual_length < AU_IRQMINSIZE) {
1022 dbg ("invalid data length received: %d bytes", urb->actual_length);
1023 goto exit;
1024 }
1025
1026 /* check the command code */
1027 if (cp->intbufp[0] != AU_IRQCMDID) {
1028 dbg ("invalid command received: %d", cp->intbufp[0]);
1029 goto exit;
1030 }
1031
1032 /* check the command type */
1033 if (cp->intbufp[1] != AU_BLOCKRDY) {
1034 dbg ("invalid command type received: %d", cp->intbufp[1]);
1035 goto exit;
1036 }
1037
1038 /* now extract the information */
1039 channelid = cp->intbufp[2];
1040 bytecount = (unsigned char)cp->intbufp[3];
1041 bytecount |= (unsigned char)cp->intbufp[4] << 8;
1042
1043 /* check the channel id */
1044 if (channelid >= AUH_TYPESIZE) {
1045 dbg ("invalid channel id received: %d", channelid);
1046 goto exit;
1047 }
1048
1049 /* check the byte count */
1050 if (bytecount > (cp->maxControlLength+AUH_SIZE)) {
1051 dbg ("invalid byte count received: %d", bytecount);
1052 goto exit;
1053 }
1054 dbg ("Service Channel = %d", channelid);
1055 dbg ("Byte Count = %d", bytecount);
1056
1057 /* get a buffer for the next data paket */
1058 spin_lock_irqsave (&cp->bufctl.lock, flags);
1059 if (!list_empty (&cp->bufctl.free_buff_list)) {
1060 /* yes: get the entry */
1061 struct list_head *tmp = cp->bufctl.free_buff_list.next;
1062 list_del (tmp);
1063 bp = list_entry (tmp, auerbuf_t, buff_list);
1064 }
1065 spin_unlock_irqrestore (&cp->bufctl.lock, flags);
1066
1067 /* if no buffer available: skip it */
1068 if (!bp) {
1069 dbg ("auerswald_int_complete: no data buffer available");
1070 /* can we do something more?
1071 This is a big problem: if this int packet is ignored, the
1072 device will wait forever and not signal any more data.
1073 The only real solution is: having enough buffers!
1074 Or perhaps temporary disabling the int endpoint?
1075 */
1076 goto exit;
1077 }
1078
1079 /* fill the control message */
1080 bp->dr->bRequestType = AUT_RREQ;
1081 bp->dr->bRequest = AUV_RBLOCK;
1082 bp->dr->wValue = cpu_to_le16 (0);
1083 bp->dr->wIndex = cpu_to_le16 (channelid | AUH_DIRECT | AUH_UNSPLIT);
1084 bp->dr->wLength = cpu_to_le16 (bytecount);
1085 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_rcvctrlpipe (cp->usbdev, 0),
1086 (unsigned char*)bp->dr, bp->bufp, bytecount,
1087 auerswald_ctrlread_complete,bp);
1088
1089 /* submit the control msg */
1090 ret = auerchain_submit_urb (&cp->controlchain, bp->urbp);
1091 if (ret) {
1092 dbg ("auerswald_int_complete: nonzero result of auerchain_submit_urb %d", ret);
1093 bp->urbp->status = ret;
1094 auerswald_ctrlread_complete( bp->urbp, NULL);
1095 /* here applies the same problem as above: device locking! */
1096 }
1097 exit:
1098 ret = usb_submit_urb (urb, GFP_ATOMIC);
1099 if (ret)
1100 err ("%s - usb_submit_urb failed with result %d",
1101 __FUNCTION__, ret);
1102 }
1103
1104 /* int memory deallocation
1105 NOTE: no mutex please!
1106 */
1107 static void auerswald_int_free (pauerswald_t cp)
1108 {
1109 if (cp->inturbp) {
1110 usb_free_urb (cp->inturbp);
1111 cp->inturbp = NULL;
1112 }
1113 if (cp->intbufp) {
1114 kfree (cp->intbufp);
1115 cp->intbufp = NULL;
1116 }
1117 }
1118
1119 /* This function is called to activate the interrupt
1120 endpoint. This function returns 0 if successful or an error code.
1121 NOTE: no mutex please!
1122 */
1123 static int auerswald_int_open (pauerswald_t cp)
1124 {
1125 int ret;
1126 struct usb_endpoint_descriptor *ep;
1127 int irqsize;
1128 dbg ("auerswald_int_open");
1129
1130 ep = usb_epnum_to_ep_desc (cp->usbdev, USB_DIR_IN | AU_IRQENDP);
1131 if (!ep) {
1132 ret = -EFAULT;
1133 goto intoend;
1134 }
1135 irqsize = ep->wMaxPacketSize;
1136 cp->irqsize = irqsize;
1137
1138 /* allocate the urb and data buffer */
1139 if (!cp->inturbp) {
1140 cp->inturbp = usb_alloc_urb (0, GFP_KERNEL);
1141 if (!cp->inturbp) {
1142 ret = -ENOMEM;
1143 goto intoend;
1144 }
1145 }
1146 if (!cp->intbufp) {
1147 cp->intbufp = (char *) kmalloc (irqsize, GFP_KERNEL);
1148 if (!cp->intbufp) {
1149 ret = -ENOMEM;
1150 goto intoend;
1151 }
1152 }
1153 /* setup urb */
1154 usb_fill_int_urb (cp->inturbp, cp->usbdev, usb_rcvintpipe (cp->usbdev,AU_IRQENDP), cp->intbufp, irqsize, auerswald_int_complete, cp, ep->bInterval);
1155 /* start the urb */
1156 cp->inturbp->status = 0; /* needed! */
1157 ret = usb_submit_urb (cp->inturbp, GFP_KERNEL);
1158
1159 intoend:
1160 if (ret < 0) {
1161 /* activation of interrupt endpoint has failed. Now clean up. */
1162 dbg ("auerswald_int_open: activation of int endpoint failed");
1163
1164 /* deallocate memory */
1165 auerswald_int_free (cp);
1166 }
1167 return ret;
1168 }
1169
1170 /* This function is called to deactivate the interrupt
1171 endpoint. This function returns 0 if successful or an error code.
1172 NOTE: no mutex please!
1173 */
1174 static int auerswald_int_release (pauerswald_t cp)
1175 {
1176 int ret = 0;
1177 dbg ("auerswald_int_release");
1178
1179 /* stop the int endpoint */
1180 if (cp->inturbp) {
1181 ret = usb_unlink_urb (cp->inturbp);
1182 if (ret)
1183 dbg ("nonzero int unlink result received: %d", ret);
1184 }
1185
1186 /* deallocate memory */
1187 auerswald_int_free (cp);
1188
1189 return ret;
1190 }
1191
1192 /* --------------------------------------------------------------------- */
1193 /* Helper functions */
1194
1195 /* wake up waiting readers */
1196 static void auerchar_disconnect (pauerscon_t scp)
1197 {
1198 pauerchar_t ccp = ((pauerchar_t)((char *)(scp)-(unsigned long)(&((pauerchar_t)0)->scontext)));
1199 dbg ("auerchar_disconnect called");
1200 ccp->removed = 1;
1201 wake_up (&ccp->readwait);
1202 }
1203
1204
1205 /* dispatch a read paket to a waiting character device */
1206 static void auerchar_ctrlread_dispatch (pauerscon_t scp, pauerbuf_t bp)
1207 {
1208 unsigned long flags;
1209 pauerchar_t ccp;
1210 pauerbuf_t newbp = NULL;
1211 char * charp;
1212 dbg ("auerchar_ctrlread_dispatch called");
1213 ccp = ((pauerchar_t)((char *)(scp)-(unsigned long)(&((pauerchar_t)0)->scontext)));
1214
1215 /* get a read buffer from character device context */
1216 spin_lock_irqsave (&ccp->bufctl.lock, flags);
1217 if (!list_empty (&ccp->bufctl.free_buff_list)) {
1218 /* yes: get the entry */
1219 struct list_head *tmp = ccp->bufctl.free_buff_list.next;
1220 list_del (tmp);
1221 newbp = list_entry (tmp, auerbuf_t, buff_list);
1222 }
1223 spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1224
1225 if (!newbp) {
1226 dbg ("No read buffer available, discard paket!");
1227 return; /* no buffer, no dispatch */
1228 }
1229
1230 /* copy information to new buffer element
1231 (all buffers have the same length) */
1232 charp = newbp->bufp;
1233 newbp->bufp = bp->bufp;
1234 bp->bufp = charp;
1235 newbp->len = bp->len;
1236
1237 /* insert new buffer in read list */
1238 spin_lock_irqsave (&ccp->bufctl.lock, flags);
1239 list_add_tail (&newbp->buff_list, &ccp->bufctl.rec_buff_list);
1240 spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1241 dbg ("read buffer appended to rec_list");
1242
1243 /* wake up pending synchronous reads */
1244 wake_up (&ccp->readwait);
1245 }
1246
1247
1248 /* Delete an auerswald driver context */
1249 static void auerswald_delete( pauerswald_t cp)
1250 {
1251 dbg( "auerswald_delete");
1252 if (cp == NULL)
1253 return;
1254
1255 /* Wake up all processes waiting for a buffer */
1256 wake_up (&cp->bufferwait);
1257
1258 /* Cleaning up */
1259 auerswald_int_release (cp);
1260 auerchain_free (&cp->controlchain);
1261 auerbuf_free_buffers (&cp->bufctl);
1262
1263 /* release the memory */
1264 kfree( cp);
1265 }
1266
1267
1268 /* Delete an auerswald character context */
1269 static void auerchar_delete( pauerchar_t ccp)
1270 {
1271 dbg ("auerchar_delete");
1272 if (ccp == NULL)
1273 return;
1274
1275 /* wake up pending synchronous reads */
1276 ccp->removed = 1;
1277 wake_up (&ccp->readwait);
1278
1279 /* remove the read buffer */
1280 if (ccp->readbuf) {
1281 auerbuf_releasebuf (ccp->readbuf);
1282 ccp->readbuf = NULL;
1283 }
1284
1285 /* remove the character buffers */
1286 auerbuf_free_buffers (&ccp->bufctl);
1287
1288 /* release the memory */
1289 kfree( ccp);
1290 }
1291
1292
1293 /* add a new service to the device
1294 scp->id must be set!
1295 return: 0 if OK, else error code
1296 */
1297 static int auerswald_addservice (pauerswald_t cp, pauerscon_t scp)
1298 {
1299 int ret;
1300
1301 /* is the device available? */
1302 if (!cp->usbdev) {
1303 dbg ("usbdev == NULL");
1304 return -EIO; /*no: can not add a service, sorry*/
1305 }
1306
1307 /* is the service available? */
1308 if (cp->services[scp->id]) {
1309 dbg ("service is busy");
1310 return -EBUSY;
1311 }
1312
1313 /* device is available, service is free */
1314 cp->services[scp->id] = scp;
1315
1316 /* register service in device */
1317 ret = auerchain_control_msg(
1318 &cp->controlchain, /* pointer to control chain */
1319 cp->usbdev, /* pointer to device */
1320 usb_sndctrlpipe (cp->usbdev, 0), /* pipe to control endpoint */
1321 AUV_CHANNELCTL, /* USB message request value */
1322 AUT_WREQ, /* USB message request type value */
1323 0x01, /* open USB message value */
1324 scp->id, /* USB message index value */
1325 NULL, /* pointer to the data to send */
1326 0, /* length in bytes of the data to send */
1327 HZ * 2); /* time to wait for the message to complete before timing out */
1328 if (ret < 0) {
1329 dbg ("auerswald_addservice: auerchain_control_msg returned error code %d", ret);
1330 /* undo above actions */
1331 cp->services[scp->id] = NULL;
1332 return ret;
1333 }
1334
1335 dbg ("auerswald_addservice: channel open OK");
1336 return 0;
1337 }
1338
1339
1340 /* remove a service from the the device
1341 scp->id must be set! */
1342 static void auerswald_removeservice (pauerswald_t cp, pauerscon_t scp)
1343 {
1344 dbg ("auerswald_removeservice called");
1345
1346 /* check if we have a service allocated */
1347 if (scp->id == AUH_UNASSIGNED)
1348 return;
1349
1350 /* If there is a device: close the channel */
1351 if (cp->usbdev) {
1352 /* Close the service channel inside the device */
1353 int ret = auerchain_control_msg(
1354 &cp->controlchain, /* pointer to control chain */
1355 cp->usbdev, /* pointer to device */
1356 usb_sndctrlpipe (cp->usbdev, 0), /* pipe to control endpoint */
1357 AUV_CHANNELCTL, /* USB message request value */
1358 AUT_WREQ, /* USB message request type value */
1359 0x00, // close /* USB message value */
1360 scp->id, /* USB message index value */
1361 NULL, /* pointer to the data to send */
1362 0, /* length in bytes of the data to send */
1363 HZ * 2); /* time to wait for the message to complete before timing out */
1364 if (ret < 0) {
1365 dbg ("auerswald_removeservice: auerchain_control_msg returned error code %d", ret);
1366 }
1367 else {
1368 dbg ("auerswald_removeservice: channel close OK");
1369 }
1370 }
1371
1372 /* remove the service from the device */
1373 cp->services[scp->id] = NULL;
1374 scp->id = AUH_UNASSIGNED;
1375 }
1376
1377
1378 /* --------------------------------------------------------------------- */
1379 /* Char device functions */
1380
1381 /* Open a new character device */
1382 static int auerchar_open (struct inode *inode, struct file *file)
1383 {
1384 int dtindex = iminor(inode);
1385 pauerswald_t cp = NULL;
1386 pauerchar_t ccp = NULL;
1387 struct usb_interface *intf;
1388 int ret;
1389
1390 /* minor number in range? */
1391 if (dtindex < 0) {
1392 return -ENODEV;
1393 }
1394 intf = usb_find_interface(&auerswald_driver, dtindex);
1395 if (!intf) {
1396 return -ENODEV;
1397 }
1398
1399 /* usb device available? */
1400 cp = usb_get_intfdata (intf);
1401 if (cp == NULL) {
1402 return -ENODEV;
1403 }
1404 if (down_interruptible (&cp->mutex)) {
1405 return -ERESTARTSYS;
1406 }
1407
1408 /* we have access to the device. Now lets allocate memory */
1409 ccp = (pauerchar_t) kmalloc(sizeof(auerchar_t), GFP_KERNEL);
1410 if (ccp == NULL) {
1411 err ("out of memory");
1412 ret = -ENOMEM;
1413 goto ofail;
1414 }
1415
1416 /* Initialize device descriptor */
1417 memset( ccp, 0, sizeof(auerchar_t));
1418 init_MUTEX( &ccp->mutex);
1419 init_MUTEX( &ccp->readmutex);
1420 auerbuf_init (&ccp->bufctl);
1421 ccp->scontext.id = AUH_UNASSIGNED;
1422 ccp->scontext.dispatch = auerchar_ctrlread_dispatch;
1423 ccp->scontext.disconnect = auerchar_disconnect;
1424 init_waitqueue_head (&ccp->readwait);
1425
1426 ret = auerbuf_setup (&ccp->bufctl, AU_RBUFFERS, cp->maxControlLength+AUH_SIZE);
1427 if (ret) {
1428 goto ofail;
1429 }
1430
1431 cp->open_count++;
1432 ccp->auerdev = cp;
1433 dbg("open %s as /dev/%s", cp->dev_desc, cp->name);
1434 up (&cp->mutex);
1435
1436 /* file IO stuff */
1437 file->f_pos = 0;
1438 file->private_data = ccp;
1439 return nonseekable_open(inode, file);
1440
1441 /* Error exit */
1442 ofail: up (&cp->mutex);
1443 auerchar_delete (ccp);
1444 return ret;
1445 }
1446
1447
1448 /* IOCTL functions */
1449 static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1450 {
1451 pauerchar_t ccp = (pauerchar_t) file->private_data;
1452 int ret = 0;
1453 audevinfo_t devinfo;
1454 pauerswald_t cp = NULL;
1455 unsigned int u;
1456 unsigned int __user *user_arg = (unsigned int __user *)arg;
1457
1458 dbg ("ioctl");
1459
1460 /* get the mutexes */
1461 if (down_interruptible (&ccp->mutex)) {
1462 return -ERESTARTSYS;
1463 }
1464 cp = ccp->auerdev;
1465 if (!cp) {
1466 up (&ccp->mutex);
1467 return -ENODEV;
1468 }
1469 if (down_interruptible (&cp->mutex)) {
1470 up(&ccp->mutex);
1471 return -ERESTARTSYS;
1472 }
1473
1474 /* Check for removal */
1475 if (!cp->usbdev) {
1476 up(&cp->mutex);
1477 up(&ccp->mutex);
1478 return -ENODEV;
1479 }
1480
1481 switch (cmd) {
1482
1483 /* return != 0 if Transmitt channel ready to send */
1484 case IOCTL_AU_TXREADY:
1485 dbg ("IOCTL_AU_TXREADY");
1486 u = ccp->auerdev
1487 && (ccp->scontext.id != AUH_UNASSIGNED)
1488 && !list_empty (&cp->bufctl.free_buff_list);
1489 ret = put_user (u, user_arg);
1490 break;
1491
1492 /* return != 0 if connected to a service channel */
1493 case IOCTL_AU_CONNECT:
1494 dbg ("IOCTL_AU_CONNECT");
1495 u = (ccp->scontext.id != AUH_UNASSIGNED);
1496 ret = put_user (u, user_arg);
1497 break;
1498
1499 /* return != 0 if Receive Data available */
1500 case IOCTL_AU_RXAVAIL:
1501 dbg ("IOCTL_AU_RXAVAIL");
1502 if (ccp->scontext.id == AUH_UNASSIGNED) {
1503 ret = -EIO;
1504 break;
1505 }
1506 u = 0; /* no data */
1507 if (ccp->readbuf) {
1508 int restlen = ccp->readbuf->len - ccp->readoffset;
1509 if (restlen > 0)
1510 u = 1;
1511 }
1512 if (!u) {
1513 if (!list_empty (&ccp->bufctl.rec_buff_list)) {
1514 u = 1;
1515 }
1516 }
1517 ret = put_user (u, user_arg);
1518 break;
1519
1520 /* return the max. buffer length for the device */
1521 case IOCTL_AU_BUFLEN:
1522 dbg ("IOCTL_AU_BUFLEN");
1523 u = cp->maxControlLength;
1524 ret = put_user (u, user_arg);
1525 break;
1526
1527 /* requesting a service channel */
1528 case IOCTL_AU_SERVREQ:
1529 dbg ("IOCTL_AU_SERVREQ");
1530 /* requesting a service means: release the previous one first */
1531 auerswald_removeservice (cp, &ccp->scontext);
1532 /* get the channel number */
1533 ret = get_user (u, user_arg);
1534 if (ret) {
1535 break;
1536 }
1537 if ((u < AUH_FIRSTUSERCH) || (u >= AUH_TYPESIZE)) {
1538 ret = -EIO;
1539 break;
1540 }
1541 dbg ("auerchar service request parameters are ok");
1542 ccp->scontext.id = u;
1543
1544 /* request the service now */
1545 ret = auerswald_addservice (cp, &ccp->scontext);
1546 if (ret) {
1547 /* no: revert service entry */
1548 ccp->scontext.id = AUH_UNASSIGNED;
1549 }
1550 break;
1551
1552 /* get a string descriptor for the device */
1553 case IOCTL_AU_DEVINFO:
1554 dbg ("IOCTL_AU_DEVINFO");
1555 if (copy_from_user (&devinfo, (void __user *) arg, sizeof (audevinfo_t))) {
1556 ret = -EFAULT;
1557 break;
1558 }
1559 u = strlen(cp->dev_desc)+1;
1560 if (u > devinfo.bsize) {
1561 u = devinfo.bsize;
1562 }
1563 ret = copy_to_user(devinfo.buf, cp->dev_desc, u) ? -EFAULT : 0;
1564 break;
1565
1566 /* get the max. string descriptor length */
1567 case IOCTL_AU_SLEN:
1568 dbg ("IOCTL_AU_SLEN");
1569 u = AUSI_DLEN;
1570 ret = put_user (u, user_arg);
1571 break;
1572
1573 default:
1574 dbg ("IOCTL_AU_UNKNOWN");
1575 ret = -ENOIOCTLCMD;
1576 break;
1577 }
1578 /* release the mutexes */
1579 up(&cp->mutex);
1580 up(&ccp->mutex);
1581 return ret;
1582 }
1583
1584 /* Read data from the device */
1585 static ssize_t auerchar_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
1586 {
1587 unsigned long flags;
1588 pauerchar_t ccp = (pauerchar_t) file->private_data;
1589 pauerbuf_t bp = NULL;
1590 wait_queue_t wait;
1591
1592 dbg ("auerchar_read");
1593
1594 /* Error checking */
1595 if (!ccp)
1596 return -EIO;
1597 if (*ppos)
1598 return -ESPIPE;
1599 if (count == 0)
1600 return 0;
1601
1602 /* get the mutex */
1603 if (down_interruptible (&ccp->mutex))
1604 return -ERESTARTSYS;
1605
1606 /* Can we expect to read something? */
1607 if (ccp->scontext.id == AUH_UNASSIGNED) {
1608 up (&ccp->mutex);
1609 return -EIO;
1610 }
1611
1612 /* only one reader per device allowed */
1613 if (down_interruptible (&ccp->readmutex)) {
1614 up (&ccp->mutex);
1615 return -ERESTARTSYS;
1616 }
1617
1618 /* read data from readbuf, if available */
1619 doreadbuf:
1620 bp = ccp->readbuf;
1621 if (bp) {
1622 /* read the maximum bytes */
1623 int restlen = bp->len - ccp->readoffset;
1624 if (restlen < 0)
1625 restlen = 0;
1626 if (count > restlen)
1627 count = restlen;
1628 if (count) {
1629 if (copy_to_user (buf, bp->bufp+ccp->readoffset, count)) {
1630 dbg ("auerswald_read: copy_to_user failed");
1631 up (&ccp->readmutex);
1632 up (&ccp->mutex);
1633 return -EFAULT;
1634 }
1635 }
1636 /* advance the read offset */
1637 ccp->readoffset += count;
1638 restlen -= count;
1639 // reuse the read buffer
1640 if (restlen <= 0) {
1641 auerbuf_releasebuf (bp);
1642 ccp->readbuf = NULL;
1643 }
1644 /* return with number of bytes read */
1645 if (count) {
1646 up (&ccp->readmutex);
1647 up (&ccp->mutex);
1648 return count;
1649 }
1650 }
1651
1652 /* a read buffer is not available. Try to get the next data block. */
1653 doreadlist:
1654 /* Preparing for sleep */
1655 init_waitqueue_entry (&wait, current);
1656 set_current_state (TASK_INTERRUPTIBLE);
1657 add_wait_queue (&ccp->readwait, &wait);
1658
1659 bp = NULL;
1660 spin_lock_irqsave (&ccp->bufctl.lock, flags);
1661 if (!list_empty (&ccp->bufctl.rec_buff_list)) {
1662 /* yes: get the entry */
1663 struct list_head *tmp = ccp->bufctl.rec_buff_list.next;
1664 list_del (tmp);
1665 bp = list_entry (tmp, auerbuf_t, buff_list);
1666 }
1667 spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1668
1669 /* have we got data? */
1670 if (bp) {
1671 ccp->readbuf = bp;
1672 ccp->readoffset = AUH_SIZE; /* for headerbyte */
1673 set_current_state (TASK_RUNNING);
1674 remove_wait_queue (&ccp->readwait, &wait);
1675 goto doreadbuf; /* now we can read! */
1676 }
1677
1678 /* no data available. Should we wait? */
1679 if (file->f_flags & O_NONBLOCK) {
1680 dbg ("No read buffer available, returning -EAGAIN");
1681 set_current_state (TASK_RUNNING);
1682 remove_wait_queue (&ccp->readwait, &wait);
1683 up (&ccp->readmutex);
1684 up (&ccp->mutex);
1685 return -EAGAIN; /* nonblocking, no data available */
1686 }
1687
1688 /* yes, we should wait! */
1689 up (&ccp->mutex); /* allow other operations while we wait */
1690 schedule();
1691 remove_wait_queue (&ccp->readwait, &wait);
1692 if (signal_pending (current)) {
1693 /* waked up by a signal */
1694 up (&ccp->readmutex);
1695 return -ERESTARTSYS;
1696 }
1697
1698 /* Anything left to read? */
1699 if ((ccp->scontext.id == AUH_UNASSIGNED) || ccp->removed) {
1700 up (&ccp->readmutex);
1701 return -EIO;
1702 }
1703
1704 if (down_interruptible (&ccp->mutex)) {
1705 up (&ccp->readmutex);
1706 return -ERESTARTSYS;
1707 }
1708
1709 /* try to read the incoming data again */
1710 goto doreadlist;
1711 }
1712
1713
1714 /* Write a data block into the right service channel of the device */
1715 static ssize_t auerchar_write (struct file *file, const char __user *buf, size_t len, loff_t *ppos)
1716 {
1717 pauerchar_t ccp = (pauerchar_t) file->private_data;
1718 pauerswald_t cp = NULL;
1719 pauerbuf_t bp;
1720 unsigned long flags;
1721 int ret;
1722 wait_queue_t wait;
1723
1724 dbg ("auerchar_write %d bytes", len);
1725
1726 /* Error checking */
1727 if (!ccp)
1728 return -EIO;
1729 if (*ppos)
1730 return -ESPIPE;
1731 if (len == 0)
1732 return 0;
1733
1734 write_again:
1735 /* get the mutex */
1736 if (down_interruptible (&ccp->mutex))
1737 return -ERESTARTSYS;
1738
1739 /* Can we expect to write something? */
1740 if (ccp->scontext.id == AUH_UNASSIGNED) {
1741 up (&ccp->mutex);
1742 return -EIO;
1743 }
1744
1745 cp = ccp->auerdev;
1746 if (!cp) {
1747 up (&ccp->mutex);
1748 return -ERESTARTSYS;
1749 }
1750 if (down_interruptible (&cp->mutex)) {
1751 up (&ccp->mutex);
1752 return -ERESTARTSYS;
1753 }
1754 if (!cp->usbdev) {
1755 up (&cp->mutex);
1756 up (&ccp->mutex);
1757 return -EIO;
1758 }
1759 /* Prepare for sleep */
1760 init_waitqueue_entry (&wait, current);
1761 set_current_state (TASK_INTERRUPTIBLE);
1762 add_wait_queue (&cp->bufferwait, &wait);
1763
1764 /* Try to get a buffer from the device pool.
1765 We can't use a buffer from ccp->bufctl because the write
1766 command will last beond a release() */
1767 bp = NULL;
1768 spin_lock_irqsave (&cp->bufctl.lock, flags);
1769 if (!list_empty (&cp->bufctl.free_buff_list)) {
1770 /* yes: get the entry */
1771 struct list_head *tmp = cp->bufctl.free_buff_list.next;
1772 list_del (tmp);
1773 bp = list_entry (tmp, auerbuf_t, buff_list);
1774 }
1775 spin_unlock_irqrestore (&cp->bufctl.lock, flags);
1776
1777 /* are there any buffers left? */
1778 if (!bp) {
1779 up (&cp->mutex);
1780 up (&ccp->mutex);
1781
1782 /* NONBLOCK: don't wait */
1783 if (file->f_flags & O_NONBLOCK) {
1784 set_current_state (TASK_RUNNING);
1785 remove_wait_queue (&cp->bufferwait, &wait);
1786 return -EAGAIN;
1787 }
1788
1789 /* BLOCKING: wait */
1790 schedule();
1791 remove_wait_queue (&cp->bufferwait, &wait);
1792 if (signal_pending (current)) {
1793 /* waked up by a signal */
1794 return -ERESTARTSYS;
1795 }
1796 goto write_again;
1797 } else {
1798 set_current_state (TASK_RUNNING);
1799 remove_wait_queue (&cp->bufferwait, &wait);
1800 }
1801
1802 /* protect against too big write requests */
1803 if (len > cp->maxControlLength)
1804 len = cp->maxControlLength;
1805
1806 /* Fill the buffer */
1807 if (copy_from_user ( bp->bufp+AUH_SIZE, buf, len)) {
1808 dbg ("copy_from_user failed");
1809 auerbuf_releasebuf (bp);
1810 /* Wake up all processes waiting for a buffer */
1811 wake_up (&cp->bufferwait);
1812 up (&cp->mutex);
1813 up (&ccp->mutex);
1814 return -EFAULT;
1815 }
1816
1817 /* set the header byte */
1818 *(bp->bufp) = ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT;
1819
1820 /* Set the transfer Parameters */
1821 bp->len = len+AUH_SIZE;
1822 bp->dr->bRequestType = AUT_WREQ;
1823 bp->dr->bRequest = AUV_WBLOCK;
1824 bp->dr->wValue = cpu_to_le16 (0);
1825 bp->dr->wIndex = cpu_to_le16 (ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT);
1826 bp->dr->wLength = cpu_to_le16 (len+AUH_SIZE);
1827 usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
1828 (unsigned char*)bp->dr, bp->bufp, len+AUH_SIZE,
1829 auerchar_ctrlwrite_complete, bp);
1830 /* up we go */
1831 ret = auerchain_submit_urb (&cp->controlchain, bp->urbp);
1832 up (&cp->mutex);
1833 if (ret) {
1834 dbg ("auerchar_write: nonzero result of auerchain_submit_urb %d", ret);
1835 auerbuf_releasebuf (bp);
1836 /* Wake up all processes waiting for a buffer */
1837 wake_up (&cp->bufferwait);
1838 up (&ccp->mutex);
1839 return -EIO;
1840 }
1841 else {
1842 dbg ("auerchar_write: Write OK");
1843 up (&ccp->mutex);
1844 return len;
1845 }
1846 }
1847
1848
1849 /* Close a character device */
1850 static int auerchar_release (struct inode *inode, struct file *file)
1851 {
1852 pauerchar_t ccp = (pauerchar_t) file->private_data;
1853 pauerswald_t cp;
1854 dbg("release");
1855
1856 /* get the mutexes */
1857 if (down_interruptible (&ccp->mutex)) {
1858 return -ERESTARTSYS;
1859 }
1860 cp = ccp->auerdev;
1861 if (cp) {
1862 if (down_interruptible (&cp->mutex)) {
1863 up (&ccp->mutex);
1864 return -ERESTARTSYS;
1865 }
1866 /* remove an open service */
1867 auerswald_removeservice (cp, &ccp->scontext);
1868 /* detach from device */
1869 if ((--cp->open_count <= 0) && (cp->usbdev == NULL)) {
1870 /* usb device waits for removal */
1871 up (&cp->mutex);
1872 auerswald_delete (cp);
1873 } else {
1874 up (&cp->mutex);
1875 }
1876 cp = NULL;
1877 ccp->auerdev = NULL;
1878 }
1879 up (&ccp->mutex);
1880 auerchar_delete (ccp);
1881
1882 return 0;
1883 }
1884
1885
1886 /*----------------------------------------------------------------------*/
1887 /* File operation structure */
1888 static struct file_operations auerswald_fops =
1889 {
1890 .owner = THIS_MODULE,
1891 .llseek = no_llseek,
1892 .read = auerchar_read,
1893 .write = auerchar_write,
1894 .ioctl = auerchar_ioctl,
1895 .open = auerchar_open,
1896 .release = auerchar_release,
1897 };
1898
1899 static struct usb_class_driver auerswald_class = {
1900 .name = "usb/auer%d",
1901 .fops = &auerswald_fops,
1902 .mode = S_IFCHR | S_IRUGO | S_IWUGO,
1903 .minor_base = AUER_MINOR_BASE,
1904 };
1905
1906
1907 /* --------------------------------------------------------------------- */
1908 /* Special USB driver functions */
1909
1910 /* Probe if this driver wants to serve an USB device
1911
1912 This entry point is called whenever a new device is attached to the bus.
1913 Then the device driver has to create a new instance of its internal data
1914 structures for the new device.
1915
1916 The dev argument specifies the device context, which contains pointers
1917 to all USB descriptors. The interface argument specifies the interface
1918 number. If a USB driver wants to bind itself to a particular device and
1919 interface it has to return a pointer. This pointer normally references
1920 the device driver's context structure.
1921
1922 Probing normally is done by checking the vendor and product identifications
1923 or the class and subclass definitions. If they match the interface number
1924 is compared with the ones supported by the driver. When probing is done
1925 class based it might be necessary to parse some more USB descriptors because
1926 the device properties can differ in a wide range.
1927 */
1928 static int auerswald_probe (struct usb_interface *intf,
1929 const struct usb_device_id *id)
1930 {
1931 struct usb_device *usbdev = interface_to_usbdev(intf);
1932 pauerswald_t cp = NULL;
1933 unsigned int u = 0;
1934 __le16 *pbuf;
1935 int ret;
1936
1937 dbg ("probe: vendor id 0x%x, device id 0x%x",
1938 usbdev->descriptor.idVendor, usbdev->descriptor.idProduct);
1939
1940 /* See if the device offered us matches that we can accept */
1941 if (usbdev->descriptor.idVendor != ID_AUERSWALD)
1942 return -ENODEV;
1943
1944 /* we use only the first -and only- interface */
1945 if (intf->altsetting->desc.bInterfaceNumber != 0)
1946 return -ENODEV;
1947
1948 /* allocate memory for our device and initialize it */
1949 cp = kmalloc (sizeof(auerswald_t), GFP_KERNEL);
1950 if (cp == NULL) {
1951 err ("out of memory");
1952 goto pfail;
1953 }
1954
1955 /* Initialize device descriptor */
1956 memset (cp, 0, sizeof(auerswald_t));
1957 init_MUTEX (&cp->mutex);
1958 cp->usbdev = usbdev;
1959 auerchain_init (&cp->controlchain);
1960 auerbuf_init (&cp->bufctl);
1961 init_waitqueue_head (&cp->bufferwait);
1962
1963 ret = usb_register_dev(intf, &auerswald_class);
1964 if (ret) {
1965 err ("Not able to get a minor for this device.");
1966 goto pfail;
1967 }
1968
1969 /* Give the device a name */
1970 sprintf (cp->name, "usb/auer%d", intf->minor);
1971
1972 /* Store the index */
1973 cp->dtindex = intf->minor;
1974
1975 /* Get the usb version of the device */
1976 cp->version = cp->usbdev->descriptor.bcdDevice;
1977 dbg ("Version is %X", cp->version);
1978
1979 /* allow some time to settle the device */
1980 msleep(334);
1981
1982 /* Try to get a suitable textual description of the device */
1983 /* Device name:*/
1984 ret = usb_string( cp->usbdev, AUSI_DEVICE, cp->dev_desc, AUSI_DLEN-1);
1985 if (ret >= 0) {
1986 u += ret;
1987 /* Append Serial Number */
1988 memcpy(&cp->dev_desc[u], ",Ser# ", 6);
1989 u += 6;
1990 ret = usb_string( cp->usbdev, AUSI_SERIALNR, &cp->dev_desc[u], AUSI_DLEN-u-1);
1991 if (ret >= 0) {
1992 u += ret;
1993 /* Append subscriber number */
1994 memcpy(&cp->dev_desc[u], ", ", 2);
1995 u += 2;
1996 ret = usb_string( cp->usbdev, AUSI_MSN, &cp->dev_desc[u], AUSI_DLEN-u-1);
1997 if (ret >= 0) {
1998 u += ret;
1999 }
2000 }
2001 }
2002 cp->dev_desc[u] = '\0';
2003 info("device is a %s", cp->dev_desc);
2004
2005 /* get the maximum allowed control transfer length */
2006 pbuf = (__le16 *) kmalloc (2, GFP_KERNEL); /* use an allocated buffer because of urb target */
2007 if (!pbuf) {
2008 err( "out of memory");
2009 goto pfail;
2010 }
2011 ret = usb_control_msg(cp->usbdev, /* pointer to device */
2012 usb_rcvctrlpipe( cp->usbdev, 0 ), /* pipe to control endpoint */
2013 AUV_GETINFO, /* USB message request value */
2014 AUT_RREQ, /* USB message request type value */
2015 0, /* USB message value */
2016 AUDI_MBCTRANS, /* USB message index value */
2017 pbuf, /* pointer to the receive buffer */
2018 2, /* length of the buffer */
2019 HZ * 2); /* time to wait for the message to complete before timing out */
2020 if (ret == 2) {
2021 cp->maxControlLength = le16_to_cpup(pbuf);
2022 kfree(pbuf);
2023 dbg("setup: max. allowed control transfersize is %d bytes", cp->maxControlLength);
2024 } else {
2025 kfree(pbuf);
2026 err("setup: getting max. allowed control transfer length failed with error %d", ret);
2027 goto pfail;
2028 }
2029
2030 /* allocate a chain for the control messages */
2031 if (auerchain_setup (&cp->controlchain, AUCH_ELEMENTS)) {
2032 err ("out of memory");
2033 goto pfail;
2034 }
2035
2036 /* allocate buffers for control messages */
2037 if (auerbuf_setup (&cp->bufctl, AU_RBUFFERS, cp->maxControlLength+AUH_SIZE)) {
2038 err ("out of memory");
2039 goto pfail;
2040 }
2041
2042 /* start the interrupt endpoint */
2043 if (auerswald_int_open (cp)) {
2044 err ("int endpoint failed");
2045 goto pfail;
2046 }
2047
2048 /* all OK */
2049 usb_set_intfdata (intf, cp);
2050 return 0;
2051
2052 /* Error exit: clean up the memory */
2053 pfail: auerswald_delete (cp);
2054 return -EIO;
2055 }
2056
2057
2058 /* Disconnect driver from a served device
2059
2060 This function is called whenever a device which was served by this driver
2061 is disconnected.
2062
2063 The argument dev specifies the device context and the driver_context
2064 returns a pointer to the previously registered driver_context of the
2065 probe function. After returning from the disconnect function the USB
2066 framework completely deallocates all data structures associated with
2067 this device. So especially the usb_device structure must not be used
2068 any longer by the usb driver.
2069 */
2070 static void auerswald_disconnect (struct usb_interface *intf)
2071 {
2072 pauerswald_t cp = usb_get_intfdata (intf);
2073 unsigned int u;
2074
2075 usb_set_intfdata (intf, NULL);
2076 if (!cp)
2077 return;
2078
2079 down (&cp->mutex);
2080 info ("device /dev/%s now disconnecting", cp->name);
2081
2082 /* give back our USB minor number */
2083 usb_deregister_dev(intf, &auerswald_class);
2084
2085 /* Stop the interrupt endpoint */
2086 auerswald_int_release (cp);
2087
2088 /* remove the control chain allocated in auerswald_probe
2089 This has the benefit of
2090 a) all pending (a)synchronous urbs are unlinked
2091 b) all buffers dealing with urbs are reclaimed
2092 */
2093 auerchain_free (&cp->controlchain);
2094
2095 if (cp->open_count == 0) {
2096 /* nobody is using this device. So we can clean up now */
2097 up (&cp->mutex);/* up() is possible here because no other task
2098 can open the device (see above). I don't want
2099 to kfree() a locked mutex. */
2100 auerswald_delete (cp);
2101 } else {
2102 /* device is used. Remove the pointer to the
2103 usb device (it's not valid any more). The last
2104 release() will do the clean up */
2105 cp->usbdev = NULL;
2106 up (&cp->mutex);
2107 /* Terminate waiting writers */
2108 wake_up (&cp->bufferwait);
2109 /* Inform all waiting readers */
2110 for ( u = 0; u < AUH_TYPESIZE; u++) {
2111 pauerscon_t scp = cp->services[u];
2112 if (scp)
2113 scp->disconnect( scp);
2114 }
2115 }
2116 }
2117
2118 /* Descriptor for the devices which are served by this driver.
2119 NOTE: this struct is parsed by the usbmanager install scripts.
2120 Don't change without caution!
2121 */
2122 static struct usb_device_id auerswald_ids [] = {
2123 { USB_DEVICE (ID_AUERSWALD, 0x00C0) }, /* COMpact 2104 USB */
2124 { USB_DEVICE (ID_AUERSWALD, 0x00DB) }, /* COMpact 4410/2206 USB */
2125 { USB_DEVICE (ID_AUERSWALD, 0x00F1) }, /* Comfort 2000 System Telephone */
2126 { USB_DEVICE (ID_AUERSWALD, 0x00F2) }, /* Comfort 1200 System Telephone */
2127 { } /* Terminating entry */
2128 };
2129
2130 /* Standard module device table */
2131 MODULE_DEVICE_TABLE (usb, auerswald_ids);
2132
2133 /* Standard usb driver struct */
2134 static struct usb_driver auerswald_driver = {
2135 .owner = THIS_MODULE,
2136 .name = "auerswald",
2137 .probe = auerswald_probe,
2138 .disconnect = auerswald_disconnect,
2139 .id_table = auerswald_ids,
2140 };
2141
2142
2143 /* --------------------------------------------------------------------- */
2144 /* Module loading/unloading */
2145
2146 /* Driver initialisation. Called after module loading.
2147 NOTE: there is no concurrency at _init
2148 */
2149 static int __init auerswald_init (void)
2150 {
2151 int result;
2152 dbg ("init");
2153
2154 /* register driver at the USB subsystem */
2155 result = usb_register (&auerswald_driver);
2156 if (result < 0) {
2157 err ("driver could not be registered");
2158 return -1;
2159 }
2160 return 0;
2161 }
2162
2163 /* Driver deinit. Called before module removal.
2164 NOTE: there is no concurrency at _cleanup
2165 */
2166 static void __exit auerswald_cleanup (void)
2167 {
2168 dbg ("cleanup");
2169 usb_deregister (&auerswald_driver);
2170 }
2171
2172 /* --------------------------------------------------------------------- */
2173 /* Linux device driver module description */
2174
2175 MODULE_AUTHOR (DRIVER_AUTHOR);
2176 MODULE_DESCRIPTION (DRIVER_DESC);
2177 MODULE_LICENSE ("GPL");
2178
2179 module_init (auerswald_init);
2180 module_exit (auerswald_cleanup);
2181
2182 /* --------------------------------------------------------------------- */
2183
MOXA 2.6.9 from sdlinux-moxaart.tgz