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