sys/arch/hp700/stand/common/pdc.c

   1 /*      $NetBSD: pdc.c,v 1.11 2009/10/26 19:16:55 cegger Exp $  */
   2
   3 /*      $OpenBSD: pdc.c,v 1.10 1999/05/06 02:27:44 mickey Exp $ */
   4
   5 /*
   6  * Copyright (c) 1998-2004 Michael Shalayeff
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
  22  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  28  * THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30 /*
  31  * Copyright 1996 1995 by Open Software Foundation, Inc.
  32  *              All Rights Reserved
  33  *
  34  * Permission to use, copy, modify, and distribute this software and
  35  * its documentation for any purpose and without fee is hereby granted,
  36  * provided that the above copyright notice appears in all copies and
  37  * that both the copyright notice and this permission notice appear in
  38  * supporting documentation.
  39  *
  40  * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
  41  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  42  * FOR A PARTICULAR PURPOSE.
  43  *
  44  * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
  45  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  46  * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
  47  * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  48  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  49  *
  50  */
  51 /*
  52  * Copyright (c) 1990 mt Xinu, Inc.  All rights reserved.
  53  * Copyright (c) 1990 University of Utah.  All rights reserved.
  54  *
  55  * This file may be freely distributed in any form as long as
  56  * this copyright notice is included.
  57  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  58  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  59  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  60  *
  61  *      Utah $Hdr: pdc.c 1.8 92/03/14$
  62  */
  63
  64 #include <sys/time.h>
  65 #include "libsa.h"
  66 #include <sys/reboot.h>
  67 #include <sys/disklabel.h>
  68
  69 #include <machine/trap.h>
  70 #include <machine/pdc.h>
  71 #include <machine/iomod.h>
  72 #include <machine/nvm.h>
  73 #include <machine/param.h>
  74 #include <machine/cpufunc.h>
  75
  76 #include "dev_hppa.h"
  77
  78 /*
  79  * Interface routines to initialize and access the PDC.
  80  */
  81
  82 pdcio_t pdc;
  83 int     pdcbuf[64] PDC_ALIGNMENT;/* PDC return buffer */
  84 struct  stable_storage sstor;   /* contents of Stable Storage */
  85 int     sstorsiz;               /* size of Stable Storage */
  86 struct bootdata bd;
  87 int bdsize = sizeof(struct bootdata);
  88
  89 /*
  90  * Initialize PDC and related variables.
  91  */
  92 void
  93 pdc_init(void)
  94 {
  95         int err;
  96
  97         /*
  98          * Initialize important global variables (defined above).
  99          */
 100         pdc = (pdcio_t)PAGE0->mem_pdc;
 101
 102         err = (*pdc)(PDC_STABLE, PDC_STABLE_SIZE, pdcbuf, 0, 0);
 103         if (err >= 0) {
 104                 sstorsiz = min(pdcbuf[0],sizeof(sstor));
 105                 err = (*pdc)(PDC_STABLE, PDC_STABLE_READ, 0, &sstor, sstorsiz);
 106         }
 107
 108         /*
 109          * Now that we (may) have an output device, if we encountered
 110          * an error reading Stable Storage (above), let them know.
 111          */
 112 #ifdef DEBUG
 113         if (debug && err)
 114                 printf("Stable storage PDC_STABLE Read Ret'd %d\n", err);
 115 #endif
 116
 117         /*
 118          * Clear the FAULT light (so we know when we get a real one)
 119          */
 120         (void) (*pdc)(PDC_CHASSIS, PDC_CHASSIS_DISP,
 121                       PDC_OSTAT(PDC_OSTAT_BOOT) | 0xCEC0);
 122 }
 123
 124 /*
 125  * Generic READ/WRITE through IODC.  Takes pointer to PDC device
 126  * information, returns (positive) number of bytes actually read or
 127  * the (negative) error condition, or zero if at "EOF".
 128  */
 129 int
 130 iodcstrategy(void *devdata, int rw, daddr_t blk, size_t size, void *buf,
 131     size_t *rsize)
 132 {
 133         struct hppa_dev *dp = devdata;
 134         struct pz_device *pzdev = dp->pz_dev;
 135         int offset, xfer, ret;
 136
 137 #ifdef PDCDEBUG
 138         if (debug)
 139                 printf("iodcstrategy(%p, %s, %u, %u, %p, %p)\n", devdata,
 140                        rw==F_READ?"READ":"WRITE", (unsigned) blk, (unsigned) size, buf, rsize);
 141
 142         if (debug > 1)
 143                 PZDEV_PRINT(pzdev);
 144 #endif
 145
 146         blk <<= DEV_BSHIFT;
 147         blk += dp->part_off;
 148         if ((pzdev->pz_class & PCL_CLASS_MASK) == PCL_SEQU) {
 149                 /* rewind and re-read to seek */
 150                 if (blk < dp->last_blk) {
 151 #ifdef PDCDEBUG
 152                         if (debug)
 153                                 printf("iodc: rewind ");
 154 #endif
 155                         twiddle();
 156                         if ((ret = (pzdev->pz_iodc_io)(pzdev->pz_hpa,
 157                                 IODC_IO_READ, pzdev->pz_spa, pzdev->pz_layers,
 158                                 pdcbuf, 0, dp->buf, 0, 0)) < 0) {
 159 #ifdef DEBUG
 160                                 if (debug)
 161                                         printf("IODC_IO: %d\n", ret);
 162 #endif
 163                                 return (EIO);
 164                         } else {
 165                                 dp->last_blk = 0;
 166                                 dp->last_read = 0;
 167                         }
 168                 }
 169
 170 #ifdef PDCDEBUG
 171                 if (debug)
 172                         printf("seek %d ", (int) dp->last_blk);
 173 #endif
 174                 for (; (dp->last_blk + dp->last_read) <= blk;
 175                      dp->last_read = ret) {
 176                         twiddle();
 177                         dp->last_blk += dp->last_read;
 178                         if ((ret = (pzdev->pz_iodc_io)(pzdev->pz_hpa,
 179                                 IODC_IO_READ, pzdev->pz_spa, pzdev->pz_layers,
 180                                 pdcbuf, (unsigned) dp->last_blk, dp->buf, IODC_MAXIOSIZ,
 181                                 IODC_MAXIOSIZ)) < 0) {
 182 #ifdef DEBUG
 183                                 if (debug)
 184                                         printf("IODC_IO: %d\n", ret);
 185 #endif
 186                                 return (EIO);
 187                         }
 188                         if ((ret = pdcbuf[0]) == 0)
 189                                 break;
 190 #ifdef PDCDEBUG
 191                         if (debug)
 192                                 printf("-");
 193 #endif
 194                 }
 195 #ifdef PDCDEBUG
 196                 if (debug)
 197                         printf("> %d[%d]\n", (int)dp->last_blk, (int)dp->last_read);
 198 #endif
 199         }
 200
 201         xfer = 0;
 202         /* see if we can scratch anything from buffer */
 203         if (dp->last_blk <= blk && (dp->last_blk + dp->last_read) > blk) {
 204                 twiddle();
 205                 offset = blk - dp->last_blk;
 206                 xfer = min(dp->last_read - offset, size);
 207                 size -= xfer;
 208                 blk += xfer;
 209 #ifdef PDCDEBUG
 210                 if (debug)
 211                         printf("off=%d,xfer=%d,size=%d,blk=%d\n",
 212                                offset, xfer, (int)size, (int)blk);
 213 #endif
 214                 memcpy(buf, dp->buf + offset, xfer);
 215                 buf = (char *) buf + xfer;
 216         }
 217
 218         /*
 219          * double buffer it all the time, to cache
 220          */
 221         for (; size;
 222             size -= ret, buf = (char *) buf + ret, blk += ret, xfer += ret) {
 223                 twiddle();
 224                 offset = blk & IOPGOFSET;
 225                 if ((ret = (pzdev->pz_iodc_io)(pzdev->pz_hpa,
 226                                 (rw == F_READ? IODC_IO_READ: IODC_IO_WRITE),
 227                                 pzdev->pz_spa, pzdev->pz_layers, pdcbuf,
 228                                 (int)blk - offset, dp->buf, IODC_MAXIOSIZ,
 229                                 IODC_MAXIOSIZ)) < 0) {
 230 #ifdef DEBUG
 231                         if (debug)
 232                                 printf("iodc_read(%d,%d): %d\n",
 233                                         (int)blk - offset, IODC_MAXIOSIZ, ret);
 234 #endif
 235                         if (xfer)
 236                                 break;
 237                         else
 238                                 return (EIO);
 239                 }
 240                 if ((ret = pdcbuf[0]) <= 0)
 241                         break;
 242                 dp->last_blk = blk - offset;
 243                 dp->last_read = ret;
 244                 if ((ret -= offset) > size)
 245                         ret = size;
 246                 memcpy(buf, dp->buf + offset, ret);
 247 #ifdef PDCDEBUG
 248                 if (debug)
 249                         printf("read %d(%d,%d)@%x ", ret,
 250                                (int)dp->last_blk, (int)dp->last_read, (u_int)buf);
 251 #endif
 252             }
 253
 254 #ifdef PDCDEBUG
 255         if (debug)
 256                 printf("\n");
 257 #endif
 258
 259         if (rsize)
 260                 *rsize = xfer;
 261         return (0);
 262 }
 263
 264 /*
 265  * Find a device with specified unit number
 266  * (any if unit == -1), and of specified class (PCL_*).
 267  */
 268 struct pz_device *
 269 pdc_findev(int unit, int class)
 270 {
 271         static struct pz_device pz;
 272         int layers[sizeof(pz.pz_layers)/sizeof(pz.pz_layers[0])];
 273         iodcio_t iodc;
 274         struct iomod *io;
 275         int err = 0;
 276
 277 #ifdef  PDCDEBUG
 278         if (debug)
 279                 printf("pdc_finddev(%d, %x)\n", unit, class);
 280 #endif
 281         iodc = (iodcio_t)(PAGE0->mem_free + IODC_MAXSIZE);
 282         io = PAGE0->mem_boot.pz_hpa;
 283
 284         /* quick hack for boot device */
 285         if (PAGE0->mem_boot.pz_class == class &&
 286             (unit == -1 || PAGE0->mem_boot.pz_layers[0] == unit)) {
 287
 288                 bcopy (&PAGE0->mem_boot.pz_dp, &pz.pz_dp, sizeof(pz.pz_dp));
 289                 bcopy (pz.pz_layers, layers, sizeof(layers));
 290                 if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, pdcbuf, io,
 291                                   IODC_INIT, iodc, IODC_MAXSIZE)) < 0) {
 292 #ifdef DEBUG
 293                         if (debug)
 294                                 printf("IODC_READ: %d\n", err);
 295 #endif
 296                         return NULL;
 297                 }
 298         } else {
 299                 struct pdc_memmap memmap;
 300                 struct iodc_data mptr;
 301                 int i, stp;
 302
 303                 for (i = 0; i < 0xf; i++) {
 304                         pz.pz_bc[0] = pz.pz_bc[1] =
 305                         pz.pz_bc[2] = pz.pz_bc[3] = -1;
 306                         pz.pz_bc[4] = 2;
 307                         pz.pz_bc[5] = 0;        /* core bus */
 308                         pz.pz_mod = i;
 309                         if ((pdc)(PDC_MEMMAP, PDC_MEMMAP_HPA, &memmap,
 310                                   &pz.pz_dp) < 0)
 311                                 continue;
 312 #ifdef PDCDEBUG
 313                         if (debug)
 314                                 printf("memap: %d.%d.%d, hpa=%x, mpgs=%x\n",
 315                                        pz.pz_bc[4], pz.pz_bc[5], pz.pz_mod,
 316                                        memmap.hpa, memmap.morepages);
 317 #endif
 318                         io = (struct iomod *) memmap.hpa;
 319
 320                         if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, &pdcbuf, io,
 321                                    IODC_DATA, &mptr, sizeof(mptr))) < 0) {
 322 #ifdef DEBUG
 323                                 if (debug)
 324                                         printf("IODC_DATA: %d\n", err);
 325 #endif
 326                                 continue;
 327                         }
 328
 329                         if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, pdcbuf, io,
 330                                           IODC_INIT, iodc, IODC_MAXSIZE)) < 0) {
 331 #ifdef DEBUG
 332                                 if (debug)
 333                                         printf("IODC_READ: %d\n", err);
 334 #endif
 335                                 continue;
 336                         }
 337
 338                         stp = IODC_INIT_FIRST;
 339                         do {
 340                                 if ((err = (iodc)(io, stp, io->io_spa, layers,
 341                                                   pdcbuf, 0, 0, 0, 0)) < 0) {
 342 #ifdef DEBUG
 343                                         if (debug && err != PDC_ERR_EOD)
 344                                                 printf("IODC_INIT_%s: %d\n",
 345                                                        stp==IODC_INIT_FIRST?
 346                                                        "FIRST":"NEXT", err);
 347 #endif
 348                                         break;
 349                                 }
 350 #ifdef PDCDEBUG
 351                                 if (debug)
 352                                         printf("[%x,%x,%x,%x,%x,%x], "
 353                                                "[%x,%x,%x,%x,%x,%x]\n",
 354                                                pdcbuf[0], pdcbuf[1], pdcbuf[2],
 355                                                pdcbuf[3], pdcbuf[4], pdcbuf[5],
 356                                                layers[0], layers[1], layers[2],
 357                                                layers[3], layers[4], layers[5]);
 358 #endif
 359                                 stp = IODC_INIT_NEXT;
 360
 361                         } while (pdcbuf[1] != class &&
 362                                  unit != -1 && unit != layers[0]);
 363
 364                         if (err >= 0)
 365                                 break;
 366                 }
 367         }
 368
 369         if (err >= 0) {
 370                 /* init device */
 371                 if (0  && (err = (iodc)(io, IODC_INIT_DEV, io->io_spa,
 372                                   layers, pdcbuf, 0, 0, 0, 0)) < 0) {
 373 #ifdef DEBUG
 374                         if (debug)
 375                                 printf("INIT_DEV: %d\n", err);
 376 #endif
 377                         return NULL;
 378                 }
 379
 380                 /* read i/o entry code */
 381                 if ((err = (pdc)(PDC_IODC, PDC_IODC_READ, pdcbuf, io,
 382                                 IODC_IO, iodc, IODC_MAXSIZE)) < 0) {
 383 #ifdef DEBUG
 384                         if (debug)
 385                                 printf("IODC_READ: %d\n", err);
 386 #endif
 387                         return NULL;
 388                 }
 389
 390                 pz.pz_flags = 0;
 391                 memcpy(pz.pz_layers, layers, sizeof(pz.pz_layers));
 392                 pz.pz_hpa = io;
 393 /* XXX          pz.pz_spa = io->io_spa; */
 394                 pz.pz_iodc_io = iodc;
 395                 pz.pz_class = class;
 396
 397                 return &pz;
 398         }
 399
 400         return NULL;
 401 }
 402
 403 static inline void
 404 fall(int c_base, int c_count, int c_loop, int c_stride, int data)
 405 {
 406         int loop;
 407
 408         for (; c_count--; c_base += c_stride)
 409                 for (loop = c_loop; loop--; )
 410                         if (data)
 411                                 fdce(0, c_base);
 412                         else
 413                                 fice(0, c_base);
 414
 415 }
 416
 417 /*
 418  * fcacheall - Flush all caches.
 419  *
 420  * This routine is just a wrapper around the real cache flush routine.
 421  */
 422 struct pdc_cache pdc_cacheinfo PDC_ALIGNMENT;
 423
 424 void
 425 fcacheall(void)
 426 {
 427         int err;
 428
 429         if ((err = (*pdc)(PDC_CACHE, PDC_CACHE_DFLT, &pdc_cacheinfo)) < 0) {
 430 #ifdef DEBUG
 431                 if (debug)
 432                         printf("fcacheall: PDC_CACHE failed (%d).\n", err);
 433 #endif
 434                 return;
 435         }
 436 #if PDCDEBUG
 437         if (debug)
 438                 printf("pdc_cache:\nic={%u,%x,%x,%u,%u,%u}\n"
 439                        "dc={%u,%x,%x,%u,%u,%u}\n",
 440                        pdc_cacheinfo.ic_size, *(u_int*)&pdc_cacheinfo.ic_conf,
 441                        pdc_cacheinfo.ic_base, pdc_cacheinfo.ic_stride,
 442                        pdc_cacheinfo.ic_count, pdc_cacheinfo.ic_loop,
 443                        pdc_cacheinfo.dc_size, *(u_int*)&pdc_cacheinfo.ic_conf,
 444                        pdc_cacheinfo.dc_base, pdc_cacheinfo.dc_stride,
 445                        pdc_cacheinfo.dc_count, pdc_cacheinfo.dc_loop);
 446 #endif
 447         /*
 448          * Flush the instruction, then data cache.
 449          */
 450         fall(pdc_cacheinfo.ic_base, pdc_cacheinfo.ic_count,
 451              pdc_cacheinfo.ic_loop, pdc_cacheinfo.ic_stride, 0);
 452         sync_caches();
 453         fall(pdc_cacheinfo.dc_base, pdc_cacheinfo.dc_count,
 454              pdc_cacheinfo.dc_loop, pdc_cacheinfo.dc_stride, 1);
 455         sync_caches();
 456 }