drivers/usb/misc/auerswald.c

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