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