drivers/isdn/hisax/netjet.c

   1 /* $Id: netjet.c,v 1.29.2.4 2004/02/11 13:21:34 keil Exp $
   2  *
   3  * low level stuff for Traverse Technologie NETJet ISDN cards
   4  *
   5  * Author       Karsten Keil
   6  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
   7  *
   8  * This software may be used and distributed according to the terms
   9  * of the GNU General Public License, incorporated herein by reference.
  10  *
  11  * Thanks to Traverse Technologies Australia for documents and information
  12  *
  13  * 16-Apr-2002 - led code added - Guy Ellis (guy@traverse.com.au)
  14  *
  15  */
  16
  17 #include <linux/init.h>
  18 #include "hisax.h"
  19 #include "isac.h"
  20 #include "hscx.h"
  21 #include "isdnl1.h"
  22 #include <linux/pci.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/ppp_defs.h>
  25 #include <asm/io.h>
  26 #include "netjet.h"
  27
  28 const char *NETjet_revision = "$Revision: 1.29.2.4 $";
  29
  30 /* Interface functions */
  31
  32 u_char
  33 NETjet_ReadIC(struct IsdnCardState *cs, u_char offset)
  34 {
  35         u_char ret;
  36
  37         cs->hw.njet.auxd &= 0xfc;
  38         cs->hw.njet.auxd |= (offset>>4) & 3;
  39         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  40         ret = bytein(cs->hw.njet.isac + ((offset & 0xf)<<2));
  41         return(ret);
  42 }
  43
  44 void
  45 NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value)
  46 {
  47         cs->hw.njet.auxd &= 0xfc;
  48         cs->hw.njet.auxd |= (offset>>4) & 3;
  49         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  50         byteout(cs->hw.njet.isac + ((offset & 0xf)<<2), value);
  51 }
  52
  53 void
  54 NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size)
  55 {
  56         cs->hw.njet.auxd &= 0xfc;
  57         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  58         insb(cs->hw.njet.isac, data, size);
  59 }
  60
  61 __u16 fcstab[256] =
  62 {
  63         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  64         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  65         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  66         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  67         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  68         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  69         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  70         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  71         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  72         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  73         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  74         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  75         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  76         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  77         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  78         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  79         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  80         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  81         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  82         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  83         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  84         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  85         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  86         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  87         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  88         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  89         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  90         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  91         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  92         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  93         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  94         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  95 };
  96
  97 void
  98 NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
  99 {
 100         cs->hw.njet.auxd &= 0xfc;
 101         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
 102         outsb(cs->hw.njet.isac, data, size);
 103 }
 104
 105 void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill)
 106 {
 107         u_int mask=0x000000ff, val = 0, *p=pos;
 108         u_int i;
 109
 110         val |= fill;
 111         if (chan) {
 112                 val  <<= 8;
 113                 mask <<= 8;
 114         }
 115         mask ^= 0xffffffff;
 116         for (i=0; i<cnt; i++) {
 117                 *p   &= mask;
 118                 *p++ |= val;
 119                 if (p > bcs->hw.tiger.s_end)
 120                         p = bcs->hw.tiger.send;
 121         }
 122 }
 123
 124 void
 125 mode_tiger(struct BCState *bcs, int mode, int bc)
 126 {
 127         struct IsdnCardState *cs = bcs->cs;
 128         u_char led;
 129
 130         if (cs->debug & L1_DEB_HSCX)
 131                 debugl1(cs, "Tiger mode %d bchan %d/%d",
 132                         mode, bc, bcs->channel);
 133         bcs->mode = mode;
 134         bcs->channel = bc;
 135         switch (mode) {
 136                 case (L1_MODE_NULL):
 137                         fill_mem(bcs, bcs->hw.tiger.send,
 138                                 NETJET_DMA_TXSIZE, bc, 0xff);
 139                         if (cs->debug & L1_DEB_HSCX)
 140                                 debugl1(cs, "Tiger stat rec %d/%d send %d",
 141                                         bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err,
 142                                         bcs->hw.tiger.s_tot);
 143                         if ((cs->bcs[0].mode == L1_MODE_NULL) &&
 144                                 (cs->bcs[1].mode == L1_MODE_NULL)) {
 145                                 cs->hw.njet.dmactrl = 0;
 146                                 byteout(cs->hw.njet.base + NETJET_DMACTRL,
 147                                         cs->hw.njet.dmactrl);
 148                                 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
 149                         }
 150                         if (cs->typ == ISDN_CTYPE_NETJET_S)
 151                         {
 152                                 // led off
 153                                 led = bc & 0x01;
 154                                 led = 0x01 << (6 + led); // convert to mask
 155                                 led = ~led;
 156                                 cs->hw.njet.auxd &= led;
 157                                 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
 158                         }
 159                         break;
 160                 case (L1_MODE_TRANS):
 161                         break;
 162                 case (L1_MODE_HDLC_56K):
 163                 case (L1_MODE_HDLC):
 164                         fill_mem(bcs, bcs->hw.tiger.send,
 165                                 NETJET_DMA_TXSIZE, bc, 0xff);
 166                         bcs->hw.tiger.r_state = HDLC_ZERO_SEARCH;
 167                         bcs->hw.tiger.r_tot = 0;
 168                         bcs->hw.tiger.r_bitcnt = 0;
 169                         bcs->hw.tiger.r_one = 0;
 170                         bcs->hw.tiger.r_err = 0;
 171                         bcs->hw.tiger.s_tot = 0;
 172                         if (! cs->hw.njet.dmactrl) {
 173                                 fill_mem(bcs, bcs->hw.tiger.send,
 174                                         NETJET_DMA_TXSIZE, !bc, 0xff);
 175                                 cs->hw.njet.dmactrl = 1;
 176                                 byteout(cs->hw.njet.base + NETJET_DMACTRL,
 177                                         cs->hw.njet.dmactrl);
 178                                 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0x0f);
 179                         /* was 0x3f now 0x0f for TJ300 and TJ320  GE 13/07/00 */
 180                         }
 181                         bcs->hw.tiger.sendp = bcs->hw.tiger.send;
 182                         bcs->hw.tiger.free = NETJET_DMA_TXSIZE;
 183                         test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
 184                         if (cs->typ == ISDN_CTYPE_NETJET_S)
 185                         {
 186                                 // led on
 187                                 led = bc & 0x01;
 188                                 led = 0x01 << (6 + led); // convert to mask
 189                                 cs->hw.njet.auxd |= led;
 190                                 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
 191                         }
 192                         break;
 193         }
 194         if (cs->debug & L1_DEB_HSCX)
 195                 debugl1(cs, "tiger: set %x %x %x  %x/%x  pulse=%d",
 196                         bytein(cs->hw.njet.base + NETJET_DMACTRL),
 197                         bytein(cs->hw.njet.base + NETJET_IRQMASK0),
 198                         bytein(cs->hw.njet.base + NETJET_IRQSTAT0),
 199                         inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 200                         inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 201                         bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
 202 }
 203
 204 static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s) {
 205         char tmp[128];
 206         char *t = tmp;
 207         int i=count,j;
 208         u_char *p = buf;
 209
 210         t += sprintf(t, "tiger %s(%4d)", s, count);
 211         while (i>0) {
 212                 if (i>16)
 213                         j=16;
 214                 else
 215                         j=i;
 216                 QuickHex(t, p, j);
 217                 debugl1(cs, tmp);
 218                 p += j;
 219                 i -= j;
 220                 t = tmp;
 221                 t += sprintf(t, "tiger %s      ", s);
 222         }
 223 }
 224
 225 // macro for 64k
 226
 227 #define MAKE_RAW_BYTE for (j=0; j<8; j++) { \
 228                         bitcnt++;\
 229                         s_val >>= 1;\
 230                         if (val & 1) {\
 231                                 s_one++;\
 232                                 s_val |= 0x80;\
 233                         } else {\
 234                                 s_one = 0;\
 235                                 s_val &= 0x7f;\
 236                         }\
 237                         if (bitcnt==8) {\
 238                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 239                                 bitcnt = 0;\
 240                         }\
 241                         if (s_one == 5) {\
 242                                 s_val >>= 1;\
 243                                 s_val &= 0x7f;\
 244                                 bitcnt++;\
 245                                 s_one = 0;\
 246                         }\
 247                         if (bitcnt==8) {\
 248                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 249                                 bitcnt = 0;\
 250                         }\
 251                         val >>= 1;\
 252                 }
 253
 254 static int make_raw_data(struct BCState *bcs) {
 255 // this make_raw is for 64k
 256         register u_int i,s_cnt=0;
 257         register u_char j;
 258         register u_char val;
 259         register u_char s_one = 0;
 260         register u_char s_val = 0;
 261         register u_char bitcnt = 0;
 262         u_int fcs;
 263
 264         if (!bcs->tx_skb) {
 265                 debugl1(bcs->cs, "tiger make_raw: NULL skb");
 266                 return(1);
 267         }
 268         bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE;
 269         fcs = PPP_INITFCS;
 270         for (i=0; i<bcs->tx_skb->len; i++) {
 271                 val = bcs->tx_skb->data[i];
 272                 fcs = PPP_FCS (fcs, val);
 273                 MAKE_RAW_BYTE;
 274         }
 275         fcs ^= 0xffff;
 276         val = fcs & 0xff;
 277         MAKE_RAW_BYTE;
 278         val = (fcs>>8) & 0xff;
 279         MAKE_RAW_BYTE;
 280         val = HDLC_FLAG_VALUE;
 281         for (j=0; j<8; j++) {
 282                 bitcnt++;
 283                 s_val >>= 1;
 284                 if (val & 1)
 285                         s_val |= 0x80;
 286                 else
 287                         s_val &= 0x7f;
 288                 if (bitcnt==8) {
 289                         bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 290                         bitcnt = 0;
 291                 }
 292                 val >>= 1;
 293         }
 294         if (bcs->cs->debug & L1_DEB_HSCX)
 295                 debugl1(bcs->cs,"tiger make_raw: in %ld out %d.%d",
 296                         bcs->tx_skb->len, s_cnt, bitcnt);
 297         if (bitcnt) {
 298                 while (8>bitcnt++) {
 299                         s_val >>= 1;
 300                         s_val |= 0x80;
 301                 }
 302                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 303                 bcs->hw.tiger.sendbuf[s_cnt++] = 0xff;  // NJ<->NJ thoughput bug fix
 304         }
 305         bcs->hw.tiger.sendcnt = s_cnt;
 306         bcs->tx_cnt -= bcs->tx_skb->len;
 307         bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
 308         return(0);
 309 }
 310
 311 // macro for 56k
 312
 313 #define MAKE_RAW_BYTE_56K for (j=0; j<8; j++) { \
 314                         bitcnt++;\
 315                         s_val >>= 1;\
 316                         if (val & 1) {\
 317                                 s_one++;\
 318                                 s_val |= 0x80;\
 319                         } else {\
 320                                 s_one = 0;\
 321                                 s_val &= 0x7f;\
 322                         }\
 323                         if (bitcnt==7) {\
 324                                 s_val >>= 1;\
 325                                 s_val |= 0x80;\
 326                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 327                                 bitcnt = 0;\
 328                         }\
 329                         if (s_one == 5) {\
 330                                 s_val >>= 1;\
 331                                 s_val &= 0x7f;\
 332                                 bitcnt++;\
 333                                 s_one = 0;\
 334                         }\
 335                         if (bitcnt==7) {\
 336                                 s_val >>= 1;\
 337                                 s_val |= 0x80;\
 338                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 339                                 bitcnt = 0;\
 340                         }\
 341                         val >>= 1;\
 342                 }
 343
 344 static int make_raw_data_56k(struct BCState *bcs) {
 345 // this make_raw is for 56k
 346         register u_int i,s_cnt=0;
 347         register u_char j;
 348         register u_char val;
 349         register u_char s_one = 0;
 350         register u_char s_val = 0;
 351         register u_char bitcnt = 0;
 352         u_int fcs;
 353
 354         if (!bcs->tx_skb) {
 355                 debugl1(bcs->cs, "tiger make_raw_56k: NULL skb");
 356                 return(1);
 357         }
 358         val = HDLC_FLAG_VALUE;
 359         for (j=0; j<8; j++) {
 360                 bitcnt++;
 361                 s_val >>= 1;
 362                 if (val & 1)
 363                         s_val |= 0x80;
 364                 else
 365                         s_val &= 0x7f;
 366                 if (bitcnt==7) {
 367                         s_val >>= 1;
 368                         s_val |= 0x80;
 369                         bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 370                         bitcnt = 0;
 371                 }
 372                 val >>= 1;
 373         };
 374         fcs = PPP_INITFCS;
 375         for (i=0; i<bcs->tx_skb->len; i++) {
 376                 val = bcs->tx_skb->data[i];
 377                 fcs = PPP_FCS (fcs, val);
 378                 MAKE_RAW_BYTE_56K;
 379         }
 380         fcs ^= 0xffff;
 381         val = fcs & 0xff;
 382         MAKE_RAW_BYTE_56K;
 383         val = (fcs>>8) & 0xff;
 384         MAKE_RAW_BYTE_56K;
 385         val = HDLC_FLAG_VALUE;
 386         for (j=0; j<8; j++) {
 387                 bitcnt++;
 388                 s_val >>= 1;
 389                 if (val & 1)
 390                         s_val |= 0x80;
 391                 else
 392                         s_val &= 0x7f;
 393                 if (bitcnt==7) {
 394                         s_val >>= 1;
 395                         s_val |= 0x80;
 396                         bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 397                         bitcnt = 0;
 398                 }
 399                 val >>= 1;
 400         }
 401         if (bcs->cs->debug & L1_DEB_HSCX)
 402                 debugl1(bcs->cs,"tiger make_raw_56k: in %ld out %d.%d",
 403                         bcs->tx_skb->len, s_cnt, bitcnt);
 404         if (bitcnt) {
 405                 while (8>bitcnt++) {
 406                         s_val >>= 1;
 407                         s_val |= 0x80;
 408                 }
 409                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 410                 bcs->hw.tiger.sendbuf[s_cnt++] = 0xff;  // NJ<->NJ thoughput bug fix
 411         }
 412         bcs->hw.tiger.sendcnt = s_cnt;
 413         bcs->tx_cnt -= bcs->tx_skb->len;
 414         bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
 415         return(0);
 416 }
 417
 418 static void got_frame(struct BCState *bcs, int count) {
 419         struct sk_buff *skb;
 420
 421         if (!(skb = dev_alloc_skb(count)))
 422                 printk(KERN_WARNING "TIGER: receive out of memory\n");
 423         else {
 424                 memcpy(skb_put(skb, count), bcs->hw.tiger.rcvbuf, count);
 425                 skb_queue_tail(&bcs->rqueue, skb);
 426         }
 427         test_and_set_bit(B_RCVBUFREADY, &bcs->event);
 428         schedule_work(&bcs->tqueue);
 429
 430         if (bcs->cs->debug & L1_DEB_RECEIVE_FRAME)
 431                 printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, "rec");
 432 }
 433
 434
 435
 436 static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
 437         int i;
 438         register u_char j;
 439         register u_char val;
 440         u_int  *pend = bcs->hw.tiger.rec +NETJET_DMA_RXSIZE -1;
 441         register u_char state = bcs->hw.tiger.r_state;
 442         register u_char r_one = bcs->hw.tiger.r_one;
 443         register u_char r_val = bcs->hw.tiger.r_val;
 444         register u_int bitcnt = bcs->hw.tiger.r_bitcnt;
 445         u_int *p = buf;
 446         int bits;
 447         u_char mask;
 448
 449         if (bcs->mode == L1_MODE_HDLC) { // it's 64k
 450                 mask = 0xff;
 451                 bits = 8;
 452         }
 453         else { // it's 56K
 454                 mask = 0x7f;
 455                 bits = 7;
 456         };
 457         for (i=0;i<cnt;i++) {
 458                 val = bcs->channel ? ((*p>>8) & 0xff) : (*p & 0xff);
 459                 p++;
 460                 if (p > pend)
 461                         p = bcs->hw.tiger.rec;
 462                 if ((val & mask) == mask) {
 463                         state = HDLC_ZERO_SEARCH;
 464                         bcs->hw.tiger.r_tot++;
 465                         bitcnt = 0;
 466                         r_one = 0;
 467                         continue;
 468                 }
 469                 for (j=0;j<bits;j++) {
 470                         if (state == HDLC_ZERO_SEARCH) {
 471                                 if (val & 1) {
 472                                         r_one++;
 473                                 } else {
 474                                         r_one=0;
 475                                         state= HDLC_FLAG_SEARCH;
 476                                         if (bcs->cs->debug & L1_DEB_HSCX)
 477                                                 debugl1(bcs->cs,"tiger read_raw: zBit(%d,%d,%d) %x",
 478                                                         bcs->hw.tiger.r_tot,i,j,val);
 479                                 }
 480                         } else if (state == HDLC_FLAG_SEARCH) {
 481                                 if (val & 1) {
 482                                         r_one++;
 483                                         if (r_one>6) {
 484                                                 state=HDLC_ZERO_SEARCH;
 485                                         }
 486                                 } else {
 487                                         if (r_one==6) {
 488                                                 bitcnt=0;
 489                                                 r_val=0;
 490                                                 state=HDLC_FLAG_FOUND;
 491                                                 if (bcs->cs->debug & L1_DEB_HSCX)
 492                                                         debugl1(bcs->cs,"tiger read_raw: flag(%d,%d,%d) %x",
 493                                                                 bcs->hw.tiger.r_tot,i,j,val);
 494                                         }
 495                                         r_one=0;
 496                                 }
 497                         } else if (state ==  HDLC_FLAG_FOUND) {
 498                                 if (val & 1) {
 499                                         r_one++;
 500                                         if (r_one>6) {
 501                                                 state=HDLC_ZERO_SEARCH;
 502                                         } else {
 503                                                 r_val >>= 1;
 504                                                 r_val |= 0x80;
 505                                                 bitcnt++;
 506                                         }
 507                                 } else {
 508                                         if (r_one==6) {
 509                                                 bitcnt=0;
 510                                                 r_val=0;
 511                                                 r_one=0;
 512                                                 val >>= 1;
 513                                                 continue;
 514                                         } else if (r_one!=5) {
 515                                                 r_val >>= 1;
 516                                                 r_val &= 0x7f;
 517                                                 bitcnt++;
 518                                         }
 519                                         r_one=0;
 520                                 }
 521                                 if ((state != HDLC_ZERO_SEARCH) &&
 522                                         !(bitcnt & 7)) {
 523                                         state=HDLC_FRAME_FOUND;
 524                                         bcs->hw.tiger.r_fcs = PPP_INITFCS;
 525                                         bcs->hw.tiger.rcvbuf[0] = r_val;
 526                                         bcs->hw.tiger.r_fcs = PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
 527                                         if (bcs->cs->debug & L1_DEB_HSCX)
 528                                                 debugl1(bcs->cs,"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x",
 529                                                         bcs->hw.tiger.r_tot,i,j,r_val,val,
 530                                                         bcs->cs->hw.njet.irqstat0);
 531                                 }
 532                         } else if (state ==  HDLC_FRAME_FOUND) {
 533                                 if (val & 1) {
 534                                         r_one++;
 535                                         if (r_one>6) {
 536                                                 state=HDLC_ZERO_SEARCH;
 537                                                 bitcnt=0;
 538                                         } else {
 539                                                 r_val >>= 1;
 540                                                 r_val |= 0x80;
 541                                                 bitcnt++;
 542                                         }
 543                                 } else {
 544                                         if (r_one==6) {
 545                                                 r_val=0;
 546                                                 r_one=0;
 547                                                 bitcnt++;
 548                                                 if (bitcnt & 7) {
 549                                                         debugl1(bcs->cs, "tiger: frame not byte aligned");
 550                                                         state=HDLC_FLAG_SEARCH;
 551                                                         bcs->hw.tiger.r_err++;
 552 #ifdef ERROR_STATISTIC
 553                                                         bcs->err_inv++;
 554 #endif
 555                                                 } else {
 556                                                         if (bcs->cs->debug & L1_DEB_HSCX)
 557                                                                 debugl1(bcs->cs,"tiger frame end(%d,%d): fcs(%x) i %x",
 558                                                                         i,j,bcs->hw.tiger.r_fcs, bcs->cs->hw.njet.irqstat0);
 559                                                         if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) {
 560                                                                 got_frame(bcs, (bitcnt>>3)-3);
 561                                                         } else {
 562                                                                 if (bcs->cs->debug) {
 563                                                                         debugl1(bcs->cs, "tiger FCS error");
 564                                                                         printframe(bcs->cs, bcs->hw.tiger.rcvbuf,
 565                                                                                 (bitcnt>>3)-1, "rec");
 566                                                                         bcs->hw.tiger.r_err++;
 567                                                                 }
 568 #ifdef ERROR_STATISTIC
 569                                                         bcs->err_crc++;
 570 #endif
 571                                                         }
 572                                                         state=HDLC_FLAG_FOUND;
 573                                                 }
 574                                                 bitcnt=0;
 575                                         } else if (r_one==5) {
 576                                                 val >>= 1;
 577                                                 r_one=0;
 578                                                 continue;
 579                                         } else {
 580                                                 r_val >>= 1;
 581                                                 r_val &= 0x7f;
 582                                                 bitcnt++;
 583                                         }
 584                                         r_one=0;
 585                                 }
 586                                 if ((state == HDLC_FRAME_FOUND) &&
 587                                         !(bitcnt & 7)) {
 588                                         if ((bitcnt>>3)>=HSCX_BUFMAX) {
 589                                                 debugl1(bcs->cs, "tiger: frame too big");
 590                                                 r_val=0;
 591                                                 state=HDLC_FLAG_SEARCH;
 592                                                 bcs->hw.tiger.r_err++;
 593 #ifdef ERROR_STATISTIC
 594                                                 bcs->err_inv++;
 595 #endif
 596                                         } else {
 597                                                 bcs->hw.tiger.rcvbuf[(bitcnt>>3)-1] = r_val;
 598                                                 bcs->hw.tiger.r_fcs =
 599                                                         PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
 600                                         }
 601                                 }
 602                         }
 603                         val >>= 1;
 604                 }
 605                 bcs->hw.tiger.r_tot++;
 606         }
 607         bcs->hw.tiger.r_state = state;
 608         bcs->hw.tiger.r_one = r_one;
 609         bcs->hw.tiger.r_val = r_val;
 610         bcs->hw.tiger.r_bitcnt = bitcnt;
 611 }
 612
 613 void read_tiger(struct IsdnCardState *cs) {
 614         u_int *p;
 615         int cnt = NETJET_DMA_RXSIZE/2;
 616
 617         if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) {
 618                 debugl1(cs,"tiger warn read double dma %x/%x",
 619                         cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
 620 #ifdef ERROR_STATISTIC
 621                 if (cs->bcs[0].mode)
 622                         cs->bcs[0].err_rdo++;
 623                 if (cs->bcs[1].mode)
 624                         cs->bcs[1].err_rdo++;
 625 #endif
 626                 return;
 627         } else {
 628                 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ;
 629                 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ);
 630         }
 631         if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1)
 632                 p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
 633         else
 634                 p = cs->bcs[0].hw.tiger.rec + cnt - 1;
 635         if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
 636                 read_raw(cs->bcs, p, cnt);
 637
 638         if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
 639                 read_raw(cs->bcs + 1, p, cnt);
 640         cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_READ;
 641 }
 642
 643 static void write_raw(struct BCState *bcs, u_int *buf, int cnt);
 644
 645 void netjet_fill_dma(struct BCState *bcs)
 646 {
 647         register u_int *p, *sp;
 648         register int cnt;
 649
 650         if (!bcs->tx_skb)
 651                 return;
 652         if (bcs->cs->debug & L1_DEB_HSCX)
 653                 debugl1(bcs->cs,"tiger fill_dma1: c%d %4x", bcs->channel,
 654                         bcs->Flag);
 655         if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag))
 656                 return;
 657         if (bcs->mode == L1_MODE_HDLC) { // it's 64k
 658                 if (make_raw_data(bcs))
 659                         return;
 660         }
 661         else { // it's 56k
 662                 if (make_raw_data_56k(bcs))
 663                         return;
 664         };
 665         if (bcs->cs->debug & L1_DEB_HSCX)
 666                 debugl1(bcs->cs,"tiger fill_dma2: c%d %4x", bcs->channel,
 667                         bcs->Flag);
 668         if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
 669                 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
 670         } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
 671                 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
 672                 sp = bcs->hw.tiger.sendp;
 673                 if (p == bcs->hw.tiger.s_end)
 674                         p = bcs->hw.tiger.send -1;
 675                 if (sp == bcs->hw.tiger.s_end)
 676                         sp = bcs->hw.tiger.send -1;
 677                 cnt = p - sp;
 678                 if (cnt <0) {
 679                         write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
 680                 } else {
 681                         p++;
 682                         cnt++;
 683                         if (p > bcs->hw.tiger.s_end)
 684                                 p = bcs->hw.tiger.send;
 685                         p++;
 686                         cnt++;
 687                         if (p > bcs->hw.tiger.s_end)
 688                                 p = bcs->hw.tiger.send;
 689                         write_raw(bcs, p, bcs->hw.tiger.free - cnt);
 690                 }
 691         } else if (test_and_clear_bit(BC_FLG_EMPTY, &bcs->Flag)) {
 692                 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
 693                 cnt = bcs->hw.tiger.s_end - p;
 694                 if (cnt < 2) {
 695                         p = bcs->hw.tiger.send + 1;
 696                         cnt = NETJET_DMA_TXSIZE/2 - 2;
 697                 } else {
 698                         p++;
 699                         p++;
 700                         if (cnt <= (NETJET_DMA_TXSIZE/2))
 701                                 cnt += NETJET_DMA_TXSIZE/2;
 702                         cnt--;
 703                         cnt--;
 704                 }
 705                 write_raw(bcs, p, cnt);
 706         }
 707         if (bcs->cs->debug & L1_DEB_HSCX)
 708                 debugl1(bcs->cs,"tiger fill_dma3: c%d %4x", bcs->channel,
 709                         bcs->Flag);
 710 }
 711
 712 static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
 713         u_int mask, val, *p=buf;
 714         u_int i, s_cnt;
 715
 716         if (cnt <= 0)
 717                 return;
 718         if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
 719                 if (bcs->hw.tiger.sendcnt> cnt) {
 720                         s_cnt = cnt;
 721                         bcs->hw.tiger.sendcnt -= cnt;
 722                 } else {
 723                         s_cnt = bcs->hw.tiger.sendcnt;
 724                         bcs->hw.tiger.sendcnt = 0;
 725                 }
 726                 if (bcs->channel)
 727                         mask = 0xffff00ff;
 728                 else
 729                         mask = 0xffffff00;
 730                 for (i=0; i<s_cnt; i++) {
 731                         val = bcs->channel ? ((bcs->hw.tiger.sp[i] <<8) & 0xff00) :
 732                                 (bcs->hw.tiger.sp[i]);
 733                         *p   &= mask;
 734                         *p++ |= val;
 735                         if (p>bcs->hw.tiger.s_end)
 736                                 p = bcs->hw.tiger.send;
 737                 }
 738                 bcs->hw.tiger.s_tot += s_cnt;
 739                 if (bcs->cs->debug & L1_DEB_HSCX)
 740                         debugl1(bcs->cs,"tiger write_raw: c%d %x-%x %d/%d %d %x", bcs->channel,
 741                                 (u_int)buf, (u_int)p, s_cnt, cnt,
 742                                 bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0);
 743                 if (bcs->cs->debug & L1_DEB_HSCX_FIFO)
 744                         printframe(bcs->cs, bcs->hw.tiger.sp, s_cnt, "snd");
 745                 bcs->hw.tiger.sp += s_cnt;
 746                 bcs->hw.tiger.sendp = p;
 747                 if (!bcs->hw.tiger.sendcnt) {
 748                         if (!bcs->tx_skb) {
 749                                 debugl1(bcs->cs,"tiger write_raw: NULL skb s_cnt %d", s_cnt);
 750                         } else {
 751                                 if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag) &&
 752                                         (PACKET_NOACK != bcs->tx_skb->pkt_type)) {
 753                                         u_long  flags;
 754                                         spin_lock_irqsave(&bcs->aclock, flags);
 755                                         bcs->ackcnt += bcs->tx_skb->len;
 756                                         spin_unlock_irqrestore(&bcs->aclock, flags);
 757                                         schedule_event(bcs, B_ACKPENDING);
 758                                 }
 759                                 dev_kfree_skb_any(bcs->tx_skb);
 760                                 bcs->tx_skb = NULL;
 761                         }
 762                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 763                         bcs->hw.tiger.free = cnt - s_cnt;
 764                         if (bcs->hw.tiger.free > (NETJET_DMA_TXSIZE/2))
 765                                 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
 766                         else {
 767                                 test_and_clear_bit(BC_FLG_HALF, &bcs->Flag);
 768                                 test_and_set_bit(BC_FLG_NOFRAME, &bcs->Flag);
 769                         }
 770                         if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
 771                                 netjet_fill_dma(bcs);
 772                         } else {
 773                                 mask ^= 0xffffffff;
 774                                 if (s_cnt < cnt) {
 775                                         for (i=s_cnt; i<cnt;i++) {
 776                                                 *p++ |= mask;
 777                                                 if (p>bcs->hw.tiger.s_end)
 778                                                         p = bcs->hw.tiger.send;
 779                                         }
 780                                         if (bcs->cs->debug & L1_DEB_HSCX)
 781                                                 debugl1(bcs->cs, "tiger write_raw: fill rest %d",
 782                                                         cnt - s_cnt);
 783                                 }
 784                                 test_and_set_bit(B_XMTBUFREADY, &bcs->event);
 785                                 schedule_work(&bcs->tqueue);
 786                         }
 787                 }
 788         } else if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
 789                 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
 790                 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
 791                 bcs->hw.tiger.free += cnt;
 792                 if (bcs->cs->debug & L1_DEB_HSCX)
 793                         debugl1(bcs->cs,"tiger write_raw: fill half");
 794         } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
 795                 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
 796                 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
 797                 if (bcs->cs->debug & L1_DEB_HSCX)
 798                         debugl1(bcs->cs,"tiger write_raw: fill full");
 799         }
 800 }
 801
 802 void write_tiger(struct IsdnCardState *cs) {
 803         u_int *p, cnt = NETJET_DMA_TXSIZE/2;
 804
 805         if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) {
 806                 debugl1(cs,"tiger warn write double dma %x/%x",
 807                         cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
 808 #ifdef ERROR_STATISTIC
 809                 if (cs->bcs[0].mode)
 810                         cs->bcs[0].err_tx++;
 811                 if (cs->bcs[1].mode)
 812                         cs->bcs[1].err_tx++;
 813 #endif
 814                 return;
 815         } else {
 816                 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE;
 817                 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE);
 818         }
 819         if (cs->hw.njet.irqstat0  & NETJET_IRQM0_WRITE_1)
 820                 p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
 821         else
 822                 p = cs->bcs[0].hw.tiger.send + cnt - 1;
 823         if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
 824                 write_raw(cs->bcs, p, cnt);
 825         if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
 826                 write_raw(cs->bcs + 1, p, cnt);
 827         cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_WRITE;
 828 }
 829
 830 static void
 831 tiger_l2l1(struct PStack *st, int pr, void *arg)
 832 {
 833         struct BCState *bcs = st->l1.bcs;
 834         struct sk_buff *skb = arg;
 835         u_long flags;
 836
 837         switch (pr) {
 838                 case (PH_DATA | REQUEST):
 839                         spin_lock_irqsave(&bcs->cs->lock, flags);
 840                         if (bcs->tx_skb) {
 841                                 skb_queue_tail(&bcs->squeue, skb);
 842                         } else {
 843                                 bcs->tx_skb = skb;
 844                                 bcs->cs->BC_Send_Data(bcs);
 845                         }
 846                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 847                         break;
 848                 case (PH_PULL | INDICATION):
 849                         spin_lock_irqsave(&bcs->cs->lock, flags);
 850                         if (bcs->tx_skb) {
 851                                 printk(KERN_WARNING "tiger_l2l1: this shouldn't happen\n");
 852                         } else {
 853                                 bcs->tx_skb = skb;
 854                                 bcs->cs->BC_Send_Data(bcs);
 855                         }
 856                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 857                         break;
 858                 case (PH_PULL | REQUEST):
 859                         if (!bcs->tx_skb) {
 860                                 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 861                                 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 862                         } else
 863                                 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 864                         break;
 865                 case (PH_ACTIVATE | REQUEST):
 866                         spin_lock_irqsave(&bcs->cs->lock, flags);
 867                         test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
 868                         mode_tiger(bcs, st->l1.mode, st->l1.bc);
 869                         /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
 870                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 871                         bcs->cs->cardmsg(bcs->cs, MDL_BC_ASSIGN, (void *)(&st->l1.bc));
 872                         l1_msg_b(st, pr, arg);
 873                         break;
 874                 case (PH_DEACTIVATE | REQUEST):
 875                         /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
 876                         bcs->cs->cardmsg(bcs->cs, MDL_BC_RELEASE, (void *)(&st->l1.bc));
 877                         l1_msg_b(st, pr, arg);
 878                         break;
 879                 case (PH_DEACTIVATE | CONFIRM):
 880                         spin_lock_irqsave(&bcs->cs->lock, flags);
 881                         test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
 882                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 883                         mode_tiger(bcs, 0, st->l1.bc);
 884                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 885                         st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
 886                         break;
 887         }
 888 }
 889
 890
 891 void
 892 close_tigerstate(struct BCState *bcs)
 893 {
 894         mode_tiger(bcs, 0, bcs->channel);
 895         if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
 896                 if (bcs->hw.tiger.rcvbuf) {
 897                         kfree(bcs->hw.tiger.rcvbuf);
 898                         bcs->hw.tiger.rcvbuf = NULL;
 899                 }
 900                 if (bcs->hw.tiger.sendbuf) {
 901                         kfree(bcs->hw.tiger.sendbuf);
 902                         bcs->hw.tiger.sendbuf = NULL;
 903                 }
 904                 skb_queue_purge(&bcs->rqueue);
 905                 skb_queue_purge(&bcs->squeue);
 906                 if (bcs->tx_skb) {
 907                         dev_kfree_skb_any(bcs->tx_skb);
 908                         bcs->tx_skb = NULL;
 909                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 910                 }
 911         }
 912 }
 913
 914 static int
 915 open_tigerstate(struct IsdnCardState *cs, struct BCState *bcs)
 916 {
 917         if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
 918                 if (!(bcs->hw.tiger.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
 919                         printk(KERN_WARNING
 920                                "HiSax: No memory for tiger.rcvbuf\n");
 921                         return (1);
 922                 }
 923                 if (!(bcs->hw.tiger.sendbuf = kmalloc(RAW_BUFMAX, GFP_ATOMIC))) {
 924                         printk(KERN_WARNING
 925                                "HiSax: No memory for tiger.sendbuf\n");
 926                         return (1);
 927                 }
 928                 skb_queue_head_init(&bcs->rqueue);
 929                 skb_queue_head_init(&bcs->squeue);
 930         }
 931         bcs->tx_skb = NULL;
 932         bcs->hw.tiger.sendcnt = 0;
 933         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 934         bcs->event = 0;
 935         bcs->tx_cnt = 0;
 936         return (0);
 937 }
 938
 939 int
 940 setstack_tiger(struct PStack *st, struct BCState *bcs)
 941 {
 942         bcs->channel = st->l1.bc;
 943         if (open_tigerstate(st->l1.hardware, bcs))
 944                 return (-1);
 945         st->l1.bcs = bcs;
 946         st->l2.l2l1 = tiger_l2l1;
 947         setstack_manager(st);
 948         bcs->st = st;
 949         setstack_l1_B(st);
 950         return (0);
 951 }
 952
 953
 954 void __init
 955 inittiger(struct IsdnCardState *cs)
 956 {
 957         if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int),
 958                 GFP_KERNEL | GFP_DMA))) {
 959                 printk(KERN_WARNING
 960                        "HiSax: No memory for tiger.send\n");
 961                 return;
 962         }
 963         cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE/2 - 1;
 964         cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
 965         cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send;
 966         cs->bcs[1].hw.tiger.s_irq = cs->bcs[0].hw.tiger.s_irq;
 967         cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end;
 968
 969         memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_TXSIZE * sizeof(unsigned int));
 970         debugl1(cs, "tiger: send buf %x - %x", (u_int)cs->bcs[0].hw.tiger.send,
 971                 (u_int)(cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1));
 972         outl(virt_to_bus(cs->bcs[0].hw.tiger.send),
 973                 cs->hw.njet.base + NETJET_DMA_READ_START);
 974         outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq),
 975                 cs->hw.njet.base + NETJET_DMA_READ_IRQ);
 976         outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end),
 977                 cs->hw.njet.base + NETJET_DMA_READ_END);
 978         if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int),
 979                 GFP_KERNEL | GFP_DMA))) {
 980                 printk(KERN_WARNING
 981                        "HiSax: No memory for tiger.rec\n");
 982                 return;
 983         }
 984         debugl1(cs, "tiger: rec buf %x - %x", (u_int)cs->bcs[0].hw.tiger.rec,
 985                 (u_int)(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1));
 986         cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec;
 987         memset(cs->bcs[0].hw.tiger.rec, 0xff, NETJET_DMA_RXSIZE * sizeof(unsigned int));
 988         outl(virt_to_bus(cs->bcs[0].hw.tiger.rec),
 989                 cs->hw.njet.base + NETJET_DMA_WRITE_START);
 990         outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE/2 - 1),
 991                 cs->hw.njet.base + NETJET_DMA_WRITE_IRQ);
 992         outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1),
 993                 cs->hw.njet.base + NETJET_DMA_WRITE_END);
 994         debugl1(cs, "tiger: dmacfg  %x/%x  pulse=%d",
 995                 inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 996                 inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 997                 bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
 998         cs->hw.njet.last_is0 = 0;
 999         cs->bcs[0].BC_SetStack = setstack_tiger;
1000         cs->bcs[1].BC_SetStack = setstack_tiger;
1001         cs->bcs[0].BC_Close = close_tigerstate;
1002         cs->bcs[1].BC_Close = close_tigerstate;
1003 }
1004
1005 void
1006 releasetiger(struct IsdnCardState *cs)
1007 {
1008         if (cs->bcs[0].hw.tiger.send) {
1009                 kfree(cs->bcs[0].hw.tiger.send);
1010                 cs->bcs[0].hw.tiger.send = NULL;
1011         }
1012         if (cs->bcs[1].hw.tiger.send) {
1013                 cs->bcs[1].hw.tiger.send = NULL;
1014         }
1015         if (cs->bcs[0].hw.tiger.rec) {
1016                 kfree(cs->bcs[0].hw.tiger.rec);
1017                 cs->bcs[0].hw.tiger.rec = NULL;
1018         }
1019         if (cs->bcs[1].hw.tiger.rec) {
1020                 cs->bcs[1].hw.tiger.rec = NULL;
1021         }
1022 }
1023
1024 void
1025 release_io_netjet(struct IsdnCardState *cs)
1026 {
1027         byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
1028         byteout(cs->hw.njet.base + NETJET_IRQMASK1, 0);
1029         releasetiger(cs);
1030         release_region(cs->hw.njet.base, 256);
1031 }
1032