/* $Id: act2000_isa.c,v 1.11.6.3 2001/09/23 22:24:32 kai Exp $ * * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000 (ISA-Version). * * Author Fritz Elfert * Copyright 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. * * Thanks to Friedemann Baitinger and IBM Germany * */ #include "act2000.h" #include "act2000_isa.h" #include "capi.h" static act2000_card *irq2card_map[16]; /* * Reset Controller, then try to read the Card's signature. + Return: * 1 = Signature found. * 0 = Signature not found. */ static int act2000_isa_reset(unsigned short portbase) { unsigned char reg; int i; int found; int serial = 0; found = 0; if ((reg = inb(portbase + ISA_COR)) != 0xff) { outb(reg | ISA_COR_RESET, portbase + ISA_COR); mdelay(10); outb(reg, portbase + ISA_COR); mdelay(10); for (i = 0; i < 16; i++) { if (inb(portbase + ISA_ISR) & ISA_ISR_SERIAL) serial |= 0x10000; serial >>= 1; } if (serial == ISA_SER_ID) found++; } return found; } int act2000_isa_detect(unsigned short portbase) { int ret = 0; if (request_region(portbase, ACT2000_PORTLEN, "act2000isa")) { ret = act2000_isa_reset(portbase); release_region(portbase, ISA_REGION); } return ret; } static irqreturn_t act2000_isa_interrupt(int irq, void *dev_id, struct pt_regs *regs) { act2000_card *card = irq2card_map[irq]; u_char istatus; if (!card) { printk(KERN_WARNING "act2000: Spurious interrupt!\n"); return IRQ_NONE; } istatus = (inb(ISA_PORT_ISR) & 0x07); if (istatus & ISA_ISR_OUT) { /* RX fifo has data */ istatus &= ISA_ISR_OUT_MASK; outb(0, ISA_PORT_SIS); act2000_isa_receive(card); outb(ISA_SIS_INT, ISA_PORT_SIS); } if (istatus & ISA_ISR_ERR) { /* Error Interrupt */ istatus &= ISA_ISR_ERR_MASK; printk(KERN_WARNING "act2000: errIRQ\n"); } if (istatus) printk(KERN_DEBUG "act2000: ?IRQ %d %02x\n", irq, istatus); return IRQ_HANDLED; } static void act2000_isa_select_irq(act2000_card * card) { unsigned char reg; reg = (inb(ISA_PORT_COR) & ~ISA_COR_IRQOFF) | ISA_COR_PERR; switch (card->irq) { case 3: reg = ISA_COR_IRQ03; break; case 5: reg = ISA_COR_IRQ05; break; case 7: reg = ISA_COR_IRQ07; break; case 10: reg = ISA_COR_IRQ10; break; case 11: reg = ISA_COR_IRQ11; break; case 12: reg = ISA_COR_IRQ12; break; case 15: reg = ISA_COR_IRQ15; break; } outb(reg, ISA_PORT_COR); } static void act2000_isa_enable_irq(act2000_card * card) { act2000_isa_select_irq(card); /* Enable READ irq */ outb(ISA_SIS_INT, ISA_PORT_SIS); } /* * Install interrupt handler, enable irq on card. * If irq is -1, choose next free irq, else irq is given explicitely. */ int act2000_isa_config_irq(act2000_card * card, short irq) { if (card->flags & ACT2000_FLAGS_IVALID) { free_irq(card->irq, NULL); irq2card_map[card->irq] = NULL; } card->flags &= ~ACT2000_FLAGS_IVALID; outb(ISA_COR_IRQOFF, ISA_PORT_COR); if (!irq) return 0; if (!request_irq(irq, &act2000_isa_interrupt, 0, card->regname, NULL)) { card->irq = irq; irq2card_map[card->irq] = card; card->flags |= ACT2000_FLAGS_IVALID; printk(KERN_WARNING "act2000: Could not request irq %d\n",irq); return -EBUSY; } else { act2000_isa_select_irq(card); /* Disable READ and WRITE irq */ outb(0, ISA_PORT_SIS); outb(0, ISA_PORT_SOS); } return 0; } int act2000_isa_config_port(act2000_card * card, unsigned short portbase) { if (card->flags & ACT2000_FLAGS_PVALID) { release_region(card->port, ISA_REGION); card->flags &= ~ACT2000_FLAGS_PVALID; } if (request_region(portbase, ACT2000_PORTLEN, card->regname) == NULL) return -EBUSY; else { card->port = portbase; card->flags |= ACT2000_FLAGS_PVALID; return 0; } } /* * Release ressources, used by an adaptor. */ void act2000_isa_release(act2000_card * card) { unsigned long flags; spin_lock_irqsave(&card->lock, flags); if (card->flags & ACT2000_FLAGS_IVALID) { free_irq(card->irq, NULL); irq2card_map[card->irq] = NULL; } card->flags &= ~ACT2000_FLAGS_IVALID; if (card->flags & ACT2000_FLAGS_PVALID) release_region(card->port, ISA_REGION); card->flags &= ~ACT2000_FLAGS_PVALID; spin_unlock_irqrestore(&card->lock, flags); } static int act2000_isa_writeb(act2000_card * card, u_char data) { u_char timeout = 40; while (timeout) { if (inb(ISA_PORT_SOS) & ISA_SOS_READY) { outb(data, ISA_PORT_SDO); return 0; } else { timeout--; udelay(10); } } return 1; } static int act2000_isa_readb(act2000_card * card, u_char * data) { u_char timeout = 40; while (timeout) { if (inb(ISA_PORT_SIS) & ISA_SIS_READY) { *data = inb(ISA_PORT_SDI); return 0; } else { timeout--; udelay(10); } } return 1; } void act2000_isa_receive(act2000_card *card) { u_char c; if (test_and_set_bit(ACT2000_LOCK_RX, (void *) &card->ilock) != 0) return; while (!act2000_isa_readb(card, &c)) { if (card->idat.isa.rcvidx < 8) { card->idat.isa.rcvhdr[card->idat.isa.rcvidx++] = c; if (card->idat.isa.rcvidx == 8) { int valid = actcapi_chkhdr(card, (actcapi_msghdr *)&card->idat.isa.rcvhdr); if (valid) { card->idat.isa.rcvlen = ((actcapi_msghdr *)&card->idat.isa.rcvhdr)->len; card->idat.isa.rcvskb = dev_alloc_skb(card->idat.isa.rcvlen); if (card->idat.isa.rcvskb == NULL) { card->idat.isa.rcvignore = 1; printk(KERN_WARNING "act2000_isa_receive: no memory\n"); test_and_clear_bit(ACT2000_LOCK_RX, (void *) &card->ilock); return; } memcpy(skb_put(card->idat.isa.rcvskb, 8), card->idat.isa.rcvhdr, 8); card->idat.isa.rcvptr = skb_put(card->idat.isa.rcvskb, card->idat.isa.rcvlen - 8); } else { card->idat.isa.rcvidx = 0; printk(KERN_WARNING "act2000_isa_receive: Invalid CAPI msg\n"); { int i; __u8 *p; __u8 *c; __u8 tmp[30]; for (i = 0, p = (__u8 *)&card->idat.isa.rcvhdr, c = tmp; i < 8; i++) c += sprintf(c, "%02x ", *(p++)); printk(KERN_WARNING "act2000_isa_receive: %s\n", tmp); } } } } else { if (!card->idat.isa.rcvignore) *card->idat.isa.rcvptr++ = c; if (++card->idat.isa.rcvidx >= card->idat.isa.rcvlen) { if (!card->idat.isa.rcvignore) { skb_queue_tail(&card->rcvq, card->idat.isa.rcvskb); act2000_schedule_rx(card); } card->idat.isa.rcvidx = 0; card->idat.isa.rcvlen = 8; card->idat.isa.rcvignore = 0; card->idat.isa.rcvskb = NULL; card->idat.isa.rcvptr = card->idat.isa.rcvhdr; } } } if (!(card->flags & ACT2000_FLAGS_IVALID)) { /* In polling mode, schedule myself */ if ((card->idat.isa.rcvidx) && (card->idat.isa.rcvignore || (card->idat.isa.rcvidx < card->idat.isa.rcvlen))) act2000_schedule_poll(card); } test_and_clear_bit(ACT2000_LOCK_RX, (void *) &card->ilock); } void act2000_isa_send(act2000_card * card) { unsigned long flags; struct sk_buff *skb; actcapi_msg *msg; int l; if (test_and_set_bit(ACT2000_LOCK_TX, (void *) &card->ilock) != 0) return; while (1) { spin_lock_irqsave(&card->lock, flags); if (!(card->sbuf)) { if ((card->sbuf = skb_dequeue(&card->sndq))) { card->ack_msg = card->sbuf->data; msg = (actcapi_msg *)card->sbuf->data; if ((msg->hdr.cmd.cmd == 0x86) && (msg->hdr.cmd.subcmd == 0) ) { /* Save flags in message */ card->need_b3ack = msg->msg.data_b3_req.flags; msg->msg.data_b3_req.flags = 0; } } } spin_unlock_irqrestore(&card->lock, flags); if (!(card->sbuf)) { /* No more data to send */ test_and_clear_bit(ACT2000_LOCK_TX, (void *) &card->ilock); return; } skb = card->sbuf; l = 0; while (skb->len) { if (act2000_isa_writeb(card, *(skb->data))) { /* Fifo is full, but more data to send */ test_and_clear_bit(ACT2000_LOCK_TX, (void *) &card->ilock); /* Schedule myself */ act2000_schedule_tx(card); return; } skb_pull(skb, 1); l++; } msg = (actcapi_msg *)card->ack_msg; if ((msg->hdr.cmd.cmd == 0x86) && (msg->hdr.cmd.subcmd == 0) ) { /* * If it's user data, reset data-ptr * and put skb into ackq. */ skb->data = card->ack_msg; /* Restore flags in message */ msg->msg.data_b3_req.flags = card->need_b3ack; skb_queue_tail(&card->ackq, skb); } else dev_kfree_skb(skb); card->sbuf = NULL; } } /* * Get firmware ID, check for 'ISDN' signature. */ static int act2000_isa_getid(act2000_card * card) { act2000_fwid fid; u_char *p = (u_char *) & fid; int count = 0; while (1) { if (count > 510) return -EPROTO; if (act2000_isa_readb(card, p++)) break; count++; } if (count <= 20) { printk(KERN_WARNING "act2000: No Firmware-ID!\n"); return -ETIME; } *p = '\0'; fid.revlen[0] = '\0'; if (strcmp(fid.isdn, "ISDN")) { printk(KERN_WARNING "act2000: Wrong Firmware-ID!\n"); return -EPROTO; } if ((p = strchr(fid.revision, '\n'))) *p = '\0'; printk(KERN_INFO "act2000: Firmware-ID: %s\n", fid.revision); if (card->flags & ACT2000_FLAGS_IVALID) { printk(KERN_DEBUG "Enabling Interrupts ...\n"); act2000_isa_enable_irq(card); } return 0; } /* * Download microcode into card, check Firmware signature. */ int act2000_isa_download(act2000_card * card, act2000_ddef __user * cb) { unsigned int length; int l; int c; long timeout; u_char *b; u_char __user *p; u_char *buf; act2000_ddef cblock; if (!act2000_isa_reset(card->port)) return -ENXIO; msleep_interruptible(500); if (copy_from_user(&cblock, cb, sizeof(cblock))) return -EFAULT; length = cblock.length; p = cblock.buffer; if (!access_ok(VERIFY_READ, p, length)) return -EFAULT; buf = (u_char *) kmalloc(1024, GFP_KERNEL); if (!buf) return -ENOMEM; timeout = 0; while (length) { l = (length > 1024) ? 1024 : length; c = 0; b = buf; if (copy_from_user(buf, p, l)) { kfree(buf); return -EFAULT; } while (c < l) { if (act2000_isa_writeb(card, *b++)) { printk(KERN_WARNING "act2000: loader timed out" " len=%d c=%d\n", length, c); kfree(buf); return -ETIME; } c++; } length -= l; p += l; } kfree(buf); msleep_interruptible(500); return (act2000_isa_getid(card)); }