git.oblomov.eu Git - linux-2.6/blob - 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 /* Interface functions */
  29
  30 u_char
  31 NETjet_ReadIC(struct IsdnCardState *cs, u_char offset)
  32 {
  33         u_char ret;
  34
  35         cs->hw.njet.auxd &= 0xfc;
  36         cs->hw.njet.auxd |= (offset>>4) & 3;
  37         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  38         ret = bytein(cs->hw.njet.isac + ((offset & 0xf)<<2));
  39         return(ret);
  40 }
  41
  42 void
  43 NETjet_WriteIC(struct IsdnCardState *cs, u_char offset, u_char value)
  44 {
  45         cs->hw.njet.auxd &= 0xfc;
  46         cs->hw.njet.auxd |= (offset>>4) & 3;
  47         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  48         byteout(cs->hw.njet.isac + ((offset & 0xf)<<2), value);
  49 }
  50
  51 void
  52 NETjet_ReadICfifo(struct IsdnCardState *cs, u_char *data, int size)
  53 {
  54         cs->hw.njet.auxd &= 0xfc;
  55         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  56         insb(cs->hw.njet.isac, data, size);
  57 }
  58
  59 void
  60 NETjet_WriteICfifo(struct IsdnCardState *cs, u_char *data, int size)
  61 {
  62         cs->hw.njet.auxd &= 0xfc;
  63         byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
  64         outsb(cs->hw.njet.isac, data, size);
  65 }
  66
  67 static void fill_mem(struct BCState *bcs, u_int *pos, u_int cnt, int chan, u_char fill)
  68 {
  69         u_int mask=0x000000ff, val = 0, *p=pos;
  70         u_int i;
  71
  72         val |= fill;
  73         if (chan) {
  74                 val  <<= 8;
  75                 mask <<= 8;
  76         }
  77         mask ^= 0xffffffff;
  78         for (i=0; i<cnt; i++) {
  79                 *p   &= mask;
  80                 *p++ |= val;
  81                 if (p > bcs->hw.tiger.s_end)
  82                         p = bcs->hw.tiger.send;
  83         }
  84 }
  85
  86 static void
  87 mode_tiger(struct BCState *bcs, int mode, int bc)
  88 {
  89         struct IsdnCardState *cs = bcs->cs;
  90         u_char led;
  91
  92         if (cs->debug & L1_DEB_HSCX)
  93                 debugl1(cs, "Tiger mode %d bchan %d/%d",
  94                         mode, bc, bcs->channel);
  95         bcs->mode = mode;
  96         bcs->channel = bc;
  97         switch (mode) {
  98                 case (L1_MODE_NULL):
  99                         fill_mem(bcs, bcs->hw.tiger.send,
 100                                 NETJET_DMA_TXSIZE, bc, 0xff);
 101                         if (cs->debug & L1_DEB_HSCX)
 102                                 debugl1(cs, "Tiger stat rec %d/%d send %d",
 103                                         bcs->hw.tiger.r_tot, bcs->hw.tiger.r_err,
 104                                         bcs->hw.tiger.s_tot);
 105                         if ((cs->bcs[0].mode == L1_MODE_NULL) &&
 106                                 (cs->bcs[1].mode == L1_MODE_NULL)) {
 107                                 cs->hw.njet.dmactrl = 0;
 108                                 byteout(cs->hw.njet.base + NETJET_DMACTRL,
 109                                         cs->hw.njet.dmactrl);
 110                                 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
 111                         }
 112                         if (cs->typ == ISDN_CTYPE_NETJET_S)
 113                         {
 114                                 // led off
 115                                 led = bc & 0x01;
 116                                 led = 0x01 << (6 + led); // convert to mask
 117                                 led = ~led;
 118                                 cs->hw.njet.auxd &= led;
 119                                 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
 120                         }
 121                         break;
 122                 case (L1_MODE_TRANS):
 123                         break;
 124                 case (L1_MODE_HDLC_56K):
 125                 case (L1_MODE_HDLC):
 126                         fill_mem(bcs, bcs->hw.tiger.send,
 127                                 NETJET_DMA_TXSIZE, bc, 0xff);
 128                         bcs->hw.tiger.r_state = HDLC_ZERO_SEARCH;
 129                         bcs->hw.tiger.r_tot = 0;
 130                         bcs->hw.tiger.r_bitcnt = 0;
 131                         bcs->hw.tiger.r_one = 0;
 132                         bcs->hw.tiger.r_err = 0;
 133                         bcs->hw.tiger.s_tot = 0;
 134                         if (! cs->hw.njet.dmactrl) {
 135                                 fill_mem(bcs, bcs->hw.tiger.send,
 136                                         NETJET_DMA_TXSIZE, !bc, 0xff);
 137                                 cs->hw.njet.dmactrl = 1;
 138                                 byteout(cs->hw.njet.base + NETJET_DMACTRL,
 139                                         cs->hw.njet.dmactrl);
 140                                 byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0x0f);
 141                         /* was 0x3f now 0x0f for TJ300 and TJ320  GE 13/07/00 */
 142                         }
 143                         bcs->hw.tiger.sendp = bcs->hw.tiger.send;
 144                         bcs->hw.tiger.free = NETJET_DMA_TXSIZE;
 145                         test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
 146                         if (cs->typ == ISDN_CTYPE_NETJET_S)
 147                         {
 148                                 // led on
 149                                 led = bc & 0x01;
 150                                 led = 0x01 << (6 + led); // convert to mask
 151                                 cs->hw.njet.auxd |= led;
 152                                 byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
 153                         }
 154                         break;
 155         }
 156         if (cs->debug & L1_DEB_HSCX)
 157                 debugl1(cs, "tiger: set %x %x %x  %x/%x  pulse=%d",
 158                         bytein(cs->hw.njet.base + NETJET_DMACTRL),
 159                         bytein(cs->hw.njet.base + NETJET_IRQMASK0),
 160                         bytein(cs->hw.njet.base + NETJET_IRQSTAT0),
 161                         inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 162                         inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 163                         bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
 164 }
 165
 166 static void printframe(struct IsdnCardState *cs, u_char *buf, int count, char *s) {
 167         char tmp[128];
 168         char *t = tmp;
 169         int i=count,j;
 170         u_char *p = buf;
 171
 172         t += sprintf(t, "tiger %s(%4d)", s, count);
 173         while (i>0) {
 174                 if (i>16)
 175                         j=16;
 176                 else
 177                         j=i;
 178                 QuickHex(t, p, j);
 179                 debugl1(cs, tmp);
 180                 p += j;
 181                 i -= j;
 182                 t = tmp;
 183                 t += sprintf(t, "tiger %s      ", s);
 184         }
 185 }
 186
 187 // macro for 64k
 188
 189 #define MAKE_RAW_BYTE for (j=0; j<8; j++) { \
 190                         bitcnt++;\
 191                         s_val >>= 1;\
 192                         if (val & 1) {\
 193                                 s_one++;\
 194                                 s_val |= 0x80;\
 195                         } else {\
 196                                 s_one = 0;\
 197                                 s_val &= 0x7f;\
 198                         }\
 199                         if (bitcnt==8) {\
 200                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 201                                 bitcnt = 0;\
 202                         }\
 203                         if (s_one == 5) {\
 204                                 s_val >>= 1;\
 205                                 s_val &= 0x7f;\
 206                                 bitcnt++;\
 207                                 s_one = 0;\
 208                         }\
 209                         if (bitcnt==8) {\
 210                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 211                                 bitcnt = 0;\
 212                         }\
 213                         val >>= 1;\
 214                 }
 215
 216 static int make_raw_data(struct BCState *bcs) {
 217 // this make_raw is for 64k
 218         register u_int i,s_cnt=0;
 219         register u_char j;
 220         register u_char val;
 221         register u_char s_one = 0;
 222         register u_char s_val = 0;
 223         register u_char bitcnt = 0;
 224         u_int fcs;
 225
 226         if (!bcs->tx_skb) {
 227                 debugl1(bcs->cs, "tiger make_raw: NULL skb");
 228                 return(1);
 229         }
 230         bcs->hw.tiger.sendbuf[s_cnt++] = HDLC_FLAG_VALUE;
 231         fcs = PPP_INITFCS;
 232         for (i=0; i<bcs->tx_skb->len; i++) {
 233                 val = bcs->tx_skb->data[i];
 234                 fcs = PPP_FCS (fcs, val);
 235                 MAKE_RAW_BYTE;
 236         }
 237         fcs ^= 0xffff;
 238         val = fcs & 0xff;
 239         MAKE_RAW_BYTE;
 240         val = (fcs>>8) & 0xff;
 241         MAKE_RAW_BYTE;
 242         val = HDLC_FLAG_VALUE;
 243         for (j=0; j<8; j++) {
 244                 bitcnt++;
 245                 s_val >>= 1;
 246                 if (val & 1)
 247                         s_val |= 0x80;
 248                 else
 249                         s_val &= 0x7f;
 250                 if (bitcnt==8) {
 251                         bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 252                         bitcnt = 0;
 253                 }
 254                 val >>= 1;
 255         }
 256         if (bcs->cs->debug & L1_DEB_HSCX)
 257                 debugl1(bcs->cs,"tiger make_raw: in %ld out %d.%d",
 258                         bcs->tx_skb->len, s_cnt, bitcnt);
 259         if (bitcnt) {
 260                 while (8>bitcnt++) {
 261                         s_val >>= 1;
 262                         s_val |= 0x80;
 263                 }
 264                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 265                 bcs->hw.tiger.sendbuf[s_cnt++] = 0xff;  // NJ<->NJ thoughput bug fix
 266         }
 267         bcs->hw.tiger.sendcnt = s_cnt;
 268         bcs->tx_cnt -= bcs->tx_skb->len;
 269         bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
 270         return(0);
 271 }
 272
 273 // macro for 56k
 274
 275 #define MAKE_RAW_BYTE_56K for (j=0; j<8; j++) { \
 276                         bitcnt++;\
 277                         s_val >>= 1;\
 278                         if (val & 1) {\
 279                                 s_one++;\
 280                                 s_val |= 0x80;\
 281                         } else {\
 282                                 s_one = 0;\
 283                                 s_val &= 0x7f;\
 284                         }\
 285                         if (bitcnt==7) {\
 286                                 s_val >>= 1;\
 287                                 s_val |= 0x80;\
 288                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 289                                 bitcnt = 0;\
 290                         }\
 291                         if (s_one == 5) {\
 292                                 s_val >>= 1;\
 293                                 s_val &= 0x7f;\
 294                                 bitcnt++;\
 295                                 s_one = 0;\
 296                         }\
 297                         if (bitcnt==7) {\
 298                                 s_val >>= 1;\
 299                                 s_val |= 0x80;\
 300                                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;\
 301                                 bitcnt = 0;\
 302                         }\
 303                         val >>= 1;\
 304                 }
 305
 306 static int make_raw_data_56k(struct BCState *bcs) {
 307 // this make_raw is for 56k
 308         register u_int i,s_cnt=0;
 309         register u_char j;
 310         register u_char val;
 311         register u_char s_one = 0;
 312         register u_char s_val = 0;
 313         register u_char bitcnt = 0;
 314         u_int fcs;
 315
 316         if (!bcs->tx_skb) {
 317                 debugl1(bcs->cs, "tiger make_raw_56k: NULL skb");
 318                 return(1);
 319         }
 320         val = HDLC_FLAG_VALUE;
 321         for (j=0; j<8; j++) {
 322                 bitcnt++;
 323                 s_val >>= 1;
 324                 if (val & 1)
 325                         s_val |= 0x80;
 326                 else
 327                         s_val &= 0x7f;
 328                 if (bitcnt==7) {
 329                         s_val >>= 1;
 330                         s_val |= 0x80;
 331                         bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 332                         bitcnt = 0;
 333                 }
 334                 val >>= 1;
 335         };
 336         fcs = PPP_INITFCS;
 337         for (i=0; i<bcs->tx_skb->len; i++) {
 338                 val = bcs->tx_skb->data[i];
 339                 fcs = PPP_FCS (fcs, val);
 340                 MAKE_RAW_BYTE_56K;
 341         }
 342         fcs ^= 0xffff;
 343         val = fcs & 0xff;
 344         MAKE_RAW_BYTE_56K;
 345         val = (fcs>>8) & 0xff;
 346         MAKE_RAW_BYTE_56K;
 347         val = HDLC_FLAG_VALUE;
 348         for (j=0; j<8; j++) {
 349                 bitcnt++;
 350                 s_val >>= 1;
 351                 if (val & 1)
 352                         s_val |= 0x80;
 353                 else
 354                         s_val &= 0x7f;
 355                 if (bitcnt==7) {
 356                         s_val >>= 1;
 357                         s_val |= 0x80;
 358                         bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 359                         bitcnt = 0;
 360                 }
 361                 val >>= 1;
 362         }
 363         if (bcs->cs->debug & L1_DEB_HSCX)
 364                 debugl1(bcs->cs,"tiger make_raw_56k: in %ld out %d.%d",
 365                         bcs->tx_skb->len, s_cnt, bitcnt);
 366         if (bitcnt) {
 367                 while (8>bitcnt++) {
 368                         s_val >>= 1;
 369                         s_val |= 0x80;
 370                 }
 371                 bcs->hw.tiger.sendbuf[s_cnt++] = s_val;
 372                 bcs->hw.tiger.sendbuf[s_cnt++] = 0xff;  // NJ<->NJ thoughput bug fix
 373         }
 374         bcs->hw.tiger.sendcnt = s_cnt;
 375         bcs->tx_cnt -= bcs->tx_skb->len;
 376         bcs->hw.tiger.sp = bcs->hw.tiger.sendbuf;
 377         return(0);
 378 }
 379
 380 static void got_frame(struct BCState *bcs, int count) {
 381         struct sk_buff *skb;
 382
 383         if (!(skb = dev_alloc_skb(count)))
 384                 printk(KERN_WARNING "TIGER: receive out of memory\n");
 385         else {
 386                 memcpy(skb_put(skb, count), bcs->hw.tiger.rcvbuf, count);
 387                 skb_queue_tail(&bcs->rqueue, skb);
 388         }
 389         test_and_set_bit(B_RCVBUFREADY, &bcs->event);
 390         schedule_work(&bcs->tqueue);
 391
 392         if (bcs->cs->debug & L1_DEB_RECEIVE_FRAME)
 393                 printframe(bcs->cs, bcs->hw.tiger.rcvbuf, count, "rec");
 394 }
 395
 396
 397
 398 static void read_raw(struct BCState *bcs, u_int *buf, int cnt){
 399         int i;
 400         register u_char j;
 401         register u_char val;
 402         u_int  *pend = bcs->hw.tiger.rec +NETJET_DMA_RXSIZE -1;
 403         register u_char state = bcs->hw.tiger.r_state;
 404         register u_char r_one = bcs->hw.tiger.r_one;
 405         register u_char r_val = bcs->hw.tiger.r_val;
 406         register u_int bitcnt = bcs->hw.tiger.r_bitcnt;
 407         u_int *p = buf;
 408         int bits;
 409         u_char mask;
 410
 411         if (bcs->mode == L1_MODE_HDLC) { // it's 64k
 412                 mask = 0xff;
 413                 bits = 8;
 414         }
 415         else { // it's 56K
 416                 mask = 0x7f;
 417                 bits = 7;
 418         };
 419         for (i=0;i<cnt;i++) {
 420                 val = bcs->channel ? ((*p>>8) & 0xff) : (*p & 0xff);
 421                 p++;
 422                 if (p > pend)
 423                         p = bcs->hw.tiger.rec;
 424                 if ((val & mask) == mask) {
 425                         state = HDLC_ZERO_SEARCH;
 426                         bcs->hw.tiger.r_tot++;
 427                         bitcnt = 0;
 428                         r_one = 0;
 429                         continue;
 430                 }
 431                 for (j=0;j<bits;j++) {
 432                         if (state == HDLC_ZERO_SEARCH) {
 433                                 if (val & 1) {
 434                                         r_one++;
 435                                 } else {
 436                                         r_one=0;
 437                                         state= HDLC_FLAG_SEARCH;
 438                                         if (bcs->cs->debug & L1_DEB_HSCX)
 439                                                 debugl1(bcs->cs,"tiger read_raw: zBit(%d,%d,%d) %x",
 440                                                         bcs->hw.tiger.r_tot,i,j,val);
 441                                 }
 442                         } else if (state == HDLC_FLAG_SEARCH) {
 443                                 if (val & 1) {
 444                                         r_one++;
 445                                         if (r_one>6) {
 446                                                 state=HDLC_ZERO_SEARCH;
 447                                         }
 448                                 } else {
 449                                         if (r_one==6) {
 450                                                 bitcnt=0;
 451                                                 r_val=0;
 452                                                 state=HDLC_FLAG_FOUND;
 453                                                 if (bcs->cs->debug & L1_DEB_HSCX)
 454                                                         debugl1(bcs->cs,"tiger read_raw: flag(%d,%d,%d) %x",
 455                                                                 bcs->hw.tiger.r_tot,i,j,val);
 456                                         }
 457                                         r_one=0;
 458                                 }
 459                         } else if (state ==  HDLC_FLAG_FOUND) {
 460                                 if (val & 1) {
 461                                         r_one++;
 462                                         if (r_one>6) {
 463                                                 state=HDLC_ZERO_SEARCH;
 464                                         } else {
 465                                                 r_val >>= 1;
 466                                                 r_val |= 0x80;
 467                                                 bitcnt++;
 468                                         }
 469                                 } else {
 470                                         if (r_one==6) {
 471                                                 bitcnt=0;
 472                                                 r_val=0;
 473                                                 r_one=0;
 474                                                 val >>= 1;
 475                                                 continue;
 476                                         } else if (r_one!=5) {
 477                                                 r_val >>= 1;
 478                                                 r_val &= 0x7f;
 479                                                 bitcnt++;
 480                                         }
 481                                         r_one=0;
 482                                 }
 483                                 if ((state != HDLC_ZERO_SEARCH) &&
 484                                         !(bitcnt & 7)) {
 485                                         state=HDLC_FRAME_FOUND;
 486                                         bcs->hw.tiger.r_fcs = PPP_INITFCS;
 487                                         bcs->hw.tiger.rcvbuf[0] = r_val;
 488                                         bcs->hw.tiger.r_fcs = PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
 489                                         if (bcs->cs->debug & L1_DEB_HSCX)
 490                                                 debugl1(bcs->cs,"tiger read_raw: byte1(%d,%d,%d) rval %x val %x i %x",
 491                                                         bcs->hw.tiger.r_tot,i,j,r_val,val,
 492                                                         bcs->cs->hw.njet.irqstat0);
 493                                 }
 494                         } else if (state ==  HDLC_FRAME_FOUND) {
 495                                 if (val & 1) {
 496                                         r_one++;
 497                                         if (r_one>6) {
 498                                                 state=HDLC_ZERO_SEARCH;
 499                                                 bitcnt=0;
 500                                         } else {
 501                                                 r_val >>= 1;
 502                                                 r_val |= 0x80;
 503                                                 bitcnt++;
 504                                         }
 505                                 } else {
 506                                         if (r_one==6) {
 507                                                 r_val=0;
 508                                                 r_one=0;
 509                                                 bitcnt++;
 510                                                 if (bitcnt & 7) {
 511                                                         debugl1(bcs->cs, "tiger: frame not byte aligned");
 512                                                         state=HDLC_FLAG_SEARCH;
 513                                                         bcs->hw.tiger.r_err++;
 514 #ifdef ERROR_STATISTIC
 515                                                         bcs->err_inv++;
 516 #endif
 517                                                 } else {
 518                                                         if (bcs->cs->debug & L1_DEB_HSCX)
 519                                                                 debugl1(bcs->cs,"tiger frame end(%d,%d): fcs(%x) i %x",
 520                                                                         i,j,bcs->hw.tiger.r_fcs, bcs->cs->hw.njet.irqstat0);
 521                                                         if (bcs->hw.tiger.r_fcs == PPP_GOODFCS) {
 522                                                                 got_frame(bcs, (bitcnt>>3)-3);
 523                                                         } else {
 524                                                                 if (bcs->cs->debug) {
 525                                                                         debugl1(bcs->cs, "tiger FCS error");
 526                                                                         printframe(bcs->cs, bcs->hw.tiger.rcvbuf,
 527                                                                                 (bitcnt>>3)-1, "rec");
 528                                                                         bcs->hw.tiger.r_err++;
 529                                                                 }
 530 #ifdef ERROR_STATISTIC
 531                                                         bcs->err_crc++;
 532 #endif
 533                                                         }
 534                                                         state=HDLC_FLAG_FOUND;
 535                                                 }
 536                                                 bitcnt=0;
 537                                         } else if (r_one==5) {
 538                                                 val >>= 1;
 539                                                 r_one=0;
 540                                                 continue;
 541                                         } else {
 542                                                 r_val >>= 1;
 543                                                 r_val &= 0x7f;
 544                                                 bitcnt++;
 545                                         }
 546                                         r_one=0;
 547                                 }
 548                                 if ((state == HDLC_FRAME_FOUND) &&
 549                                         !(bitcnt & 7)) {
 550                                         if ((bitcnt>>3)>=HSCX_BUFMAX) {
 551                                                 debugl1(bcs->cs, "tiger: frame too big");
 552                                                 r_val=0;
 553                                                 state=HDLC_FLAG_SEARCH;
 554                                                 bcs->hw.tiger.r_err++;
 555 #ifdef ERROR_STATISTIC
 556                                                 bcs->err_inv++;
 557 #endif
 558                                         } else {
 559                                                 bcs->hw.tiger.rcvbuf[(bitcnt>>3)-1] = r_val;
 560                                                 bcs->hw.tiger.r_fcs =
 561                                                         PPP_FCS (bcs->hw.tiger.r_fcs, r_val);
 562                                         }
 563                                 }
 564                         }
 565                         val >>= 1;
 566                 }
 567                 bcs->hw.tiger.r_tot++;
 568         }
 569         bcs->hw.tiger.r_state = state;
 570         bcs->hw.tiger.r_one = r_one;
 571         bcs->hw.tiger.r_val = r_val;
 572         bcs->hw.tiger.r_bitcnt = bitcnt;
 573 }
 574
 575 void read_tiger(struct IsdnCardState *cs) {
 576         u_int *p;
 577         int cnt = NETJET_DMA_RXSIZE/2;
 578
 579         if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_READ) {
 580                 debugl1(cs,"tiger warn read double dma %x/%x",
 581                         cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
 582 #ifdef ERROR_STATISTIC
 583                 if (cs->bcs[0].mode)
 584                         cs->bcs[0].err_rdo++;
 585                 if (cs->bcs[1].mode)
 586                         cs->bcs[1].err_rdo++;
 587 #endif
 588                 return;
 589         } else {
 590                 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_READ;
 591                 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ);
 592         }
 593         if (cs->hw.njet.irqstat0 & NETJET_IRQM0_READ_1)
 594                 p = cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1;
 595         else
 596                 p = cs->bcs[0].hw.tiger.rec + cnt - 1;
 597         if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
 598                 read_raw(cs->bcs, p, cnt);
 599
 600         if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
 601                 read_raw(cs->bcs + 1, p, cnt);
 602         cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_READ;
 603 }
 604
 605 static void write_raw(struct BCState *bcs, u_int *buf, int cnt);
 606
 607 void netjet_fill_dma(struct BCState *bcs)
 608 {
 609         register u_int *p, *sp;
 610         register int cnt;
 611
 612         if (!bcs->tx_skb)
 613                 return;
 614         if (bcs->cs->debug & L1_DEB_HSCX)
 615                 debugl1(bcs->cs,"tiger fill_dma1: c%d %4x", bcs->channel,
 616                         bcs->Flag);
 617         if (test_and_set_bit(BC_FLG_BUSY, &bcs->Flag))
 618                 return;
 619         if (bcs->mode == L1_MODE_HDLC) { // it's 64k
 620                 if (make_raw_data(bcs))
 621                         return;
 622         }
 623         else { // it's 56k
 624                 if (make_raw_data_56k(bcs))
 625                         return;
 626         };
 627         if (bcs->cs->debug & L1_DEB_HSCX)
 628                 debugl1(bcs->cs,"tiger fill_dma2: c%d %4x", bcs->channel,
 629                         bcs->Flag);
 630         if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
 631                 write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
 632         } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
 633                 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
 634                 sp = bcs->hw.tiger.sendp;
 635                 if (p == bcs->hw.tiger.s_end)
 636                         p = bcs->hw.tiger.send -1;
 637                 if (sp == bcs->hw.tiger.s_end)
 638                         sp = bcs->hw.tiger.send -1;
 639                 cnt = p - sp;
 640                 if (cnt <0) {
 641                         write_raw(bcs, bcs->hw.tiger.sendp, bcs->hw.tiger.free);
 642                 } else {
 643                         p++;
 644                         cnt++;
 645                         if (p > bcs->hw.tiger.s_end)
 646                                 p = bcs->hw.tiger.send;
 647                         p++;
 648                         cnt++;
 649                         if (p > bcs->hw.tiger.s_end)
 650                                 p = bcs->hw.tiger.send;
 651                         write_raw(bcs, p, bcs->hw.tiger.free - cnt);
 652                 }
 653         } else if (test_and_clear_bit(BC_FLG_EMPTY, &bcs->Flag)) {
 654                 p = bus_to_virt(inl(bcs->cs->hw.njet.base + NETJET_DMA_READ_ADR));
 655                 cnt = bcs->hw.tiger.s_end - p;
 656                 if (cnt < 2) {
 657                         p = bcs->hw.tiger.send + 1;
 658                         cnt = NETJET_DMA_TXSIZE/2 - 2;
 659                 } else {
 660                         p++;
 661                         p++;
 662                         if (cnt <= (NETJET_DMA_TXSIZE/2))
 663                                 cnt += NETJET_DMA_TXSIZE/2;
 664                         cnt--;
 665                         cnt--;
 666                 }
 667                 write_raw(bcs, p, cnt);
 668         }
 669         if (bcs->cs->debug & L1_DEB_HSCX)
 670                 debugl1(bcs->cs,"tiger fill_dma3: c%d %4x", bcs->channel,
 671                         bcs->Flag);
 672 }
 673
 674 static void write_raw(struct BCState *bcs, u_int *buf, int cnt) {
 675         u_int mask, val, *p=buf;
 676         u_int i, s_cnt;
 677
 678         if (cnt <= 0)
 679                 return;
 680         if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
 681                 if (bcs->hw.tiger.sendcnt> cnt) {
 682                         s_cnt = cnt;
 683                         bcs->hw.tiger.sendcnt -= cnt;
 684                 } else {
 685                         s_cnt = bcs->hw.tiger.sendcnt;
 686                         bcs->hw.tiger.sendcnt = 0;
 687                 }
 688                 if (bcs->channel)
 689                         mask = 0xffff00ff;
 690                 else
 691                         mask = 0xffffff00;
 692                 for (i=0; i<s_cnt; i++) {
 693                         val = bcs->channel ? ((bcs->hw.tiger.sp[i] <<8) & 0xff00) :
 694                                 (bcs->hw.tiger.sp[i]);
 695                         *p   &= mask;
 696                         *p++ |= val;
 697                         if (p>bcs->hw.tiger.s_end)
 698                                 p = bcs->hw.tiger.send;
 699                 }
 700                 bcs->hw.tiger.s_tot += s_cnt;
 701                 if (bcs->cs->debug & L1_DEB_HSCX)
 702                         debugl1(bcs->cs,"tiger write_raw: c%d %p-%p %d/%d %d %x", bcs->channel,
 703                                 buf, p, s_cnt, cnt,
 704                                 bcs->hw.tiger.sendcnt, bcs->cs->hw.njet.irqstat0);
 705                 if (bcs->cs->debug & L1_DEB_HSCX_FIFO)
 706                         printframe(bcs->cs, bcs->hw.tiger.sp, s_cnt, "snd");
 707                 bcs->hw.tiger.sp += s_cnt;
 708                 bcs->hw.tiger.sendp = p;
 709                 if (!bcs->hw.tiger.sendcnt) {
 710                         if (!bcs->tx_skb) {
 711                                 debugl1(bcs->cs,"tiger write_raw: NULL skb s_cnt %d", s_cnt);
 712                         } else {
 713                                 if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag) &&
 714                                         (PACKET_NOACK != bcs->tx_skb->pkt_type)) {
 715                                         u_long  flags;
 716                                         spin_lock_irqsave(&bcs->aclock, flags);
 717                                         bcs->ackcnt += bcs->tx_skb->len;
 718                                         spin_unlock_irqrestore(&bcs->aclock, flags);
 719                                         schedule_event(bcs, B_ACKPENDING);
 720                                 }
 721                                 dev_kfree_skb_any(bcs->tx_skb);
 722                                 bcs->tx_skb = NULL;
 723                         }
 724                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 725                         bcs->hw.tiger.free = cnt - s_cnt;
 726                         if (bcs->hw.tiger.free > (NETJET_DMA_TXSIZE/2))
 727                                 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
 728                         else {
 729                                 test_and_clear_bit(BC_FLG_HALF, &bcs->Flag);
 730                                 test_and_set_bit(BC_FLG_NOFRAME, &bcs->Flag);
 731                         }
 732                         if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
 733                                 netjet_fill_dma(bcs);
 734                         } else {
 735                                 mask ^= 0xffffffff;
 736                                 if (s_cnt < cnt) {
 737                                         for (i=s_cnt; i<cnt;i++) {
 738                                                 *p++ |= mask;
 739                                                 if (p>bcs->hw.tiger.s_end)
 740                                                         p = bcs->hw.tiger.send;
 741                                         }
 742                                         if (bcs->cs->debug & L1_DEB_HSCX)
 743                                                 debugl1(bcs->cs, "tiger write_raw: fill rest %d",
 744                                                         cnt - s_cnt);
 745                                 }
 746                                 test_and_set_bit(B_XMTBUFREADY, &bcs->event);
 747                                 schedule_work(&bcs->tqueue);
 748                         }
 749                 }
 750         } else if (test_and_clear_bit(BC_FLG_NOFRAME, &bcs->Flag)) {
 751                 test_and_set_bit(BC_FLG_HALF, &bcs->Flag);
 752                 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
 753                 bcs->hw.tiger.free += cnt;
 754                 if (bcs->cs->debug & L1_DEB_HSCX)
 755                         debugl1(bcs->cs,"tiger write_raw: fill half");
 756         } else if (test_and_clear_bit(BC_FLG_HALF, &bcs->Flag)) {
 757                 test_and_set_bit(BC_FLG_EMPTY, &bcs->Flag);
 758                 fill_mem(bcs, buf, cnt, bcs->channel, 0xff);
 759                 if (bcs->cs->debug & L1_DEB_HSCX)
 760                         debugl1(bcs->cs,"tiger write_raw: fill full");
 761         }
 762 }
 763
 764 void write_tiger(struct IsdnCardState *cs) {
 765         u_int *p, cnt = NETJET_DMA_TXSIZE/2;
 766
 767         if ((cs->hw.njet.irqstat0 & cs->hw.njet.last_is0) & NETJET_IRQM0_WRITE) {
 768                 debugl1(cs,"tiger warn write double dma %x/%x",
 769                         cs->hw.njet.irqstat0, cs->hw.njet.last_is0);
 770 #ifdef ERROR_STATISTIC
 771                 if (cs->bcs[0].mode)
 772                         cs->bcs[0].err_tx++;
 773                 if (cs->bcs[1].mode)
 774                         cs->bcs[1].err_tx++;
 775 #endif
 776                 return;
 777         } else {
 778                 cs->hw.njet.last_is0 &= ~NETJET_IRQM0_WRITE;
 779                 cs->hw.njet.last_is0 |= (cs->hw.njet.irqstat0 & NETJET_IRQM0_WRITE);
 780         }
 781         if (cs->hw.njet.irqstat0  & NETJET_IRQM0_WRITE_1)
 782                 p = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
 783         else
 784                 p = cs->bcs[0].hw.tiger.send + cnt - 1;
 785         if ((cs->bcs[0].mode == L1_MODE_HDLC) || (cs->bcs[0].mode == L1_MODE_HDLC_56K))
 786                 write_raw(cs->bcs, p, cnt);
 787         if ((cs->bcs[1].mode == L1_MODE_HDLC) || (cs->bcs[1].mode == L1_MODE_HDLC_56K))
 788                 write_raw(cs->bcs + 1, p, cnt);
 789         cs->hw.njet.irqstat0 &= ~NETJET_IRQM0_WRITE;
 790 }
 791
 792 static void
 793 tiger_l2l1(struct PStack *st, int pr, void *arg)
 794 {
 795         struct BCState *bcs = st->l1.bcs;
 796         struct sk_buff *skb = arg;
 797         u_long flags;
 798
 799         switch (pr) {
 800                 case (PH_DATA | REQUEST):
 801                         spin_lock_irqsave(&bcs->cs->lock, flags);
 802                         if (bcs->tx_skb) {
 803                                 skb_queue_tail(&bcs->squeue, skb);
 804                         } else {
 805                                 bcs->tx_skb = skb;
 806                                 bcs->cs->BC_Send_Data(bcs);
 807                         }
 808                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 809                         break;
 810                 case (PH_PULL | INDICATION):
 811                         spin_lock_irqsave(&bcs->cs->lock, flags);
 812                         if (bcs->tx_skb) {
 813                                 printk(KERN_WARNING "tiger_l2l1: this shouldn't happen\n");
 814                         } else {
 815                                 bcs->tx_skb = skb;
 816                                 bcs->cs->BC_Send_Data(bcs);
 817                         }
 818                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 819                         break;
 820                 case (PH_PULL | REQUEST):
 821                         if (!bcs->tx_skb) {
 822                                 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 823                                 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 824                         } else
 825                                 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
 826                         break;
 827                 case (PH_ACTIVATE | REQUEST):
 828                         spin_lock_irqsave(&bcs->cs->lock, flags);
 829                         test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag);
 830                         mode_tiger(bcs, st->l1.mode, st->l1.bc);
 831                         /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
 832                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 833                         bcs->cs->cardmsg(bcs->cs, MDL_BC_ASSIGN, (void *)(&st->l1.bc));
 834                         l1_msg_b(st, pr, arg);
 835                         break;
 836                 case (PH_DEACTIVATE | REQUEST):
 837                         /* 2001/10/04 Christoph Ersfeld, Formula-n Europe AG */
 838                         bcs->cs->cardmsg(bcs->cs, MDL_BC_RELEASE, (void *)(&st->l1.bc));
 839                         l1_msg_b(st, pr, arg);
 840                         break;
 841                 case (PH_DEACTIVATE | CONFIRM):
 842                         spin_lock_irqsave(&bcs->cs->lock, flags);
 843                         test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag);
 844                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 845                         mode_tiger(bcs, 0, st->l1.bc);
 846                         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 847                         st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
 848                         break;
 849         }
 850 }
 851
 852
 853 static void
 854 close_tigerstate(struct BCState *bcs)
 855 {
 856         mode_tiger(bcs, 0, bcs->channel);
 857         if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
 858                 kfree(bcs->hw.tiger.rcvbuf);
 859                 bcs->hw.tiger.rcvbuf = NULL;
 860                 kfree(bcs->hw.tiger.sendbuf);
 861                 bcs->hw.tiger.sendbuf = NULL;
 862                 skb_queue_purge(&bcs->rqueue);
 863                 skb_queue_purge(&bcs->squeue);
 864                 if (bcs->tx_skb) {
 865                         dev_kfree_skb_any(bcs->tx_skb);
 866                         bcs->tx_skb = NULL;
 867                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 868                 }
 869         }
 870 }
 871
 872 static int
 873 open_tigerstate(struct IsdnCardState *cs, struct BCState *bcs)
 874 {
 875         if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
 876                 if (!(bcs->hw.tiger.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
 877                         printk(KERN_WARNING
 878                                "HiSax: No memory for tiger.rcvbuf\n");
 879                         return (1);
 880                 }
 881                 if (!(bcs->hw.tiger.sendbuf = kmalloc(RAW_BUFMAX, GFP_ATOMIC))) {
 882                         printk(KERN_WARNING
 883                                "HiSax: No memory for tiger.sendbuf\n");
 884                         return (1);
 885                 }
 886                 skb_queue_head_init(&bcs->rqueue);
 887                 skb_queue_head_init(&bcs->squeue);
 888         }
 889         bcs->tx_skb = NULL;
 890         bcs->hw.tiger.sendcnt = 0;
 891         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 892         bcs->event = 0;
 893         bcs->tx_cnt = 0;
 894         return (0);
 895 }
 896
 897 static int
 898 setstack_tiger(struct PStack *st, struct BCState *bcs)
 899 {
 900         bcs->channel = st->l1.bc;
 901         if (open_tigerstate(st->l1.hardware, bcs))
 902                 return (-1);
 903         st->l1.bcs = bcs;
 904         st->l2.l2l1 = tiger_l2l1;
 905         setstack_manager(st);
 906         bcs->st = st;
 907         setstack_l1_B(st);
 908         return (0);
 909 }
 910
 911
 912 void __init
 913 inittiger(struct IsdnCardState *cs)
 914 {
 915         if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int),
 916                 GFP_KERNEL | GFP_DMA))) {
 917                 printk(KERN_WARNING
 918                        "HiSax: No memory for tiger.send\n");
 919                 return;
 920         }
 921         cs->bcs[0].hw.tiger.s_irq = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE/2 - 1;
 922         cs->bcs[0].hw.tiger.s_end = cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1;
 923         cs->bcs[1].hw.tiger.send = cs->bcs[0].hw.tiger.send;
 924         cs->bcs[1].hw.tiger.s_irq = cs->bcs[0].hw.tiger.s_irq;
 925         cs->bcs[1].hw.tiger.s_end = cs->bcs[0].hw.tiger.s_end;
 926
 927         memset(cs->bcs[0].hw.tiger.send, 0xff, NETJET_DMA_TXSIZE * sizeof(unsigned int));
 928         debugl1(cs, "tiger: send buf %p - %p", cs->bcs[0].hw.tiger.send,
 929                 cs->bcs[0].hw.tiger.send + NETJET_DMA_TXSIZE - 1);
 930         outl(virt_to_bus(cs->bcs[0].hw.tiger.send),
 931                 cs->hw.njet.base + NETJET_DMA_READ_START);
 932         outl(virt_to_bus(cs->bcs[0].hw.tiger.s_irq),
 933                 cs->hw.njet.base + NETJET_DMA_READ_IRQ);
 934         outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end),
 935                 cs->hw.njet.base + NETJET_DMA_READ_END);
 936         if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int),
 937                 GFP_KERNEL | GFP_DMA))) {
 938                 printk(KERN_WARNING
 939                        "HiSax: No memory for tiger.rec\n");
 940                 return;
 941         }
 942         debugl1(cs, "tiger: rec buf %p - %p", cs->bcs[0].hw.tiger.rec,
 943                 cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1);
 944         cs->bcs[1].hw.tiger.rec = cs->bcs[0].hw.tiger.rec;
 945         memset(cs->bcs[0].hw.tiger.rec, 0xff, NETJET_DMA_RXSIZE * sizeof(unsigned int));
 946         outl(virt_to_bus(cs->bcs[0].hw.tiger.rec),
 947                 cs->hw.njet.base + NETJET_DMA_WRITE_START);
 948         outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE/2 - 1),
 949                 cs->hw.njet.base + NETJET_DMA_WRITE_IRQ);
 950         outl(virt_to_bus(cs->bcs[0].hw.tiger.rec + NETJET_DMA_RXSIZE - 1),
 951                 cs->hw.njet.base + NETJET_DMA_WRITE_END);
 952         debugl1(cs, "tiger: dmacfg  %x/%x  pulse=%d",
 953                 inl(cs->hw.njet.base + NETJET_DMA_WRITE_ADR),
 954                 inl(cs->hw.njet.base + NETJET_DMA_READ_ADR),
 955                 bytein(cs->hw.njet.base + NETJET_PULSE_CNT));
 956         cs->hw.njet.last_is0 = 0;
 957         cs->bcs[0].BC_SetStack = setstack_tiger;
 958         cs->bcs[1].BC_SetStack = setstack_tiger;
 959         cs->bcs[0].BC_Close = close_tigerstate;
 960         cs->bcs[1].BC_Close = close_tigerstate;
 961 }
 962
 963 static void
 964 releasetiger(struct IsdnCardState *cs)
 965 {
 966         kfree(cs->bcs[0].hw.tiger.send);
 967         cs->bcs[0].hw.tiger.send = NULL;
 968         cs->bcs[1].hw.tiger.send = NULL;
 969         kfree(cs->bcs[0].hw.tiger.rec);
 970         cs->bcs[0].hw.tiger.rec = NULL;
 971         cs->bcs[1].hw.tiger.rec = NULL;
 972 }
 973
 974 void
 975 release_io_netjet(struct IsdnCardState *cs)
 976 {
 977         byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
 978         byteout(cs->hw.njet.base + NETJET_IRQMASK1, 0);
 979         releasetiger(cs);
 980         release_region(cs->hw.njet.base, 256);
 981 }
 982