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

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

嵌入式Linux

开发平台：

Unix_Linux

eicon_mod.c：源码内容
  1. /* $Id: eicon_mod.c,v 1.1.4.1 2001/11/20 14:19:35 kai Exp $
  2.  *
  3.  * ISDN lowlevel-module for Eicon active cards.
  4.  * 
  5.  * Copyright 1997      by Fritz Elfert (fritz@isdn4linux.de)
  6.  * Copyright 1998-2000 by Armin Schindler (mac@melware.de) 
  7.  * Copyright 1999,2000 Cytronics & Melware (info@melware.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.  * Thanks to    Eicon Networks for
  13.  *              documents, informations and hardware.
  14.  *
  15.  * Deutsche Mailbox Saar-Lor-Lux GmbH
  16.  * for sponsoring and testing fax
  17.  * capabilities with Diva Server cards.
  18.  * (dor@deutschemailbox.de)
  19.  *
  20.  */
  22. #define DRIVERNAME "Eicon active ISDN driver"
  23. #define DRIVERRELEASE "2.0"
  24. #define DRIVERPATCH ".16"
  27. #include <linux/config.h>
  28. #include <linux/module.h>
  29. #include <linux/init.h>
  30. #ifdef CONFIG_MCA
  31. #include <linux/mca.h>
  32. #endif /* CONFIG_MCA */
  34. #include "eicon.h"
  36. #include "../avmb1/capicmd.h"  /* this should be moved in a common place */
  38. #undef N_DATA
  39. #include "adapter.h"
  40. #include "uxio.h"
  42. #define INCLUDE_INLINE_FUNCS
  44. static eicon_card *cards = (eicon_card *) NULL;   /* glob. var , contains
  45.                                                      start of card-list   */
  47. static char *eicon_revision = "$Revision: 1.1.4.1 $";
  49. extern char *eicon_pci_revision;
  50. extern char *eicon_isa_revision;
  51. extern char *eicon_idi_revision;
  53. extern int do_ioctl(struct inode *pDivasInode, struct file *pDivasFile,
  54. unsigned int command, unsigned long arg);
  55. extern void eicon_pci_init_conf(eicon_card *card);
  57. #ifdef MODULE
  58. #define MOD_USE_COUNT (GET_USE_COUNT (&__this_module))
  59. #endif
  61. #define EICON_CTRL_VERSION 2 
  63. ulong DebugVar;
  65. spinlock_t eicon_lock;
  67. DESCRIPTOR idi_d[32];
  69. /* Parameters to be set by insmod */
  70. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  71. static int   membase      = -1;
  72. static int   irq          = -1;
  73. #endif
  74. static char *id           = "";
  76. MODULE_DESCRIPTION(             "ISDN4Linux: Driver for Eicon active ISDN cards");
  77. MODULE_AUTHOR(                  "Armin Schindler");
  78. MODULE_LICENSE(                 "GPL");
  79. MODULE_PARM_DESC(id,    "ID-String of first card");
  80. MODULE_PARM(id,            "s");
  81. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  82. MODULE_PARM_DESC(membase, "Base address of first ISA card");
  83. MODULE_PARM_DESC(irq,     "IRQ of first card");
  84. MODULE_PARM(membase,     "i");
  85. MODULE_PARM(irq,           "i");
  86. #endif
  88. char *eicon_ctype_name[] = {
  89.         "ISDN-S",
  90.         "ISDN-SX",
  91.         "ISDN-SCOM",
  92.         "ISDN-QUADRO",
  93.         "ISDN-S2M",
  94.         "DIVA Server BRI/PCI",
  95.         "DIVA Server 4BRI/PCI",
  96.         "DIVA Server 4BRI/PCI",
  97.         "DIVA Server PRI/PCI"
  98. };
  100. static char *
  101. eicon_getrev(const char *revision)
  102. {
  103. char *rev;
  104. char *p;
  105. if ((p = strchr(revision, ':'))) {
  106. rev = p + 2;
  107. p = strchr(rev, '$');
  108. *--p = 0;
  109. } else rev = "?.??";
  110. return rev;
  112. }
  114. static eicon_chan *
  115. find_channel(eicon_card *card, int channel)
  116. {
  117. if ((channel >= 0) && (channel < card->nchannels))
  118.          return &(card->bch[channel]);
  119. eicon_log(card, 1, "eicon: Invalid channel %dn", channel);
  120. return NULL;
  121. }
  123. #ifdef CONFIG_PCI
  124. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  125. /*
  126.  * Find pcicard with given card number 
  127.  */
  128. static inline eicon_card *
  129. eicon_findnpcicard(int driverid)
  130. {
  131.         eicon_card *p = cards;
  133.         while (p) {
  134.                 if ((p->regname[strlen(p->regname)-1] == (driverid + '0')) &&
  135. (p->bus == EICON_BUS_PCI))
  136.                         return p;
  137.                 p = p->next;
  138.         }
  139.         return (eicon_card *) 0;
  140. }
  141. #endif
  142. #endif /* CONFIG_PCI */
  144. static void
  145. eicon_rcv_dispatch(struct eicon_card *card)
  146. {
  147. switch (card->bus) {
  148. case EICON_BUS_ISA:
  149. case EICON_BUS_MCA:
  150. case EICON_BUS_PCI:
  151. eicon_io_rcv_dispatch(card);
  152. break;
  153. default:
  154. eicon_log(card, 1,
  155.        "eicon_ack_dispatch: Illegal bustype %dn", card->bus);
  156. }
  157. }
  159. static void
  160. eicon_ack_dispatch(struct eicon_card *card)
  161. {
  162. switch (card->bus) {
  163. case EICON_BUS_ISA:
  164. case EICON_BUS_MCA:
  165. case EICON_BUS_PCI:
  166. eicon_io_ack_dispatch(card);
  167. break;
  168. default:
  169. eicon_log(card, 1,
  170.         "eicon_ack_dispatch: Illegal bustype %dn", card->bus);
  171. }
  172. }
  174. static void
  175. eicon_transmit(struct eicon_card *card)
  176. {
  177. switch (card->bus) {
  178. case EICON_BUS_ISA:
  179. case EICON_BUS_MCA:
  180. case EICON_BUS_PCI:
  181. eicon_io_transmit(card);
  182. break;
  183. default:
  184. eicon_log(card, 1,
  185.        "eicon_transmit: Illegal bustype %dn", card->bus);
  186. }
  187. }
  189. static int
  190. eicon_command(eicon_card * card, isdn_ctrl * c)
  191. {
  192.         ulong a;
  193.         eicon_chan *chan;
  194. eicon_cdef cdef;
  195. #ifdef CONFIG_PCI
  196. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  197. dia_start_t dstart;
  198.         int idi_length = 0;
  199. #endif
  200. #endif
  201. isdn_ctrl cmd;
  202. int ret = 0;
  203. unsigned long flags;
  204.  
  205. eicon_log(card, 16, "eicon_cmd 0x%x with arg 0x%lx (0x%lx)n",
  206. c->command, c->arg, (ulong) *c->parm.num);
  208.         switch (c->command) {
  209. case ISDN_CMD_IOCTL:
  210. memcpy(&a, c->parm.num, sizeof(ulong));
  211. switch (c->arg) {
  212. case EICON_IOCTL_GETVER:
  213. return(EICON_CTRL_VERSION);
  214. case EICON_IOCTL_GETTYPE:
  215. if (card->bus == EICON_BUS_PCI) {
  216. copy_to_user((char *)a, &card->hwif.pci.master, sizeof(int));
  217. }
  218. return(card->type);
  219. case EICON_IOCTL_GETMMIO:
  220. switch (card->bus) {
  221. case EICON_BUS_ISA:
  222. case EICON_BUS_MCA:
  223. return (int)card->hwif.isa.shmem;
  224. default:
  225. eicon_log(card, 1,
  226.        "eicon: Illegal BUS type %dn",
  227.        card->bus);
  228. ret = -ENODEV;
  229. }
  230. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  231. case EICON_IOCTL_SETMMIO:
  232. if (card->flags & EICON_FLAGS_LOADED)
  233. return -EBUSY;
  234. switch (card->bus) {
  235. case EICON_BUS_ISA:
  236. if (eicon_isa_find_card(a,
  237. card->hwif.isa.irq,
  238. card->regname) < 0)
  239. return -EFAULT;
  240. card->hwif.isa.shmem = (eicon_isa_shmem *)a;
  241. return 0;
  242. case EICON_BUS_MCA:
  243. #if CONFIG_MCA
  244. if (eicon_mca_find_card(
  245. 0, a,
  246. card->hwif.isa.irq,
  247. card->regname) < 0)
  248. return -EFAULT;
  249. card->hwif.isa.shmem = (eicon_isa_shmem *)a;
  250. return 0;
  251. #endif /* CONFIG_MCA */
  252. default:
  253. eicon_log(card, 1,
  254.        "eicon: Illegal BUS type %dn",
  255.        card->bus);
  256. ret = -ENODEV;
  257. }
  258. #endif
  259. case EICON_IOCTL_GETIRQ:
  260. switch (card->bus) {
  261. case EICON_BUS_ISA:
  262. case EICON_BUS_MCA:
  263. return card->hwif.isa.irq;
  264. default:
  265. eicon_log(card, 1,
  266.        "eicon: Illegal BUS type %dn",
  267.        card->bus);
  268. ret = -ENODEV;
  269. }
  270. case EICON_IOCTL_SETIRQ:
  271. if (card->flags & EICON_FLAGS_LOADED)
  272. return -EBUSY;
  273. if ((a < 2) || (a > 15))
  274. return -EFAULT;
  275. switch (card->bus) {
  276. case EICON_BUS_ISA:
  277. case EICON_BUS_MCA:
  278. card->hwif.isa.irq = a;
  279. return 0;
  280. default:
  281. eicon_log(card, 1,
  282.        "eicon: Illegal BUS type %dn",
  283.        card->bus);
  284. ret = -ENODEV;
  285. }
  286. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  287. case EICON_IOCTL_LOADBOOT:
  288. if (card->flags & EICON_FLAGS_RUNNING)
  289. return -EBUSY;  
  290. switch (card->bus) {
  291. case EICON_BUS_ISA:
  292. case EICON_BUS_MCA:
  293. ret = eicon_isa_bootload(
  294. &(card->hwif.isa),
  295. &(((eicon_codebuf *)a)->isa));
  296. break;
  297. default:
  298. eicon_log(card, 1,
  299.        "eicon: Illegal BUS type %dn",
  300.        card->bus);
  301. ret = -ENODEV;
  302. }
  303. return ret;
  304. #endif
  305. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  306. case EICON_IOCTL_LOADISA:
  307. if (card->flags & EICON_FLAGS_RUNNING)
  308. return -EBUSY;  
  309. switch (card->bus) {
  310. case EICON_BUS_ISA:
  311. case EICON_BUS_MCA:
  312. ret = eicon_isa_load(
  313. &(card->hwif.isa),
  314. &(((eicon_codebuf *)a)->isa));
  315. if (!ret) {
  316.                                                                 card->flags |= EICON_FLAGS_LOADED;
  317.                                                                 card->flags |= EICON_FLAGS_RUNNING;
  318. if (card->hwif.isa.channels > 1) {
  319. cmd.command = ISDN_STAT_ADDCH;
  320. cmd.driver = card->myid;
  321. cmd.arg = card->hwif.isa.channels - 1;
  322. card->interface.statcallb(&cmd);
  323. }
  324. cmd.command = ISDN_STAT_RUN;    
  325. cmd.driver = card->myid;        
  326. cmd.arg = 0;                    
  327. card->interface.statcallb(&cmd);
  328. }
  329. break;
  330. default:
  331. eicon_log(card, 1,
  332.        "eicon: Illegal BUS type %dn",
  333.        card->bus);
  334. ret = -ENODEV;
  335. }
  336. return ret;
  337. #endif
  338. case EICON_IOCTL_MANIF:
  339. if (!card->flags & EICON_FLAGS_RUNNING)
  340. return -ENODEV;
  341. if (!card->d)
  342. return -ENODEV;
  343. if (!card->d->features & DI_MANAGE)
  344. return -ENODEV;
  345. ret = eicon_idi_manage(
  346. card, 
  347. (eicon_manifbuf *)a);
  348. return ret;
  350. case EICON_IOCTL_GETXLOG:
  351. return -ENODEV;
  353. case EICON_IOCTL_ADDCARD:
  354. if ((ret = copy_from_user(&cdef, (char *)a, sizeof(cdef))))
  355. return -EFAULT;
  356. if (!(eicon_addcard(0, cdef.membase, cdef.irq, cdef.id, 0)))
  357. return -EIO;
  358. return 0;
  359. case EICON_IOCTL_DEBUGVAR:
  360. DebugVar = a;
  361. eicon_log(card, 1, "Eicon: Debug Value set to %ldn", DebugVar);
  362. return 0;
  363. #ifdef MODULE
  364. case EICON_IOCTL_FREEIT:
  365. while (MOD_USE_COUNT > 0) MOD_DEC_USE_COUNT;
  366. MOD_INC_USE_COUNT;
  367. return 0;
  368. #endif
  369. case EICON_IOCTL_LOADPCI:
  370. eicon_log(card, 1, "Eicon: Wrong version of load-utility,n");
  371. eicon_log(card, 1, "Eicon: re-compile eiconctrl !n");
  372. eicon_log(card, 1, "Eicon: Maybe update of utility is necessary !n");
  373. return -EINVAL;
  374. default:
  375. #ifdef CONFIG_PCI
  376. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  377. if (c->arg < EICON_IOCTL_DIA_OFFSET)
  378. return -EINVAL;
  379. if (copy_from_user(&dstart, (char *)a, sizeof(dstart)))
  380. return -1;
  381. if (!(card = eicon_findnpcicard(dstart.card_id)))
  382. return -EINVAL;
  383. ret = do_ioctl(NULL, NULL,
  384. c->arg - EICON_IOCTL_DIA_OFFSET,
  385. (unsigned long) a);
  386. if (((c->arg - EICON_IOCTL_DIA_OFFSET)==DIA_IOCTL_START) && (!ret)) {
  387. if (card->type != EICON_CTYPE_MAESTRAQ) {
  388. DIVA_DIDD_Read(idi_d, sizeof(idi_d));
  389.                                                         for(idi_length = 0; idi_length < 32; idi_length++) {
  390.                                                           if (idi_d[idi_length].type == 0) break;
  391.                                                         }
  392.                                                         if ((idi_length < 1) || (idi_length >= 32)) {
  393.                   eicon_log(card, 1, "eicon: invalid idi table length.n");
  394.                                                           break;
  395.                                                         }
  396. card->d = &idi_d[idi_length - 1];
  397. card->flags |= EICON_FLAGS_LOADED;
  398. card->flags |= EICON_FLAGS_RUNNING;
  399. eicon_pci_init_conf(card);
  400. if (card->d->channels > 1) {
  401. cmd.command = ISDN_STAT_ADDCH;
  402. cmd.driver = card->myid;
  403. cmd.arg = card->d->channels - 1;
  404. card->interface.statcallb(&cmd);
  405. }
  406. cmd.command = ISDN_STAT_RUN;    
  407. cmd.driver = card->myid;        
  408. cmd.arg = 0;                    
  409. card->interface.statcallb(&cmd);
  410. eicon_log(card, 1, "Eicon: %s started, %d channels (feat. 0x%x)n",
  411. (card->type == EICON_CTYPE_MAESTRA) ? "BRI" : "PRI",
  412. card->d->channels, card->d->features);
  413. } else {
  414. int i;
  415. DIVA_DIDD_Read(idi_d, sizeof(idi_d));
  416.                                                         for(idi_length = 0; idi_length < 32; idi_length++)
  417.                                                           if (idi_d[idi_length].type == 0) break;
  418.                                                         if ((idi_length < 1) || (idi_length >= 32)) {
  419.                   eicon_log(card, 1, "eicon: invalid idi table length.n");
  420.                                                           break;
  421.                                                         }
  422.          for(i = 3; i >= 0; i--) {
  423. if (!(card = eicon_findnpcicard(dstart.card_id - i)))
  424. return -EINVAL;
  426. card->flags |= EICON_FLAGS_LOADED;
  427. card->flags |= EICON_FLAGS_RUNNING;
  428. card->d = &idi_d[idi_length - (i+1)];
  429. eicon_pci_init_conf(card);
  430. if (card->d->channels > 1) {
  431. cmd.command = ISDN_STAT_ADDCH;
  432. cmd.driver = card->myid;
  433. cmd.arg = card->d->channels - 1;
  434. card->interface.statcallb(&cmd);
  435. }
  436. cmd.command = ISDN_STAT_RUN;    
  437. cmd.driver = card->myid;        
  438. cmd.arg = 0;                    
  439. card->interface.statcallb(&cmd);
  440. eicon_log(card, 1, "Eicon: %d/4BRI started, %d channels (feat. 0x%x)n",
  441. 4-i, card->d->channels, card->d->features);
  442. }
  443. }
  444. }
  445. return ret;
  446. #else
  447. return -EINVAL;
  448. #endif
  449. #endif /* CONFIG_PCI */
  450. }
  451. break;
  452. case ISDN_CMD_DIAL:
  453. if (!card->flags & EICON_FLAGS_RUNNING)
  454. return -ENODEV;
  455. if (!(chan = find_channel(card, c->arg & 0x1f)))
  456. break;
  457. spin_lock_irqsave(&eicon_lock, flags);
  458. if ((chan->fsm_state != EICON_STATE_NULL) && (chan->fsm_state != EICON_STATE_LISTEN)) {
  459. spin_unlock_irqrestore(&eicon_lock, flags);
  460. eicon_log(card, 1, "Dial on channel %d with state %dn",
  461. chan->No, chan->fsm_state);
  462. return -EBUSY;
  463. }
  464. chan->fsm_state = EICON_STATE_OCALL;
  465. spin_unlock_irqrestore(&eicon_lock, flags);
  467. ret = idi_connect_req(card, chan, c->parm.setup.phone,
  468.      c->parm.setup.eazmsn,
  469.      c->parm.setup.si1,
  470.      c->parm.setup.si2);
  471. if (ret) {
  472. cmd.driver = card->myid;
  473. cmd.command = ISDN_STAT_DHUP;
  474. cmd.arg &= 0x1f;
  475. card->interface.statcallb(&cmd);
  476. }
  477. return ret;
  478. case ISDN_CMD_ACCEPTD:
  479. if (!card->flags & EICON_FLAGS_RUNNING)
  480. return -ENODEV;
  481. if (!(chan = find_channel(card, c->arg & 0x1f)))
  482. break;
  483. if (chan->fsm_state == EICON_STATE_ICALL) { 
  484. idi_connect_res(card, chan);
  485. }
  486. return 0;
  487. case ISDN_CMD_ACCEPTB:
  488. if (!card->flags & EICON_FLAGS_RUNNING)
  489. return -ENODEV;
  490. return 0;
  491. case ISDN_CMD_HANGUP:
  492. if (!card->flags & EICON_FLAGS_RUNNING)
  493. return -ENODEV;
  494. if (!(chan = find_channel(card, c->arg & 0x1f)))
  495. break;
  496. idi_hangup(card, chan);
  497. return 0;
  498. case ISDN_CMD_SETEAZ:
  499. if (!card->flags & EICON_FLAGS_RUNNING)
  500. return -ENODEV;
  501. if (!(chan = find_channel(card, c->arg & 0x1f)))
  502. break;
  503. chan->eazmask = 0x3ff;
  504. eicon_idi_listen_req(card, chan);
  505. return 0;
  506. case ISDN_CMD_CLREAZ:
  507. if (!card->flags & EICON_FLAGS_RUNNING)
  508. return -ENODEV;
  509. if (!(chan = find_channel(card, c->arg & 0x1f)))
  510. break;
  511. chan->eazmask = 0;
  512. eicon_idi_listen_req(card, chan);
  513. return 0;
  514. case ISDN_CMD_SETL2:
  515. if (!card->flags & EICON_FLAGS_RUNNING)
  516. return -ENODEV;
  517. if (!(chan = find_channel(card, c->arg & 0x1f)))
  518. break;
  519. chan->l2prot = (c->arg >> 8);
  520. return 0;
  521. case ISDN_CMD_GETL2:
  522. if (!card->flags & EICON_FLAGS_RUNNING)
  523. return -ENODEV;
  524. if (!(chan = find_channel(card, c->arg & 0x1f)))
  525. break;
  526. return chan->l2prot;
  527. case ISDN_CMD_SETL3:
  528. if (!card->flags & EICON_FLAGS_RUNNING)
  529. return -ENODEV;
  530. if (!(chan = find_channel(card, c->arg & 0x1f)))
  531. break;
  532. chan->l3prot = (c->arg >> 8);
  533. #ifdef CONFIG_ISDN_TTY_FAX
  534. if (chan->l3prot == ISDN_PROTO_L3_FCLASS2) {
  535. chan->fax = c->parm.fax;
  536. eicon_log(card, 128, "idi_cmd: Ch%d: SETL3 struct fax=0x%xn",chan->No, chan->fax);
  537. }
  538. #endif
  539. return 0;
  540. case ISDN_CMD_GETL3:
  541. if (!card->flags & EICON_FLAGS_RUNNING)
  542. return -ENODEV;
  543. if (!(chan = find_channel(card, c->arg & 0x1f)))
  544. break;
  545. return chan->l3prot;
  546. case ISDN_CMD_GETEAZ:
  547. if (!card->flags & EICON_FLAGS_RUNNING)
  548. return -ENODEV;
  549. eicon_log(card, 1, "eicon CMD_GETEAZ not implementedn");
  550. return 0;
  551. case ISDN_CMD_SETSIL:
  552. if (!card->flags & EICON_FLAGS_RUNNING)
  553. return -ENODEV;
  554. eicon_log(card, 1, "eicon CMD_SETSIL not implementedn");
  555. return 0;
  556. case ISDN_CMD_GETSIL:
  557. if (!card->flags & EICON_FLAGS_RUNNING)
  558. return -ENODEV;
  559. eicon_log(card, 1, "eicon CMD_GETSIL not implementedn");
  560. return 0;
  561. case ISDN_CMD_LOCK:
  562. MOD_INC_USE_COUNT;
  563. return 0;
  564. case ISDN_CMD_UNLOCK:
  565. MOD_DEC_USE_COUNT;
  566. return 0;
  567. #ifdef CONFIG_ISDN_TTY_FAX
  568. case ISDN_CMD_FAXCMD:
  569. if (!card->flags & EICON_FLAGS_RUNNING)
  570. return -ENODEV;
  571. if (!(chan = find_channel(card, c->arg & 0x1f)))
  572. break;
  573. if (!chan->fax)
  574. break;
  575. idi_fax_cmd(card, chan);
  576. return 0;
  577. #endif
  578. case ISDN_CMD_AUDIO:
  579. if (!card->flags & EICON_FLAGS_RUNNING)
  580. return -ENODEV;
  581. if (!(chan = find_channel(card, c->arg & 0x1f)))
  582. break;
  583. idi_audio_cmd(card, chan, c->arg >> 8, c->parm.num);
  584. return 0;
  585. case CAPI_PUT_MESSAGE:
  586. if (!card->flags & EICON_FLAGS_RUNNING)
  587. return -ENODEV;
  588. if (!(chan = find_channel(card, c->arg & 0x1f)))
  589. break;
  590. if (c->parm.cmsg.Length < 8)
  591. break;
  592. switch(c->parm.cmsg.Command) {
  593. case CAPI_FACILITY:
  594. if (c->parm.cmsg.Subcommand == CAPI_REQ)
  595. return(capipmsg(card, chan, &c->parm.cmsg));
  596. break;
  597. case CAPI_MANUFACTURER:
  598. default:
  599. break;
  600. }
  601. return 0;
  602.         }
  604.         return -EINVAL;
  605. }
  607. /*
  608.  * Find card with given driverId
  609.  */
  610. static inline eicon_card *
  611. eicon_findcard(int driverid)
  612. {
  613.         eicon_card *p = cards;
  615.         while (p) {
  616.                 if (p->myid == driverid)
  617.                         return p;
  618.                 p = p->next;
  619.         }
  620.         return (eicon_card *) 0;
  621. }
  623. /*
  624.  * Wrapper functions for interface to linklevel
  625.  */
  626. static int
  627. if_command(isdn_ctrl * c)
  628. {
  629.         eicon_card *card = eicon_findcard(c->driver);
  631.         if (card)
  632.                 return (eicon_command(card, c));
  633.         printk(KERN_ERR
  634.              "eicon: if_command %d called with invalid driverId %d!n",
  635.                c->command, c->driver);
  636.         return -ENODEV;
  637. }
  639. static int
  640. if_writecmd(const u_char * buf, int len, int user, int id, int channel)
  641. {
  642.         return (len);
  643. }
  645. static int
  646. if_readstatus(u_char * buf, int len, int user, int id, int channel)
  647. {
  648. int count = 0;
  649. int cnt = 0;
  650. ulong flags = 0;
  651. u_char *p = buf;
  652. struct sk_buff *skb;
  654.         eicon_card *card = eicon_findcard(id);
  656.         if (card) {
  657.                 if (!card->flags & EICON_FLAGS_RUNNING)
  658.                         return -ENODEV;
  660. spin_lock_irqsave(&eicon_lock, flags);
  661. while((skb = skb_dequeue(&card->statq))) {
  663. if ((skb->len + count) > len)
  664. cnt = len - count;
  665. else
  666. cnt = skb->len;
  668. if (user)
  669. copy_to_user(p, skb->data, cnt);
  670. else
  671. memcpy(p, skb->data, cnt);
  673. count += cnt;
  674. p += cnt;
  676. if (cnt == skb->len) {
  677. dev_kfree_skb(skb);
  678. if (card->statq_entries > 0)
  679. card->statq_entries--;
  680. } else {
  681. skb_pull(skb, cnt);
  682. skb_queue_head(&card->statq, skb);
  683. spin_unlock_irqrestore(&eicon_lock, flags);
  684. return count;
  685. }
  686. }
  687. card->statq_entries = 0;
  688. spin_unlock_irqrestore(&eicon_lock, flags);
  689. return count;
  690.         }
  691.         printk(KERN_ERR
  692.                "eicon: if_readstatus called with invalid driverId!n");
  693.         return 0;
  694. }
  696. static int
  697. if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
  698. {
  699.         eicon_card *card = eicon_findcard(id);
  700. eicon_chan *chan;
  701. int ret = 0;
  702. int len;
  704. len = skb->len;
  706.         if (card) {
  707.                 if (!card->flags & EICON_FLAGS_RUNNING)
  708.                         return -ENODEV;
  709.          if (!(chan = find_channel(card, channel)))
  710. return -ENODEV;
  712. if (chan->fsm_state == EICON_STATE_ACTIVE) {
  713. #ifdef CONFIG_ISDN_TTY_FAX
  714. if (chan->l2prot == ISDN_PROTO_L2_FAX) {
  715. if ((ret = idi_faxdata_send(card, chan, skb)) > 0)
  716. ret = len;
  717. }
  718. else
  719. #endif
  720. ret = idi_send_data(card, chan, ack, skb, 1, 1);
  721. return (ret);
  722. } else {
  723. return -ENODEV;
  724. }
  725.         }
  726.         printk(KERN_ERR
  727.                "eicon: if_sendbuf called with invalid driverId!n");
  728.         return -ENODEV;
  729. }
  731. /* jiftime() copied from HiSax */
  732. static inline int jiftime(char *s, long mark)
  733. {
  734.         s += 8;
  736.         *s-- = '';
  737.         *s-- = mark % 10 + '0';
  738.         mark /= 10;
  739.         *s-- = mark % 10 + '0';
  740.         mark /= 10;
  741.         *s-- = '.';
  742.         *s-- = mark % 10 + '0';
  743.         mark /= 10;
  744.         *s-- = mark % 6 + '0';
  745.         mark /= 6;
  746.         *s-- = ':';
  747.         *s-- = mark % 10 + '0';
  748.         mark /= 10;
  749.         *s-- = mark % 10 + '0';
  750.         return(8);
  751. }
  753. void
  754. eicon_putstatus(eicon_card * card, char * buf)
  755. {
  756. ulong flags;
  757. int count;
  758. isdn_ctrl cmd;
  759. u_char *p;
  760. struct sk_buff *skb;
  762. if (!card) {
  763. if (!(card = cards))
  764. return;
  765. }
  767. spin_lock_irqsave(&eicon_lock, flags);
  768. count = strlen(buf);
  769. skb = alloc_skb(count, GFP_ATOMIC);
  770. if (!skb) {
  771. spin_unlock_irqrestore(&eicon_lock, flags);
  772. printk(KERN_ERR "eicon: could not alloc skb in putstatusn");
  773. return;
  774. }
  775. p = skb_put(skb, count);
  776. memcpy(p, buf, count);
  778. skb_queue_tail(&card->statq, skb);
  780. if (card->statq_entries >= MAX_STATUS_BUFFER) {
  781. if ((skb = skb_dequeue(&card->statq))) {
  782. count -= skb->len;
  783. dev_kfree_skb(skb);
  784. } else
  785. count = 0;
  786. } else
  787. card->statq_entries++;
  789. spin_unlock_irqrestore(&eicon_lock, flags);
  790.         if (count) {
  791.                 cmd.command = ISDN_STAT_STAVAIL;
  792.                 cmd.driver = card->myid;
  793.                 cmd.arg = count;
  794. card->interface.statcallb(&cmd);
  795.         }
  796. }
  798. /*
  799.  * Debug and Log 
  800.  */
  801. void
  802. eicon_log(eicon_card * card, int level, const char *fmt, ...)
  803. {
  804. va_list args;
  805. char Line[160];
  806. u_char *p;
  809. if ((DebugVar & level) || (DebugVar & 256)) {
  810. va_start(args, fmt);
  812. if (DebugVar & level) {
  813. if (DebugVar & 256) {
  814. /* log-buffer */
  815. p = Line;
  816. p += jiftime(p, jiffies);
  817. *p++ = 32;
  818. p += vsprintf(p, fmt, args);
  819. *p = 0;
  820. eicon_putstatus(card, Line);
  821. } else {
  822. /* printk, syslogd */
  823. vsprintf(Line, fmt, args);
  824. printk(KERN_DEBUG "%s", Line);
  825. }
  826. }
  828. va_end(args);
  829. }
  830. }
  833. /*
  834.  * Allocate a new card-struct, initialize it
  835.  * link it into cards-list.
  836.  */
  837. static void
  838. eicon_alloccard(int Type, int membase, int irq, char *id, int card_id)
  839. {
  840. int i;
  841. int j;
  842. int qloop;
  843. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  844. char qid[5];
  845. #endif
  846.         eicon_card *card;
  848. qloop = (Type == EICON_CTYPE_QUADRO)?2:0;
  849. for (i = 0; i <= qloop; i++) {
  850. if (!(card = (eicon_card *) kmalloc(sizeof(eicon_card), GFP_KERNEL))) {
  851. eicon_log(card, 1,
  852.        "eicon: (%s) Could not allocate card-struct.n", id);
  853. return;
  854. }
  855. memset((char *) card, 0, sizeof(eicon_card));
  856. skb_queue_head_init(&card->sndq);
  857. skb_queue_head_init(&card->rcvq);
  858. skb_queue_head_init(&card->rackq);
  859. skb_queue_head_init(&card->sackq);
  860. skb_queue_head_init(&card->statq);
  861. card->statq_entries = 0;
  862. card->snd_tq.routine = (void *) (void *) eicon_transmit;
  863. card->snd_tq.data = card;
  864. card->rcv_tq.routine = (void *) (void *) eicon_rcv_dispatch;
  865. card->rcv_tq.data = card;
  866. card->ack_tq.routine = (void *) (void *) eicon_ack_dispatch;
  867. card->ack_tq.data = card;
  868. card->interface.maxbufsize = 4000;
  869. card->interface.command = if_command;
  870. card->interface.writebuf_skb = if_sendbuf;
  871. card->interface.writecmd = if_writecmd;
  872. card->interface.readstat = if_readstatus;
  873. card->interface.features =
  874. ISDN_FEATURE_L2_X75I |
  875. ISDN_FEATURE_L2_HDLC |
  876. ISDN_FEATURE_L2_TRANS |
  877. ISDN_FEATURE_L3_TRANS |
  878. ISDN_FEATURE_P_UNKNOWN;
  879. card->interface.hl_hdrlen = 20;
  880. card->ptype = ISDN_PTYPE_UNKNOWN;
  881. strncpy(card->interface.id, id, sizeof(card->interface.id) - 1);
  882. card->myid = -1;
  883. card->type = Type;
  884. switch (Type) {
  885. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  886. #if CONFIG_MCA /* only needed for MCA */
  887.                         case EICON_CTYPE_S:
  888.                         case EICON_CTYPE_SX:
  889.                         case EICON_CTYPE_SCOM:
  890. if (MCA_bus) {
  891.                                 if (membase == -1)
  892.                                          membase = EICON_ISA_MEMBASE;
  893.                                  if (irq == -1)
  894.                                          irq = EICON_ISA_IRQ;
  895.                                 card->bus = EICON_BUS_MCA;
  896.                                  card->hwif.isa.card = (void *)card;
  897.                                  card->hwif.isa.shmem = (eicon_isa_shmem *)membase;
  898. card->hwif.isa.physmem = (unsigned long)membase;
  899.                                  card->hwif.isa.master = 1;
  901.                                 card->hwif.isa.irq = irq;
  902.                                  card->hwif.isa.type = Type;
  903.                                  card->nchannels = 2;
  904.                                  card->interface.channels = 1;
  905. } else {
  906. printk(KERN_WARNING
  907. "eicon (%s): no MCA bus detected.n",
  908. card->interface.id);
  909. kfree(card);
  910. return;
  911. }
  912.                                 break;
  913. #endif /* CONFIG_MCA */
  914. case EICON_CTYPE_QUADRO:
  915. if (membase == -1)
  916. membase = EICON_ISA_MEMBASE;
  917. if (irq == -1)
  918. irq = EICON_ISA_IRQ;
  919.                                 card->bus = EICON_BUS_ISA;
  920. card->hwif.isa.card = (void *)card;
  921. card->hwif.isa.shmem = (eicon_isa_shmem *)(membase + (i+1) * EICON_ISA_QOFFSET);
  922. card->hwif.isa.physmem = (unsigned long)(membase + (i+1) * EICON_ISA_QOFFSET);
  923. card->hwif.isa.master = 0;
  924. strcpy(card->interface.id, id);
  925. if (id[strlen(id) - 1] == 'a') {
  926. card->interface.id[strlen(id) - 1] = 'a' + i + 1;
  927. } else {
  928. sprintf(qid, "_%c",'2' + i);
  929. strcat(card->interface.id, qid);
  930. }
  931. printk(KERN_INFO "Eicon: Quadro: Driver-Id %s added.n",
  932. card->interface.id);
  933. if (i == 0) {
  934. eicon_card *p = cards;
  935. while(p) {
  936. if ((p->hwif.isa.master) && (p->hwif.isa.irq == irq)) {
  937. p->qnext = card;
  938. break;
  939. }
  940. p = p->next;
  941. }
  942. if (!p) {
  943. eicon_log(card, 1, "eicon_alloccard: Quadro Master not found.n");
  944. kfree(card);
  945. return;
  946. }
  947. } else {
  948. cards->qnext = card;
  949. }
  950. card->hwif.isa.irq = irq;
  951. card->hwif.isa.type = Type;
  952. card->nchannels = 2;
  953. card->interface.channels = 1;
  954. break;
  955. #endif
  956. #ifdef CONFIG_PCI
  957. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  958. case EICON_CTYPE_MAESTRA:
  959.                                 card->bus = EICON_BUS_PCI;
  960. card->interface.features |=
  961. ISDN_FEATURE_L2_V11096 |
  962. ISDN_FEATURE_L2_V11019 |
  963. ISDN_FEATURE_L2_V11038 |
  964. ISDN_FEATURE_L2_MODEM |
  965. ISDN_FEATURE_L2_FAX | 
  966. ISDN_FEATURE_L3_TRANSDSP |
  967. ISDN_FEATURE_L3_FCLASS2;
  968.                                 card->hwif.pci.card = (void *)card;
  969.                                 card->hwif.pci.master = card_id;
  970.                                 card->hwif.pci.irq = irq;
  971.                                 card->hwif.pci.type = Type;
  972. card->flags = 0;
  973.                                 card->nchannels = 2;
  974. card->interface.channels = 1;
  975. break;
  977. case EICON_CTYPE_MAESTRAQ:
  978.                                 card->bus = EICON_BUS_PCI;
  979. card->interface.features |=
  980. ISDN_FEATURE_L2_V11096 |
  981. ISDN_FEATURE_L2_V11019 |
  982. ISDN_FEATURE_L2_V11038 |
  983. ISDN_FEATURE_L2_MODEM |
  984. ISDN_FEATURE_L2_FAX | 
  985. ISDN_FEATURE_L3_TRANSDSP |
  986. ISDN_FEATURE_L3_FCLASS2;
  987.                                 card->hwif.pci.card = (void *)card;
  988.                                 card->hwif.pci.master = card_id;
  989.                                 card->hwif.pci.irq = irq;
  990.                                 card->hwif.pci.type = Type;
  991. card->flags = 0;
  992.                                 card->nchannels = 2;
  993. card->interface.channels = 1;
  994. break;
  996. case EICON_CTYPE_MAESTRAP:
  997.                                 card->bus = EICON_BUS_PCI;
  998. card->interface.features |=
  999. ISDN_FEATURE_L2_V11096 |
  1000. ISDN_FEATURE_L2_V11019 |
  1001. ISDN_FEATURE_L2_V11038 |
  1002. ISDN_FEATURE_L2_MODEM |
  1003. ISDN_FEATURE_L2_FAX |
  1004. ISDN_FEATURE_L3_TRANSDSP |
  1005. ISDN_FEATURE_L3_FCLASS2;
  1006.                                 card->hwif.pci.card = (void *)card;
  1007.                                 card->hwif.pci.master = card_id;
  1008.                                 card->hwif.pci.irq = irq;
  1009.                                 card->hwif.pci.type = Type;
  1010. card->flags = 0;
  1011.                                 card->nchannels = 30;
  1012. card->interface.channels = 1;
  1013. break;
  1014. #endif
  1015. #endif
  1016. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1017. case EICON_CTYPE_ISABRI:
  1018. if (membase == -1)
  1019. membase = EICON_ISA_MEMBASE;
  1020. if (irq == -1)
  1021. irq = EICON_ISA_IRQ;
  1022. card->bus = EICON_BUS_ISA;
  1023. card->hwif.isa.card = (void *)card;
  1024. card->hwif.isa.shmem = (eicon_isa_shmem *)membase;
  1025. card->hwif.isa.physmem = (unsigned long)membase;
  1026. card->hwif.isa.master = 1;
  1027. card->hwif.isa.irq = irq;
  1028. card->hwif.isa.type = Type;
  1029. card->nchannels = 2;
  1030. card->interface.channels = 1;
  1031. break;
  1032. case EICON_CTYPE_ISAPRI:
  1033. if (membase == -1)
  1034. membase = EICON_ISA_MEMBASE;
  1035. if (irq == -1)
  1036. irq = EICON_ISA_IRQ;
  1037.                                 card->bus = EICON_BUS_ISA;
  1038. card->hwif.isa.card = (void *)card;
  1039. card->hwif.isa.shmem = (eicon_isa_shmem *)membase;
  1040. card->hwif.isa.physmem = (unsigned long)membase;
  1041. card->hwif.isa.master = 1;
  1042. card->hwif.isa.irq = irq;
  1043. card->hwif.isa.type = Type;
  1044. card->nchannels = 30;
  1045. card->interface.channels = 1;
  1046. break;
  1047. #endif
  1048. default:
  1049. eicon_log(card, 1, "eicon_alloccard: Invalid type %dn", Type);
  1050. kfree(card);
  1051. return;
  1052. }
  1053. if (!(card->bch = (eicon_chan *) kmalloc(sizeof(eicon_chan) * (card->nchannels + 1)
  1054.  , GFP_KERNEL))) {
  1055. eicon_log(card, 1,
  1056.        "eicon: (%s) Could not allocate bch-struct.n", id);
  1057. kfree(card);
  1058. return;
  1059. }
  1060. for (j=0; j< (card->nchannels + 1); j++) {
  1061. memset((char *)&card->bch[j], 0, sizeof(eicon_chan));
  1062. card->bch[j].statectrl = 0;
  1063. card->bch[j].l2prot = ISDN_PROTO_L2_X75I;
  1064. card->bch[j].l3prot = ISDN_PROTO_L3_TRANS;
  1065. card->bch[j].e.D3Id = 0;
  1066. card->bch[j].e.B2Id = 0;
  1067. card->bch[j].e.Req = 0;
  1068. card->bch[j].No = j;
  1069. card->bch[j].tskb1 = NULL;
  1070. card->bch[j].tskb2 = NULL;
  1071. skb_queue_head_init(&card->bch[j].e.X);
  1072. skb_queue_head_init(&card->bch[j].e.R);
  1073. }
  1075. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1076. /* *** Diva Server *** */
  1077. if (!(card->dbuf = (DBUFFER *) kmalloc((sizeof(DBUFFER) * (card->nchannels + 1))*2
  1078.  , GFP_KERNEL))) {
  1079. eicon_log(card, 1,
  1080.        "eicon: (%s) Could not allocate DBUFFER-struct.n", id);
  1081. kfree(card);
  1082. kfree(card->bch);
  1083. return;
  1084. }
  1085. if (!(card->sbuf = (BUFFERS *) kmalloc((sizeof(BUFFERS) * (card->nchannels + 1)) * 2, GFP_KERNEL))) {
  1086. eicon_log(card, 1,
  1087.        "eicon: (%s) Could not allocate BUFFERS-struct.n", id);
  1088. kfree(card);
  1089. kfree(card->bch);
  1090. kfree(card->dbuf);
  1091. return;
  1092. }
  1093. if (!(card->sbufp = (char *) kmalloc((270 * (card->nchannels + 1)) * 2, GFP_KERNEL))) {
  1094. eicon_log(card, 1,
  1095.        "eicon: (%s) Could not allocate BUFFERSP-struct.n", id);
  1096. kfree(card);
  1097. kfree(card->bch);
  1098. kfree(card->dbuf);
  1099. kfree(card->sbuf);
  1100. return;
  1101. }
  1102. for (j=0; j< (card->nchannels + 1); j++) {
  1103. memset((char *)&card->dbuf[j], 0, sizeof(DBUFFER));
  1104. card->bch[j].de.RBuffer = (DBUFFER *)&card->dbuf[j];
  1105. memset((char *)&card->dbuf[j+(card->nchannels+1)], 0, sizeof(BUFFERS));
  1106. card->bch[j].be.RBuffer = (DBUFFER *)&card->dbuf[j+(card->nchannels+1)];
  1108. memset((char *)&card->sbuf[j], 0, sizeof(BUFFERS));
  1109. card->bch[j].de.X = (BUFFERS *)&card->sbuf[j];
  1110. memset((char *)&card->sbuf[j+(card->nchannels+1)], 0, sizeof(BUFFERS));
  1111. card->bch[j].be.X = (BUFFERS *)&card->sbuf[j+(card->nchannels+1)];
  1113. memset((char *)&card->sbufp[j], 0, 270);
  1114. card->bch[j].de.X->P = (char *)&card->sbufp[j * 270];
  1115. memset((char *)&card->sbufp[j+(card->nchannels+1)], 0, 270);
  1116. card->bch[j].be.X->P = (char *)&card->sbufp[(j+(card->nchannels+1)) * 270];
  1117. }
  1118. /* *** */
  1119. #endif /* CONFIG_ISDN_DRV_EICON_PCI */
  1121. card->next = cards;
  1122. cards = card;
  1123. }
  1124. }
  1126. /*
  1127.  * register card at linklevel
  1128.  */
  1129. static int
  1130. eicon_registercard(eicon_card * card)
  1131. {
  1132.         switch (card->bus) {
  1133. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1134. case EICON_BUS_ISA:
  1135. /* TODO something to print */
  1136. break;
  1137. #ifdef CONFIG_MCA
  1138. case EICON_BUS_MCA:
  1139. eicon_isa_printpar(&card->hwif.isa);
  1140. break;
  1141. #endif /* CONFIG_MCA */
  1142. #endif
  1143. case EICON_BUS_PCI:
  1144. break;
  1145. default:
  1146. eicon_log(card, 1,
  1147.        "eicon_registercard: Illegal BUS type %dn",
  1148.        card->bus);
  1149. return -1;
  1150.         }
  1151.         if (!register_isdn(&card->interface)) {
  1152.                 printk(KERN_WARNING
  1153.                        "eicon_registercard: Unable to register %sn",
  1154.                        card->interface.id);
  1155.                 return -1;
  1156.         }
  1157.         card->myid = card->interface.channels;
  1158.         sprintf(card->regname, "%s", card->interface.id);
  1159.         return 0;
  1160. }
  1162. static void __exit
  1163. unregister_card(eicon_card * card)
  1164. {
  1165.         isdn_ctrl cmd;
  1167.         cmd.command = ISDN_STAT_UNLOAD;
  1168.         cmd.driver = card->myid;
  1169.         card->interface.statcallb(&cmd);
  1170.         switch (card->bus) {
  1171. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1172. case EICON_BUS_ISA:
  1173. #ifdef CONFIG_MCA
  1174. case EICON_BUS_MCA:
  1175. #endif /* CONFIG_MCA */
  1176. eicon_isa_release(&card->hwif.isa);
  1177. break;
  1178. #endif
  1179. case EICON_BUS_PCI:
  1180. break;
  1181. default:
  1182. eicon_log(card, 1,
  1183.        "eicon: Invalid BUS type %dn",
  1184.        card->bus);
  1185. break;
  1186.         }
  1187. }
  1189. static void
  1190. eicon_freecard(eicon_card *card) {
  1191. int i;
  1193. for(i = 0; i < (card->nchannels + 1); i++) {
  1194. skb_queue_purge(&card->bch[i].e.X);
  1195. skb_queue_purge(&card->bch[i].e.R);
  1196. }
  1197. skb_queue_purge(&card->sndq);
  1198. skb_queue_purge(&card->rcvq);
  1199. skb_queue_purge(&card->rackq);
  1200. skb_queue_purge(&card->sackq);
  1201. skb_queue_purge(&card->statq);
  1203. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1204. kfree(card->sbufp);
  1205. kfree(card->sbuf);
  1206. kfree(card->dbuf);
  1207. #endif
  1208. kfree(card->bch);
  1209. kfree(card);
  1210. }
  1212. int
  1213. eicon_addcard(int Type, int membase, int irq, char *id, int card_id)
  1214. {
  1215. eicon_card *p;
  1216. eicon_card *q = NULL;
  1217. int registered;
  1218. int added = 0;
  1219. int failed = 0;
  1221. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1222. if (!Type) /* ISA */
  1223. if ((Type = eicon_isa_find_card(membase, irq, id)) < 0)
  1224. return 0;
  1225. #endif
  1226. eicon_alloccard(Type, membase, irq, id, card_id);
  1227.         p = cards;
  1228.         while (p) {
  1229. registered = 0;
  1230. if (!p->interface.statcallb) {
  1231. /* Not yet registered.
  1232.  * Try to register and activate it.
  1233.  */
  1234. added++;
  1235. switch (p->bus) {
  1236. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1237. case EICON_BUS_ISA:
  1238. case EICON_BUS_MCA:
  1239. if (eicon_registercard(p))
  1240. break;
  1241. registered = 1;
  1242. break;
  1243. #endif
  1244. case EICON_BUS_PCI:
  1245. #ifdef CONFIG_PCI
  1246. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1247. if (eicon_registercard(p))
  1248. break;
  1249. registered = 1;
  1250. break;
  1251. #endif
  1252. #endif
  1253. default:
  1254. printk(KERN_ERR
  1255.        "eicon: addcard: Invalid BUS type %dn",
  1256.        p->bus);
  1257. }
  1258. } else
  1259. /* Card already registered */
  1260. registered = 1;
  1261.                 if (registered) {
  1262. /* Init OK, next card ... */
  1263.                         q = p;
  1264.                         p = p->next;
  1265.                 } else {
  1266.                         /* registering failed, remove card from list, free memory */
  1267.                         printk(KERN_ERR
  1268.                                "eicon: Initialization of %s failedn",
  1269.                                p->interface.id);
  1270.                         if (q) {
  1271.                                 q->next = p->next;
  1272.                                 eicon_freecard(p);
  1273.                                 p = q->next;
  1274.                         } else {
  1275.                                 cards = p->next;
  1276.                                 eicon_freecard(p);
  1277.                                 p = cards;
  1278.                         }
  1279. failed++;
  1280.                 }
  1281. }
  1282.         return (added - failed);
  1283. }
  1286. static int __init
  1287. eicon_init(void)
  1288. {
  1289. int card_count = 0;
  1290. char tmprev[50];
  1292. DebugVar = 1;
  1293. eicon_lock = (spinlock_t) SPIN_LOCK_UNLOCKED;
  1295.         printk(KERN_INFO "%s Rev: ", DRIVERNAME);
  1296. strcpy(tmprev, eicon_revision);
  1297. printk("%s/", eicon_getrev(tmprev));
  1298. strcpy(tmprev, eicon_pci_revision);
  1299. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1300. printk("%s/", eicon_getrev(tmprev));
  1301. #else
  1302. printk("---/");
  1303. #endif
  1304. strcpy(tmprev, eicon_isa_revision);
  1305. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1306. printk("%s/", eicon_getrev(tmprev));
  1307. #else
  1308. printk("---/");
  1309. #endif
  1310. strcpy(tmprev, eicon_idi_revision);
  1311. printk("%sn", eicon_getrev(tmprev));
  1312.         printk(KERN_INFO "%s Release: %s%sn", DRIVERNAME,
  1313. DRIVERRELEASE, DRIVERPATCH);
  1315. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1316. #ifdef CONFIG_MCA
  1317. /* Check if we have MCA-bus */
  1318.         if (!MCA_bus)
  1319.                 {
  1320.                 printk(KERN_INFO
  1321.                         "eicon: No MCA bus, ISDN-interfaces  not probed.n");
  1322.         } else {
  1323. eicon_log(NULL, 8,
  1324. "eicon_mca_find_card, irq=%d.n", 
  1325. irq);
  1326.                 if (!eicon_mca_find_card(0, membase, irq, id))
  1327.                        card_count++;
  1328.         };
  1329. #else
  1330. card_count = eicon_addcard(0, membase, irq, id, 0);
  1331. #endif /* CONFIG_MCA */
  1332. #endif /* CONFIG_ISDN_DRV_EICON_ISA */
  1333.  
  1334. #ifdef CONFIG_PCI
  1335. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1336. DivasCardsDiscover();
  1337. card_count += eicon_pci_find_card(id);
  1338. #endif
  1339. #endif
  1341.         if (!cards) {
  1342. #ifdef MODULE
  1343. #ifndef CONFIG_ISDN_DRV_EICON_PCI
  1344. #ifndef CONFIG_ISDN_DRV_EICON_ISA
  1345.                 printk(KERN_INFO "Eicon: Driver is neither ISA nor PCI compiled !n");
  1346.                 printk(KERN_INFO "Eicon: Driver not loaded !n");
  1347. #else
  1348.                 printk(KERN_INFO "Eicon: No cards defined, driver not loaded !n");
  1349. #endif
  1350. #else
  1351.                 printk(KERN_INFO "Eicon: No PCI-cards found, driver not loaded !n");
  1352. #endif
  1353. #endif /* MODULE */
  1354. return -ENODEV;
  1356. } else
  1357. printk(KERN_INFO "Eicon: %d card%s addedn", card_count, 
  1358.                        (card_count>1)?"s":"");
  1359.         return 0;
  1360. }
  1362. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1363. void DIVA_DIDD_Write(DESCRIPTOR *, int);
  1364. EXPORT_SYMBOL_NOVERS(DIVA_DIDD_Read);
  1365. EXPORT_SYMBOL_NOVERS(DIVA_DIDD_Write);
  1366. EXPORT_SYMBOL_NOVERS(DivasPrintf);
  1367. #else
  1368. int DivasCardNext;
  1369. card_t DivasCards[1];
  1370. #endif
  1372. static void __exit
  1373. eicon_exit(void)
  1374. {
  1375. #if CONFIG_PCI
  1376. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1377. card_t *pCard;
  1378. word wCardIndex;
  1379. extern int Divas_major;
  1380. int iTmp = 0;
  1381. #endif
  1382. #endif
  1384.         eicon_card *card = cards;
  1385.         eicon_card *last;
  1387.         while (card) {
  1388. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1389. #ifdef CONFIG_MCA
  1390.          if (MCA_bus)
  1391.                         {
  1392.                         mca_mark_as_unused (card->mca_slot);
  1393.                         mca_set_adapter_procfn(card->mca_slot, NULL, NULL);
  1394.                         };
  1395. #endif /* CONFIG_MCA */
  1396. #endif
  1397.                 unregister_card(card); 
  1398.                 card = card->next;
  1399.         }
  1400.         card = cards;
  1401.         while (card) {
  1402.                 last = card;
  1403.                 card = card->next;
  1404. eicon_freecard(last);
  1405.         }
  1407. #if CONFIG_PCI
  1408. #ifdef CONFIG_ISDN_DRV_EICON_PCI
  1409. pCard = DivasCards;
  1410. for (wCardIndex = 0; wCardIndex < MAX_CARDS; wCardIndex++)
  1411. {
  1412. if ((pCard->hw) && (pCard->hw->in_use))
  1413. {
  1414. (*pCard->card_reset)(pCard);
  1416. UxIsrRemove(pCard->hw, pCard);
  1417. UxCardHandleFree(pCard->hw);
  1419. if(pCard->e_tbl != NULL)
  1420. {
  1421. kfree(pCard->e_tbl);
  1422. }
  1424. if(pCard->hw->card_type == DIA_CARD_TYPE_DIVA_SERVER_B)
  1425. {
  1426. release_region(pCard->hw->io_base,0x20);
  1427. release_region(pCard->hw->reset_base,0x80);
  1428. }
  1430.                         // If this is a 4BRI ...
  1431.                         if (pCard->hw->card_type == DIA_CARD_TYPE_DIVA_SERVER_Q)
  1432.                         {
  1433.                                 // Skip over the next 3 virtual adapters
  1434.                                 wCardIndex += 3;
  1436.                                 // But free their handles
  1437. for (iTmp = 0; iTmp < 3; iTmp++)
  1438. {
  1439. pCard++;
  1440. UxCardHandleFree(pCard->hw);
  1442. if(pCard->e_tbl != NULL)
  1443. {
  1444. kfree(pCard->e_tbl);
  1445. }
  1446. }
  1447.                         }
  1448. }
  1449. pCard++;
  1450. }
  1451. unregister_chrdev(Divas_major, "Divas");
  1452. #endif
  1453. #endif /* CONFIG_PCI */
  1454.         printk(KERN_INFO "%s unloadedn", DRIVERNAME);
  1455. }
  1457. #ifndef MODULE
  1459. static int __init
  1460. eicon_setup(char *line)
  1461. {
  1462.         int i, argc;
  1463. int ints[5];
  1464. char *str;
  1466. str = get_options(line, 4, ints);
  1468.         argc = ints[0];
  1469.         i = 1;
  1470. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1471.         if (argc) {
  1472. membase = irq = -1;
  1473. if (argc) {
  1474. membase = ints[i];
  1475. i++;
  1476. argc--;
  1477. }
  1478. if (argc) {
  1479. irq = ints[i];
  1480. i++;
  1481. argc--;
  1482. }
  1483. if (strlen(str)) {
  1484. strcpy(id, str);
  1485. } else {
  1486. strcpy(id, "eicon");
  1487. } 
  1488.         printk(KERN_INFO "Eicon ISDN active driver setup (id=%s membase=0x%x irq=%d)n",
  1489. id, membase, irq);
  1490. }
  1491. #else
  1492. printk(KERN_INFO "Eicon ISDN active driver setupn");
  1493. #endif
  1494. return(1);
  1495. }
  1496. __setup("eicon=", eicon_setup);
  1498. #endif /* MODULE */
  1500. #ifdef CONFIG_ISDN_DRV_EICON_ISA
  1501. #ifdef CONFIG_MCA
  1503. struct eicon_mca_adapters_struct {
  1504. char * name;
  1505. int adf_id;
  1506. };
  1507. /* possible MCA-brands of eicon cards                                         */
  1508. struct eicon_mca_adapters_struct eicon_mca_adapters[] = {
  1509. { "ISDN-P/2 Adapter", 0x6abb },
  1510. { "ISDN-[S|SX|SCOM]/2 Adapter", 0x6a93 },
  1511. { "DIVA /MCA", 0x6336 },
  1512. { NULL, 0 },
  1513. };
  1515. int eicon_mca_find_card(int type,          /* type-idx of eicon-card          */
  1516.                         int membase,
  1517.         int irq,
  1518. char * id)         /* name of eicon-isdn-dev          */
  1519. {
  1520. int j, curr_slot = 0;
  1522.         eicon_log(NULL, 8,
  1523. "eicon_mca_find_card type: %d, membase: %#x, irq %d n",
  1524. type, membase, irq);
  1525. /* find a no-driver-assigned eicon card                               */
  1526. for (j=0; eicon_mca_adapters[j].adf_id != 0; j++) 
  1527. {
  1528. for ( curr_slot=0; curr_slot<=MCA_MAX_SLOT_NR; curr_slot++) 
  1529. {
  1530. curr_slot = mca_find_unused_adapter(
  1531.          eicon_mca_adapters[j].adf_id, curr_slot);
  1532. if (curr_slot != MCA_NOTFOUND) 
  1533. {
  1534. /* check if pre-set parameters match
  1535.    these of the card, check cards memory      */
  1536. if (!(int) eicon_mca_probe(curr_slot,
  1537.                                                            j,
  1538.                                                     membase, 
  1539.                                                            irq,
  1540.                                                            id))
  1541. {
  1542. return 0;
  1543. /* means: adapter parms did match     */
  1544. };
  1545. };
  1546. break;
  1547. /* MCA_NOTFOUND-branch: no matching adapter of
  1548.    THIS flavor found, next flavor                     */
  1550.              };
  1551. };
  1552. /* all adapter flavors checked without match, finito with:            */
  1553.         return -ENODEV;
  1554. };
  1557. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1558.  *  stolen from 3c523.c/elmc_getinfo, ewe, 10.5.1999 
  1559.  */
  1560. int eicon_info(char * buf, int slot, void *d)
  1561. {
  1562. int len = 0;
  1563. struct eicon_card *dev;
  1565.         dev = (struct eicon_card *) d;
  1567. if (dev == NULL)
  1568. return len;
  1569. len += sprintf(buf+len, "eicon ISDN adapter, type %d.n",dev->type);
  1570. len += sprintf(buf+len, "IRQ: %dn", dev->hwif.isa.irq);
  1571. len += sprintf(buf+len, "MEMBASE: %#lxn", (unsigned long)dev->hwif.isa.shmem);
  1573. return len;
  1574. };
  1576. int eicon_mca_probe(int slot,  /* slot-nr where the card was detected         */
  1577.     int a_idx, /* idx-nr of probed card in eicon_mca_adapters */
  1578.                     int membase,
  1579.                     int irq,
  1580.     char * id) /* name of eicon-isdn-dev                      */
  1581. {
  1582. unsigned char adf_pos0;
  1583. int cards_irq, cards_membase, cards_io;
  1584. int type = EICON_CTYPE_S;
  1585. int irq_array[]={0,3,4,2};
  1586. int irq_array1[]={3,4,0,0,2,10,11,12};
  1588.         adf_pos0 = mca_read_stored_pos(slot,2);
  1589. eicon_log(NULL, 8,
  1590. "eicon_mca_probe irq=%d, membase=%dn", 
  1591. irq,
  1592. membase);
  1593. switch (a_idx) {
  1594. case 0:                /* P/2-Adapter (== PRI/S2M ? )         */
  1595. cards_membase= 0xC0000+((adf_pos0>>4)*0x4000);
  1596. if (membase == -1) { 
  1597. membase = cards_membase;
  1598. } else {
  1599. if (membase != cards_membase)
  1600. return -ENODEV;
  1601. };
  1602. cards_irq=irq_array[((adf_pos0 & 0xC)>>2)];
  1603. if (irq == -1) { 
  1604. irq = cards_irq;
  1605. } else {
  1606. if (irq != cards_irq)
  1607. return -ENODEV;
  1608. };
  1609. cards_io= 0xC00 + ((adf_pos0>>4)*0x10);
  1610. type = EICON_CTYPE_ISAPRI; 
  1611. break;
  1613. case 1:                /* [S|SX|SCOM]/2                       */
  1614. cards_membase= 0xC0000+((adf_pos0>>4)*0x2000);
  1615. if (membase == -1) { 
  1616. membase = cards_membase;
  1617. } else {
  1618. if (membase != cards_membase)
  1619. return -ENODEV;
  1620. };
  1621. cards_irq=irq_array[((adf_pos0 & 0xC)>>2)];
  1622. if (irq == -1) { 
  1623. irq = cards_irq;
  1624. } else {
  1625. if (irq != cards_irq)
  1626. return -ENODEV;
  1627. };
  1629. cards_io= 0xC00 + ((adf_pos0>>4)*0x10);
  1630. type = EICON_CTYPE_SCOM; 
  1631.   break;
  1633. case 2:                /* DIVA/MCA                            */
  1634. cards_io = 0x200+ ((adf_pos0>>4)* 0x20);
  1635. cards_irq = irq_array1[(adf_pos0 & 0x7)];
  1636. if (irq == -1) { 
  1637. irq = cards_irq;
  1638. } else {
  1639. if (irq != cards_irq)
  1640. return -ENODEV;
  1641. };
  1642. type = 0; 
  1643. break;
  1644. default:
  1645. return -ENODEV;
  1646. };
  1647. /* matching membase & irq */
  1648. if ( 1 == eicon_addcard(type, membase, irq, id, 0)) { 
  1649. mca_set_adapter_name(slot, eicon_mca_adapters[a_idx].name);
  1650.    mca_set_adapter_procfn(slot, (MCA_ProcFn) eicon_info, cards);
  1652.          mca_mark_as_used(slot);
  1653. cards->mca_slot = slot; 
  1654. /* card->io noch setzen  oder ?? */
  1655. cards->mca_io = cards_io;
  1656. cards->hwif.isa.io = cards_io;
  1657. /* reset card */
  1658. outb_p(0,cards_io+1);
  1660. eicon_log(NULL, 8, "eicon_addcard: successful for slot # %d.n", 
  1661. cards->mca_slot+1);
  1662. return  0 ; /* eicon_addcard added a card */
  1663. } else {
  1664. return -ENODEV;
  1665. };
  1666. };
  1667. #endif /* CONFIG_MCA */
  1668. #endif /* CONFIG_ISDN_DRV_EICON_ISA */
  1670. module_init(eicon_init);
  1671. module_exit(eicon_exit);