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