drivers/isdn/hardware/mISDN/mISDNipac.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * isac.c   ISAC specific routines
   4  *
   5  * Author       Karsten Keil <keil@isdn4linux.de>
   6  *
   7  * Copyright 2009  by Karsten Keil <keil@isdn4linux.de>
   8  */
   9
  10 #include <linux/irqreturn.h>
  11 #include <linux/slab.h>
  12 #include <linux/module.h>
  13 #include <linux/mISDNhw.h>
  14 #include "ipac.h"
  15
  16
  17 #define DBUSY_TIMER_VALUE       80
  18 #define ARCOFI_USE              1
  19
  20 #define ISAC_REV                "2.0"
  21
  22 MODULE_AUTHOR("Karsten Keil");
  23 MODULE_VERSION(ISAC_REV);
  24 MODULE_LICENSE("GPL v2");
  25
  26 #define ReadISAC(is, o)         (is->read_reg(is->dch.hw, o + is->off))
  27 #define WriteISAC(is, o, v)     (is->write_reg(is->dch.hw, o + is->off, v))
  28 #define ReadHSCX(h, o)          (h->ip->read_reg(h->ip->hw, h->off + o))
  29 #define WriteHSCX(h, o, v)      (h->ip->write_reg(h->ip->hw, h->off + o, v))
  30 #define ReadIPAC(ip, o)         (ip->read_reg(ip->hw, o))
  31 #define WriteIPAC(ip, o, v)     (ip->write_reg(ip->hw, o, v))
  32
  33 static inline void
  34 ph_command(struct isac_hw *isac, u8 command)
  35 {
  36         pr_debug("%s: ph_command %x\n", isac->name, command);
  37         if (isac->type & IPAC_TYPE_ISACX)
  38                 WriteISAC(isac, ISACX_CIX0, (command << 4) | 0xE);
  39         else
  40                 WriteISAC(isac, ISAC_CIX0, (command << 2) | 3);
  41 }
  42
  43 static void
  44 isac_ph_state_change(struct isac_hw *isac)
  45 {
  46         switch (isac->state) {
  47         case (ISAC_IND_RS):
  48         case (ISAC_IND_EI):
  49                 ph_command(isac, ISAC_CMD_DUI);
  50         }
  51         schedule_event(&isac->dch, FLG_PHCHANGE);
  52 }
  53
  54 static void
  55 isac_ph_state_bh(struct dchannel *dch)
  56 {
  57         struct isac_hw *isac = container_of(dch, struct isac_hw, dch);
  58
  59         switch (isac->state) {
  60         case ISAC_IND_RS:
  61         case ISAC_IND_EI:
  62                 dch->state = 0;
  63                 l1_event(dch->l1, HW_RESET_IND);
  64                 break;
  65         case ISAC_IND_DID:
  66                 dch->state = 3;
  67                 l1_event(dch->l1, HW_DEACT_CNF);
  68                 break;
  69         case ISAC_IND_DR:
  70         case ISAC_IND_DR6:
  71                 dch->state = 3;
  72                 l1_event(dch->l1, HW_DEACT_IND);
  73                 break;
  74         case ISAC_IND_PU:
  75                 dch->state = 4;
  76                 l1_event(dch->l1, HW_POWERUP_IND);
  77                 break;
  78         case ISAC_IND_RSY:
  79                 if (dch->state <= 5) {
  80                         dch->state = 5;
  81                         l1_event(dch->l1, ANYSIGNAL);
  82                 } else {
  83                         dch->state = 8;
  84                         l1_event(dch->l1, LOSTFRAMING);
  85                 }
  86                 break;
  87         case ISAC_IND_ARD:
  88                 dch->state = 6;
  89                 l1_event(dch->l1, INFO2);
  90                 break;
  91         case ISAC_IND_AI8:
  92                 dch->state = 7;
  93                 l1_event(dch->l1, INFO4_P8);
  94                 break;
  95         case ISAC_IND_AI10:
  96                 dch->state = 7;
  97                 l1_event(dch->l1, INFO4_P10);
  98                 break;
  99         }
 100         pr_debug("%s: TE newstate %x\n", isac->name, dch->state);
 101 }
 102
 103 static void
 104 isac_empty_fifo(struct isac_hw *isac, int count)
 105 {
 106         u8 *ptr;
 107
 108         pr_debug("%s: %s  %d\n", isac->name, __func__, count);
 109
 110         if (!isac->dch.rx_skb) {
 111                 isac->dch.rx_skb = mI_alloc_skb(isac->dch.maxlen, GFP_ATOMIC);
 112                 if (!isac->dch.rx_skb) {
 113                         pr_info("%s: D receive out of memory\n", isac->name);
 114                         WriteISAC(isac, ISAC_CMDR, 0x80);
 115                         return;
 116                 }
 117         }
 118         if ((isac->dch.rx_skb->len + count) >= isac->dch.maxlen) {
 119                 pr_debug("%s: %s overrun %d\n", isac->name, __func__,
 120                          isac->dch.rx_skb->len + count);
 121                 WriteISAC(isac, ISAC_CMDR, 0x80);
 122                 return;
 123         }
 124         ptr = skb_put(isac->dch.rx_skb, count);
 125         isac->read_fifo(isac->dch.hw, isac->off, ptr, count);
 126         WriteISAC(isac, ISAC_CMDR, 0x80);
 127         if (isac->dch.debug & DEBUG_HW_DFIFO) {
 128                 char    pfx[MISDN_MAX_IDLEN + 16];
 129
 130                 snprintf(pfx, MISDN_MAX_IDLEN + 15, "D-recv %s %d ",
 131                          isac->name, count);
 132                 print_hex_dump_bytes(pfx, DUMP_PREFIX_OFFSET, ptr, count);
 133         }
 134 }
 135
 136 static void
 137 isac_fill_fifo(struct isac_hw *isac)
 138 {
 139         int count, more;
 140         u8 *ptr;
 141
 142         if (!isac->dch.tx_skb)
 143                 return;
 144         count = isac->dch.tx_skb->len - isac->dch.tx_idx;
 145         if (count <= 0)
 146                 return;
 147
 148         more = 0;
 149         if (count > 32) {
 150                 more = !0;
 151                 count = 32;
 152         }
 153         pr_debug("%s: %s  %d\n", isac->name, __func__, count);
 154         ptr = isac->dch.tx_skb->data + isac->dch.tx_idx;
 155         isac->dch.tx_idx += count;
 156         isac->write_fifo(isac->dch.hw, isac->off, ptr, count);
 157         WriteISAC(isac, ISAC_CMDR, more ? 0x8 : 0xa);
 158         if (test_and_set_bit(FLG_BUSY_TIMER, &isac->dch.Flags)) {
 159                 pr_debug("%s: %s dbusytimer running\n", isac->name, __func__);
 160                 del_timer(&isac->dch.timer);
 161         }
 162         isac->dch.timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
 163         add_timer(&isac->dch.timer);
 164         if (isac->dch.debug & DEBUG_HW_DFIFO) {
 165                 char    pfx[MISDN_MAX_IDLEN + 16];
 166
 167                 snprintf(pfx, MISDN_MAX_IDLEN + 15, "D-send %s %d ",
 168                          isac->name, count);
 169                 print_hex_dump_bytes(pfx, DUMP_PREFIX_OFFSET, ptr, count);
 170         }
 171 }
 172
 173 static void
 174 isac_rme_irq(struct isac_hw *isac)
 175 {
 176         u8 val, count;
 177
 178         val = ReadISAC(isac, ISAC_RSTA);
 179         if ((val & 0x70) != 0x20) {
 180                 if (val & 0x40) {
 181                         pr_debug("%s: ISAC RDO\n", isac->name);
 182 #ifdef ERROR_STATISTIC
 183                         isac->dch.err_rx++;
 184 #endif
 185                 }
 186                 if (!(val & 0x20)) {
 187                         pr_debug("%s: ISAC CRC error\n", isac->name);
 188 #ifdef ERROR_STATISTIC
 189                         isac->dch.err_crc++;
 190 #endif
 191                 }
 192                 WriteISAC(isac, ISAC_CMDR, 0x80);
 193                 dev_kfree_skb(isac->dch.rx_skb);
 194                 isac->dch.rx_skb = NULL;
 195         } else {
 196                 count = ReadISAC(isac, ISAC_RBCL) & 0x1f;
 197                 if (count == 0)
 198                         count = 32;
 199                 isac_empty_fifo(isac, count);
 200                 recv_Dchannel(&isac->dch);
 201         }
 202 }
 203
 204 static void
 205 isac_xpr_irq(struct isac_hw *isac)
 206 {
 207         if (test_and_clear_bit(FLG_BUSY_TIMER, &isac->dch.Flags))
 208                 del_timer(&isac->dch.timer);
 209         if (isac->dch.tx_skb && isac->dch.tx_idx < isac->dch.tx_skb->len) {
 210                 isac_fill_fifo(isac);
 211         } else {
 212                 dev_kfree_skb(isac->dch.tx_skb);
 213                 if (get_next_dframe(&isac->dch))
 214                         isac_fill_fifo(isac);
 215         }
 216 }
 217
 218 static void
 219 isac_retransmit(struct isac_hw *isac)
 220 {
 221         if (test_and_clear_bit(FLG_BUSY_TIMER, &isac->dch.Flags))
 222                 del_timer(&isac->dch.timer);
 223         if (test_bit(FLG_TX_BUSY, &isac->dch.Flags)) {
 224                 /* Restart frame */
 225                 isac->dch.tx_idx = 0;
 226                 isac_fill_fifo(isac);
 227         } else if (isac->dch.tx_skb) { /* should not happen */
 228                 pr_info("%s: tx_skb exist but not busy\n", isac->name);
 229                 test_and_set_bit(FLG_TX_BUSY, &isac->dch.Flags);
 230                 isac->dch.tx_idx = 0;
 231                 isac_fill_fifo(isac);
 232         } else {
 233                 pr_info("%s: ISAC XDU no TX_BUSY\n", isac->name);
 234                 if (get_next_dframe(&isac->dch))
 235                         isac_fill_fifo(isac);
 236         }
 237 }
 238
 239 static void
 240 isac_mos_irq(struct isac_hw *isac)
 241 {
 242         u8 val;
 243         int ret;
 244
 245         val = ReadISAC(isac, ISAC_MOSR);
 246         pr_debug("%s: ISAC MOSR %02x\n", isac->name, val);
 247 #if ARCOFI_USE
 248         if (val & 0x08) {
 249                 if (!isac->mon_rx) {
 250                         isac->mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC);
 251                         if (!isac->mon_rx) {
 252                                 pr_info("%s: ISAC MON RX out of memory!\n",
 253                                         isac->name);
 254                                 isac->mocr &= 0xf0;
 255                                 isac->mocr |= 0x0a;
 256                                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 257                                 goto afterMONR0;
 258                         } else
 259                                 isac->mon_rxp = 0;
 260                 }
 261                 if (isac->mon_rxp >= MAX_MON_FRAME) {
 262                         isac->mocr &= 0xf0;
 263                         isac->mocr |= 0x0a;
 264                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 265                         isac->mon_rxp = 0;
 266                         pr_debug("%s: ISAC MON RX overflow!\n", isac->name);
 267                         goto afterMONR0;
 268                 }
 269                 isac->mon_rx[isac->mon_rxp++] = ReadISAC(isac, ISAC_MOR0);
 270                 pr_debug("%s: ISAC MOR0 %02x\n", isac->name,
 271                          isac->mon_rx[isac->mon_rxp - 1]);
 272                 if (isac->mon_rxp == 1) {
 273                         isac->mocr |= 0x04;
 274                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 275                 }
 276         }
 277 afterMONR0:
 278         if (val & 0x80) {
 279                 if (!isac->mon_rx) {
 280                         isac->mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC);
 281                         if (!isac->mon_rx) {
 282                                 pr_info("%s: ISAC MON RX out of memory!\n",
 283                                         isac->name);
 284                                 isac->mocr &= 0x0f;
 285                                 isac->mocr |= 0xa0;
 286                                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 287                                 goto afterMONR1;
 288                         } else
 289                                 isac->mon_rxp = 0;
 290                 }
 291                 if (isac->mon_rxp >= MAX_MON_FRAME) {
 292                         isac->mocr &= 0x0f;
 293                         isac->mocr |= 0xa0;
 294                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 295                         isac->mon_rxp = 0;
 296                         pr_debug("%s: ISAC MON RX overflow!\n", isac->name);
 297                         goto afterMONR1;
 298                 }
 299                 isac->mon_rx[isac->mon_rxp++] = ReadISAC(isac, ISAC_MOR1);
 300                 pr_debug("%s: ISAC MOR1 %02x\n", isac->name,
 301                          isac->mon_rx[isac->mon_rxp - 1]);
 302                 isac->mocr |= 0x40;
 303                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 304         }
 305 afterMONR1:
 306         if (val & 0x04) {
 307                 isac->mocr &= 0xf0;
 308                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 309                 isac->mocr |= 0x0a;
 310                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 311                 if (isac->monitor) {
 312                         ret = isac->monitor(isac->dch.hw, MONITOR_RX_0,
 313                                             isac->mon_rx, isac->mon_rxp);
 314                         if (ret)
 315                                 kfree(isac->mon_rx);
 316                 } else {
 317                         pr_info("%s: MONITOR 0 received %d but no user\n",
 318                                 isac->name, isac->mon_rxp);
 319                         kfree(isac->mon_rx);
 320                 }
 321                 isac->mon_rx = NULL;
 322                 isac->mon_rxp = 0;
 323         }
 324         if (val & 0x40) {
 325                 isac->mocr &= 0x0f;
 326                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 327                 isac->mocr |= 0xa0;
 328                 WriteISAC(isac, ISAC_MOCR, isac->mocr);
 329                 if (isac->monitor) {
 330                         ret = isac->monitor(isac->dch.hw, MONITOR_RX_1,
 331                                             isac->mon_rx, isac->mon_rxp);
 332                         if (ret)
 333                                 kfree(isac->mon_rx);
 334                 } else {
 335                         pr_info("%s: MONITOR 1 received %d but no user\n",
 336                                 isac->name, isac->mon_rxp);
 337                         kfree(isac->mon_rx);
 338                 }
 339                 isac->mon_rx = NULL;
 340                 isac->mon_rxp = 0;
 341         }
 342         if (val & 0x02) {
 343                 if ((!isac->mon_tx) || (isac->mon_txc &&
 344                                         (isac->mon_txp >= isac->mon_txc) && !(val & 0x08))) {
 345                         isac->mocr &= 0xf0;
 346                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 347                         isac->mocr |= 0x0a;
 348                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 349                         if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
 350                                 if (isac->monitor)
 351                                         isac->monitor(isac->dch.hw,
 352                                                       MONITOR_TX_0, NULL, 0);
 353                         }
 354                         kfree(isac->mon_tx);
 355                         isac->mon_tx = NULL;
 356                         isac->mon_txc = 0;
 357                         isac->mon_txp = 0;
 358                         goto AfterMOX0;
 359                 }
 360                 if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
 361                         if (isac->monitor)
 362                                 isac->monitor(isac->dch.hw,
 363                                               MONITOR_TX_0, NULL, 0);
 364                         kfree(isac->mon_tx);
 365                         isac->mon_tx = NULL;
 366                         isac->mon_txc = 0;
 367                         isac->mon_txp = 0;
 368                         goto AfterMOX0;
 369                 }
 370                 WriteISAC(isac, ISAC_MOX0, isac->mon_tx[isac->mon_txp++]);
 371                 pr_debug("%s: ISAC %02x -> MOX0\n", isac->name,
 372                          isac->mon_tx[isac->mon_txp - 1]);
 373         }
 374 AfterMOX0:
 375         if (val & 0x20) {
 376                 if ((!isac->mon_tx) || (isac->mon_txc &&
 377                                         (isac->mon_txp >= isac->mon_txc) && !(val & 0x80))) {
 378                         isac->mocr &= 0x0f;
 379                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 380                         isac->mocr |= 0xa0;
 381                         WriteISAC(isac, ISAC_MOCR, isac->mocr);
 382                         if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
 383                                 if (isac->monitor)
 384                                         isac->monitor(isac->dch.hw,
 385                                                       MONITOR_TX_1, NULL, 0);
 386                         }
 387                         kfree(isac->mon_tx);
 388                         isac->mon_tx = NULL;
 389                         isac->mon_txc = 0;
 390                         isac->mon_txp = 0;
 391                         goto AfterMOX1;
 392                 }
 393                 if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
 394                         if (isac->monitor)
 395                                 isac->monitor(isac->dch.hw,
 396                                               MONITOR_TX_1, NULL, 0);
 397                         kfree(isac->mon_tx);
 398                         isac->mon_tx = NULL;
 399                         isac->mon_txc = 0;
 400                         isac->mon_txp = 0;
 401                         goto AfterMOX1;
 402                 }
 403                 WriteISAC(isac, ISAC_MOX1, isac->mon_tx[isac->mon_txp++]);
 404                 pr_debug("%s: ISAC %02x -> MOX1\n", isac->name,
 405                          isac->mon_tx[isac->mon_txp - 1]);
 406         }
 407 AfterMOX1:
 408         val = 0; /* dummy to avoid warning */
 409 #endif
 410 }
 411
 412 static void
 413 isac_cisq_irq(struct isac_hw *isac) {
 414         u8 val;
 415
 416         val = ReadISAC(isac, ISAC_CIR0);
 417         pr_debug("%s: ISAC CIR0 %02X\n", isac->name, val);
 418         if (val & 2) {
 419                 pr_debug("%s: ph_state change %x->%x\n", isac->name,
 420                          isac->state, (val >> 2) & 0xf);
 421                 isac->state = (val >> 2) & 0xf;
 422                 isac_ph_state_change(isac);
 423         }
 424         if (val & 1) {
 425                 val = ReadISAC(isac, ISAC_CIR1);
 426                 pr_debug("%s: ISAC CIR1 %02X\n", isac->name, val);
 427         }
 428 }
 429
 430 static void
 431 isacsx_cic_irq(struct isac_hw *isac)
 432 {
 433         u8 val;
 434
 435         val = ReadISAC(isac, ISACX_CIR0);
 436         pr_debug("%s: ISACX CIR0 %02X\n", isac->name, val);
 437         if (val & ISACX_CIR0_CIC0) {
 438                 pr_debug("%s: ph_state change %x->%x\n", isac->name,
 439                          isac->state, val >> 4);
 440                 isac->state = val >> 4;
 441                 isac_ph_state_change(isac);
 442         }
 443 }
 444
 445 static void
 446 isacsx_rme_irq(struct isac_hw *isac)
 447 {
 448         int count;
 449         u8 val;
 450
 451         val = ReadISAC(isac, ISACX_RSTAD);
 452         if ((val & (ISACX_RSTAD_VFR |
 453                     ISACX_RSTAD_RDO |
 454                     ISACX_RSTAD_CRC |
 455                     ISACX_RSTAD_RAB))
 456             != (ISACX_RSTAD_VFR | ISACX_RSTAD_CRC)) {
 457                 pr_debug("%s: RSTAD %#x, dropped\n", isac->name, val);
 458 #ifdef ERROR_STATISTIC
 459                 if (val & ISACX_RSTAD_CRC)
 460                         isac->dch.err_rx++;
 461                 else
 462                         isac->dch.err_crc++;
 463 #endif
 464                 WriteISAC(isac, ISACX_CMDRD, ISACX_CMDRD_RMC);
 465                 dev_kfree_skb(isac->dch.rx_skb);
 466                 isac->dch.rx_skb = NULL;
 467         } else {
 468                 count = ReadISAC(isac, ISACX_RBCLD) & 0x1f;
 469                 if (count == 0)
 470                         count = 32;
 471                 isac_empty_fifo(isac, count);
 472                 if (isac->dch.rx_skb) {
 473                         skb_trim(isac->dch.rx_skb, isac->dch.rx_skb->len - 1);
 474                         pr_debug("%s: dchannel received %d\n", isac->name,
 475                                  isac->dch.rx_skb->len);
 476                         recv_Dchannel(&isac->dch);
 477                 }
 478         }
 479 }
 480
 481 irqreturn_t
 482 mISDNisac_irq(struct isac_hw *isac, u8 val)
 483 {
 484         if (unlikely(!val))
 485                 return IRQ_NONE;
 486         pr_debug("%s: ISAC interrupt %02x\n", isac->name, val);
 487         if (isac->type & IPAC_TYPE_ISACX) {
 488                 if (val & ISACX__CIC)
 489                         isacsx_cic_irq(isac);
 490                 if (val & ISACX__ICD) {
 491                         val = ReadISAC(isac, ISACX_ISTAD);
 492                         pr_debug("%s: ISTAD %02x\n", isac->name, val);
 493                         if (val & ISACX_D_XDU) {
 494                                 pr_debug("%s: ISAC XDU\n", isac->name);
 495 #ifdef ERROR_STATISTIC
 496                                 isac->dch.err_tx++;
 497 #endif
 498                                 isac_retransmit(isac);
 499                         }
 500                         if (val & ISACX_D_XMR) {
 501                                 pr_debug("%s: ISAC XMR\n", isac->name);
 502 #ifdef ERROR_STATISTIC
 503                                 isac->dch.err_tx++;
 504 #endif
 505                                 isac_retransmit(isac);
 506                         }
 507                         if (val & ISACX_D_XPR)
 508                                 isac_xpr_irq(isac);
 509                         if (val & ISACX_D_RFO) {
 510                                 pr_debug("%s: ISAC RFO\n", isac->name);
 511                                 WriteISAC(isac, ISACX_CMDRD, ISACX_CMDRD_RMC);
 512                         }
 513                         if (val & ISACX_D_RME)
 514                                 isacsx_rme_irq(isac);
 515                         if (val & ISACX_D_RPF)
 516                                 isac_empty_fifo(isac, 0x20);
 517                 }
 518         } else {
 519                 if (val & 0x80) /* RME */
 520                         isac_rme_irq(isac);
 521                 if (val & 0x40) /* RPF */
 522                         isac_empty_fifo(isac, 32);
 523                 if (val & 0x10) /* XPR */
 524                         isac_xpr_irq(isac);
 525                 if (val & 0x04) /* CISQ */
 526                         isac_cisq_irq(isac);
 527                 if (val & 0x20) /* RSC - never */
 528                         pr_debug("%s: ISAC RSC interrupt\n", isac->name);
 529                 if (val & 0x02) /* SIN - never */
 530                         pr_debug("%s: ISAC SIN interrupt\n", isac->name);
 531                 if (val & 0x01) {       /* EXI */
 532                         val = ReadISAC(isac, ISAC_EXIR);
 533                         pr_debug("%s: ISAC EXIR %02x\n", isac->name, val);
 534                         if (val & 0x80) /* XMR */
 535                                 pr_debug("%s: ISAC XMR\n", isac->name);
 536                         if (val & 0x40) { /* XDU */
 537                                 pr_debug("%s: ISAC XDU\n", isac->name);
 538 #ifdef ERROR_STATISTIC
 539                                 isac->dch.err_tx++;
 540 #endif
 541                                 isac_retransmit(isac);
 542                         }
 543                         if (val & 0x04) /* MOS */
 544                                 isac_mos_irq(isac);
 545                 }
 546         }
 547         return IRQ_HANDLED;
 548 }
 549 EXPORT_SYMBOL(mISDNisac_irq);
 550
 551 static int
 552 isac_l1hw(struct mISDNchannel *ch, struct sk_buff *skb)
 553 {
 554         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
 555         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
 556         struct isac_hw          *isac = container_of(dch, struct isac_hw, dch);
 557         int                     ret = -EINVAL;
 558         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
 559         u32                     id;
 560         u_long                  flags;
 561
 562         switch (hh->prim) {
 563         case PH_DATA_REQ:
 564                 spin_lock_irqsave(isac->hwlock, flags);
 565                 ret = dchannel_senddata(dch, skb);
 566                 if (ret > 0) { /* direct TX */
 567                         id = hh->id; /* skb can be freed */
 568                         isac_fill_fifo(isac);
 569                         ret = 0;
 570                         spin_unlock_irqrestore(isac->hwlock, flags);
 571                         queue_ch_frame(ch, PH_DATA_CNF, id, NULL);
 572                 } else
 573                         spin_unlock_irqrestore(isac->hwlock, flags);
 574                 return ret;
 575         case PH_ACTIVATE_REQ:
 576                 ret = l1_event(dch->l1, hh->prim);
 577                 break;
 578         case PH_DEACTIVATE_REQ:
 579                 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
 580                 ret = l1_event(dch->l1, hh->prim);
 581                 break;
 582         }
 583
 584         if (!ret)
 585                 dev_kfree_skb(skb);
 586         return ret;
 587 }
 588
 589 static int
 590 isac_ctrl(struct isac_hw *isac, u32 cmd, unsigned long para)
 591 {
 592         u8 tl = 0;
 593         unsigned long flags;
 594         int ret = 0;
 595
 596         switch (cmd) {
 597         case HW_TESTLOOP:
 598                 spin_lock_irqsave(isac->hwlock, flags);
 599                 if (!(isac->type & IPAC_TYPE_ISACX)) {
 600                         /* TODO: implement for IPAC_TYPE_ISACX */
 601                         if (para & 1) /* B1 */
 602                                 tl |= 0x0c;
 603                         else if (para & 2) /* B2 */
 604                                 tl |= 0x3;
 605                         /* we only support IOM2 mode */
 606                         WriteISAC(isac, ISAC_SPCR, tl);
 607                         if (tl)
 608                                 WriteISAC(isac, ISAC_ADF1, 0x8);
 609                         else
 610                                 WriteISAC(isac, ISAC_ADF1, 0x0);
 611                 }
 612                 spin_unlock_irqrestore(isac->hwlock, flags);
 613                 break;
 614         case HW_TIMER3_VALUE:
 615                 ret = l1_event(isac->dch.l1, HW_TIMER3_VALUE | (para & 0xff));
 616                 break;
 617         default:
 618                 pr_debug("%s: %s unknown command %x %lx\n", isac->name,
 619                          __func__, cmd, para);
 620                 ret = -1;
 621         }
 622         return ret;
 623 }
 624
 625 static int
 626 isac_l1cmd(struct dchannel *dch, u32 cmd)
 627 {
 628         struct isac_hw *isac = container_of(dch, struct isac_hw, dch);
 629         u_long flags;
 630
 631         pr_debug("%s: cmd(%x) state(%02x)\n", isac->name, cmd, isac->state);
 632         switch (cmd) {
 633         case INFO3_P8:
 634                 spin_lock_irqsave(isac->hwlock, flags);
 635                 ph_command(isac, ISAC_CMD_AR8);
 636                 spin_unlock_irqrestore(isac->hwlock, flags);
 637                 break;
 638         case INFO3_P10:
 639                 spin_lock_irqsave(isac->hwlock, flags);
 640                 ph_command(isac, ISAC_CMD_AR10);
 641                 spin_unlock_irqrestore(isac->hwlock, flags);
 642                 break;
 643         case HW_RESET_REQ:
 644                 spin_lock_irqsave(isac->hwlock, flags);
 645                 if ((isac->state == ISAC_IND_EI) ||
 646                     (isac->state == ISAC_IND_DR) ||
 647                     (isac->state == ISAC_IND_DR6) ||
 648                     (isac->state == ISAC_IND_RS))
 649                         ph_command(isac, ISAC_CMD_TIM);
 650                 else
 651                         ph_command(isac, ISAC_CMD_RS);
 652                 spin_unlock_irqrestore(isac->hwlock, flags);
 653                 break;
 654         case HW_DEACT_REQ:
 655                 skb_queue_purge(&dch->squeue);
 656                 if (dch->tx_skb) {
 657                         dev_kfree_skb(dch->tx_skb);
 658                         dch->tx_skb = NULL;
 659                 }
 660                 dch->tx_idx = 0;
 661                 if (dch->rx_skb) {
 662                         dev_kfree_skb(dch->rx_skb);
 663                         dch->rx_skb = NULL;
 664                 }
 665                 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
 666                 if (test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags))
 667                         del_timer(&dch->timer);
 668                 break;
 669         case HW_POWERUP_REQ:
 670                 spin_lock_irqsave(isac->hwlock, flags);
 671                 ph_command(isac, ISAC_CMD_TIM);
 672                 spin_unlock_irqrestore(isac->hwlock, flags);
 673                 break;
 674         case PH_ACTIVATE_IND:
 675                 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
 676                 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
 677                             GFP_ATOMIC);
 678                 break;
 679         case PH_DEACTIVATE_IND:
 680                 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
 681                 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
 682                             GFP_ATOMIC);
 683                 break;
 684         default:
 685                 pr_debug("%s: %s unknown command %x\n", isac->name,
 686                          __func__, cmd);
 687                 return -1;
 688         }
 689         return 0;
 690 }
 691
 692 static void
 693 isac_release(struct isac_hw *isac)
 694 {
 695         if (isac->type & IPAC_TYPE_ISACX)
 696                 WriteISAC(isac, ISACX_MASK, 0xff);
 697         else if (isac->type != 0)
 698                 WriteISAC(isac, ISAC_MASK, 0xff);
 699         if (isac->dch.timer.function != NULL) {
 700                 del_timer(&isac->dch.timer);
 701                 isac->dch.timer.function = NULL;
 702         }
 703         kfree(isac->mon_rx);
 704         isac->mon_rx = NULL;
 705         kfree(isac->mon_tx);
 706         isac->mon_tx = NULL;
 707         if (isac->dch.l1)
 708                 l1_event(isac->dch.l1, CLOSE_CHANNEL);
 709         mISDN_freedchannel(&isac->dch);
 710 }
 711
 712 static void
 713 dbusy_timer_handler(struct timer_list *t)
 714 {
 715         struct isac_hw *isac = from_timer(isac, t, dch.timer);
 716         int rbch, star;
 717         u_long flags;
 718
 719         if (test_bit(FLG_BUSY_TIMER, &isac->dch.Flags)) {
 720                 spin_lock_irqsave(isac->hwlock, flags);
 721                 rbch = ReadISAC(isac, ISAC_RBCH);
 722                 star = ReadISAC(isac, ISAC_STAR);
 723                 pr_debug("%s: D-Channel Busy RBCH %02x STAR %02x\n",
 724                          isac->name, rbch, star);
 725                 if (rbch & ISAC_RBCH_XAC) /* D-Channel Busy */
 726                         test_and_set_bit(FLG_L1_BUSY, &isac->dch.Flags);
 727                 else {
 728                         /* discard frame; reset transceiver */
 729                         test_and_clear_bit(FLG_BUSY_TIMER, &isac->dch.Flags);
 730                         if (isac->dch.tx_idx)
 731                                 isac->dch.tx_idx = 0;
 732                         else
 733                                 pr_info("%s: ISAC D-Channel Busy no tx_idx\n",
 734                                         isac->name);
 735                         /* Transmitter reset */
 736                         WriteISAC(isac, ISAC_CMDR, 0x01);
 737                 }
 738                 spin_unlock_irqrestore(isac->hwlock, flags);
 739         }
 740 }
 741
 742 static int
 743 open_dchannel_caller(struct isac_hw *isac, struct channel_req *rq, void *caller)
 744 {
 745         pr_debug("%s: %s dev(%d) open from %p\n", isac->name, __func__,
 746                  isac->dch.dev.id, caller);
 747         if (rq->protocol != ISDN_P_TE_S0)
 748                 return -EINVAL;
 749         if (rq->adr.channel == 1)
 750                 /* E-Channel not supported */
 751                 return -EINVAL;
 752         rq->ch = &isac->dch.dev.D;
 753         rq->ch->protocol = rq->protocol;
 754         if (isac->dch.state == 7)
 755                 _queue_data(rq->ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
 756                             0, NULL, GFP_KERNEL);
 757         return 0;
 758 }
 759
 760 static int
 761 open_dchannel(struct isac_hw *isac, struct channel_req *rq)
 762 {
 763         return open_dchannel_caller(isac, rq, __builtin_return_address(0));
 764 }
 765
 766 static const char *ISACVer[] =
 767 {"2086/2186 V1.1", "2085 B1", "2085 B2",
 768  "2085 V2.3"};
 769
 770 static int
 771 isac_init(struct isac_hw *isac)
 772 {
 773         u8 val;
 774         int err = 0;
 775
 776         if (!isac->dch.l1) {
 777                 err = create_l1(&isac->dch, isac_l1cmd);
 778                 if (err)
 779                         return err;
 780         }
 781         isac->mon_tx = NULL;
 782         isac->mon_rx = NULL;
 783         timer_setup(&isac->dch.timer, dbusy_timer_handler, 0);
 784         isac->mocr = 0xaa;
 785         if (isac->type & IPAC_TYPE_ISACX) {
 786                 /* Disable all IRQ */
 787                 WriteISAC(isac, ISACX_MASK, 0xff);
 788                 val = ReadISAC(isac, ISACX_STARD);
 789                 pr_debug("%s: ISACX STARD %x\n", isac->name, val);
 790                 val = ReadISAC(isac, ISACX_ISTAD);
 791                 pr_debug("%s: ISACX ISTAD %x\n", isac->name, val);
 792                 val = ReadISAC(isac, ISACX_ISTA);
 793                 pr_debug("%s: ISACX ISTA %x\n", isac->name, val);
 794                 /* clear LDD */
 795                 WriteISAC(isac, ISACX_TR_CONF0, 0x00);
 796                 /* enable transmitter */
 797                 WriteISAC(isac, ISACX_TR_CONF2, 0x00);
 798                 /* transparent mode 0, RAC, stop/go */
 799                 WriteISAC(isac, ISACX_MODED, 0xc9);
 800                 /* all HDLC IRQ unmasked */
 801                 val = ReadISAC(isac, ISACX_ID);
 802                 if (isac->dch.debug & DEBUG_HW)
 803                         pr_notice("%s: ISACX Design ID %x\n",
 804                                   isac->name, val & 0x3f);
 805                 val = ReadISAC(isac, ISACX_CIR0);
 806                 pr_debug("%s: ISACX CIR0 %02X\n", isac->name, val);
 807                 isac->state = val >> 4;
 808                 isac_ph_state_change(isac);
 809                 ph_command(isac, ISAC_CMD_RS);
 810                 WriteISAC(isac, ISACX_MASK, IPACX__ON);
 811                 WriteISAC(isac, ISACX_MASKD, 0x00);
 812         } else { /* old isac */
 813                 WriteISAC(isac, ISAC_MASK, 0xff);
 814                 val = ReadISAC(isac, ISAC_STAR);
 815                 pr_debug("%s: ISAC STAR %x\n", isac->name, val);
 816                 val = ReadISAC(isac, ISAC_MODE);
 817                 pr_debug("%s: ISAC MODE %x\n", isac->name, val);
 818                 val = ReadISAC(isac, ISAC_ADF2);
 819                 pr_debug("%s: ISAC ADF2 %x\n", isac->name, val);
 820                 val = ReadISAC(isac, ISAC_ISTA);
 821                 pr_debug("%s: ISAC ISTA %x\n", isac->name, val);
 822                 if (val & 0x01) {
 823                         val = ReadISAC(isac, ISAC_EXIR);
 824                         pr_debug("%s: ISAC EXIR %x\n", isac->name, val);
 825                 }
 826                 val = ReadISAC(isac, ISAC_RBCH);
 827                 if (isac->dch.debug & DEBUG_HW)
 828                         pr_notice("%s: ISAC version (%x): %s\n", isac->name,
 829                                   val, ISACVer[(val >> 5) & 3]);
 830                 isac->type |= ((val >> 5) & 3);
 831                 if (!isac->adf2)
 832                         isac->adf2 = 0x80;
 833                 if (!(isac->adf2 & 0x80)) { /* only IOM 2 Mode */
 834                         pr_info("%s: only support IOM2 mode but adf2=%02x\n",
 835                                 isac->name, isac->adf2);
 836                         isac_release(isac);
 837                         return -EINVAL;
 838                 }
 839                 WriteISAC(isac, ISAC_ADF2, isac->adf2);
 840                 WriteISAC(isac, ISAC_SQXR, 0x2f);
 841                 WriteISAC(isac, ISAC_SPCR, 0x00);
 842                 WriteISAC(isac, ISAC_STCR, 0x70);
 843                 WriteISAC(isac, ISAC_MODE, 0xc9);
 844                 WriteISAC(isac, ISAC_TIMR, 0x00);
 845                 WriteISAC(isac, ISAC_ADF1, 0x00);
 846                 val = ReadISAC(isac, ISAC_CIR0);
 847                 pr_debug("%s: ISAC CIR0 %x\n", isac->name, val);
 848                 isac->state = (val >> 2) & 0xf;
 849                 isac_ph_state_change(isac);
 850                 ph_command(isac, ISAC_CMD_RS);
 851                 WriteISAC(isac, ISAC_MASK, 0);
 852         }
 853         return err;
 854 }
 855
 856 int
 857 mISDNisac_init(struct isac_hw *isac, void *hw)
 858 {
 859         mISDN_initdchannel(&isac->dch, MAX_DFRAME_LEN_L1, isac_ph_state_bh);
 860         isac->dch.hw = hw;
 861         isac->dch.dev.D.send = isac_l1hw;
 862         isac->init = isac_init;
 863         isac->release = isac_release;
 864         isac->ctrl = isac_ctrl;
 865         isac->open = open_dchannel;
 866         isac->dch.dev.Dprotocols = (1 << ISDN_P_TE_S0);
 867         isac->dch.dev.nrbchan = 2;
 868         return 0;
 869 }
 870 EXPORT_SYMBOL(mISDNisac_init);
 871
 872 static void
 873 waitforCEC(struct hscx_hw *hx)
 874 {
 875         u8 starb, to = 50;
 876
 877         while (to) {
 878                 starb = ReadHSCX(hx, IPAC_STARB);
 879                 if (!(starb & 0x04))
 880                         break;
 881                 udelay(1);
 882                 to--;
 883         }
 884         if (to < 50)
 885                 pr_debug("%s: B%1d CEC %d us\n", hx->ip->name, hx->bch.nr,
 886                          50 - to);
 887         if (!to)
 888                 pr_info("%s: B%1d CEC timeout\n", hx->ip->name, hx->bch.nr);
 889 }
 890
 891
 892 static void
 893 waitforXFW(struct hscx_hw *hx)
 894 {
 895         u8 starb, to = 50;
 896
 897         while (to) {
 898                 starb = ReadHSCX(hx, IPAC_STARB);
 899                 if ((starb & 0x44) == 0x40)
 900                         break;
 901                 udelay(1);
 902                 to--;
 903         }
 904         if (to < 50)
 905                 pr_debug("%s: B%1d XFW %d us\n", hx->ip->name, hx->bch.nr,
 906                          50 - to);
 907         if (!to)
 908                 pr_info("%s: B%1d XFW timeout\n", hx->ip->name, hx->bch.nr);
 909 }
 910
 911 static void
 912 hscx_cmdr(struct hscx_hw *hx, u8 cmd)
 913 {
 914         if (hx->ip->type & IPAC_TYPE_IPACX)
 915                 WriteHSCX(hx, IPACX_CMDRB, cmd);
 916         else {
 917                 waitforCEC(hx);
 918                 WriteHSCX(hx, IPAC_CMDRB, cmd);
 919         }
 920 }
 921
 922 static void
 923 hscx_empty_fifo(struct hscx_hw *hscx, u8 count)
 924 {
 925         u8 *p;
 926         int maxlen;
 927
 928         pr_debug("%s: B%1d %d\n", hscx->ip->name, hscx->bch.nr, count);
 929         if (test_bit(FLG_RX_OFF, &hscx->bch.Flags)) {
 930                 hscx->bch.dropcnt += count;
 931                 hscx_cmdr(hscx, 0x80); /* RMC */
 932                 return;
 933         }
 934         maxlen = bchannel_get_rxbuf(&hscx->bch, count);
 935         if (maxlen < 0) {
 936                 hscx_cmdr(hscx, 0x80); /* RMC */
 937                 if (hscx->bch.rx_skb)
 938                         skb_trim(hscx->bch.rx_skb, 0);
 939                 pr_warn("%s.B%d: No bufferspace for %d bytes\n",
 940                         hscx->ip->name, hscx->bch.nr, count);
 941                 return;
 942         }
 943         p = skb_put(hscx->bch.rx_skb, count);
 944
 945         if (hscx->ip->type & IPAC_TYPE_IPACX)
 946                 hscx->ip->read_fifo(hscx->ip->hw,
 947                                     hscx->off + IPACX_RFIFOB, p, count);
 948         else
 949                 hscx->ip->read_fifo(hscx->ip->hw,
 950                                     hscx->off, p, count);
 951
 952         hscx_cmdr(hscx, 0x80); /* RMC */
 953
 954         if (hscx->bch.debug & DEBUG_HW_BFIFO) {
 955                 snprintf(hscx->log, 64, "B%1d-recv %s %d ",
 956                          hscx->bch.nr, hscx->ip->name, count);
 957                 print_hex_dump_bytes(hscx->log, DUMP_PREFIX_OFFSET, p, count);
 958         }
 959 }
 960
 961 static void
 962 hscx_fill_fifo(struct hscx_hw *hscx)
 963 {
 964         int count, more;
 965         u8 *p;
 966
 967         if (!hscx->bch.tx_skb) {
 968                 if (!test_bit(FLG_TX_EMPTY, &hscx->bch.Flags))
 969                         return;
 970                 count = hscx->fifo_size;
 971                 more = 1;
 972                 p = hscx->log;
 973                 memset(p, hscx->bch.fill[0], count);
 974         } else {
 975                 count = hscx->bch.tx_skb->len - hscx->bch.tx_idx;
 976                 if (count <= 0)
 977                         return;
 978                 p = hscx->bch.tx_skb->data + hscx->bch.tx_idx;
 979
 980                 more = test_bit(FLG_TRANSPARENT, &hscx->bch.Flags) ? 1 : 0;
 981                 if (count > hscx->fifo_size) {
 982                         count = hscx->fifo_size;
 983                         more = 1;
 984                 }
 985                 pr_debug("%s: B%1d %d/%d/%d\n", hscx->ip->name, hscx->bch.nr,
 986                          count, hscx->bch.tx_idx, hscx->bch.tx_skb->len);
 987                 hscx->bch.tx_idx += count;
 988         }
 989         if (hscx->ip->type & IPAC_TYPE_IPACX)
 990                 hscx->ip->write_fifo(hscx->ip->hw,
 991                                      hscx->off + IPACX_XFIFOB, p, count);
 992         else {
 993                 waitforXFW(hscx);
 994                 hscx->ip->write_fifo(hscx->ip->hw,
 995                                      hscx->off, p, count);
 996         }
 997         hscx_cmdr(hscx, more ? 0x08 : 0x0a);
 998
 999         if (hscx->bch.tx_skb && (hscx->bch.debug & DEBUG_HW_BFIFO)) {
1000                 snprintf(hscx->log, 64, "B%1d-send %s %d ",
1001                          hscx->bch.nr, hscx->ip->name, count);
1002                 print_hex_dump_bytes(hscx->log, DUMP_PREFIX_OFFSET, p, count);
1003         }
1004 }
1005
1006 static void
1007 hscx_xpr(struct hscx_hw *hx)
1008 {
1009         if (hx->bch.tx_skb && hx->bch.tx_idx < hx->bch.tx_skb->len) {
1010                 hscx_fill_fifo(hx);
1011         } else {
1012                 dev_kfree_skb(hx->bch.tx_skb);
1013                 if (get_next_bframe(&hx->bch)) {
1014                         hscx_fill_fifo(hx);
1015                         test_and_clear_bit(FLG_TX_EMPTY, &hx->bch.Flags);
1016                 } else if (test_bit(FLG_TX_EMPTY, &hx->bch.Flags)) {
1017                         hscx_fill_fifo(hx);
1018                 }
1019         }
1020 }
1021
1022 static void
1023 ipac_rme(struct hscx_hw *hx)
1024 {
1025         int count;
1026         u8 rstab;
1027
1028         if (hx->ip->type & IPAC_TYPE_IPACX)
1029                 rstab = ReadHSCX(hx, IPACX_RSTAB);
1030         else
1031                 rstab = ReadHSCX(hx, IPAC_RSTAB);
1032         pr_debug("%s: B%1d RSTAB %02x\n", hx->ip->name, hx->bch.nr, rstab);
1033         if ((rstab & 0xf0) != 0xa0) {
1034                 /* !(VFR && !RDO && CRC && !RAB) */
1035                 if (!(rstab & 0x80)) {
1036                         if (hx->bch.debug & DEBUG_HW_BCHANNEL)
1037                                 pr_notice("%s: B%1d invalid frame\n",
1038                                           hx->ip->name, hx->bch.nr);
1039                 }
1040                 if (rstab & 0x40) {
1041                         if (hx->bch.debug & DEBUG_HW_BCHANNEL)
1042                                 pr_notice("%s: B%1d RDO proto=%x\n",
1043                                           hx->ip->name, hx->bch.nr,
1044                                           hx->bch.state);
1045                 }
1046                 if (!(rstab & 0x20)) {
1047                         if (hx->bch.debug & DEBUG_HW_BCHANNEL)
1048                                 pr_notice("%s: B%1d CRC error\n",
1049                                           hx->ip->name, hx->bch.nr);
1050                 }
1051                 hscx_cmdr(hx, 0x80); /* Do RMC */
1052                 return;
1053         }
1054         if (hx->ip->type & IPAC_TYPE_IPACX)
1055                 count = ReadHSCX(hx, IPACX_RBCLB);
1056         else
1057                 count = ReadHSCX(hx, IPAC_RBCLB);
1058         count &= (hx->fifo_size - 1);
1059         if (count == 0)
1060                 count = hx->fifo_size;
1061         hscx_empty_fifo(hx, count);
1062         if (!hx->bch.rx_skb)
1063                 return;
1064         if (hx->bch.rx_skb->len < 2) {
1065                 pr_debug("%s: B%1d frame to short %d\n",
1066                          hx->ip->name, hx->bch.nr, hx->bch.rx_skb->len);
1067                 skb_trim(hx->bch.rx_skb, 0);
1068         } else {
1069                 skb_trim(hx->bch.rx_skb, hx->bch.rx_skb->len - 1);
1070                 recv_Bchannel(&hx->bch, 0, false);
1071         }
1072 }
1073
1074 static void
1075 ipac_irq(struct hscx_hw *hx, u8 ista)
1076 {
1077         u8 istab, m, exirb = 0;
1078
1079         if (hx->ip->type & IPAC_TYPE_IPACX)
1080                 istab = ReadHSCX(hx, IPACX_ISTAB);
1081         else if (hx->ip->type & IPAC_TYPE_IPAC) {
1082                 istab = ReadHSCX(hx, IPAC_ISTAB);
1083                 m = (hx->bch.nr & 1) ? IPAC__EXA : IPAC__EXB;
1084                 if (m & ista) {
1085                         exirb = ReadHSCX(hx, IPAC_EXIRB);
1086                         pr_debug("%s: B%1d EXIRB %02x\n", hx->ip->name,
1087                                  hx->bch.nr, exirb);
1088                 }
1089         } else if (hx->bch.nr & 2) { /* HSCX B */
1090                 if (ista & (HSCX__EXA | HSCX__ICA))
1091                         ipac_irq(&hx->ip->hscx[0], ista);
1092                 if (ista & HSCX__EXB) {
1093                         exirb = ReadHSCX(hx, IPAC_EXIRB);
1094                         pr_debug("%s: B%1d EXIRB %02x\n", hx->ip->name,
1095                                  hx->bch.nr, exirb);
1096                 }
1097                 istab = ista & 0xF8;
1098         } else { /* HSCX A */
1099                 istab = ReadHSCX(hx, IPAC_ISTAB);
1100                 if (ista & HSCX__EXA) {
1101                         exirb = ReadHSCX(hx, IPAC_EXIRB);
1102                         pr_debug("%s: B%1d EXIRB %02x\n", hx->ip->name,
1103                                  hx->bch.nr, exirb);
1104                 }
1105                 istab = istab & 0xF8;
1106         }
1107         if (exirb & IPAC_B_XDU)
1108                 istab |= IPACX_B_XDU;
1109         if (exirb & IPAC_B_RFO)
1110                 istab |= IPACX_B_RFO;
1111         pr_debug("%s: B%1d ISTAB %02x\n", hx->ip->name, hx->bch.nr, istab);
1112
1113         if (!test_bit(FLG_ACTIVE, &hx->bch.Flags))
1114                 return;
1115
1116         if (istab & IPACX_B_RME)
1117                 ipac_rme(hx);
1118
1119         if (istab & IPACX_B_RPF) {
1120                 hscx_empty_fifo(hx, hx->fifo_size);
1121                 if (test_bit(FLG_TRANSPARENT, &hx->bch.Flags))
1122                         recv_Bchannel(&hx->bch, 0, false);
1123         }
1124
1125         if (istab & IPACX_B_RFO) {
1126                 pr_debug("%s: B%1d RFO error\n", hx->ip->name, hx->bch.nr);
1127                 hscx_cmdr(hx, 0x40);    /* RRES */
1128         }
1129
1130         if (istab & IPACX_B_XPR)
1131                 hscx_xpr(hx);
1132
1133         if (istab & IPACX_B_XDU) {
1134                 if (test_bit(FLG_TRANSPARENT, &hx->bch.Flags)) {
1135                         if (test_bit(FLG_FILLEMPTY, &hx->bch.Flags))
1136                                 test_and_set_bit(FLG_TX_EMPTY, &hx->bch.Flags);
1137                         hscx_xpr(hx);
1138                         return;
1139                 }
1140                 pr_debug("%s: B%1d XDU error at len %d\n", hx->ip->name,
1141                          hx->bch.nr, hx->bch.tx_idx);
1142                 hx->bch.tx_idx = 0;
1143                 hscx_cmdr(hx, 0x01);    /* XRES */
1144         }
1145 }
1146
1147 irqreturn_t
1148 mISDNipac_irq(struct ipac_hw *ipac, int maxloop)
1149 {
1150         int cnt = maxloop + 1;
1151         u8 ista, istad;
1152         struct isac_hw  *isac = &ipac->isac;
1153
1154         if (ipac->type & IPAC_TYPE_IPACX) {
1155                 ista = ReadIPAC(ipac, ISACX_ISTA);
1156                 while (ista && --cnt) {
1157                         pr_debug("%s: ISTA %02x\n", ipac->name, ista);
1158                         if (ista & IPACX__ICA)
1159                                 ipac_irq(&ipac->hscx[0], ista);
1160                         if (ista & IPACX__ICB)
1161                                 ipac_irq(&ipac->hscx[1], ista);
1162                         if (ista & (ISACX__ICD | ISACX__CIC))
1163                                 mISDNisac_irq(&ipac->isac, ista);
1164                         ista = ReadIPAC(ipac, ISACX_ISTA);
1165                 }
1166         } else if (ipac->type & IPAC_TYPE_IPAC) {
1167                 ista = ReadIPAC(ipac, IPAC_ISTA);
1168                 while (ista && --cnt) {
1169                         pr_debug("%s: ISTA %02x\n", ipac->name, ista);
1170                         if (ista & (IPAC__ICD | IPAC__EXD)) {
1171                                 istad = ReadISAC(isac, ISAC_ISTA);
1172                                 pr_debug("%s: ISTAD %02x\n", ipac->name, istad);
1173                                 if (istad & IPAC_D_TIN2)
1174                                         pr_debug("%s TIN2 irq\n", ipac->name);
1175                                 if (ista & IPAC__EXD)
1176                                         istad |= 1; /* ISAC EXI */
1177                                 mISDNisac_irq(isac, istad);
1178                         }
1179                         if (ista & (IPAC__ICA | IPAC__EXA))
1180                                 ipac_irq(&ipac->hscx[0], ista);
1181                         if (ista & (IPAC__ICB | IPAC__EXB))
1182                                 ipac_irq(&ipac->hscx[1], ista);
1183                         ista = ReadIPAC(ipac, IPAC_ISTA);
1184                 }
1185         } else if (ipac->type & IPAC_TYPE_HSCX) {
1186                 while (--cnt) {
1187                         ista = ReadIPAC(ipac, IPAC_ISTAB + ipac->hscx[1].off);
1188                         pr_debug("%s: B2 ISTA %02x\n", ipac->name, ista);
1189                         if (ista)
1190                                 ipac_irq(&ipac->hscx[1], ista);
1191                         istad = ReadISAC(isac, ISAC_ISTA);
1192                         pr_debug("%s: ISTAD %02x\n", ipac->name, istad);
1193                         if (istad)
1194                                 mISDNisac_irq(isac, istad);
1195                         if (0 == (ista | istad))
1196                                 break;
1197                 }
1198         }
1199         if (cnt > maxloop) /* only for ISAC/HSCX without PCI IRQ test */
1200                 return IRQ_NONE;
1201         if (cnt < maxloop)
1202                 pr_debug("%s: %d irqloops cpu%d\n", ipac->name,
1203                          maxloop - cnt, smp_processor_id());
1204         if (maxloop && !cnt)
1205                 pr_notice("%s: %d IRQ LOOP cpu%d\n", ipac->name,
1206                           maxloop, smp_processor_id());
1207         return IRQ_HANDLED;
1208 }
1209 EXPORT_SYMBOL(mISDNipac_irq);
1210
1211 static int
1212 hscx_mode(struct hscx_hw *hscx, u32 bprotocol)
1213 {
1214         pr_debug("%s: HSCX %c protocol %x-->%x ch %d\n", hscx->ip->name,
1215                  '@' + hscx->bch.nr, hscx->bch.state, bprotocol, hscx->bch.nr);
1216         if (hscx->ip->type & IPAC_TYPE_IPACX) {
1217                 if (hscx->bch.nr & 1) { /* B1 and ICA */
1218                         WriteIPAC(hscx->ip, ISACX_BCHA_TSDP_BC1, 0x80);
1219                         WriteIPAC(hscx->ip, ISACX_BCHA_CR, 0x88);
1220                 } else { /* B2 and ICB */
1221                         WriteIPAC(hscx->ip, ISACX_BCHB_TSDP_BC1, 0x81);
1222                         WriteIPAC(hscx->ip, ISACX_BCHB_CR, 0x88);
1223                 }
1224                 switch (bprotocol) {
1225                 case ISDN_P_NONE: /* init */
1226                         WriteHSCX(hscx, IPACX_MODEB, 0xC0);     /* rec off */
1227                         WriteHSCX(hscx, IPACX_EXMB,  0x30);     /* std adj. */
1228                         WriteHSCX(hscx, IPACX_MASKB, 0xFF);     /* ints off */
1229                         hscx_cmdr(hscx, 0x41);
1230                         test_and_clear_bit(FLG_HDLC, &hscx->bch.Flags);
1231                         test_and_clear_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1232                         break;
1233                 case ISDN_P_B_RAW:
1234                         WriteHSCX(hscx, IPACX_MODEB, 0x88);     /* ex trans */
1235                         WriteHSCX(hscx, IPACX_EXMB,  0x00);     /* trans */
1236                         hscx_cmdr(hscx, 0x41);
1237                         WriteHSCX(hscx, IPACX_MASKB, IPACX_B_ON);
1238                         test_and_set_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1239                         break;
1240                 case ISDN_P_B_HDLC:
1241                         WriteHSCX(hscx, IPACX_MODEB, 0xC0);     /* trans */
1242                         WriteHSCX(hscx, IPACX_EXMB,  0x00);     /* hdlc,crc */
1243                         hscx_cmdr(hscx, 0x41);
1244                         WriteHSCX(hscx, IPACX_MASKB, IPACX_B_ON);
1245                         test_and_set_bit(FLG_HDLC, &hscx->bch.Flags);
1246                         break;
1247                 default:
1248                         pr_info("%s: protocol not known %x\n", hscx->ip->name,
1249                                 bprotocol);
1250                         return -ENOPROTOOPT;
1251                 }
1252         } else if (hscx->ip->type & IPAC_TYPE_IPAC) { /* IPAC */
1253                 WriteHSCX(hscx, IPAC_CCR1, 0x82);
1254                 WriteHSCX(hscx, IPAC_CCR2, 0x30);
1255                 WriteHSCX(hscx, IPAC_XCCR, 0x07);
1256                 WriteHSCX(hscx, IPAC_RCCR, 0x07);
1257                 WriteHSCX(hscx, IPAC_TSAX, hscx->slot);
1258                 WriteHSCX(hscx, IPAC_TSAR, hscx->slot);
1259                 switch (bprotocol) {
1260                 case ISDN_P_NONE:
1261                         WriteHSCX(hscx, IPAC_TSAX, 0x1F);
1262                         WriteHSCX(hscx, IPAC_TSAR, 0x1F);
1263                         WriteHSCX(hscx, IPAC_MODEB, 0x84);
1264                         WriteHSCX(hscx, IPAC_CCR1, 0x82);
1265                         WriteHSCX(hscx, IPAC_MASKB, 0xFF);      /* ints off */
1266                         test_and_clear_bit(FLG_HDLC, &hscx->bch.Flags);
1267                         test_and_clear_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1268                         break;
1269                 case ISDN_P_B_RAW:
1270                         WriteHSCX(hscx, IPAC_MODEB, 0xe4);      /* ex trans */
1271                         WriteHSCX(hscx, IPAC_CCR1, 0x82);
1272                         hscx_cmdr(hscx, 0x41);
1273                         WriteHSCX(hscx, IPAC_MASKB, 0);
1274                         test_and_set_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1275                         break;
1276                 case ISDN_P_B_HDLC:
1277                         WriteHSCX(hscx, IPAC_MODEB, 0x8c);
1278                         WriteHSCX(hscx, IPAC_CCR1, 0x8a);
1279                         hscx_cmdr(hscx, 0x41);
1280                         WriteHSCX(hscx, IPAC_MASKB, 0);
1281                         test_and_set_bit(FLG_HDLC, &hscx->bch.Flags);
1282                         break;
1283                 default:
1284                         pr_info("%s: protocol not known %x\n", hscx->ip->name,
1285                                 bprotocol);
1286                         return -ENOPROTOOPT;
1287                 }
1288         } else if (hscx->ip->type & IPAC_TYPE_HSCX) { /* HSCX */
1289                 WriteHSCX(hscx, IPAC_CCR1, 0x85);
1290                 WriteHSCX(hscx, IPAC_CCR2, 0x30);
1291                 WriteHSCX(hscx, IPAC_XCCR, 0x07);
1292                 WriteHSCX(hscx, IPAC_RCCR, 0x07);
1293                 WriteHSCX(hscx, IPAC_TSAX, hscx->slot);
1294                 WriteHSCX(hscx, IPAC_TSAR, hscx->slot);
1295                 switch (bprotocol) {
1296                 case ISDN_P_NONE:
1297                         WriteHSCX(hscx, IPAC_TSAX, 0x1F);
1298                         WriteHSCX(hscx, IPAC_TSAR, 0x1F);
1299                         WriteHSCX(hscx, IPAC_MODEB, 0x84);
1300                         WriteHSCX(hscx, IPAC_CCR1, 0x85);
1301                         WriteHSCX(hscx, IPAC_MASKB, 0xFF);      /* ints off */
1302                         test_and_clear_bit(FLG_HDLC, &hscx->bch.Flags);
1303                         test_and_clear_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1304                         break;
1305                 case ISDN_P_B_RAW:
1306                         WriteHSCX(hscx, IPAC_MODEB, 0xe4);      /* ex trans */
1307                         WriteHSCX(hscx, IPAC_CCR1, 0x85);
1308                         hscx_cmdr(hscx, 0x41);
1309                         WriteHSCX(hscx, IPAC_MASKB, 0);
1310                         test_and_set_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1311                         break;
1312                 case ISDN_P_B_HDLC:
1313                         WriteHSCX(hscx, IPAC_MODEB, 0x8c);
1314                         WriteHSCX(hscx, IPAC_CCR1, 0x8d);
1315                         hscx_cmdr(hscx, 0x41);
1316                         WriteHSCX(hscx, IPAC_MASKB, 0);
1317                         test_and_set_bit(FLG_HDLC, &hscx->bch.Flags);
1318                         break;
1319                 default:
1320                         pr_info("%s: protocol not known %x\n", hscx->ip->name,
1321                                 bprotocol);
1322                         return -ENOPROTOOPT;
1323                 }
1324         } else
1325                 return -EINVAL;
1326         hscx->bch.state = bprotocol;
1327         return 0;
1328 }
1329
1330 static int
1331 hscx_l2l1(struct mISDNchannel *ch, struct sk_buff *skb)
1332 {
1333         struct bchannel *bch = container_of(ch, struct bchannel, ch);
1334         struct hscx_hw  *hx = container_of(bch, struct hscx_hw, bch);
1335         int ret = -EINVAL;
1336         struct mISDNhead *hh = mISDN_HEAD_P(skb);
1337         unsigned long flags;
1338
1339         switch (hh->prim) {
1340         case PH_DATA_REQ:
1341                 spin_lock_irqsave(hx->ip->hwlock, flags);
1342                 ret = bchannel_senddata(bch, skb);
1343                 if (ret > 0) { /* direct TX */
1344                         ret = 0;
1345                         hscx_fill_fifo(hx);
1346                 }
1347                 spin_unlock_irqrestore(hx->ip->hwlock, flags);
1348                 return ret;
1349         case PH_ACTIVATE_REQ:
1350                 spin_lock_irqsave(hx->ip->hwlock, flags);
1351                 if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags))
1352                         ret = hscx_mode(hx, ch->protocol);
1353                 else
1354                         ret = 0;
1355                 spin_unlock_irqrestore(hx->ip->hwlock, flags);
1356                 if (!ret)
1357                         _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
1358                                     NULL, GFP_KERNEL);
1359                 break;
1360         case PH_DEACTIVATE_REQ:
1361                 spin_lock_irqsave(hx->ip->hwlock, flags);
1362                 mISDN_clear_bchannel(bch);
1363                 hscx_mode(hx, ISDN_P_NONE);
1364                 spin_unlock_irqrestore(hx->ip->hwlock, flags);
1365                 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
1366                             NULL, GFP_KERNEL);
1367                 ret = 0;
1368                 break;
1369         default:
1370                 pr_info("%s: %s unknown prim(%x,%x)\n",
1371                         hx->ip->name, __func__, hh->prim, hh->id);
1372                 ret = -EINVAL;
1373         }
1374         if (!ret)
1375                 dev_kfree_skb(skb);
1376         return ret;
1377 }
1378
1379 static int
1380 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1381 {
1382         return mISDN_ctrl_bchannel(bch, cq);
1383 }
1384
1385 static int
1386 hscx_bctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
1387 {
1388         struct bchannel *bch = container_of(ch, struct bchannel, ch);
1389         struct hscx_hw  *hx = container_of(bch, struct hscx_hw, bch);
1390         int ret = -EINVAL;
1391         u_long flags;
1392
1393         pr_debug("%s: %s cmd:%x %p\n", hx->ip->name, __func__, cmd, arg);
1394         switch (cmd) {
1395         case CLOSE_CHANNEL:
1396                 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1397                 cancel_work_sync(&bch->workq);
1398                 spin_lock_irqsave(hx->ip->hwlock, flags);
1399                 mISDN_clear_bchannel(bch);
1400                 hscx_mode(hx, ISDN_P_NONE);
1401                 spin_unlock_irqrestore(hx->ip->hwlock, flags);
1402                 ch->protocol = ISDN_P_NONE;
1403                 ch->peer = NULL;
1404                 module_put(hx->ip->owner);
1405                 ret = 0;
1406                 break;
1407         case CONTROL_CHANNEL:
1408                 ret = channel_bctrl(bch, arg);
1409                 break;
1410         default:
1411                 pr_info("%s: %s unknown prim(%x)\n",
1412                         hx->ip->name, __func__, cmd);
1413         }
1414         return ret;
1415 }
1416
1417 static void
1418 free_ipac(struct ipac_hw *ipac)
1419 {
1420         isac_release(&ipac->isac);
1421 }
1422
1423 static const char *HSCXVer[] =
1424 {"A1", "?1", "A2", "?3", "A3", "V2.1", "?6", "?7",
1425  "?8", "?9", "?10", "?11", "?12", "?13", "?14", "???"};
1426
1427
1428
1429 static void
1430 hscx_init(struct hscx_hw *hx)
1431 {
1432         u8 val;
1433
1434         WriteHSCX(hx, IPAC_RAH2, 0xFF);
1435         WriteHSCX(hx, IPAC_XBCH, 0x00);
1436         WriteHSCX(hx, IPAC_RLCR, 0x00);
1437
1438         if (hx->ip->type & IPAC_TYPE_HSCX) {
1439                 WriteHSCX(hx, IPAC_CCR1, 0x85);
1440                 val = ReadHSCX(hx, HSCX_VSTR);
1441                 pr_debug("%s: HSCX VSTR %02x\n", hx->ip->name, val);
1442                 if (hx->bch.debug & DEBUG_HW)
1443                         pr_notice("%s: HSCX version %s\n", hx->ip->name,
1444                                   HSCXVer[val & 0x0f]);
1445         } else
1446                 WriteHSCX(hx, IPAC_CCR1, 0x82);
1447         WriteHSCX(hx, IPAC_CCR2, 0x30);
1448         WriteHSCX(hx, IPAC_XCCR, 0x07);
1449         WriteHSCX(hx, IPAC_RCCR, 0x07);
1450 }
1451
1452 static int
1453 ipac_init(struct ipac_hw *ipac)
1454 {
1455         u8 val;
1456
1457         if (ipac->type & IPAC_TYPE_HSCX) {
1458                 hscx_init(&ipac->hscx[0]);
1459                 hscx_init(&ipac->hscx[1]);
1460                 val = ReadIPAC(ipac, IPAC_ID);
1461         } else if (ipac->type & IPAC_TYPE_IPAC) {
1462                 hscx_init(&ipac->hscx[0]);
1463                 hscx_init(&ipac->hscx[1]);
1464                 WriteIPAC(ipac, IPAC_MASK, IPAC__ON);
1465                 val = ReadIPAC(ipac, IPAC_CONF);
1466                 /* conf is default 0, but can be overwritten by card setup */
1467                 pr_debug("%s: IPAC CONF %02x/%02x\n", ipac->name,
1468                          val, ipac->conf);
1469                 WriteIPAC(ipac, IPAC_CONF, ipac->conf);
1470                 val = ReadIPAC(ipac, IPAC_ID);
1471                 if (ipac->hscx[0].bch.debug & DEBUG_HW)
1472                         pr_notice("%s: IPAC Design ID %02x\n", ipac->name, val);
1473         }
1474         /* nothing special for IPACX to do here */
1475         return isac_init(&ipac->isac);
1476 }
1477
1478 static int
1479 open_bchannel(struct ipac_hw *ipac, struct channel_req *rq)
1480 {
1481         struct bchannel         *bch;
1482
1483         if (rq->adr.channel == 0 || rq->adr.channel > 2)
1484                 return -EINVAL;
1485         if (rq->protocol == ISDN_P_NONE)
1486                 return -EINVAL;
1487         bch = &ipac->hscx[rq->adr.channel - 1].bch;
1488         if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1489                 return -EBUSY; /* b-channel can be only open once */
1490         test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
1491         bch->ch.protocol = rq->protocol;
1492         rq->ch = &bch->ch;
1493         return 0;
1494 }
1495
1496 static int
1497 channel_ctrl(struct ipac_hw *ipac, struct mISDN_ctrl_req *cq)
1498 {
1499         int     ret = 0;
1500
1501         switch (cq->op) {
1502         case MISDN_CTRL_GETOP:
1503                 cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
1504                 break;
1505         case MISDN_CTRL_LOOP:
1506                 /* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
1507                 if (cq->channel < 0 || cq->channel > 3) {
1508                         ret = -EINVAL;
1509                         break;
1510                 }
1511                 ret = ipac->ctrl(ipac, HW_TESTLOOP, cq->channel);
1512                 break;
1513         case MISDN_CTRL_L1_TIMER3:
1514                 ret = ipac->isac.ctrl(&ipac->isac, HW_TIMER3_VALUE, cq->p1);
1515                 break;
1516         default:
1517                 pr_info("%s: unknown CTRL OP %x\n", ipac->name, cq->op);
1518                 ret = -EINVAL;
1519                 break;
1520         }
1521         return ret;
1522 }
1523
1524 static int
1525 ipac_dctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
1526 {
1527         struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
1528         struct dchannel *dch = container_of(dev, struct dchannel, dev);
1529         struct isac_hw *isac = container_of(dch, struct isac_hw, dch);
1530         struct ipac_hw *ipac = container_of(isac, struct ipac_hw, isac);
1531         struct channel_req *rq;
1532         int err = 0;
1533
1534         pr_debug("%s: DCTRL: %x %p\n", ipac->name, cmd, arg);
1535         switch (cmd) {
1536         case OPEN_CHANNEL:
1537                 rq = arg;
1538                 if (rq->protocol == ISDN_P_TE_S0)
1539                         err = open_dchannel_caller(isac, rq, __builtin_return_address(0));
1540                 else
1541                         err = open_bchannel(ipac, rq);
1542                 if (err)
1543                         break;
1544                 if (!try_module_get(ipac->owner))
1545                         pr_info("%s: cannot get module\n", ipac->name);
1546                 break;
1547         case CLOSE_CHANNEL:
1548                 pr_debug("%s: dev(%d) close from %p\n", ipac->name,
1549                          dch->dev.id, __builtin_return_address(0));
1550                 module_put(ipac->owner);
1551                 break;
1552         case CONTROL_CHANNEL:
1553                 err = channel_ctrl(ipac, arg);
1554                 break;
1555         default:
1556                 pr_debug("%s: unknown DCTRL command %x\n", ipac->name, cmd);
1557                 return -EINVAL;
1558         }
1559         return err;
1560 }
1561
1562 u32
1563 mISDNipac_init(struct ipac_hw *ipac, void *hw)
1564 {
1565         u32 ret;
1566         u8 i;
1567
1568         ipac->hw = hw;
1569         if (ipac->isac.dch.debug & DEBUG_HW)
1570                 pr_notice("%s: ipac type %x\n", ipac->name, ipac->type);
1571         if (ipac->type & IPAC_TYPE_HSCX) {
1572                 ipac->isac.type = IPAC_TYPE_ISAC;
1573                 ipac->hscx[0].off = 0;
1574                 ipac->hscx[1].off = 0x40;
1575                 ipac->hscx[0].fifo_size = 32;
1576                 ipac->hscx[1].fifo_size = 32;
1577         } else if (ipac->type & IPAC_TYPE_IPAC) {
1578                 ipac->isac.type = IPAC_TYPE_IPAC | IPAC_TYPE_ISAC;
1579                 ipac->hscx[0].off = 0;
1580                 ipac->hscx[1].off = 0x40;
1581                 ipac->hscx[0].fifo_size = 64;
1582                 ipac->hscx[1].fifo_size = 64;
1583         } else if (ipac->type & IPAC_TYPE_IPACX) {
1584                 ipac->isac.type = IPAC_TYPE_IPACX | IPAC_TYPE_ISACX;
1585                 ipac->hscx[0].off = IPACX_OFF_ICA;
1586                 ipac->hscx[1].off = IPACX_OFF_ICB;
1587                 ipac->hscx[0].fifo_size = 64;
1588                 ipac->hscx[1].fifo_size = 64;
1589         } else
1590                 return 0;
1591
1592         mISDNisac_init(&ipac->isac, hw);
1593
1594         ipac->isac.dch.dev.D.ctrl = ipac_dctrl;
1595
1596         for (i = 0; i < 2; i++) {
1597                 ipac->hscx[i].bch.nr = i + 1;
1598                 set_channelmap(i + 1, ipac->isac.dch.dev.channelmap);
1599                 list_add(&ipac->hscx[i].bch.ch.list,
1600                          &ipac->isac.dch.dev.bchannels);
1601                 mISDN_initbchannel(&ipac->hscx[i].bch, MAX_DATA_MEM,
1602                                    ipac->hscx[i].fifo_size);
1603                 ipac->hscx[i].bch.ch.nr = i + 1;
1604                 ipac->hscx[i].bch.ch.send = &hscx_l2l1;
1605                 ipac->hscx[i].bch.ch.ctrl = hscx_bctrl;
1606                 ipac->hscx[i].bch.hw = hw;
1607                 ipac->hscx[i].ip = ipac;
1608                 /* default values for IOM time slots
1609                  * can be overwritten by card */
1610                 ipac->hscx[i].slot = (i == 0) ? 0x2f : 0x03;
1611         }
1612
1613         ipac->init = ipac_init;
1614         ipac->release = free_ipac;
1615
1616         ret =   (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1617                 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1618         return ret;
1619 }
1620 EXPORT_SYMBOL(mISDNipac_init);
1621
1622 static int __init
1623 isac_mod_init(void)
1624 {
1625         pr_notice("mISDNipac module version %s\n", ISAC_REV);
1626         return 0;
1627 }
1628
1629 static void __exit
1630 isac_mod_cleanup(void)
1631 {
1632         pr_notice("mISDNipac module unloaded\n");
1633 }
1634 module_init(isac_mod_init);
1635 module_exit(isac_mod_cleanup);