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