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