drivers/usb/misc/auerswald.c

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