1/* $NetBSD: i4b_capi_l4if.c,v 1.8 2006/10/16 13:03:03 pooka Exp $ */ 2 3/* 4 * Copyright (c) 2001-2003 Cubical Solutions Ltd. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * capi/capi_l4if.c The CAPI i4b L4/device interface. 28 * 29 * $FreeBSD: src/sys/i4b/capi/capi_l4if.c,v 1.4 2002/04/04 21:03:20 jhb Exp $ 30 */ 31 32#include <sys/cdefs.h> 33__KERNEL_RCSID(0, "$NetBSD: i4b_capi_l4if.c,v 1.8 2006/10/16 13:03:03 pooka Exp $"); 34 35#include <sys/param.h> 36#include <sys/kernel.h> 37#include <sys/systm.h> 38#include <sys/mbuf.h> 39#include <sys/socket.h> 40#include <sys/callout.h> 41#include <net/if.h> 42 43#include <netisdn/i4b_debug.h> 44#include <netisdn/i4b_ioctl.h> 45#include <netisdn/i4b_cause.h> 46#include <netisdn/i4b_l3l4.h> 47#include <netisdn/i4b_mbuf.h> 48#include <netisdn/i4b_global.h> 49#include <netisdn/i4b_l4.h> 50#include <netisdn/i4b_capi.h> 51#include <netisdn/i4b_capi_msgs.h> 52 53static void n_connect_request(call_desc_t *); 54static void n_connect_response(call_desc_t *, int response, int cause); 55static void n_disconnect_request(call_desc_t *, int cause); 56static void n_alert_request(call_desc_t *); 57static void n_mgmt_command(struct isdn_l3_driver *, int cmd, void *parm); 58static int n_download(void *, int, struct isdn_dr_prot *); 59 60static int ncapi = 0; 61 62/* 63// i4b_capi_{ret,set}_linktab 64// i4b driver glue. 65// 66// i4b_capi_bch_config 67// Called by i4b driver to flush + {en,dis}able a channel. 68// 69// i4b_capi_bch_start_tx 70// Called by i4b driver to transmit a queued mbuf. 71// 72// i4b_capi_bch_stat 73// Called by i4b driver to obtain statistics information. 74*/ 75 76static isdn_link_t * 77i4b_capi_ret_linktab(void *token, int channel) 78{ 79 capi_softc_t *sc = token; 80 81 return &sc->sc_bchan[channel].capi_isdn_linktab; 82} 83 84static void 85i4b_capi_set_link(void *token, int channel, 86 const struct isdn_l4_driver_functions *l4_driver, void *l4_inst) 87{ 88 capi_softc_t *sc = token; 89 90 sc->sc_bchan[channel].l4_driver = l4_driver; 91 sc->sc_bchan[channel].l4_driver_softc = l4_inst; 92} 93 94static void 95i4b_capi_bch_config(void *token, int chan, int bprot, int activate) 96{ 97 capi_softc_t *sc = token; 98 99 i4b_Bcleanifq(&sc->sc_bchan[chan].tx_queue); 100 sc->sc_bchan[chan].tx_queue.ifq_maxlen = IFQ_MAXLEN; 101 sc->sc_bchan[chan].txcount = 0; 102 103 /* The telephony drivers use rx_queue for receive. */ 104 i4b_Bcleanifq(&sc->sc_bchan[chan].rx_queue); 105 sc->sc_bchan[chan].rx_queue.ifq_maxlen = IFQ_MAXLEN; 106 sc->sc_bchan[chan].rxcount = 0; 107 108 /* HDLC frames are put to in_mbuf */ 109 i4b_Bfreembuf(sc->sc_bchan[chan].in_mbuf); 110 sc->sc_bchan[chan].in_mbuf = NULL; 111 112 /* Because of the difference, we need to remember the protocol. */ 113 sc->sc_bchan[chan].bprot = bprot; 114 sc->sc_bchan[chan].busy = 0; 115} 116 117static void 118i4b_capi_bch_start_tx(void *token, int chan) 119{ 120 capi_softc_t *sc = token; 121 int s; 122 123 s = splnet(); 124 125 if (sc->sc_bchan[chan].state != B_CONNECTED) { 126 splx(s); 127 printf("capi%d: start_tx on unconnected channel\n", sc->sc_unit); 128 return; 129 } 130 131 if (sc->sc_bchan[chan].busy) { 132 splx(s); 133 return; 134 } 135 136 capi_start_tx(sc, chan); 137 138 splx(s); 139} 140 141static void 142i4b_capi_bch_stat(void *token, int chan, bchan_statistics_t *bsp) 143{ 144 capi_softc_t *sc = token; 145 int s = splnet(); 146 147 bsp->outbytes = sc->sc_bchan[chan].txcount; 148 bsp->inbytes = sc->sc_bchan[chan].rxcount; 149 150 sc->sc_bchan[chan].txcount = 0; 151 sc->sc_bchan[chan].rxcount = 0; 152 153 splx(s); 154} 155 156int capi_start_tx(void *token, int chan) 157{ 158 capi_softc_t *sc = token; 159 struct mbuf *m_b3; 160 int sent = 0; 161 162 IF_DEQUEUE(&sc->sc_bchan[chan].tx_queue, m_b3); 163 while (m_b3) { 164 struct mbuf *m = m_b3->m_next; 165 166 sc->sc_bchan[chan].txcount += m_b3->m_len; 167 capi_data_b3_req(sc, chan, m_b3); 168 sent++; 169 170 m_b3 = m; 171 } 172 173 if (sc->sc_bchan[chan].l4_driver) { 174 capi_bchan_t *bch = &sc->sc_bchan[chan]; 175 176 /* Notify i4b driver of activity, and if the queue is drained. */ 177 if (sent) 178 (*bch->l4_driver->bch_activity)(bch->l4_driver_softc, ACT_TX); 179 180 if (IF_QEMPTY(&bch->tx_queue)) 181 (*bch->l4_driver->bch_tx_queue_empty)(bch->l4_driver_softc); 182 } 183 184 return sent; 185} 186 187static const struct isdn_l4_bchannel_functions 188capi_l4_driver = { 189 i4b_capi_bch_config, 190 i4b_capi_bch_start_tx, 191 i4b_capi_bch_stat 192}; 193 194/* 195// n_mgmt_command 196// i4b L4 management command. 197*/ 198 199static void 200n_mgmt_command(struct isdn_l3_driver *l3, int op, void *arg) 201{ 202 capi_softc_t *sc = l3->l1_token; 203 204#if 0 205 printf("capi%d: mgmt command %d\n", sc->sc_unit, op); 206#endif 207 208 switch(op) { 209 case CMR_DOPEN: 210 sc->sc_enabled = 1; 211 break; 212 213 case CMR_DCLOSE: 214 sc->sc_enabled = 0; 215 break; 216 217 case CMR_SETTRACE: 218 break; 219 220 default: 221 break; 222 } 223} 224 225/* 226// n_connect_request 227// i4b L4 wants to connect. We assign a B channel to the call, 228// send a CAPI_CONNECT_REQ, and set the channel to B_CONNECT_CONF. 229*/ 230 231static void 232n_connect_request(call_desc_t *cd) 233{ 234 capi_softc_t *sc; 235 int bch, s; 236 237 sc = cd->l3drv->l1_token; 238 bch = cd->channelid; 239 240 s = splnet(); 241 242 if ((bch < 0) || (bch >= sc->sc_nbch)) 243 for (bch = 0; bch < sc->sc_nbch; bch++) 244 if (sc->sc_bchan[bch].state == B_FREE) 245 break; 246 247 if (bch == sc->sc_nbch) { 248 splx(s); 249 printf("capi%d: no free B channel\n", sc->sc_unit); 250 return; 251 } 252 253 cd->channelid = bch; 254 255 capi_connect_req(sc, cd); 256 splx(s); 257} 258 259/* 260// n_connect_response 261// i4b L4 answers a call. We send a CONNECT_RESP with the proper 262// Reject code, and set the channel to B_CONNECT_B3_IND or B_FREE, 263// depending whether we answer or not. 264*/ 265 266static void 267n_connect_response(call_desc_t *cd, int response, int cause) 268{ 269 capi_softc_t *sc; 270 int s; 271 272 sc = cd->l3drv->l1_token; 273 274 T400_stop(cd); 275 276 cd->response = response; 277 cd->cause_out = cause; 278 279 s = splnet(); 280 capi_connect_resp(sc, cd); 281 splx(s); 282} 283 284/* 285// n_disconnect_request 286// i4b L4 wants to disconnect. We send a DISCONNECT_REQ and 287// set the channel to B_DISCONNECT_CONF. 288*/ 289 290static void 291n_disconnect_request(call_desc_t *cd, int cause) 292{ 293 capi_softc_t *sc; 294 int s; 295 296 sc = cd->l3drv->l1_token; 297 298 cd->cause_out = cause; 299 300 s = splnet(); 301 capi_disconnect_req(sc, cd); 302 splx(s); 303} 304 305/* 306// n_alert_request 307// i4b L4 wants to alert an incoming call. We send ALERT_REQ. 308*/ 309 310static void 311n_alert_request(call_desc_t *cd) 312{ 313 capi_softc_t *sc; 314 int s; 315 316 sc = cd->l3drv->l1_token; 317 318 s = splnet(); 319 capi_alert_req(sc, cd); 320 splx(s); 321} 322 323/* 324// n_download 325// L4 -> firmware download 326*/ 327 328static int 329n_download(void *token, int numprotos, struct isdn_dr_prot *protocols) 330{ 331 capi_softc_t *sc = token; 332 333 if (sc->load) { 334 (*sc->load)(sc, protocols[0].bytecount, 335 protocols[0].microcode); 336 return(0); 337 } 338 339 return(ENXIO); 340} 341 342static const struct isdn_l3_driver_functions 343capi_l3_functions = { 344 i4b_capi_ret_linktab, 345 i4b_capi_set_link, 346 n_connect_request, 347 n_connect_response, 348 n_disconnect_request, 349 n_alert_request, 350 n_download, 351 NULL, 352 n_mgmt_command 353}; 354 355/* 356// capi_ll_attach 357// Called by a link layer driver at boot time. 358*/ 359 360int 361capi_ll_attach(capi_softc_t *sc, const char *devname, const char *cardname) 362{ 363 struct isdn_l3_driver *l3drv; 364 int i; 365 366 /* Unit state */ 367 368 sc->sc_enabled = 0; 369 sc->sc_state = C_DOWN; 370 sc->sc_msgid = 0; 371 372 for (i = 0; i < sc->sc_nbch; i++) { 373 sc->sc_bchan[i].ncci = INVALID; 374 sc->sc_bchan[i].msgid = 0; 375 sc->sc_bchan[i].busy = 0; 376 sc->sc_bchan[i].state = B_FREE; 377 378 memset(&sc->sc_bchan[i].tx_queue, 0, sizeof(struct ifqueue)); 379 memset(&sc->sc_bchan[i].rx_queue, 0, sizeof(struct ifqueue)); 380 sc->sc_bchan[i].tx_queue.ifq_maxlen = IFQ_MAXLEN; 381 sc->sc_bchan[i].rx_queue.ifq_maxlen = IFQ_MAXLEN; 382 383 sc->sc_bchan[i].txcount = 0; 384 sc->sc_bchan[i].rxcount = 0; 385 386 sc->sc_bchan[i].cdid = CDID_UNUSED; 387 sc->sc_bchan[i].bprot = BPROT_NONE; 388 sc->sc_bchan[i].in_mbuf = NULL; 389 390 sc->sc_bchan[i].capi_isdn_linktab.l1token = sc; 391 sc->sc_bchan[i].capi_isdn_linktab.channel = i; 392 sc->sc_bchan[i].capi_isdn_linktab.bchannel_driver = &capi_l4_driver; 393 sc->sc_bchan[i].capi_isdn_linktab.tx_queue = &sc->sc_bchan[i].tx_queue; 394 sc->sc_bchan[i].capi_isdn_linktab.rx_queue = &sc->sc_bchan[i].rx_queue; 395 sc->sc_bchan[i].capi_isdn_linktab.rx_mbuf = &sc->sc_bchan[i].in_mbuf; 396 } 397 398 l3drv = isdn_attach_isdnif(devname, cardname, sc, &capi_l3_functions, 399 sc->sc_nbch); 400 401 l3drv->tei = -1; 402 l3drv->dl_est = DL_DOWN; 403 l3drv->nbch = sc->sc_nbch; 404 405 sc->sc_unit = ncapi++; 406 sc->capi_isdnif = l3drv->isdnif; 407 408 isdn_isdnif_ready(l3drv->isdnif); 409 410 printf("capi%d: card type %d attached\n", sc->sc_unit, sc->card_type); 411 412 return(0); 413} 414 415 416/* 417// capi_ll_detach 418*/ 419 420int 421capi_ll_detach(capi_softc_t *sc) 422{ 423 424 (void)sc; 425 /* TODO */ 426 return(0); 427} 428