Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
module.c
Go to the documentation of this file.
1 /* $Id: module.c,v 1.14.6.4 2001/09/23 22:24:32 kai Exp $
2  *
3  * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000.
4  *
5  * Author Fritz Elfert
6  * Copyright by Fritz Elfert <[email protected]>
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  */
14 
15 #include "act2000.h"
16 #include "act2000_isa.h"
17 #include "capi.h"
18 #include <linux/module.h>
19 #include <linux/slab.h>
20 #include <linux/init.h>
21 
22 static unsigned short act2000_isa_ports[] =
23 {
24  0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
25  0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
26 };
27 
28 static act2000_card *cards = (act2000_card *) NULL;
29 
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 = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
35 
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_param(act_bus, int, 0);
44 module_param(act_port, int, 0);
45 module_param(act_irq, int, 0);
46 module_param(act_id, charp, 0);
47 
48 static int act2000_addcard(int, int, int, char *);
49 
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 %d\n", channel);
56  return NULL;
57 }
58 
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;
68 
69  spin_lock_irqsave(&card->lock, flags);
70  card->msn_list = NULL;
71  spin_unlock_irqrestore(&card->lock, flags);
72  while (p) {
73  q = p->next;
74  kfree(p);
75  p = q;
76  }
77 }
78 
79 /*
80  * Find an MSN entry in the list.
81  * If ia5 != 0, return IA5-encoded EAZ, else
82  * return a bitmask with corresponding bit set.
83  */
84 static __u16
85 act2000_find_msn(act2000_card *card, char *msn, int ia5)
86 {
87  struct msn_entry *p = card->msn_list;
88  __u8 eaz = '0';
89 
90  while (p) {
91  if (!strcmp(p->msn, msn)) {
92  eaz = p->eaz;
93  break;
94  }
95  p = p->next;
96  }
97  if (!ia5)
98  return (1 << (eaz - '0'));
99  else
100  return eaz;
101 }
102 
103 /*
104  * Find an EAZ entry in the list.
105  * return a string with corresponding msn.
106  */
107 char *
108 act2000_find_eaz(act2000_card *card, char eaz)
109 {
110  struct msn_entry *p = card->msn_list;
111 
112  while (p) {
113  if (p->eaz == eaz)
114  return (p->msn);
115  p = p->next;
116  }
117  return ("\0");
118 }
119 
120 /*
121  * Add or delete an MSN to the MSN list
122  *
123  * First character of msneaz is EAZ, rest is MSN.
124  * If length of eazmsn is 1, delete that entry.
125  */
126 static int
127 act2000_set_msn(act2000_card *card, char *eazmsn)
128 {
129  struct msn_entry *p = card->msn_list;
130  struct msn_entry *q = NULL;
131  unsigned long flags;
132  int i;
133 
134  if (!strlen(eazmsn))
135  return 0;
136  if (strlen(eazmsn) > 16)
137  return -EINVAL;
138  for (i = 0; i < strlen(eazmsn); i++)
139  if (!isdigit(eazmsn[i]))
140  return -EINVAL;
141  if (strlen(eazmsn) == 1) {
142  /* Delete a single MSN */
143  while (p) {
144  if (p->eaz == eazmsn[0]) {
145  spin_lock_irqsave(&card->lock, flags);
146  if (q)
147  q->next = p->next;
148  else
149  card->msn_list = p->next;
150  spin_unlock_irqrestore(&card->lock, flags);
151  kfree(p);
153  "Mapping for EAZ %c deleted\n",
154  eazmsn[0]);
155  return 0;
156  }
157  q = p;
158  p = p->next;
159  }
160  return 0;
161  }
162  /* Add a single MSN */
163  while (p) {
164  /* Found in list, replace MSN */
165  if (p->eaz == eazmsn[0]) {
166  spin_lock_irqsave(&card->lock, flags);
167  strcpy(p->msn, &eazmsn[1]);
168  spin_unlock_irqrestore(&card->lock, flags);
170  "Mapping for EAZ %c changed to %s\n",
171  eazmsn[0],
172  &eazmsn[1]);
173  return 0;
174  }
175  p = p->next;
176  }
177  /* Not found in list, add new entry */
178  p = kmalloc(sizeof(msn_entry), GFP_KERNEL);
179  if (!p)
180  return -ENOMEM;
181  p->eaz = eazmsn[0];
182  strcpy(p->msn, &eazmsn[1]);
183  p->next = card->msn_list;
184  spin_lock_irqsave(&card->lock, flags);
185  card->msn_list = p;
186  spin_unlock_irqrestore(&card->lock, flags);
188  "Mapping %c -> %s added\n",
189  eazmsn[0],
190  &eazmsn[1]);
191  return 0;
192 }
193 
194 static void
195 act2000_transmit(struct work_struct *work)
196 {
197  struct act2000_card *card =
198  container_of(work, struct act2000_card, snd_tq);
199 
200  switch (card->bus) {
201  case ACT2000_BUS_ISA:
202  act2000_isa_send(card);
203  break;
204  case ACT2000_BUS_PCMCIA:
205  case ACT2000_BUS_MCA:
206  default:
208  "act2000_transmit: Illegal bustype %d\n", card->bus);
209  }
210 }
211 
212 static void
213 act2000_receive(struct work_struct *work)
214 {
215  struct act2000_card *card =
216  container_of(work, struct act2000_card, poll_tq);
217 
218  switch (card->bus) {
219  case ACT2000_BUS_ISA:
220  act2000_isa_receive(card);
221  break;
222  case ACT2000_BUS_PCMCIA:
223  case ACT2000_BUS_MCA:
224  default:
226  "act2000_receive: Illegal bustype %d\n", card->bus);
227  }
228 }
229 
230 static void
231 act2000_poll(unsigned long data)
232 {
233  act2000_card *card = (act2000_card *)data;
234  unsigned long flags;
235 
236  act2000_receive(&card->poll_tq);
237  spin_lock_irqsave(&card->lock, flags);
238  mod_timer(&card->ptimer, jiffies + 3);
239  spin_unlock_irqrestore(&card->lock, flags);
240 }
241 
242 static int
243 act2000_command(act2000_card *card, isdn_ctrl *c)
244 {
245  ulong a;
246  act2000_chan *chan;
247  act2000_cdef cdef;
248  isdn_ctrl cmd;
249  char tmp[17];
250  int ret;
251  unsigned long flags;
252  void __user *arg;
253 
254  switch (c->command) {
255  case ISDN_CMD_IOCTL:
256  memcpy(&a, c->parm.num, sizeof(ulong));
257  arg = (void __user *)a;
258  switch (c->arg) {
260  switch (card->bus) {
261  case ACT2000_BUS_ISA:
262  ret = act2000_isa_download(card,
263  arg);
264  if (!ret) {
265  card->flags |= ACT2000_FLAGS_LOADED;
266  if (!(card->flags & ACT2000_FLAGS_IVALID)) {
267  card->ptimer.expires = jiffies + 3;
268  card->ptimer.function = act2000_poll;
269  card->ptimer.data = (unsigned long)card;
270  add_timer(&card->ptimer);
271  }
273  }
274  break;
275  default:
277  "act2000: Illegal BUS type %d\n",
278  card->bus);
279  ret = -EIO;
280  }
281  return ret;
283  card->ptype = a ? ISDN_PTYPE_EURO : ISDN_PTYPE_1TR6;
284  if (!(card->flags & ACT2000_FLAGS_RUNNING))
285  return 0;
287  return 0;
289  if (copy_from_user(tmp, arg,
290  sizeof(tmp)))
291  return -EFAULT;
292  if ((ret = act2000_set_msn(card, tmp)))
293  return ret;
294  if (card->flags & ACT2000_FLAGS_RUNNING)
295  return (actcapi_manufacturer_req_msn(card));
296  return 0;
298  if (copy_from_user(&cdef, arg,
299  sizeof(cdef)))
300  return -EFAULT;
301  if (act2000_addcard(cdef.bus, cdef.port, cdef.irq, cdef.id))
302  return -EIO;
303  return 0;
304  case ACT2000_IOCTL_TEST:
305  if (!(card->flags & ACT2000_FLAGS_RUNNING))
306  return -ENODEV;
307  return 0;
308  default:
309  return -EINVAL;
310  }
311  break;
312  case ISDN_CMD_DIAL:
313  if (!(card->flags & ACT2000_FLAGS_RUNNING))
314  return -ENODEV;
315  if (!(chan = find_channel(card, c->arg & 0x0f)))
316  break;
317  spin_lock_irqsave(&card->lock, flags);
318  if (chan->fsm_state != ACT2000_STATE_NULL) {
319  spin_unlock_irqrestore(&card->lock, flags);
320  printk(KERN_WARNING "Dial on channel with state %d\n",
321  chan->fsm_state);
322  return -EBUSY;
323  }
324  if (card->ptype == ISDN_PTYPE_EURO)
325  tmp[0] = act2000_find_msn(card, c->parm.setup.eazmsn, 1);
326  else
327  tmp[0] = c->parm.setup.eazmsn[0];
328  chan->fsm_state = ACT2000_STATE_OCALL;
329  chan->callref = 0xffff;
330  spin_unlock_irqrestore(&card->lock, flags);
331  ret = actcapi_connect_req(card, chan, c->parm.setup.phone,
332  tmp[0], c->parm.setup.si1,
333  c->parm.setup.si2);
334  if (ret) {
335  cmd.driver = card->myid;
336  cmd.command = ISDN_STAT_DHUP;
337  cmd.arg &= 0x0f;
338  card->interface.statcallb(&cmd);
339  }
340  return ret;
341  case ISDN_CMD_ACCEPTD:
342  if (!(card->flags & ACT2000_FLAGS_RUNNING))
343  return -ENODEV;
344  if (!(chan = find_channel(card, c->arg & 0x0f)))
345  break;
346  if (chan->fsm_state == ACT2000_STATE_ICALL)
347  actcapi_select_b2_protocol_req(card, chan);
348  return 0;
349  case ISDN_CMD_ACCEPTB:
350  if (!(card->flags & ACT2000_FLAGS_RUNNING))
351  return -ENODEV;
352  return 0;
353  case ISDN_CMD_HANGUP:
354  if (!(card->flags & ACT2000_FLAGS_RUNNING))
355  return -ENODEV;
356  if (!(chan = find_channel(card, c->arg & 0x0f)))
357  break;
358  switch (chan->fsm_state) {
359  case ACT2000_STATE_ICALL:
360  case ACT2000_STATE_BSETUP:
361  actcapi_connect_resp(card, chan, 0x15);
362  break;
363  case ACT2000_STATE_ACTIVE:
364  actcapi_disconnect_b3_req(card, chan);
365  break;
366  }
367  return 0;
368  case ISDN_CMD_SETEAZ:
369  if (!(card->flags & ACT2000_FLAGS_RUNNING))
370  return -ENODEV;
371  if (!(chan = find_channel(card, c->arg & 0x0f)))
372  break;
373  if (strlen(c->parm.num)) {
374  if (card->ptype == ISDN_PTYPE_EURO) {
375  chan->eazmask = act2000_find_msn(card, c->parm.num, 0);
376  }
377  if (card->ptype == ISDN_PTYPE_1TR6) {
378  int i;
379  chan->eazmask = 0;
380  for (i = 0; i < strlen(c->parm.num); i++)
381  if (isdigit(c->parm.num[i]))
382  chan->eazmask |= (1 << (c->parm.num[i] - '0'));
383  }
384  } else
385  chan->eazmask = 0x3ff;
386  actcapi_listen_req(card);
387  return 0;
388  case ISDN_CMD_CLREAZ:
389  if (!(card->flags & ACT2000_FLAGS_RUNNING))
390  return -ENODEV;
391  if (!(chan = find_channel(card, c->arg & 0x0f)))
392  break;
393  chan->eazmask = 0;
394  actcapi_listen_req(card);
395  return 0;
396  case ISDN_CMD_SETL2:
397  if (!(card->flags & ACT2000_FLAGS_RUNNING))
398  return -ENODEV;
399  if (!(chan = find_channel(card, c->arg & 0x0f)))
400  break;
401  chan->l2prot = (c->arg >> 8);
402  return 0;
403  case ISDN_CMD_SETL3:
404  if (!(card->flags & ACT2000_FLAGS_RUNNING))
405  return -ENODEV;
406  if ((c->arg >> 8) != ISDN_PROTO_L3_TRANS) {
407  printk(KERN_WARNING "L3 protocol unknown\n");
408  return -1;
409  }
410  if (!(chan = find_channel(card, c->arg & 0x0f)))
411  break;
412  chan->l3prot = (c->arg >> 8);
413  return 0;
414  }
415 
416  return -EINVAL;
417 }
418 
419 static int
420 act2000_sendbuf(act2000_card *card, int channel, int ack, struct sk_buff *skb)
421 {
422  struct sk_buff *xmit_skb;
423  int len;
424  act2000_chan *chan;
425  actcapi_msg *msg;
426 
427  if (!(chan = find_channel(card, channel)))
428  return -1;
429  if (chan->fsm_state != ACT2000_STATE_ACTIVE)
430  return -1;
431  len = skb->len;
432  if ((chan->queued + len) >= ACT2000_MAX_QUEUED)
433  return 0;
434  if (!len)
435  return 0;
436  if (skb_headroom(skb) < 19) {
437  printk(KERN_WARNING "act2000_sendbuf: Headroom only %d\n",
438  skb_headroom(skb));
439  xmit_skb = alloc_skb(len + 19, GFP_ATOMIC);
440  if (!xmit_skb) {
441  printk(KERN_WARNING "act2000_sendbuf: Out of memory\n");
442  return 0;
443  }
444  skb_reserve(xmit_skb, 19);
445  skb_copy_from_linear_data(skb, skb_put(xmit_skb, len), len);
446  } else {
447  xmit_skb = skb_clone(skb, GFP_ATOMIC);
448  if (!xmit_skb) {
449  printk(KERN_WARNING "act2000_sendbuf: Out of memory\n");
450  return 0;
451  }
452  }
453  dev_kfree_skb(skb);
454  msg = (actcapi_msg *)skb_push(xmit_skb, 19);
455  msg->hdr.len = 19 + len;
456  msg->hdr.applicationID = 1;
457  msg->hdr.cmd.cmd = 0x86;
458  msg->hdr.cmd.subcmd = 0x00;
459  msg->hdr.msgnum = actcapi_nextsmsg(card);
460  msg->msg.data_b3_req.datalen = len;
461  msg->msg.data_b3_req.blocknr = (msg->hdr.msgnum & 0xff);
462  msg->msg.data_b3_req.fakencci = MAKE_NCCI(chan->plci, 0, chan->ncci);
463  msg->msg.data_b3_req.flags = ack; /* Will be set to 0 on actual sending */
464  actcapi_debug_msg(xmit_skb, 1);
465  chan->queued += len;
466  skb_queue_tail(&card->sndq, xmit_skb);
467  act2000_schedule_tx(card);
468  return len;
469 }
470 
471 
472 /* Read the Status-replies from the Interface */
473 static int
474 act2000_readstatus(u_char __user *buf, int len, act2000_card *card)
475 {
476  int count;
477  u_char __user *p;
478 
479  for (p = buf, count = 0; count < len; p++, count++) {
480  if (card->status_buf_read == card->status_buf_write)
481  return count;
482  put_user(*card->status_buf_read++, p);
483  if (card->status_buf_read > card->status_buf_end)
484  card->status_buf_read = card->status_buf;
485  }
486  return count;
487 }
488 
489 /*
490  * Find card with given driverId
491  */
492 static inline act2000_card *
493 act2000_findcard(int driverid)
494 {
495  act2000_card *p = cards;
496 
497  while (p) {
498  if (p->myid == driverid)
499  return p;
500  p = p->next;
501  }
502  return (act2000_card *) 0;
503 }
504 
505 /*
506  * Wrapper functions for interface to linklevel
507  */
508 static int
509 if_command(isdn_ctrl *c)
510 {
511  act2000_card *card = act2000_findcard(c->driver);
512 
513  if (card)
514  return (act2000_command(card, c));
516  "act2000: if_command %d called with invalid driverId %d!\n",
517  c->command, c->driver);
518  return -ENODEV;
519 }
520 
521 static int
522 if_writecmd(const u_char __user *buf, int len, int id, int channel)
523 {
524  act2000_card *card = act2000_findcard(id);
525 
526  if (card) {
527  if (!(card->flags & ACT2000_FLAGS_RUNNING))
528  return -ENODEV;
529  return (len);
530  }
532  "act2000: if_writecmd called with invalid driverId!\n");
533  return -ENODEV;
534 }
535 
536 static int
537 if_readstatus(u_char __user *buf, int len, int id, int channel)
538 {
539  act2000_card *card = act2000_findcard(id);
540 
541  if (card) {
542  if (!(card->flags & ACT2000_FLAGS_RUNNING))
543  return -ENODEV;
544  return (act2000_readstatus(buf, len, card));
545  }
547  "act2000: if_readstatus called with invalid driverId!\n");
548  return -ENODEV;
549 }
550 
551 static int
552 if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
553 {
554  act2000_card *card = act2000_findcard(id);
555 
556  if (card) {
557  if (!(card->flags & ACT2000_FLAGS_RUNNING))
558  return -ENODEV;
559  return (act2000_sendbuf(card, channel, ack, skb));
560  }
562  "act2000: if_sendbuf called with invalid driverId!\n");
563  return -ENODEV;
564 }
565 
566 
567 /*
568  * Allocate a new card-struct, initialize it
569  * link it into cards-list.
570  */
571 static void
572 act2000_alloccard(int bus, int port, int irq, char *id)
573 {
574  int i;
575  act2000_card *card;
576  if (!(card = kzalloc(sizeof(act2000_card), GFP_KERNEL))) {
578  "act2000: (%s) Could not allocate card-struct.\n", id);
579  return;
580  }
581  spin_lock_init(&card->lock);
582  spin_lock_init(&card->mnlock);
583  skb_queue_head_init(&card->sndq);
584  skb_queue_head_init(&card->rcvq);
585  skb_queue_head_init(&card->ackq);
586  INIT_WORK(&card->snd_tq, act2000_transmit);
587  INIT_WORK(&card->rcv_tq, actcapi_dispatch);
588  INIT_WORK(&card->poll_tq, act2000_receive);
589  init_timer(&card->ptimer);
590  card->interface.owner = THIS_MODULE;
591  card->interface.channels = ACT2000_BCH;
592  card->interface.maxbufsize = 4000;
593  card->interface.command = if_command;
594  card->interface.writebuf_skb = if_sendbuf;
595  card->interface.writecmd = if_writecmd;
596  card->interface.readstat = if_readstatus;
597  card->interface.features =
602  card->interface.hl_hdrlen = 20;
603  card->ptype = ISDN_PTYPE_EURO;
604  strlcpy(card->interface.id, id, sizeof(card->interface.id));
605  for (i = 0; i < ACT2000_BCH; i++) {
606  card->bch[i].plci = 0x8000;
607  card->bch[i].ncci = 0x8000;
608  card->bch[i].l2prot = ISDN_PROTO_L2_X75I;
609  card->bch[i].l3prot = ISDN_PROTO_L3_TRANS;
610  }
611  card->myid = -1;
612  card->bus = bus;
613  card->port = port;
614  card->irq = irq;
615  card->next = cards;
616  cards = card;
617 }
618 
619 /*
620  * register card at linklevel
621  */
622 static int
623 act2000_registercard(act2000_card *card)
624 {
625  switch (card->bus) {
626  case ACT2000_BUS_ISA:
627  break;
628  case ACT2000_BUS_MCA:
629  case ACT2000_BUS_PCMCIA:
630  default:
632  "act2000: Illegal BUS type %d\n",
633  card->bus);
634  return -1;
635  }
636  if (!register_isdn(&card->interface)) {
638  "act2000: Unable to register %s\n",
639  card->interface.id);
640  return -1;
641  }
642  card->myid = card->interface.channels;
643  sprintf(card->regname, "act2000-isdn (%s)", card->interface.id);
644  return 0;
645 }
646 
647 static void
648 unregister_card(act2000_card *card)
649 {
650  isdn_ctrl cmd;
651 
653  cmd.driver = card->myid;
654  card->interface.statcallb(&cmd);
655  switch (card->bus) {
656  case ACT2000_BUS_ISA:
657  act2000_isa_release(card);
658  break;
659  case ACT2000_BUS_MCA:
660  case ACT2000_BUS_PCMCIA:
661  default:
663  "act2000: Invalid BUS type %d\n",
664  card->bus);
665  break;
666  }
667 }
668 
669 static int
670 act2000_addcard(int bus, int port, int irq, char *id)
671 {
672  act2000_card *p;
673  act2000_card *q = NULL;
674  int initialized;
675  int added = 0;
676  int failed = 0;
677  int i;
678 
679  if (!bus)
680  bus = ACT2000_BUS_ISA;
681  if (port != -1) {
682  /* Port defined, do fixed setup */
683  act2000_alloccard(bus, port, irq, id);
684  } else {
685  /* No port defined, perform autoprobing.
686  * This may result in more than one card detected.
687  */
688  switch (bus) {
689  case ACT2000_BUS_ISA:
690  for (i = 0; i < ARRAY_SIZE(act2000_isa_ports); i++)
691  if (act2000_isa_detect(act2000_isa_ports[i])) {
692  printk(KERN_INFO "act2000: Detected "
693  "ISA card at port 0x%x\n",
694  act2000_isa_ports[i]);
695  act2000_alloccard(bus,
696  act2000_isa_ports[i], irq, id);
697  }
698  break;
699  case ACT2000_BUS_MCA:
700  case ACT2000_BUS_PCMCIA:
701  default:
703  "act2000: addcard: Invalid BUS type %d\n", bus);
704  }
705  }
706  if (!cards)
707  return 1;
708  p = cards;
709  while (p) {
710  initialized = 0;
711  if (!p->interface.statcallb) {
712  /* Not yet registered.
713  * Try to register and activate it.
714  */
715  added++;
716  switch (p->bus) {
717  case ACT2000_BUS_ISA:
718  if (act2000_isa_detect(p->port)) {
719  if (act2000_registercard(p))
720  break;
721  if (act2000_isa_config_port(p, p->port)) {
723  "act2000: Could not request port 0x%04x\n",
724  p->port);
725  unregister_card(p);
726  p->interface.statcallb = NULL;
727  break;
728  }
729  if (act2000_isa_config_irq(p, p->irq)) {
731  "act2000: No IRQ available, fallback to polling\n");
732  /* Fall back to polled operation */
733  p->irq = 0;
734  }
736  "act2000: ISA"
737  "-type card at port "
738  "0x%04x ",
739  p->port);
740  if (p->irq)
741  printk("irq %d\n", p->irq);
742  else
743  printk("polled\n");
744  initialized = 1;
745  }
746  break;
747  case ACT2000_BUS_MCA:
748  case ACT2000_BUS_PCMCIA:
749  default:
751  "act2000: addcard: Invalid BUS type %d\n",
752  p->bus);
753  }
754  } else
755  /* Card already initialized */
756  initialized = 1;
757  if (initialized) {
758  /* Init OK, next card ... */
759  q = p;
760  p = p->next;
761  } else {
762  /* Init failed, remove card from list, free memory */
764  "act2000: Initialization of %s failed\n",
765  p->interface.id);
766  if (q) {
767  q->next = p->next;
768  kfree(p);
769  p = q->next;
770  } else {
771  cards = p->next;
772  kfree(p);
773  p = cards;
774  }
775  failed++;
776  }
777  }
778  return (added - failed);
779 }
780 
781 #define DRIVERNAME "IBM Active 2000 ISDN driver"
782 
783 static int __init act2000_init(void)
784 {
785  printk(KERN_INFO "%s\n", DRIVERNAME);
786  if (!cards)
787  act2000_addcard(act_bus, act_port, act_irq, act_id);
788  if (!cards)
789  printk(KERN_INFO "act2000: No cards defined yet\n");
790  return 0;
791 }
792 
793 static void __exit act2000_exit(void)
794 {
795  act2000_card *card = cards;
796  act2000_card *last;
797  while (card) {
798  unregister_card(card);
799  del_timer(&card->ptimer);
800  card = card->next;
801  }
802  card = cards;
803  while (card) {
804  last = card;
805  card = card->next;
806  act2000_clear_msn(last);
807  kfree(last);
808  }
809  printk(KERN_INFO "%s unloaded\n", DRIVERNAME);
810 }
811 
812 module_init(act2000_init);
813 module_exit(act2000_exit);