1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * mISDNisar.c ISAR (Siemens PSB 7110) specific functions 4 * 5 * Author Karsten Keil (keil@isdn4linux.de) 6 * 7 * Copyright 2009 by Karsten Keil <keil@isdn4linux.de> 8 */ 9 10 /* define this to enable static debug messages, if you kernel supports 11 * dynamic debugging, you should use debugfs for this 12 */ 13 /* #define DEBUG */ 14 15 #include <linux/gfp.h> 16 #include <linux/delay.h> 17 #include <linux/vmalloc.h> 18 #include <linux/mISDNhw.h> 19 #include <linux/module.h> 20 #include "isar.h" 21 22 #define ISAR_REV "2.1" 23 24 MODULE_AUTHOR("Karsten Keil"); 25 MODULE_LICENSE("GPL v2"); 26 MODULE_VERSION(ISAR_REV); 27 28 #define DEBUG_HW_FIRMWARE_FIFO 0x10000 29 30 static const u8 faxmodulation[] = {3, 24, 48, 72, 73, 74, 96, 97, 98, 121, 31 122, 145, 146}; 32 #define FAXMODCNT 13 33 34 static void isar_setup(struct isar_hw *); 35 36 static inline int 37 waitforHIA(struct isar_hw *isar, int timeout) 38 { 39 int t = timeout; 40 u8 val = isar->read_reg(isar->hw, ISAR_HIA); 41 42 while ((val & 1) && t) { 43 udelay(1); 44 t--; 45 val = isar->read_reg(isar->hw, ISAR_HIA); 46 } 47 pr_debug("%s: HIA after %dus\n", isar->name, timeout - t); 48 return timeout; 49 } 50 51 /* 52 * send msg to ISAR mailbox 53 * if msg is NULL use isar->buf 54 */ 55 static int 56 send_mbox(struct isar_hw *isar, u8 his, u8 creg, u8 len, u8 *msg) 57 { 58 if (!waitforHIA(isar, 1000)) 59 return 0; 60 pr_debug("send_mbox(%02x,%02x,%d)\n", his, creg, len); 61 isar->write_reg(isar->hw, ISAR_CTRL_H, creg); 62 isar->write_reg(isar->hw, ISAR_CTRL_L, len); 63 isar->write_reg(isar->hw, ISAR_WADR, 0); 64 if (!msg) 65 msg = isar->buf; 66 if (msg && len) { 67 isar->write_fifo(isar->hw, ISAR_MBOX, msg, len); 68 if (isar->ch[0].bch.debug & DEBUG_HW_BFIFO) { 69 int l = 0; 70 71 while (l < (int)len) { 72 hex_dump_to_buffer(msg + l, len - l, 32, 1, 73 isar->log, 256, 1); 74 pr_debug("%s: %s %02x: %s\n", isar->name, 75 __func__, l, isar->log); 76 l += 32; 77 } 78 } 79 } 80 isar->write_reg(isar->hw, ISAR_HIS, his); 81 waitforHIA(isar, 1000); 82 return 1; 83 } 84 85 /* 86 * receive message from ISAR mailbox 87 * if msg is NULL use isar->buf 88 */ 89 static void 90 rcv_mbox(struct isar_hw *isar, u8 *msg) 91 { 92 if (!msg) 93 msg = isar->buf; 94 isar->write_reg(isar->hw, ISAR_RADR, 0); 95 if (msg && isar->clsb) { 96 isar->read_fifo(isar->hw, ISAR_MBOX, msg, isar->clsb); 97 if (isar->ch[0].bch.debug & DEBUG_HW_BFIFO) { 98 int l = 0; 99 100 while (l < (int)isar->clsb) { 101 hex_dump_to_buffer(msg + l, isar->clsb - l, 32, 102 1, isar->log, 256, 1); 103 pr_debug("%s: %s %02x: %s\n", isar->name, 104 __func__, l, isar->log); 105 l += 32; 106 } 107 } 108 } 109 isar->write_reg(isar->hw, ISAR_IIA, 0); 110 } 111 112 static inline void 113 get_irq_infos(struct isar_hw *isar) 114 { 115 isar->iis = isar->read_reg(isar->hw, ISAR_IIS); 116 isar->cmsb = isar->read_reg(isar->hw, ISAR_CTRL_H); 117 isar->clsb = isar->read_reg(isar->hw, ISAR_CTRL_L); 118 pr_debug("%s: rcv_mbox(%02x,%02x,%d)\n", isar->name, 119 isar->iis, isar->cmsb, isar->clsb); 120 } 121 122 /* 123 * poll answer message from ISAR mailbox 124 * should be used only with ISAR IRQs disabled before DSP was started 125 * 126 */ 127 static int 128 poll_mbox(struct isar_hw *isar, int maxdelay) 129 { 130 int t = maxdelay; 131 u8 irq; 132 133 irq = isar->read_reg(isar->hw, ISAR_IRQBIT); 134 while (t && !(irq & ISAR_IRQSTA)) { 135 udelay(1); 136 t--; 137 } 138 if (t) { 139 get_irq_infos(isar); 140 rcv_mbox(isar, NULL); 141 } 142 pr_debug("%s: pulled %d bytes after %d us\n", 143 isar->name, isar->clsb, maxdelay - t); 144 return t; 145 } 146 147 static int 148 ISARVersion(struct isar_hw *isar) 149 { 150 int ver; 151 152 /* disable ISAR IRQ */ 153 isar->write_reg(isar->hw, ISAR_IRQBIT, 0); 154 isar->buf[0] = ISAR_MSG_HWVER; 155 isar->buf[1] = 0; 156 isar->buf[2] = 1; 157 if (!send_mbox(isar, ISAR_HIS_VNR, 0, 3, NULL)) 158 return -1; 159 if (!poll_mbox(isar, 1000)) 160 return -2; 161 if (isar->iis == ISAR_IIS_VNR) { 162 if (isar->clsb == 1) { 163 ver = isar->buf[0] & 0xf; 164 return ver; 165 } 166 return -3; 167 } 168 return -4; 169 } 170 171 static int 172 load_firmware(struct isar_hw *isar, const u8 *buf, int size) 173 { 174 u32 saved_debug = isar->ch[0].bch.debug; 175 int ret, cnt; 176 u8 nom, noc; 177 u16 left, val, *sp = (u16 *)buf; 178 u8 *mp; 179 u_long flags; 180 181 struct { 182 u16 sadr; 183 u16 len; 184 u16 d_key; 185 } blk_head; 186 187 if (1 != isar->version) { 188 pr_err("%s: ISAR wrong version %d firmware download aborted\n", 189 isar->name, isar->version); 190 return -EINVAL; 191 } 192 if (!(saved_debug & DEBUG_HW_FIRMWARE_FIFO)) 193 isar->ch[0].bch.debug &= ~DEBUG_HW_BFIFO; 194 pr_debug("%s: load firmware %d words (%d bytes)\n", 195 isar->name, size / 2, size); 196 cnt = 0; 197 size /= 2; 198 /* disable ISAR IRQ */ 199 spin_lock_irqsave(isar->hwlock, flags); 200 isar->write_reg(isar->hw, ISAR_IRQBIT, 0); 201 spin_unlock_irqrestore(isar->hwlock, flags); 202 while (cnt < size) { 203 blk_head.sadr = le16_to_cpu(*sp++); 204 blk_head.len = le16_to_cpu(*sp++); 205 blk_head.d_key = le16_to_cpu(*sp++); 206 cnt += 3; 207 pr_debug("ISAR firmware block (%#x,%d,%#x)\n", 208 blk_head.sadr, blk_head.len, blk_head.d_key & 0xff); 209 left = blk_head.len; 210 if (cnt + left > size) { 211 pr_info("%s: firmware error have %d need %d words\n", 212 isar->name, size, cnt + left); 213 ret = -EINVAL; 214 goto reterrflg; 215 } 216 spin_lock_irqsave(isar->hwlock, flags); 217 if (!send_mbox(isar, ISAR_HIS_DKEY, blk_head.d_key & 0xff, 218 0, NULL)) { 219 pr_info("ISAR send_mbox dkey failed\n"); 220 ret = -ETIME; 221 goto reterror; 222 } 223 if (!poll_mbox(isar, 1000)) { 224 pr_warn("ISAR poll_mbox dkey failed\n"); 225 ret = -ETIME; 226 goto reterror; 227 } 228 spin_unlock_irqrestore(isar->hwlock, flags); 229 if ((isar->iis != ISAR_IIS_DKEY) || isar->cmsb || isar->clsb) { 230 pr_info("ISAR wrong dkey response (%x,%x,%x)\n", 231 isar->iis, isar->cmsb, isar->clsb); 232 ret = 1; 233 goto reterrflg; 234 } 235 while (left > 0) { 236 if (left > 126) 237 noc = 126; 238 else 239 noc = left; 240 nom = (2 * noc) + 3; 241 mp = isar->buf; 242 /* the ISAR is big endian */ 243 *mp++ = blk_head.sadr >> 8; 244 *mp++ = blk_head.sadr & 0xFF; 245 left -= noc; 246 cnt += noc; 247 *mp++ = noc; 248 pr_debug("%s: load %3d words at %04x\n", isar->name, 249 noc, blk_head.sadr); 250 blk_head.sadr += noc; 251 while (noc) { 252 val = le16_to_cpu(*sp++); 253 *mp++ = val >> 8; 254 *mp++ = val & 0xFF; 255 noc--; 256 } 257 spin_lock_irqsave(isar->hwlock, flags); 258 if (!send_mbox(isar, ISAR_HIS_FIRM, 0, nom, NULL)) { 259 pr_info("ISAR send_mbox prog failed\n"); 260 ret = -ETIME; 261 goto reterror; 262 } 263 if (!poll_mbox(isar, 1000)) { 264 pr_info("ISAR poll_mbox prog failed\n"); 265 ret = -ETIME; 266 goto reterror; 267 } 268 spin_unlock_irqrestore(isar->hwlock, flags); 269 if ((isar->iis != ISAR_IIS_FIRM) || 270 isar->cmsb || isar->clsb) { 271 pr_info("ISAR wrong prog response (%x,%x,%x)\n", 272 isar->iis, isar->cmsb, isar->clsb); 273 ret = -EIO; 274 goto reterrflg; 275 } 276 } 277 pr_debug("%s: ISAR firmware block %d words loaded\n", 278 isar->name, blk_head.len); 279 } 280 isar->ch[0].bch.debug = saved_debug; 281 /* 10ms delay */ 282 cnt = 10; 283 while (cnt--) 284 mdelay(1); 285 isar->buf[0] = 0xff; 286 isar->buf[1] = 0xfe; 287 isar->bstat = 0; 288 spin_lock_irqsave(isar->hwlock, flags); 289 if (!send_mbox(isar, ISAR_HIS_STDSP, 0, 2, NULL)) { 290 pr_info("ISAR send_mbox start dsp failed\n"); 291 ret = -ETIME; 292 goto reterror; 293 } 294 if (!poll_mbox(isar, 1000)) { 295 pr_info("ISAR poll_mbox start dsp failed\n"); 296 ret = -ETIME; 297 goto reterror; 298 } 299 if ((isar->iis != ISAR_IIS_STDSP) || isar->cmsb || isar->clsb) { 300 pr_info("ISAR wrong start dsp response (%x,%x,%x)\n", 301 isar->iis, isar->cmsb, isar->clsb); 302 ret = -EIO; 303 goto reterror; 304 } else 305 pr_debug("%s: ISAR start dsp success\n", isar->name); 306 307 /* NORMAL mode entered */ 308 /* Enable IRQs of ISAR */ 309 isar->write_reg(isar->hw, ISAR_IRQBIT, ISAR_IRQSTA); 310 spin_unlock_irqrestore(isar->hwlock, flags); 311 cnt = 1000; /* max 1s */ 312 while ((!isar->bstat) && cnt) { 313 mdelay(1); 314 cnt--; 315 } 316 if (!cnt) { 317 pr_info("ISAR no general status event received\n"); 318 ret = -ETIME; 319 goto reterrflg; 320 } else 321 pr_debug("%s: ISAR general status event %x\n", 322 isar->name, isar->bstat); 323 /* 10ms delay */ 324 cnt = 10; 325 while (cnt--) 326 mdelay(1); 327 isar->iis = 0; 328 spin_lock_irqsave(isar->hwlock, flags); 329 if (!send_mbox(isar, ISAR_HIS_DIAG, ISAR_CTRL_STST, 0, NULL)) { 330 pr_info("ISAR send_mbox self tst failed\n"); 331 ret = -ETIME; 332 goto reterror; 333 } 334 spin_unlock_irqrestore(isar->hwlock, flags); 335 cnt = 10000; /* max 100 ms */ 336 while ((isar->iis != ISAR_IIS_DIAG) && cnt) { 337 udelay(10); 338 cnt--; 339 } 340 mdelay(1); 341 if (!cnt) { 342 pr_info("ISAR no self tst response\n"); 343 ret = -ETIME; 344 goto reterrflg; 345 } 346 if ((isar->cmsb == ISAR_CTRL_STST) && (isar->clsb == 1) 347 && (isar->buf[0] == 0)) 348 pr_debug("%s: ISAR selftest OK\n", isar->name); 349 else { 350 pr_info("ISAR selftest not OK %x/%x/%x\n", 351 isar->cmsb, isar->clsb, isar->buf[0]); 352 ret = -EIO; 353 goto reterrflg; 354 } 355 spin_lock_irqsave(isar->hwlock, flags); 356 isar->iis = 0; 357 if (!send_mbox(isar, ISAR_HIS_DIAG, ISAR_CTRL_SWVER, 0, NULL)) { 358 pr_info("ISAR RQST SVN failed\n"); 359 ret = -ETIME; 360 goto reterror; 361 } 362 spin_unlock_irqrestore(isar->hwlock, flags); 363 cnt = 30000; /* max 300 ms */ 364 while ((isar->iis != ISAR_IIS_DIAG) && cnt) { 365 udelay(10); 366 cnt--; 367 } 368 mdelay(1); 369 if (!cnt) { 370 pr_info("ISAR no SVN response\n"); 371 ret = -ETIME; 372 goto reterrflg; 373 } else { 374 if ((isar->cmsb == ISAR_CTRL_SWVER) && (isar->clsb == 1)) { 375 pr_notice("%s: ISAR software version %#x\n", 376 isar->name, isar->buf[0]); 377 } else { 378 pr_info("%s: ISAR wrong swver response (%x,%x)" 379 " cnt(%d)\n", isar->name, isar->cmsb, 380 isar->clsb, cnt); 381 ret = -EIO; 382 goto reterrflg; 383 } 384 } 385 spin_lock_irqsave(isar->hwlock, flags); 386 isar_setup(isar); 387 spin_unlock_irqrestore(isar->hwlock, flags); 388 ret = 0; 389 reterrflg: 390 spin_lock_irqsave(isar->hwlock, flags); 391 reterror: 392 isar->ch[0].bch.debug = saved_debug; 393 if (ret) 394 /* disable ISAR IRQ */ 395 isar->write_reg(isar->hw, ISAR_IRQBIT, 0); 396 spin_unlock_irqrestore(isar->hwlock, flags); 397 return ret; 398 } 399 400 static inline void 401 deliver_status(struct isar_ch *ch, int status) 402 { 403 pr_debug("%s: HL->LL FAXIND %x\n", ch->is->name, status); 404 _queue_data(&ch->bch.ch, PH_CONTROL_IND, status, 0, NULL, GFP_ATOMIC); 405 } 406 407 static inline void 408 isar_rcv_frame(struct isar_ch *ch) 409 { 410 u8 *ptr; 411 int maxlen; 412 413 if (!ch->is->clsb) { 414 pr_debug("%s; ISAR zero len frame\n", ch->is->name); 415 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 416 return; 417 } 418 if (test_bit(FLG_RX_OFF, &ch->bch.Flags)) { 419 ch->bch.dropcnt += ch->is->clsb; 420 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 421 return; 422 } 423 switch (ch->bch.state) { 424 case ISDN_P_NONE: 425 pr_debug("%s: ISAR protocol 0 spurious IIS_RDATA %x/%x/%x\n", 426 ch->is->name, ch->is->iis, ch->is->cmsb, ch->is->clsb); 427 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 428 break; 429 case ISDN_P_B_RAW: 430 case ISDN_P_B_L2DTMF: 431 case ISDN_P_B_MODEM_ASYNC: 432 maxlen = bchannel_get_rxbuf(&ch->bch, ch->is->clsb); 433 if (maxlen < 0) { 434 pr_warn("%s.B%d: No bufferspace for %d bytes\n", 435 ch->is->name, ch->bch.nr, ch->is->clsb); 436 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 437 break; 438 } 439 rcv_mbox(ch->is, skb_put(ch->bch.rx_skb, ch->is->clsb)); 440 recv_Bchannel(&ch->bch, 0, false); 441 break; 442 case ISDN_P_B_HDLC: 443 maxlen = bchannel_get_rxbuf(&ch->bch, ch->is->clsb); 444 if (maxlen < 0) { 445 pr_warn("%s.B%d: No bufferspace for %d bytes\n", 446 ch->is->name, ch->bch.nr, ch->is->clsb); 447 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 448 break; 449 } 450 if (ch->is->cmsb & HDLC_ERROR) { 451 pr_debug("%s: ISAR frame error %x len %d\n", 452 ch->is->name, ch->is->cmsb, ch->is->clsb); 453 #ifdef ERROR_STATISTIC 454 if (ch->is->cmsb & HDLC_ERR_RER) 455 ch->bch.err_inv++; 456 if (ch->is->cmsb & HDLC_ERR_CER) 457 ch->bch.err_crc++; 458 #endif 459 skb_trim(ch->bch.rx_skb, 0); 460 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 461 break; 462 } 463 if (ch->is->cmsb & HDLC_FSD) 464 skb_trim(ch->bch.rx_skb, 0); 465 ptr = skb_put(ch->bch.rx_skb, ch->is->clsb); 466 rcv_mbox(ch->is, ptr); 467 if (ch->is->cmsb & HDLC_FED) { 468 if (ch->bch.rx_skb->len < 3) { /* last 2 are the FCS */ 469 pr_debug("%s: ISAR frame to short %d\n", 470 ch->is->name, ch->bch.rx_skb->len); 471 skb_trim(ch->bch.rx_skb, 0); 472 break; 473 } 474 skb_trim(ch->bch.rx_skb, ch->bch.rx_skb->len - 2); 475 recv_Bchannel(&ch->bch, 0, false); 476 } 477 break; 478 case ISDN_P_B_T30_FAX: 479 if (ch->state != STFAX_ACTIV) { 480 pr_debug("%s: isar_rcv_frame: not ACTIV\n", 481 ch->is->name); 482 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 483 if (ch->bch.rx_skb) 484 skb_trim(ch->bch.rx_skb, 0); 485 break; 486 } 487 if (!ch->bch.rx_skb) { 488 ch->bch.rx_skb = mI_alloc_skb(ch->bch.maxlen, 489 GFP_ATOMIC); 490 if (unlikely(!ch->bch.rx_skb)) { 491 pr_info("%s: B receive out of memory\n", 492 __func__); 493 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 494 break; 495 } 496 } 497 if (ch->cmd == PCTRL_CMD_FRM) { 498 rcv_mbox(ch->is, skb_put(ch->bch.rx_skb, ch->is->clsb)); 499 pr_debug("%s: isar_rcv_frame: %d\n", 500 ch->is->name, ch->bch.rx_skb->len); 501 if (ch->is->cmsb & SART_NMD) { /* ABORT */ 502 pr_debug("%s: isar_rcv_frame: no more data\n", 503 ch->is->name); 504 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 505 send_mbox(ch->is, SET_DPS(ch->dpath) | 506 ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 507 0, NULL); 508 ch->state = STFAX_ESCAPE; 509 /* set_skb_flag(skb, DF_NOMOREDATA); */ 510 } 511 recv_Bchannel(&ch->bch, 0, false); 512 if (ch->is->cmsb & SART_NMD) 513 deliver_status(ch, HW_MOD_NOCARR); 514 break; 515 } 516 if (ch->cmd != PCTRL_CMD_FRH) { 517 pr_debug("%s: isar_rcv_frame: unknown fax mode %x\n", 518 ch->is->name, ch->cmd); 519 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 520 if (ch->bch.rx_skb) 521 skb_trim(ch->bch.rx_skb, 0); 522 break; 523 } 524 /* PCTRL_CMD_FRH */ 525 if ((ch->bch.rx_skb->len + ch->is->clsb) > 526 (ch->bch.maxlen + 2)) { 527 pr_info("%s: %s incoming packet too large\n", 528 ch->is->name, __func__); 529 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 530 skb_trim(ch->bch.rx_skb, 0); 531 break; 532 } else if (ch->is->cmsb & HDLC_ERROR) { 533 pr_info("%s: ISAR frame error %x len %d\n", 534 ch->is->name, ch->is->cmsb, ch->is->clsb); 535 skb_trim(ch->bch.rx_skb, 0); 536 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 537 break; 538 } 539 if (ch->is->cmsb & HDLC_FSD) 540 skb_trim(ch->bch.rx_skb, 0); 541 ptr = skb_put(ch->bch.rx_skb, ch->is->clsb); 542 rcv_mbox(ch->is, ptr); 543 if (ch->is->cmsb & HDLC_FED) { 544 if (ch->bch.rx_skb->len < 3) { /* last 2 are the FCS */ 545 pr_info("%s: ISAR frame to short %d\n", 546 ch->is->name, ch->bch.rx_skb->len); 547 skb_trim(ch->bch.rx_skb, 0); 548 break; 549 } 550 skb_trim(ch->bch.rx_skb, ch->bch.rx_skb->len - 2); 551 recv_Bchannel(&ch->bch, 0, false); 552 } 553 if (ch->is->cmsb & SART_NMD) { /* ABORT */ 554 pr_debug("%s: isar_rcv_frame: no more data\n", 555 ch->is->name); 556 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 557 if (ch->bch.rx_skb) 558 skb_trim(ch->bch.rx_skb, 0); 559 send_mbox(ch->is, SET_DPS(ch->dpath) | 560 ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 0, NULL); 561 ch->state = STFAX_ESCAPE; 562 deliver_status(ch, HW_MOD_NOCARR); 563 } 564 break; 565 default: 566 pr_info("isar_rcv_frame protocol (%x)error\n", ch->bch.state); 567 ch->is->write_reg(ch->is->hw, ISAR_IIA, 0); 568 break; 569 } 570 } 571 572 static void 573 isar_fill_fifo(struct isar_ch *ch) 574 { 575 int count; 576 u8 msb; 577 u8 *ptr; 578 579 pr_debug("%s: ch%d tx_skb %d tx_idx %d\n", ch->is->name, ch->bch.nr, 580 ch->bch.tx_skb ? ch->bch.tx_skb->len : -1, ch->bch.tx_idx); 581 if (!(ch->is->bstat & 582 (ch->dpath == 1 ? BSTAT_RDM1 : BSTAT_RDM2))) 583 return; 584 if (!ch->bch.tx_skb) { 585 if (!test_bit(FLG_TX_EMPTY, &ch->bch.Flags) || 586 (ch->bch.state != ISDN_P_B_RAW)) 587 return; 588 count = ch->mml; 589 /* use the card buffer */ 590 memset(ch->is->buf, ch->bch.fill[0], count); 591 send_mbox(ch->is, SET_DPS(ch->dpath) | ISAR_HIS_SDATA, 592 0, count, ch->is->buf); 593 return; 594 } 595 count = ch->bch.tx_skb->len - ch->bch.tx_idx; 596 if (count <= 0) 597 return; 598 if (count > ch->mml) { 599 msb = 0; 600 count = ch->mml; 601 } else { 602 msb = HDLC_FED; 603 } 604 ptr = ch->bch.tx_skb->data + ch->bch.tx_idx; 605 if (!ch->bch.tx_idx) { 606 pr_debug("%s: frame start\n", ch->is->name); 607 if ((ch->bch.state == ISDN_P_B_T30_FAX) && 608 (ch->cmd == PCTRL_CMD_FTH)) { 609 if (count > 1) { 610 if ((ptr[0] == 0xff) && (ptr[1] == 0x13)) { 611 /* last frame */ 612 test_and_set_bit(FLG_LASTDATA, 613 &ch->bch.Flags); 614 pr_debug("%s: set LASTDATA\n", 615 ch->is->name); 616 if (msb == HDLC_FED) 617 test_and_set_bit(FLG_DLEETX, 618 &ch->bch.Flags); 619 } 620 } 621 } 622 msb |= HDLC_FST; 623 } 624 ch->bch.tx_idx += count; 625 switch (ch->bch.state) { 626 case ISDN_P_NONE: 627 pr_info("%s: wrong protocol 0\n", __func__); 628 break; 629 case ISDN_P_B_RAW: 630 case ISDN_P_B_L2DTMF: 631 case ISDN_P_B_MODEM_ASYNC: 632 send_mbox(ch->is, SET_DPS(ch->dpath) | ISAR_HIS_SDATA, 633 0, count, ptr); 634 break; 635 case ISDN_P_B_HDLC: 636 send_mbox(ch->is, SET_DPS(ch->dpath) | ISAR_HIS_SDATA, 637 msb, count, ptr); 638 break; 639 case ISDN_P_B_T30_FAX: 640 if (ch->state != STFAX_ACTIV) 641 pr_debug("%s: not ACTIV\n", ch->is->name); 642 else if (ch->cmd == PCTRL_CMD_FTH) 643 send_mbox(ch->is, SET_DPS(ch->dpath) | ISAR_HIS_SDATA, 644 msb, count, ptr); 645 else if (ch->cmd == PCTRL_CMD_FTM) 646 send_mbox(ch->is, SET_DPS(ch->dpath) | ISAR_HIS_SDATA, 647 0, count, ptr); 648 else 649 pr_debug("%s: not FTH/FTM\n", ch->is->name); 650 break; 651 default: 652 pr_info("%s: protocol(%x) error\n", 653 __func__, ch->bch.state); 654 break; 655 } 656 } 657 658 static inline struct isar_ch * 659 sel_bch_isar(struct isar_hw *isar, u8 dpath) 660 { 661 struct isar_ch *base = &isar->ch[0]; 662 663 if ((!dpath) || (dpath > 2)) 664 return NULL; 665 if (base->dpath == dpath) 666 return base; 667 base++; 668 if (base->dpath == dpath) 669 return base; 670 return NULL; 671 } 672 673 static void 674 send_next(struct isar_ch *ch) 675 { 676 pr_debug("%s: %s ch%d tx_skb %d tx_idx %d\n", ch->is->name, __func__, 677 ch->bch.nr, ch->bch.tx_skb ? ch->bch.tx_skb->len : -1, 678 ch->bch.tx_idx); 679 if (ch->bch.state == ISDN_P_B_T30_FAX) { 680 if (ch->cmd == PCTRL_CMD_FTH) { 681 if (test_bit(FLG_LASTDATA, &ch->bch.Flags)) { 682 pr_debug("set NMD_DATA\n"); 683 test_and_set_bit(FLG_NMD_DATA, &ch->bch.Flags); 684 } 685 } else if (ch->cmd == PCTRL_CMD_FTM) { 686 if (test_bit(FLG_DLEETX, &ch->bch.Flags)) { 687 test_and_set_bit(FLG_LASTDATA, &ch->bch.Flags); 688 test_and_set_bit(FLG_NMD_DATA, &ch->bch.Flags); 689 } 690 } 691 } 692 dev_kfree_skb(ch->bch.tx_skb); 693 if (get_next_bframe(&ch->bch)) { 694 isar_fill_fifo(ch); 695 test_and_clear_bit(FLG_TX_EMPTY, &ch->bch.Flags); 696 } else if (test_bit(FLG_TX_EMPTY, &ch->bch.Flags)) { 697 isar_fill_fifo(ch); 698 } else { 699 if (test_and_clear_bit(FLG_DLEETX, &ch->bch.Flags)) { 700 if (test_and_clear_bit(FLG_LASTDATA, 701 &ch->bch.Flags)) { 702 if (test_and_clear_bit(FLG_NMD_DATA, 703 &ch->bch.Flags)) { 704 u8 zd = 0; 705 send_mbox(ch->is, SET_DPS(ch->dpath) | 706 ISAR_HIS_SDATA, 0x01, 1, &zd); 707 } 708 test_and_set_bit(FLG_LL_OK, &ch->bch.Flags); 709 } else { 710 deliver_status(ch, HW_MOD_CONNECT); 711 } 712 } else if (test_bit(FLG_FILLEMPTY, &ch->bch.Flags)) { 713 test_and_set_bit(FLG_TX_EMPTY, &ch->bch.Flags); 714 } 715 } 716 } 717 718 static void 719 check_send(struct isar_hw *isar, u8 rdm) 720 { 721 struct isar_ch *ch; 722 723 pr_debug("%s: rdm %x\n", isar->name, rdm); 724 if (rdm & BSTAT_RDM1) { 725 ch = sel_bch_isar(isar, 1); 726 if (ch && test_bit(FLG_ACTIVE, &ch->bch.Flags)) { 727 if (ch->bch.tx_skb && (ch->bch.tx_skb->len > 728 ch->bch.tx_idx)) 729 isar_fill_fifo(ch); 730 else 731 send_next(ch); 732 } 733 } 734 if (rdm & BSTAT_RDM2) { 735 ch = sel_bch_isar(isar, 2); 736 if (ch && test_bit(FLG_ACTIVE, &ch->bch.Flags)) { 737 if (ch->bch.tx_skb && (ch->bch.tx_skb->len > 738 ch->bch.tx_idx)) 739 isar_fill_fifo(ch); 740 else 741 send_next(ch); 742 } 743 } 744 } 745 746 static const char *dmril[] = {"NO SPEED", "1200/75", "NODEF2", "75/1200", "NODEF4", 747 "300", "600", "1200", "2400", "4800", "7200", 748 "9600nt", "9600t", "12000", "14400", "WRONG"}; 749 static const char *dmrim[] = {"NO MOD", "NO DEF", "V32/V32b", "V22", "V21", 750 "Bell103", "V23", "Bell202", "V17", "V29", "V27ter"}; 751 752 static void 753 isar_pump_status_rsp(struct isar_ch *ch) { 754 u8 ril = ch->is->buf[0]; 755 u8 rim; 756 757 if (!test_and_clear_bit(ISAR_RATE_REQ, &ch->is->Flags)) 758 return; 759 if (ril > 14) { 760 pr_info("%s: wrong pstrsp ril=%d\n", ch->is->name, ril); 761 ril = 15; 762 } 763 switch (ch->is->buf[1]) { 764 case 0: 765 rim = 0; 766 break; 767 case 0x20: 768 rim = 2; 769 break; 770 case 0x40: 771 rim = 3; 772 break; 773 case 0x41: 774 rim = 4; 775 break; 776 case 0x51: 777 rim = 5; 778 break; 779 case 0x61: 780 rim = 6; 781 break; 782 case 0x71: 783 rim = 7; 784 break; 785 case 0x82: 786 rim = 8; 787 break; 788 case 0x92: 789 rim = 9; 790 break; 791 case 0xa2: 792 rim = 10; 793 break; 794 default: 795 rim = 1; 796 break; 797 } 798 sprintf(ch->conmsg, "%s %s", dmril[ril], dmrim[rim]); 799 pr_debug("%s: pump strsp %s\n", ch->is->name, ch->conmsg); 800 } 801 802 static void 803 isar_pump_statev_modem(struct isar_ch *ch, u8 devt) { 804 u8 dps = SET_DPS(ch->dpath); 805 806 switch (devt) { 807 case PSEV_10MS_TIMER: 808 pr_debug("%s: pump stev TIMER\n", ch->is->name); 809 break; 810 case PSEV_CON_ON: 811 pr_debug("%s: pump stev CONNECT\n", ch->is->name); 812 deliver_status(ch, HW_MOD_CONNECT); 813 break; 814 case PSEV_CON_OFF: 815 pr_debug("%s: pump stev NO CONNECT\n", ch->is->name); 816 send_mbox(ch->is, dps | ISAR_HIS_PSTREQ, 0, 0, NULL); 817 deliver_status(ch, HW_MOD_NOCARR); 818 break; 819 case PSEV_V24_OFF: 820 pr_debug("%s: pump stev V24 OFF\n", ch->is->name); 821 break; 822 case PSEV_CTS_ON: 823 pr_debug("%s: pump stev CTS ON\n", ch->is->name); 824 break; 825 case PSEV_CTS_OFF: 826 pr_debug("%s pump stev CTS OFF\n", ch->is->name); 827 break; 828 case PSEV_DCD_ON: 829 pr_debug("%s: pump stev CARRIER ON\n", ch->is->name); 830 test_and_set_bit(ISAR_RATE_REQ, &ch->is->Flags); 831 send_mbox(ch->is, dps | ISAR_HIS_PSTREQ, 0, 0, NULL); 832 break; 833 case PSEV_DCD_OFF: 834 pr_debug("%s: pump stev CARRIER OFF\n", ch->is->name); 835 break; 836 case PSEV_DSR_ON: 837 pr_debug("%s: pump stev DSR ON\n", ch->is->name); 838 break; 839 case PSEV_DSR_OFF: 840 pr_debug("%s: pump stev DSR_OFF\n", ch->is->name); 841 break; 842 case PSEV_REM_RET: 843 pr_debug("%s: pump stev REMOTE RETRAIN\n", ch->is->name); 844 break; 845 case PSEV_REM_REN: 846 pr_debug("%s: pump stev REMOTE RENEGOTIATE\n", ch->is->name); 847 break; 848 case PSEV_GSTN_CLR: 849 pr_debug("%s: pump stev GSTN CLEAR\n", ch->is->name); 850 break; 851 default: 852 pr_info("u%s: unknown pump stev %x\n", ch->is->name, devt); 853 break; 854 } 855 } 856 857 static void 858 isar_pump_statev_fax(struct isar_ch *ch, u8 devt) { 859 u8 dps = SET_DPS(ch->dpath); 860 u8 p1; 861 862 switch (devt) { 863 case PSEV_10MS_TIMER: 864 pr_debug("%s: pump stev TIMER\n", ch->is->name); 865 break; 866 case PSEV_RSP_READY: 867 pr_debug("%s: pump stev RSP_READY\n", ch->is->name); 868 ch->state = STFAX_READY; 869 deliver_status(ch, HW_MOD_READY); 870 #ifdef AUTOCON 871 if (test_bit(BC_FLG_ORIG, &ch->bch.Flags)) 872 isar_pump_cmd(bch, HW_MOD_FRH, 3); 873 else 874 isar_pump_cmd(bch, HW_MOD_FTH, 3); 875 #endif 876 break; 877 case PSEV_LINE_TX_H: 878 if (ch->state == STFAX_LINE) { 879 pr_debug("%s: pump stev LINE_TX_H\n", ch->is->name); 880 ch->state = STFAX_CONT; 881 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 882 PCTRL_CMD_CONT, 0, NULL); 883 } else { 884 pr_debug("%s: pump stev LINE_TX_H wrong st %x\n", 885 ch->is->name, ch->state); 886 } 887 break; 888 case PSEV_LINE_RX_H: 889 if (ch->state == STFAX_LINE) { 890 pr_debug("%s: pump stev LINE_RX_H\n", ch->is->name); 891 ch->state = STFAX_CONT; 892 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 893 PCTRL_CMD_CONT, 0, NULL); 894 } else { 895 pr_debug("%s: pump stev LINE_RX_H wrong st %x\n", 896 ch->is->name, ch->state); 897 } 898 break; 899 case PSEV_LINE_TX_B: 900 if (ch->state == STFAX_LINE) { 901 pr_debug("%s: pump stev LINE_TX_B\n", ch->is->name); 902 ch->state = STFAX_CONT; 903 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 904 PCTRL_CMD_CONT, 0, NULL); 905 } else { 906 pr_debug("%s: pump stev LINE_TX_B wrong st %x\n", 907 ch->is->name, ch->state); 908 } 909 break; 910 case PSEV_LINE_RX_B: 911 if (ch->state == STFAX_LINE) { 912 pr_debug("%s: pump stev LINE_RX_B\n", ch->is->name); 913 ch->state = STFAX_CONT; 914 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 915 PCTRL_CMD_CONT, 0, NULL); 916 } else { 917 pr_debug("%s: pump stev LINE_RX_B wrong st %x\n", 918 ch->is->name, ch->state); 919 } 920 break; 921 case PSEV_RSP_CONN: 922 if (ch->state == STFAX_CONT) { 923 pr_debug("%s: pump stev RSP_CONN\n", ch->is->name); 924 ch->state = STFAX_ACTIV; 925 test_and_set_bit(ISAR_RATE_REQ, &ch->is->Flags); 926 send_mbox(ch->is, dps | ISAR_HIS_PSTREQ, 0, 0, NULL); 927 if (ch->cmd == PCTRL_CMD_FTH) { 928 int delay = (ch->mod == 3) ? 1000 : 200; 929 /* 1s (200 ms) Flags before data */ 930 if (test_and_set_bit(FLG_FTI_RUN, 931 &ch->bch.Flags)) 932 del_timer(&ch->ftimer); 933 ch->ftimer.expires = 934 jiffies + ((delay * HZ) / 1000); 935 test_and_set_bit(FLG_LL_CONN, 936 &ch->bch.Flags); 937 add_timer(&ch->ftimer); 938 } else { 939 deliver_status(ch, HW_MOD_CONNECT); 940 } 941 } else { 942 pr_debug("%s: pump stev RSP_CONN wrong st %x\n", 943 ch->is->name, ch->state); 944 } 945 break; 946 case PSEV_FLAGS_DET: 947 pr_debug("%s: pump stev FLAGS_DET\n", ch->is->name); 948 break; 949 case PSEV_RSP_DISC: 950 pr_debug("%s: pump stev RSP_DISC state(%d)\n", 951 ch->is->name, ch->state); 952 if (ch->state == STFAX_ESCAPE) { 953 p1 = 5; 954 switch (ch->newcmd) { 955 case 0: 956 ch->state = STFAX_READY; 957 break; 958 case PCTRL_CMD_FTM: 959 p1 = 2; 960 /* fall through */ 961 case PCTRL_CMD_FTH: 962 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 963 PCTRL_CMD_SILON, 1, &p1); 964 ch->state = STFAX_SILDET; 965 break; 966 case PCTRL_CMD_FRH: 967 case PCTRL_CMD_FRM: 968 ch->mod = ch->newmod; 969 p1 = ch->newmod; 970 ch->newmod = 0; 971 ch->cmd = ch->newcmd; 972 ch->newcmd = 0; 973 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 974 ch->cmd, 1, &p1); 975 ch->state = STFAX_LINE; 976 ch->try_mod = 3; 977 break; 978 default: 979 pr_debug("%s: RSP_DISC unknown newcmd %x\n", 980 ch->is->name, ch->newcmd); 981 break; 982 } 983 } else if (ch->state == STFAX_ACTIV) { 984 if (test_and_clear_bit(FLG_LL_OK, &ch->bch.Flags)) 985 deliver_status(ch, HW_MOD_OK); 986 else if (ch->cmd == PCTRL_CMD_FRM) 987 deliver_status(ch, HW_MOD_NOCARR); 988 else 989 deliver_status(ch, HW_MOD_FCERROR); 990 ch->state = STFAX_READY; 991 } else if (ch->state != STFAX_SILDET) { 992 /* ignore in STFAX_SILDET */ 993 ch->state = STFAX_READY; 994 deliver_status(ch, HW_MOD_FCERROR); 995 } 996 break; 997 case PSEV_RSP_SILDET: 998 pr_debug("%s: pump stev RSP_SILDET\n", ch->is->name); 999 if (ch->state == STFAX_SILDET) { 1000 ch->mod = ch->newmod; 1001 p1 = ch->newmod; 1002 ch->newmod = 0; 1003 ch->cmd = ch->newcmd; 1004 ch->newcmd = 0; 1005 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 1006 ch->cmd, 1, &p1); 1007 ch->state = STFAX_LINE; 1008 ch->try_mod = 3; 1009 } 1010 break; 1011 case PSEV_RSP_SILOFF: 1012 pr_debug("%s: pump stev RSP_SILOFF\n", ch->is->name); 1013 break; 1014 case PSEV_RSP_FCERR: 1015 if (ch->state == STFAX_LINE) { 1016 pr_debug("%s: pump stev RSP_FCERR try %d\n", 1017 ch->is->name, ch->try_mod); 1018 if (ch->try_mod--) { 1019 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, 1020 ch->cmd, 1, &ch->mod); 1021 break; 1022 } 1023 } 1024 pr_debug("%s: pump stev RSP_FCERR\n", ch->is->name); 1025 ch->state = STFAX_ESCAPE; 1026 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, PCTRL_CMD_ESC, 1027 0, NULL); 1028 deliver_status(ch, HW_MOD_FCERROR); 1029 break; 1030 default: 1031 break; 1032 } 1033 } 1034 1035 void 1036 mISDNisar_irq(struct isar_hw *isar) 1037 { 1038 struct isar_ch *ch; 1039 1040 get_irq_infos(isar); 1041 switch (isar->iis & ISAR_IIS_MSCMSD) { 1042 case ISAR_IIS_RDATA: 1043 ch = sel_bch_isar(isar, isar->iis >> 6); 1044 if (ch) 1045 isar_rcv_frame(ch); 1046 else { 1047 pr_debug("%s: ISAR spurious IIS_RDATA %x/%x/%x\n", 1048 isar->name, isar->iis, isar->cmsb, 1049 isar->clsb); 1050 isar->write_reg(isar->hw, ISAR_IIA, 0); 1051 } 1052 break; 1053 case ISAR_IIS_GSTEV: 1054 isar->write_reg(isar->hw, ISAR_IIA, 0); 1055 isar->bstat |= isar->cmsb; 1056 check_send(isar, isar->cmsb); 1057 break; 1058 case ISAR_IIS_BSTEV: 1059 #ifdef ERROR_STATISTIC 1060 ch = sel_bch_isar(isar, isar->iis >> 6); 1061 if (ch) { 1062 if (isar->cmsb == BSTEV_TBO) 1063 ch->bch.err_tx++; 1064 if (isar->cmsb == BSTEV_RBO) 1065 ch->bch.err_rdo++; 1066 } 1067 #endif 1068 pr_debug("%s: Buffer STEV dpath%d msb(%x)\n", 1069 isar->name, isar->iis >> 6, isar->cmsb); 1070 isar->write_reg(isar->hw, ISAR_IIA, 0); 1071 break; 1072 case ISAR_IIS_PSTEV: 1073 ch = sel_bch_isar(isar, isar->iis >> 6); 1074 if (ch) { 1075 rcv_mbox(isar, NULL); 1076 if (ch->bch.state == ISDN_P_B_MODEM_ASYNC) 1077 isar_pump_statev_modem(ch, isar->cmsb); 1078 else if (ch->bch.state == ISDN_P_B_T30_FAX) 1079 isar_pump_statev_fax(ch, isar->cmsb); 1080 else if (ch->bch.state == ISDN_P_B_RAW) { 1081 int tt; 1082 tt = isar->cmsb | 0x30; 1083 if (tt == 0x3e) 1084 tt = '*'; 1085 else if (tt == 0x3f) 1086 tt = '#'; 1087 else if (tt > '9') 1088 tt += 7; 1089 tt |= DTMF_TONE_VAL; 1090 _queue_data(&ch->bch.ch, PH_CONTROL_IND, 1091 MISDN_ID_ANY, sizeof(tt), &tt, 1092 GFP_ATOMIC); 1093 } else 1094 pr_debug("%s: ISAR IIS_PSTEV pm %d sta %x\n", 1095 isar->name, ch->bch.state, 1096 isar->cmsb); 1097 } else { 1098 pr_debug("%s: ISAR spurious IIS_PSTEV %x/%x/%x\n", 1099 isar->name, isar->iis, isar->cmsb, 1100 isar->clsb); 1101 isar->write_reg(isar->hw, ISAR_IIA, 0); 1102 } 1103 break; 1104 case ISAR_IIS_PSTRSP: 1105 ch = sel_bch_isar(isar, isar->iis >> 6); 1106 if (ch) { 1107 rcv_mbox(isar, NULL); 1108 isar_pump_status_rsp(ch); 1109 } else { 1110 pr_debug("%s: ISAR spurious IIS_PSTRSP %x/%x/%x\n", 1111 isar->name, isar->iis, isar->cmsb, 1112 isar->clsb); 1113 isar->write_reg(isar->hw, ISAR_IIA, 0); 1114 } 1115 break; 1116 case ISAR_IIS_DIAG: 1117 case ISAR_IIS_BSTRSP: 1118 case ISAR_IIS_IOM2RSP: 1119 rcv_mbox(isar, NULL); 1120 break; 1121 case ISAR_IIS_INVMSG: 1122 rcv_mbox(isar, NULL); 1123 pr_debug("%s: invalid msg his:%x\n", isar->name, isar->cmsb); 1124 break; 1125 default: 1126 rcv_mbox(isar, NULL); 1127 pr_debug("%s: unhandled msg iis(%x) ctrl(%x/%x)\n", 1128 isar->name, isar->iis, isar->cmsb, isar->clsb); 1129 break; 1130 } 1131 } 1132 EXPORT_SYMBOL(mISDNisar_irq); 1133 1134 static void 1135 ftimer_handler(struct timer_list *t) 1136 { 1137 struct isar_ch *ch = from_timer(ch, t, ftimer); 1138 1139 pr_debug("%s: ftimer flags %lx\n", ch->is->name, ch->bch.Flags); 1140 test_and_clear_bit(FLG_FTI_RUN, &ch->bch.Flags); 1141 if (test_and_clear_bit(FLG_LL_CONN, &ch->bch.Flags)) 1142 deliver_status(ch, HW_MOD_CONNECT); 1143 } 1144 1145 static void 1146 setup_pump(struct isar_ch *ch) { 1147 u8 dps = SET_DPS(ch->dpath); 1148 u8 ctrl, param[6]; 1149 1150 switch (ch->bch.state) { 1151 case ISDN_P_NONE: 1152 case ISDN_P_B_RAW: 1153 case ISDN_P_B_HDLC: 1154 send_mbox(ch->is, dps | ISAR_HIS_PUMPCFG, PMOD_BYPASS, 0, NULL); 1155 break; 1156 case ISDN_P_B_L2DTMF: 1157 if (test_bit(FLG_DTMFSEND, &ch->bch.Flags)) { 1158 param[0] = 5; /* TOA 5 db */ 1159 send_mbox(ch->is, dps | ISAR_HIS_PUMPCFG, 1160 PMOD_DTMF_TRANS, 1, param); 1161 } else { 1162 param[0] = 40; /* REL -46 dbm */ 1163 send_mbox(ch->is, dps | ISAR_HIS_PUMPCFG, 1164 PMOD_DTMF, 1, param); 1165 } 1166 /* fall through */ 1167 case ISDN_P_B_MODEM_ASYNC: 1168 ctrl = PMOD_DATAMODEM; 1169 if (test_bit(FLG_ORIGIN, &ch->bch.Flags)) { 1170 ctrl |= PCTRL_ORIG; 1171 param[5] = PV32P6_CTN; 1172 } else { 1173 param[5] = PV32P6_ATN; 1174 } 1175 param[0] = 6; /* 6 db */ 1176 param[1] = PV32P2_V23R | PV32P2_V22A | PV32P2_V22B | 1177 PV32P2_V22C | PV32P2_V21 | PV32P2_BEL; 1178 param[2] = PV32P3_AMOD | PV32P3_V32B | PV32P3_V23B; 1179 param[3] = PV32P4_UT144; 1180 param[4] = PV32P5_UT144; 1181 send_mbox(ch->is, dps | ISAR_HIS_PUMPCFG, ctrl, 6, param); 1182 break; 1183 case ISDN_P_B_T30_FAX: 1184 ctrl = PMOD_FAX; 1185 if (test_bit(FLG_ORIGIN, &ch->bch.Flags)) { 1186 ctrl |= PCTRL_ORIG; 1187 param[1] = PFAXP2_CTN; 1188 } else { 1189 param[1] = PFAXP2_ATN; 1190 } 1191 param[0] = 6; /* 6 db */ 1192 send_mbox(ch->is, dps | ISAR_HIS_PUMPCFG, ctrl, 2, param); 1193 ch->state = STFAX_NULL; 1194 ch->newcmd = 0; 1195 ch->newmod = 0; 1196 test_and_set_bit(FLG_FTI_RUN, &ch->bch.Flags); 1197 break; 1198 } 1199 udelay(1000); 1200 send_mbox(ch->is, dps | ISAR_HIS_PSTREQ, 0, 0, NULL); 1201 udelay(1000); 1202 } 1203 1204 static void 1205 setup_sart(struct isar_ch *ch) { 1206 u8 dps = SET_DPS(ch->dpath); 1207 u8 ctrl, param[2] = {0, 0}; 1208 1209 switch (ch->bch.state) { 1210 case ISDN_P_NONE: 1211 send_mbox(ch->is, dps | ISAR_HIS_SARTCFG, SMODE_DISABLE, 1212 0, NULL); 1213 break; 1214 case ISDN_P_B_RAW: 1215 case ISDN_P_B_L2DTMF: 1216 send_mbox(ch->is, dps | ISAR_HIS_SARTCFG, SMODE_BINARY, 1217 2, param); 1218 break; 1219 case ISDN_P_B_HDLC: 1220 case ISDN_P_B_T30_FAX: 1221 send_mbox(ch->is, dps | ISAR_HIS_SARTCFG, SMODE_HDLC, 1222 1, param); 1223 break; 1224 case ISDN_P_B_MODEM_ASYNC: 1225 ctrl = SMODE_V14 | SCTRL_HDMC_BOTH; 1226 param[0] = S_P1_CHS_8; 1227 param[1] = S_P2_BFT_DEF; 1228 send_mbox(ch->is, dps | ISAR_HIS_SARTCFG, ctrl, 2, param); 1229 break; 1230 } 1231 udelay(1000); 1232 send_mbox(ch->is, dps | ISAR_HIS_BSTREQ, 0, 0, NULL); 1233 udelay(1000); 1234 } 1235 1236 static void 1237 setup_iom2(struct isar_ch *ch) { 1238 u8 dps = SET_DPS(ch->dpath); 1239 u8 cmsb = IOM_CTRL_ENA, msg[5] = {IOM_P1_TXD, 0, 0, 0, 0}; 1240 1241 if (ch->bch.nr == 2) { 1242 msg[1] = 1; 1243 msg[3] = 1; 1244 } 1245 switch (ch->bch.state) { 1246 case ISDN_P_NONE: 1247 cmsb = 0; 1248 /* dummy slot */ 1249 msg[1] = ch->dpath + 2; 1250 msg[3] = ch->dpath + 2; 1251 break; 1252 case ISDN_P_B_RAW: 1253 case ISDN_P_B_HDLC: 1254 break; 1255 case ISDN_P_B_MODEM_ASYNC: 1256 case ISDN_P_B_T30_FAX: 1257 cmsb |= IOM_CTRL_RCV; 1258 /* fall through */ 1259 case ISDN_P_B_L2DTMF: 1260 if (test_bit(FLG_DTMFSEND, &ch->bch.Flags)) 1261 cmsb |= IOM_CTRL_RCV; 1262 cmsb |= IOM_CTRL_ALAW; 1263 break; 1264 } 1265 send_mbox(ch->is, dps | ISAR_HIS_IOM2CFG, cmsb, 5, msg); 1266 udelay(1000); 1267 send_mbox(ch->is, dps | ISAR_HIS_IOM2REQ, 0, 0, NULL); 1268 udelay(1000); 1269 } 1270 1271 static int 1272 modeisar(struct isar_ch *ch, u32 bprotocol) 1273 { 1274 /* Here we are selecting the best datapath for requested protocol */ 1275 if (ch->bch.state == ISDN_P_NONE) { /* New Setup */ 1276 switch (bprotocol) { 1277 case ISDN_P_NONE: /* init */ 1278 if (!ch->dpath) 1279 /* no init for dpath 0 */ 1280 return 0; 1281 test_and_clear_bit(FLG_HDLC, &ch->bch.Flags); 1282 test_and_clear_bit(FLG_TRANSPARENT, &ch->bch.Flags); 1283 break; 1284 case ISDN_P_B_RAW: 1285 case ISDN_P_B_HDLC: 1286 /* best is datapath 2 */ 1287 if (!test_and_set_bit(ISAR_DP2_USE, &ch->is->Flags)) 1288 ch->dpath = 2; 1289 else if (!test_and_set_bit(ISAR_DP1_USE, 1290 &ch->is->Flags)) 1291 ch->dpath = 1; 1292 else { 1293 pr_info("modeisar both paths in use\n"); 1294 return -EBUSY; 1295 } 1296 if (bprotocol == ISDN_P_B_HDLC) 1297 test_and_set_bit(FLG_HDLC, &ch->bch.Flags); 1298 else 1299 test_and_set_bit(FLG_TRANSPARENT, 1300 &ch->bch.Flags); 1301 break; 1302 case ISDN_P_B_MODEM_ASYNC: 1303 case ISDN_P_B_T30_FAX: 1304 case ISDN_P_B_L2DTMF: 1305 /* only datapath 1 */ 1306 if (!test_and_set_bit(ISAR_DP1_USE, &ch->is->Flags)) 1307 ch->dpath = 1; 1308 else { 1309 pr_info("%s: ISAR modeisar analog functions" 1310 "only with DP1\n", ch->is->name); 1311 return -EBUSY; 1312 } 1313 break; 1314 default: 1315 pr_info("%s: protocol not known %x\n", ch->is->name, 1316 bprotocol); 1317 return -ENOPROTOOPT; 1318 } 1319 } 1320 pr_debug("%s: ISAR ch%d dp%d protocol %x->%x\n", ch->is->name, 1321 ch->bch.nr, ch->dpath, ch->bch.state, bprotocol); 1322 ch->bch.state = bprotocol; 1323 setup_pump(ch); 1324 setup_iom2(ch); 1325 setup_sart(ch); 1326 if (ch->bch.state == ISDN_P_NONE) { 1327 /* Clear resources */ 1328 if (ch->dpath == 1) 1329 test_and_clear_bit(ISAR_DP1_USE, &ch->is->Flags); 1330 else if (ch->dpath == 2) 1331 test_and_clear_bit(ISAR_DP2_USE, &ch->is->Flags); 1332 ch->dpath = 0; 1333 ch->is->ctrl(ch->is->hw, HW_DEACT_IND, ch->bch.nr); 1334 } else 1335 ch->is->ctrl(ch->is->hw, HW_ACTIVATE_IND, ch->bch.nr); 1336 return 0; 1337 } 1338 1339 static void 1340 isar_pump_cmd(struct isar_ch *ch, u32 cmd, u8 para) 1341 { 1342 u8 dps = SET_DPS(ch->dpath); 1343 u8 ctrl = 0, nom = 0, p1 = 0; 1344 1345 pr_debug("%s: isar_pump_cmd %x/%x state(%x)\n", 1346 ch->is->name, cmd, para, ch->bch.state); 1347 switch (cmd) { 1348 case HW_MOD_FTM: 1349 if (ch->state == STFAX_READY) { 1350 p1 = para; 1351 ctrl = PCTRL_CMD_FTM; 1352 nom = 1; 1353 ch->state = STFAX_LINE; 1354 ch->cmd = ctrl; 1355 ch->mod = para; 1356 ch->newmod = 0; 1357 ch->newcmd = 0; 1358 ch->try_mod = 3; 1359 } else if ((ch->state == STFAX_ACTIV) && 1360 (ch->cmd == PCTRL_CMD_FTM) && (ch->mod == para)) 1361 deliver_status(ch, HW_MOD_CONNECT); 1362 else { 1363 ch->newmod = para; 1364 ch->newcmd = PCTRL_CMD_FTM; 1365 nom = 0; 1366 ctrl = PCTRL_CMD_ESC; 1367 ch->state = STFAX_ESCAPE; 1368 } 1369 break; 1370 case HW_MOD_FTH: 1371 if (ch->state == STFAX_READY) { 1372 p1 = para; 1373 ctrl = PCTRL_CMD_FTH; 1374 nom = 1; 1375 ch->state = STFAX_LINE; 1376 ch->cmd = ctrl; 1377 ch->mod = para; 1378 ch->newmod = 0; 1379 ch->newcmd = 0; 1380 ch->try_mod = 3; 1381 } else if ((ch->state == STFAX_ACTIV) && 1382 (ch->cmd == PCTRL_CMD_FTH) && (ch->mod == para)) 1383 deliver_status(ch, HW_MOD_CONNECT); 1384 else { 1385 ch->newmod = para; 1386 ch->newcmd = PCTRL_CMD_FTH; 1387 nom = 0; 1388 ctrl = PCTRL_CMD_ESC; 1389 ch->state = STFAX_ESCAPE; 1390 } 1391 break; 1392 case HW_MOD_FRM: 1393 if (ch->state == STFAX_READY) { 1394 p1 = para; 1395 ctrl = PCTRL_CMD_FRM; 1396 nom = 1; 1397 ch->state = STFAX_LINE; 1398 ch->cmd = ctrl; 1399 ch->mod = para; 1400 ch->newmod = 0; 1401 ch->newcmd = 0; 1402 ch->try_mod = 3; 1403 } else if ((ch->state == STFAX_ACTIV) && 1404 (ch->cmd == PCTRL_CMD_FRM) && (ch->mod == para)) 1405 deliver_status(ch, HW_MOD_CONNECT); 1406 else { 1407 ch->newmod = para; 1408 ch->newcmd = PCTRL_CMD_FRM; 1409 nom = 0; 1410 ctrl = PCTRL_CMD_ESC; 1411 ch->state = STFAX_ESCAPE; 1412 } 1413 break; 1414 case HW_MOD_FRH: 1415 if (ch->state == STFAX_READY) { 1416 p1 = para; 1417 ctrl = PCTRL_CMD_FRH; 1418 nom = 1; 1419 ch->state = STFAX_LINE; 1420 ch->cmd = ctrl; 1421 ch->mod = para; 1422 ch->newmod = 0; 1423 ch->newcmd = 0; 1424 ch->try_mod = 3; 1425 } else if ((ch->state == STFAX_ACTIV) && 1426 (ch->cmd == PCTRL_CMD_FRH) && (ch->mod == para)) 1427 deliver_status(ch, HW_MOD_CONNECT); 1428 else { 1429 ch->newmod = para; 1430 ch->newcmd = PCTRL_CMD_FRH; 1431 nom = 0; 1432 ctrl = PCTRL_CMD_ESC; 1433 ch->state = STFAX_ESCAPE; 1434 } 1435 break; 1436 case PCTRL_CMD_TDTMF: 1437 p1 = para; 1438 nom = 1; 1439 ctrl = PCTRL_CMD_TDTMF; 1440 break; 1441 } 1442 if (ctrl) 1443 send_mbox(ch->is, dps | ISAR_HIS_PUMPCTRL, ctrl, nom, &p1); 1444 } 1445 1446 static void 1447 isar_setup(struct isar_hw *isar) 1448 { 1449 u8 msg; 1450 int i; 1451 1452 /* Dpath 1, 2 */ 1453 msg = 61; 1454 for (i = 0; i < 2; i++) { 1455 /* Buffer Config */ 1456 send_mbox(isar, (i ? ISAR_HIS_DPS2 : ISAR_HIS_DPS1) | 1457 ISAR_HIS_P12CFG, 4, 1, &msg); 1458 isar->ch[i].mml = msg; 1459 isar->ch[i].bch.state = 0; 1460 isar->ch[i].dpath = i + 1; 1461 modeisar(&isar->ch[i], ISDN_P_NONE); 1462 } 1463 } 1464 1465 static int 1466 isar_l2l1(struct mISDNchannel *ch, struct sk_buff *skb) 1467 { 1468 struct bchannel *bch = container_of(ch, struct bchannel, ch); 1469 struct isar_ch *ich = container_of(bch, struct isar_ch, bch); 1470 int ret = -EINVAL; 1471 struct mISDNhead *hh = mISDN_HEAD_P(skb); 1472 u32 id, *val; 1473 u_long flags; 1474 1475 switch (hh->prim) { 1476 case PH_DATA_REQ: 1477 spin_lock_irqsave(ich->is->hwlock, flags); 1478 ret = bchannel_senddata(bch, skb); 1479 if (ret > 0) { /* direct TX */ 1480 ret = 0; 1481 isar_fill_fifo(ich); 1482 } 1483 spin_unlock_irqrestore(ich->is->hwlock, flags); 1484 return ret; 1485 case PH_ACTIVATE_REQ: 1486 spin_lock_irqsave(ich->is->hwlock, flags); 1487 if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags)) 1488 ret = modeisar(ich, ch->protocol); 1489 else 1490 ret = 0; 1491 spin_unlock_irqrestore(ich->is->hwlock, flags); 1492 if (!ret) 1493 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 0, 1494 NULL, GFP_KERNEL); 1495 break; 1496 case PH_DEACTIVATE_REQ: 1497 spin_lock_irqsave(ich->is->hwlock, flags); 1498 mISDN_clear_bchannel(bch); 1499 modeisar(ich, ISDN_P_NONE); 1500 spin_unlock_irqrestore(ich->is->hwlock, flags); 1501 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0, 1502 NULL, GFP_KERNEL); 1503 ret = 0; 1504 break; 1505 case PH_CONTROL_REQ: 1506 val = (u32 *)skb->data; 1507 pr_debug("%s: PH_CONTROL | REQUEST %x/%x\n", ich->is->name, 1508 hh->id, *val); 1509 if ((hh->id == 0) && ((*val & ~DTMF_TONE_MASK) == 1510 DTMF_TONE_VAL)) { 1511 if (bch->state == ISDN_P_B_L2DTMF) { 1512 char tt = *val & DTMF_TONE_MASK; 1513 1514 if (tt == '*') 1515 tt = 0x1e; 1516 else if (tt == '#') 1517 tt = 0x1f; 1518 else if (tt > '9') 1519 tt -= 7; 1520 tt &= 0x1f; 1521 spin_lock_irqsave(ich->is->hwlock, flags); 1522 isar_pump_cmd(ich, PCTRL_CMD_TDTMF, tt); 1523 spin_unlock_irqrestore(ich->is->hwlock, flags); 1524 } else { 1525 pr_info("%s: DTMF send wrong protocol %x\n", 1526 __func__, bch->state); 1527 return -EINVAL; 1528 } 1529 } else if ((hh->id == HW_MOD_FRM) || (hh->id == HW_MOD_FRH) || 1530 (hh->id == HW_MOD_FTM) || (hh->id == HW_MOD_FTH)) { 1531 for (id = 0; id < FAXMODCNT; id++) 1532 if (faxmodulation[id] == *val) 1533 break; 1534 if ((FAXMODCNT > id) && 1535 test_bit(FLG_INITIALIZED, &bch->Flags)) { 1536 pr_debug("%s: isar: new mod\n", ich->is->name); 1537 isar_pump_cmd(ich, hh->id, *val); 1538 ret = 0; 1539 } else { 1540 pr_info("%s: wrong modulation\n", 1541 ich->is->name); 1542 ret = -EINVAL; 1543 } 1544 } else if (hh->id == HW_MOD_LASTDATA) 1545 test_and_set_bit(FLG_DLEETX, &bch->Flags); 1546 else { 1547 pr_info("%s: unknown PH_CONTROL_REQ %x\n", 1548 ich->is->name, hh->id); 1549 ret = -EINVAL; 1550 } 1551 /* fall through */ 1552 default: 1553 pr_info("%s: %s unknown prim(%x,%x)\n", 1554 ich->is->name, __func__, hh->prim, hh->id); 1555 ret = -EINVAL; 1556 } 1557 if (!ret) 1558 dev_kfree_skb(skb); 1559 return ret; 1560 } 1561 1562 static int 1563 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq) 1564 { 1565 return mISDN_ctrl_bchannel(bch, cq); 1566 } 1567 1568 static int 1569 isar_bctrl(struct mISDNchannel *ch, u32 cmd, void *arg) 1570 { 1571 struct bchannel *bch = container_of(ch, struct bchannel, ch); 1572 struct isar_ch *ich = container_of(bch, struct isar_ch, bch); 1573 int ret = -EINVAL; 1574 u_long flags; 1575 1576 pr_debug("%s: %s cmd:%x %p\n", ich->is->name, __func__, cmd, arg); 1577 switch (cmd) { 1578 case CLOSE_CHANNEL: 1579 test_and_clear_bit(FLG_OPEN, &bch->Flags); 1580 cancel_work_sync(&bch->workq); 1581 spin_lock_irqsave(ich->is->hwlock, flags); 1582 mISDN_clear_bchannel(bch); 1583 modeisar(ich, ISDN_P_NONE); 1584 spin_unlock_irqrestore(ich->is->hwlock, flags); 1585 ch->protocol = ISDN_P_NONE; 1586 ch->peer = NULL; 1587 module_put(ich->is->owner); 1588 ret = 0; 1589 break; 1590 case CONTROL_CHANNEL: 1591 ret = channel_bctrl(bch, arg); 1592 break; 1593 default: 1594 pr_info("%s: %s unknown prim(%x)\n", 1595 ich->is->name, __func__, cmd); 1596 } 1597 return ret; 1598 } 1599 1600 static void 1601 free_isar(struct isar_hw *isar) 1602 { 1603 modeisar(&isar->ch[0], ISDN_P_NONE); 1604 modeisar(&isar->ch[1], ISDN_P_NONE); 1605 del_timer(&isar->ch[0].ftimer); 1606 del_timer(&isar->ch[1].ftimer); 1607 test_and_clear_bit(FLG_INITIALIZED, &isar->ch[0].bch.Flags); 1608 test_and_clear_bit(FLG_INITIALIZED, &isar->ch[1].bch.Flags); 1609 } 1610 1611 static int 1612 init_isar(struct isar_hw *isar) 1613 { 1614 int cnt = 3; 1615 1616 while (cnt--) { 1617 isar->version = ISARVersion(isar); 1618 if (isar->ch[0].bch.debug & DEBUG_HW) 1619 pr_notice("%s: Testing version %d (%d time)\n", 1620 isar->name, isar->version, 3 - cnt); 1621 if (isar->version == 1) 1622 break; 1623 isar->ctrl(isar->hw, HW_RESET_REQ, 0); 1624 } 1625 if (isar->version != 1) 1626 return -EINVAL; 1627 timer_setup(&isar->ch[0].ftimer, ftimer_handler, 0); 1628 test_and_set_bit(FLG_INITIALIZED, &isar->ch[0].bch.Flags); 1629 timer_setup(&isar->ch[1].ftimer, ftimer_handler, 0); 1630 test_and_set_bit(FLG_INITIALIZED, &isar->ch[1].bch.Flags); 1631 return 0; 1632 } 1633 1634 static int 1635 isar_open(struct isar_hw *isar, struct channel_req *rq) 1636 { 1637 struct bchannel *bch; 1638 1639 if (rq->adr.channel == 0 || rq->adr.channel > 2) 1640 return -EINVAL; 1641 if (rq->protocol == ISDN_P_NONE) 1642 return -EINVAL; 1643 bch = &isar->ch[rq->adr.channel - 1].bch; 1644 if (test_and_set_bit(FLG_OPEN, &bch->Flags)) 1645 return -EBUSY; /* b-channel can be only open once */ 1646 bch->ch.protocol = rq->protocol; 1647 rq->ch = &bch->ch; 1648 return 0; 1649 } 1650 1651 u32 1652 mISDNisar_init(struct isar_hw *isar, void *hw) 1653 { 1654 u32 ret, i; 1655 1656 isar->hw = hw; 1657 for (i = 0; i < 2; i++) { 1658 isar->ch[i].bch.nr = i + 1; 1659 mISDN_initbchannel(&isar->ch[i].bch, MAX_DATA_MEM, 32); 1660 isar->ch[i].bch.ch.nr = i + 1; 1661 isar->ch[i].bch.ch.send = &isar_l2l1; 1662 isar->ch[i].bch.ch.ctrl = isar_bctrl; 1663 isar->ch[i].bch.hw = hw; 1664 isar->ch[i].is = isar; 1665 } 1666 1667 isar->init = &init_isar; 1668 isar->release = &free_isar; 1669 isar->firmware = &load_firmware; 1670 isar->open = &isar_open; 1671 1672 ret = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) | 1673 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK)) | 1674 (1 << (ISDN_P_B_L2DTMF & ISDN_P_B_MASK)) | 1675 (1 << (ISDN_P_B_MODEM_ASYNC & ISDN_P_B_MASK)) | 1676 (1 << (ISDN_P_B_T30_FAX & ISDN_P_B_MASK)); 1677 1678 return ret; 1679 } 1680 EXPORT_SYMBOL(mISDNisar_init); 1681 1682 static int __init isar_mod_init(void) 1683 { 1684 pr_notice("mISDN: ISAR driver Rev. %s\n", ISAR_REV); 1685 return 0; 1686 } 1687 1688 static void __exit isar_mod_cleanup(void) 1689 { 1690 pr_notice("mISDN: ISAR module unloaded\n"); 1691 } 1692 module_init(isar_mod_init); 1693 module_exit(isar_mod_cleanup); 1694