1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * isac.c   ISAC specific routines
4  *
5  * Author       Karsten Keil <keil@isdn4linux.de>
6  *
7  * Copyright 2009  by Karsten Keil <keil@isdn4linux.de>
8  */
9 
10 #include <linux/irqreturn.h>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13 #include <linux/mISDNhw.h>
14 #include "ipac.h"
15 
16 
17 #define DBUSY_TIMER_VALUE	80
18 #define ARCOFI_USE		1
19 
20 #define ISAC_REV		"2.0"
21 
22 MODULE_AUTHOR("Karsten Keil");
23 MODULE_VERSION(ISAC_REV);
24 MODULE_LICENSE("GPL v2");
25 
26 #define ReadISAC(is, o)		(is->read_reg(is->dch.hw, o + is->off))
27 #define	WriteISAC(is, o, v)	(is->write_reg(is->dch.hw, o + is->off, v))
28 #define ReadHSCX(h, o)		(h->ip->read_reg(h->ip->hw, h->off + o))
29 #define WriteHSCX(h, o, v)	(h->ip->write_reg(h->ip->hw, h->off + o, v))
30 #define ReadIPAC(ip, o)		(ip->read_reg(ip->hw, o))
31 #define WriteIPAC(ip, o, v)	(ip->write_reg(ip->hw, o, v))
32 
33 static inline void
34 ph_command(struct isac_hw *isac, u8 command)
35 {
36 	pr_debug("%s: ph_command %x\n", isac->name, command);
37 	if (isac->type & IPAC_TYPE_ISACX)
38 		WriteISAC(isac, ISACX_CIX0, (command << 4) | 0xE);
39 	else
40 		WriteISAC(isac, ISAC_CIX0, (command << 2) | 3);
41 }
42 
43 static void
44 isac_ph_state_change(struct isac_hw *isac)
45 {
46 	switch (isac->state) {
47 	case (ISAC_IND_RS):
48 	case (ISAC_IND_EI):
49 		ph_command(isac, ISAC_CMD_DUI);
50 	}
51 	schedule_event(&isac->dch, FLG_PHCHANGE);
52 }
53 
54 static void
55 isac_ph_state_bh(struct dchannel *dch)
56 {
57 	struct isac_hw *isac = container_of(dch, struct isac_hw, dch);
58 
59 	switch (isac->state) {
60 	case ISAC_IND_RS:
61 	case ISAC_IND_EI:
62 		dch->state = 0;
63 		l1_event(dch->l1, HW_RESET_IND);
64 		break;
65 	case ISAC_IND_DID:
66 		dch->state = 3;
67 		l1_event(dch->l1, HW_DEACT_CNF);
68 		break;
69 	case ISAC_IND_DR:
70 	case ISAC_IND_DR6:
71 		dch->state = 3;
72 		l1_event(dch->l1, HW_DEACT_IND);
73 		break;
74 	case ISAC_IND_PU:
75 		dch->state = 4;
76 		l1_event(dch->l1, HW_POWERUP_IND);
77 		break;
78 	case ISAC_IND_RSY:
79 		if (dch->state <= 5) {
80 			dch->state = 5;
81 			l1_event(dch->l1, ANYSIGNAL);
82 		} else {
83 			dch->state = 8;
84 			l1_event(dch->l1, LOSTFRAMING);
85 		}
86 		break;
87 	case ISAC_IND_ARD:
88 		dch->state = 6;
89 		l1_event(dch->l1, INFO2);
90 		break;
91 	case ISAC_IND_AI8:
92 		dch->state = 7;
93 		l1_event(dch->l1, INFO4_P8);
94 		break;
95 	case ISAC_IND_AI10:
96 		dch->state = 7;
97 		l1_event(dch->l1, INFO4_P10);
98 		break;
99 	}
100 	pr_debug("%s: TE newstate %x\n", isac->name, dch->state);
101 }
102 
103 static void
104 isac_empty_fifo(struct isac_hw *isac, int count)
105 {
106 	u8 *ptr;
107 
108 	pr_debug("%s: %s  %d\n", isac->name, __func__, count);
109 
110 	if (!isac->dch.rx_skb) {
111 		isac->dch.rx_skb = mI_alloc_skb(isac->dch.maxlen, GFP_ATOMIC);
112 		if (!isac->dch.rx_skb) {
113 			pr_info("%s: D receive out of memory\n", isac->name);
114 			WriteISAC(isac, ISAC_CMDR, 0x80);
115 			return;
116 		}
117 	}
118 	if ((isac->dch.rx_skb->len + count) >= isac->dch.maxlen) {
119 		pr_debug("%s: %s overrun %d\n", isac->name, __func__,
120 			 isac->dch.rx_skb->len + count);
121 		WriteISAC(isac, ISAC_CMDR, 0x80);
122 		return;
123 	}
124 	ptr = skb_put(isac->dch.rx_skb, count);
125 	isac->read_fifo(isac->dch.hw, isac->off, ptr, count);
126 	WriteISAC(isac, ISAC_CMDR, 0x80);
127 	if (isac->dch.debug & DEBUG_HW_DFIFO) {
128 		char	pfx[MISDN_MAX_IDLEN + 16];
129 
130 		snprintf(pfx, MISDN_MAX_IDLEN + 15, "D-recv %s %d ",
131 			 isac->name, count);
132 		print_hex_dump_bytes(pfx, DUMP_PREFIX_OFFSET, ptr, count);
133 	}
134 }
135 
136 static void
137 isac_fill_fifo(struct isac_hw *isac)
138 {
139 	int count, more;
140 	u8 *ptr;
141 
142 	if (!isac->dch.tx_skb)
143 		return;
144 	count = isac->dch.tx_skb->len - isac->dch.tx_idx;
145 	if (count <= 0)
146 		return;
147 
148 	more = 0;
149 	if (count > 32) {
150 		more = !0;
151 		count = 32;
152 	}
153 	pr_debug("%s: %s  %d\n", isac->name, __func__, count);
154 	ptr = isac->dch.tx_skb->data + isac->dch.tx_idx;
155 	isac->dch.tx_idx += count;
156 	isac->write_fifo(isac->dch.hw, isac->off, ptr, count);
157 	WriteISAC(isac, ISAC_CMDR, more ? 0x8 : 0xa);
158 	if (test_and_set_bit(FLG_BUSY_TIMER, &isac->dch.Flags)) {
159 		pr_debug("%s: %s dbusytimer running\n", isac->name, __func__);
160 		del_timer(&isac->dch.timer);
161 	}
162 	isac->dch.timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
163 	add_timer(&isac->dch.timer);
164 	if (isac->dch.debug & DEBUG_HW_DFIFO) {
165 		char	pfx[MISDN_MAX_IDLEN + 16];
166 
167 		snprintf(pfx, MISDN_MAX_IDLEN + 15, "D-send %s %d ",
168 			 isac->name, count);
169 		print_hex_dump_bytes(pfx, DUMP_PREFIX_OFFSET, ptr, count);
170 	}
171 }
172 
173 static void
174 isac_rme_irq(struct isac_hw *isac)
175 {
176 	u8 val, count;
177 
178 	val = ReadISAC(isac, ISAC_RSTA);
179 	if ((val & 0x70) != 0x20) {
180 		if (val & 0x40) {
181 			pr_debug("%s: ISAC RDO\n", isac->name);
182 #ifdef ERROR_STATISTIC
183 			isac->dch.err_rx++;
184 #endif
185 		}
186 		if (!(val & 0x20)) {
187 			pr_debug("%s: ISAC CRC error\n", isac->name);
188 #ifdef ERROR_STATISTIC
189 			isac->dch.err_crc++;
190 #endif
191 		}
192 		WriteISAC(isac, ISAC_CMDR, 0x80);
193 		dev_kfree_skb(isac->dch.rx_skb);
194 		isac->dch.rx_skb = NULL;
195 	} else {
196 		count = ReadISAC(isac, ISAC_RBCL) & 0x1f;
197 		if (count == 0)
198 			count = 32;
199 		isac_empty_fifo(isac, count);
200 		recv_Dchannel(&isac->dch);
201 	}
202 }
203 
204 static void
205 isac_xpr_irq(struct isac_hw *isac)
206 {
207 	if (test_and_clear_bit(FLG_BUSY_TIMER, &isac->dch.Flags))
208 		del_timer(&isac->dch.timer);
209 	if (isac->dch.tx_skb && isac->dch.tx_idx < isac->dch.tx_skb->len) {
210 		isac_fill_fifo(isac);
211 	} else {
212 		dev_kfree_skb(isac->dch.tx_skb);
213 		if (get_next_dframe(&isac->dch))
214 			isac_fill_fifo(isac);
215 	}
216 }
217 
218 static void
219 isac_retransmit(struct isac_hw *isac)
220 {
221 	if (test_and_clear_bit(FLG_BUSY_TIMER, &isac->dch.Flags))
222 		del_timer(&isac->dch.timer);
223 	if (test_bit(FLG_TX_BUSY, &isac->dch.Flags)) {
224 		/* Restart frame */
225 		isac->dch.tx_idx = 0;
226 		isac_fill_fifo(isac);
227 	} else if (isac->dch.tx_skb) { /* should not happen */
228 		pr_info("%s: tx_skb exist but not busy\n", isac->name);
229 		test_and_set_bit(FLG_TX_BUSY, &isac->dch.Flags);
230 		isac->dch.tx_idx = 0;
231 		isac_fill_fifo(isac);
232 	} else {
233 		pr_info("%s: ISAC XDU no TX_BUSY\n", isac->name);
234 		if (get_next_dframe(&isac->dch))
235 			isac_fill_fifo(isac);
236 	}
237 }
238 
239 static void
240 isac_mos_irq(struct isac_hw *isac)
241 {
242 	u8 val;
243 	int ret;
244 
245 	val = ReadISAC(isac, ISAC_MOSR);
246 	pr_debug("%s: ISAC MOSR %02x\n", isac->name, val);
247 #if ARCOFI_USE
248 	if (val & 0x08) {
249 		if (!isac->mon_rx) {
250 			isac->mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC);
251 			if (!isac->mon_rx) {
252 				pr_info("%s: ISAC MON RX out of memory!\n",
253 					isac->name);
254 				isac->mocr &= 0xf0;
255 				isac->mocr |= 0x0a;
256 				WriteISAC(isac, ISAC_MOCR, isac->mocr);
257 				goto afterMONR0;
258 			} else
259 				isac->mon_rxp = 0;
260 		}
261 		if (isac->mon_rxp >= MAX_MON_FRAME) {
262 			isac->mocr &= 0xf0;
263 			isac->mocr |= 0x0a;
264 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
265 			isac->mon_rxp = 0;
266 			pr_debug("%s: ISAC MON RX overflow!\n", isac->name);
267 			goto afterMONR0;
268 		}
269 		isac->mon_rx[isac->mon_rxp++] = ReadISAC(isac, ISAC_MOR0);
270 		pr_debug("%s: ISAC MOR0 %02x\n", isac->name,
271 			 isac->mon_rx[isac->mon_rxp - 1]);
272 		if (isac->mon_rxp == 1) {
273 			isac->mocr |= 0x04;
274 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
275 		}
276 	}
277 afterMONR0:
278 	if (val & 0x80) {
279 		if (!isac->mon_rx) {
280 			isac->mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC);
281 			if (!isac->mon_rx) {
282 				pr_info("%s: ISAC MON RX out of memory!\n",
283 					isac->name);
284 				isac->mocr &= 0x0f;
285 				isac->mocr |= 0xa0;
286 				WriteISAC(isac, ISAC_MOCR, isac->mocr);
287 				goto afterMONR1;
288 			} else
289 				isac->mon_rxp = 0;
290 		}
291 		if (isac->mon_rxp >= MAX_MON_FRAME) {
292 			isac->mocr &= 0x0f;
293 			isac->mocr |= 0xa0;
294 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
295 			isac->mon_rxp = 0;
296 			pr_debug("%s: ISAC MON RX overflow!\n", isac->name);
297 			goto afterMONR1;
298 		}
299 		isac->mon_rx[isac->mon_rxp++] = ReadISAC(isac, ISAC_MOR1);
300 		pr_debug("%s: ISAC MOR1 %02x\n", isac->name,
301 			 isac->mon_rx[isac->mon_rxp - 1]);
302 		isac->mocr |= 0x40;
303 		WriteISAC(isac, ISAC_MOCR, isac->mocr);
304 	}
305 afterMONR1:
306 	if (val & 0x04) {
307 		isac->mocr &= 0xf0;
308 		WriteISAC(isac, ISAC_MOCR, isac->mocr);
309 		isac->mocr |= 0x0a;
310 		WriteISAC(isac, ISAC_MOCR, isac->mocr);
311 		if (isac->monitor) {
312 			ret = isac->monitor(isac->dch.hw, MONITOR_RX_0,
313 					    isac->mon_rx, isac->mon_rxp);
314 			if (ret)
315 				kfree(isac->mon_rx);
316 		} else {
317 			pr_info("%s: MONITOR 0 received %d but no user\n",
318 				isac->name, isac->mon_rxp);
319 			kfree(isac->mon_rx);
320 		}
321 		isac->mon_rx = NULL;
322 		isac->mon_rxp = 0;
323 	}
324 	if (val & 0x40) {
325 		isac->mocr &= 0x0f;
326 		WriteISAC(isac, ISAC_MOCR, isac->mocr);
327 		isac->mocr |= 0xa0;
328 		WriteISAC(isac, ISAC_MOCR, isac->mocr);
329 		if (isac->monitor) {
330 			ret = isac->monitor(isac->dch.hw, MONITOR_RX_1,
331 					    isac->mon_rx, isac->mon_rxp);
332 			if (ret)
333 				kfree(isac->mon_rx);
334 		} else {
335 			pr_info("%s: MONITOR 1 received %d but no user\n",
336 				isac->name, isac->mon_rxp);
337 			kfree(isac->mon_rx);
338 		}
339 		isac->mon_rx = NULL;
340 		isac->mon_rxp = 0;
341 	}
342 	if (val & 0x02) {
343 		if ((!isac->mon_tx) || (isac->mon_txc &&
344 					(isac->mon_txp >= isac->mon_txc) && !(val & 0x08))) {
345 			isac->mocr &= 0xf0;
346 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
347 			isac->mocr |= 0x0a;
348 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
349 			if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
350 				if (isac->monitor)
351 					isac->monitor(isac->dch.hw,
352 						      MONITOR_TX_0, NULL, 0);
353 			}
354 			kfree(isac->mon_tx);
355 			isac->mon_tx = NULL;
356 			isac->mon_txc = 0;
357 			isac->mon_txp = 0;
358 			goto AfterMOX0;
359 		}
360 		if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
361 			if (isac->monitor)
362 				isac->monitor(isac->dch.hw,
363 					      MONITOR_TX_0, NULL, 0);
364 			kfree(isac->mon_tx);
365 			isac->mon_tx = NULL;
366 			isac->mon_txc = 0;
367 			isac->mon_txp = 0;
368 			goto AfterMOX0;
369 		}
370 		WriteISAC(isac, ISAC_MOX0, isac->mon_tx[isac->mon_txp++]);
371 		pr_debug("%s: ISAC %02x -> MOX0\n", isac->name,
372 			 isac->mon_tx[isac->mon_txp - 1]);
373 	}
374 AfterMOX0:
375 	if (val & 0x20) {
376 		if ((!isac->mon_tx) || (isac->mon_txc &&
377 					(isac->mon_txp >= isac->mon_txc) && !(val & 0x80))) {
378 			isac->mocr &= 0x0f;
379 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
380 			isac->mocr |= 0xa0;
381 			WriteISAC(isac, ISAC_MOCR, isac->mocr);
382 			if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
383 				if (isac->monitor)
384 					isac->monitor(isac->dch.hw,
385 						      MONITOR_TX_1, NULL, 0);
386 			}
387 			kfree(isac->mon_tx);
388 			isac->mon_tx = NULL;
389 			isac->mon_txc = 0;
390 			isac->mon_txp = 0;
391 			goto AfterMOX1;
392 		}
393 		if (isac->mon_txc && (isac->mon_txp >= isac->mon_txc)) {
394 			if (isac->monitor)
395 				isac->monitor(isac->dch.hw,
396 					      MONITOR_TX_1, NULL, 0);
397 			kfree(isac->mon_tx);
398 			isac->mon_tx = NULL;
399 			isac->mon_txc = 0;
400 			isac->mon_txp = 0;
401 			goto AfterMOX1;
402 		}
403 		WriteISAC(isac, ISAC_MOX1, isac->mon_tx[isac->mon_txp++]);
404 		pr_debug("%s: ISAC %02x -> MOX1\n", isac->name,
405 			 isac->mon_tx[isac->mon_txp - 1]);
406 	}
407 AfterMOX1:
408 	val = 0; /* dummy to avoid warning */
409 #endif
410 }
411 
412 static void
413 isac_cisq_irq(struct isac_hw *isac) {
414 	u8 val;
415 
416 	val = ReadISAC(isac, ISAC_CIR0);
417 	pr_debug("%s: ISAC CIR0 %02X\n", isac->name, val);
418 	if (val & 2) {
419 		pr_debug("%s: ph_state change %x->%x\n", isac->name,
420 			 isac->state, (val >> 2) & 0xf);
421 		isac->state = (val >> 2) & 0xf;
422 		isac_ph_state_change(isac);
423 	}
424 	if (val & 1) {
425 		val = ReadISAC(isac, ISAC_CIR1);
426 		pr_debug("%s: ISAC CIR1 %02X\n", isac->name, val);
427 	}
428 }
429 
430 static void
431 isacsx_cic_irq(struct isac_hw *isac)
432 {
433 	u8 val;
434 
435 	val = ReadISAC(isac, ISACX_CIR0);
436 	pr_debug("%s: ISACX CIR0 %02X\n", isac->name, val);
437 	if (val & ISACX_CIR0_CIC0) {
438 		pr_debug("%s: ph_state change %x->%x\n", isac->name,
439 			 isac->state, val >> 4);
440 		isac->state = val >> 4;
441 		isac_ph_state_change(isac);
442 	}
443 }
444 
445 static void
446 isacsx_rme_irq(struct isac_hw *isac)
447 {
448 	int count;
449 	u8 val;
450 
451 	val = ReadISAC(isac, ISACX_RSTAD);
452 	if ((val & (ISACX_RSTAD_VFR |
453 		    ISACX_RSTAD_RDO |
454 		    ISACX_RSTAD_CRC |
455 		    ISACX_RSTAD_RAB))
456 	    != (ISACX_RSTAD_VFR | ISACX_RSTAD_CRC)) {
457 		pr_debug("%s: RSTAD %#x, dropped\n", isac->name, val);
458 #ifdef ERROR_STATISTIC
459 		if (val & ISACX_RSTAD_CRC)
460 			isac->dch.err_rx++;
461 		else
462 			isac->dch.err_crc++;
463 #endif
464 		WriteISAC(isac, ISACX_CMDRD, ISACX_CMDRD_RMC);
465 		dev_kfree_skb(isac->dch.rx_skb);
466 		isac->dch.rx_skb = NULL;
467 	} else {
468 		count = ReadISAC(isac, ISACX_RBCLD) & 0x1f;
469 		if (count == 0)
470 			count = 32;
471 		isac_empty_fifo(isac, count);
472 		if (isac->dch.rx_skb) {
473 			skb_trim(isac->dch.rx_skb, isac->dch.rx_skb->len - 1);
474 			pr_debug("%s: dchannel received %d\n", isac->name,
475 				 isac->dch.rx_skb->len);
476 			recv_Dchannel(&isac->dch);
477 		}
478 	}
479 }
480 
481 irqreturn_t
482 mISDNisac_irq(struct isac_hw *isac, u8 val)
483 {
484 	if (unlikely(!val))
485 		return IRQ_NONE;
486 	pr_debug("%s: ISAC interrupt %02x\n", isac->name, val);
487 	if (isac->type & IPAC_TYPE_ISACX) {
488 		if (val & ISACX__CIC)
489 			isacsx_cic_irq(isac);
490 		if (val & ISACX__ICD) {
491 			val = ReadISAC(isac, ISACX_ISTAD);
492 			pr_debug("%s: ISTAD %02x\n", isac->name, val);
493 			if (val & ISACX_D_XDU) {
494 				pr_debug("%s: ISAC XDU\n", isac->name);
495 #ifdef ERROR_STATISTIC
496 				isac->dch.err_tx++;
497 #endif
498 				isac_retransmit(isac);
499 			}
500 			if (val & ISACX_D_XMR) {
501 				pr_debug("%s: ISAC XMR\n", isac->name);
502 #ifdef ERROR_STATISTIC
503 				isac->dch.err_tx++;
504 #endif
505 				isac_retransmit(isac);
506 			}
507 			if (val & ISACX_D_XPR)
508 				isac_xpr_irq(isac);
509 			if (val & ISACX_D_RFO) {
510 				pr_debug("%s: ISAC RFO\n", isac->name);
511 				WriteISAC(isac, ISACX_CMDRD, ISACX_CMDRD_RMC);
512 			}
513 			if (val & ISACX_D_RME)
514 				isacsx_rme_irq(isac);
515 			if (val & ISACX_D_RPF)
516 				isac_empty_fifo(isac, 0x20);
517 		}
518 	} else {
519 		if (val & 0x80)	/* RME */
520 			isac_rme_irq(isac);
521 		if (val & 0x40)	/* RPF */
522 			isac_empty_fifo(isac, 32);
523 		if (val & 0x10)	/* XPR */
524 			isac_xpr_irq(isac);
525 		if (val & 0x04)	/* CISQ */
526 			isac_cisq_irq(isac);
527 		if (val & 0x20)	/* RSC - never */
528 			pr_debug("%s: ISAC RSC interrupt\n", isac->name);
529 		if (val & 0x02)	/* SIN - never */
530 			pr_debug("%s: ISAC SIN interrupt\n", isac->name);
531 		if (val & 0x01) {	/* EXI */
532 			val = ReadISAC(isac, ISAC_EXIR);
533 			pr_debug("%s: ISAC EXIR %02x\n", isac->name, val);
534 			if (val & 0x80)	/* XMR */
535 				pr_debug("%s: ISAC XMR\n", isac->name);
536 			if (val & 0x40) { /* XDU */
537 				pr_debug("%s: ISAC XDU\n", isac->name);
538 #ifdef ERROR_STATISTIC
539 				isac->dch.err_tx++;
540 #endif
541 				isac_retransmit(isac);
542 			}
543 			if (val & 0x04)	/* MOS */
544 				isac_mos_irq(isac);
545 		}
546 	}
547 	return IRQ_HANDLED;
548 }
549 EXPORT_SYMBOL(mISDNisac_irq);
550 
551 static int
552 isac_l1hw(struct mISDNchannel *ch, struct sk_buff *skb)
553 {
554 	struct mISDNdevice	*dev = container_of(ch, struct mISDNdevice, D);
555 	struct dchannel		*dch = container_of(dev, struct dchannel, dev);
556 	struct isac_hw		*isac = container_of(dch, struct isac_hw, dch);
557 	int			ret = -EINVAL;
558 	struct mISDNhead	*hh = mISDN_HEAD_P(skb);
559 	u32			id;
560 	u_long			flags;
561 
562 	switch (hh->prim) {
563 	case PH_DATA_REQ:
564 		spin_lock_irqsave(isac->hwlock, flags);
565 		ret = dchannel_senddata(dch, skb);
566 		if (ret > 0) { /* direct TX */
567 			id = hh->id; /* skb can be freed */
568 			isac_fill_fifo(isac);
569 			ret = 0;
570 			spin_unlock_irqrestore(isac->hwlock, flags);
571 			queue_ch_frame(ch, PH_DATA_CNF, id, NULL);
572 		} else
573 			spin_unlock_irqrestore(isac->hwlock, flags);
574 		return ret;
575 	case PH_ACTIVATE_REQ:
576 		ret = l1_event(dch->l1, hh->prim);
577 		break;
578 	case PH_DEACTIVATE_REQ:
579 		test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
580 		ret = l1_event(dch->l1, hh->prim);
581 		break;
582 	}
583 
584 	if (!ret)
585 		dev_kfree_skb(skb);
586 	return ret;
587 }
588 
589 static int
590 isac_ctrl(struct isac_hw *isac, u32 cmd, unsigned long para)
591 {
592 	u8 tl = 0;
593 	unsigned long flags;
594 	int ret = 0;
595 
596 	switch (cmd) {
597 	case HW_TESTLOOP:
598 		spin_lock_irqsave(isac->hwlock, flags);
599 		if (!(isac->type & IPAC_TYPE_ISACX)) {
600 			/* TODO: implement for IPAC_TYPE_ISACX */
601 			if (para & 1) /* B1 */
602 				tl |= 0x0c;
603 			else if (para & 2) /* B2 */
604 				tl |= 0x3;
605 			/* we only support IOM2 mode */
606 			WriteISAC(isac, ISAC_SPCR, tl);
607 			if (tl)
608 				WriteISAC(isac, ISAC_ADF1, 0x8);
609 			else
610 				WriteISAC(isac, ISAC_ADF1, 0x0);
611 		}
612 		spin_unlock_irqrestore(isac->hwlock, flags);
613 		break;
614 	case HW_TIMER3_VALUE:
615 		ret = l1_event(isac->dch.l1, HW_TIMER3_VALUE | (para & 0xff));
616 		break;
617 	default:
618 		pr_debug("%s: %s unknown command %x %lx\n", isac->name,
619 			 __func__, cmd, para);
620 		ret = -1;
621 	}
622 	return ret;
623 }
624 
625 static int
626 isac_l1cmd(struct dchannel *dch, u32 cmd)
627 {
628 	struct isac_hw *isac = container_of(dch, struct isac_hw, dch);
629 	u_long flags;
630 
631 	pr_debug("%s: cmd(%x) state(%02x)\n", isac->name, cmd, isac->state);
632 	switch (cmd) {
633 	case INFO3_P8:
634 		spin_lock_irqsave(isac->hwlock, flags);
635 		ph_command(isac, ISAC_CMD_AR8);
636 		spin_unlock_irqrestore(isac->hwlock, flags);
637 		break;
638 	case INFO3_P10:
639 		spin_lock_irqsave(isac->hwlock, flags);
640 		ph_command(isac, ISAC_CMD_AR10);
641 		spin_unlock_irqrestore(isac->hwlock, flags);
642 		break;
643 	case HW_RESET_REQ:
644 		spin_lock_irqsave(isac->hwlock, flags);
645 		if ((isac->state == ISAC_IND_EI) ||
646 		    (isac->state == ISAC_IND_DR) ||
647 		    (isac->state == ISAC_IND_DR6) ||
648 		    (isac->state == ISAC_IND_RS))
649 			ph_command(isac, ISAC_CMD_TIM);
650 		else
651 			ph_command(isac, ISAC_CMD_RS);
652 		spin_unlock_irqrestore(isac->hwlock, flags);
653 		break;
654 	case HW_DEACT_REQ:
655 		skb_queue_purge(&dch->squeue);
656 		if (dch->tx_skb) {
657 			dev_kfree_skb(dch->tx_skb);
658 			dch->tx_skb = NULL;
659 		}
660 		dch->tx_idx = 0;
661 		if (dch->rx_skb) {
662 			dev_kfree_skb(dch->rx_skb);
663 			dch->rx_skb = NULL;
664 		}
665 		test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
666 		if (test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags))
667 			del_timer(&dch->timer);
668 		break;
669 	case HW_POWERUP_REQ:
670 		spin_lock_irqsave(isac->hwlock, flags);
671 		ph_command(isac, ISAC_CMD_TIM);
672 		spin_unlock_irqrestore(isac->hwlock, flags);
673 		break;
674 	case PH_ACTIVATE_IND:
675 		test_and_set_bit(FLG_ACTIVE, &dch->Flags);
676 		_queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
677 			    GFP_ATOMIC);
678 		break;
679 	case PH_DEACTIVATE_IND:
680 		test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
681 		_queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
682 			    GFP_ATOMIC);
683 		break;
684 	default:
685 		pr_debug("%s: %s unknown command %x\n", isac->name,
686 			 __func__, cmd);
687 		return -1;
688 	}
689 	return 0;
690 }
691 
692 static void
693 isac_release(struct isac_hw *isac)
694 {
695 	if (isac->type & IPAC_TYPE_ISACX)
696 		WriteISAC(isac, ISACX_MASK, 0xff);
697 	else if (isac->type != 0)
698 		WriteISAC(isac, ISAC_MASK, 0xff);
699 	if (isac->dch.timer.function != NULL) {
700 		del_timer(&isac->dch.timer);
701 		isac->dch.timer.function = NULL;
702 	}
703 	kfree(isac->mon_rx);
704 	isac->mon_rx = NULL;
705 	kfree(isac->mon_tx);
706 	isac->mon_tx = NULL;
707 	if (isac->dch.l1)
708 		l1_event(isac->dch.l1, CLOSE_CHANNEL);
709 	mISDN_freedchannel(&isac->dch);
710 }
711 
712 static void
713 dbusy_timer_handler(struct timer_list *t)
714 {
715 	struct isac_hw *isac = from_timer(isac, t, dch.timer);
716 	int rbch, star;
717 	u_long flags;
718 
719 	if (test_bit(FLG_BUSY_TIMER, &isac->dch.Flags)) {
720 		spin_lock_irqsave(isac->hwlock, flags);
721 		rbch = ReadISAC(isac, ISAC_RBCH);
722 		star = ReadISAC(isac, ISAC_STAR);
723 		pr_debug("%s: D-Channel Busy RBCH %02x STAR %02x\n",
724 			 isac->name, rbch, star);
725 		if (rbch & ISAC_RBCH_XAC) /* D-Channel Busy */
726 			test_and_set_bit(FLG_L1_BUSY, &isac->dch.Flags);
727 		else {
728 			/* discard frame; reset transceiver */
729 			test_and_clear_bit(FLG_BUSY_TIMER, &isac->dch.Flags);
730 			if (isac->dch.tx_idx)
731 				isac->dch.tx_idx = 0;
732 			else
733 				pr_info("%s: ISAC D-Channel Busy no tx_idx\n",
734 					isac->name);
735 			/* Transmitter reset */
736 			WriteISAC(isac, ISAC_CMDR, 0x01);
737 		}
738 		spin_unlock_irqrestore(isac->hwlock, flags);
739 	}
740 }
741 
742 static int
743 open_dchannel_caller(struct isac_hw *isac, struct channel_req *rq, void *caller)
744 {
745 	pr_debug("%s: %s dev(%d) open from %p\n", isac->name, __func__,
746 		 isac->dch.dev.id, caller);
747 	if (rq->protocol != ISDN_P_TE_S0)
748 		return -EINVAL;
749 	if (rq->adr.channel == 1)
750 		/* E-Channel not supported */
751 		return -EINVAL;
752 	rq->ch = &isac->dch.dev.D;
753 	rq->ch->protocol = rq->protocol;
754 	if (isac->dch.state == 7)
755 		_queue_data(rq->ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
756 			    0, NULL, GFP_KERNEL);
757 	return 0;
758 }
759 
760 static int
761 open_dchannel(struct isac_hw *isac, struct channel_req *rq)
762 {
763 	return open_dchannel_caller(isac, rq, __builtin_return_address(0));
764 }
765 
766 static const char *ISACVer[] =
767 {"2086/2186 V1.1", "2085 B1", "2085 B2",
768  "2085 V2.3"};
769 
770 static int
771 isac_init(struct isac_hw *isac)
772 {
773 	u8 val;
774 	int err = 0;
775 
776 	if (!isac->dch.l1) {
777 		err = create_l1(&isac->dch, isac_l1cmd);
778 		if (err)
779 			return err;
780 	}
781 	isac->mon_tx = NULL;
782 	isac->mon_rx = NULL;
783 	timer_setup(&isac->dch.timer, dbusy_timer_handler, 0);
784 	isac->mocr = 0xaa;
785 	if (isac->type & IPAC_TYPE_ISACX) {
786 		/* Disable all IRQ */
787 		WriteISAC(isac, ISACX_MASK, 0xff);
788 		val = ReadISAC(isac, ISACX_STARD);
789 		pr_debug("%s: ISACX STARD %x\n", isac->name, val);
790 		val = ReadISAC(isac, ISACX_ISTAD);
791 		pr_debug("%s: ISACX ISTAD %x\n", isac->name, val);
792 		val = ReadISAC(isac, ISACX_ISTA);
793 		pr_debug("%s: ISACX ISTA %x\n", isac->name, val);
794 		/* clear LDD */
795 		WriteISAC(isac, ISACX_TR_CONF0, 0x00);
796 		/* enable transmitter */
797 		WriteISAC(isac, ISACX_TR_CONF2, 0x00);
798 		/* transparent mode 0, RAC, stop/go */
799 		WriteISAC(isac, ISACX_MODED, 0xc9);
800 		/* all HDLC IRQ unmasked */
801 		val = ReadISAC(isac, ISACX_ID);
802 		if (isac->dch.debug & DEBUG_HW)
803 			pr_notice("%s: ISACX Design ID %x\n",
804 				  isac->name, val & 0x3f);
805 		val = ReadISAC(isac, ISACX_CIR0);
806 		pr_debug("%s: ISACX CIR0 %02X\n", isac->name, val);
807 		isac->state = val >> 4;
808 		isac_ph_state_change(isac);
809 		ph_command(isac, ISAC_CMD_RS);
810 		WriteISAC(isac, ISACX_MASK, IPACX__ON);
811 		WriteISAC(isac, ISACX_MASKD, 0x00);
812 	} else { /* old isac */
813 		WriteISAC(isac, ISAC_MASK, 0xff);
814 		val = ReadISAC(isac, ISAC_STAR);
815 		pr_debug("%s: ISAC STAR %x\n", isac->name, val);
816 		val = ReadISAC(isac, ISAC_MODE);
817 		pr_debug("%s: ISAC MODE %x\n", isac->name, val);
818 		val = ReadISAC(isac, ISAC_ADF2);
819 		pr_debug("%s: ISAC ADF2 %x\n", isac->name, val);
820 		val = ReadISAC(isac, ISAC_ISTA);
821 		pr_debug("%s: ISAC ISTA %x\n", isac->name, val);
822 		if (val & 0x01) {
823 			val = ReadISAC(isac, ISAC_EXIR);
824 			pr_debug("%s: ISAC EXIR %x\n", isac->name, val);
825 		}
826 		val = ReadISAC(isac, ISAC_RBCH);
827 		if (isac->dch.debug & DEBUG_HW)
828 			pr_notice("%s: ISAC version (%x): %s\n", isac->name,
829 				  val, ISACVer[(val >> 5) & 3]);
830 		isac->type |= ((val >> 5) & 3);
831 		if (!isac->adf2)
832 			isac->adf2 = 0x80;
833 		if (!(isac->adf2 & 0x80)) { /* only IOM 2 Mode */
834 			pr_info("%s: only support IOM2 mode but adf2=%02x\n",
835 				isac->name, isac->adf2);
836 			isac_release(isac);
837 			return -EINVAL;
838 		}
839 		WriteISAC(isac, ISAC_ADF2, isac->adf2);
840 		WriteISAC(isac, ISAC_SQXR, 0x2f);
841 		WriteISAC(isac, ISAC_SPCR, 0x00);
842 		WriteISAC(isac, ISAC_STCR, 0x70);
843 		WriteISAC(isac, ISAC_MODE, 0xc9);
844 		WriteISAC(isac, ISAC_TIMR, 0x00);
845 		WriteISAC(isac, ISAC_ADF1, 0x00);
846 		val = ReadISAC(isac, ISAC_CIR0);
847 		pr_debug("%s: ISAC CIR0 %x\n", isac->name, val);
848 		isac->state = (val >> 2) & 0xf;
849 		isac_ph_state_change(isac);
850 		ph_command(isac, ISAC_CMD_RS);
851 		WriteISAC(isac, ISAC_MASK, 0);
852 	}
853 	return err;
854 }
855 
856 int
857 mISDNisac_init(struct isac_hw *isac, void *hw)
858 {
859 	mISDN_initdchannel(&isac->dch, MAX_DFRAME_LEN_L1, isac_ph_state_bh);
860 	isac->dch.hw = hw;
861 	isac->dch.dev.D.send = isac_l1hw;
862 	isac->init = isac_init;
863 	isac->release = isac_release;
864 	isac->ctrl = isac_ctrl;
865 	isac->open = open_dchannel;
866 	isac->dch.dev.Dprotocols = (1 << ISDN_P_TE_S0);
867 	isac->dch.dev.nrbchan = 2;
868 	return 0;
869 }
870 EXPORT_SYMBOL(mISDNisac_init);
871 
872 static void
873 waitforCEC(struct hscx_hw *hx)
874 {
875 	u8 starb, to = 50;
876 
877 	while (to) {
878 		starb = ReadHSCX(hx, IPAC_STARB);
879 		if (!(starb & 0x04))
880 			break;
881 		udelay(1);
882 		to--;
883 	}
884 	if (to < 50)
885 		pr_debug("%s: B%1d CEC %d us\n", hx->ip->name, hx->bch.nr,
886 			 50 - to);
887 	if (!to)
888 		pr_info("%s: B%1d CEC timeout\n", hx->ip->name, hx->bch.nr);
889 }
890 
891 
892 static void
893 waitforXFW(struct hscx_hw *hx)
894 {
895 	u8 starb, to = 50;
896 
897 	while (to) {
898 		starb = ReadHSCX(hx, IPAC_STARB);
899 		if ((starb & 0x44) == 0x40)
900 			break;
901 		udelay(1);
902 		to--;
903 	}
904 	if (to < 50)
905 		pr_debug("%s: B%1d XFW %d us\n", hx->ip->name, hx->bch.nr,
906 			 50 - to);
907 	if (!to)
908 		pr_info("%s: B%1d XFW timeout\n", hx->ip->name, hx->bch.nr);
909 }
910 
911 static void
912 hscx_cmdr(struct hscx_hw *hx, u8 cmd)
913 {
914 	if (hx->ip->type & IPAC_TYPE_IPACX)
915 		WriteHSCX(hx, IPACX_CMDRB, cmd);
916 	else {
917 		waitforCEC(hx);
918 		WriteHSCX(hx, IPAC_CMDRB, cmd);
919 	}
920 }
921 
922 static void
923 hscx_empty_fifo(struct hscx_hw *hscx, u8 count)
924 {
925 	u8 *p;
926 	int maxlen;
927 
928 	pr_debug("%s: B%1d %d\n", hscx->ip->name, hscx->bch.nr, count);
929 	if (test_bit(FLG_RX_OFF, &hscx->bch.Flags)) {
930 		hscx->bch.dropcnt += count;
931 		hscx_cmdr(hscx, 0x80); /* RMC */
932 		return;
933 	}
934 	maxlen = bchannel_get_rxbuf(&hscx->bch, count);
935 	if (maxlen < 0) {
936 		hscx_cmdr(hscx, 0x80); /* RMC */
937 		if (hscx->bch.rx_skb)
938 			skb_trim(hscx->bch.rx_skb, 0);
939 		pr_warn("%s.B%d: No bufferspace for %d bytes\n",
940 			hscx->ip->name, hscx->bch.nr, count);
941 		return;
942 	}
943 	p = skb_put(hscx->bch.rx_skb, count);
944 
945 	if (hscx->ip->type & IPAC_TYPE_IPACX)
946 		hscx->ip->read_fifo(hscx->ip->hw,
947 				    hscx->off + IPACX_RFIFOB, p, count);
948 	else
949 		hscx->ip->read_fifo(hscx->ip->hw,
950 				    hscx->off, p, count);
951 
952 	hscx_cmdr(hscx, 0x80); /* RMC */
953 
954 	if (hscx->bch.debug & DEBUG_HW_BFIFO) {
955 		snprintf(hscx->log, 64, "B%1d-recv %s %d ",
956 			 hscx->bch.nr, hscx->ip->name, count);
957 		print_hex_dump_bytes(hscx->log, DUMP_PREFIX_OFFSET, p, count);
958 	}
959 }
960 
961 static void
962 hscx_fill_fifo(struct hscx_hw *hscx)
963 {
964 	int count, more;
965 	u8 *p;
966 
967 	if (!hscx->bch.tx_skb) {
968 		if (!test_bit(FLG_TX_EMPTY, &hscx->bch.Flags))
969 			return;
970 		count = hscx->fifo_size;
971 		more = 1;
972 		p = hscx->log;
973 		memset(p, hscx->bch.fill[0], count);
974 	} else {
975 		count = hscx->bch.tx_skb->len - hscx->bch.tx_idx;
976 		if (count <= 0)
977 			return;
978 		p = hscx->bch.tx_skb->data + hscx->bch.tx_idx;
979 
980 		more = test_bit(FLG_TRANSPARENT, &hscx->bch.Flags) ? 1 : 0;
981 		if (count > hscx->fifo_size) {
982 			count = hscx->fifo_size;
983 			more = 1;
984 		}
985 		pr_debug("%s: B%1d %d/%d/%d\n", hscx->ip->name, hscx->bch.nr,
986 			 count, hscx->bch.tx_idx, hscx->bch.tx_skb->len);
987 		hscx->bch.tx_idx += count;
988 	}
989 	if (hscx->ip->type & IPAC_TYPE_IPACX)
990 		hscx->ip->write_fifo(hscx->ip->hw,
991 				     hscx->off + IPACX_XFIFOB, p, count);
992 	else {
993 		waitforXFW(hscx);
994 		hscx->ip->write_fifo(hscx->ip->hw,
995 				     hscx->off, p, count);
996 	}
997 	hscx_cmdr(hscx, more ? 0x08 : 0x0a);
998 
999 	if (hscx->bch.tx_skb && (hscx->bch.debug & DEBUG_HW_BFIFO)) {
1000 		snprintf(hscx->log, 64, "B%1d-send %s %d ",
1001 			 hscx->bch.nr, hscx->ip->name, count);
1002 		print_hex_dump_bytes(hscx->log, DUMP_PREFIX_OFFSET, p, count);
1003 	}
1004 }
1005 
1006 static void
1007 hscx_xpr(struct hscx_hw *hx)
1008 {
1009 	if (hx->bch.tx_skb && hx->bch.tx_idx < hx->bch.tx_skb->len) {
1010 		hscx_fill_fifo(hx);
1011 	} else {
1012 		dev_kfree_skb(hx->bch.tx_skb);
1013 		if (get_next_bframe(&hx->bch)) {
1014 			hscx_fill_fifo(hx);
1015 			test_and_clear_bit(FLG_TX_EMPTY, &hx->bch.Flags);
1016 		} else if (test_bit(FLG_TX_EMPTY, &hx->bch.Flags)) {
1017 			hscx_fill_fifo(hx);
1018 		}
1019 	}
1020 }
1021 
1022 static void
1023 ipac_rme(struct hscx_hw *hx)
1024 {
1025 	int count;
1026 	u8 rstab;
1027 
1028 	if (hx->ip->type & IPAC_TYPE_IPACX)
1029 		rstab = ReadHSCX(hx, IPACX_RSTAB);
1030 	else
1031 		rstab = ReadHSCX(hx, IPAC_RSTAB);
1032 	pr_debug("%s: B%1d RSTAB %02x\n", hx->ip->name, hx->bch.nr, rstab);
1033 	if ((rstab & 0xf0) != 0xa0) {
1034 		/* !(VFR && !RDO && CRC && !RAB) */
1035 		if (!(rstab & 0x80)) {
1036 			if (hx->bch.debug & DEBUG_HW_BCHANNEL)
1037 				pr_notice("%s: B%1d invalid frame\n",
1038 					  hx->ip->name, hx->bch.nr);
1039 		}
1040 		if (rstab & 0x40) {
1041 			if (hx->bch.debug & DEBUG_HW_BCHANNEL)
1042 				pr_notice("%s: B%1d RDO proto=%x\n",
1043 					  hx->ip->name, hx->bch.nr,
1044 					  hx->bch.state);
1045 		}
1046 		if (!(rstab & 0x20)) {
1047 			if (hx->bch.debug & DEBUG_HW_BCHANNEL)
1048 				pr_notice("%s: B%1d CRC error\n",
1049 					  hx->ip->name, hx->bch.nr);
1050 		}
1051 		hscx_cmdr(hx, 0x80); /* Do RMC */
1052 		return;
1053 	}
1054 	if (hx->ip->type & IPAC_TYPE_IPACX)
1055 		count = ReadHSCX(hx, IPACX_RBCLB);
1056 	else
1057 		count = ReadHSCX(hx, IPAC_RBCLB);
1058 	count &= (hx->fifo_size - 1);
1059 	if (count == 0)
1060 		count = hx->fifo_size;
1061 	hscx_empty_fifo(hx, count);
1062 	if (!hx->bch.rx_skb)
1063 		return;
1064 	if (hx->bch.rx_skb->len < 2) {
1065 		pr_debug("%s: B%1d frame to short %d\n",
1066 			 hx->ip->name, hx->bch.nr, hx->bch.rx_skb->len);
1067 		skb_trim(hx->bch.rx_skb, 0);
1068 	} else {
1069 		skb_trim(hx->bch.rx_skb, hx->bch.rx_skb->len - 1);
1070 		recv_Bchannel(&hx->bch, 0, false);
1071 	}
1072 }
1073 
1074 static void
1075 ipac_irq(struct hscx_hw *hx, u8 ista)
1076 {
1077 	u8 istab, m, exirb = 0;
1078 
1079 	if (hx->ip->type & IPAC_TYPE_IPACX)
1080 		istab = ReadHSCX(hx, IPACX_ISTAB);
1081 	else if (hx->ip->type & IPAC_TYPE_IPAC) {
1082 		istab = ReadHSCX(hx, IPAC_ISTAB);
1083 		m = (hx->bch.nr & 1) ? IPAC__EXA : IPAC__EXB;
1084 		if (m & ista) {
1085 			exirb = ReadHSCX(hx, IPAC_EXIRB);
1086 			pr_debug("%s: B%1d EXIRB %02x\n", hx->ip->name,
1087 				 hx->bch.nr, exirb);
1088 		}
1089 	} else if (hx->bch.nr & 2) { /* HSCX B */
1090 		if (ista & (HSCX__EXA | HSCX__ICA))
1091 			ipac_irq(&hx->ip->hscx[0], ista);
1092 		if (ista & HSCX__EXB) {
1093 			exirb = ReadHSCX(hx, IPAC_EXIRB);
1094 			pr_debug("%s: B%1d EXIRB %02x\n", hx->ip->name,
1095 				 hx->bch.nr, exirb);
1096 		}
1097 		istab = ista & 0xF8;
1098 	} else { /* HSCX A */
1099 		istab = ReadHSCX(hx, IPAC_ISTAB);
1100 		if (ista & HSCX__EXA) {
1101 			exirb = ReadHSCX(hx, IPAC_EXIRB);
1102 			pr_debug("%s: B%1d EXIRB %02x\n", hx->ip->name,
1103 				 hx->bch.nr, exirb);
1104 		}
1105 		istab = istab & 0xF8;
1106 	}
1107 	if (exirb & IPAC_B_XDU)
1108 		istab |= IPACX_B_XDU;
1109 	if (exirb & IPAC_B_RFO)
1110 		istab |= IPACX_B_RFO;
1111 	pr_debug("%s: B%1d ISTAB %02x\n", hx->ip->name, hx->bch.nr, istab);
1112 
1113 	if (!test_bit(FLG_ACTIVE, &hx->bch.Flags))
1114 		return;
1115 
1116 	if (istab & IPACX_B_RME)
1117 		ipac_rme(hx);
1118 
1119 	if (istab & IPACX_B_RPF) {
1120 		hscx_empty_fifo(hx, hx->fifo_size);
1121 		if (test_bit(FLG_TRANSPARENT, &hx->bch.Flags))
1122 			recv_Bchannel(&hx->bch, 0, false);
1123 	}
1124 
1125 	if (istab & IPACX_B_RFO) {
1126 		pr_debug("%s: B%1d RFO error\n", hx->ip->name, hx->bch.nr);
1127 		hscx_cmdr(hx, 0x40);	/* RRES */
1128 	}
1129 
1130 	if (istab & IPACX_B_XPR)
1131 		hscx_xpr(hx);
1132 
1133 	if (istab & IPACX_B_XDU) {
1134 		if (test_bit(FLG_TRANSPARENT, &hx->bch.Flags)) {
1135 			if (test_bit(FLG_FILLEMPTY, &hx->bch.Flags))
1136 				test_and_set_bit(FLG_TX_EMPTY, &hx->bch.Flags);
1137 			hscx_xpr(hx);
1138 			return;
1139 		}
1140 		pr_debug("%s: B%1d XDU error at len %d\n", hx->ip->name,
1141 			 hx->bch.nr, hx->bch.tx_idx);
1142 		hx->bch.tx_idx = 0;
1143 		hscx_cmdr(hx, 0x01);	/* XRES */
1144 	}
1145 }
1146 
1147 irqreturn_t
1148 mISDNipac_irq(struct ipac_hw *ipac, int maxloop)
1149 {
1150 	int cnt = maxloop + 1;
1151 	u8 ista, istad;
1152 	struct isac_hw  *isac = &ipac->isac;
1153 
1154 	if (ipac->type & IPAC_TYPE_IPACX) {
1155 		ista = ReadIPAC(ipac, ISACX_ISTA);
1156 		while (ista && --cnt) {
1157 			pr_debug("%s: ISTA %02x\n", ipac->name, ista);
1158 			if (ista & IPACX__ICA)
1159 				ipac_irq(&ipac->hscx[0], ista);
1160 			if (ista & IPACX__ICB)
1161 				ipac_irq(&ipac->hscx[1], ista);
1162 			if (ista & (ISACX__ICD | ISACX__CIC))
1163 				mISDNisac_irq(&ipac->isac, ista);
1164 			ista = ReadIPAC(ipac, ISACX_ISTA);
1165 		}
1166 	} else if (ipac->type & IPAC_TYPE_IPAC) {
1167 		ista = ReadIPAC(ipac, IPAC_ISTA);
1168 		while (ista && --cnt) {
1169 			pr_debug("%s: ISTA %02x\n", ipac->name, ista);
1170 			if (ista & (IPAC__ICD | IPAC__EXD)) {
1171 				istad = ReadISAC(isac, ISAC_ISTA);
1172 				pr_debug("%s: ISTAD %02x\n", ipac->name, istad);
1173 				if (istad & IPAC_D_TIN2)
1174 					pr_debug("%s TIN2 irq\n", ipac->name);
1175 				if (ista & IPAC__EXD)
1176 					istad |= 1; /* ISAC EXI */
1177 				mISDNisac_irq(isac, istad);
1178 			}
1179 			if (ista & (IPAC__ICA | IPAC__EXA))
1180 				ipac_irq(&ipac->hscx[0], ista);
1181 			if (ista & (IPAC__ICB | IPAC__EXB))
1182 				ipac_irq(&ipac->hscx[1], ista);
1183 			ista = ReadIPAC(ipac, IPAC_ISTA);
1184 		}
1185 	} else if (ipac->type & IPAC_TYPE_HSCX) {
1186 		while (--cnt) {
1187 			ista = ReadIPAC(ipac, IPAC_ISTAB + ipac->hscx[1].off);
1188 			pr_debug("%s: B2 ISTA %02x\n", ipac->name, ista);
1189 			if (ista)
1190 				ipac_irq(&ipac->hscx[1], ista);
1191 			istad = ReadISAC(isac, ISAC_ISTA);
1192 			pr_debug("%s: ISTAD %02x\n", ipac->name, istad);
1193 			if (istad)
1194 				mISDNisac_irq(isac, istad);
1195 			if (0 == (ista | istad))
1196 				break;
1197 		}
1198 	}
1199 	if (cnt > maxloop) /* only for ISAC/HSCX without PCI IRQ test */
1200 		return IRQ_NONE;
1201 	if (cnt < maxloop)
1202 		pr_debug("%s: %d irqloops cpu%d\n", ipac->name,
1203 			 maxloop - cnt, smp_processor_id());
1204 	if (maxloop && !cnt)
1205 		pr_notice("%s: %d IRQ LOOP cpu%d\n", ipac->name,
1206 			  maxloop, smp_processor_id());
1207 	return IRQ_HANDLED;
1208 }
1209 EXPORT_SYMBOL(mISDNipac_irq);
1210 
1211 static int
1212 hscx_mode(struct hscx_hw *hscx, u32 bprotocol)
1213 {
1214 	pr_debug("%s: HSCX %c protocol %x-->%x ch %d\n", hscx->ip->name,
1215 		 '@' + hscx->bch.nr, hscx->bch.state, bprotocol, hscx->bch.nr);
1216 	if (hscx->ip->type & IPAC_TYPE_IPACX) {
1217 		if (hscx->bch.nr & 1) { /* B1 and ICA */
1218 			WriteIPAC(hscx->ip, ISACX_BCHA_TSDP_BC1, 0x80);
1219 			WriteIPAC(hscx->ip, ISACX_BCHA_CR, 0x88);
1220 		} else { /* B2 and ICB */
1221 			WriteIPAC(hscx->ip, ISACX_BCHB_TSDP_BC1, 0x81);
1222 			WriteIPAC(hscx->ip, ISACX_BCHB_CR, 0x88);
1223 		}
1224 		switch (bprotocol) {
1225 		case ISDN_P_NONE: /* init */
1226 			WriteHSCX(hscx, IPACX_MODEB, 0xC0);	/* rec off */
1227 			WriteHSCX(hscx, IPACX_EXMB,  0x30);	/* std adj. */
1228 			WriteHSCX(hscx, IPACX_MASKB, 0xFF);	/* ints off */
1229 			hscx_cmdr(hscx, 0x41);
1230 			test_and_clear_bit(FLG_HDLC, &hscx->bch.Flags);
1231 			test_and_clear_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1232 			break;
1233 		case ISDN_P_B_RAW:
1234 			WriteHSCX(hscx, IPACX_MODEB, 0x88);	/* ex trans */
1235 			WriteHSCX(hscx, IPACX_EXMB,  0x00);	/* trans */
1236 			hscx_cmdr(hscx, 0x41);
1237 			WriteHSCX(hscx, IPACX_MASKB, IPACX_B_ON);
1238 			test_and_set_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1239 			break;
1240 		case ISDN_P_B_HDLC:
1241 			WriteHSCX(hscx, IPACX_MODEB, 0xC0);	/* trans */
1242 			WriteHSCX(hscx, IPACX_EXMB,  0x00);	/* hdlc,crc */
1243 			hscx_cmdr(hscx, 0x41);
1244 			WriteHSCX(hscx, IPACX_MASKB, IPACX_B_ON);
1245 			test_and_set_bit(FLG_HDLC, &hscx->bch.Flags);
1246 			break;
1247 		default:
1248 			pr_info("%s: protocol not known %x\n", hscx->ip->name,
1249 				bprotocol);
1250 			return -ENOPROTOOPT;
1251 		}
1252 	} else if (hscx->ip->type & IPAC_TYPE_IPAC) { /* IPAC */
1253 		WriteHSCX(hscx, IPAC_CCR1, 0x82);
1254 		WriteHSCX(hscx, IPAC_CCR2, 0x30);
1255 		WriteHSCX(hscx, IPAC_XCCR, 0x07);
1256 		WriteHSCX(hscx, IPAC_RCCR, 0x07);
1257 		WriteHSCX(hscx, IPAC_TSAX, hscx->slot);
1258 		WriteHSCX(hscx, IPAC_TSAR, hscx->slot);
1259 		switch (bprotocol) {
1260 		case ISDN_P_NONE:
1261 			WriteHSCX(hscx, IPAC_TSAX, 0x1F);
1262 			WriteHSCX(hscx, IPAC_TSAR, 0x1F);
1263 			WriteHSCX(hscx, IPAC_MODEB, 0x84);
1264 			WriteHSCX(hscx, IPAC_CCR1, 0x82);
1265 			WriteHSCX(hscx, IPAC_MASKB, 0xFF);	/* ints off */
1266 			test_and_clear_bit(FLG_HDLC, &hscx->bch.Flags);
1267 			test_and_clear_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1268 			break;
1269 		case ISDN_P_B_RAW:
1270 			WriteHSCX(hscx, IPAC_MODEB, 0xe4);	/* ex trans */
1271 			WriteHSCX(hscx, IPAC_CCR1, 0x82);
1272 			hscx_cmdr(hscx, 0x41);
1273 			WriteHSCX(hscx, IPAC_MASKB, 0);
1274 			test_and_set_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1275 			break;
1276 		case ISDN_P_B_HDLC:
1277 			WriteHSCX(hscx, IPAC_MODEB, 0x8c);
1278 			WriteHSCX(hscx, IPAC_CCR1, 0x8a);
1279 			hscx_cmdr(hscx, 0x41);
1280 			WriteHSCX(hscx, IPAC_MASKB, 0);
1281 			test_and_set_bit(FLG_HDLC, &hscx->bch.Flags);
1282 			break;
1283 		default:
1284 			pr_info("%s: protocol not known %x\n", hscx->ip->name,
1285 				bprotocol);
1286 			return -ENOPROTOOPT;
1287 		}
1288 	} else if (hscx->ip->type & IPAC_TYPE_HSCX) { /* HSCX */
1289 		WriteHSCX(hscx, IPAC_CCR1, 0x85);
1290 		WriteHSCX(hscx, IPAC_CCR2, 0x30);
1291 		WriteHSCX(hscx, IPAC_XCCR, 0x07);
1292 		WriteHSCX(hscx, IPAC_RCCR, 0x07);
1293 		WriteHSCX(hscx, IPAC_TSAX, hscx->slot);
1294 		WriteHSCX(hscx, IPAC_TSAR, hscx->slot);
1295 		switch (bprotocol) {
1296 		case ISDN_P_NONE:
1297 			WriteHSCX(hscx, IPAC_TSAX, 0x1F);
1298 			WriteHSCX(hscx, IPAC_TSAR, 0x1F);
1299 			WriteHSCX(hscx, IPAC_MODEB, 0x84);
1300 			WriteHSCX(hscx, IPAC_CCR1, 0x85);
1301 			WriteHSCX(hscx, IPAC_MASKB, 0xFF);	/* ints off */
1302 			test_and_clear_bit(FLG_HDLC, &hscx->bch.Flags);
1303 			test_and_clear_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1304 			break;
1305 		case ISDN_P_B_RAW:
1306 			WriteHSCX(hscx, IPAC_MODEB, 0xe4);	/* ex trans */
1307 			WriteHSCX(hscx, IPAC_CCR1, 0x85);
1308 			hscx_cmdr(hscx, 0x41);
1309 			WriteHSCX(hscx, IPAC_MASKB, 0);
1310 			test_and_set_bit(FLG_TRANSPARENT, &hscx->bch.Flags);
1311 			break;
1312 		case ISDN_P_B_HDLC:
1313 			WriteHSCX(hscx, IPAC_MODEB, 0x8c);
1314 			WriteHSCX(hscx, IPAC_CCR1, 0x8d);
1315 			hscx_cmdr(hscx, 0x41);
1316 			WriteHSCX(hscx, IPAC_MASKB, 0);
1317 			test_and_set_bit(FLG_HDLC, &hscx->bch.Flags);
1318 			break;
1319 		default:
1320 			pr_info("%s: protocol not known %x\n", hscx->ip->name,
1321 				bprotocol);
1322 			return -ENOPROTOOPT;
1323 		}
1324 	} else
1325 		return -EINVAL;
1326 	hscx->bch.state = bprotocol;
1327 	return 0;
1328 }
1329 
1330 static int
1331 hscx_l2l1(struct mISDNchannel *ch, struct sk_buff *skb)
1332 {
1333 	struct bchannel *bch = container_of(ch, struct bchannel, ch);
1334 	struct hscx_hw	*hx = container_of(bch, struct hscx_hw, bch);
1335 	int ret = -EINVAL;
1336 	struct mISDNhead *hh = mISDN_HEAD_P(skb);
1337 	unsigned long flags;
1338 
1339 	switch (hh->prim) {
1340 	case PH_DATA_REQ:
1341 		spin_lock_irqsave(hx->ip->hwlock, flags);
1342 		ret = bchannel_senddata(bch, skb);
1343 		if (ret > 0) { /* direct TX */
1344 			ret = 0;
1345 			hscx_fill_fifo(hx);
1346 		}
1347 		spin_unlock_irqrestore(hx->ip->hwlock, flags);
1348 		return ret;
1349 	case PH_ACTIVATE_REQ:
1350 		spin_lock_irqsave(hx->ip->hwlock, flags);
1351 		if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags))
1352 			ret = hscx_mode(hx, ch->protocol);
1353 		else
1354 			ret = 0;
1355 		spin_unlock_irqrestore(hx->ip->hwlock, flags);
1356 		if (!ret)
1357 			_queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
1358 				    NULL, GFP_KERNEL);
1359 		break;
1360 	case PH_DEACTIVATE_REQ:
1361 		spin_lock_irqsave(hx->ip->hwlock, flags);
1362 		mISDN_clear_bchannel(bch);
1363 		hscx_mode(hx, ISDN_P_NONE);
1364 		spin_unlock_irqrestore(hx->ip->hwlock, flags);
1365 		_queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
1366 			    NULL, GFP_KERNEL);
1367 		ret = 0;
1368 		break;
1369 	default:
1370 		pr_info("%s: %s unknown prim(%x,%x)\n",
1371 			hx->ip->name, __func__, hh->prim, hh->id);
1372 		ret = -EINVAL;
1373 	}
1374 	if (!ret)
1375 		dev_kfree_skb(skb);
1376 	return ret;
1377 }
1378 
1379 static int
1380 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1381 {
1382 	return mISDN_ctrl_bchannel(bch, cq);
1383 }
1384 
1385 static int
1386 hscx_bctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
1387 {
1388 	struct bchannel *bch = container_of(ch, struct bchannel, ch);
1389 	struct hscx_hw	*hx = container_of(bch, struct hscx_hw, bch);
1390 	int ret = -EINVAL;
1391 	u_long flags;
1392 
1393 	pr_debug("%s: %s cmd:%x %p\n", hx->ip->name, __func__, cmd, arg);
1394 	switch (cmd) {
1395 	case CLOSE_CHANNEL:
1396 		test_and_clear_bit(FLG_OPEN, &bch->Flags);
1397 		cancel_work_sync(&bch->workq);
1398 		spin_lock_irqsave(hx->ip->hwlock, flags);
1399 		mISDN_clear_bchannel(bch);
1400 		hscx_mode(hx, ISDN_P_NONE);
1401 		spin_unlock_irqrestore(hx->ip->hwlock, flags);
1402 		ch->protocol = ISDN_P_NONE;
1403 		ch->peer = NULL;
1404 		module_put(hx->ip->owner);
1405 		ret = 0;
1406 		break;
1407 	case CONTROL_CHANNEL:
1408 		ret = channel_bctrl(bch, arg);
1409 		break;
1410 	default:
1411 		pr_info("%s: %s unknown prim(%x)\n",
1412 			hx->ip->name, __func__, cmd);
1413 	}
1414 	return ret;
1415 }
1416 
1417 static void
1418 free_ipac(struct ipac_hw *ipac)
1419 {
1420 	isac_release(&ipac->isac);
1421 }
1422 
1423 static const char *HSCXVer[] =
1424 {"A1", "?1", "A2", "?3", "A3", "V2.1", "?6", "?7",
1425  "?8", "?9", "?10", "?11", "?12", "?13", "?14", "???"};
1426 
1427 
1428 
1429 static void
1430 hscx_init(struct hscx_hw *hx)
1431 {
1432 	u8 val;
1433 
1434 	WriteHSCX(hx, IPAC_RAH2, 0xFF);
1435 	WriteHSCX(hx, IPAC_XBCH, 0x00);
1436 	WriteHSCX(hx, IPAC_RLCR, 0x00);
1437 
1438 	if (hx->ip->type & IPAC_TYPE_HSCX) {
1439 		WriteHSCX(hx, IPAC_CCR1, 0x85);
1440 		val = ReadHSCX(hx, HSCX_VSTR);
1441 		pr_debug("%s: HSCX VSTR %02x\n", hx->ip->name, val);
1442 		if (hx->bch.debug & DEBUG_HW)
1443 			pr_notice("%s: HSCX version %s\n", hx->ip->name,
1444 				  HSCXVer[val & 0x0f]);
1445 	} else
1446 		WriteHSCX(hx, IPAC_CCR1, 0x82);
1447 	WriteHSCX(hx, IPAC_CCR2, 0x30);
1448 	WriteHSCX(hx, IPAC_XCCR, 0x07);
1449 	WriteHSCX(hx, IPAC_RCCR, 0x07);
1450 }
1451 
1452 static int
1453 ipac_init(struct ipac_hw *ipac)
1454 {
1455 	u8 val;
1456 
1457 	if (ipac->type & IPAC_TYPE_HSCX) {
1458 		hscx_init(&ipac->hscx[0]);
1459 		hscx_init(&ipac->hscx[1]);
1460 		val = ReadIPAC(ipac, IPAC_ID);
1461 	} else if (ipac->type & IPAC_TYPE_IPAC) {
1462 		hscx_init(&ipac->hscx[0]);
1463 		hscx_init(&ipac->hscx[1]);
1464 		WriteIPAC(ipac, IPAC_MASK, IPAC__ON);
1465 		val = ReadIPAC(ipac, IPAC_CONF);
1466 		/* conf is default 0, but can be overwritten by card setup */
1467 		pr_debug("%s: IPAC CONF %02x/%02x\n", ipac->name,
1468 			 val, ipac->conf);
1469 		WriteIPAC(ipac, IPAC_CONF, ipac->conf);
1470 		val = ReadIPAC(ipac, IPAC_ID);
1471 		if (ipac->hscx[0].bch.debug & DEBUG_HW)
1472 			pr_notice("%s: IPAC Design ID %02x\n", ipac->name, val);
1473 	}
1474 	/* nothing special for IPACX to do here */
1475 	return isac_init(&ipac->isac);
1476 }
1477 
1478 static int
1479 open_bchannel(struct ipac_hw *ipac, struct channel_req *rq)
1480 {
1481 	struct bchannel		*bch;
1482 
1483 	if (rq->adr.channel == 0 || rq->adr.channel > 2)
1484 		return -EINVAL;
1485 	if (rq->protocol == ISDN_P_NONE)
1486 		return -EINVAL;
1487 	bch = &ipac->hscx[rq->adr.channel - 1].bch;
1488 	if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1489 		return -EBUSY; /* b-channel can be only open once */
1490 	test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
1491 	bch->ch.protocol = rq->protocol;
1492 	rq->ch = &bch->ch;
1493 	return 0;
1494 }
1495 
1496 static int
1497 channel_ctrl(struct ipac_hw *ipac, struct mISDN_ctrl_req *cq)
1498 {
1499 	int	ret = 0;
1500 
1501 	switch (cq->op) {
1502 	case MISDN_CTRL_GETOP:
1503 		cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
1504 		break;
1505 	case MISDN_CTRL_LOOP:
1506 		/* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
1507 		if (cq->channel < 0 || cq->channel > 3) {
1508 			ret = -EINVAL;
1509 			break;
1510 		}
1511 		ret = ipac->ctrl(ipac, HW_TESTLOOP, cq->channel);
1512 		break;
1513 	case MISDN_CTRL_L1_TIMER3:
1514 		ret = ipac->isac.ctrl(&ipac->isac, HW_TIMER3_VALUE, cq->p1);
1515 		break;
1516 	default:
1517 		pr_info("%s: unknown CTRL OP %x\n", ipac->name, cq->op);
1518 		ret = -EINVAL;
1519 		break;
1520 	}
1521 	return ret;
1522 }
1523 
1524 static int
1525 ipac_dctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
1526 {
1527 	struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
1528 	struct dchannel *dch = container_of(dev, struct dchannel, dev);
1529 	struct isac_hw *isac = container_of(dch, struct isac_hw, dch);
1530 	struct ipac_hw *ipac = container_of(isac, struct ipac_hw, isac);
1531 	struct channel_req *rq;
1532 	int err = 0;
1533 
1534 	pr_debug("%s: DCTRL: %x %p\n", ipac->name, cmd, arg);
1535 	switch (cmd) {
1536 	case OPEN_CHANNEL:
1537 		rq = arg;
1538 		if (rq->protocol == ISDN_P_TE_S0)
1539 			err = open_dchannel_caller(isac, rq, __builtin_return_address(0));
1540 		else
1541 			err = open_bchannel(ipac, rq);
1542 		if (err)
1543 			break;
1544 		if (!try_module_get(ipac->owner))
1545 			pr_info("%s: cannot get module\n", ipac->name);
1546 		break;
1547 	case CLOSE_CHANNEL:
1548 		pr_debug("%s: dev(%d) close from %p\n", ipac->name,
1549 			 dch->dev.id, __builtin_return_address(0));
1550 		module_put(ipac->owner);
1551 		break;
1552 	case CONTROL_CHANNEL:
1553 		err = channel_ctrl(ipac, arg);
1554 		break;
1555 	default:
1556 		pr_debug("%s: unknown DCTRL command %x\n", ipac->name, cmd);
1557 		return -EINVAL;
1558 	}
1559 	return err;
1560 }
1561 
1562 u32
1563 mISDNipac_init(struct ipac_hw *ipac, void *hw)
1564 {
1565 	u32 ret;
1566 	u8 i;
1567 
1568 	ipac->hw = hw;
1569 	if (ipac->isac.dch.debug & DEBUG_HW)
1570 		pr_notice("%s: ipac type %x\n", ipac->name, ipac->type);
1571 	if (ipac->type & IPAC_TYPE_HSCX) {
1572 		ipac->isac.type = IPAC_TYPE_ISAC;
1573 		ipac->hscx[0].off = 0;
1574 		ipac->hscx[1].off = 0x40;
1575 		ipac->hscx[0].fifo_size = 32;
1576 		ipac->hscx[1].fifo_size = 32;
1577 	} else if (ipac->type & IPAC_TYPE_IPAC) {
1578 		ipac->isac.type = IPAC_TYPE_IPAC | IPAC_TYPE_ISAC;
1579 		ipac->hscx[0].off = 0;
1580 		ipac->hscx[1].off = 0x40;
1581 		ipac->hscx[0].fifo_size = 64;
1582 		ipac->hscx[1].fifo_size = 64;
1583 	} else if (ipac->type & IPAC_TYPE_IPACX) {
1584 		ipac->isac.type = IPAC_TYPE_IPACX | IPAC_TYPE_ISACX;
1585 		ipac->hscx[0].off = IPACX_OFF_ICA;
1586 		ipac->hscx[1].off = IPACX_OFF_ICB;
1587 		ipac->hscx[0].fifo_size = 64;
1588 		ipac->hscx[1].fifo_size = 64;
1589 	} else
1590 		return 0;
1591 
1592 	mISDNisac_init(&ipac->isac, hw);
1593 
1594 	ipac->isac.dch.dev.D.ctrl = ipac_dctrl;
1595 
1596 	for (i = 0; i < 2; i++) {
1597 		ipac->hscx[i].bch.nr = i + 1;
1598 		set_channelmap(i + 1, ipac->isac.dch.dev.channelmap);
1599 		list_add(&ipac->hscx[i].bch.ch.list,
1600 			 &ipac->isac.dch.dev.bchannels);
1601 		mISDN_initbchannel(&ipac->hscx[i].bch, MAX_DATA_MEM,
1602 				   ipac->hscx[i].fifo_size);
1603 		ipac->hscx[i].bch.ch.nr = i + 1;
1604 		ipac->hscx[i].bch.ch.send = &hscx_l2l1;
1605 		ipac->hscx[i].bch.ch.ctrl = hscx_bctrl;
1606 		ipac->hscx[i].bch.hw = hw;
1607 		ipac->hscx[i].ip = ipac;
1608 		/* default values for IOM time slots
1609 		 * can be overwritten by card */
1610 		ipac->hscx[i].slot = (i == 0) ? 0x2f : 0x03;
1611 	}
1612 
1613 	ipac->init = ipac_init;
1614 	ipac->release = free_ipac;
1615 
1616 	ret =	(1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1617 		(1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1618 	return ret;
1619 }
1620 EXPORT_SYMBOL(mISDNipac_init);
1621 
1622 static int __init
1623 isac_mod_init(void)
1624 {
1625 	pr_notice("mISDNipac module version %s\n", ISAC_REV);
1626 	return 0;
1627 }
1628 
1629 static void __exit
1630 isac_mod_cleanup(void)
1631 {
1632 	pr_notice("mISDNipac module unloaded\n");
1633 }
1634 module_init(isac_mod_init);
1635 module_exit(isac_mod_cleanup);
1636