add iodcstrategy() -- generic strategy through IODC routine

add device finger/mapper

1 files changed, 355 insertions, 102 deletions

diff --git a/sys/arch/hppa/stand/libsa/pdc.c b/sys/arch/hppa/stand/libsa/pdc.c
index 8d910ed5001..6f350e2d063 100644
--- a/sys/arch/hppa/stand/libsa/pdc.c
+++ b/sys/arch/hppa/stand/libsa/pdc.c
@@ -1,6 +1,35 @@
-/*	$OpenBSD: pdc.c,v 1.2 1998/07/08 21:34:37 mickey Exp $	*/
+/*	$OpenBSD: pdc.c,v 1.3 1998/09/29 07:27:02 mickey Exp $	*/
 
 /*
+ * Copyright (c) 1998 Michael Shalayeff
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Michael Shalayeff.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
  * Copyright 1996 1995 by Open Software Foundation, Inc.   
  *              All Rights Reserved 
  *  
@@ -39,29 +68,26 @@
 #include <sys/reboot.h>
 #include <sys/disklabel.h>
 
-#include "dev_hppa.h"
-
 #include <machine/pdc.h>
-#include <machine/iodc.h>
 #include <machine/iomod.h>
 #include <machine/nvm.h>
+#include <machine/param.h>
+#include <machine/cpufunc.h>
 
-#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#include "dev_hppa.h"
 
 /*
  * Interface routines to initialize and access the PDC.
  */
 
 pdcio_t pdc;
-int	pdcbuf[64] __attribute ((aligned(8)));		/* PDC return buffer */
+int	pdcbuf[64]		/* PDC return buffer */
+		__attribute ((aligned(8)));
 struct	stable_storage sstor;	/* contents of Stable Storage */
 int	sstorsiz;		/* size of Stable Storage */
-unsigned int rstaddr;
 struct bootdata bd;
 int bdsize = sizeof(struct bootdata);
-unsigned int chasdata;
-
-extern unsigned int howto, bootdev;
+u_int chasdata;
 
 /*
  * Initialize PDC and related variables.
@@ -78,7 +104,7 @@ pdc_init()
 
 	err = (*pdc)(PDC_STABLE, PDC_STABLE_SIZE, pdcbuf, 0, 0);
 	if (err >= 0) {
-		sstorsiz = MIN(pdcbuf[0],sizeof(sstor));
+		sstorsiz = min(pdcbuf[0],sizeof(sstor));
 		err = (*pdc)(PDC_STABLE, PDC_STABLE_READ, 0, &sstor, sstorsiz);
 	}
 
@@ -86,8 +112,10 @@ pdc_init()
 	 * Now that we (may) have an output device, if we encountered
 	 * an error reading Stable Storage (above), let them know.
 	 */
-	if (err)
+#ifdef DEBUG
+	if (debug && err)
 		printf("Stable storage PDC_STABLE Read Ret'd %d\n", err);
+#endif
 
 	/*
 	 * Clear the FAULT light (so we know when we get a real one)
@@ -97,112 +125,337 @@ pdc_init()
 }
 
 /*
- * Read in `bootdev' and `howto' from Non-Volatile Memory.
+ * Generic READ/WRITE through IODC.  Takes pointer to PDC device
+ * information, returns (positive) number of bytes actually read or
+ * the (negative) error condition, or zero if at "EOF".
  */
-void
-getbinfo()
+int
+iodcstrategy(devdata, rw, blk, size, buf, rsize)
+	void *devdata;
+	int rw;
+	daddr_t blk;
+	size_t size;
+	void *buf;
+	size_t *rsize;
 {
-	int err;
+	struct hppa_dev *dp = devdata;
+	struct pz_device *pzdev = dp->pz_dev;
+	register int	offset, xfer, ret;
+	register char	*bbuf = (void*)		/* align */
+		((((int)dp->buf) + MINIOSIZ - 1) & ~(MINIOSIZ - 1));
 
-	/*
-	 * Try to read bootdata from NVM through PDC.
-	 * If successful, set `howto' and `bootdev'.
-	 */
-	if ((err = (*pdc)(PDC_NVM, PDC_NVM_READ, NVM_BOOTDATA, &bd, bdsize)) < 0) {
-		/*
-		 * First, determine if this machine has Non-Volatile Memory.
-		 * If not, just return (until we come up with a new plan)!
-		 */
-		if (err == -1)		/* Nonexistent procedure */
-			return;
-		printf("NVM bootdata Read ret'd %d\n", err);
-	} else {
-		if (bd.cksum == NVM_BOOTCKSUM(bd)) {
-			/*
-			 * The user may override the PDC auto-boot, setting
-			 * an interactive boot.  We give them this right by
-			 * or'ing the bootaddr flags into `howto'.
-			 */
-			howto |= bd.flags;
-			bootdev = bd.device;
-		} else {
-			printf("NVM bootdata Bad Checksum (%x)\n", bd.cksum);
+#ifdef PDCDEBUG
+	if (debug)
+		printf("iodcstrategy(%p, %s, %u, %u, %p, %p)\n", devdata,
+		       rw==F_READ?"READ":"WRITE", blk, size, buf, rsize);
+
+	if (debug > 1)
+		PZDEV_PRINT(pzdev);
+#endif
+
+	blk <<= DEV_BSHIFT;
+	if ((pzdev->pz_class & PCL_CLASS_MASK) == PCL_SEQU) {
+		/* rewind and re-read to seek */
+		if (blk < dp->last_blk) {
+#ifdef PDCDEBUG
+			if (debug)
+				printf("iodc: rewind ");
+#endif
+			twiddle();
+			if ((ret = (pzdev->pz_iodc_io)(pzdev->pz_hpa,
+				IODC_IO_READ, pzdev->pz_spa, pzdev->pz_layers,
+				pdcbuf, 0, bbuf, 0, 0)) < 0) {
+#ifdef DEBUG
+				if (debug)
+					printf("IODC_IO: %d\n", ret);
+#endif
+				return (EIO);
+			} else {
+				dp->last_blk = 0;
+				dp->last_read = 0;
+			}
+		}
+
+#ifdef PDCDEBUG
+		if (debug)
+			printf("seek %d ", dp->last_blk);
+#endif
+		for (; (dp->last_blk + dp->last_read) <= blk;
+		     dp->last_read = ret) {
+			twiddle();
+			dp->last_blk += dp->last_read;
+			if ((ret = (pzdev->pz_iodc_io)(pzdev->pz_hpa,
+				IODC_IO_READ,
+				pzdev->pz_spa, pzdev->pz_layers, pdcbuf,
+				dp->last_blk, bbuf, BTIOSIZ, BTIOSIZ)) < 0) {
+#ifdef DEBUG
+				if (debug)
+					printf("IODC_IO: %d\n", ret);
+#endif
+				return (EIO);
+			}
+			if ((ret = pdcbuf[0]) == 0)
+				break;
+#ifdef PDCDEBUG
+			if (debug)
+				printf("-");
+#endif
 		}
+#ifdef PDCDEBUG
+		if (debug)
+			printf("> %d[%d]\n", dp->last_blk, dp->last_read);
+#endif
+	}
+
+	xfer = 0;
+	/* see if we can scratch anything from buffer */
+	if (dp->last_blk <= blk && (dp->last_blk + dp->last_read) > blk) {
+		twiddle();
+		offset = blk - dp->last_blk;
+		xfer = min(dp->last_read - offset, size);
+		size -= xfer;
+		blk += xfer;
+#ifdef DEBUG
+		if (debug)
+			printf("off=%d,xfer=%d,size=%d,blk=%d\n",
+			       offset, xfer, size, blk);
+#endif
+		bcopy(bbuf + offset, buf, xfer);
+		buf += xfer;
 	}
 
 	/*
-	 * Reset the bootdata to defaults (if necessary).
+	 * double buffer it all the time, to cache
 	 */
-	if (bd.flags != RB_AUTOBOOT || bd.device != 0) {
-		bd.flags = RB_AUTOBOOT;
-		bd.device = 0;
-		bd.cksum = NVM_BOOTCKSUM(bd);
-		if ((err = (*pdc)(PDC_NVM, PDC_NVM_WRITE, NVM_BOOTDATA,
-				  &bd, bdsize)) < 0)
-			printf("NVM bootdata Write ret'd %d\n", err);
-	}
+	for (; size; size -= ret, buf += ret, blk += ret, xfer += ret) {
+		twiddle();
+		offset = blk & IOPGOFSET;
+		if ((ret = (pzdev->pz_iodc_io)(pzdev->pz_hpa,
+				(rw == F_READ? IODC_IO_READ: IODC_IO_WRITE),
+				pzdev->pz_spa, pzdev->pz_layers, pdcbuf,
+				blk - offset, bbuf, BTIOSIZ, BTIOSIZ)) < 0) {
+#ifdef DEBUG
+			if (debug)
+				printf("IODC_IO: %d\n", ret);
+#endif
+			return (EIO);
+		}
+		if ((ret = pdcbuf[0]) <= 0)
+			break;
+		dp->last_blk = blk - offset;
+		dp->last_read = ret;
+		if ((ret -= offset) > size)
+			ret = size;
+		bcopy(bbuf + offset, buf, ret);
+#ifdef PDCDEBUG
+		if (debug)
+			printf("read %d(%d,%d)@%x ", ret,
+			       dp->last_blk, dp->last_read, (u_int)buf);
+#endif
+	    }
+
+#ifdef PDCDEBUG
+	if (debug)
+		printf("\n");
+#endif
+
+	if (rsize)
+		*rsize = xfer;
+	return (0);
 }
 
 /*
- * Generic READ/WRITE through IODC.  Takes pointer to PDC device
- * information, returns (positive) number of bytes actually read or
- * the (negative) error condition, or zero if at "EOF".
+ * Find a device with specified unit number
+ * (any if unit == -1), and of specified class (PCL_*).
  */
-int
-iodc_rw(maddr, daddr, count, func, pzdev)
-	char * maddr; /* io->i_ma = labelbuf */
-	unsigned int daddr;
-	unsigned int count;   /* io->i_cc = DEV_BSIZE */
-	int func;      
-	struct pz_device *pzdev;
+struct pz_device *
+pdc_findev(unit, class)
+	int unit, class;
 {
-	register int	offset;
-	register int	xfer_cnt = 0;
-	register int	ret;
+	static struct pz_device pz;
+	iodcio_t iodc;
+	struct pdc_memmap memmap;
+	struct iodc_data mptr;
+	int layers[6];
+	register struct iomod *io;
+	register int i, err, stp;
 
-	if (pzdev == 0)		/* default: use BOOT device */ 
-		pzdev = &PAGE0->mem_boot;
-	
-	if (pzdev->pz_iodc_io == 0)
-		return(-1);
+#ifdef	PDCDEBUG
+	if (debug)
+		printf("pdc_finddev(%d, %x)\n", unit, class);
+#endif
+	iodc = (iodcio_t)(PAGE0->mem_free + IODC_MAXSIZE);
+	err = 0;
+	io = NULL;
 
-	/*
-	 * IODC arguments are constrained in a number of ways.  If the
-	 * request doesn't fit one or more of these constraints, we have
-	 * to do the transfer to a buffer and copy it.
-	 */
-	if ((((int)maddr)&(MINIOSIZ-1))||(count&IOPGOFSET)||(daddr&IOPGOFSET))
-	    for (; count > 0; count -= ret, maddr += ret, daddr += ret) {
-		offset = daddr & IOPGOFSET;
-		if ((ret = (*pzdev->pz_iodc_io)(pzdev->pz_hpa,
-					(func == F_READ)? IODC_IO_BOOTIN:
-							  IODC_IO_BOOTOUT,
-					pzdev->pz_spa, pzdev->pz_layers, pdcbuf,
-					daddr - offset, btbuf, BTIOSIZ,
-					BTIOSIZ)) < 0)
-			return (ret);
-		if ((ret = pdcbuf[0]) == 0)
-			break;
-		if ((ret -= offset) > count)
-			ret = count;
-		bcopy(btbuf + offset, maddr, ret);
-		xfer_cnt += ret;
-	    }
-	else 
-		for (; count > 0; count -= ret, maddr += ret, daddr += ret) {
-			if ((offset = count) > MAXIOSIZ)
-				offset = MAXIOSIZ;
-			if ((ret = (*pzdev->pz_iodc_io)(pzdev->pz_hpa,
-					(func == F_READ)? IODC_IO_BOOTIN:
-							  IODC_IO_BOOTOUT,
-					pzdev->pz_spa, pzdev->pz_layers,
-					pdcbuf, daddr, maddr, offset,
-					count)) < 0)
-				return (ret);
-			if ((ret = pdcbuf[0]) == 0)
+	/* quick hack for boot device */
+	if (PAGE0->mem_boot.pz_class == class &&
+	    (unit == -1 || PAGE0->mem_boot.pz_layers[0] == unit)) {
+
+		io = PAGE0->mem_boot.pz_hpa;
+		bcopy (&PAGE0->mem_boot.pz_dp, &pz.pz_dp, sizeof(pz.pz_dp));
+		bcopy (pz.pz_layers, layers, sizeof(layers));
+		if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, pdcbuf, io,
+				  IODC_INIT, iodc, IODC_MAXSIZE)) < 0) {
+#ifdef DEBUG
+			if (debug)
+				printf("IODC_READ: %d\n", err);
+#endif
+			return NULL;
+		}
+	} else {
+
+		for (i = 0; i < 0xf; i++) {
+			pz.pz_bc[0] = pz.pz_bc[1] =
+			pz.pz_bc[2] = pz.pz_bc[3] = -1;
+			pz.pz_bc[4] = 2;
+			pz.pz_bc[5] = 0;	/* core bus */
+			pz.pz_mod = i;
+			if ((pdc)(PDC_MEMMAP, PDC_MEMMAP_HPA, &memmap,
+				  &pz.pz_dp) < 0)
+				continue;
+#ifdef PDCDEBUG
+			if (debug)
+				printf("memap: %d.%d.%d, hpa=%x, mpgs=%x\n",
+				       pz.pz_bc[4], pz.pz_bc[5], pz.pz_mod,
+				       memmap.hpa, memmap.morepages);
+#endif
+			io = (struct iomod *) memmap.hpa;
+
+			if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, &pdcbuf, io,
+				   IODC_DATA, &mptr, sizeof(mptr))) < 0) {
+#ifdef DEBUG
+				if (debug)
+					printf("IODC_DATA: %d\n", err);
+#endif
+				continue;
+			}
+
+			if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, pdcbuf, io,
+					  IODC_INIT, iodc, IODC_MAXSIZE)) < 0) {
+#ifdef DEBUG
+				if (debug)
+					printf("IODC_READ: %d\n", err);
+#endif
+				continue;
+			}
+
+			stp = IODC_INIT_FIRST;
+			do {
+				if ((err = (iodc)(io, stp, io->io_spa, layers,
+						  pdcbuf, 0, 0, 0, 0)) < 0) {
+#ifdef DEBUG
+					if (debug && err != PDC_ERR_EOD)
+						printf("IODC_INIT_%s: %d\n",
+						       stp==IODC_INIT_FIRST?
+						       "FIRST":"NEXT", err);
+#endif
+					break;
+				}
+#ifdef PDCDEBUG
+				if (debug)
+					printf("[%x,%x,%x,%x,%x,%x], "
+					       "[%x,%x,%x,%x,%x,%x]\n",
+					       pdcbuf[0], pdcbuf[1], pdcbuf[2],
+					       pdcbuf[3], pdcbuf[4], pdcbuf[5],
+					       layers[0], layers[1], layers[2],
+					       layers[3], layers[4], layers[5]);
+#endif
+				stp = IODC_INIT_NEXT;
+
+			} while (pdcbuf[1] != class &&
+				 unit != -1 && unit != layers[0]);
+
+			if (err >= 0)
 				break;
-			xfer_cnt += ret;
+		}
+	}
+
+	if (err >= 0) {
+		/* init device */
+		if ((err = (iodc)(io, IODC_INIT_DEV, io->io_spa,
+				  layers, pdcbuf, 0, 0, 0, 0)) < 0) {
+#ifdef DEBUG
+			if (debug)
+				printf("INIT_DEV: %d\n", err);
+#endif
+			return NULL;
+		}
+		/* read i/o entry code */
+		if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, pdcbuf, io,
+			  	IODC_IO, iodc, IODC_MAXSIZE)) < 0) {
+#ifdef DEBUG
+			if (debug)
+				printf("IODC_READ: %d\n", err);
+#endif
+			return NULL;
 		}
 
-	return (xfer_cnt);
+		pz.pz_flags = 0;
+		bcopy(layers, pz.pz_layers, sizeof(layers));
+		pz.pz_hpa = io;
+		pz.pz_spa = io->io_spa;
+		pz.pz_iodc_io = iodc;
+		pz.pz_class = class;
+		return &pz;
+	}
+
+	return NULL;
 }
+
+static __inline void
+fall(c_base, c_count, c_loop, c_stride, data)
+	int c_base, c_count, c_loop, c_stride, data; 
+{
+        register int loop;                  /* Internal vars */
+
+        for (; c_count--; c_base += c_stride)
+                for (loop = c_loop; loop--; )
+			if (data)
+				fdce(0, c_base);
+			else
+				fice(0, c_base);
+        
+}
+
+/*
+ * fcacheall - Flush all caches.
+ *
+ * This routine is just a wrapper around the real cache flush routine.
+ */
+struct pdc_cache pdc_cacheinfo __attribute__ ((aligned(8)));
+
+void 
+fcacheall()
+{
+	register int err;
+
+        if ((err = (*pdc)(PDC_CACHE, PDC_CACHE_DFLT, &pdc_cacheinfo)) < 0) {
+#ifdef DEBUG
+		if (debug)
+			printf("fcacheall: PDC_CACHE failed (%d).\n", err);
+#endif
+		return;
+        }
+#if PDCDEBUG
+	if (debug)
+		printf("pdc_cache:\nic={%u,%x,%x,%u,%u,%u}\n"
+		       "dc={%u,%x,%x,%u,%u,%u}\n",
+		       pdc_cacheinfo.ic_size, *(u_int*)&pdc_cacheinfo.ic_conf, 
+		       pdc_cacheinfo.ic_base, pdc_cacheinfo.ic_stride, 
+		       pdc_cacheinfo.ic_count, pdc_cacheinfo.ic_loop,
+		       pdc_cacheinfo.dc_size, *(u_int*)&pdc_cacheinfo.ic_conf, 
+		       pdc_cacheinfo.dc_base, pdc_cacheinfo.dc_stride, 
+		       pdc_cacheinfo.dc_count, pdc_cacheinfo.dc_loop);
+#endif
+        /*
+         * Flush the instruction, then data cache.
+         */
+        fall (pdc_cacheinfo.ic_base, pdc_cacheinfo.ic_count,
+	      pdc_cacheinfo.ic_loop, pdc_cacheinfo.ic_stride, 0);
+	sync_caches();
+        fall (pdc_cacheinfo.dc_base, pdc_cacheinfo.dc_count,
+	      pdc_cacheinfo.dc_loop, pdc_cacheinfo.dc_stride, 1);
+	sync_caches();
+}
+