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 too 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); 1636