/* $Id: icn.c,v 1.65.6.8 2001/09/23 22:24:55 kai Exp $ * * ISDN low-level module for the ICN active ISDN-Card. * * Copyright 1994,95,96 by Fritz Elfert (fritz@isdn4linux.de) * * This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. * */ #include "icn.h" #include #include static int portbase = ICN_BASEADDR; static unsigned long membase = ICN_MEMADDR; static char *icn_id = "\0"; static char *icn_id2 = "\0"; MODULE_DESCRIPTION("ISDN4Linux: Driver for ICN active ISDN card"); MODULE_AUTHOR("Fritz Elfert"); MODULE_LICENSE("GPL"); module_param(portbase, int, 0); MODULE_PARM_DESC(portbase, "Port address of first card"); module_param(membase, ulong, 0); MODULE_PARM_DESC(membase, "Shared memory address of all cards"); module_param(icn_id, charp, 0); MODULE_PARM_DESC(icn_id, "ID-String of first card"); module_param(icn_id2, charp, 0); MODULE_PARM_DESC(icn_id2, "ID-String of first card, second S0 (4B only)"); /* * Verbose bootcode- and protocol-downloading. */ #undef BOOT_DEBUG /* * Verbose Shmem-Mapping. */ #undef MAP_DEBUG static char *revision = "$Revision: 1.65.6.8 $"; static int icn_addcard(int, char *, char *); /* * Free send-queue completely. * Parameter: * card = pointer to card struct * channel = channel number */ static void icn_free_queue(icn_card * card, int channel) { struct sk_buff_head *queue = &card->spqueue[channel]; struct sk_buff *skb; skb_queue_purge(queue); card->xlen[channel] = 0; card->sndcount[channel] = 0; if ((skb = card->xskb[channel])) { card->xskb[channel] = NULL; dev_kfree_skb(skb); } } /* Put a value into a shift-register, highest bit first. * Parameters: * port = port for output (bit 0 is significant) * val = value to be output * firstbit = Bit-Number of highest bit * bitcount = Number of bits to output */ static inline void icn_shiftout(unsigned short port, unsigned long val, int firstbit, int bitcount) { register u_char s; register u_char c; for (s = firstbit, c = bitcount; c > 0; s--, c--) OUTB_P((u_char) ((val >> s) & 1) ? 0xff : 0, port); } /* * disable a cards shared memory */ static inline void icn_disable_ram(icn_card * card) { OUTB_P(0, ICN_MAPRAM); } /* * enable a cards shared memory */ static inline void icn_enable_ram(icn_card * card) { OUTB_P(0xff, ICN_MAPRAM); } /* * Map a cards channel0 (Bank0/Bank8) or channel1 (Bank4/Bank12) * * must called with holding the devlock */ static inline void icn_map_channel(icn_card * card, int channel) { #ifdef MAP_DEBUG printk(KERN_DEBUG "icn_map_channel %d %d\n", dev.channel, channel); #endif if ((channel == dev.channel) && (card == dev.mcard)) return; if (dev.mcard) icn_disable_ram(dev.mcard); icn_shiftout(ICN_BANK, chan2bank[channel], 3, 4); /* Select Bank */ icn_enable_ram(card); dev.mcard = card; dev.channel = channel; #ifdef MAP_DEBUG printk(KERN_DEBUG "icn_map_channel done\n"); #endif } /* * Lock a cards channel. * Return 0 if requested card/channel is unmapped (failure). * Return 1 on success. * * must called with holding the devlock */ static inline int icn_lock_channel(icn_card * card, int channel) { register int retval; #ifdef MAP_DEBUG printk(KERN_DEBUG "icn_lock_channel %d\n", channel); #endif if ((dev.channel == channel) && (card == dev.mcard)) { dev.chanlock++; retval = 1; #ifdef MAP_DEBUG printk(KERN_DEBUG "icn_lock_channel %d OK\n", channel); #endif } else { retval = 0; #ifdef MAP_DEBUG printk(KERN_DEBUG "icn_lock_channel %d FAILED, dc=%d\n", channel, dev.channel); #endif } return retval; } /* * Release current card/channel lock * * must called with holding the devlock */ static inline void __icn_release_channel(void) { #ifdef MAP_DEBUG printk(KERN_DEBUG "icn_release_channel l=%d\n", dev.chanlock); #endif if (dev.chanlock > 0) dev.chanlock--; } /* * Release current card/channel lock */ static inline void icn_release_channel(void) { ulong flags; spin_lock_irqsave(&dev.devlock, flags); __icn_release_channel(); spin_unlock_irqrestore(&dev.devlock, flags); } /* * Try to map and lock a cards channel. * Return 1 on success, 0 on failure. */ static inline int icn_trymaplock_channel(icn_card * card, int channel) { ulong flags; #ifdef MAP_DEBUG printk(KERN_DEBUG "trymaplock c=%d dc=%d l=%d\n", channel, dev.channel, dev.chanlock); #endif spin_lock_irqsave(&dev.devlock, flags); if ((!dev.chanlock) || ((dev.channel == channel) && (dev.mcard == card))) { dev.chanlock++; icn_map_channel(card, channel); spin_unlock_irqrestore(&dev.devlock, flags); #ifdef MAP_DEBUG printk(KERN_DEBUG "trymaplock %d OK\n", channel); #endif return 1; } spin_unlock_irqrestore(&dev.devlock, flags); #ifdef MAP_DEBUG printk(KERN_DEBUG "trymaplock %d FAILED\n", channel); #endif return 0; } /* * Release current card/channel lock, * then map same or other channel without locking. */ static inline void icn_maprelease_channel(icn_card * card, int channel) { ulong flags; #ifdef MAP_DEBUG printk(KERN_DEBUG "map_release c=%d l=%d\n", channel, dev.chanlock); #endif spin_lock_irqsave(&dev.devlock, flags); if (dev.chanlock > 0) dev.chanlock--; if (!dev.chanlock) icn_map_channel(card, channel); spin_unlock_irqrestore(&dev.devlock, flags); } /* Get Data from the B-Channel, assemble fragmented packets and put them * into receive-queue. Wake up any B-Channel-reading processes. * This routine is called via timer-callback from icn_pollbchan(). */ static void icn_pollbchan_receive(int channel, icn_card * card) { int mch = channel + ((card->secondhalf) ? 2 : 0); int eflag; int cnt; struct sk_buff *skb; if (icn_trymaplock_channel(card, mch)) { while (rbavl) { cnt = readb(&rbuf_l); if ((card->rcvidx[channel] + cnt) > 4000) { printk(KERN_WARNING "icn: (%s) bogus packet on ch%d, dropping.\n", CID, channel + 1); card->rcvidx[channel] = 0; eflag = 0; } else { memcpy_fromio(&card->rcvbuf[channel][card->rcvidx[channel]], &rbuf_d, cnt); card->rcvidx[channel] += cnt; eflag = readb(&rbuf_f); } rbnext; icn_maprelease_channel(card, mch & 2); if (!eflag) { if ((cnt = card->rcvidx[channel])) { if (!(skb = dev_alloc_skb(cnt))) { printk(KERN_WARNING "icn: receive out of memory\n"); break; } memcpy(skb_put(skb, cnt), card->rcvbuf[channel], cnt); card->rcvidx[channel] = 0; card->interface.rcvcallb_skb(card->myid, channel, skb); } } if (!icn_trymaplock_channel(card, mch)) break; } icn_maprelease_channel(card, mch & 2); } } /* Send data-packet to B-Channel, split it up into fragments of * ICN_FRAGSIZE length. If last fragment is sent out, signal * success to upper layers via statcallb with ISDN_STAT_BSENT argument. * This routine is called via timer-callback from icn_pollbchan() or * directly from icn_sendbuf(). */ static void icn_pollbchan_send(int channel, icn_card * card) { int mch = channel + ((card->secondhalf) ? 2 : 0); int cnt; unsigned long flags; struct sk_buff *skb; isdn_ctrl cmd; if (!(card->sndcount[channel] || card->xskb[channel] || !skb_queue_empty(&card->spqueue[channel]))) return; if (icn_trymaplock_channel(card, mch)) { while (sbfree && (card->sndcount[channel] || !skb_queue_empty(&card->spqueue[channel]) || card->xskb[channel])) { spin_lock_irqsave(&card->lock, flags); if (card->xmit_lock[channel]) { spin_unlock_irqrestore(&card->lock, flags); break; } card->xmit_lock[channel]++; spin_unlock_irqrestore(&card->lock, flags); skb = card->xskb[channel]; if (!skb) { skb = skb_dequeue(&card->spqueue[channel]); if (skb) { /* Pop ACK-flag off skb. * Store length to xlen. */ if (*(skb_pull(skb,1))) card->xlen[channel] = skb->len; else card->xlen[channel] = 0; } } if (!skb) break; if (skb->len > ICN_FRAGSIZE) { writeb(0xff, &sbuf_f); cnt = ICN_FRAGSIZE; } else { writeb(0x0, &sbuf_f); cnt = skb->len; } writeb(cnt, &sbuf_l); memcpy_toio(&sbuf_d, skb->data, cnt); skb_pull(skb, cnt); sbnext; /* switch to next buffer */ icn_maprelease_channel(card, mch & 2); spin_lock_irqsave(&card->lock, flags); card->sndcount[channel] -= cnt; if (!skb->len) { if (card->xskb[channel]) card->xskb[channel] = NULL; card->xmit_lock[channel] = 0; spin_unlock_irqrestore(&card->lock, flags); dev_kfree_skb(skb); if (card->xlen[channel]) { cmd.command = ISDN_STAT_BSENT; cmd.driver = card->myid; cmd.arg = channel; cmd.parm.length = card->xlen[channel]; card->interface.statcallb(&cmd); } } else { card->xskb[channel] = skb; card->xmit_lock[channel] = 0; spin_unlock_irqrestore(&card->lock, flags); } if (!icn_trymaplock_channel(card, mch)) break; } icn_maprelease_channel(card, mch & 2); } } /* Send/Receive Data to/from the B-Channel. * This routine is called via timer-callback. * It schedules itself while any B-Channel is open. */ static void icn_pollbchan(unsigned long data) { icn_card *card = (icn_card *) data; unsigned long flags; if (card->flags & ICN_FLAGS_B1ACTIVE) { icn_pollbchan_receive(0, card); icn_pollbchan_send(0, card); } if (card->flags & ICN_FLAGS_B2ACTIVE) { icn_pollbchan_receive(1, card); icn_pollbchan_send(1, card); } if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE)) { /* schedule b-channel polling again */ spin_lock_irqsave(&card->lock, flags); mod_timer(&card->rb_timer, jiffies+ICN_TIMER_BCREAD); card->flags |= ICN_FLAGS_RBTIMER; spin_unlock_irqrestore(&card->lock, flags); } else card->flags &= ~ICN_FLAGS_RBTIMER; } typedef struct icn_stat { char *statstr; int command; int action; } icn_stat; /* *INDENT-OFF* */ static icn_stat icn_stat_table[] = { {"BCON_", ISDN_STAT_BCONN, 1}, /* B-Channel connected */ {"BDIS_", ISDN_STAT_BHUP, 2}, /* B-Channel disconnected */ /* ** add d-channel connect and disconnect support to link-level */ {"DCON_", ISDN_STAT_DCONN, 10}, /* D-Channel connected */ {"DDIS_", ISDN_STAT_DHUP, 11}, /* D-Channel disconnected */ {"DCAL_I", ISDN_STAT_ICALL, 3}, /* Incoming call dialup-line */ {"DSCA_I", ISDN_STAT_ICALL, 3}, /* Incoming call 1TR6-SPV */ {"FCALL", ISDN_STAT_ICALL, 4}, /* Leased line connection up */ {"CIF", ISDN_STAT_CINF, 5}, /* Charge-info, 1TR6-type */ {"AOC", ISDN_STAT_CINF, 6}, /* Charge-info, DSS1-type */ {"CAU", ISDN_STAT_CAUSE, 7}, /* Cause code */ {"TEI OK", ISDN_STAT_RUN, 0}, /* Card connected to wallplug */ {"E_L1: ACT FAIL", ISDN_STAT_BHUP, 8}, /* Layer-1 activation failed */ {"E_L2: DATA LIN", ISDN_STAT_BHUP, 8}, /* Layer-2 data link lost */ {"E_L1: ACTIVATION FAILED", ISDN_STAT_BHUP, 8}, /* Layer-1 activation failed */ {NULL, 0, -1} }; /* *INDENT-ON* */ /* * Check Statusqueue-Pointer from isdn-cards. * If there are new status-replies from the interface, check * them against B-Channel-connects/disconnects and set flags accordingly. * Wake-Up any processes, who are reading the status-device. * If there are B-Channels open, initiate a timer-callback to * icn_pollbchan(). * This routine is called periodically via timer. */ static void icn_parse_status(u_char * status, int channel, icn_card * card) { icn_stat *s = icn_stat_table; int action = -1; unsigned long flags; isdn_ctrl cmd; while (s->statstr) { if (!strncmp(status, s->statstr, strlen(s->statstr))) { cmd.command = s->command; action = s->action; break; } s++; } if (action == -1) return; cmd.driver = card->myid; cmd.arg = channel; switch (action) { case 11: spin_lock_irqsave(&card->lock, flags); icn_free_queue(card,channel); card->rcvidx[channel] = 0; if (card->flags & ((channel)?ICN_FLAGS_B2ACTIVE:ICN_FLAGS_B1ACTIVE)) { isdn_ctrl ncmd; card->flags &= ~((channel)? ICN_FLAGS_B2ACTIVE:ICN_FLAGS_B1ACTIVE); memset(&ncmd, 0, sizeof(ncmd)); ncmd.driver = card->myid; ncmd.arg = channel; ncmd.command = ISDN_STAT_BHUP; spin_unlock_irqrestore(&card->lock, flags); card->interface.statcallb(&cmd); } else spin_unlock_irqrestore(&card->lock, flags); break; case 1: spin_lock_irqsave(&card->lock, flags); icn_free_queue(card,channel); card->flags |= (channel) ? ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE; spin_unlock_irqrestore(&card->lock, flags); break; case 2: spin_lock_irqsave(&card->lock, flags); card->flags &= ~((channel) ? ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE); icn_free_queue(card, channel); card->rcvidx[channel] = 0; spin_unlock_irqrestore(&card->lock, flags); break; case 3: { char *t = status + 6; char *s = strchr(t, ','); *s++ = '\0'; strlcpy(cmd.parm.setup.phone, t, sizeof(cmd.parm.setup.phone)); s = strchr(t = s, ','); *s++ = '\0'; if (!strlen(t)) cmd.parm.setup.si1 = 0; else cmd.parm.setup.si1 = simple_strtoul(t, NULL, 10); s = strchr(t = s, ','); *s++ = '\0'; if (!strlen(t)) cmd.parm.setup.si2 = 0; else cmd.parm.setup.si2 = simple_strtoul(t, NULL, 10); strlcpy(cmd.parm.setup.eazmsn, s, sizeof(cmd.parm.setup.eazmsn)); } cmd.parm.setup.plan = 0; cmd.parm.setup.screen = 0; break; case 4: sprintf(cmd.parm.setup.phone, "LEASED%d", card->myid); sprintf(cmd.parm.setup.eazmsn, "%d", channel + 1); cmd.parm.setup.si1 = 7; cmd.parm.setup.si2 = 0; cmd.parm.setup.plan = 0; cmd.parm.setup.screen = 0; break; case 5: strlcpy(cmd.parm.num, status + 3, sizeof(cmd.parm.num)); break; case 6: snprintf(cmd.parm.num, sizeof(cmd.parm.num), "%d", (int) simple_strtoul(status + 7, NULL, 16)); break; case 7: status += 3; if (strlen(status) == 4) snprintf(cmd.parm.num, sizeof(cmd.parm.num), "%s%c%c", status + 2, *status, *(status + 1)); else strlcpy(cmd.parm.num, status + 1, sizeof(cmd.parm.num)); break; case 8: spin_lock_irqsave(&card->lock, flags); card->flags &= ~ICN_FLAGS_B1ACTIVE; icn_free_queue(card, 0); card->rcvidx[0] = 0; spin_unlock_irqrestore(&card->lock, flags); cmd.arg = 0; cmd.driver = card->myid; card->interface.statcallb(&cmd); cmd.command = ISDN_STAT_DHUP; cmd.arg = 0; cmd.driver = card->myid; card->interface.statcallb(&cmd); cmd.command = ISDN_STAT_BHUP; spin_lock_irqsave(&card->lock, flags); card->flags &= ~ICN_FLAGS_B2ACTIVE; icn_free_queue(card, 1); card->rcvidx[1] = 0; spin_unlock_irqrestore(&card->lock, flags); cmd.arg = 1; cmd.driver = card->myid; card->interface.statcallb(&cmd); cmd.command = ISDN_STAT_DHUP; cmd.arg = 1; cmd.driver = card->myid; break; } card->interface.statcallb(&cmd); return; } static void icn_putmsg(icn_card * card, unsigned char c) { ulong flags; spin_lock_irqsave(&card->lock, flags); *card->msg_buf_write++ = (c == 0xff) ? '\n' : c; if (card->msg_buf_write == card->msg_buf_read) { if (++card->msg_buf_read > card->msg_buf_end) card->msg_buf_read = card->msg_buf; } if (card->msg_buf_write > card->msg_buf_end) card->msg_buf_write = card->msg_buf; spin_unlock_irqrestore(&card->lock, flags); } static void icn_polldchan(unsigned long data) { icn_card *card = (icn_card *) data; int mch = card->secondhalf ? 2 : 0; int avail = 0; int left; u_char c; int ch; unsigned long flags; int i; u_char *p; isdn_ctrl cmd; if (icn_trymaplock_channel(card, mch)) { avail = msg_avail; for (left = avail, i = readb(&msg_o); left > 0; i++, left--) { c = readb(&dev.shmem->comm_buffers.iopc_buf[i & 0xff]); icn_putmsg(card, c); if (c == 0xff) { card->imsg[card->iptr] = 0; card->iptr = 0; if (card->imsg[0] == '0' && card->imsg[1] >= '0' && card->imsg[1] <= '2' && card->imsg[2] == ';') { ch = (card->imsg[1] - '0') - 1; p = &card->imsg[3]; icn_parse_status(p, ch, card); } else { p = card->imsg; if (!strncmp(p, "DRV1.", 5)) { u_char vstr[10]; u_char *q = vstr; printk(KERN_INFO "icn: (%s) %s\n", CID, p); if (!strncmp(p + 7, "TC", 2)) { card->ptype = ISDN_PTYPE_1TR6; card->interface.features |= ISDN_FEATURE_P_1TR6; printk(KERN_INFO "icn: (%s) 1TR6-Protocol loaded and running\n", CID); } if (!strncmp(p + 7, "EC", 2)) { card->ptype = ISDN_PTYPE_EURO; card->interface.features |= ISDN_FEATURE_P_EURO; printk(KERN_INFO "icn: (%s) Euro-Protocol loaded and running\n", CID); } p = strstr(card->imsg, "BRV") + 3; while (*p) { if (*p >= '0' && *p <= '9') *q++ = *p; p++; } *q = '\0'; strcat(vstr, "000"); vstr[3] = '\0'; card->fw_rev = (int) simple_strtoul(vstr, NULL, 10); continue; } } } else { card->imsg[card->iptr] = c; if (card->iptr < 59) card->iptr++; } } writeb((readb(&msg_o) + avail) & 0xff, &msg_o); icn_release_channel(); } if (avail) { cmd.command = ISDN_STAT_STAVAIL; cmd.driver = card->myid; cmd.arg = avail; card->interface.statcallb(&cmd); } spin_lock_irqsave(&card->lock, flags); if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE)) if (!(card->flags & ICN_FLAGS_RBTIMER)) { /* schedule b-channel polling */ card->flags |= ICN_FLAGS_RBTIMER; del_timer(&card->rb_timer); card->rb_timer.function = icn_pollbchan; card->rb_timer.data = (unsigned long) card; card->rb_timer.expires = jiffies + ICN_TIMER_BCREAD; add_timer(&card->rb_timer); } /* schedule again */ mod_timer(&card->st_timer, jiffies+ICN_TIMER_DCREAD); spin_unlock_irqrestore(&card->lock, flags); } /* Append a packet to the transmit buffer-queue. * Parameters: * channel = Number of B-channel * skb = pointer to sk_buff * card = pointer to card-struct * Return: * Number of bytes transferred, -E??? on error */ static int icn_sendbuf(int channel, int ack, struct sk_buff *skb, icn_card * card) { int len = skb->len; unsigned long flags; struct sk_buff *nskb; if (len > 4000) { printk(KERN_WARNING "icn: Send packet too large\n"); return -EINVAL; } if (len) { if (!(card->flags & (channel) ? ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE)) return 0; if (card->sndcount[channel] > ICN_MAX_SQUEUE) return 0; #warning TODO test headroom or use skb->nb to flag ACK nskb = skb_clone(skb, GFP_ATOMIC); if (nskb) { /* Push ACK flag as one * byte in front of data. */ *(skb_push(nskb, 1)) = ack?1:0; skb_queue_tail(&card->spqueue[channel], nskb); dev_kfree_skb(skb); } else len = 0; spin_lock_irqsave(&card->lock, flags); card->sndcount[channel] += len; spin_unlock_irqrestore(&card->lock, flags); } return len; } /* * Check card's status after starting the bootstrap loader. * On entry, the card's shared memory has already to be mapped. * Return: * 0 on success (Boot loader ready) * -EIO on failure (timeout) */ static int icn_check_loader(int cardnumber) { int timer = 0; while (1) { #ifdef BOOT_DEBUG printk(KERN_DEBUG "Loader %d ?\n", cardnumber); #endif if (readb(&dev.shmem->data_control.scns) || readb(&dev.shmem->data_control.scnr)) { if (timer++ > 5) { printk(KERN_WARNING "icn: Boot-Loader %d timed out.\n", cardnumber); icn_release_channel(); return -EIO; } #ifdef BOOT_DEBUG printk(KERN_DEBUG "Loader %d TO?\n", cardnumber); #endif msleep_interruptible(ICN_BOOT_TIMEOUT1); } else { #ifdef BOOT_DEBUG printk(KERN_DEBUG "Loader %d OK\n", cardnumber); #endif icn_release_channel(); return 0; } } } /* Load the boot-code into the interface-card's memory and start it. * Always called from user-process. * * Parameters: * buffer = pointer to packet * Return: * 0 if successfully loaded */ #ifdef BOOT_DEBUG #define SLEEP(sec) { \ int slsec = sec; \ printk(KERN_DEBUG "SLEEP(%d)\n",slsec); \ while (slsec) { \ msleep_interruptible(1000); \ slsec--; \ } \ } #else #define SLEEP(sec) #endif static int icn_loadboot(u_char __user * buffer, icn_card * card) { int ret; u_char *codebuf; unsigned long flags; #ifdef BOOT_DEBUG printk(KERN_DEBUG "icn_loadboot called, buffaddr=%08lx\n", (ulong) buffer); #endif if (!(codebuf = kmalloc(ICN_CODE_STAGE1, GFP_KERNEL))) { printk(KERN_WARNING "icn: Could not allocate code buffer\n"); ret = -ENOMEM; goto out; } if (copy_from_user(codebuf, buffer, ICN_CODE_STAGE1)) { ret = -EFAULT; goto out_kfree; } if (!card->rvalid) { if (!request_region(card->port, ICN_PORTLEN, card->regname)) { printk(KERN_WARNING "icn: (%s) ports 0x%03x-0x%03x in use.\n", CID, card->port, card->port + ICN_PORTLEN); ret = -EBUSY; goto out_kfree; } card->rvalid = 1; if (card->doubleS0) card->other->rvalid = 1; } if (!dev.mvalid) { if (!request_mem_region(dev.memaddr, 0x4000, "icn-isdn (all cards)")) { printk(KERN_WARNING "icn: memory at 0x%08lx in use.\n", dev.memaddr); ret = -EBUSY; goto out_kfree; } dev.shmem = ioremap(dev.memaddr, 0x4000); dev.mvalid = 1; } OUTB_P(0, ICN_RUN); /* Reset Controller */ OUTB_P(0, ICN_MAPRAM); /* Disable RAM */ icn_shiftout(ICN_CFG, 0x0f, 3, 4); /* Windowsize= 16k */ icn_shiftout(ICN_CFG, dev.memaddr, 23, 10); /* Set RAM-Addr. */ #ifdef BOOT_DEBUG printk(KERN_DEBUG "shmem=%08lx\n", dev.memaddr); #endif SLEEP(1); #ifdef BOOT_DEBUG printk(KERN_DEBUG "Map Bank 0\n"); #endif spin_lock_irqsave(&dev.devlock, flags); icn_map_channel(card, 0); /* Select Bank 0 */ icn_lock_channel(card, 0); /* Lock Bank 0 */ spin_unlock_irqrestore(&dev.devlock, flags); SLEEP(1); memcpy_toio(dev.shmem, codebuf, ICN_CODE_STAGE1); /* Copy code */ #ifdef BOOT_DEBUG printk(KERN_DEBUG "Bootloader transferred\n"); #endif if (card->doubleS0) { SLEEP(1); #ifdef BOOT_DEBUG printk(KERN_DEBUG "Map Bank 8\n"); #endif spin_lock_irqsave(&dev.devlock, flags); __icn_release_channel(); icn_map_channel(card, 2); /* Select Bank 8 */ icn_lock_channel(card, 2); /* Lock Bank 8 */ spin_unlock_irqrestore(&dev.devlock, flags); SLEEP(1); memcpy_toio(dev.shmem, codebuf, ICN_CODE_STAGE1); /* Copy code */ #ifdef BOOT_DEBUG printk(KERN_DEBUG "Bootloader transferred\n"); #endif } SLEEP(1); OUTB_P(0xff, ICN_RUN); /* Start Boot-Code */ if ((ret = icn_check_loader(card->doubleS0 ? 2 : 1))) { goto out_kfree; } if (!card->doubleS0) { ret = 0; goto out_kfree; } /* reached only, if we have a Double-S0-Card */ #ifdef BOOT_DEBUG printk(KERN_DEBUG "Map Bank 0\n"); #endif spin_lock_irqsave(&dev.devlock, flags); icn_map_channel(card, 0); /* Select Bank 0 */ icn_lock_channel(card, 0); /* Lock Bank 0 */ spin_unlock_irqrestore(&dev.devlock, flags); SLEEP(1); ret = (icn_check_loader(1)); out_kfree: kfree(codebuf); out: return ret; } static int icn_loadproto(u_char __user * buffer, icn_card * card) { register u_char __user *p = buffer; u_char codebuf[256]; uint left = ICN_CODE_STAGE2; uint cnt; int timer; unsigned long flags; #ifdef BOOT_DEBUG printk(KERN_DEBUG "icn_loadproto called\n"); #endif if (!access_ok(VERIFY_READ, buffer, ICN_CODE_STAGE2)) return -EFAULT; timer = 0; spin_lock_irqsave(&dev.devlock, flags); if (card->secondhalf) { icn_map_channel(card, 2); icn_lock_channel(card, 2); } else { icn_map_channel(card, 0); icn_lock_channel(card, 0); } spin_unlock_irqrestore(&dev.devlock, flags); while (left) { if (sbfree) { /* If there is a free buffer... */ cnt = left; if (cnt > 256) cnt = 256; if (copy_from_user(codebuf, p, cnt)) { icn_maprelease_channel(card, 0); return -EFAULT; } memcpy_toio(&sbuf_l, codebuf, cnt); /* copy data */ sbnext; /* switch to next buffer */ p += cnt; left -= cnt; timer = 0; } else { #ifdef BOOT_DEBUG printk(KERN_DEBUG "boot 2 !sbfree\n"); #endif if (timer++ > 5) { icn_maprelease_channel(card, 0); return -EIO; } schedule_timeout_interruptible(10); } } writeb(0x20, &sbuf_n); timer = 0; while (1) { if (readb(&cmd_o) || readb(&cmd_i)) { #ifdef BOOT_DEBUG printk(KERN_DEBUG "Proto?\n"); #endif if (timer++ > 5) { printk(KERN_WARNING "icn: (%s) Protocol timed out.\n", CID); #ifdef BOOT_DEBUG printk(KERN_DEBUG "Proto TO!\n"); #endif icn_maprelease_channel(card, 0); return -EIO; } #ifdef BOOT_DEBUG printk(KERN_DEBUG "Proto TO?\n"); #endif msleep_interruptible(ICN_BOOT_TIMEOUT1); } else { if ((card->secondhalf) || (!card->doubleS0)) { #ifdef BOOT_DEBUG printk(KERN_DEBUG "Proto loaded, install poll-timer %d\n", card->secondhalf); #endif spin_lock_irqsave(&card->lock, flags); init_timer(&card->st_timer); card->st_timer.expires = jiffies + ICN_TIMER_DCREAD; card->st_timer.function = icn_polldchan; card->st_timer.data = (unsigned long) card; add_timer(&card->st_timer); card->flags |= ICN_FLAGS_RUNNING; if (card->doubleS0) { init_timer(&card->other->st_timer); card->other->st_timer.expires = jiffies + ICN_TIMER_DCREAD; card->other->st_timer.function = icn_polldchan; card->other->st_timer.data = (unsigned long) card->other; add_timer(&card->other->st_timer); card->other->flags |= ICN_FLAGS_RUNNING; } spin_unlock_irqrestore(&card->lock, flags); } icn_maprelease_channel(card, 0); return 0; } } } /* Read the Status-replies from the Interface */ static int icn_readstatus(u_char __user *buf, int len, icn_card * card) { int count; u_char __user *p; for (p = buf, count = 0; count < len; p++, count++) { if (card->msg_buf_read == card->msg_buf_write) return count; put_user(*card->msg_buf_read++, p); if (card->msg_buf_read > card->msg_buf_end) card->msg_buf_read = card->msg_buf; } return count; } /* Put command-strings into the command-queue of the Interface */ static int icn_writecmd(const u_char * buf, int len, int user, icn_card * card) { int mch = card->secondhalf ? 2 : 0; int pp; int i; int count; int xcount; int ocount; int loop; unsigned long flags; int lastmap_channel; struct icn_card *lastmap_card; u_char *p; isdn_ctrl cmd; u_char msg[0x100]; ocount = 1; xcount = loop = 0; while (len) { count = cmd_free; if (count > len) count = len; if (user) { if (copy_from_user(msg, buf, count)) return -EFAULT; } else memcpy(msg, buf, count); spin_lock_irqsave(&dev.devlock, flags); lastmap_card = dev.mcard; lastmap_channel = dev.channel; icn_map_channel(card, mch); icn_putmsg(card, '>'); for (p = msg, pp = readb(&cmd_i), i = count; i > 0; i--, p++, pp ++) { writeb((*p == '\n') ? 0xff : *p, &dev.shmem->comm_buffers.pcio_buf[pp & 0xff]); len--; xcount++; icn_putmsg(card, *p); if ((*p == '\n') && (i > 1)) { icn_putmsg(card, '>'); ocount++; } ocount++; } writeb((readb(&cmd_i) + count) & 0xff, &cmd_i); if (lastmap_card) icn_map_channel(lastmap_card, lastmap_channel); spin_unlock_irqrestore(&dev.devlock, flags); if (len) { mdelay(1); if (loop++ > 20) break; } else break; } if (len && (!user)) printk(KERN_WARNING "icn: writemsg incomplete!\n"); cmd.command = ISDN_STAT_STAVAIL; cmd.driver = card->myid; cmd.arg = ocount; card->interface.statcallb(&cmd); return xcount; } /* * Delete card's pending timers, send STOP to linklevel */ static void icn_stopcard(icn_card * card) { unsigned long flags; isdn_ctrl cmd; spin_lock_irqsave(&card->lock, flags); if (card->flags & ICN_FLAGS_RUNNING) { card->flags &= ~ICN_FLAGS_RUNNING; del_timer(&card->st_timer); del_timer(&card->rb_timer); spin_unlock_irqrestore(&card->lock, flags); cmd.command = ISDN_STAT_STOP; cmd.driver = card->myid; card->interface.statcallb(&cmd); if (card->doubleS0) icn_stopcard(card->other); } else spin_unlock_irqrestore(&card->lock, flags); } static void icn_stopallcards(void) { icn_card *p = cards; while (p) { icn_stopcard(p); p = p->next; } } /* * Unmap all cards, because some of them may be mapped accidetly during * autoprobing of some network drivers (SMC-driver?) */ static void icn_disable_cards(void) { icn_card *card = cards; while (card) { if (!request_region(card->port, ICN_PORTLEN, "icn-isdn")) { printk(KERN_WARNING "icn: (%s) ports 0x%03x-0x%03x in use.\n", CID, card->port, card->port + ICN_PORTLEN); } else { OUTB_P(0, ICN_RUN); /* Reset Controller */ OUTB_P(0, ICN_MAPRAM); /* Disable RAM */ release_region(card->port, ICN_PORTLEN); } card = card->next; } } static int icn_command(isdn_ctrl * c, icn_card * card) { ulong a; ulong flags; int i; char cbuf[60]; isdn_ctrl cmd; icn_cdef cdef; char __user *arg; switch (c->command) { case ISDN_CMD_IOCTL: memcpy(&a, c->parm.num, sizeof(ulong)); arg = (char __user *)a; switch (c->arg) { case ICN_IOCTL_SETMMIO: if (dev.memaddr != (a & 0x0ffc000)) { if (!request_mem_region(a & 0x0ffc000, 0x4000, "icn-isdn (all cards)")) { printk(KERN_WARNING "icn: memory at 0x%08lx in use.\n", a & 0x0ffc000); return -EINVAL; } release_mem_region(a & 0x0ffc000, 0x4000); icn_stopallcards(); spin_lock_irqsave(&card->lock, flags); if (dev.mvalid) { iounmap(dev.shmem); release_mem_region(dev.memaddr, 0x4000); } dev.mvalid = 0; dev.memaddr = a & 0x0ffc000; spin_unlock_irqrestore(&card->lock, flags); printk(KERN_INFO "icn: (%s) mmio set to 0x%08lx\n", CID, dev.memaddr); } break; case ICN_IOCTL_GETMMIO: return (long) dev.memaddr; case ICN_IOCTL_SETPORT: if (a == 0x300 || a == 0x310 || a == 0x320 || a == 0x330 || a == 0x340 || a == 0x350 || a == 0x360 || a == 0x308 || a == 0x318 || a == 0x328 || a == 0x338 || a == 0x348 || a == 0x358 || a == 0x368) { if (card->port != (unsigned short) a) { if (!request_region((unsigned short) a, ICN_PORTLEN, "icn-isdn")) { printk(KERN_WARNING "icn: (%s) ports 0x%03x-0x%03x in use.\n", CID, (int) a, (int) a + ICN_PORTLEN); return -EINVAL; } release_region((unsigned short) a, ICN_PORTLEN); icn_stopcard(card); spin_lock_irqsave(&card->lock, flags); if (card->rvalid) release_region(card->port, ICN_PORTLEN); card->port = (unsigned short) a; card->rvalid = 0; if (card->doubleS0) { card->other->port = (unsigned short) a; card->other->rvalid = 0; } spin_unlock_irqrestore(&card->lock, flags); printk(KERN_INFO "icn: (%s) port set to 0x%03x\n", CID, card->port); } } else return -EINVAL; break; case ICN_IOCTL_GETPORT: return (int) card->port; case ICN_IOCTL_GETDOUBLE: return (int) card->doubleS0; case ICN_IOCTL_DEBUGVAR: if (copy_to_user(arg, &card, sizeof(ulong))) return -EFAULT; a += sizeof(ulong); { ulong l = (ulong) & dev; if (copy_to_user(arg, &l, sizeof(ulong))) return -EFAULT; } return 0; case ICN_IOCTL_LOADBOOT: if (dev.firstload) { icn_disable_cards(); dev.firstload = 0; } icn_stopcard(card); return (icn_loadboot(arg, card)); case ICN_IOCTL_LOADPROTO: icn_stopcard(card); if ((i = (icn_loadproto(arg, card)))) return i; if (card->doubleS0) i = icn_loadproto(arg + ICN_CODE_STAGE2, card->other); return i; break; case ICN_IOCTL_ADDCARD: if (!dev.firstload) return -EBUSY; if (copy_from_user(&cdef, arg, sizeof(cdef))) return -EFAULT; return (icn_addcard(cdef.port, cdef.id1, cdef.id2)); break; case ICN_IOCTL_LEASEDCFG: if (a) { if (!card->leased) { card->leased = 1; while (card->ptype == ISDN_PTYPE_UNKNOWN) { msleep_interruptible(ICN_BOOT_TIMEOUT1); } msleep_interruptible(ICN_BOOT_TIMEOUT1); sprintf(cbuf, "00;FV2ON\n01;EAZ%c\n02;EAZ%c\n", (a & 1)?'1':'C', (a & 2)?'2':'C'); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); printk(KERN_INFO "icn: (%s) Leased-line mode enabled\n", CID); cmd.command = ISDN_STAT_RUN; cmd.driver = card->myid; cmd.arg = 0; card->interface.statcallb(&cmd); } } else { if (card->leased) { card->leased = 0; sprintf(cbuf, "00;FV2OFF\n"); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); printk(KERN_INFO "icn: (%s) Leased-line mode disabled\n", CID); cmd.command = ISDN_STAT_RUN; cmd.driver = card->myid; cmd.arg = 0; card->interface.statcallb(&cmd); } } return 0; default: return -EINVAL; } break; case ISDN_CMD_DIAL: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if (card->leased) break; if ((c->arg & 255) < ICN_BCH) { char *p; char dial[50]; char dcode[4]; a = c->arg; p = c->parm.setup.phone; if (*p == 's' || *p == 'S') { /* Dial for SPV */ p++; strcpy(dcode, "SCA"); } else /* Normal Dial */ strcpy(dcode, "CAL"); strcpy(dial, p); sprintf(cbuf, "%02d;D%s_R%s,%02d,%02d,%s\n", (int) (a + 1), dcode, dial, c->parm.setup.si1, c->parm.setup.si2, c->parm.setup.eazmsn); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } break; case ISDN_CMD_ACCEPTD: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if (c->arg < ICN_BCH) { a = c->arg + 1; if (card->fw_rev >= 300) { switch (card->l2_proto[a - 1]) { case ISDN_PROTO_L2_X75I: sprintf(cbuf, "%02d;BX75\n", (int) a); break; case ISDN_PROTO_L2_HDLC: sprintf(cbuf, "%02d;BTRA\n", (int) a); break; } i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } sprintf(cbuf, "%02d;DCON_R\n", (int) a); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } break; case ISDN_CMD_ACCEPTB: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if (c->arg < ICN_BCH) { a = c->arg + 1; if (card->fw_rev >= 300) switch (card->l2_proto[a - 1]) { case ISDN_PROTO_L2_X75I: sprintf(cbuf, "%02d;BCON_R,BX75\n", (int) a); break; case ISDN_PROTO_L2_HDLC: sprintf(cbuf, "%02d;BCON_R,BTRA\n", (int) a); break; } else sprintf(cbuf, "%02d;BCON_R\n", (int) a); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } break; case ISDN_CMD_HANGUP: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if (c->arg < ICN_BCH) { a = c->arg + 1; sprintf(cbuf, "%02d;BDIS_R\n%02d;DDIS_R\n", (int) a, (int) a); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } break; case ISDN_CMD_SETEAZ: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if (card->leased) break; if (c->arg < ICN_BCH) { a = c->arg + 1; if (card->ptype == ISDN_PTYPE_EURO) { sprintf(cbuf, "%02d;MS%s%s\n", (int) a, c->parm.num[0] ? "N" : "ALL", c->parm.num); } else sprintf(cbuf, "%02d;EAZ%s\n", (int) a, c->parm.num[0] ? (char *)(c->parm.num) : "0123456789"); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } break; case ISDN_CMD_CLREAZ: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if (card->leased) break; if (c->arg < ICN_BCH) { a = c->arg + 1; if (card->ptype == ISDN_PTYPE_EURO) sprintf(cbuf, "%02d;MSNC\n", (int) a); else sprintf(cbuf, "%02d;EAZC\n", (int) a); i = icn_writecmd(cbuf, strlen(cbuf), 0, card); } break; case ISDN_CMD_SETL2: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; if ((c->arg & 255) < ICN_BCH) { a = c->arg; switch (a >> 8) { case ISDN_PROTO_L2_X75I: sprintf(cbuf, "%02d;BX75\n", (int) (a & 255) + 1); break; case ISDN_PROTO_L2_HDLC: sprintf(cbuf, "%02d;BTRA\n", (int) (a & 255) + 1); break; default: return -EINVAL; } i = icn_writecmd(cbuf, strlen(cbuf), 0, card); card->l2_proto[a & 255] = (a >> 8); } break; case ISDN_CMD_SETL3: if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; return 0; default: return -EINVAL; } return 0; } /* * Find card with given driverId */ static inline icn_card * icn_findcard(int driverid) { icn_card *p = cards; while (p) { if (p->myid == driverid) return p; p = p->next; } return (icn_card *) 0; } /* * Wrapper functions for interface to linklevel */ static int if_command(isdn_ctrl * c) { icn_card *card = icn_findcard(c->driver); if (card) return (icn_command(c, card)); printk(KERN_ERR "icn: if_command %d called with invalid driverId %d!\n", c->command, c->driver); return -ENODEV; } static int if_writecmd(const u_char __user *buf, int len, int id, int channel) { icn_card *card = icn_findcard(id); if (card) { if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; return (icn_writecmd(buf, len, 1, card)); } printk(KERN_ERR "icn: if_writecmd called with invalid driverId!\n"); return -ENODEV; } static int if_readstatus(u_char __user *buf, int len, int id, int channel) { icn_card *card = icn_findcard(id); if (card) { if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; return (icn_readstatus(buf, len, card)); } printk(KERN_ERR "icn: if_readstatus called with invalid driverId!\n"); return -ENODEV; } static int if_sendbuf(int id, int channel, int ack, struct sk_buff *skb) { icn_card *card = icn_findcard(id); if (card) { if (!card->flags & ICN_FLAGS_RUNNING) return -ENODEV; return (icn_sendbuf(channel, ack, skb, card)); } printk(KERN_ERR "icn: if_sendbuf called with invalid driverId!\n"); return -ENODEV; } /* * Allocate a new card-struct, initialize it * link it into cards-list and register it at linklevel. */ static icn_card * icn_initcard(int port, char *id) { icn_card *card; int i; if (!(card = (icn_card *) kmalloc(sizeof(icn_card), GFP_KERNEL))) { printk(KERN_WARNING "icn: (%s) Could not allocate card-struct.\n", id); return (icn_card *) 0; } memset((char *) card, 0, sizeof(icn_card)); spin_lock_init(&card->lock); card->port = port; card->interface.owner = THIS_MODULE; card->interface.hl_hdrlen = 1; card->interface.channels = ICN_BCH; card->interface.maxbufsize = 4000; card->interface.command = if_command; card->interface.writebuf_skb = if_sendbuf; card->interface.writecmd = if_writecmd; card->interface.readstat = if_readstatus; card->interface.features = ISDN_FEATURE_L2_X75I | ISDN_FEATURE_L2_HDLC | ISDN_FEATURE_L3_TRANS | ISDN_FEATURE_P_UNKNOWN; card->ptype = ISDN_PTYPE_UNKNOWN; strlcpy(card->interface.id, id, sizeof(card->interface.id)); card->msg_buf_write = card->msg_buf; card->msg_buf_read = card->msg_buf; card->msg_buf_end = &card->msg_buf[sizeof(card->msg_buf) - 1]; for (i = 0; i < ICN_BCH; i++) { card->l2_proto[i] = ISDN_PROTO_L2_X75I; skb_queue_head_init(&card->spqueue[i]); } card->next = cards; cards = card; if (!register_isdn(&card->interface)) { cards = cards->next; printk(KERN_WARNING "icn: Unable to register %s\n", id); kfree(card); return (icn_card *) 0; } card->myid = card->interface.channels; sprintf(card->regname, "icn-isdn (%s)", card->interface.id); return card; } static int icn_addcard(int port, char *id1, char *id2) { icn_card *card; icn_card *card2; if (!(card = icn_initcard(port, id1))) { return -EIO; } if (!strlen(id2)) { printk(KERN_INFO "icn: (%s) ICN-2B, port 0x%x added\n", card->interface.id, port); return 0; } if (!(card2 = icn_initcard(port, id2))) { printk(KERN_INFO "icn: (%s) half ICN-4B, port 0x%x added\n", card2->interface.id, port); return 0; } card->doubleS0 = 1; card->secondhalf = 0; card->other = card2; card2->doubleS0 = 1; card2->secondhalf = 1; card2->other = card; printk(KERN_INFO "icn: (%s and %s) ICN-4B, port 0x%x added\n", card->interface.id, card2->interface.id, port); return 0; } #ifndef MODULE static int __init icn_setup(char *line) { char *p, *str; int ints[3]; static char sid[20]; static char sid2[20]; str = get_options(line, 2, ints); if (ints[0]) portbase = ints[1]; if (ints[0] > 1) membase = (unsigned long)ints[2]; if (str && *str) { strcpy(sid, str); icn_id = sid; if ((p = strchr(sid, ','))) { *p++ = 0; strcpy(sid2, p); icn_id2 = sid2; } } return(1); } __setup("icn=", icn_setup); #endif /* MODULE */ static int __init icn_init(void) { char *p; char rev[10]; memset(&dev, 0, sizeof(icn_dev)); dev.memaddr = (membase & 0x0ffc000); dev.channel = -1; dev.mcard = NULL; dev.firstload = 1; spin_lock_init(&dev.devlock); if ((p = strchr(revision, ':'))) { strcpy(rev, p + 1); p = strchr(rev, '$'); *p = 0; } else strcpy(rev, " ??? "); printk(KERN_NOTICE "ICN-ISDN-driver Rev%smem=0x%08lx\n", rev, dev.memaddr); return (icn_addcard(portbase, icn_id, icn_id2)); } static void __exit icn_exit(void) { isdn_ctrl cmd; icn_card *card = cards; icn_card *last, *tmpcard; int i; unsigned long flags; icn_stopallcards(); while (card) { cmd.command = ISDN_STAT_UNLOAD; cmd.driver = card->myid; card->interface.statcallb(&cmd); spin_lock_irqsave(&card->lock, flags); if (card->rvalid) { OUTB_P(0, ICN_RUN); /* Reset Controller */ OUTB_P(0, ICN_MAPRAM); /* Disable RAM */ if (card->secondhalf || (!card->doubleS0)) { release_region(card->port, ICN_PORTLEN); card->rvalid = 0; } for (i = 0; i < ICN_BCH; i++) icn_free_queue(card, i); } tmpcard = card->next; spin_unlock_irqrestore(&card->lock, flags); card = tmpcard; } card = cards; cards = NULL; while (card) { last = card; card = card->next; kfree(last); } if (dev.mvalid) { iounmap(dev.shmem); release_mem_region(dev.memaddr, 0x4000); } printk(KERN_NOTICE "ICN-ISDN-driver unloaded\n"); } module_init(icn_init); module_exit(icn_exit);