1 /* $Id: icn.c,v 1.65.6.8 2001/09/23 22:24:55 kai Exp $
3 * ISDN low-level module for the ICN active ISDN-Card.
5 * Copyright 1994,95,96 by Fritz Elfert (fritz@isdn4linux.de)
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
13 #include <linux/module.h>
14 #include <linux/init.h>
16 static int portbase = ICN_BASEADDR;
17 static unsigned long membase = ICN_MEMADDR;
18 static char *icn_id = "\0";
19 static char *icn_id2 = "\0";
21 MODULE_DESCRIPTION("ISDN4Linux: Driver for ICN active ISDN card");
22 MODULE_AUTHOR("Fritz Elfert");
23 MODULE_LICENSE("GPL");
24 MODULE_PARM(portbase, "i");
25 MODULE_PARM_DESC(portbase, "Port address of first card");
26 MODULE_PARM(membase, "l");
27 MODULE_PARM_DESC(membase, "Shared memory address of all cards");
28 MODULE_PARM(icn_id, "s");
29 MODULE_PARM_DESC(icn_id, "ID-String of first card");
30 MODULE_PARM(icn_id2, "s");
31 MODULE_PARM_DESC(icn_id2, "ID-String of first card, second S0 (4B only)");
34 * Verbose bootcode- and protocol-downloading.
39 * Verbose Shmem-Mapping.
44 *revision = "$Revision: 1.65.6.8 $";
46 static int icn_addcard(int, char *, char *);
49 * Free send-queue completely.
51 * card = pointer to card struct
52 * channel = channel number
55 icn_free_queue(icn_card * card, int channel)
57 struct sk_buff_head *queue = &card->spqueue[channel];
60 skb_queue_purge(queue);
61 card->xlen[channel] = 0;
62 card->sndcount[channel] = 0;
63 if ((skb = card->xskb[channel])) {
64 card->xskb[channel] = NULL;
69 /* Put a value into a shift-register, highest bit first.
71 * port = port for output (bit 0 is significant)
72 * val = value to be output
73 * firstbit = Bit-Number of highest bit
74 * bitcount = Number of bits to output
77 icn_shiftout(unsigned short port,
86 for (s = firstbit, c = bitcount; c > 0; s--, c--)
87 OUTB_P((u_char) ((val >> s) & 1) ? 0xff : 0, port);
91 * disable a cards shared memory
94 icn_disable_ram(icn_card * card)
96 OUTB_P(0, ICN_MAPRAM);
100 * enable a cards shared memory
103 icn_enable_ram(icn_card * card)
105 OUTB_P(0xff, ICN_MAPRAM);
109 * Map a cards channel0 (Bank0/Bank8) or channel1 (Bank4/Bank12)
111 * must called with holding the devlock
114 icn_map_channel(icn_card * card, int channel)
117 printk(KERN_DEBUG "icn_map_channel %d %d\n", dev.channel, channel);
119 if ((channel == dev.channel) && (card == dev.mcard))
122 icn_disable_ram(dev.mcard);
123 icn_shiftout(ICN_BANK, chan2bank[channel], 3, 4); /* Select Bank */
124 icn_enable_ram(card);
126 dev.channel = channel;
128 printk(KERN_DEBUG "icn_map_channel done\n");
133 * Lock a cards channel.
134 * Return 0 if requested card/channel is unmapped (failure).
135 * Return 1 on success.
137 * must called with holding the devlock
140 icn_lock_channel(icn_card * card, int channel)
145 printk(KERN_DEBUG "icn_lock_channel %d\n", channel);
147 if ((dev.channel == channel) && (card == dev.mcard)) {
151 printk(KERN_DEBUG "icn_lock_channel %d OK\n", channel);
156 printk(KERN_DEBUG "icn_lock_channel %d FAILED, dc=%d\n", channel, dev.channel);
163 * Release current card/channel lock
165 * must called with holding the devlock
168 __icn_release_channel(void)
171 printk(KERN_DEBUG "icn_release_channel l=%d\n", dev.chanlock);
173 if (dev.chanlock > 0)
178 * Release current card/channel lock
181 icn_release_channel(void)
185 spin_lock_irqsave(&dev.devlock, flags);
186 __icn_release_channel();
187 spin_unlock_irqrestore(&dev.devlock, flags);
191 * Try to map and lock a cards channel.
192 * Return 1 on success, 0 on failure.
195 icn_trymaplock_channel(icn_card * card, int channel)
200 printk(KERN_DEBUG "trymaplock c=%d dc=%d l=%d\n", channel, dev.channel,
203 spin_lock_irqsave(&dev.devlock, flags);
204 if ((!dev.chanlock) ||
205 ((dev.channel == channel) && (dev.mcard == card))) {
207 icn_map_channel(card, channel);
208 spin_unlock_irqrestore(&dev.devlock, flags);
210 printk(KERN_DEBUG "trymaplock %d OK\n", channel);
214 spin_unlock_irqrestore(&dev.devlock, flags);
216 printk(KERN_DEBUG "trymaplock %d FAILED\n", channel);
222 * Release current card/channel lock,
223 * then map same or other channel without locking.
226 icn_maprelease_channel(icn_card * card, int channel)
231 printk(KERN_DEBUG "map_release c=%d l=%d\n", channel, dev.chanlock);
233 spin_lock_irqsave(&dev.devlock, flags);
234 if (dev.chanlock > 0)
237 icn_map_channel(card, channel);
238 spin_unlock_irqrestore(&dev.devlock, flags);
241 /* Get Data from the B-Channel, assemble fragmented packets and put them
242 * into receive-queue. Wake up any B-Channel-reading processes.
243 * This routine is called via timer-callback from icn_pollbchan().
247 icn_pollbchan_receive(int channel, icn_card * card)
249 int mch = channel + ((card->secondhalf) ? 2 : 0);
254 if (icn_trymaplock_channel(card, mch)) {
256 cnt = readb(&rbuf_l);
257 if ((card->rcvidx[channel] + cnt) > 4000) {
259 "icn: (%s) bogus packet on ch%d, dropping.\n",
262 card->rcvidx[channel] = 0;
265 memcpy_fromio(&card->rcvbuf[channel][card->rcvidx[channel]],
267 card->rcvidx[channel] += cnt;
268 eflag = readb(&rbuf_f);
271 icn_maprelease_channel(card, mch & 2);
273 if ((cnt = card->rcvidx[channel])) {
274 if (!(skb = dev_alloc_skb(cnt))) {
275 printk(KERN_WARNING "icn: receive out of memory\n");
278 memcpy(skb_put(skb, cnt), card->rcvbuf[channel], cnt);
279 card->rcvidx[channel] = 0;
280 card->interface.rcvcallb_skb(card->myid, channel, skb);
283 if (!icn_trymaplock_channel(card, mch))
286 icn_maprelease_channel(card, mch & 2);
290 /* Send data-packet to B-Channel, split it up into fragments of
291 * ICN_FRAGSIZE length. If last fragment is sent out, signal
292 * success to upper layers via statcallb with ISDN_STAT_BSENT argument.
293 * This routine is called via timer-callback from icn_pollbchan() or
294 * directly from icn_sendbuf().
298 icn_pollbchan_send(int channel, icn_card * card)
300 int mch = channel + ((card->secondhalf) ? 2 : 0);
306 if (!(card->sndcount[channel] || card->xskb[channel] ||
307 skb_queue_len(&card->spqueue[channel])))
309 if (icn_trymaplock_channel(card, mch)) {
311 (card->sndcount[channel] ||
312 skb_queue_len(&card->spqueue[channel]) ||
313 card->xskb[channel])) {
314 spin_lock_irqsave(&card->lock, flags);
315 if (card->xmit_lock[channel]) {
316 spin_unlock_irqrestore(&card->lock, flags);
319 card->xmit_lock[channel]++;
320 spin_unlock_irqrestore(&card->lock, flags);
321 skb = card->xskb[channel];
323 skb = skb_dequeue(&card->spqueue[channel]);
325 /* Pop ACK-flag off skb.
326 * Store length to xlen.
328 if (*(skb_pull(skb,1)))
329 card->xlen[channel] = skb->len;
331 card->xlen[channel] = 0;
336 if (skb->len > ICN_FRAGSIZE) {
337 writeb(0xff, &sbuf_f);
340 writeb(0x0, &sbuf_f);
343 writeb(cnt, &sbuf_l);
344 memcpy_toio(&sbuf_d, skb->data, cnt);
346 sbnext; /* switch to next buffer */
347 icn_maprelease_channel(card, mch & 2);
348 spin_lock_irqsave(&card->lock, flags);
349 card->sndcount[channel] -= cnt;
351 if (card->xskb[channel])
352 card->xskb[channel] = NULL;
353 card->xmit_lock[channel] = 0;
354 spin_unlock_irqrestore(&card->lock, flags);
356 if (card->xlen[channel]) {
357 cmd.command = ISDN_STAT_BSENT;
358 cmd.driver = card->myid;
360 cmd.parm.length = card->xlen[channel];
361 card->interface.statcallb(&cmd);
364 card->xskb[channel] = skb;
365 card->xmit_lock[channel] = 0;
366 spin_unlock_irqrestore(&card->lock, flags);
368 if (!icn_trymaplock_channel(card, mch))
371 icn_maprelease_channel(card, mch & 2);
375 /* Send/Receive Data to/from the B-Channel.
376 * This routine is called via timer-callback.
377 * It schedules itself while any B-Channel is open.
381 icn_pollbchan(unsigned long data)
383 icn_card *card = (icn_card *) data;
386 if (card->flags & ICN_FLAGS_B1ACTIVE) {
387 icn_pollbchan_receive(0, card);
388 icn_pollbchan_send(0, card);
390 if (card->flags & ICN_FLAGS_B2ACTIVE) {
391 icn_pollbchan_receive(1, card);
392 icn_pollbchan_send(1, card);
394 if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE)) {
395 /* schedule b-channel polling again */
396 spin_lock_irqsave(&card->lock, flags);
397 mod_timer(&card->rb_timer, jiffies+ICN_TIMER_BCREAD);
398 card->flags |= ICN_FLAGS_RBTIMER;
399 spin_unlock_irqrestore(&card->lock, flags);
401 card->flags &= ~ICN_FLAGS_RBTIMER;
404 typedef struct icn_stat {
410 static icn_stat icn_stat_table[] =
412 {"BCON_", ISDN_STAT_BCONN, 1}, /* B-Channel connected */
413 {"BDIS_", ISDN_STAT_BHUP, 2}, /* B-Channel disconnected */
415 ** add d-channel connect and disconnect support to link-level
417 {"DCON_", ISDN_STAT_DCONN, 10}, /* D-Channel connected */
418 {"DDIS_", ISDN_STAT_DHUP, 11}, /* D-Channel disconnected */
419 {"DCAL_I", ISDN_STAT_ICALL, 3}, /* Incoming call dialup-line */
420 {"DSCA_I", ISDN_STAT_ICALL, 3}, /* Incoming call 1TR6-SPV */
421 {"FCALL", ISDN_STAT_ICALL, 4}, /* Leased line connection up */
422 {"CIF", ISDN_STAT_CINF, 5}, /* Charge-info, 1TR6-type */
423 {"AOC", ISDN_STAT_CINF, 6}, /* Charge-info, DSS1-type */
424 {"CAU", ISDN_STAT_CAUSE, 7}, /* Cause code */
425 {"TEI OK", ISDN_STAT_RUN, 0}, /* Card connected to wallplug */
426 {"E_L1: ACT FAIL", ISDN_STAT_BHUP, 8}, /* Layer-1 activation failed */
427 {"E_L2: DATA LIN", ISDN_STAT_BHUP, 8}, /* Layer-2 data link lost */
428 {"E_L1: ACTIVATION FAILED",
429 ISDN_STAT_BHUP, 8}, /* Layer-1 activation failed */
436 * Check Statusqueue-Pointer from isdn-cards.
437 * If there are new status-replies from the interface, check
438 * them against B-Channel-connects/disconnects and set flags accordingly.
439 * Wake-Up any processes, who are reading the status-device.
440 * If there are B-Channels open, initiate a timer-callback to
442 * This routine is called periodically via timer.
446 icn_parse_status(u_char * status, int channel, icn_card * card)
448 icn_stat *s = icn_stat_table;
454 if (!strncmp(status, s->statstr, strlen(s->statstr))) {
455 cmd.command = s->command;
463 cmd.driver = card->myid;
467 spin_lock_irqsave(&card->lock, flags);
468 icn_free_queue(card,channel);
469 card->rcvidx[channel] = 0;
472 ((channel)?ICN_FLAGS_B2ACTIVE:ICN_FLAGS_B1ACTIVE)) {
476 card->flags &= ~((channel)?
477 ICN_FLAGS_B2ACTIVE:ICN_FLAGS_B1ACTIVE);
479 memset(&ncmd, 0, sizeof(ncmd));
481 ncmd.driver = card->myid;
483 ncmd.command = ISDN_STAT_BHUP;
484 spin_unlock_irqrestore(&card->lock, flags);
485 card->interface.statcallb(&cmd);
487 spin_unlock_irqrestore(&card->lock, flags);
490 spin_lock_irqsave(&card->lock, flags);
491 icn_free_queue(card,channel);
492 card->flags |= (channel) ?
493 ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE;
494 spin_unlock_irqrestore(&card->lock, flags);
497 spin_lock_irqsave(&card->lock, flags);
498 card->flags &= ~((channel) ?
499 ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE);
500 icn_free_queue(card, channel);
501 card->rcvidx[channel] = 0;
502 spin_unlock_irqrestore(&card->lock, flags);
506 char *t = status + 6;
507 char *s = strchr(t, ',');
510 strlcpy(cmd.parm.setup.phone, t,
511 sizeof(cmd.parm.setup.phone));
512 s = strchr(t = s, ',');
515 cmd.parm.setup.si1 = 0;
518 simple_strtoul(t, NULL, 10);
519 s = strchr(t = s, ',');
522 cmd.parm.setup.si2 = 0;
525 simple_strtoul(t, NULL, 10);
526 strlcpy(cmd.parm.setup.eazmsn, s,
527 sizeof(cmd.parm.setup.eazmsn));
529 cmd.parm.setup.plan = 0;
530 cmd.parm.setup.screen = 0;
533 sprintf(cmd.parm.setup.phone, "LEASED%d", card->myid);
534 sprintf(cmd.parm.setup.eazmsn, "%d", channel + 1);
535 cmd.parm.setup.si1 = 7;
536 cmd.parm.setup.si2 = 0;
537 cmd.parm.setup.plan = 0;
538 cmd.parm.setup.screen = 0;
541 strlcpy(cmd.parm.num, status + 3, sizeof(cmd.parm.num));
544 snprintf(cmd.parm.num, sizeof(cmd.parm.num), "%d",
545 (int) simple_strtoul(status + 7, NULL, 16));
549 if (strlen(status) == 4)
550 snprintf(cmd.parm.num, sizeof(cmd.parm.num), "%s%c%c",
551 status + 2, *status, *(status + 1));
553 strlcpy(cmd.parm.num, status + 1, sizeof(cmd.parm.num));
556 spin_lock_irqsave(&card->lock, flags);
557 card->flags &= ~ICN_FLAGS_B1ACTIVE;
558 icn_free_queue(card, 0);
560 spin_unlock_irqrestore(&card->lock, flags);
562 cmd.driver = card->myid;
563 card->interface.statcallb(&cmd);
564 cmd.command = ISDN_STAT_DHUP;
566 cmd.driver = card->myid;
567 card->interface.statcallb(&cmd);
568 cmd.command = ISDN_STAT_BHUP;
569 spin_lock_irqsave(&card->lock, flags);
570 card->flags &= ~ICN_FLAGS_B2ACTIVE;
571 icn_free_queue(card, 1);
573 spin_unlock_irqrestore(&card->lock, flags);
575 cmd.driver = card->myid;
576 card->interface.statcallb(&cmd);
577 cmd.command = ISDN_STAT_DHUP;
579 cmd.driver = card->myid;
582 card->interface.statcallb(&cmd);
587 icn_putmsg(icn_card * card, unsigned char c)
591 spin_lock_irqsave(&card->lock, flags);
592 *card->msg_buf_write++ = (c == 0xff) ? '\n' : c;
593 if (card->msg_buf_write == card->msg_buf_read) {
594 if (++card->msg_buf_read > card->msg_buf_end)
595 card->msg_buf_read = card->msg_buf;
597 if (card->msg_buf_write > card->msg_buf_end)
598 card->msg_buf_write = card->msg_buf;
599 spin_unlock_irqrestore(&card->lock, flags);
603 icn_polldchan(unsigned long data)
605 icn_card *card = (icn_card *) data;
606 int mch = card->secondhalf ? 2 : 0;
616 if (icn_trymaplock_channel(card, mch)) {
618 for (left = avail, i = readb(&msg_o); left > 0; i++, left--) {
619 c = readb(&dev.shmem->comm_buffers.iopc_buf[i & 0xff]);
622 card->imsg[card->iptr] = 0;
624 if (card->imsg[0] == '0' && card->imsg[1] >= '0' &&
625 card->imsg[1] <= '2' && card->imsg[2] == ';') {
626 ch = (card->imsg[1] - '0') - 1;
628 icn_parse_status(p, ch, card);
631 if (!strncmp(p, "DRV1.", 5)) {
635 printk(KERN_INFO "icn: (%s) %s\n", CID, p);
636 if (!strncmp(p + 7, "TC", 2)) {
637 card->ptype = ISDN_PTYPE_1TR6;
638 card->interface.features |= ISDN_FEATURE_P_1TR6;
640 "icn: (%s) 1TR6-Protocol loaded and running\n", CID);
642 if (!strncmp(p + 7, "EC", 2)) {
643 card->ptype = ISDN_PTYPE_EURO;
644 card->interface.features |= ISDN_FEATURE_P_EURO;
646 "icn: (%s) Euro-Protocol loaded and running\n", CID);
648 p = strstr(card->imsg, "BRV") + 3;
650 if (*p >= '0' && *p <= '9')
657 card->fw_rev = (int) simple_strtoul(vstr, NULL, 10);
663 card->imsg[card->iptr] = c;
668 writeb((readb(&msg_o) + avail) & 0xff, &msg_o);
669 icn_release_channel();
672 cmd.command = ISDN_STAT_STAVAIL;
673 cmd.driver = card->myid;
675 card->interface.statcallb(&cmd);
677 spin_lock_irqsave(&card->lock, flags);
678 if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE))
679 if (!(card->flags & ICN_FLAGS_RBTIMER)) {
680 /* schedule b-channel polling */
681 card->flags |= ICN_FLAGS_RBTIMER;
682 del_timer(&card->rb_timer);
683 card->rb_timer.function = icn_pollbchan;
684 card->rb_timer.data = (unsigned long) card;
685 card->rb_timer.expires = jiffies + ICN_TIMER_BCREAD;
686 add_timer(&card->rb_timer);
689 mod_timer(&card->st_timer, jiffies+ICN_TIMER_DCREAD);
690 spin_unlock_irqrestore(&card->lock, flags);
693 /* Append a packet to the transmit buffer-queue.
695 * channel = Number of B-channel
696 * skb = pointer to sk_buff
697 * card = pointer to card-struct
699 * Number of bytes transferred, -E??? on error
703 icn_sendbuf(int channel, int ack, struct sk_buff *skb, icn_card * card)
707 struct sk_buff *nskb;
711 "icn: Send packet too large\n");
715 if (!(card->flags & (channel) ? ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE))
717 if (card->sndcount[channel] > ICN_MAX_SQUEUE)
719 #warning TODO test headroom or use skb->nb to flag ACK
720 nskb = skb_clone(skb, GFP_ATOMIC);
722 /* Push ACK flag as one
723 * byte in front of data.
725 *(skb_push(nskb, 1)) = ack?1:0;
726 skb_queue_tail(&card->spqueue[channel], nskb);
730 spin_lock_irqsave(&card->lock, flags);
731 card->sndcount[channel] += len;
732 spin_unlock_irqrestore(&card->lock, flags);
738 * Check card's status after starting the bootstrap loader.
739 * On entry, the card's shared memory has already to be mapped.
741 * 0 on success (Boot loader ready)
742 * -EIO on failure (timeout)
745 icn_check_loader(int cardnumber)
751 printk(KERN_DEBUG "Loader %d ?\n", cardnumber);
753 if (readb(&dev.shmem->data_control.scns) ||
754 readb(&dev.shmem->data_control.scnr)) {
757 "icn: Boot-Loader %d timed out.\n",
759 icn_release_channel();
763 printk(KERN_DEBUG "Loader %d TO?\n", cardnumber);
765 current->state = TASK_INTERRUPTIBLE;
766 schedule_timeout(ICN_BOOT_TIMEOUT1);
769 printk(KERN_DEBUG "Loader %d OK\n", cardnumber);
771 icn_release_channel();
777 /* Load the boot-code into the interface-card's memory and start it.
778 * Always called from user-process.
781 * buffer = pointer to packet
783 * 0 if successfully loaded
787 #define SLEEP(sec) { \
789 printk(KERN_DEBUG "SLEEP(%d)\n",slsec); \
791 current->state = TASK_INTERRUPTIBLE; \
792 schedule_timeout(HZ); \
801 icn_loadboot(u_char __user * buffer, icn_card * card)
808 printk(KERN_DEBUG "icn_loadboot called, buffaddr=%08lx\n", (ulong) buffer);
810 if (!(codebuf = kmalloc(ICN_CODE_STAGE1, GFP_KERNEL))) {
811 printk(KERN_WARNING "icn: Could not allocate code buffer\n");
815 if (copy_from_user(codebuf, buffer, ICN_CODE_STAGE1)) {
820 if (!request_region(card->port, ICN_PORTLEN, card->regname)) {
822 "icn: (%s) ports 0x%03x-0x%03x in use.\n",
825 card->port + ICN_PORTLEN);
831 card->other->rvalid = 1;
834 if (!request_mem_region(dev.memaddr, 0x4000, "icn-isdn (all cards)")) {
836 "icn: memory at 0x%08lx in use.\n", dev.memaddr);
840 dev.shmem = ioremap(dev.memaddr, 0x4000);
843 OUTB_P(0, ICN_RUN); /* Reset Controller */
844 OUTB_P(0, ICN_MAPRAM); /* Disable RAM */
845 icn_shiftout(ICN_CFG, 0x0f, 3, 4); /* Windowsize= 16k */
846 icn_shiftout(ICN_CFG, dev.memaddr, 23, 10); /* Set RAM-Addr. */
848 printk(KERN_DEBUG "shmem=%08lx\n", dev.memaddr);
852 printk(KERN_DEBUG "Map Bank 0\n");
854 spin_lock_irqsave(&dev.devlock, flags);
855 icn_map_channel(card, 0); /* Select Bank 0 */
856 icn_lock_channel(card, 0); /* Lock Bank 0 */
857 spin_unlock_irqrestore(&dev.devlock, flags);
859 memcpy_toio(dev.shmem, codebuf, ICN_CODE_STAGE1); /* Copy code */
861 printk(KERN_DEBUG "Bootloader transferred\n");
863 if (card->doubleS0) {
866 printk(KERN_DEBUG "Map Bank 8\n");
868 spin_lock_irqsave(&dev.devlock, flags);
869 __icn_release_channel();
870 icn_map_channel(card, 2); /* Select Bank 8 */
871 icn_lock_channel(card, 2); /* Lock Bank 8 */
872 spin_unlock_irqrestore(&dev.devlock, flags);
874 memcpy_toio(dev.shmem, codebuf, ICN_CODE_STAGE1); /* Copy code */
876 printk(KERN_DEBUG "Bootloader transferred\n");
880 OUTB_P(0xff, ICN_RUN); /* Start Boot-Code */
881 if ((ret = icn_check_loader(card->doubleS0 ? 2 : 1))) {
884 if (!card->doubleS0) {
888 /* reached only, if we have a Double-S0-Card */
890 printk(KERN_DEBUG "Map Bank 0\n");
892 spin_lock_irqsave(&dev.devlock, flags);
893 icn_map_channel(card, 0); /* Select Bank 0 */
894 icn_lock_channel(card, 0); /* Lock Bank 0 */
895 spin_unlock_irqrestore(&dev.devlock, flags);
897 ret = (icn_check_loader(1));
906 icn_loadproto(u_char __user * buffer, icn_card * card)
908 register u_char __user *p = buffer;
910 uint left = ICN_CODE_STAGE2;
917 printk(KERN_DEBUG "icn_loadproto called\n");
919 if ((ret = verify_area(VERIFY_READ, buffer, ICN_CODE_STAGE2)))
922 spin_lock_irqsave(&dev.devlock, flags);
923 if (card->secondhalf) {
924 icn_map_channel(card, 2);
925 icn_lock_channel(card, 2);
927 icn_map_channel(card, 0);
928 icn_lock_channel(card, 0);
930 spin_unlock_irqrestore(&dev.devlock, flags);
932 if (sbfree) { /* If there is a free buffer... */
936 if (copy_from_user(codebuf, p, cnt)) {
937 icn_maprelease_channel(card, 0);
940 memcpy_toio(&sbuf_l, codebuf, cnt); /* copy data */
941 sbnext; /* switch to next buffer */
947 printk(KERN_DEBUG "boot 2 !sbfree\n");
950 icn_maprelease_channel(card, 0);
953 current->state = TASK_INTERRUPTIBLE;
954 schedule_timeout(10);
957 writeb(0x20, &sbuf_n);
960 if (readb(&cmd_o) || readb(&cmd_i)) {
962 printk(KERN_DEBUG "Proto?\n");
966 "icn: (%s) Protocol timed out.\n",
969 printk(KERN_DEBUG "Proto TO!\n");
971 icn_maprelease_channel(card, 0);
975 printk(KERN_DEBUG "Proto TO?\n");
977 current->state = TASK_INTERRUPTIBLE;
978 schedule_timeout(ICN_BOOT_TIMEOUT1);
980 if ((card->secondhalf) || (!card->doubleS0)) {
982 printk(KERN_DEBUG "Proto loaded, install poll-timer %d\n",
985 spin_lock_irqsave(&card->lock, flags);
986 init_timer(&card->st_timer);
987 card->st_timer.expires = jiffies + ICN_TIMER_DCREAD;
988 card->st_timer.function = icn_polldchan;
989 card->st_timer.data = (unsigned long) card;
990 add_timer(&card->st_timer);
991 card->flags |= ICN_FLAGS_RUNNING;
992 if (card->doubleS0) {
993 init_timer(&card->other->st_timer);
994 card->other->st_timer.expires = jiffies + ICN_TIMER_DCREAD;
995 card->other->st_timer.function = icn_polldchan;
996 card->other->st_timer.data = (unsigned long) card->other;
997 add_timer(&card->other->st_timer);
998 card->other->flags |= ICN_FLAGS_RUNNING;
1000 spin_unlock_irqrestore(&card->lock, flags);
1002 icn_maprelease_channel(card, 0);
1008 /* Read the Status-replies from the Interface */
1010 icn_readstatus(u_char __user *buf, int len, icn_card * card)
1015 for (p = buf, count = 0; count < len; p++, count++) {
1016 if (card->msg_buf_read == card->msg_buf_write)
1018 put_user(*card->msg_buf_read++, p);
1019 if (card->msg_buf_read > card->msg_buf_end)
1020 card->msg_buf_read = card->msg_buf;
1025 /* Put command-strings into the command-queue of the Interface */
1027 icn_writecmd(const u_char * buf, int len, int user, icn_card * card)
1029 int mch = card->secondhalf ? 2 : 0;
1036 unsigned long flags;
1037 int lastmap_channel;
1038 struct icn_card *lastmap_card;
1050 if (copy_from_user(msg, buf, count))
1053 memcpy(msg, buf, count);
1055 spin_lock_irqsave(&dev.devlock, flags);
1056 lastmap_card = dev.mcard;
1057 lastmap_channel = dev.channel;
1058 icn_map_channel(card, mch);
1060 icn_putmsg(card, '>');
1061 for (p = msg, pp = readb(&cmd_i), i = count; i > 0; i--, p++, pp
1063 writeb((*p == '\n') ? 0xff : *p,
1064 &dev.shmem->comm_buffers.pcio_buf[pp & 0xff]);
1067 icn_putmsg(card, *p);
1068 if ((*p == '\n') && (i > 1)) {
1069 icn_putmsg(card, '>');
1074 writeb((readb(&cmd_i) + count) & 0xff, &cmd_i);
1076 icn_map_channel(lastmap_card, lastmap_channel);
1077 spin_unlock_irqrestore(&dev.devlock, flags);
1086 printk(KERN_WARNING "icn: writemsg incomplete!\n");
1087 cmd.command = ISDN_STAT_STAVAIL;
1088 cmd.driver = card->myid;
1090 card->interface.statcallb(&cmd);
1095 * Delete card's pending timers, send STOP to linklevel
1098 icn_stopcard(icn_card * card)
1100 unsigned long flags;
1103 spin_lock_irqsave(&card->lock, flags);
1104 if (card->flags & ICN_FLAGS_RUNNING) {
1105 card->flags &= ~ICN_FLAGS_RUNNING;
1106 del_timer(&card->st_timer);
1107 del_timer(&card->rb_timer);
1108 spin_unlock_irqrestore(&card->lock, flags);
1109 cmd.command = ISDN_STAT_STOP;
1110 cmd.driver = card->myid;
1111 card->interface.statcallb(&cmd);
1113 icn_stopcard(card->other);
1115 spin_unlock_irqrestore(&card->lock, flags);
1119 icn_stopallcards(void)
1121 icn_card *p = cards;
1130 * Unmap all cards, because some of them may be mapped accidetly during
1131 * autoprobing of some network drivers (SMC-driver?)
1134 icn_disable_cards(void)
1136 icn_card *card = cards;
1139 if (!request_region(card->port, ICN_PORTLEN, "icn-isdn")) {
1141 "icn: (%s) ports 0x%03x-0x%03x in use.\n",
1144 card->port + ICN_PORTLEN);
1146 OUTB_P(0, ICN_RUN); /* Reset Controller */
1147 OUTB_P(0, ICN_MAPRAM); /* Disable RAM */
1148 release_region(card->port, ICN_PORTLEN);
1155 icn_command(isdn_ctrl * c, icn_card * card)
1165 switch (c->command) {
1166 case ISDN_CMD_IOCTL:
1167 memcpy(&a, c->parm.num, sizeof(ulong));
1168 arg = (char __user *)a;
1170 case ICN_IOCTL_SETMMIO:
1171 if (dev.memaddr != (a & 0x0ffc000)) {
1172 if (!request_mem_region(a & 0x0ffc000, 0x4000, "icn-isdn (all cards)")) {
1174 "icn: memory at 0x%08lx in use.\n",
1178 release_mem_region(a & 0x0ffc000, 0x4000);
1180 spin_lock_irqsave(&card->lock, flags);
1183 release_mem_region(dev.memaddr, 0x4000);
1186 dev.memaddr = a & 0x0ffc000;
1187 spin_unlock_irqrestore(&card->lock, flags);
1189 "icn: (%s) mmio set to 0x%08lx\n",
1194 case ICN_IOCTL_GETMMIO:
1195 return (long) dev.memaddr;
1196 case ICN_IOCTL_SETPORT:
1197 if (a == 0x300 || a == 0x310 || a == 0x320 || a == 0x330
1198 || a == 0x340 || a == 0x350 || a == 0x360 ||
1199 a == 0x308 || a == 0x318 || a == 0x328 || a == 0x338
1200 || a == 0x348 || a == 0x358 || a == 0x368) {
1201 if (card->port != (unsigned short) a) {
1202 if (!request_region((unsigned short) a, ICN_PORTLEN, "icn-isdn")) {
1204 "icn: (%s) ports 0x%03x-0x%03x in use.\n",
1205 CID, (int) a, (int) a + ICN_PORTLEN);
1208 release_region((unsigned short) a, ICN_PORTLEN);
1210 spin_lock_irqsave(&card->lock, flags);
1212 release_region(card->port, ICN_PORTLEN);
1213 card->port = (unsigned short) a;
1215 if (card->doubleS0) {
1216 card->other->port = (unsigned short) a;
1217 card->other->rvalid = 0;
1219 spin_unlock_irqrestore(&card->lock, flags);
1221 "icn: (%s) port set to 0x%03x\n",
1227 case ICN_IOCTL_GETPORT:
1228 return (int) card->port;
1229 case ICN_IOCTL_GETDOUBLE:
1230 return (int) card->doubleS0;
1231 case ICN_IOCTL_DEBUGVAR:
1232 if (copy_to_user(arg,
1238 ulong l = (ulong) & dev;
1239 if (copy_to_user(arg,
1245 case ICN_IOCTL_LOADBOOT:
1246 if (dev.firstload) {
1247 icn_disable_cards();
1251 return (icn_loadboot(arg, card));
1252 case ICN_IOCTL_LOADPROTO:
1254 if ((i = (icn_loadproto(arg, card))))
1257 i = icn_loadproto(arg + ICN_CODE_STAGE2, card->other);
1260 case ICN_IOCTL_ADDCARD:
1263 if (copy_from_user(&cdef,
1267 return (icn_addcard(cdef.port, cdef.id1, cdef.id2));
1269 case ICN_IOCTL_LEASEDCFG:
1271 if (!card->leased) {
1273 while (card->ptype == ISDN_PTYPE_UNKNOWN) {
1274 schedule_timeout(ICN_BOOT_TIMEOUT1);
1276 schedule_timeout(ICN_BOOT_TIMEOUT1);
1277 sprintf(cbuf, "00;FV2ON\n01;EAZ%c\n02;EAZ%c\n",
1278 (a & 1)?'1':'C', (a & 2)?'2':'C');
1279 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1281 "icn: (%s) Leased-line mode enabled\n",
1283 cmd.command = ISDN_STAT_RUN;
1284 cmd.driver = card->myid;
1286 card->interface.statcallb(&cmd);
1291 sprintf(cbuf, "00;FV2OFF\n");
1292 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1294 "icn: (%s) Leased-line mode disabled\n",
1296 cmd.command = ISDN_STAT_RUN;
1297 cmd.driver = card->myid;
1299 card->interface.statcallb(&cmd);
1308 if (!card->flags & ICN_FLAGS_RUNNING)
1312 if ((c->arg & 255) < ICN_BCH) {
1318 p = c->parm.setup.phone;
1319 if (*p == 's' || *p == 'S') {
1322 strcpy(dcode, "SCA");
1325 strcpy(dcode, "CAL");
1327 sprintf(cbuf, "%02d;D%s_R%s,%02d,%02d,%s\n", (int) (a + 1),
1328 dcode, dial, c->parm.setup.si1,
1329 c->parm.setup.si2, c->parm.setup.eazmsn);
1330 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1333 case ISDN_CMD_ACCEPTD:
1334 if (!card->flags & ICN_FLAGS_RUNNING)
1336 if (c->arg < ICN_BCH) {
1338 if (card->fw_rev >= 300) {
1339 switch (card->l2_proto[a - 1]) {
1340 case ISDN_PROTO_L2_X75I:
1341 sprintf(cbuf, "%02d;BX75\n", (int) a);
1343 case ISDN_PROTO_L2_HDLC:
1344 sprintf(cbuf, "%02d;BTRA\n", (int) a);
1347 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1349 sprintf(cbuf, "%02d;DCON_R\n", (int) a);
1350 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1353 case ISDN_CMD_ACCEPTB:
1354 if (!card->flags & ICN_FLAGS_RUNNING)
1356 if (c->arg < ICN_BCH) {
1358 if (card->fw_rev >= 300)
1359 switch (card->l2_proto[a - 1]) {
1360 case ISDN_PROTO_L2_X75I:
1361 sprintf(cbuf, "%02d;BCON_R,BX75\n", (int) a);
1363 case ISDN_PROTO_L2_HDLC:
1364 sprintf(cbuf, "%02d;BCON_R,BTRA\n", (int) a);
1367 sprintf(cbuf, "%02d;BCON_R\n", (int) a);
1368 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1371 case ISDN_CMD_HANGUP:
1372 if (!card->flags & ICN_FLAGS_RUNNING)
1374 if (c->arg < ICN_BCH) {
1376 sprintf(cbuf, "%02d;BDIS_R\n%02d;DDIS_R\n", (int) a, (int) a);
1377 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1380 case ISDN_CMD_SETEAZ:
1381 if (!card->flags & ICN_FLAGS_RUNNING)
1385 if (c->arg < ICN_BCH) {
1387 if (card->ptype == ISDN_PTYPE_EURO) {
1388 sprintf(cbuf, "%02d;MS%s%s\n", (int) a,
1389 c->parm.num[0] ? "N" : "ALL", c->parm.num);
1391 sprintf(cbuf, "%02d;EAZ%s\n", (int) a,
1392 c->parm.num[0] ? (char *)(c->parm.num) : "0123456789");
1393 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1396 case ISDN_CMD_CLREAZ:
1397 if (!card->flags & ICN_FLAGS_RUNNING)
1401 if (c->arg < ICN_BCH) {
1403 if (card->ptype == ISDN_PTYPE_EURO)
1404 sprintf(cbuf, "%02d;MSNC\n", (int) a);
1406 sprintf(cbuf, "%02d;EAZC\n", (int) a);
1407 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1410 case ISDN_CMD_SETL2:
1411 if (!card->flags & ICN_FLAGS_RUNNING)
1413 if ((c->arg & 255) < ICN_BCH) {
1416 case ISDN_PROTO_L2_X75I:
1417 sprintf(cbuf, "%02d;BX75\n", (int) (a & 255) + 1);
1419 case ISDN_PROTO_L2_HDLC:
1420 sprintf(cbuf, "%02d;BTRA\n", (int) (a & 255) + 1);
1425 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1426 card->l2_proto[a & 255] = (a >> 8);
1429 case ISDN_CMD_SETL3:
1430 if (!card->flags & ICN_FLAGS_RUNNING)
1440 * Find card with given driverId
1442 static inline icn_card *
1443 icn_findcard(int driverid)
1445 icn_card *p = cards;
1448 if (p->myid == driverid)
1452 return (icn_card *) 0;
1456 * Wrapper functions for interface to linklevel
1459 if_command(isdn_ctrl * c)
1461 icn_card *card = icn_findcard(c->driver);
1464 return (icn_command(c, card));
1466 "icn: if_command %d called with invalid driverId %d!\n",
1467 c->command, c->driver);
1472 if_writecmd(const u_char __user *buf, int len, int id, int channel)
1474 icn_card *card = icn_findcard(id);
1477 if (!card->flags & ICN_FLAGS_RUNNING)
1479 return (icn_writecmd(buf, len, 1, card));
1482 "icn: if_writecmd called with invalid driverId!\n");
1487 if_readstatus(u_char __user *buf, int len, int id, int channel)
1489 icn_card *card = icn_findcard(id);
1492 if (!card->flags & ICN_FLAGS_RUNNING)
1494 return (icn_readstatus(buf, len, card));
1497 "icn: if_readstatus called with invalid driverId!\n");
1502 if_sendbuf(int id, int channel, int ack, struct sk_buff *skb)
1504 icn_card *card = icn_findcard(id);
1507 if (!card->flags & ICN_FLAGS_RUNNING)
1509 return (icn_sendbuf(channel, ack, skb, card));
1512 "icn: if_sendbuf called with invalid driverId!\n");
1517 * Allocate a new card-struct, initialize it
1518 * link it into cards-list and register it at linklevel.
1521 icn_initcard(int port, char *id)
1526 if (!(card = (icn_card *) kmalloc(sizeof(icn_card), GFP_KERNEL))) {
1528 "icn: (%s) Could not allocate card-struct.\n", id);
1529 return (icn_card *) 0;
1531 memset((char *) card, 0, sizeof(icn_card));
1532 spin_lock_init(&card->lock);
1534 card->interface.owner = THIS_MODULE;
1535 card->interface.hl_hdrlen = 1;
1536 card->interface.channels = ICN_BCH;
1537 card->interface.maxbufsize = 4000;
1538 card->interface.command = if_command;
1539 card->interface.writebuf_skb = if_sendbuf;
1540 card->interface.writecmd = if_writecmd;
1541 card->interface.readstat = if_readstatus;
1542 card->interface.features = ISDN_FEATURE_L2_X75I |
1543 ISDN_FEATURE_L2_HDLC |
1544 ISDN_FEATURE_L3_TRANS |
1545 ISDN_FEATURE_P_UNKNOWN;
1546 card->ptype = ISDN_PTYPE_UNKNOWN;
1547 strlcpy(card->interface.id, id, sizeof(card->interface.id));
1548 card->msg_buf_write = card->msg_buf;
1549 card->msg_buf_read = card->msg_buf;
1550 card->msg_buf_end = &card->msg_buf[sizeof(card->msg_buf) - 1];
1551 for (i = 0; i < ICN_BCH; i++) {
1552 card->l2_proto[i] = ISDN_PROTO_L2_X75I;
1553 skb_queue_head_init(&card->spqueue[i]);
1557 if (!register_isdn(&card->interface)) {
1558 cards = cards->next;
1560 "icn: Unable to register %s\n", id);
1562 return (icn_card *) 0;
1564 card->myid = card->interface.channels;
1565 sprintf(card->regname, "icn-isdn (%s)", card->interface.id);
1570 icn_addcard(int port, char *id1, char *id2)
1575 if (!(card = icn_initcard(port, id1))) {
1580 "icn: (%s) ICN-2B, port 0x%x added\n",
1581 card->interface.id, port);
1584 if (!(card2 = icn_initcard(port, id2))) {
1586 "icn: (%s) half ICN-4B, port 0x%x added\n",
1587 card2->interface.id, port);
1591 card->secondhalf = 0;
1592 card->other = card2;
1593 card2->doubleS0 = 1;
1594 card2->secondhalf = 1;
1595 card2->other = card;
1597 "icn: (%s and %s) ICN-4B, port 0x%x added\n",
1598 card->interface.id, card2->interface.id, port);
1604 icn_setup(char *line)
1608 static char sid[20];
1609 static char sid2[20];
1611 str = get_options(line, 2, ints);
1615 membase = (unsigned long)ints[2];
1619 if ((p = strchr(sid, ','))) {
1627 __setup("icn=", icn_setup);
1630 static int __init icn_init(void)
1635 memset(&dev, 0, sizeof(icn_dev));
1636 dev.memaddr = (membase & 0x0ffc000);
1640 spin_lock_init(&dev.devlock);
1642 if ((p = strchr(revision, ':'))) {
1644 p = strchr(rev, '$');
1647 strcpy(rev, " ??? ");
1648 printk(KERN_NOTICE "ICN-ISDN-driver Rev%smem=0x%08lx\n", rev,
1650 return (icn_addcard(portbase, icn_id, icn_id2));
1653 static void __exit icn_exit(void)
1656 icn_card *card = cards;
1659 unsigned long flags;
1663 cmd.command = ISDN_STAT_UNLOAD;
1664 cmd.driver = card->myid;
1665 card->interface.statcallb(&cmd);
1666 spin_lock_irqsave(&card->lock, flags);
1668 OUTB_P(0, ICN_RUN); /* Reset Controller */
1669 OUTB_P(0, ICN_MAPRAM); /* Disable RAM */
1670 if (card->secondhalf || (!card->doubleS0)) {
1671 release_region(card->port, ICN_PORTLEN);
1674 for (i = 0; i < ICN_BCH; i++)
1675 icn_free_queue(card, i);
1678 spin_unlock_irqrestore(&card->lock, flags);
1689 release_mem_region(dev.memaddr, 0x4000);
1691 printk(KERN_NOTICE "ICN-ISDN-driver unloaded\n");
1694 module_init(icn_init);
1695 module_exit(icn_exit);