drivers/usb/misc/auerswald.c

   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_kill_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_host_endpoint *ep;
1127         int irqsize;
1128         dbg ("auerswald_int_open");
1129
1130         ep = cp->usbdev->ep_in[AU_IRQENDP];
1131         if (!ep) {
1132                 ret = -EFAULT;
1133                 goto intoend;
1134         }
1135         irqsize = le16_to_cpu(ep->desc.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,
1155                         usb_rcvintpipe (cp->usbdev,AU_IRQENDP), cp->intbufp,
1156                         irqsize, auerswald_int_complete, cp, ep->desc.bInterval);
1157         /* start the urb */
1158         cp->inturbp->status = 0;        /* needed! */
1159         ret = usb_submit_urb (cp->inturbp, GFP_KERNEL);
1160
1161 intoend:
1162         if (ret < 0) {
1163                 /* activation of interrupt endpoint has failed. Now clean up. */
1164                 dbg ("auerswald_int_open: activation of int endpoint failed");
1165
1166                 /* deallocate memory */
1167                 auerswald_int_free (cp);
1168         }
1169         return ret;
1170 }
1171
1172 /* This function is called to deactivate the interrupt
1173    endpoint. This function returns 0 if successful or an error code.
1174    NOTE: no mutex please!
1175 */
1176 static void auerswald_int_release (pauerswald_t cp)
1177 {
1178         dbg ("auerswald_int_release");
1179
1180         /* stop the int endpoint */
1181         if (cp->inturbp)
1182                 usb_kill_urb (cp->inturbp);
1183
1184         /* deallocate memory */
1185         auerswald_int_free (cp);
1186 }
1187
1188 /* --------------------------------------------------------------------- */
1189 /* Helper functions                                                      */
1190
1191 /* wake up waiting readers */
1192 static void auerchar_disconnect (pauerscon_t scp)
1193 {
1194         pauerchar_t ccp = ((pauerchar_t)((char *)(scp)-(unsigned long)(&((pauerchar_t)0)->scontext)));
1195         dbg ("auerchar_disconnect called");
1196         ccp->removed = 1;
1197         wake_up (&ccp->readwait);
1198 }
1199
1200
1201 /* dispatch a read paket to a waiting character device */
1202 static void auerchar_ctrlread_dispatch (pauerscon_t scp, pauerbuf_t bp)
1203 {
1204         unsigned long flags;
1205         pauerchar_t ccp;
1206         pauerbuf_t newbp = NULL;
1207         char * charp;
1208         dbg ("auerchar_ctrlread_dispatch called");
1209         ccp = ((pauerchar_t)((char *)(scp)-(unsigned long)(&((pauerchar_t)0)->scontext)));
1210
1211         /* get a read buffer from character device context */
1212         spin_lock_irqsave (&ccp->bufctl.lock, flags);
1213         if (!list_empty (&ccp->bufctl.free_buff_list)) {
1214                 /* yes: get the entry */
1215                 struct list_head *tmp = ccp->bufctl.free_buff_list.next;
1216                 list_del (tmp);
1217                 newbp = list_entry (tmp, auerbuf_t, buff_list);
1218         }
1219         spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1220
1221         if (!newbp) {
1222                 dbg ("No read buffer available, discard paket!");
1223                 return;     /* no buffer, no dispatch */
1224         }
1225
1226         /* copy information to new buffer element
1227            (all buffers have the same length) */
1228         charp = newbp->bufp;
1229         newbp->bufp = bp->bufp;
1230         bp->bufp = charp;
1231         newbp->len = bp->len;
1232
1233         /* insert new buffer in read list */
1234         spin_lock_irqsave (&ccp->bufctl.lock, flags);
1235         list_add_tail (&newbp->buff_list, &ccp->bufctl.rec_buff_list);
1236         spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1237         dbg ("read buffer appended to rec_list");
1238
1239         /* wake up pending synchronous reads */
1240         wake_up (&ccp->readwait);
1241 }
1242
1243
1244 /* Delete an auerswald driver context */
1245 static void auerswald_delete( pauerswald_t cp)
1246 {
1247         dbg( "auerswald_delete");
1248         if (cp == NULL)
1249                 return;
1250
1251         /* Wake up all processes waiting for a buffer */
1252         wake_up (&cp->bufferwait);
1253
1254         /* Cleaning up */
1255         auerswald_int_release (cp);
1256         auerchain_free (&cp->controlchain);
1257         auerbuf_free_buffers (&cp->bufctl);
1258
1259         /* release the memory */
1260         kfree( cp);
1261 }
1262
1263
1264 /* Delete an auerswald character context */
1265 static void auerchar_delete( pauerchar_t ccp)
1266 {
1267         dbg ("auerchar_delete");
1268         if (ccp == NULL)
1269                 return;
1270
1271         /* wake up pending synchronous reads */
1272         ccp->removed = 1;
1273         wake_up (&ccp->readwait);
1274
1275         /* remove the read buffer */
1276         if (ccp->readbuf) {
1277                 auerbuf_releasebuf (ccp->readbuf);
1278                 ccp->readbuf = NULL;
1279         }
1280
1281         /* remove the character buffers */
1282         auerbuf_free_buffers (&ccp->bufctl);
1283
1284         /* release the memory */
1285         kfree( ccp);
1286 }
1287
1288
1289 /* add a new service to the device
1290    scp->id must be set!
1291    return: 0 if OK, else error code
1292 */
1293 static int auerswald_addservice (pauerswald_t cp, pauerscon_t scp)
1294 {
1295         int ret;
1296
1297         /* is the device available? */
1298         if (!cp->usbdev) {
1299                 dbg ("usbdev == NULL");
1300                 return -EIO;    /*no: can not add a service, sorry*/
1301         }
1302
1303         /* is the service available? */
1304         if (cp->services[scp->id]) {
1305                 dbg ("service is busy");
1306                 return -EBUSY;
1307         }
1308
1309         /* device is available, service is free */
1310         cp->services[scp->id] = scp;
1311
1312         /* register service in device */
1313         ret = auerchain_control_msg(
1314                 &cp->controlchain,                      /* pointer to control chain */
1315                 cp->usbdev,                             /* pointer to device */
1316                 usb_sndctrlpipe (cp->usbdev, 0),        /* pipe to control endpoint */
1317                 AUV_CHANNELCTL,                         /* USB message request value */
1318                 AUT_WREQ,                               /* USB message request type value */
1319                 0x01,              /* open                 USB message value */
1320                 scp->id,                                /* USB message index value */
1321                 NULL,                                   /* pointer to the data to send */
1322                 0,                                      /* length in bytes of the data to send */
1323                 HZ * 2);                                /* time to wait for the message to complete before timing out */
1324         if (ret < 0) {
1325                 dbg ("auerswald_addservice: auerchain_control_msg returned error code %d", ret);
1326                 /* undo above actions */
1327                 cp->services[scp->id] = NULL;
1328                 return ret;
1329         }
1330
1331         dbg ("auerswald_addservice: channel open OK");
1332         return 0;
1333 }
1334
1335
1336 /* remove a service from the the device
1337    scp->id must be set! */
1338 static void auerswald_removeservice (pauerswald_t cp, pauerscon_t scp)
1339 {
1340         dbg ("auerswald_removeservice called");
1341
1342         /* check if we have a service allocated */
1343         if (scp->id == AUH_UNASSIGNED)
1344                 return;
1345
1346         /* If there is a device: close the channel */
1347         if (cp->usbdev) {
1348                 /* Close the service channel inside the device */
1349                 int ret = auerchain_control_msg(
1350                 &cp->controlchain,                      /* pointer to control chain */
1351                 cp->usbdev,                             /* pointer to device */
1352                 usb_sndctrlpipe (cp->usbdev, 0),        /* pipe to control endpoint */
1353                 AUV_CHANNELCTL,                         /* USB message request value */
1354                 AUT_WREQ,                               /* USB message request type value */
1355                 0x00,              // close             /* USB message value */
1356                 scp->id,                                /* USB message index value */
1357                 NULL,                                   /* pointer to the data to send */
1358                 0,                                      /* length in bytes of the data to send */
1359                 HZ * 2);                                /* time to wait for the message to complete before timing out */
1360                 if (ret < 0) {
1361                         dbg ("auerswald_removeservice: auerchain_control_msg returned error code %d", ret);
1362                 }
1363                 else {
1364                         dbg ("auerswald_removeservice: channel close OK");
1365                 }
1366         }
1367
1368         /* remove the service from the device */
1369         cp->services[scp->id] = NULL;
1370         scp->id = AUH_UNASSIGNED;
1371 }
1372
1373
1374 /* --------------------------------------------------------------------- */
1375 /* Char device functions                                                 */
1376
1377 /* Open a new character device */
1378 static int auerchar_open (struct inode *inode, struct file *file)
1379 {
1380         int dtindex = iminor(inode);
1381         pauerswald_t cp = NULL;
1382         pauerchar_t ccp = NULL;
1383         struct usb_interface *intf;
1384         int ret;
1385
1386         /* minor number in range? */
1387         if (dtindex < 0) {
1388                 return -ENODEV;
1389         }
1390         intf = usb_find_interface(&auerswald_driver, dtindex);
1391         if (!intf) {
1392                 return -ENODEV;
1393         }
1394
1395         /* usb device available? */
1396         cp = usb_get_intfdata (intf);
1397         if (cp == NULL) {
1398                 return -ENODEV;
1399         }
1400         if (down_interruptible (&cp->mutex)) {
1401                 return -ERESTARTSYS;
1402         }
1403
1404         /* we have access to the device. Now lets allocate memory */
1405         ccp = (pauerchar_t) kmalloc(sizeof(auerchar_t), GFP_KERNEL);
1406         if (ccp == NULL) {
1407                 err ("out of memory");
1408                 ret = -ENOMEM;
1409                 goto ofail;
1410         }
1411
1412         /* Initialize device descriptor */
1413         memset( ccp, 0, sizeof(auerchar_t));
1414         init_MUTEX( &ccp->mutex);
1415         init_MUTEX( &ccp->readmutex);
1416         auerbuf_init (&ccp->bufctl);
1417         ccp->scontext.id = AUH_UNASSIGNED;
1418         ccp->scontext.dispatch = auerchar_ctrlread_dispatch;
1419         ccp->scontext.disconnect = auerchar_disconnect;
1420         init_waitqueue_head (&ccp->readwait);
1421
1422         ret = auerbuf_setup (&ccp->bufctl, AU_RBUFFERS, cp->maxControlLength+AUH_SIZE);
1423         if (ret) {
1424                 goto ofail;
1425         }
1426
1427         cp->open_count++;
1428         ccp->auerdev = cp;
1429         dbg("open %s as /dev/%s", cp->dev_desc, cp->name);
1430         up (&cp->mutex);
1431
1432         /* file IO stuff */
1433         file->f_pos = 0;
1434         file->private_data = ccp;
1435         return nonseekable_open(inode, file);
1436
1437         /* Error exit */
1438 ofail:  up (&cp->mutex);
1439         auerchar_delete (ccp);
1440         return ret;
1441 }
1442
1443
1444 /* IOCTL functions */
1445 static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1446 {
1447         pauerchar_t ccp = (pauerchar_t) file->private_data;
1448         int ret = 0;
1449         audevinfo_t devinfo;
1450         pauerswald_t cp = NULL;
1451         unsigned int u;
1452         unsigned int __user *user_arg = (unsigned int __user *)arg;
1453
1454         dbg ("ioctl");
1455
1456         /* get the mutexes */
1457         if (down_interruptible (&ccp->mutex)) {
1458                 return -ERESTARTSYS;
1459         }
1460         cp = ccp->auerdev;
1461         if (!cp) {
1462                 up (&ccp->mutex);
1463                 return -ENODEV;
1464         }
1465         if (down_interruptible (&cp->mutex)) {
1466                 up(&ccp->mutex);
1467                 return -ERESTARTSYS;
1468         }
1469
1470         /* Check for removal */
1471         if (!cp->usbdev) {
1472                 up(&cp->mutex);
1473                 up(&ccp->mutex);
1474                 return -ENODEV;
1475         }
1476
1477         switch (cmd) {
1478
1479         /* return != 0 if Transmitt channel ready to send */
1480         case IOCTL_AU_TXREADY:
1481                 dbg ("IOCTL_AU_TXREADY");
1482                 u   = ccp->auerdev
1483                    && (ccp->scontext.id != AUH_UNASSIGNED)
1484                    && !list_empty (&cp->bufctl.free_buff_list);
1485                 ret = put_user (u, user_arg);
1486                 break;
1487
1488         /* return != 0 if connected to a service channel */
1489         case IOCTL_AU_CONNECT:
1490                 dbg ("IOCTL_AU_CONNECT");
1491                 u = (ccp->scontext.id != AUH_UNASSIGNED);
1492                 ret = put_user (u, user_arg);
1493                 break;
1494
1495         /* return != 0 if Receive Data available */
1496         case IOCTL_AU_RXAVAIL:
1497                 dbg ("IOCTL_AU_RXAVAIL");
1498                 if (ccp->scontext.id == AUH_UNASSIGNED) {
1499                         ret = -EIO;
1500                         break;
1501                 }
1502                 u = 0;  /* no data */
1503                 if (ccp->readbuf) {
1504                         int restlen = ccp->readbuf->len - ccp->readoffset;
1505                         if (restlen > 0)
1506                                 u = 1;
1507                 }
1508                 if (!u) {
1509                         if (!list_empty (&ccp->bufctl.rec_buff_list)) {
1510                                 u = 1;
1511                         }
1512                 }
1513                 ret = put_user (u, user_arg);
1514                 break;
1515
1516         /* return the max. buffer length for the device */
1517         case IOCTL_AU_BUFLEN:
1518                 dbg ("IOCTL_AU_BUFLEN");
1519                 u = cp->maxControlLength;
1520                 ret = put_user (u, user_arg);
1521                 break;
1522
1523         /* requesting a service channel */
1524         case IOCTL_AU_SERVREQ:
1525                 dbg ("IOCTL_AU_SERVREQ");
1526                 /* requesting a service means: release the previous one first */
1527                 auerswald_removeservice (cp, &ccp->scontext);
1528                 /* get the channel number */
1529                 ret = get_user (u, user_arg);
1530                 if (ret) {
1531                         break;
1532                 }
1533                 if ((u < AUH_FIRSTUSERCH) || (u >= AUH_TYPESIZE)) {
1534                         ret = -EIO;
1535                         break;
1536                 }
1537                 dbg ("auerchar service request parameters are ok");
1538                 ccp->scontext.id = u;
1539
1540                 /* request the service now */
1541                 ret = auerswald_addservice (cp, &ccp->scontext);
1542                 if (ret) {
1543                         /* no: revert service entry */
1544                         ccp->scontext.id = AUH_UNASSIGNED;
1545                 }
1546                 break;
1547
1548         /* get a string descriptor for the device */
1549         case IOCTL_AU_DEVINFO:
1550                 dbg ("IOCTL_AU_DEVINFO");
1551                 if (copy_from_user (&devinfo, (void __user *) arg, sizeof (audevinfo_t))) {
1552                         ret = -EFAULT;
1553                         break;
1554                 }
1555                 u = strlen(cp->dev_desc)+1;
1556                 if (u > devinfo.bsize) {
1557                         u = devinfo.bsize;
1558                 }
1559                 ret = copy_to_user(devinfo.buf, cp->dev_desc, u) ? -EFAULT : 0;
1560                 break;
1561
1562         /* get the max. string descriptor length */
1563         case IOCTL_AU_SLEN:
1564                 dbg ("IOCTL_AU_SLEN");
1565                 u = AUSI_DLEN;
1566                 ret = put_user (u, user_arg);
1567                 break;
1568
1569         default:
1570                 dbg ("IOCTL_AU_UNKNOWN");
1571                 ret = -ENOIOCTLCMD;
1572                 break;
1573         }
1574         /* release the mutexes */
1575         up(&cp->mutex);
1576         up(&ccp->mutex);
1577         return ret;
1578 }
1579
1580 /* Read data from the device */
1581 static ssize_t auerchar_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
1582 {
1583         unsigned long flags;
1584         pauerchar_t ccp = (pauerchar_t) file->private_data;
1585         pauerbuf_t   bp = NULL;
1586         wait_queue_t wait;
1587
1588         dbg ("auerchar_read");
1589
1590         /* Error checking */
1591         if (!ccp)
1592                 return -EIO;
1593         if (*ppos)
1594                 return -ESPIPE;
1595         if (count == 0)
1596                 return 0;
1597
1598         /* get the mutex */
1599         if (down_interruptible (&ccp->mutex))
1600                 return -ERESTARTSYS;
1601
1602         /* Can we expect to read something? */
1603         if (ccp->scontext.id == AUH_UNASSIGNED) {
1604                 up (&ccp->mutex);
1605                 return -EIO;
1606         }
1607
1608         /* only one reader per device allowed */
1609         if (down_interruptible (&ccp->readmutex)) {
1610                 up (&ccp->mutex);
1611                 return -ERESTARTSYS;
1612         }
1613
1614         /* read data from readbuf, if available */
1615 doreadbuf:
1616         bp = ccp->readbuf;
1617         if (bp) {
1618                 /* read the maximum bytes */
1619                 int restlen = bp->len - ccp->readoffset;
1620                 if (restlen < 0)
1621                         restlen = 0;
1622                 if (count > restlen)
1623                         count = restlen;
1624                 if (count) {
1625                         if (copy_to_user (buf, bp->bufp+ccp->readoffset, count)) {
1626                                 dbg ("auerswald_read: copy_to_user failed");
1627                                 up (&ccp->readmutex);
1628                                 up (&ccp->mutex);
1629                                 return -EFAULT;
1630                         }
1631                 }
1632                 /* advance the read offset */
1633                 ccp->readoffset += count;
1634                 restlen -= count;
1635                 // reuse the read buffer
1636                 if (restlen <= 0) {
1637                         auerbuf_releasebuf (bp);
1638                         ccp->readbuf = NULL;
1639                 }
1640                 /* return with number of bytes read */
1641                 if (count) {
1642                         up (&ccp->readmutex);
1643                         up (&ccp->mutex);
1644                         return count;
1645                 }
1646         }
1647
1648         /* a read buffer is not available. Try to get the next data block. */
1649 doreadlist:
1650         /* Preparing for sleep */
1651         init_waitqueue_entry (&wait, current);
1652         set_current_state (TASK_INTERRUPTIBLE);
1653         add_wait_queue (&ccp->readwait, &wait);
1654
1655         bp = NULL;
1656         spin_lock_irqsave (&ccp->bufctl.lock, flags);
1657         if (!list_empty (&ccp->bufctl.rec_buff_list)) {
1658                 /* yes: get the entry */
1659                 struct list_head *tmp = ccp->bufctl.rec_buff_list.next;
1660                 list_del (tmp);
1661                 bp = list_entry (tmp, auerbuf_t, buff_list);
1662         }
1663         spin_unlock_irqrestore (&ccp->bufctl.lock, flags);
1664
1665         /* have we got data? */
1666         if (bp) {
1667                 ccp->readbuf = bp;
1668                 ccp->readoffset = AUH_SIZE; /* for headerbyte */
1669                 set_current_state (TASK_RUNNING);
1670                 remove_wait_queue (&ccp->readwait, &wait);
1671                 goto doreadbuf;           /* now we can read! */
1672         }
1673
1674         /* no data available. Should we wait? */
1675         if (file->f_flags & O_NONBLOCK) {
1676                 dbg ("No read buffer available, returning -EAGAIN");
1677                 set_current_state (TASK_RUNNING);
1678                 remove_wait_queue (&ccp->readwait, &wait);
1679                 up (&ccp->readmutex);
1680                 up (&ccp->mutex);
1681                 return -EAGAIN;  /* nonblocking, no data available */
1682         }
1683
1684         /* yes, we should wait! */
1685         up (&ccp->mutex); /* allow other operations while we wait */
1686         schedule();
1687         remove_wait_queue (&ccp->readwait, &wait);
1688         if (signal_pending (current)) {
1689                 /* waked up by a signal */
1690                 up (&ccp->readmutex);
1691                 return -ERESTARTSYS;
1692         }
1693
1694         /* Anything left to read? */
1695         if ((ccp->scontext.id == AUH_UNASSIGNED) || ccp->removed) {
1696                 up (&ccp->readmutex);
1697                 return -EIO;
1698         }
1699
1700         if (down_interruptible (&ccp->mutex)) {
1701                 up (&ccp->readmutex);
1702                 return -ERESTARTSYS;
1703         }
1704
1705         /* try to read the incoming data again */
1706         goto doreadlist;
1707 }
1708
1709
1710 /* Write a data block into the right service channel of the device */
1711 static ssize_t auerchar_write (struct file *file, const char __user *buf, size_t len, loff_t *ppos)
1712 {
1713         pauerchar_t ccp = (pauerchar_t) file->private_data;
1714         pauerswald_t cp = NULL;
1715         pauerbuf_t bp;
1716         unsigned long flags;
1717         int ret;
1718         wait_queue_t wait;
1719
1720         dbg ("auerchar_write %d bytes", len);
1721
1722         /* Error checking */
1723         if (!ccp)
1724                 return -EIO;
1725         if (*ppos)
1726                 return -ESPIPE;
1727         if (len == 0)
1728                 return 0;
1729
1730 write_again:
1731         /* get the mutex */
1732         if (down_interruptible (&ccp->mutex))
1733                 return -ERESTARTSYS;
1734
1735         /* Can we expect to write something? */
1736         if (ccp->scontext.id == AUH_UNASSIGNED) {
1737                 up (&ccp->mutex);
1738                 return -EIO;
1739         }
1740
1741         cp = ccp->auerdev;
1742         if (!cp) {
1743                 up (&ccp->mutex);
1744                 return -ERESTARTSYS;
1745         }
1746         if (down_interruptible (&cp->mutex)) {
1747                 up (&ccp->mutex);
1748                 return -ERESTARTSYS;
1749         }
1750         if (!cp->usbdev) {
1751                 up (&cp->mutex);
1752                 up (&ccp->mutex);
1753                 return -EIO;
1754         }
1755         /* Prepare for sleep */
1756         init_waitqueue_entry (&wait, current);
1757         set_current_state (TASK_INTERRUPTIBLE);
1758         add_wait_queue (&cp->bufferwait, &wait);
1759
1760         /* Try to get a buffer from the device pool.
1761            We can't use a buffer from ccp->bufctl because the write
1762            command will last beond a release() */
1763         bp = NULL;
1764         spin_lock_irqsave (&cp->bufctl.lock, flags);
1765         if (!list_empty (&cp->bufctl.free_buff_list)) {
1766                 /* yes: get the entry */
1767                 struct list_head *tmp = cp->bufctl.free_buff_list.next;
1768                 list_del (tmp);
1769                 bp = list_entry (tmp, auerbuf_t, buff_list);
1770         }
1771         spin_unlock_irqrestore (&cp->bufctl.lock, flags);
1772
1773         /* are there any buffers left? */
1774         if (!bp) {
1775                 up (&cp->mutex);
1776                 up (&ccp->mutex);
1777
1778                 /* NONBLOCK: don't wait */
1779                 if (file->f_flags & O_NONBLOCK) {
1780                         set_current_state (TASK_RUNNING);
1781                         remove_wait_queue (&cp->bufferwait, &wait);
1782                         return -EAGAIN;
1783                 }
1784
1785                 /* BLOCKING: wait */
1786                 schedule();
1787                 remove_wait_queue (&cp->bufferwait, &wait);
1788                 if (signal_pending (current)) {
1789                         /* waked up by a signal */
1790                         return -ERESTARTSYS;
1791                 }
1792                 goto write_again;
1793         } else {
1794                 set_current_state (TASK_RUNNING);
1795                 remove_wait_queue (&cp->bufferwait, &wait);
1796         }
1797
1798         /* protect against too big write requests */
1799         if (len > cp->maxControlLength)
1800                 len = cp->maxControlLength;
1801
1802         /* Fill the buffer */
1803         if (copy_from_user ( bp->bufp+AUH_SIZE, buf, len)) {
1804                 dbg ("copy_from_user failed");
1805                 auerbuf_releasebuf (bp);
1806                 /* Wake up all processes waiting for a buffer */
1807                 wake_up (&cp->bufferwait);
1808                 up (&cp->mutex);
1809                 up (&ccp->mutex);
1810                 return -EFAULT;
1811         }
1812
1813         /* set the header byte */
1814         *(bp->bufp) = ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT;
1815
1816         /* Set the transfer Parameters */
1817         bp->len = len+AUH_SIZE;
1818         bp->dr->bRequestType = AUT_WREQ;
1819         bp->dr->bRequest     = AUV_WBLOCK;
1820         bp->dr->wValue       = cpu_to_le16 (0);
1821         bp->dr->wIndex       = cpu_to_le16 (ccp->scontext.id | AUH_DIRECT | AUH_UNSPLIT);
1822         bp->dr->wLength      = cpu_to_le16 (len+AUH_SIZE);
1823         usb_fill_control_urb (bp->urbp, cp->usbdev, usb_sndctrlpipe (cp->usbdev, 0),
1824                    (unsigned char*)bp->dr, bp->bufp, len+AUH_SIZE,
1825                     auerchar_ctrlwrite_complete, bp);
1826         /* up we go */
1827         ret = auerchain_submit_urb (&cp->controlchain, bp->urbp);
1828         up (&cp->mutex);
1829         if (ret) {
1830                 dbg ("auerchar_write: nonzero result of auerchain_submit_urb %d", ret);
1831                 auerbuf_releasebuf (bp);
1832                 /* Wake up all processes waiting for a buffer */
1833                 wake_up (&cp->bufferwait);
1834                 up (&ccp->mutex);
1835                 return -EIO;
1836         }
1837         else {
1838                 dbg ("auerchar_write: Write OK");
1839                 up (&ccp->mutex);
1840                 return len;
1841         }
1842 }
1843
1844
1845 /* Close a character device */
1846 static int auerchar_release (struct inode *inode, struct file *file)
1847 {
1848         pauerchar_t ccp = (pauerchar_t) file->private_data;
1849         pauerswald_t cp;
1850         dbg("release");
1851
1852         /* get the mutexes */
1853         if (down_interruptible (&ccp->mutex)) {
1854                 return -ERESTARTSYS;
1855         }
1856         cp = ccp->auerdev;
1857         if (cp) {
1858                 if (down_interruptible (&cp->mutex)) {
1859                         up (&ccp->mutex);
1860                         return -ERESTARTSYS;
1861                 }
1862                 /* remove an open service */
1863                 auerswald_removeservice (cp, &ccp->scontext);
1864                 /* detach from device */
1865                 if ((--cp->open_count <= 0) && (cp->usbdev == NULL)) {
1866                         /* usb device waits for removal */
1867                         up (&cp->mutex);
1868                         auerswald_delete (cp);
1869                 } else {
1870                         up (&cp->mutex);
1871                 }
1872                 cp = NULL;
1873                 ccp->auerdev = NULL;
1874         }
1875         up (&ccp->mutex);
1876         auerchar_delete (ccp);
1877
1878         return 0;
1879 }
1880
1881
1882 /*----------------------------------------------------------------------*/
1883 /* File operation structure                                             */
1884 static struct file_operations auerswald_fops =
1885 {
1886         .owner =        THIS_MODULE,
1887         .llseek =       no_llseek,
1888         .read =         auerchar_read,
1889         .write =        auerchar_write,
1890         .ioctl =        auerchar_ioctl,
1891         .open =         auerchar_open,
1892         .release =      auerchar_release,
1893 };
1894
1895 static struct usb_class_driver auerswald_class = {
1896         .name =         "usb/auer%d",
1897         .fops =         &auerswald_fops,
1898         .mode =         S_IFCHR | S_IRUGO | S_IWUGO,
1899         .minor_base =   AUER_MINOR_BASE,
1900 };
1901
1902
1903 /* --------------------------------------------------------------------- */
1904 /* Special USB driver functions                                          */
1905
1906 /* Probe if this driver wants to serve an USB device
1907
1908    This entry point is called whenever a new device is attached to the bus.
1909    Then the device driver has to create a new instance of its internal data
1910    structures for the new device.
1911
1912    The  dev argument specifies the device context, which contains pointers
1913    to all USB descriptors. The  interface argument specifies the interface
1914    number. If a USB driver wants to bind itself to a particular device and
1915    interface it has to return a pointer. This pointer normally references
1916    the device driver's context structure.
1917
1918    Probing normally is done by checking the vendor and product identifications
1919    or the class and subclass definitions. If they match the interface number
1920    is compared with the ones supported by the driver. When probing is done
1921    class based it might be necessary to parse some more USB descriptors because
1922    the device properties can differ in a wide range.
1923 */
1924 static int auerswald_probe (struct usb_interface *intf,
1925                             const struct usb_device_id *id)
1926 {
1927         struct usb_device *usbdev = interface_to_usbdev(intf);
1928         pauerswald_t cp = NULL;
1929         unsigned int u = 0;
1930         __le16 *pbuf;
1931         int ret;
1932
1933         dbg ("probe: vendor id 0x%x, device id 0x%x",
1934              le16_to_cpu(usbdev->descriptor.idVendor),
1935              le16_to_cpu(usbdev->descriptor.idProduct));
1936
1937         /* we use only the first -and only- interface */
1938         if (intf->altsetting->desc.bInterfaceNumber != 0)
1939                 return -ENODEV;
1940
1941         /* allocate memory for our device and initialize it */
1942         cp = kmalloc (sizeof(auerswald_t), GFP_KERNEL);
1943         if (cp == NULL) {
1944                 err ("out of memory");
1945                 goto pfail;
1946         }
1947
1948         /* Initialize device descriptor */
1949         memset (cp, 0, sizeof(auerswald_t));
1950         init_MUTEX (&cp->mutex);
1951         cp->usbdev = usbdev;
1952         auerchain_init (&cp->controlchain);
1953         auerbuf_init (&cp->bufctl);
1954         init_waitqueue_head (&cp->bufferwait);
1955
1956         ret = usb_register_dev(intf, &auerswald_class);
1957         if (ret) {
1958                 err ("Not able to get a minor for this device.");
1959                 goto pfail;
1960         }
1961
1962         /* Give the device a name */
1963         sprintf (cp->name, "usb/auer%d", intf->minor);
1964
1965         /* Store the index */
1966         cp->dtindex = intf->minor;
1967
1968         /* Get the usb version of the device */
1969         cp->version = le16_to_cpu(cp->usbdev->descriptor.bcdDevice);
1970         dbg ("Version is %X", cp->version);
1971
1972         /* allow some time to settle the device */
1973         msleep(334);
1974
1975         /* Try to get a suitable textual description of the device */
1976         /* Device name:*/
1977         ret = usb_string( cp->usbdev, AUSI_DEVICE, cp->dev_desc, AUSI_DLEN-1);
1978         if (ret >= 0) {
1979                 u += ret;
1980                 /* Append Serial Number */
1981                 memcpy(&cp->dev_desc[u], ",Ser# ", 6);
1982                 u += 6;
1983                 ret = usb_string( cp->usbdev, AUSI_SERIALNR, &cp->dev_desc[u], AUSI_DLEN-u-1);
1984                 if (ret >= 0) {
1985                         u += ret;
1986                         /* Append subscriber number */
1987                         memcpy(&cp->dev_desc[u], ", ", 2);
1988                         u += 2;
1989                         ret = usb_string( cp->usbdev, AUSI_MSN, &cp->dev_desc[u], AUSI_DLEN-u-1);
1990                         if (ret >= 0) {
1991                                 u += ret;
1992                         }
1993                 }
1994         }
1995         cp->dev_desc[u] = '\0';
1996         info("device is a %s", cp->dev_desc);
1997
1998         /* get the maximum allowed control transfer length */
1999         pbuf = (__le16 *) kmalloc (2, GFP_KERNEL);    /* use an allocated buffer because of urb target */
2000         if (!pbuf) {
2001                 err( "out of memory");
2002                 goto pfail;
2003         }
2004         ret = usb_control_msg(cp->usbdev,           /* pointer to device */
2005                 usb_rcvctrlpipe( cp->usbdev, 0 ),   /* pipe to control endpoint */
2006                 AUV_GETINFO,                        /* USB message request value */
2007                 AUT_RREQ,                           /* USB message request type value */
2008                 0,                                  /* USB message value */
2009                 AUDI_MBCTRANS,                      /* USB message index value */
2010                 pbuf,                               /* pointer to the receive buffer */
2011                 2,                                  /* length of the buffer */
2012                 HZ * 2);                            /* time to wait for the message to complete before timing out */
2013         if (ret == 2) {
2014                 cp->maxControlLength = le16_to_cpup(pbuf);
2015                 kfree(pbuf);
2016                 dbg("setup: max. allowed control transfersize is %d bytes", cp->maxControlLength);
2017         } else {
2018                 kfree(pbuf);
2019                 err("setup: getting max. allowed control transfer length failed with error %d", ret);
2020                 goto pfail;
2021         }
2022
2023         /* allocate a chain for the control messages */
2024         if (auerchain_setup (&cp->controlchain, AUCH_ELEMENTS)) {
2025                 err ("out of memory");
2026                 goto pfail;
2027         }
2028
2029         /* allocate buffers for control messages */
2030         if (auerbuf_setup (&cp->bufctl, AU_RBUFFERS, cp->maxControlLength+AUH_SIZE)) {
2031                 err ("out of memory");
2032                 goto pfail;
2033         }
2034
2035         /* start the interrupt endpoint */
2036         if (auerswald_int_open (cp)) {
2037                 err ("int endpoint failed");
2038                 goto pfail;
2039         }
2040
2041         /* all OK */
2042         usb_set_intfdata (intf, cp);
2043         return 0;
2044
2045         /* Error exit: clean up the memory */
2046 pfail:  auerswald_delete (cp);
2047         return -EIO;
2048 }
2049
2050
2051 /* Disconnect driver from a served device
2052
2053    This function is called whenever a device which was served by this driver
2054    is disconnected.
2055
2056    The argument  dev specifies the device context and the  driver_context
2057    returns a pointer to the previously registered  driver_context of the
2058    probe function. After returning from the disconnect function the USB
2059    framework completely deallocates all data structures associated with
2060    this device. So especially the usb_device structure must not be used
2061    any longer by the usb driver.
2062 */
2063 static void auerswald_disconnect (struct usb_interface *intf)
2064 {
2065         pauerswald_t cp = usb_get_intfdata (intf);
2066         unsigned int u;
2067
2068         usb_set_intfdata (intf, NULL);
2069         if (!cp)
2070                 return;
2071
2072         down (&cp->mutex);
2073         info ("device /dev/%s now disconnecting", cp->name);
2074
2075         /* give back our USB minor number */
2076         usb_deregister_dev(intf, &auerswald_class);
2077
2078         /* Stop the interrupt endpoint */
2079         auerswald_int_release (cp);
2080
2081         /* remove the control chain allocated in auerswald_probe
2082            This has the benefit of
2083            a) all pending (a)synchronous urbs are unlinked
2084            b) all buffers dealing with urbs are reclaimed
2085         */
2086         auerchain_free (&cp->controlchain);
2087
2088         if (cp->open_count == 0) {
2089                 /* nobody is using this device. So we can clean up now */
2090                 up (&cp->mutex);/* up() is possible here because no other task
2091                                    can open the device (see above). I don't want
2092                                    to kfree() a locked mutex. */
2093                 auerswald_delete (cp);
2094         } else {
2095                 /* device is used. Remove the pointer to the
2096                    usb device (it's not valid any more). The last
2097                    release() will do the clean up */
2098                 cp->usbdev = NULL;
2099                 up (&cp->mutex);
2100                 /* Terminate waiting writers */
2101                 wake_up (&cp->bufferwait);
2102                 /* Inform all waiting readers */
2103                 for ( u = 0; u < AUH_TYPESIZE; u++) {
2104                         pauerscon_t scp = cp->services[u];
2105                         if (scp)
2106                                 scp->disconnect( scp);
2107                 }
2108         }
2109 }
2110
2111 /* Descriptor for the devices which are served by this driver.
2112    NOTE: this struct is parsed by the usbmanager install scripts.
2113          Don't change without caution!
2114 */
2115 static struct usb_device_id auerswald_ids [] = {
2116         { USB_DEVICE (ID_AUERSWALD, 0x00C0) },          /* COMpact 2104 USB */
2117         { USB_DEVICE (ID_AUERSWALD, 0x00DB) },          /* COMpact 4410/2206 USB */
2118         { USB_DEVICE (ID_AUERSWALD, 0x00F1) },          /* Comfort 2000 System Telephone */
2119         { USB_DEVICE (ID_AUERSWALD, 0x00F2) },          /* Comfort 1200 System Telephone */
2120         { }                                             /* Terminating entry */
2121 };
2122
2123 /* Standard module device table */
2124 MODULE_DEVICE_TABLE (usb, auerswald_ids);
2125
2126 /* Standard usb driver struct */
2127 static struct usb_driver auerswald_driver = {
2128         .owner =        THIS_MODULE,
2129         .name =         "auerswald",
2130         .probe =        auerswald_probe,
2131         .disconnect =   auerswald_disconnect,
2132         .id_table =     auerswald_ids,
2133 };
2134
2135
2136 /* --------------------------------------------------------------------- */
2137 /* Module loading/unloading                                              */
2138
2139 /* Driver initialisation. Called after module loading.
2140    NOTE: there is no concurrency at _init
2141 */
2142 static int __init auerswald_init (void)
2143 {
2144         int result;
2145         dbg ("init");
2146
2147         /* register driver at the USB subsystem */
2148         result = usb_register (&auerswald_driver);
2149         if (result < 0) {
2150                 err ("driver could not be registered");
2151                 return -1;
2152         }
2153         return 0;
2154 }
2155
2156 /* Driver deinit. Called before module removal.
2157    NOTE: there is no concurrency at _cleanup
2158 */
2159 static void __exit auerswald_cleanup (void)
2160 {
2161         dbg ("cleanup");
2162         usb_deregister (&auerswald_driver);
2163 }
2164
2165 /* --------------------------------------------------------------------- */
2166 /* Linux device driver module description                                */
2167
2168 MODULE_AUTHOR (DRIVER_AUTHOR);
2169 MODULE_DESCRIPTION (DRIVER_DESC);
2170 MODULE_LICENSE ("GPL");
2171
2172 module_init (auerswald_init);
2173 module_exit (auerswald_cleanup);
2174
2175 /* --------------------------------------------------------------------- */
2176