1/* $Id: elsa_ser.c,v 1.1.1.1 2007/08/03 18:52:35 Exp $ 2 * 3 * stuff for the serial modem on ELSA cards 4 * 5 * This software may be used and distributed according to the terms 6 * of the GNU General Public License, incorporated herein by reference. 7 * 8 */ 9 10#include <linux/serial.h> 11#include <linux/serial_reg.h> 12 13#define MAX_MODEM_BUF 256 14#define WAKEUP_CHARS (MAX_MODEM_BUF/2) 15#define RS_ISR_PASS_LIMIT 256 16#define BASE_BAUD ( 1843200 / 16 ) 17 18//#define SERIAL_DEBUG_OPEN 1 19//#define SERIAL_DEBUG_INTR 1 20//#define SERIAL_DEBUG_FLOW 1 21#undef SERIAL_DEBUG_OPEN 22#undef SERIAL_DEBUG_INTR 23#undef SERIAL_DEBUG_FLOW 24#undef SERIAL_DEBUG_REG 25//#define SERIAL_DEBUG_REG 1 26 27#ifdef SERIAL_DEBUG_REG 28static u_char deb[32]; 29const char *ModemIn[] = {"RBR","IER","IIR","LCR","MCR","LSR","MSR","SCR"}; 30const char *ModemOut[] = {"THR","IER","FCR","LCR","MCR","LSR","MSR","SCR"}; 31#endif 32 33static char *MInit_1 = "AT&F&C1E0&D2\r\0"; 34static char *MInit_2 = "ATL2M1S64=13\r\0"; 35static char *MInit_3 = "AT+FCLASS=0\r\0"; 36static char *MInit_4 = "ATV1S2=128X1\r\0"; 37static char *MInit_5 = "AT\\V8\\N3\r\0"; 38static char *MInit_6 = "ATL0M0&G0%E1\r\0"; 39static char *MInit_7 = "AT%L1%M0%C3\r\0"; 40 41static char *MInit_speed28800 = "AT%G0%B28800\r\0"; 42 43static char *MInit_dialout = "ATs7=60 x1 d\r\0"; 44static char *MInit_dialin = "ATs7=60 x1 a\r\0"; 45 46 47static inline unsigned int serial_in(struct IsdnCardState *cs, int offset) 48{ 49#ifdef SERIAL_DEBUG_REG 50 u_int val = inb(cs->hw.elsa.base + 8 + offset); 51 debugl1(cs,"in %s %02x",ModemIn[offset], val); 52 return(val); 53#else 54 return inb(cs->hw.elsa.base + 8 + offset); 55#endif 56} 57 58static inline unsigned int serial_inp(struct IsdnCardState *cs, int offset) 59{ 60#ifdef SERIAL_DEBUG_REG 61#ifdef ELSA_SERIAL_NOPAUSE_IO 62 u_int val = inb(cs->hw.elsa.base + 8 + offset); 63 debugl1(cs,"inp %s %02x",ModemIn[offset], val); 64#else 65 u_int val = inb_p(cs->hw.elsa.base + 8 + offset); 66 debugl1(cs,"inP %s %02x",ModemIn[offset], val); 67#endif 68 return(val); 69#else 70#ifdef ELSA_SERIAL_NOPAUSE_IO 71 return inb(cs->hw.elsa.base + 8 + offset); 72#else 73 return inb_p(cs->hw.elsa.base + 8 + offset); 74#endif 75#endif 76} 77 78static inline void serial_out(struct IsdnCardState *cs, int offset, int value) 79{ 80#ifdef SERIAL_DEBUG_REG 81 debugl1(cs,"out %s %02x",ModemOut[offset], value); 82#endif 83 outb(value, cs->hw.elsa.base + 8 + offset); 84} 85 86static inline void serial_outp(struct IsdnCardState *cs, int offset, 87 int value) 88{ 89#ifdef SERIAL_DEBUG_REG 90#ifdef ELSA_SERIAL_NOPAUSE_IO 91 debugl1(cs,"outp %s %02x",ModemOut[offset], value); 92#else 93 debugl1(cs,"outP %s %02x",ModemOut[offset], value); 94#endif 95#endif 96#ifdef ELSA_SERIAL_NOPAUSE_IO 97 outb(value, cs->hw.elsa.base + 8 + offset); 98#else 99 outb_p(value, cs->hw.elsa.base + 8 + offset); 100#endif 101} 102 103/* 104 * This routine is called to set the UART divisor registers to match 105 * the specified baud rate for a serial port. 106 */ 107static void change_speed(struct IsdnCardState *cs, int baud) 108{ 109 int quot = 0, baud_base; 110 unsigned cval, fcr = 0; 111 int bits; 112 113 114 /* byte size and parity */ 115 cval = 0x03; bits = 10; 116 /* Determine divisor based on baud rate */ 117 baud_base = BASE_BAUD; 118 quot = baud_base / baud; 119 /* If the quotient is ever zero, default to 9600 bps */ 120 if (!quot) 121 quot = baud_base / 9600; 122 123 /* Set up FIFO's */ 124 if ((baud_base / quot) < 2400) 125 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1; 126 else 127 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8; 128 serial_outp(cs, UART_FCR, fcr); 129 /* CTS flow control flag and modem status interrupts */ 130 cs->hw.elsa.IER &= ~UART_IER_MSI; 131 cs->hw.elsa.IER |= UART_IER_MSI; 132 serial_outp(cs, UART_IER, cs->hw.elsa.IER); 133 134 debugl1(cs,"modem quot=0x%x", quot); 135 serial_outp(cs, UART_LCR, cval | UART_LCR_DLAB);/* set DLAB */ 136 serial_outp(cs, UART_DLL, quot & 0xff); /* LS of divisor */ 137 serial_outp(cs, UART_DLM, quot >> 8); /* MS of divisor */ 138 serial_outp(cs, UART_LCR, cval); /* reset DLAB */ 139 serial_inp(cs, UART_RX); 140} 141 142static int mstartup(struct IsdnCardState *cs) 143{ 144 int retval=0; 145 146 /* 147 * Clear the FIFO buffers and disable them 148 * (they will be reenabled in change_speed()) 149 */ 150 serial_outp(cs, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT)); 151 152 /* 153 * At this point there's no way the LSR could still be 0xFF; 154 * if it is, then bail out, because there's likely no UART 155 * here. 156 */ 157 if (serial_inp(cs, UART_LSR) == 0xff) { 158 retval = -ENODEV; 159 goto errout; 160 } 161 162 /* 163 * Clear the interrupt registers. 164 */ 165 (void) serial_inp(cs, UART_RX); 166 (void) serial_inp(cs, UART_IIR); 167 (void) serial_inp(cs, UART_MSR); 168 169 /* 170 * Now, initialize the UART 171 */ 172 serial_outp(cs, UART_LCR, UART_LCR_WLEN8); /* reset DLAB */ 173 174 cs->hw.elsa.MCR = 0; 175 cs->hw.elsa.MCR = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2; 176 serial_outp(cs, UART_MCR, cs->hw.elsa.MCR); 177 178 /* 179 * Finally, enable interrupts 180 */ 181 cs->hw.elsa.IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI; 182 serial_outp(cs, UART_IER, cs->hw.elsa.IER); /* enable interrupts */ 183 184 /* 185 * And clear the interrupt registers again for luck. 186 */ 187 (void)serial_inp(cs, UART_LSR); 188 (void)serial_inp(cs, UART_RX); 189 (void)serial_inp(cs, UART_IIR); 190 (void)serial_inp(cs, UART_MSR); 191 192 cs->hw.elsa.transcnt = cs->hw.elsa.transp = 0; 193 cs->hw.elsa.rcvcnt = cs->hw.elsa.rcvp =0; 194 195 /* 196 * and set the speed of the serial port 197 */ 198 change_speed(cs, BASE_BAUD); 199 cs->hw.elsa.MFlag = 1; 200errout: 201 return retval; 202} 203 204/* 205 * This routine will shutdown a serial port; interrupts are disabled, and 206 * DTR is dropped if the hangup on close termio flag is on. 207 */ 208static void mshutdown(struct IsdnCardState *cs) 209{ 210 211#ifdef SERIAL_DEBUG_OPEN 212 printk(KERN_DEBUG"Shutting down serial ...."); 213#endif 214 215 /* 216 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq 217 * here so the queue might never be waken up 218 */ 219 220 cs->hw.elsa.IER = 0; 221 serial_outp(cs, UART_IER, 0x00); /* disable all intrs */ 222 cs->hw.elsa.MCR &= ~UART_MCR_OUT2; 223 224 /* disable break condition */ 225 serial_outp(cs, UART_LCR, serial_inp(cs, UART_LCR) & ~UART_LCR_SBC); 226 227 cs->hw.elsa.MCR &= ~(UART_MCR_DTR|UART_MCR_RTS); 228 serial_outp(cs, UART_MCR, cs->hw.elsa.MCR); 229 230 /* disable FIFO's */ 231 serial_outp(cs, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT)); 232 serial_inp(cs, UART_RX); /* read data port to reset things */ 233 234#ifdef SERIAL_DEBUG_OPEN 235 printk(" done\n"); 236#endif 237} 238 239static inline int 240write_modem(struct BCState *bcs) { 241 int ret=0; 242 struct IsdnCardState *cs = bcs->cs; 243 int count, len, fp; 244 245 if (!bcs->tx_skb) 246 return 0; 247 if (bcs->tx_skb->len <= 0) 248 return 0; 249 len = bcs->tx_skb->len; 250 if (len > MAX_MODEM_BUF - cs->hw.elsa.transcnt) 251 len = MAX_MODEM_BUF - cs->hw.elsa.transcnt; 252 fp = cs->hw.elsa.transcnt + cs->hw.elsa.transp; 253 fp &= (MAX_MODEM_BUF -1); 254 count = len; 255 if (count > MAX_MODEM_BUF - fp) { 256 count = MAX_MODEM_BUF - fp; 257 skb_copy_from_linear_data(bcs->tx_skb, 258 cs->hw.elsa.transbuf + fp, count); 259 skb_pull(bcs->tx_skb, count); 260 cs->hw.elsa.transcnt += count; 261 ret = count; 262 count = len - count; 263 fp = 0; 264 } 265 skb_copy_from_linear_data(bcs->tx_skb, 266 cs->hw.elsa.transbuf + fp, count); 267 skb_pull(bcs->tx_skb, count); 268 cs->hw.elsa.transcnt += count; 269 ret += count; 270 271 if (cs->hw.elsa.transcnt && 272 !(cs->hw.elsa.IER & UART_IER_THRI)) { 273 cs->hw.elsa.IER |= UART_IER_THRI; 274 serial_outp(cs, UART_IER, cs->hw.elsa.IER); 275 } 276 return(ret); 277} 278 279static inline void 280modem_fill(struct BCState *bcs) { 281 282 if (bcs->tx_skb) { 283 if (bcs->tx_skb->len) { 284 write_modem(bcs); 285 return; 286 } else { 287 if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag) && 288 (PACKET_NOACK != bcs->tx_skb->pkt_type)) { 289 u_long flags; 290 spin_lock_irqsave(&bcs->aclock, flags); 291 bcs->ackcnt += bcs->hw.hscx.count; 292 spin_unlock_irqrestore(&bcs->aclock, flags); 293 schedule_event(bcs, B_ACKPENDING); 294 } 295 dev_kfree_skb_any(bcs->tx_skb); 296 bcs->tx_skb = NULL; 297 } 298 } 299 if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) { 300 bcs->hw.hscx.count = 0; 301 test_and_set_bit(BC_FLG_BUSY, &bcs->Flag); 302 write_modem(bcs); 303 } else { 304 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag); 305 schedule_event(bcs, B_XMTBUFREADY); 306 } 307} 308 309static inline void receive_chars(struct IsdnCardState *cs, 310 int *status) 311{ 312 unsigned char ch; 313 struct sk_buff *skb; 314 315 do { 316 ch = serial_in(cs, UART_RX); 317 if (cs->hw.elsa.rcvcnt >= MAX_MODEM_BUF) 318 break; 319 cs->hw.elsa.rcvbuf[cs->hw.elsa.rcvcnt++] = ch; 320#ifdef SERIAL_DEBUG_INTR 321 printk("DR%02x:%02x...", ch, *status); 322#endif 323 if (*status & (UART_LSR_BI | UART_LSR_PE | 324 UART_LSR_FE | UART_LSR_OE)) { 325 326#ifdef SERIAL_DEBUG_INTR 327 printk("handling exept...."); 328#endif 329 } 330 *status = serial_inp(cs, UART_LSR); 331 } while (*status & UART_LSR_DR); 332 if (cs->hw.elsa.MFlag == 2) { 333 if (!(skb = dev_alloc_skb(cs->hw.elsa.rcvcnt))) 334 printk(KERN_WARNING "ElsaSER: receive out of memory\n"); 335 else { 336 memcpy(skb_put(skb, cs->hw.elsa.rcvcnt), cs->hw.elsa.rcvbuf, 337 cs->hw.elsa.rcvcnt); 338 skb_queue_tail(& cs->hw.elsa.bcs->rqueue, skb); 339 } 340 schedule_event(cs->hw.elsa.bcs, B_RCVBUFREADY); 341 } else { 342 char tmp[128]; 343 char *t = tmp; 344 345 t += sprintf(t, "modem read cnt %d", cs->hw.elsa.rcvcnt); 346 QuickHex(t, cs->hw.elsa.rcvbuf, cs->hw.elsa.rcvcnt); 347 debugl1(cs, tmp); 348 } 349 cs->hw.elsa.rcvcnt = 0; 350} 351 352static inline void transmit_chars(struct IsdnCardState *cs, int *intr_done) 353{ 354 int count; 355 356 debugl1(cs, "transmit_chars: p(%x) cnt(%x)", cs->hw.elsa.transp, 357 cs->hw.elsa.transcnt); 358 359 if (cs->hw.elsa.transcnt <= 0) { 360 cs->hw.elsa.IER &= ~UART_IER_THRI; 361 serial_out(cs, UART_IER, cs->hw.elsa.IER); 362 return; 363 } 364 count = 16; 365 do { 366 serial_outp(cs, UART_TX, cs->hw.elsa.transbuf[cs->hw.elsa.transp++]); 367 if (cs->hw.elsa.transp >= MAX_MODEM_BUF) 368 cs->hw.elsa.transp=0; 369 if (--cs->hw.elsa.transcnt <= 0) 370 break; 371 } while (--count > 0); 372 if ((cs->hw.elsa.transcnt < WAKEUP_CHARS) && (cs->hw.elsa.MFlag==2)) 373 modem_fill(cs->hw.elsa.bcs); 374 375#ifdef SERIAL_DEBUG_INTR 376 printk("THRE..."); 377#endif 378 if (intr_done) 379 *intr_done = 0; 380 if (cs->hw.elsa.transcnt <= 0) { 381 cs->hw.elsa.IER &= ~UART_IER_THRI; 382 serial_outp(cs, UART_IER, cs->hw.elsa.IER); 383 } 384} 385 386 387static void rs_interrupt_elsa(int irq, struct IsdnCardState *cs) 388{ 389 int status, iir, msr; 390 int pass_counter = 0; 391 392#ifdef SERIAL_DEBUG_INTR 393 printk("rs_interrupt_single(%d)...", irq); 394#endif 395 396 do { 397 status = serial_inp(cs, UART_LSR); 398 debugl1(cs,"rs LSR %02x", status); 399#ifdef SERIAL_DEBUG_INTR 400 printk("status = %x...", status); 401#endif 402 if (status & UART_LSR_DR) 403 receive_chars(cs, &status); 404 if (status & UART_LSR_THRE) 405 transmit_chars(cs, NULL); 406 if (pass_counter++ > RS_ISR_PASS_LIMIT) { 407 printk("rs_single loop break.\n"); 408 break; 409 } 410 iir = serial_inp(cs, UART_IIR); 411 debugl1(cs,"rs IIR %02x", iir); 412 if ((iir & 0xf) == 0) { 413 msr = serial_inp(cs, UART_MSR); 414 debugl1(cs,"rs MSR %02x", msr); 415 } 416 } while (!(iir & UART_IIR_NO_INT)); 417#ifdef SERIAL_DEBUG_INTR 418 printk("end.\n"); 419#endif 420} 421 422extern int open_hscxstate(struct IsdnCardState *cs, struct BCState *bcs); 423extern void modehscx(struct BCState *bcs, int mode, int bc); 424extern void hscx_l2l1(struct PStack *st, int pr, void *arg); 425 426static void 427close_elsastate(struct BCState *bcs) 428{ 429 modehscx(bcs, 0, bcs->channel); 430 if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) { 431 if (bcs->hw.hscx.rcvbuf) { 432 if (bcs->mode != L1_MODE_MODEM) 433 kfree(bcs->hw.hscx.rcvbuf); 434 bcs->hw.hscx.rcvbuf = NULL; 435 } 436 skb_queue_purge(&bcs->rqueue); 437 skb_queue_purge(&bcs->squeue); 438 if (bcs->tx_skb) { 439 dev_kfree_skb_any(bcs->tx_skb); 440 bcs->tx_skb = NULL; 441 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag); 442 } 443 } 444} 445 446static void 447modem_write_cmd(struct IsdnCardState *cs, u_char *buf, int len) { 448 int count, fp; 449 u_char *msg = buf; 450 451 if (!len) 452 return; 453 if (len > (MAX_MODEM_BUF - cs->hw.elsa.transcnt)) { 454 return; 455 } 456 fp = cs->hw.elsa.transcnt + cs->hw.elsa.transp; 457 fp &= (MAX_MODEM_BUF -1); 458 count = len; 459 if (count > MAX_MODEM_BUF - fp) { 460 count = MAX_MODEM_BUF - fp; 461 memcpy(cs->hw.elsa.transbuf + fp, msg, count); 462 cs->hw.elsa.transcnt += count; 463 msg += count; 464 count = len - count; 465 fp = 0; 466 } 467 memcpy(cs->hw.elsa.transbuf + fp, msg, count); 468 cs->hw.elsa.transcnt += count; 469 if (cs->hw.elsa.transcnt && 470 !(cs->hw.elsa.IER & UART_IER_THRI)) { 471 cs->hw.elsa.IER |= UART_IER_THRI; 472 serial_outp(cs, UART_IER, cs->hw.elsa.IER); 473 } 474} 475 476static void 477modem_set_init(struct IsdnCardState *cs) { 478 int timeout; 479 480#define RCV_DELAY 20000 481 modem_write_cmd(cs, MInit_1, strlen(MInit_1)); 482 timeout = 1000; 483 while(timeout-- && cs->hw.elsa.transcnt) 484 udelay(1000); 485 debugl1(cs, "msi tout=%d", timeout); 486 udelay(RCV_DELAY); 487 modem_write_cmd(cs, MInit_2, strlen(MInit_2)); 488 timeout = 1000; 489 while(timeout-- && cs->hw.elsa.transcnt) 490 udelay(1000); 491 debugl1(cs, "msi tout=%d", timeout); 492 udelay(RCV_DELAY); 493 modem_write_cmd(cs, MInit_3, strlen(MInit_3)); 494 timeout = 1000; 495 while(timeout-- && cs->hw.elsa.transcnt) 496 udelay(1000); 497 debugl1(cs, "msi tout=%d", timeout); 498 udelay(RCV_DELAY); 499 modem_write_cmd(cs, MInit_4, strlen(MInit_4)); 500 timeout = 1000; 501 while(timeout-- && cs->hw.elsa.transcnt) 502 udelay(1000); 503 debugl1(cs, "msi tout=%d", timeout); 504 udelay(RCV_DELAY ); 505 modem_write_cmd(cs, MInit_5, strlen(MInit_5)); 506 timeout = 1000; 507 while(timeout-- && cs->hw.elsa.transcnt) 508 udelay(1000); 509 debugl1(cs, "msi tout=%d", timeout); 510 udelay(RCV_DELAY); 511 modem_write_cmd(cs, MInit_6, strlen(MInit_6)); 512 timeout = 1000; 513 while(timeout-- && cs->hw.elsa.transcnt) 514 udelay(1000); 515 debugl1(cs, "msi tout=%d", timeout); 516 udelay(RCV_DELAY); 517 modem_write_cmd(cs, MInit_7, strlen(MInit_7)); 518 timeout = 1000; 519 while(timeout-- && cs->hw.elsa.transcnt) 520 udelay(1000); 521 debugl1(cs, "msi tout=%d", timeout); 522 udelay(RCV_DELAY); 523} 524 525static void 526modem_set_dial(struct IsdnCardState *cs, int outgoing) { 527 int timeout; 528#define RCV_DELAY 20000 529 530 modem_write_cmd(cs, MInit_speed28800, strlen(MInit_speed28800)); 531 timeout = 1000; 532 while(timeout-- && cs->hw.elsa.transcnt) 533 udelay(1000); 534 debugl1(cs, "msi tout=%d", timeout); 535 udelay(RCV_DELAY); 536 if (outgoing) 537 modem_write_cmd(cs, MInit_dialout, strlen(MInit_dialout)); 538 else 539 modem_write_cmd(cs, MInit_dialin, strlen(MInit_dialin)); 540 timeout = 1000; 541 while(timeout-- && cs->hw.elsa.transcnt) 542 udelay(1000); 543 debugl1(cs, "msi tout=%d", timeout); 544 udelay(RCV_DELAY); 545} 546 547static void 548modem_l2l1(struct PStack *st, int pr, void *arg) 549{ 550 struct BCState *bcs = st->l1.bcs; 551 struct sk_buff *skb = arg; 552 u_long flags; 553 554 if (pr == (PH_DATA | REQUEST)) { 555 spin_lock_irqsave(&bcs->cs->lock, flags); 556 if (bcs->tx_skb) { 557 skb_queue_tail(&bcs->squeue, skb); 558 } else { 559 bcs->tx_skb = skb; 560 test_and_set_bit(BC_FLG_BUSY, &bcs->Flag); 561 bcs->hw.hscx.count = 0; 562 write_modem(bcs); 563 } 564 spin_unlock_irqrestore(&bcs->cs->lock, flags); 565 } else if (pr == (PH_ACTIVATE | REQUEST)) { 566 test_and_set_bit(BC_FLG_ACTIV, &bcs->Flag); 567 st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL); 568 set_arcofi(bcs->cs, st->l1.bc); 569 mstartup(bcs->cs); 570 modem_set_dial(bcs->cs, test_bit(FLG_ORIG, &st->l2.flag)); 571 bcs->cs->hw.elsa.MFlag=2; 572 } else if (pr == (PH_DEACTIVATE | REQUEST)) { 573 test_and_clear_bit(BC_FLG_ACTIV, &bcs->Flag); 574 bcs->cs->dc.isac.arcofi_bc = st->l1.bc; 575 arcofi_fsm(bcs->cs, ARCOFI_START, &ARCOFI_XOP_0); 576 interruptible_sleep_on(&bcs->cs->dc.isac.arcofi_wait); 577 bcs->cs->hw.elsa.MFlag=1; 578 } else { 579 printk(KERN_WARNING"ElsaSer: unknown pr %x\n", pr); 580 } 581} 582 583static int 584setstack_elsa(struct PStack *st, struct BCState *bcs) 585{ 586 587 bcs->channel = st->l1.bc; 588 switch (st->l1.mode) { 589 case L1_MODE_HDLC: 590 case L1_MODE_TRANS: 591 if (open_hscxstate(st->l1.hardware, bcs)) 592 return (-1); 593 st->l2.l2l1 = hscx_l2l1; 594 break; 595 case L1_MODE_MODEM: 596 bcs->mode = L1_MODE_MODEM; 597 if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) { 598 bcs->hw.hscx.rcvbuf = bcs->cs->hw.elsa.rcvbuf; 599 skb_queue_head_init(&bcs->rqueue); 600 skb_queue_head_init(&bcs->squeue); 601 } 602 bcs->tx_skb = NULL; 603 test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag); 604 bcs->event = 0; 605 bcs->hw.hscx.rcvidx = 0; 606 bcs->tx_cnt = 0; 607 bcs->cs->hw.elsa.bcs = bcs; 608 st->l2.l2l1 = modem_l2l1; 609 break; 610 } 611 st->l1.bcs = bcs; 612 setstack_manager(st); 613 bcs->st = st; 614 setstack_l1_B(st); 615 return (0); 616} 617 618static void 619init_modem(struct IsdnCardState *cs) { 620 621 cs->bcs[0].BC_SetStack = setstack_elsa; 622 cs->bcs[1].BC_SetStack = setstack_elsa; 623 cs->bcs[0].BC_Close = close_elsastate; 624 cs->bcs[1].BC_Close = close_elsastate; 625 if (!(cs->hw.elsa.rcvbuf = kmalloc(MAX_MODEM_BUF, 626 GFP_ATOMIC))) { 627 printk(KERN_WARNING 628 "Elsa: No modem mem hw.elsa.rcvbuf\n"); 629 return; 630 } 631 if (!(cs->hw.elsa.transbuf = kmalloc(MAX_MODEM_BUF, 632 GFP_ATOMIC))) { 633 printk(KERN_WARNING 634 "Elsa: No modem mem hw.elsa.transbuf\n"); 635 kfree(cs->hw.elsa.rcvbuf); 636 cs->hw.elsa.rcvbuf = NULL; 637 return; 638 } 639 if (mstartup(cs)) { 640 printk(KERN_WARNING "Elsa: problem startup modem\n"); 641 } 642 modem_set_init(cs); 643} 644 645static void 646release_modem(struct IsdnCardState *cs) { 647 648 cs->hw.elsa.MFlag = 0; 649 if (cs->hw.elsa.transbuf) { 650 if (cs->hw.elsa.rcvbuf) { 651 mshutdown(cs); 652 kfree(cs->hw.elsa.rcvbuf); 653 cs->hw.elsa.rcvbuf = NULL; 654 } 655 kfree(cs->hw.elsa.transbuf); 656 cs->hw.elsa.transbuf = NULL; 657 } 658} 659