1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * NCR 5380 generic driver routines. These should make it *trivial* 41da177e4SLinus Torvalds * to implement 5380 SCSI drivers under Linux with a non-trantor 51da177e4SLinus Torvalds * architecture. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Note that these routines also work with NR53c400 family chips. 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * Copyright 1993, Drew Eckhardt 101da177e4SLinus Torvalds * Visionary Computing 111da177e4SLinus Torvalds * (Unix and Linux consulting and custom programming) 121da177e4SLinus Torvalds * drew@colorado.edu 131da177e4SLinus Torvalds * +1 (303) 666-5836 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * For more information, please consult 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * NCR 5380 Family 181da177e4SLinus Torvalds * SCSI Protocol Controller 191da177e4SLinus Torvalds * Databook 201da177e4SLinus Torvalds * 211da177e4SLinus Torvalds * NCR Microelectronics 221da177e4SLinus Torvalds * 1635 Aeroplaza Drive 231da177e4SLinus Torvalds * Colorado Springs, CO 80916 241da177e4SLinus Torvalds * 1+ (719) 578-3400 251da177e4SLinus Torvalds * 1+ (800) 334-5454 261da177e4SLinus Torvalds */ 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds /* 29c16df32eSFinn Thain * With contributions from Ray Van Tassle, Ingmar Baumgart, 30c16df32eSFinn Thain * Ronald van Cuijlenborg, Alan Cox and others. 311da177e4SLinus Torvalds */ 321da177e4SLinus Torvalds 3352d3e561SFinn Thain /* Ported to Atari by Roman Hodek and others. */ 3452d3e561SFinn Thain 35e9db3198SFinn Thain /* Adapted for the Sun 3 by Sam Creasey. */ 36e9db3198SFinn Thain 371da177e4SLinus Torvalds /* 381da177e4SLinus Torvalds * Design 391da177e4SLinus Torvalds * 401da177e4SLinus Torvalds * This is a generic 5380 driver. To use it on a different platform, 411da177e4SLinus Torvalds * one simply writes appropriate system specific macros (ie, data 421da177e4SLinus Torvalds * transfer - some PC's will use the I/O bus, 68K's must use 431da177e4SLinus Torvalds * memory mapped) and drops this file in their 'C' wrapper. 441da177e4SLinus Torvalds * 451da177e4SLinus Torvalds * As far as command queueing, two queues are maintained for 461da177e4SLinus Torvalds * each 5380 in the system - commands that haven't been issued yet, 471da177e4SLinus Torvalds * and commands that are currently executing. This means that an 481da177e4SLinus Torvalds * unlimited number of commands may be queued, letting 491da177e4SLinus Torvalds * more commands propagate from the higher driver levels giving higher 501da177e4SLinus Torvalds * throughput. Note that both I_T_L and I_T_L_Q nexuses are supported, 511da177e4SLinus Torvalds * allowing multiple commands to propagate all the way to a SCSI-II device 521da177e4SLinus Torvalds * while a command is already executing. 531da177e4SLinus Torvalds * 541da177e4SLinus Torvalds * 551da177e4SLinus Torvalds * Issues specific to the NCR5380 : 561da177e4SLinus Torvalds * 571da177e4SLinus Torvalds * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead 581da177e4SLinus Torvalds * piece of hardware that requires you to sit in a loop polling for 591da177e4SLinus Torvalds * the REQ signal as long as you are connected. Some devices are 601da177e4SLinus Torvalds * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect 61686f3990SFinn Thain * while doing long seek operations. [...] These 621da177e4SLinus Torvalds * broken devices are the exception rather than the rule and I'd rather 631da177e4SLinus Torvalds * spend my time optimizing for the normal case. 641da177e4SLinus Torvalds * 651da177e4SLinus Torvalds * Architecture : 661da177e4SLinus Torvalds * 671da177e4SLinus Torvalds * At the heart of the design is a coroutine, NCR5380_main, 681da177e4SLinus Torvalds * which is started from a workqueue for each NCR5380 host in the 691da177e4SLinus Torvalds * system. It attempts to establish I_T_L or I_T_L_Q nexuses by 701da177e4SLinus Torvalds * removing the commands from the issue queue and calling 711da177e4SLinus Torvalds * NCR5380_select() if a nexus is not established. 721da177e4SLinus Torvalds * 731da177e4SLinus Torvalds * Once a nexus is established, the NCR5380_information_transfer() 741da177e4SLinus Torvalds * phase goes through the various phases as instructed by the target. 751da177e4SLinus Torvalds * if the target goes into MSG IN and sends a DISCONNECT message, 761da177e4SLinus Torvalds * the command structure is placed into the per instance disconnected 771da177e4SLinus Torvalds * queue, and NCR5380_main tries to find more work. If the target is 781da177e4SLinus Torvalds * idle for too long, the system will try to sleep. 791da177e4SLinus Torvalds * 801da177e4SLinus Torvalds * If a command has disconnected, eventually an interrupt will trigger, 811da177e4SLinus Torvalds * calling NCR5380_intr() which will in turn call NCR5380_reselect 821da177e4SLinus Torvalds * to reestablish a nexus. This will run main if necessary. 831da177e4SLinus Torvalds * 841da177e4SLinus Torvalds * On command termination, the done function will be called as 851da177e4SLinus Torvalds * appropriate. 861da177e4SLinus Torvalds * 871da177e4SLinus Torvalds * SCSI pointers are maintained in the SCp field of SCSI command 881da177e4SLinus Torvalds * structures, being initialized after the command is connected 891da177e4SLinus Torvalds * in NCR5380_select, and set as appropriate in NCR5380_information_transfer. 901da177e4SLinus Torvalds * Note that in violation of the standard, an implicit SAVE POINTERS operation 911da177e4SLinus Torvalds * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS. 921da177e4SLinus Torvalds */ 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* 951da177e4SLinus Torvalds * Using this file : 961da177e4SLinus Torvalds * This file a skeleton Linux SCSI driver for the NCR 5380 series 971da177e4SLinus Torvalds * of chips. To use it, you write an architecture specific functions 981da177e4SLinus Torvalds * and macros and include this file in your driver. 991da177e4SLinus Torvalds * 1001da177e4SLinus Torvalds * These macros MUST be defined : 1011da177e4SLinus Torvalds * 1021da177e4SLinus Torvalds * NCR5380_read(register) - read from the specified register 1031da177e4SLinus Torvalds * 1041da177e4SLinus Torvalds * NCR5380_write(register, value) - write to the specific register 1051da177e4SLinus Torvalds * 1061da177e4SLinus Torvalds * NCR5380_implementation_fields - additional fields needed for this 1071da177e4SLinus Torvalds * specific implementation of the NCR5380 1081da177e4SLinus Torvalds * 1091da177e4SLinus Torvalds * Either real DMA *or* pseudo DMA may be implemented 1101da177e4SLinus Torvalds * 1114a98f896SFinn Thain * NCR5380_dma_xfer_len - determine size of DMA/PDMA transfer 1124a98f896SFinn Thain * NCR5380_dma_send_setup - execute DMA/PDMA from memory to 5380 1134a98f896SFinn Thain * NCR5380_dma_recv_setup - execute DMA/PDMA from 5380 to memory 1144a98f896SFinn Thain * NCR5380_dma_residual - residual byte count 1151da177e4SLinus Torvalds * 1161da177e4SLinus Torvalds * The generic driver is initialized by calling NCR5380_init(instance), 117906e4a3cSOndrej Zary * after setting the appropriate host specific fields and ID. 1181da177e4SLinus Torvalds */ 1191da177e4SLinus Torvalds 120e5d55d1aSFinn Thain #ifndef NCR5380_io_delay 121e5d55d1aSFinn Thain #define NCR5380_io_delay(x) 122e5d55d1aSFinn Thain #endif 123e5d55d1aSFinn Thain 12452d3e561SFinn Thain #ifndef NCR5380_acquire_dma_irq 12552d3e561SFinn Thain #define NCR5380_acquire_dma_irq(x) (1) 12652d3e561SFinn Thain #endif 12752d3e561SFinn Thain 12852d3e561SFinn Thain #ifndef NCR5380_release_dma_irq 12952d3e561SFinn Thain #define NCR5380_release_dma_irq(x) 13052d3e561SFinn Thain #endif 13152d3e561SFinn Thain 13254d8fe44SFinn Thain static int do_abort(struct Scsi_Host *); 13354d8fe44SFinn Thain static void do_reset(struct Scsi_Host *); 1346b0e87a6SFinn Thain static void bus_reset_cleanup(struct Scsi_Host *); 1351da177e4SLinus Torvalds 136c16df32eSFinn Thain /** 1371da177e4SLinus Torvalds * initialize_SCp - init the scsi pointer field 1381da177e4SLinus Torvalds * @cmd: command block to set up 1391da177e4SLinus Torvalds * 1401da177e4SLinus Torvalds * Set up the internal fields in the SCSI command. 1411da177e4SLinus Torvalds */ 1421da177e4SLinus Torvalds 143710ddd0dSFinn Thain static inline void initialize_SCp(struct scsi_cmnd *cmd) 1441da177e4SLinus Torvalds { 1451da177e4SLinus Torvalds /* 1461da177e4SLinus Torvalds * Initialize the Scsi Pointer field so that all of the commands in the 1471da177e4SLinus Torvalds * various queues are valid. 1481da177e4SLinus Torvalds */ 1491da177e4SLinus Torvalds 1509e0fe44dSBoaz Harrosh if (scsi_bufflen(cmd)) { 1519e0fe44dSBoaz Harrosh cmd->SCp.buffer = scsi_sglist(cmd); 15245711f1aSJens Axboe cmd->SCp.ptr = sg_virt(cmd->SCp.buffer); 1531da177e4SLinus Torvalds cmd->SCp.this_residual = cmd->SCp.buffer->length; 1541da177e4SLinus Torvalds } else { 1551da177e4SLinus Torvalds cmd->SCp.buffer = NULL; 1569e0fe44dSBoaz Harrosh cmd->SCp.ptr = NULL; 1579e0fe44dSBoaz Harrosh cmd->SCp.this_residual = 0; 1581da177e4SLinus Torvalds } 159f27db8ebSFinn Thain 160f27db8ebSFinn Thain cmd->SCp.Status = 0; 161f27db8ebSFinn Thain cmd->SCp.Message = 0; 1621da177e4SLinus Torvalds } 1631da177e4SLinus Torvalds 1640e9fdd2bSFinn Thain static inline void advance_sg_buffer(struct scsi_cmnd *cmd) 1650e9fdd2bSFinn Thain { 1660e9fdd2bSFinn Thain struct scatterlist *s = cmd->SCp.buffer; 1670e9fdd2bSFinn Thain 1680e9fdd2bSFinn Thain if (!cmd->SCp.this_residual && s && !sg_is_last(s)) { 1690e9fdd2bSFinn Thain cmd->SCp.buffer = sg_next(s); 1700e9fdd2bSFinn Thain cmd->SCp.ptr = sg_virt(cmd->SCp.buffer); 1710e9fdd2bSFinn Thain cmd->SCp.this_residual = cmd->SCp.buffer->length; 1720e9fdd2bSFinn Thain } 1730e9fdd2bSFinn Thain } 1740e9fdd2bSFinn Thain 175350767f2SFinn Thain static inline void set_resid_from_SCp(struct scsi_cmnd *cmd) 176350767f2SFinn Thain { 177350767f2SFinn Thain int resid = cmd->SCp.this_residual; 178350767f2SFinn Thain struct scatterlist *s = cmd->SCp.buffer; 179350767f2SFinn Thain 180350767f2SFinn Thain if (s) 181350767f2SFinn Thain while (!sg_is_last(s)) { 182350767f2SFinn Thain s = sg_next(s); 183350767f2SFinn Thain resid += s->length; 184350767f2SFinn Thain } 185350767f2SFinn Thain scsi_set_resid(cmd, resid); 186350767f2SFinn Thain } 187350767f2SFinn Thain 1881da177e4SLinus Torvalds /** 189b32ade12SFinn Thain * NCR5380_poll_politely2 - wait for two chip register values 190d5d37a0aSFinn Thain * @hostdata: host private data 191b32ade12SFinn Thain * @reg1: 5380 register to poll 192b32ade12SFinn Thain * @bit1: Bitmask to check 193b32ade12SFinn Thain * @val1: Expected value 194b32ade12SFinn Thain * @reg2: Second 5380 register to poll 195b32ade12SFinn Thain * @bit2: Second bitmask to check 196b32ade12SFinn Thain * @val2: Second expected value 1972f854b82SFinn Thain * @wait: Time-out in jiffies 1981da177e4SLinus Torvalds * 1992f854b82SFinn Thain * Polls the chip in a reasonably efficient manner waiting for an 2002f854b82SFinn Thain * event to occur. After a short quick poll we begin to yield the CPU 2012f854b82SFinn Thain * (if possible). In irq contexts the time-out is arbitrarily limited. 2022f854b82SFinn Thain * Callers may hold locks as long as they are held in irq mode. 2031da177e4SLinus Torvalds * 204b32ade12SFinn Thain * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT. 2051da177e4SLinus Torvalds */ 2061da177e4SLinus Torvalds 207d5d37a0aSFinn Thain static int NCR5380_poll_politely2(struct NCR5380_hostdata *hostdata, 20861e1ce58SFinn Thain unsigned int reg1, u8 bit1, u8 val1, 20961e1ce58SFinn Thain unsigned int reg2, u8 bit2, u8 val2, 21061e1ce58SFinn Thain unsigned long wait) 2111da177e4SLinus Torvalds { 212d4408dd7SFinn Thain unsigned long n = hostdata->poll_loops; 2132f854b82SFinn Thain unsigned long deadline = jiffies + wait; 2141da177e4SLinus Torvalds 2152f854b82SFinn Thain do { 216b32ade12SFinn Thain if ((NCR5380_read(reg1) & bit1) == val1) 217b32ade12SFinn Thain return 0; 218b32ade12SFinn Thain if ((NCR5380_read(reg2) & bit2) == val2) 2191da177e4SLinus Torvalds return 0; 2201da177e4SLinus Torvalds cpu_relax(); 2212f854b82SFinn Thain } while (n--); 2222f854b82SFinn Thain 2232f854b82SFinn Thain if (irqs_disabled() || in_interrupt()) 2242f854b82SFinn Thain return -ETIMEDOUT; 2252f854b82SFinn Thain 2262f854b82SFinn Thain /* Repeatedly sleep for 1 ms until deadline */ 2272f854b82SFinn Thain while (time_is_after_jiffies(deadline)) { 2282f854b82SFinn Thain schedule_timeout_uninterruptible(1); 229b32ade12SFinn Thain if ((NCR5380_read(reg1) & bit1) == val1) 230b32ade12SFinn Thain return 0; 231b32ade12SFinn Thain if ((NCR5380_read(reg2) & bit2) == val2) 2322f854b82SFinn Thain return 0; 2331da177e4SLinus Torvalds } 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds return -ETIMEDOUT; 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds 238185a7a1cSviro@ZenIV.linux.org.uk #if NDEBUG 2391da177e4SLinus Torvalds static struct { 2401da177e4SLinus Torvalds unsigned char mask; 2411da177e4SLinus Torvalds const char *name; 2421da177e4SLinus Torvalds } signals[] = { 2431da177e4SLinus Torvalds {SR_DBP, "PARITY"}, 2441da177e4SLinus Torvalds {SR_RST, "RST"}, 2451da177e4SLinus Torvalds {SR_BSY, "BSY"}, 2461da177e4SLinus Torvalds {SR_REQ, "REQ"}, 2471da177e4SLinus Torvalds {SR_MSG, "MSG"}, 2481da177e4SLinus Torvalds {SR_CD, "CD"}, 2491da177e4SLinus Torvalds {SR_IO, "IO"}, 2501da177e4SLinus Torvalds {SR_SEL, "SEL"}, 2511da177e4SLinus Torvalds {0, NULL} 2521da177e4SLinus Torvalds }, 2531da177e4SLinus Torvalds basrs[] = { 25412866b99SFinn Thain {BASR_END_DMA_TRANSFER, "END OF DMA"}, 25512866b99SFinn Thain {BASR_DRQ, "DRQ"}, 25612866b99SFinn Thain {BASR_PARITY_ERROR, "PARITY ERROR"}, 25712866b99SFinn Thain {BASR_IRQ, "IRQ"}, 25812866b99SFinn Thain {BASR_PHASE_MATCH, "PHASE MATCH"}, 25912866b99SFinn Thain {BASR_BUSY_ERROR, "BUSY ERROR"}, 2601da177e4SLinus Torvalds {BASR_ATN, "ATN"}, 2611da177e4SLinus Torvalds {BASR_ACK, "ACK"}, 2621da177e4SLinus Torvalds {0, NULL} 2631da177e4SLinus Torvalds }, 2641da177e4SLinus Torvalds icrs[] = { 2651da177e4SLinus Torvalds {ICR_ASSERT_RST, "ASSERT RST"}, 26612866b99SFinn Thain {ICR_ARBITRATION_PROGRESS, "ARB. IN PROGRESS"}, 26712866b99SFinn Thain {ICR_ARBITRATION_LOST, "LOST ARB."}, 2681da177e4SLinus Torvalds {ICR_ASSERT_ACK, "ASSERT ACK"}, 2691da177e4SLinus Torvalds {ICR_ASSERT_BSY, "ASSERT BSY"}, 2701da177e4SLinus Torvalds {ICR_ASSERT_SEL, "ASSERT SEL"}, 2711da177e4SLinus Torvalds {ICR_ASSERT_ATN, "ASSERT ATN"}, 2721da177e4SLinus Torvalds {ICR_ASSERT_DATA, "ASSERT DATA"}, 2731da177e4SLinus Torvalds {0, NULL} 2741da177e4SLinus Torvalds }, 2751da177e4SLinus Torvalds mrs[] = { 27612866b99SFinn Thain {MR_BLOCK_DMA_MODE, "BLOCK DMA MODE"}, 27712866b99SFinn Thain {MR_TARGET, "TARGET"}, 27812866b99SFinn Thain {MR_ENABLE_PAR_CHECK, "PARITY CHECK"}, 27912866b99SFinn Thain {MR_ENABLE_PAR_INTR, "PARITY INTR"}, 28012866b99SFinn Thain {MR_ENABLE_EOP_INTR, "EOP INTR"}, 28112866b99SFinn Thain {MR_MONITOR_BSY, "MONITOR BSY"}, 28212866b99SFinn Thain {MR_DMA_MODE, "DMA MODE"}, 28312866b99SFinn Thain {MR_ARBITRATE, "ARBITRATE"}, 2841da177e4SLinus Torvalds {0, NULL} 2851da177e4SLinus Torvalds }; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds /** 2881da177e4SLinus Torvalds * NCR5380_print - print scsi bus signals 2891da177e4SLinus Torvalds * @instance: adapter state to dump 2901da177e4SLinus Torvalds * 2911da177e4SLinus Torvalds * Print the SCSI bus signals for debugging purposes 2921da177e4SLinus Torvalds */ 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds static void NCR5380_print(struct Scsi_Host *instance) 2951da177e4SLinus Torvalds { 29661e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 2978cee3e16SFinn Thain unsigned char status, basr, mr, icr, i; 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds status = NCR5380_read(STATUS_REG); 3001da177e4SLinus Torvalds mr = NCR5380_read(MODE_REG); 3011da177e4SLinus Torvalds icr = NCR5380_read(INITIATOR_COMMAND_REG); 3021da177e4SLinus Torvalds basr = NCR5380_read(BUS_AND_STATUS_REG); 3031da177e4SLinus Torvalds 30412866b99SFinn Thain printk(KERN_DEBUG "SR = 0x%02x : ", status); 3051da177e4SLinus Torvalds for (i = 0; signals[i].mask; ++i) 3061da177e4SLinus Torvalds if (status & signals[i].mask) 30712866b99SFinn Thain printk(KERN_CONT "%s, ", signals[i].name); 30812866b99SFinn Thain printk(KERN_CONT "\nBASR = 0x%02x : ", basr); 3091da177e4SLinus Torvalds for (i = 0; basrs[i].mask; ++i) 3101da177e4SLinus Torvalds if (basr & basrs[i].mask) 31112866b99SFinn Thain printk(KERN_CONT "%s, ", basrs[i].name); 31212866b99SFinn Thain printk(KERN_CONT "\nICR = 0x%02x : ", icr); 3131da177e4SLinus Torvalds for (i = 0; icrs[i].mask; ++i) 3141da177e4SLinus Torvalds if (icr & icrs[i].mask) 31512866b99SFinn Thain printk(KERN_CONT "%s, ", icrs[i].name); 31612866b99SFinn Thain printk(KERN_CONT "\nMR = 0x%02x : ", mr); 3171da177e4SLinus Torvalds for (i = 0; mrs[i].mask; ++i) 3181da177e4SLinus Torvalds if (mr & mrs[i].mask) 31912866b99SFinn Thain printk(KERN_CONT "%s, ", mrs[i].name); 32012866b99SFinn Thain printk(KERN_CONT "\n"); 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds 3230d2cf867SFinn Thain static struct { 3240d2cf867SFinn Thain unsigned char value; 3250d2cf867SFinn Thain const char *name; 3260d2cf867SFinn Thain } phases[] = { 3270d2cf867SFinn Thain {PHASE_DATAOUT, "DATAOUT"}, 3280d2cf867SFinn Thain {PHASE_DATAIN, "DATAIN"}, 3290d2cf867SFinn Thain {PHASE_CMDOUT, "CMDOUT"}, 3300d2cf867SFinn Thain {PHASE_STATIN, "STATIN"}, 3310d2cf867SFinn Thain {PHASE_MSGOUT, "MSGOUT"}, 3320d2cf867SFinn Thain {PHASE_MSGIN, "MSGIN"}, 3330d2cf867SFinn Thain {PHASE_UNKNOWN, "UNKNOWN"} 3340d2cf867SFinn Thain }; 3351da177e4SLinus Torvalds 336c16df32eSFinn Thain /** 3371da177e4SLinus Torvalds * NCR5380_print_phase - show SCSI phase 3381da177e4SLinus Torvalds * @instance: adapter to dump 3391da177e4SLinus Torvalds * 3401da177e4SLinus Torvalds * Print the current SCSI phase for debugging purposes 3411da177e4SLinus Torvalds */ 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds static void NCR5380_print_phase(struct Scsi_Host *instance) 3441da177e4SLinus Torvalds { 34561e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 3461da177e4SLinus Torvalds unsigned char status; 3471da177e4SLinus Torvalds int i; 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds status = NCR5380_read(STATUS_REG); 3501da177e4SLinus Torvalds if (!(status & SR_REQ)) 3516a6ff4acSFinn Thain shost_printk(KERN_DEBUG, instance, "REQ not asserted, phase unknown.\n"); 3521da177e4SLinus Torvalds else { 3530d2cf867SFinn Thain for (i = 0; (phases[i].value != PHASE_UNKNOWN) && 3540d2cf867SFinn Thain (phases[i].value != (status & PHASE_MASK)); ++i) 3550d2cf867SFinn Thain ; 3566a6ff4acSFinn Thain shost_printk(KERN_DEBUG, instance, "phase %s\n", phases[i].name); 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds } 3591da177e4SLinus Torvalds #endif 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds /** 36209028461SFinn Thain * NCR5380_info - report driver and host information 3638c32513bSFinn Thain * @instance: relevant scsi host instance 3641da177e4SLinus Torvalds * 3658c32513bSFinn Thain * For use as the host template info() handler. 3661da177e4SLinus Torvalds */ 3671da177e4SLinus Torvalds 3688c32513bSFinn Thain static const char *NCR5380_info(struct Scsi_Host *instance) 3691da177e4SLinus Torvalds { 3708c32513bSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 3718c32513bSFinn Thain 3728c32513bSFinn Thain return hostdata->info; 3738c32513bSFinn Thain } 3748c32513bSFinn Thain 3751da177e4SLinus Torvalds /** 3761da177e4SLinus Torvalds * NCR5380_init - initialise an NCR5380 3771da177e4SLinus Torvalds * @instance: adapter to configure 3781da177e4SLinus Torvalds * @flags: control flags 3791da177e4SLinus Torvalds * 3801da177e4SLinus Torvalds * Initializes *instance and corresponding 5380 chip, 3811da177e4SLinus Torvalds * with flags OR'd into the initial flags value. 3821da177e4SLinus Torvalds * 3831da177e4SLinus Torvalds * Notes : I assume that the host, hostno, and id bits have been 3841da177e4SLinus Torvalds * set correctly. I don't care about the irq and other fields. 3851da177e4SLinus Torvalds * 3861da177e4SLinus Torvalds * Returns 0 for success 3871da177e4SLinus Torvalds */ 3881da177e4SLinus Torvalds 3896f039790SGreg Kroah-Hartman static int NCR5380_init(struct Scsi_Host *instance, int flags) 3901da177e4SLinus Torvalds { 391e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 392b6488f97SFinn Thain int i; 3932f854b82SFinn Thain unsigned long deadline; 394d4408dd7SFinn Thain unsigned long accesses_per_ms; 3951da177e4SLinus Torvalds 396ae5e33afSFinn Thain instance->max_lun = 7; 397ae5e33afSFinn Thain 3980d2cf867SFinn Thain hostdata->host = instance; 3991da177e4SLinus Torvalds hostdata->id_mask = 1 << instance->this_id; 4000d2cf867SFinn Thain hostdata->id_higher_mask = 0; 4011da177e4SLinus Torvalds for (i = hostdata->id_mask; i <= 0x80; i <<= 1) 4021da177e4SLinus Torvalds if (i > hostdata->id_mask) 4031da177e4SLinus Torvalds hostdata->id_higher_mask |= i; 4041da177e4SLinus Torvalds for (i = 0; i < 8; ++i) 4051da177e4SLinus Torvalds hostdata->busy[i] = 0; 406e4dec680SFinn Thain hostdata->dma_len = 0; 407e4dec680SFinn Thain 40811d2f63bSFinn Thain spin_lock_init(&hostdata->lock); 4091da177e4SLinus Torvalds hostdata->connected = NULL; 410f27db8ebSFinn Thain hostdata->sensing = NULL; 411f27db8ebSFinn Thain INIT_LIST_HEAD(&hostdata->autosense); 41232b26a10SFinn Thain INIT_LIST_HEAD(&hostdata->unissued); 41332b26a10SFinn Thain INIT_LIST_HEAD(&hostdata->disconnected); 41432b26a10SFinn Thain 41555181be8SFinn Thain hostdata->flags = flags; 4161da177e4SLinus Torvalds 4178d8601a7SFinn Thain INIT_WORK(&hostdata->main_task, NCR5380_main); 4180ad0eff9SFinn Thain hostdata->work_q = alloc_workqueue("ncr5380_%d", 4190ad0eff9SFinn Thain WQ_UNBOUND | WQ_MEM_RECLAIM, 4200ad0eff9SFinn Thain 1, instance->host_no); 4210ad0eff9SFinn Thain if (!hostdata->work_q) 4220ad0eff9SFinn Thain return -ENOMEM; 4231da177e4SLinus Torvalds 42409028461SFinn Thain snprintf(hostdata->info, sizeof(hostdata->info), 42509028461SFinn Thain "%s, irq %d, io_port 0x%lx, base 0x%lx, can_queue %d, cmd_per_lun %d, sg_tablesize %d, this_id %d, flags { %s%s%s}", 42609028461SFinn Thain instance->hostt->name, instance->irq, hostdata->io_port, 42709028461SFinn Thain hostdata->base, instance->can_queue, instance->cmd_per_lun, 42809028461SFinn Thain instance->sg_tablesize, instance->this_id, 42909028461SFinn Thain hostdata->flags & FLAG_DMA_FIXUP ? "DMA_FIXUP " : "", 43009028461SFinn Thain hostdata->flags & FLAG_NO_PSEUDO_DMA ? "NO_PSEUDO_DMA " : "", 43109028461SFinn Thain hostdata->flags & FLAG_TOSHIBA_DELAY ? "TOSHIBA_DELAY " : ""); 4328c32513bSFinn Thain 4331da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 4341da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 4351da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 4361da177e4SLinus Torvalds NCR5380_write(SELECT_ENABLE_REG, 0); 4372f854b82SFinn Thain 4382f854b82SFinn Thain /* Calibrate register polling loop */ 4392f854b82SFinn Thain i = 0; 4402f854b82SFinn Thain deadline = jiffies + 1; 4412f854b82SFinn Thain do { 4422f854b82SFinn Thain cpu_relax(); 4432f854b82SFinn Thain } while (time_is_after_jiffies(deadline)); 4442f854b82SFinn Thain deadline += msecs_to_jiffies(256); 4452f854b82SFinn Thain do { 4462f854b82SFinn Thain NCR5380_read(STATUS_REG); 4472f854b82SFinn Thain ++i; 4482f854b82SFinn Thain cpu_relax(); 4492f854b82SFinn Thain } while (time_is_after_jiffies(deadline)); 450d4408dd7SFinn Thain accesses_per_ms = i / 256; 451d4408dd7SFinn Thain hostdata->poll_loops = NCR5380_REG_POLL_TIME * accesses_per_ms / 2; 4522f854b82SFinn Thain 453b6488f97SFinn Thain return 0; 454b6488f97SFinn Thain } 4551da177e4SLinus Torvalds 456b6488f97SFinn Thain /** 457b6488f97SFinn Thain * NCR5380_maybe_reset_bus - Detect and correct bus wedge problems. 458b6488f97SFinn Thain * @instance: adapter to check 4591da177e4SLinus Torvalds * 460b6488f97SFinn Thain * If the system crashed, it may have crashed with a connected target and 461b6488f97SFinn Thain * the SCSI bus busy. Check for BUS FREE phase. If not, try to abort the 462b6488f97SFinn Thain * currently established nexus, which we know nothing about. Failing that 463b6488f97SFinn Thain * do a bus reset. 4641da177e4SLinus Torvalds * 465b6488f97SFinn Thain * Note that a bus reset will cause the chip to assert IRQ. 466b6488f97SFinn Thain * 467b6488f97SFinn Thain * Returns 0 if successful, otherwise -ENXIO. 4681da177e4SLinus Torvalds */ 4691da177e4SLinus Torvalds 470b6488f97SFinn Thain static int NCR5380_maybe_reset_bus(struct Scsi_Host *instance) 471b6488f97SFinn Thain { 4729c3f0e2bSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 473b6488f97SFinn Thain int pass; 474b6488f97SFinn Thain 4751da177e4SLinus Torvalds for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) { 4761da177e4SLinus Torvalds switch (pass) { 4771da177e4SLinus Torvalds case 1: 4781da177e4SLinus Torvalds case 3: 4791da177e4SLinus Torvalds case 5: 480636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "SCSI bus busy, waiting up to five seconds\n"); 481d5d37a0aSFinn Thain NCR5380_poll_politely(hostdata, 482636b1ec8SFinn Thain STATUS_REG, SR_BSY, 0, 5 * HZ); 4831da177e4SLinus Torvalds break; 4841da177e4SLinus Torvalds case 2: 485636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "bus busy, attempting abort\n"); 4861da177e4SLinus Torvalds do_abort(instance); 4871da177e4SLinus Torvalds break; 4881da177e4SLinus Torvalds case 4: 489636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "bus busy, attempting reset\n"); 4901da177e4SLinus Torvalds do_reset(instance); 4919c3f0e2bSFinn Thain /* Wait after a reset; the SCSI standard calls for 4929c3f0e2bSFinn Thain * 250ms, we wait 500ms to be on the safe side. 4939c3f0e2bSFinn Thain * But some Toshiba CD-ROMs need ten times that. 4949c3f0e2bSFinn Thain */ 4959c3f0e2bSFinn Thain if (hostdata->flags & FLAG_TOSHIBA_DELAY) 4969c3f0e2bSFinn Thain msleep(2500); 4979c3f0e2bSFinn Thain else 4989c3f0e2bSFinn Thain msleep(500); 4991da177e4SLinus Torvalds break; 5001da177e4SLinus Torvalds case 6: 501636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "bus locked solid\n"); 5021da177e4SLinus Torvalds return -ENXIO; 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds return 0; 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds /** 5091da177e4SLinus Torvalds * NCR5380_exit - remove an NCR5380 5101da177e4SLinus Torvalds * @instance: adapter to remove 5110d2cf867SFinn Thain * 5120d2cf867SFinn Thain * Assumes that no more work can be queued (e.g. by NCR5380_intr). 5131da177e4SLinus Torvalds */ 5141da177e4SLinus Torvalds 515a43cf0f3SRandy Dunlap static void NCR5380_exit(struct Scsi_Host *instance) 5161da177e4SLinus Torvalds { 517e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 5181da177e4SLinus Torvalds 5198d8601a7SFinn Thain cancel_work_sync(&hostdata->main_task); 5200ad0eff9SFinn Thain destroy_workqueue(hostdata->work_q); 5211da177e4SLinus Torvalds } 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds /** 524677e0194SFinn Thain * complete_cmd - finish processing a command and return it to the SCSI ML 525677e0194SFinn Thain * @instance: the host instance 526677e0194SFinn Thain * @cmd: command to complete 527677e0194SFinn Thain */ 528677e0194SFinn Thain 529677e0194SFinn Thain static void complete_cmd(struct Scsi_Host *instance, 530677e0194SFinn Thain struct scsi_cmnd *cmd) 531677e0194SFinn Thain { 532677e0194SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 533677e0194SFinn Thain 534677e0194SFinn Thain dsprintk(NDEBUG_QUEUES, instance, "complete_cmd: cmd %p\n", cmd); 535677e0194SFinn Thain 536f27db8ebSFinn Thain if (hostdata->sensing == cmd) { 537f27db8ebSFinn Thain /* Autosense processing ends here */ 53807035651SFinn Thain if (status_byte(cmd->result) != GOOD) { 539f27db8ebSFinn Thain scsi_eh_restore_cmnd(cmd, &hostdata->ses); 54007035651SFinn Thain } else { 541f27db8ebSFinn Thain scsi_eh_restore_cmnd(cmd, &hostdata->ses); 54207035651SFinn Thain set_driver_byte(cmd, DRIVER_SENSE); 54307035651SFinn Thain } 544f27db8ebSFinn Thain hostdata->sensing = NULL; 545f27db8ebSFinn Thain } 546f27db8ebSFinn Thain 547677e0194SFinn Thain cmd->scsi_done(cmd); 548677e0194SFinn Thain } 549677e0194SFinn Thain 550677e0194SFinn Thain /** 5511da177e4SLinus Torvalds * NCR5380_queue_command - queue a command 5521bb40589SFinn Thain * @instance: the relevant SCSI adapter 5531da177e4SLinus Torvalds * @cmd: SCSI command 5541da177e4SLinus Torvalds * 5551bb40589SFinn Thain * cmd is added to the per-instance issue queue, with minor 5561da177e4SLinus Torvalds * twiddling done to the host specific fields of cmd. If the 5571da177e4SLinus Torvalds * main coroutine is not running, it is restarted. 5581da177e4SLinus Torvalds */ 5591da177e4SLinus Torvalds 5601bb40589SFinn Thain static int NCR5380_queue_command(struct Scsi_Host *instance, 5611bb40589SFinn Thain struct scsi_cmnd *cmd) 5621da177e4SLinus Torvalds { 5631bb40589SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 56432b26a10SFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd); 5651bb40589SFinn Thain unsigned long flags; 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds #if (NDEBUG & NDEBUG_NO_WRITE) 5681da177e4SLinus Torvalds switch (cmd->cmnd[0]) { 5691da177e4SLinus Torvalds case WRITE_6: 5701da177e4SLinus Torvalds case WRITE_10: 571dbb6b350SFinn Thain shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n"); 5721da177e4SLinus Torvalds cmd->result = (DID_ERROR << 16); 5731bb40589SFinn Thain cmd->scsi_done(cmd); 5741da177e4SLinus Torvalds return 0; 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds #endif /* (NDEBUG & NDEBUG_NO_WRITE) */ 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds cmd->result = 0; 5791da177e4SLinus Torvalds 58052d3e561SFinn Thain if (!NCR5380_acquire_dma_irq(instance)) 58152d3e561SFinn Thain return SCSI_MLQUEUE_HOST_BUSY; 58252d3e561SFinn Thain 58311d2f63bSFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 5841bb40589SFinn Thain 5851da177e4SLinus Torvalds /* 5861da177e4SLinus Torvalds * Insert the cmd into the issue queue. Note that REQUEST SENSE 5871da177e4SLinus Torvalds * commands are added to the head of the queue since any command will 5881da177e4SLinus Torvalds * clear the contingent allegiance condition that exists and the 5891da177e4SLinus Torvalds * sense data is only guaranteed to be valid while the condition exists. 5901da177e4SLinus Torvalds */ 5911da177e4SLinus Torvalds 59232b26a10SFinn Thain if (cmd->cmnd[0] == REQUEST_SENSE) 59332b26a10SFinn Thain list_add(&ncmd->list, &hostdata->unissued); 59432b26a10SFinn Thain else 59532b26a10SFinn Thain list_add_tail(&ncmd->list, &hostdata->unissued); 59632b26a10SFinn Thain 59711d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 5981bb40589SFinn Thain 599dbb6b350SFinn Thain dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n", 600dbb6b350SFinn Thain cmd, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"); 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* Kick off command processing */ 6038d8601a7SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 6041da177e4SLinus Torvalds return 0; 6051da177e4SLinus Torvalds } 6061da177e4SLinus Torvalds 60752d3e561SFinn Thain static inline void maybe_release_dma_irq(struct Scsi_Host *instance) 60852d3e561SFinn Thain { 60952d3e561SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 61052d3e561SFinn Thain 61152d3e561SFinn Thain /* Caller does the locking needed to set & test these data atomically */ 61252d3e561SFinn Thain if (list_empty(&hostdata->disconnected) && 61352d3e561SFinn Thain list_empty(&hostdata->unissued) && 61452d3e561SFinn Thain list_empty(&hostdata->autosense) && 61552d3e561SFinn Thain !hostdata->connected && 6164ab2a787SFinn Thain !hostdata->selecting) { 61752d3e561SFinn Thain NCR5380_release_dma_irq(instance); 61852d3e561SFinn Thain } 6194ab2a787SFinn Thain } 62052d3e561SFinn Thain 6211da177e4SLinus Torvalds /** 622f27db8ebSFinn Thain * dequeue_next_cmd - dequeue a command for processing 623f27db8ebSFinn Thain * @instance: the scsi host instance 624f27db8ebSFinn Thain * 625f27db8ebSFinn Thain * Priority is given to commands on the autosense queue. These commands 626f27db8ebSFinn Thain * need autosense because of a CHECK CONDITION result. 627f27db8ebSFinn Thain * 628f27db8ebSFinn Thain * Returns a command pointer if a command is found for a target that is 629f27db8ebSFinn Thain * not already busy. Otherwise returns NULL. 630f27db8ebSFinn Thain */ 631f27db8ebSFinn Thain 632f27db8ebSFinn Thain static struct scsi_cmnd *dequeue_next_cmd(struct Scsi_Host *instance) 633f27db8ebSFinn Thain { 634f27db8ebSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 635f27db8ebSFinn Thain struct NCR5380_cmd *ncmd; 636f27db8ebSFinn Thain struct scsi_cmnd *cmd; 637f27db8ebSFinn Thain 6388d5dbec3SFinn Thain if (hostdata->sensing || list_empty(&hostdata->autosense)) { 639f27db8ebSFinn Thain list_for_each_entry(ncmd, &hostdata->unissued, list) { 640f27db8ebSFinn Thain cmd = NCR5380_to_scmd(ncmd); 641f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, "dequeue: cmd=%p target=%d busy=0x%02x lun=%llu\n", 642f27db8ebSFinn Thain cmd, scmd_id(cmd), hostdata->busy[scmd_id(cmd)], cmd->device->lun); 643f27db8ebSFinn Thain 644f27db8ebSFinn Thain if (!(hostdata->busy[scmd_id(cmd)] & (1 << cmd->device->lun))) { 645f27db8ebSFinn Thain list_del(&ncmd->list); 646f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, 647f27db8ebSFinn Thain "dequeue: removed %p from issue queue\n", cmd); 648f27db8ebSFinn Thain return cmd; 649f27db8ebSFinn Thain } 650f27db8ebSFinn Thain } 651f27db8ebSFinn Thain } else { 652f27db8ebSFinn Thain /* Autosense processing begins here */ 653f27db8ebSFinn Thain ncmd = list_first_entry(&hostdata->autosense, 654f27db8ebSFinn Thain struct NCR5380_cmd, list); 655f27db8ebSFinn Thain list_del(&ncmd->list); 656f27db8ebSFinn Thain cmd = NCR5380_to_scmd(ncmd); 657f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, 658f27db8ebSFinn Thain "dequeue: removed %p from autosense queue\n", cmd); 659f27db8ebSFinn Thain scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0); 660f27db8ebSFinn Thain hostdata->sensing = cmd; 661f27db8ebSFinn Thain return cmd; 662f27db8ebSFinn Thain } 663f27db8ebSFinn Thain return NULL; 664f27db8ebSFinn Thain } 665f27db8ebSFinn Thain 666f27db8ebSFinn Thain static void requeue_cmd(struct Scsi_Host *instance, struct scsi_cmnd *cmd) 667f27db8ebSFinn Thain { 668f27db8ebSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 669f27db8ebSFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd); 670f27db8ebSFinn Thain 6718d5dbec3SFinn Thain if (hostdata->sensing == cmd) { 672f27db8ebSFinn Thain scsi_eh_restore_cmnd(cmd, &hostdata->ses); 673f27db8ebSFinn Thain list_add(&ncmd->list, &hostdata->autosense); 674f27db8ebSFinn Thain hostdata->sensing = NULL; 675f27db8ebSFinn Thain } else 676f27db8ebSFinn Thain list_add(&ncmd->list, &hostdata->unissued); 677f27db8ebSFinn Thain } 678f27db8ebSFinn Thain 679f27db8ebSFinn Thain /** 6801da177e4SLinus Torvalds * NCR5380_main - NCR state machines 6811da177e4SLinus Torvalds * 6821da177e4SLinus Torvalds * NCR5380_main is a coroutine that runs as long as more work can 6831da177e4SLinus Torvalds * be done on the NCR5380 host adapters in a system. Both 6841da177e4SLinus Torvalds * NCR5380_queue_command() and NCR5380_intr() will try to start it 6851da177e4SLinus Torvalds * in case it is not running. 6861da177e4SLinus Torvalds */ 6871da177e4SLinus Torvalds 688c4028958SDavid Howells static void NCR5380_main(struct work_struct *work) 6891da177e4SLinus Torvalds { 690c4028958SDavid Howells struct NCR5380_hostdata *hostdata = 6918d8601a7SFinn Thain container_of(work, struct NCR5380_hostdata, main_task); 6921da177e4SLinus Torvalds struct Scsi_Host *instance = hostdata->host; 6931da177e4SLinus Torvalds int done; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds do { 6961da177e4SLinus Torvalds done = 1; 69711d2f63bSFinn Thain 6980a4e3612SFinn Thain spin_lock_irq(&hostdata->lock); 699ccf6efd7SFinn Thain while (!hostdata->connected && !hostdata->selecting) { 700ccf6efd7SFinn Thain struct scsi_cmnd *cmd = dequeue_next_cmd(instance); 701ccf6efd7SFinn Thain 702ccf6efd7SFinn Thain if (!cmd) 703ccf6efd7SFinn Thain break; 70432b26a10SFinn Thain 705f27db8ebSFinn Thain dsprintk(NDEBUG_MAIN, instance, "main: dequeued %p\n", cmd); 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds /* 7081da177e4SLinus Torvalds * Attempt to establish an I_T_L nexus here. 7091da177e4SLinus Torvalds * On success, instance->hostdata->connected is set. 7101da177e4SLinus Torvalds * On failure, we must add the command back to the 7111da177e4SLinus Torvalds * issue queue so we can keep trying. 7121da177e4SLinus Torvalds */ 7131da177e4SLinus Torvalds /* 7141da177e4SLinus Torvalds * REQUEST SENSE commands are issued without tagged 7151da177e4SLinus Torvalds * queueing, even on SCSI-II devices because the 7161da177e4SLinus Torvalds * contingent allegiance condition exists for the 7171da177e4SLinus Torvalds * entire unit. 7181da177e4SLinus Torvalds */ 71976f13b93SFinn Thain 720ccf6efd7SFinn Thain if (!NCR5380_select(instance, cmd)) { 721707d62b3SFinn Thain dsprintk(NDEBUG_MAIN, instance, "main: select complete\n"); 72252d3e561SFinn Thain maybe_release_dma_irq(instance); 7231da177e4SLinus Torvalds } else { 724f27db8ebSFinn Thain dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, instance, 725f27db8ebSFinn Thain "main: select failed, returning %p to queue\n", cmd); 726f27db8ebSFinn Thain requeue_cmd(instance, cmd); 7271da177e4SLinus Torvalds } 728f27db8ebSFinn Thain } 729e4dec680SFinn Thain if (hostdata->connected && !hostdata->dma_len) { 730b746545fSFinn Thain dsprintk(NDEBUG_MAIN, instance, "main: performing information transfer\n"); 7311da177e4SLinus Torvalds NCR5380_information_transfer(instance); 7321da177e4SLinus Torvalds done = 0; 7331d3db59dSFinn Thain } 73457f31326SFinn Thain if (!hostdata->connected) 73557f31326SFinn Thain NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 73611d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 7370a4e3612SFinn Thain if (!done) 7380a4e3612SFinn Thain cond_resched(); 7390a4e3612SFinn Thain } while (!done); 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds 7428053b0eeSFinn Thain /* 7438053b0eeSFinn Thain * NCR5380_dma_complete - finish DMA transfer 7448053b0eeSFinn Thain * @instance: the scsi host instance 7458053b0eeSFinn Thain * 7468053b0eeSFinn Thain * Called by the interrupt handler when DMA finishes or a phase 7478053b0eeSFinn Thain * mismatch occurs (which would end the DMA transfer). 7488053b0eeSFinn Thain */ 7498053b0eeSFinn Thain 7508053b0eeSFinn Thain static void NCR5380_dma_complete(struct Scsi_Host *instance) 7518053b0eeSFinn Thain { 7528053b0eeSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 7538053b0eeSFinn Thain int transferred; 7548053b0eeSFinn Thain unsigned char **data; 7558053b0eeSFinn Thain int *count; 7568053b0eeSFinn Thain int saved_data = 0, overrun = 0; 7578053b0eeSFinn Thain unsigned char p; 7588053b0eeSFinn Thain 7598053b0eeSFinn Thain if (hostdata->read_overruns) { 7608053b0eeSFinn Thain p = hostdata->connected->SCp.phase; 7618053b0eeSFinn Thain if (p & SR_IO) { 7628053b0eeSFinn Thain udelay(10); 7638053b0eeSFinn Thain if ((NCR5380_read(BUS_AND_STATUS_REG) & 7648053b0eeSFinn Thain (BASR_PHASE_MATCH | BASR_ACK)) == 7658053b0eeSFinn Thain (BASR_PHASE_MATCH | BASR_ACK)) { 7668053b0eeSFinn Thain saved_data = NCR5380_read(INPUT_DATA_REG); 7678053b0eeSFinn Thain overrun = 1; 7688053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, "read overrun handled\n"); 7698053b0eeSFinn Thain } 7708053b0eeSFinn Thain } 7718053b0eeSFinn Thain } 7728053b0eeSFinn Thain 773e9db3198SFinn Thain #ifdef CONFIG_SUN3 774e9db3198SFinn Thain if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) { 775e9db3198SFinn Thain pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n", 776e9db3198SFinn Thain instance->host_no); 777e9db3198SFinn Thain BUG(); 778e9db3198SFinn Thain } 779e9db3198SFinn Thain 780e9db3198SFinn Thain if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) == 781e9db3198SFinn Thain (BASR_PHASE_MATCH | BASR_ACK)) { 782e9db3198SFinn Thain pr_err("scsi%d: BASR %02x\n", instance->host_no, 783e9db3198SFinn Thain NCR5380_read(BUS_AND_STATUS_REG)); 784e9db3198SFinn Thain pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n", 785e9db3198SFinn Thain instance->host_no); 786e9db3198SFinn Thain BUG(); 787e9db3198SFinn Thain } 788e9db3198SFinn Thain #endif 789e9db3198SFinn Thain 7908053b0eeSFinn Thain NCR5380_write(MODE_REG, MR_BASE); 7918053b0eeSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 7928053b0eeSFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 7938053b0eeSFinn Thain 7944a98f896SFinn Thain transferred = hostdata->dma_len - NCR5380_dma_residual(hostdata); 7958053b0eeSFinn Thain hostdata->dma_len = 0; 7968053b0eeSFinn Thain 7978053b0eeSFinn Thain data = (unsigned char **)&hostdata->connected->SCp.ptr; 7988053b0eeSFinn Thain count = &hostdata->connected->SCp.this_residual; 7998053b0eeSFinn Thain *data += transferred; 8008053b0eeSFinn Thain *count -= transferred; 8018053b0eeSFinn Thain 8028053b0eeSFinn Thain if (hostdata->read_overruns) { 8038053b0eeSFinn Thain int cnt, toPIO; 8048053b0eeSFinn Thain 8058053b0eeSFinn Thain if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) { 8068053b0eeSFinn Thain cnt = toPIO = hostdata->read_overruns; 8078053b0eeSFinn Thain if (overrun) { 8088053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, 8098053b0eeSFinn Thain "Got an input overrun, using saved byte\n"); 8108053b0eeSFinn Thain *(*data)++ = saved_data; 8118053b0eeSFinn Thain (*count)--; 8128053b0eeSFinn Thain cnt--; 8138053b0eeSFinn Thain toPIO--; 8148053b0eeSFinn Thain } 8158053b0eeSFinn Thain if (toPIO > 0) { 8168053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, 8178053b0eeSFinn Thain "Doing %d byte PIO to 0x%p\n", cnt, *data); 8188053b0eeSFinn Thain NCR5380_transfer_pio(instance, &p, &cnt, data); 8198053b0eeSFinn Thain *count -= toPIO - cnt; 8208053b0eeSFinn Thain } 8218053b0eeSFinn Thain } 8228053b0eeSFinn Thain } 8238053b0eeSFinn Thain } 8248053b0eeSFinn Thain 8251da177e4SLinus Torvalds /** 8261da177e4SLinus Torvalds * NCR5380_intr - generic NCR5380 irq handler 8271da177e4SLinus Torvalds * @irq: interrupt number 8281da177e4SLinus Torvalds * @dev_id: device info 8291da177e4SLinus Torvalds * 8301da177e4SLinus Torvalds * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses 8311da177e4SLinus Torvalds * from the disconnected queue, and restarting NCR5380_main() 8321da177e4SLinus Torvalds * as required. 8331da177e4SLinus Torvalds * 834cd400825SFinn Thain * The chip can assert IRQ in any of six different conditions. The IRQ flag 835cd400825SFinn Thain * is then cleared by reading the Reset Parity/Interrupt Register (RPIR). 836cd400825SFinn Thain * Three of these six conditions are latched in the Bus and Status Register: 837cd400825SFinn Thain * - End of DMA (cleared by ending DMA Mode) 838cd400825SFinn Thain * - Parity error (cleared by reading RPIR) 839cd400825SFinn Thain * - Loss of BSY (cleared by reading RPIR) 840cd400825SFinn Thain * Two conditions have flag bits that are not latched: 841cd400825SFinn Thain * - Bus phase mismatch (non-maskable in DMA Mode, cleared by ending DMA Mode) 842cd400825SFinn Thain * - Bus reset (non-maskable) 843cd400825SFinn Thain * The remaining condition has no flag bit at all: 844cd400825SFinn Thain * - Selection/reselection 845cd400825SFinn Thain * 846cd400825SFinn Thain * Hence, establishing the cause(s) of any interrupt is partly guesswork. 847cd400825SFinn Thain * In "The DP8490 and DP5380 Comparison Guide", National Semiconductor 848cd400825SFinn Thain * claimed that "the design of the [DP8490] interrupt logic ensures 849cd400825SFinn Thain * interrupts will not be lost (they can be on the DP5380)." 850cd400825SFinn Thain * The L5380/53C80 datasheet from LOGIC Devices has more details. 851cd400825SFinn Thain * 852cd400825SFinn Thain * Checking for bus reset by reading RST is futile because of interrupt 853cd400825SFinn Thain * latency, but a bus reset will reset chip logic. Checking for parity error 854cd400825SFinn Thain * is unnecessary because that interrupt is never enabled. A Loss of BSY 855cd400825SFinn Thain * condition will clear DMA Mode. We can tell when this occurs because the 856cd400825SFinn Thain * the Busy Monitor interrupt is enabled together with DMA Mode. 8571da177e4SLinus Torvalds */ 8581da177e4SLinus Torvalds 859a46865dcSFinn Thain static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id) 8601da177e4SLinus Torvalds { 861baa9aac6SJeff Garzik struct Scsi_Host *instance = dev_id; 862cd400825SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 863cd400825SFinn Thain int handled = 0; 8641da177e4SLinus Torvalds unsigned char basr; 8651da177e4SLinus Torvalds unsigned long flags; 8661da177e4SLinus Torvalds 86711d2f63bSFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 868cd400825SFinn Thain 8691da177e4SLinus Torvalds basr = NCR5380_read(BUS_AND_STATUS_REG); 8701da177e4SLinus Torvalds if (basr & BASR_IRQ) { 871cd400825SFinn Thain unsigned char mr = NCR5380_read(MODE_REG); 872cd400825SFinn Thain unsigned char sr = NCR5380_read(STATUS_REG); 873cd400825SFinn Thain 874b746545fSFinn Thain dsprintk(NDEBUG_INTR, instance, "IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n", 875b746545fSFinn Thain irq, basr, sr, mr); 876cd400825SFinn Thain 8778053b0eeSFinn Thain if ((mr & MR_DMA_MODE) || (mr & MR_MONITOR_BSY)) { 8788053b0eeSFinn Thain /* Probably End of DMA, Phase Mismatch or Loss of BSY. 8798053b0eeSFinn Thain * We ack IRQ after clearing Mode Register. Workarounds 8808053b0eeSFinn Thain * for End of DMA errata need to happen in DMA Mode. 8818053b0eeSFinn Thain */ 8828053b0eeSFinn Thain 8838053b0eeSFinn Thain dsprintk(NDEBUG_INTR, instance, "interrupt in DMA mode\n"); 8848053b0eeSFinn Thain 8858053b0eeSFinn Thain if (hostdata->connected) { 8868053b0eeSFinn Thain NCR5380_dma_complete(instance); 8878053b0eeSFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 8888053b0eeSFinn Thain } else { 8898053b0eeSFinn Thain NCR5380_write(MODE_REG, MR_BASE); 8908053b0eeSFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 8918053b0eeSFinn Thain } 8928053b0eeSFinn Thain } else if ((NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_mask) && 893cd400825SFinn Thain (sr & (SR_SEL | SR_IO | SR_BSY | SR_RST)) == (SR_SEL | SR_IO)) { 894cd400825SFinn Thain /* Probably reselected */ 895cd400825SFinn Thain NCR5380_write(SELECT_ENABLE_REG, 0); 896cd400825SFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 897cd400825SFinn Thain 898b746545fSFinn Thain dsprintk(NDEBUG_INTR, instance, "interrupt with SEL and IO\n"); 899cd400825SFinn Thain 900cd400825SFinn Thain if (!hostdata->connected) { 901cd400825SFinn Thain NCR5380_reselect(instance); 9028d8601a7SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 903cd400825SFinn Thain } 904cd400825SFinn Thain if (!hostdata->connected) 905cd400825SFinn Thain NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 906cd400825SFinn Thain } else { 907cd400825SFinn Thain /* Probably Bus Reset */ 908cd400825SFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 909cd400825SFinn Thain 9106b0e87a6SFinn Thain if (sr & SR_RST) { 9116b0e87a6SFinn Thain /* Certainly Bus Reset */ 9126b0e87a6SFinn Thain shost_printk(KERN_WARNING, instance, 9136b0e87a6SFinn Thain "bus reset interrupt\n"); 9146b0e87a6SFinn Thain bus_reset_cleanup(instance); 9156b0e87a6SFinn Thain } else { 916b746545fSFinn Thain dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n"); 9176b0e87a6SFinn Thain } 918e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 919e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 920e9db3198SFinn Thain #endif 921cd400825SFinn Thain } 922cd400825SFinn Thain handled = 1; 923cd400825SFinn Thain } else { 9249af9fecbSFinn Thain dsprintk(NDEBUG_INTR, instance, "interrupt without IRQ bit\n"); 925e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 926e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 927e9db3198SFinn Thain #endif 928cd400825SFinn Thain } 929cd400825SFinn Thain 93011d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 931cd400825SFinn Thain 932cd400825SFinn Thain return IRQ_RETVAL(handled); 9331da177e4SLinus Torvalds } 9341da177e4SLinus Torvalds 935dad8261eSFinn Thain /** 936dad8261eSFinn Thain * NCR5380_select - attempt arbitration and selection for a given command 937dad8261eSFinn Thain * @instance: the Scsi_Host instance 938dad8261eSFinn Thain * @cmd: the scsi_cmnd to execute 9391da177e4SLinus Torvalds * 940dad8261eSFinn Thain * This routine establishes an I_T_L nexus for a SCSI command. This involves 941dad8261eSFinn Thain * ARBITRATION, SELECTION and MESSAGE OUT phases and an IDENTIFY message. 9421da177e4SLinus Torvalds * 943dad8261eSFinn Thain * Returns true if the operation should be retried. 944dad8261eSFinn Thain * Returns false if it should not be retried. 9451da177e4SLinus Torvalds * 9461da177e4SLinus Torvalds * Side effects : 9471da177e4SLinus Torvalds * If bus busy, arbitration failed, etc, NCR5380_select() will exit 9481da177e4SLinus Torvalds * with registers as they should have been on entry - ie 9491da177e4SLinus Torvalds * SELECT_ENABLE will be set appropriately, the NCR5380 9501da177e4SLinus Torvalds * will cease to drive any SCSI bus signals. 9511da177e4SLinus Torvalds * 952dad8261eSFinn Thain * If successful : the I_T_L nexus will be established, and 953dad8261eSFinn Thain * hostdata->connected will be set to cmd. 9541da177e4SLinus Torvalds * SELECT interrupt will be disabled. 9551da177e4SLinus Torvalds * 9561da177e4SLinus Torvalds * If failed (no target) : cmd->scsi_done() will be called, and the 9571da177e4SLinus Torvalds * cmd->result host byte set to DID_BAD_TARGET. 9581da177e4SLinus Torvalds */ 9591da177e4SLinus Torvalds 960dad8261eSFinn Thain static bool NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd) 9614ab2a787SFinn Thain __releases(&hostdata->lock) __acquires(&hostdata->lock) 9621da177e4SLinus Torvalds { 963e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 9641da177e4SLinus Torvalds unsigned char tmp[3], phase; 9651da177e4SLinus Torvalds unsigned char *data; 9661da177e4SLinus Torvalds int len; 9671da177e4SLinus Torvalds int err; 968dad8261eSFinn Thain bool ret = true; 9697c8ed783SFinn Thain bool can_disconnect = instance->irq != NO_IRQ && 9707c8ed783SFinn Thain cmd->cmnd[0] != REQUEST_SENSE; 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_ARBITRATION, instance); 973b746545fSFinn Thain dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n", 974b746545fSFinn Thain instance->this_id); 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds /* 977707d62b3SFinn Thain * Arbitration and selection phases are slow and involve dropping the 978707d62b3SFinn Thain * lock, so we have to watch out for EH. An exception handler may 979dad8261eSFinn Thain * change 'selecting' to NULL. This function will then return false 980707d62b3SFinn Thain * so that the caller will forget about 'cmd'. (During information 981707d62b3SFinn Thain * transfer phases, EH may change 'connected' to NULL.) 982707d62b3SFinn Thain */ 983707d62b3SFinn Thain hostdata->selecting = cmd; 984707d62b3SFinn Thain 985707d62b3SFinn Thain /* 9861da177e4SLinus Torvalds * Set the phase bits to 0, otherwise the NCR5380 won't drive the 9871da177e4SLinus Torvalds * data bus during SELECTION. 9881da177e4SLinus Torvalds */ 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds /* 9931da177e4SLinus Torvalds * Start arbitration. 9941da177e4SLinus Torvalds */ 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask); 9971da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_ARBITRATE); 9981da177e4SLinus Torvalds 99955500d9bSFinn Thain /* The chip now waits for BUS FREE phase. Then after the 800 ns 100055500d9bSFinn Thain * Bus Free Delay, arbitration will begin. 10011da177e4SLinus Torvalds */ 10021da177e4SLinus Torvalds 100311d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 1004d5d37a0aSFinn Thain err = NCR5380_poll_politely2(hostdata, MODE_REG, MR_ARBITRATE, 0, 1005b32ade12SFinn Thain INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS, 1006b32ade12SFinn Thain ICR_ARBITRATION_PROGRESS, HZ); 100711d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 100855500d9bSFinn Thain if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) { 100955500d9bSFinn Thain /* Reselection interrupt */ 1010707d62b3SFinn Thain goto out; 101155500d9bSFinn Thain } 1012ccf6efd7SFinn Thain if (!hostdata->selecting) { 1013ccf6efd7SFinn Thain /* Command was aborted */ 1014ccf6efd7SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 1015dad8261eSFinn Thain return false; 1016ccf6efd7SFinn Thain } 1017b32ade12SFinn Thain if (err < 0) { 1018b32ade12SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 1019b32ade12SFinn Thain shost_printk(KERN_ERR, instance, 1020b32ade12SFinn Thain "select: arbitration timeout\n"); 1021707d62b3SFinn Thain goto out; 102255500d9bSFinn Thain } 102311d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 102455500d9bSFinn Thain 102555500d9bSFinn Thain /* The SCSI-2 arbitration delay is 2.4 us */ 10261da177e4SLinus Torvalds udelay(3); 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds /* Check for lost arbitration */ 10290d2cf867SFinn Thain if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) || 10300d2cf867SFinn Thain (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) || 10310d2cf867SFinn Thain (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) { 10321da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 1033b746545fSFinn Thain dsprintk(NDEBUG_ARBITRATION, instance, "lost arbitration, deasserting MR_ARBITRATE\n"); 103411d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 1035707d62b3SFinn Thain goto out; 10361da177e4SLinus Torvalds } 1037cf13b083SFinn Thain 1038cf13b083SFinn Thain /* After/during arbitration, BSY should be asserted. 1039cf13b083SFinn Thain * IBM DPES-31080 Version S31Q works now 1040cf13b083SFinn Thain * Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman) 1041cf13b083SFinn Thain */ 1042cf13b083SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, 1043cf13b083SFinn Thain ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY); 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds /* 10461da177e4SLinus Torvalds * Again, bus clear + bus settle time is 1.2us, however, this is 10471da177e4SLinus Torvalds * a minimum so we'll udelay ceil(1.2) 10481da177e4SLinus Torvalds */ 10491da177e4SLinus Torvalds 10509c3f0e2bSFinn Thain if (hostdata->flags & FLAG_TOSHIBA_DELAY) 10519c3f0e2bSFinn Thain udelay(15); 10529c3f0e2bSFinn Thain else 10531da177e4SLinus Torvalds udelay(2); 10541da177e4SLinus Torvalds 105511d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 105611d2f63bSFinn Thain 105772064a78SFinn Thain /* NCR5380_reselect() clears MODE_REG after a reselection interrupt */ 105872064a78SFinn Thain if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) 1059707d62b3SFinn Thain goto out; 1060707d62b3SFinn Thain 1061707d62b3SFinn Thain if (!hostdata->selecting) { 1062707d62b3SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 1063707d62b3SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1064dad8261eSFinn Thain return false; 1065707d62b3SFinn Thain } 106672064a78SFinn Thain 1067b746545fSFinn Thain dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n"); 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds /* 10701da177e4SLinus Torvalds * Now that we have won arbitration, start Selection process, asserting 10711da177e4SLinus Torvalds * the host and target ID's on the SCSI bus. 10721da177e4SLinus Torvalds */ 10731da177e4SLinus Torvalds 10743d07d22bSFinn Thain NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask | (1 << scmd_id(cmd))); 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds /* 10771da177e4SLinus Torvalds * Raise ATN while SEL is true before BSY goes false from arbitration, 10781da177e4SLinus Torvalds * since this is the only way to guarantee that we'll get a MESSAGE OUT 10791da177e4SLinus Torvalds * phase immediately after selection. 10801da177e4SLinus Torvalds */ 10811da177e4SLinus Torvalds 10823d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY | 10833d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL); 10841da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds /* 10871da177e4SLinus Torvalds * Reselect interrupts must be turned off prior to the dropping of BSY, 10881da177e4SLinus Torvalds * otherwise we will trigger an interrupt. 10891da177e4SLinus Torvalds */ 10901da177e4SLinus Torvalds NCR5380_write(SELECT_ENABLE_REG, 0); 10911da177e4SLinus Torvalds 109211d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 109311d2f63bSFinn Thain 10941da177e4SLinus Torvalds /* 10951da177e4SLinus Torvalds * The initiator shall then wait at least two deskew delays and release 10961da177e4SLinus Torvalds * the BSY signal. 10971da177e4SLinus Torvalds */ 10981da177e4SLinus Torvalds udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */ 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds /* Reset BSY */ 11013d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | 11023d07d22bSFinn Thain ICR_ASSERT_ATN | ICR_ASSERT_SEL); 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds /* 11051da177e4SLinus Torvalds * Something weird happens when we cease to drive BSY - looks 11061da177e4SLinus Torvalds * like the board/chip is letting us do another read before the 11071da177e4SLinus Torvalds * appropriate propagation delay has expired, and we're confusing 11081da177e4SLinus Torvalds * a BSY signal from ourselves as the target's response to SELECTION. 11091da177e4SLinus Torvalds * 11101da177e4SLinus Torvalds * A small delay (the 'C++' frontend breaks the pipeline with an 11111da177e4SLinus Torvalds * unnecessary jump, making it work on my 386-33/Trantor T128, the 11121da177e4SLinus Torvalds * tighter 'C' code breaks and requires this) solves the problem - 11131da177e4SLinus Torvalds * the 1 us delay is arbitrary, and only used because this delay will 11141da177e4SLinus Torvalds * be the same on other platforms and since it works here, it should 11151da177e4SLinus Torvalds * work there. 11161da177e4SLinus Torvalds * 11171da177e4SLinus Torvalds * wingel suggests that this could be due to failing to wait 11181da177e4SLinus Torvalds * one deskew delay. 11191da177e4SLinus Torvalds */ 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds udelay(1); 11221da177e4SLinus Torvalds 1123b746545fSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "selecting target %d\n", scmd_id(cmd)); 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds /* 11261da177e4SLinus Torvalds * The SCSI specification calls for a 250 ms timeout for the actual 11271da177e4SLinus Torvalds * selection. 11281da177e4SLinus Torvalds */ 11291da177e4SLinus Torvalds 1130d5d37a0aSFinn Thain err = NCR5380_poll_politely(hostdata, STATUS_REG, SR_BSY, SR_BSY, 1131ae753a33SFinn Thain msecs_to_jiffies(250)); 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) { 113411d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 11351da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 11361da177e4SLinus Torvalds NCR5380_reselect(instance); 11376a6ff4acSFinn Thain shost_printk(KERN_ERR, instance, "reselection after won arbitration?\n"); 1138707d62b3SFinn Thain goto out; 11391da177e4SLinus Torvalds } 1140ae753a33SFinn Thain 1141ae753a33SFinn Thain if (err < 0) { 114211d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 1143ae753a33SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 11446a162836SFinn Thain 1145707d62b3SFinn Thain /* Can't touch cmd if it has been reclaimed by the scsi ML */ 11466a162836SFinn Thain if (!hostdata->selecting) 1147dad8261eSFinn Thain return false; 11486a162836SFinn Thain 1149ae753a33SFinn Thain cmd->result = DID_BAD_TARGET << 16; 1150677e0194SFinn Thain complete_cmd(instance, cmd); 11516a162836SFinn Thain dsprintk(NDEBUG_SELECTION, instance, 11526a162836SFinn Thain "target did not respond within 250ms\n"); 1153dad8261eSFinn Thain ret = false; 1154707d62b3SFinn Thain goto out; 1155ae753a33SFinn Thain } 1156ae753a33SFinn Thain 11571da177e4SLinus Torvalds /* 11581da177e4SLinus Torvalds * No less than two deskew delays after the initiator detects the 11591da177e4SLinus Torvalds * BSY signal is true, it shall release the SEL signal and may 11601da177e4SLinus Torvalds * change the DATA BUS. -wingel 11611da177e4SLinus Torvalds */ 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds udelay(1); 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds /* 11681da177e4SLinus Torvalds * Since we followed the SCSI spec, and raised ATN while SEL 11691da177e4SLinus Torvalds * was true but before BSY was false during selection, the information 11701da177e4SLinus Torvalds * transfer phase should be a MESSAGE OUT phase so that we can send the 11711da177e4SLinus Torvalds * IDENTIFY message. 11721da177e4SLinus Torvalds */ 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds /* Wait for start of REQ/ACK handshake */ 11751da177e4SLinus Torvalds 1176d5d37a0aSFinn Thain err = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ); 117711d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 11781cc160e1SFinn Thain if (err < 0) { 117955500d9bSFinn Thain shost_printk(KERN_ERR, instance, "select: REQ timeout\n"); 118055500d9bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1181707d62b3SFinn Thain goto out; 1182707d62b3SFinn Thain } 1183707d62b3SFinn Thain if (!hostdata->selecting) { 1184707d62b3SFinn Thain do_abort(instance); 1185dad8261eSFinn Thain return false; 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds 1188b746545fSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n", 1189b746545fSFinn Thain scmd_id(cmd)); 11907c8ed783SFinn Thain tmp[0] = IDENTIFY(can_disconnect, cmd->device->lun); 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds len = 1; 11931da177e4SLinus Torvalds data = tmp; 11941da177e4SLinus Torvalds phase = PHASE_MSGOUT; 11951da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 1196b15e791dSFinn Thain if (len) { 1197b15e791dSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1198b15e791dSFinn Thain cmd->result = DID_ERROR << 16; 1199b15e791dSFinn Thain complete_cmd(instance, cmd); 1200b15e791dSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "IDENTIFY message transfer failed\n"); 1201dad8261eSFinn Thain ret = false; 1202b15e791dSFinn Thain goto out; 1203b15e791dSFinn Thain } 1204b15e791dSFinn Thain 1205b746545fSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "nexus established.\n"); 120611d2f63bSFinn Thain 12071da177e4SLinus Torvalds hostdata->connected = cmd; 12083d07d22bSFinn Thain hostdata->busy[cmd->device->id] |= 1 << cmd->device->lun; 12091da177e4SLinus Torvalds 1210e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1211e9db3198SFinn Thain dregs->csr |= CSR_INTR; 1212e9db3198SFinn Thain #endif 1213e9db3198SFinn Thain 12141da177e4SLinus Torvalds initialize_SCp(cmd); 12151da177e4SLinus Torvalds 1216dad8261eSFinn Thain ret = false; 1217707d62b3SFinn Thain 1218707d62b3SFinn Thain out: 1219707d62b3SFinn Thain if (!hostdata->selecting) 122096edebd6SFinn Thain return false; 1221707d62b3SFinn Thain hostdata->selecting = NULL; 1222dad8261eSFinn Thain return ret; 12231da177e4SLinus Torvalds } 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds /* 12261da177e4SLinus Torvalds * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 12271da177e4SLinus Torvalds * unsigned char *phase, int *count, unsigned char **data) 12281da177e4SLinus Torvalds * 12291da177e4SLinus Torvalds * Purpose : transfers data in given phase using polled I/O 12301da177e4SLinus Torvalds * 12311da177e4SLinus Torvalds * Inputs : instance - instance of driver, *phase - pointer to 12321da177e4SLinus Torvalds * what phase is expected, *count - pointer to number of 12331da177e4SLinus Torvalds * bytes to transfer, **data - pointer to data pointer. 12341da177e4SLinus Torvalds * 12351da177e4SLinus Torvalds * Returns : -1 when different phase is entered without transferring 12360d2cf867SFinn Thain * maximum number of bytes, 0 if all bytes are transferred or exit 12371da177e4SLinus Torvalds * is in same phase. 12381da177e4SLinus Torvalds * 12391da177e4SLinus Torvalds * Also, *phase, *count, *data are modified in place. 12401da177e4SLinus Torvalds * 12411da177e4SLinus Torvalds * XXX Note : handling for bus free may be useful. 12421da177e4SLinus Torvalds */ 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds /* 12451da177e4SLinus Torvalds * Note : this code is not as quick as it could be, however it 12461da177e4SLinus Torvalds * IS 100% reliable, and for the actual data transfer where speed 12471da177e4SLinus Torvalds * counts, we will always do a pseudo DMA or DMA transfer. 12481da177e4SLinus Torvalds */ 12491da177e4SLinus Torvalds 12500d2cf867SFinn Thain static int NCR5380_transfer_pio(struct Scsi_Host *instance, 12510d2cf867SFinn Thain unsigned char *phase, int *count, 12520d2cf867SFinn Thain unsigned char **data) 12530d2cf867SFinn Thain { 125461e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 12551da177e4SLinus Torvalds unsigned char p = *phase, tmp; 12561da177e4SLinus Torvalds int c = *count; 12571da177e4SLinus Torvalds unsigned char *d = *data; 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds /* 12601da177e4SLinus Torvalds * The NCR5380 chip will only drive the SCSI bus when the 12611da177e4SLinus Torvalds * phase specified in the appropriate bits of the TARGET COMMAND 12621da177e4SLinus Torvalds * REGISTER match the STATUS REGISTER 12631da177e4SLinus Torvalds */ 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds do { 12681da177e4SLinus Torvalds /* 12691da177e4SLinus Torvalds * Wait for assertion of REQ, after which the phase bits will be 12701da177e4SLinus Torvalds * valid 12711da177e4SLinus Torvalds */ 12721da177e4SLinus Torvalds 1273d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ) < 0) 12741da177e4SLinus Torvalds break; 12751da177e4SLinus Torvalds 1276b746545fSFinn Thain dsprintk(NDEBUG_HANDSHAKE, instance, "REQ asserted\n"); 12771da177e4SLinus Torvalds 12781da177e4SLinus Torvalds /* Check for phase mismatch */ 1279686f3990SFinn Thain if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) { 1280b746545fSFinn Thain dsprintk(NDEBUG_PIO, instance, "phase mismatch\n"); 1281b746545fSFinn Thain NCR5380_dprint_phase(NDEBUG_PIO, instance); 12821da177e4SLinus Torvalds break; 12831da177e4SLinus Torvalds } 12840d2cf867SFinn Thain 12851da177e4SLinus Torvalds /* Do actual transfer from SCSI bus to / from memory */ 12861da177e4SLinus Torvalds if (!(p & SR_IO)) 12871da177e4SLinus Torvalds NCR5380_write(OUTPUT_DATA_REG, *d); 12881da177e4SLinus Torvalds else 12891da177e4SLinus Torvalds *d = NCR5380_read(CURRENT_SCSI_DATA_REG); 12901da177e4SLinus Torvalds 12911da177e4SLinus Torvalds ++d; 12921da177e4SLinus Torvalds 12931da177e4SLinus Torvalds /* 12941da177e4SLinus Torvalds * The SCSI standard suggests that in MSGOUT phase, the initiator 12951da177e4SLinus Torvalds * should drop ATN on the last byte of the message phase 12961da177e4SLinus Torvalds * after REQ has been asserted for the handshake but before 12971da177e4SLinus Torvalds * the initiator raises ACK. 12981da177e4SLinus Torvalds */ 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds if (!(p & SR_IO)) { 13011da177e4SLinus Torvalds if (!((p & SR_MSG) && c > 1)) { 13021da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 13031da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_PIO, instance); 13043d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 13053d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ACK); 13061da177e4SLinus Torvalds } else { 13073d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 13083d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ATN); 13091da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_PIO, instance); 13103d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 13113d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 13121da177e4SLinus Torvalds } 13131da177e4SLinus Torvalds } else { 13141da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_PIO, instance); 13151da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK); 13161da177e4SLinus Torvalds } 13171da177e4SLinus Torvalds 1318d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, 1319a2edc4a6SFinn Thain STATUS_REG, SR_REQ, 0, 5 * HZ) < 0) 1320a2edc4a6SFinn Thain break; 1321a2edc4a6SFinn Thain 1322b746545fSFinn Thain dsprintk(NDEBUG_HANDSHAKE, instance, "REQ negated, handshake complete\n"); 13231da177e4SLinus Torvalds 13241da177e4SLinus Torvalds /* 13251da177e4SLinus Torvalds * We have several special cases to consider during REQ/ACK handshaking : 13261da177e4SLinus Torvalds * 1. We were in MSGOUT phase, and we are on the last byte of the 13271da177e4SLinus Torvalds * message. ATN must be dropped as ACK is dropped. 13281da177e4SLinus Torvalds * 13291da177e4SLinus Torvalds * 2. We are in a MSGIN phase, and we are on the last byte of the 13301da177e4SLinus Torvalds * message. We must exit with ACK asserted, so that the calling 13311da177e4SLinus Torvalds * code may raise ATN before dropping ACK to reject the message. 13321da177e4SLinus Torvalds * 13331da177e4SLinus Torvalds * 3. ACK and ATN are clear and the target may proceed as normal. 13341da177e4SLinus Torvalds */ 13351da177e4SLinus Torvalds if (!(p == PHASE_MSGIN && c == 1)) { 13361da177e4SLinus Torvalds if (p == PHASE_MSGOUT && c > 1) 13371da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 13381da177e4SLinus Torvalds else 13391da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 13401da177e4SLinus Torvalds } 13411da177e4SLinus Torvalds } while (--c); 13421da177e4SLinus Torvalds 1343b746545fSFinn Thain dsprintk(NDEBUG_PIO, instance, "residual %d\n", c); 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds *count = c; 13461da177e4SLinus Torvalds *data = d; 13471da177e4SLinus Torvalds tmp = NCR5380_read(STATUS_REG); 1348a2edc4a6SFinn Thain /* The phase read from the bus is valid if either REQ is (already) 1349a2edc4a6SFinn Thain * asserted or if ACK hasn't been released yet. The latter applies if 1350a2edc4a6SFinn Thain * we're in MSG IN, DATA IN or STATUS and all bytes have been received. 1351a2edc4a6SFinn Thain */ 1352a2edc4a6SFinn Thain if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0)) 13531da177e4SLinus Torvalds *phase = tmp & PHASE_MASK; 13541da177e4SLinus Torvalds else 13551da177e4SLinus Torvalds *phase = PHASE_UNKNOWN; 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds if (!c || (*phase == p)) 13581da177e4SLinus Torvalds return 0; 13591da177e4SLinus Torvalds else 13601da177e4SLinus Torvalds return -1; 13611da177e4SLinus Torvalds } 13621da177e4SLinus Torvalds 13631da177e4SLinus Torvalds /** 13641da177e4SLinus Torvalds * do_reset - issue a reset command 1365636b1ec8SFinn Thain * @instance: adapter to reset 13661da177e4SLinus Torvalds * 13671da177e4SLinus Torvalds * Issue a reset sequence to the NCR5380 and try and get the bus 13681da177e4SLinus Torvalds * back into sane shape. 13691da177e4SLinus Torvalds * 1370636b1ec8SFinn Thain * This clears the reset interrupt flag because there may be no handler for 1371636b1ec8SFinn Thain * it. When the driver is initialized, the NCR5380_intr() handler has not yet 1372636b1ec8SFinn Thain * been installed. And when in EH we may have released the ST DMA interrupt. 13731da177e4SLinus Torvalds */ 13741da177e4SLinus Torvalds 137554d8fe44SFinn Thain static void do_reset(struct Scsi_Host *instance) 137654d8fe44SFinn Thain { 137761e1ce58SFinn Thain struct NCR5380_hostdata __maybe_unused *hostdata = shost_priv(instance); 1378636b1ec8SFinn Thain unsigned long flags; 1379636b1ec8SFinn Thain 1380636b1ec8SFinn Thain local_irq_save(flags); 1381636b1ec8SFinn Thain NCR5380_write(TARGET_COMMAND_REG, 1382636b1ec8SFinn Thain PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK)); 13831da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST); 1384636b1ec8SFinn Thain udelay(50); 13851da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1386636b1ec8SFinn Thain (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1387636b1ec8SFinn Thain local_irq_restore(flags); 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds 139080d3eb6dSFinn Thain /** 139180d3eb6dSFinn Thain * do_abort - abort the currently established nexus by going to 139280d3eb6dSFinn Thain * MESSAGE OUT phase and sending an ABORT message. 139380d3eb6dSFinn Thain * @instance: relevant scsi host instance 13941da177e4SLinus Torvalds * 1395*d04fc41aSFinn Thain * Returns 0 on success, negative error code on failure. 13961da177e4SLinus Torvalds */ 13971da177e4SLinus Torvalds 139854d8fe44SFinn Thain static int do_abort(struct Scsi_Host *instance) 139954d8fe44SFinn Thain { 140061e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 14011da177e4SLinus Torvalds unsigned char *msgptr, phase, tmp; 14021da177e4SLinus Torvalds int len; 14031da177e4SLinus Torvalds int rc; 14041da177e4SLinus Torvalds 14051da177e4SLinus Torvalds /* Request message out phase */ 14061da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds /* 14091da177e4SLinus Torvalds * Wait for the target to indicate a valid phase by asserting 14101da177e4SLinus Torvalds * REQ. Once this happens, we'll have either a MSGOUT phase 14111da177e4SLinus Torvalds * and can immediately send the ABORT message, or we'll have some 14121da177e4SLinus Torvalds * other phase and will have to source/sink data. 14131da177e4SLinus Torvalds * 14141da177e4SLinus Torvalds * We really don't care what value was on the bus or what value 14151da177e4SLinus Torvalds * the target sees, so we just handshake. 14161da177e4SLinus Torvalds */ 14171da177e4SLinus Torvalds 1418d5d37a0aSFinn Thain rc = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, 10 * HZ); 14191da177e4SLinus Torvalds if (rc < 0) 1420*d04fc41aSFinn Thain goto out; 14211da177e4SLinus Torvalds 1422f35d3474SFinn Thain tmp = NCR5380_read(STATUS_REG) & PHASE_MASK; 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 14251da177e4SLinus Torvalds 1426f35d3474SFinn Thain if (tmp != PHASE_MSGOUT) { 14270d2cf867SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, 14280d2cf867SFinn Thain ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 1429d5d37a0aSFinn Thain rc = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, 0, 3 * HZ); 14301cc160e1SFinn Thain if (rc < 0) 1431*d04fc41aSFinn Thain goto out; 143280d3eb6dSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 14331da177e4SLinus Torvalds } 14340d2cf867SFinn Thain 14351da177e4SLinus Torvalds tmp = ABORT; 14361da177e4SLinus Torvalds msgptr = &tmp; 14371da177e4SLinus Torvalds len = 1; 14381da177e4SLinus Torvalds phase = PHASE_MSGOUT; 143954d8fe44SFinn Thain NCR5380_transfer_pio(instance, &phase, &len, &msgptr); 1440*d04fc41aSFinn Thain if (len) 1441*d04fc41aSFinn Thain rc = -ENXIO; 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds /* 14441da177e4SLinus Torvalds * If we got here, and the command completed successfully, 14451da177e4SLinus Torvalds * we're about to go into bus free state. 14461da177e4SLinus Torvalds */ 14471da177e4SLinus Torvalds 1448*d04fc41aSFinn Thain out: 144980d3eb6dSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1450*d04fc41aSFinn Thain return rc; 14511da177e4SLinus Torvalds } 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds /* 14541da177e4SLinus Torvalds * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 14551da177e4SLinus Torvalds * unsigned char *phase, int *count, unsigned char **data) 14561da177e4SLinus Torvalds * 14571da177e4SLinus Torvalds * Purpose : transfers data in given phase using either real 14581da177e4SLinus Torvalds * or pseudo DMA. 14591da177e4SLinus Torvalds * 14601da177e4SLinus Torvalds * Inputs : instance - instance of driver, *phase - pointer to 14611da177e4SLinus Torvalds * what phase is expected, *count - pointer to number of 14621da177e4SLinus Torvalds * bytes to transfer, **data - pointer to data pointer. 14631da177e4SLinus Torvalds * 14641da177e4SLinus Torvalds * Returns : -1 when different phase is entered without transferring 146525985edcSLucas De Marchi * maximum number of bytes, 0 if all bytes or transferred or exit 14661da177e4SLinus Torvalds * is in same phase. 14671da177e4SLinus Torvalds * 14681da177e4SLinus Torvalds * Also, *phase, *count, *data are modified in place. 14691da177e4SLinus Torvalds */ 14701da177e4SLinus Torvalds 14711da177e4SLinus Torvalds 14720d2cf867SFinn Thain static int NCR5380_transfer_dma(struct Scsi_Host *instance, 14730d2cf867SFinn Thain unsigned char *phase, int *count, 14740d2cf867SFinn Thain unsigned char **data) 14750d2cf867SFinn Thain { 14760d2cf867SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 1477f0ea73a4SFinn Thain int c = *count; 1478f0ea73a4SFinn Thain unsigned char p = *phase; 1479f0ea73a4SFinn Thain unsigned char *d = *data; 14801da177e4SLinus Torvalds unsigned char tmp; 14818053b0eeSFinn Thain int result = 0; 14821da177e4SLinus Torvalds 14831da177e4SLinus Torvalds if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) { 14841da177e4SLinus Torvalds *phase = tmp; 14851da177e4SLinus Torvalds return -1; 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds 14888053b0eeSFinn Thain hostdata->connected->SCp.phase = p; 14898053b0eeSFinn Thain 14908053b0eeSFinn Thain if (p & SR_IO) { 14918053b0eeSFinn Thain if (hostdata->read_overruns) 14928053b0eeSFinn Thain c -= hostdata->read_overruns; 14938053b0eeSFinn Thain else if (hostdata->flags & FLAG_DMA_FIXUP) 14948053b0eeSFinn Thain --c; 14958053b0eeSFinn Thain } 14968053b0eeSFinn Thain 14978053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, "initializing DMA %s: length %d, address %p\n", 14988053b0eeSFinn Thain (p & SR_IO) ? "receive" : "send", c, d); 14998053b0eeSFinn Thain 1500e9db3198SFinn Thain #ifdef CONFIG_SUN3 1501e9db3198SFinn Thain /* send start chain */ 1502e9db3198SFinn Thain sun3scsi_dma_start(c, *data); 1503e9db3198SFinn Thain #endif 1504e9db3198SFinn Thain 15051da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 1506cd400825SFinn Thain NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY | 1507cd400825SFinn Thain MR_ENABLE_EOP_INTR); 15081da177e4SLinus Torvalds 15098053b0eeSFinn Thain if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) { 15108053b0eeSFinn Thain /* On the Medusa, it is a must to initialize the DMA before 15118053b0eeSFinn Thain * starting the NCR. This is also the cleaner way for the TT. 15128053b0eeSFinn Thain */ 15138053b0eeSFinn Thain if (p & SR_IO) 15144a98f896SFinn Thain result = NCR5380_dma_recv_setup(hostdata, d, c); 15158053b0eeSFinn Thain else 15164a98f896SFinn Thain result = NCR5380_dma_send_setup(hostdata, d, c); 15178053b0eeSFinn Thain } 15181da177e4SLinus Torvalds 15191da177e4SLinus Torvalds /* 15201da177e4SLinus Torvalds * On the PAS16 at least I/O recovery delays are not needed here. 15211da177e4SLinus Torvalds * Everyone else seems to want them. 15221da177e4SLinus Torvalds */ 15231da177e4SLinus Torvalds 15241da177e4SLinus Torvalds if (p & SR_IO) { 1525e9db3198SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1526e5d55d1aSFinn Thain NCR5380_io_delay(1); 15271da177e4SLinus Torvalds NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0); 15281da177e4SLinus Torvalds } else { 1529e5d55d1aSFinn Thain NCR5380_io_delay(1); 15301da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 1531e5d55d1aSFinn Thain NCR5380_io_delay(1); 15321da177e4SLinus Torvalds NCR5380_write(START_DMA_SEND_REG, 0); 1533e5d55d1aSFinn Thain NCR5380_io_delay(1); 15341da177e4SLinus Torvalds } 15351da177e4SLinus Torvalds 1536e9db3198SFinn Thain #ifdef CONFIG_SUN3 1537e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1538e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 1539e9db3198SFinn Thain #endif 1540e9db3198SFinn Thain sun3_dma_active = 1; 1541e9db3198SFinn Thain #endif 1542e9db3198SFinn Thain 15438053b0eeSFinn Thain if (hostdata->flags & FLAG_LATE_DMA_SETUP) { 15448053b0eeSFinn Thain /* On the Falcon, the DMA setup must be done after the last 15458053b0eeSFinn Thain * NCR access, else the DMA setup gets trashed! 15468053b0eeSFinn Thain */ 15478053b0eeSFinn Thain if (p & SR_IO) 15484a98f896SFinn Thain result = NCR5380_dma_recv_setup(hostdata, d, c); 15498053b0eeSFinn Thain else 15504a98f896SFinn Thain result = NCR5380_dma_send_setup(hostdata, d, c); 15518053b0eeSFinn Thain } 15528053b0eeSFinn Thain 15538053b0eeSFinn Thain /* On failure, NCR5380_dma_xxxx_setup() returns a negative int. */ 15548053b0eeSFinn Thain if (result < 0) 15558053b0eeSFinn Thain return result; 15568053b0eeSFinn Thain 15578053b0eeSFinn Thain /* For real DMA, result is the byte count. DMA interrupt is expected. */ 15588053b0eeSFinn Thain if (result > 0) { 15598053b0eeSFinn Thain hostdata->dma_len = result; 15608053b0eeSFinn Thain return 0; 15618053b0eeSFinn Thain } 15628053b0eeSFinn Thain 15638053b0eeSFinn Thain /* The result is zero iff pseudo DMA send/receive was completed. */ 15648053b0eeSFinn Thain hostdata->dma_len = c; 15658053b0eeSFinn Thain 15661da177e4SLinus Torvalds /* 1567e4dec680SFinn Thain * A note regarding the DMA errata workarounds for early NMOS silicon. 1568c16df32eSFinn Thain * 1569c16df32eSFinn Thain * For DMA sends, we want to wait until the last byte has been 1570c16df32eSFinn Thain * transferred out over the bus before we turn off DMA mode. Alas, there 1571c16df32eSFinn Thain * seems to be no terribly good way of doing this on a 5380 under all 1572c16df32eSFinn Thain * conditions. For non-scatter-gather operations, we can wait until REQ 1573c16df32eSFinn Thain * and ACK both go false, or until a phase mismatch occurs. Gather-sends 1574c16df32eSFinn Thain * are nastier, since the device will be expecting more data than we 1575c16df32eSFinn Thain * are prepared to send it, and REQ will remain asserted. On a 53C8[01] we 1576c16df32eSFinn Thain * could test Last Byte Sent to assure transfer (I imagine this is precisely 1577c16df32eSFinn Thain * why this signal was added to the newer chips) but on the older 538[01] 1578c16df32eSFinn Thain * this signal does not exist. The workaround for this lack is a watchdog; 1579c16df32eSFinn Thain * we bail out of the wait-loop after a modest amount of wait-time if 1580c16df32eSFinn Thain * the usual exit conditions are not met. Not a terribly clean or 1581c16df32eSFinn Thain * correct solution :-% 1582c16df32eSFinn Thain * 1583c16df32eSFinn Thain * DMA receive is equally tricky due to a nasty characteristic of the NCR5380. 1584c16df32eSFinn Thain * If the chip is in DMA receive mode, it will respond to a target's 1585c16df32eSFinn Thain * REQ by latching the SCSI data into the INPUT DATA register and asserting 1586c16df32eSFinn Thain * ACK, even if it has _already_ been notified by the DMA controller that 1587c16df32eSFinn Thain * the current DMA transfer has completed! If the NCR5380 is then taken 1588c16df32eSFinn Thain * out of DMA mode, this already-acknowledged byte is lost. This is 1589c16df32eSFinn Thain * not a problem for "one DMA transfer per READ command", because 1590c16df32eSFinn Thain * the situation will never arise... either all of the data is DMA'ed 1591c16df32eSFinn Thain * properly, or the target switches to MESSAGE IN phase to signal a 1592c16df32eSFinn Thain * disconnection (either operation bringing the DMA to a clean halt). 1593c16df32eSFinn Thain * However, in order to handle scatter-receive, we must work around the 1594e4dec680SFinn Thain * problem. The chosen fix is to DMA fewer bytes, then check for the 1595c16df32eSFinn Thain * condition before taking the NCR5380 out of DMA mode. One or two extra 1596c16df32eSFinn Thain * bytes are transferred via PIO as necessary to fill out the original 1597c16df32eSFinn Thain * request. 15981da177e4SLinus Torvalds */ 15991da177e4SLinus Torvalds 16008053b0eeSFinn Thain if (hostdata->flags & FLAG_DMA_FIXUP) { 16011da177e4SLinus Torvalds if (p & SR_IO) { 16021da177e4SLinus Torvalds /* 1603e4dec680SFinn Thain * The workaround was to transfer fewer bytes than we 16041da177e4SLinus Torvalds * intended to with the pseudo-DMA read function, wait for 16051da177e4SLinus Torvalds * the chip to latch the last byte, read it, and then disable 16061da177e4SLinus Torvalds * pseudo-DMA mode. 16071da177e4SLinus Torvalds * 16081da177e4SLinus Torvalds * After REQ is asserted, the NCR5380 asserts DRQ and ACK. 16091da177e4SLinus Torvalds * REQ is deasserted when ACK is asserted, and not reasserted 16101da177e4SLinus Torvalds * until ACK goes false. Since the NCR5380 won't lower ACK 16111da177e4SLinus Torvalds * until DACK is asserted, which won't happen unless we twiddle 16121da177e4SLinus Torvalds * the DMA port or we take the NCR5380 out of DMA mode, we 16131da177e4SLinus Torvalds * can guarantee that we won't handshake another extra 16141da177e4SLinus Torvalds * byte. 16151da177e4SLinus Torvalds */ 16161da177e4SLinus Torvalds 1617d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, BUS_AND_STATUS_REG, 161855181be8SFinn Thain BASR_DRQ, BASR_DRQ, HZ) < 0) { 1619438af51cSFinn Thain result = -1; 162055181be8SFinn Thain shost_printk(KERN_ERR, instance, "PDMA read: DRQ timeout\n"); 162155181be8SFinn Thain } 1622d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, STATUS_REG, 162355181be8SFinn Thain SR_REQ, 0, HZ) < 0) { 1624438af51cSFinn Thain result = -1; 162555181be8SFinn Thain shost_printk(KERN_ERR, instance, "PDMA read: !REQ timeout\n"); 162655181be8SFinn Thain } 16278053b0eeSFinn Thain d[*count - 1] = NCR5380_read(INPUT_DATA_REG); 16281da177e4SLinus Torvalds } else { 16291da177e4SLinus Torvalds /* 16301da177e4SLinus Torvalds * Wait for the last byte to be sent. If REQ is being asserted for 16311da177e4SLinus Torvalds * the byte we're interested, we'll ACK it and it will go false. 16321da177e4SLinus Torvalds */ 1633d5d37a0aSFinn Thain if (NCR5380_poll_politely2(hostdata, 163455181be8SFinn Thain BUS_AND_STATUS_REG, BASR_DRQ, BASR_DRQ, 163555181be8SFinn Thain BUS_AND_STATUS_REG, BASR_PHASE_MATCH, 0, HZ) < 0) { 1636438af51cSFinn Thain result = -1; 163755181be8SFinn Thain shost_printk(KERN_ERR, instance, "PDMA write: DRQ and phase timeout\n"); 16381da177e4SLinus Torvalds } 16391da177e4SLinus Torvalds } 16401da177e4SLinus Torvalds } 16418053b0eeSFinn Thain 16428053b0eeSFinn Thain NCR5380_dma_complete(instance); 1643438af51cSFinn Thain return result; 16441da177e4SLinus Torvalds } 16451da177e4SLinus Torvalds 16461da177e4SLinus Torvalds /* 16471da177e4SLinus Torvalds * Function : NCR5380_information_transfer (struct Scsi_Host *instance) 16481da177e4SLinus Torvalds * 16491da177e4SLinus Torvalds * Purpose : run through the various SCSI phases and do as the target 16501da177e4SLinus Torvalds * directs us to. Operates on the currently connected command, 16511da177e4SLinus Torvalds * instance->connected. 16521da177e4SLinus Torvalds * 16531da177e4SLinus Torvalds * Inputs : instance, instance for which we are doing commands 16541da177e4SLinus Torvalds * 16551da177e4SLinus Torvalds * Side effects : SCSI things happen, the disconnected queue will be 16561da177e4SLinus Torvalds * modified if a command disconnects, *instance->connected will 16571da177e4SLinus Torvalds * change. 16581da177e4SLinus Torvalds * 16591da177e4SLinus Torvalds * XXX Note : we need to watch for bus free or a reset condition here 16601da177e4SLinus Torvalds * to recover from an unexpected bus free condition. 16611da177e4SLinus Torvalds */ 16621da177e4SLinus Torvalds 16630d2cf867SFinn Thain static void NCR5380_information_transfer(struct Scsi_Host *instance) 16644ab2a787SFinn Thain __releases(&hostdata->lock) __acquires(&hostdata->lock) 16650d2cf867SFinn Thain { 1666e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 16671da177e4SLinus Torvalds unsigned char msgout = NOP; 16681da177e4SLinus Torvalds int sink = 0; 16691da177e4SLinus Torvalds int len; 16701da177e4SLinus Torvalds int transfersize; 16711da177e4SLinus Torvalds unsigned char *data; 16721da177e4SLinus Torvalds unsigned char phase, tmp, extended_msg[10], old_phase = 0xff; 167311d2f63bSFinn Thain struct scsi_cmnd *cmd; 16741da177e4SLinus Torvalds 1675e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1676e9db3198SFinn Thain dregs->csr |= CSR_INTR; 1677e9db3198SFinn Thain #endif 1678e9db3198SFinn Thain 167911d2f63bSFinn Thain while ((cmd = hostdata->connected)) { 168032b26a10SFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd); 168132b26a10SFinn Thain 16821da177e4SLinus Torvalds tmp = NCR5380_read(STATUS_REG); 16831da177e4SLinus Torvalds /* We only have a valid SCSI phase when REQ is asserted */ 16841da177e4SLinus Torvalds if (tmp & SR_REQ) { 16851da177e4SLinus Torvalds phase = (tmp & PHASE_MASK); 16861da177e4SLinus Torvalds if (phase != old_phase) { 16871da177e4SLinus Torvalds old_phase = phase; 16881da177e4SLinus Torvalds NCR5380_dprint_phase(NDEBUG_INFORMATION, instance); 16891da177e4SLinus Torvalds } 1690e9db3198SFinn Thain #ifdef CONFIG_SUN3 16914a98f896SFinn Thain if (phase == PHASE_CMDOUT && 16924a98f896SFinn Thain sun3_dma_setup_done != cmd) { 16934a98f896SFinn Thain int count; 1694e9db3198SFinn Thain 16950e9fdd2bSFinn Thain advance_sg_buffer(cmd); 1696e9db3198SFinn Thain 16974a98f896SFinn Thain count = sun3scsi_dma_xfer_len(hostdata, cmd); 16984a98f896SFinn Thain 16994a98f896SFinn Thain if (count > 0) { 17004a98f896SFinn Thain if (rq_data_dir(cmd->request)) 17014a98f896SFinn Thain sun3scsi_dma_send_setup(hostdata, 17024a98f896SFinn Thain cmd->SCp.ptr, count); 17034a98f896SFinn Thain else 17044a98f896SFinn Thain sun3scsi_dma_recv_setup(hostdata, 17054a98f896SFinn Thain cmd->SCp.ptr, count); 1706e9db3198SFinn Thain sun3_dma_setup_done = cmd; 1707e9db3198SFinn Thain } 1708e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1709e9db3198SFinn Thain dregs->csr |= CSR_INTR; 1710e9db3198SFinn Thain #endif 1711e9db3198SFinn Thain } 1712e9db3198SFinn Thain #endif /* CONFIG_SUN3 */ 1713e9db3198SFinn Thain 17141da177e4SLinus Torvalds if (sink && (phase != PHASE_MSGOUT)) { 17151da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 17161da177e4SLinus Torvalds 17173d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 17183d07d22bSFinn Thain ICR_ASSERT_ACK); 17190d2cf867SFinn Thain while (NCR5380_read(STATUS_REG) & SR_REQ) 17200d2cf867SFinn Thain ; 17213d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 17223d07d22bSFinn Thain ICR_ASSERT_ATN); 17231da177e4SLinus Torvalds sink = 0; 17241da177e4SLinus Torvalds continue; 17251da177e4SLinus Torvalds } 17260d2cf867SFinn Thain 17271da177e4SLinus Torvalds switch (phase) { 17281da177e4SLinus Torvalds case PHASE_DATAOUT: 17291da177e4SLinus Torvalds #if (NDEBUG & NDEBUG_NO_DATAOUT) 17306a6ff4acSFinn Thain shost_printk(KERN_DEBUG, instance, "NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n"); 17311da177e4SLinus Torvalds sink = 1; 17321da177e4SLinus Torvalds do_abort(instance); 17331da177e4SLinus Torvalds cmd->result = DID_ERROR << 16; 1734677e0194SFinn Thain complete_cmd(instance, cmd); 1735dc183965SFinn Thain hostdata->connected = NULL; 173645ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 17371da177e4SLinus Torvalds return; 17381da177e4SLinus Torvalds #endif 1739bf1a0c6fSFinn Thain case PHASE_DATAIN: 17401da177e4SLinus Torvalds /* 17411da177e4SLinus Torvalds * If there is no room left in the current buffer in the 17421da177e4SLinus Torvalds * scatter-gather list, move onto the next one. 17431da177e4SLinus Torvalds */ 17441da177e4SLinus Torvalds 17450e9fdd2bSFinn Thain advance_sg_buffer(cmd); 17460e9fdd2bSFinn Thain dsprintk(NDEBUG_INFORMATION, instance, 17470e9fdd2bSFinn Thain "this residual %d, sg ents %d\n", 1748b746545fSFinn Thain cmd->SCp.this_residual, 17490e9fdd2bSFinn Thain sg_nents(cmd->SCp.buffer)); 17500d2cf867SFinn Thain 17511da177e4SLinus Torvalds /* 17521da177e4SLinus Torvalds * The preferred transfer method is going to be 17531da177e4SLinus Torvalds * PSEUDO-DMA for systems that are strictly PIO, 17541da177e4SLinus Torvalds * since we can let the hardware do the handshaking. 17551da177e4SLinus Torvalds * 17561da177e4SLinus Torvalds * For this to work, we need to know the transfersize 17571da177e4SLinus Torvalds * ahead of time, since the pseudo-DMA code will sit 17581da177e4SLinus Torvalds * in an unconditional loop. 17591da177e4SLinus Torvalds */ 17601da177e4SLinus Torvalds 1761ff3d4578SFinn Thain transfersize = 0; 17627e9ec8d9SFinn Thain if (!cmd->device->borken) 17634a98f896SFinn Thain transfersize = NCR5380_dma_xfer_len(hostdata, cmd); 17641da177e4SLinus Torvalds 1765438af51cSFinn Thain if (transfersize > 0) { 17661da177e4SLinus Torvalds len = transfersize; 17670d2cf867SFinn Thain if (NCR5380_transfer_dma(instance, &phase, 17680d2cf867SFinn Thain &len, (unsigned char **)&cmd->SCp.ptr)) { 17691da177e4SLinus Torvalds /* 17700d2cf867SFinn Thain * If the watchdog timer fires, all future 17710d2cf867SFinn Thain * accesses to this device will use the 17720d2cf867SFinn Thain * polled-IO. 17731da177e4SLinus Torvalds */ 1774017560fcSJeff Garzik scmd_printk(KERN_INFO, cmd, 1775017560fcSJeff Garzik "switching to slow handshake\n"); 17761da177e4SLinus Torvalds cmd->device->borken = 1; 1777f9dfed1cSFinn Thain do_reset(instance); 1778f9dfed1cSFinn Thain bus_reset_cleanup(instance); 17798053b0eeSFinn Thain } 1780f825e40bSFinn Thain } else { 178108348b1cSFinn Thain /* Transfer a small chunk so that the 178208348b1cSFinn Thain * irq mode lock is not held too long. 17831678847eSFinn Thain */ 178408348b1cSFinn Thain transfersize = min(cmd->SCp.this_residual, 178508348b1cSFinn Thain NCR5380_PIO_CHUNK_SIZE); 17861678847eSFinn Thain len = transfersize; 17871678847eSFinn Thain NCR5380_transfer_pio(instance, &phase, &len, 17883d07d22bSFinn Thain (unsigned char **)&cmd->SCp.ptr); 17891678847eSFinn Thain cmd->SCp.this_residual -= transfersize - len; 179011d2f63bSFinn Thain } 1791e9db3198SFinn Thain #ifdef CONFIG_SUN3 1792e9db3198SFinn Thain if (sun3_dma_setup_done == cmd) 1793e9db3198SFinn Thain sun3_dma_setup_done = NULL; 1794e9db3198SFinn Thain #endif 17951678847eSFinn Thain return; 17961da177e4SLinus Torvalds case PHASE_MSGIN: 17971da177e4SLinus Torvalds len = 1; 17981da177e4SLinus Torvalds data = &tmp; 17991da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 18001da177e4SLinus Torvalds cmd->SCp.Message = tmp; 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds switch (tmp) { 18031da177e4SLinus Torvalds case ABORT: 18041da177e4SLinus Torvalds case COMMAND_COMPLETE: 18051da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18061da177e4SLinus Torvalds sink = 1; 18071da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18080d3d9a42SFinn Thain dsprintk(NDEBUG_QUEUES, instance, 18090d3d9a42SFinn Thain "COMMAND COMPLETE %p target %d lun %llu\n", 18100d3d9a42SFinn Thain cmd, scmd_id(cmd), cmd->device->lun); 18110d3d9a42SFinn Thain 18121da177e4SLinus Torvalds hostdata->connected = NULL; 181345ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 18141da177e4SLinus Torvalds 1815f27db8ebSFinn Thain cmd->result &= ~0xffff; 1816f27db8ebSFinn Thain cmd->result |= cmd->SCp.Status; 1817f27db8ebSFinn Thain cmd->result |= cmd->SCp.Message << 8; 18181da177e4SLinus Torvalds 1819350767f2SFinn Thain set_resid_from_SCp(cmd); 1820350767f2SFinn Thain 1821f27db8ebSFinn Thain if (cmd->cmnd[0] == REQUEST_SENSE) 1822f27db8ebSFinn Thain complete_cmd(instance, cmd); 1823f27db8ebSFinn Thain else { 1824f27db8ebSFinn Thain if (cmd->SCp.Status == SAM_STAT_CHECK_CONDITION || 1825f27db8ebSFinn Thain cmd->SCp.Status == SAM_STAT_COMMAND_TERMINATED) { 1826f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, "autosense: adding cmd %p to tail of autosense queue\n", 1827dbb6b350SFinn Thain cmd); 1828f27db8ebSFinn Thain list_add_tail(&ncmd->list, 1829f27db8ebSFinn Thain &hostdata->autosense); 1830f27db8ebSFinn Thain } else 1831677e0194SFinn Thain complete_cmd(instance, cmd); 18321da177e4SLinus Torvalds } 18331da177e4SLinus Torvalds 18341da177e4SLinus Torvalds /* 18351da177e4SLinus Torvalds * Restore phase bits to 0 so an interrupted selection, 18361da177e4SLinus Torvalds * arbitration can resume. 18371da177e4SLinus Torvalds */ 18381da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 183972064a78SFinn Thain 184052d3e561SFinn Thain maybe_release_dma_irq(instance); 18411da177e4SLinus Torvalds return; 18421da177e4SLinus Torvalds case MESSAGE_REJECT: 18431da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18441da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18451da177e4SLinus Torvalds switch (hostdata->last_message) { 18461da177e4SLinus Torvalds case HEAD_OF_QUEUE_TAG: 18471da177e4SLinus Torvalds case ORDERED_QUEUE_TAG: 18481da177e4SLinus Torvalds case SIMPLE_QUEUE_TAG: 18491da177e4SLinus Torvalds cmd->device->simple_tags = 0; 18509cb78c16SHannes Reinecke hostdata->busy[cmd->device->id] |= (1 << (cmd->device->lun & 0xFF)); 18511da177e4SLinus Torvalds break; 18521da177e4SLinus Torvalds default: 18531da177e4SLinus Torvalds break; 18541da177e4SLinus Torvalds } 1855340b9612SFinn Thain break; 18560d2cf867SFinn Thain case DISCONNECT: 18571da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18581da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18591da177e4SLinus Torvalds hostdata->connected = NULL; 186032b26a10SFinn Thain list_add(&ncmd->list, &hostdata->disconnected); 18610d3d9a42SFinn Thain dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES, 18620d3d9a42SFinn Thain instance, "connected command %p for target %d lun %llu moved to disconnected queue\n", 18630d3d9a42SFinn Thain cmd, scmd_id(cmd), cmd->device->lun); 18640d3d9a42SFinn Thain 18651da177e4SLinus Torvalds /* 18661da177e4SLinus Torvalds * Restore phase bits to 0 so an interrupted selection, 18671da177e4SLinus Torvalds * arbitration can resume. 18681da177e4SLinus Torvalds */ 18691da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 18701da177e4SLinus Torvalds 1871e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1872e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 1873e9db3198SFinn Thain #endif 18741da177e4SLinus Torvalds return; 18751da177e4SLinus Torvalds /* 18761da177e4SLinus Torvalds * The SCSI data pointer is *IMPLICITLY* saved on a disconnect 18771da177e4SLinus Torvalds * operation, in violation of the SCSI spec so we can safely 18781da177e4SLinus Torvalds * ignore SAVE/RESTORE pointers calls. 18791da177e4SLinus Torvalds * 18801da177e4SLinus Torvalds * Unfortunately, some disks violate the SCSI spec and 18811da177e4SLinus Torvalds * don't issue the required SAVE_POINTERS message before 18821da177e4SLinus Torvalds * disconnecting, and we have to break spec to remain 18831da177e4SLinus Torvalds * compatible. 18841da177e4SLinus Torvalds */ 18851da177e4SLinus Torvalds case SAVE_POINTERS: 18861da177e4SLinus Torvalds case RESTORE_POINTERS: 18871da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18881da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18891da177e4SLinus Torvalds break; 18901da177e4SLinus Torvalds case EXTENDED_MESSAGE: 18911da177e4SLinus Torvalds /* 1892c16df32eSFinn Thain * Start the message buffer with the EXTENDED_MESSAGE 18931abfd370SMatthew Wilcox * byte, since spi_print_msg() wants the whole thing. 18941da177e4SLinus Torvalds */ 18951da177e4SLinus Torvalds extended_msg[0] = EXTENDED_MESSAGE; 18961da177e4SLinus Torvalds /* Accept first byte by clearing ACK */ 18971da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 189811d2f63bSFinn Thain 189911d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 190011d2f63bSFinn Thain 1901b746545fSFinn Thain dsprintk(NDEBUG_EXTENDED, instance, "receiving extended message\n"); 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds len = 2; 19041da177e4SLinus Torvalds data = extended_msg + 1; 19051da177e4SLinus Torvalds phase = PHASE_MSGIN; 19061da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 1907b746545fSFinn Thain dsprintk(NDEBUG_EXTENDED, instance, "length %d, code 0x%02x\n", 1908b746545fSFinn Thain (int)extended_msg[1], 1909b746545fSFinn Thain (int)extended_msg[2]); 19101da177e4SLinus Torvalds 1911e0783ed3SFinn Thain if (!len && extended_msg[1] > 0 && 1912e0783ed3SFinn Thain extended_msg[1] <= sizeof(extended_msg) - 2) { 19131da177e4SLinus Torvalds /* Accept third byte by clearing ACK */ 19141da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 19151da177e4SLinus Torvalds len = extended_msg[1] - 1; 19161da177e4SLinus Torvalds data = extended_msg + 3; 19171da177e4SLinus Torvalds phase = PHASE_MSGIN; 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 1920b746545fSFinn Thain dsprintk(NDEBUG_EXTENDED, instance, "message received, residual %d\n", 1921b746545fSFinn Thain len); 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds switch (extended_msg[2]) { 19241da177e4SLinus Torvalds case EXTENDED_SDTR: 19251da177e4SLinus Torvalds case EXTENDED_WDTR: 19261da177e4SLinus Torvalds tmp = 0; 19271da177e4SLinus Torvalds } 19281da177e4SLinus Torvalds } else if (len) { 19296a6ff4acSFinn Thain shost_printk(KERN_ERR, instance, "error receiving extended message\n"); 19301da177e4SLinus Torvalds tmp = 0; 19311da177e4SLinus Torvalds } else { 19326a6ff4acSFinn Thain shost_printk(KERN_NOTICE, instance, "extended message code %02x length %d is too long\n", 19336a6ff4acSFinn Thain extended_msg[2], extended_msg[1]); 19341da177e4SLinus Torvalds tmp = 0; 19351da177e4SLinus Torvalds } 193611d2f63bSFinn Thain 193711d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 193811d2f63bSFinn Thain if (!hostdata->connected) 193911d2f63bSFinn Thain return; 194011d2f63bSFinn Thain 1941df135e32SFinn Thain /* Reject message */ 1942df135e32SFinn Thain /* Fall through */ 1943df135e32SFinn Thain default: 19441da177e4SLinus Torvalds /* 19451da177e4SLinus Torvalds * If we get something weird that we aren't expecting, 1946df135e32SFinn Thain * log it. 19471da177e4SLinus Torvalds */ 194839bef87cSFinn Thain if (tmp == EXTENDED_MESSAGE) 1949017560fcSJeff Garzik scmd_printk(KERN_INFO, cmd, 19500d2cf867SFinn Thain "rejecting unknown extended message code %02x, length %d\n", 195139bef87cSFinn Thain extended_msg[2], extended_msg[1]); 195239bef87cSFinn Thain else if (tmp) 195339bef87cSFinn Thain scmd_printk(KERN_INFO, cmd, 195439bef87cSFinn Thain "rejecting unknown message code %02x\n", 195539bef87cSFinn Thain tmp); 19561da177e4SLinus Torvalds 19571da177e4SLinus Torvalds msgout = MESSAGE_REJECT; 19581da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 19591da177e4SLinus Torvalds break; 19601da177e4SLinus Torvalds } /* switch (tmp) */ 19611da177e4SLinus Torvalds break; 19621da177e4SLinus Torvalds case PHASE_MSGOUT: 19631da177e4SLinus Torvalds len = 1; 19641da177e4SLinus Torvalds data = &msgout; 19651da177e4SLinus Torvalds hostdata->last_message = msgout; 19661da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 19671da177e4SLinus Torvalds if (msgout == ABORT) { 19681da177e4SLinus Torvalds hostdata->connected = NULL; 196945ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 19701da177e4SLinus Torvalds cmd->result = DID_ERROR << 16; 1971677e0194SFinn Thain complete_cmd(instance, cmd); 197252d3e561SFinn Thain maybe_release_dma_irq(instance); 19731da177e4SLinus Torvalds return; 19741da177e4SLinus Torvalds } 19751da177e4SLinus Torvalds msgout = NOP; 19761da177e4SLinus Torvalds break; 19771da177e4SLinus Torvalds case PHASE_CMDOUT: 19781da177e4SLinus Torvalds len = cmd->cmd_len; 19791da177e4SLinus Torvalds data = cmd->cmnd; 19801da177e4SLinus Torvalds /* 19811da177e4SLinus Torvalds * XXX for performance reasons, on machines with a 19821da177e4SLinus Torvalds * PSEUDO-DMA architecture we should probably 19831da177e4SLinus Torvalds * use the dma transfer function. 19841da177e4SLinus Torvalds */ 19851da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 19861da177e4SLinus Torvalds break; 19871da177e4SLinus Torvalds case PHASE_STATIN: 19881da177e4SLinus Torvalds len = 1; 19891da177e4SLinus Torvalds data = &tmp; 19901da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 19911da177e4SLinus Torvalds cmd->SCp.Status = tmp; 19921da177e4SLinus Torvalds break; 19931da177e4SLinus Torvalds default: 19946a6ff4acSFinn Thain shost_printk(KERN_ERR, instance, "unknown phase\n"); 19954dde8f7dSFinn Thain NCR5380_dprint(NDEBUG_ANY, instance); 19961da177e4SLinus Torvalds } /* switch(phase) */ 1997686f3990SFinn Thain } else { 199811d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 1999d5d37a0aSFinn Thain NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ); 200011d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 20011da177e4SLinus Torvalds } 200211d2f63bSFinn Thain } 20031da177e4SLinus Torvalds } 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds /* 20061da177e4SLinus Torvalds * Function : void NCR5380_reselect (struct Scsi_Host *instance) 20071da177e4SLinus Torvalds * 20081da177e4SLinus Torvalds * Purpose : does reselection, initializing the instance->connected 2009710ddd0dSFinn Thain * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q 20101da177e4SLinus Torvalds * nexus has been reestablished, 20111da177e4SLinus Torvalds * 20121da177e4SLinus Torvalds * Inputs : instance - this instance of the NCR5380. 20131da177e4SLinus Torvalds */ 20141da177e4SLinus Torvalds 20150d2cf867SFinn Thain static void NCR5380_reselect(struct Scsi_Host *instance) 20160d2cf867SFinn Thain { 2017e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 20181da177e4SLinus Torvalds unsigned char target_mask; 2019e9db3198SFinn Thain unsigned char lun; 20201da177e4SLinus Torvalds unsigned char msg[3]; 202132b26a10SFinn Thain struct NCR5380_cmd *ncmd; 202232b26a10SFinn Thain struct scsi_cmnd *tmp; 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds /* 20251da177e4SLinus Torvalds * Disable arbitration, etc. since the host adapter obviously 20261da177e4SLinus Torvalds * lost, and tell an interrupted NCR5380_select() to restart. 20271da177e4SLinus Torvalds */ 20281da177e4SLinus Torvalds 20291da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask); 20327ef55f67SFinn Thain if (!target_mask || target_mask & (target_mask - 1)) { 20337ef55f67SFinn Thain shost_printk(KERN_WARNING, instance, 20347ef55f67SFinn Thain "reselect: bad target_mask 0x%02x\n", target_mask); 20357ef55f67SFinn Thain return; 20367ef55f67SFinn Thain } 2037b746545fSFinn Thain 20381da177e4SLinus Torvalds /* 20391da177e4SLinus Torvalds * At this point, we have detected that our SCSI ID is on the bus, 20401da177e4SLinus Torvalds * SEL is true and BSY was false for at least one bus settle delay 20411da177e4SLinus Torvalds * (400 ns). 20421da177e4SLinus Torvalds * 20431da177e4SLinus Torvalds * We must assert BSY ourselves, until the target drops the SEL 20441da177e4SLinus Torvalds * signal. 20451da177e4SLinus Torvalds */ 20461da177e4SLinus Torvalds 20471da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY); 2048d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, 204972064a78SFinn Thain STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) { 205008267216SFinn Thain shost_printk(KERN_ERR, instance, "reselect: !SEL timeout\n"); 205172064a78SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 205272064a78SFinn Thain return; 205372064a78SFinn Thain } 20541da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds /* 20571da177e4SLinus Torvalds * Wait for target to go into MSGIN. 20581da177e4SLinus Torvalds */ 20591da177e4SLinus Torvalds 2060d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, 206172064a78SFinn Thain STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) { 2062ca694afaSFinn Thain if ((NCR5380_read(STATUS_REG) & (SR_BSY | SR_SEL)) == 0) 2063ca694afaSFinn Thain /* BUS FREE phase */ 2064ca694afaSFinn Thain return; 206508267216SFinn Thain shost_printk(KERN_ERR, instance, "reselect: REQ timeout\n"); 206672064a78SFinn Thain do_abort(instance); 206772064a78SFinn Thain return; 206872064a78SFinn Thain } 20691da177e4SLinus Torvalds 2070e9db3198SFinn Thain #ifdef CONFIG_SUN3 2071e9db3198SFinn Thain /* acknowledge toggle to MSGIN */ 2072e9db3198SFinn Thain NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN)); 2073e9db3198SFinn Thain 2074e9db3198SFinn Thain /* peek at the byte without really hitting the bus */ 2075e9db3198SFinn Thain msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG); 2076e9db3198SFinn Thain #else 2077e9db3198SFinn Thain { 2078e9db3198SFinn Thain int len = 1; 2079e9db3198SFinn Thain unsigned char *data = msg; 2080e9db3198SFinn Thain unsigned char phase = PHASE_MSGIN; 2081e9db3198SFinn Thain 20821da177e4SLinus Torvalds NCR5380_transfer_pio(instance, &phase, &len, &data); 20831da177e4SLinus Torvalds 208472064a78SFinn Thain if (len) { 208572064a78SFinn Thain do_abort(instance); 208672064a78SFinn Thain return; 208772064a78SFinn Thain } 2088e9db3198SFinn Thain } 2089e9db3198SFinn Thain #endif /* CONFIG_SUN3 */ 209072064a78SFinn Thain 20911da177e4SLinus Torvalds if (!(msg[0] & 0x80)) { 209272064a78SFinn Thain shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got "); 20931abfd370SMatthew Wilcox spi_print_msg(msg); 209472064a78SFinn Thain printk("\n"); 209572064a78SFinn Thain do_abort(instance); 209672064a78SFinn Thain return; 209772064a78SFinn Thain } 209872064a78SFinn Thain lun = msg[0] & 0x07; 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds /* 21011da177e4SLinus Torvalds * We need to add code for SCSI-II to track which devices have 21021da177e4SLinus Torvalds * I_T_L_Q nexuses established, and which have simple I_T_L 21031da177e4SLinus Torvalds * nexuses so we can chose to do additional data transfer. 21041da177e4SLinus Torvalds */ 21051da177e4SLinus Torvalds 21061da177e4SLinus Torvalds /* 21071da177e4SLinus Torvalds * Find the command corresponding to the I_T_L or I_T_L_Q nexus we 21081da177e4SLinus Torvalds * just reestablished, and remove it from the disconnected queue. 21091da177e4SLinus Torvalds */ 21101da177e4SLinus Torvalds 211132b26a10SFinn Thain tmp = NULL; 211232b26a10SFinn Thain list_for_each_entry(ncmd, &hostdata->disconnected, list) { 211332b26a10SFinn Thain struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd); 211432b26a10SFinn Thain 211532b26a10SFinn Thain if (target_mask == (1 << scmd_id(cmd)) && 211632b26a10SFinn Thain lun == (u8)cmd->device->lun) { 211732b26a10SFinn Thain list_del(&ncmd->list); 211832b26a10SFinn Thain tmp = cmd; 21191da177e4SLinus Torvalds break; 21201da177e4SLinus Torvalds } 212172064a78SFinn Thain } 21220d3d9a42SFinn Thain 21230d3d9a42SFinn Thain if (tmp) { 21240d3d9a42SFinn Thain dsprintk(NDEBUG_RESELECTION | NDEBUG_QUEUES, instance, 21250d3d9a42SFinn Thain "reselect: removed %p from disconnected queue\n", tmp); 21260d3d9a42SFinn Thain } else { 212745ddc1b2SFinn Thain int target = ffs(target_mask) - 1; 212845ddc1b2SFinn Thain 212972064a78SFinn Thain shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n", 213072064a78SFinn Thain target_mask, lun); 21311da177e4SLinus Torvalds /* 21320d2cf867SFinn Thain * Since we have an established nexus that we can't do anything 21330d2cf867SFinn Thain * with, we must abort it. 21341da177e4SLinus Torvalds */ 213545ddc1b2SFinn Thain if (do_abort(instance) == 0) 213645ddc1b2SFinn Thain hostdata->busy[target] &= ~(1 << lun); 213772064a78SFinn Thain return; 21381da177e4SLinus Torvalds } 21391da177e4SLinus Torvalds 2140e9db3198SFinn Thain #ifdef CONFIG_SUN3 21414a98f896SFinn Thain if (sun3_dma_setup_done != tmp) { 21424a98f896SFinn Thain int count; 2143e9db3198SFinn Thain 21440e9fdd2bSFinn Thain advance_sg_buffer(tmp); 2145e9db3198SFinn Thain 21464a98f896SFinn Thain count = sun3scsi_dma_xfer_len(hostdata, tmp); 21474a98f896SFinn Thain 21484a98f896SFinn Thain if (count > 0) { 21494a98f896SFinn Thain if (rq_data_dir(tmp->request)) 21504a98f896SFinn Thain sun3scsi_dma_send_setup(hostdata, 21514a98f896SFinn Thain tmp->SCp.ptr, count); 21524a98f896SFinn Thain else 21534a98f896SFinn Thain sun3scsi_dma_recv_setup(hostdata, 21544a98f896SFinn Thain tmp->SCp.ptr, count); 2155e9db3198SFinn Thain sun3_dma_setup_done = tmp; 2156e9db3198SFinn Thain } 2157e9db3198SFinn Thain } 2158e9db3198SFinn Thain 2159e9db3198SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK); 2160e9db3198SFinn Thain #endif /* CONFIG_SUN3 */ 2161e9db3198SFinn Thain 216272064a78SFinn Thain /* Accept message by clearing ACK */ 216372064a78SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 216472064a78SFinn Thain 21651da177e4SLinus Torvalds hostdata->connected = tmp; 2166c4ec6f92SFinn Thain dsprintk(NDEBUG_RESELECTION, instance, "nexus established, target %d, lun %llu\n", 2167c4ec6f92SFinn Thain scmd_id(tmp), tmp->device->lun); 21681da177e4SLinus Torvalds } 21691da177e4SLinus Torvalds 21708b00c3d5SFinn Thain /** 21718b00c3d5SFinn Thain * list_find_cmd - test for presence of a command in a linked list 21728b00c3d5SFinn Thain * @haystack: list of commands 21738b00c3d5SFinn Thain * @needle: command to search for 21748b00c3d5SFinn Thain */ 21758b00c3d5SFinn Thain 21768b00c3d5SFinn Thain static bool list_find_cmd(struct list_head *haystack, 21778b00c3d5SFinn Thain struct scsi_cmnd *needle) 21788b00c3d5SFinn Thain { 21798b00c3d5SFinn Thain struct NCR5380_cmd *ncmd; 21808b00c3d5SFinn Thain 21818b00c3d5SFinn Thain list_for_each_entry(ncmd, haystack, list) 21828b00c3d5SFinn Thain if (NCR5380_to_scmd(ncmd) == needle) 21838b00c3d5SFinn Thain return true; 21848b00c3d5SFinn Thain return false; 21858b00c3d5SFinn Thain } 21868b00c3d5SFinn Thain 21878b00c3d5SFinn Thain /** 21888b00c3d5SFinn Thain * list_remove_cmd - remove a command from linked list 21898b00c3d5SFinn Thain * @haystack: list of commands 21908b00c3d5SFinn Thain * @needle: command to remove 21918b00c3d5SFinn Thain */ 21928b00c3d5SFinn Thain 21938b00c3d5SFinn Thain static bool list_del_cmd(struct list_head *haystack, 21948b00c3d5SFinn Thain struct scsi_cmnd *needle) 21958b00c3d5SFinn Thain { 21968b00c3d5SFinn Thain if (list_find_cmd(haystack, needle)) { 21978b00c3d5SFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(needle); 21988b00c3d5SFinn Thain 21998b00c3d5SFinn Thain list_del(&ncmd->list); 22008b00c3d5SFinn Thain return true; 22018b00c3d5SFinn Thain } 22028b00c3d5SFinn Thain return false; 22038b00c3d5SFinn Thain } 22048b00c3d5SFinn Thain 22058b00c3d5SFinn Thain /** 22068b00c3d5SFinn Thain * NCR5380_abort - scsi host eh_abort_handler() method 22078b00c3d5SFinn Thain * @cmd: the command to be aborted 22081da177e4SLinus Torvalds * 22098b00c3d5SFinn Thain * Try to abort a given command by removing it from queues and/or sending 22108b00c3d5SFinn Thain * the target an abort message. This may not succeed in causing a target 22118b00c3d5SFinn Thain * to abort the command. Nonetheless, the low-level driver must forget about 22128b00c3d5SFinn Thain * the command because the mid-layer reclaims it and it may be re-issued. 22131da177e4SLinus Torvalds * 22148b00c3d5SFinn Thain * The normal path taken by a command is as follows. For EH we trace this 22158b00c3d5SFinn Thain * same path to locate and abort the command. 22161da177e4SLinus Torvalds * 22178b00c3d5SFinn Thain * unissued -> selecting -> [unissued -> selecting ->]... connected -> 22188b00c3d5SFinn Thain * [disconnected -> connected ->]... 22198b00c3d5SFinn Thain * [autosense -> connected ->] done 22201da177e4SLinus Torvalds * 22218b00c3d5SFinn Thain * If cmd was not found at all then presumably it has already been completed, 22228b00c3d5SFinn Thain * in which case return SUCCESS to try to avoid further EH measures. 2223dc183965SFinn Thain * 22248b00c3d5SFinn Thain * If the command has not completed yet, we must not fail to find it. 2225dc183965SFinn Thain * We have no option but to forget the aborted command (even if it still 2226dc183965SFinn Thain * lacks sense data). The mid-layer may re-issue a command that is in error 2227dc183965SFinn Thain * recovery (see scsi_send_eh_cmnd), but the logic and data structures in 2228dc183965SFinn Thain * this driver are such that a command can appear on one queue only. 222971a00593SFinn Thain * 223071a00593SFinn Thain * The lock protects driver data structures, but EH handlers also use it 223171a00593SFinn Thain * to serialize their own execution and prevent their own re-entry. 22321da177e4SLinus Torvalds */ 22331da177e4SLinus Torvalds 2234710ddd0dSFinn Thain static int NCR5380_abort(struct scsi_cmnd *cmd) 2235710ddd0dSFinn Thain { 22361da177e4SLinus Torvalds struct Scsi_Host *instance = cmd->device->host; 2237e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 223811d2f63bSFinn Thain unsigned long flags; 22398b00c3d5SFinn Thain int result = SUCCESS; 22401da177e4SLinus Torvalds 224111d2f63bSFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 224211d2f63bSFinn Thain 224332b26a10SFinn Thain #if (NDEBUG & NDEBUG_ANY) 22448b00c3d5SFinn Thain scmd_printk(KERN_INFO, cmd, __func__); 224532b26a10SFinn Thain #endif 2246e5c3fddfSFinn Thain NCR5380_dprint(NDEBUG_ANY, instance); 2247e5c3fddfSFinn Thain NCR5380_dprint_phase(NDEBUG_ANY, instance); 22481da177e4SLinus Torvalds 22498b00c3d5SFinn Thain if (list_del_cmd(&hostdata->unissued, cmd)) { 22508b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, 22518b00c3d5SFinn Thain "abort: removed %p from issue queue\n", cmd); 22528b00c3d5SFinn Thain cmd->result = DID_ABORT << 16; 22538b00c3d5SFinn Thain cmd->scsi_done(cmd); /* No tag or busy flag to worry about */ 2254dc183965SFinn Thain goto out; 22558b00c3d5SFinn Thain } 22568b00c3d5SFinn Thain 2257707d62b3SFinn Thain if (hostdata->selecting == cmd) { 2258707d62b3SFinn Thain dsprintk(NDEBUG_ABORT, instance, 2259707d62b3SFinn Thain "abort: cmd %p == selecting\n", cmd); 2260707d62b3SFinn Thain hostdata->selecting = NULL; 2261707d62b3SFinn Thain cmd->result = DID_ABORT << 16; 2262707d62b3SFinn Thain complete_cmd(instance, cmd); 2263707d62b3SFinn Thain goto out; 2264707d62b3SFinn Thain } 2265707d62b3SFinn Thain 22668b00c3d5SFinn Thain if (list_del_cmd(&hostdata->disconnected, cmd)) { 22678b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, 22688b00c3d5SFinn Thain "abort: removed %p from disconnected list\n", cmd); 226971a00593SFinn Thain /* Can't call NCR5380_select() and send ABORT because that 227071a00593SFinn Thain * means releasing the lock. Need a bus reset. 227171a00593SFinn Thain */ 2272dc183965SFinn Thain set_host_byte(cmd, DID_ERROR); 2273dc183965SFinn Thain complete_cmd(instance, cmd); 22748b00c3d5SFinn Thain result = FAILED; 22758b00c3d5SFinn Thain goto out; 22768b00c3d5SFinn Thain } 22778b00c3d5SFinn Thain 22788b00c3d5SFinn Thain if (hostdata->connected == cmd) { 22798b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, "abort: cmd %p is connected\n", cmd); 22808b00c3d5SFinn Thain hostdata->connected = NULL; 2281dc183965SFinn Thain hostdata->dma_len = 0; 2282*d04fc41aSFinn Thain if (do_abort(instance) < 0) { 22838b00c3d5SFinn Thain set_host_byte(cmd, DID_ERROR); 22848b00c3d5SFinn Thain complete_cmd(instance, cmd); 22858b00c3d5SFinn Thain result = FAILED; 22868b00c3d5SFinn Thain goto out; 22878b00c3d5SFinn Thain } 22888b00c3d5SFinn Thain set_host_byte(cmd, DID_ABORT); 22898b00c3d5SFinn Thain complete_cmd(instance, cmd); 2290dc183965SFinn Thain goto out; 22918b00c3d5SFinn Thain } 22928b00c3d5SFinn Thain 22938b00c3d5SFinn Thain if (list_del_cmd(&hostdata->autosense, cmd)) { 22948b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, 22958b00c3d5SFinn Thain "abort: removed %p from sense queue\n", cmd); 22968b00c3d5SFinn Thain complete_cmd(instance, cmd); 22978b00c3d5SFinn Thain } 22988b00c3d5SFinn Thain 22998b00c3d5SFinn Thain out: 23008b00c3d5SFinn Thain if (result == FAILED) 23018b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd); 230245ddc1b2SFinn Thain else { 230345ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 23048b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd); 230545ddc1b2SFinn Thain } 23068b00c3d5SFinn Thain 23078b00c3d5SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 230852d3e561SFinn Thain maybe_release_dma_irq(instance); 230911d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 23101da177e4SLinus Torvalds 23118b00c3d5SFinn Thain return result; 23121da177e4SLinus Torvalds } 23131da177e4SLinus Torvalds 23141da177e4SLinus Torvalds 23156b0e87a6SFinn Thain static void bus_reset_cleanup(struct Scsi_Host *instance) 231668b3aa7cSJeff Garzik { 231711d2f63bSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 231862717f53SFinn Thain int i; 231962717f53SFinn Thain struct NCR5380_cmd *ncmd; 23201da177e4SLinus Torvalds 232162717f53SFinn Thain /* reset NCR registers */ 232262717f53SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 232362717f53SFinn Thain NCR5380_write(TARGET_COMMAND_REG, 0); 232462717f53SFinn Thain NCR5380_write(SELECT_ENABLE_REG, 0); 232562717f53SFinn Thain 232662717f53SFinn Thain /* After the reset, there are no more connected or disconnected commands 232762717f53SFinn Thain * and no busy units; so clear the low-level status here to avoid 232862717f53SFinn Thain * conflicts when the mid-level code tries to wake up the affected 232962717f53SFinn Thain * commands! 233062717f53SFinn Thain */ 233162717f53SFinn Thain 23321884c283SFinn Thain if (hostdata->selecting) { 23331884c283SFinn Thain hostdata->selecting->result = DID_RESET << 16; 23341884c283SFinn Thain complete_cmd(instance, hostdata->selecting); 233562717f53SFinn Thain hostdata->selecting = NULL; 23361884c283SFinn Thain } 233762717f53SFinn Thain 233862717f53SFinn Thain list_for_each_entry(ncmd, &hostdata->disconnected, list) { 233962717f53SFinn Thain struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd); 234062717f53SFinn Thain 234162717f53SFinn Thain set_host_byte(cmd, DID_RESET); 2342216fad91SFinn Thain complete_cmd(instance, cmd); 234362717f53SFinn Thain } 23441884c283SFinn Thain INIT_LIST_HEAD(&hostdata->disconnected); 234562717f53SFinn Thain 234662717f53SFinn Thain list_for_each_entry(ncmd, &hostdata->autosense, list) { 234762717f53SFinn Thain struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd); 234862717f53SFinn Thain 234962717f53SFinn Thain cmd->scsi_done(cmd); 235062717f53SFinn Thain } 23511884c283SFinn Thain INIT_LIST_HEAD(&hostdata->autosense); 235262717f53SFinn Thain 235362717f53SFinn Thain if (hostdata->connected) { 235462717f53SFinn Thain set_host_byte(hostdata->connected, DID_RESET); 235562717f53SFinn Thain complete_cmd(instance, hostdata->connected); 235662717f53SFinn Thain hostdata->connected = NULL; 235762717f53SFinn Thain } 235862717f53SFinn Thain 235962717f53SFinn Thain for (i = 0; i < 8; ++i) 236062717f53SFinn Thain hostdata->busy[i] = 0; 236162717f53SFinn Thain hostdata->dma_len = 0; 236262717f53SFinn Thain 236362717f53SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 236452d3e561SFinn Thain maybe_release_dma_irq(instance); 23656b0e87a6SFinn Thain } 23666b0e87a6SFinn Thain 23676b0e87a6SFinn Thain /** 23686b0e87a6SFinn Thain * NCR5380_host_reset - reset the SCSI host 23696b0e87a6SFinn Thain * @cmd: SCSI command undergoing EH 23706b0e87a6SFinn Thain * 23716b0e87a6SFinn Thain * Returns SUCCESS 23726b0e87a6SFinn Thain */ 23736b0e87a6SFinn Thain 23746b0e87a6SFinn Thain static int NCR5380_host_reset(struct scsi_cmnd *cmd) 23756b0e87a6SFinn Thain { 23766b0e87a6SFinn Thain struct Scsi_Host *instance = cmd->device->host; 23776b0e87a6SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 23786b0e87a6SFinn Thain unsigned long flags; 23796b0e87a6SFinn Thain struct NCR5380_cmd *ncmd; 23806b0e87a6SFinn Thain 23816b0e87a6SFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 23826b0e87a6SFinn Thain 23836b0e87a6SFinn Thain #if (NDEBUG & NDEBUG_ANY) 23846b0e87a6SFinn Thain shost_printk(KERN_INFO, instance, __func__); 23856b0e87a6SFinn Thain #endif 23866b0e87a6SFinn Thain NCR5380_dprint(NDEBUG_ANY, instance); 23876b0e87a6SFinn Thain NCR5380_dprint_phase(NDEBUG_ANY, instance); 23886b0e87a6SFinn Thain 23896b0e87a6SFinn Thain list_for_each_entry(ncmd, &hostdata->unissued, list) { 23906b0e87a6SFinn Thain struct scsi_cmnd *scmd = NCR5380_to_scmd(ncmd); 23916b0e87a6SFinn Thain 23926b0e87a6SFinn Thain scmd->result = DID_RESET << 16; 23936b0e87a6SFinn Thain scmd->scsi_done(scmd); 23946b0e87a6SFinn Thain } 23956b0e87a6SFinn Thain INIT_LIST_HEAD(&hostdata->unissued); 23966b0e87a6SFinn Thain 23976b0e87a6SFinn Thain do_reset(instance); 23986b0e87a6SFinn Thain bus_reset_cleanup(instance); 23996b0e87a6SFinn Thain 240011d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 240168b3aa7cSJeff Garzik 24021da177e4SLinus Torvalds return SUCCESS; 24031da177e4SLinus Torvalds } 2404