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

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

Linux/Unix编程

开发平台：

Unix_Linux

module.c：源码内容
  1. /* $Id: module.c,v 1.1.4.1 2001/11/20 14:19:34 kai Exp $
  2.  *
  3.  * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000.
  4.  *
  5.  * Author       Fritz Elfert
  6.  * Copyright    by Fritz Elfert      <fritz@isdn4linux.de>
  7.  * 
  8.  * This software may be used and distributed according to the terms
  9.  * of the GNU General Public License, incorporated herein by reference.
  10.  *
  11.  * Thanks to Friedemann Baitinger and IBM Germany
  12.  *
  13.  */
  15. #include "act2000.h"
  16. #include "act2000_isa.h"
  17. #include "capi.h"
  18. #include <linux/module.h>
  19. #include <linux/init.h>
  21. static unsigned short act2000_isa_ports[] =
  22. {
  23.         0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
  24.         0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
  25. };
  26. #define ISA_NRPORTS (sizeof(act2000_isa_ports)/sizeof(unsigned short))
  28. static act2000_card *cards = (act2000_card *) NULL;
  30. /* Parameters to be set by insmod */
  31. static int   act_bus  =  0;
  32. static int   act_port = -1;  /* -1 = Autoprobe  */
  33. static int   act_irq  = -1;
  34. static char *act_id   = "";
  36. MODULE_DESCRIPTION(       "ISDN4Linux: Driver for IBM Active 2000 ISDN card");
  37. MODULE_AUTHOR(            "Fritz Elfert");
  38. MODULE_LICENSE(           "GPL");
  39. MODULE_PARM_DESC(act_bus, "BusType of first card, 1=ISA, 2=MCA, 3=PCMCIA, currently only ISA");
  40. MODULE_PARM_DESC(membase, "Base port address of first card");
  41. MODULE_PARM_DESC(act_irq, "IRQ of first card");
  42. MODULE_PARM_DESC(act_id,  "ID-String of first card");
  43. MODULE_PARM(act_bus,  "i");
  44. MODULE_PARM(act_port, "i");
  45. MODULE_PARM(act_irq,  "i");
  46. MODULE_PARM(act_id,   "s");
  48. static int act2000_addcard(int, int, int, char *);
  50. static act2000_chan *
  51. find_channel(act2000_card *card, int channel)
  52. {
  53. if ((channel >= 0) && (channel < ACT2000_BCH))
  54.          return &(card->bch[channel]);
  55. printk(KERN_WARNING "act2000: Invalid channel %dn", channel);
  56. return NULL;
  57. }
  59. /*
  60.  * Free MSN list
  61.  */
  62. static void
  63. act2000_clear_msn(act2000_card *card)
  64. {
  65.         struct msn_entry *p = card->msn_list;
  66.         struct msn_entry *q;
  67. unsigned long flags;
  69. save_flags(flags);
  70. cli();
  71.         card->msn_list = NULL;
  72. restore_flags(flags);
  73.         while (p) {
  74.                 q  = p->next;
  75.                 kfree(p);
  76.                 p = q;
  77.         }
  78. }
  80. /*
  81.  * Find an MSN entry in the list.
  82.  * If ia5 != 0, return IA5-encoded EAZ, else
  83.  * return a bitmask with corresponding bit set.
  84.  */
  85. static __u16
  86. act2000_find_msn(act2000_card *card, char *msn, int ia5)
  87. {
  88.         struct msn_entry *p = card->msn_list;
  89. __u8 eaz = '0';
  91. while (p) {
  92. if (!strcmp(p->msn, msn)) {
  93. eaz = p->eaz;
  94. break;
  95. }
  96. p = p->next;
  97. }
  98. if (!ia5)
  99. return (1 << (eaz - '0'));
  100. else
  101. return eaz;
  102. }
  104. /*
  105.  * Find an EAZ entry in the list.
  106.  * return a string with corresponding msn.
  107.  */
  108. char *
  109. act2000_find_eaz(act2000_card *card, char eaz)
  110. {
  111.         struct msn_entry *p = card->msn_list;
  113. while (p) {
  114. if (p->eaz == eaz)
  115. return(p->msn);
  116. p = p->next;
  117. }
  118. return("");
  119. }
  121. /*
  122.  * Add or delete an MSN to the MSN list
  123.  *
  124.  * First character of msneaz is EAZ, rest is MSN.
  125.  * If length of eazmsn is 1, delete that entry.
  126.  */
  127. static int
  128. act2000_set_msn(act2000_card *card, char *eazmsn)
  129. {
  130.         struct msn_entry *p = card->msn_list;
  131.         struct msn_entry *q = NULL;
  132. unsigned long flags;
  133. int i;
  135. if (!strlen(eazmsn))
  136. return 0;
  137. if (strlen(eazmsn) > 16)
  138. return -EINVAL;
  139. for (i = 0; i < strlen(eazmsn); i++)
  140. if (!isdigit(eazmsn[i]))
  141. return -EINVAL;
  142.         if (strlen(eazmsn) == 1) {
  143. /* Delete a single MSN */
  144. while (p) {
  145. if (p->eaz == eazmsn[0]) {
  146. save_flags(flags);
  147. cli();
  148. if (q)
  149. q->next = p->next;
  150. else
  151. card->msn_list = p->next;
  152. restore_flags(flags);
  153. kfree(p);
  154. printk(KERN_DEBUG
  155.        "Mapping for EAZ %c deletedn",
  156.        eazmsn[0]);
  157. return 0;
  158. }
  159. q = p;
  160. p = p->next;
  161. }
  162. return 0;
  163.         }
  164. /* Add a single MSN */
  165. while (p) {
  166. /* Found in list, replace MSN */
  167. if (p->eaz == eazmsn[0]) {
  168. save_flags(flags);
  169. cli();
  170. strcpy(p->msn, &eazmsn[1]);
  171. restore_flags(flags);
  172. printk(KERN_DEBUG
  173.        "Mapping for EAZ %c changed to %sn",
  174.        eazmsn[0],
  175.        &eazmsn[1]);
  176. return 0;
  177. }
  178. p = p->next;
  179. }
  180. /* Not found in list, add new entry */
  181. p = kmalloc(sizeof(msn_entry), GFP_KERNEL);
  182. if (!p)
  183. return -ENOMEM;
  184. p->eaz = eazmsn[0];
  185. strcpy(p->msn, &eazmsn[1]);
  186. p->next = card->msn_list;
  187. save_flags(flags);
  188. cli();
  189. card->msn_list = p;
  190. restore_flags(flags);
  191. printk(KERN_DEBUG
  192.        "Mapping %c -> %s addedn",
  193.        eazmsn[0],
  194.        &eazmsn[1]);
  195. return 0;
  196. }
  198. static void
  199. act2000_transmit(struct act2000_card *card)
  200. {
  201. switch (card->bus) {
  202. case ACT2000_BUS_ISA:
  203. act2000_isa_send(card);
  204. break;
  205. case ACT2000_BUS_PCMCIA:
  206. case ACT2000_BUS_MCA:
  207. default:
  208. printk(KERN_WARNING
  209.        "act2000_transmit: Illegal bustype %dn", card->bus);
  210. }
  211. }
  213. static void
  214. act2000_receive(struct act2000_card *card)
  215. {
  216. switch (card->bus) {
  217. case ACT2000_BUS_ISA:
  218. act2000_isa_receive(card);
  219. break;
  220. case ACT2000_BUS_PCMCIA:
  221. case ACT2000_BUS_MCA:
  222. default:
  223. printk(KERN_WARNING
  224.        "act2000_receive: Illegal bustype %dn", card->bus);
  225. }
  226. }
  228. static void
  229. act2000_poll(unsigned long data)
  230. {
  231. act2000_card * card = (act2000_card *)data;
  232. unsigned long flags;
  234. act2000_receive(card);
  235.         save_flags(flags);
  236.         cli();
  237.         mod_timer(&card->ptimer, jiffies+3);
  238.         restore_flags(flags);
  239. }
  241. static int
  242. act2000_command(act2000_card * card, isdn_ctrl * c)
  243. {
  244.         ulong a;
  245.         act2000_chan *chan;
  246. act2000_cdef cdef;
  247. isdn_ctrl cmd;
  248. char tmp[17];
  249. int ret;
  250. unsigned long flags;
  251.  
  252.         switch (c->command) {
  253. case ISDN_CMD_IOCTL:
  254. memcpy(&a, c->parm.num, sizeof(ulong));
  255. switch (c->arg) {
  256. case ACT2000_IOCTL_LOADBOOT:
  257. switch (card->bus) {
  258. case ACT2000_BUS_ISA:
  259. ret = act2000_isa_download(card,
  260.    (act2000_ddef *)a);
  261. if (!ret) {
  262. card->flags |= ACT2000_FLAGS_LOADED;
  263. if (!(card->flags & ACT2000_FLAGS_IVALID)) {
  264. card->ptimer.expires = jiffies + 3;
  265. card->ptimer.function = act2000_poll;
  266. card->ptimer.data = (unsigned long)card;
  267. add_timer(&card->ptimer);
  268. }
  269. actcapi_manufacturer_req_errh(card);
  270. }
  271. break;
  272. default:
  273. printk(KERN_WARNING
  274.        "act2000: Illegal BUS type %dn",
  275.        card->bus);
  276. ret = -EIO;
  277. }
  278. return ret;
  279. case ACT2000_IOCTL_SETPROTO:
  280. card->ptype = a?ISDN_PTYPE_EURO:ISDN_PTYPE_1TR6;
  281. if (!(card->flags & ACT2000_FLAGS_RUNNING))
  282. return 0;
  283. actcapi_manufacturer_req_net(card);
  284. return 0;
  285. case ACT2000_IOCTL_SETMSN:
  286. if ((ret = copy_from_user(tmp, (char *)a, sizeof(tmp))))
  287. return ret;
  288. if ((ret = act2000_set_msn(card, tmp)))
  289. return ret;
  290. if (card->flags & ACT2000_FLAGS_RUNNING)
  291. return(actcapi_manufacturer_req_msn(card));
  292. return 0;
  293. case ACT2000_IOCTL_ADDCARD:
  294. if ((ret = copy_from_user(&cdef, (char *)a, sizeof(cdef))))
  295. return ret;
  296. if (act2000_addcard(cdef.bus, cdef.port, cdef.irq, cdef.id))
  297. return -EIO;
  298. return 0;
  299. case ACT2000_IOCTL_TEST:
  300. if (!(card->flags & ACT2000_FLAGS_RUNNING))
  301. return -ENODEV;
  302. return 0;
  303. default:
  304. return -EINVAL;
  305. }
  306. break;
  307. case ISDN_CMD_DIAL:
  308. if (!card->flags & ACT2000_FLAGS_RUNNING)
  309. return -ENODEV;
  310. if (!(chan = find_channel(card, c->arg & 0x0f)))
  311. break;
  312. save_flags(flags);
  313. cli();
  314. if (chan->fsm_state != ACT2000_STATE_NULL) {
  315. restore_flags(flags);
  316. printk(KERN_WARNING "Dial on channel with state %dn",
  317. chan->fsm_state);
  318. return -EBUSY;
  319. }
  320. if (card->ptype == ISDN_PTYPE_EURO)
  321. tmp[0] = act2000_find_msn(card, c->parm.setup.eazmsn, 1);
  322. else
  323. tmp[0] = c->parm.setup.eazmsn[0];
  324. chan->fsm_state = ACT2000_STATE_OCALL;
  325. chan->callref = 0xffff;
  326. restore_flags(flags);
  327. ret = actcapi_connect_req(card, chan, c->parm.setup.phone,
  328.   tmp[0], c->parm.setup.si1,
  329.   c->parm.setup.si2);
  330. if (ret) {
  331. cmd.driver = card->myid;
  332. cmd.command = ISDN_STAT_DHUP;
  333. cmd.arg &= 0x0f;
  334. card->interface.statcallb(&cmd);
  335. }
  336. return ret;
  337. case ISDN_CMD_ACCEPTD:
  338. if (!card->flags & ACT2000_FLAGS_RUNNING)
  339. return -ENODEV;
  340. if (!(chan = find_channel(card, c->arg & 0x0f)))
  341. break;
  342. if (chan->fsm_state == ACT2000_STATE_ICALL)
  343. actcapi_select_b2_protocol_req(card, chan);
  344. return 0;
  345. case ISDN_CMD_ACCEPTB:
  346. if (!card->flags & ACT2000_FLAGS_RUNNING)
  347. return -ENODEV;
  348. return 0;
  349. case ISDN_CMD_HANGUP:
  350. if (!card->flags & ACT2000_FLAGS_RUNNING)
  351. return -ENODEV;
  352. if (!(chan = find_channel(card, c->arg & 0x0f)))
  353. break;
  354. switch (chan->fsm_state) {
  355. case ACT2000_STATE_ICALL:
  356. case ACT2000_STATE_BSETUP:
  357. actcapi_connect_resp(card, chan, 0x15);
  358. break;
  359. case ACT2000_STATE_ACTIVE:
  360. actcapi_disconnect_b3_req(card, chan);
  361. break;
  362. }
  363. return 0;
  364. case ISDN_CMD_SETEAZ:
  365. if (!card->flags & ACT2000_FLAGS_RUNNING)
  366. return -ENODEV;
  367. if (!(chan = find_channel(card, c->arg & 0x0f)))
  368. break;
  369. if (strlen(c->parm.num)) {
  370. if (card->ptype == ISDN_PTYPE_EURO) {
  371. chan->eazmask = act2000_find_msn(card, c->parm.num, 0);
  372. }
  373. if (card->ptype == ISDN_PTYPE_1TR6) {
  374. int i;
  375. chan->eazmask = 0;
  376. for (i = 0; i < strlen(c->parm.num); i++)
  377. if (isdigit(c->parm.num[i]))
  378. chan->eazmask |= (1 << (c->parm.num[i] - '0'));
  379. }
  380. } else
  381. chan->eazmask = 0x3ff;
  382. actcapi_listen_req(card);
  383. return 0;
  384. case ISDN_CMD_CLREAZ:
  385. if (!card->flags & ACT2000_FLAGS_RUNNING)
  386. return -ENODEV;
  387. if (!(chan = find_channel(card, c->arg & 0x0f)))
  388. break;
  389. chan->eazmask = 0;
  390. actcapi_listen_req(card);
  391. return 0;
  392. case ISDN_CMD_SETL2:
  393. if (!card->flags & ACT2000_FLAGS_RUNNING)
  394. return -ENODEV;
  395. if (!(chan = find_channel(card, c->arg & 0x0f)))
  396. break;
  397. chan->l2prot = (c->arg >> 8);
  398. return 0;
  399. case ISDN_CMD_GETL2:
  400. if (!card->flags & ACT2000_FLAGS_RUNNING)
  401. return -ENODEV;
  402. if (!(chan = find_channel(card, c->arg & 0x0f)))
  403. break;
  404. return chan->l2prot;
  405. case ISDN_CMD_SETL3:
  406. if (!card->flags & ACT2000_FLAGS_RUNNING)
  407. return -ENODEV;
  408. if ((c->arg >> 8) != ISDN_PROTO_L3_TRANS) {
  409. printk(KERN_WARNING "L3 protocol unknownn");
  410. return -1;
  411. }
  412. if (!(chan = find_channel(card, c->arg & 0x0f)))
  413. break;
  414. chan->l3prot = (c->arg >> 8);
  415. return 0;
  416. case ISDN_CMD_GETL3:
  417. if (!card->flags & ACT2000_FLAGS_RUNNING)
  418. return -ENODEV;
  419. if (!(chan = find_channel(card, c->arg & 0x0f)))
  420. break;
  421. return chan->l3prot;
  422. case ISDN_CMD_GETEAZ:
  423. if (!card->flags & ACT2000_FLAGS_RUNNING)
  424. return -ENODEV;
  425. printk(KERN_DEBUG "act2000 CMD_GETEAZ not implementedn");
  426. return 0;
  427. case ISDN_CMD_SETSIL:
  428. if (!card->flags & ACT2000_FLAGS_RUNNING)
  429. return -ENODEV;
  430. printk(KERN_DEBUG "act2000 CMD_SETSIL not implementedn");
  431. return 0;
  432. case ISDN_CMD_GETSIL:
  433. if (!card->flags & ACT2000_FLAGS_RUNNING)
  434. return -ENODEV;
  435. printk(KERN_DEBUG "act2000 CMD_GETSIL not implementedn");
  436. return 0;
  437. case ISDN_CMD_LOCK:
  438. MOD_INC_USE_COUNT;
  439. return 0;
  440. case ISDN_CMD_UNLOCK:
  441. MOD_DEC_USE_COUNT;
  442. return 0;
  443.         }
  445.         return -EINVAL;
  446. }
  448. static int
  449. act2000_sendbuf(act2000_card *card, int channel, int ack, struct sk_buff *skb)
  450. {
  451.         struct sk_buff *xmit_skb;
  452.         int len;
  453.         act2000_chan *chan;
  454. actcapi_msg *msg;
  456.         if (!(chan = find_channel(card, channel)))
  457. return -1;
  458.         if (chan->fsm_state != ACT2000_STATE_ACTIVE)
  459.                 return -1;
  460.         len = skb->len;
  461.         if ((chan->queued + len) >= ACT2000_MAX_QUEUED)
  462.                 return 0;
  463. if (!len)
  464. return 0;
  465. if (skb_headroom(skb) < 19) {
  466. printk(KERN_WARNING "act2000_sendbuf: Headroom only %dn",
  467.        skb_headroom(skb));
  468. xmit_skb = alloc_skb(len + 19, GFP_ATOMIC);
  469. if (!xmit_skb) {
  470. printk(KERN_WARNING "act2000_sendbuf: Out of memoryn");
  471. return 0;
  472. }
  473. skb_reserve(xmit_skb, 19);
  474. memcpy(skb_put(xmit_skb, len), skb->data, len);
  475. } else {
  476. xmit_skb = skb_clone(skb, GFP_ATOMIC);
  477. if (!xmit_skb) {
  478. printk(KERN_WARNING "act2000_sendbuf: Out of memoryn");
  479. return 0;
  480. }
  481. }
  482. dev_kfree_skb(skb);
  483. msg = (actcapi_msg *)skb_push(xmit_skb, 19);
  484. msg->hdr.len = 19 + len;
  485. msg->hdr.applicationID = 1;
  486. msg->hdr.cmd.cmd = 0x86;
  487. msg->hdr.cmd.subcmd = 0x00;
  488. msg->hdr.msgnum = actcapi_nextsmsg(card);
  489. msg->msg.data_b3_req.datalen = len;
  490. msg->msg.data_b3_req.blocknr = (msg->hdr.msgnum & 0xff);
  491. msg->msg.data_b3_req.fakencci = MAKE_NCCI(chan->plci, 0, chan->ncci);
  492. msg->msg.data_b3_req.flags = ack; /* Will be set to 0 on actual sending */
  493. actcapi_debug_msg(xmit_skb, 1);
  494.         chan->queued += len;
  495. skb_queue_tail(&card->sndq, xmit_skb);
  496. act2000_schedule_tx(card);
  497.         return len;
  498. }
  501. /* Read the Status-replies from the Interface */
  502. static int
  503. act2000_readstatus(u_char * buf, int len, int user, act2000_card * card)
  504. {
  505.         int count;
  506.         u_char *p;
  508.         for (p = buf, count = 0; count < len; p++, count++) {
  509.                 if (card->status_buf_read == card->status_buf_write)
  510.                         return count;
  511.                 if (user)
  512.                         put_user(*card->status_buf_read++, p);
  513.                 else
  514.                         *p = *card->status_buf_read++;
  515.                 if (card->status_buf_read > card->status_buf_end)
  516.                         card->status_buf_read = card->status_buf;
  517.         }
  518.         return count;
  519. }
  521. /*
  522.  * Find card with given driverId
  523.  */
  524. static inline act2000_card *
  525. act2000_findcard(int driverid)
  526. {
  527.         act2000_card *p = cards;
  529.         while (p) {
  530.                 if (p->myid == driverid)
  531.                         return p;
  532.                 p = p->next;
  533.         }
  534.         return (act2000_card *) 0;
  535. }
  537. /*
  538.  * Wrapper functions for interface to linklevel
  539.  */
  540. static int
  541. if_command(isdn_ctrl * c)
  542. {
  543.         act2000_card *card = act2000_findcard(c->driver);
  545.         if (card)
  546.                 return (act2000_command(card, c));
  547.         printk(KERN_ERR
  548.              "act2000: if_command %d called with invalid driverId %d!n",
  549.                c->command, c->driver);
  550.         return -ENODEV;
  551. }
  553. static int
  554. if_writecmd(const u_char * buf, int len, int user, int id, int channel)
  555. {
  556.         act2000_card *card = act2000_findcard(id);
  558.         if (card) {
  559.                 if (!card->flags & ACT2000_FLAGS_RUNNING)
  560.                         return -ENODEV;
  561.                 return (len);
  562.         }
  563.         printk(KERN_ERR
  564.                "act2000: if_writecmd called with invalid driverId!n");
  565.         return -ENODEV;
  566. }
  568. static int
  569. if_readstatus(u_char * buf, int len, int user, int id, int channel)
  570. {
  571.         act2000_card *card = act2000_findcard(id);
  573.         if (card) {
  574.                 if (!card->flags & ACT2000_FLAGS_RUNNING)
  575.                         return -ENODEV;
  576.                 return (act2000_readstatus(buf, len, user, card));
  577.         }
  578.         printk(KERN_ERR
  579.                "act2000: if_readstatus called with invalid driverId!n");
  580.         return -ENODEV;
  581. }
  583. static int
  584. if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
  585. {
  586.         act2000_card *card = act2000_findcard(id);
  588.         if (card) {
  589.                 if (!card->flags & ACT2000_FLAGS_RUNNING)
  590.                         return -ENODEV;
  591. return (act2000_sendbuf(card, channel, ack, skb));
  592.         }
  593.         printk(KERN_ERR
  594.                "act2000: if_sendbuf called with invalid driverId!n");
  595.         return -ENODEV;
  596. }
  599. /*
  600.  * Allocate a new card-struct, initialize it
  601.  * link it into cards-list.
  602.  */
  603. static void
  604. act2000_alloccard(int bus, int port, int irq, char *id)
  605. {
  606. int i;
  607.         act2000_card *card;
  608.         if (!(card = (act2000_card *) kmalloc(sizeof(act2000_card), GFP_KERNEL))) {
  609.                 printk(KERN_WARNING
  610.        "act2000: (%s) Could not allocate card-struct.n", id);
  611.                 return;
  612.         }
  613.         memset((char *) card, 0, sizeof(act2000_card));
  614. skb_queue_head_init(&card->sndq);
  615. skb_queue_head_init(&card->rcvq);
  616. skb_queue_head_init(&card->ackq);
  617. card->snd_tq.routine = (void *) (void *) act2000_transmit;
  618. card->snd_tq.data = card;
  619. card->rcv_tq.routine = (void *) (void *) actcapi_dispatch;
  620. card->rcv_tq.data = card;
  621. card->poll_tq.routine = (void *) (void *) act2000_receive;
  622. card->poll_tq.data = card;
  623. init_timer(&card->ptimer);
  624.         card->interface.channels = ACT2000_BCH;
  625.         card->interface.maxbufsize = 4000;
  626.         card->interface.command = if_command;
  627.         card->interface.writebuf_skb = if_sendbuf;
  628.         card->interface.writecmd = if_writecmd;
  629.         card->interface.readstat = if_readstatus;
  630.         card->interface.features =
  631. ISDN_FEATURE_L2_X75I |
  632. ISDN_FEATURE_L2_HDLC |
  633. ISDN_FEATURE_L3_TRANS |
  634. ISDN_FEATURE_P_UNKNOWN;
  635.         card->interface.hl_hdrlen = 20;
  636.         card->ptype = ISDN_PTYPE_EURO;
  637.         strncpy(card->interface.id, id, sizeof(card->interface.id) - 1);
  638.         for (i=0; i<ACT2000_BCH; i++) {
  639.                 card->bch[i].plci = 0x8000;
  640.                 card->bch[i].ncci = 0x8000;
  641.                 card->bch[i].l2prot = ISDN_PROTO_L2_X75I;
  642.                 card->bch[i].l3prot = ISDN_PROTO_L3_TRANS;
  643.         }
  644.         card->myid = -1;
  645.         card->bus = bus;
  646.         card->port = port;
  647.         card->irq = irq;
  648.         card->next = cards;
  649.         cards = card;
  650. }
  652. /*
  653.  * register card at linklevel
  654.  */
  655. static int
  656. act2000_registercard(act2000_card * card)
  657. {
  658.         switch (card->bus) {
  659. case ACT2000_BUS_ISA:
  660. break;
  661. case ACT2000_BUS_MCA:
  662. case ACT2000_BUS_PCMCIA:
  663. default:
  664. printk(KERN_WARNING
  665.        "act2000: Illegal BUS type %dn",
  666.        card->bus);
  667. return -1;
  668.         }
  669.         if (!register_isdn(&card->interface)) {
  670.                 printk(KERN_WARNING
  671.                        "act2000: Unable to register %sn",
  672.                        card->interface.id);
  673.                 return -1;
  674.         }
  675.         card->myid = card->interface.channels;
  676.         sprintf(card->regname, "act2000-isdn (%s)", card->interface.id);
  677.         return 0;
  678. }
  680. static void
  681. unregister_card(act2000_card * card)
  682. {
  683.         isdn_ctrl cmd;
  685.         cmd.command = ISDN_STAT_UNLOAD;
  686.         cmd.driver = card->myid;
  687.         card->interface.statcallb(&cmd);
  688.         switch (card->bus) {
  689. case ACT2000_BUS_ISA:
  690. act2000_isa_release(card);
  691. break;
  692. case ACT2000_BUS_MCA:
  693. case ACT2000_BUS_PCMCIA:
  694. default:
  695. printk(KERN_WARNING
  696.        "act2000: Invalid BUS type %dn",
  697.        card->bus);
  698. break;
  699.         }
  700. }
  702. static int
  703. act2000_addcard(int bus, int port, int irq, char *id)
  704. {
  705. act2000_card *p;
  706. act2000_card *q = NULL;
  707. int initialized;
  708. int added = 0;
  709. int failed = 0;
  710. int i;
  712. if (!bus)
  713. bus = ACT2000_BUS_ISA;
  714. if (port != -1) {
  715. /* Port defined, do fixed setup */
  716. act2000_alloccard(bus, port, irq, id);
  717. } else {
  718. /* No port defined, perform autoprobing.
  719.  * This may result in more than one card detected.
  720.  */
  721. switch (bus) {
  722. case ACT2000_BUS_ISA:
  723. for (i = 0; i < ISA_NRPORTS; i++)
  724. if (act2000_isa_detect(act2000_isa_ports[i])) {
  725. printk(KERN_INFO
  726.        "act2000: Detected ISA card at port 0x%xn",
  727.        act2000_isa_ports[i]);
  728. act2000_alloccard(bus, act2000_isa_ports[i], irq, id);
  729. }
  730. break;
  731. case ACT2000_BUS_MCA:
  732. case ACT2000_BUS_PCMCIA:
  733. default:
  734. printk(KERN_WARNING
  735.        "act2000: addcard: Invalid BUS type %dn",
  736.        bus);
  737. }
  738. }
  739. if (!cards)
  740. return 1;
  741.         p = cards;
  742.         while (p) {
  743. initialized = 0;
  744. if (!p->interface.statcallb) {
  745. /* Not yet registered.
  746.  * Try to register and activate it.
  747.  */
  748. added++;
  749. switch (p->bus) {
  750. case ACT2000_BUS_ISA:
  751. if (act2000_isa_detect(p->port)) {
  752. if (act2000_registercard(p))
  753. break;
  754. if (act2000_isa_config_port(p, p->port)) {
  755. printk(KERN_WARNING
  756.        "act2000: Could not request port 0x%04xn",
  757.        p->port);
  758. unregister_card(p);
  759. p->interface.statcallb = NULL;
  760. break;
  761. }
  762. if (act2000_isa_config_irq(p, p->irq)) {
  763. printk(KERN_INFO
  764.        "act2000: No IRQ available, fallback to pollingn");
  765. /* Fall back to polled operation */
  766. p->irq = 0;
  767. }
  768. printk(KERN_INFO
  769.        "act2000: ISA"
  770.        "-type card at port "
  771.        "0x%04x ",
  772.        p->port);
  773. if (p->irq)
  774. printk("irq %dn", p->irq);
  775. else
  776. printk("polledn");
  777. initialized = 1;
  778. }
  779. break;
  780. case ACT2000_BUS_MCA:
  781. case ACT2000_BUS_PCMCIA:
  782. default:
  783. printk(KERN_WARNING
  784.        "act2000: addcard: Invalid BUS type %dn",
  785.        p->bus);
  786. }
  787. } else
  788. /* Card already initialized */
  789. initialized = 1;
  790.                 if (initialized) {
  791. /* Init OK, next card ... */
  792.                         q = p;
  793.                         p = p->next;
  794.                 } else {
  795.                         /* Init failed, remove card from list, free memory */
  796.                         printk(KERN_WARNING
  797.                                "act2000: Initialization of %s failedn",
  798.                                p->interface.id);
  799.                         if (q) {
  800.                                 q->next = p->next;
  801.                                 kfree(p);
  802.                                 p = q->next;
  803.                         } else {
  804.                                 cards = p->next;
  805.                                 kfree(p);
  806.                                 p = cards;
  807.                         }
  808. failed++;
  809.                 }
  810. }
  811.         return (added - failed);
  812. }
  814. #define DRIVERNAME "IBM Active 2000 ISDN driver"
  816. static int __init act2000_init(void)
  817. {
  818.         printk(KERN_INFO "%sn", DRIVERNAME);
  819.         if (!cards)
  820. act2000_addcard(act_bus, act_port, act_irq, act_id);
  821.         if (!cards)
  822.                 printk(KERN_INFO "act2000: No cards defined yetn");
  823.         /* No symbols to export, hide all symbols */
  824.         EXPORT_NO_SYMBOLS;
  825.         return 0;
  826. }
  828. static void __exit act2000_exit(void)
  829. {
  830.         act2000_card *card = cards;
  831.         act2000_card *last;
  832.         while (card) {
  833.                 unregister_card(card);
  834. del_timer(&card->ptimer);
  835.                 card = card->next;
  836.         }
  837.         card = cards;
  838.         while (card) {
  839.                 last = card;
  840.                 card = card->next;
  841. act2000_clear_msn(last);
  842.                 kfree(last);
  843.         }
  844.         printk(KERN_INFO "%s unloadedn", DRIVERNAME);
  845. }
  847. module_init(act2000_init);
  848. module_exit(act2000_exit);