svn commit: r187314 - in stable/6/sys: . dev/esp

Marius Strobl marius at FreeBSD.org
Thu Jan 15 13:23:47 PST 2009


Author: marius
Date: Thu Jan 15 21:23:44 2009
New Revision: 187314
URL: http://svn.freebsd.org/changeset/base/187314

Log:
  MFC: r180692
  
  o Fix style(9) bugs and similar nits.
  o Merge ncr53c9x.c from NetBSD:
    1.115: fix variable shadowing
    1.118: __inline -> inline
    1.121: fix empty if

Modified:
  stable/6/sys/   (props changed)
  stable/6/sys/dev/esp/esp_sbus.c
  stable/6/sys/dev/esp/ncr53c9x.c
  stable/6/sys/dev/esp/ncr53c9xvar.h

Modified: stable/6/sys/dev/esp/esp_sbus.c
==============================================================================
--- stable/6/sys/dev/esp/esp_sbus.c	Thu Jan 15 20:49:17 2009	(r187313)
+++ stable/6/sys/dev/esp/esp_sbus.c	Thu Jan 15 21:23:44 2009	(r187314)
@@ -158,19 +158,19 @@ MODULE_DEPEND(esp, sbus, 1, 1, 1);
 MODULE_DEPEND(esp, cam, 1, 1, 1);
 
 /*
- * Functions and the switch for the MI code.
+ * Functions and the switch for the MI code
  */
-static u_char	esp_read_reg(struct ncr53c9x_softc *, int);
-static void	esp_write_reg(struct ncr53c9x_softc *, int, u_char);
-static int	esp_dma_isintr(struct ncr53c9x_softc *);
-static void	esp_dma_reset(struct ncr53c9x_softc *);
-static int	esp_dma_intr(struct ncr53c9x_softc *);
-static int	esp_dma_setup(struct ncr53c9x_softc *, caddr_t *, size_t *,
-			      int, size_t *);
-static void	esp_dma_go(struct ncr53c9x_softc *);
-static void	esp_dma_stop(struct ncr53c9x_softc *);
-static int	esp_dma_isactive(struct ncr53c9x_softc *);
-static int	espattach(struct esp_softc *, struct ncr53c9x_glue *);
+static u_char	esp_read_reg(struct ncr53c9x_softc *sc, int reg);
+static void	esp_write_reg(struct ncr53c9x_softc *sc, int reg, u_char v);
+static int	esp_dma_isintr(struct ncr53c9x_softc *sc);
+static void	esp_dma_reset(struct ncr53c9x_softc *sc);
+static int	esp_dma_intr(struct ncr53c9x_softc *sc);
+static int	esp_dma_setup(struct ncr53c9x_softc *sc, caddr_t *addr,
+		    size_t *len, int datain, size_t *dmasize);
+static void	esp_dma_go(struct ncr53c9x_softc *sc);
+static void	esp_dma_stop(struct ncr53c9x_softc *sc);
+static int	esp_dma_isactive(struct ncr53c9x_softc *sc);
+static int	espattach(struct esp_softc *esc, struct ncr53c9x_glue *gluep);
 
 static struct ncr53c9x_glue esp_sbus_glue = {
 	esp_read_reg,
@@ -311,7 +311,7 @@ esp_sbus_attach(device_t dev)
 		esc->sc_regh = rman_get_bushandle(esc->sc_res);
 	} else {
 		/*
-		 * Search accompanying DMA engine. It should have been
+		 * Search accompanying DMA engine.  It should have been
 		 * already attached otherwise there isn't much we can do.
 		 */
 		if (device_get_children(device_get_parent(dev), &children,
@@ -498,9 +498,6 @@ esp_resume(device_t dev)
 	return (ENXIO);
 }
 
-/*
- * Attach this instance, and then all the sub-devices
- */
 static int
 espattach(struct esp_softc *esc, struct ncr53c9x_glue *gluep)
 {
@@ -530,7 +527,7 @@ espattach(struct esp_softc *esc, struct 
 	 */
 
 	/*
-	 * Read the part-unique ID code of the SCSI chip. The contained
+	 * Read the part-unique ID code of the SCSI chip.  The contained
 	 * value is only valid if all of the following conditions are met:
 	 * - After power-up or chip reset.
 	 * - Before any value is written to this register.
@@ -570,7 +567,7 @@ espattach(struct esp_softc *esc, struct 
 		    (NCRCFG3_CDB | NCRCFG3_FCLK)) {
 			sc->sc_rev = NCR_VARIANT_ESP100A;
 		} else {
-			/* NCRCFG2_FE enables > 64K transfers */
+			/* NCRCFG2_FE enables > 64K transfers. */
 			sc->sc_cfg2 |= NCRCFG2_FE;
 			sc->sc_cfg3 = 0;
 			NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
@@ -581,15 +578,18 @@ espattach(struct esp_softc *esc, struct 
 				case 0x00:
 					sc->sc_rev = NCR_VARIANT_FAS100A;
 					break;
+
 				case 0x02:
 					if ((uid & 0x07) == 0x02)
 						sc->sc_rev = NCR_VARIANT_FAS216;
 					else
 						sc->sc_rev = NCR_VARIANT_FAS236;
 					break;
+
 				case 0x0a:
 					sc->sc_rev = NCR_VARIANT_FAS366;
 					break;
+
 				default:
 					/*
 					 * We could just treat unknown chips
@@ -660,10 +660,10 @@ espattach(struct esp_softc *esc, struct 
 		/*
 		 * The onboard SCSI chips in Sun Ultra 1 are actually
 		 * documented to be NCR53C9X which use NCRCFG3_FCLK and
-		 * NCRCFG3_FSCSI. BSD/OS however probes these chips as
+		 * NCRCFG3_FSCSI.  BSD/OS however probes these chips as
 		 * FAS100A and uses NCRF9XCFG3_FCLK and NCRF9XCFG3_FSCSI
 		 * instead which seems to be correct as otherwise sync
-		 * negotiation just doesn't work. Using NCRF9XCFG3_FCLK
+		 * negotiation just doesn't work.  Using NCRF9XCFG3_FCLK
 		 * and NCRF9XCFG3_FSCSI with these chips in fact also
 		 * yields Fast-SCSI speed.
 		 */
@@ -683,7 +683,7 @@ espattach(struct esp_softc *esc, struct 
 	/* Limit minsync due to unsolved performance issues. */
 	sc->sc_maxsync = sc->sc_minsync;
 
-	/* Establish interrupt channel */
+	/* Establish interrupt channel. */
 	esc->sc_irqrid = 0;
 	if ((esc->sc_irqres = bus_alloc_resource_any(esc->sc_dev, SYS_RES_IRQ,
 	    &esc->sc_irqrid, RF_SHAREABLE|RF_ACTIVE)) == NULL) {
@@ -697,7 +697,7 @@ espattach(struct esp_softc *esc, struct 
 		goto fail_ires;
 	}
 
-	/* Turn on target selection using the `DMA' method */
+	/* Turn on target selection using the `DMA' method. */
 	if (sc->sc_rev != NCR_VARIANT_FAS366)
 		sc->sc_features |= NCR_F_DMASELECT;
 
@@ -720,7 +720,7 @@ espattach(struct esp_softc *esc, struct 
 }
 
 /*
- * Glue functions.
+ * Glue functions
  */
 
 #ifdef ESP_SBUS_DEBUG
@@ -844,11 +844,8 @@ static void
 esp_dma_stop(struct ncr53c9x_softc *sc)
 {
 	struct esp_softc *esc = (struct esp_softc *)sc;
-	uint32_t csr;
 
-	csr = L64854_GCSR(esc->sc_dma);
-	csr &= ~D_EN_DMA;
-	L64854_SCSR(esc->sc_dma, csr);
+	L64854_SCSR(esc->sc_dma, L64854_GCSR(esc->sc_dma) & ~D_EN_DMA);
 }
 
 static int

Modified: stable/6/sys/dev/esp/ncr53c9x.c
==============================================================================
--- stable/6/sys/dev/esp/ncr53c9x.c	Thu Jan 15 20:49:17 2009	(r187313)
+++ stable/6/sys/dev/esp/ncr53c9x.c	Thu Jan 15 21:23:44 2009	(r187314)
@@ -129,46 +129,54 @@ __FBSDID("$FreeBSD$");
 #include <dev/esp/ncr53c9xreg.h>
 #include <dev/esp/ncr53c9xvar.h>
 
-int ncr53c9x_debug = NCR_SHOWMISC /*|NCR_SHOWPHASE|NCR_SHOWTRAC|NCR_SHOWCMDS*/;
+int ncr53c9x_debug =
+    NCR_SHOWMISC /* | NCR_SHOWPHASE | NCR_SHOWTRAC | NCR_SHOWCMDS */;
 #ifdef DEBUG
 int ncr53c9x_notag = 0;
 #endif
 
-static void	ncr53c9x_select(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
-static int	ncr53c9x_reselect(struct ncr53c9x_softc *, int, int, int);
-static void	ncr53c9x_scsi_reset(struct ncr53c9x_softc *);
-static void	ncr53c9x_poll(struct cam_sim *);
-static void	ncr53c9x_sched(struct ncr53c9x_softc *);
-static void	ncr53c9x_done(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
-static void	ncr53c9x_msgin(struct ncr53c9x_softc *);
-static void	ncr53c9x_msgout(struct ncr53c9x_softc *);
+static void	ncr53c9x_abort(struct ncr53c9x_softc *sc,
+		    struct ncr53c9x_ecb *ecb);
+static void	ncr53c9x_dequeue(struct ncr53c9x_softc *sc,
+		    struct ncr53c9x_ecb *ecb);
+static void	ncr53c9x_done(struct ncr53c9x_softc *sc,
+		    struct ncr53c9x_ecb *ecb);
+static void	ncr53c9x_free_ecb(struct ncr53c9x_softc *sc,
+		    struct ncr53c9x_ecb *ecb);
+static void	ncr53c9x_msgin(struct ncr53c9x_softc *sc);
+static void	ncr53c9x_msgout(struct ncr53c9x_softc *sc);
+static void	ncr53c9x_poll(struct cam_sim *sim);
+static int	ncr53c9x_rdfifo(struct ncr53c9x_softc *sc, int how);
+static int	ncr53c9x_reselect(struct ncr53c9x_softc *sc, int message,
+		    int tagtype, int tagid);
+static void	ncr53c9x_sense(struct ncr53c9x_softc *sc,
+		    struct ncr53c9x_ecb *ecb);
+static void	ncr53c9x_scsi_reset(struct ncr53c9x_softc *sc);
+static void	ncr53c9x_sched(struct ncr53c9x_softc *sc);
+static void	ncr53c9x_select(struct ncr53c9x_softc *sc,
+		    struct ncr53c9x_ecb *ecb);
 static void	ncr53c9x_timeout(void *arg);
 static void	ncr53c9x_watch(void *arg);
-static void	ncr53c9x_abort(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
-static void	ncr53c9x_dequeue(struct ncr53c9x_softc *,
-				struct ncr53c9x_ecb *);
-static void	ncr53c9x_sense(struct ncr53c9x_softc *, struct ncr53c9x_ecb *);
-static void	ncr53c9x_free_ecb(struct ncr53c9x_softc *,
-				  struct ncr53c9x_ecb *);
-static void	ncr53c9x_wrfifo(struct ncr53c9x_softc *, u_char *, int);
-static int	ncr53c9x_rdfifo(struct ncr53c9x_softc *, int);
-
-static struct ncr53c9x_ecb *ncr53c9x_get_ecb(struct ncr53c9x_softc *);
-static struct ncr53c9x_linfo *ncr53c9x_lunsearch(struct ncr53c9x_tinfo *,
-						 int64_t lun);
-
-static __inline void ncr53c9x_readregs(struct ncr53c9x_softc *);
-static __inline int ncr53c9x_stp2cpb(struct ncr53c9x_softc *, int);
-static __inline void ncr53c9x_setsync(struct ncr53c9x_softc *,
-				      struct ncr53c9x_tinfo *);
+static void	ncr53c9x_wrfifo(struct ncr53c9x_softc *sc, u_char *p,
+		    int len);
 
-#define NCR_RDFIFO_START   0
-#define NCR_RDFIFO_CONTINUE 1
+static struct ncr53c9x_ecb	*ncr53c9x_get_ecb(struct ncr53c9x_softc *sc);
+static struct ncr53c9x_linfo	*ncr53c9x_lunsearch(struct ncr53c9x_tinfo *sc,
+				    int64_t lun);
+
+static inline void	ncr53c9x_readregs(struct ncr53c9x_softc *sc);
+static inline void	ncr53c9x_setsync(struct ncr53c9x_softc *sc,
+			    struct ncr53c9x_tinfo *ti);
+static inline int	ncr53c9x_stp2cpb(struct ncr53c9x_softc *sc,
+			    int period);
 
-#define NCR_SET_COUNT(sc, size) do { \
-		NCR_WRITE_REG((sc), NCR_TCL, (size)); 			\
+#define	NCR_RDFIFO_START   0
+#define	NCR_RDFIFO_CONTINUE 1
+
+#define	NCR_SET_COUNT(sc, size) do {					\
+		NCR_WRITE_REG((sc), NCR_TCL, (size));			\
 		NCR_WRITE_REG((sc), NCR_TCM, (size) >> 8);		\
-		if ((sc->sc_cfg2 & NCRCFG2_FE) || 			\
+		if ((sc->sc_cfg2 & NCRCFG2_FE) ||			\
 		    (sc->sc_rev == NCR_VARIANT_FAS366)) {		\
 			NCR_WRITE_REG((sc), NCR_TCH, (size) >> 16);	\
 		}							\
@@ -178,8 +186,8 @@ static __inline void ncr53c9x_setsync(st
 } while (0)
 
 #ifndef mstohz
-#define mstohz(ms) \
-	(((ms) < 0x20000)  ? \
+#define	mstohz(ms) \
+	(((ms) < 0x20000) ? \
 	    ((ms +0u) / 1000u) * hz : \
 	    ((ms +0u) * hz) /1000u)
 #endif
@@ -211,6 +219,7 @@ static struct ncr53c9x_linfo *
 ncr53c9x_lunsearch(struct ncr53c9x_tinfo *ti, int64_t lun)
 {
 	struct ncr53c9x_linfo *li;
+
 	LIST_FOREACH(li, &ti->luns, link)
 		if (li->lun == lun)
 			return (li);
@@ -248,7 +257,7 @@ ncr53c9x_attach(struct ncr53c9x_softc *s
 	/*
 	 * Allocate SCSI message buffers.
 	 * Front-ends can override allocation to avoid alignment
-	 * handling in the DMA engines. Note that that ncr53c9x_msgout()
+	 * handling in the DMA engines.  Note that ncr53c9x_msgout()
 	 * can request a 1 byte DMA transfer.
 	 */
 	if (sc->sc_omess == NULL) {
@@ -294,12 +303,12 @@ ncr53c9x_attach(struct ncr53c9x_softc *s
 
 	sc->sc_ccf = FREQTOCCF(sc->sc_freq);
 
-	/* The value *must not* be == 1. Make it 2 */
+	/* The value *must not* be == 1.  Make it 2. */
 	if (sc->sc_ccf == 1)
 		sc->sc_ccf = 2;
 
 	/*
-	 * The recommended timeout is 250ms. This register is loaded
+	 * The recommended timeout is 250ms.  This register is loaded
 	 * with a value calculated as follows, from the docs:
 	 *
 	 *		(timout period) x (CLK frequency)
@@ -311,11 +320,11 @@ ncr53c9x_attach(struct ncr53c9x_softc *s
 	 */
 	sc->sc_timeout = ((250 * 1000) * sc->sc_freq) / (8192 * sc->sc_ccf);
 
-	/* CCF register only has 3 bits; 0 is actually 8 */
+	/* The CCF register only has 3 bits; 0 is actually 8. */
 	sc->sc_ccf &= 7;
 
 	/*
-	 * Register with CAM
+	 * Register with CAM.
 	 */
 	devq = cam_simq_alloc(sc->sc_ntarg);
 	if (devq == NULL) {
@@ -325,8 +334,7 @@ ncr53c9x_attach(struct ncr53c9x_softc *s
 	}
 
 	sim = cam_sim_alloc(ncr53c9x_action, ncr53c9x_poll, "esp", sc,
-			    device_get_unit(sc->sc_dev), 1,
-			    NCR_TAG_DEPTH, devq);
+	    device_get_unit(sc->sc_dev), 1, NCR_TAG_DEPTH, devq);
 	if (sim == NULL) {
 		device_printf(sc->sc_dev, "cannot allocate SIM entry\n");
 		error = ENOMEM;
@@ -339,8 +347,7 @@ ncr53c9x_attach(struct ncr53c9x_softc *s
 	}
 
 	if (xpt_create_path(&path, NULL, cam_sim_path(sim),
-			    CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)
-			    != CAM_REQ_CMP) {
+	    CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 		device_printf(sc->sc_dev, "cannot create path\n");
 		error = EIO;
 		goto fail_bus;
@@ -349,16 +356,19 @@ ncr53c9x_attach(struct ncr53c9x_softc *s
 	sc->sc_sim = sim;
 	sc->sc_path = path;
 
-	/* Reset state & bus */
+	/* Reset state and bus. */
 #if 0
 	sc->sc_cfflags = sc->sc_dev.dv_cfdata->cf_flags;
+#else
+	sc->sc_cfflags = 0;
 #endif
 	sc->sc_state = 0;
 	ncr53c9x_init(sc, 1);
 
 	TAILQ_INIT(&sc->free_list);
-	if ((sc->ecb_array = malloc(sizeof(struct ncr53c9x_ecb) * NCR_TAG_DEPTH,
-				    M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) {
+	if ((sc->ecb_array =
+	    malloc(sizeof(struct ncr53c9x_ecb) * NCR_TAG_DEPTH, M_DEVBUF,
+	    M_NOWAIT | M_ZERO)) == NULL) {
 		device_printf(sc->sc_dev, "cannot allocate ECB array\n");
 		error = ENOMEM;
 		goto fail_path;
@@ -416,8 +426,8 @@ ncr53c9x_detach(struct ncr53c9x_softc *s
 }
 
 /*
- * This is the generic ncr53c9x reset function. It does not reset the SCSI bus,
- * only this controller, but kills any on-going commands, and also stops
+ * This is the generic ncr53c9x reset function.  It does not reset the SCSI
+ * bus, only this controller, but kills any on-going commands, and also stops
  * and resets the DMA.
  *
  * After reset, registers are loaded with the defaults from the attach
@@ -427,20 +437,21 @@ void
 ncr53c9x_reset(struct ncr53c9x_softc *sc)
 {
 
-	/* reset DMA first */
+	/* Reset DMA first. */
 	NCRDMA_RESET(sc);
 
-	/* reset SCSI chip */
+	/* Reset SCSI chip. */
 	NCRCMD(sc, NCRCMD_RSTCHIP);
 	NCRCMD(sc, NCRCMD_NOP);
 	DELAY(500);
 
-	/* do these backwards, and fall through */
+	/* Do these backwards, and fall through. */
 	switch (sc->sc_rev) {
 	case NCR_VARIANT_ESP406:
 	case NCR_VARIANT_FAS408:
 		NCR_WRITE_REG(sc, NCR_CFG5, sc->sc_cfg5 | NCRCFG5_SINT);
 		NCR_WRITE_REG(sc, NCR_CFG4, sc->sc_cfg4);
+		/* FALLTHROUGH */
 	case NCR_VARIANT_AM53C974:
 	case NCR_VARIANT_FAS100A:
 	case NCR_VARIANT_FAS216:
@@ -450,9 +461,11 @@ ncr53c9x_reset(struct ncr53c9x_softc *sc
 	case NCR_VARIANT_ESP200:
 		sc->sc_features |= NCR_F_HASCFG3;
 		NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
+		/* FALLTHROUGH */
 	case NCR_VARIANT_ESP100A:
 		sc->sc_features |= NCR_F_SELATN3;
 		NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
+		/* FALLTHROUGH */
 	case NCR_VARIANT_ESP100:
 		NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
 		NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
@@ -466,7 +479,7 @@ ncr53c9x_reset(struct ncr53c9x_softc *sc
 		sc->sc_cfg3 = NCRFASCFG3_FASTCLK | NCRFASCFG3_OBAUTO;
 		sc->sc_cfg3_fscsi = NCRFASCFG3_FASTSCSI;
 		NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
-		sc->sc_cfg2 = 0; /* NCRCFG2_HMEFE| NCRCFG2_HME32 */
+		sc->sc_cfg2 = 0; /* NCRCFG2_HMEFE | NCRCFG2_HME32 */
 		NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
 		NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
 		NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
@@ -475,8 +488,8 @@ ncr53c9x_reset(struct ncr53c9x_softc *sc
 		break;
 
 	default:
-		device_printf(sc->sc_dev, "unknown revision code, "
-			      "assuming ESP100\n");
+		device_printf(sc->sc_dev,
+		    "unknown revision code, assuming ESP100\n");
 		NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
 		NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
 		NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
@@ -488,7 +501,7 @@ ncr53c9x_reset(struct ncr53c9x_softc *sc
 
 #if 0
 	device_printf(sc->sc_dev, "ncr53c9x_reset: revision %d\n",
-	       sc->sc_rev);
+	    sc->sc_rev);
 	device_printf(sc->sc_dev, "ncr53c9x_reset: cfg1 0x%x, cfg2 0x%x, "
 	    "cfg3 0x%x, ccf 0x%x, timeout 0x%x\n",
 	    sc->sc_cfg1, sc->sc_cfg2, sc->sc_cfg3, sc->sc_ccf, sc->sc_timeout);
@@ -496,7 +509,7 @@ ncr53c9x_reset(struct ncr53c9x_softc *sc
 }
 
 /*
- * Reset the SCSI bus, but not the chip
+ * Reset the SCSI bus, but not the chip.
  */
 static void
 ncr53c9x_scsi_reset(struct ncr53c9x_softc *sc)
@@ -510,13 +523,14 @@ ncr53c9x_scsi_reset(struct ncr53c9x_soft
 }
 
 /*
- * Initialize ncr53c9x state machine
+ * Initialize ncr53c9x state machine.
  */
 void
 ncr53c9x_init(struct ncr53c9x_softc *sc, int doreset)
 {
 	struct ncr53c9x_ecb *ecb;
 	struct ncr53c9x_linfo *li;
+	struct ncr53c9x_tinfo *ti;
 	int i, r;
 
 	NCR_MISC(("[NCR_INIT(%d) %d] ", doreset, sc->sc_state));
@@ -538,13 +552,13 @@ ncr53c9x_init(struct ncr53c9x_softc *sc,
 			ecb->ccb->ccb_h.status = CAM_CMD_TIMEOUT;
 			ncr53c9x_done(sc, ecb);
 		}
-		/* Cancel outstanding disconnected commands on each LUN */
+		/* Cancel outstanding disconnected commands on each LUN. */
 		for (r = 0; r < sc->sc_ntarg; r++) {
 			LIST_FOREACH(li, &sc->sc_tinfo[r].luns, link) {
 				if ((ecb = li->untagged) != NULL) {
 					li->untagged = NULL;
 					/*
-					 * XXXXXXX
+					 * XXX
 					 *
 					 * Should we terminate a command
 					 * that never reached the disk?
@@ -567,7 +581,7 @@ ncr53c9x_init(struct ncr53c9x_softc *sc,
 	}
 
 	/*
-	 * reset the chip to a known state
+	 * Reset the chip to a known state.
 	 */
 	ncr53c9x_reset(sc);
 
@@ -576,12 +590,14 @@ ncr53c9x_init(struct ncr53c9x_softc *sc,
 	sc->sc_phase = sc->sc_prevphase = INVALID_PHASE;
 
 	for (r = 0; r < sc->sc_ntarg; r++) {
-		struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[r];
+		ti = &sc->sc_tinfo[r];
 /* XXX - config flags per target: low bits: no reselect; high bits: no synch */
+		ti->flags = ((sc->sc_minsync != 0 &&
+		    (sc->sc_cfflags & (1 << ((r & 7) + 8))) == 0) ?
+		    0 : T_SYNCHOFF) |
+		    ((sc->sc_cfflags & (1 << (r & 7))) == 0 ?
+		    0 : T_RSELECTOFF);
 
-		ti->flags = ((sc->sc_minsync && !(sc->sc_cfflags & (1<<((r&7)+8))))
-		    ? 0 : T_SYNCHOFF) |
-		    ((sc->sc_cfflags & (1<<(r&7))) ? T_RSELECTOFF : 0);
 #ifdef DEBUG
 		if (ncr53c9x_notag)
 			ti->flags &= ~T_TAG;
@@ -606,15 +622,15 @@ ncr53c9x_init(struct ncr53c9x_softc *sc,
  * NCR_INTR - so make sure it is the last read.
  *
  * I think that (from reading the docs) most bits in these registers
- * only make sense when he DMA CSR has an interrupt showing. Call only
+ * only make sense when the DMA CSR has an interrupt showing.  Call only
  * if an interrupt is pending.
  */
-static __inline void
+static inline void
 ncr53c9x_readregs(struct ncr53c9x_softc *sc)
 {
 
 	sc->sc_espstat = NCR_READ_REG(sc, NCR_STAT);
-	/* Only the stepo bits are of interest */
+	/* Only the step bits are of interest. */
 	sc->sc_espstep = NCR_READ_REG(sc, NCR_STEP) & NCRSTEP_MASK;
 
 	if (sc->sc_rev == NCR_VARIANT_FAS366)
@@ -629,9 +645,8 @@ ncr53c9x_readregs(struct ncr53c9x_softc 
 	 * Determine the SCSI bus phase, return either a real SCSI bus phase
 	 * or some pseudo phase we use to detect certain exceptions.
 	 */
-
 	sc->sc_phase = (sc->sc_espintr & NCRINTR_DIS) ?
-	    /* Disconnected */ BUSFREE_PHASE : sc->sc_espstat & NCRSTAT_PHASE;
+	    BUSFREE_PHASE : sc->sc_espstat & NCRSTAT_PHASE;
 
 	NCR_INTS(("regs[intr=%02x,stat=%02x,step=%02x,stat2=%02x] ",
 	    sc->sc_espintr, sc->sc_espstat, sc->sc_espstep, sc->sc_espstat2));
@@ -640,18 +655,18 @@ ncr53c9x_readregs(struct ncr53c9x_softc 
 /*
  * Convert Synchronous Transfer Period to chip register Clock Per Byte value.
  */
-static __inline int
+static inline int
 ncr53c9x_stp2cpb(struct ncr53c9x_softc *sc, int period)
 {
 	int v;
 	v = (sc->sc_freq * period) / 250;
 	if (ncr53c9x_cpb2stp(sc, v) < period)
-		/* Correct round-down error */
+		/* Correct round-down error. */
 		v++;
 	return (v);
 }
 
-static __inline void
+static inline void
 ncr53c9x_setsync(struct ncr53c9x_softc *sc, struct ncr53c9x_tinfo *ti)
 {
 	u_char syncoff, synctp;
@@ -705,20 +720,17 @@ ncr53c9x_setsync(struct ncr53c9x_softc *
 static void
 ncr53c9x_select(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
 {
-	int target = ecb->ccb->ccb_h.target_id;
-	int lun = ecb->ccb->ccb_h.target_lun;
 	struct ncr53c9x_tinfo *ti;
-	int tiflags;
 	u_char *cmd;
-	int clen;
-	int selatn3, selatns;
 	size_t dmasize;
+	int clen, selatn3, selatns;
+	int lun = ecb->ccb->ccb_h.target_lun;
+	int target = ecb->ccb->ccb_h.target_id;
 
 	NCR_TRACE(("[ncr53c9x_select(t%d,l%d,cmd:%x,tag:%x,%x)] ",
 	    target, lun, ecb->cmd.cmd.opcode, ecb->tag[0], ecb->tag[1]));
 
 	ti = &sc->sc_tinfo[target];
-	tiflags = ti->flags;
 	sc->sc_state = NCR_SELECTING;
 	/*
 	 * Schedule the timeout now, the first time we will go away
@@ -730,7 +742,7 @@ ncr53c9x_select(struct ncr53c9x_softc *s
 
 	/*
 	 * The docs say the target register is never reset, and I
-	 * can't think of a better place to set it
+	 * can't think of a better place to set it.
 	 */
 	if (sc->sc_rev == NCR_VARIANT_FAS366) {
 		NCRCMD(sc, NCRCMD_FLUSH);
@@ -756,9 +768,9 @@ ncr53c9x_select(struct ncr53c9x_softc *s
 			NCR_SET_COUNT(sc, dmasize);
 
 			if (sc->sc_rev != NCR_VARIANT_FAS366)
-				NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
+				NCRCMD(sc, NCRCMD_NOP | NCRCMD_DMA);
 
-			/* And get the targets attention */
+			/* And get the target's attention */
 			NCRCMD(sc, NCRCMD_SELNATN | NCRCMD_DMA);
 			NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0,
 			    &dmasize);
@@ -773,15 +785,15 @@ ncr53c9x_select(struct ncr53c9x_softc *s
 	selatn3 = selatns = 0;
 	if (ecb->tag[0] != 0) {
 		if (sc->sc_features & NCR_F_SELATN3)
-			/* use SELATN3 to send tag messages */
+			/* Use SELATN3 to send tag messages. */
 			selatn3 = 1;
 		else
-			/* We don't have SELATN3; use SELATNS to send tags */
+			/* We don't have SELATN3; use SELATNS to send tags. */
 			selatns = 1;
 	}
 
 	if (ti->flags & T_NEGOTIATE) {
-		/* We have to use SELATNS to send sync/wide messages */
+		/* We have to use SELATNS to send sync/wide messages. */
 		selatn3 = 0;
 		selatns = 1;
 	}
@@ -789,34 +801,33 @@ ncr53c9x_select(struct ncr53c9x_softc *s
 	cmd = (u_char *)&ecb->cmd.cmd;
 
 	if (selatn3) {
-		/* We'll use tags with SELATN3 */
+		/* We'll use tags with SELATN3. */
 		clen = ecb->clen + 3;
 		cmd -= 3;
 		cmd[0] = MSG_IDENTIFY(lun, 1);	/* msg[0] */
 		cmd[1] = ecb->tag[0];		/* msg[1] */
 		cmd[2] = ecb->tag[1];		/* msg[2] */
 	} else {
-		/* We don't have tags, or will send messages with SELATNS */
+		/* We don't have tags, or will send messages with SELATNS. */
 		clen = ecb->clen + 1;
 		cmd -= 1;
-		cmd[0] = MSG_IDENTIFY(lun, (tiflags & T_RSELECTOFF) == 0);
+		cmd[0] = MSG_IDENTIFY(lun, (ti->flags & T_RSELECTOFF) == 0);
 	}
 
 	if ((sc->sc_features & NCR_F_DMASELECT) && !selatns) {
-
-		/* setup DMA transfer for command */
+		/* Setup DMA transfer for command. */
 		dmasize = clen;
 		sc->sc_cmdlen = clen;
 		sc->sc_cmdp = cmd;
 
-		/* Program the SCSI counter */
+		/* Program the SCSI counter. */
 		NCR_SET_COUNT(sc, dmasize);
 
-		/* load the count in */
+		/* Load the count in. */
 		/* if (sc->sc_rev != NCR_VARIANT_FAS366) */
-			NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
+			NCRCMD(sc, NCRCMD_NOP | NCRCMD_DMA);
 
-		/* And get the targets attention */
+		/* And get the target's attention. */
 		if (selatn3) {
 			sc->sc_msgout = SEND_TAG;
 			sc->sc_flags |= NCR_ATN;
@@ -833,13 +844,13 @@ ncr53c9x_select(struct ncr53c9x_softc *s
 	 * happy for it to disconnect etc.
 	 */
 
-	/* Now get the command into the FIFO */
+	/* Now get the command into the FIFO. */
 	ncr53c9x_wrfifo(sc, cmd, clen);
 
-	/* And get the targets attention */
+	/* And get the target's attention. */
 	if (selatns) {
 		NCR_MSGS(("SELATNS \n"));
-		/* Arbitrate, select and stop after IDENTIFY message */
+		/* Arbitrate, select and stop after IDENTIFY message. */
 		NCRCMD(sc, NCRCMD_SELATNS);
 	} else if (selatn3) {
 		sc->sc_msgout = SEND_TAG;
@@ -855,7 +866,6 @@ ncr53c9x_free_ecb(struct ncr53c9x_softc 
 
 	ecb->flags = 0;
 	TAILQ_INSERT_TAIL(&sc->free_list, ecb, free_links);
-	return;
 }
 
 static struct ncr53c9x_ecb *
@@ -870,7 +880,7 @@ ncr53c9x_get_ecb(struct ncr53c9x_softc *
 		TAILQ_REMOVE(&sc->free_list, ecb, free_links);
 		ecb->flags = ECB_ALLOC;
 		bzero(&ecb->ccb, sizeof(struct ncr53c9x_ecb) -
-		      offsetof(struct ncr53c9x_ecb, ccb));
+		    offsetof(struct ncr53c9x_ecb, ccb));
 	}
 	return (ecb);
 }
@@ -880,7 +890,7 @@ ncr53c9x_get_ecb(struct ncr53c9x_softc *
  */
 
 /*
- * Start a SCSI-command
+ * Start a SCSI-command.
  * This function is called by the higher level SCSI-driver to queue/run
  * SCSI-commands.
  */
@@ -888,8 +898,13 @@ ncr53c9x_get_ecb(struct ncr53c9x_softc *
 void
 ncr53c9x_action(struct cam_sim *sim, union ccb *ccb)
 {
-	struct ncr53c9x_softc *sc;
+	struct ccb_pathinq *cpi;
+	struct ccb_scsiio *csio;
+	struct ccb_trans_settings *cts;
 	struct ncr53c9x_ecb *ecb;
+	struct ncr53c9x_softc *sc;
+	struct ncr53c9x_tinfo *ti;
+	int target;
 
 	NCR_TRACE(("[ncr53c9x_action %d]", ccb->ccb_h.func_code));
 
@@ -903,17 +918,17 @@ ncr53c9x_action(struct cam_sim *sim, uni
 		mtx_unlock(&sc->sc_lock);
 		xpt_done(ccb);
 		return;
+
 	case XPT_CALC_GEOMETRY:
 		mtx_unlock(&sc->sc_lock);
 		cam_calc_geometry(&ccb->ccg, sc->sc_extended_geom);
 		xpt_done(ccb);
 		return;
-	case XPT_PATH_INQ:
-	{
-		struct ccb_pathinq *cpi = &ccb->cpi;
 
+	case XPT_PATH_INQ:
+		cpi = &ccb->cpi;
 		cpi->version_num = 1;
-		cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE;
+		cpi->hba_inquiry = PI_SDTR_ABLE | PI_TAG_ABLE;
 		cpi->hba_inquiry |=
 		    (sc->sc_rev == NCR_VARIANT_FAS366) ? PI_WIDE_16 : 0;
 		cpi->target_sprt = 0;
@@ -932,11 +947,10 @@ ncr53c9x_action(struct cam_sim *sim, uni
 		mtx_unlock(&sc->sc_lock);
 		xpt_done(ccb);
 		return;
-	}
+
 	case XPT_GET_TRAN_SETTINGS:
-	{
-		struct ccb_trans_settings *cts = &ccb->cts;
-		struct ncr53c9x_tinfo *ti;
+		cts = &ccb->cts;
+		ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
 
 		ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
 
@@ -965,25 +979,24 @@ ncr53c9x_action(struct cam_sim *sim, uni
 		mtx_unlock(&sc->sc_lock);
 		xpt_done(ccb);
 		return;
-	}
+
 	case XPT_ABORT:
 		printf("XPT_ABORT called\n");
 		ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 		mtx_unlock(&sc->sc_lock);
 		xpt_done(ccb);
 		return;
+
 	case XPT_TERM_IO:
 		printf("XPT_TERM_IO called\n");
 		ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 		mtx_unlock(&sc->sc_lock);
 		xpt_done(ccb);
 		return;
+
 	case XPT_RESET_DEV:
 		printf("XPT_RESET_DEV called\n");
 	case XPT_SCSI_IO:
-	{
-		struct ccb_scsiio *csio;
-
 		if (ccb->ccb_h.target_id < 0 ||
 		    ccb->ccb_h.target_id >= sc->sc_ntarg) {
 			ccb->ccb_h.status = CAM_PATH_INVALID;
@@ -1006,7 +1019,7 @@ ncr53c9x_action(struct cam_sim *sim, uni
 			return;
 		}
 
-		/* Initialize ecb */
+		/* Initialize ecb. */
 		ecb->ccb = ccb;
 		ecb->timeout = ccb->ccb_h.timeout;
 
@@ -1018,10 +1031,10 @@ ncr53c9x_action(struct cam_sim *sim, uni
 			csio = &ccb->csio;
 			if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0)
 				bcopy(csio->cdb_io.cdb_ptr, &ecb->cmd.cmd,
-				      csio->cdb_len);
+				    csio->cdb_len);
 			else
 				bcopy(csio->cdb_io.cdb_bytes, &ecb->cmd.cmd,
-				      csio->cdb_len);
+				    csio->cdb_len);
 			ecb->clen = csio->cdb_len;
 			ecb->daddr = csio->data_ptr;
 			ecb->dleft = csio->dxfer_len;
@@ -1032,15 +1045,12 @@ ncr53c9x_action(struct cam_sim *sim, uni
 		ecb->flags |= ECB_READY;
 		if (sc->sc_state == NCR_IDLE)
 			ncr53c9x_sched(sc);
-
 		break;
-	}
 
 	case XPT_SET_TRAN_SETTINGS:
-	{
-		struct ncr53c9x_tinfo *ti;
-		struct ccb_trans_settings *cts = &ccb->cts;
-		int target = ccb->ccb_h.target_id;
+		cts = &ccb->cts;
+		target = ccb->ccb_h.target_id;
+		ti = &sc->sc_tinfo[target];
 
 		ti = &sc->sc_tinfo[target];
 
@@ -1087,11 +1097,10 @@ ncr53c9x_action(struct cam_sim *sim, uni
 		ccb->ccb_h.status = CAM_REQ_CMP;
 		xpt_done(ccb);
 		return;
-	}
 
 	default:
 		device_printf(sc->sc_dev, "Unhandled function code %d\n",
-		       ccb->ccb_h.func_code);
+		    ccb->ccb_h.func_code);
 		ccb->ccb_h.status = CAM_PROVIDE_FAIL;
 		mtx_unlock(&sc->sc_lock);
 		xpt_done(ccb);
@@ -1121,7 +1130,7 @@ ncr53c9x_poll(struct cam_sim *sim)
  */
 
 /*
- * Schedule a scsi operation.  This has now been pulled out of the interrupt
+ * Schedule a SCSI operation.  This has now been pulled out of the interrupt
  * handler so that we may call it from ncr53c9x_scsipi_request and
  * ncr53c9x_done.  This may save us an unnecessary interrupt just to get
  * things going.  Should only be called when state == NCR_IDLE and at bio pl.
@@ -1130,12 +1139,12 @@ static void
 ncr53c9x_sched(struct ncr53c9x_softc *sc)
 {
 	struct ncr53c9x_ecb *ecb;
-	struct ncr53c9x_tinfo *ti;
 	struct ncr53c9x_linfo *li;
-	int lun;
-	int tag;
+	struct ncr53c9x_tinfo *ti;
+	int lun, tag;
 
 	NCR_TRACE(("[ncr53c9x_sched] "));
+
 	if (sc->sc_state != NCR_IDLE)
 		panic("ncr53c9x_sched: not IDLE (state=%d)", sc->sc_state);
 
@@ -1166,7 +1175,7 @@ ncr53c9x_sched(struct ncr53c9x_softc *sc
 		if (li == NULL) {
 			/* Initialize LUN info and add to list. */
 			if ((li = malloc(sizeof(*li),
-			    M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) {
+			    M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
 				continue;
 			}
 			li->lun = lun;
@@ -1177,17 +1186,20 @@ ncr53c9x_sched(struct ncr53c9x_softc *sc
 		}
 		li->last_used = time_second;
 		if (tag == 0) {
-			/* Try to issue this as an un-tagged command */
+			/* Try to issue this as an untagged command. */
 			if (li->untagged == NULL)
 				li->untagged = ecb;
 		}
 		if (li->untagged != NULL) {
 			tag = 0;
 			if ((li->busy != 1) && li->used == 0) {
-				/* We need to issue this untagged command now */
+				/*
+				 * We need to issue this untagged command
+				 * now.
+				 */
 				ecb = li->untagged;
 			} else {
-				/* Not ready yet */
+				/* not ready, yet */
 				continue;
 			}
 		}
@@ -1211,10 +1223,11 @@ ncr53c9x_sched(struct ncr53c9x_softc *sc
 			sc->sc_nexus = ecb;
 			ncr53c9x_select(sc, ecb);
 			break;
-		} else
+		} else {
 			NCR_TRACE(("%d:%d busy\n",
 			    ecb->ccb->ccb_h.target_id,
 			    ecb->ccb->ccb_h.target_lun));
+		}
 	}
 }
 
@@ -1222,9 +1235,9 @@ static void
 ncr53c9x_sense(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
 {
 	union ccb *ccb = ecb->ccb;
+	struct ncr53c9x_linfo *li;
 	struct ncr53c9x_tinfo *ti;
 	struct scsi_request_sense *ss = (void *)&ecb->cmd.cmd;
-	struct ncr53c9x_linfo *li;
 	int lun;
 
 	NCR_TRACE(("requesting sense "));
@@ -1232,7 +1245,7 @@ ncr53c9x_sense(struct ncr53c9x_softc *sc
 	lun = ccb->ccb_h.target_lun;
 	ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
 
-	/* Next, setup a request sense command block */
+	/* Next, setup a REQUEST SENSE command block. */
 	memset(ss, 0, sizeof(*ss));
 	ss->opcode = REQUEST_SENSE;
 	ss->byte2 = ccb->ccb_h.target_lun << SCSI_CMD_LUN_SHIFT;
@@ -1247,7 +1260,7 @@ ncr53c9x_sense(struct ncr53c9x_softc *sc
 	if (li->busy)
 		li->busy = 0;
 	ncr53c9x_dequeue(sc, ecb);
-	li->untagged = ecb; /* must be executed first to fix C/A */
+	li->untagged = ecb;	/* Must be executed first to fix C/A. */
 	li->busy = 2;
 	if (ecb == sc->sc_nexus) {
 		ncr53c9x_select(sc, ecb);
@@ -1266,15 +1279,15 @@ static void
 ncr53c9x_done(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
 {
 	union ccb *ccb = ecb->ccb;
-	struct ncr53c9x_tinfo *ti;
 	struct ncr53c9x_linfo *li;
+	struct ncr53c9x_tinfo *ti;
 	int lun;
 
 	NCR_TRACE(("[ncr53c9x_done(status:%x)] ", ccb->ccb_h.status));
 
 	ti = &sc->sc_tinfo[ccb->ccb_h.target_id];
 	lun = ccb->ccb_h.target_lun;
-	li  = TINFO_LUN(ti, lun);
+	li = TINFO_LUN(ti, lun);
 
 	untimeout(ncr53c9x_timeout, ecb, ccb->ccb_h.timeout_ch);
 
@@ -1296,7 +1309,7 @@ ncr53c9x_done(struct ncr53c9x_softc *sc,
 			if ((ecb->flags & ECB_SENSE) != 0)
 				ccb->ccb_h.status = CAM_AUTOSENSE_FAIL;
 			else {
-				/* First, save the return values */
+				/* First, save the return values. */
 				ccb->csio.resid = ecb->dleft;
 				ncr53c9x_sense(sc, ecb);
 				return;
@@ -1337,7 +1350,7 @@ ncr53c9x_done(struct ncr53c9x_softc *sc,
 	}
 
 	if (ccb->ccb_h.status == CAM_SEL_TIMEOUT) {
-		/* Selection timeout -- discard this LUN if empty */
+		/* Selection timeout -- discard this LUN if empty. */
 		if (li->untagged == NULL && li->used == 0) {
 			if (lun < NCR_NLUN)
 				ti->lun[lun] = NULL;
@@ -1354,8 +1367,8 @@ ncr53c9x_done(struct ncr53c9x_softc *sc,
 static void
 ncr53c9x_dequeue(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
 {
-	struct ncr53c9x_tinfo *ti;
 	struct ncr53c9x_linfo *li;
+	struct ncr53c9x_tinfo *ti;
 	int64_t lun;
 
 	ti = &sc->sc_tinfo[ecb->ccb->ccb_h.target_id];
@@ -1364,7 +1377,7 @@ ncr53c9x_dequeue(struct ncr53c9x_softc *
 #ifdef DIAGNOSTIC
 	if (li == NULL || li->lun != lun)
 		panic("ncr53c9x_dequeue: lun %qx for ecb %p does not exist",
-		      (long long) lun, ecb);
+		    (long long)lun, ecb);
 #endif
 	if (li->untagged == ecb) {
 		li->busy = 0;
@@ -1376,8 +1389,7 @@ ncr53c9x_dequeue(struct ncr53c9x_softc *
 		    (li->queued[ecb->tag[1]] != ecb))
 			panic("ncr53c9x_dequeue: slot %d for lun %qx has %p "
 			    "instead of ecb %p\n", ecb->tag[1],
-			    (long long) lun,
-			    li->queued[ecb->tag[1]], ecb);
+			    (long long)lun, li->queued[ecb->tag[1]], ecb);
 #endif
 		li->queued[ecb->tag[1]] = NULL;
 		li->used--;
@@ -1395,16 +1407,15 @@ ncr53c9x_dequeue(struct ncr53c9x_softc *
 
 /*
  * Schedule an outgoing message by prioritizing it, and asserting
- * attention on the bus. We can only do this when we are the initiator
+ * attention on the bus.  We can only do this when we are the initiator
  * else there will be an illegal command interrupt.
  */
-#define ncr53c9x_sched_msgout(m) \
-	do {							\
-		NCR_MSGS(("ncr53c9x_sched_msgout %x %d", m, __LINE__));	\
-		NCRCMD(sc, NCRCMD_SETATN);			\
-		sc->sc_flags |= NCR_ATN;			\
-		sc->sc_msgpriq |= (m);				\
-	} while (0)
+#define	ncr53c9x_sched_msgout(m) do {					\
+	NCR_MSGS(("ncr53c9x_sched_msgout %x %d", m, __LINE__));		\
+	NCRCMD(sc, NCRCMD_SETATN);					\
+	sc->sc_flags |= NCR_ATN;					\
+	sc->sc_msgpriq |= (m);						\
+} while (0)

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***


More information about the svn-src-stable-6 mailing list