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

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

Linux/Unix编程

开发平台：

Unix_Linux

capi.c：源码内容
  1. /* $Id: capi.c,v 1.1.4.2 2001/12/09 18:45:13 kai Exp $
  2.  *
  3.  * CAPI 2.0 Interface for Linux
  4.  *
  5.  * Copyright 1996 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/config.h>
  13. #include <linux/module.h>
  14. #include <linux/errno.h>
  15. #include <linux/kernel.h>
  16. #include <linux/major.h>
  17. #include <linux/sched.h>
  18. #include <linux/slab.h>
  19. #include <linux/fcntl.h>
  20. #include <linux/fs.h>
  21. #include <linux/signal.h>
  22. #include <linux/mm.h>
  23. #include <linux/smp_lock.h>
  24. #include <linux/timer.h>
  25. #include <linux/wait.h>
  26. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  27. #include <linux/tty.h>
  28. #ifdef CONFIG_PPP
  29. #include <linux/netdevice.h>
  30. #include <linux/ppp_defs.h>
  31. #include <linux/if_ppp.h>
  32. #undef CAPI_PPP_ON_RAW_DEVICE
  33. #endif /* CONFIG_PPP */
  34. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  35. #include <linux/skbuff.h>
  36. #include <linux/proc_fs.h>
  37. #include <linux/poll.h>
  38. #include <linux/capi.h>
  39. #include <linux/kernelcapi.h>
  40. #include <linux/init.h>
  41. #include <linux/devfs_fs_kernel.h>
  42. #include "capiutil.h"
  43. #include "capicmd.h"
  44. #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
  45. #include "capifs.h"
  46. #endif
  48. static char *revision = "$Revision: 1.1.4.2 $";
  50. MODULE_DESCRIPTION("CAPI4Linux: Userspace /dev/capi20 interface");
  51. MODULE_AUTHOR("Carsten Paeth");
  52. MODULE_LICENSE("GPL");
  54. #undef _DEBUG_REFCOUNT /* alloc/free and open/close debug */
  55. #undef _DEBUG_TTYFUNCS /* call to tty_driver */
  56. #undef _DEBUG_DATAFLOW /* data flow */
  58. /* -------- driver information -------------------------------------- */
  60. int capi_major = 68; /* allocated */
  61. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  62. int capi_rawmajor = 190;
  63. int capi_ttymajor = 191;
  64. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  66. MODULE_PARM(capi_major, "i");
  67. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  68. MODULE_PARM(capi_rawmajor, "i");
  69. MODULE_PARM(capi_ttymajor, "i");
  70. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  72. /* -------- defines ------------------------------------------------- */
  74. #define CAPINC_MAX_RECVQUEUE 10
  75. #define CAPINC_MAX_SENDQUEUE 10
  76. #define CAPI_MAX_BLKSIZE 2048
  78. /* -------- data structures ----------------------------------------- */
  80. struct capidev;
  81. struct capincci;
  82. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  83. struct capiminor;
  85. struct capiminor {
  86. struct capiminor *next;
  87. struct capincci  *nccip;
  88. unsigned int      minor;
  90. u16    applid;
  91. u32  ncci;
  92. u16  datahandle;
  93. u16  msgid;
  95. struct file      *file;
  96. struct tty_struct *tty;
  97. int                ttyinstop;
  98. int                ttyoutstop;
  99. struct sk_buff    *ttyskb;
  100. atomic_t           ttyopencount;
  102. struct sk_buff_head inqueue;
  103. int                 inbytes;
  104. struct sk_buff_head outqueue;
  105. int                 outbytes;
  107. /* for raw device */
  108. struct sk_buff_head recvqueue;
  109. wait_queue_head_t recvwait;
  110. wait_queue_head_t sendwait;
  112. /* transmit path */
  113. struct datahandle_queue {
  114.     struct datahandle_queue *next;
  115.     u16                      datahandle;
  116. } *ackqueue;
  117. int nack;
  119. };
  120. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  122. struct capincci {
  123. struct capincci *next;
  124. u32  ncci;
  125. struct capidev *cdev;
  126. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  127. struct capiminor *minorp;
  128. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  129. };
  131. struct capidev {
  132. struct capidev *next;
  133. struct file    *file;
  134. u16 applid;
  135. u16 errcode;
  136. unsigned int    minor;
  137. unsigned        userflags;
  139. struct sk_buff_head recvqueue;
  140. wait_queue_head_t recvwait;
  142. /* Statistic */
  143. unsigned long nrecvctlpkt;
  144. unsigned long nrecvdatapkt;
  145. unsigned long nsentctlpkt;
  146. unsigned long nsentdatapkt;
  148. struct capincci *nccis;
  149. };
  151. /* -------- global variables ---------------------------------------- */
  153. static struct capi_interface *capifuncs = 0;
  154. static struct capidev *capidev_openlist = 0;
  155. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  156. static struct capiminor *minors = 0;
  157. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  159. static kmem_cache_t *capidev_cachep = 0;
  160. static kmem_cache_t *capincci_cachep = 0;
  161. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  162. static kmem_cache_t *capiminor_cachep = 0;
  163. static kmem_cache_t *capidh_cachep = 0;
  164. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  166. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  167. /* -------- datahandles --------------------------------------------- */
  169. static int capincci_add_ack(struct capiminor *mp, u16 datahandle)
  170. {
  171. struct datahandle_queue *n, **pp;
  173. n = (struct datahandle_queue *)
  174. kmem_cache_alloc(capidh_cachep, GFP_ATOMIC);
  175. if (!n) {
  176.    printk(KERN_ERR "capi: alloc datahandle failedn");
  177.    return -1;
  178. }
  179. n->next = 0;
  180. n->datahandle = datahandle;
  181. for (pp = &mp->ackqueue; *pp; pp = &(*pp)->next) ;
  182. *pp = n;
  183. mp->nack++;
  184. return 0;
  185. }
  187. static int capiminor_del_ack(struct capiminor *mp, u16 datahandle)
  188. {
  189. struct datahandle_queue **pp, *p;
  191. for (pp = &mp->ackqueue; *pp; pp = &(*pp)->next) {
  192.   if ((*pp)->datahandle == datahandle) {
  193. p = *pp;
  194. *pp = (*pp)->next;
  195. kmem_cache_free(capidh_cachep, p);
  196. mp->nack--;
  197. return 0;
  198. }
  199. }
  200. return -1;
  201. }
  203. static void capiminor_del_all_ack(struct capiminor *mp)
  204. {
  205. struct datahandle_queue **pp, *p;
  207. pp = &mp->ackqueue;
  208. while (*pp) {
  209. p = *pp;
  210. *pp = (*pp)->next;
  211. kmem_cache_free(capidh_cachep, p);
  212. mp->nack--;
  213. }
  214. }
  217. /* -------- struct capiminor ---------------------------------------- */
  219. static struct capiminor *capiminor_alloc(u16 applid, u32 ncci)
  220. {
  221. struct capiminor *mp, **pp;
  222.         unsigned int minor = 0;
  224. MOD_INC_USE_COUNT;
  225. mp = (struct capiminor *)kmem_cache_alloc(capiminor_cachep, GFP_ATOMIC);
  226. if (!mp) {
  227. MOD_DEC_USE_COUNT;
  228. printk(KERN_ERR "capi: can't alloc capiminorn");
  229. return 0;
  230. }
  231. #ifdef _DEBUG_REFCOUNT
  232. printk(KERN_DEBUG "capiminor_alloc %dn", GET_USE_COUNT(THIS_MODULE));
  233. #endif
  234. memset(mp, 0, sizeof(struct capiminor));
  235. mp->applid = applid;
  236. mp->ncci = ncci;
  237. mp->msgid = 0;
  238. atomic_set(&mp->ttyopencount,0);
  240. skb_queue_head_init(&mp->inqueue);
  241. skb_queue_head_init(&mp->outqueue);
  243. skb_queue_head_init(&mp->recvqueue);
  244. init_waitqueue_head(&mp->recvwait);
  245. init_waitqueue_head(&mp->sendwait);
  247. for (pp = &minors; *pp; pp = &(*pp)->next) {
  248. if ((*pp)->minor < minor)
  249. continue;
  250. if ((*pp)->minor > minor)
  251. break;
  252. minor++;
  253. }
  254. mp->minor = minor;
  255. mp->next = *pp;
  256. *pp = mp;
  257. return mp;
  258. }
  260. static void capiminor_free(struct capiminor *mp)
  261. {
  262. struct capiminor **pp;
  264. pp = &minors;
  265. while (*pp) {
  266. if (*pp == mp) {
  267. *pp = (*pp)->next;
  268. if (mp->ttyskb) kfree_skb(mp->ttyskb);
  269. mp->ttyskb = 0;
  270. skb_queue_purge(&mp->recvqueue);
  271. skb_queue_purge(&mp->inqueue);
  272. skb_queue_purge(&mp->outqueue);
  273. capiminor_del_all_ack(mp);
  274. kmem_cache_free(capiminor_cachep, mp);
  275. MOD_DEC_USE_COUNT;
  276. #ifdef _DEBUG_REFCOUNT
  277. printk(KERN_DEBUG "capiminor_free %dn", GET_USE_COUNT(THIS_MODULE));
  278. #endif
  279. return;
  280. } else {
  281. pp = &(*pp)->next;
  282. }
  283. }
  284. }
  286. static struct capiminor *capiminor_find(unsigned int minor)
  287. {
  288. struct capiminor *p;
  289. for (p = minors; p && p->minor != minor; p = p->next)
  290. ;
  291. return p;
  292. }
  293. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  295. /* -------- struct capincci ----------------------------------------- */
  297. static struct capincci *capincci_alloc(struct capidev *cdev, u32 ncci)
  298. {
  299. struct capincci *np, **pp;
  300. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  301. struct capiminor *mp = 0;
  302. kdev_t kdev;
  303. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  305. np = (struct capincci *)kmem_cache_alloc(capincci_cachep, GFP_ATOMIC);
  306. if (!np)
  307. return 0;
  308. memset(np, 0, sizeof(struct capincci));
  309. np->ncci = ncci;
  310. np->cdev = cdev;
  311. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  312. mp = 0;
  313. if (cdev->userflags & CAPIFLAG_HIGHJACKING)
  314. mp = np->minorp = capiminor_alloc(cdev->applid, ncci);
  315. if (mp) {
  316. mp->nccip = np;
  317. #ifdef _DEBUG_REFCOUNT
  318. printk(KERN_DEBUG "set mp->nccipn");
  319. #endif
  320. #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
  321. kdev = MKDEV(capi_rawmajor, mp->minor);
  322. capifs_new_ncci('r', mp->minor, kdev);
  323. kdev = MKDEV(capi_ttymajor, mp->minor);
  324. capifs_new_ncci(0, mp->minor, kdev);
  325. #endif
  326. }
  327. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  328. for (pp=&cdev->nccis; *pp; pp = &(*pp)->next)
  329. ;
  330. *pp = np;
  331.         return np;
  332. }
  334. static void capincci_free(struct capidev *cdev, u32 ncci)
  335. {
  336. struct capincci *np, **pp;
  337. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  338. struct capiminor *mp;
  339. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  341. pp=&cdev->nccis;
  342. while (*pp) {
  343. np = *pp;
  344. if (ncci == 0xffffffff || np->ncci == ncci) {
  345. *pp = (*pp)->next;
  346. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  347. if ((mp = np->minorp) != 0) {
  348. #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
  349. capifs_free_ncci('r', mp->minor);
  350. capifs_free_ncci(0, mp->minor);
  351. #endif
  352. if (mp->tty) {
  353. mp->nccip = 0;
  354. #ifdef _DEBUG_REFCOUNT
  355. printk(KERN_DEBUG "reset mp->nccipn");
  356. #endif
  357. tty_hangup(mp->tty);
  358. } else if (mp->file) {
  359. mp->nccip = 0;
  360. #ifdef _DEBUG_REFCOUNT
  361. printk(KERN_DEBUG "reset mp->nccipn");
  362. #endif
  363. wake_up_interruptible(&mp->recvwait);
  364. wake_up_interruptible(&mp->sendwait);
  365. } else {
  366. capiminor_free(mp);
  367. }
  368. }
  369. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  370. kmem_cache_free(capincci_cachep, np);
  371. if (*pp == 0) return;
  372. } else {
  373. pp = &(*pp)->next;
  374. }
  375. }
  376. }
  378. static struct capincci *capincci_find(struct capidev *cdev, u32 ncci)
  379. {
  380. struct capincci *p;
  382. for (p=cdev->nccis; p ; p = p->next) {
  383. if (p->ncci == ncci)
  384. break;
  385. }
  386. return p;
  387. }
  389. /* -------- struct capidev ------------------------------------------ */
  391. static struct capidev *capidev_alloc(struct file *file)
  392. {
  393. struct capidev *cdev;
  394. struct capidev **pp;
  396. cdev = (struct capidev *)kmem_cache_alloc(capidev_cachep, GFP_KERNEL);
  397. if (!cdev)
  398. return 0;
  399. memset(cdev, 0, sizeof(struct capidev));
  400. cdev->file = file;
  401. cdev->minor = MINOR(file->f_dentry->d_inode->i_rdev);
  403. skb_queue_head_init(&cdev->recvqueue);
  404. init_waitqueue_head(&cdev->recvwait);
  405. pp=&capidev_openlist;
  406. while (*pp) pp = &(*pp)->next;
  407. *pp = cdev;
  408.         return cdev;
  409. }
  411. static void capidev_free(struct capidev *cdev)
  412. {
  413. struct capidev **pp;
  415. if (cdev->applid)
  416. (*capifuncs->capi_release) (cdev->applid);
  417. cdev->applid = 0;
  419. skb_queue_purge(&cdev->recvqueue);
  421. pp=&capidev_openlist;
  422. while (*pp && *pp != cdev) pp = &(*pp)->next;
  423. if (*pp)
  424. *pp = cdev->next;
  426. kmem_cache_free(capidev_cachep, cdev);
  427. }
  429. static struct capidev *capidev_find(u16 applid)
  430. {
  431. struct capidev *p;
  432. for (p=capidev_openlist; p; p = p->next) {
  433. if (p->applid == applid)
  434. break;
  435. }
  436. return p;
  437. }
  439. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  440. /* -------- handle data queue --------------------------------------- */
  442. static struct sk_buff *
  443. gen_data_b3_resp_for(struct capiminor *mp, struct sk_buff *skb)
  444. {
  445. struct sk_buff *nskb;
  446. nskb = alloc_skb(CAPI_DATA_B3_RESP_LEN, GFP_ATOMIC);
  447. if (nskb) {
  448. u16 datahandle = CAPIMSG_U16(skb->data,CAPIMSG_BASELEN+4+4+2);
  449. unsigned char *s = skb_put(nskb, CAPI_DATA_B3_RESP_LEN);
  450. capimsg_setu16(s, 0, CAPI_DATA_B3_RESP_LEN);
  451. capimsg_setu16(s, 2, mp->applid);
  452. capimsg_setu8 (s, 4, CAPI_DATA_B3);
  453. capimsg_setu8 (s, 5, CAPI_RESP);
  454. capimsg_setu16(s, 6, mp->msgid++);
  455. capimsg_setu32(s, 8, mp->ncci);
  456. capimsg_setu16(s, 12, datahandle);
  457. }
  458. return nskb;
  459. }
  461. static int handle_recv_skb(struct capiminor *mp, struct sk_buff *skb)
  462. {
  463. struct sk_buff *nskb;
  464. unsigned int datalen;
  465. u16 errcode, datahandle;
  467. datalen = skb->len - CAPIMSG_LEN(skb->data);
  468. if (mp->tty) {
  469. if (mp->tty->ldisc.receive_buf == 0) {
  470. printk(KERN_ERR "capi: ldisc has no receive_buf functionn");
  471. return -1;
  472. }
  473. if (mp->ttyinstop) {
  474. #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
  475. printk(KERN_DEBUG "capi: recv tty throttledn");
  476. #endif
  477. return -1;
  478. }
  479. if (mp->tty->ldisc.receive_room &&
  480.     mp->tty->ldisc.receive_room(mp->tty) < datalen) {
  481. #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
  482. printk(KERN_DEBUG "capi: no room in ttyn");
  483. #endif
  484. return -1;
  485. }
  486. if ((nskb = gen_data_b3_resp_for(mp, skb)) == 0) {
  487. printk(KERN_ERR "capi: gen_data_b3_resp failedn");
  488. return -1;
  489. }
  490. datahandle = CAPIMSG_U16(skb->data,CAPIMSG_BASELEN+4);
  491. errcode = (*capifuncs->capi_put_message)(mp->applid, nskb);
  492. if (errcode != CAPI_NOERROR) {
  493. printk(KERN_ERR "capi: send DATA_B3_RESP failed=%xn",
  494. errcode);
  495. kfree_skb(nskb);
  496. return -1;
  497. }
  498. (void)skb_pull(skb, CAPIMSG_LEN(skb->data));
  499. #ifdef _DEBUG_DATAFLOW
  500. printk(KERN_DEBUG "capi: DATA_B3_RESP %u len=%d => ldiscn",
  501. datahandle, skb->len);
  502. #endif
  503. mp->tty->ldisc.receive_buf(mp->tty, skb->data, 0, skb->len);
  504. kfree_skb(skb);
  505. return 0;
  507. } else if (mp->file) {
  508. if (skb_queue_len(&mp->recvqueue) > CAPINC_MAX_RECVQUEUE) {
  509. #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
  510. printk(KERN_DEBUG "capi: no room in raw queuen");
  511. #endif
  512. return -1;
  513. }
  514. if ((nskb = gen_data_b3_resp_for(mp, skb)) == 0) {
  515. printk(KERN_ERR "capi: gen_data_b3_resp failedn");
  516. return -1;
  517. }
  518. datahandle = CAPIMSG_U16(skb->data,CAPIMSG_BASELEN+4);
  519. errcode = (*capifuncs->capi_put_message)(mp->applid, nskb);
  520. if (errcode != CAPI_NOERROR) {
  521. printk(KERN_ERR "capi: send DATA_B3_RESP failed=%xn",
  522. errcode);
  523. kfree_skb(nskb);
  524. return -1;
  525. }
  526. (void)skb_pull(skb, CAPIMSG_LEN(skb->data));
  527. #ifdef _DEBUG_DATAFLOW
  528. printk(KERN_DEBUG "capi: DATA_B3_RESP %u len=%d => rawn",
  529. datahandle, skb->len);
  530. #endif
  531. skb_queue_tail(&mp->recvqueue, skb);
  532. wake_up_interruptible(&mp->recvwait);
  533. return 0;
  534. }
  535. #ifdef _DEBUG_DATAFLOW
  536. printk(KERN_DEBUG "capi: currently no receivern");
  537. #endif
  538. return -1;
  539. }
  541. static void handle_minor_recv(struct capiminor *mp)
  542. {
  543. struct sk_buff *skb;
  544. while ((skb = skb_dequeue(&mp->inqueue)) != 0) {
  545. unsigned int len = skb->len;
  546. mp->inbytes -= len;
  547. if (handle_recv_skb(mp, skb) < 0) {
  548. skb_queue_head(&mp->inqueue, skb);
  549. mp->inbytes += len;
  550. return;
  551. }
  552. }
  553. }
  555. static int handle_minor_send(struct capiminor *mp)
  556. {
  557. struct sk_buff *skb;
  558. u16 len;
  559. int count = 0;
  560. u16 errcode;
  561. u16 datahandle;
  563. if (mp->tty && mp->ttyoutstop) {
  564. #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
  565. printk(KERN_DEBUG "capi: send: tty stoppedn");
  566. #endif
  567. return 0;
  568. }
  570. while ((skb = skb_dequeue(&mp->outqueue)) != 0) {
  571. datahandle = mp->datahandle;
  572. len = (u16)skb->len;
  573. skb_push(skb, CAPI_DATA_B3_REQ_LEN);
  574. memset(skb->data, 0, CAPI_DATA_B3_REQ_LEN);
  575. capimsg_setu16(skb->data, 0, CAPI_DATA_B3_REQ_LEN);
  576. capimsg_setu16(skb->data, 2, mp->applid);
  577. capimsg_setu8 (skb->data, 4, CAPI_DATA_B3);
  578. capimsg_setu8 (skb->data, 5, CAPI_REQ);
  579. capimsg_setu16(skb->data, 6, mp->msgid++);
  580. capimsg_setu32(skb->data, 8, mp->ncci); /* NCCI */
  581. capimsg_setu32(skb->data, 12, (u32) skb->data); /* Data32 */
  582. capimsg_setu16(skb->data, 16, len); /* Data length */
  583. capimsg_setu16(skb->data, 18, datahandle);
  584. capimsg_setu16(skb->data, 20, 0); /* Flags */
  586. if (capincci_add_ack(mp, datahandle) < 0) {
  587. skb_pull(skb, CAPI_DATA_B3_REQ_LEN);
  588. skb_queue_head(&mp->outqueue, skb);
  589. return count;
  590. }
  591. errcode = (*capifuncs->capi_put_message) (mp->applid, skb);
  592. if (errcode == CAPI_NOERROR) {
  593. mp->datahandle++;
  594. count++;
  595. mp->outbytes -= len;
  596. #ifdef _DEBUG_DATAFLOW
  597. printk(KERN_DEBUG "capi: DATA_B3_REQ %u len=%un",
  598. datahandle, len);
  599. #endif
  600. continue;
  601. }
  602. capiminor_del_ack(mp, datahandle);
  604. if (errcode == CAPI_SENDQUEUEFULL) {
  605. skb_pull(skb, CAPI_DATA_B3_REQ_LEN);
  606. skb_queue_head(&mp->outqueue, skb);
  607. break;
  608. }
  610. /* ups, drop packet */
  611. printk(KERN_ERR "capi: put_message = %xn", errcode);
  612. mp->outbytes -= len;
  613. kfree_skb(skb);
  614. }
  615. if (count)
  616. wake_up_interruptible(&mp->sendwait);
  617. return count;
  618. }
  620. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  621. /* -------- function called by lower level -------------------------- */
  623. static void capi_signal(u16 applid, void *param)
  624. {
  625. struct capidev *cdev = (struct capidev *)param;
  626. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  627. struct capiminor *mp;
  628. u16 datahandle;
  629. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  630. struct capincci *np;
  631. struct sk_buff *skb = 0;
  632. u32 ncci;
  634. (void) (*capifuncs->capi_get_message) (applid, &skb);
  635. if (!skb) {
  636. printk(KERN_ERR "BUG: capi_signal: no skbn");
  637. return;
  638. }
  640. if (CAPIMSG_COMMAND(skb->data) != CAPI_DATA_B3) {
  641. skb_queue_tail(&cdev->recvqueue, skb);
  642. wake_up_interruptible(&cdev->recvwait);
  643. return;
  644. }
  645. ncci = CAPIMSG_CONTROL(skb->data);
  646. for (np = cdev->nccis; np && np->ncci != ncci; np = np->next)
  647. ;
  648. if (!np) {
  649. printk(KERN_ERR "BUG: capi_signal: ncci not foundn");
  650. skb_queue_tail(&cdev->recvqueue, skb);
  651. wake_up_interruptible(&cdev->recvwait);
  652. return;
  653. }
  654. #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
  655. skb_queue_tail(&cdev->recvqueue, skb);
  656. wake_up_interruptible(&cdev->recvwait);
  657. #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  658. mp = np->minorp;
  659. if (!mp) {
  660. skb_queue_tail(&cdev->recvqueue, skb);
  661. wake_up_interruptible(&cdev->recvwait);
  662. return;
  663. }
  666. if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_IND) {
  667. datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN+4+4+2);
  668. #ifdef _DEBUG_DATAFLOW
  669. printk(KERN_DEBUG "capi_signal: DATA_B3_IND %u len=%dn",
  670. datahandle, skb->len-CAPIMSG_LEN(skb->data));
  671. #endif
  672. skb_queue_tail(&mp->inqueue, skb);
  673. mp->inbytes += skb->len;
  674. handle_minor_recv(mp);
  676. } else if (CAPIMSG_SUBCOMMAND(skb->data) == CAPI_CONF) {
  678. datahandle = CAPIMSG_U16(skb->data, CAPIMSG_BASELEN+4);
  679. #ifdef _DEBUG_DATAFLOW
  680. printk(KERN_DEBUG "capi_signal: DATA_B3_CONF %u 0x%xn",
  681. datahandle,
  682. CAPIMSG_U16(skb->data, CAPIMSG_BASELEN+4+2));
  683. #endif
  684. kfree_skb(skb);
  685. (void)capiminor_del_ack(mp, datahandle);
  686. if (mp->tty) {
  687. if (mp->tty->ldisc.write_wakeup)
  688. mp->tty->ldisc.write_wakeup(mp->tty);
  689. } else {
  690. wake_up_interruptible(&mp->sendwait);
  691. }
  692. (void)handle_minor_send(mp);
  694. } else {
  695. /* ups, let capi application handle it :-) */
  696. skb_queue_tail(&cdev->recvqueue, skb);
  697. wake_up_interruptible(&cdev->recvwait);
  698. }
  699. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  700. }
  702. /* -------- file_operations for capidev ----------------------------- */
  704. static ssize_t
  705. capi_read(struct file *file, char *buf, size_t count, loff_t *ppos)
  706. {
  707. struct capidev *cdev = (struct capidev *)file->private_data;
  708. struct sk_buff *skb;
  709. int retval;
  710. size_t copied;
  712. if (ppos != &file->f_pos)
  713. return -ESPIPE;
  715. if (!cdev->applid)
  716. return -ENODEV;
  718. if ((skb = skb_dequeue(&cdev->recvqueue)) == 0) {
  720. if (file->f_flags & O_NONBLOCK)
  721. return -EAGAIN;
  723. for (;;) {
  724. interruptible_sleep_on(&cdev->recvwait);
  725. if ((skb = skb_dequeue(&cdev->recvqueue)) != 0)
  726. break;
  727. if (signal_pending(current))
  728. break;
  729. }
  730. if (skb == 0)
  731. return -ERESTARTNOHAND;
  732. }
  733. if (skb->len > count) {
  734. skb_queue_head(&cdev->recvqueue, skb);
  735. return -EMSGSIZE;
  736. }
  737. retval = copy_to_user(buf, skb->data, skb->len);
  738. if (retval) {
  739. skb_queue_head(&cdev->recvqueue, skb);
  740. return retval;
  741. }
  742. copied = skb->len;
  744. if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND) {
  745. cdev->nrecvdatapkt++;
  746. } else {
  747. cdev->nrecvctlpkt++;
  748. }
  750. kfree_skb(skb);
  752. return copied;
  753. }
  755. static ssize_t
  756. capi_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
  757. {
  758. struct capidev *cdev = (struct capidev *)file->private_data;
  759. struct sk_buff *skb;
  760. int retval;
  761. u16 mlen;
  763.         if (ppos != &file->f_pos)
  764. return -ESPIPE;
  766. if (!cdev->applid)
  767. return -ENODEV;
  769. skb = alloc_skb(count, GFP_USER);
  770. if (!skb)
  771. return -ENOMEM;
  773. if ((retval = copy_from_user(skb_put(skb, count), buf, count))) {
  774. kfree_skb(skb);
  775. return -EFAULT;
  776. }
  777. mlen = CAPIMSG_LEN(skb->data);
  778. if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_REQ) {
  779. if (mlen + CAPIMSG_DATALEN(skb->data) != count) {
  780. kfree_skb(skb);
  781. return -EINVAL;
  782. }
  783. } else {
  784. if (mlen != count) {
  785. kfree_skb(skb);
  786. return -EINVAL;
  787. }
  788. }
  789. CAPIMSG_SETAPPID(skb->data, cdev->applid);
  791. cdev->errcode = (*capifuncs->capi_put_message) (cdev->applid, skb);
  793. if (cdev->errcode) {
  794. kfree_skb(skb);
  795. return -EIO;
  796. }
  797. if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_REQ) {
  798. cdev->nsentdatapkt++;
  799. } else {
  800. cdev->nsentctlpkt++;
  801. }
  802. return count;
  803. }
  805. static unsigned int
  806. capi_poll(struct file *file, poll_table * wait)
  807. {
  808. struct capidev *cdev = (struct capidev *)file->private_data;
  809. unsigned int mask = 0;
  811. if (!cdev->applid)
  812. return POLLERR;
  814. poll_wait(file, &(cdev->recvwait), wait);
  815. mask = POLLOUT | POLLWRNORM;
  816. if (!skb_queue_empty(&cdev->recvqueue))
  817. mask |= POLLIN | POLLRDNORM;
  818. return mask;
  819. }
  821. static int
  822. capi_ioctl(struct inode *inode, struct file *file,
  823.       unsigned int cmd, unsigned long arg)
  824. {
  825. struct capidev *cdev = (struct capidev *)file->private_data;
  826. capi_ioctl_struct data;
  827. int retval = -EINVAL;
  829. switch (cmd) {
  830. case CAPI_REGISTER:
  831. {
  832. retval = copy_from_user((void *) &data.rparams,
  833. (void *) arg, sizeof(struct capi_register_params));
  834. if (retval)
  835. return -EFAULT;
  836. if (cdev->applid)
  837. return -EEXIST;
  838. cdev->errcode = (*capifuncs->capi_register) (&data.rparams,
  839.   &cdev->applid);
  840. if (cdev->errcode) {
  841. cdev->applid = 0;
  842. return -EIO;
  843. }
  844. (void) (*capifuncs->capi_set_signal) (cdev->applid, capi_signal, cdev);
  845. }
  846. return (int)cdev->applid;
  848. case CAPI_GET_VERSION:
  849. {
  850. retval = copy_from_user((void *) &data.contr,
  851. (void *) arg,
  852. sizeof(data.contr));
  853. if (retval)
  854. return -EFAULT;
  855.         cdev->errcode = (*capifuncs->capi_get_version) (data.contr, &data.version);
  856. if (cdev->errcode)
  857. return -EIO;
  858. retval = copy_to_user((void *) arg,
  859.       (void *) &data.version,
  860.       sizeof(data.version));
  861. if (retval)
  862. return -EFAULT;
  863. }
  864. return 0;
  866. case CAPI_GET_SERIAL:
  867. {
  868. retval = copy_from_user((void *) &data.contr,
  869. (void *) arg,
  870. sizeof(data.contr));
  871. if (retval)
  872. return -EFAULT;
  873. cdev->errcode = (*capifuncs->capi_get_serial) (data.contr, data.serial);
  874. if (cdev->errcode)
  875. return -EIO;
  876. retval = copy_to_user((void *) arg,
  877.       (void *) data.serial,
  878.       sizeof(data.serial));
  879. if (retval)
  880. return -EFAULT;
  881. }
  882. return 0;
  883. case CAPI_GET_PROFILE:
  884. {
  885. retval = copy_from_user((void *) &data.contr,
  886. (void *) arg,
  887. sizeof(data.contr));
  888. if (retval)
  889. return -EFAULT;
  891. if (data.contr == 0) {
  892. cdev->errcode = (*capifuncs->capi_get_profile) (data.contr, &data.profile);
  893. if (cdev->errcode)
  894. return -EIO;
  896. retval = copy_to_user((void *) arg,
  897.       (void *) &data.profile.ncontroller,
  898.        sizeof(data.profile.ncontroller));
  900. } else {
  901. cdev->errcode = (*capifuncs->capi_get_profile) (data.contr, &data.profile);
  902. if (cdev->errcode)
  903. return -EIO;
  905. retval = copy_to_user((void *) arg,
  906.   (void *) &data.profile,
  907.    sizeof(data.profile));
  908. }
  909. if (retval)
  910. return -EFAULT;
  911. }
  912. return 0;
  914. case CAPI_GET_MANUFACTURER:
  915. {
  916. retval = copy_from_user((void *) &data.contr,
  917. (void *) arg,
  918. sizeof(data.contr));
  919. if (retval)
  920. return -EFAULT;
  921. cdev->errcode = (*capifuncs->capi_get_manufacturer) (data.contr, data.manufacturer);
  922. if (cdev->errcode)
  923. return -EIO;
  925. retval = copy_to_user((void *) arg, (void *) data.manufacturer,
  926.       sizeof(data.manufacturer));
  927. if (retval)
  928. return -EFAULT;
  930. }
  931. return 0;
  932. case CAPI_GET_ERRCODE:
  933. data.errcode = cdev->errcode;
  934. cdev->errcode = CAPI_NOERROR;
  935. if (arg) {
  936. retval = copy_to_user((void *) arg,
  937.       (void *) &data.errcode,
  938.       sizeof(data.errcode));
  939. if (retval)
  940. return -EFAULT;
  941. }
  942. return data.errcode;
  944. case CAPI_INSTALLED:
  945. if ((*capifuncs->capi_isinstalled)() == CAPI_NOERROR)
  946. return 0;
  947. return -ENXIO;
  949. case CAPI_MANUFACTURER_CMD:
  950. {
  951. struct capi_manufacturer_cmd mcmd;
  952. if (!capable(CAP_SYS_ADMIN))
  953. return -EPERM;
  954. retval = copy_from_user((void *) &mcmd, (void *) arg,
  955. sizeof(mcmd));
  956. if (retval)
  957. return -EFAULT;
  958. return (*capifuncs->capi_manufacturer) (mcmd.cmd, mcmd.data);
  959. }
  960. return 0;
  962. case CAPI_SET_FLAGS:
  963. case CAPI_CLR_FLAGS:
  964. {
  965. unsigned userflags;
  966. retval = copy_from_user((void *) &userflags,
  967. (void *) arg,
  968. sizeof(userflags));
  969. if (retval)
  970. return -EFAULT;
  971. if (cmd == CAPI_SET_FLAGS)
  972. cdev->userflags |= userflags;
  973. else
  974. cdev->userflags &= ~userflags;
  975. }
  976. return 0;
  978. case CAPI_GET_FLAGS:
  979. {
  980. retval = copy_to_user((void *) arg,
  981.       (void *) &cdev->userflags,
  982.       sizeof(cdev->userflags));
  983. if (retval)
  984. return -EFAULT;
  985. }
  986. return 0;
  988. case CAPI_NCCI_OPENCOUNT:
  989. {
  990. struct capincci *nccip;
  991. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  992. struct capiminor *mp;
  993. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  994. unsigned ncci;
  995. int count = 0;
  996. retval = copy_from_user((void *) &ncci,
  997. (void *) arg,
  998. sizeof(ncci));
  999. if (retval)
  1000. return -EFAULT;
  1001. nccip = capincci_find(cdev, (u32) ncci);
  1002. if (!nccip)
  1003. return 0;
  1004. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1005. if ((mp = nccip->minorp) != 0) {
  1006. count += atomic_read(&mp->ttyopencount);
  1007. if (mp->file)
  1008. count++;
  1009. }
  1010. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1011. return count;
  1012. }
  1013. return 0;
  1015. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1016. case CAPI_NCCI_GETUNIT:
  1017. {
  1018. struct capincci *nccip;
  1019. struct capiminor *mp;
  1020. unsigned ncci;
  1021. retval = copy_from_user((void *) &ncci,
  1022. (void *) arg,
  1023. sizeof(ncci));
  1024. if (retval)
  1025. return -EFAULT;
  1026. nccip = capincci_find(cdev, (u32) ncci);
  1027. if (!nccip || (mp = nccip->minorp) == 0)
  1028. return -ESRCH;
  1029. return mp->minor;
  1030. }
  1031. return 0;
  1032. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1033. }
  1034. return -EINVAL;
  1035. }
  1037. static int
  1038. capi_open(struct inode *inode, struct file *file)
  1039. {
  1040. if (file->private_data)
  1041. return -EEXIST;
  1043. if ((file->private_data = capidev_alloc(file)) == 0)
  1044. return -ENOMEM;
  1046. MOD_INC_USE_COUNT;
  1047. #ifdef _DEBUG_REFCOUNT
  1048. printk(KERN_DEBUG "capi_open %dn", GET_USE_COUNT(THIS_MODULE));
  1049. #endif
  1050. return 0;
  1051. }
  1053. static int
  1054. capi_release(struct inode *inode, struct file *file)
  1055. {
  1056. struct capidev *cdev = (struct capidev *)file->private_data;
  1058. lock_kernel();
  1059. capincci_free(cdev, 0xffffffff);
  1060. capidev_free(cdev);
  1061. file->private_data = NULL;
  1063. MOD_DEC_USE_COUNT;
  1064. #ifdef _DEBUG_REFCOUNT
  1065. printk(KERN_DEBUG "capi_release %dn", GET_USE_COUNT(THIS_MODULE));
  1066. #endif
  1067. unlock_kernel();
  1068. return 0;
  1069. }
  1071. static struct file_operations capi_fops =
  1072. {
  1073. owner: THIS_MODULE,
  1074. llseek: no_llseek,
  1075. read: capi_read,
  1076. write: capi_write,
  1077. poll: capi_poll,
  1078. ioctl: capi_ioctl,
  1079. open: capi_open,
  1080. release: capi_release,
  1081. };
  1083. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1084. /* -------- file_operations for capincci ---------------------------- */
  1086. static int
  1087. capinc_raw_open(struct inode *inode, struct file *file)
  1088. {
  1089. struct capiminor *mp;
  1091. if (file->private_data)
  1092. return -EEXIST;
  1093. if ((mp = capiminor_find(MINOR(file->f_dentry->d_inode->i_rdev))) == 0)
  1094. return -ENXIO;
  1095. if (mp->nccip == 0)
  1096. return -ENXIO;
  1097. if (mp->file)
  1098. return -EBUSY;
  1100. #ifdef _DEBUG_REFCOUNT
  1101. printk(KERN_DEBUG "capi_raw_open %dn", GET_USE_COUNT(THIS_MODULE));
  1102. #endif
  1104. mp->datahandle = 0;
  1105. mp->file = file;
  1106. file->private_data = (void *)mp;
  1107. handle_minor_recv(mp);
  1108. return 0;
  1109. }
  1111. static ssize_t
  1112. capinc_raw_read(struct file *file, char *buf, size_t count, loff_t *ppos)
  1113. {
  1114. struct capiminor *mp = (struct capiminor *)file->private_data;
  1115. struct sk_buff *skb;
  1116. int retval;
  1117. size_t copied = 0;
  1119.         if (ppos != &file->f_pos)
  1120. return -ESPIPE;
  1122. if (!mp || !mp->nccip)
  1123. return -EINVAL;
  1125. if ((skb = skb_dequeue(&mp->recvqueue)) == 0) {
  1127. if (file->f_flags & O_NONBLOCK)
  1128. return -EAGAIN;
  1130. for (;;) {
  1131. interruptible_sleep_on(&mp->recvwait);
  1132. if (mp->nccip == 0)
  1133. return 0;
  1134. if ((skb = skb_dequeue(&mp->recvqueue)) != 0)
  1135. break;
  1136. if (signal_pending(current))
  1137. break;
  1138. }
  1139. if (skb == 0)
  1140. return -ERESTARTNOHAND;
  1141. }
  1142. do {
  1143. if (count < skb->len) {
  1144. retval = copy_to_user(buf, skb->data, count);
  1145. if (retval) {
  1146. skb_queue_head(&mp->recvqueue, skb);
  1147. return retval;
  1148. }
  1149. skb_pull(skb, count);
  1150. skb_queue_head(&mp->recvqueue, skb);
  1151. copied += count;
  1152. return copied;
  1153. } else {
  1154. retval = copy_to_user(buf, skb->data, skb->len);
  1155. if (retval) {
  1156. skb_queue_head(&mp->recvqueue, skb);
  1157. return copied;
  1158. }
  1159. copied += skb->len;
  1160. count -= skb->len;
  1161. buf += skb->len;
  1162. kfree_skb(skb);
  1163. }
  1164. } while ((skb = skb_dequeue(&mp->recvqueue)) != 0);
  1166. return copied;
  1167. }
  1169. static ssize_t
  1170. capinc_raw_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
  1171. {
  1172. struct capiminor *mp = (struct capiminor *)file->private_data;
  1173. struct sk_buff *skb;
  1174. int retval;
  1176.         if (ppos != &file->f_pos)
  1177. return -ESPIPE;
  1179. if (!mp || !mp->nccip)
  1180. return -EINVAL;
  1182. skb = alloc_skb(CAPI_DATA_B3_REQ_LEN+count, GFP_USER);
  1183. if (!skb)
  1184. return -ENOMEM;
  1186. skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
  1187. if ((retval = copy_from_user(skb_put(skb, count), buf, count))) {
  1188. kfree_skb(skb);
  1189. return -EFAULT;
  1190. }
  1192. while (skb_queue_len(&mp->outqueue) > CAPINC_MAX_SENDQUEUE) {
  1193. if (file->f_flags & O_NONBLOCK)
  1194. return -EAGAIN;
  1195. interruptible_sleep_on(&mp->sendwait);
  1196. if (mp->nccip == 0) {
  1197. kfree_skb(skb);
  1198. return -EIO;
  1199. }
  1200. if (signal_pending(current))
  1201. return -ERESTARTNOHAND;
  1202. }
  1203. skb_queue_tail(&mp->outqueue, skb);
  1204. mp->outbytes += skb->len;
  1205. (void)handle_minor_send(mp);
  1206. return count;
  1207. }
  1209. static unsigned int
  1210. capinc_raw_poll(struct file *file, poll_table * wait)
  1211. {
  1212. struct capiminor *mp = (struct capiminor *)file->private_data;
  1213. unsigned int mask = 0;
  1215. if (!mp || !mp->nccip)
  1216. return POLLERR|POLLHUP;
  1218. poll_wait(file, &(mp->recvwait), wait);
  1219. if (!skb_queue_empty(&mp->recvqueue))
  1220. mask |= POLLIN | POLLRDNORM;
  1221. poll_wait(file, &(mp->sendwait), wait);
  1222. if (skb_queue_len(&mp->outqueue) > CAPINC_MAX_SENDQUEUE)
  1223. mask = POLLOUT | POLLWRNORM;
  1224. return mask;
  1225. }
  1227. static int
  1228. capinc_raw_ioctl(struct inode *inode, struct file *file,
  1229.       unsigned int cmd, unsigned long arg)
  1230. {
  1231. struct capiminor *mp = (struct capiminor *)file->private_data;
  1232. if (!mp || !mp->nccip)
  1233. return -EINVAL;
  1235. switch (cmd) {
  1236. }
  1237. return -EINVAL;
  1238. }
  1240. static int
  1241. capinc_raw_release(struct inode *inode, struct file *file)
  1242. {
  1243. struct capiminor *mp = (struct capiminor *)file->private_data;
  1245. if (mp) {
  1246. lock_kernel();
  1247. mp->file = 0;
  1248. if (mp->nccip == 0) {
  1249. capiminor_free(mp);
  1250. file->private_data = NULL;
  1251. }
  1252. unlock_kernel();
  1253. }
  1255. #ifdef _DEBUG_REFCOUNT
  1256. printk(KERN_DEBUG "capinc_raw_release %dn", GET_USE_COUNT(THIS_MODULE));
  1257. #endif
  1258. return 0;
  1259. }
  1261. static struct file_operations capinc_raw_fops =
  1262. {
  1263. owner: THIS_MODULE,
  1264. llseek: no_llseek,
  1265. read: capinc_raw_read,
  1266. write: capinc_raw_write,
  1267. poll: capinc_raw_poll,
  1268. ioctl: capinc_raw_ioctl,
  1269. open: capinc_raw_open,
  1270. release: capinc_raw_release,
  1271. };
  1273. /* -------- tty_operations for capincci ----------------------------- */
  1275. static int capinc_tty_open(struct tty_struct * tty, struct file * file)
  1276. {
  1277. struct capiminor *mp;
  1279. if ((mp = capiminor_find(MINOR(file->f_dentry->d_inode->i_rdev))) == 0)
  1280. return -ENXIO;
  1281. if (mp->nccip == 0)
  1282. return -ENXIO;
  1283. if (mp->file)
  1284. return -EBUSY;
  1286. skb_queue_head_init(&mp->recvqueue);
  1287. init_waitqueue_head(&mp->recvwait);
  1288. init_waitqueue_head(&mp->sendwait);
  1289. tty->driver_data = (void *)mp;
  1290. #ifdef _DEBUG_REFCOUNT
  1291. printk(KERN_DEBUG "capi_tty_open %dn", GET_USE_COUNT(THIS_MODULE));
  1292. #endif
  1293. if (atomic_read(&mp->ttyopencount) == 0)
  1294. mp->tty = tty;
  1295. atomic_inc(&mp->ttyopencount);
  1296. #ifdef _DEBUG_REFCOUNT
  1297. printk(KERN_DEBUG "capinc_tty_open ocount=%dn", atomic_read(&mp->ttyopencount));
  1298. #endif
  1299. handle_minor_recv(mp);
  1300. return 0;
  1301. }
  1303. static void capinc_tty_close(struct tty_struct * tty, struct file * file)
  1304. {
  1305. struct capiminor *mp;
  1307. mp = (struct capiminor *)tty->driver_data;
  1308. if (mp) {
  1309. if (atomic_dec_and_test(&mp->ttyopencount)) {
  1310. #ifdef _DEBUG_REFCOUNT
  1311. printk(KERN_DEBUG "capinc_tty_close lastclosen");
  1312. #endif
  1313. tty->driver_data = (void *)0;
  1314. mp->tty = 0;
  1315. }
  1316. #ifdef _DEBUG_REFCOUNT
  1317. printk(KERN_DEBUG "capinc_tty_close ocount=%dn", atomic_read(&mp->ttyopencount));
  1318. #endif
  1319. if (mp->nccip == 0)
  1320. capiminor_free(mp);
  1321. }
  1323. #ifdef _DEBUG_REFCOUNT
  1324. printk(KERN_DEBUG "capinc_tty_closen");
  1325. #endif
  1326. }
  1328. static int capinc_tty_write(struct tty_struct * tty, int from_user,
  1329.     const unsigned char *buf, int count)
  1330. {
  1331. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1332. struct sk_buff *skb;
  1333. int retval;
  1335. #ifdef _DEBUG_TTYFUNCS
  1336. printk(KERN_DEBUG "capinc_tty_write(from_user=%d,count=%d)n",
  1337. from_user, count);
  1338. #endif
  1340. if (!mp || !mp->nccip) {
  1341. #ifdef _DEBUG_TTYFUNCS
  1342. printk(KERN_DEBUG "capinc_tty_write: mp or mp->ncci NULLn");
  1343. #endif
  1344. return 0;
  1345. }
  1347. skb = mp->ttyskb;
  1348. if (skb) {
  1349. mp->ttyskb = 0;
  1350. skb_queue_tail(&mp->outqueue, skb);
  1351. mp->outbytes += skb->len;
  1352. }
  1354. skb = alloc_skb(CAPI_DATA_B3_REQ_LEN+count, GFP_ATOMIC);
  1355. if (!skb) {
  1356. printk(KERN_ERR "capinc_tty_write: alloc_skb failedn");
  1357. return -ENOMEM;
  1358. }
  1360. skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
  1361. if (from_user) {
  1362. if ((retval = copy_from_user(skb_put(skb, count), buf, count))) {
  1363. kfree_skb(skb);
  1364. #ifdef _DEBUG_TTYFUNCS
  1365. printk(KERN_DEBUG "capinc_tty_write: copy_from_user=%dn", retval);
  1366. #endif
  1367. return -EFAULT;
  1368. }
  1369. } else {
  1370. memcpy(skb_put(skb, count), buf, count);
  1371. }
  1373. skb_queue_tail(&mp->outqueue, skb);
  1374. mp->outbytes += skb->len;
  1375. (void)handle_minor_send(mp);
  1376. (void)handle_minor_recv(mp);
  1377. return count;
  1378. }
  1380. static void capinc_tty_put_char(struct tty_struct *tty, unsigned char ch)
  1381. {
  1382. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1383. struct sk_buff *skb;
  1385. #ifdef _DEBUG_TTYFUNCS
  1386. printk(KERN_DEBUG "capinc_put_char(%u)n", ch);
  1387. #endif
  1389. if (!mp || !mp->nccip) {
  1390. #ifdef _DEBUG_TTYFUNCS
  1391. printk(KERN_DEBUG "capinc_tty_put_char: mp or mp->ncci NULLn");
  1392. #endif
  1393. return;
  1394. }
  1396. skb = mp->ttyskb;
  1397. if (skb) {
  1398. if (skb_tailroom(skb) > 0) {
  1399. *(skb_put(skb, 1)) = ch;
  1400. return;
  1401. }
  1402. mp->ttyskb = 0;
  1403. skb_queue_tail(&mp->outqueue, skb);
  1404. mp->outbytes += skb->len;
  1405. (void)handle_minor_send(mp);
  1406. }
  1407. skb = alloc_skb(CAPI_DATA_B3_REQ_LEN+CAPI_MAX_BLKSIZE, GFP_ATOMIC);
  1408. if (skb) {
  1409. skb_reserve(skb, CAPI_DATA_B3_REQ_LEN);
  1410. *(skb_put(skb, 1)) = ch;
  1411. mp->ttyskb = skb;
  1412. } else {
  1413. printk(KERN_ERR "capinc_put_char: char %u lostn", ch);
  1414. }
  1415. }
  1417. static void capinc_tty_flush_chars(struct tty_struct *tty)
  1418. {
  1419. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1420. struct sk_buff *skb;
  1422. #ifdef _DEBUG_TTYFUNCS
  1423. printk(KERN_DEBUG "capinc_tty_flush_charsn");
  1424. #endif
  1426. if (!mp || !mp->nccip) {
  1427. #ifdef _DEBUG_TTYFUNCS
  1428. printk(KERN_DEBUG "capinc_tty_flush_chars: mp or mp->ncci NULLn");
  1429. #endif
  1430. return;
  1431. }
  1433. skb = mp->ttyskb;
  1434. if (skb) {
  1435. mp->ttyskb = 0;
  1436. skb_queue_tail(&mp->outqueue, skb);
  1437. mp->outbytes += skb->len;
  1438. (void)handle_minor_send(mp);
  1439. }
  1440. (void)handle_minor_recv(mp);
  1441. }
  1443. static int capinc_tty_write_room(struct tty_struct *tty)
  1444. {
  1445. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1446. int room;
  1447. if (!mp || !mp->nccip) {
  1448. #ifdef _DEBUG_TTYFUNCS
  1449. printk(KERN_DEBUG "capinc_tty_write_room: mp or mp->ncci NULLn");
  1450. #endif
  1451. return 0;
  1452. }
  1453. room = CAPINC_MAX_SENDQUEUE-skb_queue_len(&mp->outqueue);
  1454. room *= CAPI_MAX_BLKSIZE;
  1455. #ifdef _DEBUG_TTYFUNCS
  1456. printk(KERN_DEBUG "capinc_tty_write_room = %dn", room);
  1457. #endif
  1458. return room;
  1459. }
  1461. static int capinc_tty_chars_in_buffer(struct tty_struct *tty)
  1462. {
  1463. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1464. if (!mp || !mp->nccip) {
  1465. #ifdef _DEBUG_TTYFUNCS
  1466. printk(KERN_DEBUG "capinc_tty_chars_in_buffer: mp or mp->ncci NULLn");
  1467. #endif
  1468. return 0;
  1469. }
  1470. #ifdef _DEBUG_TTYFUNCS
  1471. printk(KERN_DEBUG "capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%dn",
  1472. mp->outbytes, mp->nack,
  1473. skb_queue_len(&mp->outqueue),
  1474. skb_queue_len(&mp->inqueue));
  1475. #endif
  1476. return mp->outbytes;
  1477. }
  1479. static int capinc_tty_ioctl(struct tty_struct *tty, struct file * file,
  1480.     unsigned int cmd, unsigned long arg)
  1481. {
  1482. int error = 0;
  1483. switch (cmd) {
  1484. default:
  1485. error = n_tty_ioctl (tty, file, cmd, arg);
  1486. break;
  1487. }
  1488. return error;
  1489. }
  1491. static void capinc_tty_set_termios(struct tty_struct *tty, struct termios * old)
  1492. {
  1493. #ifdef _DEBUG_TTYFUNCS
  1494. printk(KERN_DEBUG "capinc_tty_set_termiosn");
  1495. #endif
  1496. }
  1498. static void capinc_tty_throttle(struct tty_struct * tty)
  1499. {
  1500. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1501. #ifdef _DEBUG_TTYFUNCS
  1502. printk(KERN_DEBUG "capinc_tty_throttlen");
  1503. #endif
  1504. if (mp)
  1505. mp->ttyinstop = 1;
  1506. }
  1508. static void capinc_tty_unthrottle(struct tty_struct * tty)
  1509. {
  1510. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1511. #ifdef _DEBUG_TTYFUNCS
  1512. printk(KERN_DEBUG "capinc_tty_unthrottlen");
  1513. #endif
  1514. if (mp) {
  1515. mp->ttyinstop = 0;
  1516. handle_minor_recv(mp);
  1517. }
  1518. }
  1520. static void capinc_tty_stop(struct tty_struct *tty)
  1521. {
  1522. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1523. #ifdef _DEBUG_TTYFUNCS
  1524. printk(KERN_DEBUG "capinc_tty_stopn");
  1525. #endif
  1526. if (mp) {
  1527. mp->ttyoutstop = 1;
  1528. }
  1529. }
  1531. static void capinc_tty_start(struct tty_struct *tty)
  1532. {
  1533. struct capiminor *mp = (struct capiminor *)tty->driver_data;
  1534. #ifdef _DEBUG_TTYFUNCS
  1535. printk(KERN_DEBUG "capinc_tty_startn");
  1536. #endif
  1537. if (mp) {
  1538. mp->ttyoutstop = 0;
  1539. (void)handle_minor_send(mp);
  1540. }
  1541. }
  1543. static void capinc_tty_hangup(struct tty_struct *tty)
  1544. {
  1545. #ifdef _DEBUG_TTYFUNCS
  1546. printk(KERN_DEBUG "capinc_tty_hangupn");
  1547. #endif
  1548. }
  1550. static void capinc_tty_break_ctl(struct tty_struct *tty, int state)
  1551. {
  1552. #ifdef _DEBUG_TTYFUNCS
  1553. printk(KERN_DEBUG "capinc_tty_break_ctl(%d)n", state);
  1554. #endif
  1555. }
  1557. static void capinc_tty_flush_buffer(struct tty_struct *tty)
  1558. {
  1559. #ifdef _DEBUG_TTYFUNCS
  1560. printk(KERN_DEBUG "capinc_tty_flush_buffern");
  1561. #endif
  1562. }
  1564. static void capinc_tty_set_ldisc(struct tty_struct *tty)
  1565. {
  1566. #ifdef _DEBUG_TTYFUNCS
  1567. printk(KERN_DEBUG "capinc_tty_set_ldiscn");
  1568. #endif
  1569. }
  1571. static void capinc_tty_send_xchar(struct tty_struct *tty, char ch)
  1572. {
  1573. #ifdef _DEBUG_TTYFUNCS
  1574. printk(KERN_DEBUG "capinc_tty_send_xchar(%d)n", ch);
  1575. #endif
  1576. }
  1578. static int capinc_tty_read_proc(char *page, char **start, off_t off,
  1579. int count, int *eof, void *data)
  1580. {
  1581. return 0;
  1582. }
  1584. #define CAPINC_NR_PORTS 256
  1585. static struct tty_driver capinc_tty_driver;
  1586. static int capinc_tty_refcount;
  1587. static struct tty_struct *capinc_tty_table[CAPINC_NR_PORTS];
  1588. static struct termios *capinc_tty_termios[CAPINC_NR_PORTS];
  1589. static struct termios *capinc_tty_termios_locked[CAPINC_NR_PORTS];
  1591. static int capinc_tty_init(void)
  1592. {
  1593. struct tty_driver *drv = &capinc_tty_driver;
  1595. /* Initialize the tty_driver structure */
  1597. memset(drv, 0, sizeof(struct tty_driver));
  1598. drv->magic = TTY_DRIVER_MAGIC;
  1599. #if (LINUX_VERSION_CODE > 0x20100)
  1600. drv->driver_name = "capi_nc";
  1601. #endif
  1602. drv->name = "capi/%d";
  1603. drv->major = capi_ttymajor;
  1604. drv->minor_start = 0;
  1605. drv->num = CAPINC_NR_PORTS;
  1606. drv->type = TTY_DRIVER_TYPE_SERIAL;
  1607. drv->subtype = SERIAL_TYPE_NORMAL;
  1608. drv->init_termios = tty_std_termios;
  1609. drv->init_termios.c_iflag = ICRNL;
  1610. drv->init_termios.c_oflag = OPOST | ONLCR;
  1611. drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  1612. drv->init_termios.c_lflag = 0;
  1613. drv->flags = TTY_DRIVER_REAL_RAW|TTY_DRIVER_RESET_TERMIOS;
  1614. drv->refcount = &capinc_tty_refcount;
  1615. drv->table = capinc_tty_table;
  1616. drv->termios = capinc_tty_termios;
  1617. drv->termios_locked = capinc_tty_termios_locked;
  1619. drv->open = capinc_tty_open;
  1620. drv->close = capinc_tty_close;
  1621. drv->write = capinc_tty_write;
  1622. drv->put_char = capinc_tty_put_char;
  1623. drv->flush_chars = capinc_tty_flush_chars;
  1624. drv->write_room = capinc_tty_write_room;
  1625. drv->chars_in_buffer = capinc_tty_chars_in_buffer;
  1626. drv->ioctl = capinc_tty_ioctl;
  1627. drv->set_termios = capinc_tty_set_termios;
  1628. drv->throttle = capinc_tty_throttle;
  1629. drv->unthrottle = capinc_tty_unthrottle;
  1630. drv->stop = capinc_tty_stop;
  1631. drv->start = capinc_tty_start;
  1632. drv->hangup = capinc_tty_hangup;
  1633. #if (LINUX_VERSION_CODE >= 131394) /* Linux 2.1.66 */
  1634. drv->break_ctl = capinc_tty_break_ctl;
  1635. #endif
  1636. drv->flush_buffer = capinc_tty_flush_buffer;
  1637. drv->set_ldisc = capinc_tty_set_ldisc;
  1638. #if (LINUX_VERSION_CODE >= 131343)
  1639. drv->send_xchar = capinc_tty_send_xchar;
  1640. drv->read_proc = capinc_tty_read_proc;
  1641. #endif
  1642. if (tty_register_driver(drv)) {
  1643. printk(KERN_ERR "Couldn't register capi_nc drivern");
  1644. return -1;
  1645. }
  1646. return 0;
  1647. }
  1649. static void capinc_tty_exit(void)
  1650. {
  1651. struct tty_driver *drv = &capinc_tty_driver;
  1652. int retval;
  1653. if ((retval = tty_unregister_driver(drv)))
  1654. printk(KERN_ERR "capi: failed to unregister capi_nc driver (%d)n", retval);
  1655. }
  1657. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1659. /* -------- /proc functions ----------------------------------------- */
  1661. /*
  1662.  * /proc/capi/capi20:
  1663.  *  minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
  1664.  */
  1665. static int proc_capidev_read_proc(char *page, char **start, off_t off,
  1666.                                        int count, int *eof, void *data)
  1667. {
  1668.         struct capidev *cdev;
  1669. int len = 0;
  1671. for (cdev=capidev_openlist; cdev; cdev = cdev->next) {
  1672. len += sprintf(page+len, "%d %d %lu %lu %lu %lun",
  1673. cdev->minor,
  1674. cdev->applid,
  1675. cdev->nrecvctlpkt,
  1676. cdev->nrecvdatapkt,
  1677. cdev->nsentctlpkt,
  1678. cdev->nsentdatapkt);
  1679. if (len <= off) {
  1680. off -= len;
  1681. len = 0;
  1682. } else {
  1683. if (len-off > count)
  1684. goto endloop;
  1685. }
  1686. }
  1687. endloop:
  1688. if (len < count)
  1689. *eof = 1;
  1690. if (len>count) len = count;
  1691. if (len<0) len = 0;
  1692. return len;
  1693. }
  1695. /*
  1696.  * /proc/capi/capi20ncci:
  1697.  *  applid ncci
  1698.  */
  1699. static int proc_capincci_read_proc(char *page, char **start, off_t off,
  1700.                                        int count, int *eof, void *data)
  1701. {
  1702.         struct capidev *cdev;
  1703.         struct capincci *np;
  1704. int len = 0;
  1706. for (cdev=capidev_openlist; cdev; cdev = cdev->next) {
  1707. for (np=cdev->nccis; np; np = np->next) {
  1708. len += sprintf(page+len, "%d 0x%x%sn",
  1709. cdev->applid,
  1710. np->ncci,
  1711. #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
  1712. "");
  1713. #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1714. np->minorp && np->minorp->file ? " open" : "");
  1715. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1716. if (len <= off) {
  1717. off -= len;
  1718. len = 0;
  1719. } else {
  1720. if (len-off > count)
  1721. goto endloop;
  1722. }
  1723. }
  1724. }
  1725. endloop:
  1726. *start = page+off;
  1727. if (len < count)
  1728. *eof = 1;
  1729. if (len>count) len = count;
  1730. if (len<0) len = 0;
  1731. return len;
  1732. }
  1734. static struct procfsentries {
  1735.   char *name;
  1736.   mode_t mode;
  1737.   int (*read_proc)(char *page, char **start, off_t off,
  1738.                                        int count, int *eof, void *data);
  1739.   struct proc_dir_entry *procent;
  1740. } procfsentries[] = {
  1741.    /* { "capi",   S_IFDIR, 0 }, */
  1742.    { "capi/capi20",    0  , proc_capidev_read_proc },
  1743.    { "capi/capi20ncci",   0  , proc_capincci_read_proc },
  1744. };
  1746. static void __init proc_init(void)
  1747. {
  1748.     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
  1749.     int i;
  1751.     for (i=0; i < nelem; i++) {
  1752.         struct procfsentries *p = procfsentries + i;
  1753. p->procent = create_proc_entry(p->name, p->mode, 0);
  1754. if (p->procent) p->procent->read_proc = p->read_proc;
  1755.     }
  1756. }
  1758. static void __exit proc_exit(void)
  1759. {
  1760.     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
  1761.     int i;
  1763.     for (i=nelem-1; i >= 0; i--) {
  1764.         struct procfsentries *p = procfsentries + i;
  1765. if (p->procent) {
  1766.    remove_proc_entry(p->name, 0);
  1767.    p->procent = 0;
  1768. }
  1769.     }
  1770. }
  1772. /* -------- init function and module interface ---------------------- */
  1775. static void alloc_exit(void)
  1776. {
  1777. if (capidev_cachep) {
  1778. (void)kmem_cache_destroy(capidev_cachep);
  1779. capidev_cachep = 0;
  1780. }
  1781. if (capincci_cachep) {
  1782. (void)kmem_cache_destroy(capincci_cachep);
  1783. capincci_cachep = 0;
  1784. }
  1785. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1786. if (capidh_cachep) {
  1787. (void)kmem_cache_destroy(capidh_cachep);
  1788. capidh_cachep = 0;
  1789. }
  1790. if (capiminor_cachep) {
  1791. (void)kmem_cache_destroy(capiminor_cachep);
  1792. capiminor_cachep = 0;
  1793. }
  1794. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1795. }
  1797. static int __init alloc_init(void)
  1798. {
  1799. capidev_cachep = kmem_cache_create("capi20_dev",
  1800.  sizeof(struct capidev),
  1801.  0,
  1802.  SLAB_HWCACHE_ALIGN,
  1803.  NULL, NULL);
  1804. if (!capidev_cachep) {
  1805. alloc_exit();
  1806. return -ENOMEM;
  1807. }
  1809. capincci_cachep = kmem_cache_create("capi20_ncci",
  1810.  sizeof(struct capincci),
  1811.  0,
  1812.  SLAB_HWCACHE_ALIGN,
  1813.  NULL, NULL);
  1814. if (!capincci_cachep) {
  1815. alloc_exit();
  1816. return -ENOMEM;
  1817. }
  1818. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1819. capidh_cachep = kmem_cache_create("capi20_dh",
  1820.  sizeof(struct datahandle_queue),
  1821.  0,
  1822.  SLAB_HWCACHE_ALIGN,
  1823.  NULL, NULL);
  1824. if (!capidh_cachep) {
  1825. alloc_exit();
  1826. return -ENOMEM;
  1827. }
  1828. capiminor_cachep = kmem_cache_create("capi20_minor",
  1829.  sizeof(struct capiminor),
  1830.  0,
  1831.  SLAB_HWCACHE_ALIGN,
  1832.  NULL, NULL);
  1833. if (!capiminor_cachep) {
  1834. alloc_exit();
  1835. return -ENOMEM;
  1836. }
  1837. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1838. return 0;
  1839. }
  1841. static void lower_callback(unsigned int cmd, u32 contr, void *data)
  1842. {
  1843. struct capi_ncciinfo *np;
  1844. struct capidev *cdev;
  1846. switch (cmd) {
  1847. case KCI_CONTRUP:
  1848. printk(KERN_INFO "capi: controller %hu upn", contr);
  1849. break;
  1850. case KCI_CONTRDOWN:
  1851. printk(KERN_INFO "capi: controller %hu downn", contr);
  1852. break;
  1853. case KCI_NCCIUP:
  1854. np = (struct capi_ncciinfo *)data;
  1855. if ((cdev = capidev_find(np->applid)) == 0)
  1856. return;
  1857. (void)capincci_alloc(cdev, np->ncci);
  1858. break;
  1859. case KCI_NCCIDOWN:
  1860. np = (struct capi_ncciinfo *)data;
  1861. if ((cdev = capidev_find(np->applid)) == 0)
  1862. return;
  1863. (void)capincci_free(cdev, np->ncci);
  1864. break;
  1865. }
  1866. }
  1868. static struct capi_interface_user cuser = {
  1869. name: "capi20",
  1870. callback: lower_callback,
  1871. };
  1873. static char rev[32];
  1875. static int __init capi_init(void)
  1876. {
  1877. char *p;
  1878. char *compileinfo;
  1880. MOD_INC_USE_COUNT;
  1882. if ((p = strchr(revision, ':')) != 0 && p[1]) {
  1883. strncpy(rev, p + 2, sizeof(rev));
  1884. rev[sizeof(rev)-1] = 0;
  1885. if ((p = strchr(rev, '$')) != 0 && p > rev)
  1886.    *(p-1) = 0;
  1887. } else
  1888. strcpy(rev, "1.0");
  1890. if (devfs_register_chrdev(capi_major, "capi20", &capi_fops)) {
  1891. printk(KERN_ERR "capi20: unable to get major %dn", capi_major);
  1892. MOD_DEC_USE_COUNT;
  1893. return -EIO;
  1894. }
  1896. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1897. if (devfs_register_chrdev(capi_rawmajor, "capi/r%d", &capinc_raw_fops)) {
  1898. devfs_unregister_chrdev(capi_major, "capi20");
  1899. printk(KERN_ERR "capi20: unable to get major %dn", capi_rawmajor);
  1900. MOD_DEC_USE_COUNT;
  1901. return -EIO;
  1902. }
  1903.         devfs_register_series (NULL, "capi/r%u", CAPINC_NR_PORTS,
  1904.       DEVFS_FL_DEFAULT,
  1905.                               capi_rawmajor, 0,
  1906.                               S_IFCHR | S_IRUSR | S_IWUSR,
  1907.                               &capinc_raw_fops, NULL);
  1908. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1909. devfs_register (NULL, "isdn/capi20", DEVFS_FL_DEFAULT,
  1910. capi_major, 0, S_IFCHR | S_IRUSR | S_IWUSR,
  1911. &capi_fops, NULL);
  1912. printk(KERN_NOTICE "capi20: started up with major %dn", capi_major);
  1914. if ((capifuncs = attach_capi_interface(&cuser)) == 0) {
  1916. MOD_DEC_USE_COUNT;
  1917. devfs_unregister_chrdev(capi_major, "capi20");
  1918. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1919. devfs_unregister_chrdev(capi_rawmajor, "capi/r%d");
  1920. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1921. devfs_unregister(devfs_find_handle(NULL, "capi20",
  1922.    capi_major, 0,
  1923.    DEVFS_SPECIAL_CHR, 0));
  1924. return -EIO;
  1925. }
  1927. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1928. if (capinc_tty_init() < 0) {
  1929. (void) detach_capi_interface(&cuser);
  1930. devfs_unregister_chrdev(capi_major, "capi20");
  1931. devfs_unregister_chrdev(capi_rawmajor, "capi/r%d");
  1932. MOD_DEC_USE_COUNT;
  1933. return -ENOMEM;
  1934. }
  1935. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1937. if (alloc_init() < 0) {
  1938. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1939. unsigned int j;
  1940. devfs_unregister_chrdev(capi_rawmajor, "capi/r%d");
  1941. for (j = 0; j < CAPINC_NR_PORTS; j++) {
  1942. char devname[32];
  1943. sprintf(devname, "capi/r%u", j);
  1944. devfs_unregister(devfs_find_handle(NULL, devname, capi_rawmajor, j, DEVFS_SPECIAL_CHR, 0));
  1945. }
  1946. capinc_tty_exit();
  1947. #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
  1948. (void) detach_capi_interface(&cuser);
  1949. devfs_unregister_chrdev(capi_major, "capi20");
  1950. devfs_unregister(devfs_find_handle(NULL, "capi20",
  1951.    capi_major, 0,
  1952.    DEVFS_SPECIAL_CHR, 0));
  1953. MOD_DEC_USE_COUNT;
  1954. return -ENOMEM;
  1955. }
  1957. (void)proc_init();
  1959. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1960. #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
  1961.         compileinfo = " (middleware+capifs)";
  1962. #else
  1963.         compileinfo = " (no capifs)";
  1964. #endif
  1965. #else
  1966.         compileinfo = " (no middleware)";
  1967. #endif
  1968. printk(KERN_NOTICE "capi20: Rev %s: started up with major %d%sn",
  1969. rev, capi_major, compileinfo);
  1971. MOD_DEC_USE_COUNT;
  1972. return 0;
  1973. }
  1975. static void __exit capi_exit(void)
  1976. {
  1977. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1978. unsigned int j;
  1979. #endif
  1980. alloc_exit();
  1981. (void)proc_exit();
  1983. devfs_unregister_chrdev(capi_major, "capi20");
  1984. devfs_unregister(devfs_find_handle(NULL, "isdn/capi20", capi_major, 0, DEVFS_SPECIAL_CHR, 0));
  1986. #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
  1987. capinc_tty_exit();
  1988. devfs_unregister_chrdev(capi_rawmajor, "capi/r%d");
  1989. for (j = 0; j < CAPINC_NR_PORTS; j++) {
  1990. char devname[32];
  1991. sprintf(devname, "capi/r%u", j);
  1992. devfs_unregister(devfs_find_handle(NULL, devname, capi_rawmajor, j, DEVFS_SPECIAL_CHR, 0));
  1993. }
  1994. #endif
  1995. (void) detach_capi_interface(&cuser);
  1996. printk(KERN_NOTICE "capi: Rev %s: unloadedn", rev);
  1997. }
  1999. module_init(capi_init);
  2000. module_exit(capi_exit);