2 * Copyright (c) 2001 Cubical Solutions Ltd. 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
25 * capi/capi_l4if.c The CAPI i4b L4/device interface.
27 * $FreeBSD: src/sys/i4b/capi/capi_l4if.c,v 1.1.2.1 2001/08/10 14:08:34 obrien Exp $
28 * $DragonFly: src/sys/net/i4b/capi/capi_l4if.c,v 1.2 2003/06/17 04:28:39 dillon Exp $
34 #include <sys/param.h>
35 #include <sys/kernel.h>
36 #include <sys/systm.h>
38 #include <sys/socket.h>
41 #include <machine/i4b_debug.h>
42 #include <machine/i4b_ioctl.h>
43 #include <machine/i4b_cause.h>
45 #include <i4b/include/i4b_l3l4.h>
46 #include <i4b/include/i4b_mbuf.h>
47 #include <i4b/include/i4b_global.h>
49 #include <i4b/layer4/i4b_l4.h>
51 #include <i4b/capi/capi.h>
52 #include <i4b/capi/capi_msgs.h>
54 static void n_connect_request(u_int cdid);
55 static void n_connect_response(u_int cdid, int response, int cause);
56 static void n_disconnect_request(u_int cdid, int cause);
57 static void n_alert_request(u_int cdid);
58 static void n_mgmt_command(int unit, int cmd, void *parm);
59 static int n_download(int unit, int, struct isdn_dr_prot *);
61 capi_softc_t *capi_sc[MAX_CONTROLLERS] = { NULL, };
65 // i4b_capi_{ret,set}_linktab
68 // i4b_capi_bch_config
69 // Called by i4b driver to flush + {en,dis}able a channel.
71 // i4b_capi_bch_start_tx
72 // Called by i4b driver to transmit a queued mbuf.
75 // Called by i4b driver to obtain statistics information.
79 i4b_capi_ret_linktab(int unit, int channel)
81 capi_softc_t *sc = capi_sc[unit];
82 return &sc->sc_bchan[channel].capi_isdn_linktab;
86 i4b_capi_set_linktab(int unit, int channel, drvr_link_t *dlt)
88 capi_softc_t *sc = capi_sc[unit];
89 sc->sc_bchan[channel].capi_drvr_linktab = dlt;
93 i4b_capi_bch_config(int unit, int chan, int bprot, int activate)
95 capi_softc_t *sc = capi_sc[unit];
97 i4b_Bcleanifq(&sc->sc_bchan[chan].tx_queue);
98 sc->sc_bchan[chan].tx_queue.ifq_maxlen = IFQ_MAXLEN;
99 sc->sc_bchan[chan].txcount = 0;
101 /* The telephony drivers use rx_queue for receive. */
103 i4b_Bcleanifq(&sc->sc_bchan[chan].rx_queue);
104 sc->sc_bchan[chan].rx_queue.ifq_maxlen = IFQ_MAXLEN;
105 sc->sc_bchan[chan].rxcount = 0;
107 /* HDLC frames are put to in_mbuf */
109 i4b_Bfreembuf(sc->sc_bchan[chan].in_mbuf);
110 sc->sc_bchan[chan].in_mbuf = NULL;
112 /* Because of the difference, we need to remember the protocol. */
114 sc->sc_bchan[chan].bprot = bprot;
115 sc->sc_bchan[chan].busy = 0;
119 i4b_capi_bch_start_tx(int unit, int chan)
121 capi_softc_t *sc = capi_sc[unit];
126 if (sc->sc_bchan[chan].state != B_CONNECTED) {
128 printf("capi%d: start_tx on unconnected channel\n", sc->sc_unit);
132 if (sc->sc_bchan[chan].busy) {
137 capi_start_tx(sc, chan);
143 i4b_capi_bch_stat(int unit, int chan, bchan_statistics_t *bsp)
145 capi_softc_t *sc = capi_sc[unit];
148 bsp->outbytes = sc->sc_bchan[chan].txcount;
149 bsp->inbytes = sc->sc_bchan[chan].rxcount;
151 sc->sc_bchan[chan].txcount = 0;
152 sc->sc_bchan[chan].rxcount = 0;
157 int capi_start_tx(capi_softc_t *sc, int chan)
162 _IF_DEQUEUE(&sc->sc_bchan[chan].tx_queue, m_b3);
164 struct mbuf *m = m_b3->m_next;
166 sc->sc_bchan[chan].txcount += m_b3->m_len;
167 capi_data_b3_req(sc, chan, m_b3);
173 if (sc->sc_bchan[chan].capi_drvr_linktab) {
174 /* Notify i4b driver of activity, and if the queue is drained. */
177 (*sc->sc_bchan[chan].capi_drvr_linktab->bch_activity)(
178 sc->sc_bchan[chan].capi_drvr_linktab->unit, ACT_TX);
180 if (IF_QEMPTY(&sc->sc_bchan[chan].tx_queue))
181 (*sc->sc_bchan[chan].capi_drvr_linktab->bch_tx_queue_empty)(
182 sc->sc_bchan[chan].capi_drvr_linktab->unit);
190 // Called by a link layer driver at boot time.
194 capi_ll_attach(capi_softc_t *sc)
198 if (ncapi == (sizeof(capi_sc) / sizeof(capi_sc[0]))) {
199 printf("capi%d: too many units, increase MAX_CONTROLLERS\n", ncapi);
203 /* Unit type and subtype; sc is partly filled by ll driver */
205 ctrl_desc[nctrl].unit = ncapi;
206 ctrl_desc[nctrl].ctrl_type = CTRL_CAPI;
207 ctrl_desc[nctrl].card_type = sc->card_type;
211 ctrl_types[CTRL_CAPI].get_linktab = i4b_capi_ret_linktab;
212 ctrl_types[CTRL_CAPI].set_linktab = i4b_capi_set_linktab;
214 ctrl_desc[nctrl].N_CONNECT_REQUEST = n_connect_request;
215 ctrl_desc[nctrl].N_CONNECT_RESPONSE = n_connect_response;
216 ctrl_desc[nctrl].N_DISCONNECT_REQUEST = n_disconnect_request;
217 ctrl_desc[nctrl].N_ALERT_REQUEST = n_alert_request;
218 ctrl_desc[nctrl].N_DOWNLOAD = n_download;
219 ctrl_desc[nctrl].N_DIAGNOSTICS = NULL; /* XXX todo */
220 ctrl_desc[nctrl].N_MGMT_COMMAND = n_mgmt_command;
224 sc->sc_enabled = FALSE;
225 sc->sc_state = C_DOWN;
228 ctrl_desc[nctrl].dl_est = DL_DOWN;
229 ctrl_desc[nctrl].nbch = sc->sc_nbch;
231 for (i = 0; i < sc->sc_nbch; i++) {
232 ctrl_desc[nctrl].bch_state[i] = BCH_ST_FREE;
233 sc->sc_bchan[i].ncci = INVALID;
234 sc->sc_bchan[i].msgid = 0;
235 sc->sc_bchan[i].busy = 0;
236 sc->sc_bchan[i].state = B_FREE;
238 memset(&sc->sc_bchan[i].tx_queue, 0, sizeof(struct ifqueue));
239 memset(&sc->sc_bchan[i].rx_queue, 0, sizeof(struct ifqueue));
240 sc->sc_bchan[i].tx_queue.ifq_maxlen = IFQ_MAXLEN;
241 sc->sc_bchan[i].rx_queue.ifq_maxlen = IFQ_MAXLEN;
243 #if defined (__FreeBSD__) && __FreeBSD__ > 4
244 mtx_init(&sc->sc_bchan[i].tx_queue.ifq_mtx, "i4b_capi_tx", MTX_DEF);
245 mtx_init(&sc->sc_bchan[i].rx_queue.ifq_mtx, "i4b_capi_rx", MTX_DEF);
248 sc->sc_bchan[i].txcount = 0;
249 sc->sc_bchan[i].rxcount = 0;
251 sc->sc_bchan[i].cdid = CDID_UNUSED;
252 sc->sc_bchan[i].bprot = BPROT_NONE;
253 sc->sc_bchan[i].in_mbuf = NULL;
255 sc->sc_bchan[i].capi_drvr_linktab = NULL;
257 sc->sc_bchan[i].capi_isdn_linktab.unit = ncapi;
258 sc->sc_bchan[i].capi_isdn_linktab.channel = i;
259 sc->sc_bchan[i].capi_isdn_linktab.bch_config = i4b_capi_bch_config;
260 sc->sc_bchan[i].capi_isdn_linktab.bch_tx_start = i4b_capi_bch_start_tx;
261 sc->sc_bchan[i].capi_isdn_linktab.bch_stat = i4b_capi_bch_stat;
262 sc->sc_bchan[i].capi_isdn_linktab.tx_queue = &sc->sc_bchan[i].tx_queue;
263 sc->sc_bchan[i].capi_isdn_linktab.rx_queue = &sc->sc_bchan[i].rx_queue;
264 sc->sc_bchan[i].capi_isdn_linktab.rx_mbuf = &sc->sc_bchan[i].in_mbuf;
267 ctrl_desc[nctrl].tei = -1;
269 /* Up the controller index and store the softc */
272 capi_sc[ncapi++] = sc;
273 sc->ctrl_unit = nctrl++;
275 printf("capi%d: card type %d attached\n", sc->sc_unit, sc->card_type);
282 // i4b L4 management command.
286 n_mgmt_command(int unit, int op, void *arg)
288 capi_softc_t *sc = capi_sc[unit];
290 printf("capi%d: mgmt command %d\n", sc->sc_unit, op);
294 sc->sc_enabled = TRUE;
298 sc->sc_enabled = FALSE;
311 // i4b L4 wants to connect. We assign a B channel to the call,
312 // send a CAPI_CONNECT_REQ, and set the channel to B_CONNECT_CONF.
316 n_connect_request(u_int cdid)
318 call_desc_t *cd = cd_by_cdid(cdid);
323 printf("capi?: invalid cdid %d\n", cdid);
327 sc = capi_sc[ctrl_desc[cd->controller].unit];
332 if ((bch < 0) || (bch >= sc->sc_nbch))
333 for (bch = 0; bch < sc->sc_nbch; bch++)
334 if (sc->sc_bchan[bch].state == B_FREE)
337 if (bch == sc->sc_nbch) {
339 printf("capi%d: no free B channel\n", sc->sc_unit);
345 capi_connect_req(sc, cd);
350 // n_connect_response
351 // i4b L4 answers a call. We send a CONNECT_RESP with the proper
352 // Reject code, and set the channel to B_CONNECT_B3_IND or B_FREE,
353 // depending whether we answer or not.
357 n_connect_response(u_int cdid, int response, int cause)
359 call_desc_t *cd = cd_by_cdid(cdid);
364 printf("capi?: invalid cdid %d\n", cdid);
368 sc = capi_sc[ctrl_desc[cd->controller].unit];
373 cd->response = response;
374 cd->cause_out = cause;
377 capi_connect_resp(sc, cd);
382 // n_disconnect_request
383 // i4b L4 wants to disconnect. We send a DISCONNECT_REQ and
384 // set the channel to B_DISCONNECT_CONF.
388 n_disconnect_request(u_int cdid, int cause)
390 call_desc_t *cd = cd_by_cdid(cdid);
395 printf("capi?: invalid cdid %d\n", cdid);
399 sc = capi_sc[ctrl_desc[cd->controller].unit];
402 cd->cause_out = cause;
405 capi_disconnect_req(sc, cd);
411 // i4b L4 wants to alert an incoming call. We send ALERT_REQ.
415 n_alert_request(u_int cdid)
417 call_desc_t *cd = cd_by_cdid(cdid);
422 printf("capi?: invalid cdid %d\n", cdid);
426 sc = capi_sc[ctrl_desc[cd->controller].unit];
429 capi_alert_req(sc, cd);
435 // L4 -> firmware download
439 n_download(int unit, int numprotos, struct isdn_dr_prot *protocols)
441 capi_softc_t *sc = capi_sc[unit];
444 (*capi_sc[unit]->load)(sc, protocols[0].bytecount,
445 protocols[0].microcode);
451 #endif /* NI4BCAPI > 0 */