PageRenderTime 47ms CodeModel.GetById 20ms app.highlight 23ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/isdn/act2000/module.c

https://bitbucket.org/ndreys/linux-sunxi
C | 813 lines | 702 code | 50 blank | 61 comment | 121 complexity | 1e7fc2fa549aa4c9bda8ed983530e1db MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  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/slab.h>
 20#include <linux/init.h>
 21
 22static unsigned short act2000_isa_ports[] =
 23{
 24        0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
 25        0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
 26};
 27
 28static act2000_card *cards = (act2000_card *) NULL;
 29
 30/* Parameters to be set by insmod */
 31static int   act_bus  =  0;
 32static int   act_port = -1;  /* -1 = Autoprobe  */
 33static int   act_irq  = -1;
 34static char *act_id   = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 35
 36MODULE_DESCRIPTION(       "ISDN4Linux: Driver for IBM Active 2000 ISDN card");
 37MODULE_AUTHOR(            "Fritz Elfert");
 38MODULE_LICENSE(           "GPL");
 39MODULE_PARM_DESC(act_bus, "BusType of first card, 1=ISA, 2=MCA, 3=PCMCIA, currently only ISA");
 40MODULE_PARM_DESC(membase, "Base port address of first card");
 41MODULE_PARM_DESC(act_irq, "IRQ of first card");
 42MODULE_PARM_DESC(act_id,  "ID-String of first card");
 43module_param(act_bus,  int, 0);
 44module_param(act_port, int, 0);
 45module_param(act_irq, int, 0);
 46module_param(act_id, charp, 0);
 47
 48static int act2000_addcard(int, int, int, char *);
 49
 50static act2000_chan *
 51find_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 */
 62static void
 63act2000_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 */
 84static __u16
 85act2000_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 */
107char *
108act2000_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 */
126static int
127act2000_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);
152				printk(KERN_DEBUG
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);
169			printk(KERN_DEBUG
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);
187	printk(KERN_DEBUG
188	       "Mapping %c -> %s added\n",
189	       eazmsn[0],
190	       &eazmsn[1]);
191	return 0;
192}
193
194static void
195act2000_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:
207			printk(KERN_WARNING
208			       "act2000_transmit: Illegal bustype %d\n", card->bus);
209	}
210}
211
212static void
213act2000_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:
225			printk(KERN_WARNING
226			       "act2000_receive: Illegal bustype %d\n", card->bus);
227	}
228}
229
230static void
231act2000_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
242static int
243act2000_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) {
259				case ACT2000_IOCTL_LOADBOOT:
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								}
272								actcapi_manufacturer_req_errh(card);
273							}
274							break;
275						default:
276							printk(KERN_WARNING
277							       "act2000: Illegal BUS type %d\n",
278							       card->bus);
279							ret = -EIO;
280					}
281					return ret;
282				case ACT2000_IOCTL_SETPROTO:
283					card->ptype = a?ISDN_PTYPE_EURO:ISDN_PTYPE_1TR6;
284					if (!(card->flags & ACT2000_FLAGS_RUNNING))
285						return 0;
286					actcapi_manufacturer_req_net(card);
287					return 0;
288				case ACT2000_IOCTL_SETMSN:
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;
297				case ACT2000_IOCTL_ADDCARD:
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
419static int
420act2000_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 */
473static int
474act2000_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 */
492static inline act2000_card *
493act2000_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 */
508static int
509if_command(isdn_ctrl * c)
510{
511        act2000_card *card = act2000_findcard(c->driver);
512
513        if (card)
514                return (act2000_command(card, c));
515        printk(KERN_ERR
516             "act2000: if_command %d called with invalid driverId %d!\n",
517               c->command, c->driver);
518        return -ENODEV;
519}
520
521static int
522if_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        }
531        printk(KERN_ERR
532               "act2000: if_writecmd called with invalid driverId!\n");
533        return -ENODEV;
534}
535
536static int
537if_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        }
546        printk(KERN_ERR
547               "act2000: if_readstatus called with invalid driverId!\n");
548        return -ENODEV;
549}
550
551static int
552if_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        }
561        printk(KERN_ERR
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 */
571static void
572act2000_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))) {
577                printk(KERN_WARNING
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 =
598		ISDN_FEATURE_L2_X75I |
599		ISDN_FEATURE_L2_HDLC |
600		ISDN_FEATURE_L3_TRANS |
601		ISDN_FEATURE_P_UNKNOWN;
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 */
622static int
623act2000_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:
631			printk(KERN_WARNING
632			       "act2000: Illegal BUS type %d\n",
633			       card->bus);
634			return -1;
635        }
636        if (!register_isdn(&card->interface)) {
637                printk(KERN_WARNING
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
647static void
648unregister_card(act2000_card * card)
649{
650        isdn_ctrl cmd;
651
652        cmd.command = ISDN_STAT_UNLOAD;
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:
662			printk(KERN_WARNING
663			       "act2000: Invalid BUS type %d\n",
664			       card->bus);
665			break;
666        }
667}
668
669static int
670act2000_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:
702			printk(KERN_WARNING
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)) {
722							printk(KERN_WARNING
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)) {
730							printk(KERN_INFO
731							       "act2000: No IRQ available, fallback to polling\n");
732							/* Fall back to polled operation */
733							p->irq = 0;
734						}
735						printk(KERN_INFO
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:
750					printk(KERN_WARNING
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 */
763                        printk(KERN_WARNING
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
783static 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
793static 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
812module_init(act2000_init);
813module_exit(act2000_exit);