1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * hfcmulti.c low level driver for hfc-4s/hfc-8s/hfc-e1 based cards
5 * Author Andreas Eversberg (jolly@eversberg.eu)
6 * ported to mqueue mechanism:
7 * Peter Sprenger (sprengermoving-bytes.de)
9 * inspired by existing hfc-pci driver:
10 * Copyright 1999 by Werner Cornelius (werner@isdn-development.de)
11 * Copyright 2008 by Karsten Keil (kkeil@suse.de)
12 * Copyright 2008 by Andreas Eversberg (jolly@eversberg.eu)
14 * Thanks to Cologne Chip AG for this great controller!
20 * By default (0), the card is automatically detected.
21 * Or use the following combinations:
22 * Bit 0-7 = 0x00001 = HFC-E1 (1 port)
23 * or Bit 0-7 = 0x00004 = HFC-4S (4 ports)
24 * or Bit 0-7 = 0x00008 = HFC-8S (8 ports)
25 * Bit 8 = 0x00100 = uLaw (instead of aLaw)
26 * Bit 9 = 0x00200 = Disable DTMF detect on all B-channels via hardware
28 * Bit 11 = 0x00800 = Force PCM bus into slave mode. (otherwhise auto)
29 * or Bit 12 = 0x01000 = Force PCM bus into master mode. (otherwhise auto)
31 * Bit 14 = 0x04000 = Use external ram (128K)
32 * Bit 15 = 0x08000 = Use external ram (512K)
33 * Bit 16 = 0x10000 = Use 64 timeslots instead of 32
34 * or Bit 17 = 0x20000 = Use 128 timeslots instead of anything else
36 * Bit 19 = 0x80000 = Send the Watchdog a Signal (Dual E1 with Watchdog)
37 * (all other bits are reserved and shall be 0)
38 * example: 0x20204 one HFC-4S with dtmf detection and 128 timeslots on PCM
41 * port: (optional or required for all ports on all installed cards)
42 * HFC-4S/HFC-8S only bits:
43 * Bit 0 = 0x001 = Use master clock for this S/T interface
44 * (ony once per chip).
45 * Bit 1 = 0x002 = transmitter line setup (non capacitive mode)
46 * Don't use this unless you know what you are doing!
47 * Bit 2 = 0x004 = Disable E-channel. (No E-channel processing)
48 * example: 0x0001,0x0000,0x0000,0x0000 one HFC-4S with master clock
49 * received from port 1
52 * Bit 0 = 0x0001 = interface: 0=copper, 1=optical
53 * Bit 1 = 0x0002 = reserved (later for 32 B-channels transparent mode)
54 * Bit 2 = 0x0004 = Report LOS
55 * Bit 3 = 0x0008 = Report AIS
56 * Bit 4 = 0x0010 = Report SLIP
57 * Bit 5 = 0x0020 = Report RDI
58 * Bit 8 = 0x0100 = Turn off CRC-4 Multiframe Mode, use double frame
60 * Bit 9 = 0x0200 = Force get clock from interface, even in NT mode.
61 * or Bit 10 = 0x0400 = Force put clock to interface, even in TE mode.
62 * Bit 11 = 0x0800 = Use direct RX clock for PCM sync rather than PLL.
64 * Bit 12-13 = 0xX000 = elastic jitter buffer (1-3), Set both bits to 0
66 * (all other bits are reserved and shall be 0)
69 * NOTE: only one debug value must be given for all cards
70 * enable debugging (see hfc_multi.h for debug options)
73 * NOTE: only one poll value must be given for all cards
74 * Give the number of samples for each fifo process.
75 * By default 128 is used. Decrease to reduce delay, increase to
76 * reduce cpu load. If unsure, don't mess with it!
77 * Valid is 8, 16, 32, 64, 128, 256.
80 * NOTE: only one pcm value must be given for every card.
81 * The PCM bus id tells the mISDNdsp module about the connected PCM bus.
82 * By default (0), the PCM bus id is 100 for the card that is PCM master.
83 * If multiple cards are PCM master (because they are not interconnected),
84 * each card with PCM master will have increasing PCM id.
85 * All PCM busses with the same ID are expected to be connected and have
86 * common time slots slots.
87 * Only one chip of the PCM bus must be master, the others slave.
88 * -1 means no support of PCM bus not even.
89 * Omit this value, if all cards are interconnected or none is connected.
90 * If unsure, don't give this parameter.
93 * NOTE: One dmask value must be given for every HFC-E1 card.
94 * If omitted, the E1 card has D-channel on time slot 16, which is default.
95 * dmask is a 32 bit mask. The bit must be set for an alternate time slot.
96 * If multiple bits are set, multiple virtual card fragments are created.
97 * For each bit set, a bmask value must be given. Each bit on the bmask
98 * value stands for a B-channel. The bmask may not overlap with dmask or
99 * with other bmask values for that card.
100 * Example: dmask=0x00020002 bmask=0x0000fffc,0xfffc0000
101 * This will create one fragment with D-channel on slot 1 with
102 * B-channels on slots 2..15, and a second fragment with D-channel
103 * on slot 17 with B-channels on slot 18..31. Slot 16 is unused.
104 * If bit 0 is set (dmask=0x00000001) the D-channel is on slot 0 and will
106 * Example: dmask=0x00000001 bmask=0xfffffffe
107 * This will create a port with all 31 usable timeslots as
109 * If no bits are set on bmask, no B-channel is created for that fragment.
110 * Example: dmask=0xfffffffe bmask=0,0,0,0.... (31 0-values for bmask)
111 * This will create 31 ports with one D-channel only.
112 * If you don't know how to use it, you don't need it!
115 * NOTE: only one mode value must be given for every card.
116 * -> See hfc_multi.h for HFC_IO_MODE_* values
117 * By default, the IO mode is pci memory IO (MEMIO).
118 * Some cards require specific IO mode, so it cannot be changed.
119 * It may be useful to set IO mode to register io (REGIO) to solve
120 * PCI bridge problems.
121 * If unsure, don't give this parameter.
124 * NOTE: only one clockdelay_nt value must be given once for all cards.
125 * Give the value of the clock control register (A_ST_CLK_DLY)
126 * of the S/T interfaces in NT mode.
127 * This register is needed for the TBR3 certification, so don't change it.
130 * NOTE: only one clockdelay_te value must be given once
131 * Give the value of the clock control register (A_ST_CLK_DLY)
132 * of the S/T interfaces in TE mode.
133 * This register is needed for the TBR3 certification, so don't change it.
136 * NOTE: only one clock value must be given once
137 * Selects interface with clock source for mISDN and applications.
138 * Set to card number starting with 1. Set to -1 to disable.
139 * By default, the first card is used as clock source.
142 * NOTE: only one hwid value must be given once
143 * Enable special embedded devices with XHFC controllers.
147 * debug register access (never use this, it will flood your system log)
148 * #define HFC_REGISTER_DEBUG
151 #define HFC_MULTI_VERSION "2.03"
153 #include <linux/interrupt.h>
154 #include <linux/module.h>
155 #include <linux/slab.h>
156 #include <linux/pci.h>
157 #include <linux/delay.h>
158 #include <linux/mISDNhw.h>
159 #include <linux/mISDNdsp.h>
162 #define IRQCOUNT_DEBUG
166 #include "hfc_multi.h"
172 #define MAX_PORTS (8 * MAX_CARDS)
173 #define MAX_FRAGS (32 * MAX_CARDS)
175 static LIST_HEAD(HFClist);
176 static DEFINE_SPINLOCK(HFClock); /* global hfc list lock */
178 static void ph_state_change(struct dchannel *);
180 static struct hfc_multi *syncmaster;
181 static int plxsd_master; /* if we have a master card (yet) */
182 static DEFINE_SPINLOCK(plx_lock); /* may not acquire other lock inside */
188 static int poll_timer = 6; /* default = 128 samples = 16ms */
189 /* number of POLL_TIMER interrupts for G2 timeout (ca 1s) */
190 static int nt_t1_count[] = { 3840, 1920, 960, 480, 240, 120, 60, 30 };
191 #define CLKDEL_TE 0x0f /* CLKDEL in TE mode */
192 #define CLKDEL_NT 0x6c /* CLKDEL in NT mode
193 (0x60 MUST be included!) */
195 #define DIP_4S 0x1 /* DIP Switches for Beronet 1S/2S/4S cards */
196 #define DIP_8S 0x2 /* DIP Switches for Beronet 8S+ cards */
197 #define DIP_E1 0x3 /* DIP Switches for Beronet E1 cards */
203 static uint type[MAX_CARDS];
204 static int pcm[MAX_CARDS];
205 static uint dmask[MAX_CARDS];
206 static uint bmask[MAX_FRAGS];
207 static uint iomode[MAX_CARDS];
208 static uint port[MAX_PORTS];
213 static uint clockdelay_te = CLKDEL_TE;
214 static uint clockdelay_nt = CLKDEL_NT;
216 #define HWID_MINIP4 1
217 #define HWID_MINIP8 2
218 #define HWID_MINIP16 3
219 static uint hwid = HWID_NONE;
221 static int HFC_cnt, E1_cnt, bmask_cnt, Port_cnt, PCM_cnt = 99;
223 MODULE_AUTHOR("Andreas Eversberg");
224 MODULE_LICENSE("GPL");
225 MODULE_VERSION(HFC_MULTI_VERSION);
226 module_param(debug, uint, S_IRUGO | S_IWUSR);
227 module_param(poll, uint, S_IRUGO | S_IWUSR);
228 module_param(clock, int, S_IRUGO | S_IWUSR);
229 module_param(timer, uint, S_IRUGO | S_IWUSR);
230 module_param(clockdelay_te, uint, S_IRUGO | S_IWUSR);
231 module_param(clockdelay_nt, uint, S_IRUGO | S_IWUSR);
232 module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR);
233 module_param_array(pcm, int, NULL, S_IRUGO | S_IWUSR);
234 module_param_array(dmask, uint, NULL, S_IRUGO | S_IWUSR);
235 module_param_array(bmask, uint, NULL, S_IRUGO | S_IWUSR);
236 module_param_array(iomode, uint, NULL, S_IRUGO | S_IWUSR);
237 module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR);
238 module_param(hwid, uint, S_IRUGO | S_IWUSR); /* The hardware ID */
240 #ifdef HFC_REGISTER_DEBUG
241 #define HFC_outb(hc, reg, val) \
242 (hc->HFC_outb(hc, reg, val, __func__, __LINE__))
243 #define HFC_outb_nodebug(hc, reg, val) \
244 (hc->HFC_outb_nodebug(hc, reg, val, __func__, __LINE__))
245 #define HFC_inb(hc, reg) \
246 (hc->HFC_inb(hc, reg, __func__, __LINE__))
247 #define HFC_inb_nodebug(hc, reg) \
248 (hc->HFC_inb_nodebug(hc, reg, __func__, __LINE__))
249 #define HFC_inw(hc, reg) \
250 (hc->HFC_inw(hc, reg, __func__, __LINE__))
251 #define HFC_inw_nodebug(hc, reg) \
252 (hc->HFC_inw_nodebug(hc, reg, __func__, __LINE__))
253 #define HFC_wait(hc) \
254 (hc->HFC_wait(hc, __func__, __LINE__))
255 #define HFC_wait_nodebug(hc) \
256 (hc->HFC_wait_nodebug(hc, __func__, __LINE__))
258 #define HFC_outb(hc, reg, val) (hc->HFC_outb(hc, reg, val))
259 #define HFC_outb_nodebug(hc, reg, val) (hc->HFC_outb_nodebug(hc, reg, val))
260 #define HFC_inb(hc, reg) (hc->HFC_inb(hc, reg))
261 #define HFC_inb_nodebug(hc, reg) (hc->HFC_inb_nodebug(hc, reg))
262 #define HFC_inw(hc, reg) (hc->HFC_inw(hc, reg))
263 #define HFC_inw_nodebug(hc, reg) (hc->HFC_inw_nodebug(hc, reg))
264 #define HFC_wait(hc) (hc->HFC_wait(hc))
265 #define HFC_wait_nodebug(hc) (hc->HFC_wait_nodebug(hc))
268 #ifdef CONFIG_MISDN_HFCMULTI_8xx
269 #include "hfc_multi_8xx.h"
272 /* HFC_IO_MODE_PCIMEM */
274 #ifdef HFC_REGISTER_DEBUG
275 HFC_outb_pcimem(struct hfc_multi *hc, u_char reg, u_char val,
276 const char *function, int line)
278 HFC_outb_pcimem(struct hfc_multi *hc, u_char reg, u_char val)
281 writeb(val, hc->pci_membase + reg);
284 #ifdef HFC_REGISTER_DEBUG
285 HFC_inb_pcimem(struct hfc_multi *hc, u_char reg, const char *function, int line)
287 HFC_inb_pcimem(struct hfc_multi *hc, u_char reg)
290 return readb(hc->pci_membase + reg);
293 #ifdef HFC_REGISTER_DEBUG
294 HFC_inw_pcimem(struct hfc_multi *hc, u_char reg, const char *function, int line)
296 HFC_inw_pcimem(struct hfc_multi *hc, u_char reg)
299 return readw(hc->pci_membase + reg);
302 #ifdef HFC_REGISTER_DEBUG
303 HFC_wait_pcimem(struct hfc_multi *hc, const char *function, int line)
305 HFC_wait_pcimem(struct hfc_multi *hc)
308 while (readb(hc->pci_membase + R_STATUS) & V_BUSY)
312 /* HFC_IO_MODE_REGIO */
314 #ifdef HFC_REGISTER_DEBUG
315 HFC_outb_regio(struct hfc_multi *hc, u_char reg, u_char val,
316 const char *function, int line)
318 HFC_outb_regio(struct hfc_multi *hc, u_char reg, u_char val)
321 outb(reg, hc->pci_iobase + 4);
322 outb(val, hc->pci_iobase);
325 #ifdef HFC_REGISTER_DEBUG
326 HFC_inb_regio(struct hfc_multi *hc, u_char reg, const char *function, int line)
328 HFC_inb_regio(struct hfc_multi *hc, u_char reg)
331 outb(reg, hc->pci_iobase + 4);
332 return inb(hc->pci_iobase);
335 #ifdef HFC_REGISTER_DEBUG
336 HFC_inw_regio(struct hfc_multi *hc, u_char reg, const char *function, int line)
338 HFC_inw_regio(struct hfc_multi *hc, u_char reg)
341 outb(reg, hc->pci_iobase + 4);
342 return inw(hc->pci_iobase);
345 #ifdef HFC_REGISTER_DEBUG
346 HFC_wait_regio(struct hfc_multi *hc, const char *function, int line)
348 HFC_wait_regio(struct hfc_multi *hc)
351 outb(R_STATUS, hc->pci_iobase + 4);
352 while (inb(hc->pci_iobase) & V_BUSY)
356 #ifdef HFC_REGISTER_DEBUG
358 HFC_outb_debug(struct hfc_multi *hc, u_char reg, u_char val,
359 const char *function, int line)
361 char regname[256] = "", bits[9] = "xxxxxxxx";
365 while (hfc_register_names[++i].name) {
366 if (hfc_register_names[i].reg == reg)
367 strcat(regname, hfc_register_names[i].name);
369 if (regname[0] == '\0')
370 strcpy(regname, "register");
372 bits[7] = '0' + (!!(val & 1));
373 bits[6] = '0' + (!!(val & 2));
374 bits[5] = '0' + (!!(val & 4));
375 bits[4] = '0' + (!!(val & 8));
376 bits[3] = '0' + (!!(val & 16));
377 bits[2] = '0' + (!!(val & 32));
378 bits[1] = '0' + (!!(val & 64));
379 bits[0] = '0' + (!!(val & 128));
381 "HFC_outb(chip %d, %02x=%s, 0x%02x=%s); in %s() line %d\n",
382 hc->id, reg, regname, val, bits, function, line);
383 HFC_outb_nodebug(hc, reg, val);
386 HFC_inb_debug(struct hfc_multi *hc, u_char reg, const char *function, int line)
388 char regname[256] = "", bits[9] = "xxxxxxxx";
389 u_char val = HFC_inb_nodebug(hc, reg);
393 while (hfc_register_names[i++].name)
395 while (hfc_register_names[++i].name) {
396 if (hfc_register_names[i].reg == reg)
397 strcat(regname, hfc_register_names[i].name);
399 if (regname[0] == '\0')
400 strcpy(regname, "register");
402 bits[7] = '0' + (!!(val & 1));
403 bits[6] = '0' + (!!(val & 2));
404 bits[5] = '0' + (!!(val & 4));
405 bits[4] = '0' + (!!(val & 8));
406 bits[3] = '0' + (!!(val & 16));
407 bits[2] = '0' + (!!(val & 32));
408 bits[1] = '0' + (!!(val & 64));
409 bits[0] = '0' + (!!(val & 128));
411 "HFC_inb(chip %d, %02x=%s) = 0x%02x=%s; in %s() line %d\n",
412 hc->id, reg, regname, val, bits, function, line);
416 HFC_inw_debug(struct hfc_multi *hc, u_char reg, const char *function, int line)
418 char regname[256] = "";
419 u_short val = HFC_inw_nodebug(hc, reg);
423 while (hfc_register_names[i++].name)
425 while (hfc_register_names[++i].name) {
426 if (hfc_register_names[i].reg == reg)
427 strcat(regname, hfc_register_names[i].name);
429 if (regname[0] == '\0')
430 strcpy(regname, "register");
433 "HFC_inw(chip %d, %02x=%s) = 0x%04x; in %s() line %d\n",
434 hc->id, reg, regname, val, function, line);
438 HFC_wait_debug(struct hfc_multi *hc, const char *function, int line)
440 printk(KERN_DEBUG "HFC_wait(chip %d); in %s() line %d\n",
441 hc->id, function, line);
442 HFC_wait_nodebug(hc);
446 /* write fifo data (REGIO) */
448 write_fifo_regio(struct hfc_multi *hc, u_char *data, int len)
450 outb(A_FIFO_DATA0, (hc->pci_iobase) + 4);
452 outl(cpu_to_le32(*(u32 *)data), hc->pci_iobase);
457 outw(cpu_to_le16(*(u16 *)data), hc->pci_iobase);
462 outb(*data, hc->pci_iobase);
467 /* write fifo data (PCIMEM) */
469 write_fifo_pcimem(struct hfc_multi *hc, u_char *data, int len)
472 writel(cpu_to_le32(*(u32 *)data),
473 hc->pci_membase + A_FIFO_DATA0);
478 writew(cpu_to_le16(*(u16 *)data),
479 hc->pci_membase + A_FIFO_DATA0);
484 writeb(*data, hc->pci_membase + A_FIFO_DATA0);
490 /* read fifo data (REGIO) */
492 read_fifo_regio(struct hfc_multi *hc, u_char *data, int len)
494 outb(A_FIFO_DATA0, (hc->pci_iobase) + 4);
496 *(u32 *)data = le32_to_cpu(inl(hc->pci_iobase));
501 *(u16 *)data = le16_to_cpu(inw(hc->pci_iobase));
506 *data = inb(hc->pci_iobase);
512 /* read fifo data (PCIMEM) */
514 read_fifo_pcimem(struct hfc_multi *hc, u_char *data, int len)
518 le32_to_cpu(readl(hc->pci_membase + A_FIFO_DATA0));
524 le16_to_cpu(readw(hc->pci_membase + A_FIFO_DATA0));
529 *data = readb(hc->pci_membase + A_FIFO_DATA0);
536 enable_hwirq(struct hfc_multi *hc)
538 hc->hw.r_irq_ctrl |= V_GLOB_IRQ_EN;
539 HFC_outb(hc, R_IRQ_CTRL, hc->hw.r_irq_ctrl);
543 disable_hwirq(struct hfc_multi *hc)
545 hc->hw.r_irq_ctrl &= ~((u_char)V_GLOB_IRQ_EN);
546 HFC_outb(hc, R_IRQ_CTRL, hc->hw.r_irq_ctrl);
550 #define MAX_TDM_CHAN 32
554 enablepcibridge(struct hfc_multi *c)
556 HFC_outb(c, R_BRG_PCM_CFG, (0x0 << 6) | 0x3); /* was _io before */
560 disablepcibridge(struct hfc_multi *c)
562 HFC_outb(c, R_BRG_PCM_CFG, (0x0 << 6) | 0x2); /* was _io before */
565 static inline unsigned char
566 readpcibridge(struct hfc_multi *hc, unsigned char address)
574 /* slow down a PCI read access by 1 PCI clock cycle */
575 HFC_outb(hc, R_CTRL, 0x4); /*was _io before*/
582 /* select local bridge port address by writing to CIP port */
583 /* data = HFC_inb(c, cipv); * was _io before */
584 outw(cipv, hc->pci_iobase + 4);
585 data = inb(hc->pci_iobase);
587 /* restore R_CTRL for normal PCI read cycle speed */
588 HFC_outb(hc, R_CTRL, 0x0); /* was _io before */
594 writepcibridge(struct hfc_multi *hc, unsigned char address, unsigned char data)
607 /* select local bridge port address by writing to CIP port */
608 outw(cipv, hc->pci_iobase + 4);
609 /* define a 32 bit dword with 4 identical bytes for write sequence */
610 datav = data | ((__u32) data << 8) | ((__u32) data << 16) |
611 ((__u32) data << 24);
614 * write this 32 bit dword to the bridge data port
615 * this will initiate a write sequence of up to 4 writes to the same
616 * address on the local bus interface the number of write accesses
617 * is undefined but >=1 and depends on the next PCI transaction
618 * during write sequence on the local bus
620 outl(datav, hc->pci_iobase);
624 cpld_set_reg(struct hfc_multi *hc, unsigned char reg)
626 /* Do data pin read low byte */
627 HFC_outb(hc, R_GPIO_OUT1, reg);
631 cpld_write_reg(struct hfc_multi *hc, unsigned char reg, unsigned char val)
633 cpld_set_reg(hc, reg);
636 writepcibridge(hc, 1, val);
637 disablepcibridge(hc);
642 static inline unsigned char
643 cpld_read_reg(struct hfc_multi *hc, unsigned char reg)
645 unsigned char bytein;
647 cpld_set_reg(hc, reg);
649 /* Do data pin read low byte */
650 HFC_outb(hc, R_GPIO_OUT1, reg);
653 bytein = readpcibridge(hc, 1);
654 disablepcibridge(hc);
660 vpm_write_address(struct hfc_multi *hc, unsigned short addr)
662 cpld_write_reg(hc, 0, 0xff & addr);
663 cpld_write_reg(hc, 1, 0x01 & (addr >> 8));
666 static inline unsigned short
667 vpm_read_address(struct hfc_multi *c)
670 unsigned short highbit;
672 addr = cpld_read_reg(c, 0);
673 highbit = cpld_read_reg(c, 1);
675 addr = addr | (highbit << 8);
680 static inline unsigned char
681 vpm_in(struct hfc_multi *c, int which, unsigned short addr)
685 vpm_write_address(c, addr);
693 res = readpcibridge(c, 1);
702 vpm_out(struct hfc_multi *c, int which, unsigned short addr,
705 vpm_write_address(c, addr);
714 writepcibridge(c, 1, data);
722 regin = vpm_in(c, which, addr);
724 printk(KERN_DEBUG "Wrote 0x%x to register 0x%x but got back "
725 "0x%x\n", data, addr, regin);
732 vpm_init(struct hfc_multi *wc)
736 unsigned int i, x, y;
739 for (x = 0; x < NUM_EC; x++) {
742 ver = vpm_in(wc, x, 0x1a0);
743 printk(KERN_DEBUG "VPM: Chip %d: ver %02x\n", x, ver);
746 for (y = 0; y < 4; y++) {
747 vpm_out(wc, x, 0x1a8 + y, 0x00); /* GPIO out */
748 vpm_out(wc, x, 0x1ac + y, 0x00); /* GPIO dir */
749 vpm_out(wc, x, 0x1b0 + y, 0x00); /* GPIO sel */
752 /* Setup TDM path - sets fsync and tdm_clk as inputs */
753 reg = vpm_in(wc, x, 0x1a3); /* misc_con */
754 vpm_out(wc, x, 0x1a3, reg & ~2);
756 /* Setup Echo length (256 taps) */
757 vpm_out(wc, x, 0x022, 1);
758 vpm_out(wc, x, 0x023, 0xff);
760 /* Setup timeslots */
761 vpm_out(wc, x, 0x02f, 0x00);
762 mask = 0x02020202 << (x * 4);
764 /* Setup the tdm channel masks for all chips */
765 for (i = 0; i < 4; i++)
766 vpm_out(wc, x, 0x33 - i, (mask >> (i << 3)) & 0xff);
768 /* Setup convergence rate */
769 printk(KERN_DEBUG "VPM: A-law mode\n");
770 reg = 0x00 | 0x10 | 0x01;
771 vpm_out(wc, x, 0x20, reg);
772 printk(KERN_DEBUG "VPM reg 0x20 is %x\n", reg);
773 /*vpm_out(wc, x, 0x20, (0x00 | 0x08 | 0x20 | 0x10)); */
775 vpm_out(wc, x, 0x24, 0x02);
776 reg = vpm_in(wc, x, 0x24);
777 printk(KERN_DEBUG "NLP Thresh is set to %d (0x%x)\n", reg, reg);
779 /* Initialize echo cans */
780 for (i = 0; i < MAX_TDM_CHAN; i++) {
781 if (mask & (0x00000001 << i))
782 vpm_out(wc, x, i, 0x00);
786 * ARM arch at least disallows a udelay of
787 * more than 2ms... it gives a fake "__bad_udelay"
788 * reference at link-time.
789 * long delays in kernel code are pretty sucky anyway
790 * for now work around it using 5 x 2ms instead of 1 x 10ms
799 /* Put in bypass mode */
800 for (i = 0; i < MAX_TDM_CHAN; i++) {
801 if (mask & (0x00000001 << i))
802 vpm_out(wc, x, i, 0x01);
806 for (i = 0; i < MAX_TDM_CHAN; i++) {
807 if (mask & (0x00000001 << i))
808 vpm_out(wc, x, 0x78 + i, 0x01);
816 vpm_check(struct hfc_multi *hctmp)
820 gpi2 = HFC_inb(hctmp, R_GPI_IN2);
822 if ((gpi2 & 0x3) != 0x3)
823 printk(KERN_DEBUG "Got interrupt 0x%x from VPM!\n", gpi2);
829 * Interface to enable/disable the HW Echocan
831 * these functions are called within a spin_lock_irqsave on
832 * the channel instance lock, so we are not disturbed by irqs
834 * we can later easily change the interface to make other
835 * things configurable, for now we configure the taps
840 vpm_echocan_on(struct hfc_multi *hc, int ch, int taps)
842 unsigned int timeslot;
844 struct bchannel *bch = hc->chan[ch].bch;
849 if (hc->chan[ch].protocol != ISDN_P_B_RAW)
856 skb = _alloc_mISDN_skb(PH_CONTROL_IND, HFC_VOL_CHANGE_TX,
857 sizeof(int), &txadj, GFP_ATOMIC);
859 recv_Bchannel_skb(bch, skb);
862 timeslot = ((ch / 4) * 8) + ((ch % 4) * 4) + 1;
865 printk(KERN_NOTICE "vpm_echocan_on called taps [%d] on timeslot %d\n",
868 vpm_out(hc, unit, timeslot, 0x7e);
872 vpm_echocan_off(struct hfc_multi *hc, int ch)
874 unsigned int timeslot;
876 struct bchannel *bch = hc->chan[ch].bch;
882 if (hc->chan[ch].protocol != ISDN_P_B_RAW)
889 skb = _alloc_mISDN_skb(PH_CONTROL_IND, HFC_VOL_CHANGE_TX,
890 sizeof(int), &txadj, GFP_ATOMIC);
892 recv_Bchannel_skb(bch, skb);
895 timeslot = ((ch / 4) * 8) + ((ch % 4) * 4) + 1;
898 printk(KERN_NOTICE "vpm_echocan_off called on timeslot %d\n",
901 vpm_out(hc, unit, timeslot, 0x01);
906 * Speech Design resync feature
907 * NOTE: This is called sometimes outside interrupt handler.
908 * We must lock irqsave, so no other interrupt (other card) will occur!
909 * Also multiple interrupts may nest, so must lock each access (lists, card)!
912 hfcmulti_resync(struct hfc_multi *locked, struct hfc_multi *newmaster, int rm)
914 struct hfc_multi *hc, *next, *pcmmaster = NULL;
915 void __iomem *plx_acc_32;
919 spin_lock_irqsave(&HFClock, flags);
920 spin_lock(&plx_lock); /* must be locked inside other locks */
922 if (debug & DEBUG_HFCMULTI_PLXSD)
923 printk(KERN_DEBUG "%s: RESYNC(syncmaster=0x%p)\n",
924 __func__, syncmaster);
926 /* select new master */
928 if (debug & DEBUG_HFCMULTI_PLXSD)
929 printk(KERN_DEBUG "using provided controller\n");
931 list_for_each_entry_safe(hc, next, &HFClist, list) {
932 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
933 if (hc->syncronized) {
941 /* Disable sync of all cards */
942 list_for_each_entry_safe(hc, next, &HFClist, list) {
943 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
944 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
945 pv = readl(plx_acc_32);
946 pv &= ~PLX_SYNC_O_EN;
947 writel(pv, plx_acc_32);
948 if (test_bit(HFC_CHIP_PCM_MASTER, &hc->chip)) {
950 if (hc->ctype == HFC_TYPE_E1) {
951 if (debug & DEBUG_HFCMULTI_PLXSD)
953 "Schedule SYNC_I\n");
954 hc->e1_resync |= 1; /* get SYNC_I */
962 if (debug & DEBUG_HFCMULTI_PLXSD)
963 printk(KERN_DEBUG "id=%d (0x%p) = syncronized with "
964 "interface.\n", hc->id, hc);
965 /* Enable new sync master */
966 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
967 pv = readl(plx_acc_32);
969 writel(pv, plx_acc_32);
970 /* switch to jatt PLL, if not disabled by RX_SYNC */
971 if (hc->ctype == HFC_TYPE_E1
972 && !test_bit(HFC_CHIP_RX_SYNC, &hc->chip)) {
973 if (debug & DEBUG_HFCMULTI_PLXSD)
974 printk(KERN_DEBUG "Schedule jatt PLL\n");
975 hc->e1_resync |= 2; /* switch to jatt */
980 if (debug & DEBUG_HFCMULTI_PLXSD)
982 "id=%d (0x%p) = PCM master syncronized "
983 "with QUARTZ\n", hc->id, hc);
984 if (hc->ctype == HFC_TYPE_E1) {
985 /* Use the crystal clock for the PCM
987 if (debug & DEBUG_HFCMULTI_PLXSD)
989 "Schedule QUARTZ for HFC-E1\n");
990 hc->e1_resync |= 4; /* switch quartz */
992 if (debug & DEBUG_HFCMULTI_PLXSD)
994 "QUARTZ is automatically "
995 "enabled by HFC-%dS\n", hc->ctype);
997 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
998 pv = readl(plx_acc_32);
1000 writel(pv, plx_acc_32);
1003 printk(KERN_ERR "%s no pcm master, this MUST "
1004 "not happen!\n", __func__);
1006 syncmaster = newmaster;
1008 spin_unlock(&plx_lock);
1009 spin_unlock_irqrestore(&HFClock, flags);
1012 /* This must be called AND hc must be locked irqsave!!! */
1014 plxsd_checksync(struct hfc_multi *hc, int rm)
1016 if (hc->syncronized) {
1017 if (syncmaster == NULL) {
1018 if (debug & DEBUG_HFCMULTI_PLXSD)
1019 printk(KERN_DEBUG "%s: GOT sync on card %d"
1020 " (id=%d)\n", __func__, hc->id + 1,
1022 hfcmulti_resync(hc, hc, rm);
1025 if (syncmaster == hc) {
1026 if (debug & DEBUG_HFCMULTI_PLXSD)
1027 printk(KERN_DEBUG "%s: LOST sync on card %d"
1028 " (id=%d)\n", __func__, hc->id + 1,
1030 hfcmulti_resync(hc, NULL, rm);
1037 * free hardware resources used by driver
1040 release_io_hfcmulti(struct hfc_multi *hc)
1042 void __iomem *plx_acc_32;
1046 if (debug & DEBUG_HFCMULTI_INIT)
1047 printk(KERN_DEBUG "%s: entered\n", __func__);
1049 /* soft reset also masks all interrupts */
1050 hc->hw.r_cirm |= V_SRES;
1051 HFC_outb(hc, R_CIRM, hc->hw.r_cirm);
1053 hc->hw.r_cirm &= ~V_SRES;
1054 HFC_outb(hc, R_CIRM, hc->hw.r_cirm);
1055 udelay(1000); /* instead of 'wait' that may cause locking */
1057 /* release Speech Design card, if PLX was initialized */
1058 if (test_bit(HFC_CHIP_PLXSD, &hc->chip) && hc->plx_membase) {
1059 if (debug & DEBUG_HFCMULTI_PLXSD)
1060 printk(KERN_DEBUG "%s: release PLXSD card %d\n",
1061 __func__, hc->id + 1);
1062 spin_lock_irqsave(&plx_lock, plx_flags);
1063 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
1064 writel(PLX_GPIOC_INIT, plx_acc_32);
1065 pv = readl(plx_acc_32);
1066 /* Termination off */
1068 /* Disconnect the PCM */
1069 pv |= PLX_SLAVE_EN_N;
1070 pv &= ~PLX_MASTER_EN;
1071 pv &= ~PLX_SYNC_O_EN;
1072 /* Put the DSP in Reset */
1073 pv &= ~PLX_DSP_RES_N;
1074 writel(pv, plx_acc_32);
1075 if (debug & DEBUG_HFCMULTI_INIT)
1076 printk(KERN_DEBUG "%s: PCM off: PLX_GPIO=%x\n",
1078 spin_unlock_irqrestore(&plx_lock, plx_flags);
1081 /* disable memory mapped ports / io ports */
1082 test_and_clear_bit(HFC_CHIP_PLXSD, &hc->chip); /* prevent resync */
1084 pci_write_config_word(hc->pci_dev, PCI_COMMAND, 0);
1085 if (hc->pci_membase)
1086 iounmap(hc->pci_membase);
1087 if (hc->plx_membase)
1088 iounmap(hc->plx_membase);
1090 release_region(hc->pci_iobase, 8);
1091 if (hc->xhfc_membase)
1092 iounmap((void *)hc->xhfc_membase);
1095 pci_disable_device(hc->pci_dev);
1096 pci_set_drvdata(hc->pci_dev, NULL);
1098 if (debug & DEBUG_HFCMULTI_INIT)
1099 printk(KERN_DEBUG "%s: done\n", __func__);
1103 * function called to reset the HFC chip. A complete software reset of chip
1104 * and fifos is done. All configuration of the chip is done.
1108 init_chip(struct hfc_multi *hc)
1110 u_long flags, val, val2 = 0, rev;
1112 u_char r_conf_en, rval;
1113 void __iomem *plx_acc_32;
1115 u_long plx_flags, hfc_flags;
1117 struct hfc_multi *pos, *next, *plx_last_hc;
1119 spin_lock_irqsave(&hc->lock, flags);
1120 /* reset all registers */
1121 memset(&hc->hw, 0, sizeof(struct hfcm_hw));
1123 /* revision check */
1124 if (debug & DEBUG_HFCMULTI_INIT)
1125 printk(KERN_DEBUG "%s: entered\n", __func__);
1126 val = HFC_inb(hc, R_CHIP_ID);
1127 if ((val >> 4) != 0x8 && (val >> 4) != 0xc && (val >> 4) != 0xe &&
1128 (val >> 1) != 0x31) {
1129 printk(KERN_INFO "HFC_multi: unknown CHIP_ID:%x\n", (u_int)val);
1133 rev = HFC_inb(hc, R_CHIP_RV);
1135 "HFC_multi: detected HFC with chip ID=0x%lx revision=%ld%s\n",
1136 val, rev, (rev == 0 && (hc->ctype != HFC_TYPE_XHFC)) ?
1137 " (old FIFO handling)" : "");
1138 if (hc->ctype != HFC_TYPE_XHFC && rev == 0) {
1139 test_and_set_bit(HFC_CHIP_REVISION0, &hc->chip);
1141 "HFC_multi: NOTE: Your chip is revision 0, "
1142 "ask Cologne Chip for update. Newer chips "
1143 "have a better FIFO handling. Old chips "
1144 "still work but may have slightly lower "
1145 "HDLC transmit performance.\n");
1148 printk(KERN_WARNING "HFC_multi: WARNING: This driver doesn't "
1149 "consider chip revision = %ld. The chip / "
1150 "bridge may not work.\n", rev);
1153 /* set s-ram size */
1157 hc->DTMFbase = 0x1000;
1158 if (test_bit(HFC_CHIP_EXRAM_128, &hc->chip)) {
1159 if (debug & DEBUG_HFCMULTI_INIT)
1160 printk(KERN_DEBUG "%s: changing to 128K external RAM\n",
1162 hc->hw.r_ctrl |= V_EXT_RAM;
1163 hc->hw.r_ram_sz = 1;
1167 hc->DTMFbase = 0x2000;
1169 if (test_bit(HFC_CHIP_EXRAM_512, &hc->chip)) {
1170 if (debug & DEBUG_HFCMULTI_INIT)
1171 printk(KERN_DEBUG "%s: changing to 512K external RAM\n",
1173 hc->hw.r_ctrl |= V_EXT_RAM;
1174 hc->hw.r_ram_sz = 2;
1178 hc->DTMFbase = 0x2000;
1180 if (hc->ctype == HFC_TYPE_XHFC) {
1186 hc->max_trans = poll << 1;
1187 if (hc->max_trans > hc->Zlen)
1188 hc->max_trans = hc->Zlen;
1190 /* Speech Design PLX bridge */
1191 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
1192 if (debug & DEBUG_HFCMULTI_PLXSD)
1193 printk(KERN_DEBUG "%s: initializing PLXSD card %d\n",
1194 __func__, hc->id + 1);
1195 spin_lock_irqsave(&plx_lock, plx_flags);
1196 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
1197 writel(PLX_GPIOC_INIT, plx_acc_32);
1198 pv = readl(plx_acc_32);
1199 /* The first and the last cards are terminating the PCM bus */
1200 pv |= PLX_TERM_ON; /* hc is currently the last */
1201 /* Disconnect the PCM */
1202 pv |= PLX_SLAVE_EN_N;
1203 pv &= ~PLX_MASTER_EN;
1204 pv &= ~PLX_SYNC_O_EN;
1205 /* Put the DSP in Reset */
1206 pv &= ~PLX_DSP_RES_N;
1207 writel(pv, plx_acc_32);
1208 spin_unlock_irqrestore(&plx_lock, plx_flags);
1209 if (debug & DEBUG_HFCMULTI_INIT)
1210 printk(KERN_DEBUG "%s: slave/term: PLX_GPIO=%x\n",
1213 * If we are the 3rd PLXSD card or higher, we must turn
1214 * termination of last PLXSD card off.
1216 spin_lock_irqsave(&HFClock, hfc_flags);
1219 list_for_each_entry_safe(pos, next, &HFClist, list) {
1220 if (test_bit(HFC_CHIP_PLXSD, &pos->chip)) {
1226 if (plx_count >= 3) {
1227 if (debug & DEBUG_HFCMULTI_PLXSD)
1228 printk(KERN_DEBUG "%s: card %d is between, so "
1229 "we disable termination\n",
1230 __func__, plx_last_hc->id + 1);
1231 spin_lock_irqsave(&plx_lock, plx_flags);
1232 plx_acc_32 = plx_last_hc->plx_membase + PLX_GPIOC;
1233 pv = readl(plx_acc_32);
1235 writel(pv, plx_acc_32);
1236 spin_unlock_irqrestore(&plx_lock, plx_flags);
1237 if (debug & DEBUG_HFCMULTI_INIT)
1239 "%s: term off: PLX_GPIO=%x\n",
1242 spin_unlock_irqrestore(&HFClock, hfc_flags);
1243 hc->hw.r_pcm_md0 = V_F0_LEN; /* shift clock for DSP */
1246 if (test_bit(HFC_CHIP_EMBSD, &hc->chip))
1247 hc->hw.r_pcm_md0 = V_F0_LEN; /* shift clock for DSP */
1249 /* we only want the real Z2 read-pointer for revision > 0 */
1250 if (!test_bit(HFC_CHIP_REVISION0, &hc->chip))
1251 hc->hw.r_ram_sz |= V_FZ_MD;
1253 /* select pcm mode */
1254 if (test_bit(HFC_CHIP_PCM_SLAVE, &hc->chip)) {
1255 if (debug & DEBUG_HFCMULTI_INIT)
1256 printk(KERN_DEBUG "%s: setting PCM into slave mode\n",
1259 if (test_bit(HFC_CHIP_PCM_MASTER, &hc->chip) && !plxsd_master) {
1260 if (debug & DEBUG_HFCMULTI_INIT)
1261 printk(KERN_DEBUG "%s: setting PCM into master mode\n",
1263 hc->hw.r_pcm_md0 |= V_PCM_MD;
1265 if (debug & DEBUG_HFCMULTI_INIT)
1266 printk(KERN_DEBUG "%s: performing PCM auto detect\n",
1271 HFC_outb(hc, R_CTRL, hc->hw.r_ctrl);
1272 if (hc->ctype == HFC_TYPE_XHFC)
1273 HFC_outb(hc, 0x0C /* R_FIFO_THRES */,
1274 0x11 /* 16 Bytes TX/RX */);
1276 HFC_outb(hc, R_RAM_SZ, hc->hw.r_ram_sz);
1277 HFC_outb(hc, R_FIFO_MD, 0);
1278 if (hc->ctype == HFC_TYPE_XHFC)
1279 hc->hw.r_cirm = V_SRES | V_HFCRES | V_PCMRES | V_STRES;
1281 hc->hw.r_cirm = V_SRES | V_HFCRES | V_PCMRES | V_STRES
1283 HFC_outb(hc, R_CIRM, hc->hw.r_cirm);
1286 HFC_outb(hc, R_CIRM, hc->hw.r_cirm);
1288 if (hc->ctype != HFC_TYPE_XHFC)
1289 HFC_outb(hc, R_RAM_SZ, hc->hw.r_ram_sz);
1291 /* Speech Design PLX bridge pcm and sync mode */
1292 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
1293 spin_lock_irqsave(&plx_lock, plx_flags);
1294 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
1295 pv = readl(plx_acc_32);
1297 if (hc->hw.r_pcm_md0 & V_PCM_MD) {
1298 pv |= PLX_MASTER_EN | PLX_SLAVE_EN_N;
1299 pv |= PLX_SYNC_O_EN;
1300 if (debug & DEBUG_HFCMULTI_INIT)
1301 printk(KERN_DEBUG "%s: master: PLX_GPIO=%x\n",
1304 pv &= ~(PLX_MASTER_EN | PLX_SLAVE_EN_N);
1305 pv &= ~PLX_SYNC_O_EN;
1306 if (debug & DEBUG_HFCMULTI_INIT)
1307 printk(KERN_DEBUG "%s: slave: PLX_GPIO=%x\n",
1310 writel(pv, plx_acc_32);
1311 spin_unlock_irqrestore(&plx_lock, plx_flags);
1315 HFC_outb(hc, R_PCM_MD0, hc->hw.r_pcm_md0 | 0x90);
1316 if (hc->slots == 32)
1317 HFC_outb(hc, R_PCM_MD1, 0x00);
1318 if (hc->slots == 64)
1319 HFC_outb(hc, R_PCM_MD1, 0x10);
1320 if (hc->slots == 128)
1321 HFC_outb(hc, R_PCM_MD1, 0x20);
1322 HFC_outb(hc, R_PCM_MD0, hc->hw.r_pcm_md0 | 0xa0);
1323 if (test_bit(HFC_CHIP_PLXSD, &hc->chip))
1324 HFC_outb(hc, R_PCM_MD2, V_SYNC_SRC); /* sync via SYNC_I / O */
1325 else if (test_bit(HFC_CHIP_EMBSD, &hc->chip))
1326 HFC_outb(hc, R_PCM_MD2, 0x10); /* V_C2O_EN */
1328 HFC_outb(hc, R_PCM_MD2, 0x00); /* sync from interface */
1329 HFC_outb(hc, R_PCM_MD0, hc->hw.r_pcm_md0 | 0x00);
1330 for (i = 0; i < 256; i++) {
1331 HFC_outb_nodebug(hc, R_SLOT, i);
1332 HFC_outb_nodebug(hc, A_SL_CFG, 0);
1333 if (hc->ctype != HFC_TYPE_XHFC)
1334 HFC_outb_nodebug(hc, A_CONF, 0);
1335 hc->slot_owner[i] = -1;
1338 /* set clock speed */
1339 if (test_bit(HFC_CHIP_CLOCK2, &hc->chip)) {
1340 if (debug & DEBUG_HFCMULTI_INIT)
1342 "%s: setting double clock\n", __func__);
1343 HFC_outb(hc, R_BRG_PCM_CFG, V_PCM_CLK);
1346 if (test_bit(HFC_CHIP_EMBSD, &hc->chip))
1347 HFC_outb(hc, 0x02 /* R_CLK_CFG */, 0x40 /* V_CLKO_OFF */);
1350 if (test_bit(HFC_CHIP_B410P, &hc->chip)) {
1351 printk(KERN_NOTICE "Setting GPIOs\n");
1352 HFC_outb(hc, R_GPIO_SEL, 0x30);
1353 HFC_outb(hc, R_GPIO_EN1, 0x3);
1355 printk(KERN_NOTICE "calling vpm_init\n");
1359 /* check if R_F0_CNT counts (8 kHz frame count) */
1360 val = HFC_inb(hc, R_F0_CNTL);
1361 val += HFC_inb(hc, R_F0_CNTH) << 8;
1362 if (debug & DEBUG_HFCMULTI_INIT)
1364 "HFC_multi F0_CNT %ld after reset\n", val);
1365 spin_unlock_irqrestore(&hc->lock, flags);
1366 set_current_state(TASK_UNINTERRUPTIBLE);
1367 schedule_timeout((HZ / 100) ? : 1); /* Timeout minimum 10ms */
1368 spin_lock_irqsave(&hc->lock, flags);
1369 val2 = HFC_inb(hc, R_F0_CNTL);
1370 val2 += HFC_inb(hc, R_F0_CNTH) << 8;
1371 if (debug & DEBUG_HFCMULTI_INIT)
1373 "HFC_multi F0_CNT %ld after 10 ms (1st try)\n",
1375 if (val2 >= val + 8) { /* 1 ms */
1376 /* it counts, so we keep the pcm mode */
1377 if (test_bit(HFC_CHIP_PCM_MASTER, &hc->chip))
1378 printk(KERN_INFO "controller is PCM bus MASTER\n");
1380 if (test_bit(HFC_CHIP_PCM_SLAVE, &hc->chip))
1381 printk(KERN_INFO "controller is PCM bus SLAVE\n");
1383 test_and_set_bit(HFC_CHIP_PCM_SLAVE, &hc->chip);
1384 printk(KERN_INFO "controller is PCM bus SLAVE "
1385 "(auto detected)\n");
1388 /* does not count */
1389 if (test_bit(HFC_CHIP_PCM_MASTER, &hc->chip)) {
1391 printk(KERN_ERR "HFC_multi ERROR, getting no 125us "
1392 "pulse. Seems that controller fails.\n");
1396 if (test_bit(HFC_CHIP_PCM_SLAVE, &hc->chip)) {
1397 printk(KERN_INFO "controller is PCM bus SLAVE "
1398 "(ignoring missing PCM clock)\n");
1400 /* only one pcm master */
1401 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)
1403 printk(KERN_ERR "HFC_multi ERROR, no clock "
1404 "on another Speech Design card found. "
1405 "Please be sure to connect PCM cable.\n");
1409 /* retry with master clock */
1410 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
1411 spin_lock_irqsave(&plx_lock, plx_flags);
1412 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
1413 pv = readl(plx_acc_32);
1414 pv |= PLX_MASTER_EN | PLX_SLAVE_EN_N;
1415 pv |= PLX_SYNC_O_EN;
1416 writel(pv, plx_acc_32);
1417 spin_unlock_irqrestore(&plx_lock, plx_flags);
1418 if (debug & DEBUG_HFCMULTI_INIT)
1419 printk(KERN_DEBUG "%s: master: "
1420 "PLX_GPIO=%x\n", __func__, pv);
1422 hc->hw.r_pcm_md0 |= V_PCM_MD;
1423 HFC_outb(hc, R_PCM_MD0, hc->hw.r_pcm_md0 | 0x00);
1424 spin_unlock_irqrestore(&hc->lock, flags);
1425 set_current_state(TASK_UNINTERRUPTIBLE);
1426 schedule_timeout((HZ / 100) ?: 1); /* Timeout min. 10ms */
1427 spin_lock_irqsave(&hc->lock, flags);
1428 val2 = HFC_inb(hc, R_F0_CNTL);
1429 val2 += HFC_inb(hc, R_F0_CNTH) << 8;
1430 if (debug & DEBUG_HFCMULTI_INIT)
1431 printk(KERN_DEBUG "HFC_multi F0_CNT %ld after "
1432 "10 ms (2nd try)\n", val2);
1433 if (val2 >= val + 8) { /* 1 ms */
1434 test_and_set_bit(HFC_CHIP_PCM_MASTER,
1436 printk(KERN_INFO "controller is PCM bus MASTER "
1437 "(auto detected)\n");
1439 goto controller_fail;
1443 /* Release the DSP Reset */
1444 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
1445 if (test_bit(HFC_CHIP_PCM_MASTER, &hc->chip))
1447 spin_lock_irqsave(&plx_lock, plx_flags);
1448 plx_acc_32 = hc->plx_membase + PLX_GPIOC;
1449 pv = readl(plx_acc_32);
1450 pv |= PLX_DSP_RES_N;
1451 writel(pv, plx_acc_32);
1452 spin_unlock_irqrestore(&plx_lock, plx_flags);
1453 if (debug & DEBUG_HFCMULTI_INIT)
1454 printk(KERN_DEBUG "%s: reset off: PLX_GPIO=%x\n",
1460 printk(KERN_INFO "controller has given PCM BUS ID %d\n",
1463 if (test_bit(HFC_CHIP_PCM_MASTER, &hc->chip)
1464 || test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
1465 PCM_cnt++; /* SD has proprietary bridging */
1468 printk(KERN_INFO "controller has PCM BUS ID %d "
1469 "(auto selected)\n", hc->pcm);
1473 HFC_outb(hc, R_TI_WD, poll_timer);
1474 hc->hw.r_irqmsk_misc |= V_TI_IRQMSK;
1476 /* set E1 state machine IRQ */
1477 if (hc->ctype == HFC_TYPE_E1)
1478 hc->hw.r_irqmsk_misc |= V_STA_IRQMSK;
1480 /* set DTMF detection */
1481 if (test_bit(HFC_CHIP_DTMF, &hc->chip)) {
1482 if (debug & DEBUG_HFCMULTI_INIT)
1483 printk(KERN_DEBUG "%s: enabling DTMF detection "
1484 "for all B-channel\n", __func__);
1485 hc->hw.r_dtmf = V_DTMF_EN | V_DTMF_STOP;
1486 if (test_bit(HFC_CHIP_ULAW, &hc->chip))
1487 hc->hw.r_dtmf |= V_ULAW_SEL;
1488 HFC_outb(hc, R_DTMF_N, 102 - 1);
1489 hc->hw.r_irqmsk_misc |= V_DTMF_IRQMSK;
1492 /* conference engine */
1493 if (test_bit(HFC_CHIP_ULAW, &hc->chip))
1494 r_conf_en = V_CONF_EN | V_ULAW;
1496 r_conf_en = V_CONF_EN;
1497 if (hc->ctype != HFC_TYPE_XHFC)
1498 HFC_outb(hc, R_CONF_EN, r_conf_en);
1502 case 1: /* HFC-E1 OEM */
1503 if (test_bit(HFC_CHIP_WATCHDOG, &hc->chip))
1504 HFC_outb(hc, R_GPIO_SEL, 0x32);
1506 HFC_outb(hc, R_GPIO_SEL, 0x30);
1508 HFC_outb(hc, R_GPIO_EN1, 0x0f);
1509 HFC_outb(hc, R_GPIO_OUT1, 0x00);
1511 HFC_outb(hc, R_GPIO_EN0, V_GPIO_EN2 | V_GPIO_EN3);
1514 case 2: /* HFC-4S OEM */
1516 HFC_outb(hc, R_GPIO_SEL, 0xf0);
1517 HFC_outb(hc, R_GPIO_EN1, 0xff);
1518 HFC_outb(hc, R_GPIO_OUT1, 0x00);
1522 if (test_bit(HFC_CHIP_EMBSD, &hc->chip)) {
1523 hc->hw.r_st_sync = 0x10; /* V_AUTO_SYNCI */
1524 HFC_outb(hc, R_ST_SYNC, hc->hw.r_st_sync);
1527 /* set master clock */
1528 if (hc->masterclk >= 0) {
1529 if (debug & DEBUG_HFCMULTI_INIT)
1530 printk(KERN_DEBUG "%s: setting ST master clock "
1531 "to port %d (0..%d)\n",
1532 __func__, hc->masterclk, hc->ports - 1);
1533 hc->hw.r_st_sync |= (hc->masterclk | V_AUTO_SYNC);
1534 HFC_outb(hc, R_ST_SYNC, hc->hw.r_st_sync);
1539 /* setting misc irq */
1540 HFC_outb(hc, R_IRQMSK_MISC, hc->hw.r_irqmsk_misc);
1541 if (debug & DEBUG_HFCMULTI_INIT)
1542 printk(KERN_DEBUG "r_irqmsk_misc.2: 0x%x\n",
1543 hc->hw.r_irqmsk_misc);
1545 /* RAM access test */
1546 HFC_outb(hc, R_RAM_ADDR0, 0);
1547 HFC_outb(hc, R_RAM_ADDR1, 0);
1548 HFC_outb(hc, R_RAM_ADDR2, 0);
1549 for (i = 0; i < 256; i++) {
1550 HFC_outb_nodebug(hc, R_RAM_ADDR0, i);
1551 HFC_outb_nodebug(hc, R_RAM_DATA, ((i * 3) & 0xff));
1553 for (i = 0; i < 256; i++) {
1554 HFC_outb_nodebug(hc, R_RAM_ADDR0, i);
1555 HFC_inb_nodebug(hc, R_RAM_DATA);
1556 rval = HFC_inb_nodebug(hc, R_INT_DATA);
1557 if (rval != ((i * 3) & 0xff)) {
1559 "addr:%x val:%x should:%x\n", i, rval,
1565 printk(KERN_DEBUG "aborting - %d RAM access errors\n", err);
1570 if (debug & DEBUG_HFCMULTI_INIT)
1571 printk(KERN_DEBUG "%s: done\n", __func__);
1573 spin_unlock_irqrestore(&hc->lock, flags);
1579 * control the watchdog
1582 hfcmulti_watchdog(struct hfc_multi *hc)
1586 if (hc->wdcount > 10) {
1588 hc->wdbyte = hc->wdbyte == V_GPIO_OUT2 ?
1589 V_GPIO_OUT3 : V_GPIO_OUT2;
1591 /* printk("Sending Watchdog Kill %x\n",hc->wdbyte); */
1592 HFC_outb(hc, R_GPIO_EN0, V_GPIO_EN2 | V_GPIO_EN3);
1593 HFC_outb(hc, R_GPIO_OUT0, hc->wdbyte);
1603 hfcmulti_leds(struct hfc_multi *hc)
1606 unsigned long leddw;
1607 int i, state, active, leds;
1608 struct dchannel *dch;
1612 case 1: /* HFC-E1 OEM */
1613 /* 2 red steady: LOS
1614 * 1 red steady: L1 not active
1615 * 2 green steady: L1 active
1616 * 1st green flashing: activity on TX
1617 * 2nd green flashing: activity on RX
1623 dch = hc->chan[hc->dnum[0]].dch;
1625 if (hc->chan[hc->dnum[0]].los)
1627 if (hc->e1_state != 1) {
1634 if (!hc->flash[2] && hc->activity_tx)
1635 hc->flash[2] = poll;
1636 if (!hc->flash[3] && hc->activity_rx)
1637 hc->flash[3] = poll;
1638 if (hc->flash[2] && hc->flash[2] < 1024)
1640 if (hc->flash[3] && hc->flash[3] < 1024)
1642 if (hc->flash[2] >= 2048)
1644 if (hc->flash[3] >= 2048)
1647 hc->flash[2] += poll;
1649 hc->flash[3] += poll;
1652 leds = (led[0] | (led[1]<<2) | (led[2]<<1) | (led[3]<<3))^0xF;
1653 /* leds are inverted */
1654 if (leds != (int)hc->ledstate) {
1655 HFC_outb_nodebug(hc, R_GPIO_OUT1, leds);
1656 hc->ledstate = leds;
1660 case 2: /* HFC-4S OEM */
1661 /* red steady: PH_DEACTIVATE
1662 * green steady: PH_ACTIVATE
1663 * green flashing: activity on TX
1665 for (i = 0; i < 4; i++) {
1668 dch = hc->chan[(i << 2) | 2].dch;
1671 if (dch->dev.D.protocol == ISDN_P_NT_S0)
1677 if (state == active) {
1678 led[i] = 1; /* led green */
1679 hc->activity_tx |= hc->activity_rx;
1680 if (!hc->flash[i] &&
1681 (hc->activity_tx & (1 << i)))
1682 hc->flash[i] = poll;
1683 if (hc->flash[i] && hc->flash[i] < 1024)
1684 led[i] = 0; /* led off */
1685 if (hc->flash[i] >= 2048)
1688 hc->flash[i] += poll;
1690 led[i] = 2; /* led red */
1694 led[i] = 0; /* led off */
1696 if (test_bit(HFC_CHIP_B410P, &hc->chip)) {
1698 for (i = 0; i < 4; i++) {
1701 leds |= (0x2 << (i * 2));
1702 } else if (led[i] == 2) {
1704 leds |= (0x1 << (i * 2));
1707 if (leds != (int)hc->ledstate) {
1708 vpm_out(hc, 0, 0x1a8 + 3, leds);
1709 hc->ledstate = leds;
1712 leds = ((led[3] > 0) << 0) | ((led[1] > 0) << 1) |
1713 ((led[0] > 0) << 2) | ((led[2] > 0) << 3) |
1714 ((led[3] & 1) << 4) | ((led[1] & 1) << 5) |
1715 ((led[0] & 1) << 6) | ((led[2] & 1) << 7);
1716 if (leds != (int)hc->ledstate) {
1717 HFC_outb_nodebug(hc, R_GPIO_EN1, leds & 0x0F);
1718 HFC_outb_nodebug(hc, R_GPIO_OUT1, leds >> 4);
1719 hc->ledstate = leds;
1724 case 3: /* HFC 1S/2S Beronet */
1725 /* red steady: PH_DEACTIVATE
1726 * green steady: PH_ACTIVATE
1727 * green flashing: activity on TX
1729 for (i = 0; i < 2; i++) {
1732 dch = hc->chan[(i << 2) | 2].dch;
1735 if (dch->dev.D.protocol == ISDN_P_NT_S0)
1741 if (state == active) {
1742 led[i] = 1; /* led green */
1743 hc->activity_tx |= hc->activity_rx;
1744 if (!hc->flash[i] &&
1745 (hc->activity_tx & (1 << i)))
1746 hc->flash[i] = poll;
1747 if (hc->flash[i] < 1024)
1748 led[i] = 0; /* led off */
1749 if (hc->flash[i] >= 2048)
1752 hc->flash[i] += poll;
1754 led[i] = 2; /* led red */
1758 led[i] = 0; /* led off */
1760 leds = (led[0] > 0) | ((led[1] > 0) << 1) | ((led[0]&1) << 2)
1761 | ((led[1]&1) << 3);
1762 if (leds != (int)hc->ledstate) {
1763 HFC_outb_nodebug(hc, R_GPIO_EN1,
1764 ((led[0] > 0) << 2) | ((led[1] > 0) << 3));
1765 HFC_outb_nodebug(hc, R_GPIO_OUT1,
1766 ((led[0] & 1) << 2) | ((led[1] & 1) << 3));
1767 hc->ledstate = leds;
1770 case 8: /* HFC 8S+ Beronet */
1771 /* off: PH_DEACTIVATE
1772 * steady: PH_ACTIVATE
1773 * flashing: activity on TX
1775 lled = 0xff; /* leds off */
1776 for (i = 0; i < 8; i++) {
1779 dch = hc->chan[(i << 2) | 2].dch;
1782 if (dch->dev.D.protocol == ISDN_P_NT_S0)
1788 if (state == active) {
1789 lled &= ~(1 << i); /* led on */
1790 hc->activity_tx |= hc->activity_rx;
1791 if (!hc->flash[i] &&
1792 (hc->activity_tx & (1 << i)))
1793 hc->flash[i] = poll;
1794 if (hc->flash[i] < 1024)
1795 lled |= 1 << i; /* led off */
1796 if (hc->flash[i] >= 2048)
1799 hc->flash[i] += poll;
1804 leddw = lled << 24 | lled << 16 | lled << 8 | lled;
1805 if (leddw != hc->ledstate) {
1806 /* HFC_outb(hc, R_BRG_PCM_CFG, 1);
1807 HFC_outb(c, R_BRG_PCM_CFG, (0x0 << 6) | 0x3); */
1808 /* was _io before */
1809 HFC_outb_nodebug(hc, R_BRG_PCM_CFG, 1 | V_PCM_CLK);
1810 outw(0x4000, hc->pci_iobase + 4);
1811 outl(leddw, hc->pci_iobase);
1812 HFC_outb_nodebug(hc, R_BRG_PCM_CFG, V_PCM_CLK);
1813 hc->ledstate = leddw;
1817 hc->activity_tx = 0;
1818 hc->activity_rx = 0;
1821 * read dtmf coefficients
1825 hfcmulti_dtmf(struct hfc_multi *hc)
1830 struct bchannel *bch = NULL;
1835 struct sk_buff *skb;
1836 struct mISDNhead *hh;
1838 if (debug & DEBUG_HFCMULTI_DTMF)
1839 printk(KERN_DEBUG "%s: dtmf detection irq\n", __func__);
1840 for (ch = 0; ch <= 31; ch++) {
1841 /* only process enabled B-channels */
1842 bch = hc->chan[ch].bch;
1845 if (!hc->created[hc->chan[ch].port])
1847 if (!test_bit(FLG_TRANSPARENT, &bch->Flags))
1849 if (debug & DEBUG_HFCMULTI_DTMF)
1850 printk(KERN_DEBUG "%s: dtmf channel %d:",
1852 coeff = &(hc->chan[ch].coeff[hc->chan[ch].coeff_count * 16]);
1854 for (co = 0; co < 8; co++) {
1855 /* read W(n-1) coefficient */
1856 addr = hc->DTMFbase + ((co << 7) | (ch << 2));
1857 HFC_outb_nodebug(hc, R_RAM_ADDR0, addr);
1858 HFC_outb_nodebug(hc, R_RAM_ADDR1, addr >> 8);
1859 HFC_outb_nodebug(hc, R_RAM_ADDR2, (addr >> 16)
1861 w_float = HFC_inb_nodebug(hc, R_RAM_DATA);
1862 w_float |= (HFC_inb_nodebug(hc, R_RAM_DATA) << 8);
1863 if (debug & DEBUG_HFCMULTI_DTMF)
1864 printk(" %04x", w_float);
1866 /* decode float (see chip doc) */
1867 mantissa = w_float & 0x0fff;
1868 if (w_float & 0x8000)
1869 mantissa |= 0xfffff000;
1870 exponent = (w_float >> 12) & 0x7;
1873 mantissa <<= (exponent - 1);
1876 /* store coefficient */
1877 coeff[co << 1] = mantissa;
1879 /* read W(n) coefficient */
1880 w_float = HFC_inb_nodebug(hc, R_RAM_DATA);
1881 w_float |= (HFC_inb_nodebug(hc, R_RAM_DATA) << 8);
1882 if (debug & DEBUG_HFCMULTI_DTMF)
1883 printk(" %04x", w_float);
1885 /* decode float (see chip doc) */
1886 mantissa = w_float & 0x0fff;
1887 if (w_float & 0x8000)
1888 mantissa |= 0xfffff000;
1889 exponent = (w_float >> 12) & 0x7;
1892 mantissa <<= (exponent - 1);
1895 /* store coefficient */
1896 coeff[(co << 1) | 1] = mantissa;
1898 if (debug & DEBUG_HFCMULTI_DTMF)
1899 printk(" DTMF ready %08x %08x %08x %08x "
1900 "%08x %08x %08x %08x\n",
1901 coeff[0], coeff[1], coeff[2], coeff[3],
1902 coeff[4], coeff[5], coeff[6], coeff[7]);
1903 hc->chan[ch].coeff_count++;
1904 if (hc->chan[ch].coeff_count == 8) {
1905 hc->chan[ch].coeff_count = 0;
1906 skb = mI_alloc_skb(512, GFP_ATOMIC);
1908 printk(KERN_DEBUG "%s: No memory for skb\n",
1912 hh = mISDN_HEAD_P(skb);
1913 hh->prim = PH_CONTROL_IND;
1914 hh->id = DTMF_HFC_COEF;
1915 skb_put_data(skb, hc->chan[ch].coeff, 512);
1916 recv_Bchannel_skb(bch, skb);
1920 /* restart DTMF processing */
1923 HFC_outb_nodebug(hc, R_DTMF, hc->hw.r_dtmf | V_RST_DTMF);
1928 * fill fifo as much as possible
1932 hfcmulti_tx(struct hfc_multi *hc, int ch)
1934 int i, ii, temp, len = 0;
1935 int Zspace, z1, z2; /* must be int for calculation */
1938 int *txpending, slot_tx;
1939 struct bchannel *bch;
1940 struct dchannel *dch;
1941 struct sk_buff **sp = NULL;
1944 bch = hc->chan[ch].bch;
1945 dch = hc->chan[ch].dch;
1946 if ((!dch) && (!bch))
1949 txpending = &hc->chan[ch].txpending;
1950 slot_tx = hc->chan[ch].slot_tx;
1952 if (!test_bit(FLG_ACTIVE, &dch->Flags))
1955 idxp = &dch->tx_idx;
1957 if (!test_bit(FLG_ACTIVE, &bch->Flags))
1960 idxp = &bch->tx_idx;
1965 if ((!len) && *txpending != 1)
1966 return; /* no data */
1968 if (test_bit(HFC_CHIP_B410P, &hc->chip) &&
1969 (hc->chan[ch].protocol == ISDN_P_B_RAW) &&
1970 (hc->chan[ch].slot_rx < 0) &&
1971 (hc->chan[ch].slot_tx < 0))
1972 HFC_outb_nodebug(hc, R_FIFO, 0x20 | (ch << 1));
1974 HFC_outb_nodebug(hc, R_FIFO, ch << 1);
1975 HFC_wait_nodebug(hc);
1977 if (*txpending == 2) {
1979 HFC_outb_nodebug(hc, R_INC_RES_FIFO, V_RES_F);
1980 HFC_wait_nodebug(hc);
1981 HFC_outb(hc, A_SUBCH_CFG, 0);
1985 if (dch || test_bit(FLG_HDLC, &bch->Flags)) {
1986 f1 = HFC_inb_nodebug(hc, A_F1);
1987 f2 = HFC_inb_nodebug(hc, A_F2);
1988 while (f2 != (temp = HFC_inb_nodebug(hc, A_F2))) {
1989 if (debug & DEBUG_HFCMULTI_FIFO)
1991 "%s(card %d): reread f2 because %d!=%d\n",
1992 __func__, hc->id + 1, temp, f2);
1993 f2 = temp; /* repeat until F2 is equal */
1995 Fspace = f2 - f1 - 1;
1999 * Old FIFO handling doesn't give us the current Z2 read
2000 * pointer, so we cannot send the next frame before the fifo
2001 * is empty. It makes no difference except for a slightly
2002 * lower performance.
2004 if (test_bit(HFC_CHIP_REVISION0, &hc->chip)) {
2010 /* one frame only for ST D-channels, to allow resending */
2011 if (hc->ctype != HFC_TYPE_E1 && dch) {
2015 /* F-counter full condition */
2019 z1 = HFC_inw_nodebug(hc, A_Z1) - hc->Zmin;
2020 z2 = HFC_inw_nodebug(hc, A_Z2) - hc->Zmin;
2021 while (z2 != (temp = (HFC_inw_nodebug(hc, A_Z2) - hc->Zmin))) {
2022 if (debug & DEBUG_HFCMULTI_FIFO)
2023 printk(KERN_DEBUG "%s(card %d): reread z2 because "
2024 "%d!=%d\n", __func__, hc->id + 1, temp, z2);
2025 z2 = temp; /* repeat unti Z2 is equal */
2027 hc->chan[ch].Zfill = z1 - z2;
2028 if (hc->chan[ch].Zfill < 0)
2029 hc->chan[ch].Zfill += hc->Zlen;
2033 Zspace -= 4; /* keep not too full, so pointers will not overrun */
2034 /* fill transparent data only to maxinum transparent load (minus 4) */
2035 if (bch && test_bit(FLG_TRANSPARENT, &bch->Flags))
2036 Zspace = Zspace - hc->Zlen + hc->max_trans;
2037 if (Zspace <= 0) /* no space of 4 bytes */
2042 if (z1 == z2) { /* empty */
2043 /* if done with FIFO audio data during PCM connection */
2044 if (bch && (!test_bit(FLG_HDLC, &bch->Flags)) &&
2045 *txpending && slot_tx >= 0) {
2046 if (debug & DEBUG_HFCMULTI_MODE)
2048 "%s: reconnecting PCM due to no "
2049 "more FIFO data: channel %d "
2051 __func__, ch, slot_tx);
2053 if (hc->ctype == HFC_TYPE_XHFC)
2054 HFC_outb(hc, A_CON_HDLC, 0xc0
2055 | 0x07 << 2 | V_HDLC_TRP | V_IFF);
2056 /* Enable FIFO, no interrupt */
2058 HFC_outb(hc, A_CON_HDLC, 0xc0 | 0x00 |
2059 V_HDLC_TRP | V_IFF);
2060 HFC_outb_nodebug(hc, R_FIFO, ch << 1 | 1);
2061 HFC_wait_nodebug(hc);
2062 if (hc->ctype == HFC_TYPE_XHFC)
2063 HFC_outb(hc, A_CON_HDLC, 0xc0
2064 | 0x07 << 2 | V_HDLC_TRP | V_IFF);
2065 /* Enable FIFO, no interrupt */
2067 HFC_outb(hc, A_CON_HDLC, 0xc0 | 0x00 |
2068 V_HDLC_TRP | V_IFF);
2069 HFC_outb_nodebug(hc, R_FIFO, ch << 1);
2070 HFC_wait_nodebug(hc);
2074 return; /* no data */
2077 /* "fill fifo if empty" feature */
2078 if (bch && test_bit(FLG_FILLEMPTY, &bch->Flags)
2079 && !test_bit(FLG_HDLC, &bch->Flags) && z2 == z1) {
2080 if (debug & DEBUG_HFCMULTI_FILL)
2081 printk(KERN_DEBUG "%s: buffer empty, so we have "
2082 "underrun\n", __func__);
2083 /* fill buffer, to prevent future underrun */
2084 hc->write_fifo(hc, hc->silence_data, poll >> 1);
2085 Zspace -= (poll >> 1);
2088 /* if audio data and connected slot */
2089 if (bch && (!test_bit(FLG_HDLC, &bch->Flags)) && (!*txpending)
2091 if (debug & DEBUG_HFCMULTI_MODE)
2092 printk(KERN_DEBUG "%s: disconnecting PCM due to "
2093 "FIFO data: channel %d slot_tx %d\n",
2094 __func__, ch, slot_tx);
2095 /* disconnect slot */
2096 if (hc->ctype == HFC_TYPE_XHFC)
2097 HFC_outb(hc, A_CON_HDLC, 0x80
2098 | 0x07 << 2 | V_HDLC_TRP | V_IFF);
2099 /* Enable FIFO, no interrupt */
2101 HFC_outb(hc, A_CON_HDLC, 0x80 | 0x00 |
2102 V_HDLC_TRP | V_IFF);
2103 HFC_outb_nodebug(hc, R_FIFO, ch << 1 | 1);
2104 HFC_wait_nodebug(hc);
2105 if (hc->ctype == HFC_TYPE_XHFC)
2106 HFC_outb(hc, A_CON_HDLC, 0x80
2107 | 0x07 << 2 | V_HDLC_TRP | V_IFF);
2108 /* Enable FIFO, no interrupt */
2110 HFC_outb(hc, A_CON_HDLC, 0x80 | 0x00 |
2111 V_HDLC_TRP | V_IFF);
2112 HFC_outb_nodebug(hc, R_FIFO, ch << 1);
2113 HFC_wait_nodebug(hc);
2119 hc->activity_tx |= 1 << hc->chan[ch].port;
2121 /* fill fifo to what we have left */
2123 if (dch || test_bit(FLG_HDLC, &bch->Flags))
2128 d = (*sp)->data + i;
2129 if (ii - i > Zspace)
2131 if (debug & DEBUG_HFCMULTI_FIFO)
2132 printk(KERN_DEBUG "%s(card %d): fifo(%d) has %d bytes space "
2133 "left (z1=%04x, z2=%04x) sending %d of %d bytes %s\n",
2134 __func__, hc->id + 1, ch, Zspace, z1, z2, ii-i, len-i,
2135 temp ? "HDLC" : "TRANS");
2137 /* Have to prep the audio data */
2138 hc->write_fifo(hc, d, ii - i);
2139 hc->chan[ch].Zfill += ii - i;
2142 /* if not all data has been written */
2144 /* NOTE: fifo is started by the calling function */
2148 /* if all data has been written, terminate frame */
2149 if (dch || test_bit(FLG_HDLC, &bch->Flags)) {
2150 /* increment f-counter */
2151 HFC_outb_nodebug(hc, R_INC_RES_FIFO, V_INC_F);
2152 HFC_wait_nodebug(hc);
2156 /* check for next frame */
2157 if (bch && get_next_bframe(bch)) {
2161 if (dch && get_next_dframe(dch)) {
2167 * now we have no more data, so in case of transparent,
2168 * we set the last byte in fifo to 'silence' in case we will get
2169 * no more data at all. this prevents sending an undefined value.
2171 if (bch && test_bit(FLG_TRANSPARENT, &bch->Flags))
2172 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, hc->silence);
2176 /* NOTE: only called if E1 card is in active state */
2178 hfcmulti_rx(struct hfc_multi *hc, int ch)
2181 int Zsize, z1, z2 = 0; /* = 0, to make GCC happy */
2182 int f1 = 0, f2 = 0; /* = 0, to make GCC happy */
2184 struct bchannel *bch;
2185 struct dchannel *dch = NULL;
2186 struct sk_buff *skb, **sp = NULL;
2189 bch = hc->chan[ch].bch;
2191 if (!test_bit(FLG_ACTIVE, &bch->Flags))
2193 } else if (hc->chan[ch].dch) {
2194 dch = hc->chan[ch].dch;
2195 if (!test_bit(FLG_ACTIVE, &dch->Flags))
2201 /* on first AND before getting next valid frame, R_FIFO must be written
2203 if (test_bit(HFC_CHIP_B410P, &hc->chip) &&
2204 (hc->chan[ch].protocol == ISDN_P_B_RAW) &&
2205 (hc->chan[ch].slot_rx < 0) &&
2206 (hc->chan[ch].slot_tx < 0))
2207 HFC_outb_nodebug(hc, R_FIFO, 0x20 | (ch << 1) | 1);
2209 HFC_outb_nodebug(hc, R_FIFO, (ch << 1) | 1);
2210 HFC_wait_nodebug(hc);
2212 /* ignore if rx is off BUT change fifo (above) to start pending TX */
2213 if (hc->chan[ch].rx_off) {
2215 bch->dropcnt += poll; /* not exact but fair enough */
2219 if (dch || test_bit(FLG_HDLC, &bch->Flags)) {
2220 f1 = HFC_inb_nodebug(hc, A_F1);
2221 while (f1 != (temp = HFC_inb_nodebug(hc, A_F1))) {
2222 if (debug & DEBUG_HFCMULTI_FIFO)
2224 "%s(card %d): reread f1 because %d!=%d\n",
2225 __func__, hc->id + 1, temp, f1);
2226 f1 = temp; /* repeat until F1 is equal */
2228 f2 = HFC_inb_nodebug(hc, A_F2);
2230 z1 = HFC_inw_nodebug(hc, A_Z1) - hc->Zmin;
2231 while (z1 != (temp = (HFC_inw_nodebug(hc, A_Z1) - hc->Zmin))) {
2232 if (debug & DEBUG_HFCMULTI_FIFO)
2233 printk(KERN_DEBUG "%s(card %d): reread z2 because "
2234 "%d!=%d\n", __func__, hc->id + 1, temp, z2);
2235 z1 = temp; /* repeat until Z1 is equal */
2237 z2 = HFC_inw_nodebug(hc, A_Z2) - hc->Zmin;
2239 if ((dch || test_bit(FLG_HDLC, &bch->Flags)) && f1 != f2)
2240 /* complete hdlc frame */
2244 /* if buffer is empty */
2249 maxlen = bchannel_get_rxbuf(bch, Zsize);
2251 pr_warn("card%d.B%d: No bufferspace for %d bytes\n",
2252 hc->id + 1, bch->nr, Zsize);
2256 maxlen = bch->maxlen;
2257 } else { /* Dchannel */
2259 maxlen = dch->maxlen + 3;
2261 *sp = mI_alloc_skb(maxlen, GFP_ATOMIC);
2263 pr_warn("card%d: No mem for dch rx_skb\n",
2271 hc->activity_rx |= 1 << hc->chan[ch].port;
2273 /* empty fifo with what we have */
2274 if (dch || test_bit(FLG_HDLC, &bch->Flags)) {
2275 if (debug & DEBUG_HFCMULTI_FIFO)
2276 printk(KERN_DEBUG "%s(card %d): fifo(%d) reading %d "
2277 "bytes (z1=%04x, z2=%04x) HDLC %s (f1=%d, f2=%d) "
2278 "got=%d (again %d)\n", __func__, hc->id + 1, ch,
2279 Zsize, z1, z2, (f1 == f2) ? "fragment" : "COMPLETE",
2280 f1, f2, Zsize + (*sp)->len, again);
2282 if ((Zsize + (*sp)->len) > maxlen) {
2283 if (debug & DEBUG_HFCMULTI_FIFO)
2285 "%s(card %d): hdlc-frame too large.\n",
2286 __func__, hc->id + 1);
2288 HFC_outb_nodebug(hc, R_INC_RES_FIFO, V_RES_F);
2289 HFC_wait_nodebug(hc);
2293 hc->read_fifo(hc, skb_put(*sp, Zsize), Zsize);
2296 /* increment Z2,F2-counter */
2297 HFC_outb_nodebug(hc, R_INC_RES_FIFO, V_INC_F);
2298 HFC_wait_nodebug(hc);
2300 if ((*sp)->len < 4) {
2301 if (debug & DEBUG_HFCMULTI_FIFO)
2303 "%s(card %d): Frame below minimum "
2304 "size\n", __func__, hc->id + 1);
2308 /* there is at least one complete frame, check crc */
2309 if ((*sp)->data[(*sp)->len - 1]) {
2310 if (debug & DEBUG_HFCMULTI_CRC)
2312 "%s: CRC-error\n", __func__);
2316 skb_trim(*sp, (*sp)->len - 3);
2317 if ((*sp)->len < MISDN_COPY_SIZE) {
2319 *sp = mI_alloc_skb(skb->len, GFP_ATOMIC);
2321 skb_put_data(*sp, skb->data, skb->len);
2324 printk(KERN_DEBUG "%s: No mem\n",
2332 if (debug & DEBUG_HFCMULTI_FIFO) {
2333 printk(KERN_DEBUG "%s(card %d):",
2334 __func__, hc->id + 1);
2336 while (temp < (*sp)->len)
2337 printk(" %02x", (*sp)->data[temp++]);
2343 recv_Bchannel(bch, MISDN_ID_ANY, false);
2348 /* there is an incomplete frame */
2351 hc->read_fifo(hc, skb_put(*sp, Zsize), Zsize);
2352 if (debug & DEBUG_HFCMULTI_FIFO)
2354 "%s(card %d): fifo(%d) reading %d bytes "
2355 "(z1=%04x, z2=%04x) TRANS\n",
2356 __func__, hc->id + 1, ch, Zsize, z1, z2);
2357 /* only bch is transparent */
2358 recv_Bchannel(bch, hc->chan[ch].Zfill, false);
2367 signal_state_up(struct dchannel *dch, int info, char *msg)
2369 struct sk_buff *skb;
2370 int id, data = info;
2372 if (debug & DEBUG_HFCMULTI_STATE)
2373 printk(KERN_DEBUG "%s: %s\n", __func__, msg);
2375 id = TEI_SAPI | (GROUP_TEI << 8); /* manager address */
2377 skb = _alloc_mISDN_skb(MPH_INFORMATION_IND, id, sizeof(data), &data,
2381 recv_Dchannel_skb(dch, skb);
2385 handle_timer_irq(struct hfc_multi *hc)
2388 struct dchannel *dch;
2391 /* process queued resync jobs */
2392 if (hc->e1_resync) {
2393 /* lock, so e1_resync gets not changed */
2394 spin_lock_irqsave(&HFClock, flags);
2395 if (hc->e1_resync & 1) {
2396 if (debug & DEBUG_HFCMULTI_PLXSD)
2397 printk(KERN_DEBUG "Enable SYNC_I\n");
2398 HFC_outb(hc, R_SYNC_CTRL, V_EXT_CLK_SYNC);
2399 /* disable JATT, if RX_SYNC is set */
2400 if (test_bit(HFC_CHIP_RX_SYNC, &hc->chip))
2401 HFC_outb(hc, R_SYNC_OUT, V_SYNC_E1_RX);
2403 if (hc->e1_resync & 2) {
2404 if (debug & DEBUG_HFCMULTI_PLXSD)
2405 printk(KERN_DEBUG "Enable jatt PLL\n");
2406 HFC_outb(hc, R_SYNC_CTRL, V_SYNC_OFFS);
2408 if (hc->e1_resync & 4) {
2409 if (debug & DEBUG_HFCMULTI_PLXSD)
2411 "Enable QUARTZ for HFC-E1\n");
2412 /* set jatt to quartz */
2413 HFC_outb(hc, R_SYNC_CTRL, V_EXT_CLK_SYNC
2415 /* switch to JATT, in case it is not already */
2416 HFC_outb(hc, R_SYNC_OUT, 0);
2419 spin_unlock_irqrestore(&HFClock, flags);
2422 if (hc->ctype != HFC_TYPE_E1 || hc->e1_state == 1)
2423 for (ch = 0; ch <= 31; ch++) {
2424 if (hc->created[hc->chan[ch].port]) {
2425 hfcmulti_tx(hc, ch);
2426 /* fifo is started when switching to rx-fifo */
2427 hfcmulti_rx(hc, ch);
2428 if (hc->chan[ch].dch &&
2429 hc->chan[ch].nt_timer > -1) {
2430 dch = hc->chan[ch].dch;
2431 if (!(--hc->chan[ch].nt_timer)) {
2435 DEBUG_HFCMULTI_STATE)
2445 if (hc->ctype == HFC_TYPE_E1 && hc->created[0]) {
2446 dch = hc->chan[hc->dnum[0]].dch;
2448 temp = HFC_inb_nodebug(hc, R_SYNC_STA) & V_SIG_LOS;
2449 hc->chan[hc->dnum[0]].los = temp;
2450 if (test_bit(HFC_CFG_REPORT_LOS, &hc->chan[hc->dnum[0]].cfg)) {
2451 if (!temp && hc->chan[hc->dnum[0]].los)
2452 signal_state_up(dch, L1_SIGNAL_LOS_ON,
2454 if (temp && !hc->chan[hc->dnum[0]].los)
2455 signal_state_up(dch, L1_SIGNAL_LOS_OFF,
2458 if (test_bit(HFC_CFG_REPORT_AIS, &hc->chan[hc->dnum[0]].cfg)) {
2460 temp = HFC_inb_nodebug(hc, R_SYNC_STA) & V_AIS;
2461 if (!temp && hc->chan[hc->dnum[0]].ais)
2462 signal_state_up(dch, L1_SIGNAL_AIS_ON,
2464 if (temp && !hc->chan[hc->dnum[0]].ais)
2465 signal_state_up(dch, L1_SIGNAL_AIS_OFF,
2467 hc->chan[hc->dnum[0]].ais = temp;
2469 if (test_bit(HFC_CFG_REPORT_SLIP, &hc->chan[hc->dnum[0]].cfg)) {
2471 temp = HFC_inb_nodebug(hc, R_SLIP) & V_FOSLIP_RX;
2472 if (!temp && hc->chan[hc->dnum[0]].slip_rx)
2473 signal_state_up(dch, L1_SIGNAL_SLIP_RX,
2474 " bit SLIP detected RX");
2475 hc->chan[hc->dnum[0]].slip_rx = temp;
2476 temp = HFC_inb_nodebug(hc, R_SLIP) & V_FOSLIP_TX;
2477 if (!temp && hc->chan[hc->dnum[0]].slip_tx)
2478 signal_state_up(dch, L1_SIGNAL_SLIP_TX,
2479 " bit SLIP detected TX");
2480 hc->chan[hc->dnum[0]].slip_tx = temp;
2482 if (test_bit(HFC_CFG_REPORT_RDI, &hc->chan[hc->dnum[0]].cfg)) {
2484 temp = HFC_inb_nodebug(hc, R_RX_SL0_0) & V_A;
2485 if (!temp && hc->chan[hc->dnum[0]].rdi)
2486 signal_state_up(dch, L1_SIGNAL_RDI_ON,
2488 if (temp && !hc->chan[hc->dnum[0]].rdi)
2489 signal_state_up(dch, L1_SIGNAL_RDI_OFF,
2491 hc->chan[hc->dnum[0]].rdi = temp;
2493 temp = HFC_inb_nodebug(hc, R_JATT_DIR);
2494 switch (hc->chan[hc->dnum[0]].sync) {
2496 if ((temp & 0x60) == 0x60) {
2497 if (debug & DEBUG_HFCMULTI_SYNC)
2499 "%s: (id=%d) E1 now "
2502 HFC_outb(hc, R_RX_OFF,
2503 hc->chan[hc->dnum[0]].jitter | V_RX_INIT);
2504 HFC_outb(hc, R_TX_OFF,
2505 hc->chan[hc->dnum[0]].jitter | V_RX_INIT);
2506 hc->chan[hc->dnum[0]].sync = 1;
2507 goto check_framesync;
2511 if ((temp & 0x60) != 0x60) {
2512 if (debug & DEBUG_HFCMULTI_SYNC)
2515 "lost clock sync\n",
2517 hc->chan[hc->dnum[0]].sync = 0;
2521 temp = HFC_inb_nodebug(hc, R_SYNC_STA);
2523 if (debug & DEBUG_HFCMULTI_SYNC)
2526 "now in frame sync\n",
2528 hc->chan[hc->dnum[0]].sync = 2;
2532 if ((temp & 0x60) != 0x60) {
2533 if (debug & DEBUG_HFCMULTI_SYNC)
2535 "%s: (id=%d) E1 lost "
2536 "clock & frame sync\n",
2538 hc->chan[hc->dnum[0]].sync = 0;
2541 temp = HFC_inb_nodebug(hc, R_SYNC_STA);
2543 if (debug & DEBUG_HFCMULTI_SYNC)
2546 "lost frame sync\n",
2548 hc->chan[hc->dnum[0]].sync = 1;
2554 if (test_bit(HFC_CHIP_WATCHDOG, &hc->chip))
2555 hfcmulti_watchdog(hc);
2562 ph_state_irq(struct hfc_multi *hc, u_char r_irq_statech)
2564 struct dchannel *dch;
2567 u_char st_status, temp;
2570 for (ch = 0; ch <= 31; ch++) {
2571 if (hc->chan[ch].dch) {
2572 dch = hc->chan[ch].dch;
2573 if (r_irq_statech & 1) {
2574 HFC_outb_nodebug(hc, R_ST_SEL,
2576 /* undocumented: delay after R_ST_SEL */
2578 /* undocumented: status changes during read */
2579 st_status = HFC_inb_nodebug(hc, A_ST_RD_STATE);
2580 while (st_status != (temp =
2581 HFC_inb_nodebug(hc, A_ST_RD_STATE))) {
2582 if (debug & DEBUG_HFCMULTI_STATE)
2583 printk(KERN_DEBUG "%s: reread "
2584 "STATE because %d!=%d\n",
2587 st_status = temp; /* repeat */
2590 /* Speech Design TE-sync indication */
2591 if (test_bit(HFC_CHIP_PLXSD, &hc->chip) &&
2592 dch->dev.D.protocol == ISDN_P_TE_S0) {
2593 if (st_status & V_FR_SYNC_ST)
2595 (1 << hc->chan[ch].port);
2598 ~(1 << hc->chan[ch].port);
2600 dch->state = st_status & 0x0f;
2601 if (dch->dev.D.protocol == ISDN_P_NT_S0)
2605 if (dch->state == active) {
2606 HFC_outb_nodebug(hc, R_FIFO,
2608 HFC_wait_nodebug(hc);
2609 HFC_outb_nodebug(hc,
2610 R_INC_RES_FIFO, V_RES_F);
2611 HFC_wait_nodebug(hc);
2614 schedule_event(dch, FLG_PHCHANGE);
2615 if (debug & DEBUG_HFCMULTI_STATE)
2617 "%s: S/T newstate %x port %d\n",
2618 __func__, dch->state,
2621 r_irq_statech >>= 1;
2624 if (test_bit(HFC_CHIP_PLXSD, &hc->chip))
2625 plxsd_checksync(hc, 0);
2629 fifo_irq(struct hfc_multi *hc, int block)
2632 struct dchannel *dch;
2633 struct bchannel *bch;
2634 u_char r_irq_fifo_bl;
2636 r_irq_fifo_bl = HFC_inb_nodebug(hc, R_IRQ_FIFO_BL0 + block);
2639 ch = (block << 2) + (j >> 1);
2640 dch = hc->chan[ch].dch;
2641 bch = hc->chan[ch].bch;
2642 if (((!dch) && (!bch)) || (!hc->created[hc->chan[ch].port])) {
2646 if (dch && (r_irq_fifo_bl & (1 << j)) &&
2647 test_bit(FLG_ACTIVE, &dch->Flags)) {
2648 hfcmulti_tx(hc, ch);
2650 HFC_outb_nodebug(hc, R_FIFO, 0);
2651 HFC_wait_nodebug(hc);
2653 if (bch && (r_irq_fifo_bl & (1 << j)) &&
2654 test_bit(FLG_ACTIVE, &bch->Flags)) {
2655 hfcmulti_tx(hc, ch);
2657 HFC_outb_nodebug(hc, R_FIFO, 0);
2658 HFC_wait_nodebug(hc);
2661 if (dch && (r_irq_fifo_bl & (1 << j)) &&
2662 test_bit(FLG_ACTIVE, &dch->Flags)) {
2663 hfcmulti_rx(hc, ch);
2665 if (bch && (r_irq_fifo_bl & (1 << j)) &&
2666 test_bit(FLG_ACTIVE, &bch->Flags)) {
2667 hfcmulti_rx(hc, ch);
2677 hfcmulti_interrupt(int intno, void *dev_id)
2679 #ifdef IRQCOUNT_DEBUG
2680 static int iq1 = 0, iq2 = 0, iq3 = 0, iq4 = 0,
2681 iq5 = 0, iq6 = 0, iqcnt = 0;
2683 struct hfc_multi *hc = dev_id;
2684 struct dchannel *dch;
2685 u_char r_irq_statech, status, r_irq_misc, r_irq_oview;
2687 void __iomem *plx_acc;
2689 u_char e1_syncsta, temp, temp2;
2693 printk(KERN_ERR "HFC-multi: Spurious interrupt!\n");
2697 spin_lock(&hc->lock);
2701 printk(KERN_ERR "irq for card %d during irq from "
2702 "card %d, this is no bug.\n", hc->id + 1, irqsem);
2703 irqsem = hc->id + 1;
2705 #ifdef CONFIG_MISDN_HFCMULTI_8xx
2706 if (hc->immap->im_cpm.cp_pbdat & hc->pb_irqmsk)
2709 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
2710 spin_lock_irqsave(&plx_lock, flags);
2711 plx_acc = hc->plx_membase + PLX_INTCSR;
2712 wval = readw(plx_acc);
2713 spin_unlock_irqrestore(&plx_lock, flags);
2714 if (!(wval & PLX_INTCSR_LINTI1_STATUS))
2718 status = HFC_inb_nodebug(hc, R_STATUS);
2719 r_irq_statech = HFC_inb_nodebug(hc, R_IRQ_STATECH);
2720 #ifdef IRQCOUNT_DEBUG
2723 if (status & V_DTMF_STA)
2725 if (status & V_LOST_STA)
2727 if (status & V_EXT_IRQSTA)
2729 if (status & V_MISC_IRQSTA)
2731 if (status & V_FR_IRQSTA)
2733 if (iqcnt++ > 5000) {
2734 printk(KERN_ERR "iq1:%x iq2:%x iq3:%x iq4:%x iq5:%x iq6:%x\n",
2735 iq1, iq2, iq3, iq4, iq5, iq6);
2740 if (!r_irq_statech &&
2741 !(status & (V_DTMF_STA | V_LOST_STA | V_EXT_IRQSTA |
2742 V_MISC_IRQSTA | V_FR_IRQSTA))) {
2743 /* irq is not for us */
2747 if (r_irq_statech) {
2748 if (hc->ctype != HFC_TYPE_E1)
2749 ph_state_irq(hc, r_irq_statech);
2751 if (status & V_LOST_STA) {
2753 HFC_outb(hc, R_INC_RES_FIFO, V_RES_LOST); /* clear irq! */
2755 if (status & V_MISC_IRQSTA) {
2757 r_irq_misc = HFC_inb_nodebug(hc, R_IRQ_MISC);
2758 r_irq_misc &= hc->hw.r_irqmsk_misc; /* ignore disabled irqs */
2759 if (r_irq_misc & V_STA_IRQ) {
2760 if (hc->ctype == HFC_TYPE_E1) {
2762 dch = hc->chan[hc->dnum[0]].dch;
2763 e1_syncsta = HFC_inb_nodebug(hc, R_SYNC_STA);
2764 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)
2765 && hc->e1_getclock) {
2766 if (e1_syncsta & V_FR_SYNC_E1)
2767 hc->syncronized = 1;
2769 hc->syncronized = 0;
2771 /* undocumented: status changes during read */
2772 temp = HFC_inb_nodebug(hc, R_E1_RD_STA);
2773 while (temp != (temp2 =
2774 HFC_inb_nodebug(hc, R_E1_RD_STA))) {
2775 if (debug & DEBUG_HFCMULTI_STATE)
2776 printk(KERN_DEBUG "%s: reread "
2777 "STATE because %d!=%d\n",
2778 __func__, temp, temp2);
2779 temp = temp2; /* repeat */
2781 /* broadcast state change to all fragments */
2782 if (debug & DEBUG_HFCMULTI_STATE)
2784 "%s: E1 (id=%d) newstate %x\n",
2785 __func__, hc->id, temp & 0x7);
2786 for (i = 0; i < hc->ports; i++) {
2787 dch = hc->chan[hc->dnum[i]].dch;
2788 dch->state = temp & 0x7;
2789 schedule_event(dch, FLG_PHCHANGE);
2792 if (test_bit(HFC_CHIP_PLXSD, &hc->chip))
2793 plxsd_checksync(hc, 0);
2796 if (r_irq_misc & V_TI_IRQ) {
2798 mISDN_clock_update(hc->iclock, poll, NULL);
2799 handle_timer_irq(hc);
2802 if (r_irq_misc & V_DTMF_IRQ)
2805 if (r_irq_misc & V_IRQ_PROC) {
2806 static int irq_proc_cnt;
2807 if (!irq_proc_cnt++)
2808 printk(KERN_DEBUG "%s: got V_IRQ_PROC -"
2809 " this should not happen\n", __func__);
2813 if (status & V_FR_IRQSTA) {
2815 r_irq_oview = HFC_inb_nodebug(hc, R_IRQ_OVIEW);
2816 for (i = 0; i < 8; i++) {
2817 if (r_irq_oview & (1 << i))
2825 spin_unlock(&hc->lock);
2832 spin_unlock(&hc->lock);
2838 * timer callback for D-chan busy resolution. Currently no function
2842 hfcmulti_dbusy_timer(struct timer_list *t)
2848 * activate/deactivate hardware for selected channels and mode
2850 * configure B-channel with the given protocol
2851 * ch eqals to the HFC-channel (0-31)
2852 * ch is the number of channel (0-4,4-7,8-11,12-15,16-19,20-23,24-27,28-31
2853 * for S/T, 1-31 for E1)
2854 * the hdlc interrupts will be set/unset
2857 mode_hfcmulti(struct hfc_multi *hc, int ch, int protocol, int slot_tx,
2858 int bank_tx, int slot_rx, int bank_rx)
2860 int flow_tx = 0, flow_rx = 0, routing = 0;
2861 int oslot_tx, oslot_rx;
2864 if (ch < 0 || ch > 31)
2866 oslot_tx = hc->chan[ch].slot_tx;
2867 oslot_rx = hc->chan[ch].slot_rx;
2868 conf = hc->chan[ch].conf;
2870 if (debug & DEBUG_HFCMULTI_MODE)
2872 "%s: card %d channel %d protocol %x slot old=%d new=%d "
2873 "bank new=%d (TX) slot old=%d new=%d bank new=%d (RX)\n",
2874 __func__, hc->id, ch, protocol, oslot_tx, slot_tx,
2875 bank_tx, oslot_rx, slot_rx, bank_rx);
2877 if (oslot_tx >= 0 && slot_tx != oslot_tx) {
2878 /* remove from slot */
2879 if (debug & DEBUG_HFCMULTI_MODE)
2880 printk(KERN_DEBUG "%s: remove from slot %d (TX)\n",
2881 __func__, oslot_tx);
2882 if (hc->slot_owner[oslot_tx << 1] == ch) {
2883 HFC_outb(hc, R_SLOT, oslot_tx << 1);
2884 HFC_outb(hc, A_SL_CFG, 0);
2885 if (hc->ctype != HFC_TYPE_XHFC)
2886 HFC_outb(hc, A_CONF, 0);
2887 hc->slot_owner[oslot_tx << 1] = -1;
2889 if (debug & DEBUG_HFCMULTI_MODE)
2891 "%s: we are not owner of this tx slot "
2892 "anymore, channel %d is.\n",
2893 __func__, hc->slot_owner[oslot_tx << 1]);
2897 if (oslot_rx >= 0 && slot_rx != oslot_rx) {
2898 /* remove from slot */
2899 if (debug & DEBUG_HFCMULTI_MODE)
2901 "%s: remove from slot %d (RX)\n",
2902 __func__, oslot_rx);
2903 if (hc->slot_owner[(oslot_rx << 1) | 1] == ch) {
2904 HFC_outb(hc, R_SLOT, (oslot_rx << 1) | V_SL_DIR);
2905 HFC_outb(hc, A_SL_CFG, 0);
2906 hc->slot_owner[(oslot_rx << 1) | 1] = -1;
2908 if (debug & DEBUG_HFCMULTI_MODE)
2910 "%s: we are not owner of this rx slot "
2911 "anymore, channel %d is.\n",
2913 hc->slot_owner[(oslot_rx << 1) | 1]);
2918 flow_tx = 0x80; /* FIFO->ST */
2919 /* disable pcm slot */
2920 hc->chan[ch].slot_tx = -1;
2921 hc->chan[ch].bank_tx = 0;
2924 if (hc->chan[ch].txpending)
2925 flow_tx = 0x80; /* FIFO->ST */
2927 flow_tx = 0xc0; /* PCM->ST */
2929 routing = bank_tx ? 0xc0 : 0x80;
2930 if (conf >= 0 || bank_tx > 1)
2931 routing = 0x40; /* loop */
2932 if (debug & DEBUG_HFCMULTI_MODE)
2933 printk(KERN_DEBUG "%s: put channel %d to slot %d bank"
2934 " %d flow %02x routing %02x conf %d (TX)\n",
2935 __func__, ch, slot_tx, bank_tx,
2936 flow_tx, routing, conf);
2937 HFC_outb(hc, R_SLOT, slot_tx << 1);
2938 HFC_outb(hc, A_SL_CFG, (ch << 1) | routing);
2939 if (hc->ctype != HFC_TYPE_XHFC)
2940 HFC_outb(hc, A_CONF,
2941 (conf < 0) ? 0 : (conf | V_CONF_SL));
2942 hc->slot_owner[slot_tx << 1] = ch;
2943 hc->chan[ch].slot_tx = slot_tx;
2944 hc->chan[ch].bank_tx = bank_tx;
2947 /* disable pcm slot */
2948 flow_rx = 0x80; /* ST->FIFO */
2949 hc->chan[ch].slot_rx = -1;
2950 hc->chan[ch].bank_rx = 0;
2953 if (hc->chan[ch].txpending)
2954 flow_rx = 0x80; /* ST->FIFO */
2956 flow_rx = 0xc0; /* ST->(FIFO,PCM) */
2958 routing = bank_rx ? 0x80 : 0xc0; /* reversed */
2959 if (conf >= 0 || bank_rx > 1)
2960 routing = 0x40; /* loop */
2961 if (debug & DEBUG_HFCMULTI_MODE)
2962 printk(KERN_DEBUG "%s: put channel %d to slot %d bank"
2963 " %d flow %02x routing %02x conf %d (RX)\n",
2964 __func__, ch, slot_rx, bank_rx,
2965 flow_rx, routing, conf);
2966 HFC_outb(hc, R_SLOT, (slot_rx << 1) | V_SL_DIR);
2967 HFC_outb(hc, A_SL_CFG, (ch << 1) | V_CH_DIR | routing);
2968 hc->slot_owner[(slot_rx << 1) | 1] = ch;
2969 hc->chan[ch].slot_rx = slot_rx;
2970 hc->chan[ch].bank_rx = bank_rx;
2975 /* disable TX fifo */
2976 HFC_outb(hc, R_FIFO, ch << 1);
2978 HFC_outb(hc, A_CON_HDLC, flow_tx | 0x00 | V_IFF);
2979 HFC_outb(hc, A_SUBCH_CFG, 0);
2980 HFC_outb(hc, A_IRQ_MSK, 0);
2981 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
2983 /* disable RX fifo */
2984 HFC_outb(hc, R_FIFO, (ch << 1) | 1);
2986 HFC_outb(hc, A_CON_HDLC, flow_rx | 0x00);
2987 HFC_outb(hc, A_SUBCH_CFG, 0);
2988 HFC_outb(hc, A_IRQ_MSK, 0);
2989 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
2991 if (hc->chan[ch].bch && hc->ctype != HFC_TYPE_E1) {
2992 hc->hw.a_st_ctrl0[hc->chan[ch].port] &=
2993 ((ch & 0x3) == 0) ? ~V_B1_EN : ~V_B2_EN;
2994 HFC_outb(hc, R_ST_SEL, hc->chan[ch].port);
2995 /* undocumented: delay after R_ST_SEL */
2997 HFC_outb(hc, A_ST_CTRL0,
2998 hc->hw.a_st_ctrl0[hc->chan[ch].port]);
3000 if (hc->chan[ch].bch) {
3001 test_and_clear_bit(FLG_HDLC, &hc->chan[ch].bch->Flags);
3002 test_and_clear_bit(FLG_TRANSPARENT,
3003 &hc->chan[ch].bch->Flags);
3006 case (ISDN_P_B_RAW): /* B-channel */
3008 if (test_bit(HFC_CHIP_B410P, &hc->chip) &&
3009 (hc->chan[ch].slot_rx < 0) &&
3010 (hc->chan[ch].slot_tx < 0)) {
3013 "Setting B-channel %d to echo cancelable "
3014 "state on PCM slot %d\n", ch,
3015 ((ch / 4) * 8) + ((ch % 4) * 4) + 1);
3017 "Enabling pass through for channel\n");
3018 vpm_out(hc, ch, ((ch / 4) * 8) +
3019 ((ch % 4) * 4) + 1, 0x01);
3022 HFC_outb(hc, R_FIFO, (ch << 1));
3024 HFC_outb(hc, A_CON_HDLC, 0xc0 | V_HDLC_TRP | V_IFF);
3025 HFC_outb(hc, R_SLOT, (((ch / 4) * 8) +
3026 ((ch % 4) * 4) + 1) << 1);
3027 HFC_outb(hc, A_SL_CFG, 0x80 | (ch << 1));
3030 HFC_outb(hc, R_FIFO, 0x20 | (ch << 1) | 1);
3032 HFC_outb(hc, A_CON_HDLC, 0x20 | V_HDLC_TRP | V_IFF);
3033 HFC_outb(hc, A_SUBCH_CFG, 0);
3034 HFC_outb(hc, A_IRQ_MSK, 0);
3035 if (hc->chan[ch].protocol != protocol) {
3036 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
3039 HFC_outb(hc, R_SLOT, ((((ch / 4) * 8) +
3040 ((ch % 4) * 4) + 1) << 1) | 1);
3041 HFC_outb(hc, A_SL_CFG, 0x80 | 0x20 | (ch << 1) | 1);
3045 HFC_outb(hc, R_FIFO, (ch << 1) | 1);
3047 HFC_outb(hc, A_CON_HDLC, 0xc0 | V_HDLC_TRP | V_IFF);
3048 HFC_outb(hc, R_SLOT, ((((ch / 4) * 8) +
3049 ((ch % 4) * 4)) << 1) | 1);
3050 HFC_outb(hc, A_SL_CFG, 0x80 | 0x40 | (ch << 1) | 1);
3053 HFC_outb(hc, R_FIFO, 0x20 | (ch << 1));
3055 HFC_outb(hc, A_CON_HDLC, 0x20 | V_HDLC_TRP | V_IFF);
3056 HFC_outb(hc, A_SUBCH_CFG, 0);
3057 HFC_outb(hc, A_IRQ_MSK, 0);
3058 if (hc->chan[ch].protocol != protocol) {
3059 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
3063 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, hc->silence);
3064 HFC_outb(hc, R_SLOT, (((ch / 4) * 8) +
3065 ((ch % 4) * 4)) << 1);
3066 HFC_outb(hc, A_SL_CFG, 0x80 | 0x20 | (ch << 1));
3068 /* enable TX fifo */
3069 HFC_outb(hc, R_FIFO, ch << 1);
3071 if (hc->ctype == HFC_TYPE_XHFC)
3072 HFC_outb(hc, A_CON_HDLC, flow_tx | 0x07 << 2 |
3073 V_HDLC_TRP | V_IFF);
3074 /* Enable FIFO, no interrupt */
3076 HFC_outb(hc, A_CON_HDLC, flow_tx | 0x00 |
3077 V_HDLC_TRP | V_IFF);
3078 HFC_outb(hc, A_SUBCH_CFG, 0);
3079 HFC_outb(hc, A_IRQ_MSK, 0);
3080 if (hc->chan[ch].protocol != protocol) {
3081 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
3085 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, hc->silence);
3086 /* enable RX fifo */
3087 HFC_outb(hc, R_FIFO, (ch << 1) | 1);
3089 if (hc->ctype == HFC_TYPE_XHFC)
3090 HFC_outb(hc, A_CON_HDLC, flow_rx | 0x07 << 2 |
3092 /* Enable FIFO, no interrupt*/
3094 HFC_outb(hc, A_CON_HDLC, flow_rx | 0x00 |
3096 HFC_outb(hc, A_SUBCH_CFG, 0);
3097 HFC_outb(hc, A_IRQ_MSK, 0);
3098 if (hc->chan[ch].protocol != protocol) {
3099 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
3103 if (hc->ctype != HFC_TYPE_E1) {
3104 hc->hw.a_st_ctrl0[hc->chan[ch].port] |=
3105 ((ch & 0x3) == 0) ? V_B1_EN : V_B2_EN;
3106 HFC_outb(hc, R_ST_SEL, hc->chan[ch].port);
3107 /* undocumented: delay after R_ST_SEL */
3109 HFC_outb(hc, A_ST_CTRL0,
3110 hc->hw.a_st_ctrl0[hc->chan[ch].port]);
3112 if (hc->chan[ch].bch)
3113 test_and_set_bit(FLG_TRANSPARENT,
3114 &hc->chan[ch].bch->Flags);
3116 case (ISDN_P_B_HDLC): /* B-channel */
3117 case (ISDN_P_TE_S0): /* D-channel */
3118 case (ISDN_P_NT_S0):
3119 case (ISDN_P_TE_E1):
3120 case (ISDN_P_NT_E1):
3121 /* enable TX fifo */
3122 HFC_outb(hc, R_FIFO, ch << 1);
3124 if (hc->ctype == HFC_TYPE_E1 || hc->chan[ch].bch) {
3125 /* E1 or B-channel */
3126 HFC_outb(hc, A_CON_HDLC, flow_tx | 0x04);
3127 HFC_outb(hc, A_SUBCH_CFG, 0);
3129 /* D-Channel without HDLC fill flags */
3130 HFC_outb(hc, A_CON_HDLC, flow_tx | 0x04 | V_IFF);
3131 HFC_outb(hc, A_SUBCH_CFG, 2);
3133 HFC_outb(hc, A_IRQ_MSK, V_IRQ);
3134 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
3136 /* enable RX fifo */
3137 HFC_outb(hc, R_FIFO, (ch << 1) | 1);
3139 HFC_outb(hc, A_CON_HDLC, flow_rx | 0x04);
3140 if (hc->ctype == HFC_TYPE_E1 || hc->chan[ch].bch)
3141 HFC_outb(hc, A_SUBCH_CFG, 0); /* full 8 bits */
3143 HFC_outb(hc, A_SUBCH_CFG, 2); /* 2 bits dchannel */
3144 HFC_outb(hc, A_IRQ_MSK, V_IRQ);
3145 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
3147 if (hc->chan[ch].bch) {
3148 test_and_set_bit(FLG_HDLC, &hc->chan[ch].bch->Flags);
3149 if (hc->ctype != HFC_TYPE_E1) {
3150 hc->hw.a_st_ctrl0[hc->chan[ch].port] |=
3151 ((ch & 0x3) == 0) ? V_B1_EN : V_B2_EN;
3152 HFC_outb(hc, R_ST_SEL, hc->chan[ch].port);
3153 /* undocumented: delay after R_ST_SEL */
3155 HFC_outb(hc, A_ST_CTRL0,
3156 hc->hw.a_st_ctrl0[hc->chan[ch].port]);
3161 printk(KERN_DEBUG "%s: protocol not known %x\n",
3162 __func__, protocol);
3163 hc->chan[ch].protocol = ISDN_P_NONE;
3164 return -ENOPROTOOPT;
3166 hc->chan[ch].protocol = protocol;
3172 * connect/disconnect PCM
3176 hfcmulti_pcm(struct hfc_multi *hc, int ch, int slot_tx, int bank_tx,
3177 int slot_rx, int bank_rx)
3179 if (slot_tx < 0 || slot_rx < 0 || bank_tx < 0 || bank_rx < 0) {
3181 mode_hfcmulti(hc, ch, hc->chan[ch].protocol, -1, 0, -1, 0);
3186 mode_hfcmulti(hc, ch, hc->chan[ch].protocol, slot_tx, bank_tx,
3191 * set/disable conference
3195 hfcmulti_conf(struct hfc_multi *hc, int ch, int num)
3197 if (num >= 0 && num <= 7)
3198 hc->chan[ch].conf = num;
3200 hc->chan[ch].conf = -1;
3201 mode_hfcmulti(hc, ch, hc->chan[ch].protocol, hc->chan[ch].slot_tx,
3202 hc->chan[ch].bank_tx, hc->chan[ch].slot_rx,
3203 hc->chan[ch].bank_rx);
3208 * set/disable sample loop
3211 /* NOTE: this function is experimental and therefore disabled */
3214 * Layer 1 callback function
3217 hfcm_l1callback(struct dchannel *dch, u_int cmd)
3219 struct hfc_multi *hc = dch->hw;
3220 struct sk_buff_head free_queue;
3228 /* start activation */
3229 spin_lock_irqsave(&hc->lock, flags);
3230 if (hc->ctype == HFC_TYPE_E1) {
3231 if (debug & DEBUG_HFCMULTI_MSG)
3233 "%s: HW_RESET_REQ no BRI\n",
3236 HFC_outb(hc, R_ST_SEL, hc->chan[dch->slot].port);
3237 /* undocumented: delay after R_ST_SEL */
3239 HFC_outb(hc, A_ST_WR_STATE, V_ST_LD_STA | 3); /* F3 */
3240 udelay(6); /* wait at least 5,21us */
3241 HFC_outb(hc, A_ST_WR_STATE, 3);
3242 HFC_outb(hc, A_ST_WR_STATE, 3 | (V_ST_ACT * 3));
3245 spin_unlock_irqrestore(&hc->lock, flags);
3246 l1_event(dch->l1, HW_POWERUP_IND);
3249 __skb_queue_head_init(&free_queue);
3250 /* start deactivation */
3251 spin_lock_irqsave(&hc->lock, flags);
3252 if (hc->ctype == HFC_TYPE_E1) {
3253 if (debug & DEBUG_HFCMULTI_MSG)
3255 "%s: HW_DEACT_REQ no BRI\n",
3258 HFC_outb(hc, R_ST_SEL, hc->chan[dch->slot].port);
3259 /* undocumented: delay after R_ST_SEL */
3261 HFC_outb(hc, A_ST_WR_STATE, V_ST_ACT * 2);
3263 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
3265 ~(1 << hc->chan[dch->slot].port);
3266 plxsd_checksync(hc, 0);
3269 skb_queue_splice_init(&dch->squeue, &free_queue);
3271 __skb_queue_tail(&free_queue, dch->tx_skb);
3276 __skb_queue_tail(&free_queue, dch->rx_skb);
3279 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
3280 if (test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags))
3281 del_timer(&dch->timer);
3282 spin_unlock_irqrestore(&hc->lock, flags);
3283 __skb_queue_purge(&free_queue);
3285 case HW_POWERUP_REQ:
3286 spin_lock_irqsave(&hc->lock, flags);
3287 if (hc->ctype == HFC_TYPE_E1) {
3288 if (debug & DEBUG_HFCMULTI_MSG)
3290 "%s: HW_POWERUP_REQ no BRI\n",
3293 HFC_outb(hc, R_ST_SEL, hc->chan[dch->slot].port);
3294 /* undocumented: delay after R_ST_SEL */
3296 HFC_outb(hc, A_ST_WR_STATE, 3 | 0x10); /* activate */
3297 udelay(6); /* wait at least 5,21us */
3298 HFC_outb(hc, A_ST_WR_STATE, 3); /* activate */
3300 spin_unlock_irqrestore(&hc->lock, flags);
3302 case PH_ACTIVATE_IND:
3303 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
3304 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
3307 case PH_DEACTIVATE_IND:
3308 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
3309 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
3313 if (dch->debug & DEBUG_HW)
3314 printk(KERN_DEBUG "%s: unknown command %x\n",
3322 * Layer2 -> Layer 1 Transfer
3326 handle_dmsg(struct mISDNchannel *ch, struct sk_buff *skb)
3328 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
3329 struct dchannel *dch = container_of(dev, struct dchannel, dev);
3330 struct hfc_multi *hc = dch->hw;
3331 struct mISDNhead *hh = mISDN_HEAD_P(skb);
3340 spin_lock_irqsave(&hc->lock, flags);
3341 ret = dchannel_senddata(dch, skb);
3342 if (ret > 0) { /* direct TX */
3343 id = hh->id; /* skb can be freed */
3344 hfcmulti_tx(hc, dch->slot);
3347 HFC_outb(hc, R_FIFO, 0);
3349 spin_unlock_irqrestore(&hc->lock, flags);
3350 queue_ch_frame(ch, PH_DATA_CNF, id, NULL);
3352 spin_unlock_irqrestore(&hc->lock, flags);
3354 case PH_ACTIVATE_REQ:
3355 if (dch->dev.D.protocol != ISDN_P_TE_S0) {
3356 spin_lock_irqsave(&hc->lock, flags);
3358 if (debug & DEBUG_HFCMULTI_MSG)
3360 "%s: PH_ACTIVATE port %d (0..%d)\n",
3361 __func__, hc->chan[dch->slot].port,
3363 /* start activation */
3364 if (hc->ctype == HFC_TYPE_E1) {
3365 ph_state_change(dch);
3366 if (debug & DEBUG_HFCMULTI_STATE)
3368 "%s: E1 report state %x \n",
3369 __func__, dch->state);
3371 HFC_outb(hc, R_ST_SEL,
3372 hc->chan[dch->slot].port);
3373 /* undocumented: delay after R_ST_SEL */
3375 HFC_outb(hc, A_ST_WR_STATE, V_ST_LD_STA | 1);
3377 udelay(6); /* wait at least 5,21us */
3378 HFC_outb(hc, A_ST_WR_STATE, 1);
3379 HFC_outb(hc, A_ST_WR_STATE, 1 |
3380 (V_ST_ACT * 3)); /* activate */
3383 spin_unlock_irqrestore(&hc->lock, flags);
3385 ret = l1_event(dch->l1, hh->prim);
3387 case PH_DEACTIVATE_REQ:
3388 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
3389 if (dch->dev.D.protocol != ISDN_P_TE_S0) {
3390 struct sk_buff_head free_queue;
3392 __skb_queue_head_init(&free_queue);
3393 spin_lock_irqsave(&hc->lock, flags);
3394 if (debug & DEBUG_HFCMULTI_MSG)
3396 "%s: PH_DEACTIVATE port %d (0..%d)\n",
3397 __func__, hc->chan[dch->slot].port,
3399 /* start deactivation */
3400 if (hc->ctype == HFC_TYPE_E1) {
3401 if (debug & DEBUG_HFCMULTI_MSG)
3403 "%s: PH_DEACTIVATE no BRI\n",
3406 HFC_outb(hc, R_ST_SEL,
3407 hc->chan[dch->slot].port);
3408 /* undocumented: delay after R_ST_SEL */
3410 HFC_outb(hc, A_ST_WR_STATE, V_ST_ACT * 2);
3414 skb_queue_splice_init(&dch->squeue, &free_queue);
3416 __skb_queue_tail(&free_queue, dch->tx_skb);
3421 __skb_queue_tail(&free_queue, dch->rx_skb);
3424 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
3425 if (test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags))
3426 del_timer(&dch->timer);
3428 if (test_and_clear_bit(FLG_L1_BUSY, &dch->Flags))
3429 dchannel_sched_event(&hc->dch, D_CLEARBUSY);
3432 spin_unlock_irqrestore(&hc->lock, flags);
3433 __skb_queue_purge(&free_queue);
3435 ret = l1_event(dch->l1, hh->prim);
3444 deactivate_bchannel(struct bchannel *bch)
3446 struct hfc_multi *hc = bch->hw;
3449 spin_lock_irqsave(&hc->lock, flags);
3450 mISDN_clear_bchannel(bch);
3451 hc->chan[bch->slot].coeff_count = 0;
3452 hc->chan[bch->slot].rx_off = 0;
3453 hc->chan[bch->slot].conf = -1;
3454 mode_hfcmulti(hc, bch->slot, ISDN_P_NONE, -1, 0, -1, 0);
3455 spin_unlock_irqrestore(&hc->lock, flags);
3459 handle_bmsg(struct mISDNchannel *ch, struct sk_buff *skb)
3461 struct bchannel *bch = container_of(ch, struct bchannel, ch);
3462 struct hfc_multi *hc = bch->hw;
3464 struct mISDNhead *hh = mISDN_HEAD_P(skb);
3465 unsigned long flags;
3471 spin_lock_irqsave(&hc->lock, flags);
3472 ret = bchannel_senddata(bch, skb);
3473 if (ret > 0) { /* direct TX */
3474 hfcmulti_tx(hc, bch->slot);
3477 HFC_outb_nodebug(hc, R_FIFO, 0);
3478 HFC_wait_nodebug(hc);
3480 spin_unlock_irqrestore(&hc->lock, flags);
3482 case PH_ACTIVATE_REQ:
3483 if (debug & DEBUG_HFCMULTI_MSG)
3484 printk(KERN_DEBUG "%s: PH_ACTIVATE ch %d (0..32)\n",
3485 __func__, bch->slot);
3486 spin_lock_irqsave(&hc->lock, flags);
3487 /* activate B-channel if not already activated */
3488 if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags)) {
3489 hc->chan[bch->slot].txpending = 0;
3490 ret = mode_hfcmulti(hc, bch->slot,
3492 hc->chan[bch->slot].slot_tx,
3493 hc->chan[bch->slot].bank_tx,
3494 hc->chan[bch->slot].slot_rx,
3495 hc->chan[bch->slot].bank_rx);
3497 if (ch->protocol == ISDN_P_B_RAW && !hc->dtmf
3498 && test_bit(HFC_CHIP_DTMF, &hc->chip)) {
3501 if (debug & DEBUG_HFCMULTI_DTMF)
3503 "%s: start dtmf decoder\n",
3505 HFC_outb(hc, R_DTMF, hc->hw.r_dtmf |
3511 spin_unlock_irqrestore(&hc->lock, flags);
3513 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 0, NULL,
3516 case PH_CONTROL_REQ:
3517 spin_lock_irqsave(&hc->lock, flags);
3519 case HFC_SPL_LOOP_ON: /* set sample loop */
3520 if (debug & DEBUG_HFCMULTI_MSG)
3522 "%s: HFC_SPL_LOOP_ON (len = %d)\n",
3523 __func__, skb->len);
3526 case HFC_SPL_LOOP_OFF: /* set silence */
3527 if (debug & DEBUG_HFCMULTI_MSG)
3528 printk(KERN_DEBUG "%s: HFC_SPL_LOOP_OFF\n",
3534 "%s: unknown PH_CONTROL_REQ info %x\n",
3538 spin_unlock_irqrestore(&hc->lock, flags);
3540 case PH_DEACTIVATE_REQ:
3541 deactivate_bchannel(bch); /* locked there */
3542 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0, NULL,
3553 * bchannel control function
3556 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
3559 struct dsp_features *features =
3560 (struct dsp_features *)(*((u_long *)&cq->p1));
3561 struct hfc_multi *hc = bch->hw;
3569 case MISDN_CTRL_GETOP:
3570 ret = mISDN_ctrl_bchannel(bch, cq);
3571 cq->op |= MISDN_CTRL_HFC_OP | MISDN_CTRL_HW_FEATURES_OP;
3573 case MISDN_CTRL_RX_OFF: /* turn off / on rx stream */
3574 ret = mISDN_ctrl_bchannel(bch, cq);
3575 hc->chan[bch->slot].rx_off = !!cq->p1;
3576 if (!hc->chan[bch->slot].rx_off) {
3577 /* reset fifo on rx on */
3578 HFC_outb_nodebug(hc, R_FIFO, (bch->slot << 1) | 1);
3579 HFC_wait_nodebug(hc);
3580 HFC_outb_nodebug(hc, R_INC_RES_FIFO, V_RES_F);
3581 HFC_wait_nodebug(hc);
3583 if (debug & DEBUG_HFCMULTI_MSG)
3584 printk(KERN_DEBUG "%s: RX_OFF request (nr=%d off=%d)\n",
3585 __func__, bch->nr, hc->chan[bch->slot].rx_off);
3587 case MISDN_CTRL_FILL_EMPTY:
3588 ret = mISDN_ctrl_bchannel(bch, cq);
3589 hc->silence = bch->fill[0];
3590 memset(hc->silence_data, hc->silence, sizeof(hc->silence_data));
3592 case MISDN_CTRL_HW_FEATURES: /* fill features structure */
3593 if (debug & DEBUG_HFCMULTI_MSG)
3594 printk(KERN_DEBUG "%s: HW_FEATURE request\n",
3596 /* create confirm */
3597 features->hfc_id = hc->id;
3598 if (test_bit(HFC_CHIP_DTMF, &hc->chip))
3599 features->hfc_dtmf = 1;
3600 if (test_bit(HFC_CHIP_CONF, &hc->chip))
3601 features->hfc_conf = 1;
3602 features->hfc_loops = 0;
3603 if (test_bit(HFC_CHIP_B410P, &hc->chip)) {
3604 features->hfc_echocanhw = 1;
3606 features->pcm_id = hc->pcm;
3607 features->pcm_slots = hc->slots;
3608 features->pcm_banks = 2;
3611 case MISDN_CTRL_HFC_PCM_CONN: /* connect to pcm timeslot (0..N) */
3612 slot_tx = cq->p1 & 0xff;
3613 bank_tx = cq->p1 >> 8;
3614 slot_rx = cq->p2 & 0xff;
3615 bank_rx = cq->p2 >> 8;
3616 if (debug & DEBUG_HFCMULTI_MSG)
3618 "%s: HFC_PCM_CONN slot %d bank %d (TX) "
3619 "slot %d bank %d (RX)\n",
3620 __func__, slot_tx, bank_tx,
3622 if (slot_tx < hc->slots && bank_tx <= 2 &&
3623 slot_rx < hc->slots && bank_rx <= 2)
3624 hfcmulti_pcm(hc, bch->slot,
3625 slot_tx, bank_tx, slot_rx, bank_rx);
3628 "%s: HFC_PCM_CONN slot %d bank %d (TX) "
3629 "slot %d bank %d (RX) out of range\n",
3630 __func__, slot_tx, bank_tx,
3635 case MISDN_CTRL_HFC_PCM_DISC: /* release interface from pcm timeslot */
3636 if (debug & DEBUG_HFCMULTI_MSG)
3637 printk(KERN_DEBUG "%s: HFC_PCM_DISC\n",
3639 hfcmulti_pcm(hc, bch->slot, -1, 0, -1, 0);
3641 case MISDN_CTRL_HFC_CONF_JOIN: /* join conference (0..7) */
3642 num = cq->p1 & 0xff;
3643 if (debug & DEBUG_HFCMULTI_MSG)
3644 printk(KERN_DEBUG "%s: HFC_CONF_JOIN conf %d\n",
3647 hfcmulti_conf(hc, bch->slot, num);
3650 "%s: HW_CONF_JOIN conf %d out of range\n",
3655 case MISDN_CTRL_HFC_CONF_SPLIT: /* split conference */
3656 if (debug & DEBUG_HFCMULTI_MSG)
3657 printk(KERN_DEBUG "%s: HFC_CONF_SPLIT\n", __func__);
3658 hfcmulti_conf(hc, bch->slot, -1);
3660 case MISDN_CTRL_HFC_ECHOCAN_ON:
3661 if (debug & DEBUG_HFCMULTI_MSG)
3662 printk(KERN_DEBUG "%s: HFC_ECHOCAN_ON\n", __func__);
3663 if (test_bit(HFC_CHIP_B410P, &hc->chip))
3664 vpm_echocan_on(hc, bch->slot, cq->p1);
3669 case MISDN_CTRL_HFC_ECHOCAN_OFF:
3670 if (debug & DEBUG_HFCMULTI_MSG)
3671 printk(KERN_DEBUG "%s: HFC_ECHOCAN_OFF\n",
3673 if (test_bit(HFC_CHIP_B410P, &hc->chip))
3674 vpm_echocan_off(hc, bch->slot);
3679 ret = mISDN_ctrl_bchannel(bch, cq);
3686 hfcm_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
3688 struct bchannel *bch = container_of(ch, struct bchannel, ch);
3689 struct hfc_multi *hc = bch->hw;
3693 if (bch->debug & DEBUG_HW)
3694 printk(KERN_DEBUG "%s: cmd:%x %p\n",
3695 __func__, cmd, arg);
3698 test_and_clear_bit(FLG_OPEN, &bch->Flags);
3699 deactivate_bchannel(bch); /* locked there */
3700 ch->protocol = ISDN_P_NONE;
3702 module_put(THIS_MODULE);
3705 case CONTROL_CHANNEL:
3706 spin_lock_irqsave(&hc->lock, flags);
3707 err = channel_bctrl(bch, arg);
3708 spin_unlock_irqrestore(&hc->lock, flags);
3711 printk(KERN_WARNING "%s: unknown prim(%x)\n",
3718 * handle D-channel events
3720 * handle state change event
3723 ph_state_change(struct dchannel *dch)
3725 struct hfc_multi *hc;
3729 printk(KERN_WARNING "%s: ERROR given dch is NULL\n", __func__);
3735 if (hc->ctype == HFC_TYPE_E1) {
3736 if (dch->dev.D.protocol == ISDN_P_TE_E1) {
3737 if (debug & DEBUG_HFCMULTI_STATE)
3739 "%s: E1 TE (id=%d) newstate %x\n",
3740 __func__, hc->id, dch->state);
3742 if (debug & DEBUG_HFCMULTI_STATE)
3744 "%s: E1 NT (id=%d) newstate %x\n",
3745 __func__, hc->id, dch->state);
3747 switch (dch->state) {
3749 if (hc->e1_state != 1) {
3750 for (i = 1; i <= 31; i++) {
3751 /* reset fifos on e1 activation */
3752 HFC_outb_nodebug(hc, R_FIFO,
3754 HFC_wait_nodebug(hc);
3755 HFC_outb_nodebug(hc, R_INC_RES_FIFO,
3757 HFC_wait_nodebug(hc);
3760 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
3761 _queue_data(&dch->dev.D, PH_ACTIVATE_IND,
3762 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
3766 if (hc->e1_state != 1)
3768 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
3769 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND,
3770 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
3772 hc->e1_state = dch->state;
3774 if (dch->dev.D.protocol == ISDN_P_TE_S0) {
3775 if (debug & DEBUG_HFCMULTI_STATE)
3777 "%s: S/T TE newstate %x\n",
3778 __func__, dch->state);
3779 switch (dch->state) {
3781 l1_event(dch->l1, HW_RESET_IND);
3784 l1_event(dch->l1, HW_DEACT_IND);
3788 l1_event(dch->l1, ANYSIGNAL);
3791 l1_event(dch->l1, INFO2);
3794 l1_event(dch->l1, INFO4_P8);
3798 if (debug & DEBUG_HFCMULTI_STATE)
3799 printk(KERN_DEBUG "%s: S/T NT newstate %x\n",
3800 __func__, dch->state);
3801 switch (dch->state) {
3803 if (hc->chan[ch].nt_timer == 0) {
3804 hc->chan[ch].nt_timer = -1;
3805 HFC_outb(hc, R_ST_SEL,
3807 /* undocumented: delay after R_ST_SEL */
3809 HFC_outb(hc, A_ST_WR_STATE, 4 |
3810 V_ST_LD_STA); /* G4 */
3811 udelay(6); /* wait at least 5,21us */
3812 HFC_outb(hc, A_ST_WR_STATE, 4);
3815 /* one extra count for the next event */
3816 hc->chan[ch].nt_timer =
3817 nt_t1_count[poll_timer] + 1;
3818 HFC_outb(hc, R_ST_SEL,
3820 /* undocumented: delay after R_ST_SEL */
3822 /* allow G2 -> G3 transition */
3823 HFC_outb(hc, A_ST_WR_STATE, 2 |
3828 hc->chan[ch].nt_timer = -1;
3829 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
3830 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND,
3831 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
3834 hc->chan[ch].nt_timer = -1;
3837 hc->chan[ch].nt_timer = -1;
3838 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
3839 _queue_data(&dch->dev.D, PH_ACTIVATE_IND,
3840 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
3848 * called for card mode init message
3852 hfcmulti_initmode(struct dchannel *dch)
3854 struct hfc_multi *hc = dch->hw;
3855 u_char a_st_wr_state, r_e1_wr_sta;
3858 if (debug & DEBUG_HFCMULTI_INIT)
3859 printk(KERN_DEBUG "%s: entered\n", __func__);
3862 pt = hc->chan[i].port;
3863 if (hc->ctype == HFC_TYPE_E1) {
3865 hc->chan[hc->dnum[pt]].slot_tx = -1;
3866 hc->chan[hc->dnum[pt]].slot_rx = -1;
3867 hc->chan[hc->dnum[pt]].conf = -1;
3869 mode_hfcmulti(hc, dch->slot, dch->dev.D.protocol,
3871 timer_setup(&dch->timer, hfcmulti_dbusy_timer, 0);
3873 for (i = 1; i <= 31; i++) {
3874 if (!((1 << i) & hc->bmask[pt])) /* skip unused chan */
3876 hc->chan[i].slot_tx = -1;
3877 hc->chan[i].slot_rx = -1;
3878 hc->chan[i].conf = -1;
3879 mode_hfcmulti(hc, i, ISDN_P_NONE, -1, 0, -1, 0);
3882 if (hc->ctype == HFC_TYPE_E1 && pt == 0) {
3884 dch = hc->chan[hc->dnum[0]].dch;
3885 if (test_bit(HFC_CFG_REPORT_LOS, &hc->chan[hc->dnum[0]].cfg)) {
3886 HFC_outb(hc, R_LOS0, 255); /* 2 ms */
3887 HFC_outb(hc, R_LOS1, 255); /* 512 ms */
3889 if (test_bit(HFC_CFG_OPTICAL, &hc->chan[hc->dnum[0]].cfg)) {
3890 HFC_outb(hc, R_RX0, 0);
3891 hc->hw.r_tx0 = 0 | V_OUT_EN;
3893 HFC_outb(hc, R_RX0, 1);
3894 hc->hw.r_tx0 = 1 | V_OUT_EN;
3896 hc->hw.r_tx1 = V_ATX | V_NTRI;
3897 HFC_outb(hc, R_TX0, hc->hw.r_tx0);
3898 HFC_outb(hc, R_TX1, hc->hw.r_tx1);
3899 HFC_outb(hc, R_TX_FR0, 0x00);
3900 HFC_outb(hc, R_TX_FR1, 0xf8);
3902 if (test_bit(HFC_CFG_CRC4, &hc->chan[hc->dnum[0]].cfg))
3903 HFC_outb(hc, R_TX_FR2, V_TX_MF | V_TX_E | V_NEG_E);
3905 HFC_outb(hc, R_RX_FR0, V_AUTO_RESYNC | V_AUTO_RECO | 0);
3907 if (test_bit(HFC_CFG_CRC4, &hc->chan[hc->dnum[0]].cfg))
3908 HFC_outb(hc, R_RX_FR1, V_RX_MF | V_RX_MF_SYNC);
3910 if (dch->dev.D.protocol == ISDN_P_NT_E1) {
3911 if (debug & DEBUG_HFCMULTI_INIT)
3912 printk(KERN_DEBUG "%s: E1 port is NT-mode\n",
3914 r_e1_wr_sta = 0; /* G0 */
3915 hc->e1_getclock = 0;
3917 if (debug & DEBUG_HFCMULTI_INIT)
3918 printk(KERN_DEBUG "%s: E1 port is TE-mode\n",
3920 r_e1_wr_sta = 0; /* F0 */
3921 hc->e1_getclock = 1;
3923 if (test_bit(HFC_CHIP_RX_SYNC, &hc->chip))
3924 HFC_outb(hc, R_SYNC_OUT, V_SYNC_E1_RX);
3926 HFC_outb(hc, R_SYNC_OUT, 0);
3927 if (test_bit(HFC_CHIP_E1CLOCK_GET, &hc->chip))
3928 hc->e1_getclock = 1;
3929 if (test_bit(HFC_CHIP_E1CLOCK_PUT, &hc->chip))
3930 hc->e1_getclock = 0;
3931 if (test_bit(HFC_CHIP_PCM_SLAVE, &hc->chip)) {
3932 /* SLAVE (clock master) */
3933 if (debug & DEBUG_HFCMULTI_INIT)
3935 "%s: E1 port is clock master "
3936 "(clock from PCM)\n", __func__);
3937 HFC_outb(hc, R_SYNC_CTRL, V_EXT_CLK_SYNC | V_PCM_SYNC);
3939 if (hc->e1_getclock) {
3940 /* MASTER (clock slave) */
3941 if (debug & DEBUG_HFCMULTI_INIT)
3943 "%s: E1 port is clock slave "
3944 "(clock to PCM)\n", __func__);
3945 HFC_outb(hc, R_SYNC_CTRL, V_SYNC_OFFS);
3947 /* MASTER (clock master) */
3948 if (debug & DEBUG_HFCMULTI_INIT)
3949 printk(KERN_DEBUG "%s: E1 port is "
3951 "(clock from QUARTZ)\n",
3953 HFC_outb(hc, R_SYNC_CTRL, V_EXT_CLK_SYNC |
3954 V_PCM_SYNC | V_JATT_OFF);
3955 HFC_outb(hc, R_SYNC_OUT, 0);
3958 HFC_outb(hc, R_JATT_ATT, 0x9c); /* undoc register */
3959 HFC_outb(hc, R_PWM_MD, V_PWM0_MD);
3960 HFC_outb(hc, R_PWM0, 0x50);
3961 HFC_outb(hc, R_PWM1, 0xff);
3962 /* state machine setup */
3963 HFC_outb(hc, R_E1_WR_STA, r_e1_wr_sta | V_E1_LD_STA);
3964 udelay(6); /* wait at least 5,21us */
3965 HFC_outb(hc, R_E1_WR_STA, r_e1_wr_sta);
3966 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
3967 hc->syncronized = 0;
3968 plxsd_checksync(hc, 0);
3971 if (hc->ctype != HFC_TYPE_E1) {
3973 hc->chan[i].slot_tx = -1;
3974 hc->chan[i].slot_rx = -1;
3975 hc->chan[i].conf = -1;
3976 mode_hfcmulti(hc, i, dch->dev.D.protocol, -1, 0, -1, 0);
3977 timer_setup(&dch->timer, hfcmulti_dbusy_timer, 0);
3978 hc->chan[i - 2].slot_tx = -1;
3979 hc->chan[i - 2].slot_rx = -1;
3980 hc->chan[i - 2].conf = -1;
3981 mode_hfcmulti(hc, i - 2, ISDN_P_NONE, -1, 0, -1, 0);
3982 hc->chan[i - 1].slot_tx = -1;
3983 hc->chan[i - 1].slot_rx = -1;
3984 hc->chan[i - 1].conf = -1;
3985 mode_hfcmulti(hc, i - 1, ISDN_P_NONE, -1, 0, -1, 0);
3986 /* select interface */
3987 HFC_outb(hc, R_ST_SEL, pt);
3988 /* undocumented: delay after R_ST_SEL */
3990 if (dch->dev.D.protocol == ISDN_P_NT_S0) {
3991 if (debug & DEBUG_HFCMULTI_INIT)
3993 "%s: ST port %d is NT-mode\n",
3996 HFC_outb(hc, A_ST_CLK_DLY, clockdelay_nt);
3997 a_st_wr_state = 1; /* G1 */
3998 hc->hw.a_st_ctrl0[pt] = V_ST_MD;
4000 if (debug & DEBUG_HFCMULTI_INIT)
4002 "%s: ST port %d is TE-mode\n",
4005 HFC_outb(hc, A_ST_CLK_DLY, clockdelay_te);
4006 a_st_wr_state = 2; /* F2 */
4007 hc->hw.a_st_ctrl0[pt] = 0;
4009 if (!test_bit(HFC_CFG_NONCAP_TX, &hc->chan[i].cfg))
4010 hc->hw.a_st_ctrl0[pt] |= V_TX_LI;
4011 if (hc->ctype == HFC_TYPE_XHFC) {
4012 hc->hw.a_st_ctrl0[pt] |= 0x40 /* V_ST_PU_CTRL */;
4013 HFC_outb(hc, 0x35 /* A_ST_CTRL3 */,
4014 0x7c << 1 /* V_ST_PULSE */);
4017 HFC_outb(hc, A_ST_CTRL0, hc->hw.a_st_ctrl0[pt]);
4018 /* disable E-channel */
4019 if ((dch->dev.D.protocol == ISDN_P_NT_S0) ||
4020 test_bit(HFC_CFG_DIS_ECHANNEL, &hc->chan[i].cfg))
4021 HFC_outb(hc, A_ST_CTRL1, V_E_IGNO);
4023 HFC_outb(hc, A_ST_CTRL1, 0);
4024 /* enable B-channel receive */
4025 HFC_outb(hc, A_ST_CTRL2, V_B1_RX_EN | V_B2_RX_EN);
4026 /* state machine setup */
4027 HFC_outb(hc, A_ST_WR_STATE, a_st_wr_state | V_ST_LD_STA);
4028 udelay(6); /* wait at least 5,21us */
4029 HFC_outb(hc, A_ST_WR_STATE, a_st_wr_state);
4030 hc->hw.r_sci_msk |= 1 << pt;
4031 /* state machine interrupts */
4032 HFC_outb(hc, R_SCI_MSK, hc->hw.r_sci_msk);
4033 /* unset sync on port */
4034 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
4036 ~(1 << hc->chan[dch->slot].port);
4037 plxsd_checksync(hc, 0);
4040 if (debug & DEBUG_HFCMULTI_INIT)
4041 printk("%s: done\n", __func__);
4046 open_dchannel(struct hfc_multi *hc, struct dchannel *dch,
4047 struct channel_req *rq)
4052 if (debug & DEBUG_HW_OPEN)
4053 printk(KERN_DEBUG "%s: dev(%d) open from %p\n", __func__,
4054 dch->dev.id, __builtin_return_address(0));
4055 if (rq->protocol == ISDN_P_NONE)
4057 if ((dch->dev.D.protocol != ISDN_P_NONE) &&
4058 (dch->dev.D.protocol != rq->protocol)) {
4059 if (debug & DEBUG_HFCMULTI_MODE)
4060 printk(KERN_DEBUG "%s: change protocol %x to %x\n",
4061 __func__, dch->dev.D.protocol, rq->protocol);
4063 if ((dch->dev.D.protocol == ISDN_P_TE_S0) &&
4064 (rq->protocol != ISDN_P_TE_S0))
4065 l1_event(dch->l1, CLOSE_CHANNEL);
4066 if (dch->dev.D.protocol != rq->protocol) {
4067 if (rq->protocol == ISDN_P_TE_S0) {
4068 err = create_l1(dch, hfcm_l1callback);
4072 dch->dev.D.protocol = rq->protocol;
4073 spin_lock_irqsave(&hc->lock, flags);
4074 hfcmulti_initmode(dch);
4075 spin_unlock_irqrestore(&hc->lock, flags);
4077 if (test_bit(FLG_ACTIVE, &dch->Flags))
4078 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, MISDN_ID_ANY,
4079 0, NULL, GFP_KERNEL);
4080 rq->ch = &dch->dev.D;
4081 if (!try_module_get(THIS_MODULE))
4082 printk(KERN_WARNING "%s:cannot get module\n", __func__);
4087 open_bchannel(struct hfc_multi *hc, struct dchannel *dch,
4088 struct channel_req *rq)
4090 struct bchannel *bch;
4093 if (!test_channelmap(rq->adr.channel, dch->dev.channelmap))
4095 if (rq->protocol == ISDN_P_NONE)
4097 if (hc->ctype == HFC_TYPE_E1)
4098 ch = rq->adr.channel;
4100 ch = (rq->adr.channel - 1) + (dch->slot - 2);
4101 bch = hc->chan[ch].bch;
4103 printk(KERN_ERR "%s:internal error ch %d has no bch\n",
4107 if (test_and_set_bit(FLG_OPEN, &bch->Flags))
4108 return -EBUSY; /* b-channel can be only open once */
4109 bch->ch.protocol = rq->protocol;
4110 hc->chan[ch].rx_off = 0;
4112 if (!try_module_get(THIS_MODULE))
4113 printk(KERN_WARNING "%s:cannot get module\n", __func__);
4118 * device control function
4121 channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
4123 struct hfc_multi *hc = dch->hw;
4125 int wd_mode, wd_cnt;
4128 case MISDN_CTRL_GETOP:
4129 cq->op = MISDN_CTRL_HFC_OP | MISDN_CTRL_L1_TIMER3;
4131 case MISDN_CTRL_HFC_WD_INIT: /* init the watchdog */
4132 wd_cnt = cq->p1 & 0xf;
4133 wd_mode = !!(cq->p1 >> 4);
4134 if (debug & DEBUG_HFCMULTI_MSG)
4135 printk(KERN_DEBUG "%s: MISDN_CTRL_HFC_WD_INIT mode %s"
4136 ", counter 0x%x\n", __func__,
4137 wd_mode ? "AUTO" : "MANUAL", wd_cnt);
4138 /* set the watchdog timer */
4139 HFC_outb(hc, R_TI_WD, poll_timer | (wd_cnt << 4));
4140 hc->hw.r_bert_wd_md = (wd_mode ? V_AUTO_WD_RES : 0);
4141 if (hc->ctype == HFC_TYPE_XHFC)
4142 hc->hw.r_bert_wd_md |= 0x40 /* V_WD_EN */;
4143 /* init the watchdog register and reset the counter */
4144 HFC_outb(hc, R_BERT_WD_MD, hc->hw.r_bert_wd_md | V_WD_RES);
4145 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
4146 /* enable the watchdog output for Speech-Design */
4147 HFC_outb(hc, R_GPIO_SEL, V_GPIO_SEL7);
4148 HFC_outb(hc, R_GPIO_EN1, V_GPIO_EN15);
4149 HFC_outb(hc, R_GPIO_OUT1, 0);
4150 HFC_outb(hc, R_GPIO_OUT1, V_GPIO_OUT15);
4153 case MISDN_CTRL_HFC_WD_RESET: /* reset the watchdog counter */
4154 if (debug & DEBUG_HFCMULTI_MSG)
4155 printk(KERN_DEBUG "%s: MISDN_CTRL_HFC_WD_RESET\n",
4157 HFC_outb(hc, R_BERT_WD_MD, hc->hw.r_bert_wd_md | V_WD_RES);
4159 case MISDN_CTRL_L1_TIMER3:
4160 ret = l1_event(dch->l1, HW_TIMER3_VALUE | (cq->p1 & 0xff));
4163 printk(KERN_WARNING "%s: unknown Op %x\n",
4172 hfcm_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
4174 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
4175 struct dchannel *dch = container_of(dev, struct dchannel, dev);
4176 struct hfc_multi *hc = dch->hw;
4177 struct channel_req *rq;
4181 if (dch->debug & DEBUG_HW)
4182 printk(KERN_DEBUG "%s: cmd:%x %p\n",
4183 __func__, cmd, arg);
4187 switch (rq->protocol) {
4190 if (hc->ctype == HFC_TYPE_E1) {
4194 err = open_dchannel(hc, dch, rq); /* locked there */
4198 if (hc->ctype != HFC_TYPE_E1) {
4202 err = open_dchannel(hc, dch, rq); /* locked there */
4205 spin_lock_irqsave(&hc->lock, flags);
4206 err = open_bchannel(hc, dch, rq);
4207 spin_unlock_irqrestore(&hc->lock, flags);
4211 if (debug & DEBUG_HW_OPEN)
4212 printk(KERN_DEBUG "%s: dev(%d) close from %p\n",
4213 __func__, dch->dev.id,
4214 __builtin_return_address(0));
4215 module_put(THIS_MODULE);
4217 case CONTROL_CHANNEL:
4218 spin_lock_irqsave(&hc->lock, flags);
4219 err = channel_dctrl(dch, arg);
4220 spin_unlock_irqrestore(&hc->lock, flags);
4223 if (dch->debug & DEBUG_HW)
4224 printk(KERN_DEBUG "%s: unknown command %x\n",
4232 clockctl(void *priv, int enable)
4234 struct hfc_multi *hc = priv;
4236 hc->iclock_on = enable;
4241 * initialize the card
4245 * start timer irq, wait some time and check if we have interrupts.
4246 * if not, reset chip and try again.
4249 init_card(struct hfc_multi *hc)
4253 void __iomem *plx_acc;
4256 if (debug & DEBUG_HFCMULTI_INIT)
4257 printk(KERN_DEBUG "%s: entered\n", __func__);
4259 spin_lock_irqsave(&hc->lock, flags);
4260 /* set interrupts but leave global interrupt disabled */
4261 hc->hw.r_irq_ctrl = V_FIFO_IRQ;
4263 spin_unlock_irqrestore(&hc->lock, flags);
4265 if (request_irq(hc->irq, hfcmulti_interrupt, IRQF_SHARED,
4267 printk(KERN_WARNING "mISDN: Could not get interrupt %d.\n",
4273 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
4274 spin_lock_irqsave(&plx_lock, plx_flags);
4275 plx_acc = hc->plx_membase + PLX_INTCSR;
4276 writew((PLX_INTCSR_PCIINT_ENABLE | PLX_INTCSR_LINTI1_ENABLE),
4277 plx_acc); /* enable PCI & LINT1 irq */
4278 spin_unlock_irqrestore(&plx_lock, plx_flags);
4281 if (debug & DEBUG_HFCMULTI_INIT)
4282 printk(KERN_DEBUG "%s: IRQ %d count %d\n",
4283 __func__, hc->irq, hc->irqcnt);
4284 err = init_chip(hc);
4288 * Finally enable IRQ output
4289 * this is only allowed, if an IRQ routine is already
4290 * established for this HFC, so don't do that earlier
4292 spin_lock_irqsave(&hc->lock, flags);
4294 spin_unlock_irqrestore(&hc->lock, flags);
4295 /* printk(KERN_DEBUG "no master irq set!!!\n"); */
4296 set_current_state(TASK_UNINTERRUPTIBLE);
4297 schedule_timeout((100 * HZ) / 1000); /* Timeout 100ms */
4298 /* turn IRQ off until chip is completely initialized */
4299 spin_lock_irqsave(&hc->lock, flags);
4301 spin_unlock_irqrestore(&hc->lock, flags);
4302 if (debug & DEBUG_HFCMULTI_INIT)
4303 printk(KERN_DEBUG "%s: IRQ %d count %d\n",
4304 __func__, hc->irq, hc->irqcnt);
4306 if (debug & DEBUG_HFCMULTI_INIT)
4307 printk(KERN_DEBUG "%s: done\n", __func__);
4311 if (test_bit(HFC_CHIP_PCM_SLAVE, &hc->chip)) {
4312 printk(KERN_INFO "ignoring missing interrupts\n");
4316 printk(KERN_ERR "HFC PCI: IRQ(%d) getting no interrupts during init.\n",
4322 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
4323 spin_lock_irqsave(&plx_lock, plx_flags);
4324 plx_acc = hc->plx_membase + PLX_INTCSR;
4325 writew(0x00, plx_acc); /*disable IRQs*/
4326 spin_unlock_irqrestore(&plx_lock, plx_flags);
4329 if (debug & DEBUG_HFCMULTI_INIT)
4330 printk(KERN_DEBUG "%s: free irq %d\n", __func__, hc->irq);
4332 free_irq(hc->irq, hc);
4336 if (debug & DEBUG_HFCMULTI_INIT)
4337 printk(KERN_DEBUG "%s: done (err=%d)\n", __func__, err);
4342 * find pci device and set it up
4346 setup_pci(struct hfc_multi *hc, struct pci_dev *pdev,
4347 const struct pci_device_id *ent)
4349 struct hm_map *m = (struct hm_map *)ent->driver_data;
4352 "HFC-multi: card manufacturer: '%s' card name: '%s' clock: %s\n",
4353 m->vendor_name, m->card_name, m->clock2 ? "double" : "normal");
4357 test_and_set_bit(HFC_CHIP_CLOCK2, &hc->chip);
4359 if (ent->vendor == PCI_VENDOR_ID_DIGIUM &&
4360 ent->device == PCI_DEVICE_ID_DIGIUM_HFC4S) {
4361 test_and_set_bit(HFC_CHIP_B410P, &hc->chip);
4362 test_and_set_bit(HFC_CHIP_PCM_MASTER, &hc->chip);
4363 test_and_clear_bit(HFC_CHIP_PCM_SLAVE, &hc->chip);
4367 if (hc->pci_dev->irq <= 0) {
4368 printk(KERN_WARNING "HFC-multi: No IRQ for PCI card found.\n");
4371 if (pci_enable_device(hc->pci_dev)) {
4372 printk(KERN_WARNING "HFC-multi: Error enabling PCI card.\n");
4376 hc->ledstate = 0xAFFEAFFE;
4377 hc->opticalsupport = m->opticalsupport;
4380 hc->pci_membase = NULL;
4381 hc->plx_membase = NULL;
4383 /* set memory access methods */
4384 if (m->io_mode) /* use mode from card config */
4385 hc->io_mode = m->io_mode;
4386 switch (hc->io_mode) {
4387 case HFC_IO_MODE_PLXSD:
4388 test_and_set_bit(HFC_CHIP_PLXSD, &hc->chip);
4389 hc->slots = 128; /* required */
4390 hc->HFC_outb = HFC_outb_pcimem;
4391 hc->HFC_inb = HFC_inb_pcimem;
4392 hc->HFC_inw = HFC_inw_pcimem;
4393 hc->HFC_wait = HFC_wait_pcimem;
4394 hc->read_fifo = read_fifo_pcimem;
4395 hc->write_fifo = write_fifo_pcimem;
4396 hc->plx_origmembase = hc->pci_dev->resource[0].start;
4397 /* MEMBASE 1 is PLX PCI Bridge */
4399 if (!hc->plx_origmembase) {
4401 "HFC-multi: No IO-Memory for PCI PLX bridge found\n");
4402 pci_disable_device(hc->pci_dev);
4406 hc->plx_membase = ioremap(hc->plx_origmembase, 0x80);
4407 if (!hc->plx_membase) {
4409 "HFC-multi: failed to remap plx address space. "
4410 "(internal error)\n");
4411 pci_disable_device(hc->pci_dev);
4415 "HFC-multi: plx_membase:%#lx plx_origmembase:%#lx\n",
4416 (u_long)hc->plx_membase, hc->plx_origmembase);
4418 hc->pci_origmembase = hc->pci_dev->resource[2].start;
4419 /* MEMBASE 1 is PLX PCI Bridge */
4420 if (!hc->pci_origmembase) {
4422 "HFC-multi: No IO-Memory for PCI card found\n");
4423 pci_disable_device(hc->pci_dev);
4427 hc->pci_membase = ioremap(hc->pci_origmembase, 0x400);
4428 if (!hc->pci_membase) {
4429 printk(KERN_WARNING "HFC-multi: failed to remap io "
4430 "address space. (internal error)\n");
4431 pci_disable_device(hc->pci_dev);
4436 "card %d: defined at MEMBASE %#lx (%#lx) IRQ %d HZ %d "
4438 hc->id, (u_long)hc->pci_membase, hc->pci_origmembase,
4439 hc->pci_dev->irq, HZ, hc->leds);
4440 pci_write_config_word(hc->pci_dev, PCI_COMMAND, PCI_ENA_MEMIO);
4442 case HFC_IO_MODE_PCIMEM:
4443 hc->HFC_outb = HFC_outb_pcimem;
4444 hc->HFC_inb = HFC_inb_pcimem;
4445 hc->HFC_inw = HFC_inw_pcimem;
4446 hc->HFC_wait = HFC_wait_pcimem;
4447 hc->read_fifo = read_fifo_pcimem;
4448 hc->write_fifo = write_fifo_pcimem;
4449 hc->pci_origmembase = hc->pci_dev->resource[1].start;
4450 if (!hc->pci_origmembase) {
4452 "HFC-multi: No IO-Memory for PCI card found\n");
4453 pci_disable_device(hc->pci_dev);
4457 hc->pci_membase = ioremap(hc->pci_origmembase, 256);
4458 if (!hc->pci_membase) {
4460 "HFC-multi: failed to remap io address space. "
4461 "(internal error)\n");
4462 pci_disable_device(hc->pci_dev);
4465 printk(KERN_INFO "card %d: defined at MEMBASE %#lx (%#lx) IRQ "
4466 "%d HZ %d leds-type %d\n", hc->id, (u_long)hc->pci_membase,
4467 hc->pci_origmembase, hc->pci_dev->irq, HZ, hc->leds);
4468 pci_write_config_word(hc->pci_dev, PCI_COMMAND, PCI_ENA_MEMIO);
4470 case HFC_IO_MODE_REGIO:
4471 hc->HFC_outb = HFC_outb_regio;
4472 hc->HFC_inb = HFC_inb_regio;
4473 hc->HFC_inw = HFC_inw_regio;
4474 hc->HFC_wait = HFC_wait_regio;
4475 hc->read_fifo = read_fifo_regio;
4476 hc->write_fifo = write_fifo_regio;
4477 hc->pci_iobase = (u_int) hc->pci_dev->resource[0].start;
4478 if (!hc->pci_iobase) {
4480 "HFC-multi: No IO for PCI card found\n");
4481 pci_disable_device(hc->pci_dev);
4485 if (!request_region(hc->pci_iobase, 8, "hfcmulti")) {
4486 printk(KERN_WARNING "HFC-multi: failed to request "
4487 "address space at 0x%08lx (internal error)\n",
4489 pci_disable_device(hc->pci_dev);
4494 "%s %s: defined at IOBASE %#x IRQ %d HZ %d leds-type %d\n",
4495 m->vendor_name, m->card_name, (u_int) hc->pci_iobase,
4496 hc->pci_dev->irq, HZ, hc->leds);
4497 pci_write_config_word(hc->pci_dev, PCI_COMMAND, PCI_ENA_REGIO);
4500 printk(KERN_WARNING "HFC-multi: Invalid IO mode.\n");
4501 pci_disable_device(hc->pci_dev);
4505 pci_set_drvdata(hc->pci_dev, hc);
4507 /* At this point the needed PCI config is done */
4508 /* fifos are still not enabled */
4518 release_port(struct hfc_multi *hc, struct dchannel *dch)
4522 struct bchannel *pb;
4525 pt = hc->chan[ci].port;
4527 if (debug & DEBUG_HFCMULTI_INIT)
4528 printk(KERN_DEBUG "%s: entered for port %d\n",
4531 if (pt >= hc->ports) {
4532 printk(KERN_WARNING "%s: ERROR port out of range (%d).\n",
4537 if (debug & DEBUG_HFCMULTI_INIT)
4538 printk(KERN_DEBUG "%s: releasing port=%d\n",
4541 if (dch->dev.D.protocol == ISDN_P_TE_S0)
4542 l1_event(dch->l1, CLOSE_CHANNEL);
4544 hc->chan[ci].dch = NULL;
4546 if (hc->created[pt]) {
4547 hc->created[pt] = 0;
4548 mISDN_unregister_device(&dch->dev);
4551 spin_lock_irqsave(&hc->lock, flags);
4553 if (dch->timer.function) {
4554 del_timer(&dch->timer);
4555 dch->timer.function = NULL;
4558 if (hc->ctype == HFC_TYPE_E1) { /* E1 */
4560 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
4561 hc->syncronized = 0;
4562 plxsd_checksync(hc, 1);
4565 for (i = 0; i <= 31; i++) {
4566 if (!((1 << i) & hc->bmask[pt])) /* skip unused chan */
4568 if (hc->chan[i].bch) {
4569 if (debug & DEBUG_HFCMULTI_INIT)
4571 "%s: free port %d channel %d\n",
4572 __func__, hc->chan[i].port + 1, i);
4573 pb = hc->chan[i].bch;
4574 hc->chan[i].bch = NULL;
4575 spin_unlock_irqrestore(&hc->lock, flags);
4576 mISDN_freebchannel(pb);
4578 kfree(hc->chan[i].coeff);
4579 spin_lock_irqsave(&hc->lock, flags);
4584 if (test_bit(HFC_CHIP_PLXSD, &hc->chip)) {
4586 ~(1 << hc->chan[ci].port);
4587 plxsd_checksync(hc, 1);
4590 if (hc->chan[ci - 2].bch) {
4591 if (debug & DEBUG_HFCMULTI_INIT)
4593 "%s: free port %d channel %d\n",
4594 __func__, hc->chan[ci - 2].port + 1,
4596 pb = hc->chan[ci - 2].bch;
4597 hc->chan[ci - 2].bch = NULL;
4598 spin_unlock_irqrestore(&hc->lock, flags);
4599 mISDN_freebchannel(pb);
4601 kfree(hc->chan[ci - 2].coeff);
4602 spin_lock_irqsave(&hc->lock, flags);
4604 if (hc->chan[ci - 1].bch) {
4605 if (debug & DEBUG_HFCMULTI_INIT)
4607 "%s: free port %d channel %d\n",
4608 __func__, hc->chan[ci - 1].port + 1,
4610 pb = hc->chan[ci - 1].bch;
4611 hc->chan[ci - 1].bch = NULL;
4612 spin_unlock_irqrestore(&hc->lock, flags);
4613 mISDN_freebchannel(pb);
4615 kfree(hc->chan[ci - 1].coeff);
4616 spin_lock_irqsave(&hc->lock, flags);
4620 spin_unlock_irqrestore(&hc->lock, flags);
4622 if (debug & DEBUG_HFCMULTI_INIT)
4623 printk(KERN_DEBUG "%s: free port %d channel D(%d)\n", __func__,
4625 mISDN_freedchannel(dch);
4628 if (debug & DEBUG_HFCMULTI_INIT)
4629 printk(KERN_DEBUG "%s: done!\n", __func__);
4633 release_card(struct hfc_multi *hc)
4638 if (debug & DEBUG_HFCMULTI_INIT)
4639 printk(KERN_DEBUG "%s: release card (%d) entered\n",
4642 /* unregister clock source */
4644 mISDN_unregister_clock(hc->iclock);
4646 /* disable and free irq */
4647 spin_lock_irqsave(&hc->lock, flags);
4649 spin_unlock_irqrestore(&hc->lock, flags);
4652 if (debug & DEBUG_HFCMULTI_INIT)
4653 printk(KERN_DEBUG "%s: free irq %d (hc=%p)\n",
4654 __func__, hc->irq, hc);
4655 free_irq(hc->irq, hc);
4660 /* disable D-channels & B-channels */
4661 if (debug & DEBUG_HFCMULTI_INIT)
4662 printk(KERN_DEBUG "%s: disable all channels (d and b)\n",
4664 for (ch = 0; ch <= 31; ch++) {
4665 if (hc->chan[ch].dch)
4666 release_port(hc, hc->chan[ch].dch);
4673 /* release hardware */
4674 release_io_hfcmulti(hc);
4676 if (debug & DEBUG_HFCMULTI_INIT)
4677 printk(KERN_DEBUG "%s: remove instance from list\n",
4679 list_del(&hc->list);
4681 if (debug & DEBUG_HFCMULTI_INIT)
4682 printk(KERN_DEBUG "%s: delete instance\n", __func__);
4683 if (hc == syncmaster)
4686 if (debug & DEBUG_HFCMULTI_INIT)
4687 printk(KERN_DEBUG "%s: card successfully removed\n",
4692 init_e1_port_hw(struct hfc_multi *hc, struct hm_map *m)
4694 /* set optical line type */
4695 if (port[Port_cnt] & 0x001) {
4696 if (!m->opticalsupport) {
4698 "This board has no optical "
4701 if (debug & DEBUG_HFCMULTI_INIT)
4703 "%s: PORT set optical "
4704 "interfacs: card(%d) "
4708 test_and_set_bit(HFC_CFG_OPTICAL,
4709 &hc->chan[hc->dnum[0]].cfg);
4712 /* set LOS report */
4713 if (port[Port_cnt] & 0x004) {
4714 if (debug & DEBUG_HFCMULTI_INIT)
4715 printk(KERN_DEBUG "%s: PORT set "
4716 "LOS report: card(%d) port(%d)\n",
4717 __func__, HFC_cnt + 1, 1);
4718 test_and_set_bit(HFC_CFG_REPORT_LOS,
4719 &hc->chan[hc->dnum[0]].cfg);
4721 /* set AIS report */
4722 if (port[Port_cnt] & 0x008) {
4723 if (debug & DEBUG_HFCMULTI_INIT)
4724 printk(KERN_DEBUG "%s: PORT set "
4725 "AIS report: card(%d) port(%d)\n",
4726 __func__, HFC_cnt + 1, 1);
4727 test_and_set_bit(HFC_CFG_REPORT_AIS,
4728 &hc->chan[hc->dnum[0]].cfg);
4730 /* set SLIP report */
4731 if (port[Port_cnt] & 0x010) {
4732 if (debug & DEBUG_HFCMULTI_INIT)
4734 "%s: PORT set SLIP report: "
4735 "card(%d) port(%d)\n",
4736 __func__, HFC_cnt + 1, 1);
4737 test_and_set_bit(HFC_CFG_REPORT_SLIP,
4738 &hc->chan[hc->dnum[0]].cfg);
4740 /* set RDI report */
4741 if (port[Port_cnt] & 0x020) {
4742 if (debug & DEBUG_HFCMULTI_INIT)
4744 "%s: PORT set RDI report: "
4745 "card(%d) port(%d)\n",
4746 __func__, HFC_cnt + 1, 1);
4747 test_and_set_bit(HFC_CFG_REPORT_RDI,
4748 &hc->chan[hc->dnum[0]].cfg);
4750 /* set CRC-4 Mode */
4751 if (!(port[Port_cnt] & 0x100)) {
4752 if (debug & DEBUG_HFCMULTI_INIT)
4753 printk(KERN_DEBUG "%s: PORT turn on CRC4 report:"
4754 " card(%d) port(%d)\n",
4755 __func__, HFC_cnt + 1, 1);
4756 test_and_set_bit(HFC_CFG_CRC4,
4757 &hc->chan[hc->dnum[0]].cfg);
4759 if (debug & DEBUG_HFCMULTI_INIT)
4760 printk(KERN_DEBUG "%s: PORT turn off CRC4"
4761 " report: card(%d) port(%d)\n",
4762 __func__, HFC_cnt + 1, 1);
4764 /* set forced clock */
4765 if (port[Port_cnt] & 0x0200) {
4766 if (debug & DEBUG_HFCMULTI_INIT)
4767 printk(KERN_DEBUG "%s: PORT force getting clock from "
4768 "E1: card(%d) port(%d)\n",
4769 __func__, HFC_cnt + 1, 1);
4770 test_and_set_bit(HFC_CHIP_E1CLOCK_GET, &hc->chip);
4772 if (port[Port_cnt] & 0x0400) {
4773 if (debug & DEBUG_HFCMULTI_INIT)
4774 printk(KERN_DEBUG "%s: PORT force putting clock to "
4775 "E1: card(%d) port(%d)\n",
4776 __func__, HFC_cnt + 1, 1);
4777 test_and_set_bit(HFC_CHIP_E1CLOCK_PUT, &hc->chip);
4780 if (port[Port_cnt] & 0x0800) {
4781 if (debug & DEBUG_HFCMULTI_INIT)
4782 printk(KERN_DEBUG "%s: PORT disable JATT PLL on "
4783 "E1: card(%d) port(%d)\n",
4784 __func__, HFC_cnt + 1, 1);
4785 test_and_set_bit(HFC_CHIP_RX_SYNC, &hc->chip);
4787 /* set elastic jitter buffer */
4788 if (port[Port_cnt] & 0x3000) {
4789 hc->chan[hc->dnum[0]].jitter = (port[Port_cnt]>>12) & 0x3;
4790 if (debug & DEBUG_HFCMULTI_INIT)
4792 "%s: PORT set elastic "
4793 "buffer to %d: card(%d) port(%d)\n",
4794 __func__, hc->chan[hc->dnum[0]].jitter,
4797 hc->chan[hc->dnum[0]].jitter = 2; /* default */
4801 init_e1_port(struct hfc_multi *hc, struct hm_map *m, int pt)
4803 struct dchannel *dch;
4804 struct bchannel *bch;
4806 char name[MISDN_MAX_IDLEN];
4809 dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
4813 mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, ph_state_change);
4815 dch->dev.Dprotocols = (1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1);
4816 dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
4817 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
4818 dch->dev.D.send = handle_dmsg;
4819 dch->dev.D.ctrl = hfcm_dctrl;
4820 dch->slot = hc->dnum[pt];
4821 hc->chan[hc->dnum[pt]].dch = dch;
4822 hc->chan[hc->dnum[pt]].port = pt;
4823 hc->chan[hc->dnum[pt]].nt_timer = -1;
4824 for (ch = 1; ch <= 31; ch++) {
4825 if (!((1 << ch) & hc->bmask[pt])) /* skip unused channel */
4827 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
4829 printk(KERN_ERR "%s: no memory for bchannel\n",
4834 hc->chan[ch].coeff = kzalloc(512, GFP_KERNEL);
4835 if (!hc->chan[ch].coeff) {
4836 printk(KERN_ERR "%s: no memory for coeffs\n",
4845 mISDN_initbchannel(bch, MAX_DATA_MEM, poll >> 1);
4847 bch->ch.send = handle_bmsg;
4848 bch->ch.ctrl = hfcm_bctrl;
4850 list_add(&bch->ch.list, &dch->dev.bchannels);
4851 hc->chan[ch].bch = bch;
4852 hc->chan[ch].port = pt;
4853 set_channelmap(bch->nr, dch->dev.channelmap);
4856 dch->dev.nrbchan = bcount;
4858 init_e1_port_hw(hc, m);
4860 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-e1.%d-%d",
4863 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-e1.%d", HFC_cnt + 1);
4864 ret = mISDN_register_device(&dch->dev, &hc->pci_dev->dev, name);
4867 hc->created[pt] = 1;
4870 release_port(hc, dch);
4875 init_multi_port(struct hfc_multi *hc, int pt)
4877 struct dchannel *dch;
4878 struct bchannel *bch;
4880 char name[MISDN_MAX_IDLEN];
4882 dch = kzalloc(sizeof(struct dchannel), GFP_KERNEL);
4886 mISDN_initdchannel(dch, MAX_DFRAME_LEN_L1, ph_state_change);
4888 dch->dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
4889 dch->dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
4890 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
4891 dch->dev.D.send = handle_dmsg;
4892 dch->dev.D.ctrl = hfcm_dctrl;
4893 dch->dev.nrbchan = 2;
4896 hc->chan[i + 2].dch = dch;
4897 hc->chan[i + 2].port = pt;
4898 hc->chan[i + 2].nt_timer = -1;
4899 for (ch = 0; ch < dch->dev.nrbchan; ch++) {
4900 bch = kzalloc(sizeof(struct bchannel), GFP_KERNEL);
4902 printk(KERN_ERR "%s: no memory for bchannel\n",
4907 hc->chan[i + ch].coeff = kzalloc(512, GFP_KERNEL);
4908 if (!hc->chan[i + ch].coeff) {
4909 printk(KERN_ERR "%s: no memory for coeffs\n",
4918 mISDN_initbchannel(bch, MAX_DATA_MEM, poll >> 1);
4920 bch->ch.send = handle_bmsg;
4921 bch->ch.ctrl = hfcm_bctrl;
4922 bch->ch.nr = ch + 1;
4923 list_add(&bch->ch.list, &dch->dev.bchannels);
4924 hc->chan[i + ch].bch = bch;
4925 hc->chan[i + ch].port = pt;
4926 set_channelmap(bch->nr, dch->dev.channelmap);
4928 /* set master clock */
4929 if (port[Port_cnt] & 0x001) {
4930 if (debug & DEBUG_HFCMULTI_INIT)
4932 "%s: PROTOCOL set master clock: "
4933 "card(%d) port(%d)\n",
4934 __func__, HFC_cnt + 1, pt + 1);
4935 if (dch->dev.D.protocol != ISDN_P_TE_S0) {
4936 printk(KERN_ERR "Error: Master clock "
4937 "for port(%d) of card(%d) is only"
4938 " possible with TE-mode\n",
4939 pt + 1, HFC_cnt + 1);
4943 if (hc->masterclk >= 0) {
4944 printk(KERN_ERR "Error: Master clock "
4945 "for port(%d) of card(%d) already "
4946 "defined for port(%d)\n",
4947 pt + 1, HFC_cnt + 1, hc->masterclk + 1);
4953 /* set transmitter line to non capacitive */
4954 if (port[Port_cnt] & 0x002) {
4955 if (debug & DEBUG_HFCMULTI_INIT)
4957 "%s: PROTOCOL set non capacitive "
4958 "transmitter: card(%d) port(%d)\n",
4959 __func__, HFC_cnt + 1, pt + 1);
4960 test_and_set_bit(HFC_CFG_NONCAP_TX,
4961 &hc->chan[i + 2].cfg);
4963 /* disable E-channel */
4964 if (port[Port_cnt] & 0x004) {
4965 if (debug & DEBUG_HFCMULTI_INIT)
4967 "%s: PROTOCOL disable E-channel: "
4968 "card(%d) port(%d)\n",
4969 __func__, HFC_cnt + 1, pt + 1);
4970 test_and_set_bit(HFC_CFG_DIS_ECHANNEL,
4971 &hc->chan[i + 2].cfg);
4973 if (hc->ctype == HFC_TYPE_XHFC) {
4974 snprintf(name, MISDN_MAX_IDLEN - 1, "xhfc.%d-%d",
4975 HFC_cnt + 1, pt + 1);
4976 ret = mISDN_register_device(&dch->dev, NULL, name);
4978 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-%ds.%d-%d",
4979 hc->ctype, HFC_cnt + 1, pt + 1);
4980 ret = mISDN_register_device(&dch->dev, &hc->pci_dev->dev, name);
4984 hc->created[pt] = 1;
4987 release_port(hc, dch);
4992 hfcmulti_init(struct hm_map *m, struct pci_dev *pdev,
4993 const struct pci_device_id *ent)
4997 struct hfc_multi *hc;
4999 u_char dips = 0, pmj = 0; /* dip settings, port mode Jumpers */
5003 if (HFC_cnt >= MAX_CARDS) {
5004 printk(KERN_ERR "too many cards (max=%d).\n",
5008 if ((type[HFC_cnt] & 0xff) && (type[HFC_cnt] & 0xff) != m->type) {
5009 printk(KERN_WARNING "HFC-MULTI: Card '%s:%s' type %d found but "
5010 "type[%d] %d was supplied as module parameter\n",
5011 m->vendor_name, m->card_name, m->type, HFC_cnt,
5012 type[HFC_cnt] & 0xff);
5013 printk(KERN_WARNING "HFC-MULTI: Load module without parameters "
5014 "first, to see cards and their types.");
5017 if (debug & DEBUG_HFCMULTI_INIT)
5018 printk(KERN_DEBUG "%s: Registering %s:%s chip type %d (0x%x)\n",
5019 __func__, m->vendor_name, m->card_name, m->type,
5022 /* allocate card+fifo structure */
5023 hc = kzalloc(sizeof(struct hfc_multi), GFP_KERNEL);
5025 printk(KERN_ERR "No kmem for HFC-Multi card\n");
5028 spin_lock_init(&hc->lock);
5030 hc->ctype = m->type;
5031 hc->ports = m->ports;
5033 hc->pcm = pcm[HFC_cnt];
5034 hc->io_mode = iomode[HFC_cnt];
5035 if (hc->ctype == HFC_TYPE_E1 && dmask[E1_cnt]) {
5039 for (ch = 0; ch <= 31; ch++) {
5040 if (!((1 << ch) & dmask[E1_cnt]))
5043 hc->bmask[pt] = bmask[bmask_cnt++];
5044 if ((maskcheck & hc->bmask[pt])
5045 || (dmask[E1_cnt] & hc->bmask[pt])) {
5047 "HFC-E1 #%d has overlapping B-channels on fragment #%d\n",
5052 maskcheck |= hc->bmask[pt];
5054 "HFC-E1 #%d uses D-channel on slot %d and a B-channel map of 0x%08x\n",
5055 E1_cnt + 1, ch, hc->bmask[pt]);
5060 if (hc->ctype == HFC_TYPE_E1 && !dmask[E1_cnt]) {
5061 /* default card layout */
5063 hc->bmask[0] = 0xfffefffe;
5067 /* set chip specific features */
5069 if (type[HFC_cnt] & 0x100) {
5070 test_and_set_bit(HFC_CHIP_ULAW, &hc->chip);
5071 hc->silence = 0xff; /* ulaw silence */
5073 hc->silence = 0x2a; /* alaw silence */
5074 if ((poll >> 1) > sizeof(hc->silence_data)) {
5075 printk(KERN_ERR "HFCMULTI error: silence_data too small, "
5080 for (i = 0; i < (poll >> 1); i++)
5081 hc->silence_data[i] = hc->silence;
5083 if (hc->ctype != HFC_TYPE_XHFC) {
5084 if (!(type[HFC_cnt] & 0x200))
5085 test_and_set_bit(HFC_CHIP_DTMF, &hc->chip);
5086 test_and_set_bit(HFC_CHIP_CONF, &hc->chip);
5089 if (type[HFC_cnt] & 0x800)
5090 test_and_set_bit(HFC_CHIP_PCM_SLAVE, &hc->chip);
5091 if (type[HFC_cnt] & 0x1000) {
5092 test_and_set_bit(HFC_CHIP_PCM_MASTER, &hc->chip);
5093 test_and_clear_bit(HFC_CHIP_PCM_SLAVE, &hc->chip);
5095 if (type[HFC_cnt] & 0x4000)
5096 test_and_set_bit(HFC_CHIP_EXRAM_128, &hc->chip);
5097 if (type[HFC_cnt] & 0x8000)
5098 test_and_set_bit(HFC_CHIP_EXRAM_512, &hc->chip);
5100 if (type[HFC_cnt] & 0x10000)
5102 if (type[HFC_cnt] & 0x20000)
5104 if (type[HFC_cnt] & 0x80000) {
5105 test_and_set_bit(HFC_CHIP_WATCHDOG, &hc->chip);
5107 hc->wdbyte = V_GPIO_OUT2;
5108 printk(KERN_NOTICE "Watchdog enabled\n");
5112 /* setup pci, hc->slots may change due to PLXSD */
5113 ret_err = setup_pci(hc, pdev, ent);
5115 #ifdef CONFIG_MISDN_HFCMULTI_8xx
5116 ret_err = setup_embedded(hc, m);
5119 printk(KERN_WARNING "Embedded IO Mode not selected\n");
5124 if (hc == syncmaster)
5130 hc->HFC_outb_nodebug = hc->HFC_outb;
5131 hc->HFC_inb_nodebug = hc->HFC_inb;
5132 hc->HFC_inw_nodebug = hc->HFC_inw;
5133 hc->HFC_wait_nodebug = hc->HFC_wait;
5134 #ifdef HFC_REGISTER_DEBUG
5135 hc->HFC_outb = HFC_outb_debug;
5136 hc->HFC_inb = HFC_inb_debug;
5137 hc->HFC_inw = HFC_inw_debug;
5138 hc->HFC_wait = HFC_wait_debug;
5140 /* create channels */
5141 for (pt = 0; pt < hc->ports; pt++) {
5142 if (Port_cnt >= MAX_PORTS) {
5143 printk(KERN_ERR "too many ports (max=%d).\n",
5148 if (hc->ctype == HFC_TYPE_E1)
5149 ret_err = init_e1_port(hc, m, pt);
5151 ret_err = init_multi_port(hc, pt);
5152 if (debug & DEBUG_HFCMULTI_INIT)
5154 "%s: Registering D-channel, card(%d) port(%d) "
5156 __func__, HFC_cnt + 1, pt + 1, ret_err);
5159 while (pt) { /* release already registered ports */
5161 if (hc->ctype == HFC_TYPE_E1)
5163 hc->chan[hc->dnum[pt]].dch);
5166 hc->chan[(pt << 2) + 2].dch);
5170 if (hc->ctype != HFC_TYPE_E1)
5171 Port_cnt++; /* for each S0 port */
5173 if (hc->ctype == HFC_TYPE_E1) {
5174 Port_cnt++; /* for each E1 port */
5179 switch (m->dip_type) {
5182 * Get DIP setting for beroNet 1S/2S/4S cards
5183 * DIP Setting: (collect GPIO 13/14/15 (R_GPIO_IN1) +
5184 * GPI 19/23 (R_GPI_IN2))
5186 dips = ((~HFC_inb(hc, R_GPIO_IN1) & 0xE0) >> 5) |
5187 ((~HFC_inb(hc, R_GPI_IN2) & 0x80) >> 3) |
5188 (~HFC_inb(hc, R_GPI_IN2) & 0x08);
5190 /* Port mode (TE/NT) jumpers */
5191 pmj = ((HFC_inb(hc, R_GPI_IN3) >> 4) & 0xf);
5193 if (test_bit(HFC_CHIP_B410P, &hc->chip))
5196 printk(KERN_INFO "%s: %s DIPs(0x%x) jumpers(0x%x)\n",
5197 m->vendor_name, m->card_name, dips, pmj);
5201 * Get DIP Setting for beroNet 8S0+ cards
5202 * Enable PCI auxbridge function
5204 HFC_outb(hc, R_BRG_PCM_CFG, 1 | V_PCM_CLK);
5205 /* prepare access to auxport */
5206 outw(0x4000, hc->pci_iobase + 4);
5208 * some dummy reads are required to
5209 * read valid DIP switch data
5211 dips = inb(hc->pci_iobase);
5212 dips = inb(hc->pci_iobase);
5213 dips = inb(hc->pci_iobase);
5214 dips = ~inb(hc->pci_iobase) & 0x3F;
5215 outw(0x0, hc->pci_iobase + 4);
5216 /* disable PCI auxbridge function */
5217 HFC_outb(hc, R_BRG_PCM_CFG, V_PCM_CLK);
5218 printk(KERN_INFO "%s: %s DIPs(0x%x)\n",
5219 m->vendor_name, m->card_name, dips);
5223 * get DIP Setting for beroNet E1 cards
5224 * DIP Setting: collect GPI 4/5/6/7 (R_GPI_IN0)
5226 dips = (~HFC_inb(hc, R_GPI_IN0) & 0xF0) >> 4;
5227 printk(KERN_INFO "%s: %s DIPs(0x%x)\n",
5228 m->vendor_name, m->card_name, dips);
5233 spin_lock_irqsave(&HFClock, flags);
5234 list_add_tail(&hc->list, &HFClist);
5235 spin_unlock_irqrestore(&HFClock, flags);
5237 /* use as clock source */
5238 if (clock == HFC_cnt + 1)
5239 hc->iclock = mISDN_register_clock("HFCMulti", 0, clockctl, hc);
5241 /* initialize hardware */
5242 hc->irq = (m->irq) ? : hc->pci_dev->irq;
5243 ret_err = init_card(hc);
5245 printk(KERN_ERR "init card returns %d\n", ret_err);
5250 /* start IRQ and return */
5251 spin_lock_irqsave(&hc->lock, flags);
5253 spin_unlock_irqrestore(&hc->lock, flags);
5257 release_io_hfcmulti(hc);
5258 if (hc == syncmaster)
5264 static void hfc_remove_pci(struct pci_dev *pdev)
5266 struct hfc_multi *card = pci_get_drvdata(pdev);
5270 printk(KERN_INFO "removing hfc_multi card vendor:%x "
5271 "device:%x subvendor:%x subdevice:%x\n",
5272 pdev->vendor, pdev->device,
5273 pdev->subsystem_vendor, pdev->subsystem_device);
5276 spin_lock_irqsave(&HFClock, flags);
5278 spin_unlock_irqrestore(&HFClock, flags);
5281 printk(KERN_DEBUG "%s: drvdata already removed\n",
5286 #define VENDOR_CCD "Cologne Chip AG"
5287 #define VENDOR_BN "beroNet GmbH"
5288 #define VENDOR_DIG "Digium Inc."
5289 #define VENDOR_JH "Junghanns.NET GmbH"
5290 #define VENDOR_PRIM "PrimuX"
5292 static const struct hm_map hfcm_map[] = {
5293 /*0*/ {VENDOR_BN, "HFC-1S Card (mini PCI)", 4, 1, 1, 3, 0, DIP_4S, 0, 0},
5294 /*1*/ {VENDOR_BN, "HFC-2S Card", 4, 2, 1, 3, 0, DIP_4S, 0, 0},
5295 /*2*/ {VENDOR_BN, "HFC-2S Card (mini PCI)", 4, 2, 1, 3, 0, DIP_4S, 0, 0},
5296 /*3*/ {VENDOR_BN, "HFC-4S Card", 4, 4, 1, 2, 0, DIP_4S, 0, 0},
5297 /*4*/ {VENDOR_BN, "HFC-4S Card (mini PCI)", 4, 4, 1, 2, 0, 0, 0, 0},
5298 /*5*/ {VENDOR_CCD, "HFC-4S Eval (old)", 4, 4, 0, 0, 0, 0, 0, 0},
5299 /*6*/ {VENDOR_CCD, "HFC-4S IOB4ST", 4, 4, 1, 2, 0, DIP_4S, 0, 0},
5300 /*7*/ {VENDOR_CCD, "HFC-4S", 4, 4, 1, 2, 0, 0, 0, 0},
5301 /*8*/ {VENDOR_DIG, "HFC-4S Card", 4, 4, 0, 2, 0, 0, HFC_IO_MODE_REGIO, 0},
5302 /*9*/ {VENDOR_CCD, "HFC-4S Swyx 4xS0 SX2 QuadBri", 4, 4, 1, 2, 0, 0, 0, 0},
5303 /*10*/ {VENDOR_JH, "HFC-4S (junghanns 2.0)", 4, 4, 1, 2, 0, 0, 0, 0},
5304 /*11*/ {VENDOR_PRIM, "HFC-2S Primux Card", 4, 2, 0, 0, 0, 0, 0, 0},
5306 /*12*/ {VENDOR_BN, "HFC-8S Card", 8, 8, 1, 0, 0, 0, 0, 0},
5307 /*13*/ {VENDOR_BN, "HFC-8S Card (+)", 8, 8, 1, 8, 0, DIP_8S,
5308 HFC_IO_MODE_REGIO, 0},
5309 /*14*/ {VENDOR_CCD, "HFC-8S Eval (old)", 8, 8, 0, 0, 0, 0, 0, 0},
5310 /*15*/ {VENDOR_CCD, "HFC-8S IOB4ST Recording", 8, 8, 1, 0, 0, 0, 0, 0},
5312 /*16*/ {VENDOR_CCD, "HFC-8S IOB8ST", 8, 8, 1, 0, 0, 0, 0, 0},
5313 /*17*/ {VENDOR_CCD, "HFC-8S", 8, 8, 1, 0, 0, 0, 0, 0},
5314 /*18*/ {VENDOR_CCD, "HFC-8S", 8, 8, 1, 0, 0, 0, 0, 0},
5316 /*19*/ {VENDOR_BN, "HFC-E1 Card", 1, 1, 0, 1, 0, DIP_E1, 0, 0},
5317 /*20*/ {VENDOR_BN, "HFC-E1 Card (mini PCI)", 1, 1, 0, 1, 0, 0, 0, 0},
5318 /*21*/ {VENDOR_BN, "HFC-E1+ Card (Dual)", 1, 1, 0, 1, 0, DIP_E1, 0, 0},
5319 /*22*/ {VENDOR_BN, "HFC-E1 Card (Dual)", 1, 1, 0, 1, 0, DIP_E1, 0, 0},
5321 /*23*/ {VENDOR_CCD, "HFC-E1 Eval (old)", 1, 1, 0, 0, 0, 0, 0, 0},
5322 /*24*/ {VENDOR_CCD, "HFC-E1 IOB1E1", 1, 1, 0, 1, 0, 0, 0, 0},
5323 /*25*/ {VENDOR_CCD, "HFC-E1", 1, 1, 0, 1, 0, 0, 0, 0},
5325 /*26*/ {VENDOR_CCD, "HFC-4S Speech Design", 4, 4, 0, 0, 0, 0,
5326 HFC_IO_MODE_PLXSD, 0},
5327 /*27*/ {VENDOR_CCD, "HFC-E1 Speech Design", 1, 1, 0, 0, 0, 0,
5328 HFC_IO_MODE_PLXSD, 0},
5329 /*28*/ {VENDOR_CCD, "HFC-4S OpenVox", 4, 4, 1, 0, 0, 0, 0, 0},
5330 /*29*/ {VENDOR_CCD, "HFC-2S OpenVox", 4, 2, 1, 0, 0, 0, 0, 0},
5331 /*30*/ {VENDOR_CCD, "HFC-8S OpenVox", 8, 8, 1, 0, 0, 0, 0, 0},
5332 /*31*/ {VENDOR_CCD, "XHFC-4S Speech Design", 5, 4, 0, 0, 0, 0,
5333 HFC_IO_MODE_EMBSD, XHFC_IRQ},
5334 /*32*/ {VENDOR_JH, "HFC-8S (junghanns)", 8, 8, 1, 0, 0, 0, 0, 0},
5335 /*33*/ {VENDOR_BN, "HFC-2S Beronet Card PCIe", 4, 2, 1, 3, 0, DIP_4S, 0, 0},
5336 /*34*/ {VENDOR_BN, "HFC-4S Beronet Card PCIe", 4, 4, 1, 2, 0, DIP_4S, 0, 0},
5340 #define H(x) ((unsigned long)&hfcm_map[x])
5341 static const struct pci_device_id hfmultipci_ids[] = {
5343 /* Cards with HFC-4S Chip */
5344 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5345 PCI_SUBDEVICE_ID_CCD_BN1SM, 0, 0, H(0)}, /* BN1S mini PCI */
5346 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5347 PCI_SUBDEVICE_ID_CCD_BN2S, 0, 0, H(1)}, /* BN2S */
5348 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5349 PCI_SUBDEVICE_ID_CCD_BN2SM, 0, 0, H(2)}, /* BN2S mini PCI */
5350 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5351 PCI_SUBDEVICE_ID_CCD_BN4S, 0, 0, H(3)}, /* BN4S */
5352 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5353 PCI_SUBDEVICE_ID_CCD_BN4SM, 0, 0, H(4)}, /* BN4S mini PCI */
5354 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5355 PCI_DEVICE_ID_CCD_HFC4S, 0, 0, H(5)}, /* Old Eval */
5356 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5357 PCI_SUBDEVICE_ID_CCD_IOB4ST, 0, 0, H(6)}, /* IOB4ST */
5358 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5359 PCI_SUBDEVICE_ID_CCD_HFC4S, 0, 0, H(7)}, /* 4S */
5360 { PCI_VENDOR_ID_DIGIUM, PCI_DEVICE_ID_DIGIUM_HFC4S,
5361 PCI_VENDOR_ID_DIGIUM, PCI_DEVICE_ID_DIGIUM_HFC4S, 0, 0, H(8)},
5362 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5363 PCI_SUBDEVICE_ID_CCD_SWYX4S, 0, 0, H(9)}, /* 4S Swyx */
5364 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5365 PCI_SUBDEVICE_ID_CCD_JH4S20, 0, 0, H(10)},
5366 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5367 PCI_SUBDEVICE_ID_CCD_PMX2S, 0, 0, H(11)}, /* Primux */
5368 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5369 PCI_SUBDEVICE_ID_CCD_OV4S, 0, 0, H(28)}, /* OpenVox 4 */
5370 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5371 PCI_SUBDEVICE_ID_CCD_OV2S, 0, 0, H(29)}, /* OpenVox 2 */
5372 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5373 0xb761, 0, 0, H(33)}, /* BN2S PCIe */
5374 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
5375 0xb762, 0, 0, H(34)}, /* BN4S PCIe */
5377 /* Cards with HFC-8S Chip */
5378 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5379 PCI_SUBDEVICE_ID_CCD_BN8S, 0, 0, H(12)}, /* BN8S */
5380 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5381 PCI_SUBDEVICE_ID_CCD_BN8SP, 0, 0, H(13)}, /* BN8S+ */
5382 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5383 PCI_DEVICE_ID_CCD_HFC8S, 0, 0, H(14)}, /* old Eval */
5384 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5385 PCI_SUBDEVICE_ID_CCD_IOB8STR, 0, 0, H(15)}, /* IOB8ST Recording */
5386 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5387 PCI_SUBDEVICE_ID_CCD_IOB8ST, 0, 0, H(16)}, /* IOB8ST */
5388 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5389 PCI_SUBDEVICE_ID_CCD_IOB8ST_1, 0, 0, H(17)}, /* IOB8ST */
5390 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5391 PCI_SUBDEVICE_ID_CCD_HFC8S, 0, 0, H(18)}, /* 8S */
5392 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5393 PCI_SUBDEVICE_ID_CCD_OV8S, 0, 0, H(30)}, /* OpenVox 8 */
5394 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5395 PCI_SUBDEVICE_ID_CCD_JH8S, 0, 0, H(32)}, /* Junganns 8S */
5398 /* Cards with HFC-E1 Chip */
5399 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5400 PCI_SUBDEVICE_ID_CCD_BNE1, 0, 0, H(19)}, /* BNE1 */
5401 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5402 PCI_SUBDEVICE_ID_CCD_BNE1M, 0, 0, H(20)}, /* BNE1 mini PCI */
5403 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5404 PCI_SUBDEVICE_ID_CCD_BNE1DP, 0, 0, H(21)}, /* BNE1 + (Dual) */
5405 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5406 PCI_SUBDEVICE_ID_CCD_BNE1D, 0, 0, H(22)}, /* BNE1 (Dual) */
5408 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5409 PCI_DEVICE_ID_CCD_HFCE1, 0, 0, H(23)}, /* Old Eval */
5410 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5411 PCI_SUBDEVICE_ID_CCD_IOB1E1, 0, 0, H(24)}, /* IOB1E1 */
5412 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5413 PCI_SUBDEVICE_ID_CCD_HFCE1, 0, 0, H(25)}, /* E1 */
5415 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_CCD,
5416 PCI_SUBDEVICE_ID_CCD_SPD4S, 0, 0, H(26)}, /* PLX PCI Bridge */
5417 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_CCD,
5418 PCI_SUBDEVICE_ID_CCD_SPDE1, 0, 0, H(27)}, /* PLX PCI Bridge */
5420 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFCE1, PCI_VENDOR_ID_CCD,
5421 PCI_SUBDEVICE_ID_CCD_JHSE1, 0, 0, H(25)}, /* Junghanns E1 */
5423 { PCI_VDEVICE(CCD, PCI_DEVICE_ID_CCD_HFC4S), 0 },
5424 { PCI_VDEVICE(CCD, PCI_DEVICE_ID_CCD_HFC8S), 0 },
5425 { PCI_VDEVICE(CCD, PCI_DEVICE_ID_CCD_HFCE1), 0 },
5430 MODULE_DEVICE_TABLE(pci, hfmultipci_ids);
5433 hfcmulti_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
5435 struct hm_map *m = (struct hm_map *)ent->driver_data;
5438 if (m == NULL && ent->vendor == PCI_VENDOR_ID_CCD && (
5439 ent->device == PCI_DEVICE_ID_CCD_HFC4S ||
5440 ent->device == PCI_DEVICE_ID_CCD_HFC8S ||
5441 ent->device == PCI_DEVICE_ID_CCD_HFCE1)) {
5443 "Unknown HFC multiport controller (vendor:%04x device:%04x "
5444 "subvendor:%04x subdevice:%04x)\n", pdev->vendor,
5445 pdev->device, pdev->subsystem_vendor,
5446 pdev->subsystem_device);
5448 "Please contact the driver maintainer for support.\n");
5451 ret = hfcmulti_init(m, pdev, ent);
5455 printk(KERN_INFO "%d devices registered\n", HFC_cnt);
5459 static struct pci_driver hfcmultipci_driver = {
5460 .name = "hfc_multi",
5461 .probe = hfcmulti_probe,
5462 .remove = hfc_remove_pci,
5463 .id_table = hfmultipci_ids,
5467 HFCmulti_cleanup(void)
5469 struct hfc_multi *card, *next;
5471 /* get rid of all devices of this driver */
5472 list_for_each_entry_safe(card, next, &HFClist, list)
5474 pci_unregister_driver(&hfcmultipci_driver);
5484 printk(KERN_INFO "mISDN: HFC-multi driver %s\n", HFC_MULTI_VERSION);
5487 printk(KERN_DEBUG "%s: IRQ_DEBUG IS ENABLED!\n", __func__);
5490 if (debug & DEBUG_HFCMULTI_INIT)
5491 printk(KERN_DEBUG "%s: init entered\n", __func__);
5518 "%s: Wrong poll value (%d).\n", __func__, poll);
5527 /* Register the embedded devices.
5528 * This should be done before the PCI cards registration */
5546 for (i = 0; i < xhfc; ++i) {
5547 err = hfcmulti_init(&m, NULL, NULL);
5549 printk(KERN_ERR "error registering embedded driver: "
5554 printk(KERN_INFO "%d devices registered\n", HFC_cnt);
5557 /* Register the PCI cards */
5558 err = pci_register_driver(&hfcmultipci_driver);
5560 printk(KERN_ERR "error registering pci driver: %x\n", err);
5568 module_init(HFCmulti_init);
5569 module_exit(HFCmulti_cleanup);