Annotation of sys/arch/sparc64/stand/ofwboot/ofdev.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ofdev.c,v 1.9 2007/05/29 06:28:15 otto Exp $ */
2: /* $NetBSD: ofdev.c,v 1.1 2000/08/20 14:58:41 mrg Exp $ */
3:
4: /*
5: * Copyright (C) 1995, 1996 Wolfgang Solfrank.
6: * Copyright (C) 1995, 1996 TooLs GmbH.
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: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by TooLs GmbH.
20: * 4. The name of TooLs GmbH may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
29: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
31: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
32: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34: /*
35: * Device I/O routines using Open Firmware
36: */
37: #include <sys/param.h>
38: #include <sys/disklabel.h>
39: #ifdef NETBOOT
40: #include <netinet/in.h>
41: #endif
42:
43: #include <lib/libsa/stand.h>
44: #include <lib/libsa/ufs.h>
45: #include <lib/libsa/cd9660.h>
46: #ifdef NETBOOT
47: #include <lib/libsa/nfs.h>
48: #endif
49:
50: #include <dev/sun/disklabel.h>
51: #include "ofdev.h"
52:
53: extern char bootdev[];
54:
55: /*
56: * This is ugly. A path on a sparc machine is something like this:
57: *
58: * [device] [-<options] [path] [-options] [otherstuff] [-<more options]
59: *
60: */
61:
62: static char *
63: filename(str, ppart)
64: char *str;
65: char *ppart;
66: {
67: char *cp, *lp;
68: char savec;
69: int dhandle;
70: char devtype[16];
71:
72: lp = str;
73: devtype[0] = 0;
74: *ppart = 0;
75: for (cp = str; *cp; lp = cp) {
76: /* For each component of the path name... */
77: while (*++cp && *cp != '/');
78: savec = *cp;
79: *cp = 0;
80: /* ...look whether there is a device with this name */
81: dhandle = OF_finddevice(str);
82: #ifdef NOTDEF_DEBUG
83: printf("filename: OF_finddevice(%s) says %x\n",
84: str, dhandle);
85: #endif
86: *cp = savec;
87: if (dhandle == -1) {
88: /* if not, lp is the delimiter between device and path */
89: /* if the last component was a block device... */
90: if (!strcmp(devtype, "block")) {
91: /* search for arguments */
92: #ifdef NOTDEF_DEBUG
93: printf("filename: hunting for arguments in %s\n", str);
94: #endif
95: for (cp = lp;
96: --cp >= str && *cp != '/' && *cp != '-';);
97: if (cp >= str && *cp == '-') {
98: /* found arguments, make firmware ignore them */
99: *cp = 0;
100: for (cp = lp; *--cp && *cp != ',';);
101: if (*++cp >= 'a' && *cp <= 'a' + MAXPARTITIONS)
102: *ppart = *cp;
103: }
104: }
105: #ifdef NOTDEF_DEBUG
106: printf("filename: found %s\n",lp);
107: #endif
108: return lp;
109: } else if (OF_getprop(dhandle, "device_type", devtype, sizeof devtype) < 0)
110: devtype[0] = 0;
111: }
112: #ifdef NOTDEF_DEBUG
113: printf("filename: not found\n",lp);
114: #endif
115: return 0;
116: }
117:
118: static int
119: strategy(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 of_dev *dev = devdata;
128: u_quad_t pos;
129: int n;
130:
131: if (rw != F_READ)
132: return EPERM;
133: if (dev->type != OFDEV_DISK)
134: panic("strategy");
135:
136: #ifdef NON_DEBUG
137: printf("strategy: block %lx, partition offset %lx, blksz %lx\n",
138: (long)blk, (long)dev->partoff, (long)dev->bsize);
139: printf("strategy: seek position should be: %lx\n",
140: (long)((blk + dev->partoff) * dev->bsize));
141: #endif
142: pos = (u_quad_t)(blk + dev->partoff) * dev->bsize;
143:
144: for (;;) {
145: #ifdef NON_DEBUG
146: printf("strategy: seeking to %lx\n", (long)pos);
147: #endif
148: if (OF_seek(dev->handle, pos) < 0)
149: break;
150: #ifdef NON_DEBUG
151: printf("strategy: reading %lx at %p\n", (long)size, buf);
152: #endif
153: n = OF_read(dev->handle, buf, size);
154: if (n == -2)
155: continue;
156: if (n < 0)
157: break;
158: *rsize = n;
159: return 0;
160: }
161: return EIO;
162: }
163:
164: static int
165: devclose(of)
166: struct open_file *of;
167: {
168: struct of_dev *op = of->f_devdata;
169:
170: #ifdef NETBOOT
171: if (op->type == OFDEV_NET)
172: net_close(op);
173: #endif
174: OF_close(op->handle);
175: op->handle = -1;
176: }
177:
178: static struct devsw devsw[1] = {
179: "OpenFirmware",
180: strategy,
181: (int (*)(struct open_file *, ...))nodev,
182: devclose,
183: noioctl
184: };
185: int ndevs = sizeof devsw / sizeof devsw[0];
186:
187: #ifdef SPARC_BOOT_UFS
188: static struct fs_ops file_system_ufs = {
189: ufs_open, ufs_close, ufs_read, ufs_write, ufs_seek, ufs_stat
190: };
191: #endif
192: #ifdef SPARC_BOOT_HSFS
193: static struct fs_ops file_system_cd9660 = {
194: cd9660_open, cd9660_close, cd9660_read, cd9660_write, cd9660_seek,
195: cd9660_stat
196: };
197: #endif
198: #ifdef NETBOOT
199: static struct fs_ops file_system_nfs = {
200: nfs_open, nfs_close, nfs_read, nfs_write, nfs_seek, nfs_stat
201: };
202: #endif
203:
204: struct fs_ops file_system[3];
205: int nfsys;
206:
207: static struct of_dev ofdev = {
208: -1,
209: };
210:
211: char opened_name[256];
212:
213: static u_long
214: get_long(p)
215: const void *p;
216: {
217: const unsigned char *cp = p;
218:
219: return cp[0] | (cp[1] << 8) | (cp[2] << 16) | (cp[3] << 24);
220: }
221: /************************************************************************
222: *
223: * The rest of this was taken from arch/sparc64/scsi/sun_disklabel.c
224: * and then substantially rewritten by Gordon W. Ross
225: *
226: ************************************************************************/
227:
228: /* What partition types to assume for Sun disklabels: */
229: static u_char
230: sun_fstypes[8] = {
231: FS_BSDFFS, /* a */
232: FS_SWAP, /* b */
233: FS_OTHER, /* c - whole disk */
234: FS_BSDFFS, /* d */
235: FS_BSDFFS, /* e */
236: FS_BSDFFS, /* f */
237: FS_BSDFFS, /* g */
238: FS_BSDFFS, /* h */
239: };
240:
241: /*
242: * Given a SunOS disk label, set lp to a BSD disk label.
243: * Returns NULL on success, else an error string.
244: *
245: * The BSD label is cleared out before this is called.
246: */
247: static char *
248: disklabel_sun_to_bsd(cp, lp)
249: char *cp;
250: struct disklabel *lp;
251: {
252: struct sun_disklabel *sl;
253: struct partition *npp;
254: struct sun_dkpart *spp;
255: int i, secpercyl;
256: u_short cksum, *sp1, *sp2;
257:
258: sl = (struct sun_disklabel *)cp;
259:
260: /* Verify the XOR check. */
261: sp1 = (u_short *)sl;
262: sp2 = (u_short *)(sl + 1);
263: cksum = 0;
264: while (sp1 < sp2)
265: cksum ^= *sp1++;
266: if (cksum != 0)
267: return("SunOS disk label, bad checksum");
268:
269: /* Format conversion. */
270: lp->d_magic = DISKMAGIC;
271: lp->d_magic2 = DISKMAGIC;
272: memcpy(lp->d_packname, sl->sl_text, sizeof(lp->d_packname));
273:
274: lp->d_secsize = 512;
275: lp->d_nsectors = sl->sl_nsectors;
276: lp->d_ntracks = sl->sl_ntracks;
277: lp->d_ncylinders = sl->sl_ncylinders;
278:
279: secpercyl = sl->sl_nsectors * sl->sl_ntracks;
280: lp->d_secpercyl = secpercyl;
281: lp->d_secperunit = secpercyl * sl->sl_ncylinders;
282:
283: lp->d_sparespercyl = sl->sl_sparespercyl;
284: lp->d_acylinders = sl->sl_acylinders;
285: lp->d_rpm = sl->sl_rpm;
286: lp->d_interleave = sl->sl_interleave;
287:
288: lp->d_npartitions = 8;
289: /* These are as defined in <ufs/ffs/fs.h> */
290: lp->d_bbsize = 8192; /* XXX */
291: lp->d_sbsize = 8192; /* XXX */
292:
293: for (i = 0; i < 8; i++) {
294: spp = &sl->sl_part[i];
295: npp = &lp->d_partitions[i];
296: npp->p_offset = spp->sdkp_cyloffset * secpercyl;
297: npp->p_size = spp->sdkp_nsectors;
298: #ifdef NOTDEF_DEBUG
299: printf("partition %d start %x size %x\n", i, (int)npp->p_offset, (int)npp->p_size);
300: #endif
301: if (npp->p_size == 0) {
302: npp->p_fstype = FS_UNUSED;
303: } else {
304: npp->p_fstype = sun_fstypes[i];
305: if (npp->p_fstype == FS_BSDFFS) {
306: /*
307: * The sun label does not store the FFS fields,
308: * so just set them with default values here.
309: */
310: npp->p_fragblock =
311: DISKLABELV1_FFS_FRAGBLOCK(1024, 8);
312: npp->p_cpg = 16;
313: }
314: }
315: }
316:
317: lp->d_checksum = 0;
318: lp->d_checksum = dkcksum(lp);
319: #ifdef NOTDEF_DEBUG
320: printf("disklabel_sun_to_bsd: success!\n");
321: #endif
322: return (NULL);
323: }
324:
325: /*
326: * Find a valid disklabel.
327: */
328: static char *
329: search_label(devp, off, buf, lp, off0)
330: struct of_dev *devp;
331: u_long off;
332: char *buf;
333: struct disklabel *lp;
334: u_long off0;
335: {
336: size_t read;
337: struct mbr_partition *p;
338: int i;
339: u_long poff;
340: static int recursion;
341:
342: struct disklabel *dlp;
343: struct sun_disklabel *slp;
344: int error;
345:
346: /* minimal requirements for archetypal disk label */
347: if (lp->d_secperunit == 0)
348: lp->d_secperunit = 0x1fffffff;
349: lp->d_npartitions = 1;
350: if (lp->d_partitions[0].p_size == 0)
351: lp->d_partitions[0].p_size = 0x1fffffff;
352: lp->d_partitions[0].p_offset = 0;
353:
354: if (strategy(devp, F_READ, LABELSECTOR, DEV_BSIZE, buf, &read)
355: || read != DEV_BSIZE)
356: return ("Cannot read label");
357: /* Check for a NetBSD disk label. */
358: dlp = (struct disklabel *) (buf + LABELOFFSET);
359: if (dlp->d_magic == DISKMAGIC) {
360: if (dkcksum(dlp))
361: return ("NetBSD disk label corrupted");
362: *lp = *dlp;
363: #ifdef NOTDEF_DEBUG
364: printf("search_label: found NetBSD label\n");
365: #endif
366: return (NULL);
367: }
368:
369: /* Check for a Sun disk label (for PROM compatibility). */
370: slp = (struct sun_disklabel *) buf;
371: if (slp->sl_magic == SUN_DKMAGIC)
372: return (disklabel_sun_to_bsd(buf, lp));
373:
374:
375: bzero(buf, sizeof(buf));
376: return ("no disk label");
377: }
378:
379: int
380: devopen(of, name, file)
381: struct open_file *of;
382: const char *name;
383: char **file;
384: {
385: char *cp;
386: char partition;
387: char fname[256];
388: char buf[DEV_BSIZE];
389: struct disklabel label;
390: int handle, part;
391: size_t read;
392: char *errmsg = NULL;
393: int error = 0;
394:
395: if (ofdev.handle != -1)
396: panic("devopen");
397: if (of->f_flags != F_READ)
398: return EPERM;
399: #ifdef NOTDEF_DEBUG
400: printf("devopen: you want %s\n", name);
401: #endif
402: strlcpy(fname, name, sizeof fname);
403: cp = filename(fname, &partition);
404: if (cp) {
405: strlcpy(buf, cp, sizeof buf);
406: *cp = 0;
407: }
408: if (!cp || !*buf)
409: strlcpy(buf, DEFAULT_KERNEL, sizeof buf);
410: if (!*fname)
411: strlcpy(fname, bootdev, sizeof fname);
412: strlcpy(opened_name, fname, sizeof opened_name);
413: if (partition) {
414: cp = opened_name + strlen(opened_name);
415: *cp++ = ':';
416: *cp++ = partition;
417: *cp = 0;
418: }
419: if (*buf != '/')
420: strlcat(opened_name, "/", sizeof opened_name);
421: strlcat(opened_name, buf, sizeof opened_name);
422: *file = opened_name + strlen(fname) + 1;
423: #ifdef NOTDEF_DEBUG
424: printf("devopen: trying %s\n", fname);
425: #endif
426: if ((handle = OF_finddevice(fname)) == -1)
427: return ENOENT;
428: #ifdef NOTDEF_DEBUG
429: printf("devopen: found %s\n", fname);
430: #endif
431: if (OF_getprop(handle, "name", buf, sizeof buf) < 0)
432: return ENXIO;
433: #ifdef NOTDEF_DEBUG
434: printf("devopen: %s is called %s\n", fname, buf);
435: #endif
436: if (OF_getprop(handle, "device_type", buf, sizeof buf) < 0)
437: return ENXIO;
438: #ifdef NOTDEF_DEBUG
439: printf("devopen: %s is a %s device\n", fname, buf);
440: #endif
441: #ifdef NOTDEF_DEBUG
442: printf("devopen: opening %s\n", fname);
443: #endif
444: if ((handle = OF_open(fname)) == -1) {
445: #ifdef NOTDEF_DEBUG
446: printf("devopen: open of %s failed\n", fname);
447: #endif
448: return ENXIO;
449: }
450: #ifdef NOTDEF_DEBUG
451: printf("devopen: %s is now open\n", fname);
452: #endif
453: bzero(&ofdev, sizeof ofdev);
454: ofdev.handle = handle;
455: if (!strcmp(buf, "block")) {
456: ofdev.type = OFDEV_DISK;
457: ofdev.bsize = DEV_BSIZE;
458: /* First try to find a disklabel without MBR partitions */
459: #ifdef NOTDEF_DEBUG
460: printf("devopen: trying to read disklabel\n");
461: #endif
462: if (strategy(&ofdev, F_READ,
463: LABELSECTOR, DEV_BSIZE, buf, &read) != 0
464: || read != DEV_BSIZE
465: || (errmsg = getdisklabel(buf, &label))) {
466: #ifdef NOTDEF_DEBUG
467: if (errmsg) printf("devopen: getdisklabel says %s\n", errmsg);
468: #endif
469: /* Else try MBR partitions */
470: errmsg = search_label(&ofdev, 0, buf, &label, 0);
471: if (errmsg) {
472: printf("devopen: search_label says %s\n", errmsg);
473: error = ERDLAB;
474: }
475: if (error && error != ERDLAB)
476: goto bad;
477: }
478:
479: if (error == ERDLAB) {
480: if (partition)
481: /* User specified a parititon, but there is none */
482: goto bad;
483: /* No, label, just use complete disk */
484: ofdev.partoff = 0;
485: } else {
486: part = partition ? partition - 'a' : 0;
487: ofdev.partoff = label.d_partitions[part].p_offset;
488: #ifdef NOTDEF_DEBUG
489: printf("devopen: setting partition %d offset %x\n",
490: part, ofdev.partoff);
491: #endif
492: }
493:
494: of->f_dev = devsw;
495: of->f_devdata = &ofdev;
496: #ifdef SPARC_BOOT_UFS
497: bcopy(&file_system_ufs, &file_system[nfsys++], sizeof file_system[0]);
498: #endif
499: #ifdef SPARC_BOOT_HSFS
500: bcopy(&file_system_cd9660, &file_system[nfsys++],
501: sizeof file_system[0]);
502: #endif
503: #ifdef NOTDEF_DEBUG
504: printf("devopen: return 0\n");
505: #endif
506: return 0;
507: }
508: #ifdef NETBOOT
509: if (!strcmp(buf, "network")) {
510: ofdev.type = OFDEV_NET;
511: of->f_dev = devsw;
512: of->f_devdata = &ofdev;
513: bcopy(&file_system_nfs, file_system, sizeof file_system[0]);
514: nfsys = 1;
515: if (error = net_open(&ofdev))
516: goto bad;
517: return 0;
518: }
519: #endif
520: error = EFTYPE;
521: bad:
522: #ifdef NOTDEF_DEBUG
523: printf("devopen: error %d, cannot open device\n", error);
524: #endif
525: OF_close(handle);
526: ofdev.handle = -1;
527: return error;
528: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ofdev.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / stand / ofwboot