drivers/usb/misc/auerswald.c

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