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

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

Linux/Unix编程

开发平台：

Unix_Linux

kcapi.c：源码内容
  1. /* $Id: kcapi.c,v 1.1.4.1 2001/11/20 14:19:34 kai Exp $
  2.  * 
  3.  * Kernel CAPI 2.0 Module
  4.  * 
  5.  * Copyright 1999 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. #define CONFIG_AVMB1_COMPAT
  14. #include <linux/config.h>
  15. #include <linux/module.h>
  16. #include <linux/kernel.h>
  17. #include <linux/mm.h>
  18. #include <linux/interrupt.h>
  19. #include <linux/ioport.h>
  20. #include <asm/segment.h>
  21. #include <linux/proc_fs.h>
  22. #include <linux/skbuff.h>
  23. #include <linux/tqueue.h>
  24. #include <linux/capi.h>
  25. #include <linux/kernelcapi.h>
  26. #include <linux/locks.h>
  27. #include <linux/init.h>
  28. #include <asm/uaccess.h>
  29. #include "capicmd.h"
  30. #include "capiutil.h"
  31. #include "capilli.h"
  32. #ifdef CONFIG_AVMB1_COMPAT
  33. #include <linux/b1lli.h>
  34. #endif
  36. static char *revision = "$Revision: 1.1.4.1 $";
  38. /* ------------------------------------------------------------- */
  40. #define CARD_FREE 0
  41. #define CARD_DETECTED 1
  42. #define CARD_LOADING 2
  43. #define CARD_RUNNING 3
  45. /* ------------------------------------------------------------- */
  47. static int showcapimsgs = 0;
  49. MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
  50. MODULE_AUTHOR("Carsten Paeth");
  51. MODULE_LICENSE("GPL");
  52. MODULE_PARM(showcapimsgs, "i");
  54. /* ------------------------------------------------------------- */
  56. struct msgidqueue {
  57. struct msgidqueue *next;
  58. __u16 msgid;
  59. };
  61. struct capi_ncci {
  62. struct capi_ncci *next;
  63. __u16 applid;
  64. __u32 ncci;
  65. __u32 winsize;
  66. int   nmsg;
  67. struct msgidqueue *msgidqueue;
  68. struct msgidqueue *msgidlast;
  69. struct msgidqueue *msgidfree;
  70. struct msgidqueue msgidpool[CAPI_MAXDATAWINDOW];
  71. };
  73. struct capi_appl {
  74. __u16 applid;
  75. capi_register_params rparam;
  76. int releasing;
  77. void *param;
  78. void (*signal) (__u16 applid, void *param);
  79. struct sk_buff_head recv_queue;
  80. int nncci;
  81. struct capi_ncci *nccilist;
  83. unsigned long nrecvctlpkt;
  84. unsigned long nrecvdatapkt;
  85. unsigned long nsentctlpkt;
  86. unsigned long nsentdatapkt;
  87. };
  89. struct capi_notifier {
  90. struct capi_notifier *next;
  91. unsigned int cmd;
  92. __u32 controller;
  93. __u16 applid;
  94. __u32 ncci;
  95. };
  97. /* ------------------------------------------------------------- */
  99. static struct capi_version driver_version = {2, 0, 1, 1<<4};
  100. static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
  101. static char capi_manufakturer[64] = "AVM Berlin";
  103. #define APPL(a)    (&applications[(a)-1])
  104. #define VALID_APPLID(a)    ((a) && (a) <= CAPI_MAXAPPL && APPL(a)->applid == a)
  105. #define APPL_IS_FREE(a)    (APPL(a)->applid == 0)
  106. #define APPL_MARK_FREE(a)  do{ APPL(a)->applid=0; MOD_DEC_USE_COUNT; }while(0)
  107. #define APPL_MARK_USED(a)  do{ APPL(a)->applid=(a); MOD_INC_USE_COUNT; }while(0)
  109. #define NCCI2CTRL(ncci)    (((ncci) >> 24) & 0x7f)
  111. #define VALID_CARD(c)    ((c) > 0 && (c) <= CAPI_MAXCONTR)
  112. #define CARD(c)    (&cards[(c)-1])
  113. #define CARDNR(cp)    ((((cp)-cards)+1) & 0xff)
  115. static struct capi_appl applications[CAPI_MAXAPPL];
  116. static struct capi_ctr cards[CAPI_MAXCONTR];
  117. static int ncards = 0;
  118. static struct sk_buff_head recv_queue;
  119. static struct capi_interface_user *capi_users = 0;
  120. static spinlock_t capi_users_lock = SPIN_LOCK_UNLOCKED;
  121. static struct capi_driver *drivers;
  122. static spinlock_t drivers_lock = SPIN_LOCK_UNLOCKED;
  124. static struct tq_struct tq_state_notify;
  125. static struct tq_struct tq_recv_notify;
  127. /* -------- util functions ------------------------------------ */
  129. static char *cardstate2str(unsigned short cardstate)
  130. {
  131. switch (cardstate) {
  132.          default:
  133. case CARD_FREE: return "free";
  134. case CARD_DETECTED: return "detected";
  135. case CARD_LOADING: return "loading";
  136. case CARD_RUNNING: return "running";
  137. }
  138. }
  140. static inline int capi_cmd_valid(__u8 cmd)
  141. {
  142. switch (cmd) {
  143. case CAPI_ALERT:
  144. case CAPI_CONNECT:
  145. case CAPI_CONNECT_ACTIVE:
  146. case CAPI_CONNECT_B3_ACTIVE:
  147. case CAPI_CONNECT_B3:
  148. case CAPI_CONNECT_B3_T90_ACTIVE:
  149. case CAPI_DATA_B3:
  150. case CAPI_DISCONNECT_B3:
  151. case CAPI_DISCONNECT:
  152. case CAPI_FACILITY:
  153. case CAPI_INFO:
  154. case CAPI_LISTEN:
  155. case CAPI_MANUFACTURER:
  156. case CAPI_RESET_B3:
  157. case CAPI_SELECT_B_PROTOCOL:
  158. return 1;
  159. }
  160. return 0;
  161. }
  163. static inline int capi_subcmd_valid(__u8 subcmd)
  164. {
  165. switch (subcmd) {
  166. case CAPI_REQ:
  167. case CAPI_CONF:
  168. case CAPI_IND:
  169. case CAPI_RESP:
  170. return 1;
  171. }
  172. return 0;
  173. }
  175. /* -------- /proc functions ----------------------------------- */
  176. /*
  177.  * /proc/capi/applications:
  178.  *      applid l3cnt dblkcnt dblklen #ncci recvqueuelen
  179.  */
  180. static int proc_applications_read_proc(char *page, char **start, off_t off,
  181.                                        int count, int *eof, void *data)
  182. {
  183. struct capi_appl *ap;
  184. int i;
  185. int len = 0;
  187. for (i=0; i < CAPI_MAXAPPL; i++) {
  188. ap = &applications[i];
  189. if (ap->applid == 0) continue;
  190. len += sprintf(page+len, "%u %d %d %d %d %dn",
  191. ap->applid,
  192. ap->rparam.level3cnt,
  193. ap->rparam.datablkcnt,
  194. ap->rparam.datablklen,
  195. ap->nncci,
  196.                         skb_queue_len(&ap->recv_queue));
  197. if (len <= off) {
  198. off -= len;
  199. len = 0;
  200. } else {
  201. if (len-off > count)
  202. goto endloop;
  203. }
  204. }
  205. endloop:
  206. *start = page+off;
  207. if (len < count)
  208. *eof = 1;
  209. if (len>count) len = count;
  210. if (len<0) len = 0;
  211. return len;
  212. }
  214. /*
  215.  * /proc/capi/ncci:
  216.  * applid ncci winsize nblk
  217.  */
  218. static int proc_ncci_read_proc(char *page, char **start, off_t off,
  219.                                        int count, int *eof, void *data)
  220. {
  221. struct capi_appl *ap;
  222. struct capi_ncci *np;
  223. int i;
  224. int len = 0;
  226. for (i=0; i < CAPI_MAXAPPL; i++) {
  227. ap = &applications[i];
  228. if (ap->applid == 0) continue;
  229. for (np = ap->nccilist; np; np = np->next) {
  230. len += sprintf(page+len, "%d 0x%x %d %dn",
  231. np->applid,
  232. np->ncci,
  233. np->winsize,
  234. np->nmsg);
  235. if (len <= off) {
  236. off -= len;
  237. len = 0;
  238. } else {
  239. if (len-off > count)
  240. goto endloop;
  241. }
  242. }
  243. }
  244. endloop:
  245. *start = page+off;
  246. if (len < count)
  247. *eof = 1;
  248. if (len>count) len = count;
  249. if (len<0) len = 0;
  250. return len;
  251. }
  253. /*
  254.  * /proc/capi/driver:
  255.  * driver ncontroller
  256.  */
  257. static int proc_driver_read_proc(char *page, char **start, off_t off,
  258.                                        int count, int *eof, void *data)
  259. {
  260. struct capi_driver *driver;
  261. int len = 0;
  263. spin_lock(&drivers_lock);
  264. for (driver = drivers; driver; driver = driver->next) {
  265. len += sprintf(page+len, "%-32s %d %sn",
  266. driver->name,
  267. driver->ncontroller,
  268. driver->revision);
  269. if (len <= off) {
  270. off -= len;
  271. len = 0;
  272. } else {
  273. if (len-off > count)
  274. goto endloop;
  275. }
  276. }
  277. endloop:
  278. spin_unlock(&drivers_lock);
  279. *start = page+off;
  280. if (len < count)
  281. *eof = 1;
  282. if (len>count) len = count;
  283. if (len<0) len = 0;
  284. return len;
  285. }
  287. /*
  288.  * /proc/capi/users:
  289.  * name
  290.  */
  291. static int proc_users_read_proc(char *page, char **start, off_t off,
  292.                                        int count, int *eof, void *data)
  293. {
  294.         struct capi_interface_user *cp;
  295. int len = 0;
  297. spin_lock(&capi_users_lock);
  298.         for (cp = capi_users; cp ; cp = cp->next) {
  299. len += sprintf(page+len, "%sn", cp->name);
  300. if (len <= off) {
  301. off -= len;
  302. len = 0;
  303. } else {
  304. if (len-off > count)
  305. goto endloop;
  306. }
  307. }
  308. endloop:
  309. spin_unlock(&capi_users_lock);
  310. *start = page+off;
  311. if (len < count)
  312. *eof = 1;
  313. if (len>count) len = count;
  314. if (len<0) len = 0;
  315. return len;
  316. }
  318. /*
  319.  * /proc/capi/controller:
  320.  * cnr driver cardstate name driverinfo
  321.  */
  322. static int proc_controller_read_proc(char *page, char **start, off_t off,
  323.                                        int count, int *eof, void *data)
  324. {
  325. struct capi_ctr *cp;
  326. int i;
  327. int len = 0;
  329. for (i=0; i < CAPI_MAXCONTR; i++) {
  330. cp = &cards[i];
  331. if (cp->cardstate == CARD_FREE) continue;
  332. len += sprintf(page+len, "%d %-10s %-8s %-16s %sn",
  333. cp->cnr, cp->driver->name, 
  334. cardstate2str(cp->cardstate),
  335. cp->name,
  336. cp->driver->procinfo ?  cp->driver->procinfo(cp) : ""
  337. );
  338. if (len <= off) {
  339. off -= len;
  340. len = 0;
  341. } else {
  342. if (len-off > count)
  343. goto endloop;
  344. }
  345. }
  346. endloop:
  347. *start = page+off;
  348. if (len < count)
  349. *eof = 1;
  350. if (len>count) len = count;
  351. if (len<0) len = 0;
  352. return len;
  353. }
  355. /*
  356.  * /proc/capi/applstats:
  357.  * applid nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt
  358.  */
  359. static int proc_applstats_read_proc(char *page, char **start, off_t off,
  360.                                        int count, int *eof, void *data)
  361. {
  362. struct capi_appl *ap;
  363. int i;
  364. int len = 0;
  366. for (i=0; i < CAPI_MAXAPPL; i++) {
  367. ap = &applications[i];
  368. if (ap->applid == 0) continue;
  369. len += sprintf(page+len, "%u %lu %lu %lu %lun",
  370. ap->applid,
  371. ap->nrecvctlpkt,
  372. ap->nrecvdatapkt,
  373. ap->nsentctlpkt,
  374. ap->nsentdatapkt);
  375. if (len <= off) {
  376. off -= len;
  377. len = 0;
  378. } else {
  379. if (len-off > count)
  380. goto endloop;
  381. }
  382. }
  383. endloop:
  384. *start = page+off;
  385. if (len < count)
  386. *eof = 1;
  387. if (len>count) len = count;
  388. if (len<0) len = 0;
  389. return len;
  390. }
  392. /*
  393.  * /proc/capi/contrstats:
  394.  * cnr nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt
  395.  */
  396. static int proc_contrstats_read_proc(char *page, char **start, off_t off,
  397.                                        int count, int *eof, void *data)
  398. {
  399. struct capi_ctr *cp;
  400. int i;
  401. int len = 0;
  403. for (i=0; i < CAPI_MAXCONTR; i++) {
  404. cp = &cards[i];
  405. if (cp->cardstate == CARD_FREE) continue;
  406. len += sprintf(page+len, "%d %lu %lu %lu %lun",
  407. cp->cnr, 
  408. cp->nrecvctlpkt,
  409. cp->nrecvdatapkt,
  410. cp->nsentctlpkt,
  411. cp->nsentdatapkt);
  412. if (len <= off) {
  413. off -= len;
  414. len = 0;
  415. } else {
  416. if (len-off > count)
  417. goto endloop;
  418. }
  419. }
  420. endloop:
  421. *start = page+off;
  422. if (len < count)
  423. *eof = 1;
  424. if (len>count) len = count;
  425. if (len<0) len = 0;
  426. return len;
  427. }
  429. static struct procfsentries {
  430.   char *name;
  431.   mode_t mode;
  432.   int (*read_proc)(char *page, char **start, off_t off,
  433.                                        int count, int *eof, void *data);
  434.   struct proc_dir_entry *procent;
  435. } procfsentries[] = {
  436.    { "capi",   S_IFDIR, 0 },
  437.    { "capi/applications", 0  , proc_applications_read_proc },
  438.    { "capi/ncci",    0  , proc_ncci_read_proc },
  439.    { "capi/driver",       0  , proc_driver_read_proc },
  440.    { "capi/users",    0  , proc_users_read_proc },
  441.    { "capi/controller",   0  , proc_controller_read_proc },
  442.    { "capi/applstats",    0  , proc_applstats_read_proc },
  443.    { "capi/contrstats",   0  , proc_contrstats_read_proc },
  444.    { "capi/drivers",   S_IFDIR, 0 },
  445.    { "capi/controllers",  S_IFDIR, 0 },
  446. };
  448. static void proc_capi_init(void)
  449. {
  450.     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
  451.     int i;
  453.     for (i=0; i < nelem; i++) {
  454.         struct procfsentries *p = procfsentries + i;
  455. p->procent = create_proc_entry(p->name, p->mode, 0);
  456. if (p->procent) p->procent->read_proc = p->read_proc;
  457.     }
  458. }
  460. static void proc_capi_exit(void)
  461. {
  462.     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
  463.     int i;
  465.     for (i=nelem-1; i >= 0; i--) {
  466.         struct procfsentries *p = procfsentries + i;
  467. if (p->procent) {
  468.    remove_proc_entry(p->name, 0);
  469.    p->procent = 0;
  470. }
  471.     }
  472. }
  474. /* -------- Notifier handling --------------------------------- */
  476. static struct capi_notifier_list{
  477. struct capi_notifier *head;
  478. struct capi_notifier *tail;
  479. } notifier_list;
  481. static spinlock_t notifier_lock = SPIN_LOCK_UNLOCKED;
  483. static inline void notify_enqueue(struct capi_notifier *np)
  484. {
  485. struct capi_notifier_list *q = &notifier_list;
  486. unsigned long flags;
  488. spin_lock_irqsave(&notifier_lock, flags);
  489. if (q->tail) {
  490. q->tail->next = np;
  491. q->tail = np;
  492. } else {
  493. q->head = q->tail = np;
  494. }
  495. spin_unlock_irqrestore(&notifier_lock, flags);
  496. }
  498. static inline struct capi_notifier *notify_dequeue(void)
  499. {
  500. struct capi_notifier_list *q = &notifier_list;
  501. struct capi_notifier *np = 0;
  502. unsigned long flags;
  504. spin_lock_irqsave(&notifier_lock, flags);
  505. if (q->head) {
  506. np = q->head;
  507. if ((q->head = np->next) == 0)
  508.   q->tail = 0;
  509. np->next = 0;
  510. }
  511. spin_unlock_irqrestore(&notifier_lock, flags);
  512. return np;
  513. }
  515. static int notify_push(unsigned int cmd, __u32 controller,
  516. __u16 applid, __u32 ncci)
  517. {
  518. struct capi_notifier *np;
  520. MOD_INC_USE_COUNT;
  521. np = (struct capi_notifier *)kmalloc(sizeof(struct capi_notifier), GFP_ATOMIC);
  522. if (!np) {
  523. MOD_DEC_USE_COUNT;
  524. return -1;
  525. }
  526. memset(np, 0, sizeof(struct capi_notifier));
  527. np->cmd = cmd;
  528. np->controller = controller;
  529. np->applid = applid;
  530. np->ncci = ncci;
  531. notify_enqueue(np);
  532. /*
  533.  * The notifier will result in adding/deleteing
  534.  * of devices. Devices can only removed in
  535.  * user process, not in bh.
  536.  */
  537. MOD_INC_USE_COUNT;
  538. if (schedule_task(&tq_state_notify) == 0)
  539. MOD_DEC_USE_COUNT;
  540. return 0;
  541. }
  543. /* -------- KCI_CONTRUP --------------------------------------- */
  545. static void notify_up(__u32 contr)
  546. {
  547. struct capi_interface_user *p;
  549.         printk(KERN_NOTICE "kcapi: notify up contr %dn", contr);
  550. spin_lock(&capi_users_lock);
  551. for (p = capi_users; p; p = p->next) {
  552. if (!p->callback) continue;
  553. (*p->callback) (KCI_CONTRUP, contr, &CARD(contr)->profile);
  554. }
  555. spin_unlock(&capi_users_lock);
  556. }
  558. /* -------- KCI_CONTRDOWN ------------------------------------- */
  560. static void notify_down(__u32 contr)
  561. {
  562. struct capi_interface_user *p;
  563.         printk(KERN_NOTICE "kcapi: notify down contr %dn", contr);
  564. spin_lock(&capi_users_lock);
  565. for (p = capi_users; p; p = p->next) {
  566. if (!p->callback) continue;
  567. (*p->callback) (KCI_CONTRDOWN, contr, 0);
  568. }
  569. spin_unlock(&capi_users_lock);
  570. }
  572. /* -------- KCI_NCCIUP ---------------------------------------- */
  574. static void notify_ncciup(__u32 contr, __u16 applid, __u32 ncci)
  575. {
  576. struct capi_interface_user *p;
  577. struct capi_ncciinfo n;
  578. n.applid = applid;
  579. n.ncci = ncci;
  580.         /*printk(KERN_NOTICE "kcapi: notify up contr %dn", contr);*/
  581. spin_lock(&capi_users_lock);
  582. for (p = capi_users; p; p = p->next) {
  583. if (!p->callback) continue;
  584. (*p->callback) (KCI_NCCIUP, contr, &n);
  585. }
  586. spin_unlock(&capi_users_lock);
  587. };
  589. /* -------- KCI_NCCIDOWN -------------------------------------- */
  591. static void notify_nccidown(__u32 contr, __u16 applid, __u32 ncci)
  592. {
  593. struct capi_interface_user *p;
  594. struct capi_ncciinfo n;
  595. n.applid = applid;
  596. n.ncci = ncci;
  597.         /*printk(KERN_NOTICE "kcapi: notify down contr %dn", contr);*/
  598. spin_lock(&capi_users_lock);
  599. for (p = capi_users; p; p = p->next) {
  600. if (!p->callback) continue;
  601. (*p->callback) (KCI_NCCIDOWN, contr, &n);
  602. }
  603. spin_unlock(&capi_users_lock);
  604. };
  606. /* ------------------------------------------------------------ */
  608. static void inline notify_doit(struct capi_notifier *np)
  609. {
  610. switch (np->cmd) {
  611. case KCI_CONTRUP:
  612. notify_up(np->controller);
  613. break;
  614. case KCI_CONTRDOWN:
  615. notify_down(np->controller);
  616. break;
  617. case KCI_NCCIUP:
  618. notify_ncciup(np->controller, np->applid, np->ncci);
  619. break;
  620. case KCI_NCCIDOWN:
  621. notify_nccidown(np->controller, np->applid, np->ncci);
  622. break;
  623. }
  624. }
  626. static void notify_handler(void *dummy)
  627. {
  628. struct capi_notifier *np;
  630. while ((np = notify_dequeue()) != 0) {
  631. notify_doit(np);
  632. kfree(np);
  633. MOD_DEC_USE_COUNT;
  634. }
  635. MOD_DEC_USE_COUNT;
  636. }
  638. /* -------- NCCI Handling ------------------------------------- */
  640. static inline void mq_init(struct capi_ncci * np)
  641. {
  642. int i;
  643. np->msgidqueue = 0;
  644. np->msgidlast = 0;
  645. np->nmsg = 0;
  646. memset(np->msgidpool, 0, sizeof(np->msgidpool));
  647. np->msgidfree = &np->msgidpool[0];
  648. for (i = 1; i < np->winsize; i++) {
  649. np->msgidpool[i].next = np->msgidfree;
  650. np->msgidfree = &np->msgidpool[i];
  651. }
  652. }
  654. static inline int mq_enqueue(struct capi_ncci * np, __u16 msgid)
  655. {
  656. struct msgidqueue *mq;
  657. if ((mq = np->msgidfree) == 0)
  658. return 0;
  659. np->msgidfree = mq->next;
  660. mq->msgid = msgid;
  661. mq->next = 0;
  662. if (np->msgidlast)
  663. np->msgidlast->next = mq;
  664. np->msgidlast = mq;
  665. if (!np->msgidqueue)
  666. np->msgidqueue = mq;
  667. np->nmsg++;
  668. return 1;
  669. }
  671. static inline int mq_dequeue(struct capi_ncci * np, __u16 msgid)
  672. {
  673. struct msgidqueue **pp;
  674. for (pp = &np->msgidqueue; *pp; pp = &(*pp)->next) {
  675. if ((*pp)->msgid == msgid) {
  676. struct msgidqueue *mq = *pp;
  677. *pp = mq->next;
  678. if (mq == np->msgidlast)
  679. np->msgidlast = 0;
  680. mq->next = np->msgidfree;
  681. np->msgidfree = mq;
  682. np->nmsg--;
  683. return 1;
  684. }
  685. }
  686. return 0;
  687. }
  689. static void controllercb_appl_registered(struct capi_ctr * card, __u16 appl)
  690. {
  691. }
  693. static void controllercb_appl_released(struct capi_ctr * card, __u16 appl)
  694. {
  695. struct capi_ncci **pp, **nextpp;
  696. for (pp = &APPL(appl)->nccilist; *pp; pp = nextpp) {
  697. if (NCCI2CTRL((*pp)->ncci) == card->cnr) {
  698. struct capi_ncci *np = *pp;
  699. *pp = np->next;
  700. printk(KERN_INFO "kcapi: appl %d ncci 0x%x down!n", appl, np->ncci);
  701. kfree(np);
  702. APPL(appl)->nncci--;
  703. nextpp = pp;
  704. } else {
  705. nextpp = &(*pp)->next;
  706. }
  707. }
  708. APPL(appl)->releasing--;
  709. if (APPL(appl)->releasing <= 0) {
  710. APPL(appl)->signal = 0;
  711. APPL_MARK_FREE(appl);
  712. printk(KERN_INFO "kcapi: appl %d downn", appl);
  713. }
  714. }
  715. /*
  716.  * ncci management
  717.  */
  719. static void controllercb_new_ncci(struct capi_ctr * card,
  720. __u16 appl, __u32 ncci, __u32 winsize)
  721. {
  722. struct capi_ncci *np;
  723. if (!VALID_APPLID(appl)) {
  724. printk(KERN_ERR "avmb1_handle_new_ncci: illegal appl %dn", appl);
  725. return;
  726. }
  727. if ((np = (struct capi_ncci *) kmalloc(sizeof(struct capi_ncci), GFP_ATOMIC)) == 0) {
  728. printk(KERN_ERR "capi_new_ncci: alloc failed ncci 0x%xn", ncci);
  729. return;
  730. }
  731. if (winsize > CAPI_MAXDATAWINDOW) {
  732. printk(KERN_ERR "capi_new_ncci: winsize %d too big, set to %dn",
  733.        winsize, CAPI_MAXDATAWINDOW);
  734. winsize = CAPI_MAXDATAWINDOW;
  735. }
  736. np->applid = appl;
  737. np->ncci = ncci;
  738. np->winsize = winsize;
  739. mq_init(np);
  740. np->next = APPL(appl)->nccilist;
  741. APPL(appl)->nccilist = np;
  742. APPL(appl)->nncci++;
  743. printk(KERN_INFO "kcapi: appl %d ncci 0x%x upn", appl, ncci);
  745. notify_push(KCI_NCCIUP, CARDNR(card), appl, ncci);
  746. }
  748. static void controllercb_free_ncci(struct capi_ctr * card,
  749. __u16 appl, __u32 ncci)
  750. {
  751. struct capi_ncci **pp;
  752. if (!VALID_APPLID(appl)) {
  753. printk(KERN_ERR "free_ncci: illegal appl %dn", appl);
  754. return;
  755. }
  756. for (pp = &APPL(appl)->nccilist; *pp; pp = &(*pp)->next) {
  757. if ((*pp)->ncci == ncci) {
  758. struct capi_ncci *np = *pp;
  759. *pp = np->next;
  760. kfree(np);
  761. APPL(appl)->nncci--;
  762. printk(KERN_INFO "kcapi: appl %d ncci 0x%x downn", appl, ncci);
  763. notify_push(KCI_NCCIDOWN, CARDNR(card), appl, ncci);
  764. return;
  765. }
  766. }
  767. printk(KERN_ERR "free_ncci: ncci 0x%x not foundn", ncci);
  768. }
  771. static struct capi_ncci *find_ncci(struct capi_appl * app, __u32 ncci)
  772. {
  773. struct capi_ncci *np;
  774. for (np = app->nccilist; np; np = np->next) {
  775. if (np->ncci == ncci)
  776. return np;
  777. }
  778. return 0;
  779. }
  781. /* -------- Receiver ------------------------------------------ */
  783. static void recv_handler(void *dummy)
  784. {
  785. struct sk_buff *skb;
  787. while ((skb = skb_dequeue(&recv_queue)) != 0) {
  788. __u16 appl = CAPIMSG_APPID(skb->data);
  789. struct capi_ncci *np;
  790. if (!VALID_APPLID(appl)) {
  791. printk(KERN_ERR "kcapi: recv_handler: applid %d ? (%s)n",
  792.        appl, capi_message2str(skb->data));
  793. kfree_skb(skb);
  794. continue;
  795. }
  796. if (APPL(appl)->signal == 0) {
  797. printk(KERN_ERR "kcapi: recv_handler: applid %d has no signal functionn",
  798.        appl);
  799. kfree_skb(skb);
  800. continue;
  801. }
  802. if (   CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3
  803.     && CAPIMSG_SUBCOMMAND(skb->data) == CAPI_CONF
  804.             && (np = find_ncci(APPL(appl), CAPIMSG_NCCI(skb->data))) != 0
  805.     && mq_dequeue(np, CAPIMSG_MSGID(skb->data)) == 0) {
  806. printk(KERN_ERR "kcapi: msgid %hu ncci 0x%x not on queuen",
  807. CAPIMSG_MSGID(skb->data), np->ncci);
  808. }
  809. if (   CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3
  810.     && CAPIMSG_SUBCOMMAND(skb->data) == CAPI_IND) {
  811. APPL(appl)->nrecvdatapkt++;
  812. } else {
  813. APPL(appl)->nrecvctlpkt++;
  814. }
  815. skb_queue_tail(&APPL(appl)->recv_queue, skb);
  816. (APPL(appl)->signal) (APPL(appl)->applid, APPL(appl)->param);
  817. }
  818. }
  820. static void controllercb_handle_capimsg(struct capi_ctr * card,
  821. __u16 appl, struct sk_buff *skb)
  822. {
  823. int showctl = 0;
  824. __u8 cmd, subcmd;
  826. if (card->cardstate != CARD_RUNNING) {
  827. printk(KERN_INFO "kcapi: controller %d not active, got: %s",
  828.        card->cnr, capi_message2str(skb->data));
  829. goto error;
  830. }
  831. cmd = CAPIMSG_COMMAND(skb->data);
  832.         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
  833. if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
  834. card->nrecvdatapkt++;
  835.         if (card->traceflag > 2) showctl |= 2;
  836. } else {
  837. card->nrecvctlpkt++;
  838.         if (card->traceflag) showctl |= 2;
  839. }
  840. showctl |= (card->traceflag & 1);
  841. if (showctl & 2) {
  842. if (showctl & 1) {
  843. printk(KERN_DEBUG "kcapi: got [0x%lx] id#%d %s len=%un",
  844.        (unsigned long) card->cnr,
  845.        CAPIMSG_APPID(skb->data),
  846.        capi_cmd2str(cmd, subcmd),
  847.        CAPIMSG_LEN(skb->data));
  848. } else {
  849. printk(KERN_DEBUG "kcapi: got [0x%lx] %sn",
  850. (unsigned long) card->cnr,
  851. capi_message2str(skb->data));
  852. }
  854. }
  855. skb_queue_tail(&recv_queue, skb);
  856. queue_task(&tq_recv_notify, &tq_immediate);
  857. mark_bh(IMMEDIATE_BH);
  858. return;
  860. error:
  861. kfree_skb(skb);
  862. }
  864. static void controllercb_ready(struct capi_ctr * card)
  865. {
  866. __u16 appl;
  868. card->cardstate = CARD_RUNNING;
  870. for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
  871. if (!VALID_APPLID(appl)) continue;
  872. if (APPL(appl)->releasing) continue;
  873. card->driver->register_appl(card, appl, &APPL(appl)->rparam);
  874. }
  876.         printk(KERN_NOTICE "kcapi: card %d "%s" ready.n",
  877. CARDNR(card), card->name);
  879. notify_push(KCI_CONTRUP, CARDNR(card), 0, 0);
  880. }
  882. static void controllercb_reseted(struct capi_ctr * card)
  883. {
  884. __u16 appl;
  886.         if (card->cardstate == CARD_FREE)
  887. return;
  888.         if (card->cardstate == CARD_DETECTED)
  889. return;
  891.         card->cardstate = CARD_DETECTED;
  893. memset(card->manu, 0, sizeof(card->manu));
  894. memset(&card->version, 0, sizeof(card->version));
  895. memset(&card->profile, 0, sizeof(card->profile));
  896. memset(card->serial, 0, sizeof(card->serial));
  898. for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
  899. struct capi_ncci **pp, **nextpp;
  900. for (pp = &APPL(appl)->nccilist; *pp; pp = nextpp) {
  901. if (NCCI2CTRL((*pp)->ncci) == card->cnr) {
  902. struct capi_ncci *np = *pp;
  903. *pp = np->next;
  904. printk(KERN_INFO "kcapi: appl %d ncci 0x%x forced down!n", appl, np->ncci);
  905. notify_push(KCI_NCCIDOWN, CARDNR(card), appl, np->ncci);
  906. kfree(np);
  907. nextpp = pp;
  908. } else {
  909. nextpp = &(*pp)->next;
  910. }
  911. }
  912. }
  914. printk(KERN_NOTICE "kcapi: card %d down.n", CARDNR(card));
  916. notify_push(KCI_CONTRDOWN, CARDNR(card), 0, 0);
  917. }
  919. static void controllercb_suspend_output(struct capi_ctr *card)
  920. {
  921. if (!card->blocked) {
  922. printk(KERN_DEBUG "kcapi: card %d suspendn", CARDNR(card));
  923. card->blocked = 1;
  924. }
  925. }
  927. static void controllercb_resume_output(struct capi_ctr *card)
  928. {
  929. if (card->blocked) {
  930. printk(KERN_DEBUG "kcapi: card %d resumen", CARDNR(card));
  931. card->blocked = 0;
  932. }
  933. }
  935. /* ------------------------------------------------------------- */
  938. struct capi_ctr *
  939. drivercb_attach_ctr(struct capi_driver *driver, char *name, void *driverdata)
  940. {
  941. struct capi_ctr *card, **pp;
  942. int i;
  944. for (i=0; i < CAPI_MAXCONTR && cards[i].cardstate != CARD_FREE; i++) ;
  945.    
  946. if (i == CAPI_MAXCONTR) {
  947. printk(KERN_ERR "kcapi: out of controller slotsn");
  948.     return 0;
  949. }
  950. card = &cards[i];
  951. memset(card, 0, sizeof(struct capi_ctr));
  952. card->driver = driver;
  953. card->cnr = CARDNR(card);
  954. strncpy(card->name, name, sizeof(card->name));
  955. card->cardstate = CARD_DETECTED;
  956. card->blocked = 0;
  957. card->driverdata = driverdata;
  958. card->traceflag = showcapimsgs;
  960.         card->ready = controllercb_ready; 
  961.         card->reseted = controllercb_reseted; 
  962.         card->suspend_output = controllercb_suspend_output;
  963.         card->resume_output = controllercb_resume_output;
  964.         card->handle_capimsg = controllercb_handle_capimsg;
  965. card->appl_registered = controllercb_appl_registered;
  966. card->appl_released = controllercb_appl_released;
  967.         card->new_ncci = controllercb_new_ncci;
  968.         card->free_ncci = controllercb_free_ncci;
  970. for (pp = &driver->controller; *pp; pp = &(*pp)->next) ;
  971. card->next = 0;
  972. *pp = card;
  973. driver->ncontroller++;
  974. sprintf(card->procfn, "capi/controllers/%d", card->cnr);
  975. card->procent = create_proc_entry(card->procfn, 0, 0);
  976. if (card->procent) {
  977.    card->procent->read_proc = 
  978. (int (*)(char *,char **,off_t,int,int *,void *))
  979. driver->ctr_read_proc;
  980.    card->procent->data = card;
  981. }
  983. ncards++;
  984. printk(KERN_NOTICE "kcapi: Controller %d: %s attachedn",
  985. card->cnr, card->name);
  986. return card;
  987. }
  989. static int drivercb_detach_ctr(struct capi_ctr *card)
  990. {
  991. struct capi_driver *driver = card->driver;
  992. struct capi_ctr **pp;
  994.         if (card->cardstate == CARD_FREE)
  995. return 0;
  996.         if (card->cardstate != CARD_DETECTED)
  997. controllercb_reseted(card);
  998. for (pp = &driver->controller; *pp ; pp = &(*pp)->next) {
  999.          if (*pp == card) {
  1000.          *pp = card->next;
  1001. driver->ncontroller--;
  1002. ncards--;
  1003.          break;
  1004. }
  1005. }
  1006. if (card->procent) {
  1007.    remove_proc_entry(card->procfn, 0);
  1008.    card->procent = 0;
  1009. }
  1010. card->cardstate = CARD_FREE;
  1011. printk(KERN_NOTICE "kcapi: Controller %d: %s unregisteredn",
  1012. card->cnr, card->name);
  1013. return 0;
  1014. }
  1016. /* ------------------------------------------------------------- */
  1018. /* fallback if no driver read_proc function defined by driver */
  1020. static int driver_read_proc(char *page, char **start, off_t off,
  1021.          int count, int *eof, void *data)
  1022. {
  1023. struct capi_driver *driver = (struct capi_driver *)data;
  1024. int len = 0;
  1026. len += sprintf(page+len, "%-16s %sn", "name", driver->name);
  1027. len += sprintf(page+len, "%-16s %sn", "revision", driver->revision);
  1029. if (len < off) 
  1030.            return 0;
  1031. *eof = 1;
  1032. *start = page + off;
  1033. return ((count < len-off) ? count : len-off);
  1034. }
  1036. /* ------------------------------------------------------------- */
  1038. static struct capi_driver_interface di = {
  1039.     drivercb_attach_ctr,
  1040.     drivercb_detach_ctr,
  1041. };
  1043. struct capi_driver_interface *attach_capi_driver(struct capi_driver *driver)
  1044. {
  1045. struct capi_driver **pp;
  1047. MOD_INC_USE_COUNT;
  1048. spin_lock(&drivers_lock);
  1049. for (pp = &drivers; *pp; pp = &(*pp)->next) ;
  1050. driver->next = 0;
  1051. *pp = driver;
  1052. spin_unlock(&drivers_lock);
  1053. printk(KERN_NOTICE "kcapi: driver %s attachedn", driver->name);
  1054. sprintf(driver->procfn, "capi/drivers/%s", driver->name);
  1055. driver->procent = create_proc_entry(driver->procfn, 0, 0);
  1056. if (driver->procent) {
  1057.    if (driver->driver_read_proc) {
  1058.    driver->procent->read_proc = 
  1059.         (int (*)(char *,char **,off_t,int,int *,void *))
  1060. driver->driver_read_proc;
  1061.    } else {
  1062.    driver->procent->read_proc = driver_read_proc;
  1063.    }
  1064.    driver->procent->data = driver;
  1065. }
  1066. return &di;
  1067. }
  1069. void detach_capi_driver(struct capi_driver *driver)
  1070. {
  1071. struct capi_driver **pp;
  1072. spin_lock(&drivers_lock);
  1073. for (pp = &drivers; *pp && *pp != driver; pp = &(*pp)->next) ;
  1074. if (*pp) {
  1075. *pp = (*pp)->next;
  1076. printk(KERN_NOTICE "kcapi: driver %s detachedn", driver->name);
  1077. } else {
  1078. printk(KERN_ERR "kcapi: driver %s double detach ?n", driver->name);
  1079. }
  1080. spin_unlock(&drivers_lock);
  1081. if (driver->procent) {
  1082.    remove_proc_entry(driver->procfn, 0);
  1083.    driver->procent = 0;
  1084. }
  1085. MOD_DEC_USE_COUNT;
  1086. }
  1088. /* ------------------------------------------------------------- */
  1089. /* -------- CAPI2.0 Interface ---------------------------------- */
  1090. /* ------------------------------------------------------------- */
  1092. static __u16 capi_isinstalled(void)
  1093. {
  1094. int i;
  1095. for (i = 0; i < CAPI_MAXCONTR; i++) {
  1096. if (cards[i].cardstate == CARD_RUNNING)
  1097. return CAPI_NOERROR;
  1098. }
  1099. return CAPI_REGNOTINSTALLED;
  1100. }
  1102. static __u16 capi_register(capi_register_params * rparam, __u16 * applidp)
  1103. {
  1104. int appl;
  1105. int i;
  1107. if (rparam->datablklen < 128)
  1108. return CAPI_LOGBLKSIZETOSMALL;
  1110. for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
  1111. if (APPL_IS_FREE(appl))
  1112. break;
  1113. }
  1114. if (appl > CAPI_MAXAPPL)
  1115. return CAPI_TOOMANYAPPLS;
  1117. APPL_MARK_USED(appl);
  1118. skb_queue_head_init(&APPL(appl)->recv_queue);
  1119. APPL(appl)->nncci = 0;
  1121. memcpy(&APPL(appl)->rparam, rparam, sizeof(capi_register_params));
  1123. for (i = 0; i < CAPI_MAXCONTR; i++) {
  1124. if (cards[i].cardstate != CARD_RUNNING)
  1125. continue;
  1126. cards[i].driver->register_appl(&cards[i], appl,
  1127. &APPL(appl)->rparam);
  1128. }
  1129. *applidp = appl;
  1130. printk(KERN_INFO "kcapi: appl %d upn", appl);
  1132. return CAPI_NOERROR;
  1133. }
  1135. static __u16 capi_release(__u16 applid)
  1136. {
  1137. int i;
  1139. if (!VALID_APPLID(applid) || APPL(applid)->releasing)
  1140. return CAPI_ILLAPPNR;
  1141. APPL(applid)->releasing++;
  1142. skb_queue_purge(&APPL(applid)->recv_queue);
  1143. for (i = 0; i < CAPI_MAXCONTR; i++) {
  1144. if (cards[i].cardstate != CARD_RUNNING)
  1145. continue;
  1146. APPL(applid)->releasing++;
  1147. cards[i].driver->release_appl(&cards[i], applid);
  1148. }
  1149. APPL(applid)->releasing--;
  1150. if (APPL(applid)->releasing <= 0) {
  1151.         APPL(applid)->signal = 0;
  1152. APPL_MARK_FREE(applid);
  1153. printk(KERN_INFO "kcapi: appl %d downn", applid);
  1154. }
  1155. return CAPI_NOERROR;
  1156. }
  1158. static __u16 capi_put_message(__u16 applid, struct sk_buff *skb)
  1159. {
  1160. struct capi_ncci *np;
  1161. __u32 contr;
  1162. int showctl = 0;
  1163. __u8 cmd, subcmd;
  1165. if (ncards == 0)
  1166. return CAPI_REGNOTINSTALLED;
  1167. if (!VALID_APPLID(applid))
  1168. return CAPI_ILLAPPNR;
  1169. if (skb->len < 12
  1170.     || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
  1171.     || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
  1172. return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
  1173. contr = CAPIMSG_CONTROLLER(skb->data);
  1174. if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) {
  1175. contr = 1;
  1176.         if (CARD(contr)->cardstate != CARD_RUNNING) 
  1177. return CAPI_REGNOTINSTALLED;
  1178. }
  1179. if (CARD(contr)->blocked)
  1180. return CAPI_SENDQUEUEFULL;
  1182. cmd = CAPIMSG_COMMAND(skb->data);
  1183.         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
  1185. if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
  1186.      if ((np = find_ncci(APPL(applid), CAPIMSG_NCCI(skb->data))) != 0
  1187.             && mq_enqueue(np, CAPIMSG_MSGID(skb->data)) == 0)
  1188. return CAPI_SENDQUEUEFULL;
  1189. CARD(contr)->nsentdatapkt++;
  1190. APPL(applid)->nsentdatapkt++;
  1191.         if (CARD(contr)->traceflag > 2) showctl |= 2;
  1192. } else {
  1193. CARD(contr)->nsentctlpkt++;
  1194. APPL(applid)->nsentctlpkt++;
  1195.         if (CARD(contr)->traceflag) showctl |= 2;
  1196. }
  1197. showctl |= (CARD(contr)->traceflag & 1);
  1198. if (showctl & 2) {
  1199. if (showctl & 1) {
  1200. printk(KERN_DEBUG "kcapi: put [0x%lx] id#%d %s len=%un",
  1201.        (unsigned long) contr,
  1202.        CAPIMSG_APPID(skb->data),
  1203.        capi_cmd2str(cmd, subcmd),
  1204.        CAPIMSG_LEN(skb->data));
  1205. } else {
  1206. printk(KERN_DEBUG "kcapi: put [0x%lx] %sn",
  1207. (unsigned long) contr,
  1208. capi_message2str(skb->data));
  1209. }
  1211. }
  1212. CARD(contr)->driver->send_message(CARD(contr), skb);
  1213. return CAPI_NOERROR;
  1214. }
  1216. static __u16 capi_get_message(__u16 applid, struct sk_buff **msgp)
  1217. {
  1218. struct sk_buff *skb;
  1220. if (!VALID_APPLID(applid))
  1221. return CAPI_ILLAPPNR;
  1222. if ((skb = skb_dequeue(&APPL(applid)->recv_queue)) == 0)
  1223. return CAPI_RECEIVEQUEUEEMPTY;
  1224. *msgp = skb;
  1225. return CAPI_NOERROR;
  1226. }
  1228. static __u16 capi_set_signal(__u16 applid,
  1229.      void (*signal) (__u16 applid, void *param),
  1230.      void *param)
  1231. {
  1232. if (!VALID_APPLID(applid))
  1233. return CAPI_ILLAPPNR;
  1234. APPL(applid)->signal = signal;
  1235. APPL(applid)->param = param;
  1236. return CAPI_NOERROR;
  1237. }
  1239. static __u16 capi_get_manufacturer(__u32 contr, __u8 buf[CAPI_MANUFACTURER_LEN])
  1240. {
  1241. if (contr == 0) {
  1242. strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
  1243. return CAPI_NOERROR;
  1244. }
  1245. if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) 
  1246. return CAPI_REGNOTINSTALLED;
  1248. strncpy(buf, CARD(contr)->manu, CAPI_MANUFACTURER_LEN);
  1249. return CAPI_NOERROR;
  1250. }
  1252. static __u16 capi_get_version(__u32 contr, struct capi_version *verp)
  1253. {
  1254. if (contr == 0) {
  1255. *verp = driver_version;
  1256. return CAPI_NOERROR;
  1257. }
  1258. if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) 
  1259. return CAPI_REGNOTINSTALLED;
  1261. memcpy((void *) verp, &CARD(contr)->version, sizeof(capi_version));
  1262. return CAPI_NOERROR;
  1263. }
  1265. static __u16 capi_get_serial(__u32 contr, __u8 serial[CAPI_SERIAL_LEN])
  1266. {
  1267. if (contr == 0) {
  1268. strncpy(serial, driver_serial, CAPI_SERIAL_LEN);
  1269. return CAPI_NOERROR;
  1270. }
  1271. if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) 
  1272. return CAPI_REGNOTINSTALLED;
  1274. strncpy((void *) serial, CARD(contr)->serial, CAPI_SERIAL_LEN);
  1275. return CAPI_NOERROR;
  1276. }
  1278. static __u16 capi_get_profile(__u32 contr, struct capi_profile *profp)
  1279. {
  1280. if (contr == 0) {
  1281. profp->ncontroller = ncards;
  1282. return CAPI_NOERROR;
  1283. }
  1284. if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) 
  1285. return CAPI_REGNOTINSTALLED;
  1287. memcpy((void *) profp, &CARD(contr)->profile,
  1288. sizeof(struct capi_profile));
  1289. return CAPI_NOERROR;
  1290. }
  1292. static struct capi_driver *find_driver(char *name)
  1293. {
  1294. struct capi_driver *dp;
  1295. spin_lock(&drivers_lock);
  1296. for (dp = drivers; dp; dp = dp->next)
  1297. if (strcmp(dp->name, name) == 0)
  1298. break;
  1299. spin_unlock(&drivers_lock);
  1300. return dp;
  1301. }
  1303. #ifdef CONFIG_AVMB1_COMPAT
  1304. static int old_capi_manufacturer(unsigned int cmd, void *data)
  1305. {
  1306. avmb1_loadandconfigdef ldef;
  1307. avmb1_extcarddef cdef;
  1308. avmb1_resetdef rdef;
  1309. avmb1_getdef gdef;
  1310. struct capi_driver *driver;
  1311. struct capi_ctr *card;
  1312. capicardparams cparams;
  1313. capiloaddata ldata;
  1314. int retval;
  1316. switch (cmd) {
  1317. case AVMB1_ADDCARD:
  1318. case AVMB1_ADDCARD_WITH_TYPE:
  1319. if (cmd == AVMB1_ADDCARD) {
  1320.    if ((retval = copy_from_user((void *) &cdef, data,
  1321.     sizeof(avmb1_carddef))))
  1322.    return retval;
  1323.    cdef.cardtype = AVM_CARDTYPE_B1;
  1324. } else {
  1325.    if ((retval = copy_from_user((void *) &cdef, data,
  1326.     sizeof(avmb1_extcarddef))))
  1327.    return retval;
  1328. }
  1329. cparams.port = cdef.port;
  1330. cparams.irq = cdef.irq;
  1331. cparams.cardnr = cdef.cardnr;
  1333.                 switch (cdef.cardtype) {
  1334. case AVM_CARDTYPE_B1:
  1335. driver = find_driver("b1isa");
  1336. break;
  1337. case AVM_CARDTYPE_T1:
  1338. driver = find_driver("t1isa");
  1339. break;
  1340. default:
  1341. driver = 0;
  1342. break;
  1343. }
  1344. if (!driver) {
  1345. printk(KERN_ERR "kcapi: driver not loaded.n");
  1346. return -EIO;
  1347. }
  1348. if (!driver->add_card) {
  1349. printk(KERN_ERR "kcapi: driver has no add card function.n");
  1350. return -EIO;
  1351. }
  1353. return driver->add_card(driver, &cparams);
  1355. case AVMB1_LOAD:
  1356. case AVMB1_LOAD_AND_CONFIG:
  1358. if (cmd == AVMB1_LOAD) {
  1359. if ((retval = copy_from_user((void *) &ldef, data,
  1360. sizeof(avmb1_loaddef))))
  1361. return retval;
  1362. ldef.t4config.len = 0;
  1363. ldef.t4config.data = 0;
  1364. } else {
  1365. if ((retval = copy_from_user((void *) &ldef, data,
  1366.      sizeof(avmb1_loadandconfigdef))))
  1367. return retval;
  1368. }
  1369. if (!VALID_CARD(ldef.contr))
  1370. return -ESRCH;
  1372. card = CARD(ldef.contr);
  1373. if (card->cardstate == CARD_FREE)
  1374. return -ESRCH;
  1375. if (card->driver->load_firmware == 0) {
  1376. printk(KERN_DEBUG "kcapi: load: driver %s" has no load functionn", card->driver->name);
  1377. return -ESRCH;
  1378. }
  1380. if (ldef.t4file.len <= 0) {
  1381. printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?n", ldef.t4file.len);
  1382. return -EINVAL;
  1383. }
  1384. if (ldef.t4file.data == 0) {
  1385. printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0n");
  1386. return -EINVAL;
  1387. }
  1389. ldata.firmware.user = 1;
  1390. ldata.firmware.data = ldef.t4file.data;
  1391. ldata.firmware.len = ldef.t4file.len;
  1392. ldata.configuration.user = 1;
  1393. ldata.configuration.data = ldef.t4config.data;
  1394. ldata.configuration.len = ldef.t4config.len;
  1396. if (card->cardstate != CARD_DETECTED) {
  1397. printk(KERN_INFO "kcapi: load: contr=%d not in detect staten", ldef.contr);
  1398. return -EBUSY;
  1399. }
  1400. card->cardstate = CARD_LOADING;
  1402. retval = card->driver->load_firmware(card, &ldata);
  1404. if (retval) {
  1405. card->cardstate = CARD_DETECTED;
  1406. return retval;
  1407. }
  1409. while (card->cardstate != CARD_RUNNING) {
  1411. set_current_state(TASK_INTERRUPTIBLE);
  1412. schedule_timeout(HZ/10); /* 0.1 sec */
  1414. if (signal_pending(current))
  1415. return -EINTR;
  1416. }
  1417. return 0;
  1419. case AVMB1_RESETCARD:
  1420. if ((retval = copy_from_user((void *) &rdef, data,
  1421.  sizeof(avmb1_resetdef))))
  1422. return retval;
  1423. if (!VALID_CARD(rdef.contr))
  1424. return -ESRCH;
  1425. card = CARD(rdef.contr);
  1427. if (card->cardstate == CARD_FREE)
  1428. return -ESRCH;
  1429. if (card->cardstate == CARD_DETECTED)
  1430. return 0;
  1432. card->driver->reset_ctr(card);
  1434. while (card->cardstate > CARD_DETECTED) {
  1436. set_current_state(TASK_INTERRUPTIBLE);
  1437. schedule_timeout(HZ/10); /* 0.1 sec */
  1439. if (signal_pending(current))
  1440. return -EINTR;
  1441. }
  1442. return 0;
  1444. case AVMB1_GET_CARDINFO:
  1445. if ((retval = copy_from_user((void *) &gdef, data,
  1446.  sizeof(avmb1_getdef))))
  1447. return retval;
  1449. if (!VALID_CARD(gdef.contr))
  1450. return -ESRCH;
  1452. card = CARD(gdef.contr);
  1454. if (card->cardstate == CARD_FREE)
  1455. return -ESRCH;
  1457. gdef.cardstate = card->cardstate;
  1458. if (card->driver == find_driver("t1isa"))
  1459. gdef.cardtype = AVM_CARDTYPE_T1;
  1460. else gdef.cardtype = AVM_CARDTYPE_B1;
  1462. if ((retval = copy_to_user(data, (void *) &gdef,
  1463.  sizeof(avmb1_getdef))))
  1464. return retval;
  1466. return 0;
  1468. case AVMB1_REMOVECARD:
  1469. if ((retval = copy_from_user((void *) &rdef, data,
  1470.  sizeof(avmb1_resetdef))))
  1471. return retval;
  1473. if (!VALID_CARD(rdef.contr))
  1474. return -ESRCH;
  1475. card = CARD(rdef.contr);
  1477. if (card->cardstate == CARD_FREE)
  1478. return -ESRCH;
  1480. if (card->cardstate != CARD_DETECTED)
  1481. return -EBUSY;
  1483. card->driver->remove_ctr(card);
  1485. while (card->cardstate != CARD_FREE) {
  1487. set_current_state(TASK_INTERRUPTIBLE);
  1488. schedule_timeout(HZ/10); /* 0.1 sec */
  1490. if (signal_pending(current))
  1491. return -EINTR;
  1492. }
  1493. return 0;
  1494. }
  1495. return -EINVAL;
  1496. }
  1497. #endif
  1499. static int capi_manufacturer(unsigned int cmd, void *data)
  1500. {
  1501.         struct capi_ctr *card;
  1502. int retval;
  1504. switch (cmd) {
  1505. #ifdef CONFIG_AVMB1_COMPAT
  1506. case AVMB1_ADDCARD:
  1507. case AVMB1_ADDCARD_WITH_TYPE:
  1508. case AVMB1_LOAD:
  1509. case AVMB1_LOAD_AND_CONFIG:
  1510. case AVMB1_RESETCARD:
  1511. case AVMB1_GET_CARDINFO:
  1512. case AVMB1_REMOVECARD:
  1513. return old_capi_manufacturer(cmd, data);
  1514. #endif
  1515. case KCAPI_CMD_TRACE:
  1516. {
  1517. kcapi_flagdef fdef;
  1519. if ((retval = copy_from_user((void *) &fdef, data,
  1520.  sizeof(kcapi_flagdef))))
  1521. return retval;
  1523. if (!VALID_CARD(fdef.contr))
  1524. return -ESRCH;
  1525. card = CARD(fdef.contr);
  1526. if (card->cardstate == CARD_FREE)
  1527. return -ESRCH;
  1528. card->traceflag = fdef.flag;
  1529. printk(KERN_INFO "kcapi: contr %d set trace=%dn",
  1530. card->cnr, card->traceflag);
  1531. return 0;
  1532. }
  1534. case KCAPI_CMD_ADDCARD:
  1535. {
  1536. struct capi_driver *driver;
  1537. capicardparams cparams;
  1538. kcapi_carddef cdef;
  1540. if ((retval = copy_from_user((void *) &cdef, data,
  1541. sizeof(cdef))))
  1542. return retval;
  1544. cparams.port = cdef.port;
  1545. cparams.irq = cdef.irq;
  1546. cparams.membase = cdef.membase;
  1547. cparams.cardnr = cdef.cardnr;
  1548. cparams.cardtype = 0;
  1549. cdef.driver[sizeof(cdef.driver)-1] = 0;
  1551. if ((driver = find_driver(cdef.driver)) == 0) {
  1552. printk(KERN_ERR "kcapi: driver "%s" not loaded.n",
  1553. cdef.driver);
  1554. return -ESRCH;
  1555. }
  1557. if (!driver->add_card) {
  1558. printk(KERN_ERR "kcapi: driver "%s" has no add card function.n", cdef.driver);
  1559. return -EIO;
  1560. }
  1562. return driver->add_card(driver, &cparams);
  1563. }
  1565. default:
  1566. printk(KERN_ERR "kcapi: manufacturer command %d unknown.n",
  1567. cmd);
  1568. break;
  1570. }
  1571. return -EINVAL;
  1572. }
  1574. struct capi_interface avmb1_interface =
  1575. {
  1576. capi_isinstalled,
  1577. capi_register,
  1578. capi_release,
  1579. capi_put_message,
  1580. capi_get_message,
  1581. capi_set_signal,
  1582. capi_get_manufacturer,
  1583. capi_get_version,
  1584. capi_get_serial,
  1585. capi_get_profile,
  1586. capi_manufacturer
  1587. };
  1589. /* ------------------------------------------------------------- */
  1590. /* -------- Exported Functions --------------------------------- */
  1591. /* ------------------------------------------------------------- */
  1593. struct capi_interface *attach_capi_interface(struct capi_interface_user *userp)
  1594. {
  1595. struct capi_interface_user *p;
  1597. MOD_INC_USE_COUNT;
  1598. spin_lock(&capi_users_lock);
  1599. for (p = capi_users; p; p = p->next) {
  1600. if (p == userp) {
  1601. spin_unlock(&capi_users_lock);
  1602. printk(KERN_ERR "kcapi: double attach from %sn",
  1603.        userp->name);
  1604. MOD_DEC_USE_COUNT;
  1605. return 0;
  1606. }
  1607. }
  1608. userp->next = capi_users;
  1609. capi_users = userp;
  1610. spin_unlock(&capi_users_lock);
  1611. printk(KERN_NOTICE "kcapi: %s attachedn", userp->name);
  1613. return &avmb1_interface;
  1614. }
  1616. int detach_capi_interface(struct capi_interface_user *userp)
  1617. {
  1618. struct capi_interface_user **pp;
  1620. spin_lock(&capi_users_lock);
  1621. for (pp = &capi_users; *pp; pp = &(*pp)->next) {
  1622. if (*pp == userp) {
  1623. *pp = userp->next;
  1624. spin_unlock(&capi_users_lock);
  1625. userp->next = 0;
  1626. printk(KERN_NOTICE "kcapi: %s detachedn", userp->name);
  1627. MOD_DEC_USE_COUNT;
  1628. return 0;
  1629. }
  1630. }
  1631. spin_unlock(&capi_users_lock);
  1632. printk(KERN_ERR "kcapi: double detach from %sn", userp->name);
  1633. return -1;
  1634. }
  1636. /* ------------------------------------------------------------- */
  1637. /* -------- Init & Cleanup ------------------------------------- */
  1638. /* ------------------------------------------------------------- */
  1640. EXPORT_SYMBOL(attach_capi_interface);
  1641. EXPORT_SYMBOL(detach_capi_interface);
  1642. EXPORT_SYMBOL(attach_capi_driver);
  1643. EXPORT_SYMBOL(detach_capi_driver);
  1645. /*
  1646.  * init / exit functions
  1647.  */
  1649. static int __init kcapi_init(void)
  1650. {
  1651. char *p;
  1652. char rev[32];
  1654. MOD_INC_USE_COUNT;
  1656. skb_queue_head_init(&recv_queue);
  1658. tq_state_notify.routine = notify_handler;
  1659. tq_state_notify.data = 0;
  1661. tq_recv_notify.routine = recv_handler;
  1662. tq_recv_notify.data = 0;
  1664.         proc_capi_init();
  1666. if ((p = strchr(revision, ':')) != 0 && p[1]) {
  1667. strncpy(rev, p + 2, sizeof(rev));
  1668. rev[sizeof(rev)-1] = 0;
  1669. if ((p = strchr(rev, '$')) != 0 && p > rev)
  1670.    *(p-1) = 0;
  1671. } else
  1672. strcpy(rev, "1.0");
  1674. #ifdef MODULE
  1675.         printk(KERN_NOTICE "CAPI-driver Rev %s: loadedn", rev);
  1676. #else
  1677. printk(KERN_NOTICE "CAPI-driver Rev %s: startedn", rev);
  1678. #endif
  1679. MOD_DEC_USE_COUNT;
  1680. return 0;
  1681. }
  1683. static void __exit kcapi_exit(void)
  1684. {
  1685. char rev[10];
  1686. char *p;
  1688. if ((p = strchr(revision, ':'))) {
  1689. strcpy(rev, p + 1);
  1690. p = strchr(rev, '$');
  1691. *p = 0;
  1692. } else {
  1693. strcpy(rev, "1.0");
  1694. }
  1696.         proc_capi_exit();
  1697. printk(KERN_NOTICE "CAPI-driver Rev%s: unloadedn", rev);
  1698. }
  1700. module_init(kcapi_init);
  1701. module_exit(kcapi_exit);