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