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