1 /* $NetBSD: pdc.c,v 1.4 2019/01/08 19:14:08 christos 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/param.h>
65 #include <sys/time.h>
66 #include "libsa.h"
67 #include <sys/reboot.h>
68 #include <sys/disklabel.h>
69
70 #include <machine/trap.h>
71 #include <machine/pdc.h>
72 #include <machine/iomod.h>
73 #include <machine/nvm.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
pdc_init(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 = uimin(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
iodcstrategy(void * devdata,int rw,daddr_t blk,size_t size,void * buf,size_t * rsize)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 = uimin(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 *
pdc_findev(int unit,int class)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
fall(int c_base,int c_count,int c_loop,int c_stride,int data)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
fcacheall(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 }
457