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