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