git.oblomov.eu Git - linux-2.6/blob - drivers/usb/misc/auerswald.c

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