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 1320b7a2235SFinn Thain static unsigned int disconnect_mask = ~0; 1330b7a2235SFinn Thain module_param(disconnect_mask, int, 0444); 1340b7a2235SFinn Thain 135*e7734ef1SAhmed S. Darwish static int do_abort(struct Scsi_Host *, unsigned int); 13654d8fe44SFinn Thain static void do_reset(struct Scsi_Host *); 1376b0e87a6SFinn Thain static void bus_reset_cleanup(struct Scsi_Host *); 1381da177e4SLinus Torvalds 139c16df32eSFinn Thain /** 1401da177e4SLinus Torvalds * initialize_SCp - init the scsi pointer field 1411da177e4SLinus Torvalds * @cmd: command block to set up 1421da177e4SLinus Torvalds * 1431da177e4SLinus Torvalds * Set up the internal fields in the SCSI command. 1441da177e4SLinus Torvalds */ 1451da177e4SLinus Torvalds 146710ddd0dSFinn Thain static inline void initialize_SCp(struct scsi_cmnd *cmd) 1471da177e4SLinus Torvalds { 1481da177e4SLinus Torvalds /* 1491da177e4SLinus Torvalds * Initialize the Scsi Pointer field so that all of the commands in the 1501da177e4SLinus Torvalds * various queues are valid. 1511da177e4SLinus Torvalds */ 1521da177e4SLinus Torvalds 1539e0fe44dSBoaz Harrosh if (scsi_bufflen(cmd)) { 1549e0fe44dSBoaz Harrosh cmd->SCp.buffer = scsi_sglist(cmd); 15545711f1aSJens Axboe cmd->SCp.ptr = sg_virt(cmd->SCp.buffer); 1561da177e4SLinus Torvalds cmd->SCp.this_residual = cmd->SCp.buffer->length; 1571da177e4SLinus Torvalds } else { 1581da177e4SLinus Torvalds cmd->SCp.buffer = NULL; 1599e0fe44dSBoaz Harrosh cmd->SCp.ptr = NULL; 1609e0fe44dSBoaz Harrosh cmd->SCp.this_residual = 0; 1611da177e4SLinus Torvalds } 162f27db8ebSFinn Thain 163f27db8ebSFinn Thain cmd->SCp.Status = 0; 164f27db8ebSFinn Thain cmd->SCp.Message = 0; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds 1670e9fdd2bSFinn Thain static inline void advance_sg_buffer(struct scsi_cmnd *cmd) 1680e9fdd2bSFinn Thain { 1690e9fdd2bSFinn Thain struct scatterlist *s = cmd->SCp.buffer; 1700e9fdd2bSFinn Thain 1710e9fdd2bSFinn Thain if (!cmd->SCp.this_residual && s && !sg_is_last(s)) { 1720e9fdd2bSFinn Thain cmd->SCp.buffer = sg_next(s); 1730e9fdd2bSFinn Thain cmd->SCp.ptr = sg_virt(cmd->SCp.buffer); 1740e9fdd2bSFinn Thain cmd->SCp.this_residual = cmd->SCp.buffer->length; 1750e9fdd2bSFinn Thain } 1760e9fdd2bSFinn Thain } 1770e9fdd2bSFinn Thain 178350767f2SFinn Thain static inline void set_resid_from_SCp(struct scsi_cmnd *cmd) 179350767f2SFinn Thain { 180350767f2SFinn Thain int resid = cmd->SCp.this_residual; 181350767f2SFinn Thain struct scatterlist *s = cmd->SCp.buffer; 182350767f2SFinn Thain 183350767f2SFinn Thain if (s) 184350767f2SFinn Thain while (!sg_is_last(s)) { 185350767f2SFinn Thain s = sg_next(s); 186350767f2SFinn Thain resid += s->length; 187350767f2SFinn Thain } 188350767f2SFinn Thain scsi_set_resid(cmd, resid); 189350767f2SFinn Thain } 190350767f2SFinn Thain 1911da177e4SLinus Torvalds /** 192b32ade12SFinn Thain * NCR5380_poll_politely2 - wait for two chip register values 193d5d37a0aSFinn Thain * @hostdata: host private data 194b32ade12SFinn Thain * @reg1: 5380 register to poll 195b32ade12SFinn Thain * @bit1: Bitmask to check 196b32ade12SFinn Thain * @val1: Expected value 197b32ade12SFinn Thain * @reg2: Second 5380 register to poll 198b32ade12SFinn Thain * @bit2: Second bitmask to check 199b32ade12SFinn Thain * @val2: Second expected value 200*e7734ef1SAhmed S. Darwish * @wait: Time-out in jiffies, 0 if sleeping is not allowed 2011da177e4SLinus Torvalds * 2022f854b82SFinn Thain * Polls the chip in a reasonably efficient manner waiting for an 2032f854b82SFinn Thain * event to occur. After a short quick poll we begin to yield the CPU 2042f854b82SFinn Thain * (if possible). In irq contexts the time-out is arbitrarily limited. 2052f854b82SFinn Thain * Callers may hold locks as long as they are held in irq mode. 2061da177e4SLinus Torvalds * 207b32ade12SFinn Thain * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT. 2081da177e4SLinus Torvalds */ 2091da177e4SLinus Torvalds 210d5d37a0aSFinn Thain static int NCR5380_poll_politely2(struct NCR5380_hostdata *hostdata, 21161e1ce58SFinn Thain unsigned int reg1, u8 bit1, u8 val1, 21261e1ce58SFinn Thain unsigned int reg2, u8 bit2, u8 val2, 21361e1ce58SFinn Thain unsigned long wait) 2141da177e4SLinus Torvalds { 215d4408dd7SFinn Thain unsigned long n = hostdata->poll_loops; 2162f854b82SFinn Thain unsigned long deadline = jiffies + wait; 2171da177e4SLinus Torvalds 2182f854b82SFinn Thain do { 219b32ade12SFinn Thain if ((NCR5380_read(reg1) & bit1) == val1) 220b32ade12SFinn Thain return 0; 221b32ade12SFinn Thain if ((NCR5380_read(reg2) & bit2) == val2) 2221da177e4SLinus Torvalds return 0; 2231da177e4SLinus Torvalds cpu_relax(); 2242f854b82SFinn Thain } while (n--); 2252f854b82SFinn Thain 226*e7734ef1SAhmed S. Darwish if (!wait) 2272f854b82SFinn Thain return -ETIMEDOUT; 2282f854b82SFinn Thain 2292f854b82SFinn Thain /* Repeatedly sleep for 1 ms until deadline */ 2302f854b82SFinn Thain while (time_is_after_jiffies(deadline)) { 2312f854b82SFinn Thain schedule_timeout_uninterruptible(1); 232b32ade12SFinn Thain if ((NCR5380_read(reg1) & bit1) == val1) 233b32ade12SFinn Thain return 0; 234b32ade12SFinn Thain if ((NCR5380_read(reg2) & bit2) == val2) 2352f854b82SFinn Thain return 0; 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds return -ETIMEDOUT; 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 241185a7a1cSviro@ZenIV.linux.org.uk #if NDEBUG 2421da177e4SLinus Torvalds static struct { 2431da177e4SLinus Torvalds unsigned char mask; 2441da177e4SLinus Torvalds const char *name; 2451da177e4SLinus Torvalds } signals[] = { 2461da177e4SLinus Torvalds {SR_DBP, "PARITY"}, 2471da177e4SLinus Torvalds {SR_RST, "RST"}, 2481da177e4SLinus Torvalds {SR_BSY, "BSY"}, 2491da177e4SLinus Torvalds {SR_REQ, "REQ"}, 2501da177e4SLinus Torvalds {SR_MSG, "MSG"}, 2511da177e4SLinus Torvalds {SR_CD, "CD"}, 2521da177e4SLinus Torvalds {SR_IO, "IO"}, 2531da177e4SLinus Torvalds {SR_SEL, "SEL"}, 2541da177e4SLinus Torvalds {0, NULL} 2551da177e4SLinus Torvalds }, 2561da177e4SLinus Torvalds basrs[] = { 25712866b99SFinn Thain {BASR_END_DMA_TRANSFER, "END OF DMA"}, 25812866b99SFinn Thain {BASR_DRQ, "DRQ"}, 25912866b99SFinn Thain {BASR_PARITY_ERROR, "PARITY ERROR"}, 26012866b99SFinn Thain {BASR_IRQ, "IRQ"}, 26112866b99SFinn Thain {BASR_PHASE_MATCH, "PHASE MATCH"}, 26212866b99SFinn Thain {BASR_BUSY_ERROR, "BUSY ERROR"}, 2631da177e4SLinus Torvalds {BASR_ATN, "ATN"}, 2641da177e4SLinus Torvalds {BASR_ACK, "ACK"}, 2651da177e4SLinus Torvalds {0, NULL} 2661da177e4SLinus Torvalds }, 2671da177e4SLinus Torvalds icrs[] = { 2681da177e4SLinus Torvalds {ICR_ASSERT_RST, "ASSERT RST"}, 26912866b99SFinn Thain {ICR_ARBITRATION_PROGRESS, "ARB. IN PROGRESS"}, 27012866b99SFinn Thain {ICR_ARBITRATION_LOST, "LOST ARB."}, 2711da177e4SLinus Torvalds {ICR_ASSERT_ACK, "ASSERT ACK"}, 2721da177e4SLinus Torvalds {ICR_ASSERT_BSY, "ASSERT BSY"}, 2731da177e4SLinus Torvalds {ICR_ASSERT_SEL, "ASSERT SEL"}, 2741da177e4SLinus Torvalds {ICR_ASSERT_ATN, "ASSERT ATN"}, 2751da177e4SLinus Torvalds {ICR_ASSERT_DATA, "ASSERT DATA"}, 2761da177e4SLinus Torvalds {0, NULL} 2771da177e4SLinus Torvalds }, 2781da177e4SLinus Torvalds mrs[] = { 27912866b99SFinn Thain {MR_BLOCK_DMA_MODE, "BLOCK DMA MODE"}, 28012866b99SFinn Thain {MR_TARGET, "TARGET"}, 28112866b99SFinn Thain {MR_ENABLE_PAR_CHECK, "PARITY CHECK"}, 28212866b99SFinn Thain {MR_ENABLE_PAR_INTR, "PARITY INTR"}, 28312866b99SFinn Thain {MR_ENABLE_EOP_INTR, "EOP INTR"}, 28412866b99SFinn Thain {MR_MONITOR_BSY, "MONITOR BSY"}, 28512866b99SFinn Thain {MR_DMA_MODE, "DMA MODE"}, 28612866b99SFinn Thain {MR_ARBITRATE, "ARBITRATE"}, 2871da177e4SLinus Torvalds {0, NULL} 2881da177e4SLinus Torvalds }; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds /** 2911da177e4SLinus Torvalds * NCR5380_print - print scsi bus signals 2921da177e4SLinus Torvalds * @instance: adapter state to dump 2931da177e4SLinus Torvalds * 2941da177e4SLinus Torvalds * Print the SCSI bus signals for debugging purposes 2951da177e4SLinus Torvalds */ 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds static void NCR5380_print(struct Scsi_Host *instance) 2981da177e4SLinus Torvalds { 29961e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 3008cee3e16SFinn Thain unsigned char status, basr, mr, icr, i; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds status = NCR5380_read(STATUS_REG); 3031da177e4SLinus Torvalds mr = NCR5380_read(MODE_REG); 3041da177e4SLinus Torvalds icr = NCR5380_read(INITIATOR_COMMAND_REG); 3051da177e4SLinus Torvalds basr = NCR5380_read(BUS_AND_STATUS_REG); 3061da177e4SLinus Torvalds 30712866b99SFinn Thain printk(KERN_DEBUG "SR = 0x%02x : ", status); 3081da177e4SLinus Torvalds for (i = 0; signals[i].mask; ++i) 3091da177e4SLinus Torvalds if (status & signals[i].mask) 31012866b99SFinn Thain printk(KERN_CONT "%s, ", signals[i].name); 31112866b99SFinn Thain printk(KERN_CONT "\nBASR = 0x%02x : ", basr); 3121da177e4SLinus Torvalds for (i = 0; basrs[i].mask; ++i) 3131da177e4SLinus Torvalds if (basr & basrs[i].mask) 31412866b99SFinn Thain printk(KERN_CONT "%s, ", basrs[i].name); 31512866b99SFinn Thain printk(KERN_CONT "\nICR = 0x%02x : ", icr); 3161da177e4SLinus Torvalds for (i = 0; icrs[i].mask; ++i) 3171da177e4SLinus Torvalds if (icr & icrs[i].mask) 31812866b99SFinn Thain printk(KERN_CONT "%s, ", icrs[i].name); 31912866b99SFinn Thain printk(KERN_CONT "\nMR = 0x%02x : ", mr); 3201da177e4SLinus Torvalds for (i = 0; mrs[i].mask; ++i) 3211da177e4SLinus Torvalds if (mr & mrs[i].mask) 32212866b99SFinn Thain printk(KERN_CONT "%s, ", mrs[i].name); 32312866b99SFinn Thain printk(KERN_CONT "\n"); 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds 3260d2cf867SFinn Thain static struct { 3270d2cf867SFinn Thain unsigned char value; 3280d2cf867SFinn Thain const char *name; 3290d2cf867SFinn Thain } phases[] = { 3300d2cf867SFinn Thain {PHASE_DATAOUT, "DATAOUT"}, 3310d2cf867SFinn Thain {PHASE_DATAIN, "DATAIN"}, 3320d2cf867SFinn Thain {PHASE_CMDOUT, "CMDOUT"}, 3330d2cf867SFinn Thain {PHASE_STATIN, "STATIN"}, 3340d2cf867SFinn Thain {PHASE_MSGOUT, "MSGOUT"}, 3350d2cf867SFinn Thain {PHASE_MSGIN, "MSGIN"}, 3360d2cf867SFinn Thain {PHASE_UNKNOWN, "UNKNOWN"} 3370d2cf867SFinn Thain }; 3381da177e4SLinus Torvalds 339c16df32eSFinn Thain /** 3401da177e4SLinus Torvalds * NCR5380_print_phase - show SCSI phase 3411da177e4SLinus Torvalds * @instance: adapter to dump 3421da177e4SLinus Torvalds * 3431da177e4SLinus Torvalds * Print the current SCSI phase for debugging purposes 3441da177e4SLinus Torvalds */ 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds static void NCR5380_print_phase(struct Scsi_Host *instance) 3471da177e4SLinus Torvalds { 34861e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 3491da177e4SLinus Torvalds unsigned char status; 3501da177e4SLinus Torvalds int i; 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds status = NCR5380_read(STATUS_REG); 3531da177e4SLinus Torvalds if (!(status & SR_REQ)) 3546a6ff4acSFinn Thain shost_printk(KERN_DEBUG, instance, "REQ not asserted, phase unknown.\n"); 3551da177e4SLinus Torvalds else { 3560d2cf867SFinn Thain for (i = 0; (phases[i].value != PHASE_UNKNOWN) && 3570d2cf867SFinn Thain (phases[i].value != (status & PHASE_MASK)); ++i) 3580d2cf867SFinn Thain ; 3596a6ff4acSFinn Thain shost_printk(KERN_DEBUG, instance, "phase %s\n", phases[i].name); 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds #endif 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds /** 36509028461SFinn Thain * NCR5380_info - report driver and host information 3668c32513bSFinn Thain * @instance: relevant scsi host instance 3671da177e4SLinus Torvalds * 3688c32513bSFinn Thain * For use as the host template info() handler. 3691da177e4SLinus Torvalds */ 3701da177e4SLinus Torvalds 3718c32513bSFinn Thain static const char *NCR5380_info(struct Scsi_Host *instance) 3721da177e4SLinus Torvalds { 3738c32513bSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 3748c32513bSFinn Thain 3758c32513bSFinn Thain return hostdata->info; 3768c32513bSFinn Thain } 3778c32513bSFinn Thain 3781da177e4SLinus Torvalds /** 3791da177e4SLinus Torvalds * NCR5380_init - initialise an NCR5380 3801da177e4SLinus Torvalds * @instance: adapter to configure 3811da177e4SLinus Torvalds * @flags: control flags 3821da177e4SLinus Torvalds * 3831da177e4SLinus Torvalds * Initializes *instance and corresponding 5380 chip, 3841da177e4SLinus Torvalds * with flags OR'd into the initial flags value. 3851da177e4SLinus Torvalds * 3861da177e4SLinus Torvalds * Notes : I assume that the host, hostno, and id bits have been 3871da177e4SLinus Torvalds * set correctly. I don't care about the irq and other fields. 3881da177e4SLinus Torvalds * 3891da177e4SLinus Torvalds * Returns 0 for success 3901da177e4SLinus Torvalds */ 3911da177e4SLinus Torvalds 3926f039790SGreg Kroah-Hartman static int NCR5380_init(struct Scsi_Host *instance, int flags) 3931da177e4SLinus Torvalds { 394e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 395b6488f97SFinn Thain int i; 3962f854b82SFinn Thain unsigned long deadline; 397d4408dd7SFinn Thain unsigned long accesses_per_ms; 3981da177e4SLinus Torvalds 399ae5e33afSFinn Thain instance->max_lun = 7; 400ae5e33afSFinn Thain 4010d2cf867SFinn Thain hostdata->host = instance; 4021da177e4SLinus Torvalds hostdata->id_mask = 1 << instance->this_id; 4030d2cf867SFinn Thain hostdata->id_higher_mask = 0; 4041da177e4SLinus Torvalds for (i = hostdata->id_mask; i <= 0x80; i <<= 1) 4051da177e4SLinus Torvalds if (i > hostdata->id_mask) 4061da177e4SLinus Torvalds hostdata->id_higher_mask |= i; 4071da177e4SLinus Torvalds for (i = 0; i < 8; ++i) 4081da177e4SLinus Torvalds hostdata->busy[i] = 0; 409e4dec680SFinn Thain hostdata->dma_len = 0; 410e4dec680SFinn Thain 41111d2f63bSFinn Thain spin_lock_init(&hostdata->lock); 4121da177e4SLinus Torvalds hostdata->connected = NULL; 413f27db8ebSFinn Thain hostdata->sensing = NULL; 414f27db8ebSFinn Thain INIT_LIST_HEAD(&hostdata->autosense); 41532b26a10SFinn Thain INIT_LIST_HEAD(&hostdata->unissued); 41632b26a10SFinn Thain INIT_LIST_HEAD(&hostdata->disconnected); 41732b26a10SFinn Thain 41855181be8SFinn Thain hostdata->flags = flags; 4191da177e4SLinus Torvalds 4208d8601a7SFinn Thain INIT_WORK(&hostdata->main_task, NCR5380_main); 4210ad0eff9SFinn Thain hostdata->work_q = alloc_workqueue("ncr5380_%d", 4220ad0eff9SFinn Thain WQ_UNBOUND | WQ_MEM_RECLAIM, 4230ad0eff9SFinn Thain 1, instance->host_no); 4240ad0eff9SFinn Thain if (!hostdata->work_q) 4250ad0eff9SFinn Thain return -ENOMEM; 4261da177e4SLinus Torvalds 42709028461SFinn Thain snprintf(hostdata->info, sizeof(hostdata->info), 42809028461SFinn 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}", 42909028461SFinn Thain instance->hostt->name, instance->irq, hostdata->io_port, 43009028461SFinn Thain hostdata->base, instance->can_queue, instance->cmd_per_lun, 43109028461SFinn Thain instance->sg_tablesize, instance->this_id, 43209028461SFinn Thain hostdata->flags & FLAG_DMA_FIXUP ? "DMA_FIXUP " : "", 43309028461SFinn Thain hostdata->flags & FLAG_NO_PSEUDO_DMA ? "NO_PSEUDO_DMA " : "", 43409028461SFinn Thain hostdata->flags & FLAG_TOSHIBA_DELAY ? "TOSHIBA_DELAY " : ""); 4358c32513bSFinn Thain 4361da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 4371da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 4381da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 4391da177e4SLinus Torvalds NCR5380_write(SELECT_ENABLE_REG, 0); 4402f854b82SFinn Thain 4412f854b82SFinn Thain /* Calibrate register polling loop */ 4422f854b82SFinn Thain i = 0; 4432f854b82SFinn Thain deadline = jiffies + 1; 4442f854b82SFinn Thain do { 4452f854b82SFinn Thain cpu_relax(); 4462f854b82SFinn Thain } while (time_is_after_jiffies(deadline)); 4472f854b82SFinn Thain deadline += msecs_to_jiffies(256); 4482f854b82SFinn Thain do { 4492f854b82SFinn Thain NCR5380_read(STATUS_REG); 4502f854b82SFinn Thain ++i; 4512f854b82SFinn Thain cpu_relax(); 4522f854b82SFinn Thain } while (time_is_after_jiffies(deadline)); 453d4408dd7SFinn Thain accesses_per_ms = i / 256; 454d4408dd7SFinn Thain hostdata->poll_loops = NCR5380_REG_POLL_TIME * accesses_per_ms / 2; 4552f854b82SFinn Thain 456b6488f97SFinn Thain return 0; 457b6488f97SFinn Thain } 4581da177e4SLinus Torvalds 459b6488f97SFinn Thain /** 460b6488f97SFinn Thain * NCR5380_maybe_reset_bus - Detect and correct bus wedge problems. 461b6488f97SFinn Thain * @instance: adapter to check 4621da177e4SLinus Torvalds * 463b6488f97SFinn Thain * If the system crashed, it may have crashed with a connected target and 464b6488f97SFinn Thain * the SCSI bus busy. Check for BUS FREE phase. If not, try to abort the 465b6488f97SFinn Thain * currently established nexus, which we know nothing about. Failing that 466b6488f97SFinn Thain * do a bus reset. 4671da177e4SLinus Torvalds * 468b6488f97SFinn Thain * Note that a bus reset will cause the chip to assert IRQ. 469b6488f97SFinn Thain * 470b6488f97SFinn Thain * Returns 0 if successful, otherwise -ENXIO. 4711da177e4SLinus Torvalds */ 4721da177e4SLinus Torvalds 473b6488f97SFinn Thain static int NCR5380_maybe_reset_bus(struct Scsi_Host *instance) 474b6488f97SFinn Thain { 4759c3f0e2bSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 476b6488f97SFinn Thain int pass; 477b6488f97SFinn Thain 4781da177e4SLinus Torvalds for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) { 4791da177e4SLinus Torvalds switch (pass) { 4801da177e4SLinus Torvalds case 1: 4811da177e4SLinus Torvalds case 3: 4821da177e4SLinus Torvalds case 5: 483636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "SCSI bus busy, waiting up to five seconds\n"); 484d5d37a0aSFinn Thain NCR5380_poll_politely(hostdata, 485636b1ec8SFinn Thain STATUS_REG, SR_BSY, 0, 5 * HZ); 4861da177e4SLinus Torvalds break; 4871da177e4SLinus Torvalds case 2: 488636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "bus busy, attempting abort\n"); 489*e7734ef1SAhmed S. Darwish do_abort(instance, 1); 4901da177e4SLinus Torvalds break; 4911da177e4SLinus Torvalds case 4: 492636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "bus busy, attempting reset\n"); 4931da177e4SLinus Torvalds do_reset(instance); 4949c3f0e2bSFinn Thain /* Wait after a reset; the SCSI standard calls for 4959c3f0e2bSFinn Thain * 250ms, we wait 500ms to be on the safe side. 4969c3f0e2bSFinn Thain * But some Toshiba CD-ROMs need ten times that. 4979c3f0e2bSFinn Thain */ 4989c3f0e2bSFinn Thain if (hostdata->flags & FLAG_TOSHIBA_DELAY) 4999c3f0e2bSFinn Thain msleep(2500); 5009c3f0e2bSFinn Thain else 5019c3f0e2bSFinn Thain msleep(500); 5021da177e4SLinus Torvalds break; 5031da177e4SLinus Torvalds case 6: 504636b1ec8SFinn Thain shost_printk(KERN_ERR, instance, "bus locked solid\n"); 5051da177e4SLinus Torvalds return -ENXIO; 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds return 0; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds /** 5121da177e4SLinus Torvalds * NCR5380_exit - remove an NCR5380 5131da177e4SLinus Torvalds * @instance: adapter to remove 5140d2cf867SFinn Thain * 5150d2cf867SFinn Thain * Assumes that no more work can be queued (e.g. by NCR5380_intr). 5161da177e4SLinus Torvalds */ 5171da177e4SLinus Torvalds 518a43cf0f3SRandy Dunlap static void NCR5380_exit(struct Scsi_Host *instance) 5191da177e4SLinus Torvalds { 520e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 5211da177e4SLinus Torvalds 5228d8601a7SFinn Thain cancel_work_sync(&hostdata->main_task); 5230ad0eff9SFinn Thain destroy_workqueue(hostdata->work_q); 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /** 527677e0194SFinn Thain * complete_cmd - finish processing a command and return it to the SCSI ML 528677e0194SFinn Thain * @instance: the host instance 529677e0194SFinn Thain * @cmd: command to complete 530677e0194SFinn Thain */ 531677e0194SFinn Thain 532677e0194SFinn Thain static void complete_cmd(struct Scsi_Host *instance, 533677e0194SFinn Thain struct scsi_cmnd *cmd) 534677e0194SFinn Thain { 535677e0194SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 536677e0194SFinn Thain 537677e0194SFinn Thain dsprintk(NDEBUG_QUEUES, instance, "complete_cmd: cmd %p\n", cmd); 538677e0194SFinn Thain 539f27db8ebSFinn Thain if (hostdata->sensing == cmd) { 540f27db8ebSFinn Thain /* Autosense processing ends here */ 54107035651SFinn Thain if (status_byte(cmd->result) != GOOD) { 542f27db8ebSFinn Thain scsi_eh_restore_cmnd(cmd, &hostdata->ses); 54307035651SFinn Thain } else { 544f27db8ebSFinn Thain scsi_eh_restore_cmnd(cmd, &hostdata->ses); 54507035651SFinn Thain set_driver_byte(cmd, DRIVER_SENSE); 54607035651SFinn Thain } 547f27db8ebSFinn Thain hostdata->sensing = NULL; 548f27db8ebSFinn Thain } 549f27db8ebSFinn Thain 550677e0194SFinn Thain cmd->scsi_done(cmd); 551677e0194SFinn Thain } 552677e0194SFinn Thain 553677e0194SFinn Thain /** 5541da177e4SLinus Torvalds * NCR5380_queue_command - queue a command 5551bb40589SFinn Thain * @instance: the relevant SCSI adapter 5561da177e4SLinus Torvalds * @cmd: SCSI command 5571da177e4SLinus Torvalds * 5581bb40589SFinn Thain * cmd is added to the per-instance issue queue, with minor 5591da177e4SLinus Torvalds * twiddling done to the host specific fields of cmd. If the 5601da177e4SLinus Torvalds * main coroutine is not running, it is restarted. 5611da177e4SLinus Torvalds */ 5621da177e4SLinus Torvalds 5631bb40589SFinn Thain static int NCR5380_queue_command(struct Scsi_Host *instance, 5641bb40589SFinn Thain struct scsi_cmnd *cmd) 5651da177e4SLinus Torvalds { 5661bb40589SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 56732b26a10SFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd); 5681bb40589SFinn Thain unsigned long flags; 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds #if (NDEBUG & NDEBUG_NO_WRITE) 5711da177e4SLinus Torvalds switch (cmd->cmnd[0]) { 5721da177e4SLinus Torvalds case WRITE_6: 5731da177e4SLinus Torvalds case WRITE_10: 574dbb6b350SFinn Thain shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n"); 5751da177e4SLinus Torvalds cmd->result = (DID_ERROR << 16); 5761bb40589SFinn Thain cmd->scsi_done(cmd); 5771da177e4SLinus Torvalds return 0; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds #endif /* (NDEBUG & NDEBUG_NO_WRITE) */ 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds cmd->result = 0; 5821da177e4SLinus Torvalds 58311d2f63bSFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 5841bb40589SFinn Thain 58503fe6a64SFinn Thain if (!NCR5380_acquire_dma_irq(instance)) { 58603fe6a64SFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 58703fe6a64SFinn Thain 58803fe6a64SFinn Thain return SCSI_MLQUEUE_HOST_BUSY; 58903fe6a64SFinn Thain } 59003fe6a64SFinn Thain 5911da177e4SLinus Torvalds /* 5921da177e4SLinus Torvalds * Insert the cmd into the issue queue. Note that REQUEST SENSE 5931da177e4SLinus Torvalds * commands are added to the head of the queue since any command will 5941da177e4SLinus Torvalds * clear the contingent allegiance condition that exists and the 5951da177e4SLinus Torvalds * sense data is only guaranteed to be valid while the condition exists. 5961da177e4SLinus Torvalds */ 5971da177e4SLinus Torvalds 59832b26a10SFinn Thain if (cmd->cmnd[0] == REQUEST_SENSE) 59932b26a10SFinn Thain list_add(&ncmd->list, &hostdata->unissued); 60032b26a10SFinn Thain else 60132b26a10SFinn Thain list_add_tail(&ncmd->list, &hostdata->unissued); 60232b26a10SFinn Thain 60311d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 6041bb40589SFinn Thain 605dbb6b350SFinn Thain dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n", 606dbb6b350SFinn Thain cmd, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"); 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds /* Kick off command processing */ 6098d8601a7SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 6101da177e4SLinus Torvalds return 0; 6111da177e4SLinus Torvalds } 6121da177e4SLinus Torvalds 61352d3e561SFinn Thain static inline void maybe_release_dma_irq(struct Scsi_Host *instance) 61452d3e561SFinn Thain { 61552d3e561SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 61652d3e561SFinn Thain 61752d3e561SFinn Thain /* Caller does the locking needed to set & test these data atomically */ 61852d3e561SFinn Thain if (list_empty(&hostdata->disconnected) && 61952d3e561SFinn Thain list_empty(&hostdata->unissued) && 62052d3e561SFinn Thain list_empty(&hostdata->autosense) && 62152d3e561SFinn Thain !hostdata->connected && 6224ab2a787SFinn Thain !hostdata->selecting) { 62352d3e561SFinn Thain NCR5380_release_dma_irq(instance); 62452d3e561SFinn Thain } 6254ab2a787SFinn Thain } 62652d3e561SFinn Thain 6271da177e4SLinus Torvalds /** 628f27db8ebSFinn Thain * dequeue_next_cmd - dequeue a command for processing 629f27db8ebSFinn Thain * @instance: the scsi host instance 630f27db8ebSFinn Thain * 631f27db8ebSFinn Thain * Priority is given to commands on the autosense queue. These commands 632f27db8ebSFinn Thain * need autosense because of a CHECK CONDITION result. 633f27db8ebSFinn Thain * 634f27db8ebSFinn Thain * Returns a command pointer if a command is found for a target that is 635f27db8ebSFinn Thain * not already busy. Otherwise returns NULL. 636f27db8ebSFinn Thain */ 637f27db8ebSFinn Thain 638f27db8ebSFinn Thain static struct scsi_cmnd *dequeue_next_cmd(struct Scsi_Host *instance) 639f27db8ebSFinn Thain { 640f27db8ebSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 641f27db8ebSFinn Thain struct NCR5380_cmd *ncmd; 642f27db8ebSFinn Thain struct scsi_cmnd *cmd; 643f27db8ebSFinn Thain 6448d5dbec3SFinn Thain if (hostdata->sensing || list_empty(&hostdata->autosense)) { 645f27db8ebSFinn Thain list_for_each_entry(ncmd, &hostdata->unissued, list) { 646f27db8ebSFinn Thain cmd = NCR5380_to_scmd(ncmd); 647f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, "dequeue: cmd=%p target=%d busy=0x%02x lun=%llu\n", 648f27db8ebSFinn Thain cmd, scmd_id(cmd), hostdata->busy[scmd_id(cmd)], cmd->device->lun); 649f27db8ebSFinn Thain 650f27db8ebSFinn Thain if (!(hostdata->busy[scmd_id(cmd)] & (1 << cmd->device->lun))) { 651f27db8ebSFinn Thain list_del(&ncmd->list); 652f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, 653f27db8ebSFinn Thain "dequeue: removed %p from issue queue\n", cmd); 654f27db8ebSFinn Thain return cmd; 655f27db8ebSFinn Thain } 656f27db8ebSFinn Thain } 657f27db8ebSFinn Thain } else { 658f27db8ebSFinn Thain /* Autosense processing begins here */ 659f27db8ebSFinn Thain ncmd = list_first_entry(&hostdata->autosense, 660f27db8ebSFinn Thain struct NCR5380_cmd, list); 661f27db8ebSFinn Thain list_del(&ncmd->list); 662f27db8ebSFinn Thain cmd = NCR5380_to_scmd(ncmd); 663f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, 664f27db8ebSFinn Thain "dequeue: removed %p from autosense queue\n", cmd); 665f27db8ebSFinn Thain scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0); 666f27db8ebSFinn Thain hostdata->sensing = cmd; 667f27db8ebSFinn Thain return cmd; 668f27db8ebSFinn Thain } 669f27db8ebSFinn Thain return NULL; 670f27db8ebSFinn Thain } 671f27db8ebSFinn Thain 672f27db8ebSFinn Thain static void requeue_cmd(struct Scsi_Host *instance, struct scsi_cmnd *cmd) 673f27db8ebSFinn Thain { 674f27db8ebSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 675f27db8ebSFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd); 676f27db8ebSFinn Thain 6778d5dbec3SFinn Thain if (hostdata->sensing == cmd) { 678f27db8ebSFinn Thain scsi_eh_restore_cmnd(cmd, &hostdata->ses); 679f27db8ebSFinn Thain list_add(&ncmd->list, &hostdata->autosense); 680f27db8ebSFinn Thain hostdata->sensing = NULL; 681f27db8ebSFinn Thain } else 682f27db8ebSFinn Thain list_add(&ncmd->list, &hostdata->unissued); 683f27db8ebSFinn Thain } 684f27db8ebSFinn Thain 685f27db8ebSFinn Thain /** 6861da177e4SLinus Torvalds * NCR5380_main - NCR state machines 6871da177e4SLinus Torvalds * 6881da177e4SLinus Torvalds * NCR5380_main is a coroutine that runs as long as more work can 6891da177e4SLinus Torvalds * be done on the NCR5380 host adapters in a system. Both 6901da177e4SLinus Torvalds * NCR5380_queue_command() and NCR5380_intr() will try to start it 6911da177e4SLinus Torvalds * in case it is not running. 6921da177e4SLinus Torvalds */ 6931da177e4SLinus Torvalds 694c4028958SDavid Howells static void NCR5380_main(struct work_struct *work) 6951da177e4SLinus Torvalds { 696c4028958SDavid Howells struct NCR5380_hostdata *hostdata = 6978d8601a7SFinn Thain container_of(work, struct NCR5380_hostdata, main_task); 6981da177e4SLinus Torvalds struct Scsi_Host *instance = hostdata->host; 6991da177e4SLinus Torvalds int done; 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds do { 7021da177e4SLinus Torvalds done = 1; 70311d2f63bSFinn Thain 7040a4e3612SFinn Thain spin_lock_irq(&hostdata->lock); 705ccf6efd7SFinn Thain while (!hostdata->connected && !hostdata->selecting) { 706ccf6efd7SFinn Thain struct scsi_cmnd *cmd = dequeue_next_cmd(instance); 707ccf6efd7SFinn Thain 708ccf6efd7SFinn Thain if (!cmd) 709ccf6efd7SFinn Thain break; 71032b26a10SFinn Thain 711f27db8ebSFinn Thain dsprintk(NDEBUG_MAIN, instance, "main: dequeued %p\n", cmd); 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds /* 7141da177e4SLinus Torvalds * Attempt to establish an I_T_L nexus here. 7151da177e4SLinus Torvalds * On success, instance->hostdata->connected is set. 7161da177e4SLinus Torvalds * On failure, we must add the command back to the 7171da177e4SLinus Torvalds * issue queue so we can keep trying. 7181da177e4SLinus Torvalds */ 7191da177e4SLinus Torvalds /* 7201da177e4SLinus Torvalds * REQUEST SENSE commands are issued without tagged 7211da177e4SLinus Torvalds * queueing, even on SCSI-II devices because the 7221da177e4SLinus Torvalds * contingent allegiance condition exists for the 7231da177e4SLinus Torvalds * entire unit. 7241da177e4SLinus Torvalds */ 72576f13b93SFinn Thain 726ccf6efd7SFinn Thain if (!NCR5380_select(instance, cmd)) { 727707d62b3SFinn Thain dsprintk(NDEBUG_MAIN, instance, "main: select complete\n"); 7281da177e4SLinus Torvalds } else { 729f27db8ebSFinn Thain dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, instance, 730f27db8ebSFinn Thain "main: select failed, returning %p to queue\n", cmd); 731f27db8ebSFinn Thain requeue_cmd(instance, cmd); 7321da177e4SLinus Torvalds } 733f27db8ebSFinn Thain } 734e4dec680SFinn Thain if (hostdata->connected && !hostdata->dma_len) { 735b746545fSFinn Thain dsprintk(NDEBUG_MAIN, instance, "main: performing information transfer\n"); 7361da177e4SLinus Torvalds NCR5380_information_transfer(instance); 7371da177e4SLinus Torvalds done = 0; 7381d3db59dSFinn Thain } 739bdd1cc03SFinn Thain if (!hostdata->connected) { 74057f31326SFinn Thain NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 741bdd1cc03SFinn Thain maybe_release_dma_irq(instance); 742bdd1cc03SFinn Thain } 74311d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 7440a4e3612SFinn Thain if (!done) 7450a4e3612SFinn Thain cond_resched(); 7460a4e3612SFinn Thain } while (!done); 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds 7498053b0eeSFinn Thain /* 7508053b0eeSFinn Thain * NCR5380_dma_complete - finish DMA transfer 7518053b0eeSFinn Thain * @instance: the scsi host instance 7528053b0eeSFinn Thain * 7538053b0eeSFinn Thain * Called by the interrupt handler when DMA finishes or a phase 7548053b0eeSFinn Thain * mismatch occurs (which would end the DMA transfer). 7558053b0eeSFinn Thain */ 7568053b0eeSFinn Thain 7578053b0eeSFinn Thain static void NCR5380_dma_complete(struct Scsi_Host *instance) 7588053b0eeSFinn Thain { 7598053b0eeSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 7608053b0eeSFinn Thain int transferred; 7618053b0eeSFinn Thain unsigned char **data; 7628053b0eeSFinn Thain int *count; 7638053b0eeSFinn Thain int saved_data = 0, overrun = 0; 7648053b0eeSFinn Thain unsigned char p; 7658053b0eeSFinn Thain 7668053b0eeSFinn Thain if (hostdata->read_overruns) { 7678053b0eeSFinn Thain p = hostdata->connected->SCp.phase; 7688053b0eeSFinn Thain if (p & SR_IO) { 7698053b0eeSFinn Thain udelay(10); 7708053b0eeSFinn Thain if ((NCR5380_read(BUS_AND_STATUS_REG) & 7718053b0eeSFinn Thain (BASR_PHASE_MATCH | BASR_ACK)) == 7728053b0eeSFinn Thain (BASR_PHASE_MATCH | BASR_ACK)) { 7738053b0eeSFinn Thain saved_data = NCR5380_read(INPUT_DATA_REG); 7748053b0eeSFinn Thain overrun = 1; 7758053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, "read overrun handled\n"); 7768053b0eeSFinn Thain } 7778053b0eeSFinn Thain } 7788053b0eeSFinn Thain } 7798053b0eeSFinn Thain 780e9db3198SFinn Thain #ifdef CONFIG_SUN3 781e9db3198SFinn Thain if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) { 782e9db3198SFinn Thain pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n", 783e9db3198SFinn Thain instance->host_no); 784e9db3198SFinn Thain BUG(); 785e9db3198SFinn Thain } 786e9db3198SFinn Thain 787e9db3198SFinn Thain if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) == 788e9db3198SFinn Thain (BASR_PHASE_MATCH | BASR_ACK)) { 789e9db3198SFinn Thain pr_err("scsi%d: BASR %02x\n", instance->host_no, 790e9db3198SFinn Thain NCR5380_read(BUS_AND_STATUS_REG)); 791e9db3198SFinn Thain pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n", 792e9db3198SFinn Thain instance->host_no); 793e9db3198SFinn Thain BUG(); 794e9db3198SFinn Thain } 795e9db3198SFinn Thain #endif 796e9db3198SFinn Thain 7978053b0eeSFinn Thain NCR5380_write(MODE_REG, MR_BASE); 7988053b0eeSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 7998053b0eeSFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 8008053b0eeSFinn Thain 8014a98f896SFinn Thain transferred = hostdata->dma_len - NCR5380_dma_residual(hostdata); 8028053b0eeSFinn Thain hostdata->dma_len = 0; 8038053b0eeSFinn Thain 8048053b0eeSFinn Thain data = (unsigned char **)&hostdata->connected->SCp.ptr; 8058053b0eeSFinn Thain count = &hostdata->connected->SCp.this_residual; 8068053b0eeSFinn Thain *data += transferred; 8078053b0eeSFinn Thain *count -= transferred; 8088053b0eeSFinn Thain 8098053b0eeSFinn Thain if (hostdata->read_overruns) { 8108053b0eeSFinn Thain int cnt, toPIO; 8118053b0eeSFinn Thain 8128053b0eeSFinn Thain if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) { 8138053b0eeSFinn Thain cnt = toPIO = hostdata->read_overruns; 8148053b0eeSFinn Thain if (overrun) { 8158053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, 8168053b0eeSFinn Thain "Got an input overrun, using saved byte\n"); 8178053b0eeSFinn Thain *(*data)++ = saved_data; 8188053b0eeSFinn Thain (*count)--; 8198053b0eeSFinn Thain cnt--; 8208053b0eeSFinn Thain toPIO--; 8218053b0eeSFinn Thain } 8228053b0eeSFinn Thain if (toPIO > 0) { 8238053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, 8248053b0eeSFinn Thain "Doing %d byte PIO to 0x%p\n", cnt, *data); 825*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &p, &cnt, data, 0); 8268053b0eeSFinn Thain *count -= toPIO - cnt; 8278053b0eeSFinn Thain } 8288053b0eeSFinn Thain } 8298053b0eeSFinn Thain } 8308053b0eeSFinn Thain } 8318053b0eeSFinn Thain 8321da177e4SLinus Torvalds /** 8331da177e4SLinus Torvalds * NCR5380_intr - generic NCR5380 irq handler 8341da177e4SLinus Torvalds * @irq: interrupt number 8351da177e4SLinus Torvalds * @dev_id: device info 8361da177e4SLinus Torvalds * 8371da177e4SLinus Torvalds * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses 8381da177e4SLinus Torvalds * from the disconnected queue, and restarting NCR5380_main() 8391da177e4SLinus Torvalds * as required. 8401da177e4SLinus Torvalds * 841cd400825SFinn Thain * The chip can assert IRQ in any of six different conditions. The IRQ flag 842cd400825SFinn Thain * is then cleared by reading the Reset Parity/Interrupt Register (RPIR). 843cd400825SFinn Thain * Three of these six conditions are latched in the Bus and Status Register: 844cd400825SFinn Thain * - End of DMA (cleared by ending DMA Mode) 845cd400825SFinn Thain * - Parity error (cleared by reading RPIR) 846cd400825SFinn Thain * - Loss of BSY (cleared by reading RPIR) 847cd400825SFinn Thain * Two conditions have flag bits that are not latched: 848cd400825SFinn Thain * - Bus phase mismatch (non-maskable in DMA Mode, cleared by ending DMA Mode) 849cd400825SFinn Thain * - Bus reset (non-maskable) 850cd400825SFinn Thain * The remaining condition has no flag bit at all: 851cd400825SFinn Thain * - Selection/reselection 852cd400825SFinn Thain * 853cd400825SFinn Thain * Hence, establishing the cause(s) of any interrupt is partly guesswork. 854cd400825SFinn Thain * In "The DP8490 and DP5380 Comparison Guide", National Semiconductor 855cd400825SFinn Thain * claimed that "the design of the [DP8490] interrupt logic ensures 856cd400825SFinn Thain * interrupts will not be lost (they can be on the DP5380)." 857cd400825SFinn Thain * The L5380/53C80 datasheet from LOGIC Devices has more details. 858cd400825SFinn Thain * 859cd400825SFinn Thain * Checking for bus reset by reading RST is futile because of interrupt 860cd400825SFinn Thain * latency, but a bus reset will reset chip logic. Checking for parity error 861cd400825SFinn Thain * is unnecessary because that interrupt is never enabled. A Loss of BSY 862cd400825SFinn Thain * condition will clear DMA Mode. We can tell when this occurs because the 863cd400825SFinn Thain * the Busy Monitor interrupt is enabled together with DMA Mode. 8641da177e4SLinus Torvalds */ 8651da177e4SLinus Torvalds 866a46865dcSFinn Thain static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id) 8671da177e4SLinus Torvalds { 868baa9aac6SJeff Garzik struct Scsi_Host *instance = dev_id; 869cd400825SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 870cd400825SFinn Thain int handled = 0; 8711da177e4SLinus Torvalds unsigned char basr; 8721da177e4SLinus Torvalds unsigned long flags; 8731da177e4SLinus Torvalds 87411d2f63bSFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 875cd400825SFinn Thain 8761da177e4SLinus Torvalds basr = NCR5380_read(BUS_AND_STATUS_REG); 8771da177e4SLinus Torvalds if (basr & BASR_IRQ) { 878cd400825SFinn Thain unsigned char mr = NCR5380_read(MODE_REG); 879cd400825SFinn Thain unsigned char sr = NCR5380_read(STATUS_REG); 880cd400825SFinn Thain 881b746545fSFinn Thain dsprintk(NDEBUG_INTR, instance, "IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n", 882b746545fSFinn Thain irq, basr, sr, mr); 883cd400825SFinn Thain 8848053b0eeSFinn Thain if ((mr & MR_DMA_MODE) || (mr & MR_MONITOR_BSY)) { 8858053b0eeSFinn Thain /* Probably End of DMA, Phase Mismatch or Loss of BSY. 8868053b0eeSFinn Thain * We ack IRQ after clearing Mode Register. Workarounds 8878053b0eeSFinn Thain * for End of DMA errata need to happen in DMA Mode. 8888053b0eeSFinn Thain */ 8898053b0eeSFinn Thain 8908053b0eeSFinn Thain dsprintk(NDEBUG_INTR, instance, "interrupt in DMA mode\n"); 8918053b0eeSFinn Thain 8928053b0eeSFinn Thain if (hostdata->connected) { 8938053b0eeSFinn Thain NCR5380_dma_complete(instance); 8948053b0eeSFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 8958053b0eeSFinn Thain } else { 8968053b0eeSFinn Thain NCR5380_write(MODE_REG, MR_BASE); 8978053b0eeSFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 8988053b0eeSFinn Thain } 8998053b0eeSFinn Thain } else if ((NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_mask) && 900cd400825SFinn Thain (sr & (SR_SEL | SR_IO | SR_BSY | SR_RST)) == (SR_SEL | SR_IO)) { 901cd400825SFinn Thain /* Probably reselected */ 902cd400825SFinn Thain NCR5380_write(SELECT_ENABLE_REG, 0); 903cd400825SFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 904cd400825SFinn Thain 905b746545fSFinn Thain dsprintk(NDEBUG_INTR, instance, "interrupt with SEL and IO\n"); 906cd400825SFinn Thain 907cd400825SFinn Thain if (!hostdata->connected) { 908cd400825SFinn Thain NCR5380_reselect(instance); 9098d8601a7SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 910cd400825SFinn Thain } 911cd400825SFinn Thain if (!hostdata->connected) 912cd400825SFinn Thain NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 913cd400825SFinn Thain } else { 914cd400825SFinn Thain /* Probably Bus Reset */ 915cd400825SFinn Thain NCR5380_read(RESET_PARITY_INTERRUPT_REG); 916cd400825SFinn Thain 9176b0e87a6SFinn Thain if (sr & SR_RST) { 9186b0e87a6SFinn Thain /* Certainly Bus Reset */ 9196b0e87a6SFinn Thain shost_printk(KERN_WARNING, instance, 9206b0e87a6SFinn Thain "bus reset interrupt\n"); 9216b0e87a6SFinn Thain bus_reset_cleanup(instance); 9226b0e87a6SFinn Thain } else { 923b746545fSFinn Thain dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n"); 9246b0e87a6SFinn Thain } 925e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 926e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 927e9db3198SFinn Thain #endif 928cd400825SFinn Thain } 929cd400825SFinn Thain handled = 1; 930cd400825SFinn Thain } else { 9319af9fecbSFinn Thain dsprintk(NDEBUG_INTR, instance, "interrupt without IRQ bit\n"); 932e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 933e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 934e9db3198SFinn Thain #endif 935cd400825SFinn Thain } 936cd400825SFinn Thain 93711d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 938cd400825SFinn Thain 939cd400825SFinn Thain return IRQ_RETVAL(handled); 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds 942dad8261eSFinn Thain /** 943dad8261eSFinn Thain * NCR5380_select - attempt arbitration and selection for a given command 944dad8261eSFinn Thain * @instance: the Scsi_Host instance 945dad8261eSFinn Thain * @cmd: the scsi_cmnd to execute 9461da177e4SLinus Torvalds * 947dad8261eSFinn Thain * This routine establishes an I_T_L nexus for a SCSI command. This involves 948dad8261eSFinn Thain * ARBITRATION, SELECTION and MESSAGE OUT phases and an IDENTIFY message. 9491da177e4SLinus Torvalds * 950dad8261eSFinn Thain * Returns true if the operation should be retried. 951dad8261eSFinn Thain * Returns false if it should not be retried. 9521da177e4SLinus Torvalds * 9531da177e4SLinus Torvalds * Side effects : 9541da177e4SLinus Torvalds * If bus busy, arbitration failed, etc, NCR5380_select() will exit 9551da177e4SLinus Torvalds * with registers as they should have been on entry - ie 9561da177e4SLinus Torvalds * SELECT_ENABLE will be set appropriately, the NCR5380 9571da177e4SLinus Torvalds * will cease to drive any SCSI bus signals. 9581da177e4SLinus Torvalds * 959dad8261eSFinn Thain * If successful : the I_T_L nexus will be established, and 960dad8261eSFinn Thain * hostdata->connected will be set to cmd. 9611da177e4SLinus Torvalds * SELECT interrupt will be disabled. 9621da177e4SLinus Torvalds * 9631da177e4SLinus Torvalds * If failed (no target) : cmd->scsi_done() will be called, and the 9641da177e4SLinus Torvalds * cmd->result host byte set to DID_BAD_TARGET. 9651da177e4SLinus Torvalds */ 9661da177e4SLinus Torvalds 967dad8261eSFinn Thain static bool NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd) 9684ab2a787SFinn Thain __releases(&hostdata->lock) __acquires(&hostdata->lock) 9691da177e4SLinus Torvalds { 970e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 9711da177e4SLinus Torvalds unsigned char tmp[3], phase; 9721da177e4SLinus Torvalds unsigned char *data; 9731da177e4SLinus Torvalds int len; 9741da177e4SLinus Torvalds int err; 975dad8261eSFinn Thain bool ret = true; 9767c8ed783SFinn Thain bool can_disconnect = instance->irq != NO_IRQ && 9770b7a2235SFinn Thain cmd->cmnd[0] != REQUEST_SENSE && 9780b7a2235SFinn Thain (disconnect_mask & BIT(scmd_id(cmd))); 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_ARBITRATION, instance); 981b746545fSFinn Thain dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n", 982b746545fSFinn Thain instance->this_id); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds /* 985707d62b3SFinn Thain * Arbitration and selection phases are slow and involve dropping the 986707d62b3SFinn Thain * lock, so we have to watch out for EH. An exception handler may 987dad8261eSFinn Thain * change 'selecting' to NULL. This function will then return false 988707d62b3SFinn Thain * so that the caller will forget about 'cmd'. (During information 989707d62b3SFinn Thain * transfer phases, EH may change 'connected' to NULL.) 990707d62b3SFinn Thain */ 991707d62b3SFinn Thain hostdata->selecting = cmd; 992707d62b3SFinn Thain 993707d62b3SFinn Thain /* 9941da177e4SLinus Torvalds * Set the phase bits to 0, otherwise the NCR5380 won't drive the 9951da177e4SLinus Torvalds * data bus during SELECTION. 9961da177e4SLinus Torvalds */ 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 9991da177e4SLinus Torvalds 10001da177e4SLinus Torvalds /* 10011da177e4SLinus Torvalds * Start arbitration. 10021da177e4SLinus Torvalds */ 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask); 10051da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_ARBITRATE); 10061da177e4SLinus Torvalds 100755500d9bSFinn Thain /* The chip now waits for BUS FREE phase. Then after the 800 ns 100855500d9bSFinn Thain * Bus Free Delay, arbitration will begin. 10091da177e4SLinus Torvalds */ 10101da177e4SLinus Torvalds 101111d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 1012d5d37a0aSFinn Thain err = NCR5380_poll_politely2(hostdata, MODE_REG, MR_ARBITRATE, 0, 1013b32ade12SFinn Thain INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS, 1014b32ade12SFinn Thain ICR_ARBITRATION_PROGRESS, HZ); 101511d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 101655500d9bSFinn Thain if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) { 101755500d9bSFinn Thain /* Reselection interrupt */ 1018707d62b3SFinn Thain goto out; 101955500d9bSFinn Thain } 1020ccf6efd7SFinn Thain if (!hostdata->selecting) { 1021ccf6efd7SFinn Thain /* Command was aborted */ 1022ccf6efd7SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 1023dad8261eSFinn Thain return false; 1024ccf6efd7SFinn Thain } 1025b32ade12SFinn Thain if (err < 0) { 1026b32ade12SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 1027b32ade12SFinn Thain shost_printk(KERN_ERR, instance, 1028b32ade12SFinn Thain "select: arbitration timeout\n"); 1029707d62b3SFinn Thain goto out; 103055500d9bSFinn Thain } 103111d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 103255500d9bSFinn Thain 103355500d9bSFinn Thain /* The SCSI-2 arbitration delay is 2.4 us */ 10341da177e4SLinus Torvalds udelay(3); 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds /* Check for lost arbitration */ 10370d2cf867SFinn Thain if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) || 10380d2cf867SFinn Thain (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) || 10390d2cf867SFinn Thain (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) { 10401da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 1041b746545fSFinn Thain dsprintk(NDEBUG_ARBITRATION, instance, "lost arbitration, deasserting MR_ARBITRATE\n"); 104211d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 1043707d62b3SFinn Thain goto out; 10441da177e4SLinus Torvalds } 1045cf13b083SFinn Thain 1046cf13b083SFinn Thain /* After/during arbitration, BSY should be asserted. 1047cf13b083SFinn Thain * IBM DPES-31080 Version S31Q works now 1048cf13b083SFinn Thain * Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman) 1049cf13b083SFinn Thain */ 1050cf13b083SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, 1051cf13b083SFinn Thain ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY); 10521da177e4SLinus Torvalds 10531da177e4SLinus Torvalds /* 10541da177e4SLinus Torvalds * Again, bus clear + bus settle time is 1.2us, however, this is 10551da177e4SLinus Torvalds * a minimum so we'll udelay ceil(1.2) 10561da177e4SLinus Torvalds */ 10571da177e4SLinus Torvalds 10589c3f0e2bSFinn Thain if (hostdata->flags & FLAG_TOSHIBA_DELAY) 10599c3f0e2bSFinn Thain udelay(15); 10609c3f0e2bSFinn Thain else 10611da177e4SLinus Torvalds udelay(2); 10621da177e4SLinus Torvalds 106311d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 106411d2f63bSFinn Thain 106572064a78SFinn Thain /* NCR5380_reselect() clears MODE_REG after a reselection interrupt */ 106672064a78SFinn Thain if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) 1067707d62b3SFinn Thain goto out; 1068707d62b3SFinn Thain 1069707d62b3SFinn Thain if (!hostdata->selecting) { 1070707d62b3SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 1071707d62b3SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1072dad8261eSFinn Thain return false; 1073707d62b3SFinn Thain } 107472064a78SFinn Thain 1075b746545fSFinn Thain dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n"); 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds /* 10781da177e4SLinus Torvalds * Now that we have won arbitration, start Selection process, asserting 10791da177e4SLinus Torvalds * the host and target ID's on the SCSI bus. 10801da177e4SLinus Torvalds */ 10811da177e4SLinus Torvalds 10823d07d22bSFinn Thain NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask | (1 << scmd_id(cmd))); 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds /* 10851da177e4SLinus Torvalds * Raise ATN while SEL is true before BSY goes false from arbitration, 10861da177e4SLinus Torvalds * since this is the only way to guarantee that we'll get a MESSAGE OUT 10871da177e4SLinus Torvalds * phase immediately after selection. 10881da177e4SLinus Torvalds */ 10891da177e4SLinus Torvalds 10903d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY | 10913d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL); 10921da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds /* 10951da177e4SLinus Torvalds * Reselect interrupts must be turned off prior to the dropping of BSY, 10961da177e4SLinus Torvalds * otherwise we will trigger an interrupt. 10971da177e4SLinus Torvalds */ 10981da177e4SLinus Torvalds NCR5380_write(SELECT_ENABLE_REG, 0); 10991da177e4SLinus Torvalds 110011d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 110111d2f63bSFinn Thain 11021da177e4SLinus Torvalds /* 11031da177e4SLinus Torvalds * The initiator shall then wait at least two deskew delays and release 11041da177e4SLinus Torvalds * the BSY signal. 11051da177e4SLinus Torvalds */ 11061da177e4SLinus Torvalds udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */ 11071da177e4SLinus Torvalds 11081da177e4SLinus Torvalds /* Reset BSY */ 11093d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | 11103d07d22bSFinn Thain ICR_ASSERT_ATN | ICR_ASSERT_SEL); 11111da177e4SLinus Torvalds 11121da177e4SLinus Torvalds /* 11131da177e4SLinus Torvalds * Something weird happens when we cease to drive BSY - looks 11141da177e4SLinus Torvalds * like the board/chip is letting us do another read before the 11151da177e4SLinus Torvalds * appropriate propagation delay has expired, and we're confusing 11161da177e4SLinus Torvalds * a BSY signal from ourselves as the target's response to SELECTION. 11171da177e4SLinus Torvalds * 11181da177e4SLinus Torvalds * A small delay (the 'C++' frontend breaks the pipeline with an 11191da177e4SLinus Torvalds * unnecessary jump, making it work on my 386-33/Trantor T128, the 11201da177e4SLinus Torvalds * tighter 'C' code breaks and requires this) solves the problem - 11211da177e4SLinus Torvalds * the 1 us delay is arbitrary, and only used because this delay will 11221da177e4SLinus Torvalds * be the same on other platforms and since it works here, it should 11231da177e4SLinus Torvalds * work there. 11241da177e4SLinus Torvalds * 11251da177e4SLinus Torvalds * wingel suggests that this could be due to failing to wait 11261da177e4SLinus Torvalds * one deskew delay. 11271da177e4SLinus Torvalds */ 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds udelay(1); 11301da177e4SLinus Torvalds 1131b746545fSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "selecting target %d\n", scmd_id(cmd)); 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds /* 11341da177e4SLinus Torvalds * The SCSI specification calls for a 250 ms timeout for the actual 11351da177e4SLinus Torvalds * selection. 11361da177e4SLinus Torvalds */ 11371da177e4SLinus Torvalds 1138d5d37a0aSFinn Thain err = NCR5380_poll_politely(hostdata, STATUS_REG, SR_BSY, SR_BSY, 1139ae753a33SFinn Thain msecs_to_jiffies(250)); 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) { 114211d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 11431da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 11441da177e4SLinus Torvalds NCR5380_reselect(instance); 11456a6ff4acSFinn Thain shost_printk(KERN_ERR, instance, "reselection after won arbitration?\n"); 1146707d62b3SFinn Thain goto out; 11471da177e4SLinus Torvalds } 1148ae753a33SFinn Thain 1149ae753a33SFinn Thain if (err < 0) { 115011d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 1151ae753a33SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 11526a162836SFinn Thain 1153707d62b3SFinn Thain /* Can't touch cmd if it has been reclaimed by the scsi ML */ 11546a162836SFinn Thain if (!hostdata->selecting) 1155dad8261eSFinn Thain return false; 11566a162836SFinn Thain 1157ae753a33SFinn Thain cmd->result = DID_BAD_TARGET << 16; 1158677e0194SFinn Thain complete_cmd(instance, cmd); 11596a162836SFinn Thain dsprintk(NDEBUG_SELECTION, instance, 11606a162836SFinn Thain "target did not respond within 250ms\n"); 1161dad8261eSFinn Thain ret = false; 1162707d62b3SFinn Thain goto out; 1163ae753a33SFinn Thain } 1164ae753a33SFinn Thain 11651da177e4SLinus Torvalds /* 11661da177e4SLinus Torvalds * No less than two deskew delays after the initiator detects the 11671da177e4SLinus Torvalds * BSY signal is true, it shall release the SEL signal and may 11681da177e4SLinus Torvalds * change the DATA BUS. -wingel 11691da177e4SLinus Torvalds */ 11701da177e4SLinus Torvalds 11711da177e4SLinus Torvalds udelay(1); 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds /* 11761da177e4SLinus Torvalds * Since we followed the SCSI spec, and raised ATN while SEL 11771da177e4SLinus Torvalds * was true but before BSY was false during selection, the information 11781da177e4SLinus Torvalds * transfer phase should be a MESSAGE OUT phase so that we can send the 11791da177e4SLinus Torvalds * IDENTIFY message. 11801da177e4SLinus Torvalds */ 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds /* Wait for start of REQ/ACK handshake */ 11831da177e4SLinus Torvalds 1184d5d37a0aSFinn Thain err = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ); 118511d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 11861cc160e1SFinn Thain if (err < 0) { 118755500d9bSFinn Thain shost_printk(KERN_ERR, instance, "select: REQ timeout\n"); 118855500d9bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1189707d62b3SFinn Thain goto out; 1190707d62b3SFinn Thain } 1191707d62b3SFinn Thain if (!hostdata->selecting) { 1192*e7734ef1SAhmed S. Darwish do_abort(instance, 0); 1193dad8261eSFinn Thain return false; 11941da177e4SLinus Torvalds } 11951da177e4SLinus Torvalds 1196b746545fSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n", 1197b746545fSFinn Thain scmd_id(cmd)); 11987c8ed783SFinn Thain tmp[0] = IDENTIFY(can_disconnect, cmd->device->lun); 11991da177e4SLinus Torvalds 12001da177e4SLinus Torvalds len = 1; 12011da177e4SLinus Torvalds data = tmp; 12021da177e4SLinus Torvalds phase = PHASE_MSGOUT; 1203*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 0); 1204b15e791dSFinn Thain if (len) { 1205b15e791dSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1206b15e791dSFinn Thain cmd->result = DID_ERROR << 16; 1207b15e791dSFinn Thain complete_cmd(instance, cmd); 1208b15e791dSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "IDENTIFY message transfer failed\n"); 1209dad8261eSFinn Thain ret = false; 1210b15e791dSFinn Thain goto out; 1211b15e791dSFinn Thain } 1212b15e791dSFinn Thain 1213b746545fSFinn Thain dsprintk(NDEBUG_SELECTION, instance, "nexus established.\n"); 121411d2f63bSFinn Thain 12151da177e4SLinus Torvalds hostdata->connected = cmd; 12163d07d22bSFinn Thain hostdata->busy[cmd->device->id] |= 1 << cmd->device->lun; 12171da177e4SLinus Torvalds 1218e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1219e9db3198SFinn Thain dregs->csr |= CSR_INTR; 1220e9db3198SFinn Thain #endif 1221e9db3198SFinn Thain 12221da177e4SLinus Torvalds initialize_SCp(cmd); 12231da177e4SLinus Torvalds 1224dad8261eSFinn Thain ret = false; 1225707d62b3SFinn Thain 1226707d62b3SFinn Thain out: 1227707d62b3SFinn Thain if (!hostdata->selecting) 122896edebd6SFinn Thain return false; 1229707d62b3SFinn Thain hostdata->selecting = NULL; 1230dad8261eSFinn Thain return ret; 12311da177e4SLinus Torvalds } 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds /* 12341da177e4SLinus Torvalds * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 12351da177e4SLinus Torvalds * unsigned char *phase, int *count, unsigned char **data) 12361da177e4SLinus Torvalds * 12371da177e4SLinus Torvalds * Purpose : transfers data in given phase using polled I/O 12381da177e4SLinus Torvalds * 12391da177e4SLinus Torvalds * Inputs : instance - instance of driver, *phase - pointer to 12401da177e4SLinus Torvalds * what phase is expected, *count - pointer to number of 1241*e7734ef1SAhmed S. Darwish * bytes to transfer, **data - pointer to data pointer, 1242*e7734ef1SAhmed S. Darwish * can_sleep - 1 or 0 when sleeping is permitted or not, respectively. 12431da177e4SLinus Torvalds * 12441da177e4SLinus Torvalds * Returns : -1 when different phase is entered without transferring 12450d2cf867SFinn Thain * maximum number of bytes, 0 if all bytes are transferred or exit 12461da177e4SLinus Torvalds * is in same phase. 12471da177e4SLinus Torvalds * 12481da177e4SLinus Torvalds * Also, *phase, *count, *data are modified in place. 12491da177e4SLinus Torvalds * 12501da177e4SLinus Torvalds * XXX Note : handling for bus free may be useful. 12511da177e4SLinus Torvalds */ 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds /* 12541da177e4SLinus Torvalds * Note : this code is not as quick as it could be, however it 12551da177e4SLinus Torvalds * IS 100% reliable, and for the actual data transfer where speed 12561da177e4SLinus Torvalds * counts, we will always do a pseudo DMA or DMA transfer. 12571da177e4SLinus Torvalds */ 12581da177e4SLinus Torvalds 12590d2cf867SFinn Thain static int NCR5380_transfer_pio(struct Scsi_Host *instance, 12600d2cf867SFinn Thain unsigned char *phase, int *count, 1261*e7734ef1SAhmed S. Darwish unsigned char **data, unsigned int can_sleep) 12620d2cf867SFinn Thain { 126361e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 12641da177e4SLinus Torvalds unsigned char p = *phase, tmp; 12651da177e4SLinus Torvalds int c = *count; 12661da177e4SLinus Torvalds unsigned char *d = *data; 12671da177e4SLinus Torvalds 12681da177e4SLinus Torvalds /* 12691da177e4SLinus Torvalds * The NCR5380 chip will only drive the SCSI bus when the 12701da177e4SLinus Torvalds * phase specified in the appropriate bits of the TARGET COMMAND 12711da177e4SLinus Torvalds * REGISTER match the STATUS REGISTER 12721da177e4SLinus Torvalds */ 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds do { 12771da177e4SLinus Torvalds /* 12781da177e4SLinus Torvalds * Wait for assertion of REQ, after which the phase bits will be 12791da177e4SLinus Torvalds * valid 12801da177e4SLinus Torvalds */ 12811da177e4SLinus Torvalds 1282*e7734ef1SAhmed S. Darwish if (NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, 1283*e7734ef1SAhmed S. Darwish HZ * can_sleep) < 0) 12841da177e4SLinus Torvalds break; 12851da177e4SLinus Torvalds 1286b746545fSFinn Thain dsprintk(NDEBUG_HANDSHAKE, instance, "REQ asserted\n"); 12871da177e4SLinus Torvalds 12881da177e4SLinus Torvalds /* Check for phase mismatch */ 1289686f3990SFinn Thain if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) { 1290b746545fSFinn Thain dsprintk(NDEBUG_PIO, instance, "phase mismatch\n"); 1291b746545fSFinn Thain NCR5380_dprint_phase(NDEBUG_PIO, instance); 12921da177e4SLinus Torvalds break; 12931da177e4SLinus Torvalds } 12940d2cf867SFinn Thain 12951da177e4SLinus Torvalds /* Do actual transfer from SCSI bus to / from memory */ 12961da177e4SLinus Torvalds if (!(p & SR_IO)) 12971da177e4SLinus Torvalds NCR5380_write(OUTPUT_DATA_REG, *d); 12981da177e4SLinus Torvalds else 12991da177e4SLinus Torvalds *d = NCR5380_read(CURRENT_SCSI_DATA_REG); 13001da177e4SLinus Torvalds 13011da177e4SLinus Torvalds ++d; 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds /* 13041da177e4SLinus Torvalds * The SCSI standard suggests that in MSGOUT phase, the initiator 13051da177e4SLinus Torvalds * should drop ATN on the last byte of the message phase 13061da177e4SLinus Torvalds * after REQ has been asserted for the handshake but before 13071da177e4SLinus Torvalds * the initiator raises ACK. 13081da177e4SLinus Torvalds */ 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds if (!(p & SR_IO)) { 13111da177e4SLinus Torvalds if (!((p & SR_MSG) && c > 1)) { 13121da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 13131da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_PIO, instance); 13143d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 13153d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ACK); 13161da177e4SLinus Torvalds } else { 13173d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 13183d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ATN); 13191da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_PIO, instance); 13203d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 13213d07d22bSFinn Thain ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 13221da177e4SLinus Torvalds } 13231da177e4SLinus Torvalds } else { 13241da177e4SLinus Torvalds NCR5380_dprint(NDEBUG_PIO, instance); 13251da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK); 13261da177e4SLinus Torvalds } 13271da177e4SLinus Torvalds 1328d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, 1329*e7734ef1SAhmed S. Darwish STATUS_REG, SR_REQ, 0, 5 * HZ * can_sleep) < 0) 1330a2edc4a6SFinn Thain break; 1331a2edc4a6SFinn Thain 1332b746545fSFinn Thain dsprintk(NDEBUG_HANDSHAKE, instance, "REQ negated, handshake complete\n"); 13331da177e4SLinus Torvalds 13341da177e4SLinus Torvalds /* 13351da177e4SLinus Torvalds * We have several special cases to consider during REQ/ACK handshaking : 13361da177e4SLinus Torvalds * 1. We were in MSGOUT phase, and we are on the last byte of the 13371da177e4SLinus Torvalds * message. ATN must be dropped as ACK is dropped. 13381da177e4SLinus Torvalds * 13391da177e4SLinus Torvalds * 2. We are in a MSGIN phase, and we are on the last byte of the 13401da177e4SLinus Torvalds * message. We must exit with ACK asserted, so that the calling 13411da177e4SLinus Torvalds * code may raise ATN before dropping ACK to reject the message. 13421da177e4SLinus Torvalds * 13431da177e4SLinus Torvalds * 3. ACK and ATN are clear and the target may proceed as normal. 13441da177e4SLinus Torvalds */ 13451da177e4SLinus Torvalds if (!(p == PHASE_MSGIN && c == 1)) { 13461da177e4SLinus Torvalds if (p == PHASE_MSGOUT && c > 1) 13471da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 13481da177e4SLinus Torvalds else 13491da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 13501da177e4SLinus Torvalds } 13511da177e4SLinus Torvalds } while (--c); 13521da177e4SLinus Torvalds 1353b746545fSFinn Thain dsprintk(NDEBUG_PIO, instance, "residual %d\n", c); 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds *count = c; 13561da177e4SLinus Torvalds *data = d; 13571da177e4SLinus Torvalds tmp = NCR5380_read(STATUS_REG); 1358a2edc4a6SFinn Thain /* The phase read from the bus is valid if either REQ is (already) 1359a2edc4a6SFinn Thain * asserted or if ACK hasn't been released yet. The latter applies if 1360a2edc4a6SFinn Thain * we're in MSG IN, DATA IN or STATUS and all bytes have been received. 1361a2edc4a6SFinn Thain */ 1362a2edc4a6SFinn Thain if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0)) 13631da177e4SLinus Torvalds *phase = tmp & PHASE_MASK; 13641da177e4SLinus Torvalds else 13651da177e4SLinus Torvalds *phase = PHASE_UNKNOWN; 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds if (!c || (*phase == p)) 13681da177e4SLinus Torvalds return 0; 13691da177e4SLinus Torvalds else 13701da177e4SLinus Torvalds return -1; 13711da177e4SLinus Torvalds } 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds /** 13741da177e4SLinus Torvalds * do_reset - issue a reset command 1375636b1ec8SFinn Thain * @instance: adapter to reset 13761da177e4SLinus Torvalds * 13771da177e4SLinus Torvalds * Issue a reset sequence to the NCR5380 and try and get the bus 13781da177e4SLinus Torvalds * back into sane shape. 13791da177e4SLinus Torvalds * 1380636b1ec8SFinn Thain * This clears the reset interrupt flag because there may be no handler for 1381636b1ec8SFinn Thain * it. When the driver is initialized, the NCR5380_intr() handler has not yet 1382636b1ec8SFinn Thain * been installed. And when in EH we may have released the ST DMA interrupt. 13831da177e4SLinus Torvalds */ 13841da177e4SLinus Torvalds 138554d8fe44SFinn Thain static void do_reset(struct Scsi_Host *instance) 138654d8fe44SFinn Thain { 138761e1ce58SFinn Thain struct NCR5380_hostdata __maybe_unused *hostdata = shost_priv(instance); 1388636b1ec8SFinn Thain unsigned long flags; 1389636b1ec8SFinn Thain 1390636b1ec8SFinn Thain local_irq_save(flags); 1391636b1ec8SFinn Thain NCR5380_write(TARGET_COMMAND_REG, 1392636b1ec8SFinn Thain PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK)); 13931da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST); 1394636b1ec8SFinn Thain udelay(50); 13951da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1396636b1ec8SFinn Thain (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1397636b1ec8SFinn Thain local_irq_restore(flags); 13981da177e4SLinus Torvalds } 13991da177e4SLinus Torvalds 140080d3eb6dSFinn Thain /** 140180d3eb6dSFinn Thain * do_abort - abort the currently established nexus by going to 140280d3eb6dSFinn Thain * MESSAGE OUT phase and sending an ABORT message. 140380d3eb6dSFinn Thain * @instance: relevant scsi host instance 1404*e7734ef1SAhmed S. Darwish * @can_sleep: 1 or 0 when sleeping is permitted or not, respectively 14051da177e4SLinus Torvalds * 1406d04fc41aSFinn Thain * Returns 0 on success, negative error code on failure. 14071da177e4SLinus Torvalds */ 14081da177e4SLinus Torvalds 1409*e7734ef1SAhmed S. Darwish static int do_abort(struct Scsi_Host *instance, unsigned int can_sleep) 141054d8fe44SFinn Thain { 141161e1ce58SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 14121da177e4SLinus Torvalds unsigned char *msgptr, phase, tmp; 14131da177e4SLinus Torvalds int len; 14141da177e4SLinus Torvalds int rc; 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds /* Request message out phase */ 14171da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds /* 14201da177e4SLinus Torvalds * Wait for the target to indicate a valid phase by asserting 14211da177e4SLinus Torvalds * REQ. Once this happens, we'll have either a MSGOUT phase 14221da177e4SLinus Torvalds * and can immediately send the ABORT message, or we'll have some 14231da177e4SLinus Torvalds * other phase and will have to source/sink data. 14241da177e4SLinus Torvalds * 14251da177e4SLinus Torvalds * We really don't care what value was on the bus or what value 14261da177e4SLinus Torvalds * the target sees, so we just handshake. 14271da177e4SLinus Torvalds */ 14281da177e4SLinus Torvalds 1429*e7734ef1SAhmed S. Darwish rc = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, 1430*e7734ef1SAhmed S. Darwish 10 * HZ * can_sleep); 14311da177e4SLinus Torvalds if (rc < 0) 1432d04fc41aSFinn Thain goto out; 14331da177e4SLinus Torvalds 1434f35d3474SFinn Thain tmp = NCR5380_read(STATUS_REG) & PHASE_MASK; 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 14371da177e4SLinus Torvalds 1438f35d3474SFinn Thain if (tmp != PHASE_MSGOUT) { 14390d2cf867SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, 14400d2cf867SFinn Thain ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 1441*e7734ef1SAhmed S. Darwish rc = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, 0, 1442*e7734ef1SAhmed S. Darwish 3 * HZ * can_sleep); 14431cc160e1SFinn Thain if (rc < 0) 1444d04fc41aSFinn Thain goto out; 144580d3eb6dSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 14461da177e4SLinus Torvalds } 14470d2cf867SFinn Thain 14481da177e4SLinus Torvalds tmp = ABORT; 14491da177e4SLinus Torvalds msgptr = &tmp; 14501da177e4SLinus Torvalds len = 1; 14511da177e4SLinus Torvalds phase = PHASE_MSGOUT; 1452*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &msgptr, can_sleep); 1453d04fc41aSFinn Thain if (len) 1454d04fc41aSFinn Thain rc = -ENXIO; 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds /* 14571da177e4SLinus Torvalds * If we got here, and the command completed successfully, 14581da177e4SLinus Torvalds * we're about to go into bus free state. 14591da177e4SLinus Torvalds */ 14601da177e4SLinus Torvalds 1461d04fc41aSFinn Thain out: 146280d3eb6dSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1463d04fc41aSFinn Thain return rc; 14641da177e4SLinus Torvalds } 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds /* 14671da177e4SLinus Torvalds * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 14681da177e4SLinus Torvalds * unsigned char *phase, int *count, unsigned char **data) 14691da177e4SLinus Torvalds * 14701da177e4SLinus Torvalds * Purpose : transfers data in given phase using either real 14711da177e4SLinus Torvalds * or pseudo DMA. 14721da177e4SLinus Torvalds * 14731da177e4SLinus Torvalds * Inputs : instance - instance of driver, *phase - pointer to 14741da177e4SLinus Torvalds * what phase is expected, *count - pointer to number of 14751da177e4SLinus Torvalds * bytes to transfer, **data - pointer to data pointer. 14761da177e4SLinus Torvalds * 14771da177e4SLinus Torvalds * Returns : -1 when different phase is entered without transferring 147825985edcSLucas De Marchi * maximum number of bytes, 0 if all bytes or transferred or exit 14791da177e4SLinus Torvalds * is in same phase. 14801da177e4SLinus Torvalds * 14811da177e4SLinus Torvalds * Also, *phase, *count, *data are modified in place. 14821da177e4SLinus Torvalds */ 14831da177e4SLinus Torvalds 14841da177e4SLinus Torvalds 14850d2cf867SFinn Thain static int NCR5380_transfer_dma(struct Scsi_Host *instance, 14860d2cf867SFinn Thain unsigned char *phase, int *count, 14870d2cf867SFinn Thain unsigned char **data) 14880d2cf867SFinn Thain { 14890d2cf867SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 1490f0ea73a4SFinn Thain int c = *count; 1491f0ea73a4SFinn Thain unsigned char p = *phase; 1492f0ea73a4SFinn Thain unsigned char *d = *data; 14931da177e4SLinus Torvalds unsigned char tmp; 14948053b0eeSFinn Thain int result = 0; 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) { 14971da177e4SLinus Torvalds *phase = tmp; 14981da177e4SLinus Torvalds return -1; 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds 15018053b0eeSFinn Thain hostdata->connected->SCp.phase = p; 15028053b0eeSFinn Thain 15038053b0eeSFinn Thain if (p & SR_IO) { 15048053b0eeSFinn Thain if (hostdata->read_overruns) 15058053b0eeSFinn Thain c -= hostdata->read_overruns; 15068053b0eeSFinn Thain else if (hostdata->flags & FLAG_DMA_FIXUP) 15078053b0eeSFinn Thain --c; 15088053b0eeSFinn Thain } 15098053b0eeSFinn Thain 15108053b0eeSFinn Thain dsprintk(NDEBUG_DMA, instance, "initializing DMA %s: length %d, address %p\n", 15118053b0eeSFinn Thain (p & SR_IO) ? "receive" : "send", c, d); 15128053b0eeSFinn Thain 1513e9db3198SFinn Thain #ifdef CONFIG_SUN3 1514e9db3198SFinn Thain /* send start chain */ 1515e9db3198SFinn Thain sun3scsi_dma_start(c, *data); 1516e9db3198SFinn Thain #endif 1517e9db3198SFinn Thain 15181da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 1519cd400825SFinn Thain NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY | 1520cd400825SFinn Thain MR_ENABLE_EOP_INTR); 15211da177e4SLinus Torvalds 15228053b0eeSFinn Thain if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) { 15238053b0eeSFinn Thain /* On the Medusa, it is a must to initialize the DMA before 15248053b0eeSFinn Thain * starting the NCR. This is also the cleaner way for the TT. 15258053b0eeSFinn Thain */ 15268053b0eeSFinn Thain if (p & SR_IO) 15274a98f896SFinn Thain result = NCR5380_dma_recv_setup(hostdata, d, c); 15288053b0eeSFinn Thain else 15294a98f896SFinn Thain result = NCR5380_dma_send_setup(hostdata, d, c); 15308053b0eeSFinn Thain } 15311da177e4SLinus Torvalds 15321da177e4SLinus Torvalds /* 15331da177e4SLinus Torvalds * On the PAS16 at least I/O recovery delays are not needed here. 15341da177e4SLinus Torvalds * Everyone else seems to want them. 15351da177e4SLinus Torvalds */ 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds if (p & SR_IO) { 1538e9db3198SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1539e5d55d1aSFinn Thain NCR5380_io_delay(1); 15401da177e4SLinus Torvalds NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0); 15411da177e4SLinus Torvalds } else { 1542e5d55d1aSFinn Thain NCR5380_io_delay(1); 15431da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 1544e5d55d1aSFinn Thain NCR5380_io_delay(1); 15451da177e4SLinus Torvalds NCR5380_write(START_DMA_SEND_REG, 0); 1546e5d55d1aSFinn Thain NCR5380_io_delay(1); 15471da177e4SLinus Torvalds } 15481da177e4SLinus Torvalds 1549e9db3198SFinn Thain #ifdef CONFIG_SUN3 1550e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1551e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 1552e9db3198SFinn Thain #endif 1553e9db3198SFinn Thain sun3_dma_active = 1; 1554e9db3198SFinn Thain #endif 1555e9db3198SFinn Thain 15568053b0eeSFinn Thain if (hostdata->flags & FLAG_LATE_DMA_SETUP) { 15578053b0eeSFinn Thain /* On the Falcon, the DMA setup must be done after the last 15588053b0eeSFinn Thain * NCR access, else the DMA setup gets trashed! 15598053b0eeSFinn Thain */ 15608053b0eeSFinn Thain if (p & SR_IO) 15614a98f896SFinn Thain result = NCR5380_dma_recv_setup(hostdata, d, c); 15628053b0eeSFinn Thain else 15634a98f896SFinn Thain result = NCR5380_dma_send_setup(hostdata, d, c); 15648053b0eeSFinn Thain } 15658053b0eeSFinn Thain 15668053b0eeSFinn Thain /* On failure, NCR5380_dma_xxxx_setup() returns a negative int. */ 15678053b0eeSFinn Thain if (result < 0) 15688053b0eeSFinn Thain return result; 15698053b0eeSFinn Thain 15708053b0eeSFinn Thain /* For real DMA, result is the byte count. DMA interrupt is expected. */ 15718053b0eeSFinn Thain if (result > 0) { 15728053b0eeSFinn Thain hostdata->dma_len = result; 15738053b0eeSFinn Thain return 0; 15748053b0eeSFinn Thain } 15758053b0eeSFinn Thain 15768053b0eeSFinn Thain /* The result is zero iff pseudo DMA send/receive was completed. */ 15778053b0eeSFinn Thain hostdata->dma_len = c; 15788053b0eeSFinn Thain 15791da177e4SLinus Torvalds /* 1580e4dec680SFinn Thain * A note regarding the DMA errata workarounds for early NMOS silicon. 1581c16df32eSFinn Thain * 1582c16df32eSFinn Thain * For DMA sends, we want to wait until the last byte has been 1583c16df32eSFinn Thain * transferred out over the bus before we turn off DMA mode. Alas, there 1584c16df32eSFinn Thain * seems to be no terribly good way of doing this on a 5380 under all 1585c16df32eSFinn Thain * conditions. For non-scatter-gather operations, we can wait until REQ 1586c16df32eSFinn Thain * and ACK both go false, or until a phase mismatch occurs. Gather-sends 1587c16df32eSFinn Thain * are nastier, since the device will be expecting more data than we 1588c16df32eSFinn Thain * are prepared to send it, and REQ will remain asserted. On a 53C8[01] we 1589c16df32eSFinn Thain * could test Last Byte Sent to assure transfer (I imagine this is precisely 1590c16df32eSFinn Thain * why this signal was added to the newer chips) but on the older 538[01] 1591c16df32eSFinn Thain * this signal does not exist. The workaround for this lack is a watchdog; 1592c16df32eSFinn Thain * we bail out of the wait-loop after a modest amount of wait-time if 1593c16df32eSFinn Thain * the usual exit conditions are not met. Not a terribly clean or 1594c16df32eSFinn Thain * correct solution :-% 1595c16df32eSFinn Thain * 1596c16df32eSFinn Thain * DMA receive is equally tricky due to a nasty characteristic of the NCR5380. 1597c16df32eSFinn Thain * If the chip is in DMA receive mode, it will respond to a target's 1598c16df32eSFinn Thain * REQ by latching the SCSI data into the INPUT DATA register and asserting 1599c16df32eSFinn Thain * ACK, even if it has _already_ been notified by the DMA controller that 1600c16df32eSFinn Thain * the current DMA transfer has completed! If the NCR5380 is then taken 1601c16df32eSFinn Thain * out of DMA mode, this already-acknowledged byte is lost. This is 1602c16df32eSFinn Thain * not a problem for "one DMA transfer per READ command", because 1603c16df32eSFinn Thain * the situation will never arise... either all of the data is DMA'ed 1604c16df32eSFinn Thain * properly, or the target switches to MESSAGE IN phase to signal a 1605c16df32eSFinn Thain * disconnection (either operation bringing the DMA to a clean halt). 1606c16df32eSFinn Thain * However, in order to handle scatter-receive, we must work around the 1607e4dec680SFinn Thain * problem. The chosen fix is to DMA fewer bytes, then check for the 1608c16df32eSFinn Thain * condition before taking the NCR5380 out of DMA mode. One or two extra 1609c16df32eSFinn Thain * bytes are transferred via PIO as necessary to fill out the original 1610c16df32eSFinn Thain * request. 16111da177e4SLinus Torvalds */ 16121da177e4SLinus Torvalds 16138053b0eeSFinn Thain if (hostdata->flags & FLAG_DMA_FIXUP) { 16141da177e4SLinus Torvalds if (p & SR_IO) { 16151da177e4SLinus Torvalds /* 1616e4dec680SFinn Thain * The workaround was to transfer fewer bytes than we 16171da177e4SLinus Torvalds * intended to with the pseudo-DMA read function, wait for 16181da177e4SLinus Torvalds * the chip to latch the last byte, read it, and then disable 16191da177e4SLinus Torvalds * pseudo-DMA mode. 16201da177e4SLinus Torvalds * 16211da177e4SLinus Torvalds * After REQ is asserted, the NCR5380 asserts DRQ and ACK. 16221da177e4SLinus Torvalds * REQ is deasserted when ACK is asserted, and not reasserted 16231da177e4SLinus Torvalds * until ACK goes false. Since the NCR5380 won't lower ACK 16241da177e4SLinus Torvalds * until DACK is asserted, which won't happen unless we twiddle 16251da177e4SLinus Torvalds * the DMA port or we take the NCR5380 out of DMA mode, we 16261da177e4SLinus Torvalds * can guarantee that we won't handshake another extra 16271da177e4SLinus Torvalds * byte. 16281da177e4SLinus Torvalds */ 16291da177e4SLinus Torvalds 1630d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, BUS_AND_STATUS_REG, 1631*e7734ef1SAhmed S. Darwish BASR_DRQ, BASR_DRQ, 0) < 0) { 1632438af51cSFinn Thain result = -1; 163355181be8SFinn Thain shost_printk(KERN_ERR, instance, "PDMA read: DRQ timeout\n"); 163455181be8SFinn Thain } 1635d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, STATUS_REG, 1636*e7734ef1SAhmed S. Darwish SR_REQ, 0, 0) < 0) { 1637438af51cSFinn Thain result = -1; 163855181be8SFinn Thain shost_printk(KERN_ERR, instance, "PDMA read: !REQ timeout\n"); 163955181be8SFinn Thain } 16408053b0eeSFinn Thain d[*count - 1] = NCR5380_read(INPUT_DATA_REG); 16411da177e4SLinus Torvalds } else { 16421da177e4SLinus Torvalds /* 16431da177e4SLinus Torvalds * Wait for the last byte to be sent. If REQ is being asserted for 16441da177e4SLinus Torvalds * the byte we're interested, we'll ACK it and it will go false. 16451da177e4SLinus Torvalds */ 1646d5d37a0aSFinn Thain if (NCR5380_poll_politely2(hostdata, 164755181be8SFinn Thain BUS_AND_STATUS_REG, BASR_DRQ, BASR_DRQ, 1648*e7734ef1SAhmed S. Darwish BUS_AND_STATUS_REG, BASR_PHASE_MATCH, 0, 0) < 0) { 1649438af51cSFinn Thain result = -1; 165055181be8SFinn Thain shost_printk(KERN_ERR, instance, "PDMA write: DRQ and phase timeout\n"); 16511da177e4SLinus Torvalds } 16521da177e4SLinus Torvalds } 16531da177e4SLinus Torvalds } 16548053b0eeSFinn Thain 16558053b0eeSFinn Thain NCR5380_dma_complete(instance); 1656438af51cSFinn Thain return result; 16571da177e4SLinus Torvalds } 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds /* 16601da177e4SLinus Torvalds * Function : NCR5380_information_transfer (struct Scsi_Host *instance) 16611da177e4SLinus Torvalds * 16621da177e4SLinus Torvalds * Purpose : run through the various SCSI phases and do as the target 16631da177e4SLinus Torvalds * directs us to. Operates on the currently connected command, 16641da177e4SLinus Torvalds * instance->connected. 16651da177e4SLinus Torvalds * 16661da177e4SLinus Torvalds * Inputs : instance, instance for which we are doing commands 16671da177e4SLinus Torvalds * 16681da177e4SLinus Torvalds * Side effects : SCSI things happen, the disconnected queue will be 16691da177e4SLinus Torvalds * modified if a command disconnects, *instance->connected will 16701da177e4SLinus Torvalds * change. 16711da177e4SLinus Torvalds * 16721da177e4SLinus Torvalds * XXX Note : we need to watch for bus free or a reset condition here 16731da177e4SLinus Torvalds * to recover from an unexpected bus free condition. 16741da177e4SLinus Torvalds */ 16751da177e4SLinus Torvalds 16760d2cf867SFinn Thain static void NCR5380_information_transfer(struct Scsi_Host *instance) 16774ab2a787SFinn Thain __releases(&hostdata->lock) __acquires(&hostdata->lock) 16780d2cf867SFinn Thain { 1679e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 16801da177e4SLinus Torvalds unsigned char msgout = NOP; 16811da177e4SLinus Torvalds int sink = 0; 16821da177e4SLinus Torvalds int len; 16831da177e4SLinus Torvalds int transfersize; 16841da177e4SLinus Torvalds unsigned char *data; 16851da177e4SLinus Torvalds unsigned char phase, tmp, extended_msg[10], old_phase = 0xff; 168611d2f63bSFinn Thain struct scsi_cmnd *cmd; 16871da177e4SLinus Torvalds 1688e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1689e9db3198SFinn Thain dregs->csr |= CSR_INTR; 1690e9db3198SFinn Thain #endif 1691e9db3198SFinn Thain 169211d2f63bSFinn Thain while ((cmd = hostdata->connected)) { 169332b26a10SFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd); 169432b26a10SFinn Thain 16951da177e4SLinus Torvalds tmp = NCR5380_read(STATUS_REG); 16961da177e4SLinus Torvalds /* We only have a valid SCSI phase when REQ is asserted */ 16971da177e4SLinus Torvalds if (tmp & SR_REQ) { 16981da177e4SLinus Torvalds phase = (tmp & PHASE_MASK); 16991da177e4SLinus Torvalds if (phase != old_phase) { 17001da177e4SLinus Torvalds old_phase = phase; 17011da177e4SLinus Torvalds NCR5380_dprint_phase(NDEBUG_INFORMATION, instance); 17021da177e4SLinus Torvalds } 1703e9db3198SFinn Thain #ifdef CONFIG_SUN3 17044a98f896SFinn Thain if (phase == PHASE_CMDOUT && 17054a98f896SFinn Thain sun3_dma_setup_done != cmd) { 17064a98f896SFinn Thain int count; 1707e9db3198SFinn Thain 17080e9fdd2bSFinn Thain advance_sg_buffer(cmd); 1709e9db3198SFinn Thain 17104a98f896SFinn Thain count = sun3scsi_dma_xfer_len(hostdata, cmd); 17114a98f896SFinn Thain 17124a98f896SFinn Thain if (count > 0) { 17134a98f896SFinn Thain if (rq_data_dir(cmd->request)) 17144a98f896SFinn Thain sun3scsi_dma_send_setup(hostdata, 17154a98f896SFinn Thain cmd->SCp.ptr, count); 17164a98f896SFinn Thain else 17174a98f896SFinn Thain sun3scsi_dma_recv_setup(hostdata, 17184a98f896SFinn Thain cmd->SCp.ptr, count); 1719e9db3198SFinn Thain sun3_dma_setup_done = cmd; 1720e9db3198SFinn Thain } 1721e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1722e9db3198SFinn Thain dregs->csr |= CSR_INTR; 1723e9db3198SFinn Thain #endif 1724e9db3198SFinn Thain } 1725e9db3198SFinn Thain #endif /* CONFIG_SUN3 */ 1726e9db3198SFinn Thain 17271da177e4SLinus Torvalds if (sink && (phase != PHASE_MSGOUT)) { 17281da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 17291da177e4SLinus Torvalds 17303d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 17313d07d22bSFinn Thain ICR_ASSERT_ACK); 17320d2cf867SFinn Thain while (NCR5380_read(STATUS_REG) & SR_REQ) 17330d2cf867SFinn Thain ; 17343d07d22bSFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 17353d07d22bSFinn Thain ICR_ASSERT_ATN); 17361da177e4SLinus Torvalds sink = 0; 17371da177e4SLinus Torvalds continue; 17381da177e4SLinus Torvalds } 17390d2cf867SFinn Thain 17401da177e4SLinus Torvalds switch (phase) { 17411da177e4SLinus Torvalds case PHASE_DATAOUT: 17421da177e4SLinus Torvalds #if (NDEBUG & NDEBUG_NO_DATAOUT) 17436a6ff4acSFinn Thain shost_printk(KERN_DEBUG, instance, "NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n"); 17441da177e4SLinus Torvalds sink = 1; 1745*e7734ef1SAhmed S. Darwish do_abort(instance, 0); 17461da177e4SLinus Torvalds cmd->result = DID_ERROR << 16; 1747677e0194SFinn Thain complete_cmd(instance, cmd); 1748dc183965SFinn Thain hostdata->connected = NULL; 174945ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 17501da177e4SLinus Torvalds return; 17511da177e4SLinus Torvalds #endif 1752bf1a0c6fSFinn Thain case PHASE_DATAIN: 17531da177e4SLinus Torvalds /* 17541da177e4SLinus Torvalds * If there is no room left in the current buffer in the 17551da177e4SLinus Torvalds * scatter-gather list, move onto the next one. 17561da177e4SLinus Torvalds */ 17571da177e4SLinus Torvalds 17580e9fdd2bSFinn Thain advance_sg_buffer(cmd); 17590e9fdd2bSFinn Thain dsprintk(NDEBUG_INFORMATION, instance, 17600e9fdd2bSFinn Thain "this residual %d, sg ents %d\n", 1761b746545fSFinn Thain cmd->SCp.this_residual, 17620e9fdd2bSFinn Thain sg_nents(cmd->SCp.buffer)); 17630d2cf867SFinn Thain 17641da177e4SLinus Torvalds /* 17651da177e4SLinus Torvalds * The preferred transfer method is going to be 17661da177e4SLinus Torvalds * PSEUDO-DMA for systems that are strictly PIO, 17671da177e4SLinus Torvalds * since we can let the hardware do the handshaking. 17681da177e4SLinus Torvalds * 17691da177e4SLinus Torvalds * For this to work, we need to know the transfersize 17701da177e4SLinus Torvalds * ahead of time, since the pseudo-DMA code will sit 17711da177e4SLinus Torvalds * in an unconditional loop. 17721da177e4SLinus Torvalds */ 17731da177e4SLinus Torvalds 1774ff3d4578SFinn Thain transfersize = 0; 17757e9ec8d9SFinn Thain if (!cmd->device->borken) 17764a98f896SFinn Thain transfersize = NCR5380_dma_xfer_len(hostdata, cmd); 17771da177e4SLinus Torvalds 1778438af51cSFinn Thain if (transfersize > 0) { 17791da177e4SLinus Torvalds len = transfersize; 17800d2cf867SFinn Thain if (NCR5380_transfer_dma(instance, &phase, 17810d2cf867SFinn Thain &len, (unsigned char **)&cmd->SCp.ptr)) { 17821da177e4SLinus Torvalds /* 17830d2cf867SFinn Thain * If the watchdog timer fires, all future 17840d2cf867SFinn Thain * accesses to this device will use the 17850d2cf867SFinn Thain * polled-IO. 17861da177e4SLinus Torvalds */ 1787017560fcSJeff Garzik scmd_printk(KERN_INFO, cmd, 1788017560fcSJeff Garzik "switching to slow handshake\n"); 17891da177e4SLinus Torvalds cmd->device->borken = 1; 1790f9dfed1cSFinn Thain do_reset(instance); 1791f9dfed1cSFinn Thain bus_reset_cleanup(instance); 17928053b0eeSFinn Thain } 1793f825e40bSFinn Thain } else { 179408348b1cSFinn Thain /* Transfer a small chunk so that the 179508348b1cSFinn Thain * irq mode lock is not held too long. 17961678847eSFinn Thain */ 179708348b1cSFinn Thain transfersize = min(cmd->SCp.this_residual, 179808348b1cSFinn Thain NCR5380_PIO_CHUNK_SIZE); 17991678847eSFinn Thain len = transfersize; 18001678847eSFinn Thain NCR5380_transfer_pio(instance, &phase, &len, 1801*e7734ef1SAhmed S. Darwish (unsigned char **)&cmd->SCp.ptr, 1802*e7734ef1SAhmed S. Darwish 0); 18031678847eSFinn Thain cmd->SCp.this_residual -= transfersize - len; 180411d2f63bSFinn Thain } 1805e9db3198SFinn Thain #ifdef CONFIG_SUN3 1806e9db3198SFinn Thain if (sun3_dma_setup_done == cmd) 1807e9db3198SFinn Thain sun3_dma_setup_done = NULL; 1808e9db3198SFinn Thain #endif 18091678847eSFinn Thain return; 18101da177e4SLinus Torvalds case PHASE_MSGIN: 18111da177e4SLinus Torvalds len = 1; 18121da177e4SLinus Torvalds data = &tmp; 1813*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 0); 18141da177e4SLinus Torvalds cmd->SCp.Message = tmp; 18151da177e4SLinus Torvalds 18161da177e4SLinus Torvalds switch (tmp) { 18171da177e4SLinus Torvalds case ABORT: 18181da177e4SLinus Torvalds case COMMAND_COMPLETE: 18191da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18201da177e4SLinus Torvalds sink = 1; 18211da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18220d3d9a42SFinn Thain dsprintk(NDEBUG_QUEUES, instance, 18230d3d9a42SFinn Thain "COMMAND COMPLETE %p target %d lun %llu\n", 18240d3d9a42SFinn Thain cmd, scmd_id(cmd), cmd->device->lun); 18250d3d9a42SFinn Thain 18261da177e4SLinus Torvalds hostdata->connected = NULL; 182745ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 18281da177e4SLinus Torvalds 1829f27db8ebSFinn Thain cmd->result &= ~0xffff; 1830f27db8ebSFinn Thain cmd->result |= cmd->SCp.Status; 1831f27db8ebSFinn Thain cmd->result |= cmd->SCp.Message << 8; 18321da177e4SLinus Torvalds 1833350767f2SFinn Thain set_resid_from_SCp(cmd); 1834350767f2SFinn Thain 1835f27db8ebSFinn Thain if (cmd->cmnd[0] == REQUEST_SENSE) 1836f27db8ebSFinn Thain complete_cmd(instance, cmd); 1837f27db8ebSFinn Thain else { 1838f27db8ebSFinn Thain if (cmd->SCp.Status == SAM_STAT_CHECK_CONDITION || 1839f27db8ebSFinn Thain cmd->SCp.Status == SAM_STAT_COMMAND_TERMINATED) { 1840f27db8ebSFinn Thain dsprintk(NDEBUG_QUEUES, instance, "autosense: adding cmd %p to tail of autosense queue\n", 1841dbb6b350SFinn Thain cmd); 1842f27db8ebSFinn Thain list_add_tail(&ncmd->list, 1843f27db8ebSFinn Thain &hostdata->autosense); 1844f27db8ebSFinn Thain } else 1845677e0194SFinn Thain complete_cmd(instance, cmd); 18461da177e4SLinus Torvalds } 18471da177e4SLinus Torvalds 18481da177e4SLinus Torvalds /* 18491da177e4SLinus Torvalds * Restore phase bits to 0 so an interrupted selection, 18501da177e4SLinus Torvalds * arbitration can resume. 18511da177e4SLinus Torvalds */ 18521da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 185372064a78SFinn Thain 18541da177e4SLinus Torvalds return; 18551da177e4SLinus Torvalds case MESSAGE_REJECT: 18561da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18571da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18581da177e4SLinus Torvalds switch (hostdata->last_message) { 18591da177e4SLinus Torvalds case HEAD_OF_QUEUE_TAG: 18601da177e4SLinus Torvalds case ORDERED_QUEUE_TAG: 18611da177e4SLinus Torvalds case SIMPLE_QUEUE_TAG: 18621da177e4SLinus Torvalds cmd->device->simple_tags = 0; 18639cb78c16SHannes Reinecke hostdata->busy[cmd->device->id] |= (1 << (cmd->device->lun & 0xFF)); 18641da177e4SLinus Torvalds break; 18651da177e4SLinus Torvalds default: 18661da177e4SLinus Torvalds break; 18671da177e4SLinus Torvalds } 1868340b9612SFinn Thain break; 18690d2cf867SFinn Thain case DISCONNECT: 18701da177e4SLinus Torvalds /* Accept message by clearing ACK */ 18711da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 18721da177e4SLinus Torvalds hostdata->connected = NULL; 187332b26a10SFinn Thain list_add(&ncmd->list, &hostdata->disconnected); 18740d3d9a42SFinn Thain dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES, 18750d3d9a42SFinn Thain instance, "connected command %p for target %d lun %llu moved to disconnected queue\n", 18760d3d9a42SFinn Thain cmd, scmd_id(cmd), cmd->device->lun); 18770d3d9a42SFinn Thain 18781da177e4SLinus Torvalds /* 18791da177e4SLinus Torvalds * Restore phase bits to 0 so an interrupted selection, 18801da177e4SLinus Torvalds * arbitration can resume. 18811da177e4SLinus Torvalds */ 18821da177e4SLinus Torvalds NCR5380_write(TARGET_COMMAND_REG, 0); 18831da177e4SLinus Torvalds 1884e9db3198SFinn Thain #ifdef SUN3_SCSI_VME 1885e9db3198SFinn Thain dregs->csr |= CSR_DMA_ENABLE; 1886e9db3198SFinn Thain #endif 18871da177e4SLinus Torvalds return; 18881da177e4SLinus Torvalds /* 18891da177e4SLinus Torvalds * The SCSI data pointer is *IMPLICITLY* saved on a disconnect 18901da177e4SLinus Torvalds * operation, in violation of the SCSI spec so we can safely 18911da177e4SLinus Torvalds * ignore SAVE/RESTORE pointers calls. 18921da177e4SLinus Torvalds * 18931da177e4SLinus Torvalds * Unfortunately, some disks violate the SCSI spec and 18941da177e4SLinus Torvalds * don't issue the required SAVE_POINTERS message before 18951da177e4SLinus Torvalds * disconnecting, and we have to break spec to remain 18961da177e4SLinus Torvalds * compatible. 18971da177e4SLinus Torvalds */ 18981da177e4SLinus Torvalds case SAVE_POINTERS: 18991da177e4SLinus Torvalds case RESTORE_POINTERS: 19001da177e4SLinus Torvalds /* Accept message by clearing ACK */ 19011da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 19021da177e4SLinus Torvalds break; 19031da177e4SLinus Torvalds case EXTENDED_MESSAGE: 19041da177e4SLinus Torvalds /* 1905c16df32eSFinn Thain * Start the message buffer with the EXTENDED_MESSAGE 19061abfd370SMatthew Wilcox * byte, since spi_print_msg() wants the whole thing. 19071da177e4SLinus Torvalds */ 19081da177e4SLinus Torvalds extended_msg[0] = EXTENDED_MESSAGE; 19091da177e4SLinus Torvalds /* Accept first byte by clearing ACK */ 19101da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 191111d2f63bSFinn Thain 191211d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 191311d2f63bSFinn Thain 1914b746545fSFinn Thain dsprintk(NDEBUG_EXTENDED, instance, "receiving extended message\n"); 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds len = 2; 19171da177e4SLinus Torvalds data = extended_msg + 1; 19181da177e4SLinus Torvalds phase = PHASE_MSGIN; 1919*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 1); 1920b746545fSFinn Thain dsprintk(NDEBUG_EXTENDED, instance, "length %d, code 0x%02x\n", 1921b746545fSFinn Thain (int)extended_msg[1], 1922b746545fSFinn Thain (int)extended_msg[2]); 19231da177e4SLinus Torvalds 1924e0783ed3SFinn Thain if (!len && extended_msg[1] > 0 && 1925e0783ed3SFinn Thain extended_msg[1] <= sizeof(extended_msg) - 2) { 19261da177e4SLinus Torvalds /* Accept third byte by clearing ACK */ 19271da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 19281da177e4SLinus Torvalds len = extended_msg[1] - 1; 19291da177e4SLinus Torvalds data = extended_msg + 3; 19301da177e4SLinus Torvalds phase = PHASE_MSGIN; 19311da177e4SLinus Torvalds 1932*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 1); 1933b746545fSFinn Thain dsprintk(NDEBUG_EXTENDED, instance, "message received, residual %d\n", 1934b746545fSFinn Thain len); 19351da177e4SLinus Torvalds 19361da177e4SLinus Torvalds switch (extended_msg[2]) { 19371da177e4SLinus Torvalds case EXTENDED_SDTR: 19381da177e4SLinus Torvalds case EXTENDED_WDTR: 19391da177e4SLinus Torvalds tmp = 0; 19401da177e4SLinus Torvalds } 19411da177e4SLinus Torvalds } else if (len) { 19426a6ff4acSFinn Thain shost_printk(KERN_ERR, instance, "error receiving extended message\n"); 19431da177e4SLinus Torvalds tmp = 0; 19441da177e4SLinus Torvalds } else { 19456a6ff4acSFinn Thain shost_printk(KERN_NOTICE, instance, "extended message code %02x length %d is too long\n", 19466a6ff4acSFinn Thain extended_msg[2], extended_msg[1]); 19471da177e4SLinus Torvalds tmp = 0; 19481da177e4SLinus Torvalds } 194911d2f63bSFinn Thain 195011d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 195111d2f63bSFinn Thain if (!hostdata->connected) 195211d2f63bSFinn Thain return; 195311d2f63bSFinn Thain 1954df135e32SFinn Thain /* Reject message */ 1955df561f66SGustavo A. R. Silva fallthrough; 1956df135e32SFinn Thain default: 19571da177e4SLinus Torvalds /* 19581da177e4SLinus Torvalds * If we get something weird that we aren't expecting, 1959df135e32SFinn Thain * log it. 19601da177e4SLinus Torvalds */ 196139bef87cSFinn Thain if (tmp == EXTENDED_MESSAGE) 1962017560fcSJeff Garzik scmd_printk(KERN_INFO, cmd, 19630d2cf867SFinn Thain "rejecting unknown extended message code %02x, length %d\n", 196439bef87cSFinn Thain extended_msg[2], extended_msg[1]); 196539bef87cSFinn Thain else if (tmp) 196639bef87cSFinn Thain scmd_printk(KERN_INFO, cmd, 196739bef87cSFinn Thain "rejecting unknown message code %02x\n", 196839bef87cSFinn Thain tmp); 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds msgout = MESSAGE_REJECT; 19711da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 19721da177e4SLinus Torvalds break; 19731da177e4SLinus Torvalds } /* switch (tmp) */ 19741da177e4SLinus Torvalds break; 19751da177e4SLinus Torvalds case PHASE_MSGOUT: 19761da177e4SLinus Torvalds len = 1; 19771da177e4SLinus Torvalds data = &msgout; 19781da177e4SLinus Torvalds hostdata->last_message = msgout; 1979*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 0); 19801da177e4SLinus Torvalds if (msgout == ABORT) { 19811da177e4SLinus Torvalds hostdata->connected = NULL; 198245ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 19831da177e4SLinus Torvalds cmd->result = DID_ERROR << 16; 1984677e0194SFinn Thain complete_cmd(instance, cmd); 19851da177e4SLinus Torvalds return; 19861da177e4SLinus Torvalds } 19871da177e4SLinus Torvalds msgout = NOP; 19881da177e4SLinus Torvalds break; 19891da177e4SLinus Torvalds case PHASE_CMDOUT: 19901da177e4SLinus Torvalds len = cmd->cmd_len; 19911da177e4SLinus Torvalds data = cmd->cmnd; 19921da177e4SLinus Torvalds /* 19931da177e4SLinus Torvalds * XXX for performance reasons, on machines with a 19941da177e4SLinus Torvalds * PSEUDO-DMA architecture we should probably 19951da177e4SLinus Torvalds * use the dma transfer function. 19961da177e4SLinus Torvalds */ 1997*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 0); 19981da177e4SLinus Torvalds break; 19991da177e4SLinus Torvalds case PHASE_STATIN: 20001da177e4SLinus Torvalds len = 1; 20011da177e4SLinus Torvalds data = &tmp; 2002*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 0); 20031da177e4SLinus Torvalds cmd->SCp.Status = tmp; 20041da177e4SLinus Torvalds break; 20051da177e4SLinus Torvalds default: 20066a6ff4acSFinn Thain shost_printk(KERN_ERR, instance, "unknown phase\n"); 20074dde8f7dSFinn Thain NCR5380_dprint(NDEBUG_ANY, instance); 20081da177e4SLinus Torvalds } /* switch(phase) */ 2009686f3990SFinn Thain } else { 201011d2f63bSFinn Thain spin_unlock_irq(&hostdata->lock); 2011d5d37a0aSFinn Thain NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ); 201211d2f63bSFinn Thain spin_lock_irq(&hostdata->lock); 20131da177e4SLinus Torvalds } 201411d2f63bSFinn Thain } 20151da177e4SLinus Torvalds } 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds /* 20181da177e4SLinus Torvalds * Function : void NCR5380_reselect (struct Scsi_Host *instance) 20191da177e4SLinus Torvalds * 20201da177e4SLinus Torvalds * Purpose : does reselection, initializing the instance->connected 2021710ddd0dSFinn Thain * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q 20221da177e4SLinus Torvalds * nexus has been reestablished, 20231da177e4SLinus Torvalds * 20241da177e4SLinus Torvalds * Inputs : instance - this instance of the NCR5380. 20251da177e4SLinus Torvalds */ 20261da177e4SLinus Torvalds 20270d2cf867SFinn Thain static void NCR5380_reselect(struct Scsi_Host *instance) 20280d2cf867SFinn Thain { 2029e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 20301da177e4SLinus Torvalds unsigned char target_mask; 2031e9db3198SFinn Thain unsigned char lun; 20321da177e4SLinus Torvalds unsigned char msg[3]; 203332b26a10SFinn Thain struct NCR5380_cmd *ncmd; 203432b26a10SFinn Thain struct scsi_cmnd *tmp; 20351da177e4SLinus Torvalds 20361da177e4SLinus Torvalds /* 20371da177e4SLinus Torvalds * Disable arbitration, etc. since the host adapter obviously 20381da177e4SLinus Torvalds * lost, and tell an interrupted NCR5380_select() to restart. 20391da177e4SLinus Torvalds */ 20401da177e4SLinus Torvalds 20411da177e4SLinus Torvalds NCR5380_write(MODE_REG, MR_BASE); 20421da177e4SLinus Torvalds 20431da177e4SLinus Torvalds target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask); 20447ef55f67SFinn Thain if (!target_mask || target_mask & (target_mask - 1)) { 20457ef55f67SFinn Thain shost_printk(KERN_WARNING, instance, 20467ef55f67SFinn Thain "reselect: bad target_mask 0x%02x\n", target_mask); 20477ef55f67SFinn Thain return; 20487ef55f67SFinn Thain } 2049b746545fSFinn Thain 20501da177e4SLinus Torvalds /* 20511da177e4SLinus Torvalds * At this point, we have detected that our SCSI ID is on the bus, 20521da177e4SLinus Torvalds * SEL is true and BSY was false for at least one bus settle delay 20531da177e4SLinus Torvalds * (400 ns). 20541da177e4SLinus Torvalds * 20551da177e4SLinus Torvalds * We must assert BSY ourselves, until the target drops the SEL 20561da177e4SLinus Torvalds * signal. 20571da177e4SLinus Torvalds */ 20581da177e4SLinus Torvalds 20591da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY); 2060d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, 2061*e7734ef1SAhmed S. Darwish STATUS_REG, SR_SEL, 0, 0) < 0) { 206208267216SFinn Thain shost_printk(KERN_ERR, instance, "reselect: !SEL timeout\n"); 206372064a78SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 206472064a78SFinn Thain return; 206572064a78SFinn Thain } 20661da177e4SLinus Torvalds NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 20671da177e4SLinus Torvalds 20681da177e4SLinus Torvalds /* 20691da177e4SLinus Torvalds * Wait for target to go into MSGIN. 20701da177e4SLinus Torvalds */ 20711da177e4SLinus Torvalds 2072d5d37a0aSFinn Thain if (NCR5380_poll_politely(hostdata, 2073*e7734ef1SAhmed S. Darwish STATUS_REG, SR_REQ, SR_REQ, 0) < 0) { 2074ca694afaSFinn Thain if ((NCR5380_read(STATUS_REG) & (SR_BSY | SR_SEL)) == 0) 2075ca694afaSFinn Thain /* BUS FREE phase */ 2076ca694afaSFinn Thain return; 207708267216SFinn Thain shost_printk(KERN_ERR, instance, "reselect: REQ timeout\n"); 2078*e7734ef1SAhmed S. Darwish do_abort(instance, 0); 207972064a78SFinn Thain return; 208072064a78SFinn Thain } 20811da177e4SLinus Torvalds 2082e9db3198SFinn Thain #ifdef CONFIG_SUN3 2083e9db3198SFinn Thain /* acknowledge toggle to MSGIN */ 2084e9db3198SFinn Thain NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN)); 2085e9db3198SFinn Thain 2086e9db3198SFinn Thain /* peek at the byte without really hitting the bus */ 2087e9db3198SFinn Thain msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG); 2088e9db3198SFinn Thain #else 2089e9db3198SFinn Thain { 2090e9db3198SFinn Thain int len = 1; 2091e9db3198SFinn Thain unsigned char *data = msg; 2092e9db3198SFinn Thain unsigned char phase = PHASE_MSGIN; 2093e9db3198SFinn Thain 2094*e7734ef1SAhmed S. Darwish NCR5380_transfer_pio(instance, &phase, &len, &data, 0); 20951da177e4SLinus Torvalds 209672064a78SFinn Thain if (len) { 2097*e7734ef1SAhmed S. Darwish do_abort(instance, 0); 209872064a78SFinn Thain return; 209972064a78SFinn Thain } 2100e9db3198SFinn Thain } 2101e9db3198SFinn Thain #endif /* CONFIG_SUN3 */ 210272064a78SFinn Thain 21031da177e4SLinus Torvalds if (!(msg[0] & 0x80)) { 210472064a78SFinn Thain shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got "); 21051abfd370SMatthew Wilcox spi_print_msg(msg); 210672064a78SFinn Thain printk("\n"); 2107*e7734ef1SAhmed S. Darwish do_abort(instance, 0); 210872064a78SFinn Thain return; 210972064a78SFinn Thain } 211072064a78SFinn Thain lun = msg[0] & 0x07; 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds /* 21131da177e4SLinus Torvalds * We need to add code for SCSI-II to track which devices have 21141da177e4SLinus Torvalds * I_T_L_Q nexuses established, and which have simple I_T_L 21151da177e4SLinus Torvalds * nexuses so we can chose to do additional data transfer. 21161da177e4SLinus Torvalds */ 21171da177e4SLinus Torvalds 21181da177e4SLinus Torvalds /* 21191da177e4SLinus Torvalds * Find the command corresponding to the I_T_L or I_T_L_Q nexus we 21201da177e4SLinus Torvalds * just reestablished, and remove it from the disconnected queue. 21211da177e4SLinus Torvalds */ 21221da177e4SLinus Torvalds 212332b26a10SFinn Thain tmp = NULL; 212432b26a10SFinn Thain list_for_each_entry(ncmd, &hostdata->disconnected, list) { 212532b26a10SFinn Thain struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd); 212632b26a10SFinn Thain 212732b26a10SFinn Thain if (target_mask == (1 << scmd_id(cmd)) && 212832b26a10SFinn Thain lun == (u8)cmd->device->lun) { 212932b26a10SFinn Thain list_del(&ncmd->list); 213032b26a10SFinn Thain tmp = cmd; 21311da177e4SLinus Torvalds break; 21321da177e4SLinus Torvalds } 213372064a78SFinn Thain } 21340d3d9a42SFinn Thain 21350d3d9a42SFinn Thain if (tmp) { 21360d3d9a42SFinn Thain dsprintk(NDEBUG_RESELECTION | NDEBUG_QUEUES, instance, 21370d3d9a42SFinn Thain "reselect: removed %p from disconnected queue\n", tmp); 21380d3d9a42SFinn Thain } else { 213945ddc1b2SFinn Thain int target = ffs(target_mask) - 1; 214045ddc1b2SFinn Thain 214172064a78SFinn Thain shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n", 214272064a78SFinn Thain target_mask, lun); 21431da177e4SLinus Torvalds /* 21440d2cf867SFinn Thain * Since we have an established nexus that we can't do anything 21450d2cf867SFinn Thain * with, we must abort it. 21461da177e4SLinus Torvalds */ 2147*e7734ef1SAhmed S. Darwish if (do_abort(instance, 0) == 0) 214845ddc1b2SFinn Thain hostdata->busy[target] &= ~(1 << lun); 214972064a78SFinn Thain return; 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds 2152e9db3198SFinn Thain #ifdef CONFIG_SUN3 21534a98f896SFinn Thain if (sun3_dma_setup_done != tmp) { 21544a98f896SFinn Thain int count; 2155e9db3198SFinn Thain 21560e9fdd2bSFinn Thain advance_sg_buffer(tmp); 2157e9db3198SFinn Thain 21584a98f896SFinn Thain count = sun3scsi_dma_xfer_len(hostdata, tmp); 21594a98f896SFinn Thain 21604a98f896SFinn Thain if (count > 0) { 21614a98f896SFinn Thain if (rq_data_dir(tmp->request)) 21624a98f896SFinn Thain sun3scsi_dma_send_setup(hostdata, 21634a98f896SFinn Thain tmp->SCp.ptr, count); 21644a98f896SFinn Thain else 21654a98f896SFinn Thain sun3scsi_dma_recv_setup(hostdata, 21664a98f896SFinn Thain tmp->SCp.ptr, count); 2167e9db3198SFinn Thain sun3_dma_setup_done = tmp; 2168e9db3198SFinn Thain } 2169e9db3198SFinn Thain } 2170e9db3198SFinn Thain 2171e9db3198SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK); 2172e9db3198SFinn Thain #endif /* CONFIG_SUN3 */ 2173e9db3198SFinn Thain 217472064a78SFinn Thain /* Accept message by clearing ACK */ 217572064a78SFinn Thain NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 217672064a78SFinn Thain 21771da177e4SLinus Torvalds hostdata->connected = tmp; 2178c4ec6f92SFinn Thain dsprintk(NDEBUG_RESELECTION, instance, "nexus established, target %d, lun %llu\n", 2179c4ec6f92SFinn Thain scmd_id(tmp), tmp->device->lun); 21801da177e4SLinus Torvalds } 21811da177e4SLinus Torvalds 21828b00c3d5SFinn Thain /** 21838b00c3d5SFinn Thain * list_find_cmd - test for presence of a command in a linked list 21848b00c3d5SFinn Thain * @haystack: list of commands 21858b00c3d5SFinn Thain * @needle: command to search for 21868b00c3d5SFinn Thain */ 21878b00c3d5SFinn Thain 21888b00c3d5SFinn Thain static bool list_find_cmd(struct list_head *haystack, 21898b00c3d5SFinn Thain struct scsi_cmnd *needle) 21908b00c3d5SFinn Thain { 21918b00c3d5SFinn Thain struct NCR5380_cmd *ncmd; 21928b00c3d5SFinn Thain 21938b00c3d5SFinn Thain list_for_each_entry(ncmd, haystack, list) 21948b00c3d5SFinn Thain if (NCR5380_to_scmd(ncmd) == needle) 21958b00c3d5SFinn Thain return true; 21968b00c3d5SFinn Thain return false; 21978b00c3d5SFinn Thain } 21988b00c3d5SFinn Thain 21998b00c3d5SFinn Thain /** 22008b00c3d5SFinn Thain * list_remove_cmd - remove a command from linked list 22018b00c3d5SFinn Thain * @haystack: list of commands 22028b00c3d5SFinn Thain * @needle: command to remove 22038b00c3d5SFinn Thain */ 22048b00c3d5SFinn Thain 22058b00c3d5SFinn Thain static bool list_del_cmd(struct list_head *haystack, 22068b00c3d5SFinn Thain struct scsi_cmnd *needle) 22078b00c3d5SFinn Thain { 22088b00c3d5SFinn Thain if (list_find_cmd(haystack, needle)) { 22098b00c3d5SFinn Thain struct NCR5380_cmd *ncmd = scsi_cmd_priv(needle); 22108b00c3d5SFinn Thain 22118b00c3d5SFinn Thain list_del(&ncmd->list); 22128b00c3d5SFinn Thain return true; 22138b00c3d5SFinn Thain } 22148b00c3d5SFinn Thain return false; 22158b00c3d5SFinn Thain } 22168b00c3d5SFinn Thain 22178b00c3d5SFinn Thain /** 22188b00c3d5SFinn Thain * NCR5380_abort - scsi host eh_abort_handler() method 22198b00c3d5SFinn Thain * @cmd: the command to be aborted 22201da177e4SLinus Torvalds * 22218b00c3d5SFinn Thain * Try to abort a given command by removing it from queues and/or sending 22228b00c3d5SFinn Thain * the target an abort message. This may not succeed in causing a target 22238b00c3d5SFinn Thain * to abort the command. Nonetheless, the low-level driver must forget about 22248b00c3d5SFinn Thain * the command because the mid-layer reclaims it and it may be re-issued. 22251da177e4SLinus Torvalds * 22268b00c3d5SFinn Thain * The normal path taken by a command is as follows. For EH we trace this 22278b00c3d5SFinn Thain * same path to locate and abort the command. 22281da177e4SLinus Torvalds * 22298b00c3d5SFinn Thain * unissued -> selecting -> [unissued -> selecting ->]... connected -> 22308b00c3d5SFinn Thain * [disconnected -> connected ->]... 22318b00c3d5SFinn Thain * [autosense -> connected ->] done 22321da177e4SLinus Torvalds * 22338b00c3d5SFinn Thain * If cmd was not found at all then presumably it has already been completed, 22348b00c3d5SFinn Thain * in which case return SUCCESS to try to avoid further EH measures. 2235dc183965SFinn Thain * 22368b00c3d5SFinn Thain * If the command has not completed yet, we must not fail to find it. 2237dc183965SFinn Thain * We have no option but to forget the aborted command (even if it still 2238dc183965SFinn Thain * lacks sense data). The mid-layer may re-issue a command that is in error 2239dc183965SFinn Thain * recovery (see scsi_send_eh_cmnd), but the logic and data structures in 2240dc183965SFinn Thain * this driver are such that a command can appear on one queue only. 224171a00593SFinn Thain * 224271a00593SFinn Thain * The lock protects driver data structures, but EH handlers also use it 224371a00593SFinn Thain * to serialize their own execution and prevent their own re-entry. 22441da177e4SLinus Torvalds */ 22451da177e4SLinus Torvalds 2246710ddd0dSFinn Thain static int NCR5380_abort(struct scsi_cmnd *cmd) 2247710ddd0dSFinn Thain { 22481da177e4SLinus Torvalds struct Scsi_Host *instance = cmd->device->host; 2249e8a60144SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 225011d2f63bSFinn Thain unsigned long flags; 22518b00c3d5SFinn Thain int result = SUCCESS; 22521da177e4SLinus Torvalds 225311d2f63bSFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 225411d2f63bSFinn Thain 225532b26a10SFinn Thain #if (NDEBUG & NDEBUG_ANY) 22568b00c3d5SFinn Thain scmd_printk(KERN_INFO, cmd, __func__); 225732b26a10SFinn Thain #endif 2258e5c3fddfSFinn Thain NCR5380_dprint(NDEBUG_ANY, instance); 2259e5c3fddfSFinn Thain NCR5380_dprint_phase(NDEBUG_ANY, instance); 22601da177e4SLinus Torvalds 22618b00c3d5SFinn Thain if (list_del_cmd(&hostdata->unissued, cmd)) { 22628b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, 22638b00c3d5SFinn Thain "abort: removed %p from issue queue\n", cmd); 22648b00c3d5SFinn Thain cmd->result = DID_ABORT << 16; 22658b00c3d5SFinn Thain cmd->scsi_done(cmd); /* No tag or busy flag to worry about */ 2266dc183965SFinn Thain goto out; 22678b00c3d5SFinn Thain } 22688b00c3d5SFinn Thain 2269707d62b3SFinn Thain if (hostdata->selecting == cmd) { 2270707d62b3SFinn Thain dsprintk(NDEBUG_ABORT, instance, 2271707d62b3SFinn Thain "abort: cmd %p == selecting\n", cmd); 2272707d62b3SFinn Thain hostdata->selecting = NULL; 2273707d62b3SFinn Thain cmd->result = DID_ABORT << 16; 2274707d62b3SFinn Thain complete_cmd(instance, cmd); 2275707d62b3SFinn Thain goto out; 2276707d62b3SFinn Thain } 2277707d62b3SFinn Thain 22788b00c3d5SFinn Thain if (list_del_cmd(&hostdata->disconnected, cmd)) { 22798b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, 22808b00c3d5SFinn Thain "abort: removed %p from disconnected list\n", cmd); 228171a00593SFinn Thain /* Can't call NCR5380_select() and send ABORT because that 228271a00593SFinn Thain * means releasing the lock. Need a bus reset. 228371a00593SFinn Thain */ 2284dc183965SFinn Thain set_host_byte(cmd, DID_ERROR); 2285dc183965SFinn Thain complete_cmd(instance, cmd); 22868b00c3d5SFinn Thain result = FAILED; 22878b00c3d5SFinn Thain goto out; 22888b00c3d5SFinn Thain } 22898b00c3d5SFinn Thain 22908b00c3d5SFinn Thain if (hostdata->connected == cmd) { 22918b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, "abort: cmd %p is connected\n", cmd); 22928b00c3d5SFinn Thain hostdata->connected = NULL; 2293dc183965SFinn Thain hostdata->dma_len = 0; 2294*e7734ef1SAhmed S. Darwish if (do_abort(instance, 0) < 0) { 22958b00c3d5SFinn Thain set_host_byte(cmd, DID_ERROR); 22968b00c3d5SFinn Thain complete_cmd(instance, cmd); 22978b00c3d5SFinn Thain result = FAILED; 22988b00c3d5SFinn Thain goto out; 22998b00c3d5SFinn Thain } 23008b00c3d5SFinn Thain set_host_byte(cmd, DID_ABORT); 23018b00c3d5SFinn Thain complete_cmd(instance, cmd); 2302dc183965SFinn Thain goto out; 23038b00c3d5SFinn Thain } 23048b00c3d5SFinn Thain 23058b00c3d5SFinn Thain if (list_del_cmd(&hostdata->autosense, cmd)) { 23068b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, 23078b00c3d5SFinn Thain "abort: removed %p from sense queue\n", cmd); 23088b00c3d5SFinn Thain complete_cmd(instance, cmd); 23098b00c3d5SFinn Thain } 23108b00c3d5SFinn Thain 23118b00c3d5SFinn Thain out: 23128b00c3d5SFinn Thain if (result == FAILED) 23138b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd); 231445ddc1b2SFinn Thain else { 231545ddc1b2SFinn Thain hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun); 23168b00c3d5SFinn Thain dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd); 231745ddc1b2SFinn Thain } 23188b00c3d5SFinn Thain 23198b00c3d5SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 232011d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 23211da177e4SLinus Torvalds 23228b00c3d5SFinn Thain return result; 23231da177e4SLinus Torvalds } 23241da177e4SLinus Torvalds 23251da177e4SLinus Torvalds 23266b0e87a6SFinn Thain static void bus_reset_cleanup(struct Scsi_Host *instance) 232768b3aa7cSJeff Garzik { 232811d2f63bSFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 232962717f53SFinn Thain int i; 233062717f53SFinn Thain struct NCR5380_cmd *ncmd; 23311da177e4SLinus Torvalds 233262717f53SFinn Thain /* reset NCR registers */ 233362717f53SFinn Thain NCR5380_write(MODE_REG, MR_BASE); 233462717f53SFinn Thain NCR5380_write(TARGET_COMMAND_REG, 0); 233562717f53SFinn Thain NCR5380_write(SELECT_ENABLE_REG, 0); 233662717f53SFinn Thain 233762717f53SFinn Thain /* After the reset, there are no more connected or disconnected commands 233862717f53SFinn Thain * and no busy units; so clear the low-level status here to avoid 233962717f53SFinn Thain * conflicts when the mid-level code tries to wake up the affected 234062717f53SFinn Thain * commands! 234162717f53SFinn Thain */ 234262717f53SFinn Thain 23431884c283SFinn Thain if (hostdata->selecting) { 23441884c283SFinn Thain hostdata->selecting->result = DID_RESET << 16; 23451884c283SFinn Thain complete_cmd(instance, hostdata->selecting); 234662717f53SFinn Thain hostdata->selecting = NULL; 23471884c283SFinn Thain } 234862717f53SFinn Thain 234962717f53SFinn Thain list_for_each_entry(ncmd, &hostdata->disconnected, list) { 235062717f53SFinn Thain struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd); 235162717f53SFinn Thain 235262717f53SFinn Thain set_host_byte(cmd, DID_RESET); 2353216fad91SFinn Thain complete_cmd(instance, cmd); 235462717f53SFinn Thain } 23551884c283SFinn Thain INIT_LIST_HEAD(&hostdata->disconnected); 235662717f53SFinn Thain 235762717f53SFinn Thain list_for_each_entry(ncmd, &hostdata->autosense, list) { 235862717f53SFinn Thain struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd); 235962717f53SFinn Thain 236062717f53SFinn Thain cmd->scsi_done(cmd); 236162717f53SFinn Thain } 23621884c283SFinn Thain INIT_LIST_HEAD(&hostdata->autosense); 236362717f53SFinn Thain 236462717f53SFinn Thain if (hostdata->connected) { 236562717f53SFinn Thain set_host_byte(hostdata->connected, DID_RESET); 236662717f53SFinn Thain complete_cmd(instance, hostdata->connected); 236762717f53SFinn Thain hostdata->connected = NULL; 236862717f53SFinn Thain } 236962717f53SFinn Thain 237062717f53SFinn Thain for (i = 0; i < 8; ++i) 237162717f53SFinn Thain hostdata->busy[i] = 0; 237262717f53SFinn Thain hostdata->dma_len = 0; 237362717f53SFinn Thain 237462717f53SFinn Thain queue_work(hostdata->work_q, &hostdata->main_task); 23756b0e87a6SFinn Thain } 23766b0e87a6SFinn Thain 23776b0e87a6SFinn Thain /** 23786b0e87a6SFinn Thain * NCR5380_host_reset - reset the SCSI host 23796b0e87a6SFinn Thain * @cmd: SCSI command undergoing EH 23806b0e87a6SFinn Thain * 23816b0e87a6SFinn Thain * Returns SUCCESS 23826b0e87a6SFinn Thain */ 23836b0e87a6SFinn Thain 23846b0e87a6SFinn Thain static int NCR5380_host_reset(struct scsi_cmnd *cmd) 23856b0e87a6SFinn Thain { 23866b0e87a6SFinn Thain struct Scsi_Host *instance = cmd->device->host; 23876b0e87a6SFinn Thain struct NCR5380_hostdata *hostdata = shost_priv(instance); 23886b0e87a6SFinn Thain unsigned long flags; 23896b0e87a6SFinn Thain struct NCR5380_cmd *ncmd; 23906b0e87a6SFinn Thain 23916b0e87a6SFinn Thain spin_lock_irqsave(&hostdata->lock, flags); 23926b0e87a6SFinn Thain 23936b0e87a6SFinn Thain #if (NDEBUG & NDEBUG_ANY) 23946b0e87a6SFinn Thain shost_printk(KERN_INFO, instance, __func__); 23956b0e87a6SFinn Thain #endif 23966b0e87a6SFinn Thain NCR5380_dprint(NDEBUG_ANY, instance); 23976b0e87a6SFinn Thain NCR5380_dprint_phase(NDEBUG_ANY, instance); 23986b0e87a6SFinn Thain 23996b0e87a6SFinn Thain list_for_each_entry(ncmd, &hostdata->unissued, list) { 24006b0e87a6SFinn Thain struct scsi_cmnd *scmd = NCR5380_to_scmd(ncmd); 24016b0e87a6SFinn Thain 24026b0e87a6SFinn Thain scmd->result = DID_RESET << 16; 24036b0e87a6SFinn Thain scmd->scsi_done(scmd); 24046b0e87a6SFinn Thain } 24056b0e87a6SFinn Thain INIT_LIST_HEAD(&hostdata->unissued); 24066b0e87a6SFinn Thain 24076b0e87a6SFinn Thain do_reset(instance); 24086b0e87a6SFinn Thain bus_reset_cleanup(instance); 24096b0e87a6SFinn Thain 241011d2f63bSFinn Thain spin_unlock_irqrestore(&hostdata->lock, flags); 241168b3aa7cSJeff Garzik 24121da177e4SLinus Torvalds return SUCCESS; 24131da177e4SLinus Torvalds } 2414