1/* 2 * This software may be used and distributed according to the terms 3 * of the GNU General Public License, incorporated herein by reference. 4 * 5 */ 6 7#include <linux/module.h> 8#include <linux/init.h> 9#include <linux/interrupt.h> 10#include <linux/delay.h> 11#include "includes.h" 12#include "hardware.h" 13#include "card.h" 14 15MODULE_DESCRIPTION("ISDN4Linux: Driver for Spellcaster card"); 16MODULE_AUTHOR("Spellcaster Telecommunications Inc."); 17MODULE_LICENSE("GPL"); 18 19board *sc_adapter[MAX_CARDS]; 20int cinst; 21 22static char devname[] = "scX"; 23static const char version[] = "2.0b1"; 24 25static const char *boardname[] = { "DataCommute/BRI", "DataCommute/PRI", "TeleCommute/BRI" }; 26 27/* insmod set parameters */ 28static unsigned int io[] = {0,0,0,0}; 29static unsigned char irq[] = {0,0,0,0}; 30static unsigned long ram[] = {0,0,0,0}; 31static int do_reset = 0; 32 33module_param_array(io, int, NULL, 0); 34module_param_array(irq, int, NULL, 0); 35module_param_array(ram, int, NULL, 0); 36module_param(do_reset, bool, 0); 37 38static int identify_board(unsigned long, unsigned int); 39 40static int __init sc_init(void) 41{ 42 int b = -1; 43 int i, j; 44 int status = -ENODEV; 45 46 unsigned long memsize = 0; 47 unsigned long features = 0; 48 isdn_if *interface; 49 unsigned char channels; 50 unsigned char pgport; 51 unsigned long magic; 52 int model; 53 int last_base = IOBASE_MIN; 54 int probe_exhasted = 0; 55 56#ifdef MODULE 57 pr_info("SpellCaster ISA ISDN Adapter Driver rev. %s Loaded\n", version); 58#else 59 pr_info("SpellCaster ISA ISDN Adapter Driver rev. %s\n", version); 60#endif 61 pr_info("Copyright (C) 1996 SpellCaster Telecommunications Inc.\n"); 62 63 while(b++ < MAX_CARDS - 1) { 64 pr_debug("Probing for adapter #%d\n", b); 65 /* 66 * Initialize reusable variables 67 */ 68 model = -1; 69 magic = 0; 70 channels = 0; 71 pgport = 0; 72 73 /* 74 * See if we should probe for IO base 75 */ 76 pr_debug("I/O Base for board %d is 0x%x, %s probe\n", b, io[b], 77 io[b] == 0 ? "will" : "won't"); 78 if(io[b]) { 79 /* 80 * No, I/O Base has been provided 81 */ 82 for (i = 0 ; i < MAX_IO_REGS - 1 ; i++) { 83 if(!request_region(io[b] + i * 0x400, 1, "sc test")) { 84 pr_debug("request_region for 0x%x failed\n", io[b] + i * 0x400); 85 io[b] = 0; 86 break; 87 } else 88 release_region(io[b] + i * 0x400, 1); 89 } 90 91 /* 92 * Confirm the I/O Address with a test 93 */ 94 if(io[b] == 0) { 95 pr_debug("I/O Address invalid.\n"); 96 continue; 97 } 98 99 outb(0x18, io[b] + 0x400 * EXP_PAGE0); 100 if(inb(io[b] + 0x400 * EXP_PAGE0) != 0x18) { 101 pr_debug("I/O Base 0x%x fails test\n", 102 io[b] + 0x400 * EXP_PAGE0); 103 continue; 104 } 105 } 106 else { 107 /* 108 * Yes, probe for I/O Base 109 */ 110 if(probe_exhasted) { 111 pr_debug("All probe addresses exhasted, skipping\n"); 112 continue; 113 } 114 pr_debug("Probing for I/O...\n"); 115 for (i = last_base ; i <= IOBASE_MAX ; i += IOBASE_OFFSET) { 116 int found_io = 1; 117 if (i == IOBASE_MAX) { 118 probe_exhasted = 1; /* No more addresses to probe */ 119 pr_debug("End of Probes\n"); 120 } 121 last_base = i + IOBASE_OFFSET; 122 pr_debug(" checking 0x%x...", i); 123 for ( j = 0 ; j < MAX_IO_REGS - 1 ; j++) { 124 if(!request_region(i + j * 0x400, 1, "sc test")) { 125 pr_debug("Failed\n"); 126 found_io = 0; 127 break; 128 } else 129 release_region(i + j * 0x400, 1); 130 } 131 132 if(found_io) { 133 io[b] = i; 134 outb(0x18, io[b] + 0x400 * EXP_PAGE0); 135 if(inb(io[b] + 0x400 * EXP_PAGE0) != 0x18) { 136 pr_debug("Failed by test\n"); 137 continue; 138 } 139 pr_debug("Passed\n"); 140 break; 141 } 142 } 143 if(probe_exhasted) { 144 continue; 145 } 146 } 147 148 /* 149 * See if we should probe for shared RAM 150 */ 151 if(do_reset) { 152 pr_debug("Doing a SAFE probe reset\n"); 153 outb(0xFF, io[b] + RESET_OFFSET); 154 msleep_interruptible(10000); 155 } 156 pr_debug("RAM Base for board %d is 0x%lx, %s probe\n", b, 157 ram[b], ram[b] == 0 ? "will" : "won't"); 158 159 if(ram[b]) { 160 /* 161 * No, the RAM base has been provided 162 * Just look for a signature and ID the 163 * board model 164 */ 165 if(request_region(ram[b], SRAM_PAGESIZE, "sc test")) { 166 pr_debug("request_region for RAM base 0x%lx succeeded\n", ram[b]); 167 model = identify_board(ram[b], io[b]); 168 release_region(ram[b], SRAM_PAGESIZE); 169 } 170 } 171 else { 172 /* 173 * Yes, probe for free RAM and look for 174 * a signature and id the board model 175 */ 176 for (i = SRAM_MIN ; i < SRAM_MAX ; i += SRAM_PAGESIZE) { 177 pr_debug("Checking RAM address 0x%x...\n", i); 178 if(request_region(i, SRAM_PAGESIZE, "sc test")) { 179 pr_debug(" request_region succeeded\n"); 180 model = identify_board(i, io[b]); 181 release_region(i, SRAM_PAGESIZE); 182 if (model >= 0) { 183 pr_debug(" Identified a %s\n", 184 boardname[model]); 185 ram[b] = i; 186 break; 187 } 188 pr_debug(" Unidentifed or inaccessible\n"); 189 continue; 190 } 191 pr_debug(" request failed\n"); 192 } 193 } 194 /* 195 * See if we found free RAM and the board model 196 */ 197 if(!ram[b] || model < 0) { 198 /* 199 * Nope, there was no place in RAM for the 200 * board, or it couldn't be identified 201 */ 202 pr_debug("Failed to find an adapter at 0x%lx\n", ram[b]); 203 continue; 204 } 205 206 /* 207 * Set the board's magic number, memory size and page register 208 */ 209 switch(model) { 210 case PRI_BOARD: 211 channels = 23; 212 magic = 0x20000; 213 memsize = 0x100000; 214 features = PRI_FEATURES; 215 break; 216 217 case BRI_BOARD: 218 case POTS_BOARD: 219 channels = 2; 220 magic = 0x60000; 221 memsize = 0x10000; 222 features = BRI_FEATURES; 223 break; 224 } 225 switch(ram[b] >> 12 & 0x0F) { 226 case 0x0: 227 pr_debug("RAM Page register set to EXP_PAGE0\n"); 228 pgport = EXP_PAGE0; 229 break; 230 231 case 0x4: 232 pr_debug("RAM Page register set to EXP_PAGE1\n"); 233 pgport = EXP_PAGE1; 234 break; 235 236 case 0x8: 237 pr_debug("RAM Page register set to EXP_PAGE2\n"); 238 pgport = EXP_PAGE2; 239 break; 240 241 case 0xC: 242 pr_debug("RAM Page register set to EXP_PAGE3\n"); 243 pgport = EXP_PAGE3; 244 break; 245 246 default: 247 pr_debug("RAM base address doesn't fall on 16K boundary\n"); 248 continue; 249 } 250 251 pr_debug("current IRQ: %d b: %d\n",irq[b],b); 252 253 /* 254 * Make sure we got an IRQ 255 */ 256 if(!irq[b]) { 257 /* 258 * No interrupt could be used 259 */ 260 pr_debug("Failed to acquire an IRQ line\n"); 261 continue; 262 } 263 264 /* 265 * Horray! We found a board, Make sure we can register 266 * it with ISDN4Linux 267 */ 268 interface = kzalloc(sizeof(isdn_if), GFP_KERNEL); 269 if (interface == NULL) { 270 /* 271 * Oops, can't malloc isdn_if 272 */ 273 continue; 274 } 275 276 interface->owner = THIS_MODULE; 277 interface->hl_hdrlen = 0; 278 interface->channels = channels; 279 interface->maxbufsize = BUFFER_SIZE; 280 interface->features = features; 281 interface->writebuf_skb = sndpkt; 282 interface->writecmd = NULL; 283 interface->command = command; 284 strcpy(interface->id, devname); 285 interface->id[2] = '0' + cinst; 286 287 /* 288 * Allocate the board structure 289 */ 290 sc_adapter[cinst] = kzalloc(sizeof(board), GFP_KERNEL); 291 if (sc_adapter[cinst] == NULL) { 292 /* 293 * Oops, can't alloc memory for the board 294 */ 295 kfree(interface); 296 continue; 297 } 298 spin_lock_init(&sc_adapter[cinst]->lock); 299 300 if(!register_isdn(interface)) { 301 /* 302 * Oops, couldn't register for some reason 303 */ 304 kfree(interface); 305 kfree(sc_adapter[cinst]); 306 continue; 307 } 308 309 sc_adapter[cinst]->card = interface; 310 sc_adapter[cinst]->driverId = interface->channels; 311 strcpy(sc_adapter[cinst]->devicename, interface->id); 312 sc_adapter[cinst]->nChannels = channels; 313 sc_adapter[cinst]->ramsize = memsize; 314 sc_adapter[cinst]->shmem_magic = magic; 315 sc_adapter[cinst]->shmem_pgport = pgport; 316 sc_adapter[cinst]->StartOnReset = 1; 317 318 /* 319 * Allocate channels status structures 320 */ 321 sc_adapter[cinst]->channel = kzalloc(sizeof(bchan) * channels, GFP_KERNEL); 322 if (sc_adapter[cinst]->channel == NULL) { 323 /* 324 * Oops, can't alloc memory for the channels 325 */ 326 indicate_status(cinst, ISDN_STAT_UNLOAD, 0, NULL); /* Fix me */ 327 kfree(interface); 328 kfree(sc_adapter[cinst]); 329 continue; 330 } 331 332 /* 333 * Lock down the hardware resources 334 */ 335 sc_adapter[cinst]->interrupt = irq[b]; 336 if (request_irq(sc_adapter[cinst]->interrupt, interrupt_handler, 337 IRQF_DISABLED, interface->id, NULL)) 338 { 339 kfree(sc_adapter[cinst]->channel); 340 indicate_status(cinst, ISDN_STAT_UNLOAD, 0, NULL); /* Fix me */ 341 kfree(interface); 342 kfree(sc_adapter[cinst]); 343 continue; 344 345 } 346 sc_adapter[cinst]->iobase = io[b]; 347 for(i = 0 ; i < MAX_IO_REGS - 1 ; i++) { 348 sc_adapter[cinst]->ioport[i] = io[b] + i * 0x400; 349 request_region(sc_adapter[cinst]->ioport[i], 1, 350 interface->id); 351 pr_debug("Requesting I/O Port %#x\n", 352 sc_adapter[cinst]->ioport[i]); 353 } 354 sc_adapter[cinst]->ioport[IRQ_SELECT] = io[b] + 0x2; 355 request_region(sc_adapter[cinst]->ioport[IRQ_SELECT], 1, 356 interface->id); 357 pr_debug("Requesting I/O Port %#x\n", 358 sc_adapter[cinst]->ioport[IRQ_SELECT]); 359 sc_adapter[cinst]->rambase = ram[b]; 360 request_region(sc_adapter[cinst]->rambase, SRAM_PAGESIZE, 361 interface->id); 362 363 pr_info(" %s (%d) - %s %d channels IRQ %d, I/O Base 0x%x, RAM Base 0x%lx\n", 364 sc_adapter[cinst]->devicename, 365 sc_adapter[cinst]->driverId, 366 boardname[model], channels, irq[b], io[b], ram[b]); 367 368 /* 369 * reset the adapter to put things in motion 370 */ 371 reset(cinst); 372 373 cinst++; 374 status = 0; 375 } 376 if (status) 377 pr_info("Failed to find any adapters, driver unloaded\n"); 378 return status; 379} 380 381static void __exit sc_exit(void) 382{ 383 int i, j; 384 385 for(i = 0 ; i < cinst ; i++) { 386 pr_debug("Cleaning up after adapter %d\n", i); 387 /* 388 * kill the timers 389 */ 390 del_timer(&(sc_adapter[i]->reset_timer)); 391 del_timer(&(sc_adapter[i]->stat_timer)); 392 393 /* 394 * Tell I4L we're toast 395 */ 396 indicate_status(i, ISDN_STAT_STOP, 0, NULL); 397 indicate_status(i, ISDN_STAT_UNLOAD, 0, NULL); 398 399 /* 400 * Release shared RAM 401 */ 402 release_region(sc_adapter[i]->rambase, SRAM_PAGESIZE); 403 404 /* 405 * Release the IRQ 406 */ 407 FREE_IRQ(sc_adapter[i]->interrupt, NULL); 408 409 /* 410 * Reset for a clean start 411 */ 412 outb(0xFF, sc_adapter[i]->ioport[SFT_RESET]); 413 414 /* 415 * Release the I/O Port regions 416 */ 417 for(j = 0 ; j < MAX_IO_REGS - 1; j++) { 418 release_region(sc_adapter[i]->ioport[j], 1); 419 pr_debug("Releasing I/O Port %#x\n", 420 sc_adapter[i]->ioport[j]); 421 } 422 release_region(sc_adapter[i]->ioport[IRQ_SELECT], 1); 423 pr_debug("Releasing I/O Port %#x\n", 424 sc_adapter[i]->ioport[IRQ_SELECT]); 425 426 /* 427 * Release any memory we alloced 428 */ 429 kfree(sc_adapter[i]->channel); 430 kfree(sc_adapter[i]->card); 431 kfree(sc_adapter[i]); 432 } 433 pr_info("SpellCaster ISA ISDN Adapter Driver Unloaded.\n"); 434} 435 436static int identify_board(unsigned long rambase, unsigned int iobase) 437{ 438 unsigned int pgport; 439 unsigned long sig; 440 DualPortMemory *dpm; 441 RspMessage rcvmsg; 442 ReqMessage sndmsg; 443 HWConfig_pl hwci; 444 int x; 445 446 pr_debug("Attempting to identify adapter @ 0x%lx io 0x%x\n", 447 rambase, iobase); 448 449 /* 450 * Enable the base pointer 451 */ 452 outb(rambase >> 12, iobase + 0x2c00); 453 454 switch(rambase >> 12 & 0x0F) { 455 case 0x0: 456 pgport = iobase + PG0_OFFSET; 457 pr_debug("Page Register offset is 0x%x\n", PG0_OFFSET); 458 break; 459 460 case 0x4: 461 pgport = iobase + PG1_OFFSET; 462 pr_debug("Page Register offset is 0x%x\n", PG1_OFFSET); 463 break; 464 465 case 0x8: 466 pgport = iobase + PG2_OFFSET; 467 pr_debug("Page Register offset is 0x%x\n", PG2_OFFSET); 468 break; 469 470 case 0xC: 471 pgport = iobase + PG3_OFFSET; 472 pr_debug("Page Register offset is 0x%x\n", PG3_OFFSET); 473 break; 474 default: 475 pr_debug("Invalid rambase 0x%lx\n", rambase); 476 return -1; 477 } 478 479 /* 480 * Try to identify a PRI card 481 */ 482 outb(PRI_BASEPG_VAL, pgport); 483 msleep_interruptible(1000); 484 sig = readl(rambase + SIG_OFFSET); 485 pr_debug("Looking for a signature, got 0x%lx\n", sig); 486 if(sig == SIGNATURE) 487 return PRI_BOARD; 488 489 /* 490 * Try to identify a PRI card 491 */ 492 outb(BRI_BASEPG_VAL, pgport); 493 msleep_interruptible(1000); 494 sig = readl(rambase + SIG_OFFSET); 495 pr_debug("Looking for a signature, got 0x%lx\n", sig); 496 if(sig == SIGNATURE) 497 return BRI_BOARD; 498 499 return -1; 500 501 /* 502 * Try to spot a card 503 */ 504 sig = readl(rambase + SIG_OFFSET); 505 pr_debug("Looking for a signature, got 0x%lx\n", sig); 506 if(sig != SIGNATURE) 507 return -1; 508 509 dpm = (DualPortMemory *) rambase; 510 511 memset(&sndmsg, 0, MSG_LEN); 512 sndmsg.msg_byte_cnt = 3; 513 sndmsg.type = cmReqType1; 514 sndmsg.class = cmReqClass0; 515 sndmsg.code = cmReqHWConfig; 516 memcpy_toio(&(dpm->req_queue[dpm->req_head++]), &sndmsg, MSG_LEN); 517 outb(0, iobase + 0x400); 518 pr_debug("Sent HWConfig message\n"); 519 /* 520 * Wait for the response 521 */ 522 x = 0; 523 while((inb(iobase + FIFOSTAT_OFFSET) & RF_HAS_DATA) && x < 100) { 524 schedule_timeout_interruptible(1); 525 x++; 526 } 527 if(x == 100) { 528 pr_debug("Timeout waiting for response\n"); 529 return -1; 530 } 531 532 memcpy_fromio(&rcvmsg, &(dpm->rsp_queue[dpm->rsp_tail]), MSG_LEN); 533 pr_debug("Got HWConfig response, status = 0x%x\n", rcvmsg.rsp_status); 534 memcpy(&hwci, &(rcvmsg.msg_data.HWCresponse), sizeof(HWConfig_pl)); 535 pr_debug("Hardware Config: Interface: %s, RAM Size: %ld, Serial: %s\n" 536 " Part: %s, Rev: %s\n", 537 hwci.st_u_sense ? "S/T" : "U", hwci.ram_size, 538 hwci.serial_no, hwci.part_no, hwci.rev_no); 539 540 if(!strncmp(PRI_PARTNO, hwci.part_no, 6)) 541 return PRI_BOARD; 542 if(!strncmp(BRI_PARTNO, hwci.part_no, 6)) 543 return BRI_BOARD; 544 545 return -1; 546} 547 548module_init(sc_init); 549module_exit(sc_exit); 550