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