drivers/staging/i4l/act2000/act2000_isa.c

   1 /* $Id: act2000_isa.c,v 1.11.6.3 2001/09/23 22:24:32 kai Exp $
   2  *
   3  * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000 (ISA-Version).
   4  *
   5  * Author       Fritz Elfert
   6  * Copyright    by Fritz Elfert      <fritz@isdn4linux.de>
   7  *
   8  * This software may be used and distributed according to the terms
   9  * of the GNU General Public License, incorporated herein by reference.
  10  *
  11  * Thanks to Friedemann Baitinger and IBM Germany
  12  *
  13  */
  14
  15 #include "act2000.h"
  16 #include "act2000_isa.h"
  17 #include "capi.h"
  18
  19 /*
  20  * Reset Controller, then try to read the Card's signature.
  21  + Return:
  22  *   1 = Signature found.
  23  *   0 = Signature not found.
  24  */
  25 static int
  26 act2000_isa_reset(unsigned short portbase)
  27 {
  28         unsigned char reg;
  29         int i;
  30         int found;
  31         int serial = 0;
  32
  33         found = 0;
  34         reg = inb(portbase + ISA_COR);
  35         if (reg != 0xff) {
  36                 outb(reg | ISA_COR_RESET, portbase + ISA_COR);
  37                 mdelay(10);
  38                 outb(reg, portbase + ISA_COR);
  39                 mdelay(10);
  40
  41                 for (i = 0; i < 16; i++) {
  42                         if (inb(portbase + ISA_ISR) & ISA_ISR_SERIAL)
  43                                 serial |= 0x10000;
  44                         serial >>= 1;
  45                 }
  46                 if (serial == ISA_SER_ID)
  47                         found++;
  48         }
  49         return found;
  50 }
  51
  52 int
  53 act2000_isa_detect(unsigned short portbase)
  54 {
  55         int ret = 0;
  56
  57         if (request_region(portbase, ACT2000_PORTLEN, "act2000isa")) {
  58                 ret = act2000_isa_reset(portbase);
  59                 release_region(portbase, ISA_REGION);
  60         }
  61         return ret;
  62 }
  63
  64 static irqreturn_t
  65 act2000_isa_interrupt(int dummy, void *dev_id)
  66 {
  67         act2000_card *card = dev_id;
  68         u_char istatus;
  69
  70         istatus = (inb(ISA_PORT_ISR) & 0x07);
  71         if (istatus & ISA_ISR_OUT) {
  72                 /* RX fifo has data */
  73                 istatus &= ISA_ISR_OUT_MASK;
  74                 outb(0, ISA_PORT_SIS);
  75                 act2000_isa_receive(card);
  76                 outb(ISA_SIS_INT, ISA_PORT_SIS);
  77         }
  78         if (istatus & ISA_ISR_ERR) {
  79                 /* Error Interrupt */
  80                 istatus &= ISA_ISR_ERR_MASK;
  81                 printk(KERN_WARNING "act2000: errIRQ\n");
  82         }
  83         if (istatus)
  84                 printk(KERN_DEBUG "act2000: ?IRQ %d %02x\n", card->irq, istatus);
  85         return IRQ_HANDLED;
  86 }
  87
  88 static void
  89 act2000_isa_select_irq(act2000_card *card)
  90 {
  91         unsigned char reg;
  92
  93         reg = (inb(ISA_PORT_COR) & ~ISA_COR_IRQOFF) | ISA_COR_PERR;
  94         switch (card->irq) {
  95         case 3:
  96                 reg = ISA_COR_IRQ03;
  97                 break;
  98         case 5:
  99                 reg = ISA_COR_IRQ05;
 100                 break;
 101         case 7:
 102                 reg = ISA_COR_IRQ07;
 103                 break;
 104         case 10:
 105                 reg = ISA_COR_IRQ10;
 106                 break;
 107         case 11:
 108                 reg = ISA_COR_IRQ11;
 109                 break;
 110         case 12:
 111                 reg = ISA_COR_IRQ12;
 112                 break;
 113         case 15:
 114                 reg = ISA_COR_IRQ15;
 115                 break;
 116         }
 117         outb(reg, ISA_PORT_COR);
 118 }
 119
 120 static void
 121 act2000_isa_enable_irq(act2000_card *card)
 122 {
 123         act2000_isa_select_irq(card);
 124         /* Enable READ irq */
 125         outb(ISA_SIS_INT, ISA_PORT_SIS);
 126 }
 127
 128 /*
 129  * Install interrupt handler, enable irq on card.
 130  * If irq is -1, choose next free irq, else irq is given explicitly.
 131  */
 132 int
 133 act2000_isa_config_irq(act2000_card *card, short irq)
 134 {
 135         int old_irq;
 136
 137         if (card->flags & ACT2000_FLAGS_IVALID)
 138                 free_irq(card->irq, card);
 139
 140         card->flags &= ~ACT2000_FLAGS_IVALID;
 141         outb(ISA_COR_IRQOFF, ISA_PORT_COR);
 142         if (!irq)
 143                 return 0;
 144
 145         old_irq = card->irq;
 146         card->irq = irq;
 147         if (request_irq(irq, &act2000_isa_interrupt, 0, card->regname, card)) {
 148                 card->irq = old_irq;
 149                 card->flags |= ACT2000_FLAGS_IVALID;
 150                 printk(KERN_WARNING
 151                        "act2000: Could not request irq %d\n", irq);
 152                 return -EBUSY;
 153         } else {
 154                 act2000_isa_select_irq(card);
 155                 /* Disable READ and WRITE irq */
 156                 outb(0, ISA_PORT_SIS);
 157                 outb(0, ISA_PORT_SOS);
 158         }
 159         return 0;
 160 }
 161
 162 int
 163 act2000_isa_config_port(act2000_card *card, unsigned short portbase)
 164 {
 165         if (card->flags & ACT2000_FLAGS_PVALID) {
 166                 release_region(card->port, ISA_REGION);
 167                 card->flags &= ~ACT2000_FLAGS_PVALID;
 168         }
 169         if (!request_region(portbase, ACT2000_PORTLEN, card->regname))
 170                 return -EBUSY;
 171         else {
 172                 card->port = portbase;
 173                 card->flags |= ACT2000_FLAGS_PVALID;
 174                 return 0;
 175         }
 176 }
 177
 178 /*
 179  * Release resources, used by an adaptor.
 180  */
 181 void
 182 act2000_isa_release(act2000_card *card)
 183 {
 184         unsigned long flags;
 185
 186         spin_lock_irqsave(&card->lock, flags);
 187         if (card->flags & ACT2000_FLAGS_IVALID)
 188                 free_irq(card->irq, card);
 189
 190         card->flags &= ~ACT2000_FLAGS_IVALID;
 191         if (card->flags & ACT2000_FLAGS_PVALID)
 192                 release_region(card->port, ISA_REGION);
 193         card->flags &= ~ACT2000_FLAGS_PVALID;
 194         spin_unlock_irqrestore(&card->lock, flags);
 195 }
 196
 197 static int
 198 act2000_isa_writeb(act2000_card *card, u_char data)
 199 {
 200         u_char timeout = 40;
 201
 202         while (timeout) {
 203                 if (inb(ISA_PORT_SOS) & ISA_SOS_READY) {
 204                         outb(data, ISA_PORT_SDO);
 205                         return 0;
 206                 } else {
 207                         timeout--;
 208                         udelay(10);
 209                 }
 210         }
 211         return 1;
 212 }
 213
 214 static int
 215 act2000_isa_readb(act2000_card *card, u_char *data)
 216 {
 217         u_char timeout = 40;
 218
 219         while (timeout) {
 220                 if (inb(ISA_PORT_SIS) & ISA_SIS_READY) {
 221                         *data = inb(ISA_PORT_SDI);
 222                         return 0;
 223                 } else {
 224                         timeout--;
 225                         udelay(10);
 226                 }
 227         }
 228         return 1;
 229 }
 230
 231 void
 232 act2000_isa_receive(act2000_card *card)
 233 {
 234         u_char c;
 235
 236         if (test_and_set_bit(ACT2000_LOCK_RX, (void *)&card->ilock) != 0)
 237                 return;
 238         while (!act2000_isa_readb(card, &c)) {
 239                 if (card->idat.isa.rcvidx < 8) {
 240                         card->idat.isa.rcvhdr[card->idat.isa.rcvidx++] = c;
 241                         if (card->idat.isa.rcvidx == 8) {
 242                                 int valid = actcapi_chkhdr(card, (actcapi_msghdr *)&card->idat.isa.rcvhdr);
 243
 244                                 if (valid) {
 245                                         card->idat.isa.rcvlen = ((actcapi_msghdr *)&card->idat.isa.rcvhdr)->len;
 246                                         card->idat.isa.rcvskb = dev_alloc_skb(card->idat.isa.rcvlen);
 247                                         if (!card->idat.isa.rcvskb) {
 248                                                 card->idat.isa.rcvignore = 1;
 249                                                 printk(KERN_WARNING
 250                                                        "act2000_isa_receive: no memory\n");
 251                                                 test_and_clear_bit(ACT2000_LOCK_RX, (void *)&card->ilock);
 252                                                 return;
 253                                         }
 254                                         memcpy(skb_put(card->idat.isa.rcvskb, 8), card->idat.isa.rcvhdr, 8);
 255                                         card->idat.isa.rcvptr = skb_put(card->idat.isa.rcvskb, card->idat.isa.rcvlen - 8);
 256                                 } else {
 257                                         card->idat.isa.rcvidx = 0;
 258                                         printk(KERN_WARNING
 259                                                "act2000_isa_receive: Invalid CAPI msg\n");
 260                                         {
 261                                                 int i; __u8 *p; __u8 *t; __u8 tmp[30];
 262                                                 for (i = 0, p = (__u8 *)&card->idat.isa.rcvhdr, t = tmp; i < 8; i++)
 263                                                         t += sprintf(t, "%02x ", *(p++));
 264                                                 printk(KERN_WARNING "act2000_isa_receive: %s\n", tmp);
 265                                         }
 266                                 }
 267                         }
 268                 } else {
 269                         if (!card->idat.isa.rcvignore)
 270                                 *card->idat.isa.rcvptr++ = c;
 271                         if (++card->idat.isa.rcvidx >= card->idat.isa.rcvlen) {
 272                                 if (!card->idat.isa.rcvignore) {
 273                                         skb_queue_tail(&card->rcvq, card->idat.isa.rcvskb);
 274                                         act2000_schedule_rx(card);
 275                                 }
 276                                 card->idat.isa.rcvidx = 0;
 277                                 card->idat.isa.rcvlen = 8;
 278                                 card->idat.isa.rcvignore = 0;
 279                                 card->idat.isa.rcvskb = NULL;
 280                                 card->idat.isa.rcvptr = card->idat.isa.rcvhdr;
 281                         }
 282                 }
 283         }
 284         if (!(card->flags & ACT2000_FLAGS_IVALID)) {
 285                 /* In polling mode, schedule myself */
 286                 if ((card->idat.isa.rcvidx) &&
 287                     (card->idat.isa.rcvignore ||
 288                      (card->idat.isa.rcvidx < card->idat.isa.rcvlen)))
 289                         act2000_schedule_poll(card);
 290         }
 291         test_and_clear_bit(ACT2000_LOCK_RX, (void *)&card->ilock);
 292 }
 293
 294 void
 295 act2000_isa_send(act2000_card *card)
 296 {
 297         unsigned long flags;
 298         struct sk_buff *skb;
 299         actcapi_msg *msg;
 300         int l;
 301
 302         if (test_and_set_bit(ACT2000_LOCK_TX, (void *)&card->ilock) != 0)
 303                 return;
 304         while (1) {
 305                 spin_lock_irqsave(&card->lock, flags);
 306                 if (!(card->sbuf)) {
 307                         card->sbuf = skb_dequeue(&card->sndq);
 308                         if (card->sbuf) {
 309                                 card->ack_msg = card->sbuf->data;
 310                                 msg = (actcapi_msg *)card->sbuf->data;
 311                                 if ((msg->hdr.cmd.cmd == 0x86) &&
 312                                     (msg->hdr.cmd.subcmd == 0)) {
 313                                         /* Save flags in message */
 314                                         card->need_b3ack = msg->msg.data_b3_req.flags;
 315                                         msg->msg.data_b3_req.flags = 0;
 316                                 }
 317                         }
 318                 }
 319                 spin_unlock_irqrestore(&card->lock, flags);
 320                 if (!(card->sbuf)) {
 321                         /* No more data to send */
 322                         test_and_clear_bit(ACT2000_LOCK_TX, (void *)&card->ilock);
 323                         return;
 324                 }
 325                 skb = card->sbuf;
 326                 l = 0;
 327                 while (skb->len) {
 328                         if (act2000_isa_writeb(card, *(skb->data))) {
 329                                 /* Fifo is full, but more data to send */
 330                                 test_and_clear_bit(ACT2000_LOCK_TX, (void *)&card->ilock);
 331                                 /* Schedule myself */
 332                                 act2000_schedule_tx(card);
 333                                 return;
 334                         }
 335                         skb_pull(skb, 1);
 336                         l++;
 337                 }
 338                 msg = (actcapi_msg *)card->ack_msg;
 339                 if ((msg->hdr.cmd.cmd == 0x86) &&
 340                     (msg->hdr.cmd.subcmd == 0)) {
 341                         /*
 342                          * If it's user data, reset data-ptr
 343                          * and put skb into ackq.
 344                          */
 345                         skb->data = card->ack_msg;
 346                         /* Restore flags in message */
 347                         msg->msg.data_b3_req.flags = card->need_b3ack;
 348                         skb_queue_tail(&card->ackq, skb);
 349                 } else
 350                         dev_kfree_skb(skb);
 351                 card->sbuf = NULL;
 352         }
 353 }
 354
 355 /*
 356  * Get firmware ID, check for 'ISDN' signature.
 357  */
 358 static int
 359 act2000_isa_getid(act2000_card *card)
 360 {
 361         act2000_fwid fid;
 362         u_char *p = (u_char *)&fid;
 363         int count = 0;
 364
 365         while (1) {
 366                 if (count > 510)
 367                         return -EPROTO;
 368                 if (act2000_isa_readb(card, p++))
 369                         break;
 370                 count++;
 371         }
 372         if (count <= 20) {
 373                 printk(KERN_WARNING "act2000: No Firmware-ID!\n");
 374                 return -ETIME;
 375         }
 376         *p = '\0';
 377         fid.revlen[0] = '\0';
 378         if (strcmp(fid.isdn, "ISDN")) {
 379                 printk(KERN_WARNING "act2000: Wrong Firmware-ID!\n");
 380                 return -EPROTO;
 381         }
 382         p = strchr(fid.revision, '\n');
 383         if (p)
 384                 *p = '\0';
 385         printk(KERN_INFO "act2000: Firmware-ID: %s\n", fid.revision);
 386         if (card->flags & ACT2000_FLAGS_IVALID) {
 387                 printk(KERN_DEBUG "Enabling Interrupts ...\n");
 388                 act2000_isa_enable_irq(card);
 389         }
 390         return 0;
 391 }
 392
 393 /*
 394  * Download microcode into card, check Firmware signature.
 395  */
 396 int
 397 act2000_isa_download(act2000_card *card, act2000_ddef __user *cb)
 398 {
 399         unsigned int length;
 400         int l;
 401         int c;
 402         u_char *b;
 403         u_char __user *p;
 404         u_char *buf;
 405         act2000_ddef cblock;
 406
 407         if (!act2000_isa_reset(card->port))
 408                 return -ENXIO;
 409         msleep_interruptible(500);
 410         if (copy_from_user(&cblock, cb, sizeof(cblock)))
 411                 return -EFAULT;
 412         length = cblock.length;
 413         p = cblock.buffer;
 414         if (!access_ok(VERIFY_READ, p, length))
 415                 return -EFAULT;
 416         buf = kmalloc(1024, GFP_KERNEL);
 417         if (!buf)
 418                 return -ENOMEM;
 419         while (length) {
 420                 l = (length > 1024) ? 1024 : length;
 421                 c = 0;
 422                 b = buf;
 423                 if (copy_from_user(buf, p, l)) {
 424                         kfree(buf);
 425                         return -EFAULT;
 426                 }
 427                 while (c < l) {
 428                         if (act2000_isa_writeb(card, *b++)) {
 429                                 printk(KERN_WARNING
 430                                        "act2000: loader timed out"
 431                                        " len=%d c=%d\n", length, c);
 432                                 kfree(buf);
 433                                 return -ETIME;
 434                         }
 435                         c++;
 436                 }
 437                 length -= l;
 438                 p += l;
 439         }
 440         kfree(buf);
 441         msleep_interruptible(500);
 442         return act2000_isa_getid(card);
 443 }