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 <linux/sched.h> 12#include <linux/slab.h> 13#include "includes.h" 14#include "hardware.h" 15#include "card.h" 16 17MODULE_DESCRIPTION("ISDN4Linux: Driver for Spellcaster card"); 18MODULE_AUTHOR("Spellcaster Telecommunications Inc."); 19MODULE_LICENSE("GPL"); 20 21board *sc_adapter[MAX_CARDS]; 22int cinst; 23 24static char devname[] = "scX"; 25static const char version[] = "2.0b1"; 26 27static const char *boardname[] = { "DataCommute/BRI", "DataCommute/PRI", "TeleCommute/BRI" }; 28 29/* insmod set parameters */ 30static unsigned int io[] = {0, 0, 0, 0}; 31static unsigned char irq[] = {0, 0, 0, 0}; 32static unsigned long ram[] = {0, 0, 0, 0}; 33static bool do_reset; 34 35module_param_array(io, int, NULL, 0); 36module_param_array(irq, byte, NULL, 0); 37module_param_array(ram, long, NULL, 0); 38module_param(do_reset, bool, 0); 39 40static int identify_board(unsigned long, unsigned int); 41 42static int __init sc_init(void) 43{ 44 int b = -1; 45 int i, j; 46 int status = -ENODEV; 47 48 unsigned long memsize = 0; 49 unsigned long features = 0; 50 isdn_if *interface; 51 unsigned char channels; 52 unsigned char pgport; 53 unsigned long magic; 54 int model; 55 int last_base = IOBASE_MIN; 56 int probe_exhasted = 0; 57 58#ifdef MODULE 59 pr_info("SpellCaster ISA ISDN Adapter Driver rev. %s Loaded\n", version); 60#else 61 pr_info("SpellCaster ISA ISDN Adapter Driver rev. %s\n", version); 62#endif 63 pr_info("Copyright (C) 1996 SpellCaster Telecommunications Inc.\n"); 64 65 while (b++ < MAX_CARDS - 1) { 66 pr_debug("Probing for adapter #%d\n", b); 67 /* 68 * Initialize reusable variables 69 */ 70 model = -1; 71 magic = 0; 72 channels = 0; 73 pgport = 0; 74 75 /* 76 * See if we should probe for IO base 77 */ 78 pr_debug("I/O Base for board %d is 0x%x, %s probe\n", b, io[b], 79 io[b] == 0 ? "will" : "won't"); 80 if (io[b]) { 81 /* 82 * No, I/O Base has been provided 83 */ 84 for (i = 0; i < MAX_IO_REGS - 1; i++) { 85 if (!request_region(io[b] + i * 0x400, 1, "sc test")) { 86 pr_debug("request_region for 0x%x failed\n", io[b] + i * 0x400); 87 io[b] = 0; 88 break; 89 } else 90 release_region(io[b] + i * 0x400, 1); 91 } 92 93 /* 94 * Confirm the I/O Address with a test 95 */ 96 if (io[b] == 0) { 97 pr_debug("I/O Address invalid.\n"); 98 continue; 99 } 100 101 outb(0x18, io[b] + 0x400 * EXP_PAGE0); 102 if (inb(io[b] + 0x400 * EXP_PAGE0) != 0x18) { 103 pr_debug("I/O Base 0x%x fails test\n", 104 io[b] + 0x400 * EXP_PAGE0); 105 continue; 106 } 107 } else { 108 /* 109 * Yes, probe for I/O Base 110 */ 111 if (probe_exhasted) { 112 pr_debug("All probe addresses exhausted, skipping\n"); 113 continue; 114 } 115 pr_debug("Probing for I/O...\n"); 116 for (i = last_base; i <= IOBASE_MAX; i += IOBASE_OFFSET) { 117 int found_io = 1; 118 if (i == IOBASE_MAX) { 119 probe_exhasted = 1; /* No more addresses to probe */ 120 pr_debug("End of Probes\n"); 121 } 122 last_base = i + IOBASE_OFFSET; 123 pr_debug(" checking 0x%x...", i); 124 for (j = 0; j < MAX_IO_REGS - 1; j++) { 125 if (!request_region(i + j * 0x400, 1, "sc test")) { 126 pr_debug("Failed\n"); 127 found_io = 0; 128 break; 129 } else 130 release_region(i + j * 0x400, 1); 131 } 132 133 if (found_io) { 134 io[b] = i; 135 outb(0x18, io[b] + 0x400 * EXP_PAGE0); 136 if (inb(io[b] + 0x400 * EXP_PAGE0) != 0x18) { 137 pr_debug("Failed by test\n"); 138 continue; 139 } 140 pr_debug("Passed\n"); 141 break; 142 } 143 } 144 if (probe_exhasted) { 145 continue; 146 } 147 } 148 149 /* 150 * See if we should probe for shared RAM 151 */ 152 if (do_reset) { 153 pr_debug("Doing a SAFE probe reset\n"); 154 outb(0xFF, io[b] + RESET_OFFSET); 155 msleep_interruptible(10000); 156 } 157 pr_debug("RAM Base for board %d is 0x%lx, %s probe\n", b, 158 ram[b], ram[b] == 0 ? "will" : "won't"); 159 160 if (ram[b]) { 161 /* 162 * No, the RAM base has been provided 163 * Just look for a signature and ID the 164 * board model 165 */ 166 if (request_region(ram[b], SRAM_PAGESIZE, "sc test")) { 167 pr_debug("request_region for RAM base 0x%lx succeeded\n", ram[b]); 168 model = identify_board(ram[b], io[b]); 169 release_region(ram[b], SRAM_PAGESIZE); 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(" Unidentified 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 0, interface->id, 338 (void *)(unsigned long) cinst)) { 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_sync(&(sc_adapter[i]->reset_timer)); 391 del_timer_sync(&(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