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

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

Linux/Unix编程

开发平台：

Unix_Linux

isdn_common.c：源码内容
  1. /* $Id: isdn_common.c,v 1.1.4.1 2001/11/20 14:19:34 kai Exp $
  2.  *
  3.  * Linux ISDN subsystem, common used functions (linklevel).
  4.  *
  5.  * Copyright 1994-1999  by Fritz Elfert (fritz@isdn4linux.de)
  6.  * Copyright 1995,96    Thinking Objects Software GmbH Wuerzburg
  7.  * Copyright 1995,96    by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
  8.  *
  9.  * This software may be used and distributed according to the terms
  10.  * of the GNU General Public License, incorporated herein by reference.
  11.  *
  12.  */
  14. #include <linux/config.h>
  15. #include <linux/module.h>
  16. #include <linux/init.h>
  17. #include <linux/version.h>
  18. #include <linux/poll.h>
  19. #include <linux/vmalloc.h>
  20. #include <linux/isdn.h>
  21. #include <linux/smp_lock.h>
  22. #include "isdn_common.h"
  23. #include "isdn_tty.h"
  24. #include "isdn_net.h"
  25. #include "isdn_ppp.h"
  26. #ifdef CONFIG_ISDN_AUDIO
  27. #include "isdn_audio.h"
  28. #endif
  29. #ifdef CONFIG_ISDN_DIVERSION_MODULE
  30. #define CONFIG_ISDN_DIVERSION
  31. #endif
  32. #ifdef CONFIG_ISDN_DIVERSION
  33. #include <linux/isdn_divertif.h>
  34. #endif /* CONFIG_ISDN_DIVERSION */
  35. #include "isdn_v110.h"
  36. #include <linux/devfs_fs_kernel.h>
  38. /* Debugflags */
  39. #undef ISDN_DEBUG_STATCALLB
  41. MODULE_DESCRIPTION("ISDN4Linux: link layer");
  42. MODULE_AUTHOR("Fritz Elfert");
  43. MODULE_LICENSE("GPL");
  45. isdn_dev *dev;
  47. static char *isdn_revision = "$Revision: 1.1.4.1 $";
  49. extern char *isdn_net_revision;
  50. extern char *isdn_tty_revision;
  51. #ifdef CONFIG_ISDN_PPP
  52. extern char *isdn_ppp_revision;
  53. #else
  54. static char *isdn_ppp_revision = ": none $";
  55. #endif
  56. #ifdef CONFIG_ISDN_AUDIO
  57. extern char *isdn_audio_revision;
  58. #else
  59. static char *isdn_audio_revision = ": none $";
  60. #endif
  61. extern char *isdn_v110_revision;
  63. #ifdef CONFIG_ISDN_DIVERSION
  64. static isdn_divert_if *divert_if; /* = NULL */
  65. #endif /* CONFIG_ISDN_DIVERSION */
  68. static int isdn_writebuf_stub(int, int, const u_char *, int, int);
  69. static void set_global_features(void);
  70. static void isdn_register_devfs(int);
  71. static void isdn_unregister_devfs(int);
  72. static int isdn_wildmat(char *s, char *p);
  74. void
  75. isdn_lock_drivers(void)
  76. {
  77. int i;
  78. isdn_ctrl cmd;
  80. for (i = 0; i < ISDN_MAX_DRIVERS; i++) {
  81. if (!dev->drv[i])
  82. continue;
  84. cmd.driver = i;
  85. cmd.arg = 0;
  86. cmd.command = ISDN_CMD_LOCK;
  87. isdn_command(&cmd);
  88. dev->drv[i]->locks++;
  89. }
  90. }
  92. void
  93. isdn_MOD_INC_USE_COUNT(void)
  94. {
  95. MOD_INC_USE_COUNT;
  96. isdn_lock_drivers();
  97. }
  99. void
  100. isdn_unlock_drivers(void)
  101. {
  102. int i;
  104. for (i = 0; i < ISDN_MAX_DRIVERS; i++) {
  105. if (!dev->drv[i])
  106. continue;
  108. if (dev->drv[i]->locks > 0) {
  109. isdn_ctrl cmd;
  111. cmd.driver = i;
  112. cmd.arg = 0;
  113. cmd.command = ISDN_CMD_UNLOCK;
  114. isdn_command(&cmd);
  115. dev->drv[i]->locks--;
  116. }
  117. }
  118. }
  120. void
  121. isdn_MOD_DEC_USE_COUNT(void)
  122. {
  123. MOD_DEC_USE_COUNT;
  124. isdn_unlock_drivers();
  125. }
  127. #if defined(ISDN_DEBUG_NET_DUMP) || defined(ISDN_DEBUG_MODEM_DUMP)
  128. void
  129. isdn_dumppkt(char *s, u_char * p, int len, int dumplen)
  130. {
  131. int dumpc;
  133. printk(KERN_DEBUG "%s(%d) ", s, len);
  134. for (dumpc = 0; (dumpc < dumplen) && (len); len--, dumpc++)
  135. printk(" %02x", *p++);
  136. printk("n");
  137. }
  138. #endif
  140. /*
  141.  * I picked the pattern-matching-functions from an old GNU-tar version (1.10)
  142.  * It was originally written and put to PD by rs@mirror.TMC.COM (Rich Salz)
  143.  */
  144. static int
  145. isdn_star(char *s, char *p)
  146. {
  147. while (isdn_wildmat(s, p)) {
  148. if (*++s == '')
  149. return (2);
  150. }
  151. return (0);
  152. }
  154. /*
  155.  * Shell-type Pattern-matching for incoming caller-Ids
  156.  * This function gets a string in s and checks, if it matches the pattern
  157.  * given in p.
  158.  *
  159.  * Return:
  160.  *   0 = match.
  161.  *   1 = no match.
  162.  *   2 = no match. Would eventually match, if s would be longer.
  163.  *
  164.  * Possible Patterns:
  165.  *
  166.  * '?'     matches one character
  167.  * '*'     matches zero or more characters
  168.  * [xyz]   matches the set of characters in brackets.
  169.  * [^xyz]  matches any single character not in the set of characters
  170.  */
  172. static int
  173. isdn_wildmat(char *s, char *p)
  174. {
  175. register int last;
  176. register int matched;
  177. register int reverse;
  178. register int nostar = 1;
  180. if (!(*s) && !(*p))
  181. return(1);
  182. for (; *p; s++, p++)
  183. switch (*p) {
  184. case '\':
  185. /*
  186.  * Literal match with following character,
  187.  * fall through.
  188.  */
  189. p++;
  190. default:
  191. if (*s != *p)
  192. return (*s == '')?2:1;
  193. continue;
  194. case '?':
  195. /* Match anything. */
  196. if (*s == '')
  197. return (2);
  198. continue;
  199. case '*':
  200. nostar = 0;
  201. /* Trailing star matches everything. */
  202. return (*++p ? isdn_star(s, p) : 0);
  203. case '[':
  204. /* [^....] means inverse character class. */
  205. if ((reverse = (p[1] == '^')))
  206. p++;
  207. for (last = 0, matched = 0; *++p && (*p != ']'); last = *p)
  208. /* This next line requires a good C compiler. */
  209. if (*p == '-' ? *s <= *++p && *s >= last : *s == *p)
  210. matched = 1;
  211. if (matched == reverse)
  212. return (1);
  213. continue;
  214. }
  215. return (*s == '')?0:nostar;
  216. }
  218. int isdn_msncmp( const char * msn1, const char * msn2 )
  219. {
  220. char TmpMsn1[ ISDN_MSNLEN ];
  221. char TmpMsn2[ ISDN_MSNLEN ];
  222. char *p;
  224. for ( p = TmpMsn1; *msn1 && *msn1 != ':'; )  // Strip off a SPID
  225. *p++ = *msn1++;
  226. *p = '';
  228. for ( p = TmpMsn2; *msn2 && *msn2 != ':'; )  // Strip off a SPID
  229. *p++ = *msn2++;
  230. *p = '';
  232. return isdn_wildmat( TmpMsn1, TmpMsn2 );
  233. }
  235. int
  236. isdn_dc2minor(int di, int ch)
  237. {
  238. int i;
  239. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  240. if (dev->chanmap[i] == ch && dev->drvmap[i] == di)
  241. return i;
  242. return -1;
  243. }
  245. static int isdn_timer_cnt1 = 0;
  246. static int isdn_timer_cnt2 = 0;
  247. static int isdn_timer_cnt3 = 0;
  249. static void
  250. isdn_timer_funct(ulong dummy)
  251. {
  252. int tf = dev->tflags;
  253. if (tf & ISDN_TIMER_FAST) {
  254. if (tf & ISDN_TIMER_MODEMREAD)
  255. isdn_tty_readmodem();
  256. if (tf & ISDN_TIMER_MODEMPLUS)
  257. isdn_tty_modem_escape();
  258. if (tf & ISDN_TIMER_MODEMXMIT)
  259. isdn_tty_modem_xmit();
  260. }
  261. if (tf & ISDN_TIMER_SLOW) {
  262. if (++isdn_timer_cnt1 >= ISDN_TIMER_02SEC) {
  263. isdn_timer_cnt1 = 0;
  264. if (tf & ISDN_TIMER_NETDIAL)
  265. isdn_net_dial();
  266. }
  267. if (++isdn_timer_cnt2 >= ISDN_TIMER_1SEC) {
  268. isdn_timer_cnt2 = 0;
  269. if (tf & ISDN_TIMER_NETHANGUP)
  270. isdn_net_autohup();
  271. if (++isdn_timer_cnt3 >= ISDN_TIMER_RINGING) {
  272. isdn_timer_cnt3 = 0;
  273. if (tf & ISDN_TIMER_MODEMRING)
  274. isdn_tty_modem_ring();
  275. }
  276. if (tf & ISDN_TIMER_CARRIER)
  277. isdn_tty_carrier_timeout();
  278. }
  279. }
  280. if (tf) 
  281. {
  282. unsigned long flags;
  284. save_flags(flags);
  285. cli();
  286. mod_timer(&dev->timer, jiffies+ISDN_TIMER_RES);
  287. restore_flags(flags);
  288. }
  289. }
  291. void
  292. isdn_timer_ctrl(int tf, int onoff)
  293. {
  294. unsigned long flags;
  295. int old_tflags;
  297. save_flags(flags);
  298. cli();
  299. if ((tf & ISDN_TIMER_SLOW) && (!(dev->tflags & ISDN_TIMER_SLOW))) {
  300. /* If the slow-timer wasn't activated until now */
  301. isdn_timer_cnt1 = 0;
  302. isdn_timer_cnt2 = 0;
  303. }
  304. old_tflags = dev->tflags;
  305. if (onoff)
  306. dev->tflags |= tf;
  307. else
  308. dev->tflags &= ~tf;
  309. if (dev->tflags && !old_tflags)
  310. mod_timer(&dev->timer, jiffies+ISDN_TIMER_RES);
  311. restore_flags(flags);
  312. }
  314. /*
  315.  * Receive a packet from B-Channel. (Called from low-level-module)
  316.  */
  317. static void
  318. isdn_receive_skb_callback(int di, int channel, struct sk_buff *skb)
  319. {
  320. int i;
  322. if ((i = isdn_dc2minor(di, channel)) == -1) {
  323. dev_kfree_skb(skb);
  324. return;
  325. }
  326. /* Update statistics */
  327. dev->ibytes[i] += skb->len;
  329. /* First, try to deliver data to network-device */
  330. if (isdn_net_rcv_skb(i, skb))
  331. return;
  333. /* V.110 handling
  334.  * makes sense for async streams only, so it is
  335.  * called after possible net-device delivery.
  336.  */
  337. if (dev->v110[i]) {
  338. atomic_inc(&dev->v110use[i]);
  339. skb = isdn_v110_decode(dev->v110[i], skb);
  340. atomic_dec(&dev->v110use[i]);
  341. if (!skb)
  342. return;
  343. }
  345. /* No network-device found, deliver to tty or raw-channel */
  346. if (skb->len) {
  347. if (isdn_tty_rcv_skb(i, di, channel, skb))
  348. return;
  349. wake_up_interruptible(&dev->drv[di]->rcv_waitq[channel]);
  350. } else
  351. dev_kfree_skb(skb);
  352. }
  354. /*
  355.  * Intercept command from Linklevel to Lowlevel.
  356.  * If layer 2 protocol is V.110 and this is not supported by current
  357.  * lowlevel-driver, use driver's transparent mode and handle V.110 in
  358.  * linklevel instead.
  359.  */
  360. int
  361. isdn_command(isdn_ctrl *cmd)
  362. {
  363. if (cmd->driver == -1) {
  364. printk(KERN_WARNING "isdn_command command(%x) driver -1n", cmd->command);
  365. return(1);
  366. }
  367. if (cmd->command == ISDN_CMD_SETL2) {
  368. int idx = isdn_dc2minor(cmd->driver, cmd->arg & 255);
  369. unsigned long l2prot = (cmd->arg >> 8) & 255;
  370. unsigned long features = (dev->drv[cmd->driver]->interface->features
  371. >> ISDN_FEATURE_L2_SHIFT) &
  372. ISDN_FEATURE_L2_MASK;
  373. unsigned long l2_feature = (1 << l2prot);
  375. switch (l2prot) {
  376. case ISDN_PROTO_L2_V11096:
  377. case ISDN_PROTO_L2_V11019:
  378. case ISDN_PROTO_L2_V11038:
  379. /* If V.110 requested, but not supported by
  380.  * HL-driver, set emulator-flag and change
  381.  * Layer-2 to transparent
  382.  */
  383. if (!(features & l2_feature)) {
  384. dev->v110emu[idx] = l2prot;
  385. cmd->arg = (cmd->arg & 255) |
  386. (ISDN_PROTO_L2_TRANS << 8);
  387. } else
  388. dev->v110emu[idx] = 0;
  389. }
  390. }
  391. return dev->drv[cmd->driver]->interface->command(cmd);
  392. }
  394. void
  395. isdn_all_eaz(int di, int ch)
  396. {
  397. isdn_ctrl cmd;
  399. if (di < 0)
  400. return;
  401. cmd.driver = di;
  402. cmd.arg = ch;
  403. cmd.command = ISDN_CMD_SETEAZ;
  404. cmd.parm.num[0] = '';
  405. isdn_command(&cmd);
  406. }
  408. /*
  409.  * Begin of a CAPI like LL<->HL interface, currently used only for 
  410.  * supplementary service (CAPI 2.0 part III)
  411.  */
  412. #include "avmb1/capicmd.h"  /* this should be moved in a common place */
  414. int
  415. isdn_capi_rec_hl_msg(capi_msg *cm) {
  417. int di;
  418. int ch;
  420. di = (cm->adr.Controller & 0x7f) -1;
  421. ch = isdn_dc2minor(di, (cm->adr.Controller>>8)& 0x7f);
  422. switch(cm->Command) {
  423. case CAPI_FACILITY:
  424. /* in the moment only handled in tty */
  425. return(isdn_tty_capi_facility(cm));
  426. default:
  427. return(-1);
  428. }
  429. }
  431. static int
  432. isdn_status_callback(isdn_ctrl * c)
  433. {
  434. int di;
  435. ulong flags;
  436. int i;
  437. int r;
  438. int retval = 0;
  439. isdn_ctrl cmd;
  440. isdn_net_dev *p;
  442. di = c->driver;
  443. i = isdn_dc2minor(di, c->arg);
  444. switch (c->command) {
  445. case ISDN_STAT_BSENT:
  446. if (i < 0)
  447. return -1;
  448. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  449. return 0;
  450. if (isdn_net_stat_callback(i, c))
  451. return 0;
  452. if (isdn_v110_stat_callback(i, c))
  453. return 0;
  454. if (isdn_tty_stat_callback(i, c))
  455. return 0;
  456. wake_up_interruptible(&dev->drv[di]->snd_waitq[c->arg]);
  457. break;
  458. case ISDN_STAT_STAVAIL:
  459. save_flags(flags);
  460. cli();
  461. dev->drv[di]->stavail += c->arg;
  462. restore_flags(flags);
  463. wake_up_interruptible(&dev->drv[di]->st_waitq);
  464. break;
  465. case ISDN_STAT_RUN:
  466. dev->drv[di]->flags |= DRV_FLAG_RUNNING;
  467. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  468. if (dev->drvmap[i] == di)
  469. isdn_all_eaz(di, dev->chanmap[i]);
  470. set_global_features();
  471. break;
  472. case ISDN_STAT_STOP:
  473. dev->drv[di]->flags &= ~DRV_FLAG_RUNNING;
  474. break;
  475. case ISDN_STAT_ICALL:
  476. if (i < 0)
  477. return -1;
  478. #ifdef ISDN_DEBUG_STATCALLB
  479. printk(KERN_DEBUG "ICALL (net): %d %ld %sn", di, c->arg, c->parm.num);
  480. #endif
  481. if (dev->global_flags & ISDN_GLOBAL_STOPPED) {
  482. cmd.driver = di;
  483. cmd.arg = c->arg;
  484. cmd.command = ISDN_CMD_HANGUP;
  485. isdn_command(&cmd);
  486. return 0;
  487. }
  488. /* Try to find a network-interface which will accept incoming call */
  489. r = ((c->command == ISDN_STAT_ICALLW) ? 0 : isdn_net_find_icall(di, c->arg, i, &c->parm.setup));
  490. switch (r) {
  491. case 0:
  492. /* No network-device replies.
  493.  * Try ttyI's.
  494.  * These return 0 on no match, 1 on match and
  495.  * 3 on eventually match, if CID is longer.
  496.  */
  497.                                         if (c->command == ISDN_STAT_ICALL)
  498.   if ((retval = isdn_tty_find_icall(di, c->arg, &c->parm.setup))) return(retval);
  499. #ifdef CONFIG_ISDN_DIVERSION 
  500.                                          if (divert_if)
  501.                                     if ((retval = divert_if->stat_callback(c))) 
  502.     return(retval); /* processed */
  503. #endif /* CONFIG_ISDN_DIVERSION */                       
  504. if ((!retval) && (dev->drv[di]->flags & DRV_FLAG_REJBUS)) {
  505. /* No tty responding */
  506. cmd.driver = di;
  507. cmd.arg = c->arg;
  508. cmd.command = ISDN_CMD_HANGUP;
  509. isdn_command(&cmd);
  510. retval = 2;
  511. }
  512. break;
  513. case 1:
  514. /* Schedule connection-setup */
  515. isdn_net_dial();
  516. cmd.driver = di;
  517. cmd.arg = c->arg;
  518. cmd.command = ISDN_CMD_ACCEPTD;
  519. for ( p = dev->netdev; p; p = p->next )
  520. if ( p->local->isdn_channel == cmd.arg )
  521. {
  522. strcpy( cmd.parm.setup.eazmsn, p->local->msn );
  523. isdn_command(&cmd);
  524. retval = 1;
  525. break;
  526. }
  527. break;
  529. case 2: /* For calling back, first reject incoming call ... */
  530. case 3: /* Interface found, but down, reject call actively  */
  531. retval = 2;
  532. printk(KERN_INFO "isdn: Rejecting Calln");
  533. cmd.driver = di;
  534. cmd.arg = c->arg;
  535. cmd.command = ISDN_CMD_HANGUP;
  536. isdn_command(&cmd);
  537. if (r == 3)
  538. break;
  539. /* Fall through */
  540. case 4:
  541. /* ... then start callback. */
  542. isdn_net_dial();
  543. break;
  544. case 5:
  545. /* Number would eventually match, if longer */
  546. retval = 3;
  547. break;
  548. }
  549. #ifdef ISDN_DEBUG_STATCALLB
  550. printk(KERN_DEBUG "ICALL: ret=%dn", retval);
  551. #endif
  552. return retval;
  553. break;
  554. case ISDN_STAT_CINF:
  555. if (i < 0)
  556. return -1;
  557. #ifdef ISDN_DEBUG_STATCALLB
  558. printk(KERN_DEBUG "CINF: %ld %sn", c->arg, c->parm.num);
  559. #endif
  560. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  561. return 0;
  562. if (strcmp(c->parm.num, "0"))
  563. isdn_net_stat_callback(i, c);
  564. isdn_tty_stat_callback(i, c);
  565. break;
  566. case ISDN_STAT_CAUSE:
  567. #ifdef ISDN_DEBUG_STATCALLB
  568. printk(KERN_DEBUG "CAUSE: %ld %sn", c->arg, c->parm.num);
  569. #endif
  570. printk(KERN_INFO "isdn: %s,ch%ld cause: %sn",
  571.        dev->drvid[di], c->arg, c->parm.num);
  572. isdn_tty_stat_callback(i, c);
  573. #ifdef CONFIG_ISDN_DIVERSION
  574.                         if (divert_if)
  575.                          divert_if->stat_callback(c); 
  576. #endif /* CONFIG_ISDN_DIVERSION */
  577. break;
  578. case ISDN_STAT_DISPLAY:
  579. #ifdef ISDN_DEBUG_STATCALLB
  580. printk(KERN_DEBUG "DISPLAY: %ld %sn", c->arg, c->parm.display);
  581. #endif
  582. isdn_tty_stat_callback(i, c);
  583. #ifdef CONFIG_ISDN_DIVERSION
  584.                         if (divert_if)
  585.                          divert_if->stat_callback(c); 
  586. #endif /* CONFIG_ISDN_DIVERSION */
  587. break;
  588. case ISDN_STAT_DCONN:
  589. if (i < 0)
  590. return -1;
  591. #ifdef ISDN_DEBUG_STATCALLB
  592. printk(KERN_DEBUG "DCONN: %ldn", c->arg);
  593. #endif
  594. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  595. return 0;
  596. /* Find any net-device, waiting for D-channel setup */
  597. if (isdn_net_stat_callback(i, c))
  598. break;
  599. isdn_v110_stat_callback(i, c);
  600. /* Find any ttyI, waiting for D-channel setup */
  601. if (isdn_tty_stat_callback(i, c)) {
  602. cmd.driver = di;
  603. cmd.arg = c->arg;
  604. cmd.command = ISDN_CMD_ACCEPTB;
  605. isdn_command(&cmd);
  606. break;
  607. }
  608. break;
  609. case ISDN_STAT_DHUP:
  610. if (i < 0)
  611. return -1;
  612. #ifdef ISDN_DEBUG_STATCALLB
  613. printk(KERN_DEBUG "DHUP: %ldn", c->arg);
  614. #endif
  615. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  616. return 0;
  617. dev->drv[di]->online &= ~(1 << (c->arg));
  618. isdn_info_update();
  619. /* Signal hangup to network-devices */
  620. if (isdn_net_stat_callback(i, c))
  621. break;
  622. isdn_v110_stat_callback(i, c);
  623. if (isdn_tty_stat_callback(i, c))
  624. break;
  625. #ifdef CONFIG_ISDN_DIVERSION
  626.                         if (divert_if)
  627.                          divert_if->stat_callback(c); 
  628. #endif /* CONFIG_ISDN_DIVERSION */
  629. break;
  630. break;
  631. case ISDN_STAT_BCONN:
  632. if (i < 0)
  633. return -1;
  634. #ifdef ISDN_DEBUG_STATCALLB
  635. printk(KERN_DEBUG "BCONN: %ldn", c->arg);
  636. #endif
  637. /* Signal B-channel-connect to network-devices */
  638. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  639. return 0;
  640. dev->drv[di]->online |= (1 << (c->arg));
  641. isdn_info_update();
  642. if (isdn_net_stat_callback(i, c))
  643. break;
  644. isdn_v110_stat_callback(i, c);
  645. if (isdn_tty_stat_callback(i, c))
  646. break;
  647. break;
  648. case ISDN_STAT_BHUP:
  649. if (i < 0)
  650. return -1;
  651. #ifdef ISDN_DEBUG_STATCALLB
  652. printk(KERN_DEBUG "BHUP: %ldn", c->arg);
  653. #endif
  654. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  655. return 0;
  656. dev->drv[di]->online &= ~(1 << (c->arg));
  657. isdn_info_update();
  658. #ifdef CONFIG_ISDN_X25
  659. /* Signal hangup to network-devices */
  660. if (isdn_net_stat_callback(i, c))
  661. break;
  662. #endif
  663. isdn_v110_stat_callback(i, c);
  664. if (isdn_tty_stat_callback(i, c))
  665. break;
  666. break;
  667. case ISDN_STAT_NODCH:
  668. if (i < 0)
  669. return -1;
  670. #ifdef ISDN_DEBUG_STATCALLB
  671. printk(KERN_DEBUG "NODCH: %ldn", c->arg);
  672. #endif
  673. if (dev->global_flags & ISDN_GLOBAL_STOPPED)
  674. return 0;
  675. if (isdn_net_stat_callback(i, c))
  676. break;
  677. if (isdn_tty_stat_callback(i, c))
  678. break;
  679. break;
  680. case ISDN_STAT_ADDCH:
  681. if (isdn_add_channels(dev->drv[di], di, c->arg, 1))
  682. return -1;
  683. isdn_info_update();
  684. break;
  685. case ISDN_STAT_DISCH:
  686. save_flags(flags);
  687. cli();
  688. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  689. if ((dev->drvmap[i] == di) &&
  690.     (dev->chanmap[i] == c->arg)) {
  691.     if (c->parm.num[0])
  692.       dev->usage[i] &= ~ISDN_USAGE_DISABLED;
  693.     else
  694.       if (USG_NONE(dev->usage[i])) {
  695. dev->usage[i] |= ISDN_USAGE_DISABLED;
  696.       }
  697.       else 
  698. retval = -1;
  699.     break;
  700. }
  701. restore_flags(flags);
  702. isdn_info_update();
  703. break;
  704. case ISDN_STAT_UNLOAD:
  705. while (dev->drv[di]->locks > 0) {
  706. isdn_ctrl cmd;
  707. cmd.driver = di;
  708. cmd.arg = 0;
  709. cmd.command = ISDN_CMD_UNLOCK;
  710. isdn_command(&cmd);
  711. dev->drv[di]->locks--;
  712. }
  713. save_flags(flags);
  714. cli();
  715. isdn_tty_stat_callback(i, c);
  716. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  717. if (dev->drvmap[i] == di) {
  718. dev->drvmap[i] = -1;
  719. dev->chanmap[i] = -1;
  720. dev->usage[i] &= ~ISDN_USAGE_DISABLED;
  721. isdn_unregister_devfs(i);
  722. }
  723. dev->drivers--;
  724. dev->channels -= dev->drv[di]->channels;
  725. kfree(dev->drv[di]->rcverr);
  726. kfree(dev->drv[di]->rcvcount);
  727. for (i = 0; i < dev->drv[di]->channels; i++)
  728. skb_queue_purge(&dev->drv[di]->rpqueue[i]);
  729. kfree(dev->drv[di]->rpqueue);
  730. kfree(dev->drv[di]->rcv_waitq);
  731. kfree(dev->drv[di]);
  732. dev->drv[di] = NULL;
  733. dev->drvid[di][0] = '';
  734. isdn_info_update();
  735. set_global_features();
  736. restore_flags(flags);
  737. return 0;
  738. case ISDN_STAT_L1ERR:
  739. break;
  740. case CAPI_PUT_MESSAGE:
  741. return(isdn_capi_rec_hl_msg(&c->parm.cmsg));
  742. #ifdef CONFIG_ISDN_TTY_FAX
  743. case ISDN_STAT_FAXIND:
  744. isdn_tty_stat_callback(i, c);
  745. break;
  746. #endif
  747. #ifdef CONFIG_ISDN_AUDIO
  748. case ISDN_STAT_AUDIO:
  749. isdn_tty_stat_callback(i, c);
  750. break;
  751. #endif
  752. #ifdef CONFIG_ISDN_DIVERSION
  753.         case ISDN_STAT_PROT:
  754.         case ISDN_STAT_REDIR:
  755.                         if (divert_if)
  756.                           return(divert_if->stat_callback(c));
  757. #endif /* CONFIG_ISDN_DIVERSION */
  758. default:
  759. return -1;
  760. }
  761. return 0;
  762. }
  764. /*
  765.  * Get integer from char-pointer, set pointer to end of number
  766.  */
  767. int
  768. isdn_getnum(char **p)
  769. {
  770. int v = -1;
  772. while (*p[0] >= '0' && *p[0] <= '9')
  773. v = ((v < 0) ? 0 : (v * 10)) + (int) ((*p[0]++) - '0');
  774. return v;
  775. }
  777. #define DLE 0x10
  779. /*
  780.  * isdn_readbchan() tries to get data from the read-queue.
  781.  * It MUST be called with interrupts off.
  782.  *
  783.  * Be aware that this is not an atomic operation when sleep != 0, even though 
  784.  * interrupts are turned off! Well, like that we are currently only called
  785.  * on behalf of a read system call on raw device files (which are documented
  786.  * to be dangerous and for for debugging purpose only). The inode semaphore
  787.  * takes care that this is not called for the same minor device number while
  788.  * we are sleeping, but access is not serialized against simultaneous read()
  789.  * from the corresponding ttyI device. Can other ugly events, like changes
  790.  * of the mapping (di,ch)<->minor, happen during the sleep? --he 
  791.  */
  792. int
  793. isdn_readbchan(int di, int channel, u_char * buf, u_char * fp, int len, wait_queue_head_t *sleep)
  794. {
  795. int count;
  796. int count_pull;
  797. int count_put;
  798. int dflag;
  799. struct sk_buff *skb;
  800. u_char *cp;
  802. if (!dev->drv[di])
  803. return 0;
  804. if (skb_queue_empty(&dev->drv[di]->rpqueue[channel])) {
  805. if (sleep)
  806. interruptible_sleep_on(sleep);
  807. else
  808. return 0;
  809. }
  810. if (len > dev->drv[di]->rcvcount[channel])
  811. len = dev->drv[di]->rcvcount[channel];
  812. cp = buf;
  813. count = 0;
  814. while (len) {
  815. if (!(skb = skb_peek(&dev->drv[di]->rpqueue[channel])))
  816. break;
  817. #ifdef CONFIG_ISDN_AUDIO
  818. if (ISDN_AUDIO_SKB_LOCK(skb))
  819. break;
  820. ISDN_AUDIO_SKB_LOCK(skb) = 1;
  821. if ((ISDN_AUDIO_SKB_DLECOUNT(skb)) || (dev->drv[di]->DLEflag & (1 << channel))) {
  822. char *p = skb->data;
  823. unsigned long DLEmask = (1 << channel);
  825. dflag = 0;
  826. count_pull = count_put = 0;
  827. while ((count_pull < skb->len) && (len > 0)) {
  828. len--;
  829. if (dev->drv[di]->DLEflag & DLEmask) {
  830. *cp++ = DLE;
  831. dev->drv[di]->DLEflag &= ~DLEmask;
  832. } else {
  833. *cp++ = *p;
  834. if (*p == DLE) {
  835. dev->drv[di]->DLEflag |= DLEmask;
  836. (ISDN_AUDIO_SKB_DLECOUNT(skb))--;
  837. }
  838. p++;
  839. count_pull++;
  840. }
  841. count_put++;
  842. }
  843. if (count_pull >= skb->len)
  844. dflag = 1;
  845. } else {
  846. #endif
  847. /* No DLE's in buff, so simply copy it */
  848. dflag = 1;
  849. if ((count_pull = skb->len) > len) {
  850. count_pull = len;
  851. dflag = 0;
  852. }
  853. count_put = count_pull;
  854. memcpy(cp, skb->data, count_put);
  855. cp += count_put;
  856. len -= count_put;
  857. #ifdef CONFIG_ISDN_AUDIO
  858. }
  859. #endif
  860. count += count_put;
  861. if (fp) {
  862. memset(fp, 0, count_put);
  863. fp += count_put;
  864. }
  865. if (dflag) {
  866. /* We got all the data in this buff.
  867.  * Now we can dequeue it.
  868.  */
  869. if (fp)
  870. *(fp - 1) = 0xff;
  871. #ifdef CONFIG_ISDN_AUDIO
  872. ISDN_AUDIO_SKB_LOCK(skb) = 0;
  873. #endif
  874. skb = skb_dequeue(&dev->drv[di]->rpqueue[channel]);
  875. dev_kfree_skb(skb);
  876. } else {
  877. /* Not yet emptied this buff, so it
  878.  * must stay in the queue, for further calls
  879.  * but we pull off the data we got until now.
  880.  */
  881. skb_pull(skb, count_pull);
  882. #ifdef CONFIG_ISDN_AUDIO
  883. ISDN_AUDIO_SKB_LOCK(skb) = 0;
  884. #endif
  885. }
  886. dev->drv[di]->rcvcount[channel] -= count_put;
  887. }
  888. return count;
  889. }
  891. static __inline int
  892. isdn_minor2drv(int minor)
  893. {
  894. return (dev->drvmap[minor]);
  895. }
  897. static __inline int
  898. isdn_minor2chan(int minor)
  899. {
  900. return (dev->chanmap[minor]);
  901. }
  903. static char *
  904. isdn_statstr(void)
  905. {
  906. static char istatbuf[2048];
  907. char *p;
  908. int i;
  910. sprintf(istatbuf, "idmap:t");
  911. p = istatbuf + strlen(istatbuf);
  912. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  913. sprintf(p, "%s ", (dev->drvmap[i] < 0) ? "-" : dev->drvid[dev->drvmap[i]]);
  914. p = istatbuf + strlen(istatbuf);
  915. }
  916. sprintf(p, "nchmap:t");
  917. p = istatbuf + strlen(istatbuf);
  918. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  919. sprintf(p, "%d ", dev->chanmap[i]);
  920. p = istatbuf + strlen(istatbuf);
  921. }
  922. sprintf(p, "ndrmap:t");
  923. p = istatbuf + strlen(istatbuf);
  924. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  925. sprintf(p, "%d ", dev->drvmap[i]);
  926. p = istatbuf + strlen(istatbuf);
  927. }
  928. sprintf(p, "nusage:t");
  929. p = istatbuf + strlen(istatbuf);
  930. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  931. sprintf(p, "%d ", dev->usage[i]);
  932. p = istatbuf + strlen(istatbuf);
  933. }
  934. sprintf(p, "nflags:t");
  935. p = istatbuf + strlen(istatbuf);
  936. for (i = 0; i < ISDN_MAX_DRIVERS; i++) {
  937. if (dev->drv[i]) {
  938. sprintf(p, "%ld ", dev->drv[i]->online);
  939. p = istatbuf + strlen(istatbuf);
  940. } else {
  941. sprintf(p, "? ");
  942. p = istatbuf + strlen(istatbuf);
  943. }
  944. }
  945. sprintf(p, "nphone:t");
  946. p = istatbuf + strlen(istatbuf);
  947. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  948. sprintf(p, "%s ", dev->num[i]);
  949. p = istatbuf + strlen(istatbuf);
  950. }
  951. sprintf(p, "n");
  952. return istatbuf;
  953. }
  955. /* Module interface-code */
  957. void
  958. isdn_info_update(void)
  959. {
  960. infostruct *p = dev->infochain;
  962. while (p) {
  963. *(p->private) = 1;
  964. p = (infostruct *) p->next;
  965. }
  966. wake_up_interruptible(&(dev->info_waitq));
  967. }
  969. static ssize_t
  970. isdn_read(struct file *file, char *buf, size_t count, loff_t * off)
  971. {
  972. uint minor = MINOR(file->f_dentry->d_inode->i_rdev);
  973. int len = 0;
  974. ulong flags;
  975. int drvidx;
  976. int chidx;
  977. int retval;
  978. char *p;
  980. if (off != &file->f_pos)
  981. return -ESPIPE;
  983. lock_kernel();
  984. if (minor == ISDN_MINOR_STATUS) {
  985. if (!file->private_data) {
  986. if (file->f_flags & O_NONBLOCK) {
  987. retval = -EAGAIN;
  988. goto out;
  989. }
  990. interruptible_sleep_on(&(dev->info_waitq));
  991. }
  992. p = isdn_statstr();
  993. file->private_data = 0;
  994. if ((len = strlen(p)) <= count) {
  995. if (copy_to_user(buf, p, len)) {
  996. retval = -EFAULT;
  997. goto out;
  998. }
  999. *off += len;
  1000. retval = len;
  1001. goto out;
  1002. }
  1003. retval = 0;
  1004. goto out;
  1005. }
  1006. if (!dev->drivers) {
  1007. retval = -ENODEV;
  1008. goto out;
  1009. }
  1010. if (minor <= ISDN_MINOR_BMAX) {
  1011. printk(KERN_WARNING "isdn_read minor %d obsolete!n", minor);
  1012. drvidx = isdn_minor2drv(minor);
  1013. if (drvidx < 0) {
  1014. retval = -ENODEV;
  1015. goto out;
  1016. }
  1017. if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) {
  1018. retval = -ENODEV;
  1019. goto out;
  1020. }
  1021. chidx = isdn_minor2chan(minor);
  1022. if (!(p = kmalloc(count, GFP_KERNEL))) {
  1023. retval = -ENOMEM;
  1024. goto out;
  1025. }
  1026. save_flags(flags);
  1027. cli();
  1028. len = isdn_readbchan(drvidx, chidx, p, 0, count,
  1029.      &dev->drv[drvidx]->rcv_waitq[chidx]);
  1030. *off += len;
  1031. restore_flags(flags);
  1032. if (copy_to_user(buf,p,len)) 
  1033. len = -EFAULT;
  1034. kfree(p);
  1035. retval = len;
  1036. goto out;
  1037. }
  1038. if (minor <= ISDN_MINOR_CTRLMAX) {
  1039. drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
  1040. if (drvidx < 0) {
  1041. retval = -ENODEV;
  1042. goto out;
  1043. }
  1044. if (!dev->drv[drvidx]->stavail) {
  1045. if (file->f_flags & O_NONBLOCK) {
  1046. retval = -EAGAIN;
  1047. goto out;
  1048. }
  1049. interruptible_sleep_on(&(dev->drv[drvidx]->st_waitq));
  1050. }
  1051. if (dev->drv[drvidx]->interface->readstat) {
  1052. if (count > dev->drv[drvidx]->stavail)
  1053. count = dev->drv[drvidx]->stavail;
  1054. len = dev->drv[drvidx]->interface->
  1055. readstat(buf, count, 1, drvidx,
  1056.  isdn_minor2chan(minor));
  1057. } else {
  1058. len = 0;
  1059. }
  1060. save_flags(flags);
  1061. cli();
  1062. if (len)
  1063. dev->drv[drvidx]->stavail -= len;
  1064. else
  1065. dev->drv[drvidx]->stavail = 0;
  1066. restore_flags(flags);
  1067. *off += len;
  1068. retval = len;
  1069. goto out;
  1070. }
  1071. #ifdef CONFIG_ISDN_PPP
  1072. if (minor <= ISDN_MINOR_PPPMAX) {
  1073. retval = isdn_ppp_read(minor - ISDN_MINOR_PPP, file, buf, count);
  1074. goto out;
  1075. }
  1076. #endif
  1077. retval = -ENODEV;
  1078.  out:
  1079. unlock_kernel();
  1080. return retval;
  1081. }
  1083. static ssize_t
  1084. isdn_write(struct file *file, const char *buf, size_t count, loff_t * off)
  1085. {
  1086. uint minor = MINOR(file->f_dentry->d_inode->i_rdev);
  1087. int drvidx;
  1088. int chidx;
  1089. int retval;
  1091. if (off != &file->f_pos)
  1092. return -ESPIPE;
  1094. if (minor == ISDN_MINOR_STATUS)
  1095. return -EPERM;
  1096. if (!dev->drivers)
  1097. return -ENODEV;
  1099. lock_kernel();
  1100. if (minor <= ISDN_MINOR_BMAX) {
  1101. printk(KERN_WARNING "isdn_write minor %d obsolete!n", minor);
  1102. drvidx = isdn_minor2drv(minor);
  1103. if (drvidx < 0) {
  1104. retval = -ENODEV;
  1105. goto out;
  1106. }
  1107. if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) {
  1108. retval = -ENODEV;
  1109. goto out;
  1110. }
  1111. chidx = isdn_minor2chan(minor);
  1112. while (isdn_writebuf_stub(drvidx, chidx, buf, count, 1) != count)
  1113. interruptible_sleep_on(&dev->drv[drvidx]->snd_waitq[chidx]);
  1114. retval = count;
  1115. goto out;
  1116. }
  1117. if (minor <= ISDN_MINOR_CTRLMAX) {
  1118. drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
  1119. if (drvidx < 0) {
  1120. retval = -ENODEV;
  1121. goto out;
  1122. }
  1123. /*
  1124.  * We want to use the isdnctrl device to load the firmware
  1125.  *
  1126.  if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING))
  1127.  return -ENODEV;
  1128.  */
  1129. if (dev->drv[drvidx]->interface->writecmd)
  1130. retval = dev->drv[drvidx]->interface->
  1131. writecmd(buf, count, 1, drvidx, isdn_minor2chan(minor));
  1132. else
  1133. retval = count;
  1134. goto out;
  1135. }
  1136. #ifdef CONFIG_ISDN_PPP
  1137. if (minor <= ISDN_MINOR_PPPMAX) {
  1138. retval = isdn_ppp_write(minor - ISDN_MINOR_PPP, file, buf, count);
  1139. goto out;
  1140. }
  1141. #endif
  1142. retval = -ENODEV;
  1143.  out:
  1144. unlock_kernel();
  1145. return retval;
  1146. }
  1148. static unsigned int
  1149. isdn_poll(struct file *file, poll_table * wait)
  1150. {
  1151. unsigned int mask = 0;
  1152. unsigned int minor = MINOR(file->f_dentry->d_inode->i_rdev);
  1153. int drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
  1155. lock_kernel();
  1156. if (minor == ISDN_MINOR_STATUS) {
  1157. poll_wait(file, &(dev->info_waitq), wait);
  1158. /* mask = POLLOUT | POLLWRNORM; */
  1159. if (file->private_data) {
  1160. mask |= POLLIN | POLLRDNORM;
  1161. }
  1162. goto out;
  1163. }
  1164. if (minor >= ISDN_MINOR_CTRL && minor <= ISDN_MINOR_CTRLMAX) {
  1165. if (drvidx < 0) {
  1166. /* driver deregistered while file open */
  1167. mask = POLLHUP;
  1168. goto out;
  1169. }
  1170. poll_wait(file, &(dev->drv[drvidx]->st_waitq), wait);
  1171. mask = POLLOUT | POLLWRNORM;
  1172. if (dev->drv[drvidx]->stavail) {
  1173. mask |= POLLIN | POLLRDNORM;
  1174. }
  1175. goto out;
  1176. }
  1177. #ifdef CONFIG_ISDN_PPP
  1178. if (minor <= ISDN_MINOR_PPPMAX) {
  1179. mask = isdn_ppp_poll(file, wait);
  1180. goto out;
  1181. }
  1182. #endif
  1183. mask = POLLERR;
  1184.  out:
  1185. unlock_kernel();
  1186. return mask;
  1187. }
  1190. static int
  1191. isdn_ioctl(struct inode *inode, struct file *file, uint cmd, ulong arg)
  1192. {
  1193. uint minor = MINOR(inode->i_rdev);
  1194. isdn_ctrl c;
  1195. int drvidx;
  1196. int chidx;
  1197. int ret;
  1198. int i;
  1199. char *p;
  1200. char *s;
  1201. union iocpar {
  1202. char name[10];
  1203. char bname[22];
  1204. isdn_ioctl_struct iocts;
  1205. isdn_net_ioctl_phone phone;
  1206. isdn_net_ioctl_cfg cfg;
  1207. } iocpar;
  1209. #define name  iocpar.name
  1210. #define bname iocpar.bname
  1211. #define iocts iocpar.iocts
  1212. #define phone iocpar.phone
  1213. #define cfg   iocpar.cfg
  1215. if (minor == ISDN_MINOR_STATUS) {
  1216. switch (cmd) {
  1217. case IIOCGETDVR:
  1218. return (TTY_DV +
  1219. (NET_DV << 8) +
  1220. (INF_DV << 16));
  1221. case IIOCGETCPS:
  1222. if (arg) {
  1223. ulong *p = (ulong *) arg;
  1224. int i;
  1225. if ((ret = verify_area(VERIFY_WRITE, (void *) arg,
  1226.        sizeof(ulong) * ISDN_MAX_CHANNELS * 2)))
  1227. return ret;
  1228. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  1229. put_user(dev->ibytes[i], p++);
  1230. put_user(dev->obytes[i], p++);
  1231. }
  1232. return 0;
  1233. } else
  1234. return -EINVAL;
  1235. break;
  1236. #ifdef CONFIG_NETDEVICES
  1237. case IIOCNETGPN:
  1238. /* Get peer phone number of a connected 
  1239.  * isdn network interface */
  1240. if (arg) {
  1241. if (copy_from_user((char *) &phone, (char *) arg, sizeof(phone)))
  1242. return -EFAULT;
  1243. return isdn_net_getpeer(&phone, (isdn_net_ioctl_phone *) arg);
  1244. } else
  1245. return -EINVAL;
  1246. #endif
  1247. default:
  1248. return -EINVAL;
  1249. }
  1250. }
  1251. if (!dev->drivers)
  1252. return -ENODEV;
  1253. if (minor <= ISDN_MINOR_BMAX) {
  1254. drvidx = isdn_minor2drv(minor);
  1255. if (drvidx < 0)
  1256. return -ENODEV;
  1257. chidx = isdn_minor2chan(minor);
  1258. if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING))
  1259. return -ENODEV;
  1260. return 0;
  1261. }
  1262. if (minor <= ISDN_MINOR_CTRLMAX) {
  1263. /*
  1264.  * isdn net devices manage lots of configuration variables as linked lists.
  1265.  * Those lists must only be manipulated from user space. Some of the ioctl's
  1266.  * service routines access user space and are not atomic. Therefor, ioctl's
  1267.  * manipulating the lists and ioctl's sleeping while accessing the lists
  1268.  * are serialized by means of a semaphore.
  1269.  */
  1270. switch (cmd) {
  1271. case IIOCNETDWRSET:
  1272. printk(KERN_INFO "INFO: ISDN_DW_ABC_EXTENSION not enabledn");
  1273. return(-EINVAL);
  1274. case IIOCNETLCR:
  1275. printk(KERN_INFO "INFO: ISDN_ABC_LCR_SUPPORT not enabledn");
  1276. return -ENODEV;
  1277. #ifdef CONFIG_NETDEVICES
  1278. case IIOCNETAIF:
  1279. /* Add a network-interface */
  1280. if (arg) {
  1281. if (copy_from_user(name, (char *) arg, sizeof(name)))
  1282. return -EFAULT;
  1283. s = name;
  1284. } else {
  1285. s = NULL;
  1286. }
  1287. ret = down_interruptible(&dev->sem);
  1288. if( ret ) return ret;
  1289. if ((s = isdn_net_new(s, NULL))) {
  1290. if (copy_to_user((char *) arg, s, strlen(s) + 1)){
  1291. ret = -EFAULT;
  1292. } else {
  1293. ret = 0;
  1294. }
  1295. } else
  1296. ret = -ENODEV;
  1297. up(&dev->sem);
  1298. return ret;
  1299. case IIOCNETASL:
  1300. /* Add a slave to a network-interface */
  1301. if (arg) {
  1302. if (copy_from_user(bname, (char *) arg, sizeof(bname) - 1))
  1303. return -EFAULT;
  1304. } else
  1305. return -EINVAL;
  1306. ret = down_interruptible(&dev->sem);
  1307. if( ret ) return ret;
  1308. if ((s = isdn_net_newslave(bname))) {
  1309. if (copy_to_user((char *) arg, s, strlen(s) + 1)){
  1310. ret = -EFAULT;
  1311. } else {
  1312. ret = 0;
  1313. }
  1314. } else
  1315. ret = -ENODEV;
  1316. up(&dev->sem);
  1317. return ret;
  1318. case IIOCNETDIF:
  1319. /* Delete a network-interface */
  1320. if (arg) {
  1321. if (copy_from_user(name, (char *) arg, sizeof(name)))
  1322. return -EFAULT;
  1323. ret = down_interruptible(&dev->sem);
  1324. if( ret ) return ret;
  1325. ret = isdn_net_rm(name);
  1326. up(&dev->sem);
  1327. return ret;
  1328. } else
  1329. return -EINVAL;
  1330. case IIOCNETSCF:
  1331. /* Set configurable parameters of a network-interface */
  1332. if (arg) {
  1333. if (copy_from_user((char *) &cfg, (char *) arg, sizeof(cfg)))
  1334. return -EFAULT;
  1335. return isdn_net_setcfg(&cfg);
  1336. } else
  1337. return -EINVAL;
  1338. case IIOCNETGCF:
  1339. /* Get configurable parameters of a network-interface */
  1340. if (arg) {
  1341. if (copy_from_user((char *) &cfg, (char *) arg, sizeof(cfg)))
  1342. return -EFAULT;
  1343. if (!(ret = isdn_net_getcfg(&cfg))) {
  1344. if (copy_to_user((char *) arg, (char *) &cfg, sizeof(cfg)))
  1345. return -EFAULT;
  1346. }
  1347. return ret;
  1348. } else
  1349. return -EINVAL;
  1350. case IIOCNETANM:
  1351. /* Add a phone-number to a network-interface */
  1352. if (arg) {
  1353. if (copy_from_user((char *) &phone, (char *) arg, sizeof(phone)))
  1354. return -EFAULT;
  1355. ret = down_interruptible(&dev->sem);
  1356. if( ret ) return ret;
  1357. ret = isdn_net_addphone(&phone);
  1358. up(&dev->sem);
  1359. return ret;
  1360. } else
  1361. return -EINVAL;
  1362. case IIOCNETGNM:
  1363. /* Get list of phone-numbers of a network-interface */
  1364. if (arg) {
  1365. if (copy_from_user((char *) &phone, (char *) arg, sizeof(phone)))
  1366. return -EFAULT;
  1367. ret = down_interruptible(&dev->sem);
  1368. if( ret ) return ret;
  1369. ret = isdn_net_getphones(&phone, (char *) arg);
  1370. up(&dev->sem);
  1371. return ret;
  1372. } else
  1373. return -EINVAL;
  1374. case IIOCNETDNM:
  1375. /* Delete a phone-number of a network-interface */
  1376. if (arg) {
  1377. if (copy_from_user((char *) &phone, (char *) arg, sizeof(phone)))
  1378. return -EFAULT;
  1379. ret = down_interruptible(&dev->sem);
  1380. if( ret ) return ret;
  1381. ret = isdn_net_delphone(&phone);
  1382. up(&dev->sem);
  1383. return ret;
  1384. } else
  1385. return -EINVAL;
  1386. case IIOCNETDIL:
  1387. /* Force dialing of a network-interface */
  1388. if (arg) {
  1389. if (copy_from_user(name, (char *) arg, sizeof(name)))
  1390. return -EFAULT;
  1391. return isdn_net_force_dial(name);
  1392. } else
  1393. return -EINVAL;
  1394. #ifdef CONFIG_ISDN_PPP
  1395. case IIOCNETALN:
  1396. if (!arg)
  1397. return -EINVAL;
  1398. if (copy_from_user(name, (char *) arg, sizeof(name)))
  1399. return -EFAULT;
  1400. return isdn_ppp_dial_slave(name);
  1401. case IIOCNETDLN:
  1402. if (!arg)
  1403. return -EINVAL;
  1404. if (copy_from_user(name, (char *) arg, sizeof(name)))
  1405. return -EFAULT;
  1406. return isdn_ppp_hangup_slave(name);
  1407. #endif
  1408. case IIOCNETHUP:
  1409. /* Force hangup of a network-interface */
  1410. if (!arg)
  1411. return -EINVAL;
  1412. if (copy_from_user(name, (char *) arg, sizeof(name)))
  1413. return -EFAULT;
  1414. return isdn_net_force_hangup(name);
  1415. break;
  1416. #endif                          /* CONFIG_NETDEVICES */
  1417. case IIOCSETVER:
  1418. dev->net_verbose = arg;
  1419. printk(KERN_INFO "isdn: Verbose-Level is %dn", dev->net_verbose);
  1420. return 0;
  1421. case IIOCSETGST:
  1422. if (arg)
  1423. dev->global_flags |= ISDN_GLOBAL_STOPPED;
  1424. else
  1425. dev->global_flags &= ~ISDN_GLOBAL_STOPPED;
  1426. printk(KERN_INFO "isdn: Global Mode %sn",
  1427.        (dev->global_flags & ISDN_GLOBAL_STOPPED) ? "stopped" : "running");
  1428. return 0;
  1429. case IIOCSETBRJ:
  1430. drvidx = -1;
  1431. if (arg) {
  1432. int i;
  1433. char *p;
  1434. if (copy_from_user((char *) &iocts, (char *) arg,
  1435.      sizeof(isdn_ioctl_struct)))
  1436. return -EFAULT;
  1437. if (strlen(iocts.drvid)) {
  1438. if ((p = strchr(iocts.drvid, ',')))
  1439. *p = 0;
  1440. drvidx = -1;
  1441. for (i = 0; i < ISDN_MAX_DRIVERS; i++)
  1442. if (!(strcmp(dev->drvid[i], iocts.drvid))) {
  1443. drvidx = i;
  1444. break;
  1445. }
  1446. }
  1447. }
  1448. if (drvidx == -1)
  1449. return -ENODEV;
  1450. if (iocts.arg)
  1451. dev->drv[drvidx]->flags |= DRV_FLAG_REJBUS;
  1452. else
  1453. dev->drv[drvidx]->flags &= ~DRV_FLAG_REJBUS;
  1454. return 0;
  1455. case IIOCSIGPRF:
  1456. dev->profd = current;
  1457. return 0;
  1458. break;
  1459. case IIOCGETPRF:
  1460. /* Get all Modem-Profiles */
  1461. if (arg) {
  1462. char *p = (char *) arg;
  1463. int i;
  1465. if ((ret = verify_area(VERIFY_WRITE, (void *) arg,
  1466. (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN)
  1467.    * ISDN_MAX_CHANNELS)))
  1468. return ret;
  1470. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  1471. if (copy_to_user(p, dev->mdm.info[i].emu.profile,
  1472.       ISDN_MODEM_NUMREG))
  1473. return -EFAULT;
  1474. p += ISDN_MODEM_NUMREG;
  1475. if (copy_to_user(p, dev->mdm.info[i].emu.pmsn, ISDN_MSNLEN))
  1476. return -EFAULT;
  1477. p += ISDN_MSNLEN;
  1478. if (copy_to_user(p, dev->mdm.info[i].emu.plmsn, ISDN_LMSNLEN))
  1479. return -EFAULT;
  1480. p += ISDN_LMSNLEN;
  1481. }
  1482. return (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN) * ISDN_MAX_CHANNELS;
  1483. } else
  1484. return -EINVAL;
  1485. break;
  1486. case IIOCSETPRF:
  1487. /* Set all Modem-Profiles */
  1488. if (arg) {
  1489. char *p = (char *) arg;
  1490. int i;
  1492. if ((ret = verify_area(VERIFY_READ, (void *) arg,
  1493. (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN)
  1494.    * ISDN_MAX_CHANNELS)))
  1495. return ret;
  1497. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  1498. if (copy_from_user(dev->mdm.info[i].emu.profile, p,
  1499.      ISDN_MODEM_NUMREG))
  1500. return -EFAULT;
  1501. p += ISDN_MODEM_NUMREG;
  1502. if (copy_from_user(dev->mdm.info[i].emu.plmsn, p, ISDN_LMSNLEN))
  1503. return -EFAULT;
  1504. p += ISDN_LMSNLEN;
  1505. if (copy_from_user(dev->mdm.info[i].emu.pmsn, p, ISDN_MSNLEN))
  1506. return -EFAULT;
  1507. p += ISDN_MSNLEN;
  1508. }
  1509. return 0;
  1510. } else
  1511. return -EINVAL;
  1512. break;
  1513. case IIOCSETMAP:
  1514. case IIOCGETMAP:
  1515. /* Set/Get MSN->EAZ-Mapping for a driver */
  1516. if (arg) {
  1518. if (copy_from_user((char *) &iocts,
  1519.     (char *) arg,
  1520.      sizeof(isdn_ioctl_struct)))
  1521. return -EFAULT;
  1522. if (strlen(iocts.drvid)) {
  1523. drvidx = -1;
  1524. for (i = 0; i < ISDN_MAX_DRIVERS; i++)
  1525. if (!(strcmp(dev->drvid[i], iocts.drvid))) {
  1526. drvidx = i;
  1527. break;
  1528. }
  1529. } else
  1530. drvidx = 0;
  1531. if (drvidx == -1)
  1532. return -ENODEV;
  1533. if (cmd == IIOCSETMAP) {
  1534. int loop = 1;
  1536. p = (char *) iocts.arg;
  1537. i = 0;
  1538. while (loop) {
  1539. int j = 0;
  1541. while (1) {
  1542. if ((ret = verify_area(VERIFY_READ, p, 1)))
  1543. return ret;
  1544. get_user(bname[j], p++);
  1545. switch (bname[j]) {
  1546. case '':
  1547. loop = 0;
  1548. /* Fall through */
  1549. case ',':
  1550. bname[j] = '';
  1551. strcpy(dev->drv[drvidx]->msn2eaz[i], bname);
  1552. j = ISDN_MSNLEN;
  1553. break;
  1554. default:
  1555. j++;
  1556. }
  1557. if (j >= ISDN_MSNLEN)
  1558. break;
  1559. }
  1560. if (++i > 9)
  1561. break;
  1562. }
  1563. } else {
  1564. p = (char *) iocts.arg;
  1565. for (i = 0; i < 10; i++) {
  1566. sprintf(bname, "%s%s",
  1567. strlen(dev->drv[drvidx]->msn2eaz[i]) ?
  1568. dev->drv[drvidx]->msn2eaz[i] : "_",
  1569. (i < 9) ? "," : "");
  1570. if (copy_to_user(p, bname, strlen(bname) + 1))
  1571. return -EFAULT;
  1572. p += strlen(bname);
  1573. }
  1574. }
  1575. return 0;
  1576. } else
  1577. return -EINVAL;
  1578. case IIOCDBGVAR:
  1579. if (arg) {
  1580. if (copy_to_user((char *) arg, (char *) &dev, sizeof(ulong)))
  1581. return -EFAULT;
  1582. return 0;
  1583. } else
  1584. return -EINVAL;
  1585. break;
  1586. default:
  1587. if ((cmd & IIOCDRVCTL) == IIOCDRVCTL)
  1588. cmd = ((cmd >> _IOC_NRSHIFT) & _IOC_NRMASK) & ISDN_DRVIOCTL_MASK;
  1589. else
  1590. return -EINVAL;
  1591. if (arg) {
  1592. int i;
  1593. char *p;
  1594. if (copy_from_user((char *) &iocts, (char *) arg, sizeof(isdn_ioctl_struct)))
  1595. return -EFAULT;
  1596. if (strlen(iocts.drvid)) {
  1597. if ((p = strchr(iocts.drvid, ',')))
  1598. *p = 0;
  1599. drvidx = -1;
  1600. for (i = 0; i < ISDN_MAX_DRIVERS; i++)
  1601. if (!(strcmp(dev->drvid[i], iocts.drvid))) {
  1602. drvidx = i;
  1603. break;
  1604. }
  1605. } else
  1606. drvidx = 0;
  1607. if (drvidx == -1)
  1608. return -ENODEV;
  1609. if ((ret = verify_area(VERIFY_WRITE, (void *) arg,
  1610.      sizeof(isdn_ioctl_struct))))
  1611. return ret;
  1612. c.driver = drvidx;
  1613. c.command = ISDN_CMD_IOCTL;
  1614. c.arg = cmd;
  1615. memcpy(c.parm.num, (char *) &iocts.arg, sizeof(ulong));
  1616. ret = isdn_command(&c);
  1617. memcpy((char *) &iocts.arg, c.parm.num, sizeof(ulong));
  1618. if (copy_to_user((char *) arg, &iocts, sizeof(isdn_ioctl_struct)))
  1619. return -EFAULT;
  1620. return ret;
  1621. } else
  1622. return -EINVAL;
  1623. }
  1624. }
  1625. #ifdef CONFIG_ISDN_PPP
  1626. if (minor <= ISDN_MINOR_PPPMAX)
  1627. return (isdn_ppp_ioctl(minor - ISDN_MINOR_PPP, file, cmd, arg));
  1628. #endif
  1629. return -ENODEV;
  1631. #undef name
  1632. #undef bname
  1633. #undef iocts
  1634. #undef phone
  1635. #undef cfg
  1636. }
  1638. /*
  1639.  * Open the device code.
  1640.  */
  1641. static int
  1642. isdn_open(struct inode *ino, struct file *filep)
  1643. {
  1644. uint minor = MINOR(ino->i_rdev);
  1645. int drvidx;
  1646. int chidx;
  1647. int retval = -ENODEV;
  1650. if (minor == ISDN_MINOR_STATUS) {
  1651. infostruct *p;
  1653. if ((p = kmalloc(sizeof(infostruct), GFP_KERNEL))) {
  1654. p->next = (char *) dev->infochain;
  1655. p->private = (char *) &(filep->private_data);
  1656. dev->infochain = p;
  1657. /* At opening we allow a single update */
  1658. filep->private_data = (char *) 1;
  1659. retval = 0;
  1660. goto out;
  1661. } else {
  1662. retval = -ENOMEM;
  1663. goto out;
  1664. }
  1665. }
  1666. if (!dev->channels)
  1667. goto out;
  1668. if (minor <= ISDN_MINOR_BMAX) {
  1669. printk(KERN_WARNING "isdn_open minor %d obsolete!n", minor);
  1670. drvidx = isdn_minor2drv(minor);
  1671. if (drvidx < 0)
  1672. goto out;
  1673. chidx = isdn_minor2chan(minor);
  1674. if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING))
  1675. goto out;
  1676. if (!(dev->drv[drvidx]->online & (1 << chidx)))
  1677. goto out;
  1678. isdn_lock_drivers();
  1679. retval = 0;
  1680. goto out;
  1681. }
  1682. if (minor <= ISDN_MINOR_CTRLMAX) {
  1683. drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL);
  1684. if (drvidx < 0)
  1685. goto out;
  1686. isdn_lock_drivers();
  1687. retval = 0;
  1688. goto out;
  1689. }
  1690. #ifdef CONFIG_ISDN_PPP
  1691. if (minor <= ISDN_MINOR_PPPMAX) {
  1692. retval = isdn_ppp_open(minor - ISDN_MINOR_PPP, filep);
  1693. if (retval == 0)
  1694. isdn_lock_drivers();
  1695. goto out;
  1696. }
  1697. #endif
  1698.  out:
  1699. return retval;
  1700. }
  1702. static int
  1703. isdn_close(struct inode *ino, struct file *filep)
  1704. {
  1705. uint minor = MINOR(ino->i_rdev);
  1707. lock_kernel();
  1708. if (minor == ISDN_MINOR_STATUS) {
  1709. infostruct *p = dev->infochain;
  1710. infostruct *q = NULL;
  1712. while (p) {
  1713. if (p->private == (char *) &(filep->private_data)) {
  1714. if (q)
  1715. q->next = p->next;
  1716. else
  1717. dev->infochain = (infostruct *) (p->next);
  1718. kfree(p);
  1719. goto out;
  1720. }
  1721. q = p;
  1722. p = (infostruct *) (p->next);
  1723. }
  1724. printk(KERN_WARNING "isdn: No private data while closing isdnctrln");
  1725. goto out;
  1726. }
  1727. isdn_unlock_drivers();
  1728. if (minor <= ISDN_MINOR_BMAX)
  1729. goto out;
  1730. if (minor <= ISDN_MINOR_CTRLMAX) {
  1731. if (dev->profd == current)
  1732. dev->profd = NULL;
  1733. goto out;
  1734. }
  1735. #ifdef CONFIG_ISDN_PPP
  1736. if (minor <= ISDN_MINOR_PPPMAX)
  1737. isdn_ppp_release(minor - ISDN_MINOR_PPP, filep);
  1738. #endif
  1740.  out:
  1741. unlock_kernel();
  1742. return 0;
  1743. }
  1745. static struct file_operations isdn_fops =
  1746. {
  1747. owner: THIS_MODULE,
  1748. llseek: no_llseek,
  1749. read: isdn_read,
  1750. write: isdn_write,
  1751. poll: isdn_poll,
  1752. ioctl: isdn_ioctl,
  1753. open: isdn_open,
  1754. release: isdn_close,
  1755. };
  1757. char *
  1758. isdn_map_eaz2msn(char *msn, int di)
  1759. {
  1760. driver *this = dev->drv[di];
  1761. int i;
  1763. if (strlen(msn) == 1) {
  1764. i = msn[0] - '0';
  1765. if ((i >= 0) && (i <= 9))
  1766. if (strlen(this->msn2eaz[i]))
  1767. return (this->msn2eaz[i]);
  1768. }
  1769. return (msn);
  1770. }
  1772. /*
  1773.  * Find an unused ISDN-channel, whose feature-flags match the
  1774.  * given L2- and L3-protocols.
  1775.  */
  1776. #define L2V (~(ISDN_FEATURE_L2_V11096|ISDN_FEATURE_L2_V11019|ISDN_FEATURE_L2_V11038))
  1778. int
  1779. isdn_get_free_channel(int usage, int l2_proto, int l3_proto, int pre_dev
  1780.       ,int pre_chan, char *msn)
  1781. {
  1782. int i;
  1783. ulong flags;
  1784. ulong features;
  1785. ulong vfeatures;
  1787. save_flags(flags);
  1788. cli();
  1789. features = ((1 << l2_proto) | (0x10000 << l3_proto));
  1790. vfeatures = (((1 << l2_proto) | (0x10000 << l3_proto)) &
  1791.      ~(ISDN_FEATURE_L2_V11096|ISDN_FEATURE_L2_V11019|ISDN_FEATURE_L2_V11038));
  1792. /* If Layer-2 protocol is V.110, accept drivers with
  1793.  * transparent feature even if these don't support V.110
  1794.  * because we can emulate this in linklevel.
  1795.  */
  1796. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  1797. if (USG_NONE(dev->usage[i]) &&
  1798.     (dev->drvmap[i] != -1)) {
  1799. int d = dev->drvmap[i];
  1800. if ((dev->usage[i] & ISDN_USAGE_EXCLUSIVE) &&
  1801. ((pre_dev != d) || (pre_chan != dev->chanmap[i])))
  1802. continue;
  1803. if (!strcmp(isdn_map_eaz2msn(msn, d), "-"))
  1804. continue;
  1805. if (dev->usage[i] & ISDN_USAGE_DISABLED)
  1806.         continue; /* usage not allowed */
  1807. if (dev->drv[d]->flags & DRV_FLAG_RUNNING) {
  1808. if (((dev->drv[d]->interface->features & features) == features) ||
  1809.     (((dev->drv[d]->interface->features & vfeatures) == vfeatures) &&
  1810.      (dev->drv[d]->interface->features & ISDN_FEATURE_L2_TRANS))) {
  1811. if ((pre_dev < 0) || (pre_chan < 0)) {
  1812. dev->usage[i] &= ISDN_USAGE_EXCLUSIVE;
  1813. dev->usage[i] |= usage;
  1814. isdn_info_update();
  1815. restore_flags(flags);
  1816. return i;
  1817. } else {
  1818. if ((pre_dev == d) && (pre_chan == dev->chanmap[i])) {
  1819. dev->usage[i] &= ISDN_USAGE_EXCLUSIVE;
  1820. dev->usage[i] |= usage;
  1821. isdn_info_update();
  1822. restore_flags(flags);
  1823. return i;
  1824. }
  1825. }
  1826. }
  1827. }
  1828. }
  1829. restore_flags(flags);
  1830. return -1;
  1831. }
  1833. /*
  1834.  * Set state of ISDN-channel to 'unused'
  1835.  */
  1836. void
  1837. isdn_free_channel(int di, int ch, int usage)
  1838. {
  1839. int i;
  1840. ulong flags;
  1842. save_flags(flags);
  1843. cli();
  1844. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  1845. if (((!usage) || ((dev->usage[i] & ISDN_USAGE_MASK) == usage)) &&
  1846.     (dev->drvmap[i] == di) &&
  1847.     (dev->chanmap[i] == ch)) {
  1848. dev->usage[i] &= (ISDN_USAGE_NONE | ISDN_USAGE_EXCLUSIVE);
  1849. strcpy(dev->num[i], "???");
  1850. dev->ibytes[i] = 0;
  1851. dev->obytes[i] = 0;
  1852. // 20.10.99 JIM, try to reinitialize v110 !
  1853. dev->v110emu[i] = 0;
  1854. atomic_set(&(dev->v110use[i]), 0);
  1855. isdn_v110_close(dev->v110[i]);
  1856. dev->v110[i] = NULL;
  1857. // 20.10.99 JIM, try to reinitialize v110 !
  1858. isdn_info_update();
  1859. skb_queue_purge(&dev->drv[di]->rpqueue[ch]);
  1860. }
  1861. restore_flags(flags);
  1862. }
  1864. /*
  1865.  * Cancel Exclusive-Flag for ISDN-channel
  1866.  */
  1867. void
  1868. isdn_unexclusive_channel(int di, int ch)
  1869. {
  1870. int i;
  1871. ulong flags;
  1873. save_flags(flags);
  1874. cli();
  1875. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  1876. if ((dev->drvmap[i] == di) &&
  1877.     (dev->chanmap[i] == ch)) {
  1878. dev->usage[i] &= ~ISDN_USAGE_EXCLUSIVE;
  1879. isdn_info_update();
  1880. restore_flags(flags);
  1881. return;
  1882. }
  1883. restore_flags(flags);
  1884. }
  1886. /*
  1887.  *  writebuf replacement for SKB_ABLE drivers
  1888.  */
  1889. static int
  1890. isdn_writebuf_stub(int drvidx, int chan, const u_char * buf, int len,
  1891.    int user)
  1892. {
  1893. int ret;
  1894. int hl = dev->drv[drvidx]->interface->hl_hdrlen;
  1895. struct sk_buff *skb = alloc_skb(hl + len, GFP_ATOMIC);
  1897. if (!skb)
  1898. return 0;
  1899. skb_reserve(skb, hl);
  1900. if (user)
  1901. copy_from_user(skb_put(skb, len), buf, len);
  1902. else
  1903. memcpy(skb_put(skb, len), buf, len);
  1904. ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, 1, skb);
  1905. if (ret <= 0)
  1906. dev_kfree_skb(skb);
  1907. if (ret > 0)
  1908. dev->obytes[isdn_dc2minor(drvidx, chan)] += ret;
  1909. return ret;
  1910. }
  1912. /*
  1913.  * Return: length of data on success, -ERRcode on failure.
  1914.  */
  1915. int
  1916. isdn_writebuf_skb_stub(int drvidx, int chan, int ack, struct sk_buff *skb)
  1917. {
  1918. int ret;
  1919. struct sk_buff *nskb = NULL;
  1920. int v110_ret = skb->len;
  1921. int idx = isdn_dc2minor(drvidx, chan);
  1923. if (dev->v110[idx]) {
  1924. atomic_inc(&dev->v110use[idx]);
  1925. nskb = isdn_v110_encode(dev->v110[idx], skb);
  1926. atomic_dec(&dev->v110use[idx]);
  1927. if (!nskb)
  1928. return 0;
  1929. v110_ret = *((int *)nskb->data);
  1930. skb_pull(nskb, sizeof(int));
  1931. if (!nskb->len) {
  1932. dev_kfree_skb(nskb);
  1933. return v110_ret;
  1934. }
  1935. /* V.110 must always be acknowledged */
  1936. ack = 1;
  1937. ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, ack, nskb);
  1938. } else {
  1939. int hl = dev->drv[drvidx]->interface->hl_hdrlen;
  1941. if( skb_headroom(skb) < hl ){
  1942. /* 
  1943.  * This should only occur when new HL driver with
  1944.  * increased hl_hdrlen was loaded after netdevice
  1945.  * was created and connected to the new driver.
  1946.  *
  1947.  * The V.110 branch (re-allocates on its own) does
  1948.  * not need this
  1949.  */
  1950. struct sk_buff * skb_tmp;
  1952. skb_tmp = skb_realloc_headroom(skb, hl);
  1953. printk(KERN_DEBUG "isdn_writebuf_skb_stub: reallocating headroom%sn", skb_tmp ? "" : " failed");
  1954. if (!skb_tmp) return -ENOMEM; /* 0 better? */
  1955. ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, ack, skb_tmp);
  1956. if( ret > 0 ){
  1957. dev_kfree_skb(skb);
  1958. } else {
  1959. dev_kfree_skb(skb_tmp);
  1960. }
  1961. } else {
  1962. ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, ack, skb);
  1963. }
  1964. }
  1965. if (ret > 0) {
  1966. dev->obytes[idx] += ret;
  1967. if (dev->v110[idx]) {
  1968. atomic_inc(&dev->v110use[idx]);
  1969. dev->v110[idx]->skbuser++;
  1970. atomic_dec(&dev->v110use[idx]);
  1971. /* For V.110 return unencoded data length */
  1972. ret = v110_ret;
  1973. /* if the complete frame was send we free the skb;
  1974.    if not upper function will requeue the skb */ 
  1975. if (ret == skb->len)
  1976. dev_kfree_skb(skb);
  1977. }
  1978. } else
  1979. if (dev->v110[idx])
  1980. dev_kfree_skb(nskb);
  1981. return ret;
  1982. }
  1984. int
  1985. isdn_add_channels(driver *d, int drvidx, int n, int adding)
  1986. {
  1987. int j, k, m;
  1988. ulong flags;
  1990. init_waitqueue_head(&d->st_waitq);
  1991. if (d->flags & DRV_FLAG_RUNNING)
  1992. return -1;
  1993.         if (n < 1) return 0;
  1995. m = (adding) ? d->channels + n : n;
  1997. if (dev->channels + n > ISDN_MAX_CHANNELS) {
  1998. printk(KERN_WARNING "register_isdn: Max. %d channels supportedn",
  1999.        ISDN_MAX_CHANNELS);
  2000. return -1;
  2001. }
  2003. if ((adding) && (d->rcverr))
  2004. kfree(d->rcverr);
  2005. if (!(d->rcverr = kmalloc(sizeof(int) * m, GFP_KERNEL))) {
  2006. printk(KERN_WARNING "register_isdn: Could not alloc rcverrn");
  2007. return -1;
  2008. }
  2009. memset((char *) d->rcverr, 0, sizeof(int) * m);
  2011. if ((adding) && (d->rcvcount))
  2012. kfree(d->rcvcount);
  2013. if (!(d->rcvcount = kmalloc(sizeof(int) * m, GFP_KERNEL))) {
  2014. printk(KERN_WARNING "register_isdn: Could not alloc rcvcountn");
  2015. if (!adding) kfree(d->rcverr);
  2016. return -1;
  2017. }
  2018. memset((char *) d->rcvcount, 0, sizeof(int) * m);
  2020. if ((adding) && (d->rpqueue)) {
  2021. for (j = 0; j < d->channels; j++)
  2022. skb_queue_purge(&d->rpqueue[j]);
  2023. kfree(d->rpqueue);
  2024. }
  2025. if (!(d->rpqueue = kmalloc(sizeof(struct sk_buff_head) * m, GFP_KERNEL))) {
  2026. printk(KERN_WARNING "register_isdn: Could not alloc rpqueuen");
  2027. if (!adding) {
  2028. kfree(d->rcvcount);
  2029. kfree(d->rcverr);
  2030. }
  2031. return -1; 
  2032. }
  2033. for (j = 0; j < m; j++) {
  2034. skb_queue_head_init(&d->rpqueue[j]);
  2035. }
  2037. if ((adding) && (d->rcv_waitq))
  2038. kfree(d->rcv_waitq);
  2039. d->rcv_waitq = kmalloc(sizeof(wait_queue_head_t) * 2 * m, GFP_KERNEL);
  2040. if (!d->rcv_waitq) {
  2041. printk(KERN_WARNING "register_isdn: Could not alloc rcv_waitqn");
  2042. if (!adding) {
  2043. kfree(d->rpqueue);
  2044. kfree(d->rcvcount);
  2045. kfree(d->rcverr);
  2046. }
  2047. return -1;
  2048. }
  2049. d->snd_waitq = d->rcv_waitq + m;
  2050. for (j = 0; j < m; j++) {
  2051. init_waitqueue_head(&d->rcv_waitq[j]);
  2052. init_waitqueue_head(&d->snd_waitq[j]);
  2053. }
  2055. dev->channels += n;
  2056. save_flags(flags);
  2057. cli();
  2058. for (j = d->channels; j < m; j++)
  2059. for (k = 0; k < ISDN_MAX_CHANNELS; k++)
  2060. if (dev->chanmap[k] < 0) {
  2061. dev->chanmap[k] = j;
  2062. dev->drvmap[k] = drvidx;
  2063. isdn_register_devfs(k);
  2064. break;
  2065. }
  2066. restore_flags(flags);
  2067. d->channels = m;
  2068. return 0;
  2069. }
  2071. /*
  2072.  * Low-level-driver registration
  2073.  */
  2075. static void
  2076. set_global_features(void)
  2077. {
  2078. int drvidx;
  2080. dev->global_features = 0;
  2081. for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++) {
  2082. if (!dev->drv[drvidx])
  2083. continue;
  2084. if (dev->drv[drvidx]->interface)
  2085. dev->global_features |= dev->drv[drvidx]->interface->features;
  2086. }
  2087. }
  2089. #ifdef CONFIG_ISDN_DIVERSION
  2091. static char *map_drvname(int di)
  2092. {
  2093.   if ((di < 0) || (di >= ISDN_MAX_DRIVERS)) 
  2094.     return(NULL);
  2095.   return(dev->drvid[di]); /* driver name */
  2096. } /* map_drvname */
  2098. static int map_namedrv(char *id)
  2099. {  int i;
  2101.    for (i = 0; i < ISDN_MAX_DRIVERS; i++)
  2102.     { if (!strcmp(dev->drvid[i],id)) 
  2103.         return(i);
  2104.     }
  2105.    return(-1);
  2106. } /* map_namedrv */
  2108. int DIVERT_REG_NAME(isdn_divert_if *i_div)
  2109. {
  2110.   if (i_div->if_magic != DIVERT_IF_MAGIC) 
  2111.     return(DIVERT_VER_ERR);
  2112.   switch (i_div->cmd)
  2113.     {
  2114.       case DIVERT_CMD_REL:
  2115.         if (divert_if != i_div) 
  2116.           return(DIVERT_REL_ERR);
  2117.         divert_if = NULL; /* free interface */
  2118.         MOD_DEC_USE_COUNT;
  2119.         return(DIVERT_NO_ERR);
  2121.       case DIVERT_CMD_REG:
  2122.         if (divert_if) 
  2123.           return(DIVERT_REG_ERR);
  2124.         i_div->ll_cmd = isdn_command; /* set command function */
  2125.         i_div->drv_to_name = map_drvname; 
  2126.         i_div->name_to_drv = map_namedrv; 
  2127.         MOD_INC_USE_COUNT;
  2128.         divert_if = i_div; /* remember interface */
  2129.         return(DIVERT_NO_ERR);
  2131.       default:
  2132.         return(DIVERT_CMD_ERR);   
  2133.     }
  2134. } /* DIVERT_REG_NAME */
  2136. EXPORT_SYMBOL(DIVERT_REG_NAME);
  2138. #endif /* CONFIG_ISDN_DIVERSION */
  2141. EXPORT_SYMBOL(register_isdn);
  2142. #ifdef CONFIG_ISDN_PPP
  2143. EXPORT_SYMBOL(isdn_ppp_register_compressor);
  2144. EXPORT_SYMBOL(isdn_ppp_unregister_compressor);
  2145. #endif
  2147. int
  2148. register_isdn(isdn_if * i)
  2149. {
  2150. driver *d;
  2151. int j;
  2152. ulong flags;
  2153. int drvidx;
  2155. if (dev->drivers >= ISDN_MAX_DRIVERS) {
  2156. printk(KERN_WARNING "register_isdn: Max. %d drivers supportedn",
  2157.        ISDN_MAX_DRIVERS);
  2158. return 0;
  2159. }
  2160. if (!i->writebuf_skb) {
  2161. printk(KERN_WARNING "register_isdn: No write routine given.n");
  2162. return 0;
  2163. }
  2164. if (!(d = kmalloc(sizeof(driver), GFP_KERNEL))) {
  2165. printk(KERN_WARNING "register_isdn: Could not alloc driver-structn");
  2166. return 0;
  2167. }
  2168. memset((char *) d, 0, sizeof(driver));
  2170. d->maxbufsize = i->maxbufsize;
  2171. d->pktcount = 0;
  2172. d->stavail = 0;
  2173. d->flags = DRV_FLAG_LOADED;
  2174. d->online = 0;
  2175. d->interface = i;
  2176. d->channels = 0;
  2177. for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++)
  2178. if (!dev->drv[drvidx])
  2179. break;
  2180. if (isdn_add_channels(d, drvidx, i->channels, 0)) {
  2181. kfree(d);
  2182. return 0;
  2183. }
  2184. i->channels = drvidx;
  2185. i->rcvcallb_skb = isdn_receive_skb_callback;
  2186. i->statcallb = isdn_status_callback;
  2187. if (!strlen(i->id))
  2188. sprintf(i->id, "line%d", drvidx);
  2189. save_flags(flags);
  2190. cli();
  2191. for (j = 0; j < drvidx; j++)
  2192. if (!strcmp(i->id, dev->drvid[j]))
  2193. sprintf(i->id, "line%d", drvidx);
  2194. dev->drv[drvidx] = d;
  2195. strcpy(dev->drvid[drvidx], i->id);
  2196. isdn_info_update();
  2197. dev->drivers++;
  2198. set_global_features();
  2199. restore_flags(flags);
  2200. return 1;
  2201. }
  2203. /*
  2204.  *****************************************************************************
  2205.  * And now the modules code.
  2206.  *****************************************************************************
  2207.  */
  2209. static char *
  2210. isdn_getrev(const char *revision)
  2211. {
  2212. char *rev;
  2213. char *p;
  2215. if ((p = strchr(revision, ':'))) {
  2216. rev = p + 2;
  2217. p = strchr(rev, '$');
  2218. *--p = 0;
  2219. } else
  2220. rev = "???";
  2221. return rev;
  2222. }
  2224. #ifdef CONFIG_DEVFS_FS
  2226. static devfs_handle_t devfs_handle;
  2228. static void isdn_register_devfs(int k)
  2229. {
  2230. char buf[11];
  2232. sprintf (buf, "isdn%d", k);
  2233. dev->devfs_handle_isdnX[k] =
  2234.     devfs_register (devfs_handle, buf, DEVFS_FL_DEFAULT,
  2235.     ISDN_MAJOR, ISDN_MINOR_B + k,0600 | S_IFCHR,
  2236.     &isdn_fops, NULL);
  2237. sprintf (buf, "isdnctrl%d", k);
  2238. dev->devfs_handle_isdnctrlX[k] =
  2239.     devfs_register (devfs_handle, buf, DEVFS_FL_DEFAULT,
  2240.     ISDN_MAJOR, ISDN_MINOR_CTRL + k, 0600 | S_IFCHR,
  2241.     &isdn_fops, NULL);
  2242. }
  2244. static void isdn_unregister_devfs(int k)
  2245. {
  2246. devfs_unregister (dev->devfs_handle_isdnX[k]);
  2247. devfs_unregister (dev->devfs_handle_isdnctrlX[k]);
  2248. }
  2250. static void isdn_init_devfs(void)
  2251. {
  2252. #  ifdef CONFIG_ISDN_PPP
  2253. int i;
  2254. #  endif
  2256. devfs_handle = devfs_mk_dir (NULL, "isdn", NULL);
  2257. #  ifdef CONFIG_ISDN_PPP
  2258. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  2259. char buf[8];
  2261. sprintf (buf, "ippp%d", i);
  2262. dev->devfs_handle_ipppX[i] =
  2263.     devfs_register (devfs_handle, buf, DEVFS_FL_DEFAULT,
  2264.     ISDN_MAJOR, ISDN_MINOR_PPP + i,
  2265.     0600 | S_IFCHR, &isdn_fops, NULL);
  2266. }
  2267. #  endif
  2269. dev->devfs_handle_isdninfo =
  2270.     devfs_register (devfs_handle, "isdninfo", DEVFS_FL_DEFAULT,
  2271.     ISDN_MAJOR, ISDN_MINOR_STATUS, 0600 | S_IFCHR,
  2272.     &isdn_fops, NULL);
  2273. dev->devfs_handle_isdnctrl =
  2274.     devfs_register (devfs_handle, "isdnctrl", DEVFS_FL_DEFAULT,
  2275.     ISDN_MAJOR, ISDN_MINOR_CTRL, 0600 | S_IFCHR, 
  2276.     &isdn_fops, NULL);
  2277. }
  2279. static void isdn_cleanup_devfs(void)
  2280. {
  2281. #  ifdef CONFIG_ISDN_PPP
  2282. int i;
  2283. for (i = 0; i < ISDN_MAX_CHANNELS; i++) 
  2284. devfs_unregister (dev->devfs_handle_ipppX[i]);
  2285. #  endif
  2286. devfs_unregister (dev->devfs_handle_isdninfo);
  2287. devfs_unregister (dev->devfs_handle_isdnctrl);
  2288. devfs_unregister (devfs_handle);
  2289. }
  2291. #else   /* CONFIG_DEVFS_FS */
  2292. static void isdn_register_devfs(int dummy)
  2293. {
  2294. return;
  2295. }
  2297. static void isdn_unregister_devfs(int dummy)
  2298. {
  2299. return;
  2300. }
  2302. static void isdn_init_devfs(void)
  2303. {
  2304.     return;
  2305. }
  2307. static void isdn_cleanup_devfs(void)
  2308. {
  2309.     return;
  2310. }
  2312. #endif  /* CONFIG_DEVFS_FS */
  2314. /*
  2315.  * Allocate and initialize all data, register modem-devices
  2316.  */
  2317. static int __init isdn_init(void)
  2318. {
  2319. int i;
  2320. char tmprev[50];
  2322. if (!(dev = (isdn_dev *) vmalloc(sizeof(isdn_dev)))) {
  2323. printk(KERN_WARNING "isdn: Could not allocate device-struct.n");
  2324. return -EIO;
  2325. }
  2326. memset((char *) dev, 0, sizeof(isdn_dev));
  2327. init_timer(&dev->timer);
  2328. dev->timer.function = isdn_timer_funct;
  2329. init_MUTEX(&dev->sem);
  2330. init_waitqueue_head(&dev->info_waitq);
  2331. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  2332. dev->drvmap[i] = -1;
  2333. dev->chanmap[i] = -1;
  2334. dev->m_idx[i] = -1;
  2335. strcpy(dev->num[i], "???");
  2336. init_waitqueue_head(&dev->mdm.info[i].open_wait);
  2337. init_waitqueue_head(&dev->mdm.info[i].close_wait);
  2338. }
  2339. if (devfs_register_chrdev(ISDN_MAJOR, "isdn", &isdn_fops)) {
  2340. printk(KERN_WARNING "isdn: Could not register control devicesn");
  2341. vfree(dev);
  2342. return -EIO;
  2343. }
  2344. isdn_init_devfs();
  2345. if ((i = isdn_tty_modem_init()) < 0) {
  2346. printk(KERN_WARNING "isdn: Could not register tty devicesn");
  2347. if (i == -3)
  2348. tty_unregister_driver(&dev->mdm.cua_modem);
  2349. if (i <= -2)
  2350. tty_unregister_driver(&dev->mdm.tty_modem);
  2351. vfree(dev);
  2352. isdn_cleanup_devfs();
  2353. devfs_unregister_chrdev(ISDN_MAJOR, "isdn");
  2354. return -EIO;
  2355. }
  2356. #ifdef CONFIG_ISDN_PPP
  2357. if (isdn_ppp_init() < 0) {
  2358. printk(KERN_WARNING "isdn: Could not create PPP-device-structsn");
  2359. tty_unregister_driver(&dev->mdm.tty_modem);
  2360. tty_unregister_driver(&dev->mdm.cua_modem);
  2361. for (i = 0; i < ISDN_MAX_CHANNELS; i++)
  2362. kfree(dev->mdm.info[i].xmit_buf - 4);
  2363. isdn_cleanup_devfs();
  2364. devfs_unregister_chrdev(ISDN_MAJOR, "isdn");
  2365. vfree(dev);
  2366. return -EIO;
  2367. }
  2368. #endif                          /* CONFIG_ISDN_PPP */
  2370. strcpy(tmprev, isdn_revision);
  2371. printk(KERN_NOTICE "ISDN subsystem Rev: %s/", isdn_getrev(tmprev));
  2372. strcpy(tmprev, isdn_tty_revision);
  2373. printk("%s/", isdn_getrev(tmprev));
  2374. strcpy(tmprev, isdn_net_revision);
  2375. printk("%s/", isdn_getrev(tmprev));
  2376. strcpy(tmprev, isdn_ppp_revision);
  2377. printk("%s/", isdn_getrev(tmprev));
  2378. strcpy(tmprev, isdn_audio_revision);
  2379. printk("%s/", isdn_getrev(tmprev));
  2380. strcpy(tmprev, isdn_v110_revision);
  2381. printk("%s", isdn_getrev(tmprev));
  2383. #ifdef MODULE
  2384. printk(" loadedn");
  2385. #else
  2386. printk("n");
  2387. #endif
  2388. isdn_info_update();
  2389. return 0;
  2390. }
  2392. /*
  2393.  * Unload module
  2394.  */
  2395. static void __exit isdn_exit(void)
  2396. {
  2397. unsigned long flags;
  2398. int i;
  2400. #ifdef CONFIG_ISDN_PPP
  2401. isdn_ppp_cleanup();
  2402. #endif
  2403. save_flags(flags);
  2404. cli();
  2405. if (isdn_net_rmall() < 0) {
  2406. printk(KERN_WARNING "isdn: net-device busy, remove cancelledn");
  2407. restore_flags(flags);
  2408. return;
  2409. }
  2410. if (tty_unregister_driver(&dev->mdm.tty_modem)) {
  2411. printk(KERN_WARNING "isdn: ttyI-device busy, remove cancelledn");
  2412. restore_flags(flags);
  2413. return;
  2414. }
  2415. if (tty_unregister_driver(&dev->mdm.cua_modem)) {
  2416. printk(KERN_WARNING "isdn: cui-device busy, remove cancelledn");
  2417. restore_flags(flags);
  2418. return;
  2419. }
  2420. for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
  2421. isdn_tty_cleanup_xmit(&dev->mdm.info[i]);
  2422. kfree(dev->mdm.info[i].xmit_buf - 4);
  2423. #ifdef CONFIG_ISDN_TTY_FAX
  2424. kfree(dev->mdm.info[i].fax);
  2425. #endif
  2426. }
  2427. if (devfs_unregister_chrdev(ISDN_MAJOR, "isdn") != 0) {
  2428. printk(KERN_WARNING "isdn: controldevice busy, remove cancelledn");
  2429. restore_flags(flags);
  2430. } else {
  2431. isdn_cleanup_devfs();
  2432. del_timer(&dev->timer);
  2433. restore_flags(flags);
  2434. /* call vfree with interrupts enabled, else it will hang */
  2435. vfree(dev);
  2436. printk(KERN_NOTICE "ISDN-subsystem unloadedn");
  2437. }
  2438. }
  2440. module_init(isdn_init);
  2441. module_exit(isdn_exit);