![[BACK]](/icons/back.gif){kind=icon}
Return to bugdev.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvmeppc / stand / libsa|
Return to bugdev.c CVS log | Up to [local] / sys / arch / mvmeppc / stand / libsa |
1.1 nbrk 1: /* $OpenBSD: bugdev.c,v 1.4 2006/10/12 12:14:17 krw Exp $ */
2:
3: /*
4: * Copyright (c) 1993 Paul Kranenburg
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Paul Kranenburg.
18: * 4. The name of the author may not be used to endorse or promote products
19: * derived from this software without specific prior written permission
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31: */
32:
33: #include <sys/param.h>
34: #include <sys/disklabel.h>
35: #include <machine/prom.h>
36:
37: #include <stand.h>
38: #include <ufs.h>
39: #include "rawfs.h"
40: #include "tftpfs.h"
41:
42: #include "libsa.h"
43:
44: int errno;
45: int bootdev_type = BUGDEV_DISK;
46:
47: #if 1
48: #define md_swap_long(x) ( (((x) >> 24) & 0xff) | (((x) >> 8 ) & 0xff00) | \
49: (((x) << 8) & 0xff0000) | (((x) << 24) & 0xff000000))
50: #else
51: #define md_swap_long(x) (x)
52: #endif
53:
54: struct bugdev_softc {
55: int fd; /* Prom file descriptor */
56: u_int pnum; /* Partition number */
57: u_int poff; /* Partition offset */
58: u_int psize; /* Partition size */
59: short clun;
60: short dlun;
61: } bugdev_softc[1];
62:
63: extern struct fs_ops ufs_file_system;
64: extern struct fs_ops tftp_file_system;
65: extern struct fs_ops raw_file_system;
66:
67: struct fs_ops file_system[1];
68:
69: struct mvmeprom_dskio tape_ioreq;
70:
71: #ifdef BUG_DEBUG
72: unsigned io = 0, mem = 0;
73: #define PCI_BASE 0x80000000
74: #define CFC *(unsigned *)(PCI_BASE + 0xcfc)
75: #define CF8 *(unsigned *)(PCI_BASE + 0xcf8)
76: #define BUS_SHIFT 16
77: #define DEVICE_SHIFT 11
78: #define FNC_SHIFT 8
79:
80: unsigned
81: bugpci_make_tag(bus, dev, fnc)
82: int bus, dev, fnc;
83: {
84: return (bus << BUS_SHIFT) | (dev << DEVICE_SHIFT) | (fnc << FNC_SHIFT);
85: }
86:
87: static unsigned
88: bugpci_gen_config_reg(tag, offset)
89: unsigned tag;
90: int offset;
91: {
92: unsigned reg;
93:
94: /* config mechanism #2, type 0
95: /* standard cf8/cfc config */
96: reg = 0x80000000 | tag | offset;
97:
98: return reg;
99: }
100:
101: /*#define DEBUG_CONFIG */
102: unsigned
103: bugpci_conf_read(bus, dev, func, offset)
104: int bus, dev, func, offset;
105: {
106:
107: unsigned data;
108: unsigned reg, tag, xx;
109:
110: if(offset & 3 || offset < 0 || offset >= 0x100) {
111: printf ("bugpci_conf_read: bad reg %x\n", offset);
112: return(~0);
113: }
114:
115: tag = bugpci_make_tag(bus, dev, func);
116: reg = bugpci_gen_config_reg(tag, offset);
117: reg = md_swap_long(reg);
118: /* if invalid tag, return -1 */
119: if (reg == 0xffffffff) {
120: return 0xffffffff;
121: }
122:
123: CF8 = reg;
124: xx = CF8;
125: data = CFC;
126: data = md_swap_long(data);
127:
128: CF8 = 0;
129:
130: return(data);
131: }
132:
133: void
134: bugpci_conf_write(bus, dev, func, offset, data)
135: int bus, dev, func, offset;
136: unsigned data;
137: {
138: unsigned reg, tag, xx;
139:
140: tag = bugpci_make_tag(bus, dev, func);
141: reg = bugpci_gen_config_reg(tag, offset);
142: reg = md_swap_long(reg);
143:
144: /* if invalid tag, return ??? */
145: if (reg == 0xffffffff) {
146: return;
147: }
148:
149: CF8 = reg;
150: xx = CF8;
151: data = md_swap_long(data);
152: CFC = data;
153: CF8 = 0;
154: xx = CF8;
155: }
156: #endif
157:
158: static u_long
159: get_long(p)
160: const void *p;
161: {
162: const unsigned char *cp = p;
163:
164: return cp[0] | (cp[1] << 8) | (cp[2] << 16) | (cp[3] << 24);
165: }
166:
167: /*
168: * Find a valid disklabel.
169: */
170: static int
171: search_label(devp, off, buf, lp, off0)
172: void *devp;
173: u_long off;
174: char *buf;
175: struct disklabel *lp;
176: u_long off0;
177: {
178: size_t read;
179: struct dos_partition *p;
180: int i;
181: u_long poff;
182: static int recursion;
183:
184: if (dsk_strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)
185: || read != DEV_BSIZE)
186: return ERDLAB;
187:
188: if (buf[510] != 0x55 || buf[511] != 0xaa)
189: return ERDLAB;
190:
191: if (recursion++ <= 1)
192: off0 += off;
193: for (p = (struct dos_partition *)(buf + DOSPARTOFF), i = 4;
194: --i >= 0; p++) {
195: if (p->dp_typ == DOSPTYP_OPENBSD) {
196: poff = get_long(&p->dp_start) + off0;
197: if (dsk_strategy(devp, F_READ, poff + LABELSECTOR,
198: DEV_BSIZE, buf, &read) == 0
199: && read == DEV_BSIZE) {
200: if (!getdisklabel(buf, lp)) {
201: recursion--;
202: return 0;
203: }
204: }
205: if (dsk_strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)
206: || read != DEV_BSIZE) {
207: recursion--;
208: return ERDLAB;
209: }
210: } else if (p->dp_typ == DOSPTYP_EXTEND) {
211: poff = get_long(&p->dp_start);
212: if (!search_label(devp, poff, buf, lp, off0)) {
213: recursion--;
214: return 0;
215: }
216: if (dsk_strategy(devp, F_READ, off, DEV_BSIZE, buf, &read)
217: || read != DEV_BSIZE) {
218: recursion--;
219: return ERDLAB;
220: }
221: }
222: }
223: recursion--;
224: return ERDLAB;
225: }
226:
227: int dsk_read_disklabel(devp)
228: void *devp;
229: {
230: static char iobuf[MAXBSIZE];
231: struct disklabel label;
232: int error = 0;
233: int i;
234:
235: register struct bugdev_softc *pp = (struct bugdev_softc *)devp;
236:
237: #ifdef DEBUG
238: printf("dsk_open:\n");
239: #endif
240: /* First try to find a disklabel without MBR partitions */
241: if (dsk_strategy(pp, F_READ, LABELSECTOR, DEV_BSIZE, iobuf, &i) != 0
242: || i != DEV_BSIZE
243: || getdisklabel(iobuf, &label)) {
244: /* Else try MBR partitions */
245: error = search_label(pp, 0, iobuf, &label, 0);
246: if (error && error != ERDLAB)
247: return (error);
248: }
249: if (error == ERDLAB) {
250: if (pp->pnum)
251: /* User specified a partition, but there is none */
252: return (error);
253: /* No, label, just use complete disk */
254: pp->poff = 0;
255: } else {
256: pp->poff = label.d_partitions[pp->pnum].p_offset;
257: pp->psize = label.d_partitions[pp->pnum].p_size;
258: }
259: return(0);
260: }
261:
262:
263: int
264: devopen(f, fname, file)
265: struct open_file *f;
266: const char *fname;
267: char **file;
268: {
269: register struct bugdev_softc *pp = &bugdev_softc[0];
270: int error;
271: char *dev, *cp;
272:
273: pp->clun = (short)bugargs.ctrl_lun;
274: pp->dlun = (short)bugargs.dev_lun;
275: pp->poff = 0;
276: pp->psize = 0;
277: pp->fd = 0;
278: pp->pnum = 0;
279:
280: f->f_devdata = (void *)pp;
281:
282: switch (bootdev_type) {
283: case BUGDEV_DISK:
284: dev = bugargs.arg_start;
285: /*
286: * Extract partition # from boot device string.
287: */
288: for (cp = dev; *cp; cp++) /* void */;
289: while (*cp != '/' && cp > dev) {
290: if (*cp == ':')
291: pp->pnum = *(cp+1) - 'a';
292: --cp;
293: }
294:
295: error = dsk_read_disklabel(pp);
296: if (error)
297: return(error);
298:
299: bcopy(&ufs_file_system, file_system, sizeof file_system[0]);
300: break;
301:
302: case BUGDEV_NET:
303: bcopy(&tftp_file_system, file_system, sizeof file_system[0]);
304: break;
305:
306: case BUGDEV_TAPE:
307: bcopy(&raw_file_system, file_system, sizeof file_system[0]);
308: break;
309: }
310:
311: f->f_dev = &devsw[bootdev_type];
312: nfsys = 1;
313: *file = (char *)fname;
314: return (0);
315: }
316:
317: /* silly block scale factor */
318: #define BUG_BLOCK_SIZE 256
319: #define BUG_SCALE (512/BUG_BLOCK_SIZE)
320: int
321: dsk_strategy(devdata, func, dblk, size, buf, rsize)
322: void *devdata;
323: int func;
324: daddr_t dblk;
325: size_t size;
326: void *buf;
327: size_t *rsize;
328: {
329: struct mvmeprom_dskio dio;
330: register struct bugdev_softc *pp = (struct bugdev_softc *)devdata;
331: daddr_t blk = dblk + pp->poff;
332:
333: twiddle();
334:
335: dio.ctrl_lun = pp->clun;
336: dio.dev_lun = pp->dlun;
337: dio.status = 0;
338: dio.pbuffer = buf;
339: dio.blk_num = blk * BUG_SCALE;
340: dio.blk_cnt = size / BUG_BLOCK_SIZE; /* assumed size in bytes */
341: dio.flag = 0;
342: dio.addr_mod = 0;
343: #ifdef DEBUG
344: printf("dsk_strategy: size=%d blk=%d buf=%x\n", size, blk, buf);
345: printf("ctrl %d dev %d\n", dio.ctrl_lun, dio.dev_lun);
346: #endif
347: mvmeprom_diskrd(&dio);
348:
349: *rsize = dio.blk_cnt * BUG_BLOCK_SIZE;
350: #ifdef DEBUG
351: printf("rsize %d status %x\n", *rsize, dio.status);
352: #endif
353:
354: if (dio.status)
355: return (EIO);
356: return (0);
357: }
358:
359: int
360: dsk_open(f)
361: struct open_file *f;
362: {
363: #ifdef DEBUG
364: register struct bugdev_softc *pp = (struct bugdev_softc *)f->f_devdata;
365: printf("dsk_open:\n");
366: printf("using mvmebug ctrl %d dev %d\n",
367: pp->clun, pp->dlun);
368: #endif
369: return (0);
370: }
371:
372: int
373: dsk_close(f)
374: struct open_file *f;
375: {
376: return (EIO);
377: }
378:
379: int
380: dsk_ioctl(f, cmd, data)
381: struct open_file *f;
382: u_long cmd;
383: void *data;
384: {
385: return (EIO);
386: }
387:
388: #define NFR_TIMEOUT 5
389: /* netboot stuff */
390: int
391: net_strategy(devdata, func, nblk, size, buf, rsize)
392: void *devdata;
393: int func;
394: daddr_t nblk;
395: size_t size;
396: void *buf;
397: size_t *rsize;
398: {
399: int attempts = 0;
400: struct mvmeprom_netfread nfr;
401: register struct bugdev_softc *pp = (struct bugdev_softc *)devdata;
402:
403: retry:
404:
405: attempts+=1;
406:
407: nfr.clun = pp->clun;
408: nfr.dlun = pp->dlun;
409: nfr.status = 0;
410: nfr.addr = buf;
411: nfr.bytes = 0;
412: nfr.blk = nblk;
413: nfr.timeout = NFR_TIMEOUT;
414: #ifdef DEBUG
415: printf("net_strategy: size=%d blk=%d buf=%x\n", size, nblk, buf);
416: printf("ctrl %d dev %d\n", nfr.clun, nfr.dlun);
417: #endif
418: mvmeprom_netfread(&nfr);
419:
420: #ifdef BUG_DEBUG
421: io = bugpci_conf_read(0, 14, 0, 0x10) & ~0xf;
422: mem = bugpci_conf_read(0, 14, 0, 0x14) & ~0xf;
423:
424: printf(" IO @ %x\n", io);
425: printf("MEM @ %x\n", mem);
426:
427: #define PRINT_REG(regname, x) printf("%s = 0x%x\n", regname, \
428: md_swap_long(*(unsigned *)(io + x)))
429:
430: PRINT_REG("CSR0", 0x00);
431: PRINT_REG("CSR1", 0x08);
432: PRINT_REG("CSR2", 0x10);
433: PRINT_REG("CSR3", 0x18);
434: PRINT_REG("CSR4", 0x20);
435: PRINT_REG("CSR5", 0x28);
436: PRINT_REG("CSR6", 0x30);
437: PRINT_REG("CSR7", 0x38);
438: PRINT_REG("CSR8", 0x40);
439: PRINT_REG("CSR9", 0x48);
440: PRINT_REG("CSR10", 0x50);
441: PRINT_REG("CSR11", 0x58);
442: PRINT_REG("CSR12", 0x60);
443: PRINT_REG("CSR13", 0x68);
444: PRINT_REG("CSR14", 0x70);
445: PRINT_REG("CSR15", 0x78);
446: #endif
447: if (rsize) {
448: *rsize = nfr.bytes;
449: }
450: #ifdef DEBUG
451: printf("rsize %d status %x\n", *rsize, nfr.status);
452: #endif
453:
454: if (nfr.status)
455: if (attempts < 10)
456: goto retry;
457: else
458: return (EIO);
459: return (0);
460: }
461:
462: int
463: net_open(struct open_file *f, ...)
464: {
465: va_list ap;
466: struct mvmeprom_netfopen nfo;
467: register struct bugdev_softc *pp = (struct bugdev_softc *)f->f_devdata;
468: char *filename;
469: short nfoerr = 0;
470: va_start(ap, f);
471: filename = va_arg(ap, char *);
472: va_end(ap);
473:
474: #ifdef DEBUG
475: printf("net_open: using mvmebug ctrl %d dev %d, filename: %s\n",
476: pp->clun, pp->dlun, filename);
477: #endif
478: nfo.clun = pp->clun;
479: nfo.dlun = pp->dlun;
480: nfo.status = 0;
481: strlcpy(nfo.filename, filename, sizeof nfo.filename);
482: /* .NETFOPN syscall */
483: mvmeprom_netfopen(&nfo);
484:
485: #ifdef DEBUG
486: if (nfo.status) {
487: nfoerr = nfo.status;
488: printf("net_open: ci err = 0x%x, cd err = 0x%x\n",
489: ((nfoerr >> 8) & 0x0F), (nfoerr & 0x0F));
490: }
491: #endif
492: return (nfo.status);
493: }
494:
495: int
496: net_close(f)
497: struct open_file *f;
498: {
499: return (EIO);
500: }
501:
502: int
503: net_ioctl(f, cmd, data)
504: struct open_file *f;
505: u_long cmd;
506: void *data;
507: {
508: return (EIO);
509: }
510:
511: int
512: tape_open(struct open_file *f, ...)
513: {
514: va_list ap;
515: int error = 0;
516: int part;
517: struct mvmeprom_dskio *ti;
518: char *fname; /* partition number, i.e. "1" */
519:
520: va_start(ap, f);
521: fname = va_arg(ap, char *);
522: va_end(ap);
523:
524: /*
525: * Set the tape segment number to the one indicated
526: * by the single digit fname passed in above.
527: */
528: if ((fname[0] < '0') && (fname[0] > '9')) {
529: return ENOENT;
530: }
531: part = fname[0] - '0';
532: fname = NULL;
533:
534: /*
535: * Setup our part of the saioreq.
536: * (determines what gets opened)
537: */
538: ti = &tape_ioreq;
539: bzero((caddr_t)ti, sizeof(*ti));
540:
541: ti->ctrl_lun = bugargs.ctrl_lun;
542: ti->dev_lun = bugargs.dev_lun;
543: ti->status = 0;
544: ti->pbuffer = NULL;
545: ti->blk_num = part;
546: ti->blk_cnt = 0;
547: ti->flag = 0;
548: ti->addr_mod = 0;
549:
550: f->f_devdata = ti;
551:
552: return (0);
553: }
554:
555: int
556: tape_close(f)
557: struct open_file *f;
558: {
559: struct mvmeprom_dskio *ti;
560:
561:
562: ti = f->f_devdata;
563: f->f_devdata = NULL;
564: return 0;
565: }
566:
567: #define MVMEPROM_SCALE (512/MVMEPROM_BLOCK_SIZE)
568:
569: int
570: tape_strategy(devdata, flag, dblk, size, buf, rsize)
571: void *devdata;
572: int flag;
573: daddr_t dblk;
574: size_t size;
575: void *buf;
576: size_t *rsize;
577: {
578: struct mvmeprom_dskio *ti;
579: int ret;
580:
581: ti = devdata;
582:
583: if (flag != F_READ)
584: return(EROFS);
585:
586: ti->status = 0;
587: ti->pbuffer = buf;
588: /* don't change block #, set in open */
589: ti->blk_cnt = size / (512 / MVMEPROM_SCALE);
590:
591: ret = mvmeprom_diskrd(ti);
592:
593: if (ret != 0)
594: return (EIO);
595:
596: *rsize = (ti->blk_cnt / MVMEPROM_SCALE) * 512;
597: ti->flag |= IGNORE_FILENUM; /* ignore next time */
598:
599: return (0);
600: }
601:
602: int
603: tape_ioctl(f, cmd, data)
604: struct open_file *f;
605: u_long cmd;
606: void *data;
607: {
608: return EIO;
609: }
610:
611: