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 #include <linux/module.h> 29 #include <linux/kernel.h> 30 #include <linux/init.h> 31 #include <linux/slab.h> 32 #include <linux/string.h> 33 #include <linux/timer.h> 34 #include <linux/ioport.h> 35 #include <linux/delay.h> 36 #include <linux/interrupt.h> 37 #include <linux/major.h> 38 #include <linux/blkdev.h> 39 #include <linux/stat.h> 40 41 #include <asm/io.h> 42 #include <asm/irq.h> 43 44 #include <../drivers/scsi/scsi.h> 45 #include <scsi/scsi_host.h> 46 47 #include <scsi/scsi.h> 48 #include <scsi/scsi_ioctl.h> 49 50 #include <pcmcia/cistpl.h> 51 #include <pcmcia/cisreg.h> 52 #include <pcmcia/ds.h> 53 54 #include "nsp_cs.h" 55 56 MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>"); 57 MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module"); 58 MODULE_SUPPORTED_DEVICE("sd,sr,sg,st"); 59 MODULE_LICENSE("GPL"); 60 61 #include "nsp_io.h" 62 63 /*====================================================================*/ 64 /* Parameters that can be set with 'insmod' */ 65 66 static int nsp_burst_mode = BURST_MEM32; 67 module_param(nsp_burst_mode, int, 0); 68 MODULE_PARM_DESC(nsp_burst_mode, "Burst transfer mode (0=io8, 1=io32, 2=mem32(default))"); 69 70 /* Release IO ports after configuration? */ 71 static bool free_ports = 0; 72 module_param(free_ports, bool, 0); 73 MODULE_PARM_DESC(free_ports, "Release IO ports after configuration? (default: 0 (=no))"); 74 75 static struct scsi_host_template nsp_driver_template = { 76 .proc_name = "nsp_cs", 77 .show_info = nsp_show_info, 78 .name = "WorkBit NinjaSCSI-3/32Bi(16bit)", 79 .info = nsp_info, 80 .queuecommand = nsp_queuecommand, 81 /* .eh_abort_handler = nsp_eh_abort,*/ 82 .eh_bus_reset_handler = nsp_eh_bus_reset, 83 .eh_host_reset_handler = nsp_eh_host_reset, 84 .can_queue = 1, 85 .this_id = NSP_INITIATOR_ID, 86 .sg_tablesize = SG_ALL, 87 .dma_boundary = PAGE_SIZE - 1, 88 }; 89 90 static nsp_hw_data nsp_data_base; /* attach <-> detect glue */ 91 92 93 94 /* 95 * debug, error print 96 */ 97 #ifndef NSP_DEBUG 98 # define NSP_DEBUG_MASK 0x000000 99 # define nsp_msg(type, args...) nsp_cs_message("", 0, (type), args) 100 # define nsp_dbg(mask, args...) /* */ 101 #else 102 # define NSP_DEBUG_MASK 0xffffff 103 # define nsp_msg(type, args...) \ 104 nsp_cs_message (__func__, __LINE__, (type), args) 105 # define nsp_dbg(mask, args...) \ 106 nsp_cs_dmessage(__func__, __LINE__, (mask), args) 107 #endif 108 109 #define NSP_DEBUG_QUEUECOMMAND BIT(0) 110 #define NSP_DEBUG_REGISTER BIT(1) 111 #define NSP_DEBUG_AUTOSCSI BIT(2) 112 #define NSP_DEBUG_INTR BIT(3) 113 #define NSP_DEBUG_SGLIST BIT(4) 114 #define NSP_DEBUG_BUSFREE BIT(5) 115 #define NSP_DEBUG_CDB_CONTENTS BIT(6) 116 #define NSP_DEBUG_RESELECTION BIT(7) 117 #define NSP_DEBUG_MSGINOCCUR BIT(8) 118 #define NSP_DEBUG_EEPROM BIT(9) 119 #define NSP_DEBUG_MSGOUTOCCUR BIT(10) 120 #define NSP_DEBUG_BUSRESET BIT(11) 121 #define NSP_DEBUG_RESTART BIT(12) 122 #define NSP_DEBUG_SYNC BIT(13) 123 #define NSP_DEBUG_WAIT BIT(14) 124 #define NSP_DEBUG_TARGETFLAG BIT(15) 125 #define NSP_DEBUG_PROC BIT(16) 126 #define NSP_DEBUG_INIT BIT(17) 127 #define NSP_DEBUG_DATA_IO BIT(18) 128 #define NSP_SPECIAL_PRINT_REGISTER BIT(20) 129 130 #define NSP_DEBUG_BUF_LEN 150 131 132 static inline void nsp_inc_resid(struct scsi_cmnd *SCpnt, int residInc) 133 { 134 scsi_set_resid(SCpnt, scsi_get_resid(SCpnt) + residInc); 135 } 136 137 __printf(4, 5) 138 static void nsp_cs_message(const char *func, int line, char *type, char *fmt, ...) 139 { 140 va_list args; 141 char buf[NSP_DEBUG_BUF_LEN]; 142 143 va_start(args, fmt); 144 vsnprintf(buf, sizeof(buf), fmt, args); 145 va_end(args); 146 147 #ifndef NSP_DEBUG 148 printk("%snsp_cs: %s\n", type, buf); 149 #else 150 printk("%snsp_cs: %s (%d): %s\n", type, func, line, buf); 151 #endif 152 } 153 154 #ifdef NSP_DEBUG 155 static void nsp_cs_dmessage(const char *func, int line, int mask, char *fmt, ...) 156 { 157 va_list args; 158 char buf[NSP_DEBUG_BUF_LEN]; 159 160 va_start(args, fmt); 161 vsnprintf(buf, sizeof(buf), fmt, args); 162 va_end(args); 163 164 if (mask & NSP_DEBUG_MASK) { 165 printk("nsp_cs-debug: 0x%x %s (%d): %s\n", mask, func, line, buf); 166 } 167 } 168 #endif 169 170 /***********************************************************/ 171 172 /*==================================================== 173 * Clenaup parameters and call done() functions. 174 * You must be set SCpnt->result before call this function. 175 */ 176 static void nsp_scsi_done(struct scsi_cmnd *SCpnt) 177 { 178 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 179 180 data->CurrentSC = NULL; 181 182 SCpnt->scsi_done(SCpnt); 183 } 184 185 static int nsp_queuecommand_lck(struct scsi_cmnd *SCpnt, 186 void (*done)(struct scsi_cmnd *)) 187 { 188 #ifdef NSP_DEBUG 189 /*unsigned int host_id = SCpnt->device->host->this_id;*/ 190 /*unsigned int base = SCpnt->device->host->io_port;*/ 191 unsigned char target = scmd_id(SCpnt); 192 #endif 193 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 194 195 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, 196 "SCpnt=0x%p target=%d lun=%llu sglist=0x%p bufflen=%d sg_count=%d", 197 SCpnt, target, SCpnt->device->lun, scsi_sglist(SCpnt), 198 scsi_bufflen(SCpnt), scsi_sg_count(SCpnt)); 199 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "before CurrentSC=0x%p", data->CurrentSC); 200 201 SCpnt->scsi_done = done; 202 203 if (data->CurrentSC != NULL) { 204 nsp_msg(KERN_DEBUG, "CurrentSC!=NULL this can't be happen"); 205 SCpnt->result = DID_BAD_TARGET << 16; 206 nsp_scsi_done(SCpnt); 207 return 0; 208 } 209 210 #if 0 211 /* XXX: pcmcia-cs generates SCSI command with "scsi_info" utility. 212 This makes kernel crash when suspending... */ 213 if (data->ScsiInfo->stop != 0) { 214 nsp_msg(KERN_INFO, "suspending device. reject command."); 215 SCpnt->result = DID_BAD_TARGET << 16; 216 nsp_scsi_done(SCpnt); 217 return SCSI_MLQUEUE_HOST_BUSY; 218 } 219 #endif 220 221 show_command(SCpnt); 222 223 data->CurrentSC = SCpnt; 224 225 SCpnt->SCp.Status = CHECK_CONDITION; 226 SCpnt->SCp.Message = 0; 227 SCpnt->SCp.have_data_in = IO_UNKNOWN; 228 SCpnt->SCp.sent_command = 0; 229 SCpnt->SCp.phase = PH_UNDETERMINED; 230 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt)); 231 232 /* setup scratch area 233 SCp.ptr : buffer pointer 234 SCp.this_residual : buffer length 235 SCp.buffer : next buffer 236 SCp.buffers_residual : left buffers in list 237 SCp.phase : current state of the command */ 238 if (scsi_bufflen(SCpnt)) { 239 SCpnt->SCp.buffer = scsi_sglist(SCpnt); 240 SCpnt->SCp.ptr = BUFFER_ADDR; 241 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 242 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1; 243 } else { 244 SCpnt->SCp.ptr = NULL; 245 SCpnt->SCp.this_residual = 0; 246 SCpnt->SCp.buffer = NULL; 247 SCpnt->SCp.buffers_residual = 0; 248 } 249 250 if (nsphw_start_selection(SCpnt) == FALSE) { 251 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "selection fail"); 252 SCpnt->result = DID_BUS_BUSY << 16; 253 nsp_scsi_done(SCpnt); 254 return 0; 255 } 256 257 258 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "out"); 259 #ifdef NSP_DEBUG 260 data->CmdId++; 261 #endif 262 return 0; 263 } 264 265 static DEF_SCSI_QCMD(nsp_queuecommand) 266 267 /* 268 * setup PIO FIFO transfer mode and enable/disable to data out 269 */ 270 static void nsp_setup_fifo(nsp_hw_data *data, int enabled) 271 { 272 unsigned int base = data->BaseAddress; 273 unsigned char transfer_mode_reg; 274 275 //nsp_dbg(NSP_DEBUG_DATA_IO, "enabled=%d", enabled); 276 277 if (enabled != FALSE) { 278 transfer_mode_reg = TRANSFER_GO | BRAIND; 279 } else { 280 transfer_mode_reg = 0; 281 } 282 283 transfer_mode_reg |= data->TransferMode; 284 285 nsp_index_write(base, TRANSFERMODE, transfer_mode_reg); 286 } 287 288 static void nsphw_init_sync(nsp_hw_data *data) 289 { 290 sync_data tmp_sync = { .SyncNegotiation = SYNC_NOT_YET, 291 .SyncPeriod = 0, 292 .SyncOffset = 0 293 }; 294 int i; 295 296 /* setup sync data */ 297 for ( i = 0; i < ARRAY_SIZE(data->Sync); i++ ) { 298 data->Sync[i] = tmp_sync; 299 } 300 } 301 302 /* 303 * Initialize Ninja hardware 304 */ 305 static int nsphw_init(nsp_hw_data *data) 306 { 307 unsigned int base = data->BaseAddress; 308 309 nsp_dbg(NSP_DEBUG_INIT, "in base=0x%x", base); 310 311 data->ScsiClockDiv = CLOCK_40M | FAST_20; 312 data->CurrentSC = NULL; 313 data->FifoCount = 0; 314 data->TransferMode = MODE_IO8; 315 316 nsphw_init_sync(data); 317 318 /* block all interrupts */ 319 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK); 320 321 /* setup SCSI interface */ 322 nsp_write(base, IFSELECT, IF_IFSEL); 323 324 nsp_index_write(base, SCSIIRQMODE, 0); 325 326 nsp_index_write(base, TRANSFERMODE, MODE_IO8); 327 nsp_index_write(base, CLOCKDIV, data->ScsiClockDiv); 328 329 nsp_index_write(base, PARITYCTRL, 0); 330 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | 331 ACK_COUNTER_CLEAR | 332 REQ_COUNTER_CLEAR | 333 HOST_COUNTER_CLEAR); 334 335 /* setup fifo asic */ 336 nsp_write(base, IFSELECT, IF_REGSEL); 337 nsp_index_write(base, TERMPWRCTRL, 0); 338 if ((nsp_index_read(base, OTHERCONTROL) & TPWR_SENSE) == 0) { 339 nsp_msg(KERN_INFO, "terminator power on"); 340 nsp_index_write(base, TERMPWRCTRL, POWER_ON); 341 } 342 343 nsp_index_write(base, TIMERCOUNT, 0); 344 nsp_index_write(base, TIMERCOUNT, 0); /* requires 2 times!! */ 345 346 nsp_index_write(base, SYNCREG, 0); 347 nsp_index_write(base, ACKWIDTH, 0); 348 349 /* enable interrupts and ack them */ 350 nsp_index_write(base, SCSIIRQMODE, SCSI_PHASE_CHANGE_EI | 351 RESELECT_EI | 352 SCSI_RESET_IRQ_EI ); 353 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR); 354 355 nsp_setup_fifo(data, FALSE); 356 357 return TRUE; 358 } 359 360 /* 361 * Start selection phase 362 */ 363 static int nsphw_start_selection(struct scsi_cmnd *SCpnt) 364 { 365 unsigned int host_id = SCpnt->device->host->this_id; 366 unsigned int base = SCpnt->device->host->io_port; 367 unsigned char target = scmd_id(SCpnt); 368 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 369 int time_out; 370 unsigned char phase, arbit; 371 372 //nsp_dbg(NSP_DEBUG_RESELECTION, "in"); 373 374 phase = nsp_index_read(base, SCSIBUSMON); 375 if(phase != BUSMON_BUS_FREE) { 376 //nsp_dbg(NSP_DEBUG_RESELECTION, "bus busy"); 377 return FALSE; 378 } 379 380 /* start arbitration */ 381 //nsp_dbg(NSP_DEBUG_RESELECTION, "start arbit"); 382 SCpnt->SCp.phase = PH_ARBSTART; 383 nsp_index_write(base, SETARBIT, ARBIT_GO); 384 385 time_out = 1000; 386 do { 387 /* XXX: what a stupid chip! */ 388 arbit = nsp_index_read(base, ARBITSTATUS); 389 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit=%d, wait_count=%d", arbit, wait_count); 390 udelay(1); /* hold 1.2us */ 391 } while((arbit & (ARBIT_WIN | ARBIT_FAIL)) == 0 && 392 (time_out-- != 0)); 393 394 if (!(arbit & ARBIT_WIN)) { 395 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit fail"); 396 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR); 397 return FALSE; 398 } 399 400 /* assert select line */ 401 //nsp_dbg(NSP_DEBUG_RESELECTION, "assert SEL line"); 402 SCpnt->SCp.phase = PH_SELSTART; 403 udelay(3); /* wait 2.4us */ 404 nsp_index_write(base, SCSIDATALATCH, BIT(host_id) | BIT(target)); 405 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_ATN); 406 udelay(2); /* wait >1.2us */ 407 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_DATAOUT_ENB | SCSI_ATN); 408 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR); 409 /*udelay(1);*/ /* wait >90ns */ 410 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_DATAOUT_ENB | SCSI_ATN); 411 412 /* check selection timeout */ 413 nsp_start_timer(SCpnt, 1000/51); 414 data->SelectionTimeOut = 1; 415 416 return TRUE; 417 } 418 419 struct nsp_sync_table { 420 unsigned int min_period; 421 unsigned int max_period; 422 unsigned int chip_period; 423 unsigned int ack_width; 424 }; 425 426 static struct nsp_sync_table nsp_sync_table_40M[] = { 427 {0x0c, 0x0c, 0x1, 0}, /* 20MB 50ns*/ 428 {0x19, 0x19, 0x3, 1}, /* 10MB 100ns*/ 429 {0x1a, 0x25, 0x5, 2}, /* 7.5MB 150ns*/ 430 {0x26, 0x32, 0x7, 3}, /* 5MB 200ns*/ 431 { 0, 0, 0, 0}, 432 }; 433 434 static struct nsp_sync_table nsp_sync_table_20M[] = { 435 {0x19, 0x19, 0x1, 0}, /* 10MB 100ns*/ 436 {0x1a, 0x25, 0x2, 0}, /* 7.5MB 150ns*/ 437 {0x26, 0x32, 0x3, 1}, /* 5MB 200ns*/ 438 { 0, 0, 0, 0}, 439 }; 440 441 /* 442 * setup synchronous data transfer mode 443 */ 444 static int nsp_analyze_sdtr(struct scsi_cmnd *SCpnt) 445 { 446 unsigned char target = scmd_id(SCpnt); 447 // unsigned char lun = SCpnt->device->lun; 448 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 449 sync_data *sync = &(data->Sync[target]); 450 struct nsp_sync_table *sync_table; 451 unsigned int period, offset; 452 int i; 453 454 455 nsp_dbg(NSP_DEBUG_SYNC, "in"); 456 457 period = sync->SyncPeriod; 458 offset = sync->SyncOffset; 459 460 nsp_dbg(NSP_DEBUG_SYNC, "period=0x%x, offset=0x%x", period, offset); 461 462 if ((data->ScsiClockDiv & (BIT(0)|BIT(1))) == CLOCK_20M) { 463 sync_table = nsp_sync_table_20M; 464 } else { 465 sync_table = nsp_sync_table_40M; 466 } 467 468 for ( i = 0; sync_table->max_period != 0; i++, sync_table++) { 469 if ( period >= sync_table->min_period && 470 period <= sync_table->max_period ) { 471 break; 472 } 473 } 474 475 if (period != 0 && sync_table->max_period == 0) { 476 /* 477 * No proper period/offset found 478 */ 479 nsp_dbg(NSP_DEBUG_SYNC, "no proper period/offset"); 480 481 sync->SyncPeriod = 0; 482 sync->SyncOffset = 0; 483 sync->SyncRegister = 0; 484 sync->AckWidth = 0; 485 486 return FALSE; 487 } 488 489 sync->SyncRegister = (sync_table->chip_period << SYNCREG_PERIOD_SHIFT) | 490 (offset & SYNCREG_OFFSET_MASK); 491 sync->AckWidth = sync_table->ack_width; 492 493 nsp_dbg(NSP_DEBUG_SYNC, "sync_reg=0x%x, ack_width=0x%x", sync->SyncRegister, sync->AckWidth); 494 495 return TRUE; 496 } 497 498 499 /* 500 * start ninja hardware timer 501 */ 502 static void nsp_start_timer(struct scsi_cmnd *SCpnt, int time) 503 { 504 unsigned int base = SCpnt->device->host->io_port; 505 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 506 507 //nsp_dbg(NSP_DEBUG_INTR, "in SCpnt=0x%p, time=%d", SCpnt, time); 508 data->TimerCount = time; 509 nsp_index_write(base, TIMERCOUNT, time); 510 } 511 512 /* 513 * wait for bus phase change 514 */ 515 static int nsp_negate_signal(struct scsi_cmnd *SCpnt, unsigned char mask, 516 char *str) 517 { 518 unsigned int base = SCpnt->device->host->io_port; 519 unsigned char reg; 520 int time_out; 521 522 //nsp_dbg(NSP_DEBUG_INTR, "in"); 523 524 time_out = 100; 525 526 do { 527 reg = nsp_index_read(base, SCSIBUSMON); 528 if (reg == 0xff) { 529 break; 530 } 531 } while ((--time_out != 0) && (reg & mask) != 0); 532 533 if (time_out == 0) { 534 nsp_msg(KERN_DEBUG, " %s signal off timeout", str); 535 } 536 537 return 0; 538 } 539 540 /* 541 * expect Ninja Irq 542 */ 543 static int nsp_expect_signal(struct scsi_cmnd *SCpnt, 544 unsigned char current_phase, 545 unsigned char mask) 546 { 547 unsigned int base = SCpnt->device->host->io_port; 548 int time_out; 549 unsigned char phase, i_src; 550 551 //nsp_dbg(NSP_DEBUG_INTR, "current_phase=0x%x, mask=0x%x", current_phase, mask); 552 553 time_out = 100; 554 do { 555 phase = nsp_index_read(base, SCSIBUSMON); 556 if (phase == 0xff) { 557 //nsp_dbg(NSP_DEBUG_INTR, "ret -1"); 558 return -1; 559 } 560 i_src = nsp_read(base, IRQSTATUS); 561 if (i_src & IRQSTATUS_SCSI) { 562 //nsp_dbg(NSP_DEBUG_INTR, "ret 0 found scsi signal"); 563 return 0; 564 } 565 if ((phase & mask) != 0 && (phase & BUSMON_PHASE_MASK) == current_phase) { 566 //nsp_dbg(NSP_DEBUG_INTR, "ret 1 phase=0x%x", phase); 567 return 1; 568 } 569 } while(time_out-- != 0); 570 571 //nsp_dbg(NSP_DEBUG_INTR, "timeout"); 572 return -1; 573 } 574 575 /* 576 * transfer SCSI message 577 */ 578 static int nsp_xfer(struct scsi_cmnd *SCpnt, int phase) 579 { 580 unsigned int base = SCpnt->device->host->io_port; 581 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 582 char *buf = data->MsgBuffer; 583 int len = min(MSGBUF_SIZE, data->MsgLen); 584 int ptr; 585 int ret; 586 587 //nsp_dbg(NSP_DEBUG_DATA_IO, "in"); 588 for (ptr = 0; len > 0; len--, ptr++) { 589 590 ret = nsp_expect_signal(SCpnt, phase, BUSMON_REQ); 591 if (ret <= 0) { 592 nsp_dbg(NSP_DEBUG_DATA_IO, "xfer quit"); 593 return 0; 594 } 595 596 /* if last byte, negate ATN */ 597 if (len == 1 && SCpnt->SCp.phase == PH_MSG_OUT) { 598 nsp_index_write(base, SCSIBUSCTRL, AUTODIRECTION | ACKENB); 599 } 600 601 /* read & write message */ 602 if (phase & BUSMON_IO) { 603 nsp_dbg(NSP_DEBUG_DATA_IO, "read msg"); 604 buf[ptr] = nsp_index_read(base, SCSIDATAWITHACK); 605 } else { 606 nsp_dbg(NSP_DEBUG_DATA_IO, "write msg"); 607 nsp_index_write(base, SCSIDATAWITHACK, buf[ptr]); 608 } 609 nsp_negate_signal(SCpnt, BUSMON_ACK, "xfer<ack>"); 610 611 } 612 return len; 613 } 614 615 /* 616 * get extra SCSI data from fifo 617 */ 618 static int nsp_dataphase_bypass(struct scsi_cmnd *SCpnt) 619 { 620 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 621 unsigned int count; 622 623 //nsp_dbg(NSP_DEBUG_DATA_IO, "in"); 624 625 if (SCpnt->SCp.have_data_in != IO_IN) { 626 return 0; 627 } 628 629 count = nsp_fifo_count(SCpnt); 630 if (data->FifoCount == count) { 631 //nsp_dbg(NSP_DEBUG_DATA_IO, "not use bypass quirk"); 632 return 0; 633 } 634 635 /* 636 * XXX: NSP_QUIRK 637 * data phase skip only occures in case of SCSI_LOW_READ 638 */ 639 nsp_dbg(NSP_DEBUG_DATA_IO, "use bypass quirk"); 640 SCpnt->SCp.phase = PH_DATA; 641 nsp_pio_read(SCpnt); 642 nsp_setup_fifo(data, FALSE); 643 644 return 0; 645 } 646 647 /* 648 * accept reselection 649 */ 650 static int nsp_reselected(struct scsi_cmnd *SCpnt) 651 { 652 unsigned int base = SCpnt->device->host->io_port; 653 unsigned int host_id = SCpnt->device->host->this_id; 654 //nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 655 unsigned char bus_reg; 656 unsigned char id_reg, tmp; 657 int target; 658 659 nsp_dbg(NSP_DEBUG_RESELECTION, "in"); 660 661 id_reg = nsp_index_read(base, RESELECTID); 662 tmp = id_reg & (~BIT(host_id)); 663 target = 0; 664 while(tmp != 0) { 665 if (tmp & BIT(0)) { 666 break; 667 } 668 tmp >>= 1; 669 target++; 670 } 671 672 if (scmd_id(SCpnt) != target) { 673 nsp_msg(KERN_ERR, "XXX: reselect ID must be %d in this implementation.", target); 674 } 675 676 nsp_negate_signal(SCpnt, BUSMON_SEL, "reselect<SEL>"); 677 678 nsp_nexus(SCpnt); 679 bus_reg = nsp_index_read(base, SCSIBUSCTRL) & ~(SCSI_BSY | SCSI_ATN); 680 nsp_index_write(base, SCSIBUSCTRL, bus_reg); 681 nsp_index_write(base, SCSIBUSCTRL, bus_reg | AUTODIRECTION | ACKENB); 682 683 return TRUE; 684 } 685 686 /* 687 * count how many data transferd 688 */ 689 static int nsp_fifo_count(struct scsi_cmnd *SCpnt) 690 { 691 unsigned int base = SCpnt->device->host->io_port; 692 unsigned int count; 693 unsigned int l, m, h; 694 695 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | ACK_COUNTER); 696 697 l = nsp_index_read(base, TRANSFERCOUNT); 698 m = nsp_index_read(base, TRANSFERCOUNT); 699 h = nsp_index_read(base, TRANSFERCOUNT); 700 nsp_index_read(base, TRANSFERCOUNT); /* required this! */ 701 702 count = (h << 16) | (m << 8) | (l << 0); 703 704 //nsp_dbg(NSP_DEBUG_DATA_IO, "count=0x%x", count); 705 706 return count; 707 } 708 709 /* fifo size */ 710 #define RFIFO_CRIT 64 711 #define WFIFO_CRIT 64 712 713 /* 714 * read data in DATA IN phase 715 */ 716 static void nsp_pio_read(struct scsi_cmnd *SCpnt) 717 { 718 unsigned int base = SCpnt->device->host->io_port; 719 unsigned long mmio_base = SCpnt->device->host->base; 720 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 721 long time_out; 722 int ocount, res; 723 unsigned char stat, fifo_stat; 724 725 ocount = data->FifoCount; 726 727 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", 728 SCpnt, scsi_get_resid(SCpnt), ocount, SCpnt->SCp.ptr, 729 SCpnt->SCp.this_residual, SCpnt->SCp.buffer, 730 SCpnt->SCp.buffers_residual); 731 732 time_out = 1000; 733 734 while ((time_out-- != 0) && 735 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0 ) ) { 736 737 stat = nsp_index_read(base, SCSIBUSMON); 738 stat &= BUSMON_PHASE_MASK; 739 740 741 res = nsp_fifo_count(SCpnt) - ocount; 742 //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); 743 if (res == 0) { /* if some data available ? */ 744 if (stat == BUSPHASE_DATA_IN) { /* phase changed? */ 745 //nsp_dbg(NSP_DEBUG_DATA_IO, " wait for data this=%d", SCpnt->SCp.this_residual); 746 continue; 747 } else { 748 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x", stat); 749 break; 750 } 751 } 752 753 fifo_stat = nsp_read(base, FIFOSTATUS); 754 if ((fifo_stat & FIFOSTATUS_FULL_EMPTY) == 0 && 755 stat == BUSPHASE_DATA_IN) { 756 continue; 757 } 758 759 res = min(res, SCpnt->SCp.this_residual); 760 761 switch (data->TransferMode) { 762 case MODE_IO32: 763 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 764 nsp_fifo32_read(base, SCpnt->SCp.ptr, res >> 2); 765 break; 766 case MODE_IO8: 767 nsp_fifo8_read (base, SCpnt->SCp.ptr, res ); 768 break; 769 770 case MODE_MEM32: 771 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 772 nsp_mmio_fifo32_read(mmio_base, SCpnt->SCp.ptr, res >> 2); 773 break; 774 775 default: 776 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown read mode"); 777 return; 778 } 779 780 nsp_inc_resid(SCpnt, -res); 781 SCpnt->SCp.ptr += res; 782 SCpnt->SCp.this_residual -= res; 783 ocount += res; 784 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this_residual=0x%x ocount=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, ocount); 785 786 /* go to next scatter list if available */ 787 if (SCpnt->SCp.this_residual == 0 && 788 SCpnt->SCp.buffers_residual != 0 ) { 789 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next timeout=%d", time_out); 790 SCpnt->SCp.buffers_residual--; 791 SCpnt->SCp.buffer = sg_next(SCpnt->SCp.buffer); 792 SCpnt->SCp.ptr = BUFFER_ADDR; 793 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 794 time_out = 1000; 795 796 //nsp_dbg(NSP_DEBUG_DATA_IO, "page: 0x%p, off: 0x%x", SCpnt->SCp.buffer->page, SCpnt->SCp.buffer->offset); 797 } 798 } 799 800 data->FifoCount = ocount; 801 802 if (time_out < 0) { 803 nsp_msg(KERN_DEBUG, "pio read timeout resid=%d this_residual=%d buffers_residual=%d", 804 scsi_get_resid(SCpnt), SCpnt->SCp.this_residual, 805 SCpnt->SCp.buffers_residual); 806 } 807 nsp_dbg(NSP_DEBUG_DATA_IO, "read ocount=0x%x", ocount); 808 nsp_dbg(NSP_DEBUG_DATA_IO, "r cmd=%d resid=0x%x\n", data->CmdId, 809 scsi_get_resid(SCpnt)); 810 } 811 812 /* 813 * write data in DATA OUT phase 814 */ 815 static void nsp_pio_write(struct scsi_cmnd *SCpnt) 816 { 817 unsigned int base = SCpnt->device->host->io_port; 818 unsigned long mmio_base = SCpnt->device->host->base; 819 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 820 int time_out; 821 int ocount, res; 822 unsigned char stat; 823 824 ocount = data->FifoCount; 825 826 nsp_dbg(NSP_DEBUG_DATA_IO, "in fifocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d resid=0x%x", 827 data->FifoCount, SCpnt->SCp.ptr, SCpnt->SCp.this_residual, 828 SCpnt->SCp.buffer, SCpnt->SCp.buffers_residual, 829 scsi_get_resid(SCpnt)); 830 831 time_out = 1000; 832 833 while ((time_out-- != 0) && 834 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0)) { 835 stat = nsp_index_read(base, SCSIBUSMON); 836 stat &= BUSMON_PHASE_MASK; 837 838 if (stat != BUSPHASE_DATA_OUT) { 839 res = ocount - nsp_fifo_count(SCpnt); 840 841 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x, res=%d\n", stat, res); 842 /* Put back pointer */ 843 nsp_inc_resid(SCpnt, res); 844 SCpnt->SCp.ptr -= res; 845 SCpnt->SCp.this_residual += res; 846 ocount -= res; 847 848 break; 849 } 850 851 res = ocount - nsp_fifo_count(SCpnt); 852 if (res > 0) { /* write all data? */ 853 nsp_dbg(NSP_DEBUG_DATA_IO, "wait for all data out. ocount=0x%x res=%d", ocount, res); 854 continue; 855 } 856 857 res = min(SCpnt->SCp.this_residual, WFIFO_CRIT); 858 859 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x res=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, res); 860 switch (data->TransferMode) { 861 case MODE_IO32: 862 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 863 nsp_fifo32_write(base, SCpnt->SCp.ptr, res >> 2); 864 break; 865 case MODE_IO8: 866 nsp_fifo8_write (base, SCpnt->SCp.ptr, res ); 867 break; 868 869 case MODE_MEM32: 870 res &= ~(BIT(1)|BIT(0)); /* align 4 */ 871 nsp_mmio_fifo32_write(mmio_base, SCpnt->SCp.ptr, res >> 2); 872 break; 873 874 default: 875 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown write mode"); 876 break; 877 } 878 879 nsp_inc_resid(SCpnt, -res); 880 SCpnt->SCp.ptr += res; 881 SCpnt->SCp.this_residual -= res; 882 ocount += res; 883 884 /* go to next scatter list if available */ 885 if (SCpnt->SCp.this_residual == 0 && 886 SCpnt->SCp.buffers_residual != 0 ) { 887 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next"); 888 SCpnt->SCp.buffers_residual--; 889 SCpnt->SCp.buffer = sg_next(SCpnt->SCp.buffer); 890 SCpnt->SCp.ptr = BUFFER_ADDR; 891 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 892 time_out = 1000; 893 } 894 } 895 896 data->FifoCount = ocount; 897 898 if (time_out < 0) { 899 nsp_msg(KERN_DEBUG, "pio write timeout resid=0x%x", 900 scsi_get_resid(SCpnt)); 901 } 902 nsp_dbg(NSP_DEBUG_DATA_IO, "write ocount=0x%x", ocount); 903 nsp_dbg(NSP_DEBUG_DATA_IO, "w cmd=%d resid=0x%x\n", data->CmdId, 904 scsi_get_resid(SCpnt)); 905 } 906 #undef RFIFO_CRIT 907 #undef WFIFO_CRIT 908 909 /* 910 * setup synchronous/asynchronous data transfer mode 911 */ 912 static int nsp_nexus(struct scsi_cmnd *SCpnt) 913 { 914 unsigned int base = SCpnt->device->host->io_port; 915 unsigned char target = scmd_id(SCpnt); 916 // unsigned char lun = SCpnt->device->lun; 917 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 918 sync_data *sync = &(data->Sync[target]); 919 920 //nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p", SCpnt); 921 922 /* setup synch transfer registers */ 923 nsp_index_write(base, SYNCREG, sync->SyncRegister); 924 nsp_index_write(base, ACKWIDTH, sync->AckWidth); 925 926 if (scsi_get_resid(SCpnt) % 4 != 0 || 927 scsi_get_resid(SCpnt) <= PAGE_SIZE ) { 928 data->TransferMode = MODE_IO8; 929 } else if (nsp_burst_mode == BURST_MEM32) { 930 data->TransferMode = MODE_MEM32; 931 } else if (nsp_burst_mode == BURST_IO32) { 932 data->TransferMode = MODE_IO32; 933 } else { 934 data->TransferMode = MODE_IO8; 935 } 936 937 /* setup pdma fifo */ 938 nsp_setup_fifo(data, TRUE); 939 940 /* clear ack counter */ 941 data->FifoCount = 0; 942 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | 943 ACK_COUNTER_CLEAR | 944 REQ_COUNTER_CLEAR | 945 HOST_COUNTER_CLEAR); 946 947 return 0; 948 } 949 950 #include "nsp_message.c" 951 /* 952 * interrupt handler 953 */ 954 static irqreturn_t nspintr(int irq, void *dev_id) 955 { 956 unsigned int base; 957 unsigned char irq_status, irq_phase, phase; 958 struct scsi_cmnd *tmpSC; 959 unsigned char target, lun; 960 unsigned int *sync_neg; 961 int i, tmp; 962 nsp_hw_data *data; 963 964 965 //nsp_dbg(NSP_DEBUG_INTR, "dev_id=0x%p", dev_id); 966 //nsp_dbg(NSP_DEBUG_INTR, "host=0x%p", ((scsi_info_t *)dev_id)->host); 967 968 if ( dev_id != NULL && 969 ((scsi_info_t *)dev_id)->host != NULL ) { 970 scsi_info_t *info = (scsi_info_t *)dev_id; 971 972 data = (nsp_hw_data *)info->host->hostdata; 973 } else { 974 nsp_dbg(NSP_DEBUG_INTR, "host data wrong"); 975 return IRQ_NONE; 976 } 977 978 //nsp_dbg(NSP_DEBUG_INTR, "&nsp_data_base=0x%p, dev_id=0x%p", &nsp_data_base, dev_id); 979 980 base = data->BaseAddress; 981 //nsp_dbg(NSP_DEBUG_INTR, "base=0x%x", base); 982 983 /* 984 * interrupt check 985 */ 986 nsp_write(base, IRQCONTROL, IRQCONTROL_IRQDISABLE); 987 irq_status = nsp_read(base, IRQSTATUS); 988 //nsp_dbg(NSP_DEBUG_INTR, "irq_status=0x%x", irq_status); 989 if ((irq_status == 0xff) || ((irq_status & IRQSTATUS_MASK) == 0)) { 990 nsp_write(base, IRQCONTROL, 0); 991 //nsp_dbg(NSP_DEBUG_INTR, "no irq/shared irq"); 992 return IRQ_NONE; 993 } 994 995 /* XXX: IMPORTANT 996 * Do not read an irq_phase register if no scsi phase interrupt. 997 * Unless, you should lose a scsi phase interrupt. 998 */ 999 phase = nsp_index_read(base, SCSIBUSMON); 1000 if((irq_status & IRQSTATUS_SCSI) != 0) { 1001 irq_phase = nsp_index_read(base, IRQPHASESENCE); 1002 } else { 1003 irq_phase = 0; 1004 } 1005 1006 //nsp_dbg(NSP_DEBUG_INTR, "irq_phase=0x%x", irq_phase); 1007 1008 /* 1009 * timer interrupt handler (scsi vs timer interrupts) 1010 */ 1011 //nsp_dbg(NSP_DEBUG_INTR, "timercount=%d", data->TimerCount); 1012 if (data->TimerCount != 0) { 1013 //nsp_dbg(NSP_DEBUG_INTR, "stop timer"); 1014 nsp_index_write(base, TIMERCOUNT, 0); 1015 nsp_index_write(base, TIMERCOUNT, 0); 1016 data->TimerCount = 0; 1017 } 1018 1019 if ((irq_status & IRQSTATUS_MASK) == IRQSTATUS_TIMER && 1020 data->SelectionTimeOut == 0) { 1021 //nsp_dbg(NSP_DEBUG_INTR, "timer start"); 1022 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR); 1023 return IRQ_HANDLED; 1024 } 1025 1026 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR | IRQCONTROL_FIFO_CLEAR); 1027 1028 if ((irq_status & IRQSTATUS_SCSI) && 1029 (irq_phase & SCSI_RESET_IRQ)) { 1030 nsp_msg(KERN_ERR, "bus reset (power off?)"); 1031 1032 nsphw_init(data); 1033 nsp_bus_reset(data); 1034 1035 if(data->CurrentSC != NULL) { 1036 tmpSC = data->CurrentSC; 1037 tmpSC->result = (DID_RESET << 16) | 1038 ((tmpSC->SCp.Message & 0xff) << 8) | 1039 ((tmpSC->SCp.Status & 0xff) << 0); 1040 nsp_scsi_done(tmpSC); 1041 } 1042 return IRQ_HANDLED; 1043 } 1044 1045 if (data->CurrentSC == NULL) { 1046 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); 1047 nsphw_init(data); 1048 nsp_bus_reset(data); 1049 return IRQ_HANDLED; 1050 } 1051 1052 tmpSC = data->CurrentSC; 1053 target = tmpSC->device->id; 1054 lun = tmpSC->device->lun; 1055 sync_neg = &(data->Sync[target].SyncNegotiation); 1056 1057 /* 1058 * parse hardware SCSI irq reasons register 1059 */ 1060 if (irq_status & IRQSTATUS_SCSI) { 1061 if (irq_phase & RESELECT_IRQ) { 1062 nsp_dbg(NSP_DEBUG_INTR, "reselect"); 1063 nsp_write(base, IRQCONTROL, IRQCONTROL_RESELECT_CLEAR); 1064 if (nsp_reselected(tmpSC) != FALSE) { 1065 return IRQ_HANDLED; 1066 } 1067 } 1068 1069 if ((irq_phase & (PHASE_CHANGE_IRQ | LATCHED_BUS_FREE)) == 0) { 1070 return IRQ_HANDLED; 1071 } 1072 } 1073 1074 //show_phase(tmpSC); 1075 1076 switch(tmpSC->SCp.phase) { 1077 case PH_SELSTART: 1078 // *sync_neg = SYNC_NOT_YET; 1079 if ((phase & BUSMON_BSY) == 0) { 1080 //nsp_dbg(NSP_DEBUG_INTR, "selection count=%d", data->SelectionTimeOut); 1081 if (data->SelectionTimeOut >= NSP_SELTIMEOUT) { 1082 nsp_dbg(NSP_DEBUG_INTR, "selection time out"); 1083 data->SelectionTimeOut = 0; 1084 nsp_index_write(base, SCSIBUSCTRL, 0); 1085 1086 tmpSC->result = DID_TIME_OUT << 16; 1087 nsp_scsi_done(tmpSC); 1088 1089 return IRQ_HANDLED; 1090 } 1091 data->SelectionTimeOut += 1; 1092 nsp_start_timer(tmpSC, 1000/51); 1093 return IRQ_HANDLED; 1094 } 1095 1096 /* attention assert */ 1097 //nsp_dbg(NSP_DEBUG_INTR, "attention assert"); 1098 data->SelectionTimeOut = 0; 1099 tmpSC->SCp.phase = PH_SELECTED; 1100 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN); 1101 udelay(1); 1102 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN | AUTODIRECTION | ACKENB); 1103 return IRQ_HANDLED; 1104 1105 break; 1106 1107 case PH_RESELECT: 1108 //nsp_dbg(NSP_DEBUG_INTR, "phase reselect"); 1109 // *sync_neg = SYNC_NOT_YET; 1110 if ((phase & BUSMON_PHASE_MASK) != BUSPHASE_MESSAGE_IN) { 1111 1112 tmpSC->result = DID_ABORT << 16; 1113 nsp_scsi_done(tmpSC); 1114 return IRQ_HANDLED; 1115 } 1116 /* fall thru */ 1117 default: 1118 if ((irq_status & (IRQSTATUS_SCSI | IRQSTATUS_FIFO)) == 0) { 1119 return IRQ_HANDLED; 1120 } 1121 break; 1122 } 1123 1124 /* 1125 * SCSI sequencer 1126 */ 1127 //nsp_dbg(NSP_DEBUG_INTR, "start scsi seq"); 1128 1129 /* normal disconnect */ 1130 if (((tmpSC->SCp.phase == PH_MSG_IN) || (tmpSC->SCp.phase == PH_MSG_OUT)) && 1131 (irq_phase & LATCHED_BUS_FREE) != 0 ) { 1132 nsp_dbg(NSP_DEBUG_INTR, "normal disconnect irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase); 1133 1134 //*sync_neg = SYNC_NOT_YET; 1135 1136 /* all command complete and return status */ 1137 if (tmpSC->SCp.Message == MSG_COMMAND_COMPLETE) { 1138 tmpSC->result = (DID_OK << 16) | 1139 ((tmpSC->SCp.Message & 0xff) << 8) | 1140 ((tmpSC->SCp.Status & 0xff) << 0); 1141 nsp_dbg(NSP_DEBUG_INTR, "command complete result=0x%x", tmpSC->result); 1142 nsp_scsi_done(tmpSC); 1143 1144 return IRQ_HANDLED; 1145 } 1146 1147 return IRQ_HANDLED; 1148 } 1149 1150 1151 /* check unexpected bus free state */ 1152 if (phase == 0) { 1153 nsp_msg(KERN_DEBUG, "unexpected bus free. irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase); 1154 1155 *sync_neg = SYNC_NG; 1156 tmpSC->result = DID_ERROR << 16; 1157 nsp_scsi_done(tmpSC); 1158 return IRQ_HANDLED; 1159 } 1160 1161 switch (phase & BUSMON_PHASE_MASK) { 1162 case BUSPHASE_COMMAND: 1163 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_COMMAND"); 1164 if ((phase & BUSMON_REQ) == 0) { 1165 nsp_dbg(NSP_DEBUG_INTR, "REQ == 0"); 1166 return IRQ_HANDLED; 1167 } 1168 1169 tmpSC->SCp.phase = PH_COMMAND; 1170 1171 nsp_nexus(tmpSC); 1172 1173 /* write scsi command */ 1174 nsp_dbg(NSP_DEBUG_INTR, "cmd_len=%d", tmpSC->cmd_len); 1175 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER); 1176 for (i = 0; i < tmpSC->cmd_len; i++) { 1177 nsp_index_write(base, COMMANDDATA, tmpSC->cmnd[i]); 1178 } 1179 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER | AUTO_COMMAND_GO); 1180 break; 1181 1182 case BUSPHASE_DATA_OUT: 1183 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_OUT"); 1184 1185 tmpSC->SCp.phase = PH_DATA; 1186 tmpSC->SCp.have_data_in = IO_OUT; 1187 1188 nsp_pio_write(tmpSC); 1189 1190 break; 1191 1192 case BUSPHASE_DATA_IN: 1193 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_IN"); 1194 1195 tmpSC->SCp.phase = PH_DATA; 1196 tmpSC->SCp.have_data_in = IO_IN; 1197 1198 nsp_pio_read(tmpSC); 1199 1200 break; 1201 1202 case BUSPHASE_STATUS: 1203 nsp_dataphase_bypass(tmpSC); 1204 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_STATUS"); 1205 1206 tmpSC->SCp.phase = PH_STATUS; 1207 1208 tmpSC->SCp.Status = nsp_index_read(base, SCSIDATAWITHACK); 1209 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x status=0x%x", tmpSC->SCp.Message, tmpSC->SCp.Status); 1210 1211 break; 1212 1213 case BUSPHASE_MESSAGE_OUT: 1214 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_OUT"); 1215 if ((phase & BUSMON_REQ) == 0) { 1216 goto timer_out; 1217 } 1218 1219 tmpSC->SCp.phase = PH_MSG_OUT; 1220 1221 //*sync_neg = SYNC_NOT_YET; 1222 1223 data->MsgLen = i = 0; 1224 data->MsgBuffer[i] = IDENTIFY(TRUE, lun); i++; 1225 1226 if (*sync_neg == SYNC_NOT_YET) { 1227 data->Sync[target].SyncPeriod = 0; 1228 data->Sync[target].SyncOffset = 0; 1229 1230 /**/ 1231 data->MsgBuffer[i] = MSG_EXTENDED; i++; 1232 data->MsgBuffer[i] = 3; i++; 1233 data->MsgBuffer[i] = MSG_EXT_SDTR; i++; 1234 data->MsgBuffer[i] = 0x0c; i++; 1235 data->MsgBuffer[i] = 15; i++; 1236 /**/ 1237 } 1238 data->MsgLen = i; 1239 1240 nsp_analyze_sdtr(tmpSC); 1241 show_message(data); 1242 nsp_message_out(tmpSC); 1243 break; 1244 1245 case BUSPHASE_MESSAGE_IN: 1246 nsp_dataphase_bypass(tmpSC); 1247 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_IN"); 1248 if ((phase & BUSMON_REQ) == 0) { 1249 goto timer_out; 1250 } 1251 1252 tmpSC->SCp.phase = PH_MSG_IN; 1253 nsp_message_in(tmpSC); 1254 1255 /**/ 1256 if (*sync_neg == SYNC_NOT_YET) { 1257 //nsp_dbg(NSP_DEBUG_INTR, "sync target=%d,lun=%d",target,lun); 1258 1259 if (data->MsgLen >= 5 && 1260 data->MsgBuffer[0] == MSG_EXTENDED && 1261 data->MsgBuffer[1] == 3 && 1262 data->MsgBuffer[2] == MSG_EXT_SDTR ) { 1263 data->Sync[target].SyncPeriod = data->MsgBuffer[3]; 1264 data->Sync[target].SyncOffset = data->MsgBuffer[4]; 1265 //nsp_dbg(NSP_DEBUG_INTR, "sync ok, %d %d", data->MsgBuffer[3], data->MsgBuffer[4]); 1266 *sync_neg = SYNC_OK; 1267 } else { 1268 data->Sync[target].SyncPeriod = 0; 1269 data->Sync[target].SyncOffset = 0; 1270 *sync_neg = SYNC_NG; 1271 } 1272 nsp_analyze_sdtr(tmpSC); 1273 } 1274 /**/ 1275 1276 /* search last messeage byte */ 1277 tmp = -1; 1278 for (i = 0; i < data->MsgLen; i++) { 1279 tmp = data->MsgBuffer[i]; 1280 if (data->MsgBuffer[i] == MSG_EXTENDED) { 1281 i += (1 + data->MsgBuffer[i+1]); 1282 } 1283 } 1284 tmpSC->SCp.Message = tmp; 1285 1286 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x len=%d", tmpSC->SCp.Message, data->MsgLen); 1287 show_message(data); 1288 1289 break; 1290 1291 case BUSPHASE_SELECT: 1292 default: 1293 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE other"); 1294 1295 break; 1296 } 1297 1298 //nsp_dbg(NSP_DEBUG_INTR, "out"); 1299 return IRQ_HANDLED; 1300 1301 timer_out: 1302 nsp_start_timer(tmpSC, 1000/102); 1303 return IRQ_HANDLED; 1304 } 1305 1306 #ifdef NSP_DEBUG 1307 #include "nsp_debug.c" 1308 #endif /* NSP_DEBUG */ 1309 1310 /*----------------------------------------------------------------*/ 1311 /* look for ninja3 card and init if found */ 1312 /*----------------------------------------------------------------*/ 1313 static struct Scsi_Host *nsp_detect(struct scsi_host_template *sht) 1314 { 1315 struct Scsi_Host *host; /* registered host structure */ 1316 nsp_hw_data *data_b = &nsp_data_base, *data; 1317 1318 nsp_dbg(NSP_DEBUG_INIT, "this_id=%d", sht->this_id); 1319 host = scsi_host_alloc(&nsp_driver_template, sizeof(nsp_hw_data)); 1320 if (host == NULL) { 1321 nsp_dbg(NSP_DEBUG_INIT, "host failed"); 1322 return NULL; 1323 } 1324 1325 memcpy(host->hostdata, data_b, sizeof(nsp_hw_data)); 1326 data = (nsp_hw_data *)host->hostdata; 1327 data->ScsiInfo->host = host; 1328 #ifdef NSP_DEBUG 1329 data->CmdId = 0; 1330 #endif 1331 1332 nsp_dbg(NSP_DEBUG_INIT, "irq=%d,%d", data_b->IrqNumber, ((nsp_hw_data *)host->hostdata)->IrqNumber); 1333 1334 host->unique_id = data->BaseAddress; 1335 host->io_port = data->BaseAddress; 1336 host->n_io_port = data->NumAddress; 1337 host->irq = data->IrqNumber; 1338 host->base = data->MmioAddress; 1339 1340 spin_lock_init(&(data->Lock)); 1341 1342 snprintf(data->nspinfo, 1343 sizeof(data->nspinfo), 1344 "NinjaSCSI-3/32Bi Driver $Revision: 1.23 $ IO:0x%04lx-0x%04lx MMIO(virt addr):0x%04lx IRQ:%02d", 1345 host->io_port, host->io_port + host->n_io_port - 1, 1346 host->base, 1347 host->irq); 1348 sht->name = data->nspinfo; 1349 1350 nsp_dbg(NSP_DEBUG_INIT, "end"); 1351 1352 1353 return host; /* detect done. */ 1354 } 1355 1356 /*----------------------------------------------------------------*/ 1357 /* return info string */ 1358 /*----------------------------------------------------------------*/ 1359 static const char *nsp_info(struct Scsi_Host *shpnt) 1360 { 1361 nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata; 1362 1363 return data->nspinfo; 1364 } 1365 1366 static int nsp_show_info(struct seq_file *m, struct Scsi_Host *host) 1367 { 1368 int id; 1369 int speed; 1370 unsigned long flags; 1371 nsp_hw_data *data; 1372 int hostno; 1373 1374 hostno = host->host_no; 1375 data = (nsp_hw_data *)host->hostdata; 1376 1377 seq_puts(m, "NinjaSCSI status\n\n" 1378 "Driver version: $Revision: 1.23 $\n"); 1379 seq_printf(m, "SCSI host No.: %d\n", hostno); 1380 seq_printf(m, "IRQ: %d\n", host->irq); 1381 seq_printf(m, "IO: 0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1); 1382 seq_printf(m, "MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1); 1383 seq_printf(m, "sg_tablesize: %d\n", host->sg_tablesize); 1384 1385 seq_puts(m, "burst transfer mode: "); 1386 switch (nsp_burst_mode) { 1387 case BURST_IO8: 1388 seq_puts(m, "io8"); 1389 break; 1390 case BURST_IO32: 1391 seq_puts(m, "io32"); 1392 break; 1393 case BURST_MEM32: 1394 seq_puts(m, "mem32"); 1395 break; 1396 default: 1397 seq_puts(m, "???"); 1398 break; 1399 } 1400 seq_putc(m, '\n'); 1401 1402 1403 spin_lock_irqsave(&(data->Lock), flags); 1404 seq_printf(m, "CurrentSC: 0x%p\n\n", data->CurrentSC); 1405 spin_unlock_irqrestore(&(data->Lock), flags); 1406 1407 seq_puts(m, "SDTR status\n"); 1408 for(id = 0; id < ARRAY_SIZE(data->Sync); id++) { 1409 1410 seq_printf(m, "id %d: ", id); 1411 1412 if (id == host->this_id) { 1413 seq_puts(m, "----- NinjaSCSI-3 host adapter\n"); 1414 continue; 1415 } 1416 1417 switch(data->Sync[id].SyncNegotiation) { 1418 case SYNC_OK: 1419 seq_puts(m, " sync"); 1420 break; 1421 case SYNC_NG: 1422 seq_puts(m, "async"); 1423 break; 1424 case SYNC_NOT_YET: 1425 seq_puts(m, " none"); 1426 break; 1427 default: 1428 seq_puts(m, "?????"); 1429 break; 1430 } 1431 1432 if (data->Sync[id].SyncPeriod != 0) { 1433 speed = 1000000 / (data->Sync[id].SyncPeriod * 4); 1434 1435 seq_printf(m, " transfer %d.%dMB/s, offset %d", 1436 speed / 1000, 1437 speed % 1000, 1438 data->Sync[id].SyncOffset 1439 ); 1440 } 1441 seq_putc(m, '\n'); 1442 } 1443 return 0; 1444 } 1445 1446 /*---------------------------------------------------------------*/ 1447 /* error handler */ 1448 /*---------------------------------------------------------------*/ 1449 1450 /* 1451 static int nsp_eh_abort(struct scsi_cmnd *SCpnt) 1452 { 1453 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt); 1454 1455 return nsp_eh_bus_reset(SCpnt); 1456 }*/ 1457 1458 static int nsp_bus_reset(nsp_hw_data *data) 1459 { 1460 unsigned int base = data->BaseAddress; 1461 int i; 1462 1463 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK); 1464 1465 nsp_index_write(base, SCSIBUSCTRL, SCSI_RST); 1466 mdelay(100); /* 100ms */ 1467 nsp_index_write(base, SCSIBUSCTRL, 0); 1468 for(i = 0; i < 5; i++) { 1469 nsp_index_read(base, IRQPHASESENCE); /* dummy read */ 1470 } 1471 1472 nsphw_init_sync(data); 1473 1474 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR); 1475 1476 return SUCCESS; 1477 } 1478 1479 static int nsp_eh_bus_reset(struct scsi_cmnd *SCpnt) 1480 { 1481 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 1482 1483 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt); 1484 1485 return nsp_bus_reset(data); 1486 } 1487 1488 static int nsp_eh_host_reset(struct scsi_cmnd *SCpnt) 1489 { 1490 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata; 1491 1492 nsp_dbg(NSP_DEBUG_BUSRESET, "in"); 1493 1494 nsphw_init(data); 1495 1496 return SUCCESS; 1497 } 1498 1499 1500 /********************************************************************** 1501 PCMCIA functions 1502 **********************************************************************/ 1503 1504 static int nsp_cs_probe(struct pcmcia_device *link) 1505 { 1506 scsi_info_t *info; 1507 nsp_hw_data *data = &nsp_data_base; 1508 int ret; 1509 1510 nsp_dbg(NSP_DEBUG_INIT, "in"); 1511 1512 /* Create new SCSI device */ 1513 info = kzalloc(sizeof(*info), GFP_KERNEL); 1514 if (info == NULL) { return -ENOMEM; } 1515 info->p_dev = link; 1516 link->priv = info; 1517 data->ScsiInfo = info; 1518 1519 nsp_dbg(NSP_DEBUG_INIT, "info=0x%p", info); 1520 1521 ret = nsp_cs_config(link); 1522 1523 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link); 1524 return ret; 1525 } /* nsp_cs_attach */ 1526 1527 1528 static void nsp_cs_detach(struct pcmcia_device *link) 1529 { 1530 nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link); 1531 1532 ((scsi_info_t *)link->priv)->stop = 1; 1533 nsp_cs_release(link); 1534 1535 kfree(link->priv); 1536 link->priv = NULL; 1537 } /* nsp_cs_detach */ 1538 1539 1540 static int nsp_cs_config_check(struct pcmcia_device *p_dev, void *priv_data) 1541 { 1542 nsp_hw_data *data = priv_data; 1543 1544 if (p_dev->config_index == 0) 1545 return -ENODEV; 1546 1547 /* This reserves IO space but doesn't actually enable it */ 1548 if (pcmcia_request_io(p_dev) != 0) 1549 goto next_entry; 1550 1551 if (resource_size(p_dev->resource[2])) { 1552 p_dev->resource[2]->flags |= (WIN_DATA_WIDTH_16 | 1553 WIN_MEMORY_TYPE_CM | 1554 WIN_ENABLE); 1555 if (p_dev->resource[2]->end < 0x1000) 1556 p_dev->resource[2]->end = 0x1000; 1557 if (pcmcia_request_window(p_dev, p_dev->resource[2], 0) != 0) 1558 goto next_entry; 1559 if (pcmcia_map_mem_page(p_dev, p_dev->resource[2], 1560 p_dev->card_addr) != 0) 1561 goto next_entry; 1562 1563 data->MmioAddress = (unsigned long) 1564 ioremap(p_dev->resource[2]->start, 1565 resource_size(p_dev->resource[2])); 1566 data->MmioLength = resource_size(p_dev->resource[2]); 1567 } 1568 /* If we got this far, we're cool! */ 1569 return 0; 1570 1571 next_entry: 1572 nsp_dbg(NSP_DEBUG_INIT, "next"); 1573 pcmcia_disable_device(p_dev); 1574 return -ENODEV; 1575 } 1576 1577 static int nsp_cs_config(struct pcmcia_device *link) 1578 { 1579 int ret; 1580 scsi_info_t *info = link->priv; 1581 struct Scsi_Host *host; 1582 nsp_hw_data *data = &nsp_data_base; 1583 1584 nsp_dbg(NSP_DEBUG_INIT, "in"); 1585 1586 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_CHECK_VCC | 1587 CONF_AUTO_SET_VPP | CONF_AUTO_AUDIO | CONF_AUTO_SET_IOMEM | 1588 CONF_AUTO_SET_IO; 1589 1590 ret = pcmcia_loop_config(link, nsp_cs_config_check, data); 1591 if (ret) 1592 goto cs_failed; 1593 1594 if (pcmcia_request_irq(link, nspintr)) 1595 goto cs_failed; 1596 1597 ret = pcmcia_enable_device(link); 1598 if (ret) 1599 goto cs_failed; 1600 1601 if (free_ports) { 1602 if (link->resource[0]) { 1603 release_region(link->resource[0]->start, 1604 resource_size(link->resource[0])); 1605 } 1606 if (link->resource[1]) { 1607 release_region(link->resource[1]->start, 1608 resource_size(link->resource[1])); 1609 } 1610 } 1611 1612 /* Set port and IRQ */ 1613 data->BaseAddress = link->resource[0]->start; 1614 data->NumAddress = resource_size(link->resource[0]); 1615 data->IrqNumber = link->irq; 1616 1617 nsp_dbg(NSP_DEBUG_INIT, "I/O[0x%x+0x%x] IRQ %d", 1618 data->BaseAddress, data->NumAddress, data->IrqNumber); 1619 1620 if(nsphw_init(data) == FALSE) { 1621 goto cs_failed; 1622 } 1623 1624 host = nsp_detect(&nsp_driver_template); 1625 1626 if (host == NULL) { 1627 nsp_dbg(NSP_DEBUG_INIT, "detect failed"); 1628 goto cs_failed; 1629 } 1630 1631 1632 ret = scsi_add_host (host, NULL); 1633 if (ret) 1634 goto cs_failed; 1635 1636 scsi_scan_host(host); 1637 1638 info->host = host; 1639 1640 return 0; 1641 1642 cs_failed: 1643 nsp_dbg(NSP_DEBUG_INIT, "config fail"); 1644 nsp_cs_release(link); 1645 1646 return -ENODEV; 1647 } /* nsp_cs_config */ 1648 1649 1650 static void nsp_cs_release(struct pcmcia_device *link) 1651 { 1652 scsi_info_t *info = link->priv; 1653 nsp_hw_data *data = NULL; 1654 1655 if (info->host == NULL) { 1656 nsp_msg(KERN_DEBUG, "unexpected card release call."); 1657 } else { 1658 data = (nsp_hw_data *)info->host->hostdata; 1659 } 1660 1661 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link); 1662 1663 /* Unlink the device chain */ 1664 if (info->host != NULL) { 1665 scsi_remove_host(info->host); 1666 } 1667 1668 if (resource_size(link->resource[2])) { 1669 if (data != NULL) { 1670 iounmap((void *)(data->MmioAddress)); 1671 } 1672 } 1673 pcmcia_disable_device(link); 1674 1675 if (info->host != NULL) { 1676 scsi_host_put(info->host); 1677 } 1678 } /* nsp_cs_release */ 1679 1680 static int nsp_cs_suspend(struct pcmcia_device *link) 1681 { 1682 scsi_info_t *info = link->priv; 1683 nsp_hw_data *data; 1684 1685 nsp_dbg(NSP_DEBUG_INIT, "event: suspend"); 1686 1687 if (info->host != NULL) { 1688 nsp_msg(KERN_INFO, "clear SDTR status"); 1689 1690 data = (nsp_hw_data *)info->host->hostdata; 1691 1692 nsphw_init_sync(data); 1693 } 1694 1695 info->stop = 1; 1696 1697 return 0; 1698 } 1699 1700 static int nsp_cs_resume(struct pcmcia_device *link) 1701 { 1702 scsi_info_t *info = link->priv; 1703 nsp_hw_data *data; 1704 1705 nsp_dbg(NSP_DEBUG_INIT, "event: resume"); 1706 1707 info->stop = 0; 1708 1709 if (info->host != NULL) { 1710 nsp_msg(KERN_INFO, "reset host and bus"); 1711 1712 data = (nsp_hw_data *)info->host->hostdata; 1713 1714 nsphw_init (data); 1715 nsp_bus_reset(data); 1716 } 1717 1718 return 0; 1719 } 1720 1721 /*======================================================================* 1722 * module entry point 1723 *====================================================================*/ 1724 static const struct pcmcia_device_id nsp_cs_ids[] = { 1725 PCMCIA_DEVICE_PROD_ID123("IO DATA", "CBSC16 ", "1", 0x547e66dc, 0x0d63a3fd, 0x51de003a), 1726 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-001", "1", 0x534c02bc, 0x52008408, 0x51de003a), 1727 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-002", "1", 0x534c02bc, 0xcb09d5b2, 0x51de003a), 1728 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-003", "1", 0x534c02bc, 0xbc0ee524, 0x51de003a), 1729 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-004", "1", 0x534c02bc, 0x226a7087, 0x51de003a), 1730 PCMCIA_DEVICE_PROD_ID123("WBT", "NinjaSCSI-3", "R1.0", 0xc7ba805f, 0xfdc7c97d, 0x6973710e), 1731 PCMCIA_DEVICE_PROD_ID123("WORKBIT", "UltraNinja-16", "1", 0x28191418, 0xb70f4b09, 0x51de003a), 1732 PCMCIA_DEVICE_NULL 1733 }; 1734 MODULE_DEVICE_TABLE(pcmcia, nsp_cs_ids); 1735 1736 static struct pcmcia_driver nsp_driver = { 1737 .owner = THIS_MODULE, 1738 .name = "nsp_cs", 1739 .probe = nsp_cs_probe, 1740 .remove = nsp_cs_detach, 1741 .id_table = nsp_cs_ids, 1742 .suspend = nsp_cs_suspend, 1743 .resume = nsp_cs_resume, 1744 }; 1745 module_pcmcia_driver(nsp_driver); 1746 1747 /* end */ 1748