| /* $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" |
| |
| /* |
| * 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 dummy, void *dev_id) |
| { |
| act2000_card *card = dev_id; |
| u_char istatus; |
| |
| 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", card->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 explicitly. |
| */ |
| int |
| act2000_isa_config_irq(act2000_card * card, short irq) |
| { |
| int old_irq; |
| |
| if (card->flags & ACT2000_FLAGS_IVALID) { |
| free_irq(card->irq, card); |
| } |
| card->flags &= ~ACT2000_FLAGS_IVALID; |
| outb(ISA_COR_IRQOFF, ISA_PORT_COR); |
| if (!irq) |
| return 0; |
| |
| old_irq = card->irq; |
| card->irq = irq; |
| if (request_irq(irq, &act2000_isa_interrupt, 0, card->regname, card)) { |
| card->irq = old_irq; |
| 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, card); |
| |
| 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 = 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)); |
| } |