2 * Copyright (c) 2000, 2001 Hellmuth Michaelis. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 /*---------------------------------------------------------------------------
28 * i4b_l1dmux.c - isdn4bsd layer 1 driver multiplexer
29 * --------------------------------------------------
30 * last edit-date: [Wed Jan 10 16:43:24 2001]
32 *---------------------------------------------------------------------------*/
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
37 #include <sys/param.h>
38 #include <sys/systm.h>
40 #include <i4b/include/i4b_debug.h>
41 #include <i4b/include/i4b_ioctl.h>
42 #include <i4b/include/i4b_trace.h>
44 #include <i4b/layer1/i4b_l1.h>
46 #include <i4b/include/i4b_l1l2.h>
47 #include <i4b/include/i4b_global.h>
50 * this code is nothing but a big dynamic switch to multiplex and demultiplex
51 * layer 1 hardware isdn drivers to a common layer 2.
53 * when a card is successfully attached at system boot time, the driver for
54 * this card calls the routine i4b_l1_mph_status_ind() with status = STI_ATTACH.
56 * This command is used to setup the tables for converting a "driver unit" and
57 * "driver type" pair (encoded in the calls from the hardware driver to the
58 * routines in this source file) to a "unit number" used in layer 2 and the
59 * layers above (up to and including the isdnd daemon) and for converting
60 * layer 2 units back to calling the appropriate driver and driver unit
63 * Example: in my setup, a Winbond (iwic) card is probed first and gets
64 * driver unit number 0, driver type 1 in layer 1. This becomes unit
65 * number 0 in layer 2 and up. The second card probed is a Teles card
66 * (isic) and gets driver unit number 0, driver type 0 in layer 1. This
67 * becomes unit number 1 in layer 1 and up.
69 * To add support for a new driver, add a new driver number to i4b_l1.h:
70 * currently we have L1DRVR_ISIC and L1DRVR_IWIC, so you would add
71 * L1DRVR_FOO. More you would want to add a L0FOOUNIT to encode unit
72 * numbers in your driver. You then have to add a l1foounittab[] and
73 * add an entry to the getl1tab() routine for your driver. The only
74 * thing left now is to write your driver with the support functions
75 * for this multiplexer ;-)
78 unsigned int i4b_l1_debug = L1_DEBUG_DEFAULT;
80 static int l1isicunittab[MAXL1UNITS];
82 static int l1iwicunittab[MAXL1UNITS];
84 static int l1ifpiunittab[MAXL1UNITS];
86 static int l1ifpi2unittab[MAXL1UNITS];
88 static int l1ihfcunittab[MAXL1UNITS];
90 static int l1ifpnpunittab[MAXL1UNITS];
92 static int l1itjcunittab[MAXL1UNITS];
94 static int numl1units = 0;
96 static int l1drvunittab[MAXL1UNITS];
97 static struct i4b_l1mux_func *l1mux_func[MAXL1DRVR];
99 static int i4b_l1_ph_data_req(int, struct mbuf *, int);
100 static int i4b_l1_ph_activate_req(int);
102 /* from i4btrc driver i4b_trace.c */
103 int get_trace_data_from_l1(int unit, int what, int len, char *buf);
106 int i4b_ph_data_ind(int unit, struct mbuf *m);
107 int i4b_ph_activate_ind(int unit);
108 int i4b_ph_deactivate_ind(int unit);
109 int i4b_mph_status_ind(int, int, int);
112 int i4b_l1_mph_command_req(int, int, void *);
114 /*---------------------------------------------------------------------------*
115 * jump table: interface function pointers L1/L2 interface
116 *---------------------------------------------------------------------------*/
117 struct i4b_l1l2_func i4b_l1l2_func = {
119 /* Layer 1 --> Layer 2 */
121 (int (*)(int, struct mbuf *)) i4b_ph_data_ind,
122 (int (*)(int)) i4b_ph_activate_ind,
123 (int (*)(int)) i4b_ph_deactivate_ind,
125 /* Layer 2 --> Layer 1 */
127 (int (*)(int, struct mbuf *, int)) i4b_l1_ph_data_req,
129 (int (*)(int)) i4b_l1_ph_activate_req,
131 /* Layer 1 --> trace interface driver, ISDN trace data */
133 (int (*)(i4b_trace_hdr_t *, int, u_char *)) get_trace_data_from_l1,
135 /* Driver control and status information */
137 (int (*)(int, int, int)) i4b_mph_status_ind,
138 (int (*)(int, int, void *)) i4b_l1_mph_command_req,
141 /*---------------------------------------------------------------------------*
142 * return a pointer to a layer 0 drivers unit tab
143 *---------------------------------------------------------------------------*/
144 static __inline int *
150 return(l1isicunittab);
153 return(l1iwicunittab);
156 return(l1ifpiunittab);
159 return(l1ifpi2unittab);
162 return(l1ihfcunittab);
165 return(l1ifpnpunittab);
168 return(l1itjcunittab);
176 /*===========================================================================*
177 * B - Channel (data transfer)
178 *===========================================================================*/
180 /*---------------------------------------------------------------------------*
181 * return the address of ISDN drivers linktab
182 *---------------------------------------------------------------------------*/
184 i4b_l1_ret_linktab(int unit, int channel)
186 int drv_unit, ch_unit;
188 drv_unit = L0DRVR(l1drvunittab[unit]);
189 ch_unit = L0UNIT(l1drvunittab[unit]);
191 NDBGL1(L1_PRIM, "unit %d -> drv %d / drvunit %d", unit, drv_unit, ch_unit);
193 if (drv_unit >= MAXL1DRVR || l1mux_func[drv_unit] == NULL
194 || l1mux_func[drv_unit]->ret_linktab == NULL)
195 panic("i4b_l1_ret_linktab: unknown driver type %d\n", drv_unit);
197 return(l1mux_func[drv_unit]->ret_linktab(ch_unit, channel));
200 /*---------------------------------------------------------------------------*
201 * set the ISDN driver linktab
202 *---------------------------------------------------------------------------*/
204 i4b_l1_set_linktab(int unit, int channel, drvr_link_t *dlt)
206 int drv_unit, ch_unit;
208 drv_unit = L0DRVR(l1drvunittab[unit]);
209 ch_unit = L0UNIT(l1drvunittab[unit]);
211 NDBGL1(L1_PRIM, "unit %d -> drv %d / drvunit %d", unit, drv_unit, ch_unit);
213 if (drv_unit >= MAXL1DRVR || l1mux_func[drv_unit] == NULL
214 || l1mux_func[drv_unit]->set_linktab == NULL)
215 panic("i4b_l1_set_linktab: unknown driver type %d\n", drv_unit);
217 l1mux_func[drv_unit]->set_linktab(ch_unit, channel, dlt);
220 /*===========================================================================*
221 * trace D- and B-Channel support
222 *===========================================================================*/
224 /*---------------------------------------------------------------------------*
225 * L0 -> L1 trace information to trace driver
226 *---------------------------------------------------------------------------*/
228 i4b_l1_trace_ind(i4b_trace_hdr_t *hdr, int len, u_char *data)
232 if((tab = getl1tab(L0DRVR(hdr->unit))) == NULL)
233 panic("i4b_l1_trace_ind: unknown driver type %d\n", L0DRVR(hdr->unit));
235 NDBGL1(L1_PRIM, "(drv %d / drvunit %d) -> unit %d", L0DRVR(hdr->unit), L0UNIT(hdr->unit), tab[L0UNIT(hdr->unit)]);
237 hdr->unit = tab[L0UNIT(hdr->unit)];
239 return(MPH_Trace_Ind(hdr, len, data));
242 /*===========================================================================*
243 * D - Channel (signalling)
244 *===========================================================================*/
246 /*---------------------------------------------------------------------------*
247 * L0 -> L1 status indication from hardware
248 *---------------------------------------------------------------------------*/
250 i4b_l1_mph_status_ind(int drv_unit, int status, int parm, struct i4b_l1mux_func *l1mux_func_p)
255 * in case the status STI_ATTACH is sent from the hardware, the
256 * driver has just attached itself and we need to initialize
257 * the tables and assorted variables.
260 if(status == STI_ATTACH)
262 if (l1mux_func_p == (struct i4b_l1mux_func *)0)
263 panic("i4b_l1_mph_status_ind: i4b_l1mux_func pointer is NULL\n");
265 if(numl1units < MAXL1UNITS)
267 if((tab = getl1tab(L0DRVR(drv_unit))) == NULL)
268 panic("i4b_l1_mph_status_ind: unknown driver type %d\n", L0DRVR(drv_unit));
270 tab[L0UNIT(drv_unit)] = numl1units;
272 l1drvunittab[numl1units] = drv_unit;
274 l1mux_func[L0DRVR(drv_unit)] = l1mux_func_p;
276 switch(L0DRVR(drv_unit))
279 printf("isic%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
282 printf("iwic%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
285 printf("ifpi%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
288 printf("ifpi2-%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
291 printf("ifpnp%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
294 printf("ihfc%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
297 printf("itjc%d: passive stack unit %d\n", L0UNIT(drv_unit), numl1units);
301 NDBGL1(L1_PRIM, "ATTACH drv %d, drvunit %d -> unit %d", L0DRVR(drv_unit), L0UNIT(drv_unit), numl1units);
307 if((tab = getl1tab(L0DRVR(drv_unit))) == NULL)
308 panic("i4b_l1_mph_status_ind: unknown driver type %d\n", L0DRVR(drv_unit));
310 NDBGL1(L1_PRIM, "(drv %d / drvunit %d) -> unit %d\n", L0DRVR(drv_unit), L0UNIT(drv_unit), tab[L0UNIT(drv_unit)]);
312 return(MPH_Status_Ind(tab[L0UNIT(drv_unit)], status, parm));
315 /*---------------------------------------------------------------------------*
316 * L0 -> L1 data from hardware
317 *---------------------------------------------------------------------------*/
319 i4b_l1_ph_data_ind(int drv_unit, struct mbuf *data)
323 if((tab = getl1tab(L0DRVR(drv_unit))) == NULL)
324 panic("i4b_l1_ph_data_ind: unknown driver type %d\n", L0DRVR(drv_unit));
327 NDBGL1(L1_PRIM, "(drv %d / drvunit %d) -> unit %d", L0DRVR(drv_unit), L0UNIT(drv_unit), tab[L0UNIT(drv_unit)]);
330 return(PH_Data_Ind(tab[L0UNIT(drv_unit)], data));
333 /*---------------------------------------------------------------------------*
334 * L0 -> L1 activate indication from hardware
335 *---------------------------------------------------------------------------*/
337 i4b_l1_ph_activate_ind(int drv_unit)
341 if((tab = getl1tab(L0DRVR(drv_unit))) == NULL)
342 panic("i4b_l1_ph_activate_ind: unknown driver type %d\n", L0DRVR(drv_unit));
344 NDBGL1(L1_PRIM, "(drv %d / drvunit %d) -> unit %d", L0DRVR(drv_unit), L0UNIT(drv_unit), tab[L0UNIT(drv_unit)]);
346 return(PH_Act_Ind(tab[L0UNIT(drv_unit)]));
349 /*---------------------------------------------------------------------------*
350 * L0 -> L1 deactivate indication from hardware
351 *---------------------------------------------------------------------------*/
353 i4b_l1_ph_deactivate_ind(int drv_unit)
357 if((tab = getl1tab(L0DRVR(drv_unit))) == NULL)
358 panic("i4b_l1_ph_deactivate_ind: unknown driver type %d\n", L0DRVR(drv_unit));
360 NDBGL1(L1_PRIM, "(drv %d / drvunit %d) -> unit %d", L0DRVR(drv_unit), L0UNIT(drv_unit), tab[L0UNIT(drv_unit)]);
362 return(PH_Deact_Ind(tab[L0UNIT(drv_unit)]));
365 /*---------------------------------------------------------------------------*
366 * L2 -> L1 command to hardware
367 *---------------------------------------------------------------------------*/
369 i4b_l1_mph_command_req(int unit, int command, void * parm)
371 register int drv_unit = L0DRVR(l1drvunittab[unit]);
372 register int ch_unit = L0UNIT(l1drvunittab[unit]);
374 NDBGL1(L1_PRIM, "unit %d -> drv %d / drvunit %d", unit, drv_unit, ch_unit);
376 if (drv_unit >= MAXL1DRVR || l1mux_func[drv_unit] == NULL
377 || l1mux_func[drv_unit]->mph_command_req == NULL)
378 panic("i4b_l1_mph_command_req: unknown driver type %d\n", drv_unit);
380 return(l1mux_func[drv_unit]->mph_command_req(ch_unit, command, parm));
383 /*---------------------------------------------------------------------------*
384 * L2 -> L1 data to be transmitted to hardware
385 *---------------------------------------------------------------------------*/
387 i4b_l1_ph_data_req(int unit, struct mbuf *data, int flag)
389 register int drv_unit = L0DRVR(l1drvunittab[unit]);
390 register int ch_unit = L0UNIT(l1drvunittab[unit]);
393 NDBGL1(L1_PRIM, "unit %d -> drv %d / drvunit %d", unit, drv_unit, ch_unit);
396 if (drv_unit >= MAXL1DRVR || l1mux_func[drv_unit] == NULL
397 || l1mux_func[drv_unit]->ph_data_req == NULL)
398 panic("i4b_l1_ph_data_req: unknown driver type %d\n", drv_unit);
400 return(l1mux_func[drv_unit]->ph_data_req(ch_unit, data, flag));
403 /*---------------------------------------------------------------------------*
404 * L2 -> L1 activate request to hardware
405 *---------------------------------------------------------------------------*/
407 i4b_l1_ph_activate_req(int unit)
409 register int drv_unit = L0DRVR(l1drvunittab[unit]);
410 register int ch_unit = L0UNIT(l1drvunittab[unit]);
412 NDBGL1(L1_PRIM, "unit %d -> drv %d / drvunit %d", unit, drv_unit, ch_unit);
414 if (drv_unit >= MAXL1DRVR || l1mux_func[drv_unit] == NULL
415 || l1mux_func[drv_unit]->ph_activate_req == NULL)
416 panic("i4b_l1_ph_activate_req: unknown driver type %d\n", drv_unit);
418 return(l1mux_func[drv_unit]->ph_activate_req(ch_unit));