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