1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /************************************************************************** 3 * Initio 9100 device driver for Linux. 4 * 5 * Copyright (c) 1994-1998 Initio Corporation 6 * Copyright (c) 1998 Bas Vermeulen <bvermeul@blackstar.xs4all.nl> 7 * Copyright (c) 2004 Christoph Hellwig <hch@lst.de> 8 * Copyright (c) 2007 Red Hat 9 * 10 ************************************************************************* 11 * 12 * DESCRIPTION: 13 * 14 * This is the Linux low-level SCSI driver for Initio INI-9X00U/UW SCSI host 15 * adapters 16 * 17 * 08/06/97 hc - v1.01h 18 * - Support inic-940 and inic-935 19 * 09/26/97 hc - v1.01i 20 * - Make correction from J.W. Schultz suggestion 21 * 10/13/97 hc - Support reset function 22 * 10/21/97 hc - v1.01j 23 * - Support 32 LUN (SCSI 3) 24 * 01/14/98 hc - v1.01k 25 * - Fix memory allocation problem 26 * 03/04/98 hc - v1.01l 27 * - Fix tape rewind which will hang the system problem 28 * - Set can_queue to initio_num_scb 29 * 06/25/98 hc - v1.01m 30 * - Get it work for kernel version >= 2.1.75 31 * - Dynamic assign SCSI bus reset holding time in initio_init() 32 * 07/02/98 hc - v1.01n 33 * - Support 0002134A 34 * 08/07/98 hc - v1.01o 35 * - Change the initio_abort_srb routine to use scsi_done. <01> 36 * 09/07/98 hl - v1.02 37 * - Change the INI9100U define and proc_dir_entry to 38 * reflect the newer Kernel 2.1.118, but the v1.o1o 39 * should work with Kernel 2.1.118. 40 * 09/20/98 wh - v1.02a 41 * - Support Abort command. 42 * - Handle reset routine. 43 * 09/21/98 hl - v1.03 44 * - remove comments. 45 * 12/09/98 bv - v1.03a 46 * - Removed unused code 47 * 12/13/98 bv - v1.03b 48 * - Remove cli() locking for kernels >= 2.1.95. This uses 49 * spinlocks to serialize access to the pSRB_head and 50 * pSRB_tail members of the HCS structure. 51 * 09/01/99 bv - v1.03d 52 * - Fixed a deadlock problem in SMP. 53 * 21/01/99 bv - v1.03e 54 * - Add support for the Domex 3192U PCI SCSI 55 * This is a slightly modified patch by 56 * Brian Macy <bmacy@sunshinecomputing.com> 57 * 22/02/99 bv - v1.03f 58 * - Didn't detect the INIC-950 in 2.0.x correctly. 59 * Now fixed. 60 * 05/07/99 bv - v1.03g 61 * - Changed the assumption that HZ = 100 62 * 10/17/03 mc - v1.04 63 * - added new DMA API support 64 * 06/01/04 jmd - v1.04a 65 * - Re-add reset_bus support 66 **************************************************************************/ 67 68 #include <linux/module.h> 69 #include <linux/errno.h> 70 #include <linux/delay.h> 71 #include <linux/pci.h> 72 #include <linux/init.h> 73 #include <linux/blkdev.h> 74 #include <linux/spinlock.h> 75 #include <linux/stat.h> 76 #include <linux/kernel.h> 77 #include <linux/proc_fs.h> 78 #include <linux/string.h> 79 #include <linux/interrupt.h> 80 #include <linux/ioport.h> 81 #include <linux/slab.h> 82 #include <linux/jiffies.h> 83 #include <linux/dma-mapping.h> 84 #include <asm/io.h> 85 86 #include <scsi/scsi.h> 87 #include <scsi/scsi_cmnd.h> 88 #include <scsi/scsi_device.h> 89 #include <scsi/scsi_host.h> 90 #include <scsi/scsi_tcq.h> 91 92 #include "initio.h" 93 94 #define SENSE_SIZE 14 95 96 #define i91u_MAXQUEUE 2 97 #define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.04a" 98 99 #ifdef DEBUG_i91u 100 static unsigned int i91u_debug = DEBUG_DEFAULT; 101 #endif 102 103 static int initio_tag_enable = 1; 104 105 #ifdef DEBUG_i91u 106 static int setup_debug = 0; 107 #endif 108 109 static void i91uSCBPost(u8 * pHcb, u8 * pScb); 110 111 #define DEBUG_INTERRUPT 0 112 #define DEBUG_QUEUE 0 113 #define DEBUG_STATE 0 114 #define INT_DISC 0 115 116 /*--- forward references ---*/ 117 static struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun); 118 static struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host); 119 120 static int tulip_main(struct initio_host * host); 121 122 static int initio_next_state(struct initio_host * host); 123 static int initio_state_1(struct initio_host * host); 124 static int initio_state_2(struct initio_host * host); 125 static int initio_state_3(struct initio_host * host); 126 static int initio_state_4(struct initio_host * host); 127 static int initio_state_5(struct initio_host * host); 128 static int initio_state_6(struct initio_host * host); 129 static int initio_state_7(struct initio_host * host); 130 static int initio_xfer_data_in(struct initio_host * host); 131 static int initio_xfer_data_out(struct initio_host * host); 132 static int initio_xpad_in(struct initio_host * host); 133 static int initio_xpad_out(struct initio_host * host); 134 static int initio_status_msg(struct initio_host * host); 135 136 static int initio_msgin(struct initio_host * host); 137 static int initio_msgin_sync(struct initio_host * host); 138 static int initio_msgin_accept(struct initio_host * host); 139 static int initio_msgout_reject(struct initio_host * host); 140 static int initio_msgin_extend(struct initio_host * host); 141 142 static int initio_msgout_ide(struct initio_host * host); 143 static int initio_msgout_abort_targ(struct initio_host * host); 144 static int initio_msgout_abort_tag(struct initio_host * host); 145 146 static int initio_bus_device_reset(struct initio_host * host); 147 static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb); 148 static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb); 149 static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb); 150 static int int_initio_busfree(struct initio_host * host); 151 static int int_initio_scsi_rst(struct initio_host * host); 152 static int int_initio_bad_seq(struct initio_host * host); 153 static int int_initio_resel(struct initio_host * host); 154 static int initio_sync_done(struct initio_host * host); 155 static int wdtr_done(struct initio_host * host); 156 static int wait_tulip(struct initio_host * host); 157 static int initio_wait_done_disc(struct initio_host * host); 158 static int initio_wait_disc(struct initio_host * host); 159 static void tulip_scsi(struct initio_host * host); 160 static int initio_post_scsi_rst(struct initio_host * host); 161 162 static void initio_se2_ew_en(unsigned long base); 163 static void initio_se2_ew_ds(unsigned long base); 164 static int initio_se2_rd_all(unsigned long base); 165 static void initio_se2_update_all(unsigned long base); /* setup default pattern */ 166 static void initio_read_eeprom(unsigned long base); 167 168 /* ---- INTERNAL VARIABLES ---- */ 169 170 static NVRAM i91unvram; 171 static NVRAM *i91unvramp; 172 173 static u8 i91udftNvRam[64] = 174 { 175 /*----------- header -----------*/ 176 0x25, 0xc9, /* Signature */ 177 0x40, /* Size */ 178 0x01, /* Revision */ 179 /* -- Host Adapter Structure -- */ 180 0x95, /* ModelByte0 */ 181 0x00, /* ModelByte1 */ 182 0x00, /* ModelInfo */ 183 0x01, /* NumOfCh */ 184 NBC1_DEFAULT, /* BIOSConfig1 */ 185 0, /* BIOSConfig2 */ 186 0, /* HAConfig1 */ 187 0, /* HAConfig2 */ 188 /* SCSI channel 0 and target Structure */ 189 7, /* SCSIid */ 190 NCC1_DEFAULT, /* SCSIconfig1 */ 191 0, /* SCSIconfig2 */ 192 0x10, /* NumSCSItarget */ 193 194 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 195 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 196 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 197 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 198 199 /* SCSI channel 1 and target Structure */ 200 7, /* SCSIid */ 201 NCC1_DEFAULT, /* SCSIconfig1 */ 202 0, /* SCSIconfig2 */ 203 0x10, /* NumSCSItarget */ 204 205 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 206 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 207 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 208 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, 209 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 210 0, 0}; /* - CheckSum - */ 211 212 213 static u8 initio_rate_tbl[8] = /* fast 20 */ 214 { 215 /* nanosecond divide by 4 */ 216 12, /* 50ns, 20M */ 217 18, /* 75ns, 13.3M */ 218 25, /* 100ns, 10M */ 219 31, /* 125ns, 8M */ 220 37, /* 150ns, 6.6M */ 221 43, /* 175ns, 5.7M */ 222 50, /* 200ns, 5M */ 223 62 /* 250ns, 4M */ 224 }; 225 226 static void initio_do_pause(unsigned amount) 227 { 228 /* Pause for amount jiffies */ 229 unsigned long the_time = jiffies + amount; 230 231 while (time_before_eq(jiffies, the_time)) 232 cpu_relax(); 233 } 234 235 /*-- forward reference --*/ 236 237 /****************************************************************** 238 Input: instruction for Serial E2PROM 239 240 EX: se2_rd(0 call se2_instr() to send address and read command 241 242 StartBit OP_Code Address Data 243 --------- -------- ------------------ ------- 244 1 1 , 0 A5,A4,A3,A2,A1,A0 D15-D0 245 246 +----------------------------------------------------- 247 | 248 CS -----+ 249 +--+ +--+ +--+ +--+ +--+ 250 ^ | ^ | ^ | ^ | ^ | 251 | | | | | | | | | | 252 CLK -------+ +--+ +--+ +--+ +--+ +-- 253 (leading edge trigger) 254 255 +--1-----1--+ 256 | SB OP | OP A5 A4 257 DI ----+ +--0------------------ 258 (address and cmd sent to nvram) 259 260 -------------------------------------------+ 261 | 262 DO +--- 263 (data sent from nvram) 264 265 266 ******************************************************************/ 267 268 /** 269 * initio_se2_instr - bitbang an instruction 270 * @base: Base of InitIO controller 271 * @instr: Instruction for serial E2PROM 272 * 273 * Bitbang an instruction out to the serial E2Prom 274 */ 275 276 static void initio_se2_instr(unsigned long base, u8 instr) 277 { 278 int i; 279 u8 b; 280 281 outb(SE2CS | SE2DO, base + TUL_NVRAM); /* cs+start bit */ 282 udelay(30); 283 outb(SE2CS | SE2CLK | SE2DO, base + TUL_NVRAM); /* +CLK */ 284 udelay(30); 285 286 for (i = 0; i < 8; i++) { 287 if (instr & 0x80) 288 b = SE2CS | SE2DO; /* -CLK+dataBit */ 289 else 290 b = SE2CS; /* -CLK */ 291 outb(b, base + TUL_NVRAM); 292 udelay(30); 293 outb(b | SE2CLK, base + TUL_NVRAM); /* +CLK */ 294 udelay(30); 295 instr <<= 1; 296 } 297 outb(SE2CS, base + TUL_NVRAM); /* -CLK */ 298 udelay(30); 299 } 300 301 302 /** 303 * initio_se2_ew_en - Enable erase/write 304 * @base: Base address of InitIO controller 305 * 306 * Enable erase/write state of serial EEPROM 307 */ 308 void initio_se2_ew_en(unsigned long base) 309 { 310 initio_se2_instr(base, 0x30); /* EWEN */ 311 outb(0, base + TUL_NVRAM); /* -CS */ 312 udelay(30); 313 } 314 315 316 /** 317 * initio_se2_ew_ds - Disable erase/write 318 * @base: Base address of InitIO controller 319 * 320 * Disable erase/write state of serial EEPROM 321 */ 322 void initio_se2_ew_ds(unsigned long base) 323 { 324 initio_se2_instr(base, 0); /* EWDS */ 325 outb(0, base + TUL_NVRAM); /* -CS */ 326 udelay(30); 327 } 328 329 330 /** 331 * initio_se2_rd - read E2PROM word 332 * @base: Base of InitIO controller 333 * @addr: Address of word in E2PROM 334 * 335 * Read a word from the NV E2PROM device 336 */ 337 static u16 initio_se2_rd(unsigned long base, u8 addr) 338 { 339 u8 instr, rb; 340 u16 val = 0; 341 int i; 342 343 instr = (u8) (addr | 0x80); 344 initio_se2_instr(base, instr); /* READ INSTR */ 345 346 for (i = 15; i >= 0; i--) { 347 outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */ 348 udelay(30); 349 outb(SE2CS, base + TUL_NVRAM); /* -CLK */ 350 351 /* sample data after the following edge of clock */ 352 rb = inb(base + TUL_NVRAM); 353 rb &= SE2DI; 354 val += (rb << i); 355 udelay(30); /* 6/20/95 */ 356 } 357 358 outb(0, base + TUL_NVRAM); /* no chip select */ 359 udelay(30); 360 return val; 361 } 362 363 /** 364 * initio_se2_wr - read E2PROM word 365 * @base: Base of InitIO controller 366 * @addr: Address of word in E2PROM 367 * @val: Value to write 368 * 369 * Write a word to the NV E2PROM device. Used when recovering from 370 * a problem with the NV. 371 */ 372 static void initio_se2_wr(unsigned long base, u8 addr, u16 val) 373 { 374 u8 rb; 375 u8 instr; 376 int i; 377 378 instr = (u8) (addr | 0x40); 379 initio_se2_instr(base, instr); /* WRITE INSTR */ 380 for (i = 15; i >= 0; i--) { 381 if (val & 0x8000) 382 outb(SE2CS | SE2DO, base + TUL_NVRAM); /* -CLK+dataBit 1 */ 383 else 384 outb(SE2CS, base + TUL_NVRAM); /* -CLK+dataBit 0 */ 385 udelay(30); 386 outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */ 387 udelay(30); 388 val <<= 1; 389 } 390 outb(SE2CS, base + TUL_NVRAM); /* -CLK */ 391 udelay(30); 392 outb(0, base + TUL_NVRAM); /* -CS */ 393 udelay(30); 394 395 outb(SE2CS, base + TUL_NVRAM); /* +CS */ 396 udelay(30); 397 398 for (;;) { 399 outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */ 400 udelay(30); 401 outb(SE2CS, base + TUL_NVRAM); /* -CLK */ 402 udelay(30); 403 if ((rb = inb(base + TUL_NVRAM)) & SE2DI) 404 break; /* write complete */ 405 } 406 outb(0, base + TUL_NVRAM); /* -CS */ 407 } 408 409 /** 410 * initio_se2_rd_all - read hostadapter NV configuration 411 * @base: Base address of InitIO controller 412 * 413 * Reads the E2PROM data into main memory. Ensures that the checksum 414 * and header marker are valid. Returns 1 on success -1 on error. 415 */ 416 417 static int initio_se2_rd_all(unsigned long base) 418 { 419 int i; 420 u16 chksum = 0; 421 u16 *np; 422 423 i91unvramp = &i91unvram; 424 np = (u16 *) i91unvramp; 425 for (i = 0; i < 32; i++) 426 *np++ = initio_se2_rd(base, i); 427 428 /* Is signature "ini" ok ? */ 429 if (i91unvramp->NVM_Signature != INI_SIGNATURE) 430 return -1; 431 /* Is ckecksum ok ? */ 432 np = (u16 *) i91unvramp; 433 for (i = 0; i < 31; i++) 434 chksum += *np++; 435 if (i91unvramp->NVM_CheckSum != chksum) 436 return -1; 437 return 1; 438 } 439 440 /** 441 * initio_se2_update_all - Update E2PROM 442 * @base: Base of InitIO controller 443 * 444 * Update the E2PROM by wrting any changes into the E2PROM 445 * chip, rewriting the checksum. 446 */ 447 static void initio_se2_update_all(unsigned long base) 448 { /* setup default pattern */ 449 int i; 450 u16 chksum = 0; 451 u16 *np, *np1; 452 453 i91unvramp = &i91unvram; 454 /* Calculate checksum first */ 455 np = (u16 *) i91udftNvRam; 456 for (i = 0; i < 31; i++) 457 chksum += *np++; 458 *np = chksum; 459 initio_se2_ew_en(base); /* Enable write */ 460 461 np = (u16 *) i91udftNvRam; 462 np1 = (u16 *) i91unvramp; 463 for (i = 0; i < 32; i++, np++, np1++) { 464 if (*np != *np1) 465 initio_se2_wr(base, i, *np); 466 } 467 initio_se2_ew_ds(base); /* Disable write */ 468 } 469 470 /** 471 * initio_read_eeprom - Retrieve configuration 472 * @base: Base of InitIO Host Adapter 473 * 474 * Retrieve the host adapter configuration data from E2Prom. If the 475 * data is invalid then the defaults are used and are also restored 476 * into the E2PROM. This forms the access point for the SCSI driver 477 * into the E2PROM layer, the other functions for the E2PROM are all 478 * internal use. 479 * 480 * Must be called single threaded, uses a shared global area. 481 */ 482 483 static void initio_read_eeprom(unsigned long base) 484 { 485 u8 gctrl; 486 487 i91unvramp = &i91unvram; 488 /* Enable EEProm programming */ 489 gctrl = inb(base + TUL_GCTRL); 490 outb(gctrl | TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL); 491 if (initio_se2_rd_all(base) != 1) { 492 initio_se2_update_all(base); /* setup default pattern */ 493 initio_se2_rd_all(base); /* load again */ 494 } 495 /* Disable EEProm programming */ 496 gctrl = inb(base + TUL_GCTRL); 497 outb(gctrl & ~TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL); 498 } 499 500 /** 501 * initio_stop_bm - stop bus master 502 * @host: InitIO we are stopping 503 * 504 * Stop any pending DMA operation, aborting the DMA if necessary 505 */ 506 507 static void initio_stop_bm(struct initio_host * host) 508 { 509 510 if (inb(host->addr + TUL_XStatus) & XPEND) { /* if DMA xfer is pending, abort DMA xfer */ 511 outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd); 512 /* wait Abort DMA xfer done */ 513 while ((inb(host->addr + TUL_Int) & XABT) == 0) 514 cpu_relax(); 515 } 516 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 517 } 518 519 /** 520 * initio_reset_scsi - Reset SCSI host controller 521 * @host: InitIO host to reset 522 * @seconds: Recovery time 523 * 524 * Perform a full reset of the SCSI subsystem. 525 */ 526 527 static int initio_reset_scsi(struct initio_host * host, int seconds) 528 { 529 outb(TSC_RST_BUS, host->addr + TUL_SCtrl0); 530 531 while (!((host->jsint = inb(host->addr + TUL_SInt)) & TSS_SCSIRST_INT)) 532 cpu_relax(); 533 534 /* reset tulip chip */ 535 outb(0, host->addr + TUL_SSignal); 536 537 /* Stall for a while, wait for target's firmware ready,make it 2 sec ! */ 538 /* SONY 5200 tape drive won't work if only stall for 1 sec */ 539 /* FIXME: this is a very long busy wait right now */ 540 initio_do_pause(seconds * HZ); 541 542 inb(host->addr + TUL_SInt); 543 return SCSI_RESET_SUCCESS; 544 } 545 546 /** 547 * initio_init - set up an InitIO host adapter 548 * @host: InitIO host adapter 549 * @bios_addr: BIOS address 550 * 551 * Set up the host adapter and devices according to the configuration 552 * retrieved from the E2PROM. 553 * 554 * Locking: Calls E2PROM layer code which is not re-enterable so must 555 * run single threaded for now. 556 */ 557 558 static void initio_init(struct initio_host * host, u8 *bios_addr) 559 { 560 int i; 561 u8 *flags; 562 u8 *heads; 563 564 /* Get E2Prom configuration */ 565 initio_read_eeprom(host->addr); 566 if (i91unvramp->NVM_SCSIInfo[0].NVM_NumOfTarg == 8) 567 host->max_tar = 8; 568 else 569 host->max_tar = 16; 570 571 host->config = i91unvramp->NVM_SCSIInfo[0].NVM_ChConfig1; 572 573 host->scsi_id = i91unvramp->NVM_SCSIInfo[0].NVM_ChSCSIID; 574 host->idmask = ~(1 << host->scsi_id); 575 576 #ifdef CHK_PARITY 577 /* Enable parity error response */ 578 outb(inb(host->addr + TUL_PCMD) | 0x40, host->addr + TUL_PCMD); 579 #endif 580 581 /* Mask all the interrupt */ 582 outb(0x1F, host->addr + TUL_Mask); 583 584 initio_stop_bm(host); 585 /* --- Initialize the tulip --- */ 586 outb(TSC_RST_CHIP, host->addr + TUL_SCtrl0); 587 588 /* program HBA's SCSI ID */ 589 outb(host->scsi_id << 4, host->addr + TUL_SScsiId); 590 591 /* Enable Initiator Mode ,phase latch,alternate sync period mode, 592 disable SCSI reset */ 593 if (host->config & HCC_EN_PAR) 594 host->sconf1 = (TSC_INITDEFAULT | TSC_EN_SCSI_PAR); 595 else 596 host->sconf1 = (TSC_INITDEFAULT); 597 outb(host->sconf1, host->addr + TUL_SConfig); 598 599 /* Enable HW reselect */ 600 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); 601 602 outb(0, host->addr + TUL_SPeriod); 603 604 /* selection time out = 250 ms */ 605 outb(153, host->addr + TUL_STimeOut); 606 607 /* Enable SCSI terminator */ 608 outb((host->config & (HCC_ACT_TERM1 | HCC_ACT_TERM2)), 609 host->addr + TUL_XCtrl); 610 outb(((host->config & HCC_AUTO_TERM) >> 4) | 611 (inb(host->addr + TUL_GCTRL1) & 0xFE), 612 host->addr + TUL_GCTRL1); 613 614 for (i = 0, 615 flags = & (i91unvramp->NVM_SCSIInfo[0].NVM_Targ0Config), 616 heads = bios_addr + 0x180; 617 i < host->max_tar; 618 i++, flags++) { 619 host->targets[i].flags = *flags & ~(TCF_SYNC_DONE | TCF_WDTR_DONE); 620 if (host->targets[i].flags & TCF_EN_255) 621 host->targets[i].drv_flags = TCF_DRV_255_63; 622 else 623 host->targets[i].drv_flags = 0; 624 host->targets[i].js_period = 0; 625 host->targets[i].sconfig0 = host->sconf1; 626 host->targets[i].heads = *heads++; 627 if (host->targets[i].heads == 255) 628 host->targets[i].drv_flags = TCF_DRV_255_63; 629 else 630 host->targets[i].drv_flags = 0; 631 host->targets[i].sectors = *heads++; 632 host->targets[i].flags &= ~TCF_BUSY; 633 host->act_tags[i] = 0; 634 host->max_tags[i] = 0xFF; 635 } /* for */ 636 printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n", 637 host->addr, host->pci_dev->irq, 638 host->bios_addr, host->scsi_id); 639 /* Reset SCSI Bus */ 640 if (host->config & HCC_SCSI_RESET) { 641 printk(KERN_INFO "i91u: Reset SCSI Bus ... \n"); 642 initio_reset_scsi(host, 10); 643 } 644 outb(0x17, host->addr + TUL_SCFG1); 645 outb(0xE9, host->addr + TUL_SIntEnable); 646 } 647 648 /** 649 * initio_alloc_scb - Allocate an SCB 650 * @host: InitIO host we are allocating for 651 * 652 * Walk the SCB list for the controller and allocate a free SCB if 653 * one exists. 654 */ 655 static struct scsi_ctrl_blk *initio_alloc_scb(struct initio_host *host) 656 { 657 struct scsi_ctrl_blk *scb; 658 unsigned long flags; 659 660 spin_lock_irqsave(&host->avail_lock, flags); 661 if ((scb = host->first_avail) != NULL) { 662 #if DEBUG_QUEUE 663 printk("find scb at %p\n", scb); 664 #endif 665 if ((host->first_avail = scb->next) == NULL) 666 host->last_avail = NULL; 667 scb->next = NULL; 668 scb->status = SCB_RENT; 669 } 670 spin_unlock_irqrestore(&host->avail_lock, flags); 671 return scb; 672 } 673 674 /** 675 * initio_release_scb - Release an SCB 676 * @host: InitIO host that owns the SCB 677 * @cmnd: SCB command block being returned 678 * 679 * Return an allocated SCB to the host free list 680 */ 681 682 static void initio_release_scb(struct initio_host * host, struct scsi_ctrl_blk * cmnd) 683 { 684 unsigned long flags; 685 686 #if DEBUG_QUEUE 687 printk("Release SCB %p; ", cmnd); 688 #endif 689 spin_lock_irqsave(&(host->avail_lock), flags); 690 cmnd->srb = NULL; 691 cmnd->status = 0; 692 cmnd->next = NULL; 693 if (host->last_avail != NULL) { 694 host->last_avail->next = cmnd; 695 host->last_avail = cmnd; 696 } else { 697 host->first_avail = cmnd; 698 host->last_avail = cmnd; 699 } 700 spin_unlock_irqrestore(&(host->avail_lock), flags); 701 } 702 703 /***************************************************************************/ 704 static void initio_append_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) 705 { 706 707 #if DEBUG_QUEUE 708 printk("Append pend SCB %p; ", scbp); 709 #endif 710 scbp->status = SCB_PEND; 711 scbp->next = NULL; 712 if (host->last_pending != NULL) { 713 host->last_pending->next = scbp; 714 host->last_pending = scbp; 715 } else { 716 host->first_pending = scbp; 717 host->last_pending = scbp; 718 } 719 } 720 721 /***************************************************************************/ 722 static void initio_push_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) 723 { 724 725 #if DEBUG_QUEUE 726 printk("Push pend SCB %p; ", scbp); 727 #endif 728 scbp->status = SCB_PEND; 729 if ((scbp->next = host->first_pending) != NULL) { 730 host->first_pending = scbp; 731 } else { 732 host->first_pending = scbp; 733 host->last_pending = scbp; 734 } 735 } 736 737 static struct scsi_ctrl_blk *initio_find_first_pend_scb(struct initio_host * host) 738 { 739 struct scsi_ctrl_blk *first; 740 741 742 first = host->first_pending; 743 while (first != NULL) { 744 if (first->opcode != ExecSCSI) 745 return first; 746 if (first->tagmsg == 0) { 747 if ((host->act_tags[first->target] == 0) && 748 !(host->targets[first->target].flags & TCF_BUSY)) 749 return first; 750 } else { 751 if ((host->act_tags[first->target] >= 752 host->max_tags[first->target]) | 753 (host->targets[first->target].flags & TCF_BUSY)) { 754 first = first->next; 755 continue; 756 } 757 return first; 758 } 759 first = first->next; 760 } 761 return first; 762 } 763 764 static void initio_unlink_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scb) 765 { 766 struct scsi_ctrl_blk *tmp, *prev; 767 768 #if DEBUG_QUEUE 769 printk("unlink pend SCB %p; ", scb); 770 #endif 771 772 prev = tmp = host->first_pending; 773 while (tmp != NULL) { 774 if (scb == tmp) { /* Unlink this SCB */ 775 if (tmp == host->first_pending) { 776 if ((host->first_pending = tmp->next) == NULL) 777 host->last_pending = NULL; 778 } else { 779 prev->next = tmp->next; 780 if (tmp == host->last_pending) 781 host->last_pending = prev; 782 } 783 tmp->next = NULL; 784 break; 785 } 786 prev = tmp; 787 tmp = tmp->next; 788 } 789 } 790 791 static void initio_append_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) 792 { 793 794 #if DEBUG_QUEUE 795 printk("append busy SCB %p; ", scbp); 796 #endif 797 if (scbp->tagmsg) 798 host->act_tags[scbp->target]++; 799 else 800 host->targets[scbp->target].flags |= TCF_BUSY; 801 scbp->status = SCB_BUSY; 802 scbp->next = NULL; 803 if (host->last_busy != NULL) { 804 host->last_busy->next = scbp; 805 host->last_busy = scbp; 806 } else { 807 host->first_busy = scbp; 808 host->last_busy = scbp; 809 } 810 } 811 812 /***************************************************************************/ 813 static struct scsi_ctrl_blk *initio_pop_busy_scb(struct initio_host * host) 814 { 815 struct scsi_ctrl_blk *tmp; 816 817 818 if ((tmp = host->first_busy) != NULL) { 819 if ((host->first_busy = tmp->next) == NULL) 820 host->last_busy = NULL; 821 tmp->next = NULL; 822 if (tmp->tagmsg) 823 host->act_tags[tmp->target]--; 824 else 825 host->targets[tmp->target].flags &= ~TCF_BUSY; 826 } 827 #if DEBUG_QUEUE 828 printk("Pop busy SCB %p; ", tmp); 829 #endif 830 return tmp; 831 } 832 833 /***************************************************************************/ 834 static void initio_unlink_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scb) 835 { 836 struct scsi_ctrl_blk *tmp, *prev; 837 838 #if DEBUG_QUEUE 839 printk("unlink busy SCB %p; ", scb); 840 #endif 841 842 prev = tmp = host->first_busy; 843 while (tmp != NULL) { 844 if (scb == tmp) { /* Unlink this SCB */ 845 if (tmp == host->first_busy) { 846 if ((host->first_busy = tmp->next) == NULL) 847 host->last_busy = NULL; 848 } else { 849 prev->next = tmp->next; 850 if (tmp == host->last_busy) 851 host->last_busy = prev; 852 } 853 tmp->next = NULL; 854 if (tmp->tagmsg) 855 host->act_tags[tmp->target]--; 856 else 857 host->targets[tmp->target].flags &= ~TCF_BUSY; 858 break; 859 } 860 prev = tmp; 861 tmp = tmp->next; 862 } 863 return; 864 } 865 866 struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun) 867 { 868 struct scsi_ctrl_blk *tmp; 869 u16 scbp_tarlun; 870 871 872 tmp = host->first_busy; 873 while (tmp != NULL) { 874 scbp_tarlun = (tmp->lun << 8) | (tmp->target); 875 if (scbp_tarlun == tarlun) { /* Unlink this SCB */ 876 break; 877 } 878 tmp = tmp->next; 879 } 880 #if DEBUG_QUEUE 881 printk("find busy SCB %p; ", tmp); 882 #endif 883 return tmp; 884 } 885 886 static void initio_append_done_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp) 887 { 888 #if DEBUG_QUEUE 889 printk("append done SCB %p; ", scbp); 890 #endif 891 892 scbp->status = SCB_DONE; 893 scbp->next = NULL; 894 if (host->last_done != NULL) { 895 host->last_done->next = scbp; 896 host->last_done = scbp; 897 } else { 898 host->first_done = scbp; 899 host->last_done = scbp; 900 } 901 } 902 903 struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host) 904 { 905 struct scsi_ctrl_blk *tmp; 906 907 if ((tmp = host->first_done) != NULL) { 908 if ((host->first_done = tmp->next) == NULL) 909 host->last_done = NULL; 910 tmp->next = NULL; 911 } 912 #if DEBUG_QUEUE 913 printk("find done SCB %p; ",tmp); 914 #endif 915 return tmp; 916 } 917 918 static int initio_abort_srb(struct initio_host * host, struct scsi_cmnd *srbp) 919 { 920 unsigned long flags; 921 struct scsi_ctrl_blk *tmp, *prev; 922 923 spin_lock_irqsave(&host->semaph_lock, flags); 924 925 if ((host->semaph == 0) && (host->active == NULL)) { 926 /* disable Jasmin SCSI Int */ 927 outb(0x1F, host->addr + TUL_Mask); 928 spin_unlock_irqrestore(&host->semaph_lock, flags); 929 /* FIXME: synchronize_irq needed ? */ 930 tulip_main(host); 931 spin_lock_irqsave(&host->semaph_lock, flags); 932 host->semaph = 1; 933 outb(0x0F, host->addr + TUL_Mask); 934 spin_unlock_irqrestore(&host->semaph_lock, flags); 935 return SCSI_ABORT_SNOOZE; 936 } 937 prev = tmp = host->first_pending; /* Check Pend queue */ 938 while (tmp != NULL) { 939 /* 07/27/98 */ 940 if (tmp->srb == srbp) { 941 if (tmp == host->active) { 942 spin_unlock_irqrestore(&host->semaph_lock, flags); 943 return SCSI_ABORT_BUSY; 944 } else if (tmp == host->first_pending) { 945 if ((host->first_pending = tmp->next) == NULL) 946 host->last_pending = NULL; 947 } else { 948 prev->next = tmp->next; 949 if (tmp == host->last_pending) 950 host->last_pending = prev; 951 } 952 tmp->hastat = HOST_ABORTED; 953 tmp->flags |= SCF_DONE; 954 if (tmp->flags & SCF_POST) 955 (*tmp->post) ((u8 *) host, (u8 *) tmp); 956 spin_unlock_irqrestore(&host->semaph_lock, flags); 957 return SCSI_ABORT_SUCCESS; 958 } 959 prev = tmp; 960 tmp = tmp->next; 961 } 962 963 prev = tmp = host->first_busy; /* Check Busy queue */ 964 while (tmp != NULL) { 965 if (tmp->srb == srbp) { 966 if (tmp == host->active) { 967 spin_unlock_irqrestore(&host->semaph_lock, flags); 968 return SCSI_ABORT_BUSY; 969 } else if (tmp->tagmsg == 0) { 970 spin_unlock_irqrestore(&host->semaph_lock, flags); 971 return SCSI_ABORT_BUSY; 972 } else { 973 host->act_tags[tmp->target]--; 974 if (tmp == host->first_busy) { 975 if ((host->first_busy = tmp->next) == NULL) 976 host->last_busy = NULL; 977 } else { 978 prev->next = tmp->next; 979 if (tmp == host->last_busy) 980 host->last_busy = prev; 981 } 982 tmp->next = NULL; 983 984 985 tmp->hastat = HOST_ABORTED; 986 tmp->flags |= SCF_DONE; 987 if (tmp->flags & SCF_POST) 988 (*tmp->post) ((u8 *) host, (u8 *) tmp); 989 spin_unlock_irqrestore(&host->semaph_lock, flags); 990 return SCSI_ABORT_SUCCESS; 991 } 992 } 993 prev = tmp; 994 tmp = tmp->next; 995 } 996 spin_unlock_irqrestore(&host->semaph_lock, flags); 997 return SCSI_ABORT_NOT_RUNNING; 998 } 999 1000 /***************************************************************************/ 1001 static int initio_bad_seq(struct initio_host * host) 1002 { 1003 struct scsi_ctrl_blk *scb; 1004 1005 printk("initio_bad_seg c=%d\n", host->index); 1006 1007 if ((scb = host->active) != NULL) { 1008 initio_unlink_busy_scb(host, scb); 1009 scb->hastat = HOST_BAD_PHAS; 1010 scb->tastat = 0; 1011 initio_append_done_scb(host, scb); 1012 } 1013 initio_stop_bm(host); 1014 initio_reset_scsi(host, 8); /* 7/29/98 */ 1015 return initio_post_scsi_rst(host); 1016 } 1017 1018 1019 /************************************************************************/ 1020 static void initio_exec_scb(struct initio_host * host, struct scsi_ctrl_blk * scb) 1021 { 1022 unsigned long flags; 1023 1024 scb->mode = 0; 1025 1026 scb->sgidx = 0; 1027 scb->sgmax = scb->sglen; 1028 1029 spin_lock_irqsave(&host->semaph_lock, flags); 1030 1031 initio_append_pend_scb(host, scb); /* Append this SCB to Pending queue */ 1032 1033 /* VVVVV 07/21/98 */ 1034 if (host->semaph == 1) { 1035 /* Disable Jasmin SCSI Int */ 1036 outb(0x1F, host->addr + TUL_Mask); 1037 host->semaph = 0; 1038 spin_unlock_irqrestore(&host->semaph_lock, flags); 1039 1040 tulip_main(host); 1041 1042 spin_lock_irqsave(&host->semaph_lock, flags); 1043 host->semaph = 1; 1044 outb(0x0F, host->addr + TUL_Mask); 1045 } 1046 spin_unlock_irqrestore(&host->semaph_lock, flags); 1047 return; 1048 } 1049 1050 /***************************************************************************/ 1051 static int initio_isr(struct initio_host * host) 1052 { 1053 if (inb(host->addr + TUL_Int) & TSS_INT_PENDING) { 1054 if (host->semaph == 1) { 1055 outb(0x1F, host->addr + TUL_Mask); 1056 /* Disable Tulip SCSI Int */ 1057 host->semaph = 0; 1058 1059 tulip_main(host); 1060 1061 host->semaph = 1; 1062 outb(0x0F, host->addr + TUL_Mask); 1063 return 1; 1064 } 1065 } 1066 return 0; 1067 } 1068 1069 static int tulip_main(struct initio_host * host) 1070 { 1071 struct scsi_ctrl_blk *scb; 1072 1073 for (;;) { 1074 tulip_scsi(host); /* Call tulip_scsi */ 1075 1076 /* Walk the list of completed SCBs */ 1077 while ((scb = initio_find_done_scb(host)) != NULL) { /* find done entry */ 1078 if (scb->tastat == INI_QUEUE_FULL) { 1079 host->max_tags[scb->target] = 1080 host->act_tags[scb->target] - 1; 1081 scb->tastat = 0; 1082 initio_append_pend_scb(host, scb); 1083 continue; 1084 } 1085 if (!(scb->mode & SCM_RSENS)) { /* not in auto req. sense mode */ 1086 if (scb->tastat == 2) { 1087 1088 /* clr sync. nego flag */ 1089 1090 if (scb->flags & SCF_SENSE) { 1091 u8 len; 1092 len = scb->senselen; 1093 if (len == 0) 1094 len = 1; 1095 scb->buflen = scb->senselen; 1096 scb->bufptr = scb->senseptr; 1097 scb->flags &= ~(SCF_SG | SCF_DIR); /* for xfer_data_in */ 1098 /* so, we won't report wrong direction in xfer_data_in, 1099 and won't report HOST_DO_DU in state_6 */ 1100 scb->mode = SCM_RSENS; 1101 scb->ident &= 0xBF; /* Disable Disconnect */ 1102 scb->tagmsg = 0; 1103 scb->tastat = 0; 1104 scb->cdblen = 6; 1105 scb->cdb[0] = SCSICMD_RequestSense; 1106 scb->cdb[1] = 0; 1107 scb->cdb[2] = 0; 1108 scb->cdb[3] = 0; 1109 scb->cdb[4] = len; 1110 scb->cdb[5] = 0; 1111 initio_push_pend_scb(host, scb); 1112 break; 1113 } 1114 } 1115 } else { /* in request sense mode */ 1116 1117 if (scb->tastat == 2) { /* check contition status again after sending 1118 requset sense cmd 0x3 */ 1119 scb->hastat = HOST_BAD_PHAS; 1120 } 1121 scb->tastat = 2; 1122 } 1123 scb->flags |= SCF_DONE; 1124 if (scb->flags & SCF_POST) { 1125 /* FIXME: only one post method and lose casts */ 1126 (*scb->post) ((u8 *) host, (u8 *) scb); 1127 } 1128 } /* while */ 1129 /* find_active: */ 1130 if (inb(host->addr + TUL_SStatus0) & TSS_INT_PENDING) 1131 continue; 1132 if (host->active) /* return to OS and wait for xfer_done_ISR/Selected_ISR */ 1133 return 1; /* return to OS, enable interrupt */ 1134 /* Check pending SCB */ 1135 if (initio_find_first_pend_scb(host) == NULL) 1136 return 1; /* return to OS, enable interrupt */ 1137 } /* End of for loop */ 1138 /* statement won't reach here */ 1139 } 1140 1141 static void tulip_scsi(struct initio_host * host) 1142 { 1143 struct scsi_ctrl_blk *scb; 1144 struct target_control *active_tc; 1145 1146 /* make sure to service interrupt asap */ 1147 if ((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING) { 1148 host->phase = host->jsstatus0 & TSS_PH_MASK; 1149 host->jsstatus1 = inb(host->addr + TUL_SStatus1); 1150 host->jsint = inb(host->addr + TUL_SInt); 1151 if (host->jsint & TSS_SCSIRST_INT) { /* SCSI bus reset detected */ 1152 int_initio_scsi_rst(host); 1153 return; 1154 } 1155 if (host->jsint & TSS_RESEL_INT) { /* if selected/reselected interrupt */ 1156 if (int_initio_resel(host) == 0) 1157 initio_next_state(host); 1158 return; 1159 } 1160 if (host->jsint & TSS_SEL_TIMEOUT) { 1161 int_initio_busfree(host); 1162 return; 1163 } 1164 if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ 1165 int_initio_busfree(host); /* unexpected bus free or sel timeout */ 1166 return; 1167 } 1168 if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) { /* func complete or Bus service */ 1169 if (host->active) 1170 initio_next_state(host); 1171 return; 1172 } 1173 } 1174 if (host->active != NULL) 1175 return; 1176 1177 if ((scb = initio_find_first_pend_scb(host)) == NULL) 1178 return; 1179 1180 /* program HBA's SCSI ID & target SCSI ID */ 1181 outb((host->scsi_id << 4) | (scb->target & 0x0F), 1182 host->addr + TUL_SScsiId); 1183 if (scb->opcode == ExecSCSI) { 1184 active_tc = &host->targets[scb->target]; 1185 1186 if (scb->tagmsg) 1187 active_tc->drv_flags |= TCF_DRV_EN_TAG; 1188 else 1189 active_tc->drv_flags &= ~TCF_DRV_EN_TAG; 1190 1191 outb(active_tc->js_period, host->addr + TUL_SPeriod); 1192 if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) { /* do wdtr negotiation */ 1193 initio_select_atn_stop(host, scb); 1194 } else { 1195 if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) { /* do sync negotiation */ 1196 initio_select_atn_stop(host, scb); 1197 } else { 1198 if (scb->tagmsg) 1199 initio_select_atn3(host, scb); 1200 else 1201 initio_select_atn(host, scb); 1202 } 1203 } 1204 if (scb->flags & SCF_POLL) { 1205 while (wait_tulip(host) != -1) { 1206 if (initio_next_state(host) == -1) 1207 break; 1208 } 1209 } 1210 } else if (scb->opcode == BusDevRst) { 1211 initio_select_atn_stop(host, scb); 1212 scb->next_state = 8; 1213 if (scb->flags & SCF_POLL) { 1214 while (wait_tulip(host) != -1) { 1215 if (initio_next_state(host) == -1) 1216 break; 1217 } 1218 } 1219 } else if (scb->opcode == AbortCmd) { 1220 if (initio_abort_srb(host, scb->srb) != 0) { 1221 initio_unlink_pend_scb(host, scb); 1222 initio_release_scb(host, scb); 1223 } else { 1224 scb->opcode = BusDevRst; 1225 initio_select_atn_stop(host, scb); 1226 scb->next_state = 8; 1227 } 1228 } else { 1229 initio_unlink_pend_scb(host, scb); 1230 scb->hastat = 0x16; /* bad command */ 1231 initio_append_done_scb(host, scb); 1232 } 1233 return; 1234 } 1235 1236 /** 1237 * initio_next_state - Next SCSI state 1238 * @host: InitIO host we are processing 1239 * 1240 * Progress the active command block along the state machine 1241 * until we hit a state which we must wait for activity to occur. 1242 * 1243 * Returns zero or a negative code. 1244 */ 1245 1246 static int initio_next_state(struct initio_host * host) 1247 { 1248 int next; 1249 1250 next = host->active->next_state; 1251 for (;;) { 1252 switch (next) { 1253 case 1: 1254 next = initio_state_1(host); 1255 break; 1256 case 2: 1257 next = initio_state_2(host); 1258 break; 1259 case 3: 1260 next = initio_state_3(host); 1261 break; 1262 case 4: 1263 next = initio_state_4(host); 1264 break; 1265 case 5: 1266 next = initio_state_5(host); 1267 break; 1268 case 6: 1269 next = initio_state_6(host); 1270 break; 1271 case 7: 1272 next = initio_state_7(host); 1273 break; 1274 case 8: 1275 return initio_bus_device_reset(host); 1276 default: 1277 return initio_bad_seq(host); 1278 } 1279 if (next <= 0) 1280 return next; 1281 } 1282 } 1283 1284 1285 /** 1286 * initio_state_1 - SCSI state machine 1287 * @host: InitIO host we are controlling 1288 * 1289 * Perform SCSI state processing for Select/Attention/Stop 1290 */ 1291 1292 static int initio_state_1(struct initio_host * host) 1293 { 1294 struct scsi_ctrl_blk *scb = host->active; 1295 struct target_control *active_tc = host->active_tc; 1296 #if DEBUG_STATE 1297 printk("-s1-"); 1298 #endif 1299 1300 /* Move the SCB from pending to busy */ 1301 initio_unlink_pend_scb(host, scb); 1302 initio_append_busy_scb(host, scb); 1303 1304 outb(active_tc->sconfig0, host->addr + TUL_SConfig ); 1305 /* ATN on */ 1306 if (host->phase == MSG_OUT) { 1307 outb(TSC_EN_BUS_IN | TSC_HW_RESELECT, host->addr + TUL_SCtrl1); 1308 outb(scb->ident, host->addr + TUL_SFifo); 1309 1310 if (scb->tagmsg) { 1311 outb(scb->tagmsg, host->addr + TUL_SFifo); 1312 outb(scb->tagid, host->addr + TUL_SFifo); 1313 } 1314 if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) { 1315 active_tc->flags |= TCF_WDTR_DONE; 1316 outb(EXTENDED_MESSAGE, host->addr + TUL_SFifo); 1317 outb(2, host->addr + TUL_SFifo); /* Extended msg length */ 1318 outb(EXTENDED_SDTR, host->addr + TUL_SFifo); /* Sync request */ 1319 outb(1, host->addr + TUL_SFifo); /* Start from 16 bits */ 1320 } else if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) { 1321 active_tc->flags |= TCF_SYNC_DONE; 1322 outb(EXTENDED_MESSAGE, host->addr + TUL_SFifo); 1323 outb(3, host->addr + TUL_SFifo); /* extended msg length */ 1324 outb(EXTENDED_SDTR, host->addr + TUL_SFifo); /* sync request */ 1325 outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo); 1326 outb(MAX_OFFSET, host->addr + TUL_SFifo); /* REQ/ACK offset */ 1327 } 1328 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1329 if (wait_tulip(host) == -1) 1330 return -1; 1331 } 1332 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1333 outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal); 1334 /* Into before CDB xfer */ 1335 return 3; 1336 } 1337 1338 1339 /** 1340 * initio_state_2 - SCSI state machine 1341 * @host: InitIO host we are controlling 1342 * 1343 * state after selection with attention 1344 * state after selection with attention3 1345 */ 1346 1347 static int initio_state_2(struct initio_host * host) 1348 { 1349 struct scsi_ctrl_blk *scb = host->active; 1350 struct target_control *active_tc = host->active_tc; 1351 #if DEBUG_STATE 1352 printk("-s2-"); 1353 #endif 1354 1355 initio_unlink_pend_scb(host, scb); 1356 initio_append_busy_scb(host, scb); 1357 1358 outb(active_tc->sconfig0, host->addr + TUL_SConfig); 1359 1360 if (host->jsstatus1 & TSS_CMD_PH_CMP) 1361 return 4; 1362 1363 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1364 outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal); 1365 /* Into before CDB xfer */ 1366 return 3; 1367 } 1368 1369 /** 1370 * initio_state_3 - SCSI state machine 1371 * @host: InitIO host we are controlling 1372 * 1373 * state before CDB xfer is done 1374 */ 1375 1376 static int initio_state_3(struct initio_host * host) 1377 { 1378 struct scsi_ctrl_blk *scb = host->active; 1379 struct target_control *active_tc = host->active_tc; 1380 int i; 1381 1382 #if DEBUG_STATE 1383 printk("-s3-"); 1384 #endif 1385 for (;;) { 1386 switch (host->phase) { 1387 case CMD_OUT: /* Command out phase */ 1388 for (i = 0; i < (int) scb->cdblen; i++) 1389 outb(scb->cdb[i], host->addr + TUL_SFifo); 1390 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1391 if (wait_tulip(host) == -1) 1392 return -1; 1393 if (host->phase == CMD_OUT) 1394 return initio_bad_seq(host); 1395 return 4; 1396 1397 case MSG_IN: /* Message in phase */ 1398 scb->next_state = 3; 1399 if (initio_msgin(host) == -1) 1400 return -1; 1401 break; 1402 1403 case STATUS_IN: /* Status phase */ 1404 if (initio_status_msg(host) == -1) 1405 return -1; 1406 break; 1407 1408 case MSG_OUT: /* Message out phase */ 1409 if (active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) { 1410 outb(NOP, host->addr + TUL_SFifo); /* msg nop */ 1411 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1412 if (wait_tulip(host) == -1) 1413 return -1; 1414 } else { 1415 active_tc->flags |= TCF_SYNC_DONE; 1416 1417 outb(EXTENDED_MESSAGE, host->addr + TUL_SFifo); 1418 outb(3, host->addr + TUL_SFifo); /* ext. msg len */ 1419 outb(EXTENDED_SDTR, host->addr + TUL_SFifo); /* sync request */ 1420 outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo); 1421 outb(MAX_OFFSET, host->addr + TUL_SFifo); /* REQ/ACK offset */ 1422 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1423 if (wait_tulip(host) == -1) 1424 return -1; 1425 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1426 outb(inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7), host->addr + TUL_SSignal); 1427 1428 } 1429 break; 1430 default: 1431 return initio_bad_seq(host); 1432 } 1433 } 1434 } 1435 1436 /** 1437 * initio_state_4 - SCSI state machine 1438 * @host: InitIO host we are controlling 1439 * 1440 * SCSI state machine. State 4 1441 */ 1442 1443 static int initio_state_4(struct initio_host * host) 1444 { 1445 struct scsi_ctrl_blk *scb = host->active; 1446 1447 #if DEBUG_STATE 1448 printk("-s4-"); 1449 #endif 1450 if ((scb->flags & SCF_DIR) == SCF_NO_XF) { 1451 return 6; /* Go to state 6 (After data) */ 1452 } 1453 for (;;) { 1454 if (scb->buflen == 0) 1455 return 6; 1456 1457 switch (host->phase) { 1458 1459 case STATUS_IN: /* Status phase */ 1460 if ((scb->flags & SCF_DIR) != 0) /* if direction bit set then report data underrun */ 1461 scb->hastat = HOST_DO_DU; 1462 if ((initio_status_msg(host)) == -1) 1463 return -1; 1464 break; 1465 1466 case MSG_IN: /* Message in phase */ 1467 scb->next_state = 0x4; 1468 if (initio_msgin(host) == -1) 1469 return -1; 1470 break; 1471 1472 case MSG_OUT: /* Message out phase */ 1473 if (host->jsstatus0 & TSS_PAR_ERROR) { 1474 scb->buflen = 0; 1475 scb->hastat = HOST_DO_DU; 1476 if (initio_msgout_ide(host) == -1) 1477 return -1; 1478 return 6; 1479 } else { 1480 outb(NOP, host->addr + TUL_SFifo); /* msg nop */ 1481 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1482 if (wait_tulip(host) == -1) 1483 return -1; 1484 } 1485 break; 1486 1487 case DATA_IN: /* Data in phase */ 1488 return initio_xfer_data_in(host); 1489 1490 case DATA_OUT: /* Data out phase */ 1491 return initio_xfer_data_out(host); 1492 1493 default: 1494 return initio_bad_seq(host); 1495 } 1496 } 1497 } 1498 1499 1500 /** 1501 * initio_state_5 - SCSI state machine 1502 * @host: InitIO host we are controlling 1503 * 1504 * State after dma xfer done or phase change before xfer done 1505 */ 1506 1507 static int initio_state_5(struct initio_host * host) 1508 { 1509 struct scsi_ctrl_blk *scb = host->active; 1510 long cnt, xcnt; /* cannot use unsigned !! code: if (xcnt < 0) */ 1511 1512 #if DEBUG_STATE 1513 printk("-s5-"); 1514 #endif 1515 /*------ get remaining count -------*/ 1516 cnt = inl(host->addr + TUL_SCnt0) & 0x0FFFFFF; 1517 1518 if (inb(host->addr + TUL_XCmd) & 0x20) { 1519 /* ----------------------- DATA_IN ----------------------------- */ 1520 /* check scsi parity error */ 1521 if (host->jsstatus0 & TSS_PAR_ERROR) 1522 scb->hastat = HOST_DO_DU; 1523 if (inb(host->addr + TUL_XStatus) & XPEND) { /* DMA xfer pending, Send STOP */ 1524 /* tell Hardware scsi xfer has been terminated */ 1525 outb(inb(host->addr + TUL_XCtrl) | 0x80, host->addr + TUL_XCtrl); 1526 /* wait until DMA xfer not pending */ 1527 while (inb(host->addr + TUL_XStatus) & XPEND) 1528 cpu_relax(); 1529 } 1530 } else { 1531 /*-------- DATA OUT -----------*/ 1532 if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) { 1533 if (host->active_tc->js_period & TSC_WIDE_SCSI) 1534 cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F) << 1; 1535 else 1536 cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F); 1537 } 1538 if (inb(host->addr + TUL_XStatus) & XPEND) { /* if DMA xfer is pending, abort DMA xfer */ 1539 outb(TAX_X_ABT, host->addr + TUL_XCmd); 1540 /* wait Abort DMA xfer done */ 1541 while ((inb(host->addr + TUL_Int) & XABT) == 0) 1542 cpu_relax(); 1543 } 1544 if ((cnt == 1) && (host->phase == DATA_OUT)) { 1545 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1546 if (wait_tulip(host) == -1) 1547 return -1; 1548 cnt = 0; 1549 } else { 1550 if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) 1551 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1552 } 1553 } 1554 if (cnt == 0) { 1555 scb->buflen = 0; 1556 return 6; /* After Data */ 1557 } 1558 /* Update active data pointer */ 1559 xcnt = (long) scb->buflen - cnt; /* xcnt== bytes already xferred */ 1560 scb->buflen = (u32) cnt; /* cnt == bytes left to be xferred */ 1561 if (scb->flags & SCF_SG) { 1562 struct sg_entry *sgp; 1563 unsigned long i; 1564 1565 sgp = &scb->sglist[scb->sgidx]; 1566 for (i = scb->sgidx; i < scb->sgmax; sgp++, i++) { 1567 xcnt -= (long) sgp->len; 1568 if (xcnt < 0) { /* this sgp xfer half done */ 1569 xcnt += (long) sgp->len; /* xcnt == bytes xferred in this sgp */ 1570 sgp->data += (u32) xcnt; /* new ptr to be xfer */ 1571 sgp->len -= (u32) xcnt; /* new len to be xfer */ 1572 scb->bufptr += ((u32) (i - scb->sgidx) << 3); 1573 /* new SG table ptr */ 1574 scb->sglen = (u8) (scb->sgmax - i); 1575 /* new SG table len */ 1576 scb->sgidx = (u16) i; 1577 /* for next disc and come in this loop */ 1578 return 4; /* Go to state 4 */ 1579 } 1580 /* else (xcnt >= 0 , i.e. this sgp already xferred */ 1581 } /* for */ 1582 return 6; /* Go to state 6 */ 1583 } else { 1584 scb->bufptr += (u32) xcnt; 1585 } 1586 return 4; /* Go to state 4 */ 1587 } 1588 1589 /** 1590 * initio_state_6 - SCSI state machine 1591 * @host: InitIO host we are controlling 1592 * 1593 * State after Data phase 1594 */ 1595 1596 static int initio_state_6(struct initio_host * host) 1597 { 1598 struct scsi_ctrl_blk *scb = host->active; 1599 1600 #if DEBUG_STATE 1601 printk("-s6-"); 1602 #endif 1603 for (;;) { 1604 switch (host->phase) { 1605 case STATUS_IN: /* Status phase */ 1606 if ((initio_status_msg(host)) == -1) 1607 return -1; 1608 break; 1609 1610 case MSG_IN: /* Message in phase */ 1611 scb->next_state = 6; 1612 if ((initio_msgin(host)) == -1) 1613 return -1; 1614 break; 1615 1616 case MSG_OUT: /* Message out phase */ 1617 outb(NOP, host->addr + TUL_SFifo); /* msg nop */ 1618 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1619 if (wait_tulip(host) == -1) 1620 return -1; 1621 break; 1622 1623 case DATA_IN: /* Data in phase */ 1624 return initio_xpad_in(host); 1625 1626 case DATA_OUT: /* Data out phase */ 1627 return initio_xpad_out(host); 1628 1629 default: 1630 return initio_bad_seq(host); 1631 } 1632 } 1633 } 1634 1635 /** 1636 * initio_state_7 - SCSI state machine 1637 * @host: InitIO host we are controlling 1638 * 1639 */ 1640 1641 static int initio_state_7(struct initio_host * host) 1642 { 1643 int cnt, i; 1644 1645 #if DEBUG_STATE 1646 printk("-s7-"); 1647 #endif 1648 /* flush SCSI FIFO */ 1649 cnt = inb(host->addr + TUL_SFifoCnt) & 0x1F; 1650 if (cnt) { 1651 for (i = 0; i < cnt; i++) 1652 inb(host->addr + TUL_SFifo); 1653 } 1654 switch (host->phase) { 1655 case DATA_IN: /* Data in phase */ 1656 case DATA_OUT: /* Data out phase */ 1657 return initio_bad_seq(host); 1658 default: 1659 return 6; /* Go to state 6 */ 1660 } 1661 } 1662 1663 /** 1664 * initio_xfer_data_in - Commence data input 1665 * @host: InitIO host in use 1666 * 1667 * Commence a block of data transfer. The transfer itself will 1668 * be managed by the controller and we will get a completion (or 1669 * failure) interrupt. 1670 */ 1671 static int initio_xfer_data_in(struct initio_host * host) 1672 { 1673 struct scsi_ctrl_blk *scb = host->active; 1674 1675 if ((scb->flags & SCF_DIR) == SCF_DOUT) 1676 return 6; /* wrong direction */ 1677 1678 outl(scb->buflen, host->addr + TUL_SCnt0); 1679 outb(TSC_XF_DMA_IN, host->addr + TUL_SCmd); /* 7/25/95 */ 1680 1681 if (scb->flags & SCF_SG) { /* S/G xfer */ 1682 outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH); 1683 outl(scb->bufptr, host->addr + TUL_XAddH); 1684 outb(TAX_SG_IN, host->addr + TUL_XCmd); 1685 } else { 1686 outl(scb->buflen, host->addr + TUL_XCntH); 1687 outl(scb->bufptr, host->addr + TUL_XAddH); 1688 outb(TAX_X_IN, host->addr + TUL_XCmd); 1689 } 1690 scb->next_state = 0x5; 1691 return 0; /* return to OS, wait xfer done , let jas_isr come in */ 1692 } 1693 1694 /** 1695 * initio_xfer_data_out - Commence data output 1696 * @host: InitIO host in use 1697 * 1698 * Commence a block of data transfer. The transfer itself will 1699 * be managed by the controller and we will get a completion (or 1700 * failure) interrupt. 1701 */ 1702 1703 static int initio_xfer_data_out(struct initio_host * host) 1704 { 1705 struct scsi_ctrl_blk *scb = host->active; 1706 1707 if ((scb->flags & SCF_DIR) == SCF_DIN) 1708 return 6; /* wrong direction */ 1709 1710 outl(scb->buflen, host->addr + TUL_SCnt0); 1711 outb(TSC_XF_DMA_OUT, host->addr + TUL_SCmd); 1712 1713 if (scb->flags & SCF_SG) { /* S/G xfer */ 1714 outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH); 1715 outl(scb->bufptr, host->addr + TUL_XAddH); 1716 outb(TAX_SG_OUT, host->addr + TUL_XCmd); 1717 } else { 1718 outl(scb->buflen, host->addr + TUL_XCntH); 1719 outl(scb->bufptr, host->addr + TUL_XAddH); 1720 outb(TAX_X_OUT, host->addr + TUL_XCmd); 1721 } 1722 1723 scb->next_state = 0x5; 1724 return 0; /* return to OS, wait xfer done , let jas_isr come in */ 1725 } 1726 1727 int initio_xpad_in(struct initio_host * host) 1728 { 1729 struct scsi_ctrl_blk *scb = host->active; 1730 struct target_control *active_tc = host->active_tc; 1731 1732 if ((scb->flags & SCF_DIR) != SCF_NO_DCHK) 1733 scb->hastat = HOST_DO_DU; /* over run */ 1734 for (;;) { 1735 if (active_tc->js_period & TSC_WIDE_SCSI) 1736 outl(2, host->addr + TUL_SCnt0); 1737 else 1738 outl(1, host->addr + TUL_SCnt0); 1739 1740 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd); 1741 if (wait_tulip(host) == -1) 1742 return -1; 1743 if (host->phase != DATA_IN) { 1744 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1745 return 6; 1746 } 1747 inb(host->addr + TUL_SFifo); 1748 } 1749 } 1750 1751 int initio_xpad_out(struct initio_host * host) 1752 { 1753 struct scsi_ctrl_blk *scb = host->active; 1754 struct target_control *active_tc = host->active_tc; 1755 1756 if ((scb->flags & SCF_DIR) != SCF_NO_DCHK) 1757 scb->hastat = HOST_DO_DU; /* over run */ 1758 for (;;) { 1759 if (active_tc->js_period & TSC_WIDE_SCSI) 1760 outl(2, host->addr + TUL_SCnt0); 1761 else 1762 outl(1, host->addr + TUL_SCnt0); 1763 1764 outb(0, host->addr + TUL_SFifo); 1765 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1766 if ((wait_tulip(host)) == -1) 1767 return -1; 1768 if (host->phase != DATA_OUT) { /* Disable wide CPU to allow read 16 bits */ 1769 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); 1770 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1771 return 6; 1772 } 1773 } 1774 } 1775 1776 int initio_status_msg(struct initio_host * host) 1777 { /* status & MSG_IN */ 1778 struct scsi_ctrl_blk *scb = host->active; 1779 u8 msg; 1780 1781 outb(TSC_CMD_COMP, host->addr + TUL_SCmd); 1782 if (wait_tulip(host) == -1) 1783 return -1; 1784 1785 /* get status */ 1786 scb->tastat = inb(host->addr + TUL_SFifo); 1787 1788 if (host->phase == MSG_OUT) { 1789 if (host->jsstatus0 & TSS_PAR_ERROR) 1790 outb(MSG_PARITY_ERROR, host->addr + TUL_SFifo); 1791 else 1792 outb(NOP, host->addr + TUL_SFifo); 1793 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1794 return wait_tulip(host); 1795 } 1796 if (host->phase == MSG_IN) { 1797 msg = inb(host->addr + TUL_SFifo); 1798 if (host->jsstatus0 & TSS_PAR_ERROR) { /* Parity error */ 1799 if ((initio_msgin_accept(host)) == -1) 1800 return -1; 1801 if (host->phase != MSG_OUT) 1802 return initio_bad_seq(host); 1803 outb(MSG_PARITY_ERROR, host->addr + TUL_SFifo); 1804 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 1805 return wait_tulip(host); 1806 } 1807 if (msg == 0) { /* Command complete */ 1808 1809 if ((scb->tastat & 0x18) == 0x10) /* No link support */ 1810 return initio_bad_seq(host); 1811 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1812 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd); 1813 return initio_wait_done_disc(host); 1814 1815 } 1816 if (msg == LINKED_CMD_COMPLETE || 1817 msg == LINKED_FLG_CMD_COMPLETE) { 1818 if ((scb->tastat & 0x18) == 0x10) 1819 return initio_msgin_accept(host); 1820 } 1821 } 1822 return initio_bad_seq(host); 1823 } 1824 1825 1826 /* scsi bus free */ 1827 int int_initio_busfree(struct initio_host * host) 1828 { 1829 struct scsi_ctrl_blk *scb = host->active; 1830 1831 if (scb != NULL) { 1832 if (scb->status & SCB_SELECT) { /* selection timeout */ 1833 initio_unlink_pend_scb(host, scb); 1834 scb->hastat = HOST_SEL_TOUT; 1835 initio_append_done_scb(host, scb); 1836 } else { /* Unexpected bus free */ 1837 initio_unlink_busy_scb(host, scb); 1838 scb->hastat = HOST_BUS_FREE; 1839 initio_append_done_scb(host, scb); 1840 } 1841 host->active = NULL; 1842 host->active_tc = NULL; 1843 } 1844 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ 1845 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig); 1846 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */ 1847 return -1; 1848 } 1849 1850 1851 /** 1852 * int_initio_scsi_rst - SCSI reset occurred 1853 * @host: Host seeing the reset 1854 * 1855 * A SCSI bus reset has occurred. Clean up any pending transfer 1856 * the hardware is doing by DMA and then abort all active and 1857 * disconnected commands. The mid layer should sort the rest out 1858 * for us 1859 */ 1860 1861 static int int_initio_scsi_rst(struct initio_host * host) 1862 { 1863 struct scsi_ctrl_blk *scb; 1864 int i; 1865 1866 /* if DMA xfer is pending, abort DMA xfer */ 1867 if (inb(host->addr + TUL_XStatus) & 0x01) { 1868 outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd); 1869 /* wait Abort DMA xfer done */ 1870 while ((inb(host->addr + TUL_Int) & 0x04) == 0) 1871 cpu_relax(); 1872 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 1873 } 1874 /* Abort all active & disconnected scb */ 1875 while ((scb = initio_pop_busy_scb(host)) != NULL) { 1876 scb->hastat = HOST_BAD_PHAS; 1877 initio_append_done_scb(host, scb); 1878 } 1879 host->active = NULL; 1880 host->active_tc = NULL; 1881 1882 /* clr sync nego. done flag */ 1883 for (i = 0; i < host->max_tar; i++) 1884 host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE); 1885 return -1; 1886 } 1887 1888 /** 1889 * int_initio_resel - Reselection occurred 1890 * @host: InitIO host adapter 1891 * 1892 * A SCSI reselection event has been signalled and the interrupt 1893 * is now being processed. Work out which command block needs attention 1894 * and continue processing that command. 1895 */ 1896 1897 int int_initio_resel(struct initio_host * host) 1898 { 1899 struct scsi_ctrl_blk *scb; 1900 struct target_control *active_tc; 1901 u8 tag, msg = 0; 1902 u8 tar, lun; 1903 1904 if ((scb = host->active) != NULL) { 1905 /* FIXME: Why check and not just clear ? */ 1906 if (scb->status & SCB_SELECT) /* if waiting for selection complete */ 1907 scb->status &= ~SCB_SELECT; 1908 host->active = NULL; 1909 } 1910 /* --------- get target id---------------------- */ 1911 tar = inb(host->addr + TUL_SBusId); 1912 /* ------ get LUN from Identify message----------- */ 1913 lun = inb(host->addr + TUL_SIdent) & 0x0F; 1914 /* 07/22/98 from 0x1F -> 0x0F */ 1915 active_tc = &host->targets[tar]; 1916 host->active_tc = active_tc; 1917 outb(active_tc->sconfig0, host->addr + TUL_SConfig); 1918 outb(active_tc->js_period, host->addr + TUL_SPeriod); 1919 1920 /* ------------- tag queueing ? ------------------- */ 1921 if (active_tc->drv_flags & TCF_DRV_EN_TAG) { 1922 if ((initio_msgin_accept(host)) == -1) 1923 return -1; 1924 if (host->phase != MSG_IN) 1925 goto no_tag; 1926 outl(1, host->addr + TUL_SCnt0); 1927 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd); 1928 if (wait_tulip(host) == -1) 1929 return -1; 1930 msg = inb(host->addr + TUL_SFifo); /* Read Tag Message */ 1931 1932 if (msg < SIMPLE_QUEUE_TAG || msg > ORDERED_QUEUE_TAG) 1933 /* Is simple Tag */ 1934 goto no_tag; 1935 1936 if (initio_msgin_accept(host) == -1) 1937 return -1; 1938 1939 if (host->phase != MSG_IN) 1940 goto no_tag; 1941 1942 outl(1, host->addr + TUL_SCnt0); 1943 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd); 1944 if (wait_tulip(host) == -1) 1945 return -1; 1946 tag = inb(host->addr + TUL_SFifo); /* Read Tag ID */ 1947 scb = host->scb + tag; 1948 if (scb->target != tar || scb->lun != lun) { 1949 return initio_msgout_abort_tag(host); 1950 } 1951 if (scb->status != SCB_BUSY) { /* 03/24/95 */ 1952 return initio_msgout_abort_tag(host); 1953 } 1954 host->active = scb; 1955 if ((initio_msgin_accept(host)) == -1) 1956 return -1; 1957 } else { /* No tag */ 1958 no_tag: 1959 if ((scb = initio_find_busy_scb(host, tar | (lun << 8))) == NULL) { 1960 return initio_msgout_abort_targ(host); 1961 } 1962 host->active = scb; 1963 if (!(active_tc->drv_flags & TCF_DRV_EN_TAG)) { 1964 if ((initio_msgin_accept(host)) == -1) 1965 return -1; 1966 } 1967 } 1968 return 0; 1969 } 1970 1971 /** 1972 * int_initio_bad_seq - out of phase 1973 * @host: InitIO host flagging event 1974 * 1975 * We have ended up out of phase somehow. Reset the host controller 1976 * and throw all our toys out of the pram. Let the midlayer clean up 1977 */ 1978 1979 static int int_initio_bad_seq(struct initio_host * host) 1980 { /* target wrong phase */ 1981 struct scsi_ctrl_blk *scb; 1982 int i; 1983 1984 initio_reset_scsi(host, 10); 1985 1986 while ((scb = initio_pop_busy_scb(host)) != NULL) { 1987 scb->hastat = HOST_BAD_PHAS; 1988 initio_append_done_scb(host, scb); 1989 } 1990 for (i = 0; i < host->max_tar; i++) 1991 host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE); 1992 return -1; 1993 } 1994 1995 1996 /** 1997 * initio_msgout_abort_targ - abort a tag 1998 * @host: InitIO host 1999 * 2000 * Abort when the target/lun does not match or when our SCB is not 2001 * busy. Used by untagged commands. 2002 */ 2003 2004 static int initio_msgout_abort_targ(struct initio_host * host) 2005 { 2006 2007 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal); 2008 if (initio_msgin_accept(host) == -1) 2009 return -1; 2010 if (host->phase != MSG_OUT) 2011 return initio_bad_seq(host); 2012 2013 outb(ABORT_TASK_SET, host->addr + TUL_SFifo); 2014 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2015 2016 return initio_wait_disc(host); 2017 } 2018 2019 /** 2020 * initio_msgout_abort_tag - abort a tag 2021 * @host: InitIO host 2022 * 2023 * Abort when the target/lun does not match or when our SCB is not 2024 * busy. Used for tagged commands. 2025 */ 2026 2027 static int initio_msgout_abort_tag(struct initio_host * host) 2028 { 2029 2030 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal); 2031 if (initio_msgin_accept(host) == -1) 2032 return -1; 2033 if (host->phase != MSG_OUT) 2034 return initio_bad_seq(host); 2035 2036 outb(ABORT_TASK, host->addr + TUL_SFifo); 2037 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2038 2039 return initio_wait_disc(host); 2040 2041 } 2042 2043 /** 2044 * initio_msgin - Message in 2045 * @host: InitIO Host 2046 * 2047 * Process incoming message 2048 */ 2049 static int initio_msgin(struct initio_host * host) 2050 { 2051 struct target_control *active_tc; 2052 2053 for (;;) { 2054 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 2055 2056 outl(1, host->addr + TUL_SCnt0); 2057 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd); 2058 if (wait_tulip(host) == -1) 2059 return -1; 2060 2061 switch (inb(host->addr + TUL_SFifo)) { 2062 case DISCONNECT: /* Disconnect msg */ 2063 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd); 2064 return initio_wait_disc(host); 2065 case SAVE_POINTERS: 2066 case RESTORE_POINTERS: 2067 case NOP: 2068 initio_msgin_accept(host); 2069 break; 2070 case MESSAGE_REJECT: /* Clear ATN first */ 2071 outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), 2072 host->addr + TUL_SSignal); 2073 active_tc = host->active_tc; 2074 if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) /* do sync nego */ 2075 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), 2076 host->addr + TUL_SSignal); 2077 initio_msgin_accept(host); 2078 break; 2079 case EXTENDED_MESSAGE: /* extended msg */ 2080 initio_msgin_extend(host); 2081 break; 2082 case IGNORE_WIDE_RESIDUE: 2083 initio_msgin_accept(host); 2084 break; 2085 case COMMAND_COMPLETE: 2086 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 2087 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd); 2088 return initio_wait_done_disc(host); 2089 default: 2090 initio_msgout_reject(host); 2091 break; 2092 } 2093 if (host->phase != MSG_IN) 2094 return host->phase; 2095 } 2096 /* statement won't reach here */ 2097 } 2098 2099 static int initio_msgout_reject(struct initio_host * host) 2100 { 2101 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal); 2102 2103 if (initio_msgin_accept(host) == -1) 2104 return -1; 2105 2106 if (host->phase == MSG_OUT) { 2107 outb(MESSAGE_REJECT, host->addr + TUL_SFifo); /* Msg reject */ 2108 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2109 return wait_tulip(host); 2110 } 2111 return host->phase; 2112 } 2113 2114 static int initio_msgout_ide(struct initio_host * host) 2115 { 2116 outb(INITIATOR_ERROR, host->addr + TUL_SFifo); /* Initiator Detected Error */ 2117 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2118 return wait_tulip(host); 2119 } 2120 2121 static int initio_msgin_extend(struct initio_host * host) 2122 { 2123 u8 len, idx; 2124 2125 if (initio_msgin_accept(host) != MSG_IN) 2126 return host->phase; 2127 2128 /* Get extended msg length */ 2129 outl(1, host->addr + TUL_SCnt0); 2130 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd); 2131 if (wait_tulip(host) == -1) 2132 return -1; 2133 2134 len = inb(host->addr + TUL_SFifo); 2135 host->msg[0] = len; 2136 for (idx = 1; len != 0; len--) { 2137 2138 if ((initio_msgin_accept(host)) != MSG_IN) 2139 return host->phase; 2140 outl(1, host->addr + TUL_SCnt0); 2141 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd); 2142 if (wait_tulip(host) == -1) 2143 return -1; 2144 host->msg[idx++] = inb(host->addr + TUL_SFifo); 2145 } 2146 if (host->msg[1] == 1) { /* if it's synchronous data transfer request */ 2147 u8 r; 2148 if (host->msg[0] != 3) /* if length is not right */ 2149 return initio_msgout_reject(host); 2150 if (host->active_tc->flags & TCF_NO_SYNC_NEGO) { /* Set OFFSET=0 to do async, nego back */ 2151 host->msg[3] = 0; 2152 } else { 2153 if (initio_msgin_sync(host) == 0 && 2154 (host->active_tc->flags & TCF_SYNC_DONE)) { 2155 initio_sync_done(host); 2156 return initio_msgin_accept(host); 2157 } 2158 } 2159 2160 r = inb(host->addr + TUL_SSignal); 2161 outb((r & (TSC_SET_ACK | 7)) | TSC_SET_ATN, 2162 host->addr + TUL_SSignal); 2163 if (initio_msgin_accept(host) != MSG_OUT) 2164 return host->phase; 2165 /* sync msg out */ 2166 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); 2167 2168 initio_sync_done(host); 2169 2170 outb(EXTENDED_MESSAGE, host->addr + TUL_SFifo); 2171 outb(3, host->addr + TUL_SFifo); 2172 outb(EXTENDED_SDTR, host->addr + TUL_SFifo); 2173 outb(host->msg[2], host->addr + TUL_SFifo); 2174 outb(host->msg[3], host->addr + TUL_SFifo); 2175 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2176 return wait_tulip(host); 2177 } 2178 if (host->msg[0] != 2 || host->msg[1] != 3) 2179 return initio_msgout_reject(host); 2180 /* if it's WIDE DATA XFER REQ */ 2181 if (host->active_tc->flags & TCF_NO_WDTR) { 2182 host->msg[2] = 0; 2183 } else { 2184 if (host->msg[2] > 2) /* > 32 bits */ 2185 return initio_msgout_reject(host); 2186 if (host->msg[2] == 2) { /* == 32 */ 2187 host->msg[2] = 1; 2188 } else { 2189 if ((host->active_tc->flags & TCF_NO_WDTR) == 0) { 2190 wdtr_done(host); 2191 if ((host->active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) 2192 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal); 2193 return initio_msgin_accept(host); 2194 } 2195 } 2196 } 2197 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal); 2198 2199 if (initio_msgin_accept(host) != MSG_OUT) 2200 return host->phase; 2201 /* WDTR msg out */ 2202 outb(EXTENDED_MESSAGE, host->addr + TUL_SFifo); 2203 outb(2, host->addr + TUL_SFifo); 2204 outb(EXTENDED_WDTR, host->addr + TUL_SFifo); 2205 outb(host->msg[2], host->addr + TUL_SFifo); 2206 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2207 return wait_tulip(host); 2208 } 2209 2210 static int initio_msgin_sync(struct initio_host * host) 2211 { 2212 char default_period; 2213 2214 default_period = initio_rate_tbl[host->active_tc->flags & TCF_SCSI_RATE]; 2215 if (host->msg[3] > MAX_OFFSET) { 2216 host->msg[3] = MAX_OFFSET; 2217 if (host->msg[2] < default_period) { 2218 host->msg[2] = default_period; 2219 return 1; 2220 } 2221 if (host->msg[2] >= 59) /* Change to async */ 2222 host->msg[3] = 0; 2223 return 1; 2224 } 2225 /* offset requests asynchronous transfers ? */ 2226 if (host->msg[3] == 0) { 2227 return 0; 2228 } 2229 if (host->msg[2] < default_period) { 2230 host->msg[2] = default_period; 2231 return 1; 2232 } 2233 if (host->msg[2] >= 59) { 2234 host->msg[3] = 0; 2235 return 1; 2236 } 2237 return 0; 2238 } 2239 2240 static int wdtr_done(struct initio_host * host) 2241 { 2242 host->active_tc->flags &= ~TCF_SYNC_DONE; 2243 host->active_tc->flags |= TCF_WDTR_DONE; 2244 2245 host->active_tc->js_period = 0; 2246 if (host->msg[2]) /* if 16 bit */ 2247 host->active_tc->js_period |= TSC_WIDE_SCSI; 2248 host->active_tc->sconfig0 &= ~TSC_ALT_PERIOD; 2249 outb(host->active_tc->sconfig0, host->addr + TUL_SConfig); 2250 outb(host->active_tc->js_period, host->addr + TUL_SPeriod); 2251 2252 return 1; 2253 } 2254 2255 static int initio_sync_done(struct initio_host * host) 2256 { 2257 int i; 2258 2259 host->active_tc->flags |= TCF_SYNC_DONE; 2260 2261 if (host->msg[3]) { 2262 host->active_tc->js_period |= host->msg[3]; 2263 for (i = 0; i < 8; i++) { 2264 if (initio_rate_tbl[i] >= host->msg[2]) /* pick the big one */ 2265 break; 2266 } 2267 host->active_tc->js_period |= (i << 4); 2268 host->active_tc->sconfig0 |= TSC_ALT_PERIOD; 2269 } 2270 outb(host->active_tc->sconfig0, host->addr + TUL_SConfig); 2271 outb(host->active_tc->js_period, host->addr + TUL_SPeriod); 2272 2273 return -1; 2274 } 2275 2276 2277 static int initio_post_scsi_rst(struct initio_host * host) 2278 { 2279 struct scsi_ctrl_blk *scb; 2280 struct target_control *active_tc; 2281 int i; 2282 2283 host->active = NULL; 2284 host->active_tc = NULL; 2285 host->flags = 0; 2286 2287 while ((scb = initio_pop_busy_scb(host)) != NULL) { 2288 scb->hastat = HOST_BAD_PHAS; 2289 initio_append_done_scb(host, scb); 2290 } 2291 /* clear sync done flag */ 2292 active_tc = &host->targets[0]; 2293 for (i = 0; i < host->max_tar; active_tc++, i++) { 2294 active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE); 2295 /* Initialize the sync. xfer register values to an asyn xfer */ 2296 active_tc->js_period = 0; 2297 active_tc->sconfig0 = host->sconf1; 2298 host->act_tags[0] = 0; /* 07/22/98 */ 2299 host->targets[i].flags &= ~TCF_BUSY; /* 07/22/98 */ 2300 } /* for */ 2301 2302 return -1; 2303 } 2304 2305 static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb) 2306 { 2307 scb->status |= SCB_SELECT; 2308 scb->next_state = 0x1; 2309 host->active = scb; 2310 host->active_tc = &host->targets[scb->target]; 2311 outb(TSC_SELATNSTOP, host->addr + TUL_SCmd); 2312 } 2313 2314 2315 static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb) 2316 { 2317 int i; 2318 2319 scb->status |= SCB_SELECT; 2320 scb->next_state = 0x2; 2321 2322 outb(scb->ident, host->addr + TUL_SFifo); 2323 for (i = 0; i < (int) scb->cdblen; i++) 2324 outb(scb->cdb[i], host->addr + TUL_SFifo); 2325 host->active_tc = &host->targets[scb->target]; 2326 host->active = scb; 2327 outb(TSC_SEL_ATN, host->addr + TUL_SCmd); 2328 } 2329 2330 static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb) 2331 { 2332 int i; 2333 2334 scb->status |= SCB_SELECT; 2335 scb->next_state = 0x2; 2336 2337 outb(scb->ident, host->addr + TUL_SFifo); 2338 outb(scb->tagmsg, host->addr + TUL_SFifo); 2339 outb(scb->tagid, host->addr + TUL_SFifo); 2340 for (i = 0; i < scb->cdblen; i++) 2341 outb(scb->cdb[i], host->addr + TUL_SFifo); 2342 host->active_tc = &host->targets[scb->target]; 2343 host->active = scb; 2344 outb(TSC_SEL_ATN3, host->addr + TUL_SCmd); 2345 } 2346 2347 /** 2348 * initio_bus_device_reset - SCSI Bus Device Reset 2349 * @host: InitIO host to reset 2350 * 2351 * Perform a device reset and abort all pending SCBs for the 2352 * victim device 2353 */ 2354 int initio_bus_device_reset(struct initio_host * host) 2355 { 2356 struct scsi_ctrl_blk *scb = host->active; 2357 struct target_control *active_tc = host->active_tc; 2358 struct scsi_ctrl_blk *tmp, *prev; 2359 u8 tar; 2360 2361 if (host->phase != MSG_OUT) 2362 return int_initio_bad_seq(host); /* Unexpected phase */ 2363 2364 initio_unlink_pend_scb(host, scb); 2365 initio_release_scb(host, scb); 2366 2367 2368 tar = scb->target; /* target */ 2369 active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE | TCF_BUSY); 2370 /* clr sync. nego & WDTR flags 07/22/98 */ 2371 2372 /* abort all SCB with same target */ 2373 prev = tmp = host->first_busy; /* Check Busy queue */ 2374 while (tmp != NULL) { 2375 if (tmp->target == tar) { 2376 /* unlink it */ 2377 if (tmp == host->first_busy) { 2378 if ((host->first_busy = tmp->next) == NULL) 2379 host->last_busy = NULL; 2380 } else { 2381 prev->next = tmp->next; 2382 if (tmp == host->last_busy) 2383 host->last_busy = prev; 2384 } 2385 tmp->hastat = HOST_ABORTED; 2386 initio_append_done_scb(host, tmp); 2387 } 2388 /* Previous haven't change */ 2389 else { 2390 prev = tmp; 2391 } 2392 tmp = tmp->next; 2393 } 2394 outb(TARGET_RESET, host->addr + TUL_SFifo); 2395 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd); 2396 return initio_wait_disc(host); 2397 2398 } 2399 2400 static int initio_msgin_accept(struct initio_host * host) 2401 { 2402 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd); 2403 return wait_tulip(host); 2404 } 2405 2406 static int wait_tulip(struct initio_host * host) 2407 { 2408 2409 while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) 2410 & TSS_INT_PENDING)) 2411 cpu_relax(); 2412 2413 host->jsint = inb(host->addr + TUL_SInt); 2414 host->phase = host->jsstatus0 & TSS_PH_MASK; 2415 host->jsstatus1 = inb(host->addr + TUL_SStatus1); 2416 2417 if (host->jsint & TSS_RESEL_INT) /* if SCSI bus reset detected */ 2418 return int_initio_resel(host); 2419 if (host->jsint & TSS_SEL_TIMEOUT) /* if selected/reselected timeout interrupt */ 2420 return int_initio_busfree(host); 2421 if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */ 2422 return int_initio_scsi_rst(host); 2423 2424 if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ 2425 if (host->flags & HCF_EXPECT_DONE_DISC) { 2426 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ 2427 initio_unlink_busy_scb(host, host->active); 2428 host->active->hastat = 0; 2429 initio_append_done_scb(host, host->active); 2430 host->active = NULL; 2431 host->active_tc = NULL; 2432 host->flags &= ~HCF_EXPECT_DONE_DISC; 2433 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig); 2434 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */ 2435 return -1; 2436 } 2437 if (host->flags & HCF_EXPECT_DISC) { 2438 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ 2439 host->active = NULL; 2440 host->active_tc = NULL; 2441 host->flags &= ~HCF_EXPECT_DISC; 2442 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig); 2443 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */ 2444 return -1; 2445 } 2446 return int_initio_busfree(host); 2447 } 2448 /* The old code really does the below. Can probably be removed */ 2449 if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) 2450 return host->phase; 2451 return host->phase; 2452 } 2453 2454 static int initio_wait_disc(struct initio_host * host) 2455 { 2456 while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING)) 2457 cpu_relax(); 2458 2459 host->jsint = inb(host->addr + TUL_SInt); 2460 2461 if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */ 2462 return int_initio_scsi_rst(host); 2463 if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ 2464 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ 2465 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig); 2466 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */ 2467 host->active = NULL; 2468 return -1; 2469 } 2470 return initio_bad_seq(host); 2471 } 2472 2473 static int initio_wait_done_disc(struct initio_host * host) 2474 { 2475 while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) 2476 & TSS_INT_PENDING)) 2477 cpu_relax(); 2478 2479 host->jsint = inb(host->addr + TUL_SInt); 2480 2481 if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */ 2482 return int_initio_scsi_rst(host); 2483 if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */ 2484 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */ 2485 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig); 2486 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */ 2487 initio_unlink_busy_scb(host, host->active); 2488 2489 initio_append_done_scb(host, host->active); 2490 host->active = NULL; 2491 return -1; 2492 } 2493 return initio_bad_seq(host); 2494 } 2495 2496 /** 2497 * i91u_intr - IRQ handler 2498 * @irqno: IRQ number 2499 * @dev_id: IRQ identifier 2500 * 2501 * Take the relevant locks and then invoke the actual isr processing 2502 * code under the lock. 2503 */ 2504 2505 static irqreturn_t i91u_intr(int irqno, void *dev_id) 2506 { 2507 struct Scsi_Host *dev = dev_id; 2508 unsigned long flags; 2509 int r; 2510 2511 spin_lock_irqsave(dev->host_lock, flags); 2512 r = initio_isr((struct initio_host *)dev->hostdata); 2513 spin_unlock_irqrestore(dev->host_lock, flags); 2514 if (r) 2515 return IRQ_HANDLED; 2516 else 2517 return IRQ_NONE; 2518 } 2519 2520 2521 /** 2522 * initio_build_scb - Build the mappings and SCB 2523 * @host: InitIO host taking the command 2524 * @cblk: Firmware command block 2525 * @cmnd: SCSI midlayer command block 2526 * 2527 * Translate the abstract SCSI command into a firmware command block 2528 * suitable for feeding to the InitIO host controller. This also requires 2529 * we build the scatter gather lists and ensure they are mapped properly. 2530 */ 2531 2532 static void initio_build_scb(struct initio_host * host, struct scsi_ctrl_blk * cblk, struct scsi_cmnd * cmnd) 2533 { /* Create corresponding SCB */ 2534 struct scatterlist *sglist; 2535 struct sg_entry *sg; /* Pointer to SG list */ 2536 int i, nseg; 2537 long total_len; 2538 dma_addr_t dma_addr; 2539 2540 /* Fill in the command headers */ 2541 cblk->post = i91uSCBPost; /* i91u's callback routine */ 2542 cblk->srb = cmnd; 2543 cblk->opcode = ExecSCSI; 2544 cblk->flags = SCF_POST; /* After SCSI done, call post routine */ 2545 cblk->target = cmnd->device->id; 2546 cblk->lun = cmnd->device->lun; 2547 cblk->ident = cmnd->device->lun | DISC_ALLOW; 2548 2549 cblk->flags |= SCF_SENSE; /* Turn on auto request sense */ 2550 2551 /* Map the sense buffer into bus memory */ 2552 dma_addr = dma_map_single(&host->pci_dev->dev, cmnd->sense_buffer, 2553 SENSE_SIZE, DMA_FROM_DEVICE); 2554 cblk->senseptr = (u32)dma_addr; 2555 cblk->senselen = SENSE_SIZE; 2556 initio_priv(cmnd)->sense_dma_addr = dma_addr; 2557 cblk->cdblen = cmnd->cmd_len; 2558 2559 /* Clear the returned status */ 2560 cblk->hastat = 0; 2561 cblk->tastat = 0; 2562 /* Command the command */ 2563 memcpy(cblk->cdb, cmnd->cmnd, cmnd->cmd_len); 2564 2565 /* Set up tags */ 2566 if (cmnd->device->tagged_supported) { /* Tag Support */ 2567 cblk->tagmsg = SIMPLE_QUEUE_TAG; /* Do simple tag only */ 2568 } else { 2569 cblk->tagmsg = 0; /* No tag support */ 2570 } 2571 2572 /* todo handle map_sg error */ 2573 nseg = scsi_dma_map(cmnd); 2574 BUG_ON(nseg < 0); 2575 if (nseg) { 2576 dma_addr = dma_map_single(&host->pci_dev->dev, &cblk->sglist[0], 2577 sizeof(struct sg_entry) * TOTAL_SG_ENTRY, 2578 DMA_BIDIRECTIONAL); 2579 cblk->bufptr = (u32)dma_addr; 2580 initio_priv(cmnd)->sglist_dma_addr = dma_addr; 2581 2582 cblk->sglen = nseg; 2583 2584 cblk->flags |= SCF_SG; /* Turn on SG list flag */ 2585 total_len = 0; 2586 sg = &cblk->sglist[0]; 2587 scsi_for_each_sg(cmnd, sglist, cblk->sglen, i) { 2588 sg->data = cpu_to_le32((u32)sg_dma_address(sglist)); 2589 sg->len = cpu_to_le32((u32)sg_dma_len(sglist)); 2590 total_len += sg_dma_len(sglist); 2591 ++sg; 2592 } 2593 2594 cblk->buflen = (scsi_bufflen(cmnd) > total_len) ? 2595 total_len : scsi_bufflen(cmnd); 2596 } else { /* No data transfer required */ 2597 cblk->buflen = 0; 2598 cblk->sglen = 0; 2599 } 2600 } 2601 2602 /** 2603 * i91u_queuecommand_lck - Queue a new command if possible 2604 * @cmd: SCSI command block from the mid layer 2605 * 2606 * Attempts to queue a new command with the host adapter. Will return 2607 * zero if successful or indicate a host busy condition if not (which 2608 * will cause the mid layer to call us again later with the command) 2609 */ 2610 static int i91u_queuecommand_lck(struct scsi_cmnd *cmd) 2611 { 2612 struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata; 2613 struct scsi_ctrl_blk *cmnd; 2614 2615 cmnd = initio_alloc_scb(host); 2616 if (!cmnd) 2617 return SCSI_MLQUEUE_HOST_BUSY; 2618 2619 initio_build_scb(host, cmnd, cmd); 2620 initio_exec_scb(host, cmnd); 2621 return 0; 2622 } 2623 2624 static DEF_SCSI_QCMD(i91u_queuecommand) 2625 2626 /** 2627 * i91u_bus_reset - reset the SCSI bus 2628 * @cmnd: Command block we want to trigger the reset for 2629 * 2630 * Initiate a SCSI bus reset sequence 2631 */ 2632 2633 static int i91u_bus_reset(struct scsi_cmnd * cmnd) 2634 { 2635 struct initio_host *host; 2636 2637 host = (struct initio_host *) cmnd->device->host->hostdata; 2638 2639 spin_lock_irq(cmnd->device->host->host_lock); 2640 initio_reset_scsi(host, 0); 2641 spin_unlock_irq(cmnd->device->host->host_lock); 2642 2643 return SUCCESS; 2644 } 2645 2646 /** 2647 * i91u_biosparam - return the "logical geometry 2648 * @sdev: SCSI device 2649 * @dev: Matching block device 2650 * @capacity: Sector size of drive 2651 * @info_array: Return space for BIOS geometry 2652 * 2653 * Map the device geometry in a manner compatible with the host 2654 * controller BIOS behaviour. 2655 * 2656 * FIXME: limited to 2^32 sector devices. 2657 */ 2658 2659 static int i91u_biosparam(struct scsi_device *sdev, struct block_device *dev, 2660 sector_t capacity, int *info_array) 2661 { 2662 struct initio_host *host; /* Point to Host adapter control block */ 2663 struct target_control *tc; 2664 2665 host = (struct initio_host *) sdev->host->hostdata; 2666 tc = &host->targets[sdev->id]; 2667 2668 if (tc->heads) { 2669 info_array[0] = tc->heads; 2670 info_array[1] = tc->sectors; 2671 info_array[2] = (unsigned long)capacity / tc->heads / tc->sectors; 2672 } else { 2673 if (tc->drv_flags & TCF_DRV_255_63) { 2674 info_array[0] = 255; 2675 info_array[1] = 63; 2676 info_array[2] = (unsigned long)capacity / 255 / 63; 2677 } else { 2678 info_array[0] = 64; 2679 info_array[1] = 32; 2680 info_array[2] = (unsigned long)capacity >> 11; 2681 } 2682 } 2683 2684 #if defined(DEBUG_BIOSPARAM) 2685 if (i91u_debug & debug_biosparam) { 2686 printk("bios geometry: head=%d, sec=%d, cyl=%d\n", 2687 info_array[0], info_array[1], info_array[2]); 2688 printk("WARNING: check, if the bios geometry is correct.\n"); 2689 } 2690 #endif 2691 2692 return 0; 2693 } 2694 2695 /** 2696 * i91u_unmap_scb - Unmap a command 2697 * @pci_dev: PCI device the command is for 2698 * @cmnd: The command itself 2699 * 2700 * Unmap any PCI mapping/IOMMU resources allocated when the command 2701 * was mapped originally as part of initio_build_scb 2702 */ 2703 2704 static void i91u_unmap_scb(struct pci_dev *pci_dev, struct scsi_cmnd *cmnd) 2705 { 2706 /* auto sense buffer */ 2707 if (initio_priv(cmnd)->sense_dma_addr) { 2708 dma_unmap_single(&pci_dev->dev, 2709 initio_priv(cmnd)->sense_dma_addr, 2710 SENSE_SIZE, DMA_FROM_DEVICE); 2711 initio_priv(cmnd)->sense_dma_addr = 0; 2712 } 2713 2714 /* request buffer */ 2715 if (scsi_sg_count(cmnd)) { 2716 dma_unmap_single(&pci_dev->dev, 2717 initio_priv(cmnd)->sglist_dma_addr, 2718 sizeof(struct sg_entry) * TOTAL_SG_ENTRY, 2719 DMA_BIDIRECTIONAL); 2720 2721 scsi_dma_unmap(cmnd); 2722 } 2723 } 2724 2725 /* 2726 * i91uSCBPost - SCSI callback 2727 * 2728 * This is callback routine be called when tulip finish one 2729 * SCSI command. 2730 */ 2731 2732 static void i91uSCBPost(u8 * host_mem, u8 * cblk_mem) 2733 { 2734 struct scsi_cmnd *cmnd; /* Pointer to SCSI request block */ 2735 struct initio_host *host; 2736 struct scsi_ctrl_blk *cblk; 2737 2738 host = (struct initio_host *) host_mem; 2739 cblk = (struct scsi_ctrl_blk *) cblk_mem; 2740 if ((cmnd = cblk->srb) == NULL) { 2741 printk(KERN_ERR "i91uSCBPost: SRB pointer is empty\n"); 2742 WARN_ON(1); 2743 initio_release_scb(host, cblk); /* Release SCB for current channel */ 2744 return; 2745 } 2746 2747 /* 2748 * Remap the firmware error status into a mid layer one 2749 */ 2750 switch (cblk->hastat) { 2751 case 0x0: 2752 case 0xa: /* Linked command complete without error and linked normally */ 2753 case 0xb: /* Linked command complete without error interrupt generated */ 2754 cblk->hastat = 0; 2755 break; 2756 2757 case 0x11: /* Selection time out-The initiator selection or target 2758 reselection was not complete within the SCSI Time out period */ 2759 cblk->hastat = DID_TIME_OUT; 2760 break; 2761 2762 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus 2763 phase sequence was requested by the target. The host adapter 2764 will generate a SCSI Reset Condition, notifying the host with 2765 a SCRD interrupt */ 2766 cblk->hastat = DID_RESET; 2767 break; 2768 2769 case 0x1a: /* SCB Aborted. 07/21/98 */ 2770 cblk->hastat = DID_ABORT; 2771 break; 2772 2773 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data 2774 than was allocated by the Data Length field or the sum of the 2775 Scatter / Gather Data Length fields. */ 2776 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */ 2777 case 0x16: /* Invalid SCB Operation Code. */ 2778 2779 default: 2780 printk("ini9100u: %x %x\n", cblk->hastat, cblk->tastat); 2781 cblk->hastat = DID_ERROR; /* Couldn't find any better */ 2782 break; 2783 } 2784 2785 cmnd->result = cblk->tastat | (cblk->hastat << 16); 2786 i91u_unmap_scb(host->pci_dev, cmnd); 2787 scsi_done(cmnd); /* Notify system DONE */ 2788 initio_release_scb(host, cblk); /* Release SCB for current channel */ 2789 } 2790 2791 static struct scsi_host_template initio_template = { 2792 .proc_name = "INI9100U", 2793 .name = "Initio INI-9X00U/UW SCSI device driver", 2794 .queuecommand = i91u_queuecommand, 2795 .eh_bus_reset_handler = i91u_bus_reset, 2796 .bios_param = i91u_biosparam, 2797 .can_queue = MAX_TARGETS * i91u_MAXQUEUE, 2798 .this_id = 1, 2799 .sg_tablesize = SG_ALL, 2800 .cmd_size = sizeof(struct initio_cmd_priv), 2801 }; 2802 2803 static int initio_probe_one(struct pci_dev *pdev, 2804 const struct pci_device_id *id) 2805 { 2806 struct Scsi_Host *shost; 2807 struct initio_host *host; 2808 u32 reg; 2809 u16 bios_seg; 2810 struct scsi_ctrl_blk *scb, *tmp, *prev = NULL /* silence gcc */; 2811 int num_scb, i, error; 2812 2813 error = pci_enable_device(pdev); 2814 if (error) 2815 return error; 2816 2817 pci_read_config_dword(pdev, 0x44, (u32 *) & reg); 2818 bios_seg = (u16) (reg & 0xFF); 2819 if (((reg & 0xFF00) >> 8) == 0xFF) 2820 reg = 0; 2821 bios_seg = (bios_seg << 8) + ((u16) ((reg & 0xFF00) >> 8)); 2822 2823 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) { 2824 printk(KERN_WARNING "i91u: Could not set 32 bit DMA mask\n"); 2825 error = -ENODEV; 2826 goto out_disable_device; 2827 } 2828 shost = scsi_host_alloc(&initio_template, sizeof(struct initio_host)); 2829 if (!shost) { 2830 printk(KERN_WARNING "initio: Could not allocate host structure.\n"); 2831 error = -ENOMEM; 2832 goto out_disable_device; 2833 } 2834 host = (struct initio_host *)shost->hostdata; 2835 memset(host, 0, sizeof(struct initio_host)); 2836 host->addr = pci_resource_start(pdev, 0); 2837 host->bios_addr = bios_seg; 2838 2839 if (!request_region(host->addr, 256, "i91u")) { 2840 printk(KERN_WARNING "initio: I/O port range 0x%x is busy.\n", host->addr); 2841 error = -ENODEV; 2842 goto out_host_put; 2843 } 2844 2845 if (initio_tag_enable) /* 1.01i */ 2846 num_scb = MAX_TARGETS * i91u_MAXQUEUE; 2847 else 2848 num_scb = MAX_TARGETS + 3; /* 1-tape, 1-CD_ROM, 1- extra */ 2849 2850 for (; num_scb >= MAX_TARGETS + 3; num_scb--) { 2851 i = num_scb * sizeof(struct scsi_ctrl_blk); 2852 scb = kzalloc(i, GFP_KERNEL); 2853 if (scb) 2854 break; 2855 } 2856 2857 if (!scb) { 2858 printk(KERN_WARNING "initio: Cannot allocate SCB array.\n"); 2859 error = -ENOMEM; 2860 goto out_release_region; 2861 } 2862 2863 host->pci_dev = pdev; 2864 2865 host->semaph = 1; 2866 spin_lock_init(&host->semaph_lock); 2867 host->num_scbs = num_scb; 2868 host->scb = scb; 2869 host->next_pending = scb; 2870 host->next_avail = scb; 2871 for (i = 0, tmp = scb; i < num_scb; i++, tmp++) { 2872 tmp->tagid = i; 2873 if (i != 0) 2874 prev->next = tmp; 2875 prev = tmp; 2876 } 2877 prev->next = NULL; 2878 host->scb_end = tmp; 2879 host->first_avail = scb; 2880 host->last_avail = prev; 2881 spin_lock_init(&host->avail_lock); 2882 2883 initio_init(host, phys_to_virt(((u32)bios_seg << 4))); 2884 2885 host->jsstatus0 = 0; 2886 2887 shost->io_port = host->addr; 2888 shost->n_io_port = 0xff; 2889 shost->can_queue = num_scb; /* 03/05/98 */ 2890 shost->unique_id = host->addr; 2891 shost->max_id = host->max_tar; 2892 shost->max_lun = 32; /* 10/21/97 */ 2893 shost->irq = pdev->irq; 2894 shost->this_id = host->scsi_id; /* Assign HCS index */ 2895 shost->base = host->addr; 2896 shost->sg_tablesize = TOTAL_SG_ENTRY; 2897 2898 error = request_irq(pdev->irq, i91u_intr, IRQF_SHARED, "i91u", shost); 2899 if (error < 0) { 2900 printk(KERN_WARNING "initio: Unable to request IRQ %d\n", pdev->irq); 2901 goto out_free_scbs; 2902 } 2903 2904 pci_set_drvdata(pdev, shost); 2905 2906 error = scsi_add_host(shost, &pdev->dev); 2907 if (error) 2908 goto out_free_irq; 2909 scsi_scan_host(shost); 2910 return 0; 2911 out_free_irq: 2912 free_irq(pdev->irq, shost); 2913 out_free_scbs: 2914 kfree(host->scb); 2915 out_release_region: 2916 release_region(host->addr, 256); 2917 out_host_put: 2918 scsi_host_put(shost); 2919 out_disable_device: 2920 pci_disable_device(pdev); 2921 return error; 2922 } 2923 2924 /** 2925 * initio_remove_one - control shutdown 2926 * @pdev: PCI device being released 2927 * 2928 * Release the resources assigned to this adapter after it has 2929 * finished being used. 2930 */ 2931 2932 static void initio_remove_one(struct pci_dev *pdev) 2933 { 2934 struct Scsi_Host *host = pci_get_drvdata(pdev); 2935 struct initio_host *s = (struct initio_host *)host->hostdata; 2936 scsi_remove_host(host); 2937 free_irq(pdev->irq, host); 2938 release_region(s->addr, 256); 2939 scsi_host_put(host); 2940 pci_disable_device(pdev); 2941 } 2942 2943 MODULE_LICENSE("GPL"); 2944 2945 static struct pci_device_id initio_pci_tbl[] = { 2946 {PCI_VENDOR_ID_INIT, 0x9500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2947 {PCI_VENDOR_ID_INIT, 0x9400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2948 {PCI_VENDOR_ID_INIT, 0x9401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2949 {PCI_VENDOR_ID_INIT, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2950 {PCI_VENDOR_ID_DOMEX, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2951 {0,} 2952 }; 2953 MODULE_DEVICE_TABLE(pci, initio_pci_tbl); 2954 2955 static struct pci_driver initio_pci_driver = { 2956 .name = "initio", 2957 .id_table = initio_pci_tbl, 2958 .probe = initio_probe_one, 2959 .remove = initio_remove_one, 2960 }; 2961 module_pci_driver(initio_pci_driver); 2962 2963 MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver"); 2964 MODULE_AUTHOR("Initio Corporation"); 2965 MODULE_LICENSE("GPL"); 2966