drivers/usb/auerisdn.c

   1 /*****************************************************************************/
   2 /*
   3  *      auerisdn.c  --  Auerswald PBX/System Telephone ISDN interface.
   4  *
   5  *      Copyright (C) 2002  Wolfgang Mües (wolfgang@iksw-muees.de)
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21  /*****************************************************************************/
  22
  23 #include <linux/isdnif.h>
  24 #include <linux/netdevice.h>
  25 #include <linux/sched.h>
  26
  27 #undef  DEBUG                   /* include debug macros until it's done */
  28 #include <linux/usb.h>
  29
  30 #include "auerisdn.h"
  31 #include "auermain.h"
  32
  33 /*-------------------------------------------------------------------*/
  34 /* ISDN support defines                                              */
  35 #define AUISDN_TEI      64      /* use a constant TEI */
  36
  37 /*-------------------------------------------------------------------*/
  38 /* Debug support                                                     */
  39 #ifdef DEBUG
  40 #define dump( desc, adr, len) \
  41 do {                    \
  42         unsigned int u; \
  43         printk (KERN_DEBUG); \
  44         printk (desc); \
  45         for (u = 0; u < len; u++) \
  46                 printk (" %02X", adr[u] & 0xFF); \
  47         printk ("\n"); \
  48 } while (0)
  49 #else
  50 #define dump( desc, adr, len)
  51 #endif
  52
  53 /*-------------------------------------------------------------------*/
  54 /* Hisax Interface.                                                  */
  55
  56 /* The interface to hisax is long-lasting because hisax_unregister()
  57    don't work well in Linux 2.4.x. So we have to hold each registered
  58    hisax interface until driver removal. */
  59 static struct auerhisax auerhisax_table[AUER_MAX_DEVICES];
  60
  61
  62 /*-------------------------------------------------------------------*/
  63
  64 /* Callback to L2 for HISAX */
  65 /* This callback can be called from 3 sources:
  66    a) from hisax context (answer from a l2l1 function)
  67    b) from interrupt context (a D channel paket arrived)
  68    c) from kernel daemon context (probe/disconnecting)
  69 */
  70 static void auerisdn_d_l1l2(struct auerisdn *ip, int pr, void *arg)
  71 {
  72         struct sk_buff *skb;
  73         struct auerhisax *ahp;
  74
  75         /* do the callback */
  76         ahp = ip->ahp;
  77         if (ahp) {
  78                 ahp->hisax_d_if.ifc.l1l2(&ahp->hisax_d_if.ifc, pr, arg);
  79         } else {
  80                 dbg("auerisdn_d_l1l2 with ahp == NULL");
  81                 if (pr == (PH_DATA | INDICATION)) {
  82                         skb = (struct sk_buff *) arg;
  83                         if (skb) {
  84                                 skb_pull(skb, skb->len);
  85                                 dev_kfree_skb_any(skb);
  86                         }
  87                 }
  88         }
  89 }
  90
  91
  92 /* D-Channel sending completion function */
  93 static void auerisdn_dcw_complete(struct urb *urb)
  94 {
  95         struct auerbuf *bp = (struct auerbuf *) urb->context;
  96         struct auerswald *cp =
  97             ((struct auerswald *) ((char *) (bp->list) -
  98                                    (unsigned
  99                                     long) (&((struct auerswald *) 0)->
 100                                            bufctl)));
 101
 102         dbg("auerisdn_dcw_complete with status %d", urb->status);
 103
 104         /* reuse the buffer */
 105         auerbuf_releasebuf(bp);
 106
 107         /* Wake up all processes waiting for a buffer */
 108         wake_up(&cp->bufferwait);
 109 }
 110
 111
 112 /* Translate non-ETSI ISDN messages from the device */
 113 static void auerisdn_translate_incoming(struct auerswald *cp,
 114                                         unsigned char *msg,
 115                                         unsigned int len)
 116 {
 117         struct auerbuf *bp;
 118         int ret;
 119
 120         /* Translate incomming CONNECT -> CONNECT_ACK */
 121         /* Format:   0   1    2     3     4        5        6    7      */
 122         /*         SAPI TEI TXSEQ RXSEQ PID=08 CREFLEN=01 CREF MSG=7 ...*/
 123         /* CREF.7 == 0 -> Incoming Call                                 */
 124
 125         /* Check for minimum length */
 126         if (len < 8)
 127                 return;
 128
 129         /* Check for a CONNECT, call originated from device */
 130         if (((msg[6] & 0x80) == 0) && (msg[7] == 0x07)) {
 131                 dbg("false CONNECT from device found");
 132                 /* change into CONNECT_ACK */
 133                 msg[7] = 0x0F;
 134
 135                 /* Send a CONNECT_ACK back to the device */
 136
 137                 /* get a new data buffer */
 138                 bp = auerbuf_getbuf(&cp->bufctl);
 139                 if (!bp) {
 140                         warn("no auerbuf free");
 141                         return;
 142                 }
 143
 144                 /* Form a CONNECT ACK */
 145                 bp->bufp[0] =
 146                     cp->isdn.dchannelservice.id | AUH_DIRECT | AUH_UNSPLIT;
 147                 bp->bufp[1] = 0x08;
 148                 bp->bufp[2] = 0x01;
 149                 bp->bufp[3] = msg[6] | 0x80;
 150                 bp->bufp[4] = 0x0F;
 151
 152                 /* Set the transfer Parameters */
 153                 bp->len = 5;
 154                 bp->dr->bRequestType = AUT_WREQ;
 155                 bp->dr->bRequest = AUV_WBLOCK;
 156                 bp->dr->wValue = cpu_to_le16(0);
 157                 bp->dr->wIndex =
 158                     cpu_to_le16(cp->isdn.dchannelservice.
 159                                 id | AUH_DIRECT | AUH_UNSPLIT);
 160                 bp->dr->wLength = cpu_to_le16(5);
 161                 FILL_CONTROL_URB(bp->urbp, cp->usbdev,
 162                                  usb_sndctrlpipe(cp->usbdev, 0),
 163                                  (unsigned char *) bp->dr, bp->bufp, 5,
 164                                  auerisdn_dcw_complete, bp);
 165                 /* up we go */
 166                 ret = auerchain_submit_urb(&cp->controlchain, bp->urbp);
 167                 if (ret)
 168                         auerisdn_dcw_complete(bp->urbp);
 169                 else
 170                         dbg("auerisdn_translate: Write OK");
 171         }
 172         /* Check for a DISCONNECT and change to RELEASE */
 173         if (msg[7] == 0x45) {
 174                 dbg("DISCONNECT changed to RELEASE");
 175                 msg[7] = 0x4D;
 176                 return;
 177         }
 178 }
 179
 180
 181 /* a D-channel paket arrived from the device */
 182 static void auerisdn_dispatch_dc(struct auerscon *scp, struct auerbuf *bp)
 183 {
 184         struct sk_buff *skb;
 185         struct auerhisax *ahp;
 186         struct auerswald *cp =
 187             ((struct auerswald *) ((char *) (scp) -
 188                                    (unsigned
 189                                     long) (&((struct auerswald *) 0)->isdn.
 190                                            dchannelservice)));
 191         unsigned char *sp;
 192         unsigned int l2_index;
 193         unsigned char c;
 194         unsigned char l2_header[10];
 195         unsigned long flags;
 196
 197         dump("D-Channel paket arrived:", bp->bufp, bp->len);
 198         if (cp->disconnecting)
 199                 return;
 200
 201         /* add a self-generated L2 message header */
 202         l2_index = 0;
 203         l2_header[l2_index++] = 0x02;   /* SAPI 0, C/R = 1 */
 204
 205         /* Parse the L3 message */
 206         sp = bp->bufp + AUH_SIZE;
 207
 208         c = *sp++;              /* Protocol discriminator */
 209         if (c != 0x08) {
 210                 warn("D channel paket is not ETSI");
 211                 return;
 212         }
 213         c = *sp++;              /* Call Reference length byte */
 214         sp += c;                /* Skip Call Reference */
 215
 216         /* translate charge IEs */
 217         /* Format of Auerswald Header:
 218            0x32 len=0x0B 0xFF 0xFF 0x73 len=0x07 0x27 */
 219         /* Format of IE2_UNIT:
 220            0x49 len=0x04 uu1 uu2 uu3 uu4 */
 221         /* Translate into: (?? Bytes)
 222            0x1C Facility
 223            0x?? restlen
 224            0x91 Sup. Services
 225            0xA1 Invoke
 226            0x?? restlen
 227            0x02 Invoke ID Tag
 228            0x02 Invoke ID len
 229            0x12 Invoke ID = 0x1234
 230            0x34
 231            0x02 OP Value Tag
 232            0x01 Length of OPvalue
 233            0x24 OpValue = AOCE
 234            0x30 Universal Constructor Sequence
 235            0x?? restlen
 236            0x30 Universal Constructor Sequence
 237            0x?? restlen
 238            0xA1 Context Specific Constructor Recorded Units List
 239            0x?? restlen
 240            0x30 Universal Constructor Sequence
 241            0x?? restlen
 242            0x02 Universal Primitive Integer
 243            0x?? len from IE2_UNIT
 244            uu1  Recorded Units List
 245            uu2
 246            uu3
 247            uu4
 248          */
 249         {
 250                 unsigned char *ucp = sp;        // pointer to start of msg
 251                 int l = bp->len;        // length until EOP
 252                 unsigned char alen;     // length of auerswald msg
 253                 l -= (int) (ucp - bp->bufp);
 254                 // scan for Auerswald Header
 255                 for (; l >= 9; l--, ucp++) {    // 9 = minimal length of auerswald msg
 256                         if (ucp[0] != 0x32)
 257                                 continue;
 258                         if (ucp[2] != 0xFF)
 259                                 continue;
 260                         if (ucp[3] != 0xFF)
 261                                 continue;
 262                         if (ucp[4] != 0x73)
 263                                 continue;
 264                         if (ucp[6] != 0x27)
 265                                 continue;
 266                         // Auerswald Header found. Is it units?
 267                         dbg("Auerswald msg header found");
 268                         alen = ucp[1] + 2;
 269                         if (ucp[7] == 0x49) {
 270                                 // yes
 271                                 unsigned char ul = ucp[8] + 1;  // length of charge integer
 272                                 unsigned char charge[32];
 273                                 // Copy charge info into new buffer
 274                                 unsigned char *xp = &ucp[8];
 275                                 int count;
 276                                 for (count = 0; count < ul; count++)
 277                                         charge[count] = *xp++;
 278                                 // Erase auerswald msg
 279                                 count = l - alen;
 280                                 xp = ucp;
 281                                 for (; count; count--, xp++)
 282                                         xp[0] = xp[alen];
 283                                 l -= alen;
 284                                 bp->len -= alen;
 285                                 // make room for new message
 286                                 count = l;
 287                                 xp = &ucp[l - 1];
 288                                 for (; count; count--, xp--);
 289                                 xp[21 + ul] = xp[0];
 290                                 l += (21 + ul);
 291                                 bp->len += (21 + ul);
 292                                 // insert IE header
 293                                 ucp[0] = 0x1C;
 294                                 ucp[1] = 19 + ul;
 295                                 ucp[2] = 0x91;
 296                                 ucp[3] = 0xA1;
 297                                 ucp[4] = 16 + ul;
 298                                 ucp[5] = 0x02;
 299                                 ucp[6] = 0x02;
 300                                 ucp[7] = 0x12;
 301                                 ucp[8] = 0x34;
 302                                 ucp[9] = 0x02;
 303                                 ucp[10] = 0x01;
 304                                 ucp[11] = 0x24;
 305                                 ucp[12] = 0x30;
 306                                 ucp[13] = 7 + ul;
 307                                 ucp[14] = 0x30;
 308                                 ucp[15] = 5 + ul;
 309                                 ucp[16] = 0xA1;
 310                                 ucp[17] = 3 + ul;
 311                                 ucp[18] = 0x30;
 312                                 ucp[19] = 1 + ul;
 313                                 ucp[20] = 0x02;
 314                                 // Insert charge units
 315                                 xp = &ucp[21];
 316                                 for (count = 0; count < ul; count++)
 317                                         *xp++ = charge[count];
 318                                 dump("Rearranged message:", bp->bufp,
 319                                      bp->len);
 320                                 break;
 321                         } else {
 322                                 // we can't handle something else, erase it
 323                                 int count = l - alen;
 324                                 unsigned char *xp = ucp;
 325                                 for (; count; count--, xp++)
 326                                         xp[0] = xp[alen];
 327                                 l -= alen;
 328                                 bp->len -= alen;
 329                                 dump("Shortened message:", bp->bufp,
 330                                      bp->len);
 331                         }
 332                 }
 333         }
 334
 335
 336         c = *sp;                /* Message type */
 337         if (c == 0x05) {
 338                 /* SETUP. Use an UI frame */
 339                 dbg("SETUP");
 340                 l2_header[l2_index++] = 0xFF;   /* TEI 127 */
 341                 l2_header[l2_index++] = 0x03;   /* UI control field */
 342                 skb = dev_alloc_skb(bp->len - AUH_SIZE + l2_index);
 343         } else {
 344                 /* use an I frame */
 345                 dbg("I Frame");
 346                 l2_header[l2_index++] = (AUISDN_TEI << 1) | 0x01;       /* TEI byte */
 347                 skb = dev_alloc_skb(bp->len - AUH_SIZE + l2_index + 2);
 348                 if (skb) {
 349                         ahp = cp->isdn.ahp;
 350                         if (!ahp) {
 351                                 err("ahp == NULL");
 352                                 return;
 353                         }
 354                         spin_lock_irqsave(&ahp->seq_lock, flags);
 355                         l2_header[l2_index++] = ahp->txseq;     /* transmitt sequence number */
 356                         l2_header[l2_index++] = ahp->rxseq;     /* receive sequence number */
 357                         ahp->txseq += 2;                        /* next paket gets next number */
 358                         spin_unlock_irqrestore(&ahp->seq_lock, flags);
 359                 }
 360         }
 361         if (!skb) {
 362                 err("no memory - skipped");
 363                 return;
 364         }
 365         sp = skb_put(skb, bp->len - AUH_SIZE + l2_index);
 366         /* Add L2 header */
 367         memcpy(sp, l2_header, l2_index);
 368         memcpy(sp + l2_index, bp->bufp + AUH_SIZE, bp->len - AUH_SIZE);
 369         /* Translate false messages */
 370         auerisdn_translate_incoming(cp, sp, bp->len - AUH_SIZE + l2_index);
 371         /* Send message to L2 */
 372         auerisdn_d_l1l2(&cp->isdn, PH_DATA | INDICATION, skb);
 373 }
 374
 375 /* D-channel is closed because the device is removed */
 376 /* This is a no-op because ISDN close is handled different */
 377 static void auerisdn_disconnect_dc(struct auerscon *scp)
 378 {
 379 }
 380
 381
 382 /* confirmation helper function. */
 383 static void auerisdn_d_confirmskb(struct auerswald *cp,
 384                                   struct sk_buff *skb)
 385 {
 386         /* free the skb */
 387         if (skb) {
 388                 skb_pull(skb, skb->len);
 389                 dev_kfree_skb_any(skb);
 390         }
 391
 392         /* confirm the sending of data */
 393         dbg("Confirm PH_DATA");
 394         auerisdn_d_l1l2(&cp->isdn, PH_DATA | CONFIRM, NULL);
 395 }
 396
 397 /* D-channel transfer function L2->L1 */
 398 static void auerisdn_d_l2l1(struct hisax_if *hisax_d_if, int pr, void *arg)
 399 {
 400         struct auerhisax *ahp;
 401         struct sk_buff *skb;
 402         unsigned int len;
 403         int ret;
 404         struct auerbuf *bp;
 405         struct auerswald *cp;
 406         unsigned long flags;
 407         unsigned int l2_index;
 408         unsigned char c;
 409         unsigned char l2_header[32];
 410         unsigned char *sp;
 411
 412         dbg("hisax D-Channel l2l1 called");
 413
 414         /* Get reference to auerhisax struct */
 415         cp = NULL;
 416         ahp = hisax_d_if->priv;
 417         if (ahp)
 418                 cp = ahp->cp;
 419         if (cp && !cp->disconnecting) {
 420                 /* normal usage */
 421                 switch (pr) {
 422                 case PH_ACTIVATE | REQUEST:     /* activation request */
 423                         dbg("Activation Request");
 424                         cp->isdn.dc_activated = 1;
 425                         /* send activation back to layer 2 */
 426                         auerisdn_d_l1l2(&cp->isdn,
 427                                         PH_ACTIVATE | INDICATION, NULL);
 428                         break;
 429                 case PH_DEACTIVATE | REQUEST:   /* deactivation request */
 430                         dbg("Deactivation Request");
 431                         cp->isdn.dc_activated = 0;
 432                         /* send deactivation back to layer 2 */
 433                         auerisdn_d_l1l2(&cp->isdn,
 434                                         PH_DEACTIVATE | INDICATION, NULL);
 435                         break;
 436                 case PH_DATA | REQUEST: /* Transmit data request */
 437                         skb = (struct sk_buff *) arg;
 438                         len = skb->len;
 439                         l2_index = 0;
 440                         sp = skb->data;
 441                         dump("Data Request:", sp, len);
 442
 443                         /* Parse the L2 header */
 444                         if (!len)
 445                                 goto phd_free;
 446                         c = *sp++;      /* SAPI */
 447                         l2_header[l2_index++] = c;
 448                         len--;
 449                         if (!len)
 450                                 goto phd_free;
 451                         c = *sp++;      /* TEI */
 452                         l2_header[l2_index++] = c;
 453                         len--;
 454                         if (!len)
 455                                 goto phd_free;
 456                         c = *sp++;      /* Control Field, Byte 1 */
 457                         len--;
 458                         if (!(c & 0x01)) {
 459                                 /* I FRAME */
 460                                 dbg("I Frame");
 461                                 if (!len)
 462                                         goto phd_free;
 463                                 spin_lock_irqsave(&ahp->seq_lock, flags);
 464                                 ahp->rxseq = c + 2;     /* store new sequence info */
 465                                 spin_unlock_irqrestore(&ahp->seq_lock,
 466                                                        flags);
 467                                 sp++;   /* skip Control Field, Byte 2 */
 468                                 len--;
 469                                 /* Check for RELEASE command */
 470                                 /* and change to RELEASE_COMPLETE */
 471                                 if (sp[3] == 0x4D)
 472                                         sp[3] = 0x5A;
 473                                 goto phd_send;
 474                         }
 475                         /* check the frame type */
 476                         switch (c) {
 477                         case 0x03:      /* UI frame */
 478                                 dbg("UI Frame");
 479                                 if (l2_header[0] == 0xFC) {
 480                                         dbg("TEI Managment");
 481                                         l2_header[0] = 0xFE;    /* set C/R bit in answer */
 482                                         l2_header[l2_index++] = c;      /* Answer is UI frame */
 483                                         if (!len)
 484                                                 break;
 485                                         c = *sp++;      /* Managment ID */
 486                                         len--;
 487                                         if (c != 0x0F)
 488                                                 break;
 489                                         l2_header[l2_index++] = c;
 490                                         /* Read Reference Number */
 491                                         if (!len)
 492                                                 break;
 493                                         l2_header[l2_index++] = *sp++;
 494                                         len--;
 495                                         if (!len)
 496                                                 break;
 497                                         l2_header[l2_index++] = *sp++;
 498                                         len--;
 499                                         if (!len)
 500                                                 break;
 501                                         c = *sp++;      /* Message Type */
 502                                         len--;
 503                                         switch (c) {
 504                                         case 0x01:      /* Identity Request */
 505                                                 dbg("Identity Request");
 506                                                 l2_header[l2_index++] = 0x02;   /* Identity Assign */
 507                                                 l2_header[l2_index++] =
 508                                                     (AUISDN_TEI << 1) |
 509                                                     0x01;
 510                                                 goto phd_answer;
 511                                         default:
 512                                                 dbg("Unhandled TEI Managment %X", (int) c);
 513                                                 break;
 514                                         }
 515                                         // throw away
 516                                         goto phd_free;
 517                                 }
 518                                 /* else send UI frame out */
 519                                 goto phd_send;
 520                         case 0x01:      /* RR frame */
 521                         case 0x05:      /* RNR frame */
 522                                 dbg("RR/RNR Frame");
 523                                 if (!len)
 524                                         break;
 525                                 c = *sp++;      /* Control Field, Byte 2 */
 526                                 len--;
 527                                 if (!(c & 0x01))
 528                                         break;  /* P/F = 1 in commands */
 529                                 if (l2_header[0] & 0x02)
 530                                         break;  /* C/R = 0 from TE */
 531                                 dbg("Send RR as answer");
 532                                 l2_header[l2_index++] = 0x01;   /* send an RR as Answer */
 533                                 spin_lock_irqsave(&ahp->seq_lock, flags);
 534                                 l2_header[l2_index++] = ahp->rxseq | 0x01;
 535                                 spin_unlock_irqrestore(&ahp->seq_lock,
 536                                                        flags);
 537                                 goto phd_answer;
 538                         case 0x7F:      /* SABME */
 539                                 dbg("SABME");
 540                                 spin_lock_irqsave(&ahp->seq_lock, flags);
 541                                 ahp->txseq = 0;
 542                                 ahp->rxseq = 0;
 543                                 spin_unlock_irqrestore(&ahp->seq_lock,
 544                                                        flags);
 545                                 l2_header[l2_index++] = 0x73;   /* UA */
 546                                 goto phd_answer;
 547                         case 0x53:      /* DISC */
 548                                 dbg("DISC");
 549                                 /* Send back a UA */
 550                                 l2_header[l2_index++] = 0x73;   /* UA */
 551                                 goto phd_answer;
 552                         default:
 553                                 dbg("Unhandled L2 Message %X", (int) c);
 554                                 break;
 555                         }
 556                         /* all done */
 557                         goto phd_free;
 558
 559                         /* we have to generate a local answer */
 560                         /* first, confirm old message, free old skb */
 561                       phd_answer:auerisdn_d_confirmskb(cp,
 562                                               skb);
 563
 564                         /* allocate a new skbuff */
 565                         skb = dev_alloc_skb(l2_index);
 566                         if (!skb) {
 567                                 err("no memory for new skb");
 568                                 break;
 569                         }
 570                         dump("local answer to L2 is:", l2_header,
 571                              l2_index);
 572                         memcpy(skb_put(skb, l2_index), l2_header,
 573                                l2_index);
 574                         auerisdn_d_l1l2(&cp->isdn, PH_DATA | INDICATION,
 575                                         skb);
 576                         break;
 577
 578                         /* we have to send the L3 message out */
 579                       phd_send:if (!len)
 580                                 goto phd_free;  /* no message left */
 581
 582                         /* get a new data buffer */
 583                         bp = auerbuf_getbuf(&cp->bufctl);
 584                         if (!bp) {
 585                                 warn("no auerbuf free");
 586                                 goto phd_free;
 587                         }
 588                         /* protect against too big write requests */
 589                         /* Should not happen */
 590                         if (len > cp->maxControlLength) {
 591                                 err("too long D-channel paket truncated");
 592                                 len = cp->maxControlLength;
 593                         }
 594
 595                         /* Copy the data */
 596                         memcpy(bp->bufp + AUH_SIZE, sp, len);
 597
 598                         /* set the header byte */
 599                         *(bp->bufp) =
 600                             cp->isdn.dchannelservice.
 601                             id | AUH_DIRECT | AUH_UNSPLIT;
 602
 603                         /* Set the transfer Parameters */
 604                         bp->len = len + AUH_SIZE;
 605                         bp->dr->bRequestType = AUT_WREQ;
 606                         bp->dr->bRequest = AUV_WBLOCK;
 607                         bp->dr->wValue = cpu_to_le16(0);
 608                         bp->dr->wIndex =
 609                             cpu_to_le16(cp->isdn.dchannelservice.
 610                                         id | AUH_DIRECT | AUH_UNSPLIT);
 611                         bp->dr->wLength = cpu_to_le16(len + AUH_SIZE);
 612                         FILL_CONTROL_URB(bp->urbp, cp->usbdev,
 613                                          usb_sndctrlpipe(cp->usbdev, 0),
 614                                          (unsigned char *) bp->dr,
 615                                          bp->bufp, len + AUH_SIZE,
 616                                          auerisdn_dcw_complete, bp);
 617                         /* up we go */
 618                         ret =
 619                             auerchain_submit_urb(&cp->controlchain,
 620                                                  bp->urbp);
 621                         if (ret)
 622                                 auerisdn_dcw_complete(bp->urbp);
 623                         else
 624                                 dbg("auerisdn_dwrite: Write OK");
 625                         /* confirm message, free skb */
 626                       phd_free:auerisdn_d_confirmskb(cp,
 627                                               skb);
 628                         break;
 629
 630                 default:
 631                         warn("pr %#x\n", pr);
 632                         break;
 633                 }
 634         } else {
 635                 /* hisax interface is down */
 636                 switch (pr) {
 637                 case PH_ACTIVATE | REQUEST:     /* activation request */
 638                         dbg("D channel PH_ACTIVATE | REQUEST with interface down");
 639                         /* don't answer this request! Endless... */
 640                         break;
 641                 case PH_DEACTIVATE | REQUEST:   /* deactivation request */
 642                         dbg("D channel PH_DEACTIVATE | REQUEST with interface down");
 643                         hisax_d_if->l1l2(hisax_d_if,
 644                                          PH_DEACTIVATE | INDICATION, NULL);
 645                         break;
 646                 case PH_DATA | REQUEST: /* Transmit data request */
 647                         dbg("D channel PH_DATA | REQUEST with interface down");
 648                         skb = (struct sk_buff *) arg;
 649                         /* free data buffer */
 650                         if (skb) {
 651                                 skb_pull(skb, skb->len);
 652                                 dev_kfree_skb_any(skb);
 653                         }
 654                         /* send confirmation back to layer 2 */
 655                         hisax_d_if->l1l2(hisax_d_if, PH_DATA | CONFIRM,
 656                                          NULL);
 657                         break;
 658                 default:
 659                         warn("pr %#x\n", pr);
 660                         break;
 661                 }
 662         }
 663 }
 664
 665
 666 /* Completion function for D channel open */
 667 static void auerisdn_dcopen_complete(struct urb *urbp)
 668 {
 669         struct auerbuf *bp = (struct auerbuf *) urbp->context;
 670         struct auerswald *cp =
 671             ((struct auerswald *) ((char *) (bp->list) -
 672                                    (unsigned
 673                                     long) (&((struct auerswald *) 0)->
 674                                            bufctl)));
 675         dbg("auerisdn_dcopen_complete called");
 676
 677         auerbuf_releasebuf(bp);
 678
 679         /* Wake up all processes waiting for a buffer */
 680         wake_up(&cp->bufferwait);
 681 }
 682
 683
 684 /* Open the D-channel once more */
 685 static void auerisdn_dcopen(unsigned long data)
 686 {
 687         struct auerswald *cp = (struct auerswald *) data;
 688         struct auerbuf *bp;
 689         int ret;
 690
 691         if (cp->disconnecting)
 692                 return;
 693         dbg("auerisdn_dcopen running");
 694
 695         /* get a buffer for the command */
 696         bp = auerbuf_getbuf(&cp->bufctl);
 697         /* if no buffer available: can't change the mode */
 698         if (!bp) {
 699                 err("auerisdn_dcopen: no data buffer available");
 700                 return;
 701         }
 702
 703         /* fill the control message */
 704         bp->dr->bRequestType = AUT_WREQ;
 705         bp->dr->bRequest = AUV_CHANNELCTL;
 706         bp->dr->wValue = cpu_to_le16(1);
 707         bp->dr->wIndex = cpu_to_le16(0);
 708         bp->dr->wLength = cpu_to_le16(0);
 709         FILL_CONTROL_URB(bp->urbp, cp->usbdev,
 710                          usb_sndctrlpipe(cp->usbdev, 0),
 711                          (unsigned char *) bp->dr, bp->bufp, 0,
 712                          (usb_complete_t) auerisdn_dcopen_complete, bp);
 713
 714         /* submit the control msg */
 715         ret = auerchain_submit_urb(&cp->controlchain, bp->urbp);
 716         dbg("dcopen submitted");
 717         if (ret) {
 718                 bp->urbp->status = ret;
 719                 auerisdn_dcopen_complete(bp->urbp);
 720         }
 721         return;
 722 }
 723
 724
 725 /* Initialize the isdn related items in struct auerswald */
 726 void auerisdn_init_dev(struct auerswald *cp)
 727 {
 728         unsigned int u;
 729         cp->isdn.dchannelservice.id = AUH_UNASSIGNED;
 730         cp->isdn.dchannelservice.dispatch = auerisdn_dispatch_dc;
 731         cp->isdn.dchannelservice.disconnect = auerisdn_disconnect_dc;
 732         init_timer(&cp->isdn.dcopen_timer);
 733         cp->isdn.dcopen_timer.data = (unsigned long) cp;
 734         cp->isdn.dcopen_timer.function = auerisdn_dcopen;
 735         for (u = 0; u < AUISDN_BCHANNELS; u++) {
 736                 cp->isdn.bc[u].cp = cp;
 737                 cp->isdn.bc[u].mode = L1_MODE_NULL;
 738                 cp->isdn.bc[u].channel = u;
 739                 spin_lock_init(&cp->isdn.bc[u].txskb_lock);
 740         }
 741 }
 742
 743
 744 /* Connect to the HISAX interface. Returns 0 if successfull */
 745 int auerisdn_probe(struct auerswald *cp)
 746 {
 747         struct hisax_b_if *b_if[AUISDN_BCHANNELS];
 748         struct usb_endpoint_descriptor *ep;
 749         struct auerhisax *ahp;
 750         DECLARE_WAIT_QUEUE_HEAD(wqh);
 751         unsigned int u;
 752         unsigned char *ucp;
 753         unsigned int first_time;
 754         int ret;
 755
 756         /* First allocate resources, then register hisax interface */
 757
 758         /* Allocate RX buffers */
 759         for (u = 0; u < AUISDN_BCHANNELS; u++) {
 760                 if (!cp->isdn.bc[u].rxbuf) {
 761                         cp->isdn.bc[u].rxbuf =
 762                             (char *) kmalloc(AUISDN_RXSIZE, GFP_KERNEL);
 763                         if (!cp->isdn.bc[u].rxbuf) {
 764                                 err("can't allocate buffer for B channel RX data");
 765                                 return -1;
 766                         }
 767                 }
 768         }
 769
 770         /* Read out B-Channel output fifo size */
 771         ucp = kmalloc(32, GFP_KERNEL);
 772         if (!ucp) {
 773                 err("Out of memory");
 774                 return -3;
 775         }
 776         ret = usb_control_msg(cp->usbdev,                       /* pointer to device */
 777                               usb_rcvctrlpipe(cp->usbdev, 0),   /* pipe to control endpoint */
 778                               AUV_GETINFO,                      /* USB message request value */
 779                               AUT_RREQ,                         /* USB message request type value */
 780                               0,                                /* USB message value */
 781                               AUDI_OUTFSIZE,                    /* USB message index value */
 782                               ucp,                              /* pointer to the receive buffer */
 783                               32,                               /* length of the buffer */
 784                               HZ * 2);                          /* time to wait for the message to complete before timing out */
 785         if (ret < 4) {
 786                 kfree(ucp);
 787                 err("can't read TX Fifo sizes for B1,B2");
 788                 return -4;
 789         }
 790         for (u = 0; u < AUISDN_BCHANNELS; u++) {
 791                 ret = le16_to_cpup(ucp + u * 2);
 792                 cp->isdn.bc[u].ofsize = ret;
 793                 cp->isdn.bc[u].txfree = ret;
 794         }
 795         kfree(ucp);
 796         for (u = 0; u < AUISDN_BCHANNELS; u++) {
 797                 dbg("B%d buffer size is %d", u, cp->isdn.bc[u].ofsize);
 798         }
 799
 800         /* get the B channel output INT size */
 801         cp->isdn.intbo_endp = AU_IRQENDPBO;
 802         ep = usb_epnum_to_ep_desc(cp->usbdev, USB_DIR_OUT | AU_IRQENDPBO);
 803         if (!ep) {
 804                 /* Some devices have another endpoint number here ... */
 805                 cp->isdn.intbo_endp = AU_IRQENDPBO_2;
 806                 ep = usb_epnum_to_ep_desc(cp->usbdev,
 807                                           USB_DIR_OUT | AU_IRQENDPBO_2);
 808                 if (!ep) {
 809                         err("can't get B channel OUT endpoint");
 810                         return -5;
 811                 }
 812         }
 813         cp->isdn.outsize = ep->wMaxPacketSize;
 814         cp->isdn.outInterval = ep->bInterval;
 815         cp->isdn.usbdev = cp->usbdev;
 816
 817         /* allocate the urb and data buffer */
 818         if (!cp->isdn.intbo_urbp) {
 819                 cp->isdn.intbo_urbp = usb_alloc_urb(0);
 820                 if (!cp->isdn.intbo_urbp) {
 821                         err("can't allocate urb for B channel output endpoint");
 822                         return -6;
 823                 }
 824         }
 825         if (!cp->isdn.intbo_bufp) {
 826                 cp->isdn.intbo_bufp =
 827                     (char *) kmalloc(cp->isdn.outsize, GFP_KERNEL);
 828                 if (!cp->isdn.intbo_bufp) {
 829                         err("can't allocate buffer for B channel output endpoint");
 830                         return -7;
 831                 }
 832         }
 833
 834         /* get the B channel input INT size */
 835         ep = usb_epnum_to_ep_desc(cp->usbdev, USB_DIR_IN | AU_IRQENDPBI);
 836         if (!ep) {
 837                 err("can't get B channel IN endpoint");
 838                 return -8;
 839         }
 840         cp->isdn.insize = ep->wMaxPacketSize;
 841
 842         /* allocate the urb and data buffer */
 843         if (!cp->isdn.intbi_urbp) {
 844                 cp->isdn.intbi_urbp = usb_alloc_urb(0);
 845                 if (!cp->isdn.intbi_urbp) {
 846                         err("can't allocate urb for B channel input endpoint");
 847                         return -9;
 848                 }
 849         }
 850         if (!cp->isdn.intbi_bufp) {
 851                 cp->isdn.intbi_bufp =
 852                     (char *) kmalloc(cp->isdn.insize, GFP_KERNEL);
 853                 if (!cp->isdn.intbi_bufp) {
 854                         err("can't allocate buffer for B channel input endpoint");
 855                         return -10;
 856                 }
 857         }
 858
 859         /* setup urb */
 860         FILL_INT_URB(cp->isdn.intbi_urbp, cp->usbdev,
 861                      usb_rcvintpipe(cp->usbdev, AU_IRQENDPBI),
 862                      cp->isdn.intbi_bufp, cp->isdn.insize,
 863                      auerisdn_intbi_complete, cp, ep->bInterval);
 864         /* start the urb */
 865         cp->isdn.intbi_urbp->status = 0;        /* needed! */
 866         ret = usb_submit_urb(cp->isdn.intbi_urbp);
 867         if (ret < 0) {
 868                 err("activation of B channel input int failed %d", ret);
 869                 usb_free_urb(cp->isdn.intbi_urbp);
 870                 cp->isdn.intbi_urbp = NULL;
 871                 return -11;
 872         }
 873
 874         /* request the D-channel service now */
 875         dbg("Requesting D channel now");
 876         cp->isdn.dchannelservice.id = AUH_DCHANNEL;
 877         if (auerswald_addservice(cp, &cp->isdn.dchannelservice)) {
 878                 err("can not open D-channel");
 879                 cp->isdn.dchannelservice.id = AUH_UNASSIGNED;
 880                 return -2;
 881         }
 882
 883         /* Find a free hisax interface */
 884         for (u = 0; u < AUER_MAX_DEVICES; u++) {
 885                 ahp = &auerhisax_table[u];
 886                 if (!ahp->cp) {
 887                         first_time = (u == 0);
 888                         goto ahp_found;
 889                 }
 890         }
 891         /* no free interface found */
 892         return -12;
 893
 894         /* we found a free hisax interface */
 895       ahp_found:
 896         /* Wait until ipppd timeout expired. The reason behind this ugly construct:
 897            If we connect to a hisax device without waiting for ipppd we are not able
 898            to make a new IP connection. */
 899         if (ahp->last_close) {
 900                 unsigned long timeout = jiffies - ahp->last_close;
 901                 if (timeout < AUISDN_IPTIMEOUT) {
 902                         info("waiting for ipppd to timeout");
 903                         sleep_on_timeout(&wqh, AUISDN_IPTIMEOUT - timeout);
 904                 }
 905         }
 906
 907         cp->isdn.ahp = ahp;
 908         u = ahp->hisax_registered;
 909         ahp->hisax_registered = 1;
 910         ahp->cp = cp;
 911
 912         /* now do the registration */
 913         if (!u) {
 914                 for (u = 0; u < AUISDN_BCHANNELS; u++) {
 915                         b_if[u] = &ahp->hisax_b_if[u];
 916                 }
 917                 if (hisax_register
 918                     (&ahp->hisax_d_if, b_if, "auerswald_usb",
 919                      ISDN_PTYPE_EURO)) {
 920                         err("hisax registration failed");
 921                         ahp->cp = NULL;
 922                         cp->isdn.ahp = NULL;
 923                         ahp->hisax_registered = 0;
 924                         return -13;
 925                 }
 926                 dbg("hisax interface registered");
 927         }
 928
 929         /* send a D channel L1 activation indication to hisax */
 930         auerisdn_d_l1l2(&cp->isdn, PH_ACTIVATE | INDICATION, NULL);
 931         cp->isdn.dc_activated = 1;
 932
 933         /* do another D channel activation for problematic devices */
 934         cp->isdn.dcopen_timer.expires = jiffies + HZ;
 935         dbg("add timer");
 936         add_timer(&cp->isdn.dcopen_timer);
 937
 938         return 0;
 939 }
 940
 941 /* The USB device was disconnected */
 942 void auerisdn_disconnect(struct auerswald *cp)
 943 {
 944         struct auerhisax *ahp;
 945         DECLARE_WAIT_QUEUE_HEAD(wqh);
 946         unsigned long flags;
 947         unsigned int u;
 948         int ret;
 949         unsigned int stop_bc;
 950
 951         dbg("auerisdn_disconnect called");
 952
 953         /* stop a running timer */
 954         del_timer_sync(&cp->isdn.dcopen_timer);
 955
 956         /* first, stop the B channels */
 957         stop_bc = auerisdn_b_disconnect(cp);
 958
 959         /* stop the D channels */
 960         auerisdn_d_l1l2(&cp->isdn, PH_DEACTIVATE | INDICATION, NULL);
 961         cp->isdn.dc_activated = 0;
 962         dbg("D-Channel disconnected");
 963
 964         /* Wait a moment */
 965         sleep_on_timeout(&wqh, HZ / 10);
 966
 967         /* Shut the connection to the hisax interface */
 968         ahp = cp->isdn.ahp;
 969         if (ahp) {
 970                 dbg("closing connection to hisax interface");
 971                 ahp->cp = NULL;
 972                 cp->isdn.ahp = NULL;
 973                 /* time of last closure */
 974                 if (stop_bc)
 975                         /* if we kill a running connection ... */
 976                         ahp->last_close = jiffies;
 977                 else
 978                         ahp->last_close = 0;
 979         }
 980
 981         /* Now free the memory */
 982         if (cp->isdn.intbi_urbp) {
 983                 ret = usb_unlink_urb(cp->isdn.intbi_urbp);
 984                 if (ret)
 985                         dbg("B in: nonzero int unlink result received: %d",
 986                             ret);
 987                 usb_free_urb(cp->isdn.intbi_urbp);
 988                 cp->isdn.intbi_urbp = NULL;
 989         }
 990         kfree(cp->isdn.intbi_bufp);
 991         cp->isdn.intbi_bufp = NULL;
 992
 993         if (cp->isdn.intbo_urbp) {
 994                 cp->isdn.intbo_urbp->transfer_flags &= ~USB_ASYNC_UNLINK;
 995                 ret = usb_unlink_urb(cp->isdn.intbo_urbp);
 996                 if (ret)
 997                         dbg("B out: nonzero int unlink result received: %d", ret);
 998                 usb_free_urb(cp->isdn.intbo_urbp);
 999                 cp->isdn.intbo_urbp = NULL;
1000         }
1001         kfree(cp->isdn.intbo_bufp);
1002         cp->isdn.intbo_bufp = NULL;
1003
1004         /* Remove the rx and tx buffers */
1005         for (u = 0; u < AUISDN_BCHANNELS; u++) {
1006                 kfree(cp->isdn.bc[u].rxbuf);
1007                 cp->isdn.bc[u].rxbuf = NULL;
1008                 spin_lock_irqsave(&cp->isdn.bc[u].txskb_lock, flags);
1009                 if (cp->isdn.bc[u].txskb) {
1010                         skb_pull(cp->isdn.bc[u].txskb,
1011                                  cp->isdn.bc[u].txskb->len);
1012                         dev_kfree_skb_any(cp->isdn.bc[u].txskb);
1013                         cp->isdn.bc[u].txskb = NULL;
1014                 }
1015                 spin_unlock_irqrestore(&cp->isdn.bc[u].txskb_lock, flags);
1016         }
1017
1018         /* Remove the D-channel connection */
1019         auerswald_removeservice(cp, &cp->isdn.dchannelservice);
1020 }
1021
1022
1023 /*-------------------------------------------------------------------*/
1024 /* Environment for long-lasting hisax interface                      */
1025
1026 /* Wrapper for hisax B0 channel L2L1 */
1027 static void auerisdn_b0_l2l1_wrapper(struct hisax_if *ifc, int pr,
1028                                      void *arg)
1029 {
1030         auerisdn_b_l2l1(ifc, pr, arg, 0);
1031 }
1032
1033 /* Wrapper for hisax B1 channel L2L1 */
1034 static void auerisdn_b1_l2l1_wrapper(struct hisax_if *ifc, int pr,
1035                                      void *arg)
1036 {
1037         auerisdn_b_l2l1(ifc, pr, arg, 1);
1038 }
1039
1040 /* Init the global variables */
1041 void auerisdn_init(void)
1042 {
1043         struct auerhisax *ahp;
1044         unsigned int u;
1045
1046         memset(&auerhisax_table, 0, sizeof(auerhisax_table));
1047         for (u = 0; u < AUER_MAX_DEVICES; u++) {
1048                 ahp = &auerhisax_table[u];
1049                 spin_lock_init(&ahp->seq_lock);
1050                 ahp->hisax_d_if.ifc.priv = ahp;
1051                 ahp->hisax_d_if.ifc.l2l1 = auerisdn_d_l2l1;
1052                 ahp->hisax_b_if[0].ifc.priv = ahp;
1053                 ahp->hisax_b_if[0].ifc.l2l1 = auerisdn_b0_l2l1_wrapper;
1054                 ahp->hisax_b_if[1].ifc.priv = ahp;
1055                 ahp->hisax_b_if[1].ifc.l2l1 = auerisdn_b1_l2l1_wrapper;
1056         }
1057 }
1058
1059 /* Deinit the global variables */
1060 void auerisdn_cleanup(void)
1061 {
1062         struct auerhisax *ahp;
1063         int i;
1064
1065         /* cleanup last allocated device first */
1066         for (i = AUER_MAX_DEVICES - 1; i >= 0; i--) {
1067                 ahp = &auerhisax_table[i];
1068                 if (ahp->cp) {
1069                         err("hisax device %d open at cleanup", i);
1070                 }
1071                 if (ahp->hisax_registered) {
1072                         hisax_unregister(&ahp->hisax_d_if);
1073                         dbg("hisax interface %d freed", i);
1074                 }
1075         }
1076 }