1 /*====================================================================== 2 3 NinjaSCSI-3 / NinjaSCSI-32Bi PCMCIA SCSI host adapter card driver 4 By: YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp> 5 6 Ver.2.8 Support 32bit MMIO mode 7 Support Synchronous Data Transfer Request (SDTR) mode 8 Ver.2.0 Support 32bit PIO mode 9 Ver.1.1.2 Fix for scatter list buffer exceeds 10 Ver.1.1 Support scatter list 11 Ver.0.1 Initial version 12 13 This software may be used and distributed according to the terms of 14 the GNU General Public License. 15 16 ======================================================================*/ 17 18 /*********************************************************************** 19 This driver is for these PCcards. 20 21 I-O DATA PCSC-F (Workbit NinjaSCSI-3) 22 "WBT", "NinjaSCSI-3", "R1.0" 23 I-O DATA CBSC-II (Workbit NinjaSCSI-32Bi in 16bit mode) 24 "IO DATA", "CBSC16 ", "1" 25 26 ***********************************************************************/ 27 28 /* $Id: nsp_cs.c,v 1.23 2003/08/18 11:09:19 elca Exp $ */ 29 30 #include <linux/version.h> 31 #include <linux/module.h> 32 #include <linux/kernel.h> 33 #include <linux/init.h> 34 #include <linux/sched.h> 35 #include <linux/slab.h> 36 #include <linux/string.h> 37 #include <linux/timer.h> 38 #include <linux/ioport.h> 39 #include <linux/delay.h> 40 #include <linux/interrupt.h> 41 #include <linux/major.h> 42 #include <linux/blkdev.h> 43 #include <linux/stat.h> 44 45 #include <asm/io.h> 46 #include <asm/irq.h> 47 48 #include <../drivers/scsi/scsi.h> 49 #include <scsi/scsi_host.h> 50 51 #include <scsi/scsi.h> 52 #include <scsi/scsi_ioctl.h> 53 54 #include <pcmcia/version.h> 55 #include <pcmcia/cs_types.h> 56 #include <pcmcia/cs.h> 57 #include <pcmcia/cistpl.h> 58 #include <pcmcia/cisreg.h> 59 #include <pcmcia/ds.h> 60 61 #include "nsp_cs.h" 62 63 MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>"); 64 MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module $Revision: 1.23 $"); 65 MODULE_SUPPORTED_DEVICE("sd,sr,sg,st"); 66 #ifdef MODULE_LICENSE 67 MODULE_LICENSE("GPL"); 68 #endif 69 70 #include "nsp_io.h" 71 72 /*====================================================================*/ 73 /* Parameters that can be set with 'insmod' */ 74 75 static int nsp_burst_mode = BURST_MEM32; 76 module_param(nsp_burst_mode, int, 0); 77 MODULE_PARM_DESC(nsp_burst_mode, "Burst transfer mode (0=io8, 1=io32, 2=mem32(default))"); 78 79 /* Release IO ports after configuration? */ 80 static int free_ports = 0; 81 module_param(free_ports, bool, 0); 82 MODULE_PARM_DESC(free_ports, "Release IO ports after configuration? (default: 0 (=no))"); 83 84 /* /usr/src/linux/drivers/scsi/hosts.h */ 85 static Scsi_Host_Template nsp_driver_template = { 86 .proc_name = "nsp_cs", 87 .proc_info = nsp_proc_info, 88 .name = "WorkBit NinjaSCSI-3/32Bi(16bit)", 89 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) 90 .detect = nsp_detect_old, 91 .release = nsp_release_old, 92 #endif 93 .info = nsp_info, 94 .queuecommand = nsp_queuecommand, 95 /* .eh_abort_handler = nsp_eh_abort,*/ 96 .eh_bus_reset_handler = nsp_eh_bus_reset, 97 .eh_host_reset_handler = nsp_eh_host_reset, 98 .can_queue = 1, 99 .this_id = NSP_INITIATOR_ID, 100 .sg_tablesize = SG_ALL, 101 .cmd_per_lun = 1, 102 .use_clustering = DISABLE_CLUSTERING, 103 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,2)) 104 .use_new_eh_code = 1, 105 #endif 106 }; 107 108 static dev_link_t *dev_list = NULL; 109 static dev_info_t dev_info = {"nsp_cs"}; 110 111 static nsp_hw_data nsp_data_base; /* attach <-> detect glue */ 112 113 114 115 /* 116 * debug, error print 117 */ 118 #ifndef NSP_DEBUG 119 # define NSP_DEBUG_MASK 0x000000 120 # define nsp_msg(type, args...) nsp_cs_message("", 0, (type), args) 121 # define nsp_dbg(mask, args...) /* */ 122 #else 123 # define NSP_DEBUG_MASK 0xffffff 124 # define nsp_msg(type, args...) \ 125 nsp_cs_message (__FUNCTION__, __LINE__, (type), args) 126 # define nsp_dbg(mask, args...) \ 127 nsp_cs_dmessage(__FUNCTION__, __LINE__, (mask), args) 128 #endif 129 130 #define NSP_DEBUG_QUEUECOMMAND BIT(0) 131 #define NSP_DEBUG_REGISTER BIT(1) 132 #define NSP_DEBUG_AUTOSCSI BIT(2) 133 #define NSP_DEBUG_INTR BIT(3) 134 #define NSP_DEBUG_SGLIST BIT(4) 135 #define NSP_DEBUG_BUSFREE BIT(5) 136 #define NSP_DEBUG_CDB_CONTENTS BIT(6) 137 #define NSP_DEBUG_RESELECTION BIT(7) 138 #define NSP_DEBUG_MSGINOCCUR BIT(8) 139 #define NSP_DEBUG_EEPROM BIT(9) 140 #define NSP_DEBUG_MSGOUTOCCUR BIT(10) 141 #define NSP_DEBUG_BUSRESET BIT(11) 142 #define NSP_DEBUG_RESTART BIT(12) 143 #define NSP_DEBUG_SYNC BIT(13) 144 #define NSP_DEBUG_WAIT BIT(14) 145 #define NSP_DEBUG_TARGETFLAG BIT(15) 146 #define NSP_DEBUG_PROC BIT(16) 147 #define NSP_DEBUG_INIT BIT(17) 148 #define NSP_DEBUG_DATA_IO BIT(18) 149 #define NSP_SPECIAL_PRINT_REGISTER BIT(20) 150 151 #define NSP_DEBUG_BUF_LEN 150 152 153 static void nsp_cs_message(const char *func, int line, char *type, char *fmt, ...) 154 { 155 va_list args; 156 char buf[NSP_DEBUG_BUF_LEN]; 157 158 va_start(args, fmt); 159 vsnprintf(buf, sizeof(buf), fmt, args); 160 va_end(args); 161 162 #ifndef NSP_DEBUG 163 printk("%snsp_cs: %s\n", type, buf); 164 #else 165 printk("%snsp_cs: %s (%d): %s\n", type, func, line, buf); 166 #endif 167 } 168 169 #ifdef NSP_DEBUG 170 static void nsp_cs_dmessage(const char *func, int line, int mask, char *fmt, ...) 171 { 172 va_list args; 173 char buf[NSP_DEBUG_BUF_LEN]; 174 175 va_start(args, fmt); 176 vsnprintf(buf, sizeof(buf), fmt, args); 177 va_end(args); 178 179 if (mask & NSP_DEBUG_MASK) { 180 printk("nsp_cs-debug: 0x%x %s (%d): %s\n", mask, func, line, buf); 181 } 182 } 183 #endif 184 185 /***********************************************************/ 186 187 /*==================================================== 188 * Clenaup parameters and call done() functions. 189 * You must be set SCpnt->result before call this function. 190 */ 191 static void nsp_scsi_done(Scsi_Cmnd *SCpnt) 192 { 193 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 194 195 data->CurrentSC = NULL; 196 197 SCpnt->scsi_done(SCpnt); 198 } 199 200 static int nsp_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) 201 { 202 #ifdef NSP_DEBUG 203 /*unsigned int host_id = SCpnt->device->host->this_id;*/ 204 /*unsigned int base = SCpnt->device->host->io_port;*/ 205 unsigned char target = SCpnt->device->id; 206 #endif 207 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 208 209 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "SCpnt=0x%p target=%d lun=%d buff=0x%p bufflen=%d use_sg=%d", 210 SCpnt, target, SCpnt->device->lun, SCpnt->request_buffer, SCpnt->request_bufflen, SCpnt->use_sg); 211 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "before CurrentSC=0x%p", data->CurrentSC); 212 213 SCpnt->scsi_done = done; 214 215 if (data->CurrentSC != NULL) { 216 nsp_msg(KERN_DEBUG, "CurrentSC!=NULL this can't be happen"); 217 SCpnt->result = DID_BAD_TARGET << 16; 218 nsp_scsi_done(SCpnt); 219 return 0; 220 } 221 222 #if 0 223 /* XXX: pcmcia-cs generates SCSI command with "scsi_info" utility. 224 This makes kernel crash when suspending... */ 225 if (data->ScsiInfo->stop != 0) { 226 nsp_msg(KERN_INFO, "suspending device. reject command."); 227 SCpnt->result = DID_BAD_TARGET << 16; 228 nsp_scsi_done(SCpnt); 229 return SCSI_MLQUEUE_HOST_BUSY; 230 } 231 #endif 232 233 show_command(SCpnt); 234 235 data->CurrentSC = SCpnt; 236 237 SCpnt->SCp.Status = CHECK_CONDITION; 238 SCpnt->SCp.Message = 0; 239 SCpnt->SCp.have_data_in = IO_UNKNOWN; 240 SCpnt->SCp.sent_command = 0; 241 SCpnt->SCp.phase = PH_UNDETERMINED; 242 SCpnt->resid = SCpnt->request_bufflen; 243 244 /* setup scratch area 245 SCp.ptr : buffer pointer 246 SCp.this_residual : buffer length 247 SCp.buffer : next buffer 248 SCp.buffers_residual : left buffers in list 249 SCp.phase : current state of the command */ 250 if (SCpnt->use_sg) { 251 SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer; 252 SCpnt->SCp.ptr = BUFFER_ADDR; 253 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 254 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1; 255 } else { 256 SCpnt->SCp.ptr = (char *) SCpnt->request_buffer; 257 SCpnt->SCp.this_residual = SCpnt->request_bufflen; 258 SCpnt->SCp.buffer = NULL; 259 SCpnt->SCp.buffers_residual = 0; 260 } 261 262 if (nsphw_start_selection(SCpnt) == FALSE) { 263 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "selection fail"); 264 SCpnt->result = DID_BUS_BUSY << 16; 265 nsp_scsi_done(SCpnt); 266 return 0; 267 } 268 269 270 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "out"); 271 #ifdef NSP_DEBUG 272 data->CmdId++; 273 #endif 274 return 0; 275 } 276 277 /* 278 * setup PIO FIFO transfer mode and enable/disable to data out 279 */ 280 static void nsp_setup_fifo(nsp_hw_data *data, int enabled) 281 { 282 unsigned int base = data->BaseAddress; 283 unsigned char transfer_mode_reg; 284 285 //nsp_dbg(NSP_DEBUG_DATA_IO, "enabled=%d", enabled); 286 287 if (enabled != FALSE) { 288 transfer_mode_reg = TRANSFER_GO | BRAIND; 289 } else { 290 transfer_mode_reg = 0; 291 } 292 293 transfer_mode_reg |= data->TransferMode; 294 295 nsp_index_write(base, TRANSFERMODE, transfer_mode_reg); 296 } 297 298 static void nsphw_init_sync(nsp_hw_data *data) 299 { 300 sync_data tmp_sync = { .SyncNegotiation = SYNC_NOT_YET, 301 .SyncPeriod = 0, 302 .SyncOffset = 0 303 }; 304 int i; 305 306 /* setup sync data */ 307 for ( i = 0; i < ARRAY_SIZE(data->Sync); i++ ) { 308 data->Sync[i] = tmp_sync; 309 } 310 } 311 312 /* 313 * Initialize Ninja hardware 314 */ 315 static int nsphw_init(nsp_hw_data *data) 316 { 317 unsigned int base = data->BaseAddress; 318 319 nsp_dbg(NSP_DEBUG_INIT, "in base=0x%x", base); 320 321 data->ScsiClockDiv = CLOCK_40M | FAST_20; 322 data->CurrentSC = NULL; 323 data->FifoCount = 0; 324 data->TransferMode = MODE_IO8; 325 326 nsphw_init_sync(data); 327 328 /* block all interrupts */ 329 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK); 330 331 /* setup SCSI interface */ 332 nsp_write(base, IFSELECT, IF_IFSEL); 333 334 nsp_index_write(base, SCSIIRQMODE, 0); 335 336 nsp_index_write(base, TRANSFERMODE, MODE_IO8); 337 nsp_index_write(base, CLOCKDIV, data->ScsiClockDiv); 338 339 nsp_index_write(base, PARITYCTRL, 0); 340 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | 341 ACK_COUNTER_CLEAR | 342 REQ_COUNTER_CLEAR | 343 HOST_COUNTER_CLEAR); 344 345 /* setup fifo asic */ 346 nsp_write(base, IFSELECT, IF_REGSEL); 347 nsp_index_write(base, TERMPWRCTRL, 0); 348 if ((nsp_index_read(base, OTHERCONTROL) & TPWR_SENSE) == 0) { 349 nsp_msg(KERN_INFO, "terminator power on"); 350 nsp_index_write(base, TERMPWRCTRL, POWER_ON); 351 } 352 353 nsp_index_write(base, TIMERCOUNT, 0); 354 nsp_index_write(base, TIMERCOUNT, 0); /* requires 2 times!! */ 355 356 nsp_index_write(base, SYNCREG, 0); 357 nsp_index_write(base, ACKWIDTH, 0); 358 359 /* enable interrupts and ack them */ 360 nsp_index_write(base, SCSIIRQMODE, SCSI_PHASE_CHANGE_EI | 361 RESELECT_EI | 362 SCSI_RESET_IRQ_EI ); 363 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR); 364 365 nsp_setup_fifo(data, FALSE); 366 367 return TRUE; 368 } 369 370 /* 371 * Start selection phase 372 */ 373 static int nsphw_start_selection(Scsi_Cmnd *SCpnt) 374 { 375 unsigned int host_id = SCpnt->device->host->this_id; 376 unsigned int base = SCpnt->device->host->io_port; 377 unsigned char target = SCpnt->device->id; 378 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 379 int time_out; 380 unsigned char phase, arbit; 381 382 //nsp_dbg(NSP_DEBUG_RESELECTION, "in"); 383 384 phase = nsp_index_read(base, SCSIBUSMON); 385 if(phase != BUSMON_BUS_FREE) { 386 //nsp_dbg(NSP_DEBUG_RESELECTION, "bus busy"); 387 return FALSE; 388 } 389 390 /* start arbitration */ 391 //nsp_dbg(NSP_DEBUG_RESELECTION, "start arbit"); 392 SCpnt->SCp.phase = PH_ARBSTART; 393 nsp_index_write(base, SETARBIT, ARBIT_GO); 394 395 time_out = 1000; 396 do { 397 /* XXX: what a stupid chip! */ 398 arbit = nsp_index_read(base, ARBITSTATUS); 399 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit=%d, wait_count=%d", arbit, wait_count); 400 udelay(1); /* hold 1.2us */ 401 } while((arbit & (ARBIT_WIN | ARBIT_FAIL)) == 0 && 402 (time_out-- != 0)); 403 404 if (!(arbit & ARBIT_WIN)) { 405 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit fail"); 406 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR); 407 return FALSE; 408 } 409 410 /* assert select line */ 411 //nsp_dbg(NSP_DEBUG_RESELECTION, "assert SEL line"); 412 SCpnt->SCp.phase = PH_SELSTART; 413 udelay(3); /* wait 2.4us */ 414 nsp_index_write(base, SCSIDATALATCH, BIT(host_id) | BIT(target)); 415 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_ATN); 416 udelay(2); /* wait >1.2us */ 417 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_DATAOUT_ENB | SCSI_ATN); 418 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR); 419 /*udelay(1);*/ /* wait >90ns */ 420 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_DATAOUT_ENB | SCSI_ATN); 421 422 /* check selection timeout */ 423 nsp_start_timer(SCpnt, 1000/51); 424 data->SelectionTimeOut = 1; 425 426 return TRUE; 427 } 428 429 struct nsp_sync_table { 430 unsigned int min_period; 431 unsigned int max_period; 432 unsigned int chip_period; 433 unsigned int ack_width; 434 }; 435 436 static struct nsp_sync_table nsp_sync_table_40M[] = { 437 {0x0c, 0x0c, 0x1, 0}, /* 20MB 50ns*/ 438 {0x19, 0x19, 0x3, 1}, /* 10MB 100ns*/ 439 {0x1a, 0x25, 0x5, 2}, /* 7.5MB 150ns*/ 440 {0x26, 0x32, 0x7, 3}, /* 5MB 200ns*/ 441 { 0, 0, 0, 0}, 442 }; 443 444 static struct nsp_sync_table nsp_sync_table_20M[] = { 445 {0x19, 0x19, 0x1, 0}, /* 10MB 100ns*/ 446 {0x1a, 0x25, 0x2, 0}, /* 7.5MB 150ns*/ 447 {0x26, 0x32, 0x3, 1}, /* 5MB 200ns*/ 448 { 0, 0, 0, 0}, 449 }; 450 451 /* 452 * setup synchronous data transfer mode 453 */ 454 static int nsp_analyze_sdtr(Scsi_Cmnd *SCpnt) 455 { 456 unsigned char target = SCpnt->device->id; 457 // unsigned char lun = SCpnt->device->lun; 458 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 459 sync_data *sync = &(data->Sync[target]); 460 struct nsp_sync_table *sync_table; 461 unsigned int period, offset; 462 int i; 463 464 465 nsp_dbg(NSP_DEBUG_SYNC, "in"); 466 467 period = sync->SyncPeriod; 468 offset = sync->SyncOffset; 469 470 nsp_dbg(NSP_DEBUG_SYNC, "period=0x%x, offset=0x%x", period, offset); 471 472 if ((data->ScsiClockDiv & (BIT(0)|BIT(1))) == CLOCK_20M) { 473 sync_table = nsp_sync_table_20M; 474 } else { 475 sync_table = nsp_sync_table_40M; 476 } 477 478 for ( i = 0; sync_table->max_period != 0; i++, sync_table++) { 479 if ( period >= sync_table->min_period && 480 period <= sync_table->max_period ) { 481 break; 482 } 483 } 484 485 if (period != 0 && sync_table->max_period == 0) { 486 /* 487 * No proper period/offset found 488 */ 489 nsp_dbg(NSP_DEBUG_SYNC, "no proper period/offset"); 490 491 sync->SyncPeriod = 0; 492 sync->SyncOffset = 0; 493 sync->SyncRegister = 0; 494 sync->AckWidth = 0; 495 496 return FALSE; 497 } 498 499 sync->SyncRegister = (sync_table->chip_period << SYNCREG_PERIOD_SHIFT) | 500 (offset & SYNCREG_OFFSET_MASK); 501 sync->AckWidth = sync_table->ack_width; 502 503 nsp_dbg(NSP_DEBUG_SYNC, "sync_reg=0x%x, ack_width=0x%x", sync->SyncRegister, sync->AckWidth); 504 505 return TRUE; 506 } 507 508 509 /* 510 * start ninja hardware timer 511 */ 512 static void nsp_start_timer(Scsi_Cmnd *SCpnt, int time) 513 { 514 unsigned int base = SCpnt->device->host->io_port; 515 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 516 517 //nsp_dbg(NSP_DEBUG_INTR, "in SCpnt=0x%p, time=%d", SCpnt, time); 518 data->TimerCount = time; 519 nsp_index_write(base, TIMERCOUNT, time); 520 } 521 522 /* 523 * wait for bus phase change 524 */ 525 static int nsp_negate_signal(Scsi_Cmnd *SCpnt, unsigned char mask, char *str) 526 { 527 unsigned int base = SCpnt->device->host->io_port; 528 unsigned char reg; 529 int time_out; 530 531 //nsp_dbg(NSP_DEBUG_INTR, "in"); 532 533 time_out = 100; 534 535 do { 536 reg = nsp_index_read(base, SCSIBUSMON); 537 if (reg == 0xff) { 538 break; 539 } 540 } while ((time_out-- != 0) && (reg & mask) != 0); 541 542 if (time_out == 0) { 543 nsp_msg(KERN_DEBUG, " %s signal off timeut", str); 544 } 545 546 return 0; 547 } 548 549 /* 550 * expect Ninja Irq 551 */ 552 static int nsp_expect_signal(Scsi_Cmnd *SCpnt, 553 unsigned char current_phase, 554 unsigned char mask) 555 { 556 unsigned int base = SCpnt->device->host->io_port; 557 int time_out; 558 unsigned char phase, i_src; 559 560 //nsp_dbg(NSP_DEBUG_INTR, "current_phase=0x%x, mask=0x%x", current_phase, mask); 561 562 time_out = 100; 563 do { 564 phase = nsp_index_read(base, SCSIBUSMON); 565 if (phase == 0xff) { 566 //nsp_dbg(NSP_DEBUG_INTR, "ret -1"); 567 return -1; 568 } 569 i_src = nsp_read(base, IRQSTATUS); 570 if (i_src & IRQSTATUS_SCSI) { 571 //nsp_dbg(NSP_DEBUG_INTR, "ret 0 found scsi signal"); 572 return 0; 573 } 574 if ((phase & mask) != 0 && (phase & BUSMON_PHASE_MASK) == current_phase) { 575 //nsp_dbg(NSP_DEBUG_INTR, "ret 1 phase=0x%x", phase); 576 return 1; 577 } 578 } while(time_out-- != 0); 579 580 //nsp_dbg(NSP_DEBUG_INTR, "timeout"); 581 return -1; 582 } 583 584 /* 585 * transfer SCSI message 586 */ 587 static int nsp_xfer(Scsi_Cmnd *SCpnt, int phase) 588 { 589 unsigned int base = SCpnt->device->host->io_port; 590 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 591 char *buf = data->MsgBuffer; 592 int len = min(MSGBUF_SIZE, data->MsgLen); 593 int ptr; 594 int ret; 595 596 //nsp_dbg(NSP_DEBUG_DATA_IO, "in"); 597 for (ptr = 0; len > 0; len--, ptr++) { 598 599 ret = nsp_expect_signal(SCpnt, phase, BUSMON_REQ); 600 if (ret <= 0) { 601 nsp_dbg(NSP_DEBUG_DATA_IO, "xfer quit"); 602 return 0; 603 } 604 605 /* if last byte, negate ATN */ 606 if (len == 1 && SCpnt->SCp.phase == PH_MSG_OUT) { 607 nsp_index_write(base, SCSIBUSCTRL, AUTODIRECTION | ACKENB); 608 } 609 610 /* read & write message */ 611 if (phase & BUSMON_IO) { 612 nsp_dbg(NSP_DEBUG_DATA_IO, "read msg"); 613 buf[ptr] = nsp_index_read(base, SCSIDATAWITHACK); 614 } else { 615 nsp_dbg(NSP_DEBUG_DATA_IO, "write msg"); 616 nsp_index_write(base, SCSIDATAWITHACK, buf[ptr]); 617 } 618 nsp_negate_signal(SCpnt, BUSMON_ACK, "xfer<ack>"); 619 620 } 621 return len; 622 } 623 624 /* 625 * get extra SCSI data from fifo 626 */ 627 static int nsp_dataphase_bypass(Scsi_Cmnd *SCpnt) 628 { 629 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 630 unsigned int count; 631 632 //nsp_dbg(NSP_DEBUG_DATA_IO, "in"); 633 634 if (SCpnt->SCp.have_data_in != IO_IN) { 635 return 0; 636 } 637 638 count = nsp_fifo_count(SCpnt); 639 if (data->FifoCount == count) { 640 //nsp_dbg(NSP_DEBUG_DATA_IO, "not use bypass quirk"); 641 return 0; 642 } 643 644 /* 645 * XXX: NSP_QUIRK 646 * data phase skip only occures in case of SCSI_LOW_READ 647 */ 648 nsp_dbg(NSP_DEBUG_DATA_IO, "use bypass quirk"); 649 SCpnt->SCp.phase = PH_DATA; 650 nsp_pio_read(SCpnt); 651 nsp_setup_fifo(data, FALSE); 652 653 return 0; 654 } 655 656 /* 657 * accept reselection 658 */ 659 static int nsp_reselected(Scsi_Cmnd *SCpnt) 660 { 661 unsigned int base = SCpnt->device->host->io_port; 662 unsigned int host_id = SCpnt->device->host->this_id; 663 //nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 664 unsigned char bus_reg; 665 unsigned char id_reg, tmp; 666 int target; 667 668 nsp_dbg(NSP_DEBUG_RESELECTION, "in"); 669 670 id_reg = nsp_index_read(base, RESELECTID); 671 tmp = id_reg & (~BIT(host_id)); 672 target = 0; 673 while(tmp != 0) { 674 if (tmp & BIT(0)) { 675 break; 676 } 677 tmp >>= 1; 678 target++; 679 } 680 681 if (SCpnt->device->id != target) { 682 nsp_msg(KERN_ERR, "XXX: reselect ID must be %d in this implementation.", target); 683 } 684 685 nsp_negate_signal(SCpnt, BUSMON_SEL, "reselect<SEL>"); 686 687 nsp_nexus(SCpnt); 688 bus_reg = nsp_index_read(base, SCSIBUSCTRL) & ~(SCSI_BSY | SCSI_ATN); 689 nsp_index_write(base, SCSIBUSCTRL, bus_reg); 690 nsp_index_write(base, SCSIBUSCTRL, bus_reg | AUTODIRECTION | ACKENB); 691 692 return TRUE; 693 } 694 695 /* 696 * count how many data transferd 697 */ 698 static int nsp_fifo_count(Scsi_Cmnd *SCpnt) 699 { 700 unsigned int base = SCpnt->device->host->io_port; 701 unsigned int count; 702 unsigned int l, m, h, dummy; 703 704 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | ACK_COUNTER); 705 706 l = nsp_index_read(base, TRANSFERCOUNT); 707 m = nsp_index_read(base, TRANSFERCOUNT); 708 h = nsp_index_read(base, TRANSFERCOUNT); 709 dummy = nsp_index_read(base, TRANSFERCOUNT); /* required this! */ 710 711 count = (h << 16) | (m << 8) | (l << 0); 712 713 //nsp_dbg(NSP_DEBUG_DATA_IO, "count=0x%x", count); 714 715 return count; 716 } 717 718 /* fifo size */ 719 #define RFIFO_CRIT 64 720 #define WFIFO_CRIT 64 721 722 /* 723 * read data in DATA IN phase 724 */ 725 static void nsp_pio_read(Scsi_Cmnd *SCpnt) 726 { 727 unsigned int base = SCpnt->device->host->io_port; 728 unsigned long mmio_base = SCpnt->device->host->base; 729 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 730 long time_out; 731 int ocount, res; 732 unsigned char stat, fifo_stat; 733 734 ocount = data->FifoCount; 735 736 nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p resid=%d ocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d", 737 SCpnt, SCpnt->resid, ocount, SCpnt->SCp.ptr, SCpnt->SCp.this_residual, SCpnt->SCp.buffer, SCpnt->SCp.buffers_residual); 738 739 time_out = 1000; 740 741 while ((time_out-- != 0) && 742 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0 ) ) { 743 744 stat = nsp_index_read(base, SCSIBUSMON); 745 stat &= BUSMON_PHASE_MASK; 746 747 748 res = nsp_fifo_count(SCpnt) - ocount; 749 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x ocount=0x%x res=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, ocount, res); 750 if (res == 0) { /* if some data avilable ? */ 751 if (stat == BUSPHASE_DATA_IN) { /* phase changed? */ 752 //nsp_dbg(NSP_DEBUG_DATA_IO, " wait for data this=%d", SCpnt->SCp.this_residual); 753 continue; 754 } else { 755 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x", stat); 756 break; 757 } 758 } 759 760 fifo_stat = nsp_read(base, FIFOSTATUS); 761 if ((fifo_stat & FIFOSTATUS_FULL_EMPTY) == 0 && 762 stat == BUSPHASE_DATA_IN) { 763 continue; 764 } 765 766 res = min(res, SCpnt->SCp.this_residual); 767 768 switch (data->TransferMode) { 769 case MODE_IO32: 770 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 771 nsp_fifo32_read(base, SCpnt->SCp.ptr, res >> 2); 772 break; 773 case MODE_IO8: 774 nsp_fifo8_read (base, SCpnt->SCp.ptr, res ); 775 break; 776 777 case MODE_MEM32: 778 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 779 nsp_mmio_fifo32_read(mmio_base, SCpnt->SCp.ptr, res >> 2); 780 break; 781 782 default: 783 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown read mode"); 784 return; 785 } 786 787 SCpnt->resid -= res; 788 SCpnt->SCp.ptr += res; 789 SCpnt->SCp.this_residual -= res; 790 ocount += res; 791 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this_residual=0x%x ocount=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, ocount); 792 793 /* go to next scatter list if available */ 794 if (SCpnt->SCp.this_residual == 0 && 795 SCpnt->SCp.buffers_residual != 0 ) { 796 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next timeout=%d", time_out); 797 SCpnt->SCp.buffers_residual--; 798 SCpnt->SCp.buffer++; 799 SCpnt->SCp.ptr = BUFFER_ADDR; 800 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 801 time_out = 1000; 802 803 //nsp_dbg(NSP_DEBUG_DATA_IO, "page: 0x%p, off: 0x%x", SCpnt->SCp.buffer->page, SCpnt->SCp.buffer->offset); 804 } 805 } 806 807 data->FifoCount = ocount; 808 809 if (time_out == 0) { 810 nsp_msg(KERN_DEBUG, "pio read timeout resid=%d this_residual=%d buffers_residual=%d", 811 SCpnt->resid, SCpnt->SCp.this_residual, SCpnt->SCp.buffers_residual); 812 } 813 nsp_dbg(NSP_DEBUG_DATA_IO, "read ocount=0x%x", ocount); 814 nsp_dbg(NSP_DEBUG_DATA_IO, "r cmd=%d resid=0x%x\n", data->CmdId, SCpnt->resid); 815 } 816 817 /* 818 * write data in DATA OUT phase 819 */ 820 static void nsp_pio_write(Scsi_Cmnd *SCpnt) 821 { 822 unsigned int base = SCpnt->device->host->io_port; 823 unsigned long mmio_base = SCpnt->device->host->base; 824 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 825 int time_out; 826 int ocount, res; 827 unsigned char stat; 828 829 ocount = data->FifoCount; 830 831 nsp_dbg(NSP_DEBUG_DATA_IO, "in fifocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d resid=0x%x", 832 data->FifoCount, SCpnt->SCp.ptr, SCpnt->SCp.this_residual, SCpnt->SCp.buffer, SCpnt->SCp.buffers_residual, SCpnt->resid); 833 834 time_out = 1000; 835 836 while ((time_out-- != 0) && 837 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0)) { 838 stat = nsp_index_read(base, SCSIBUSMON); 839 stat &= BUSMON_PHASE_MASK; 840 841 if (stat != BUSPHASE_DATA_OUT) { 842 res = ocount - nsp_fifo_count(SCpnt); 843 844 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x, res=%d\n", stat, res); 845 /* Put back pointer */ 846 SCpnt->resid += res; 847 SCpnt->SCp.ptr -= res; 848 SCpnt->SCp.this_residual += res; 849 ocount -= res; 850 851 break; 852 } 853 854 res = ocount - nsp_fifo_count(SCpnt); 855 if (res > 0) { /* write all data? */ 856 nsp_dbg(NSP_DEBUG_DATA_IO, "wait for all data out. ocount=0x%x res=%d", ocount, res); 857 continue; 858 } 859 860 res = min(SCpnt->SCp.this_residual, WFIFO_CRIT); 861 862 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x res=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, res); 863 switch (data->TransferMode) { 864 case MODE_IO32: 865 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 866 nsp_fifo32_write(base, SCpnt->SCp.ptr, res >> 2); 867 break; 868 case MODE_IO8: 869 nsp_fifo8_write (base, SCpnt->SCp.ptr, res ); 870 break; 871 872 case MODE_MEM32: 873 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 874 nsp_mmio_fifo32_write(mmio_base, SCpnt->SCp.ptr, res >> 2); 875 break; 876 877 default: 878 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown write mode"); 879 break; 880 } 881 882 SCpnt->resid -= res; 883 SCpnt->SCp.ptr += res; 884 SCpnt->SCp.this_residual -= res; 885 ocount += res; 886 887 /* go to next scatter list if available */ 888 if (SCpnt->SCp.this_residual == 0 && 889 SCpnt->SCp.buffers_residual != 0 ) { 890 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next"); 891 SCpnt->SCp.buffers_residual--; 892 SCpnt->SCp.buffer++; 893 SCpnt->SCp.ptr = BUFFER_ADDR; 894 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 895 time_out = 1000; 896 } 897 } 898 899 data->FifoCount = ocount; 900 901 if (time_out == 0) { 902 nsp_msg(KERN_DEBUG, "pio write timeout resid=0x%x", SCpnt->resid); 903 } 904 nsp_dbg(NSP_DEBUG_DATA_IO, "write ocount=0x%x", ocount); 905 nsp_dbg(NSP_DEBUG_DATA_IO, "w cmd=%d resid=0x%x\n", data->CmdId, SCpnt->resid); 906 } 907 #undef RFIFO_CRIT 908 #undef WFIFO_CRIT 909 910 /* 911 * setup synchronous/asynchronous data transfer mode 912 */ 913 static int nsp_nexus(Scsi_Cmnd *SCpnt) 914 { 915 unsigned int base = SCpnt->device->host->io_port; 916 unsigned char target = SCpnt->device->id; 917 // unsigned char lun = SCpnt->device->lun; 918 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 919 sync_data *sync = &(data->Sync[target]); 920 921 //nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p", SCpnt); 922 923 /* setup synch transfer registers */ 924 nsp_index_write(base, SYNCREG, sync->SyncRegister); 925 nsp_index_write(base, ACKWIDTH, sync->AckWidth); 926 927 if (SCpnt->use_sg == 0 || 928 SCpnt->resid % 4 != 0 || 929 SCpnt->resid <= PAGE_SIZE ) { 930 data->TransferMode = MODE_IO8; 931 } else if (nsp_burst_mode == BURST_MEM32) { 932 data->TransferMode = MODE_MEM32; 933 } else if (nsp_burst_mode == BURST_IO32) { 934 data->TransferMode = MODE_IO32; 935 } else { 936 data->TransferMode = MODE_IO8; 937 } 938 939 /* setup pdma fifo */ 940 nsp_setup_fifo(data, TRUE); 941 942 /* clear ack counter */ 943 data->FifoCount = 0; 944 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | 945 ACK_COUNTER_CLEAR | 946 REQ_COUNTER_CLEAR | 947 HOST_COUNTER_CLEAR); 948 949 return 0; 950 } 951 952 #include "nsp_message.c" 953 /* 954 * interrupt handler 955 */ 956 static irqreturn_t nspintr(int irq, void *dev_id, struct pt_regs *regs) 957 { 958 unsigned int base; 959 unsigned char irq_status, irq_phase, phase; 960 Scsi_Cmnd *tmpSC; 961 unsigned char target, lun; 962 unsigned int *sync_neg; 963 int i, tmp; 964 nsp_hw_data *data; 965 966 967 //nsp_dbg(NSP_DEBUG_INTR, "dev_id=0x%p", dev_id); 968 //nsp_dbg(NSP_DEBUG_INTR, "host=0x%p", ((scsi_info_t *)dev_id)->host); 969 970 if ( dev_id != NULL && 971 ((scsi_info_t *)dev_id)->host != NULL ) { 972 scsi_info_t *info = (scsi_info_t *)dev_id; 973 974 data = (nsp_hw_data *)info->host->hostdata; 975 } else { 976 nsp_dbg(NSP_DEBUG_INTR, "host data wrong"); 977 return IRQ_NONE; 978 } 979 980 //nsp_dbg(NSP_DEBUG_INTR, "&nsp_data_base=0x%p, dev_id=0x%p", &nsp_data_base, dev_id); 981 982 base = data->BaseAddress; 983 //nsp_dbg(NSP_DEBUG_INTR, "base=0x%x", base); 984 985 /* 986 * interrupt check 987 */ 988 nsp_write(base, IRQCONTROL, IRQCONTROL_IRQDISABLE); 989 irq_status = nsp_read(base, IRQSTATUS); 990 //nsp_dbg(NSP_DEBUG_INTR, "irq_status=0x%x", irq_status); 991 if ((irq_status == 0xff) || ((irq_status & IRQSTATUS_MASK) == 0)) { 992 nsp_write(base, IRQCONTROL, 0); 993 //nsp_dbg(NSP_DEBUG_INTR, "no irq/shared irq"); 994 return IRQ_NONE; 995 } 996 997 /* XXX: IMPORTANT 998 * Do not read an irq_phase register if no scsi phase interrupt. 999 * Unless, you should lose a scsi phase interrupt. 1000 */ 1001 phase = nsp_index_read(base, SCSIBUSMON); 1002 if((irq_status & IRQSTATUS_SCSI) != 0) { 1003 irq_phase = nsp_index_read(base, IRQPHASESENCE); 1004 } else { 1005 irq_phase = 0; 1006 } 1007 1008 //nsp_dbg(NSP_DEBUG_INTR, "irq_phase=0x%x", irq_phase); 1009 1010 /* 1011 * timer interrupt handler (scsi vs timer interrupts) 1012 */ 1013 //nsp_dbg(NSP_DEBUG_INTR, "timercount=%d", data->TimerCount); 1014 if (data->TimerCount != 0) { 1015 //nsp_dbg(NSP_DEBUG_INTR, "stop timer"); 1016 nsp_index_write(base, TIMERCOUNT, 0); 1017 nsp_index_write(base, TIMERCOUNT, 0); 1018 data->TimerCount = 0; 1019 } 1020 1021 if ((irq_status & IRQSTATUS_MASK) == IRQSTATUS_TIMER && 1022 data->SelectionTimeOut == 0) { 1023 //nsp_dbg(NSP_DEBUG_INTR, "timer start"); 1024 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR); 1025 return IRQ_HANDLED; 1026 } 1027 1028 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR | IRQCONTROL_FIFO_CLEAR); 1029 1030 if ((irq_status & IRQSTATUS_SCSI) && 1031 (irq_phase & SCSI_RESET_IRQ)) { 1032 nsp_msg(KERN_ERR, "bus reset (power off?)"); 1033 1034 nsphw_init(data); 1035 nsp_bus_reset(data); 1036 1037 if(data->CurrentSC != NULL) { 1038 tmpSC = data->CurrentSC; 1039 tmpSC->result = (DID_RESET << 16) | 1040 ((tmpSC->SCp.Message & 0xff) << 8) | 1041 ((tmpSC->SCp.Status & 0xff) << 0); 1042 nsp_scsi_done(tmpSC); 1043 } 1044 return IRQ_HANDLED; 1045 } 1046 1047 if (data->CurrentSC == NULL) { 1048 nsp_msg(KERN_ERR, "CurrentSC==NULL irq_status=0x%x phase=0x%x irq_phase=0x%x this can't be happen. reset everything", irq_status, phase, irq_phase); 1049 nsphw_init(data); 1050 nsp_bus_reset(data); 1051 return IRQ_HANDLED; 1052 } 1053 1054 tmpSC = data->CurrentSC; 1055 target = tmpSC->device->id; 1056 lun = tmpSC->device->lun; 1057 sync_neg = &(data->Sync[target].SyncNegotiation); 1058 1059 /* 1060 * parse hardware SCSI irq reasons register 1061 */ 1062 if (irq_status & IRQSTATUS_SCSI) { 1063 if (irq_phase & RESELECT_IRQ) { 1064 nsp_dbg(NSP_DEBUG_INTR, "reselect"); 1065 nsp_write(base, IRQCONTROL, IRQCONTROL_RESELECT_CLEAR); 1066 if (nsp_reselected(tmpSC) != FALSE) { 1067 return IRQ_HANDLED; 1068 } 1069 } 1070 1071 if ((irq_phase & (PHASE_CHANGE_IRQ | LATCHED_BUS_FREE)) == 0) { 1072 return IRQ_HANDLED; 1073 } 1074 } 1075 1076 //show_phase(tmpSC); 1077 1078 switch(tmpSC->SCp.phase) { 1079 case PH_SELSTART: 1080 // *sync_neg = SYNC_NOT_YET; 1081 if ((phase & BUSMON_BSY) == 0) { 1082 //nsp_dbg(NSP_DEBUG_INTR, "selection count=%d", data->SelectionTimeOut); 1083 if (data->SelectionTimeOut >= NSP_SELTIMEOUT) { 1084 nsp_dbg(NSP_DEBUG_INTR, "selection time out"); 1085 data->SelectionTimeOut = 0; 1086 nsp_index_write(base, SCSIBUSCTRL, 0); 1087 1088 tmpSC->result = DID_TIME_OUT << 16; 1089 nsp_scsi_done(tmpSC); 1090 1091 return IRQ_HANDLED; 1092 } 1093 data->SelectionTimeOut += 1; 1094 nsp_start_timer(tmpSC, 1000/51); 1095 return IRQ_HANDLED; 1096 } 1097 1098 /* attention assert */ 1099 //nsp_dbg(NSP_DEBUG_INTR, "attention assert"); 1100 data->SelectionTimeOut = 0; 1101 tmpSC->SCp.phase = PH_SELECTED; 1102 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN); 1103 udelay(1); 1104 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN | AUTODIRECTION | ACKENB); 1105 return IRQ_HANDLED; 1106 1107 break; 1108 1109 case PH_RESELECT: 1110 //nsp_dbg(NSP_DEBUG_INTR, "phase reselect"); 1111 // *sync_neg = SYNC_NOT_YET; 1112 if ((phase & BUSMON_PHASE_MASK) != BUSPHASE_MESSAGE_IN) { 1113 1114 tmpSC->result = DID_ABORT << 16; 1115 nsp_scsi_done(tmpSC); 1116 return IRQ_HANDLED; 1117 } 1118 /* fall thru */ 1119 default: 1120 if ((irq_status & (IRQSTATUS_SCSI | IRQSTATUS_FIFO)) == 0) { 1121 return IRQ_HANDLED; 1122 } 1123 break; 1124 } 1125 1126 /* 1127 * SCSI sequencer 1128 */ 1129 //nsp_dbg(NSP_DEBUG_INTR, "start scsi seq"); 1130 1131 /* normal disconnect */ 1132 if (((tmpSC->SCp.phase == PH_MSG_IN) || (tmpSC->SCp.phase == PH_MSG_OUT)) && 1133 (irq_phase & LATCHED_BUS_FREE) != 0 ) { 1134 nsp_dbg(NSP_DEBUG_INTR, "normal disconnect irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase); 1135 1136 //*sync_neg = SYNC_NOT_YET; 1137 1138 if ((tmpSC->SCp.Message == MSG_COMMAND_COMPLETE)) { /* all command complete and return status */ 1139 tmpSC->result = (DID_OK << 16) | 1140 ((tmpSC->SCp.Message & 0xff) << 8) | 1141 ((tmpSC->SCp.Status & 0xff) << 0); 1142 nsp_dbg(NSP_DEBUG_INTR, "command complete result=0x%x", tmpSC->result); 1143 nsp_scsi_done(tmpSC); 1144 1145 return IRQ_HANDLED; 1146 } 1147 1148 return IRQ_HANDLED; 1149 } 1150 1151 1152 /* check unexpected bus free state */ 1153 if (phase == 0) { 1154 nsp_msg(KERN_DEBUG, "unexpected bus free. irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase); 1155 1156 *sync_neg = SYNC_NG; 1157 tmpSC->result = DID_ERROR << 16; 1158 nsp_scsi_done(tmpSC); 1159 return IRQ_HANDLED; 1160 } 1161 1162 switch (phase & BUSMON_PHASE_MASK) { 1163 case BUSPHASE_COMMAND: 1164 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_COMMAND"); 1165 if ((phase & BUSMON_REQ) == 0) { 1166 nsp_dbg(NSP_DEBUG_INTR, "REQ == 0"); 1167 return IRQ_HANDLED; 1168 } 1169 1170 tmpSC->SCp.phase = PH_COMMAND; 1171 1172 nsp_nexus(tmpSC); 1173 1174 /* write scsi command */ 1175 nsp_dbg(NSP_DEBUG_INTR, "cmd_len=%d", tmpSC->cmd_len); 1176 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER); 1177 for (i = 0; i < tmpSC->cmd_len; i++) { 1178 nsp_index_write(base, COMMANDDATA, tmpSC->cmnd[i]); 1179 } 1180 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER | AUTO_COMMAND_GO); 1181 break; 1182 1183 case BUSPHASE_DATA_OUT: 1184 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_OUT"); 1185 1186 tmpSC->SCp.phase = PH_DATA; 1187 tmpSC->SCp.have_data_in = IO_OUT; 1188 1189 nsp_pio_write(tmpSC); 1190 1191 break; 1192 1193 case BUSPHASE_DATA_IN: 1194 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_IN"); 1195 1196 tmpSC->SCp.phase = PH_DATA; 1197 tmpSC->SCp.have_data_in = IO_IN; 1198 1199 nsp_pio_read(tmpSC); 1200 1201 break; 1202 1203 case BUSPHASE_STATUS: 1204 nsp_dataphase_bypass(tmpSC); 1205 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_STATUS"); 1206 1207 tmpSC->SCp.phase = PH_STATUS; 1208 1209 tmpSC->SCp.Status = nsp_index_read(base, SCSIDATAWITHACK); 1210 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x status=0x%x", tmpSC->SCp.Message, tmpSC->SCp.Status); 1211 1212 break; 1213 1214 case BUSPHASE_MESSAGE_OUT: 1215 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_OUT"); 1216 if ((phase & BUSMON_REQ) == 0) { 1217 goto timer_out; 1218 } 1219 1220 tmpSC->SCp.phase = PH_MSG_OUT; 1221 1222 //*sync_neg = SYNC_NOT_YET; 1223 1224 data->MsgLen = i = 0; 1225 data->MsgBuffer[i] = IDENTIFY(TRUE, lun); i++; 1226 1227 if (*sync_neg == SYNC_NOT_YET) { 1228 data->Sync[target].SyncPeriod = 0; 1229 data->Sync[target].SyncOffset = 0; 1230 1231 /**/ 1232 data->MsgBuffer[i] = MSG_EXTENDED; i++; 1233 data->MsgBuffer[i] = 3; i++; 1234 data->MsgBuffer[i] = MSG_EXT_SDTR; i++; 1235 data->MsgBuffer[i] = 0x0c; i++; 1236 data->MsgBuffer[i] = 15; i++; 1237 /**/ 1238 } 1239 data->MsgLen = i; 1240 1241 nsp_analyze_sdtr(tmpSC); 1242 show_message(data); 1243 nsp_message_out(tmpSC); 1244 break; 1245 1246 case BUSPHASE_MESSAGE_IN: 1247 nsp_dataphase_bypass(tmpSC); 1248 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_IN"); 1249 if ((phase & BUSMON_REQ) == 0) { 1250 goto timer_out; 1251 } 1252 1253 tmpSC->SCp.phase = PH_MSG_IN; 1254 nsp_message_in(tmpSC); 1255 1256 /**/ 1257 if (*sync_neg == SYNC_NOT_YET) { 1258 //nsp_dbg(NSP_DEBUG_INTR, "sync target=%d,lun=%d",target,lun); 1259 1260 if (data->MsgLen >= 5 && 1261 data->MsgBuffer[0] == MSG_EXTENDED && 1262 data->MsgBuffer[1] == 3 && 1263 data->MsgBuffer[2] == MSG_EXT_SDTR ) { 1264 data->Sync[target].SyncPeriod = data->MsgBuffer[3]; 1265 data->Sync[target].SyncOffset = data->MsgBuffer[4]; 1266 //nsp_dbg(NSP_DEBUG_INTR, "sync ok, %d %d", data->MsgBuffer[3], data->MsgBuffer[4]); 1267 *sync_neg = SYNC_OK; 1268 } else { 1269 data->Sync[target].SyncPeriod = 0; 1270 data->Sync[target].SyncOffset = 0; 1271 *sync_neg = SYNC_NG; 1272 } 1273 nsp_analyze_sdtr(tmpSC); 1274 } 1275 /**/ 1276 1277 /* search last messeage byte */ 1278 tmp = -1; 1279 for (i = 0; i < data->MsgLen; i++) { 1280 tmp = data->MsgBuffer[i]; 1281 if (data->MsgBuffer[i] == MSG_EXTENDED) { 1282 i += (1 + data->MsgBuffer[i+1]); 1283 } 1284 } 1285 tmpSC->SCp.Message = tmp; 1286 1287 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x len=%d", tmpSC->SCp.Message, data->MsgLen); 1288 show_message(data); 1289 1290 break; 1291 1292 case BUSPHASE_SELECT: 1293 default: 1294 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE other"); 1295 1296 break; 1297 } 1298 1299 //nsp_dbg(NSP_DEBUG_INTR, "out"); 1300 return IRQ_HANDLED; 1301 1302 timer_out: 1303 nsp_start_timer(tmpSC, 1000/102); 1304 return IRQ_HANDLED; 1305 } 1306 1307 #ifdef NSP_DEBUG 1308 #include "nsp_debug.c" 1309 #endif /* NSP_DEBUG */ 1310 1311 /*----------------------------------------------------------------*/ 1312 /* look for ninja3 card and init if found */ 1313 /*----------------------------------------------------------------*/ 1314 static struct Scsi_Host *nsp_detect(Scsi_Host_Template *sht) 1315 { 1316 struct Scsi_Host *host; /* registered host structure */ 1317 nsp_hw_data *data_b = &nsp_data_base, *data; 1318 1319 nsp_dbg(NSP_DEBUG_INIT, "this_id=%d", sht->this_id); 1320 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73)) 1321 host = scsi_host_alloc(&nsp_driver_template, sizeof(nsp_hw_data)); 1322 #else 1323 host = scsi_register(sht, sizeof(nsp_hw_data)); 1324 #endif 1325 if (host == NULL) { 1326 nsp_dbg(NSP_DEBUG_INIT, "host failed"); 1327 return NULL; 1328 } 1329 1330 memcpy(host->hostdata, data_b, sizeof(nsp_hw_data)); 1331 data = (nsp_hw_data *)host->hostdata; 1332 data->ScsiInfo->host = host; 1333 #ifdef NSP_DEBUG 1334 data->CmdId = 0; 1335 #endif 1336 1337 nsp_dbg(NSP_DEBUG_INIT, "irq=%d,%d", data_b->IrqNumber, ((nsp_hw_data *)host->hostdata)->IrqNumber); 1338 1339 host->unique_id = data->BaseAddress; 1340 host->io_port = data->BaseAddress; 1341 host->n_io_port = data->NumAddress; 1342 host->irq = data->IrqNumber; 1343 host->base = data->MmioAddress; 1344 1345 spin_lock_init(&(data->Lock)); 1346 1347 snprintf(data->nspinfo, 1348 sizeof(data->nspinfo), 1349 "NinjaSCSI-3/32Bi Driver $Revision: 1.23 $ IO:0x%04lx-0x%04lx MMIO(virt addr):0x%04lx IRQ:%02d", 1350 host->io_port, host->io_port + host->n_io_port - 1, 1351 host->base, 1352 host->irq); 1353 sht->name = data->nspinfo; 1354 1355 nsp_dbg(NSP_DEBUG_INIT, "end"); 1356 1357 1358 return host; /* detect done. */ 1359 } 1360 1361 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) 1362 static int nsp_detect_old(Scsi_Host_Template *sht) 1363 { 1364 if (nsp_detect(sht) == NULL) { 1365 return 0; 1366 } else { 1367 //MOD_INC_USE_COUNT; 1368 return 1; 1369 } 1370 } 1371 1372 1373 static int nsp_release_old(struct Scsi_Host *shpnt) 1374 { 1375 //nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata; 1376 1377 /* PCMCIA Card Service dose same things below. */ 1378 /* So we do nothing. */ 1379 //if (shpnt->irq) { 1380 // free_irq(shpnt->irq, data->ScsiInfo); 1381 //} 1382 //if (shpnt->io_port) { 1383 // release_region(shpnt->io_port, shpnt->n_io_port); 1384 //} 1385 1386 //MOD_DEC_USE_COUNT; 1387 1388 return 0; 1389 } 1390 #endif 1391 1392 /*----------------------------------------------------------------*/ 1393 /* return info string */ 1394 /*----------------------------------------------------------------*/ 1395 static const char *nsp_info(struct Scsi_Host *shpnt) 1396 { 1397 nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata; 1398 1399 return data->nspinfo; 1400 } 1401 1402 #undef SPRINTF 1403 #define SPRINTF(args...) \ 1404 do { \ 1405 if(length > (pos - buffer)) { \ 1406 pos += snprintf(pos, length - (pos - buffer) + 1, ## args); \ 1407 nsp_dbg(NSP_DEBUG_PROC, "buffer=0x%p pos=0x%p length=%d %d\n", buffer, pos, length, length - (pos - buffer));\ 1408 } \ 1409 } while(0) 1410 static int 1411 nsp_proc_info( 1412 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73)) 1413 struct Scsi_Host *host, 1414 #endif 1415 char *buffer, 1416 char **start, 1417 off_t offset, 1418 int length, 1419 #if !(LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73)) 1420 int hostno, 1421 #endif 1422 int inout) 1423 { 1424 int id; 1425 char *pos = buffer; 1426 int thislength; 1427 int speed; 1428 unsigned long flags; 1429 nsp_hw_data *data; 1430 #if !(LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73)) 1431 struct Scsi_Host *host; 1432 #else 1433 int hostno; 1434 #endif 1435 if (inout) { 1436 return -EINVAL; 1437 } 1438 1439 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73)) 1440 hostno = host->host_no; 1441 #else 1442 /* search this HBA host */ 1443 host = scsi_host_hn_get(hostno); 1444 if (host == NULL) { 1445 return -ESRCH; 1446 } 1447 #endif 1448 data = (nsp_hw_data *)host->hostdata; 1449 1450 1451 SPRINTF("NinjaSCSI status\n\n"); 1452 SPRINTF("Driver version: $Revision: 1.23 $\n"); 1453 SPRINTF("SCSI host No.: %d\n", hostno); 1454 SPRINTF("IRQ: %d\n", host->irq); 1455 SPRINTF("IO: 0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1); 1456 SPRINTF("MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1); 1457 SPRINTF("sg_tablesize: %d\n", host->sg_tablesize); 1458 1459 SPRINTF("burst transfer mode: "); 1460 switch (nsp_burst_mode) { 1461 case BURST_IO8: 1462 SPRINTF("io8"); 1463 break; 1464 case BURST_IO32: 1465 SPRINTF("io32"); 1466 break; 1467 case BURST_MEM32: 1468 SPRINTF("mem32"); 1469 break; 1470 default: 1471 SPRINTF("???"); 1472 break; 1473 } 1474 SPRINTF("\n"); 1475 1476 1477 spin_lock_irqsave(&(data->Lock), flags); 1478 SPRINTF("CurrentSC: 0x%p\n\n", data->CurrentSC); 1479 spin_unlock_irqrestore(&(data->Lock), flags); 1480 1481 SPRINTF("SDTR status\n"); 1482 for(id = 0; id < ARRAY_SIZE(data->Sync); id++) { 1483 1484 SPRINTF("id %d: ", id); 1485 1486 if (id == host->this_id) { 1487 SPRINTF("----- NinjaSCSI-3 host adapter\n"); 1488 continue; 1489 } 1490 1491 switch(data->Sync[id].SyncNegotiation) { 1492 case SYNC_OK: 1493 SPRINTF(" sync"); 1494 break; 1495 case SYNC_NG: 1496 SPRINTF("async"); 1497 break; 1498 case SYNC_NOT_YET: 1499 SPRINTF(" none"); 1500 break; 1501 default: 1502 SPRINTF("?????"); 1503 break; 1504 } 1505 1506 if (data->Sync[id].SyncPeriod != 0) { 1507 speed = 1000000 / (data->Sync[id].SyncPeriod * 4); 1508 1509 SPRINTF(" transfer %d.%dMB/s, offset %d", 1510 speed / 1000, 1511 speed % 1000, 1512 data->Sync[id].SyncOffset 1513 ); 1514 } 1515 SPRINTF("\n"); 1516 } 1517 1518 thislength = pos - (buffer + offset); 1519 1520 if(thislength < 0) { 1521 *start = NULL; 1522 return 0; 1523 } 1524 1525 1526 thislength = min(thislength, length); 1527 *start = buffer + offset; 1528 1529 return thislength; 1530 } 1531 #undef SPRINTF 1532 1533 /*---------------------------------------------------------------*/ 1534 /* error handler */ 1535 /*---------------------------------------------------------------*/ 1536 1537 /* 1538 static int nsp_eh_abort(Scsi_Cmnd *SCpnt) 1539 { 1540 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt); 1541 1542 return nsp_eh_bus_reset(SCpnt); 1543 }*/ 1544 1545 static int nsp_bus_reset(nsp_hw_data *data) 1546 { 1547 unsigned int base = data->BaseAddress; 1548 int i; 1549 1550 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK); 1551 1552 nsp_index_write(base, SCSIBUSCTRL, SCSI_RST); 1553 mdelay(100); /* 100ms */ 1554 nsp_index_write(base, SCSIBUSCTRL, 0); 1555 for(i = 0; i < 5; i++) { 1556 nsp_index_read(base, IRQPHASESENCE); /* dummy read */ 1557 } 1558 1559 nsphw_init_sync(data); 1560 1561 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR); 1562 1563 return SUCCESS; 1564 } 1565 1566 static int nsp_eh_bus_reset(Scsi_Cmnd *SCpnt) 1567 { 1568 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 1569 1570 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt); 1571 1572 return nsp_bus_reset(data); 1573 } 1574 1575 static int nsp_eh_host_reset(Scsi_Cmnd *SCpnt) 1576 { 1577 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 1578 1579 nsp_dbg(NSP_DEBUG_BUSRESET, "in"); 1580 1581 nsphw_init(data); 1582 1583 return SUCCESS; 1584 } 1585 1586 1587 /********************************************************************** 1588 PCMCIA functions 1589 **********************************************************************/ 1590 1591 /*====================================================================== 1592 nsp_cs_attach() creates an "instance" of the driver, allocating 1593 local data structures for one device. The device is registered 1594 with Card Services. 1595 1596 The dev_link structure is initialized, but we don't actually 1597 configure the card at this point -- we wait until we receive a 1598 card insertion event. 1599 ======================================================================*/ 1600 static dev_link_t *nsp_cs_attach(void) 1601 { 1602 scsi_info_t *info; 1603 client_reg_t client_reg; 1604 dev_link_t *link; 1605 int ret; 1606 nsp_hw_data *data = &nsp_data_base; 1607 1608 nsp_dbg(NSP_DEBUG_INIT, "in"); 1609 1610 /* Create new SCSI device */ 1611 info = kmalloc(sizeof(*info), GFP_KERNEL); 1612 if (info == NULL) { return NULL; } 1613 memset(info, 0, sizeof(*info)); 1614 link = &info->link; 1615 link->priv = info; 1616 data->ScsiInfo = info; 1617 1618 nsp_dbg(NSP_DEBUG_INIT, "info=0x%p", info); 1619 1620 /* The io structure describes IO port mapping */ 1621 link->io.NumPorts1 = 0x10; 1622 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; 1623 link->io.IOAddrLines = 10; /* not used */ 1624 1625 /* Interrupt setup */ 1626 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; 1627 link->irq.IRQInfo1 = IRQ_LEVEL_ID; 1628 1629 /* Interrupt handler */ 1630 link->irq.Handler = &nspintr; 1631 link->irq.Instance = info; 1632 link->irq.Attributes |= (SA_SHIRQ | SA_SAMPLE_RANDOM); 1633 1634 /* General socket configuration */ 1635 link->conf.Attributes = CONF_ENABLE_IRQ; 1636 link->conf.Vcc = 50; 1637 link->conf.IntType = INT_MEMORY_AND_IO; 1638 link->conf.Present = PRESENT_OPTION; 1639 1640 1641 /* Register with Card Services */ 1642 link->next = dev_list; 1643 dev_list = link; 1644 client_reg.dev_info = &dev_info; 1645 client_reg.EventMask = 1646 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | 1647 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | 1648 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME ; 1649 client_reg.event_handler = &nsp_cs_event; 1650 client_reg.Version = 0x0210; 1651 client_reg.event_callback_args.client_data = link; 1652 ret = pcmcia_register_client(&link->handle, &client_reg); 1653 if (ret != CS_SUCCESS) { 1654 cs_error(link->handle, RegisterClient, ret); 1655 nsp_cs_detach(link); 1656 return NULL; 1657 } 1658 1659 1660 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link); 1661 return link; 1662 } /* nsp_cs_attach */ 1663 1664 1665 /*====================================================================== 1666 This deletes a driver "instance". The device is de-registered 1667 with Card Services. If it has been released, all local data 1668 structures are freed. Otherwise, the structures will be freed 1669 when the device is released. 1670 ======================================================================*/ 1671 static void nsp_cs_detach(dev_link_t *link) 1672 { 1673 dev_link_t **linkp; 1674 1675 nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link); 1676 1677 /* Locate device structure */ 1678 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) { 1679 if (*linkp == link) { 1680 break; 1681 } 1682 } 1683 if (*linkp == NULL) { 1684 return; 1685 } 1686 1687 if (link->state & DEV_CONFIG) 1688 nsp_cs_release(link); 1689 1690 /* Break the link with Card Services */ 1691 if (link->handle) { 1692 pcmcia_deregister_client(link->handle); 1693 } 1694 1695 /* Unlink device structure, free bits */ 1696 *linkp = link->next; 1697 kfree(link->priv); 1698 link->priv = NULL; 1699 1700 } /* nsp_cs_detach */ 1701 1702 1703 /*====================================================================== 1704 nsp_cs_config() is scheduled to run after a CARD_INSERTION event 1705 is received, to configure the PCMCIA socket, and to make the 1706 ethernet device available to the system. 1707 ======================================================================*/ 1708 #define CS_CHECK(fn, ret) \ 1709 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) 1710 /*====================================================================*/ 1711 static void nsp_cs_config(dev_link_t *link) 1712 { 1713 client_handle_t handle = link->handle; 1714 scsi_info_t *info = link->priv; 1715 tuple_t tuple; 1716 cisparse_t parse; 1717 int last_ret, last_fn; 1718 unsigned char tuple_data[64]; 1719 config_info_t conf; 1720 win_req_t req; 1721 memreq_t map; 1722 cistpl_cftable_entry_t dflt = { 0 }; 1723 struct Scsi_Host *host; 1724 nsp_hw_data *data = &nsp_data_base; 1725 #if !(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,74)) 1726 Scsi_Device *dev; 1727 dev_node_t **tail, *node; 1728 #endif 1729 1730 nsp_dbg(NSP_DEBUG_INIT, "in"); 1731 1732 tuple.DesiredTuple = CISTPL_CONFIG; 1733 tuple.Attributes = 0; 1734 tuple.TupleData = tuple_data; 1735 tuple.TupleDataMax = sizeof(tuple_data); 1736 tuple.TupleOffset = 0; 1737 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); 1738 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); 1739 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse)); 1740 link->conf.ConfigBase = parse.config.base; 1741 link->conf.Present = parse.config.rmask[0]; 1742 1743 /* Configure card */ 1744 link->state |= DEV_CONFIG; 1745 1746 /* Look up the current Vcc */ 1747 CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf)); 1748 link->conf.Vcc = conf.Vcc; 1749 1750 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 1751 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); 1752 while (1) { 1753 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); 1754 1755 if (pcmcia_get_tuple_data(handle, &tuple) != 0 || 1756 pcmcia_parse_tuple(handle, &tuple, &parse) != 0) 1757 goto next_entry; 1758 1759 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) { dflt = *cfg; } 1760 if (cfg->index == 0) { goto next_entry; } 1761 link->conf.ConfigIndex = cfg->index; 1762 1763 /* Does this card need audio output? */ 1764 if (cfg->flags & CISTPL_CFTABLE_AUDIO) { 1765 link->conf.Attributes |= CONF_ENABLE_SPKR; 1766 link->conf.Status = CCSR_AUDIO_ENA; 1767 } 1768 1769 /* Use power settings for Vcc and Vpp if present */ 1770 /* Note that the CIS values need to be rescaled */ 1771 if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) { 1772 if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000) { 1773 goto next_entry; 1774 } 1775 } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) { 1776 if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM]/10000) { 1777 goto next_entry; 1778 } 1779 } 1780 1781 if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) { 1782 link->conf.Vpp1 = link->conf.Vpp2 = 1783 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000; 1784 } else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM)) { 1785 link->conf.Vpp1 = link->conf.Vpp2 = 1786 dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000; 1787 } 1788 1789 /* Do we need to allocate an interrupt? */ 1790 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) { 1791 link->conf.Attributes |= CONF_ENABLE_IRQ; 1792 } 1793 1794 /* IO window settings */ 1795 link->io.NumPorts1 = link->io.NumPorts2 = 0; 1796 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { 1797 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io; 1798 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; 1799 if (!(io->flags & CISTPL_IO_8BIT)) 1800 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16; 1801 if (!(io->flags & CISTPL_IO_16BIT)) 1802 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 1803 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK; 1804 link->io.BasePort1 = io->win[0].base; 1805 link->io.NumPorts1 = io->win[0].len; 1806 if (io->nwin > 1) { 1807 link->io.Attributes2 = link->io.Attributes1; 1808 link->io.BasePort2 = io->win[1].base; 1809 link->io.NumPorts2 = io->win[1].len; 1810 } 1811 /* This reserves IO space but doesn't actually enable it */ 1812 if (pcmcia_request_io(link->handle, &link->io) != 0) 1813 goto next_entry; 1814 } 1815 1816 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) { 1817 cistpl_mem_t *mem = 1818 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem; 1819 req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM; 1820 req.Attributes |= WIN_ENABLE; 1821 req.Base = mem->win[0].host_addr; 1822 req.Size = mem->win[0].len; 1823 if (req.Size < 0x1000) { 1824 req.Size = 0x1000; 1825 } 1826 req.AccessSpeed = 0; 1827 if (pcmcia_request_window(&link->handle, &req, &link->win) != 0) 1828 goto next_entry; 1829 map.Page = 0; map.CardOffset = mem->win[0].card_addr; 1830 if (pcmcia_map_mem_page(link->win, &map) != 0) 1831 goto next_entry; 1832 1833 data->MmioAddress = (unsigned long)ioremap_nocache(req.Base, req.Size); 1834 data->MmioLength = req.Size; 1835 } 1836 /* If we got this far, we're cool! */ 1837 break; 1838 1839 next_entry: 1840 nsp_dbg(NSP_DEBUG_INIT, "next"); 1841 1842 if (link->io.NumPorts1) { 1843 pcmcia_release_io(link->handle, &link->io); 1844 } 1845 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple)); 1846 } 1847 1848 if (link->conf.Attributes & CONF_ENABLE_IRQ) { 1849 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq)); 1850 } 1851 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf)); 1852 1853 if (free_ports) { 1854 if (link->io.BasePort1) { 1855 release_region(link->io.BasePort1, link->io.NumPorts1); 1856 } 1857 if (link->io.BasePort2) { 1858 release_region(link->io.BasePort2, link->io.NumPorts2); 1859 } 1860 } 1861 1862 /* Set port and IRQ */ 1863 data->BaseAddress = link->io.BasePort1; 1864 data->NumAddress = link->io.NumPorts1; 1865 data->IrqNumber = link->irq.AssignedIRQ; 1866 1867 nsp_dbg(NSP_DEBUG_INIT, "I/O[0x%x+0x%x] IRQ %d", 1868 data->BaseAddress, data->NumAddress, data->IrqNumber); 1869 1870 if(nsphw_init(data) == FALSE) { 1871 goto cs_failed; 1872 } 1873 1874 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,2)) 1875 host = nsp_detect(&nsp_driver_template); 1876 #else 1877 scsi_register_host(&nsp_driver_template); 1878 for (host = scsi_host_get_next(NULL); host != NULL; 1879 host = scsi_host_get_next(host)) { 1880 if (host->hostt == &nsp_driver_template) { 1881 break; 1882 } 1883 } 1884 #endif 1885 1886 if (host == NULL) { 1887 nsp_dbg(NSP_DEBUG_INIT, "detect failed"); 1888 goto cs_failed; 1889 } 1890 1891 1892 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,74)) 1893 scsi_add_host (host, NULL); 1894 scsi_scan_host(host); 1895 1896 snprintf(info->node.dev_name, sizeof(info->node.dev_name), "scsi%d", host->host_no); 1897 link->dev = &info->node; 1898 info->host = host; 1899 1900 #else 1901 nsp_dbg(NSP_DEBUG_INIT, "GET_SCSI_INFO"); 1902 tail = &link->dev; 1903 info->ndev = 0; 1904 1905 nsp_dbg(NSP_DEBUG_INIT, "host=0x%p", host); 1906 1907 for (dev = host->host_queue; dev != NULL; dev = dev->next) { 1908 unsigned long id; 1909 id = (dev->id & 0x0f) + ((dev->lun & 0x0f) << 4) + 1910 ((dev->channel & 0x0f) << 8) + 1911 ((dev->host->host_no & 0x0f) << 12); 1912 node = &info->node[info->ndev]; 1913 node->minor = 0; 1914 switch (dev->type) { 1915 case TYPE_TAPE: 1916 node->major = SCSI_TAPE_MAJOR; 1917 snprintf(node->dev_name, sizeof(node->dev_name), "st#%04lx", id); 1918 break; 1919 case TYPE_DISK: 1920 case TYPE_MOD: 1921 node->major = SCSI_DISK0_MAJOR; 1922 snprintf(node->dev_name, sizeof(node->dev_name), "sd#%04lx", id); 1923 break; 1924 case TYPE_ROM: 1925 case TYPE_WORM: 1926 node->major = SCSI_CDROM_MAJOR; 1927 snprintf(node->dev_name, sizeof(node->dev_name), "sr#%04lx", id); 1928 break; 1929 default: 1930 node->major = SCSI_GENERIC_MAJOR; 1931 snprintf(node->dev_name, sizeof(node->dev_name), "sg#%04lx", id); 1932 break; 1933 } 1934 *tail = node; tail = &node->next; 1935 info->ndev++; 1936 info->host = dev->host; 1937 } 1938 1939 *tail = NULL; 1940 if (info->ndev == 0) { 1941 nsp_msg(KERN_INFO, "no SCSI devices found"); 1942 } 1943 nsp_dbg(NSP_DEBUG_INIT, "host=0x%p", host); 1944 #endif 1945 1946 /* Finally, report what we've done */ 1947 printk(KERN_INFO "nsp_cs: index 0x%02x: Vcc %d.%d", 1948 link->conf.ConfigIndex, 1949 link->conf.Vcc/10, link->conf.Vcc%10); 1950 if (link->conf.Vpp1) { 1951 printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10); 1952 } 1953 if (link->conf.Attributes & CONF_ENABLE_IRQ) { 1954 printk(", irq %d", link->irq.AssignedIRQ); 1955 } 1956 if (link->io.NumPorts1) { 1957 printk(", io 0x%04x-0x%04x", link->io.BasePort1, 1958 link->io.BasePort1+link->io.NumPorts1-1); 1959 } 1960 if (link->io.NumPorts2) 1961 printk(" & 0x%04x-0x%04x", link->io.BasePort2, 1962 link->io.BasePort2+link->io.NumPorts2-1); 1963 if (link->win) 1964 printk(", mem 0x%06lx-0x%06lx", req.Base, 1965 req.Base+req.Size-1); 1966 printk("\n"); 1967 1968 link->state &= ~DEV_CONFIG_PENDING; 1969 return; 1970 1971 cs_failed: 1972 nsp_dbg(NSP_DEBUG_INIT, "config fail"); 1973 cs_error(link->handle, last_fn, last_ret); 1974 nsp_cs_release(link); 1975 1976 return; 1977 } /* nsp_cs_config */ 1978 #undef CS_CHECK 1979 1980 1981 /*====================================================================== 1982 After a card is removed, nsp_cs_release() will unregister the net 1983 device, and release the PCMCIA configuration. If the device is 1984 still open, this will be postponed until it is closed. 1985 ======================================================================*/ 1986 static void nsp_cs_release(dev_link_t *link) 1987 { 1988 scsi_info_t *info = link->priv; 1989 nsp_hw_data *data = NULL; 1990 1991 if (info->host == NULL) { 1992 nsp_msg(KERN_DEBUG, "unexpected card release call."); 1993 } else { 1994 data = (nsp_hw_data *)info->host->hostdata; 1995 } 1996 1997 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link); 1998 1999 /* Unlink the device chain */ 2000 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,2)) 2001 if (info->host != NULL) { 2002 scsi_remove_host(info->host); 2003 } 2004 #else 2005 scsi_unregister_host(&nsp_driver_template); 2006 #endif 2007 link->dev = NULL; 2008 2009 if (link->win) { 2010 if (data != NULL) { 2011 iounmap((void *)(data->MmioAddress)); 2012 } 2013 pcmcia_release_window(link->win); 2014 } 2015 pcmcia_release_configuration(link->handle); 2016 if (link->io.NumPorts1) { 2017 pcmcia_release_io(link->handle, &link->io); 2018 } 2019 if (link->irq.AssignedIRQ) { 2020 pcmcia_release_irq(link->handle, &link->irq); 2021 } 2022 link->state &= ~DEV_CONFIG; 2023 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,2)) 2024 if (info->host != NULL) { 2025 scsi_host_put(info->host); 2026 } 2027 #endif 2028 } /* nsp_cs_release */ 2029 2030 /*====================================================================== 2031 2032 The card status event handler. Mostly, this schedules other 2033 stuff to run after an event is received. A CARD_REMOVAL event 2034 also sets some flags to discourage the net drivers from trying 2035 to talk to the card any more. 2036 2037 When a CARD_REMOVAL event is received, we immediately set a flag 2038 to block future accesses to this device. All the functions that 2039 actually access the device should check this flag to make sure 2040 the card is still present. 2041 2042 ======================================================================*/ 2043 static int nsp_cs_event(event_t event, 2044 int priority, 2045 event_callback_args_t *args) 2046 { 2047 dev_link_t *link = args->client_data; 2048 scsi_info_t *info = link->priv; 2049 nsp_hw_data *data; 2050 2051 nsp_dbg(NSP_DEBUG_INIT, "in, event=0x%08x", event); 2052 2053 switch (event) { 2054 case CS_EVENT_CARD_REMOVAL: 2055 nsp_dbg(NSP_DEBUG_INIT, "event: remove"); 2056 link->state &= ~DEV_PRESENT; 2057 if (link->state & DEV_CONFIG) { 2058 ((scsi_info_t *)link->priv)->stop = 1; 2059 nsp_cs_release(link); 2060 } 2061 break; 2062 2063 case CS_EVENT_CARD_INSERTION: 2064 nsp_dbg(NSP_DEBUG_INIT, "event: insert"); 2065 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; 2066 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,68)) 2067 info->bus = args->bus; 2068 #endif 2069 nsp_cs_config(link); 2070 break; 2071 2072 case CS_EVENT_PM_SUSPEND: 2073 nsp_dbg(NSP_DEBUG_INIT, "event: suspend"); 2074 link->state |= DEV_SUSPEND; 2075 /* Fall through... */ 2076 case CS_EVENT_RESET_PHYSICAL: 2077 /* Mark the device as stopped, to block IO until later */ 2078 nsp_dbg(NSP_DEBUG_INIT, "event: reset physical"); 2079 2080 if (info->host != NULL) { 2081 nsp_msg(KERN_INFO, "clear SDTR status"); 2082 2083 data = (nsp_hw_data *)info->host->hostdata; 2084 2085 nsphw_init_sync(data); 2086 } 2087 2088 info->stop = 1; 2089 if (link->state & DEV_CONFIG) { 2090 pcmcia_release_configuration(link->handle); 2091 } 2092 break; 2093 2094 case CS_EVENT_PM_RESUME: 2095 nsp_dbg(NSP_DEBUG_INIT, "event: resume"); 2096 link->state &= ~DEV_SUSPEND; 2097 /* Fall through... */ 2098 case CS_EVENT_CARD_RESET: 2099 nsp_dbg(NSP_DEBUG_INIT, "event: reset"); 2100 if (link->state & DEV_CONFIG) { 2101 pcmcia_request_configuration(link->handle, &link->conf); 2102 } 2103 info->stop = 0; 2104 2105 if (info->host != NULL) { 2106 nsp_msg(KERN_INFO, "reset host and bus"); 2107 2108 data = (nsp_hw_data *)info->host->hostdata; 2109 2110 nsphw_init (data); 2111 nsp_bus_reset(data); 2112 } 2113 2114 break; 2115 2116 default: 2117 nsp_dbg(NSP_DEBUG_INIT, "event: unknown"); 2118 break; 2119 } 2120 nsp_dbg(NSP_DEBUG_INIT, "end"); 2121 return 0; 2122 } /* nsp_cs_event */ 2123 2124 /*======================================================================* 2125 * module entry point 2126 *====================================================================*/ 2127 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68)) 2128 static struct pcmcia_driver nsp_driver = { 2129 .owner = THIS_MODULE, 2130 .drv = { 2131 .name = "nsp_cs", 2132 }, 2133 .attach = nsp_cs_attach, 2134 .detach = nsp_cs_detach, 2135 }; 2136 #endif 2137 2138 static int __init nsp_cs_init(void) 2139 { 2140 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68)) 2141 nsp_msg(KERN_INFO, "loading..."); 2142 2143 return pcmcia_register_driver(&nsp_driver); 2144 #else 2145 servinfo_t serv; 2146 2147 nsp_msg(KERN_INFO, "loading..."); 2148 pcmcia_get_card_services_info(&serv); 2149 if (serv.Revision != CS_RELEASE_CODE) { 2150 nsp_msg(KERN_DEBUG, "Card Services release does not match!"); 2151 return -EINVAL; 2152 } 2153 register_pcmcia_driver(&dev_info, &nsp_cs_attach, &nsp_cs_detach); 2154 2155 nsp_dbg(NSP_DEBUG_INIT, "out"); 2156 return 0; 2157 #endif 2158 } 2159 2160 static void __exit nsp_cs_exit(void) 2161 { 2162 nsp_msg(KERN_INFO, "unloading..."); 2163 2164 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68)) 2165 pcmcia_unregister_driver(&nsp_driver); 2166 BUG_ON(dev_list != NULL); 2167 #else 2168 unregister_pcmcia_driver(&dev_info); 2169 /* XXX: this really needs to move into generic code.. */ 2170 while (dev_list != NULL) { 2171 if (dev_list->state & DEV_CONFIG) { 2172 nsp_cs_release(dev_list); 2173 } 2174 nsp_cs_detach(dev_list); 2175 } 2176 #endif 2177 } 2178 2179 2180 module_init(nsp_cs_init) 2181 module_exit(nsp_cs_exit) 2182 2183 /* end */ 2184