开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
callc.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：49k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

callc.c：源码内容
  1. /* $Id: callc.c,v 1.1.4.1 2001/11/20 14:19:35 kai Exp $
  2.  *
  3.  * Author       Karsten Keil
  4.  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
  5.  * 
  6.  * This software may be used and distributed according to the terms
  7.  * of the GNU General Public License, incorporated herein by reference.
  8.  *
  9.  * For changes and modifications please read
  10.  * ../../../Documentation/isdn/HiSax.cert
  11.  *
  12.  * based on the teles driver from Jan den Ouden
  13.  *
  14.  * Thanks to    Jan den Ouden
  15.  *              Fritz Elfert
  16.  *
  17.  */
  19. #define __NO_VERSION__
  20. #include <linux/module.h>
  21. #include <linux/init.h>
  22. #include "hisax.h"
  23. #include "../avmb1/capicmd.h"  /* this should be moved in a common place */
  25. #ifdef MODULE
  26. #define MOD_USE_COUNT ( GET_USE_COUNT (&__this_module))
  27. #endif /* MODULE */
  29. const char *lli_revision = "$Revision: 1.1.4.1 $";
  31. extern struct IsdnCard cards[];
  32. extern int nrcards;
  33. extern void HiSax_mod_dec_use_count(struct IsdnCardState *cs);
  34. extern void HiSax_mod_inc_use_count(struct IsdnCardState *cs);
  36. static int init_b_st(struct Channel *chanp, int incoming);
  37. static void release_b_st(struct Channel *chanp);
  39. static struct Fsm callcfsm;
  40. static int chancount;
  42. /* experimental REJECT after ALERTING for CALLBACK to beat the 4s delay */
  43. #define ALERT_REJECT 0
  45. /* Value to delay the sending of the first B-channel paket after CONNECT
  46.  * here is no value given by ITU, but experience shows that 300 ms will
  47.  * work on many networks, if you or your other side is behind local exchanges
  48.  * a greater value may be recommented. If the delay is to short the first paket
  49.  * will be lost and autodetect on many comercial routers goes wrong !
  50.  * You can adjust this value on runtime with
  51.  * hisaxctrl <id> 2 <value>
  52.  * value is in milliseconds
  53.  */
  54. #define DEFAULT_B_DELAY 300
  56. /* Flags for remembering action done in lli */
  58. #define  FLG_START_B 0
  60. /*
  61.  * Find card with given driverId
  62.  */
  63. static inline struct IsdnCardState *
  64. hisax_findcard(int driverid)
  65. {
  66. int i;
  68. for (i = 0; i < nrcards; i++)
  69. if (cards[i].cs)
  70. if (cards[i].cs->myid == driverid)
  71. return (cards[i].cs);
  72. return (struct IsdnCardState *) 0;
  73. }
  75. static void
  76. link_debug(struct Channel *chanp, int direction, char *fmt, ...)
  77. {
  78. va_list args;
  79. char tmp[16];
  81. va_start(args, fmt);
  82. sprintf(tmp, "Ch%d %s ", chanp->chan,
  83. direction ? "LL->HL" : "HL->LL");
  84. VHiSax_putstatus(chanp->cs, tmp, fmt, args);
  85. va_end(args);
  86. }
  88. enum {
  89. ST_NULL, /*  0 inactive */
  90. ST_OUT_DIAL, /*  1 outgoing, SETUP send; awaiting confirm */
  91. ST_IN_WAIT_LL, /*  2 incoming call received; wait for LL confirm */
  92. ST_IN_ALERT_SENT, /*  3 incoming call received; ALERT send */
  93. ST_IN_WAIT_CONN_ACK, /*  4 incoming CONNECT send; awaiting CONN_ACK */
  94. ST_WAIT_BCONN, /*  5 CONNECT/CONN_ACK received, awaiting b-channel prot. estbl. */
  95. ST_ACTIVE, /*  6 active, b channel prot. established */
  96. ST_WAIT_BRELEASE, /*  7 call clear. (initiator), awaiting b channel prot. rel. */
  97. ST_WAIT_BREL_DISC, /*  8 call clear. (receiver), DISCONNECT req. received */
  98. ST_WAIT_DCOMMAND, /*  9 call clear. (receiver), awaiting DCHANNEL message */
  99. ST_WAIT_DRELEASE, /* 10 DISCONNECT sent, awaiting RELEASE */
  100. ST_WAIT_D_REL_CNF, /* 11 RELEASE sent, awaiting RELEASE confirm */
  101. ST_IN_PROCEED_SEND, /* 12 incoming call, proceeding send */ 
  102. };
  103.   
  105. #define STATE_COUNT (ST_IN_PROCEED_SEND + 1)
  107. static char *strState[] =
  108. {
  109. "ST_NULL",
  110. "ST_OUT_DIAL",
  111. "ST_IN_WAIT_LL",
  112. "ST_IN_ALERT_SENT",
  113. "ST_IN_WAIT_CONN_ACK",
  114. "ST_WAIT_BCONN",
  115. "ST_ACTIVE",
  116. "ST_WAIT_BRELEASE",
  117. "ST_WAIT_BREL_DISC",
  118. "ST_WAIT_DCOMMAND",
  119. "ST_WAIT_DRELEASE",
  120. "ST_WAIT_D_REL_CNF",
  121. "ST_IN_PROCEED_SEND",
  122. };
  124. enum {
  125. EV_DIAL, /*  0 */
  126. EV_SETUP_CNF, /*  1 */
  127. EV_ACCEPTB, /*  2 */
  128. EV_DISCONNECT_IND, /*  3 */
  129. EV_RELEASE,  /*  4 */
  130. EV_LEASED, /*  5 */
  131. EV_LEASED_REL, /*  6 */
  132. EV_SETUP_IND, /*  7 */
  133. EV_ACCEPTD, /*  8 */
  134. EV_SETUP_CMPL_IND, /*  9 */
  135. EV_BC_EST, /* 10 */
  136. EV_WRITEBUF, /* 11 */
  137. EV_HANGUP, /* 12 */
  138. EV_BC_REL, /* 13 */
  139. EV_CINF, /* 14 */
  140. EV_SUSPEND, /* 15 */
  141. EV_RESUME, /* 16 */
  142. EV_NOSETUP_RSP, /* 17 */
  143. EV_SETUP_ERR, /* 18 */
  144. EV_CONNECT_ERR, /* 19 */
  145. EV_PROCEED, /* 20 */
  146. EV_ALERT, /* 21 */ 
  147. EV_REDIR, /* 22 */ 
  148. };
  150. #define EVENT_COUNT (EV_REDIR + 1)
  152. static char *strEvent[] =
  153. {
  154. "EV_DIAL",
  155. "EV_SETUP_CNF",
  156. "EV_ACCEPTB",
  157. "EV_DISCONNECT_IND",
  158. "EV_RELEASE",
  159. "EV_LEASED",
  160. "EV_LEASED_REL",
  161. "EV_SETUP_IND",
  162. "EV_ACCEPTD",
  163. "EV_SETUP_CMPL_IND",
  164. "EV_BC_EST",
  165. "EV_WRITEBUF",
  166. "EV_HANGUP",
  167. "EV_BC_REL",
  168. "EV_CINF",
  169. "EV_SUSPEND",
  170. "EV_RESUME",
  171. "EV_NOSETUP_RSP",
  172. "EV_SETUP_ERR",
  173. "EV_CONNECT_ERR",
  174. "EV_PROCEED",
  175. "EV_ALERT",
  176. "EV_REDIR",
  177. };
  180. static inline void
  181. HL_LL(struct Channel *chanp, int command)
  182. {
  183. isdn_ctrl ic;
  185. ic.driver = chanp->cs->myid;
  186. ic.command = command;
  187. ic.arg = chanp->chan;
  188. chanp->cs->iif.statcallb(&ic);
  189. }
  191. static inline void
  192. lli_deliver_cause(struct Channel *chanp)
  193. {
  194. isdn_ctrl ic;
  196. if (!chanp->proc)
  197. return;
  198. if (chanp->proc->para.cause == NO_CAUSE)
  199. return;
  200. ic.driver = chanp->cs->myid;
  201. ic.command = ISDN_STAT_CAUSE;
  202. ic.arg = chanp->chan;
  203. if (chanp->cs->protocol == ISDN_PTYPE_EURO)
  204. sprintf(ic.parm.num, "E%02X%02X", chanp->proc->para.loc & 0x7f,
  205. chanp->proc->para.cause & 0x7f);
  206. else
  207. sprintf(ic.parm.num, "%02X%02X", chanp->proc->para.loc & 0x7f,
  208. chanp->proc->para.cause & 0x7f);
  209. chanp->cs->iif.statcallb(&ic);
  210. }
  212. static inline void
  213. lli_close(struct FsmInst *fi)
  214. {
  215. struct Channel *chanp = fi->userdata;
  217. FsmChangeState(fi, ST_NULL);
  218. chanp->Flags = 0;
  219. chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
  220. }
  222. static void
  223. lli_leased_in(struct FsmInst *fi, int event, void *arg)
  224. {
  225. struct Channel *chanp = fi->userdata;
  226. isdn_ctrl ic;
  227. int ret;
  229. if (!chanp->leased)
  230. return;
  231. chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
  232. FsmChangeState(fi, ST_IN_WAIT_LL);
  233. if (chanp->debug & 1)
  234. link_debug(chanp, 0, "STAT_ICALL_LEASED");
  235. ic.driver = chanp->cs->myid;
  236. ic.command = ((chanp->chan < 2) ? ISDN_STAT_ICALL : ISDN_STAT_ICALLW);
  237. ic.arg = chanp->chan;
  238. ic.parm.setup.si1 = 7;
  239. ic.parm.setup.si2 = 0;
  240. ic.parm.setup.plan = 0;
  241. ic.parm.setup.screen = 0;
  242. sprintf(ic.parm.setup.eazmsn,"%d", chanp->chan + 1);
  243. sprintf(ic.parm.setup.phone,"LEASED%d", chanp->cs->myid);
  244. ret = chanp->cs->iif.statcallb(&ic);
  245. if (chanp->debug & 1)
  246. link_debug(chanp, 1, "statcallb ret=%d", ret);
  247. if (!ret) {
  248. chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
  249. FsmChangeState(fi, ST_NULL);
  250. }
  251. }
  254. /*
  255.  * Dial out
  256.  */
  257. static void
  258. lli_init_bchan_out(struct FsmInst *fi, int event, void *arg)
  259. {
  260. struct Channel *chanp = fi->userdata;
  262. FsmChangeState(fi, ST_WAIT_BCONN);
  263. if (chanp->debug & 1)
  264. link_debug(chanp, 0, "STAT_DCONN");
  265. HL_LL(chanp, ISDN_STAT_DCONN);
  266. init_b_st(chanp, 0);
  267. chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
  268. }
  270. static void
  271. lli_prep_dialout(struct FsmInst *fi, int event, void *arg)
  272. {
  273. struct Channel *chanp = fi->userdata;
  275. FsmDelTimer(&chanp->drel_timer, 60);
  276. FsmDelTimer(&chanp->dial_timer, 73);
  277. chanp->l2_active_protocol = chanp->l2_protocol;
  278. chanp->incoming = 0;
  279. chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
  280. if (chanp->leased) {
  281. lli_init_bchan_out(fi, event, arg);
  282. } else {
  283. FsmChangeState(fi, ST_OUT_DIAL);
  284. chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | REQUEST, chanp);
  285. }
  286. }
  288. static void
  289. lli_resume(struct FsmInst *fi, int event, void *arg)
  290. {
  291. struct Channel *chanp = fi->userdata;
  293. FsmDelTimer(&chanp->drel_timer, 60);
  294. FsmDelTimer(&chanp->dial_timer, 73);
  295. chanp->l2_active_protocol = chanp->l2_protocol;
  296. chanp->incoming = 0;
  297. chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
  298. if (chanp->leased) {
  299. lli_init_bchan_out(fi, event, arg);
  300. } else {
  301. FsmChangeState(fi, ST_OUT_DIAL);
  302. chanp->d_st->lli.l4l3(chanp->d_st, CC_RESUME | REQUEST, chanp);
  303. }
  304. }
  306. static void
  307. lli_go_active(struct FsmInst *fi, int event, void *arg)
  308. {
  309. struct Channel *chanp = fi->userdata;
  310. isdn_ctrl ic;
  313. FsmChangeState(fi, ST_ACTIVE);
  314. chanp->data_open = !0;
  315. if (chanp->bcs->conmsg)
  316. strcpy(ic.parm.num, chanp->bcs->conmsg);
  317. else
  318. ic.parm.num[0] = 0;
  319. if (chanp->debug & 1)
  320. link_debug(chanp, 0, "STAT_BCONN %s", ic.parm.num);
  321. ic.driver = chanp->cs->myid;
  322. ic.command = ISDN_STAT_BCONN;
  323. ic.arg = chanp->chan;
  324. chanp->cs->iif.statcallb(&ic);
  325. chanp->cs->cardmsg(chanp->cs, MDL_INFO_CONN, (void *) (long)chanp->chan);
  326. }
  329. /*
  330.  * RESUME
  331.  */
  333. /* incoming call */
  335. static void
  336. lli_deliver_call(struct FsmInst *fi, int event, void *arg)
  337. {
  338. struct Channel *chanp = fi->userdata;
  339. isdn_ctrl ic;
  340. int ret;
  342. chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
  343. /*
  344.  * Report incoming calls only once to linklevel, use CallFlags
  345.  * which is set to 3 with each broadcast message in isdnl1.c
  346.  * and resetted if a interface  answered the STAT_ICALL.
  347.  */
  348. if (1) { /* for only one TEI */
  349. FsmChangeState(fi, ST_IN_WAIT_LL);
  350. if (chanp->debug & 1)
  351. link_debug(chanp, 0, (chanp->chan < 2) ? "STAT_ICALL" : "STAT_ICALLW");
  352. ic.driver = chanp->cs->myid;
  353. ic.command = ((chanp->chan < 2) ? ISDN_STAT_ICALL : ISDN_STAT_ICALLW);
  355. ic.arg = chanp->chan;
  356. /*
  357.  * No need to return "unknown" for calls without OAD,
  358.  * cause that's handled in linklevel now (replaced by '0')
  359.  */
  360. memcpy(&ic.parm.setup, &chanp->proc->para.setup, sizeof(setup_parm));
  361. ret = chanp->cs->iif.statcallb(&ic);
  362. if (chanp->debug & 1)
  363. link_debug(chanp, 1, "statcallb ret=%d", ret);
  365. switch (ret) {
  366. case 1: /* OK, someone likes this call */
  367. FsmDelTimer(&chanp->drel_timer, 61);
  368. FsmChangeState(fi, ST_IN_ALERT_SENT);
  369. chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
  370. break;
  371. case 5: /* direct redirect */
  372. case 4: /* Proceeding desired */
  373. FsmDelTimer(&chanp->drel_timer, 61);
  374. FsmChangeState(fi, ST_IN_PROCEED_SEND);
  375. chanp->d_st->lli.l4l3(chanp->d_st, CC_PROCEED_SEND | REQUEST, chanp->proc);
  376. if (ret == 5) {
  377. memcpy(&chanp->setup, &ic.parm.setup, sizeof(setup_parm));
  378. chanp->d_st->lli.l4l3(chanp->d_st, CC_REDIR | REQUEST, chanp->proc);
  379. }
  380. break;
  381. case 2: /* Rejecting Call */
  382. break;
  383. case 3: /* incomplete number */
  384. FsmDelTimer(&chanp->drel_timer, 61);
  385. chanp->d_st->lli.l4l3(chanp->d_st, CC_MORE_INFO | REQUEST, chanp->proc);
  386. break;
  387. case 0: /* OK, nobody likes this call */
  388. default: /* statcallb problems */
  389. chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
  390. chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
  391. FsmChangeState(fi, ST_NULL);
  392. break;
  393. }
  394. } else {
  395. chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
  396. chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
  397. }
  398. }
  400. static void
  401. lli_send_dconnect(struct FsmInst *fi, int event, void *arg)
  402. {
  403. struct Channel *chanp = fi->userdata;
  405. FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
  406. chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
  407. }
  409. static void
  410. lli_send_alert(struct FsmInst *fi, int event, void *arg)
  411. {
  412. struct Channel *chanp = fi->userdata;
  414. FsmChangeState(fi, ST_IN_ALERT_SENT);
  415. chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
  416. }
  418. static void
  419. lli_send_redir(struct FsmInst *fi, int event, void *arg)
  420. {
  421. struct Channel *chanp = fi->userdata;
  423. chanp->d_st->lli.l4l3(chanp->d_st, CC_REDIR | REQUEST, chanp->proc);
  424. }
  426. static void
  427. lli_init_bchan_in(struct FsmInst *fi, int event, void *arg)
  428. {
  429. struct Channel *chanp = fi->userdata;
  431. FsmChangeState(fi, ST_WAIT_BCONN);
  432. if (chanp->debug & 1)
  433. link_debug(chanp, 0, "STAT_DCONN");
  434. HL_LL(chanp, ISDN_STAT_DCONN);
  435. chanp->l2_active_protocol = chanp->l2_protocol;
  436. chanp->incoming = !0;
  437. init_b_st(chanp, !0);
  438. chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
  439. }
  441. static void
  442. lli_setup_rsp(struct FsmInst *fi, int event, void *arg)
  443. {
  444. struct Channel *chanp = fi->userdata;
  446. if (chanp->leased) {
  447. lli_init_bchan_in(fi, event, arg);
  448. } else {
  449. FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
  450. #ifdef WANT_ALERT
  451. chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
  452. #endif
  453. chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
  454. }
  455. }
  457. /* Call suspend */
  459. static void
  460. lli_suspend(struct FsmInst *fi, int event, void *arg)
  461. {
  462. struct Channel *chanp = fi->userdata;
  464. chanp->d_st->lli.l4l3(chanp->d_st, CC_SUSPEND | REQUEST, chanp->proc);
  465. }
  467. /* Call clearing */
  469. static void
  470. lli_leased_hup(struct FsmInst *fi, struct Channel *chanp)
  471. {
  472. isdn_ctrl ic;
  474. ic.driver = chanp->cs->myid;
  475. ic.command = ISDN_STAT_CAUSE;
  476. ic.arg = chanp->chan;
  477. sprintf(ic.parm.num, "L0010");
  478. chanp->cs->iif.statcallb(&ic);
  479. if (chanp->debug & 1)
  480. link_debug(chanp, 0, "STAT_DHUP");
  481. HL_LL(chanp, ISDN_STAT_DHUP);
  482. lli_close(fi);
  483. }
  485. static void
  486. lli_disconnect_req(struct FsmInst *fi, int event, void *arg)
  487. {
  488. struct Channel *chanp = fi->userdata;
  490. if (chanp->leased) {
  491. lli_leased_hup(fi, chanp);
  492. } else {
  493. FsmChangeState(fi, ST_WAIT_DRELEASE);
  494. if (chanp->proc)
  495. chanp->proc->para.cause = 0x10; /* Normal Call Clearing */
  496. chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
  497. chanp->proc);
  498. }
  499. }
  501. static void
  502. lli_disconnect_reject(struct FsmInst *fi, int event, void *arg)
  503. {
  504. struct Channel *chanp = fi->userdata;
  506. if (chanp->leased) {
  507. lli_leased_hup(fi, chanp);
  508. } else {
  509. FsmChangeState(fi, ST_WAIT_DRELEASE);
  510. if (chanp->proc)
  511. chanp->proc->para.cause = 0x15; /* Call Rejected */
  512. chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
  513. chanp->proc);
  514. }
  515. }
  517. static void
  518. lli_dhup_close(struct FsmInst *fi, int event, void *arg)
  519. {
  520. struct Channel *chanp = fi->userdata;
  522. if (chanp->leased) {
  523. lli_leased_hup(fi, chanp);
  524. } else {
  525. if (chanp->debug & 1)
  526. link_debug(chanp, 0, "STAT_DHUP");
  527. lli_deliver_cause(chanp);
  528. HL_LL(chanp, ISDN_STAT_DHUP);
  529. lli_close(fi);
  530. }
  531. }
  533. static void
  534. lli_reject_req(struct FsmInst *fi, int event, void *arg)
  535. {
  536. struct Channel *chanp = fi->userdata;
  538. if (chanp->leased) {
  539. lli_leased_hup(fi, chanp);
  540. return;
  541. }
  542. #ifndef ALERT_REJECT
  543. if (chanp->proc)
  544. chanp->proc->para.cause = 0x15; /* Call Rejected */
  545. chanp->d_st->lli.l4l3(chanp->d_st, CC_REJECT | REQUEST, chanp->proc);
  546. lli_dhup_close(fi, event, arg);
  547. #else
  548. FsmRestartTimer(&chanp->drel_timer, 40, EV_HANGUP, NULL, 63);
  549. FsmChangeState(fi, ST_IN_ALERT_SENT);
  550. chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
  551. #endif
  552. }
  554. static void
  555. lli_disconn_bchan(struct FsmInst *fi, int event, void *arg)
  556. {
  557. struct Channel *chanp = fi->userdata;
  559. chanp->data_open = 0;
  560. FsmChangeState(fi, ST_WAIT_BRELEASE);
  561. chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
  562. }
  564. static void
  565. lli_start_disc(struct FsmInst *fi, int event, void *arg)
  566. {
  567. struct Channel *chanp = fi->userdata;
  569. if (chanp->leased) {
  570. lli_leased_hup(fi, chanp);
  571. } else {
  572. lli_disconnect_req(fi, event, arg);
  573. }
  574. }
  576. static void
  577. lli_rel_b_disc(struct FsmInst *fi, int event, void *arg)
  578. {
  579. struct Channel *chanp = fi->userdata;
  581. release_b_st(chanp);
  582. lli_start_disc(fi, event, arg);
  583. }
  585. static void
  586. lli_bhup_disc(struct FsmInst *fi, int event, void *arg)
  587. {
  588. struct Channel *chanp = fi->userdata;
  589.  
  590. if (chanp->debug & 1)
  591. link_debug(chanp, 0, "STAT_BHUP");
  592. HL_LL(chanp, ISDN_STAT_BHUP);
  593. lli_rel_b_disc(fi, event, arg);
  594. }
  596. static void
  597. lli_bhup_rel_b(struct FsmInst *fi, int event, void *arg)
  598. {
  599. struct Channel *chanp = fi->userdata;
  601. FsmChangeState(fi, ST_WAIT_DCOMMAND);
  602. chanp->data_open = 0;
  603. if (chanp->debug & 1)
  604. link_debug(chanp, 0, "STAT_BHUP");
  605. HL_LL(chanp, ISDN_STAT_BHUP);
  606. release_b_st(chanp);
  607. }
  609. static void
  610. lli_release_bchan(struct FsmInst *fi, int event, void *arg)
  611. {
  612. struct Channel *chanp = fi->userdata;
  614. chanp->data_open = 0;
  615. FsmChangeState(fi, ST_WAIT_BREL_DISC);
  616. chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
  617. }
  620. static void
  621. lli_rel_b_dhup(struct FsmInst *fi, int event, void *arg)
  622. {
  623. struct Channel *chanp = fi->userdata;
  625. release_b_st(chanp);
  626. lli_dhup_close(fi, event, arg);
  627. }
  629. static void
  630. lli_bhup_dhup(struct FsmInst *fi, int event, void *arg)
  631. {
  632. struct Channel *chanp = fi->userdata;
  634. if (chanp->debug & 1)
  635. link_debug(chanp, 0, "STAT_BHUP");
  636. HL_LL(chanp, ISDN_STAT_BHUP);
  637. lli_rel_b_dhup(fi, event, arg);
  638. }
  640. static void
  641. lli_abort(struct FsmInst *fi, int event, void *arg)
  642. {
  643. struct Channel *chanp = fi->userdata;
  645. chanp->data_open = 0;
  646. chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
  647. lli_bhup_dhup(fi, event, arg);
  648. }
  649.  
  650. static void
  651. lli_release_req(struct FsmInst *fi, int event, void *arg)
  652. {
  653. struct Channel *chanp = fi->userdata;
  655. if (chanp->leased) {
  656. lli_leased_hup(fi, chanp);
  657. } else {
  658. FsmChangeState(fi, ST_WAIT_D_REL_CNF);
  659. chanp->d_st->lli.l4l3(chanp->d_st, CC_RELEASE | REQUEST,
  660. chanp->proc);
  661. }
  662. }
  664. static void
  665. lli_rel_b_release_req(struct FsmInst *fi, int event, void *arg)
  666. {
  667. struct Channel *chanp = fi->userdata;
  669. release_b_st(chanp);
  670. lli_release_req(fi, event, arg);
  671. }
  673. static void
  674. lli_bhup_release_req(struct FsmInst *fi, int event, void *arg)
  675. {
  676. struct Channel *chanp = fi->userdata;
  677.  
  678. if (chanp->debug & 1)
  679. link_debug(chanp, 0, "STAT_BHUP");
  680. HL_LL(chanp, ISDN_STAT_BHUP);
  681. lli_rel_b_release_req(fi, event, arg);
  682. }
  685. /* processing charge info */
  686. static void
  687. lli_charge_info(struct FsmInst *fi, int event, void *arg)
  688. {
  689. struct Channel *chanp = fi->userdata;
  690. isdn_ctrl ic;
  692. ic.driver = chanp->cs->myid;
  693. ic.command = ISDN_STAT_CINF;
  694. ic.arg = chanp->chan;
  695. sprintf(ic.parm.num, "%d", chanp->proc->para.chargeinfo);
  696. chanp->cs->iif.statcallb(&ic);
  697. }
  699. /* error procedures */
  701. static void
  702. lli_dchan_not_ready(struct FsmInst *fi, int event, void *arg)
  703. {
  704. struct Channel *chanp = fi->userdata;
  706. if (chanp->debug & 1)
  707. link_debug(chanp, 0, "STAT_DHUP");
  708. HL_LL(chanp, ISDN_STAT_DHUP); 
  709. }
  711. static void
  712. lli_no_setup_rsp(struct FsmInst *fi, int event, void *arg)
  713. {
  714. struct Channel *chanp = fi->userdata;
  716. if (chanp->debug & 1)
  717. link_debug(chanp, 0, "STAT_DHUP");
  718. HL_LL(chanp, ISDN_STAT_DHUP);
  719. lli_close(fi); 
  720. }
  722. static void
  723. lli_error(struct FsmInst *fi, int event, void *arg)
  724. {
  725. FsmChangeState(fi, ST_WAIT_DRELEASE);
  726. }
  728. static void
  729. lli_failure_l(struct FsmInst *fi, int event, void *arg)
  730. {
  731. struct Channel *chanp = fi->userdata;
  732. isdn_ctrl ic;
  734. FsmChangeState(fi, ST_NULL);
  735. ic.driver = chanp->cs->myid;
  736. ic.command = ISDN_STAT_CAUSE;
  737. ic.arg = chanp->chan;
  738. sprintf(ic.parm.num, "L%02X%02X", 0, 0x2f);
  739. chanp->cs->iif.statcallb(&ic);
  740. HL_LL(chanp, ISDN_STAT_DHUP);
  741. chanp->Flags = 0;
  742. chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
  743. }
  745. static void
  746. lli_rel_b_fail(struct FsmInst *fi, int event, void *arg)
  747. {
  748. struct Channel *chanp = fi->userdata;
  750. release_b_st(chanp);
  751. lli_failure_l(fi, event, arg);
  752. }
  754. static void
  755. lli_bhup_fail(struct FsmInst *fi, int event, void *arg)
  756. {
  757. struct Channel *chanp = fi->userdata;
  759. if (chanp->debug & 1)
  760. link_debug(chanp, 0, "STAT_BHUP");
  761. HL_LL(chanp, ISDN_STAT_BHUP);
  762. lli_rel_b_fail(fi, event, arg);
  763. }
  765. static void
  766. lli_failure_a(struct FsmInst *fi, int event, void *arg)
  767. {
  768. struct Channel *chanp = fi->userdata;
  770. chanp->data_open = 0;
  771. chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
  772. lli_bhup_fail(fi, event, arg);
  773. }
  775. /* *INDENT-OFF* */
  776. static struct FsmNode fnlist[] __initdata =
  777. {
  778.         {ST_NULL,               EV_DIAL,                lli_prep_dialout},
  779.         {ST_NULL,               EV_RESUME,              lli_resume},
  780.         {ST_NULL,               EV_SETUP_IND,           lli_deliver_call},
  781.         {ST_NULL,               EV_LEASED,              lli_leased_in},
  782.         {ST_OUT_DIAL,           EV_SETUP_CNF,           lli_init_bchan_out},
  783.         {ST_OUT_DIAL,           EV_HANGUP,              lli_disconnect_req},
  784.         {ST_OUT_DIAL,           EV_DISCONNECT_IND,      lli_release_req},
  785.         {ST_OUT_DIAL,           EV_RELEASE,             lli_dhup_close},
  786.         {ST_OUT_DIAL,           EV_NOSETUP_RSP,         lli_no_setup_rsp},
  787.         {ST_OUT_DIAL,           EV_SETUP_ERR,           lli_error},
  788.         {ST_IN_WAIT_LL,         EV_LEASED_REL,          lli_failure_l},
  789.         {ST_IN_WAIT_LL,         EV_ACCEPTD,             lli_setup_rsp},
  790.         {ST_IN_WAIT_LL,         EV_HANGUP,              lli_reject_req},
  791.         {ST_IN_WAIT_LL,         EV_DISCONNECT_IND,      lli_release_req},
  792.         {ST_IN_WAIT_LL,         EV_RELEASE,             lli_dhup_close},
  793.         {ST_IN_WAIT_LL,         EV_SETUP_IND,           lli_deliver_call},
  794.         {ST_IN_WAIT_LL,         EV_SETUP_ERR,           lli_error},
  795.         {ST_IN_ALERT_SENT,      EV_SETUP_CMPL_IND,      lli_init_bchan_in},
  796.         {ST_IN_ALERT_SENT,      EV_ACCEPTD,             lli_send_dconnect},
  797.         {ST_IN_ALERT_SENT,      EV_HANGUP,              lli_disconnect_reject},
  798.         {ST_IN_ALERT_SENT,      EV_DISCONNECT_IND,      lli_release_req},
  799.         {ST_IN_ALERT_SENT,      EV_RELEASE,             lli_dhup_close},
  800. {ST_IN_ALERT_SENT, EV_REDIR, lli_send_redir},
  801. {ST_IN_PROCEED_SEND, EV_REDIR, lli_send_redir},
  802. {ST_IN_PROCEED_SEND, EV_ALERT, lli_send_alert},
  803. {ST_IN_PROCEED_SEND, EV_ACCEPTD, lli_send_dconnect},
  804. {ST_IN_PROCEED_SEND, EV_HANGUP, lli_disconnect_reject},
  805. {ST_IN_PROCEED_SEND, EV_DISCONNECT_IND, lli_dhup_close},
  806.         {ST_IN_ALERT_SENT,      EV_RELEASE,             lli_dhup_close},
  807.         {ST_IN_WAIT_CONN_ACK,   EV_SETUP_CMPL_IND,      lli_init_bchan_in},
  808.         {ST_IN_WAIT_CONN_ACK,   EV_HANGUP,              lli_disconnect_req},
  809.         {ST_IN_WAIT_CONN_ACK,   EV_DISCONNECT_IND,      lli_release_req},
  810.         {ST_IN_WAIT_CONN_ACK,   EV_RELEASE,             lli_dhup_close},
  811.         {ST_IN_WAIT_CONN_ACK,   EV_CONNECT_ERR,         lli_error},
  812.         {ST_WAIT_BCONN,         EV_BC_EST,              lli_go_active},
  813.         {ST_WAIT_BCONN,         EV_BC_REL,              lli_rel_b_disc},
  814.         {ST_WAIT_BCONN,         EV_HANGUP,              lli_rel_b_disc},
  815.         {ST_WAIT_BCONN,         EV_DISCONNECT_IND,      lli_rel_b_release_req},
  816.         {ST_WAIT_BCONN,         EV_RELEASE,             lli_rel_b_dhup},
  817.         {ST_WAIT_BCONN,         EV_LEASED_REL,          lli_rel_b_fail},
  818.         {ST_WAIT_BCONN,         EV_CINF,                lli_charge_info},
  819.         {ST_ACTIVE,             EV_CINF,                lli_charge_info},
  820.         {ST_ACTIVE,             EV_BC_REL,              lli_bhup_rel_b},
  821.         {ST_ACTIVE,             EV_SUSPEND,             lli_suspend},
  822.         {ST_ACTIVE,             EV_HANGUP,              lli_disconn_bchan},
  823.         {ST_ACTIVE,             EV_DISCONNECT_IND,      lli_release_bchan},
  824.         {ST_ACTIVE,             EV_RELEASE,             lli_abort},
  825.         {ST_ACTIVE,             EV_LEASED_REL,          lli_failure_a},
  826.         {ST_WAIT_BRELEASE,      EV_BC_REL,              lli_bhup_disc},
  827.         {ST_WAIT_BRELEASE,      EV_DISCONNECT_IND,      lli_bhup_release_req},
  828.         {ST_WAIT_BRELEASE,      EV_RELEASE,             lli_bhup_dhup},
  829.         {ST_WAIT_BRELEASE,      EV_LEASED_REL,          lli_bhup_fail},
  830.         {ST_WAIT_BREL_DISC,     EV_BC_REL,              lli_bhup_release_req},
  831.         {ST_WAIT_BREL_DISC,     EV_RELEASE,             lli_bhup_dhup},
  832.         {ST_WAIT_DCOMMAND,      EV_HANGUP,              lli_start_disc},
  833.         {ST_WAIT_DCOMMAND,      EV_DISCONNECT_IND,      lli_release_req},
  834.         {ST_WAIT_DCOMMAND,      EV_RELEASE,             lli_dhup_close},
  835.         {ST_WAIT_DCOMMAND,      EV_LEASED_REL,          lli_failure_l},
  836.         {ST_WAIT_DRELEASE,      EV_RELEASE,             lli_dhup_close},
  837.         {ST_WAIT_DRELEASE,      EV_DIAL,                lli_dchan_not_ready},
  838.   /* ETS 300-104 16.1 */
  839.         {ST_WAIT_D_REL_CNF,     EV_RELEASE,             lli_dhup_close},
  840.         {ST_WAIT_D_REL_CNF,     EV_DIAL,                lli_dchan_not_ready},
  841. };
  842. /* *INDENT-ON* */
  844. #define FNCOUNT (sizeof(fnlist)/sizeof(struct FsmNode))
  846. int __init
  847. CallcNew(void)
  848. {
  849. callcfsm.state_count = STATE_COUNT;
  850. callcfsm.event_count = EVENT_COUNT;
  851. callcfsm.strEvent = strEvent;
  852. callcfsm.strState = strState;
  853. return FsmNew(&callcfsm, fnlist, FNCOUNT);
  854. }
  856. void
  857. CallcFree(void)
  858. {
  859. FsmFree(&callcfsm);
  860. }
  862. static void
  863. release_b_st(struct Channel *chanp)
  864. {
  865. struct PStack *st = chanp->b_st;
  867. if(test_and_clear_bit(FLG_START_B, &chanp->Flags)) {
  868. chanp->bcs->BC_Close(chanp->bcs);
  869. switch (chanp->l2_active_protocol) {
  870. case (ISDN_PROTO_L2_X75I):
  871. releasestack_isdnl2(st);
  872. break;
  873. case (ISDN_PROTO_L2_HDLC):
  874. case (ISDN_PROTO_L2_HDLC_56K):
  875. case (ISDN_PROTO_L2_TRANS):
  876. case (ISDN_PROTO_L2_MODEM):
  877. case (ISDN_PROTO_L2_FAX):
  878. releasestack_transl2(st);
  879. break;
  880. }
  881. } 
  882. }
  884. struct Channel
  885. *selectfreechannel(struct PStack *st, int bch)
  886. {
  887. struct IsdnCardState *cs = st->l1.hardware;
  888. struct Channel *chanp = st->lli.userdata;
  889. int i;
  891. if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
  892. i=1;
  893. else
  894. i=0;
  896. if (!bch) {
  897. i = 2; /* virtual channel */
  898. chanp += 2;
  899. }
  901. while (i < ((bch) ? cs->chanlimit : (2 + MAX_WAITING_CALLS))) {
  902. if (chanp->fi.state == ST_NULL)
  903. return (chanp);
  904. chanp++;
  905. i++;
  906. }
  908. if (bch) /* number of channels is limited */ {
  909. i = 2; /* virtual channel */
  910. chanp = st->lli.userdata;
  911. chanp += i;
  912. while (i < (2 + MAX_WAITING_CALLS)) {
  913. if (chanp->fi.state == ST_NULL)
  914. return (chanp);
  915. chanp++;
  916. i++;
  917. }
  918. }
  919. return (NULL);
  920. }
  922. static void stat_redir_result(struct IsdnCardState *cs, int chan, ulong result)
  923. { isdn_ctrl ic;
  924.   
  925. ic.driver = cs->myid;
  926. ic.command = ISDN_STAT_REDIR;
  927. ic.arg = chan; 
  928. (ulong)(ic.parm.num[0]) = result;
  929. cs->iif.statcallb(&ic);
  930. } /* stat_redir_result */
  932. static void
  933. dchan_l3l4(struct PStack *st, int pr, void *arg)
  934. {
  935. struct l3_process *pc = arg;
  936. struct IsdnCardState *cs = st->l1.hardware;
  937. struct Channel *chanp;
  939. if(!pc)
  940. return;
  942. if (pr == (CC_SETUP | INDICATION)) {
  943. if (!(chanp = selectfreechannel(pc->st, pc->para.bchannel))) {
  944. pc->para.cause = 0x11; /* User busy */
  945. pc->st->lli.l4l3(pc->st, CC_REJECT | REQUEST, pc);
  946. } else {
  947. chanp->proc = pc;
  948. pc->chan = chanp;
  949. FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
  950. }
  951. return;
  952. }
  953. if (!(chanp = pc->chan))
  954. return;
  956. switch (pr) {
  957. case (CC_MORE_INFO | INDICATION):
  958. FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
  959. break;
  960. case (CC_DISCONNECT | INDICATION):
  961. FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
  962. break;
  963. case (CC_RELEASE | CONFIRM):
  964. FsmEvent(&chanp->fi, EV_RELEASE, NULL);
  965. break;
  966. case (CC_SUSPEND | CONFIRM):
  967. FsmEvent(&chanp->fi, EV_RELEASE, NULL);
  968. break;
  969. case (CC_RESUME | CONFIRM):
  970. FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
  971. break;
  972. case (CC_RESUME_ERR):
  973. FsmEvent(&chanp->fi, EV_RELEASE, NULL);
  974. break;
  975. case (CC_RELEASE | INDICATION):
  976. FsmEvent(&chanp->fi, EV_RELEASE, NULL);
  977. break;
  978. case (CC_SETUP_COMPL | INDICATION):
  979. FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
  980. break;
  981. case (CC_SETUP | CONFIRM):
  982. FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
  983. break;
  984. case (CC_CHARGE | INDICATION):
  985. FsmEvent(&chanp->fi, EV_CINF, NULL);
  986. break;
  987. case (CC_NOSETUP_RSP):
  988. FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
  989. break;
  990. case (CC_SETUP_ERR):
  991. FsmEvent(&chanp->fi, EV_SETUP_ERR, NULL);
  992. break;
  993. case (CC_CONNECT_ERR):
  994. FsmEvent(&chanp->fi, EV_CONNECT_ERR, NULL);
  995. break;
  996. case (CC_RELEASE_ERR):
  997. FsmEvent(&chanp->fi, EV_RELEASE, NULL);
  998. break;
  999. case (CC_PROCEED_SEND | INDICATION):
  1000. case (CC_PROCEEDING | INDICATION):
  1001. case (CC_ALERTING | INDICATION):
  1002. case (CC_PROGRESS | INDICATION):
  1003. case (CC_NOTIFY | INDICATION):
  1004. break;
  1005. case (CC_REDIR | INDICATION):
  1006. stat_redir_result(cs, chanp->chan, pc->redir_result); 
  1007. break;
  1008. default:
  1009. if (chanp->debug & 0x800) {
  1010. HiSax_putstatus(chanp->cs, "Ch",
  1011. "%d L3->L4 unknown primitiv %#x",
  1012. chanp->chan, pr);
  1013. }
  1014. }
  1015. }
  1017. static void
  1018. dummy_pstack(struct PStack *st, int pr, void *arg) {
  1019. printk(KERN_WARNING"call to dummy_pstack pr=%04x arg %lxn", pr, (long)arg);
  1020. }
  1022. static int
  1023. init_PStack(struct PStack **stp) {
  1024. *stp = kmalloc(sizeof(struct PStack), GFP_ATOMIC);
  1025. if (!*stp)
  1026. return -ENOMEM;
  1027. (*stp)->next = NULL;
  1028. (*stp)->l1.l1l2 = dummy_pstack;
  1029. (*stp)->l1.l1hw = dummy_pstack;
  1030. (*stp)->l1.l1tei = dummy_pstack;
  1031. (*stp)->l2.l2tei = dummy_pstack;
  1032. (*stp)->l2.l2l1 = dummy_pstack;
  1033. (*stp)->l2.l2l3 = dummy_pstack;
  1034. (*stp)->l3.l3l2 = dummy_pstack;
  1035. (*stp)->l3.l3ml3 = dummy_pstack;
  1036. (*stp)->l3.l3l4 = dummy_pstack;
  1037. (*stp)->lli.l4l3 = dummy_pstack;
  1038. (*stp)->ma.layer = dummy_pstack;
  1039. return 0;
  1040. }
  1042. static int
  1043. init_d_st(struct Channel *chanp)
  1044. {
  1045. struct PStack *st;
  1046. struct IsdnCardState *cs = chanp->cs;
  1047. char tmp[16];
  1048. int err;
  1050. err = init_PStack(&chanp->d_st);
  1051. if (err)
  1052. return err;
  1053. st = chanp->d_st;
  1054. st->next = NULL;
  1055. HiSax_addlist(cs, st);
  1056. setstack_HiSax(st, cs);
  1057. st->l2.sap = 0;
  1058. st->l2.tei = -1;
  1059. st->l2.flag = 0;
  1060. test_and_set_bit(FLG_MOD128, &st->l2.flag);
  1061. test_and_set_bit(FLG_LAPD, &st->l2.flag);
  1062. test_and_set_bit(FLG_ORIG, &st->l2.flag);
  1063. st->l2.maxlen = MAX_DFRAME_LEN;
  1064. st->l2.window = 1;
  1065. st->l2.T200 = 1000; /* 1000 milliseconds  */
  1066. st->l2.N200 = 3; /* try 3 times        */
  1067. st->l2.T203 = 10000; /* 10000 milliseconds */
  1068. if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
  1069. sprintf(tmp, "DCh%d Q.921 ", chanp->chan);
  1070. else
  1071. sprintf(tmp, "DCh Q.921 ");
  1072. setstack_isdnl2(st, tmp);
  1073. setstack_l3dc(st, chanp);
  1074. st->lli.userdata = chanp;
  1075. st->lli.l2writewakeup = NULL;
  1076. st->l3.l3l4 = dchan_l3l4;
  1078. return 0;
  1079. }
  1081. static void
  1082. callc_debug(struct FsmInst *fi, char *fmt, ...)
  1083. {
  1084. va_list args;
  1085. struct Channel *chanp = fi->userdata;
  1086. char tmp[16];
  1088. va_start(args, fmt);
  1089. sprintf(tmp, "Ch%d callc ", chanp->chan);
  1090. VHiSax_putstatus(chanp->cs, tmp, fmt, args);
  1091. va_end(args);
  1092. }
  1094. static int
  1095. init_chan(int chan, struct IsdnCardState *csta)
  1096. {
  1097. struct Channel *chanp = csta->channel + chan;
  1098. int err;
  1100. chanp->cs = csta;
  1101. chanp->bcs = csta->bcs + chan;
  1102. chanp->chan = chan;
  1103. chanp->incoming = 0;
  1104. chanp->debug = 0;
  1105. chanp->Flags = 0;
  1106. chanp->leased = 0;
  1107. err = init_PStack(&chanp->b_st);
  1108. if (err)
  1109. return err;
  1110. chanp->b_st->l1.delay = DEFAULT_B_DELAY;
  1111. chanp->fi.fsm = &callcfsm;
  1112. chanp->fi.state = ST_NULL;
  1113. chanp->fi.debug = 0;
  1114. chanp->fi.userdata = chanp;
  1115. chanp->fi.printdebug = callc_debug;
  1116. FsmInitTimer(&chanp->fi, &chanp->dial_timer);
  1117. FsmInitTimer(&chanp->fi, &chanp->drel_timer);
  1118. if (!chan || (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags) && chan < 2)) {
  1119. err = init_d_st(chanp);
  1120. if (err)
  1121. return err;
  1122. } else {
  1123. chanp->d_st = csta->channel->d_st;
  1124. }
  1125. chanp->data_open = 0;
  1126. return 0;
  1127. }
  1129. int
  1130. CallcNewChan(struct IsdnCardState *csta) {
  1131. int i, err;
  1133. chancount += 2;
  1134. err = init_chan(0, csta);
  1135. if (err)
  1136. return err;
  1137. err = init_chan(1, csta);
  1138. if (err)
  1139. return err;
  1140. printk(KERN_INFO "HiSax: 2 channels addedn");
  1142. for (i = 0; i < MAX_WAITING_CALLS; i++) { 
  1143. err = init_chan(i+2,csta);
  1144. if (err)
  1145. return err;
  1146. }
  1147. printk(KERN_INFO "HiSax: MAX_WAITING_CALLS addedn");
  1148. if (test_bit(FLG_PTP, &csta->channel->d_st->l2.flag)) {
  1149. printk(KERN_INFO "LAYER2 WATCHING ESTABLISHn");
  1150. csta->channel->d_st->lli.l4l3(csta->channel->d_st,
  1151. DL_ESTABLISH | REQUEST, NULL);
  1152. }
  1153. return (0);
  1154. }
  1156. static void
  1157. release_d_st(struct Channel *chanp)
  1158. {
  1159. struct PStack *st = chanp->d_st;
  1161. if (!st)
  1162. return;
  1163. releasestack_isdnl2(st);
  1164. releasestack_isdnl3(st);
  1165. HiSax_rmlist(st->l1.hardware, st);
  1166. kfree(st);
  1167. chanp->d_st = NULL;
  1168. }
  1170. void
  1171. CallcFreeChan(struct IsdnCardState *csta)
  1172. {
  1173. int i;
  1175. for (i = 0; i < 2; i++) {
  1176. FsmDelTimer(&csta->channel[i].drel_timer, 74);
  1177. FsmDelTimer(&csta->channel[i].dial_timer, 75);
  1178. if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags))
  1179. release_d_st(csta->channel + i);
  1180. if (csta->channel[i].b_st) {
  1181. release_b_st(csta->channel + i);
  1182. kfree(csta->channel[i].b_st);
  1183. csta->channel[i].b_st = NULL;
  1184. } else
  1185. printk(KERN_WARNING "CallcFreeChan b_st ch%d allready freedn", i);
  1186. if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
  1187. release_d_st(csta->channel + i);
  1188. } else
  1189. csta->channel[i].d_st = NULL;
  1190. }
  1191. }
  1193. static void
  1194. lldata_handler(struct PStack *st, int pr, void *arg)
  1195. {
  1196. struct Channel *chanp = (struct Channel *) st->lli.userdata;
  1197. struct sk_buff *skb = arg;
  1199. switch (pr) {
  1200. case (DL_DATA  | INDICATION):
  1201. if (chanp->data_open) {
  1202. if (chanp->debug & 0x800)
  1203. link_debug(chanp, 0, "lldata: %d", skb->len);
  1204. chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
  1205. } else {
  1206. link_debug(chanp, 0, "lldata: channel not open");
  1207. dev_kfree_skb(skb);
  1208. }
  1209. break;
  1210. case (DL_ESTABLISH | INDICATION):
  1211. case (DL_ESTABLISH | CONFIRM):
  1212. FsmEvent(&chanp->fi, EV_BC_EST, NULL);
  1213. break;
  1214. case (DL_RELEASE | INDICATION):
  1215. case (DL_RELEASE | CONFIRM):
  1216. FsmEvent(&chanp->fi, EV_BC_REL, NULL);
  1217. break;
  1218. default:
  1219. printk(KERN_WARNING "lldata_handler unknown primitive %#xn",
  1220. pr);
  1221. break;
  1222. }
  1223. }
  1225. static void
  1226. lltrans_handler(struct PStack *st, int pr, void *arg)
  1227. {
  1228. struct Channel *chanp = (struct Channel *) st->lli.userdata;
  1229. struct sk_buff *skb = arg;
  1231. switch (pr) {
  1232. case (PH_DATA | INDICATION):
  1233. if (chanp->data_open) {
  1234. if (chanp->debug & 0x800)
  1235. link_debug(chanp, 0, "lltrans: %d", skb->len);
  1236. chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
  1237. } else {
  1238. link_debug(chanp, 0, "lltrans: channel not open");
  1239. dev_kfree_skb(skb);
  1240. }
  1241. break;
  1242. case (PH_ACTIVATE | INDICATION):
  1243. case (PH_ACTIVATE | CONFIRM):
  1244. FsmEvent(&chanp->fi, EV_BC_EST, NULL);
  1245. break;
  1246. case (PH_DEACTIVATE | INDICATION):
  1247. case (PH_DEACTIVATE | CONFIRM):
  1248. FsmEvent(&chanp->fi, EV_BC_REL, NULL);
  1249. break;
  1250. default:
  1251. printk(KERN_WARNING "lltrans_handler unknown primitive %#xn",
  1252. pr);
  1253. break;
  1254. }
  1255. }
  1257. static void
  1258. ll_writewakeup(struct PStack *st, int len)
  1259. {
  1260. struct Channel *chanp = st->lli.userdata;
  1261. isdn_ctrl ic;
  1263. if (chanp->debug & 0x800)
  1264. link_debug(chanp, 0, "llwakeup: %d", len);
  1265. ic.driver = chanp->cs->myid;
  1266. ic.command = ISDN_STAT_BSENT;
  1267. ic.arg = chanp->chan;
  1268. ic.parm.length = len;
  1269. chanp->cs->iif.statcallb(&ic);
  1270. }
  1272. static int
  1273. init_b_st(struct Channel *chanp, int incoming)
  1274. {
  1275. struct PStack *st = chanp->b_st;
  1276. struct IsdnCardState *cs = chanp->cs;
  1277. char tmp[16];
  1279. st->l1.hardware = cs;
  1280. if (chanp->leased)
  1281. st->l1.bc = chanp->chan & 1;
  1282. else
  1283. st->l1.bc = chanp->proc->para.bchannel - 1;
  1284. switch (chanp->l2_active_protocol) {
  1285. case (ISDN_PROTO_L2_X75I):
  1286. case (ISDN_PROTO_L2_HDLC):
  1287. st->l1.mode = L1_MODE_HDLC;
  1288. break;
  1289. case (ISDN_PROTO_L2_HDLC_56K):
  1290. st->l1.mode = L1_MODE_HDLC_56K;
  1291. break;
  1292. case (ISDN_PROTO_L2_TRANS):
  1293. st->l1.mode = L1_MODE_TRANS;
  1294. break;
  1295. case (ISDN_PROTO_L2_MODEM):
  1296. st->l1.mode = L1_MODE_V32;
  1297. break;
  1298. case (ISDN_PROTO_L2_FAX):
  1299. st->l1.mode = L1_MODE_FAX;
  1300. break;
  1301. }
  1302. chanp->bcs->conmsg = NULL;
  1303. if (chanp->bcs->BC_SetStack(st, chanp->bcs))
  1304. return (-1);
  1305. st->l2.flag = 0;
  1306. test_and_set_bit(FLG_LAPB, &st->l2.flag);
  1307. st->l2.maxlen = MAX_DATA_SIZE;
  1308. if (!incoming)
  1309. test_and_set_bit(FLG_ORIG, &st->l2.flag);
  1310. st->l2.T200 = 1000; /* 1000 milliseconds */
  1311. st->l2.window = 7;
  1312. st->l2.N200 = 4; /* try 4 times       */
  1313. st->l2.T203 = 5000; /* 5000 milliseconds */
  1314. st->l3.debug = 0;
  1315. switch (chanp->l2_active_protocol) {
  1316. case (ISDN_PROTO_L2_X75I):
  1317. sprintf(tmp, "Ch%d X.75", chanp->chan);
  1318. setstack_isdnl2(st, tmp);
  1319. setstack_l3bc(st, chanp);
  1320. st->l2.l2l3 = lldata_handler;
  1321. st->lli.userdata = chanp;
  1322. st->lli.l1writewakeup = NULL;
  1323. st->lli.l2writewakeup = ll_writewakeup;
  1324. st->l2.l2m.debug = chanp->debug & 16;
  1325. st->l2.debug = chanp->debug & 64;
  1326. break;
  1327. case (ISDN_PROTO_L2_HDLC):
  1328. case (ISDN_PROTO_L2_HDLC_56K):
  1329. case (ISDN_PROTO_L2_TRANS):
  1330. case (ISDN_PROTO_L2_MODEM):
  1331. case (ISDN_PROTO_L2_FAX):
  1332. st->l1.l1l2 = lltrans_handler;
  1333. st->lli.userdata = chanp;
  1334. st->lli.l1writewakeup = ll_writewakeup;
  1335. setstack_transl2(st);
  1336. setstack_l3bc(st, chanp);
  1337. break;
  1338. }
  1339. test_and_set_bit(FLG_START_B, &chanp->Flags);
  1340. return (0);
  1341. }
  1343. static void
  1344. leased_l4l3(struct PStack *st, int pr, void *arg)
  1345. {
  1346. struct Channel *chanp = (struct Channel *) st->lli.userdata;
  1347. struct sk_buff *skb = arg;
  1349. switch (pr) {
  1350. case (DL_DATA | REQUEST):
  1351. link_debug(chanp, 0, "leased line d-channel DATA");
  1352. dev_kfree_skb(skb);
  1353. break;
  1354. case (DL_ESTABLISH | REQUEST):
  1355. st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
  1356. break;
  1357. case (DL_RELEASE | REQUEST):
  1358. break;
  1359. default:
  1360. printk(KERN_WARNING "transd_l4l3 unknown primitive %#xn",
  1361. pr);
  1362. break;
  1363. }
  1364. }
  1366. static void
  1367. leased_l1l2(struct PStack *st, int pr, void *arg)
  1368. {
  1369. struct Channel *chanp = (struct Channel *) st->lli.userdata;
  1370. struct sk_buff *skb = arg;
  1371. int i,event = EV_LEASED_REL;
  1373. switch (pr) {
  1374. case (PH_DATA | INDICATION):
  1375. link_debug(chanp, 0, "leased line d-channel DATA");
  1376. dev_kfree_skb(skb);
  1377. break;
  1378. case (PH_ACTIVATE | INDICATION):
  1379. case (PH_ACTIVATE | CONFIRM):
  1380. event = EV_LEASED;
  1381. case (PH_DEACTIVATE | INDICATION):
  1382. case (PH_DEACTIVATE | CONFIRM):
  1383. if (test_bit(FLG_TWO_DCHAN, &chanp->cs->HW_Flags))
  1384. i = 1;
  1385. else
  1386. i = 0;
  1387. while (i < 2) {
  1388. FsmEvent(&chanp->fi, event, NULL);
  1389. chanp++;
  1390. i++;
  1391. }
  1392. break;
  1393. default:
  1394. printk(KERN_WARNING
  1395. "transd_l1l2 unknown primitive %#xn", pr);
  1396. break;
  1397. }
  1398. }
  1400. static void
  1401. distr_debug(struct IsdnCardState *csta, int debugflags)
  1402. {
  1403. int i;
  1404. struct Channel *chanp = csta->channel;
  1406. for (i = 0; i < (2 + MAX_WAITING_CALLS) ; i++) {
  1407. chanp[i].debug = debugflags;
  1408. chanp[i].fi.debug = debugflags & 2;
  1409. chanp[i].d_st->l2.l2m.debug = debugflags & 8;
  1410. chanp[i].b_st->l2.l2m.debug = debugflags & 0x10;
  1411. chanp[i].d_st->l2.debug = debugflags & 0x20;
  1412. chanp[i].b_st->l2.debug = debugflags & 0x40;
  1413. chanp[i].d_st->l3.l3m.debug = debugflags & 0x80;
  1414. chanp[i].b_st->l3.l3m.debug = debugflags & 0x100;
  1415. chanp[i].b_st->ma.tei_m.debug = debugflags & 0x200;
  1416. chanp[i].b_st->ma.debug = debugflags & 0x200;
  1417. chanp[i].d_st->l1.l1m.debug = debugflags & 0x1000;
  1418. chanp[i].b_st->l1.l1m.debug = debugflags & 0x2000;
  1419. }
  1420. if (debugflags & 4)
  1421. csta->debug |= DEB_DLOG_HEX;
  1422. else
  1423. csta->debug &= ~DEB_DLOG_HEX;
  1424. }
  1426. static char tmpbuf[256];
  1428. static void
  1429. capi_debug(struct Channel *chanp, capi_msg *cm)
  1430. {
  1431. char *t = tmpbuf;
  1433. t += QuickHex(t, (u_char *)cm, (cm->Length>50)? 50: cm->Length);
  1434. t--;
  1435. *t= 0;
  1436. HiSax_putstatus(chanp->cs, "Ch", "%d CAPIMSG %s", chanp->chan, tmpbuf);
  1437. }
  1439. void
  1440. lli_got_fac_req(struct Channel *chanp, capi_msg *cm) {
  1441. if ((cm->para[0] != 3) || (cm->para[1] != 0))
  1442. return;
  1443. if (cm->para[2]<3)
  1444. return;
  1445. if (cm->para[4] != 0)
  1446. return;
  1447. switch(cm->para[3]) {
  1448. case 4: /* Suspend */
  1449. strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
  1450. FsmEvent(&chanp->fi, EV_SUSPEND, cm);
  1451. break;
  1452. case 5: /* Resume */
  1453. strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
  1454. if (chanp->fi.state == ST_NULL) {
  1455. FsmEvent(&chanp->fi, EV_RESUME, cm);
  1456. } else {
  1457. FsmDelTimer(&chanp->dial_timer, 72);
  1458. FsmAddTimer(&chanp->dial_timer, 80, EV_RESUME, cm, 73);
  1459. }
  1460. break;
  1461. }
  1462. }
  1464. void
  1465. lli_got_manufacturer(struct Channel *chanp, struct IsdnCardState *cs, capi_msg *cm) {
  1466. if ((cs->typ == ISDN_CTYPE_ELSA) || (cs->typ == ISDN_CTYPE_ELSA_PNP) ||
  1467. (cs->typ == ISDN_CTYPE_ELSA_PCI)) {
  1468. if (cs->hw.elsa.MFlag) {
  1469. cs->cardmsg(cs, CARD_AUX_IND, cm->para);
  1470. }
  1471. }
  1472. }
  1475. /***************************************************************/
  1476. /* Limit the available number of channels for the current card */
  1477. /***************************************************************/
  1478. static int 
  1479. set_channel_limit(struct IsdnCardState *cs, int chanmax)
  1480. {
  1481. isdn_ctrl ic;
  1482. int i, ii;
  1484. if ((chanmax < 0) || (chanmax > 2))
  1485. return(-EINVAL);
  1486. cs->chanlimit = 0;
  1487. for (ii = 0; ii < 2; ii++) {
  1488. ic.driver = cs->myid;
  1489. ic.command = ISDN_STAT_DISCH;
  1490. ic.arg = ii;
  1491. if (ii >= chanmax)
  1492. ic.parm.num[0] = 0; /* disabled */
  1493. else
  1494. ic.parm.num[0] = 1; /* enabled */
  1495. i = cs->iif.statcallb(&ic); 
  1496. if (i) return(-EINVAL);
  1497. if (ii < chanmax) 
  1498. cs->chanlimit++;
  1499. }
  1500. return(0);
  1501. } /* set_channel_limit */
  1503. int
  1504. HiSax_command(isdn_ctrl * ic)
  1505. {
  1506. struct IsdnCardState *csta = hisax_findcard(ic->driver);
  1507. struct PStack *st;
  1508. struct Channel *chanp;
  1509. int i;
  1510. u_int num;
  1512. if (!csta) {
  1513. printk(KERN_ERR
  1514. "HiSax: if_command %d called with invalid driverId %d!n",
  1515. ic->command, ic->driver);
  1516. return -ENODEV;
  1517. }
  1518. switch (ic->command) {
  1519. case (ISDN_CMD_SETEAZ):
  1520. chanp = csta->channel + ic->arg;
  1521. break;
  1522. case (ISDN_CMD_SETL2):
  1523. chanp = csta->channel + (ic->arg & 0xff);
  1524. if (chanp->debug & 1)
  1525. link_debug(chanp, 1, "SETL2 card %d %ld",
  1526. csta->cardnr + 1, ic->arg >> 8);
  1527. chanp->l2_protocol = ic->arg >> 8;
  1528. break;
  1529. case (ISDN_CMD_SETL3):
  1530. chanp = csta->channel + (ic->arg & 0xff);
  1531. if (chanp->debug & 1)
  1532. link_debug(chanp, 1, "SETL3 card %d %ld",
  1533. csta->cardnr + 1, ic->arg >> 8);
  1534. chanp->l3_protocol = ic->arg >> 8;
  1535. break;
  1536. case (ISDN_CMD_DIAL):
  1537. chanp = csta->channel + (ic->arg & 0xff);
  1538. if (chanp->debug & 1)
  1539. link_debug(chanp, 1, "DIAL %s -> %s (%d,%d)",
  1540. ic->parm.setup.eazmsn, ic->parm.setup.phone,
  1541. ic->parm.setup.si1, ic->parm.setup.si2);
  1542. memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
  1543. if (!strcmp(chanp->setup.eazmsn, "0"))
  1544. chanp->setup.eazmsn[0] = '';
  1545. /* this solution is dirty and may be change, if
  1546.  * we make a callreference based callmanager */
  1547. if (chanp->fi.state == ST_NULL) {
  1548. FsmEvent(&chanp->fi, EV_DIAL, NULL);
  1549. } else {
  1550. FsmDelTimer(&chanp->dial_timer, 70);
  1551. FsmAddTimer(&chanp->dial_timer, 50, EV_DIAL, NULL, 71);
  1552. }
  1553. break;
  1554. case (ISDN_CMD_ACCEPTB):
  1555. chanp = csta->channel + ic->arg;
  1556. if (chanp->debug & 1)
  1557. link_debug(chanp, 1, "ACCEPTB");
  1558. FsmEvent(&chanp->fi, EV_ACCEPTB, NULL);
  1559. break;
  1560. case (ISDN_CMD_ACCEPTD):
  1561. chanp = csta->channel + ic->arg;
  1562. memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
  1563. if (chanp->debug & 1)
  1564. link_debug(chanp, 1, "ACCEPTD");
  1565. FsmEvent(&chanp->fi, EV_ACCEPTD, NULL);
  1566. break;
  1567. case (ISDN_CMD_HANGUP):
  1568. chanp = csta->channel + ic->arg;
  1569. if (chanp->debug & 1)
  1570. link_debug(chanp, 1, "HANGUP");
  1571. FsmEvent(&chanp->fi, EV_HANGUP, NULL);
  1572. break;
  1573. case (CAPI_PUT_MESSAGE):
  1574. chanp = csta->channel + ic->arg;
  1575. if (chanp->debug & 1)
  1576. capi_debug(chanp, &ic->parm.cmsg);
  1577. if (ic->parm.cmsg.Length < 8)
  1578. break;
  1579. switch(ic->parm.cmsg.Command) {
  1580. case CAPI_FACILITY:
  1581. if (ic->parm.cmsg.Subcommand == CAPI_REQ)
  1582. lli_got_fac_req(chanp, &ic->parm.cmsg);
  1583. break;
  1584. case CAPI_MANUFACTURER:
  1585. if (ic->parm.cmsg.Subcommand == CAPI_REQ)
  1586. lli_got_manufacturer(chanp, csta, &ic->parm.cmsg);
  1587. break;
  1588. default:
  1589. break;
  1590. }
  1591. break;
  1592. case (ISDN_CMD_LOCK):
  1593. HiSax_mod_inc_use_count(csta);
  1594. #ifdef MODULE
  1595. if (csta->channel[0].debug & 0x400)
  1596. HiSax_putstatus(csta, "   LOCK ", "modcnt %lx",
  1597. MOD_USE_COUNT);
  1598. #endif /* MODULE */
  1599. break;
  1600. case (ISDN_CMD_UNLOCK):
  1601. HiSax_mod_dec_use_count(csta);
  1602. #ifdef MODULE
  1603. if (csta->channel[0].debug & 0x400)
  1604. HiSax_putstatus(csta, " UNLOCK ", "modcnt %lx",
  1605. MOD_USE_COUNT);
  1606. #endif /* MODULE */
  1607. break;
  1608. case (ISDN_CMD_IOCTL):
  1609. switch (ic->arg) {
  1610. case (0):
  1611. num = *(unsigned int *) ic->parm.num;
  1612. HiSax_reportcard(csta->cardnr, num);
  1613. break;
  1614. case (1):
  1615. num = *(unsigned int *) ic->parm.num;
  1616. distr_debug(csta, num);
  1617. printk(KERN_DEBUG "HiSax: debugging flags card %d set to %xn",
  1618. csta->cardnr + 1, num);
  1619. HiSax_putstatus(csta, "debugging flags ",
  1620. "card %d set to %x", csta->cardnr + 1, num);
  1621. break;
  1622. case (2):
  1623. num = *(unsigned int *) ic->parm.num;
  1624. csta->channel[0].b_st->l1.delay = num;
  1625. csta->channel[1].b_st->l1.delay = num;
  1626. HiSax_putstatus(csta, "delay ", "card %d set to %d ms",
  1627. csta->cardnr + 1, num);
  1628. printk(KERN_DEBUG "HiSax: delay card %d set to %d msn",
  1629. csta->cardnr + 1, num);
  1630. break;
  1631. case (3):
  1632. for (i = 0; i < *(unsigned int *) ic->parm.num; i++)
  1633. HiSax_mod_dec_use_count(NULL);
  1634. break;
  1635. case (4):
  1636. for (i = 0; i < *(unsigned int *) ic->parm.num; i++)
  1637. HiSax_mod_inc_use_count(NULL);
  1638. break;
  1639. case (5): /* set card in leased mode */
  1640. num = *(unsigned int *) ic->parm.num;
  1641. if ((num <1) || (num > 2)) {
  1642. HiSax_putstatus(csta, "Set LEASED ",
  1643. "wrong channel %d", num);
  1644. printk(KERN_WARNING "HiSax: Set LEASED wrong channel %dn",
  1645. num);
  1646. } else {
  1647. num--;
  1648. chanp = csta->channel +num;
  1649. chanp->leased = 1;
  1650. HiSax_putstatus(csta, "Card",
  1651. "%d channel %d set leased moden",
  1652. csta->cardnr + 1, num + 1);
  1653. chanp->d_st->l1.l1l2 = leased_l1l2;
  1654. chanp->d_st->lli.l4l3 = leased_l4l3;
  1655. chanp->d_st->lli.l4l3(chanp->d_st,
  1656. DL_ESTABLISH | REQUEST, NULL);
  1657. }
  1658. break;
  1659. case (6): /* set B-channel test loop */
  1660. num = *(unsigned int *) ic->parm.num;
  1661. if (csta->stlist)
  1662. csta->stlist->l2.l2l1(csta->stlist,
  1663. PH_TESTLOOP | REQUEST, (void *) (long)num);
  1664. break;
  1665. case (7): /* set card in PTP mode */
  1666. num = *(unsigned int *) ic->parm.num;
  1667. if (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
  1668. printk(KERN_ERR "HiSax PTP mode only with one TEI possiblen");
  1669. } else if (num) {
  1670. test_and_set_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
  1671. test_and_set_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
  1672. csta->channel[0].d_st->l2.tei = 0;
  1673. HiSax_putstatus(csta, "set card ", "in PTP mode");
  1674. printk(KERN_DEBUG "HiSax: set card in PTP moden");
  1675. printk(KERN_INFO "LAYER2 WATCHING ESTABLISHn");
  1676. csta->channel[0].d_st->lli.l4l3(csta->channel[0].d_st,
  1677. DL_ESTABLISH | REQUEST, NULL);
  1678. } else {
  1679. test_and_clear_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
  1680. test_and_clear_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
  1681. HiSax_putstatus(csta, "set card ", "in PTMP mode");
  1682. printk(KERN_DEBUG "HiSax: set card in PTMP moden");
  1683. }
  1684. break;
  1685. case (8): /* set card in FIXED TEI mode */
  1686. num = *(unsigned int *) ic->parm.num;
  1687. chanp = csta->channel + (num & 1);
  1688. num = num >>1;
  1689. if (num == 127) {
  1690. test_and_clear_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
  1691. chanp->d_st->l2.tei = -1;
  1692. HiSax_putstatus(csta, "set card ", "in VAR TEI mode");
  1693. printk(KERN_DEBUG "HiSax: set card in VAR TEI moden");
  1694. } else {
  1695. test_and_set_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
  1696. chanp->d_st->l2.tei = num;
  1697. HiSax_putstatus(csta, "set card ", "in FIXED TEI (%d) mode", num);
  1698. printk(KERN_DEBUG "HiSax: set card in FIXED TEI (%d) moden",
  1699. num);
  1700. }
  1701. chanp->d_st->lli.l4l3(chanp->d_st,
  1702. DL_ESTABLISH | REQUEST, NULL);
  1703. break;
  1704. #ifdef MODULE
  1705. case (55):
  1706. MOD_USE_COUNT = 0;
  1707. HiSax_mod_inc_use_count(NULL);
  1708. break;
  1709. #endif /* MODULE */
  1710. case (11):
  1711. num = csta->debug & DEB_DLOG_HEX;
  1712. csta->debug = *(unsigned int *) ic->parm.num;
  1713. csta->debug |= num;
  1714. HiSax_putstatus(cards[0].cs, "l1 debugging ",
  1715. "flags card %d set to %x",
  1716. csta->cardnr + 1, csta->debug);
  1717. printk(KERN_DEBUG "HiSax: l1 debugging flags card %d set to %xn",
  1718. csta->cardnr + 1, csta->debug);
  1719. break;
  1720. case (13):
  1721. csta->channel[0].d_st->l3.debug = *(unsigned int *) ic->parm.num;
  1722. csta->channel[1].d_st->l3.debug = *(unsigned int *) ic->parm.num;
  1723. HiSax_putstatus(cards[0].cs, "l3 debugging ",
  1724. "flags card %d set to %xn", csta->cardnr + 1,
  1725. *(unsigned int *) ic->parm.num);
  1726. printk(KERN_DEBUG "HiSax: l3 debugging flags card %d set to %xn",
  1727. csta->cardnr + 1, *(unsigned int *) ic->parm.num);
  1728. break;
  1729. case (10):
  1730. i = *(unsigned int *) ic->parm.num;
  1731. return(set_channel_limit(csta, i));
  1732. default:
  1733. if (csta->auxcmd)
  1734. return(csta->auxcmd(csta, ic));
  1735. printk(KERN_DEBUG "HiSax: invalid ioclt %dn",
  1736. (int) ic->arg);
  1737. return (-EINVAL);
  1738. }
  1739. break;
  1741. case (ISDN_CMD_PROCEED):
  1742. chanp = csta->channel + ic->arg;
  1743. if (chanp->debug & 1)
  1744. link_debug(chanp, 1, "PROCEED");
  1745. FsmEvent(&chanp->fi, EV_PROCEED, NULL);
  1746. break;
  1748. case (ISDN_CMD_ALERT):
  1749. chanp = csta->channel + ic->arg;
  1750. if (chanp->debug & 1)
  1751. link_debug(chanp, 1, "ALERT");
  1752. FsmEvent(&chanp->fi, EV_ALERT, NULL);
  1753. break;
  1755. case (ISDN_CMD_REDIR):
  1756. chanp = csta->channel + ic->arg;
  1757. if (chanp->debug & 1)
  1758. link_debug(chanp, 1, "REDIR");
  1759. memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
  1760. FsmEvent(&chanp->fi, EV_REDIR, NULL);
  1761. break;
  1763. /* protocol specific io commands */
  1764. case (ISDN_CMD_PROT_IO):
  1765. for (st = csta->stlist; st; st = st->next)
  1766. if (st->protocol == (ic->arg & 0xFF))
  1767. return(st->lli.l4l3_proto(st, ic));
  1768. return(-EINVAL);
  1769. break;
  1770. default:
  1771. if (csta->auxcmd)
  1772. return(csta->auxcmd(csta, ic));
  1773. return(-EINVAL);
  1774. }
  1775. return (0);
  1776. }
  1778. int
  1779. HiSax_writebuf_skb(int id, int chan, int ack, struct sk_buff *skb)
  1780. {
  1781. struct IsdnCardState *csta = hisax_findcard(id);
  1782. struct Channel *chanp;
  1783. struct PStack *st;
  1784. int len = skb->len;
  1785. unsigned long flags;
  1786. struct sk_buff *nskb;
  1788. if (!csta) {
  1789. printk(KERN_ERR
  1790. "HiSax: if_sendbuf called with invalid driverId!n");
  1791. return -ENODEV;
  1792. }
  1793. chanp = csta->channel + chan;
  1794. st = chanp->b_st;
  1795. if (!chanp->data_open) {
  1796. link_debug(chanp, 1, "writebuf: channel not open");
  1797. return -EIO;
  1798. }
  1799. if (len > MAX_DATA_SIZE) {
  1800. link_debug(chanp, 1, "writebuf: packet too large (%d bytes)", len);
  1801. printk(KERN_WARNING "HiSax_writebuf: packet too large (%d bytes) !n",
  1802. len);
  1803. return -EINVAL;
  1804. }
  1805. if (len) {
  1806. if ((len + chanp->bcs->tx_cnt) > MAX_DATA_MEM) {
  1807. /* Must return 0 here, since this is not an error
  1808.  * but a temporary lack of resources.
  1809.  */
  1810. if (chanp->debug & 0x800)
  1811. link_debug(chanp, 1, "writebuf: no buffers for %d bytes", len);
  1812. return 0;
  1813. } else if (chanp->debug & 0x800)
  1814. link_debug(chanp, 1, "writebuf %d/%d/%d", len, chanp->bcs->tx_cnt,MAX_DATA_MEM);
  1815. save_flags(flags);
  1816. cli();
  1817. nskb = skb_clone(skb, GFP_ATOMIC);
  1818. if (nskb) {
  1819. nskb->truesize = nskb->len;
  1820. if (!ack)
  1821. nskb->pkt_type = PACKET_NOACK;
  1822. if (chanp->l2_active_protocol == ISDN_PROTO_L2_X75I)
  1823. st->l3.l3l2(st, DL_DATA | REQUEST, nskb);
  1824. else {
  1825. chanp->bcs->tx_cnt += len;
  1826. st->l2.l2l1(st, PH_DATA | REQUEST, nskb);
  1827. }
  1828. dev_kfree_skb(skb);
  1829. } else
  1830. len = 0;
  1831. restore_flags(flags);
  1832. }
  1833. return (len);
  1834. }