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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
capidrv.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：63k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

capidrv.c：源码内容
  1. /* $Id: capidrv.c,v 1.1.4.1 2001/11/20 14:19:34 kai Exp $
  2.  *
  3.  * ISDN4Linux Driver, using capi20 interface (kernelcapi)
  4.  *
  5.  * Copyright 1997 by Carsten Paeth <calle@calle.de>
  6.  *
  7.  * This software may be used and distributed according to the terms
  8.  * of the GNU General Public License, incorporated herein by reference.
  9.  *
  10.  */
  12. #include <linux/module.h>
  13. #include <linux/errno.h>
  14. #include <linux/kernel.h>
  15. #include <linux/major.h>
  16. #include <linux/sched.h>
  17. #include <linux/slab.h>
  18. #include <linux/fcntl.h>
  19. #include <linux/fs.h>
  20. #include <linux/signal.h>
  21. #include <linux/mm.h>
  22. #include <linux/timer.h>
  23. #include <linux/wait.h>
  24. #include <linux/skbuff.h>
  25. #include <linux/isdn.h>
  26. #include <linux/isdnif.h>
  27. #include <linux/proc_fs.h>
  28. #include <linux/capi.h>
  29. #include <linux/kernelcapi.h>
  30. #include <linux/ctype.h>
  31. #include <linux/init.h>
  32. #include <asm/segment.h>
  34. #include "capiutil.h"
  35. #include "capicmd.h"
  36. #include "capidrv.h"
  38. static char *revision = "$Revision: 1.1.4.1 $";
  39. static int debugmode = 0;
  41. MODULE_DESCRIPTION("CAPI4Linux: Interface to ISDN4Linux");
  42. MODULE_AUTHOR("Carsten Paeth");
  43. MODULE_LICENSE("GPL");
  44. MODULE_PARM(debugmode, "i");
  46. /* -------- type definitions ----------------------------------------- */
  49. struct capidrv_contr {
  51. struct capidrv_contr *next;
  53. __u32 contrnr;
  54. char name[20];
  56. /*
  57.  * for isdn4linux
  58.  */
  59. isdn_if interface;
  60. int myid;
  62. /*
  63.  * LISTEN state
  64.  */
  65. int state;
  66. __u32 cipmask;
  67. __u32 cipmask2;
  68.         struct timer_list listentimer;
  70. /*
  71.  * ID of capi message sent
  72.  */
  73. __u16 msgid;
  75. /*
  76.  * B-Channels
  77.  */
  78. int nbchan;
  79. struct capidrv_bchan {
  80. struct capidrv_contr *contr;
  81. __u8 msn[ISDN_MSNLEN];
  82. int l2;
  83. int l3;
  84. __u8 num[ISDN_MSNLEN];
  85. __u8 mynum[ISDN_MSNLEN];
  86. int si1;
  87. int si2;
  88. int incoming;
  89. int disconnecting;
  90. struct capidrv_plci {
  91. struct capidrv_plci *next;
  92. __u32 plci;
  93. __u32 ncci; /* ncci for CONNECT_ACTIVE_IND */
  94. __u16 msgid; /* to identfy CONNECT_CONF */
  95. int chan;
  96. int state;
  97. int leasedline;
  98. struct capidrv_ncci {
  99. struct capidrv_ncci *next;
  100. struct capidrv_plci *plcip;
  101. __u32 ncci;
  102. __u16 msgid; /* to identfy CONNECT_B3_CONF */
  103. int chan;
  104. int state;
  105. int oldstate;
  106. /* */
  107. __u16 datahandle;
  108. struct ncci_datahandle_queue {
  109.     struct ncci_datahandle_queue *next;
  110.     __u16                         datahandle;
  111.     int                           len;
  112. } *ackqueue;
  113. } *ncci_list;
  114. } *plcip;
  115. struct capidrv_ncci *nccip;
  116. } *bchans;
  118. struct capidrv_plci *plci_list;
  120. /* for q931 data */
  121. __u8  q931_buf[4096];
  122. __u8 *q931_read;
  123. __u8 *q931_write;
  124. __u8 *q931_end;
  125. };
  128. struct capidrv_data {
  129. __u16 appid;
  130. int ncontr;
  131. struct capidrv_contr *contr_list;
  133.         /* statistic */
  134. unsigned long nrecvctlpkt;
  135. unsigned long nrecvdatapkt;
  136. unsigned long nsentctlpkt;
  137. unsigned long nsentdatapkt;
  138. };
  140. typedef struct capidrv_plci capidrv_plci;
  141. typedef struct capidrv_ncci capidrv_ncci;
  142. typedef struct capidrv_contr capidrv_contr;
  143. typedef struct capidrv_data capidrv_data;
  144. typedef struct capidrv_bchan capidrv_bchan;
  146. /* -------- data definitions ----------------------------------------- */
  148. static capidrv_data global;
  149. static spinlock_t global_lock = SPIN_LOCK_UNLOCKED;
  150. static struct capi_interface *capifuncs;
  152. static void handle_dtrace_data(capidrv_contr *card,
  153. int send, int level2, __u8 *data, __u16 len);
  155. /* -------- convert functions ---------------------------------------- */
  157. static inline __u32 b1prot(int l2, int l3)
  158. {
  159. switch (l2) {
  160. case ISDN_PROTO_L2_X75I:
  161. case ISDN_PROTO_L2_X75UI:
  162. case ISDN_PROTO_L2_X75BUI:
  163. return 0;
  164. case ISDN_PROTO_L2_HDLC:
  165. default:
  166. return 0;
  167. case ISDN_PROTO_L2_TRANS:
  168. return 1;
  169.         case ISDN_PROTO_L2_V11096:
  170.         case ISDN_PROTO_L2_V11019:
  171.         case ISDN_PROTO_L2_V11038:
  172. return 2;
  173.         case ISDN_PROTO_L2_FAX:
  174. return 4;
  175. case ISDN_PROTO_L2_MODEM:
  176. return 8;
  177. }
  178. }
  180. static inline __u32 b2prot(int l2, int l3)
  181. {
  182. switch (l2) {
  183. case ISDN_PROTO_L2_X75I:
  184. case ISDN_PROTO_L2_X75UI:
  185. case ISDN_PROTO_L2_X75BUI:
  186. default:
  187. return 0;
  188. case ISDN_PROTO_L2_HDLC:
  189. case ISDN_PROTO_L2_TRANS:
  190.         case ISDN_PROTO_L2_V11096:
  191.         case ISDN_PROTO_L2_V11019:
  192.         case ISDN_PROTO_L2_V11038:
  193. case ISDN_PROTO_L2_MODEM:
  194. return 1;
  195.         case ISDN_PROTO_L2_FAX:
  196. return 4;
  197. }
  198. }
  200. static inline __u32 b3prot(int l2, int l3)
  201. {
  202. switch (l2) {
  203. case ISDN_PROTO_L2_X75I:
  204. case ISDN_PROTO_L2_X75UI:
  205. case ISDN_PROTO_L2_X75BUI:
  206. case ISDN_PROTO_L2_HDLC:
  207. case ISDN_PROTO_L2_TRANS:
  208.         case ISDN_PROTO_L2_V11096:
  209.         case ISDN_PROTO_L2_V11019:
  210.         case ISDN_PROTO_L2_V11038:
  211. case ISDN_PROTO_L2_MODEM:
  212. default:
  213. return 0;
  214.         case ISDN_PROTO_L2_FAX:
  215. return 4;
  216. }
  217. }
  219. static _cstruct b1config_async_v110(__u16 rate)
  220. {
  221. /* CAPI-Spec "B1 Configuration" */
  222. static unsigned char buf[9];
  223. buf[0] = 8; /* len */
  224. /* maximum bitrate */
  225. buf[1] = rate & 0xff; buf[2] = (rate >> 8) & 0xff;
  226. buf[3] = 8; buf[4] = 0; /* 8 bits per character */
  227. buf[5] = 0; buf[6] = 0; /* parity none */
  228. buf[7] = 0; buf[8] = 0; /* 1 stop bit */
  229. return buf;
  230. }
  232. static _cstruct b1config(int l2, int l3)
  233. {
  234. switch (l2) {
  235. case ISDN_PROTO_L2_X75I:
  236. case ISDN_PROTO_L2_X75UI:
  237. case ISDN_PROTO_L2_X75BUI:
  238. case ISDN_PROTO_L2_HDLC:
  239. case ISDN_PROTO_L2_TRANS:
  240. default:
  241. return 0;
  242.         case ISDN_PROTO_L2_V11096:
  243.     return b1config_async_v110(9600);
  244.         case ISDN_PROTO_L2_V11019:
  245.     return b1config_async_v110(19200);
  246.         case ISDN_PROTO_L2_V11038:
  247.     return b1config_async_v110(38400);
  248. }
  249. }
  251. static inline __u16 si2cip(__u8 si1, __u8 si2)
  252. {
  253. static const __u8 cip[17][5] =
  254. {
  255. /*  0  1  2  3  4  */
  256. {0, 0, 0, 0, 0}, /*0 */
  257. {16, 16, 4, 26, 16}, /*1 */
  258. {17, 17, 17, 4, 4}, /*2 */
  259. {2, 2, 2, 2, 2}, /*3 */
  260. {18, 18, 18, 18, 18}, /*4 */
  261. {2, 2, 2, 2, 2}, /*5 */
  262. {0, 0, 0, 0, 0}, /*6 */
  263. {2, 2, 2, 2, 2}, /*7 */
  264. {2, 2, 2, 2, 2}, /*8 */
  265. {21, 21, 21, 21, 21}, /*9 */
  266. {19, 19, 19, 19, 19}, /*10 */
  267. {0, 0, 0, 0, 0}, /*11 */
  268. {0, 0, 0, 0, 0}, /*12 */
  269. {0, 0, 0, 0, 0}, /*13 */
  270. {0, 0, 0, 0, 0}, /*14 */
  271. {22, 22, 22, 22, 22}, /*15 */
  272. {27, 27, 27, 28, 27} /*16 */
  273. };
  274. if (si1 > 16)
  275. si1 = 0;
  276. if (si2 > 4)
  277. si2 = 0;
  279. return (__u16) cip[si1][si2];
  280. }
  282. static inline __u8 cip2si1(__u16 cipval)
  283. {
  284. static const __u8 si[32] =
  285. {7, 1, 7, 7, 1, 1, 7, 7, /*0-7 */
  286.  7, 1, 0, 0, 0, 0, 0, 0, /*8-15 */
  287.  1, 2, 4, 10, 9, 9, 15, 7, /*16-23 */
  288.  7, 7, 1, 16, 16, 0, 0, 0}; /*24-31 */
  290. if (cipval > 31)
  291. cipval = 0; /* .... */
  292. return si[cipval];
  293. }
  295. static inline __u8 cip2si2(__u16 cipval)
  296. {
  297. static const __u8 si[32] =
  298. {0, 0, 0, 0, 2, 3, 0, 0, /*0-7 */
  299.  0, 3, 0, 0, 0, 0, 0, 0, /*8-15 */
  300.  1, 2, 0, 0, 9, 0, 0, 0, /*16-23 */
  301.  0, 0, 3, 2, 3, 0, 0, 0}; /*24-31 */
  303. if (cipval > 31)
  304. cipval = 0; /* .... */
  305. return si[cipval];
  306. }
  309. /* -------- controller management ------------------------------------- */
  311. static inline capidrv_contr *findcontrbydriverid(int driverid)
  312. {
  313.      unsigned long flags;
  314. capidrv_contr *p;
  316. spin_lock_irqsave(&global_lock, flags);
  317. for (p = global.contr_list; p; p = p->next)
  318. if (p->myid == driverid)
  319. break;
  320. spin_unlock_irqrestore(&global_lock, flags);
  321. return p;
  322. }
  324. static capidrv_contr *findcontrbynumber(__u32 contr)
  325. {
  326. unsigned long flags;
  327. capidrv_contr *p = global.contr_list;
  329. spin_lock_irqsave(&global_lock, flags);
  330. for (p = global.contr_list; p; p = p->next)
  331. if (p->contrnr == contr)
  332. break;
  333. spin_unlock_irqrestore(&global_lock, flags);
  334. return p;
  335. }
  338. /* -------- plci management ------------------------------------------ */
  340. static capidrv_plci *new_plci(capidrv_contr * card, int chan)
  341. {
  342. capidrv_plci *plcip;
  344. plcip = (capidrv_plci *) kmalloc(sizeof(capidrv_plci), GFP_ATOMIC);
  346. if (plcip == 0)
  347. return 0;
  349. memset(plcip, 0, sizeof(capidrv_plci));
  350. plcip->state = ST_PLCI_NONE;
  351. plcip->plci = 0;
  352. plcip->msgid = 0;
  353. plcip->chan = chan;
  354. plcip->next = card->plci_list;
  355. card->plci_list = plcip;
  356. card->bchans[chan].plcip = plcip;
  358. return plcip;
  359. }
  361. static capidrv_plci *find_plci_by_plci(capidrv_contr * card, __u32 plci)
  362. {
  363. capidrv_plci *p;
  364. for (p = card->plci_list; p; p = p->next)
  365. if (p->plci == plci)
  366. return p;
  367. return 0;
  368. }
  370. static capidrv_plci *find_plci_by_msgid(capidrv_contr * card, __u16 msgid)
  371. {
  372. capidrv_plci *p;
  373. for (p = card->plci_list; p; p = p->next)
  374. if (p->msgid == msgid)
  375. return p;
  376. return 0;
  377. }
  379. static capidrv_plci *find_plci_by_ncci(capidrv_contr * card, __u32 ncci)
  380. {
  381. capidrv_plci *p;
  382. for (p = card->plci_list; p; p = p->next)
  383. if (p->plci == (ncci & 0xffff))
  384. return p;
  385. return 0;
  386. }
  388. static void free_plci(capidrv_contr * card, capidrv_plci * plcip)
  389. {
  390. capidrv_plci **pp;
  392. for (pp = &card->plci_list; *pp; pp = &(*pp)->next) {
  393. if (*pp == plcip) {
  394. *pp = (*pp)->next;
  395. card->bchans[plcip->chan].plcip = 0;
  396. card->bchans[plcip->chan].disconnecting = 0;
  397. card->bchans[plcip->chan].incoming = 0;
  398. kfree(plcip);
  399. return;
  400. }
  401. }
  402. printk(KERN_ERR "capidrv-%d: free_plci %p (0x%x) not found, Huh?n",
  403.        card->contrnr, plcip, plcip->plci);
  404. }
  406. /* -------- ncci management ------------------------------------------ */
  408. static inline capidrv_ncci *new_ncci(capidrv_contr * card,
  409.      capidrv_plci * plcip,
  410.      __u32 ncci)
  411. {
  412. capidrv_ncci *nccip;
  414. nccip = (capidrv_ncci *) kmalloc(sizeof(capidrv_ncci), GFP_ATOMIC);
  416. if (nccip == 0)
  417. return 0;
  419. memset(nccip, 0, sizeof(capidrv_ncci));
  420. nccip->ncci = ncci;
  421. nccip->state = ST_NCCI_NONE;
  422. nccip->plcip = plcip;
  423. nccip->chan = plcip->chan;
  424. nccip->datahandle = 0;
  426. nccip->next = plcip->ncci_list;
  427. plcip->ncci_list = nccip;
  429. card->bchans[plcip->chan].nccip = nccip;
  431. return nccip;
  432. }
  434. static inline capidrv_ncci *find_ncci(capidrv_contr * card, __u32 ncci)
  435. {
  436. capidrv_plci *plcip;
  437. capidrv_ncci *p;
  439. if ((plcip = find_plci_by_ncci(card, ncci)) == 0)
  440. return 0;
  442. for (p = plcip->ncci_list; p; p = p->next)
  443. if (p->ncci == ncci)
  444. return p;
  445. return 0;
  446. }
  448. static inline capidrv_ncci *find_ncci_by_msgid(capidrv_contr * card,
  449.        __u32 ncci, __u16 msgid)
  450. {
  451. capidrv_plci *plcip;
  452. capidrv_ncci *p;
  454. if ((plcip = find_plci_by_ncci(card, ncci)) == 0)
  455. return 0;
  457. for (p = plcip->ncci_list; p; p = p->next)
  458. if (p->msgid == msgid)
  459. return p;
  460. return 0;
  461. }
  463. static void free_ncci(capidrv_contr * card, struct capidrv_ncci *nccip)
  464. {
  465. struct capidrv_ncci **pp;
  467. for (pp = &(nccip->plcip->ncci_list); *pp; pp = &(*pp)->next) {
  468. if (*pp == nccip) {
  469. *pp = (*pp)->next;
  470. break;
  471. }
  472. }
  473. card->bchans[nccip->chan].nccip = 0;
  474. kfree(nccip);
  475. }
  477. static int capidrv_add_ack(struct capidrv_ncci *nccip,
  478.            __u16 datahandle, int len)
  479. {
  480. struct ncci_datahandle_queue *n, **pp;
  482. n = (struct ncci_datahandle_queue *)
  483. kmalloc(sizeof(struct ncci_datahandle_queue), GFP_ATOMIC);
  484. if (!n) {
  485.    printk(KERN_ERR "capidrv: kmalloc ncci_datahandle failedn");
  486.    return -1;
  487. }
  488. n->next = 0;
  489. n->datahandle = datahandle;
  490. n->len = len;
  491. for (pp = &nccip->ackqueue; *pp; pp = &(*pp)->next) ;
  492. *pp = n;
  493. return 0;
  494. }
  496. static int capidrv_del_ack(struct capidrv_ncci *nccip, __u16 datahandle)
  497. {
  498. struct ncci_datahandle_queue **pp, *p;
  499. int len;
  501. for (pp = &nccip->ackqueue; *pp; pp = &(*pp)->next) {
  502.   if ((*pp)->datahandle == datahandle) {
  503. p = *pp;
  504. len = p->len;
  505. *pp = (*pp)->next;
  506.         kfree(p);
  507. return len;
  508. }
  509. }
  510. return -1;
  511. }
  513. /* -------- convert and send capi message ---------------------------- */
  515. static void send_message(capidrv_contr * card, _cmsg * cmsg)
  516. {
  517. struct sk_buff *skb;
  518. size_t len;
  519. capi_cmsg2message(cmsg, cmsg->buf);
  520. len = CAPIMSG_LEN(cmsg->buf);
  521. skb = alloc_skb(len, GFP_ATOMIC);
  522. memcpy(skb_put(skb, len), cmsg->buf, len);
  523. (*capifuncs->capi_put_message) (global.appid, skb);
  524. global.nsentctlpkt++;
  525. }
  527. /* -------- state machine -------------------------------------------- */
  529. struct listenstatechange {
  530. int actstate;
  531. int nextstate;
  532. int event;
  533. };
  535. static struct listenstatechange listentable[] =
  536. {
  537.   {ST_LISTEN_NONE, ST_LISTEN_WAIT_CONF, EV_LISTEN_REQ},
  538.   {ST_LISTEN_ACTIVE, ST_LISTEN_ACTIVE_WAIT_CONF, EV_LISTEN_REQ},
  539.   {ST_LISTEN_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_ERROR},
  540.   {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_ERROR},
  541.   {ST_LISTEN_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_EMPTY},
  542.   {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_EMPTY},
  543.   {ST_LISTEN_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_OK},
  544.   {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_OK},
  545.   {},
  546. };
  548. static void listen_change_state(capidrv_contr * card, int event)
  549. {
  550. struct listenstatechange *p = listentable;
  551. while (p->event) {
  552. if (card->state == p->actstate && p->event == event) {
  553. if (debugmode)
  554. printk(KERN_DEBUG "capidrv-%d: listen_change_state %d -> %dn",
  555.        card->contrnr, card->state, p->nextstate);
  556. card->state = p->nextstate;
  557. return;
  558. }
  559. p++;
  560. }
  561. printk(KERN_ERR "capidrv-%d: listen_change_state state=%d event=%d ????n",
  562.        card->contrnr, card->state, event);
  564. }
  566. /* ------------------------------------------------------------------ */
  568. static void p0(capidrv_contr * card, capidrv_plci * plci)
  569. {
  570. isdn_ctrl cmd;
  572. card->bchans[plci->chan].contr = 0;
  573. cmd.command = ISDN_STAT_DHUP;
  574. cmd.driver = card->myid;
  575. cmd.arg = plci->chan;
  576. card->interface.statcallb(&cmd);
  577. free_plci(card, plci);
  578. }
  580. /* ------------------------------------------------------------------ */
  582. struct plcistatechange {
  583. int actstate;
  584. int nextstate;
  585. int event;
  586. void (*changefunc) (capidrv_contr * card, capidrv_plci * plci);
  587. };
  589. static struct plcistatechange plcitable[] =
  590. {
  591.   /* P-0 */
  592.   {ST_PLCI_NONE, ST_PLCI_OUTGOING, EV_PLCI_CONNECT_REQ, 0},
  593.   {ST_PLCI_NONE, ST_PLCI_ALLOCATED, EV_PLCI_FACILITY_IND_UP, 0},
  594.   {ST_PLCI_NONE, ST_PLCI_INCOMING, EV_PLCI_CONNECT_IND, 0},
  595.   {ST_PLCI_NONE, ST_PLCI_RESUMEING, EV_PLCI_RESUME_REQ, 0},
  596.   /* P-0.1 */
  597.   {ST_PLCI_OUTGOING, ST_PLCI_NONE, EV_PLCI_CONNECT_CONF_ERROR, p0},
  598.   {ST_PLCI_OUTGOING, ST_PLCI_ALLOCATED, EV_PLCI_CONNECT_CONF_OK, 0},
  599.   /* P-1 */
  600.   {ST_PLCI_ALLOCATED, ST_PLCI_ACTIVE, EV_PLCI_CONNECT_ACTIVE_IND, 0},
  601.   {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, 0},
  602.   {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, 0},
  603.   {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, 0},
  604.   /* P-ACT */
  605.   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, 0},
  606.   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, 0},
  607.   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, 0},
  608.   {ST_PLCI_ACTIVE, ST_PLCI_HELD, EV_PLCI_HOLD_IND, 0},
  609.   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_SUSPEND_IND, 0},
  610.   /* P-2 */
  611.   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_CONNECT_REJECT, 0},
  612.   {ST_PLCI_INCOMING, ST_PLCI_FACILITY_IND, EV_PLCI_FACILITY_IND_UP, 0},
  613.   {ST_PLCI_INCOMING, ST_PLCI_ACCEPTING, EV_PLCI_CONNECT_RESP, 0},
  614.   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, 0},
  615.   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, 0},
  616.   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, 0},
  617.   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_CD_IND, 0},
  618.   /* P-3 */
  619.   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_CONNECT_REJECT, 0},
  620.   {ST_PLCI_FACILITY_IND, ST_PLCI_ACCEPTING, EV_PLCI_CONNECT_ACTIVE_IND, 0},
  621.   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, 0},
  622.   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, 0},
  623.   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, 0},
  624.   /* P-4 */
  625.   {ST_PLCI_ACCEPTING, ST_PLCI_ACTIVE, EV_PLCI_CONNECT_ACTIVE_IND, 0},
  626.   {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, 0},
  627.   {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, 0},
  628.   {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, 0},
  629.   /* P-5 */
  630.   {ST_PLCI_DISCONNECTING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, 0},
  631.   /* P-6 */
  632.   {ST_PLCI_DISCONNECTED, ST_PLCI_NONE, EV_PLCI_DISCONNECT_RESP, p0},
  633.   /* P-0.Res */
  634.   {ST_PLCI_RESUMEING, ST_PLCI_NONE, EV_PLCI_RESUME_CONF_ERROR, p0},
  635.   {ST_PLCI_RESUMEING, ST_PLCI_RESUME, EV_PLCI_RESUME_CONF_OK, 0},
  636.   /* P-RES */
  637.   {ST_PLCI_RESUME, ST_PLCI_ACTIVE, EV_PLCI_RESUME_IND, 0},
  638.   /* P-HELD */
  639.   {ST_PLCI_HELD, ST_PLCI_ACTIVE, EV_PLCI_RETRIEVE_IND, 0},
  640.   {},
  641. };
  643. static void plci_change_state(capidrv_contr * card, capidrv_plci * plci, int event)
  644. {
  645. struct plcistatechange *p = plcitable;
  646. while (p->event) {
  647. if (plci->state == p->actstate && p->event == event) {
  648. if (debugmode)
  649. printk(KERN_DEBUG "capidrv-%d: plci_change_state:0x%x %d -> %dn",
  650.   card->contrnr, plci->plci, plci->state, p->nextstate);
  651. plci->state = p->nextstate;
  652. if (p->changefunc)
  653. p->changefunc(card, plci);
  654. return;
  655. }
  656. p++;
  657. }
  658. printk(KERN_ERR "capidrv-%d: plci_change_state:0x%x state=%d event=%d ????n",
  659.        card->contrnr, plci->plci, plci->state, event);
  660. }
  662. /* ------------------------------------------------------------------ */
  664. static _cmsg cmsg;
  666. static void n0(capidrv_contr * card, capidrv_ncci * ncci)
  667. {
  668. isdn_ctrl cmd;
  670. capi_fill_DISCONNECT_REQ(&cmsg,
  671.  global.appid,
  672.  card->msgid++,
  673.  ncci->plcip->plci,
  674.  0, /* BChannelinformation */
  675.  0, /* Keypadfacility */
  676.  0, /* Useruserdata */   /* $$$$ */
  677.  0 /* Facilitydataarray */
  678. );
  679. send_message(card, &cmsg);
  680. plci_change_state(card, ncci->plcip, EV_PLCI_DISCONNECT_REQ);
  682. cmd.command = ISDN_STAT_BHUP;
  683. cmd.driver = card->myid;
  684. cmd.arg = ncci->chan;
  685. card->interface.statcallb(&cmd);
  686. free_ncci(card, ncci);
  687. }
  689. /* ------------------------------------------------------------------ */
  691. struct nccistatechange {
  692. int actstate;
  693. int nextstate;
  694. int event;
  695. void (*changefunc) (capidrv_contr * card, capidrv_ncci * ncci);
  696. };
  698. static struct nccistatechange nccitable[] =
  699. {
  700.   /* N-0 */
  701.   {ST_NCCI_NONE, ST_NCCI_OUTGOING, EV_NCCI_CONNECT_B3_REQ, 0},
  702.   {ST_NCCI_NONE, ST_NCCI_INCOMING, EV_NCCI_CONNECT_B3_IND, 0},
  703.   /* N-0.1 */
  704.   {ST_NCCI_OUTGOING, ST_NCCI_ALLOCATED, EV_NCCI_CONNECT_B3_CONF_OK, 0},
  705.   {ST_NCCI_OUTGOING, ST_NCCI_NONE, EV_NCCI_CONNECT_B3_CONF_ERROR, n0},
  706.   /* N-1 */
  707.   {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTING, EV_NCCI_CONNECT_B3_REJECT, 0},
  708.   {ST_NCCI_INCOMING, ST_NCCI_ALLOCATED, EV_NCCI_CONNECT_B3_RESP, 0},
  709.   {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, 0},
  710.   {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, 0},
  711.   /* N-2 */
  712.   {ST_NCCI_ALLOCATED, ST_NCCI_ACTIVE, EV_NCCI_CONNECT_B3_ACTIVE_IND, 0},
  713.   {ST_NCCI_ALLOCATED, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, 0},
  714.   {ST_NCCI_ALLOCATED, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, 0},
  715.   /* N-ACT */
  716.   {ST_NCCI_ACTIVE, ST_NCCI_ACTIVE, EV_NCCI_RESET_B3_IND, 0},
  717.   {ST_NCCI_ACTIVE, ST_NCCI_RESETING, EV_NCCI_RESET_B3_REQ, 0},
  718.   {ST_NCCI_ACTIVE, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, 0},
  719.   {ST_NCCI_ACTIVE, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, 0},
  720.   /* N-3 */
  721.   {ST_NCCI_RESETING, ST_NCCI_ACTIVE, EV_NCCI_RESET_B3_IND, 0},
  722.   {ST_NCCI_RESETING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, 0},
  723.   {ST_NCCI_RESETING, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, 0},
  724.   /* N-4 */
  725.   {ST_NCCI_DISCONNECTING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, 0},
  726.   {ST_NCCI_DISCONNECTING, ST_NCCI_PREVIOUS, EV_NCCI_DISCONNECT_B3_CONF_ERROR,0},
  727.   /* N-5 */
  728.   {ST_NCCI_DISCONNECTED, ST_NCCI_NONE, EV_NCCI_DISCONNECT_B3_RESP, n0},
  729.   {},
  730. };
  732. static void ncci_change_state(capidrv_contr * card, capidrv_ncci * ncci, int event)
  733. {
  734. struct nccistatechange *p = nccitable;
  735. while (p->event) {
  736. if (ncci->state == p->actstate && p->event == event) {
  737. if (debugmode)
  738. printk(KERN_DEBUG "capidrv-%d: ncci_change_state:0x%x %d -> %dn",
  739.   card->contrnr, ncci->ncci, ncci->state, p->nextstate);
  740. if (p->nextstate == ST_NCCI_PREVIOUS) {
  741. ncci->state = ncci->oldstate;
  742. ncci->oldstate = p->actstate;
  743. } else {
  744. ncci->oldstate = p->actstate;
  745. ncci->state = p->nextstate;
  746. }
  747. if (p->changefunc)
  748. p->changefunc(card, ncci);
  749. return;
  750. }
  751. p++;
  752. }
  753. printk(KERN_ERR "capidrv-%d: ncci_change_state:0x%x state=%d event=%d ????n",
  754.        card->contrnr, ncci->ncci, ncci->state, event);
  755. }
  757. /* ------------------------------------------------------------------- */
  759. static inline int new_bchan(capidrv_contr * card)
  760. {
  761. int i;
  762. for (i = 0; i < card->nbchan; i++) {
  763. if (card->bchans[i].plcip == 0) {
  764. card->bchans[i].disconnecting = 0;
  765. return i;
  766. }
  767. }
  768. return -1;
  769. }
  771. /* ------------------------------------------------------------------- */
  773. static void handle_controller(_cmsg * cmsg)
  774. {
  775. capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
  777. if (!card) {
  778. printk(KERN_ERR "capidrv: %s from unknown controller 0x%xn",
  779.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  780.        cmsg->adr.adrController & 0x7f);
  781. return;
  782. }
  783. switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
  785. case CAPI_LISTEN_CONF: /* Controller */
  786. if (debugmode)
  787. printk(KERN_DEBUG "capidrv-%d: listenconf Info=0x%4x (%s) cipmask=0x%xn",
  788.        card->contrnr, cmsg->Info, capi_info2str(cmsg->Info), card->cipmask);
  789. if (cmsg->Info) {
  790. listen_change_state(card, EV_LISTEN_CONF_ERROR);
  791. } else if (card->cipmask == 0) {
  792. listen_change_state(card, EV_LISTEN_CONF_EMPTY);
  793. } else {
  794. listen_change_state(card, EV_LISTEN_CONF_OK);
  795. }
  796. break;
  798. case CAPI_MANUFACTURER_IND: /* Controller */
  799. if (   cmsg->ManuID == 0x214D5641
  800.     && cmsg->Class == 0
  801.     && cmsg->Function == 1) {
  802.    __u8  *data = cmsg->ManuData+3;
  803.    __u16  len = cmsg->ManuData[0];
  804.    __u16 layer;
  805.    int direction;
  806.    if (len == 255) {
  807.       len = (cmsg->ManuData[1] | (cmsg->ManuData[2] << 8));
  808.       data += 2;
  809.    }
  810.    len -= 2;
  811.    layer = ((*(data-1)) << 8) | *(data-2);
  812.    if (layer & 0x300)
  813. direction = (layer & 0x200) ? 0 : 1;
  814.    else direction = (layer & 0x800) ? 0 : 1;
  815.    if (layer & 0x0C00) {
  816.     if ((layer & 0xff) == 0x80) {
  817.            handle_dtrace_data(card, direction, 1, data, len);
  818.            break;
  819.     }
  820.    } else if ((layer & 0xff) < 0x80) {
  821.       handle_dtrace_data(card, direction, 0, data, len);
  822.       break;
  823.    }
  824.            printk(KERN_INFO "capidrv-%d: %s from controller 0x%x layer 0x%x, ignoredn",
  825.                         card->contrnr, 
  826. capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  827. cmsg->adr.adrController, layer);
  828.                    break;
  829. }
  830. goto ignored;
  831. case CAPI_MANUFACTURER_CONF: /* Controller */
  832. if (cmsg->ManuID == 0x214D5641) {
  833.    char *s = 0;
  834.    switch (cmsg->Class) {
  835.       case 0: break;
  836.       case 1: s = "unknown class"; break;
  837.       case 2: s = "unknown function"; break;
  838.       default: s = "unkown error"; break;
  839.    }
  840.    if (s)
  841.            printk(KERN_INFO "capidrv-%d: %s from controller 0x%x function %d: %sn",
  842. card->contrnr,
  843. capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  844. cmsg->adr.adrController,
  845. cmsg->Function, s);
  846.    break;
  847. }
  848. goto ignored;
  849. case CAPI_FACILITY_IND: /* Controller/plci/ncci */
  850. goto ignored;
  851. case CAPI_FACILITY_CONF: /* Controller/plci/ncci */
  852. goto ignored;
  853. case CAPI_INFO_IND: /* Controller/plci */
  854. goto ignored;
  855. case CAPI_INFO_CONF: /* Controller/plci */
  856. goto ignored;
  858. default:
  859. printk(KERN_ERR "capidrv-%d: got %s from controller 0x%x ???",
  860.        card->contrnr,
  861.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  862.        cmsg->adr.adrController);
  863. }
  864. return;
  866.       ignored:
  867. printk(KERN_INFO "capidrv-%d: %s from controller 0x%x ignoredn",
  868.        card->contrnr,
  869.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  870.        cmsg->adr.adrController);
  871. }
  873. static void handle_incoming_call(capidrv_contr * card, _cmsg * cmsg)
  874. {
  875. capidrv_plci *plcip;
  876. capidrv_bchan *bchan;
  877. isdn_ctrl cmd;
  878. int chan;
  880. if ((chan = new_bchan(card)) == -1) {
  881. printk(KERN_ERR "capidrv-%d: incoming call on not existing bchan ?n", card->contrnr);
  882. return;
  883. }
  884. bchan = &card->bchans[chan];
  885. if ((plcip = new_plci(card, chan)) == 0) {
  886. printk(KERN_ERR "capidrv-%d: incoming call: no memory, sorry.n", card->contrnr);
  887. return;
  888. }
  889. bchan->incoming = 1;
  890. plcip->plci = cmsg->adr.adrPLCI;
  891. plci_change_state(card, plcip, EV_PLCI_CONNECT_IND);
  893. cmd.command = ISDN_STAT_ICALL;
  894. cmd.driver = card->myid;
  895. cmd.arg = chan;
  896. memset(&cmd.parm.setup, 0, sizeof(cmd.parm.setup));
  897. strncpy(cmd.parm.setup.phone,
  898.         cmsg->CallingPartyNumber + 3,
  899. cmsg->CallingPartyNumber[0] - 2);
  900. strncpy(cmd.parm.setup.eazmsn,
  901.         cmsg->CalledPartyNumber + 2,
  902. cmsg->CalledPartyNumber[0] - 1);
  903. cmd.parm.setup.si1 = cip2si1(cmsg->CIPValue);
  904. cmd.parm.setup.si2 = cip2si2(cmsg->CIPValue);
  905. cmd.parm.setup.plan = cmsg->CallingPartyNumber[1];
  906. cmd.parm.setup.screen = cmsg->CallingPartyNumber[2];
  908. printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%sn", 
  909. card->contrnr,
  910. cmd.parm.setup.phone,
  911. cmd.parm.setup.si1,
  912. cmd.parm.setup.si2,
  913. cmd.parm.setup.eazmsn);
  915. if (cmd.parm.setup.si1 == 1 && cmd.parm.setup.si2 != 0) {
  916. printk(KERN_INFO "capidrv-%d: patching si2=%d to 0 for VBOXn", 
  917. card->contrnr,
  918. cmd.parm.setup.si2);
  919. cmd.parm.setup.si2 = 0;
  920. }
  922. switch (card->interface.statcallb(&cmd)) {
  923. case 0:
  924. case 3:
  925. /* No device matching this call.
  926.  * and isdn_common.c has send a HANGUP command
  927.  * which is ignored in state ST_PLCI_INCOMING,
  928.  * so we send RESP to ignore the call
  929.  */
  930. capi_cmsg_answer(cmsg);
  931. cmsg->Reject = 1; /* ignore */
  932. send_message(card, cmsg);
  933. plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
  934. printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s ignoredn",
  935. card->contrnr,
  936. cmd.parm.setup.phone,
  937. cmd.parm.setup.si1,
  938. cmd.parm.setup.si2,
  939. cmd.parm.setup.eazmsn);
  940. break;
  941. case 1:
  942. /* At least one device matching this call (RING on ttyI)
  943.  * HL-driver may send ALERTING on the D-channel in this
  944.  * case.
  945.  * really means: RING on ttyI or a net interface
  946.  * accepted this call already.
  947.  *
  948.  * If the call was accepted, state has already changed,
  949.  * and CONNECT_RESP already sent.
  950.  */
  951. if (plcip->state == ST_PLCI_INCOMING) {
  952. printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s tty alertingn",
  953. card->contrnr,
  954. cmd.parm.setup.phone,
  955. cmd.parm.setup.si1,
  956. cmd.parm.setup.si2,
  957. cmd.parm.setup.eazmsn);
  958. capi_fill_ALERT_REQ(cmsg,
  959.     global.appid,
  960.     card->msgid++,
  961.     plcip->plci, /* adr */
  962.     0, /* BChannelinformation */
  963.     0, /* Keypadfacility */
  964.     0, /* Useruserdata */
  965.     0 /* Facilitydataarray */
  966. );
  967. plcip->msgid = cmsg->Messagenumber;
  968. send_message(card, cmsg);
  969. } else {
  970. printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s on netdevn",
  971. card->contrnr,
  972. cmd.parm.setup.phone,
  973. cmd.parm.setup.si1,
  974. cmd.parm.setup.si2,
  975. cmd.parm.setup.eazmsn);
  976. }
  977. break;
  979. case 2: /* Call will be rejected. */
  980. capi_cmsg_answer(cmsg);
  981. cmsg->Reject = 2; /* reject call, normal call clearing */
  982. send_message(card, cmsg);
  983. plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
  984. break;
  986. default:
  987. /* An error happened. (Invalid parameters for example.) */
  988. capi_cmsg_answer(cmsg);
  989. cmsg->Reject = 8; /* reject call,
  990.    destination out of order */
  991. send_message(card, cmsg);
  992. plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
  993. break;
  994. }
  995. return;
  996. }
  998. static void handle_plci(_cmsg * cmsg)
  999. {
  1000. capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
  1001. capidrv_plci *plcip;
  1002. isdn_ctrl cmd;
  1004. if (!card) {
  1005. printk(KERN_ERR "capidrv: %s from unknown controller 0x%xn",
  1006.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1007.        cmsg->adr.adrController & 0x7f);
  1008. return;
  1009. }
  1010. switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
  1012. case CAPI_DISCONNECT_IND: /* plci */
  1013. if (cmsg->Reason) {
  1014. printk(KERN_INFO "capidrv-%d: %s reason 0x%x (%s) for plci 0x%xn",
  1015.    card->contrnr,
  1016.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1017.        cmsg->Reason, capi_info2str(cmsg->Reason), cmsg->adr.adrPLCI);
  1018. }
  1019. if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI))) {
  1020. capi_cmsg_answer(cmsg);
  1021. send_message(card, cmsg);
  1022. goto notfound;
  1023. }
  1024. card->bchans[plcip->chan].disconnecting = 1;
  1025. plci_change_state(card, plcip, EV_PLCI_DISCONNECT_IND);
  1026. capi_cmsg_answer(cmsg);
  1027. send_message(card, cmsg);
  1028. plci_change_state(card, plcip, EV_PLCI_DISCONNECT_RESP);
  1029. break;
  1031. case CAPI_DISCONNECT_CONF: /* plci */
  1032. if (cmsg->Info) {
  1033. printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%xn",
  1034.    card->contrnr,
  1035.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1036.        cmsg->Info, capi_info2str(cmsg->Info), 
  1037.        cmsg->adr.adrPLCI);
  1038. }
  1039. if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
  1040. goto notfound;
  1042. card->bchans[plcip->chan].disconnecting = 1;
  1043. break;
  1045. case CAPI_ALERT_CONF: /* plci */
  1046. if (cmsg->Info) {
  1047. printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%xn",
  1048.    card->contrnr,
  1049.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1050.        cmsg->Info, capi_info2str(cmsg->Info), 
  1051.        cmsg->adr.adrPLCI);
  1052. }
  1053. break;
  1055. case CAPI_CONNECT_IND: /* plci */
  1056. handle_incoming_call(card, cmsg);
  1057. break;
  1059. case CAPI_CONNECT_CONF: /* plci */
  1060. if (cmsg->Info) {
  1061. printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%xn",
  1062.    card->contrnr,
  1063.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1064.        cmsg->Info, capi_info2str(cmsg->Info), 
  1065.        cmsg->adr.adrPLCI);
  1066. }
  1067. if (!(plcip = find_plci_by_msgid(card, cmsg->Messagenumber)))
  1068. goto notfound;
  1070. plcip->plci = cmsg->adr.adrPLCI;
  1071. if (cmsg->Info) {
  1072. plci_change_state(card, plcip, EV_PLCI_CONNECT_CONF_ERROR);
  1073. } else {
  1074. plci_change_state(card, plcip, EV_PLCI_CONNECT_CONF_OK);
  1075. }
  1076. break;
  1078. case CAPI_CONNECT_ACTIVE_IND: /* plci */
  1080. if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
  1081. goto notfound;
  1083. if (card->bchans[plcip->chan].incoming) {
  1084. capi_cmsg_answer(cmsg);
  1085. send_message(card, cmsg);
  1086. plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND);
  1087. } else {
  1088. capidrv_ncci *nccip;
  1089. capi_cmsg_answer(cmsg);
  1090. send_message(card, cmsg);
  1092. nccip = new_ncci(card, plcip, cmsg->adr.adrPLCI);
  1094. if (!nccip) {
  1095. printk(KERN_ERR "capidrv-%d: no mem for ncci, sorryn", card->contrnr);
  1096. break; /* $$$$ */
  1097. }
  1098. capi_fill_CONNECT_B3_REQ(cmsg,
  1099.  global.appid,
  1100.  card->msgid++,
  1101.  plcip->plci, /* adr */
  1102.  0 /* NCPI */
  1103. );
  1104. nccip->msgid = cmsg->Messagenumber;
  1105. send_message(card, cmsg);
  1106. cmd.command = ISDN_STAT_DCONN;
  1107. cmd.driver = card->myid;
  1108. cmd.arg = plcip->chan;
  1109. card->interface.statcallb(&cmd);
  1110. plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND);
  1111. ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_REQ);
  1112. }
  1113. break;
  1115. case CAPI_INFO_IND: /* Controller/plci */
  1117. if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
  1118. goto notfound;
  1120. if (cmsg->InfoNumber == 0x4000) {
  1121. if (cmsg->InfoElement[0] == 4) {
  1122. cmd.command = ISDN_STAT_CINF;
  1123. cmd.driver = card->myid;
  1124. cmd.arg = plcip->chan;
  1125. sprintf(cmd.parm.num, "%lu",
  1126. (unsigned long)
  1127. ((__u32) cmsg->InfoElement[1]
  1128.   | ((__u32) (cmsg->InfoElement[2]) << 8)
  1129.  | ((__u32) (cmsg->InfoElement[3]) << 16)
  1130.  | ((__u32) (cmsg->InfoElement[4]) << 24)));
  1131. card->interface.statcallb(&cmd);
  1132. break;
  1133. }
  1134. }
  1135. printk(KERN_ERR "capidrv-%d: %sn",
  1136. card->contrnr, capi_cmsg2str(cmsg));
  1137. break;
  1139. case CAPI_CONNECT_ACTIVE_CONF: /* plci */
  1140. goto ignored;
  1141. case CAPI_SELECT_B_PROTOCOL_CONF: /* plci */
  1142. goto ignored;
  1143. case CAPI_FACILITY_IND: /* Controller/plci/ncci */
  1144. goto ignored;
  1145. case CAPI_FACILITY_CONF: /* Controller/plci/ncci */
  1146. goto ignored;
  1148. case CAPI_INFO_CONF: /* Controller/plci */
  1149. goto ignored;
  1151. default:
  1152. printk(KERN_ERR "capidrv-%d: got %s for plci 0x%x ???",
  1153.        card->contrnr,
  1154.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1155.        cmsg->adr.adrPLCI);
  1156. }
  1157. return;
  1158.       ignored:
  1159. printk(KERN_INFO "capidrv-%d: %s for plci 0x%x ignoredn",
  1160.        card->contrnr,
  1161.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1162.        cmsg->adr.adrPLCI);
  1163. return;
  1164.       notfound:
  1165. printk(KERN_ERR "capidrv-%d: %s: plci 0x%x not foundn",
  1166.        card->contrnr,
  1167.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1168.        cmsg->adr.adrPLCI);
  1169. return;
  1170. }
  1172. static void handle_ncci(_cmsg * cmsg)
  1173. {
  1174. capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
  1175. capidrv_plci *plcip;
  1176. capidrv_ncci *nccip;
  1177. isdn_ctrl cmd;
  1178. int len;
  1180. if (!card) {
  1181. printk(KERN_ERR "capidrv: %s from unknown controller 0x%xn",
  1182.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1183.        cmsg->adr.adrController & 0x7f);
  1184. return;
  1185. }
  1186. switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
  1188. case CAPI_CONNECT_B3_ACTIVE_IND: /* ncci */
  1189. if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
  1190. goto notfound;
  1192. capi_cmsg_answer(cmsg);
  1193. send_message(card, cmsg);
  1194. ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_ACTIVE_IND);
  1196. cmd.command = ISDN_STAT_BCONN;
  1197. cmd.driver = card->myid;
  1198. cmd.arg = nccip->chan;
  1199. card->interface.statcallb(&cmd);
  1201. printk(KERN_INFO "capidrv-%d: chan %d up with ncci 0x%xn",
  1202.        card->contrnr, nccip->chan, nccip->ncci);
  1203. break;
  1205. case CAPI_CONNECT_B3_ACTIVE_CONF: /* ncci */
  1206. goto ignored;
  1208. case CAPI_CONNECT_B3_IND: /* ncci */
  1210. plcip = find_plci_by_ncci(card, cmsg->adr.adrNCCI);
  1211. if (plcip) {
  1212. nccip = new_ncci(card, plcip, cmsg->adr.adrNCCI);
  1213. if (nccip) {
  1214. ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_IND);
  1215. capi_fill_CONNECT_B3_RESP(cmsg,
  1216.   global.appid,
  1217.   card->msgid++,
  1218.   nccip->ncci, /* adr */
  1219.   0, /* Reject */
  1220.   0 /* NCPI */
  1221. );
  1222. send_message(card, cmsg);
  1223. ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_RESP);
  1224. break;
  1225. }
  1226. printk(KERN_ERR "capidrv-%d: no mem for ncci, sorryn", card->contrnr);
  1227. } else {
  1228. printk(KERN_ERR "capidrv-%d: %s: plci for ncci 0x%x not foundn",
  1229.    card->contrnr,
  1230.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1231.        cmsg->adr.adrNCCI);
  1232. }
  1233. capi_fill_CONNECT_B3_RESP(cmsg,
  1234.   global.appid,
  1235.   card->msgid++,
  1236.   cmsg->adr.adrNCCI,
  1237.   2, /* Reject */
  1238.   0 /* NCPI */
  1239. );
  1240. send_message(card, cmsg);
  1241. break;
  1243. case CAPI_CONNECT_B3_CONF: /* ncci */
  1245. if (!(nccip = find_ncci_by_msgid(card,
  1246.  cmsg->adr.adrNCCI,
  1247.  cmsg->Messagenumber)))
  1248. goto notfound;
  1250. nccip->ncci = cmsg->adr.adrNCCI;
  1251. if (cmsg->Info) {
  1252. printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for ncci 0x%xn",
  1253.    card->contrnr,
  1254.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1255.        cmsg->Info, capi_info2str(cmsg->Info), 
  1256.        cmsg->adr.adrNCCI);
  1257. }
  1259. if (cmsg->Info)
  1260. ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_CONF_ERROR);
  1261. else
  1262. ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_CONF_OK);
  1263. break;
  1265. case CAPI_CONNECT_B3_T90_ACTIVE_IND: /* ncci */
  1266. capi_cmsg_answer(cmsg);
  1267. send_message(card, cmsg);
  1268. break;
  1270. case CAPI_DATA_B3_IND: /* ncci */
  1271. /* handled in handle_data() */
  1272. goto ignored;
  1274. case CAPI_DATA_B3_CONF: /* ncci */
  1275. if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
  1276. goto notfound;
  1278. len = capidrv_del_ack(nccip, cmsg->DataHandle);
  1279. if (len < 0)
  1280. break;
  1281.         cmd.command = ISDN_STAT_BSENT;
  1282.         cmd.driver = card->myid;
  1283.         cmd.arg = nccip->chan;
  1284. cmd.parm.length = len;
  1285.         card->interface.statcallb(&cmd);
  1286. break;
  1288. case CAPI_DISCONNECT_B3_IND: /* ncci */
  1289. if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
  1290. goto notfound;
  1292. card->bchans[nccip->chan].disconnecting = 1;
  1293. ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_IND);
  1294. capi_cmsg_answer(cmsg);
  1295. send_message(card, cmsg);
  1296. ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_RESP);
  1297. break;
  1299. case CAPI_DISCONNECT_B3_CONF: /* ncci */
  1300. if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
  1301. goto notfound;
  1302. if (cmsg->Info) {
  1303. printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for ncci 0x%xn",
  1304.    card->contrnr,
  1305.    capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1306.        cmsg->Info, capi_info2str(cmsg->Info), 
  1307.        cmsg->adr.adrNCCI);
  1308. ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_CONF_ERROR);
  1309. }
  1310. break;
  1312. case CAPI_RESET_B3_IND: /* ncci */
  1313. if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
  1314. goto notfound;
  1315. ncci_change_state(card, nccip, EV_NCCI_RESET_B3_IND);
  1316. capi_cmsg_answer(cmsg);
  1317. send_message(card, cmsg);
  1318. break;
  1320. case CAPI_RESET_B3_CONF: /* ncci */
  1321. goto ignored; /* $$$$ */
  1323. case CAPI_FACILITY_IND: /* Controller/plci/ncci */
  1324. goto ignored;
  1325. case CAPI_FACILITY_CONF: /* Controller/plci/ncci */
  1326. goto ignored;
  1328. default:
  1329. printk(KERN_ERR "capidrv-%d: got %s for ncci 0x%x ???",
  1330.        card->contrnr,
  1331.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1332.        cmsg->adr.adrNCCI);
  1333. }
  1334. return;
  1335.       ignored:
  1336. printk(KERN_INFO "capidrv-%d: %s for ncci 0x%x ignoredn",
  1337.        card->contrnr,
  1338.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1339.        cmsg->adr.adrNCCI);
  1340. return;
  1341.       notfound:
  1342. printk(KERN_ERR "capidrv-%d: %s: ncci 0x%x not foundn",
  1343.        card->contrnr,
  1344.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1345.        cmsg->adr.adrNCCI);
  1346. }
  1349. static void handle_data(_cmsg * cmsg, struct sk_buff *skb)
  1350. {
  1351. capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
  1352. capidrv_ncci *nccip;
  1354. if (!card) {
  1355. printk(KERN_ERR "capidrv: %s from unknown controller 0x%xn",
  1356.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1357.        cmsg->adr.adrController & 0x7f);
  1358. kfree_skb(skb);
  1359. return;
  1360. }
  1361. if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI))) {
  1362. printk(KERN_ERR "capidrv-%d: %s: ncci 0x%x not foundn",
  1363.        card->contrnr,
  1364.        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
  1365.        cmsg->adr.adrNCCI);
  1366. kfree_skb(skb);
  1367. return;
  1368. }
  1369. (void) skb_pull(skb, CAPIMSG_LEN(skb->data));
  1370. card->interface.rcvcallb_skb(card->myid, nccip->chan, skb);
  1371. capi_cmsg_answer(cmsg);
  1372. send_message(card, cmsg);
  1373. }
  1375. static _cmsg s_cmsg;
  1377. static void capidrv_signal(__u16 applid, void *dummy)
  1378. {
  1379. struct sk_buff *skb = 0;
  1381. while ((*capifuncs->capi_get_message) (global.appid, &skb) == CAPI_NOERROR) {
  1382. capi_message2cmsg(&s_cmsg, skb->data);
  1383. if (debugmode > 2)
  1384. printk(KERN_DEBUG "capidrv_signal: applid=%d %sn",
  1385. applid, capi_cmsg2str(&s_cmsg));
  1387. if (s_cmsg.Command == CAPI_DATA_B3
  1388.     && s_cmsg.Subcommand == CAPI_IND) {
  1389. handle_data(&s_cmsg, skb);
  1390. global.nrecvdatapkt++;
  1391. continue;
  1392. }
  1393. if ((s_cmsg.adr.adrController & 0xffffff00) == 0)
  1394. handle_controller(&s_cmsg);
  1395. else if ((s_cmsg.adr.adrPLCI & 0xffff0000) == 0)
  1396. handle_plci(&s_cmsg);
  1397. else
  1398. handle_ncci(&s_cmsg);
  1399. /*
  1400.  * data of skb used in s_cmsg,
  1401.  * free data when s_cmsg is not used again
  1402.  * thanks to Lars Heete <hel@admin.de>
  1403.  */
  1404. kfree_skb(skb);
  1405. global.nrecvctlpkt++;
  1406. }
  1407. }
  1409. /* ------------------------------------------------------------------- */
  1411. #define PUTBYTE_TO_STATUS(card, byte) 
  1412. do { 
  1413. *(card)->q931_write++ = (byte); 
  1414.          if ((card)->q931_write > (card)->q931_end) 
  1415.    (card)->q931_write = (card)->q931_buf; 
  1416. } while (0)
  1418. static void handle_dtrace_data(capidrv_contr *card,
  1419.      int send, int level2, __u8 *data, __u16 len)
  1420. {
  1421.      __u8 *p, *end;
  1422.      isdn_ctrl cmd;
  1424.      if (!len) {
  1425. printk(KERN_DEBUG "capidrv-%d: avmb1_q931_data: len == %dn",
  1426. card->contrnr, len);
  1427. return;
  1428. }
  1430. if (level2) {
  1431. PUTBYTE_TO_STATUS(card, 'D');
  1432. PUTBYTE_TO_STATUS(card, '2');
  1433.          PUTBYTE_TO_STATUS(card, send ? '>' : '<');
  1434.          PUTBYTE_TO_STATUS(card, ':');
  1435. } else {
  1436.          PUTBYTE_TO_STATUS(card, 'D');
  1437.          PUTBYTE_TO_STATUS(card, '3');
  1438.          PUTBYTE_TO_STATUS(card, send ? '>' : '<');
  1439.          PUTBYTE_TO_STATUS(card, ':');
  1440.      }
  1442. for (p = data, end = data+len; p < end; p++) {
  1443. __u8 w;
  1444. PUTBYTE_TO_STATUS(card, ' ');
  1445. w = (*p >> 4) & 0xf;
  1446. PUTBYTE_TO_STATUS(card, (w < 10) ? '0'+w : 'A'-10+w);
  1447. w = *p & 0xf;
  1448. PUTBYTE_TO_STATUS(card, (w < 10) ? '0'+w : 'A'-10+w);
  1449. }
  1450. PUTBYTE_TO_STATUS(card, 'n');
  1452. cmd.command = ISDN_STAT_STAVAIL;
  1453. cmd.driver = card->myid;
  1454. cmd.arg = len*3+5;
  1455. card->interface.statcallb(&cmd);
  1456. }
  1458. /* ------------------------------------------------------------------- */
  1460. static _cmsg cmdcmsg;
  1462. static int capidrv_ioctl(isdn_ctrl * c, capidrv_contr * card)
  1463. {
  1464. switch (c->arg) {
  1465. case 1:
  1466. debugmode = (int)(*((unsigned int *)c->parm.num));
  1467. printk(KERN_DEBUG "capidrv-%d: debugmode=%dn",
  1468. card->contrnr, debugmode);
  1469. return 0;
  1470. default:
  1471. printk(KERN_DEBUG "capidrv-%d: capidrv_ioctl(%ld) called ??n",
  1472. card->contrnr, c->arg);
  1473. return -EINVAL;
  1474. }
  1475. return -EINVAL;
  1476. }
  1478. /*
  1479.  * Handle leased lines (CAPI-Bundling)
  1480.  */
  1482. struct internal_bchannelinfo {
  1483.    unsigned short channelalloc;
  1484.    unsigned short operation;
  1485.    unsigned char  cmask[31];
  1486. };
  1488. static int decodeFVteln(char *teln, unsigned long *bmaskp, int *activep)
  1489. {
  1490. unsigned long bmask = 0;
  1491. int active = !0;
  1492. char *s;
  1493. int i;
  1495. if (strncmp(teln, "FV:", 3) != 0)
  1496. return 1;
  1497. s = teln + 3;
  1498. while (*s && *s == ' ') s++;
  1499. if (!*s) return -2;
  1500. if (*s == 'p' || *s == 'P') {
  1501. active = 0;
  1502. s++;
  1503. }
  1504. if (*s == 'a' || *s == 'A') {
  1505. active = !0;
  1506. s++;
  1507. }
  1508. while (*s) {
  1509. int digit1 = 0;
  1510. int digit2 = 0;
  1511. if (!isdigit(*s)) return -3;
  1512. while (isdigit(*s)) { digit1 = digit1*10 + (*s - '0'); s++; }
  1513. if (digit1 <= 0 && digit1 > 30) return -4;
  1514. if (*s == 0 || *s == ',' || *s == ' ') {
  1515. bmask |= (1 << digit1);
  1516. digit1 = 0;
  1517. if (*s) s++;
  1518. continue;
  1519. }
  1520. if (*s != '-') return -5;
  1521. s++;
  1522. if (!isdigit(*s)) return -3;
  1523. while (isdigit(*s)) { digit2 = digit2*10 + (*s - '0'); s++; }
  1524. if (digit2 <= 0 && digit2 > 30) return -4;
  1525. if (*s == 0 || *s == ',' || *s == ' ') {
  1526. if (digit1 > digit2)
  1527. for (i = digit2; i <= digit1 ; i++)
  1528. bmask |= (1 << i);
  1529. else 
  1530. for (i = digit1; i <= digit2 ; i++)
  1531. bmask |= (1 << i);
  1532. digit1 = digit2 = 0;
  1533. if (*s) s++;
  1534. continue;
  1535. }
  1536. return -6;
  1537. }
  1538. if (activep) *activep = active;
  1539. if (bmaskp) *bmaskp = bmask;
  1540. return 0;
  1541. }
  1543. static int FVteln2capi20(char *teln, __u8 AdditionalInfo[1+2+2+31])
  1544. {
  1545. unsigned long bmask;
  1546. int active;
  1547. int rc, i;
  1548.    
  1549. rc = decodeFVteln(teln, &bmask, &active);
  1550. if (rc) return rc;
  1551. /* Length */
  1552. AdditionalInfo[0] = 2+2+31;
  1553.         /* Channel: 3 => use channel allocation */
  1554.         AdditionalInfo[1] = 3; AdditionalInfo[2] = 0;
  1555. /* Operation: 0 => DTE mode, 1 => DCE mode */
  1556.         if (active) {
  1557.     AdditionalInfo[3] = 0; AdditionalInfo[4] = 0;
  1558.     } else {
  1559.     AdditionalInfo[3] = 1; AdditionalInfo[4] = 0;
  1560. }
  1561. /* Channel mask array */
  1562. AdditionalInfo[5] = 0; /* no D-Channel */
  1563. for (i=1; i <= 30; i++)
  1564. AdditionalInfo[5+i] = (bmask & (1 << i)) ? 0xff : 0;
  1565. return 0;
  1566. }
  1568. static int capidrv_command(isdn_ctrl * c, capidrv_contr * card)
  1569. {
  1570. isdn_ctrl cmd;
  1571. struct capidrv_bchan *bchan;
  1572. struct capidrv_plci *plcip;
  1573. __u8 AdditionalInfo[1+2+2+31];
  1574.         int rc, isleasedline = 0;
  1576. if (c->command == ISDN_CMD_IOCTL)
  1577. return capidrv_ioctl(c, card);
  1579. switch (c->command) {
  1580. case ISDN_CMD_DIAL:{
  1581. __u8 calling[ISDN_MSNLEN + 3];
  1582. __u8 called[ISDN_MSNLEN + 2];
  1584. if (debugmode)
  1585. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_DIAL(ch=%ld,"%s,%d,%d,%s")n",
  1586. card->contrnr,
  1587. c->arg,
  1588.         c->parm.setup.phone,
  1589.         c->parm.setup.si1,
  1590.         c->parm.setup.si2,
  1591.         c->parm.setup.eazmsn);
  1593. bchan = &card->bchans[c->arg % card->nbchan];
  1595. if (bchan->plcip) {
  1596. printk(KERN_ERR "capidrv-%d: dail ch=%ld,"%s,%d,%d,%s" in use (plci=0x%x)n",
  1597. card->contrnr,
  1598.          c->arg, 
  1599.         c->parm.setup.phone,
  1600.         c->parm.setup.si1,
  1601.         c->parm.setup.si2,
  1602.         c->parm.setup.eazmsn,
  1603.         bchan->plcip->plci);
  1604. return 0;
  1605. }
  1606. bchan->si1 = c->parm.setup.si1;
  1607. bchan->si2 = c->parm.setup.si2;
  1609. strncpy(bchan->num, c->parm.setup.phone, sizeof(bchan->num));
  1610. strncpy(bchan->mynum, c->parm.setup.eazmsn, sizeof(bchan->mynum));
  1611.                         rc = FVteln2capi20(bchan->num, AdditionalInfo);
  1612. isleasedline = (rc == 0);
  1613. if (rc < 0)
  1614. printk(KERN_ERR "capidrv-%d: WARNING: illegal leased linedefinition "%s"n", card->contrnr, bchan->num);
  1616. if (isleasedline) {
  1617. calling[0] = 0;
  1618. called[0] = 0;
  1619.         if (debugmode)
  1620. printk(KERN_DEBUG "capidrv-%d: connecting leased linen", card->contrnr);
  1621. } else {
  1622.          calling[0] = strlen(bchan->mynum) + 2;
  1623.          calling[1] = 0;
  1624.       calling[2] = 0x80;
  1625.     strncpy(calling + 3, bchan->mynum, ISDN_MSNLEN);
  1626. called[0] = strlen(bchan->num) + 1;
  1627. called[1] = 0x80;
  1628. strncpy(called + 2, bchan->num, ISDN_MSNLEN);
  1629. }
  1631. capi_fill_CONNECT_REQ(&cmdcmsg,
  1632.       global.appid,
  1633.       card->msgid++,
  1634.       card->contrnr, /* adr */
  1635.   si2cip(bchan->si1, bchan->si2), /* cipvalue */
  1636.       called, /* CalledPartyNumber */
  1637.       calling, /* CallingPartyNumber */
  1638.       0, /* CalledPartySubaddress */
  1639.       0, /* CallingPartySubaddress */
  1640.     b1prot(bchan->l2, bchan->l3), /* B1protocol */
  1641.     b2prot(bchan->l2, bchan->l3), /* B2protocol */
  1642.     b3prot(bchan->l2, bchan->l3), /* B3protocol */
  1643.     b1config(bchan->l2, bchan->l3), /* B1configuration */
  1644.       0, /* B2configuration */
  1645.       0, /* B3configuration */
  1646.       0, /* BC */
  1647.       0, /* LLC */
  1648.       0, /* HLC */
  1649.       /* BChannelinformation */
  1650.       isleasedline ? AdditionalInfo : 0,
  1651.       0, /* Keypadfacility */
  1652.       0, /* Useruserdata */
  1653.       0 /* Facilitydataarray */
  1654.     );
  1655. if ((plcip = new_plci(card, (c->arg % card->nbchan))) == 0) {
  1656. cmd.command = ISDN_STAT_DHUP;
  1657. cmd.driver = card->myid;
  1658. cmd.arg = (c->arg % card->nbchan);
  1659. card->interface.statcallb(&cmd);
  1660. return -1;
  1661. }
  1662. plcip->msgid = cmdcmsg.Messagenumber;
  1663. plcip->leasedline = isleasedline;
  1664. plci_change_state(card, plcip, EV_PLCI_CONNECT_REQ);
  1665. send_message(card, &cmdcmsg);
  1666. return 0;
  1667. }
  1669. case ISDN_CMD_ACCEPTD:
  1671. bchan = &card->bchans[c->arg % card->nbchan];
  1672. if (debugmode)
  1673. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_ACCEPTD(ch=%ld) l2=%d l3=%dn",
  1674.        card->contrnr,
  1675.        c->arg, bchan->l2, bchan->l3);
  1677. capi_fill_CONNECT_RESP(&cmdcmsg,
  1678.        global.appid,
  1679.        card->msgid++,
  1680.        bchan->plcip->plci, /* adr */
  1681.        0, /* Reject */
  1682.        b1prot(bchan->l2, bchan->l3), /* B1protocol */
  1683.        b2prot(bchan->l2, bchan->l3), /* B2protocol */
  1684.        b3prot(bchan->l2, bchan->l3), /* B3protocol */
  1685.        b1config(bchan->l2, bchan->l3), /* B1configuration */
  1686.        0, /* B2configuration */
  1687.        0, /* B3configuration */
  1688.        0, /* ConnectedNumber */
  1689.        0, /* ConnectedSubaddress */
  1690.        0, /* LLC */
  1691.        0, /* BChannelinformation */
  1692.        0, /* Keypadfacility */
  1693.        0, /* Useruserdata */
  1694.        0 /* Facilitydataarray */
  1695. );
  1696. capi_cmsg2message(&cmdcmsg, cmdcmsg.buf);
  1697. plci_change_state(card, bchan->plcip, EV_PLCI_CONNECT_RESP);
  1698. send_message(card, &cmdcmsg);
  1699. return 0;
  1701. case ISDN_CMD_ACCEPTB:
  1702. if (debugmode)
  1703. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_ACCEPTB(ch=%ld)n",
  1704.        card->contrnr,
  1705.        c->arg);
  1706. return -ENOSYS;
  1708. case ISDN_CMD_HANGUP:
  1709. if (debugmode)
  1710. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_HANGUP(ch=%ld)n",
  1711.        card->contrnr,
  1712.        c->arg);
  1713. bchan = &card->bchans[c->arg % card->nbchan];
  1715. if (bchan->disconnecting) {
  1716. if (debugmode)
  1717. printk(KERN_DEBUG "capidrv-%d: chan %ld already disconnecting ...n",
  1718.        card->contrnr,
  1719.        c->arg);
  1720. return 0;
  1721. }
  1722. if (bchan->nccip) {
  1723. bchan->disconnecting = 1;
  1724. capi_fill_DISCONNECT_B3_REQ(&cmdcmsg,
  1725.     global.appid,
  1726.     card->msgid++,
  1727.     bchan->nccip->ncci,
  1728.     0 /* NCPI */
  1729. );
  1730. ncci_change_state(card, bchan->nccip, EV_NCCI_DISCONNECT_B3_REQ);
  1731. send_message(card, &cmdcmsg);
  1732. return 0;
  1733. } else if (bchan->plcip) {
  1734. if (bchan->plcip->state == ST_PLCI_INCOMING) {
  1735. /*
  1736.  * just ignore, we a called from
  1737.  * isdn_status_callback(),
  1738.  * which will return 0 or 2, this is handled
  1739.  * by the CONNECT_IND handler
  1740.  */
  1741. bchan->disconnecting = 1;
  1742. return 0;
  1743. } else if (bchan->plcip->plci) {
  1744. bchan->disconnecting = 1;
  1745. capi_fill_DISCONNECT_REQ(&cmdcmsg,
  1746.  global.appid,
  1747.  card->msgid++,
  1748.       bchan->plcip->plci,
  1749.  0, /* BChannelinformation */
  1750.  0, /* Keypadfacility */
  1751.  0, /* Useruserdata */
  1752.  0 /* Facilitydataarray */
  1753. );
  1754. plci_change_state(card, bchan->plcip, EV_PLCI_DISCONNECT_REQ);
  1755. send_message(card, &cmdcmsg);
  1756. return 0;
  1757. } else {
  1758. printk(KERN_ERR "capidrv-%d: chan %ld disconnect request while waiting for CONNECT_CONFn",
  1759.        card->contrnr,
  1760.        c->arg);
  1761. return -EINVAL;
  1762. }
  1763. }
  1764. printk(KERN_ERR "capidrv-%d: chan %ld disconnect request on free channeln",
  1765.        card->contrnr,
  1766.        c->arg);
  1767. return -EINVAL;
  1768. /* ready */
  1770. case ISDN_CMD_SETL2:
  1771. if (debugmode)
  1772. printk(KERN_DEBUG "capidrv-%d: set L2 on chan %ld to %ldn",
  1773.        card->contrnr,
  1774.        (c->arg & 0xff), (c->arg >> 8));
  1775. bchan = &card->bchans[(c->arg & 0xff) % card->nbchan];
  1776. bchan->l2 = (c->arg >> 8);
  1777. return 0;
  1779. case ISDN_CMD_SETL3:
  1780. if (debugmode)
  1781. printk(KERN_DEBUG "capidrv-%d: set L3 on chan %ld to %ldn",
  1782.        card->contrnr,
  1783.        (c->arg & 0xff), (c->arg >> 8));
  1784. bchan = &card->bchans[(c->arg & 0xff) % card->nbchan];
  1785. bchan->l3 = (c->arg >> 8);
  1786. return 0;
  1788. case ISDN_CMD_SETEAZ:
  1789. if (debugmode)
  1790. printk(KERN_DEBUG "capidrv-%d: set EAZ "%s" on chan %ldn",
  1791.        card->contrnr,
  1792.        c->parm.num, c->arg);
  1793. bchan = &card->bchans[c->arg % card->nbchan];
  1794. strncpy(bchan->msn, c->parm.num, ISDN_MSNLEN);
  1795. return 0;
  1797. case ISDN_CMD_CLREAZ:
  1798. if (debugmode)
  1799. printk(KERN_DEBUG "capidrv-%d: clearing EAZ on chan %ldn",
  1800. card->contrnr, c->arg);
  1801. bchan = &card->bchans[c->arg % card->nbchan];
  1802. bchan->msn[0] = 0;
  1803. return 0;
  1805. case ISDN_CMD_LOCK:
  1806. if (debugmode > 1)
  1807. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_LOCK (%ld)n", card->contrnr, c->arg);
  1808. MOD_INC_USE_COUNT;
  1809. break;
  1811. case ISDN_CMD_UNLOCK:
  1812. if (debugmode > 1)
  1813. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_UNLOCK (%ld)n",
  1814. card->contrnr, c->arg);
  1815. MOD_DEC_USE_COUNT;
  1816. break;
  1818. /* never called */
  1819. case ISDN_CMD_GETL2:
  1820. if (debugmode)
  1821. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_GETL2n",
  1822. card->contrnr);
  1823. return -ENODEV;
  1824. case ISDN_CMD_GETL3:
  1825. if (debugmode)
  1826. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_GETL3n",
  1827. card->contrnr);
  1828. return -ENODEV;
  1829. case ISDN_CMD_GETEAZ:
  1830. if (debugmode)
  1831. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_GETEAZn",
  1832. card->contrnr);
  1833. return -ENODEV;
  1834. case ISDN_CMD_SETSIL:
  1835. if (debugmode)
  1836. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_SETSILn",
  1837. card->contrnr);
  1838. return -ENODEV;
  1839. case ISDN_CMD_GETSIL:
  1840. if (debugmode)
  1841. printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_GETSILn",
  1842. card->contrnr);
  1843. return -ENODEV;
  1844. default:
  1845. printk(KERN_ERR "capidrv-%d: ISDN_CMD_%d, Huh?n",
  1846. card->contrnr, c->command);
  1847. return -EINVAL;
  1848. }
  1849. return 0;
  1850. }
  1852. static int if_command(isdn_ctrl * c)
  1853. {
  1854. capidrv_contr *card = findcontrbydriverid(c->driver);
  1856. if (card)
  1857. return capidrv_command(c, card);
  1859. printk(KERN_ERR
  1860.      "capidrv: if_command %d called with invalid driverId %d!n",
  1861. c->command, c->driver);
  1862. return -ENODEV;
  1863. }
  1865. static _cmsg sendcmsg;
  1867. static int if_sendbuf(int id, int channel, int doack, struct sk_buff *skb)
  1868. {
  1869. capidrv_contr *card = findcontrbydriverid(id);
  1870. capidrv_bchan *bchan;
  1871. capidrv_ncci *nccip;
  1872. int len = skb->len;
  1873. size_t msglen;
  1874. __u16 errcode;
  1875. __u16 datahandle;
  1877. if (!card) {
  1878. printk(KERN_ERR "capidrv: if_sendbuf called with invalid driverId %d!n",
  1879.        id);
  1880. return 0;
  1881. }
  1882. if (debugmode > 1)
  1883. printk(KERN_DEBUG "capidrv-%d: sendbuf len=%d skb=%p doack=%dn",
  1884. card->contrnr, len, skb, doack);
  1885. bchan = &card->bchans[channel % card->nbchan];
  1886. nccip = bchan->nccip;
  1887. if (!nccip || nccip->state != ST_NCCI_ACTIVE) {
  1888. printk(KERN_ERR "capidrv-%d: if_sendbuf: %s:%d: chan not up!n",
  1889.        card->contrnr, card->name, channel);
  1890. return 0;
  1891. }
  1892. datahandle = nccip->datahandle;
  1893. capi_fill_DATA_B3_REQ(&sendcmsg, global.appid, card->msgid++,
  1894.       nccip->ncci, /* adr */
  1895.       (__u32) skb->data, /* Data */
  1896.       skb->len, /* DataLength */
  1897.       datahandle, /* DataHandle */
  1898.       0 /* Flags */
  1899.     );
  1901. if (capidrv_add_ack(nccip, datahandle, doack ? skb->len : -1) < 0)
  1902.    return 0;
  1904. capi_cmsg2message(&sendcmsg, sendcmsg.buf);
  1905. msglen = CAPIMSG_LEN(sendcmsg.buf);
  1906. if (skb_headroom(skb) < msglen) {
  1907. struct sk_buff *nskb = skb_realloc_headroom(skb, msglen);
  1908. if (!nskb) {
  1909. printk(KERN_ERR "capidrv-%d: if_sendbuf: no memoryn",
  1910. card->contrnr);
  1911.         (void)capidrv_del_ack(nccip, datahandle);
  1912. return 0;
  1913. }
  1914. printk(KERN_DEBUG "capidrv-%d: only %d bytes headroom, need %dn",
  1915.        card->contrnr, skb_headroom(skb), msglen);
  1916. memcpy(skb_push(nskb, msglen), sendcmsg.buf, msglen);
  1917. errcode = (*capifuncs->capi_put_message) (global.appid, nskb);
  1918. if (errcode == CAPI_NOERROR) {
  1919. dev_kfree_skb(skb);
  1920. nccip->datahandle++;
  1921. global.nsentdatapkt++;
  1922. return len;
  1923. }
  1924.         (void)capidrv_del_ack(nccip, datahandle);
  1925.         dev_kfree_skb(nskb);
  1926. return errcode == CAPI_SENDQUEUEFULL ? 0 : -1;
  1927. } else {
  1928. memcpy(skb_push(skb, msglen), sendcmsg.buf, msglen);
  1929. errcode = (*capifuncs->capi_put_message) (global.appid, skb);
  1930. if (errcode == CAPI_NOERROR) {
  1931. nccip->datahandle++;
  1932. global.nsentdatapkt++;
  1933. return len;
  1934. }
  1935. skb_pull(skb, msglen);
  1936.         (void)capidrv_del_ack(nccip, datahandle);
  1937. return errcode == CAPI_SENDQUEUEFULL ? 0 : -1;
  1938. }
  1939. }
  1941. static int if_readstat(__u8 *buf, int len, int user, int id, int channel)
  1942. {
  1943. capidrv_contr *card = findcontrbydriverid(id);
  1944. int count;
  1945. __u8 *p;
  1947. if (!card) {
  1948. printk(KERN_ERR "capidrv: if_readstat called with invalid driverId %d!n",
  1949.        id);
  1950. return -ENODEV;
  1951. }
  1953. for (p=buf, count=0; count < len; p++, count++) {
  1954.         if (user)
  1955.                 put_user(*card->q931_read++, p);
  1956.         else
  1957.                 *p = *card->q931_read++;
  1958.         if (card->q931_read > card->q931_end)
  1959.                 card->q931_read = card->q931_buf;
  1960. }
  1961. return count;
  1963. }
  1965. static void enable_dchannel_trace(capidrv_contr *card)
  1966. {
  1967.         __u8 manufacturer[CAPI_MANUFACTURER_LEN];
  1968.         capi_version version;
  1969. __u16 contr = card->contrnr;
  1970. __u16 errcode;
  1971. __u16 avmversion[3];
  1973.         errcode = (*capifuncs->capi_get_manufacturer)(contr, manufacturer);
  1974.         if (errcode != CAPI_NOERROR) {
  1975.    printk(KERN_ERR "%s: can't get manufacturer (0x%x)n",
  1976. card->name, errcode);
  1977.    return;
  1978. }
  1979. if (strstr(manufacturer, "AVM") == 0) {
  1980.    printk(KERN_ERR "%s: not from AVM, no d-channel trace possible (%s)n",
  1981. card->name, manufacturer);
  1982.    return;
  1983. }
  1984.         errcode = (*capifuncs->capi_get_version)(contr, &version);
  1985.         if (errcode != CAPI_NOERROR) {
  1986.    printk(KERN_ERR "%s: can't get version (0x%x)n",
  1987. card->name, errcode);
  1988.    return;
  1989. }
  1990. avmversion[0] = (version.majormanuversion >> 4) & 0x0f;
  1991. avmversion[1] = (version.majormanuversion << 4) & 0xf0;
  1992. avmversion[1] |= (version.minormanuversion >> 4) & 0x0f;
  1993. avmversion[2] |= version.minormanuversion & 0x0f;
  1995.         if (avmversion[0] > 3 || (avmversion[0] == 3 && avmversion[1] > 5)) {
  1996. printk(KERN_INFO "%s: D2 trace enabledn", card->name);
  1997. capi_fill_MANUFACTURER_REQ(&cmdcmsg, global.appid,
  1998.    card->msgid++,
  1999.    contr,
  2000.    0x214D5641,  /* ManuID */
  2001.    0,           /* Class */
  2002.    1,           /* Function */
  2003.    (_cstruct)"04200140000");
  2004. } else {
  2005. printk(KERN_INFO "%s: D3 trace enabledn", card->name);
  2006. capi_fill_MANUFACTURER_REQ(&cmdcmsg, global.appid,
  2007.    card->msgid++,
  2008.    contr,
  2009.    0x214D5641,  /* ManuID */
  2010.    0,           /* Class */
  2011.    1,           /* Function */
  2012.    (_cstruct)"0402030000");
  2013. }
  2014. send_message(card, &cmdcmsg);
  2015. }
  2018. static void send_listen(capidrv_contr *card)
  2019. {
  2020. capi_fill_LISTEN_REQ(&cmdcmsg, global.appid,
  2021.      card->msgid++,
  2022.      card->contrnr, /* controller */
  2023.      1 << 6, /* Infomask */
  2024.      card->cipmask,
  2025.      card->cipmask2,
  2026.      0, 0);
  2027. send_message(card, &cmdcmsg);
  2028. listen_change_state(card, EV_LISTEN_REQ);
  2029. }
  2031. static void listentimerfunc(unsigned long x)
  2032. {
  2033. capidrv_contr *card = (capidrv_contr *)x;
  2034. if (card->state != ST_LISTEN_NONE && card->state != ST_LISTEN_ACTIVE)
  2035. printk(KERN_ERR "%s: controller dead ??n", card->name);
  2036.         send_listen(card);
  2037. mod_timer(&card->listentimer, jiffies + 60*HZ);
  2038. }
  2041. static int capidrv_addcontr(__u16 contr, struct capi_profile *profp)
  2042. {
  2043. capidrv_contr *card;
  2044. long flags;
  2045. isdn_ctrl cmd;
  2046. char id[20];
  2047. int i;
  2049. MOD_INC_USE_COUNT;
  2051. sprintf(id, "capidrv-%d", contr);
  2052. if (!(card = (capidrv_contr *) kmalloc(sizeof(capidrv_contr), GFP_ATOMIC))) {
  2053. printk(KERN_WARNING
  2054.  "capidrv: (%s) Could not allocate contr-struct.n", id);
  2055. MOD_DEC_USE_COUNT;
  2056. return -1;
  2057. }
  2058. memset(card, 0, sizeof(capidrv_contr));
  2059. init_timer(&card->listentimer);
  2060. strcpy(card->name, id);
  2061. card->contrnr = contr;
  2062. card->nbchan = profp->nbchannel;
  2063. card->bchans = (capidrv_bchan *) kmalloc(sizeof(capidrv_bchan) * card->nbchan, GFP_ATOMIC);
  2064. if (!card->bchans) {
  2065. printk(KERN_WARNING
  2066. "capidrv: (%s) Could not allocate bchan-structs.n", id);
  2067. kfree(card);
  2068. MOD_DEC_USE_COUNT;
  2069. return -1;
  2070. }
  2071. card->interface.channels = profp->nbchannel;
  2072. card->interface.maxbufsize = 2048;
  2073. card->interface.command = if_command;
  2074. card->interface.writebuf_skb = if_sendbuf;
  2075. card->interface.writecmd = 0;
  2076. card->interface.readstat = if_readstat;
  2077. card->interface.features = ISDN_FEATURE_L2_HDLC |
  2078.         ISDN_FEATURE_L2_TRANS |
  2079.         ISDN_FEATURE_L3_TRANS |
  2080.    ISDN_FEATURE_P_UNKNOWN |
  2081.    ISDN_FEATURE_L2_X75I |
  2082.    ISDN_FEATURE_L2_X75UI |
  2083.    ISDN_FEATURE_L2_X75BUI;
  2084. if (profp->support1 & (1<<2))
  2085. card->interface.features |= ISDN_FEATURE_L2_V11096 |
  2086.          ISDN_FEATURE_L2_V11019 |
  2087.          ISDN_FEATURE_L2_V11038;
  2088. if (profp->support1 & (1<<8))
  2089. card->interface.features |= ISDN_FEATURE_L2_MODEM;
  2090. card->interface.hl_hdrlen = 22; /* len of DATA_B3_REQ */
  2091. strncpy(card->interface.id, id, sizeof(card->interface.id) - 1);
  2094. card->q931_read = card->q931_buf;
  2095. card->q931_write = card->q931_buf;
  2096. card->q931_end = card->q931_buf + sizeof(card->q931_buf) - 1;
  2098. if (!register_isdn(&card->interface)) {
  2099. printk(KERN_ERR "capidrv: Unable to register contr %sn", id);
  2100. kfree(card->bchans);
  2101. kfree(card);
  2102. MOD_DEC_USE_COUNT;
  2103. return -1;
  2104. }
  2105. card->myid = card->interface.channels;
  2107. spin_lock_irqsave(&global_lock, flags);
  2108. card->next = global.contr_list;
  2109. global.contr_list = card;
  2110. global.ncontr++;
  2111. spin_unlock_irqrestore(&global_lock, flags);
  2113. memset(card->bchans, 0, sizeof(capidrv_bchan) * card->nbchan);
  2114. for (i = 0; i < card->nbchan; i++) {
  2115. card->bchans[i].contr = card;
  2116. }
  2118. cmd.command = ISDN_STAT_RUN;
  2119. cmd.driver = card->myid;
  2120. card->interface.statcallb(&cmd);
  2122. card->cipmask = 0x1FFF03FF; /* any */
  2123. card->cipmask2 = 0;
  2125. send_listen(card);
  2127. card->listentimer.data = (unsigned long)card;
  2128. card->listentimer.function = listentimerfunc;
  2129. mod_timer(&card->listentimer, jiffies + 60*HZ);
  2131. printk(KERN_INFO "%s: now up (%d B channels)n",
  2132. card->name, card->nbchan);
  2134. enable_dchannel_trace(card);
  2136. return 0;
  2137. }
  2139. static int capidrv_delcontr(__u16 contr)
  2140. {
  2141. capidrv_contr **pp, *card;
  2142. unsigned long flags;
  2143. isdn_ctrl cmd;
  2145. spin_lock_irqsave(&global_lock, flags);
  2146. for (card = global.contr_list; card; card = card->next) {
  2147. if (card->contrnr == contr)
  2148. break;
  2149. }
  2150. if (!card) {
  2151. spin_unlock_irqrestore(&global_lock, flags);
  2152. printk(KERN_ERR "capidrv: delcontr: no contr %un", contr);
  2153. return -1;
  2154. }
  2155. spin_unlock_irqrestore(&global_lock, flags);
  2157. del_timer(&card->listentimer);
  2159. if (debugmode)
  2160. printk(KERN_DEBUG "capidrv-%d: id=%d unloadingn",
  2161. card->contrnr, card->myid);
  2163. cmd.command = ISDN_STAT_STOP;
  2164. cmd.driver = card->myid;
  2165. card->interface.statcallb(&cmd);
  2167. while (card->nbchan) {
  2169. cmd.command = ISDN_STAT_DISCH;
  2170. cmd.driver = card->myid;
  2171. cmd.arg = card->nbchan-1;
  2172.         cmd.parm.num[0] = 0;
  2173. if (debugmode)
  2174. printk(KERN_DEBUG "capidrv-%d: id=%d disable chan=%ldn",
  2175. card->contrnr, card->myid, cmd.arg);
  2176. card->interface.statcallb(&cmd);
  2178. if (card->bchans[card->nbchan-1].nccip)
  2179. free_ncci(card, card->bchans[card->nbchan-1].nccip);
  2180. if (card->bchans[card->nbchan-1].plcip)
  2181. free_plci(card, card->bchans[card->nbchan-1].plcip);
  2182. if (card->plci_list)
  2183. printk(KERN_ERR "capidrv: bug in free_plci()n");
  2184. card->nbchan--;
  2185. }
  2186. kfree(card->bchans);
  2187. card->bchans = 0;
  2189. if (debugmode)
  2190. printk(KERN_DEBUG "capidrv-%d: id=%d isdn unloadn",
  2191. card->contrnr, card->myid);
  2193. cmd.command = ISDN_STAT_UNLOAD;
  2194. cmd.driver = card->myid;
  2195. card->interface.statcallb(&cmd);
  2197. if (debugmode)
  2198. printk(KERN_DEBUG "capidrv-%d: id=%d remove contr from listn",
  2199. card->contrnr, card->myid);
  2201. spin_lock_irqsave(&global_lock, flags);
  2202. for (pp = &global.contr_list; *pp; pp = &(*pp)->next) {
  2203. if (*pp == card) {
  2204. *pp = (*pp)->next;
  2205. card->next = 0;
  2206. global.ncontr--;
  2207. break;
  2208. }
  2209. }
  2210. spin_unlock_irqrestore(&global_lock, flags);
  2212. printk(KERN_INFO "%s: now down.n", card->name);
  2214. kfree(card);
  2216. MOD_DEC_USE_COUNT;
  2218. return 0;
  2219. }
  2222. static void lower_callback(unsigned int cmd, __u32 contr, void *data)
  2223. {
  2225. switch (cmd) {
  2226. case KCI_CONTRUP:
  2227. printk(KERN_INFO "capidrv: controller %hu upn", contr);
  2228. (void) capidrv_addcontr(contr, (capi_profile *) data);
  2229. break;
  2230. case KCI_CONTRDOWN:
  2231. printk(KERN_INFO "capidrv: controller %hu downn", contr);
  2232. (void) capidrv_delcontr(contr);
  2233. break;
  2234. }
  2235. }
  2237. /*
  2238.  * /proc/capi/capidrv:
  2239.  * nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
  2240.  */
  2241. static int proc_capidrv_read_proc(char *page, char **start, off_t off,
  2242.                                        int count, int *eof, void *data)
  2243. {
  2244. int len = 0;
  2246. len += sprintf(page+len, "%lu %lu %lu %lun",
  2247. global.nrecvctlpkt,
  2248. global.nrecvdatapkt,
  2249. global.nsentctlpkt,
  2250. global.nsentdatapkt);
  2251. if (off+count >= len)
  2252.    *eof = 1;
  2253. if (len < off)
  2254.            return 0;
  2255. *start = page + off;
  2256. return ((count < len-off) ? count : len-off);
  2257. }
  2259. static struct procfsentries {
  2260.   char *name;
  2261.   mode_t mode;
  2262.   int (*read_proc)(char *page, char **start, off_t off,
  2263.                                        int count, int *eof, void *data);
  2264.   struct proc_dir_entry *procent;
  2265. } procfsentries[] = {
  2266.    /* { "capi",   S_IFDIR, 0 }, */
  2267.    { "capi/capidrv",    0  , proc_capidrv_read_proc },
  2268. };
  2270. static void __init proc_init(void)
  2271. {
  2272.     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
  2273.     int i;
  2275.     for (i=0; i < nelem; i++) {
  2276.         struct procfsentries *p = procfsentries + i;
  2277. p->procent = create_proc_entry(p->name, p->mode, 0);
  2278. if (p->procent) p->procent->read_proc = p->read_proc;
  2279.     }
  2280. }
  2282. static void __exit proc_exit(void)
  2283. {
  2284.     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
  2285.     int i;
  2287.     for (i=nelem-1; i >= 0; i--) {
  2288.         struct procfsentries *p = procfsentries + i;
  2289. if (p->procent) {
  2290.    remove_proc_entry(p->name, 0);
  2291.    p->procent = 0;
  2292. }
  2293.     }
  2294. }
  2296. static struct capi_interface_user cuser = {
  2297. name: "capidrv",
  2298. callback: lower_callback
  2299. };
  2301. static int __init capidrv_init(void)
  2302. {
  2303. struct capi_register_params rparam;
  2304. capi_profile profile;
  2305. char rev[32];
  2306. char *p;
  2307. __u32 ncontr, contr;
  2308. __u16 errcode;
  2310. MOD_INC_USE_COUNT;
  2312. capifuncs = attach_capi_interface(&cuser);
  2314. if (!capifuncs) {
  2315. MOD_DEC_USE_COUNT;
  2316. return -EIO;
  2317. }
  2319. if ((p = strchr(revision, ':')) != 0 && p[1]) {
  2320. strncpy(rev, p + 2, sizeof(rev));
  2321. rev[sizeof(rev)-1] = 0;
  2322. if ((p = strchr(rev, '$')) != 0 && p > rev)
  2323.    *(p-1) = 0;
  2324. } else
  2325. strcpy(rev, "1.0");
  2327. rparam.level3cnt = -2;  /* number of bchannels twice */
  2328. rparam.datablkcnt = 16;
  2329. rparam.datablklen = 2048;
  2330. errcode = (*capifuncs->capi_register) (&rparam, &global.appid);
  2331. if (errcode) {
  2332. detach_capi_interface(&cuser);
  2333. MOD_DEC_USE_COUNT;
  2334. return -EIO;
  2335. }
  2337. errcode = (*capifuncs->capi_get_profile) (0, &profile);
  2338. if (errcode != CAPI_NOERROR) {
  2339. (void) (*capifuncs->capi_release) (global.appid);
  2340. detach_capi_interface(&cuser);
  2341. MOD_DEC_USE_COUNT;
  2342. return -EIO;
  2343. }
  2345. (void) (*capifuncs->capi_set_signal) (global.appid, capidrv_signal, 0);
  2347. ncontr = profile.ncontroller;
  2348. for (contr = 1; contr <= ncontr; contr++) {
  2349. errcode = (*capifuncs->capi_get_profile) (contr, &profile);
  2350. if (errcode != CAPI_NOERROR)
  2351. continue;
  2352. (void) capidrv_addcontr(contr, &profile);
  2353. }
  2354. proc_init();
  2356. printk(KERN_NOTICE "capidrv: Rev %s: loadedn", rev);
  2357. MOD_DEC_USE_COUNT;
  2359. return 0;
  2360. }
  2362. static void __exit capidrv_exit(void)
  2363. {
  2364. char rev[10];
  2365. char *p;
  2367. if ((p = strchr(revision, ':')) != 0) {
  2368. strcpy(rev, p + 1);
  2369. p = strchr(rev, '$');
  2370. *p = 0;
  2371. } else {
  2372. strcpy(rev, " ??? ");
  2373. }
  2375. (void) (*capifuncs->capi_release) (global.appid);
  2377. detach_capi_interface(&cuser);
  2379. proc_exit();
  2381. printk(KERN_NOTICE "capidrv: Rev%s: unloadedn", rev);
  2382. }
  2384. module_init(capidrv_init);
  2385. module_exit(capidrv_exit);