drivers/isdn/hisax/hscx_irq.c

   1 /* $Id: hscx_irq.c,v 1.18.2.3 2004/02/11 13:21:34 keil Exp $
   2  *
   3  * low level b-channel stuff for Siemens HSCX
   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  * This is an include file for fast inline IRQ stuff
  12  *
  13  */
  14
  15
  16 static inline void
  17 waitforCEC(struct IsdnCardState *cs, int hscx)
  18 {
  19         int to = 50;
  20
  21         while ((READHSCX(cs, hscx, HSCX_STAR) & 0x04) && to) {
  22                 udelay(1);
  23                 to--;
  24         }
  25         if (!to)
  26                 printk(KERN_WARNING "HiSax: waitforCEC timeout\n");
  27 }
  28
  29
  30 static inline void
  31 waitforXFW(struct IsdnCardState *cs, int hscx)
  32 {
  33         int to = 50;
  34
  35         while ((!(READHSCX(cs, hscx, HSCX_STAR) & 0x44) == 0x40) && to) {
  36                 udelay(1);
  37                 to--;
  38         }
  39         if (!to)
  40                 printk(KERN_WARNING "HiSax: waitforXFW timeout\n");
  41 }
  42
  43 static inline void
  44 WriteHSCXCMDR(struct IsdnCardState *cs, int hscx, u_char data)
  45 {
  46         waitforCEC(cs, hscx);
  47         WRITEHSCX(cs, hscx, HSCX_CMDR, data);
  48 }
  49
  50
  51
  52 static void
  53 hscx_empty_fifo(struct BCState *bcs, int count)
  54 {
  55         u_char *ptr;
  56         struct IsdnCardState *cs = bcs->cs;
  57
  58         if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  59                 debugl1(cs, "hscx_empty_fifo");
  60
  61         if (bcs->hw.hscx.rcvidx + count > HSCX_BUFMAX) {
  62                 if (cs->debug & L1_DEB_WARN)
  63                         debugl1(cs, "hscx_empty_fifo: incoming packet too large");
  64                 WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 0x80);
  65                 bcs->hw.hscx.rcvidx = 0;
  66                 return;
  67         }
  68         ptr = bcs->hw.hscx.rcvbuf + bcs->hw.hscx.rcvidx;
  69         bcs->hw.hscx.rcvidx += count;
  70         READHSCXFIFO(cs, bcs->hw.hscx.hscx, ptr, count);
  71         WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 0x80);
  72         if (cs->debug & L1_DEB_HSCX_FIFO) {
  73                 char *t = bcs->blog;
  74
  75                 t += sprintf(t, "hscx_empty_fifo %c cnt %d",
  76                              bcs->hw.hscx.hscx ? 'B' : 'A', count);
  77                 QuickHex(t, ptr, count);
  78                 debugl1(cs, bcs->blog);
  79         }
  80 }
  81
  82 static void
  83 hscx_fill_fifo(struct BCState *bcs)
  84 {
  85         struct IsdnCardState *cs = bcs->cs;
  86         int more, count;
  87         int fifo_size = test_bit(HW_IPAC, &cs->HW_Flags)? 64: 32;
  88         u_char *ptr;
  89
  90         if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  91                 debugl1(cs, "hscx_fill_fifo");
  92
  93         if (!bcs->tx_skb)
  94                 return;
  95         if (bcs->tx_skb->len <= 0)
  96                 return;
  97
  98         more = (bcs->mode == L1_MODE_TRANS) ? 1 : 0;
  99         if (bcs->tx_skb->len > fifo_size) {
 100                 more = !0;
 101                 count = fifo_size;
 102         } else
 103                 count = bcs->tx_skb->len;
 104
 105         waitforXFW(cs, bcs->hw.hscx.hscx);
 106         ptr = bcs->tx_skb->data;
 107         skb_pull(bcs->tx_skb, count);
 108         bcs->tx_cnt -= count;
 109         bcs->hw.hscx.count += count;
 110         WRITEHSCXFIFO(cs, bcs->hw.hscx.hscx, ptr, count);
 111         WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, more ? 0x8 : 0xa);
 112         if (cs->debug & L1_DEB_HSCX_FIFO) {
 113                 char *t = bcs->blog;
 114
 115                 t += sprintf(t, "hscx_fill_fifo %c cnt %d",
 116                              bcs->hw.hscx.hscx ? 'B' : 'A', count);
 117                 QuickHex(t, ptr, count);
 118                 debugl1(cs, bcs->blog);
 119         }
 120 }
 121
 122 static void
 123 hscx_interrupt(struct IsdnCardState *cs, u_char val, u_char hscx)
 124 {
 125         u_char r;
 126         struct BCState *bcs = cs->bcs + hscx;
 127         struct sk_buff *skb;
 128         int fifo_size = test_bit(HW_IPAC, &cs->HW_Flags)? 64: 32;
 129         int count;
 130
 131         if (!test_bit(BC_FLG_INIT, &bcs->Flag))
 132                 return;
 133
 134         if (val & 0x80) {       /* RME */
 135                 r = READHSCX(cs, hscx, HSCX_RSTA);
 136                 if ((r & 0xf0) != 0xa0) {
 137                         if (!(r & 0x80)) {
 138                                 if (cs->debug & L1_DEB_WARN)
 139                                         debugl1(cs, "HSCX invalid frame");
 140 #ifdef ERROR_STATISTIC
 141                                 bcs->err_inv++;
 142 #endif
 143                         }
 144                         if ((r & 0x40) && bcs->mode) {
 145                                 if (cs->debug & L1_DEB_WARN)
 146                                         debugl1(cs, "HSCX RDO mode=%d",
 147                                                 bcs->mode);
 148 #ifdef ERROR_STATISTIC
 149                                 bcs->err_rdo++;
 150 #endif
 151                         }
 152                         if (!(r & 0x20)) {
 153                                 if (cs->debug & L1_DEB_WARN)
 154                                         debugl1(cs, "HSCX CRC error");
 155 #ifdef ERROR_STATISTIC
 156                                 bcs->err_crc++;
 157 #endif
 158                         }
 159                         WriteHSCXCMDR(cs, hscx, 0x80);
 160                 } else {
 161                         count = READHSCX(cs, hscx, HSCX_RBCL) & (
 162                                 test_bit(HW_IPAC, &cs->HW_Flags)? 0x3f: 0x1f);
 163                         if (count == 0)
 164                                 count = fifo_size;
 165                         hscx_empty_fifo(bcs, count);
 166                         if ((count = bcs->hw.hscx.rcvidx - 1) > 0) {
 167                                 if (cs->debug & L1_DEB_HSCX_FIFO)
 168                                         debugl1(cs, "HX Frame %d", count);
 169                                 if (!(skb = dev_alloc_skb(count)))
 170                                         printk(KERN_WARNING "HSCX: receive out of memory\n");
 171                                 else {
 172                                         memcpy(skb_put(skb, count), bcs->hw.hscx.rcvbuf, count);
 173                                         skb_queue_tail(&bcs->rqueue, skb);
 174                                 }
 175                         }
 176                 }
 177                 bcs->hw.hscx.rcvidx = 0;
 178                 schedule_event(bcs, B_RCVBUFREADY);
 179         }
 180         if (val & 0x40) {       /* RPF */
 181                 hscx_empty_fifo(bcs, fifo_size);
 182                 if (bcs->mode == L1_MODE_TRANS) {
 183                         /* receive audio data */
 184                         if (!(skb = dev_alloc_skb(fifo_size)))
 185                                 printk(KERN_WARNING "HiSax: receive out of memory\n");
 186                         else {
 187                                 memcpy(skb_put(skb, fifo_size), bcs->hw.hscx.rcvbuf, fifo_size);
 188                                 skb_queue_tail(&bcs->rqueue, skb);
 189                         }
 190                         bcs->hw.hscx.rcvidx = 0;
 191                         schedule_event(bcs, B_RCVBUFREADY);
 192                 }
 193         }
 194         if (val & 0x10) {       /* XPR */
 195                 if (bcs->tx_skb) {
 196                         if (bcs->tx_skb->len) {
 197                                 hscx_fill_fifo(bcs);
 198                                 return;
 199                         } else {
 200                                 if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag) &&
 201                                         (PACKET_NOACK != bcs->tx_skb->pkt_type)) {
 202                                         u_long  flags;
 203                                         spin_lock_irqsave(&bcs->aclock, flags);
 204                                         bcs->ackcnt += bcs->hw.hscx.count;
 205                                         spin_unlock_irqrestore(&bcs->aclock, flags);
 206                                         schedule_event(bcs, B_ACKPENDING);
 207                                 }
 208                                 dev_kfree_skb_irq(bcs->tx_skb);
 209                                 bcs->hw.hscx.count = 0;
 210                                 bcs->tx_skb = NULL;
 211                         }
 212                 }
 213                 if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
 214                         bcs->hw.hscx.count = 0;
 215                         test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
 216                         hscx_fill_fifo(bcs);
 217                 } else {
 218                         test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 219                         schedule_event(bcs, B_XMTBUFREADY);
 220                 }
 221         }
 222 }
 223
 224 static void
 225 hscx_int_main(struct IsdnCardState *cs, u_char val)
 226 {
 227
 228         u_char exval;
 229         struct BCState *bcs;
 230
 231         if (val & 0x01) {
 232                 bcs = cs->bcs + 1;
 233                 exval = READHSCX(cs, 1, HSCX_EXIR);
 234                 if (exval & 0x40) {
 235                         if (bcs->mode == 1)
 236                                 hscx_fill_fifo(bcs);
 237                         else {
 238 #ifdef ERROR_STATISTIC
 239                                 bcs->err_tx++;
 240 #endif
 241                                 /* Here we lost an TX interrupt, so
 242                                    * restart transmitting the whole frame.
 243                                  */
 244                                 if (bcs->tx_skb) {
 245                                         skb_push(bcs->tx_skb, bcs->hw.hscx.count);
 246                                         bcs->tx_cnt += bcs->hw.hscx.count;
 247                                         bcs->hw.hscx.count = 0;
 248                                 }
 249                                 WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 0x01);
 250                                 if (cs->debug & L1_DEB_WARN)
 251                                         debugl1(cs, "HSCX B EXIR %x Lost TX", exval);
 252                         }
 253                 } else if (cs->debug & L1_DEB_HSCX)
 254                         debugl1(cs, "HSCX B EXIR %x", exval);
 255         }
 256         if (val & 0xf8) {
 257                 if (cs->debug & L1_DEB_HSCX)
 258                         debugl1(cs, "HSCX B interrupt %x", val);
 259                 hscx_interrupt(cs, val, 1);
 260         }
 261         if (val & 0x02) {
 262                 bcs = cs->bcs;
 263                 exval = READHSCX(cs, 0, HSCX_EXIR);
 264                 if (exval & 0x40) {
 265                         if (bcs->mode == L1_MODE_TRANS)
 266                                 hscx_fill_fifo(bcs);
 267                         else {
 268                                 /* Here we lost an TX interrupt, so
 269                                    * restart transmitting the whole frame.
 270                                  */
 271 #ifdef ERROR_STATISTIC
 272                                 bcs->err_tx++;
 273 #endif
 274                                 if (bcs->tx_skb) {
 275                                         skb_push(bcs->tx_skb, bcs->hw.hscx.count);
 276                                         bcs->tx_cnt += bcs->hw.hscx.count;
 277                                         bcs->hw.hscx.count = 0;
 278                                 }
 279                                 WriteHSCXCMDR(cs, bcs->hw.hscx.hscx, 0x01);
 280                                 if (cs->debug & L1_DEB_WARN)
 281                                         debugl1(cs, "HSCX A EXIR %x Lost TX", exval);
 282                         }
 283                 } else if (cs->debug & L1_DEB_HSCX)
 284                         debugl1(cs, "HSCX A EXIR %x", exval);
 285         }
 286         if (val & 0x04) {
 287                 exval = READHSCX(cs, 0, HSCX_ISTA);
 288                 if (cs->debug & L1_DEB_HSCX)
 289                         debugl1(cs, "HSCX A interrupt %x", exval);
 290                 hscx_interrupt(cs, exval, 0);
 291         }
 292 }