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