LXR linux/drivers/isdn/hisax/elsa

   1/* $Id: elsa_ser.c,v 2.14.2.3 2004/02/11 13:21:33 keil 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#include <linux/slab.h>
  13
  14#define MAX_MODEM_BUF   256
  15#define WAKEUP_CHARS    (MAX_MODEM_BUF / 2)
  16#define RS_ISR_PASS_LIMIT 256
  17#define BASE_BAUD (1843200 / 16)
  18
  19//#define SERIAL_DEBUG_OPEN 1
  20//#define SERIAL_DEBUG_INTR 1
  21//#define SERIAL_DEBUG_FLOW 1
  22#undef SERIAL_DEBUG_OPEN
  23#undef SERIAL_DEBUG_INTR
  24#undef SERIAL_DEBUG_FLOW
  25#undef SERIAL_DEBUG_REG
  26//#define SERIAL_DEBUG_REG 1
  27
  28#ifdef SERIAL_DEBUG_REG
  29static u_char deb[32];
  30const char *ModemIn[] = {"RBR", "IER", "IIR", "LCR", "MCR", "LSR", "MSR", "SCR"};
  31const char *ModemOut[] = {"THR", "IER", "FCR", "LCR", "MCR", "LSR", "MSR", "SCR"};
  32#endif
  33
  34static char *MInit_1 = "AT&F&C1E0&D2\r\0";
  35static char *MInit_2 = "ATL2M1S64=13\r\0";
  36static char *MInit_3 = "AT+FCLASS=0\r\0";
  37static char *MInit_4 = "ATV1S2=128X1\r\0";
  38static char *MInit_5 = "AT\\V8\\N3\r\0";
  39static char *MInit_6 = "ATL0M0&G0%E1\r\0";
  40static char *MInit_7 = "AT%L1%M0%C3\r\0";
  41
  42static char *MInit_speed28800 = "AT%G0%B28800\r\0";
  43
  44static char *MInit_dialout = "ATs7=60 x1 d\r\0";
  45static char *MInit_dialin = "ATs7=60 x1 a\r\0";
  46
  47
  48static inline unsigned int serial_in(struct IsdnCardState *cs, int offset)
  49{
  50#ifdef SERIAL_DEBUG_REG
  51        u_int val = inb(cs->hw.elsa.base + 8 + offset);
  52        debugl1(cs, "in   %s %02x", ModemIn[offset], val);
  53        return (val);
  54#else
  55        return inb(cs->hw.elsa.base + 8 + offset);
  56#endif
  57}
  58
  59static inline unsigned int serial_inp(struct IsdnCardState *cs, int offset)
  60{
  61#ifdef SERIAL_DEBUG_REG
  62#ifdef ELSA_SERIAL_NOPAUSE_IO
  63        u_int val = inb(cs->hw.elsa.base + 8 + offset);
  64        debugl1(cs, "inp  %s %02x", ModemIn[offset], val);
  65#else
  66        u_int val = inb_p(cs->hw.elsa.base + 8 + offset);
  67        debugl1(cs, "inP  %s %02x", ModemIn[offset], val);
  68#endif
  69        return (val);
  70#else
  71#ifdef ELSA_SERIAL_NOPAUSE_IO
  72        return inb(cs->hw.elsa.base + 8 + offset);
  73#else
  74        return inb_p(cs->hw.elsa.base + 8 + offset);
  75#endif
  76#endif
  77}
  78
  79static inline void serial_out(struct IsdnCardState *cs, int offset, int value)
  80{
  81#ifdef SERIAL_DEBUG_REG
  82        debugl1(cs, "out  %s %02x", ModemOut[offset], value);
  83#endif
  84        outb(value, cs->hw.elsa.base + 8 + offset);
  85}
  86
  87static inline void serial_outp(struct IsdnCardState *cs, int offset,
  88                               int value)
  89{
  90#ifdef SERIAL_DEBUG_REG
  91#ifdef ELSA_SERIAL_NOPAUSE_IO
  92        debugl1(cs, "outp %s %02x", ModemOut[offset], value);
  93#else
  94        debugl1(cs, "outP %s %02x", ModemOut[offset], value);
  95#endif
  96#endif
  97#ifdef ELSA_SERIAL_NOPAUSE_IO
  98        outb(value, cs->hw.elsa.base + 8 + offset);
  99#else
 100        outb_p(value, cs->hw.elsa.base + 8 + offset);
 101#endif
 102}
 103
 104/*
 105 * This routine is called to set the UART divisor registers to match
 106 * the specified baud rate for a serial port.
 107 */
 108static void change_speed(struct IsdnCardState *cs, int baud)
 109{
 110        int     quot = 0, baud_base;
 111        unsigned cval, fcr = 0;
 112
 113
 114        /* byte size and parity */
 115        cval = 0x03;
 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, "%s", 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(struct IsdnCardState *cs)
 388{
 389        int status, iir, msr;
 390        int pass_counter = 0;
 391
 392#ifdef SERIAL_DEBUG_INTR
 393        printk(KERN_DEBUG "rs_interrupt_single(%d)...", cs->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 20
 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        mdelay(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        mdelay(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        mdelay(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        mdelay(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        mdelay(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        mdelay(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        mdelay(RCV_DELAY);
 523}
 524
 525static void
 526modem_set_dial(struct IsdnCardState *cs, int outgoing) {
 527        int timeout;
 528#define RCV_DELAY 20
 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        mdelay(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        mdelay(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                wait_event_interruptible(bcs->cs->dc.isac.arcofi_wait,
 577                                 bcs->cs->dc.isac.arcofi_state == ARCOFI_NOP);
 578                bcs->cs->hw.elsa.MFlag = 1;
 579        } else {
 580                printk(KERN_WARNING "ElsaSer: unknown pr %x\n", pr);
 581        }
 582}
 583
 584static int
 585setstack_elsa(struct PStack *st, struct BCState *bcs)
 586{
 587
 588        bcs->channel = st->l1.bc;
 589        switch (st->l1.mode) {
 590        case L1_MODE_HDLC:
 591        case L1_MODE_TRANS:
 592                if (open_hscxstate(st->l1.hardware, bcs))
 593                        return (-1);
 594                st->l2.l2l1 = hscx_l2l1;
 595                break;
 596        case L1_MODE_MODEM:
 597                bcs->mode = L1_MODE_MODEM;
 598                if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
 599                        bcs->hw.hscx.rcvbuf = bcs->cs->hw.elsa.rcvbuf;
 600                        skb_queue_head_init(&bcs->rqueue);
 601                        skb_queue_head_init(&bcs->squeue);
 602                }
 603                bcs->tx_skb = NULL;
 604                test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
 605                bcs->event = 0;
 606                bcs->hw.hscx.rcvidx = 0;
 607                bcs->tx_cnt = 0;
 608                bcs->cs->hw.elsa.bcs = bcs;
 609                st->l2.l2l1 = modem_l2l1;
 610                break;
 611        }
 612        st->l1.bcs = bcs;
 613        setstack_manager(st);
 614        bcs->st = st;
 615        setstack_l1_B(st);
 616        return (0);
 617}
 618
 619static void
 620init_modem(struct IsdnCardState *cs) {
 621
 622        cs->bcs[0].BC_SetStack = setstack_elsa;
 623        cs->bcs[1].BC_SetStack = setstack_elsa;
 624        cs->bcs[0].BC_Close = close_elsastate;
 625        cs->bcs[1].BC_Close = close_elsastate;
 626        if (!(cs->hw.elsa.rcvbuf = kmalloc(MAX_MODEM_BUF,
 627                                           GFP_ATOMIC))) {
 628                printk(KERN_WARNING
 629                       "Elsa: No modem mem hw.elsa.rcvbuf\n");
 630                return;
 631        }
 632        if (!(cs->hw.elsa.transbuf = kmalloc(MAX_MODEM_BUF,
 633                                             GFP_ATOMIC))) {
 634                printk(KERN_WARNING
 635                       "Elsa: No modem mem hw.elsa.transbuf\n");
 636                kfree(cs->hw.elsa.rcvbuf);
 637                cs->hw.elsa.rcvbuf = NULL;
 638                return;
 639        }
 640        if (mstartup(cs)) {
 641                printk(KERN_WARNING "Elsa: problem startup modem\n");
 642        }
 643        modem_set_init(cs);
 644}
 645
 646static void
 647release_modem(struct IsdnCardState *cs) {
 648
 649        cs->hw.elsa.MFlag = 0;
 650        if (cs->hw.elsa.transbuf) {
 651                if (cs->hw.elsa.rcvbuf) {
 652                        mshutdown(cs);
 653                        kfree(cs->hw.elsa.rcvbuf);
 654                        cs->hw.elsa.rcvbuf = NULL;
 655                }
 656                kfree(cs->hw.elsa.transbuf);
 657                cs->hw.elsa.transbuf = NULL;
 658        }
 659}
 660