![[BACK]](/icons/back.gif){kind=icon}
Return to nubus.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mac68k / dev|
Return to nubus.c CVS log | Up to [local] / sys / arch / mac68k / dev |
1.1 nbrk 1: /* $OpenBSD: nubus.c,v 1.33 2007/04/10 17:47:54 miod Exp $ */
2: /* $NetBSD: nubus.c,v 1.53 2002/04/13 17:49:41 briggs Exp $ */
3:
4: /*
5: * Copyright (c) 1995, 1996 Allen Briggs. 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 Allen Briggs.
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/systm.h>
35: #include <sys/malloc.h>
36: #include <sys/device.h>
37: #include <sys/buf.h>
38: #include <sys/conf.h>
39:
40: #include <uvm/uvm_extern.h>
41:
42: #include <machine/autoconf.h>
43: #include <machine/bus.h>
44: #include <machine/vmparam.h>
45: #include <machine/param.h>
46: #include <machine/cpu.h>
47: #include <machine/pte.h>
48: #include <machine/viareg.h>
49:
50: #include <mac68k/dev/nubus.h>
51:
52: #ifdef DEBUG
53: #define NDB_PROBE 0x1
54: #define NDB_FOLLOW 0x2
55: #define NDB_ARITH 0x4
56: static int nubus_debug = 0 /* | NDB_PROBE | NDB_FOLLOW | NDB_ARITH */ ;
57: #endif
58:
59: static int nubus_print(void *, const char *);
60: static int nubus_match(struct device *, void *, void *);
61: static void nubus_attach(struct device *, struct device *, void *);
62: static int nubus_video_resource(int);
63:
64: static int nubus_probe_slot(bus_space_tag_t, bus_space_handle_t,
65: int, nubus_slot *);
66: static u_int32_t nubus_calc_CRC(bus_space_tag_t, bus_space_handle_t,
67: nubus_slot *);
68:
69: static u_long nubus_adjust_ptr(u_int8_t, u_long, long);
70: static u_int8_t nubus_read_1(bus_space_tag_t, bus_space_handle_t,
71: u_int8_t, u_long);
72: #ifdef notyet
73: static u_int16_t nubus_read_2(bus_space_tag_t, bus_space_handle_t,
74: u_int8_t, u_long);
75: #endif
76: static u_int32_t nubus_read_4(bus_space_tag_t, bus_space_handle_t,
77: u_int8_t, u_long);
78:
79: struct cfattach nubus_ca = {
80: sizeof(struct nubus_softc), nubus_match, nubus_attach
81: };
82:
83: struct cfdriver nubus_cd = {
84: NULL, "nubus", DV_DULL,
85: };
86:
87: static int
88: nubus_match(parent, cf, aux)
89: struct device *parent;
90: void *cf;
91: void *aux;
92: {
93: static int nubus_matched = 0;
94:
95: /* Allow only one instance. */
96: if (nubus_matched)
97: return (0);
98:
99: nubus_matched = 1;
100: return (1);
101: }
102:
103: static void
104: nubus_attach(parent, self, aux)
105: struct device *parent, *self;
106: void *aux;
107: {
108: struct nubus_attach_args na_args;
109: bus_space_tag_t bst;
110: bus_space_handle_t bsh;
111: nubus_slot fmtblock;
112: nubus_dir dir;
113: nubus_dirent dirent;
114: nubus_type slottype;
115: u_long entry;
116: int i, rsrcid;
117: u_int8_t lanes;
118:
119: printf("\n");
120:
121: for (i = NUBUS_MIN_SLOT; i <= NUBUS_MAX_SLOT; i++) {
122: na_args.slot = i;
123: na_args.na_tag = bst = MAC68K_BUS_SPACE_MEM;
124:
125: if (bus_space_map(bst,
126: NUBUS_SLOT2PA(na_args.slot), NBMEMSIZE, 0, &bsh)) {
127: #ifdef DEBUG
128: if (nubus_debug & NDB_PROBE)
129: printf("%s: failed to map slot %x, "
130: "address %p (in use?)\n",
131: self->dv_xname, i,
132: (void *)NUBUS_SLOT2PA(i));
133: #endif
134: continue;
135: }
136:
137: if (nubus_probe_slot(bst, bsh, i, &fmtblock) <= 0) {
138: notfound:
139: bus_space_unmap(bst, bsh, NBMEMSIZE);
140: continue;
141: }
142:
143: rsrcid = 0x80;
144: lanes = fmtblock.bytelanes;
145:
146: nubus_get_main_dir(&fmtblock, &dir);
147:
148: /*
149: * Get the resource for the first function on the card.
150: * This is assumed to be at resource ID 0x80. If we can
151: * not find this entry (as we can not on some video cards),
152: * check to see if we can get a different ID from the list
153: * of video resources given to us by the booter. If that
154: * doesn't work either, take the first resource following
155: * the board resource.
156: * If we only find a board resource, report that.
157: * There are cards that do not have anything else; their
158: * driver then has to match on the board resource and
159: * the card name.
160: */
161: if (nubus_find_rsrc(bst, bsh,
162: &fmtblock, &dir, rsrcid, &dirent) <= 0) {
163: if ((rsrcid = nubus_video_resource(i)) == -1) {
164: int has_board_rsrc = 0;
165:
166: /*
167: * Since nubus_find_rsrc failed, the directory
168: * is back at its base.
169: */
170: entry = dir.curr_ent;
171:
172: /*
173: * All nubus cards should have a board
174: * resource, but be sure that's what it
175: * is before we skip it, and note the fact.
176: */
177: rsrcid = nubus_read_1(bst, bsh,
178: lanes, entry);
179: if (rsrcid == 0x1) {
180: has_board_rsrc = 1;
181: entry = nubus_adjust_ptr(lanes,
182: dir.curr_ent, 4);
183: }
184: rsrcid = nubus_read_1(bst, bsh, lanes, entry);
185: /* end of chain? */
186: if (rsrcid == 0xff) {
187: if (!has_board_rsrc)
188: goto notfound;
189: else
190: rsrcid = 0x01;
191: }
192: #ifdef DEBUG
193: if (nubus_debug & NDB_FOLLOW)
194: printf("\tUsing rsrc 0x%x.\n", rsrcid);
195: #endif
196: }
197: /*
198: * Try to find the resource passed by the booter
199: * or the one we just tracked down.
200: */
201: if (nubus_find_rsrc(bst, bsh,
202: &fmtblock, &dir, rsrcid, &dirent) <= 0)
203: goto notfound;
204: }
205:
206: nubus_get_dir_from_rsrc(&fmtblock, &dirent, &dir);
207:
208: if (nubus_find_rsrc(bst, bsh,
209: &fmtblock, &dir, NUBUS_RSRC_TYPE, &dirent) <= 0)
210: goto notfound;
211:
212: if (nubus_get_ind_data(bst, bsh, &fmtblock, &dirent,
213: (caddr_t)&slottype, sizeof(nubus_type)) <= 0)
214: goto notfound;
215:
216: /*
217: * If this is a display card, try to pull out the correct
218: * display mode as passed by the booter.
219: */
220: if (slottype.category == NUBUS_CATEGORY_DISPLAY) {
221: int r;
222:
223: if ((r = nubus_video_resource(i)) != -1) {
224:
225: nubus_get_main_dir(&fmtblock, &dir);
226:
227: if (nubus_find_rsrc(bst, bsh,
228: &fmtblock, &dir, r, &dirent) <= 0)
229: goto notfound;
230:
231: nubus_get_dir_from_rsrc(&fmtblock,
232: &dirent, &dir);
233:
234: if (nubus_find_rsrc(bst, bsh, &fmtblock, &dir,
235: NUBUS_RSRC_TYPE, &dirent) <= 0)
236: goto notfound;
237:
238: if (nubus_get_ind_data(bst, bsh,
239: &fmtblock, &dirent, (caddr_t)&slottype,
240: sizeof(nubus_type)) <= 0)
241: goto notfound;
242:
243: rsrcid = r;
244: }
245: }
246:
247: na_args.slot = i;
248: na_args.rsrcid = rsrcid;
249: na_args.category = slottype.category;
250: na_args.type = slottype.type;
251: na_args.drsw = slottype.drsw;
252: na_args.drhw = slottype.drhw;
253: na_args.fmt = &fmtblock;
254:
255: bus_space_unmap(bst, bsh, NBMEMSIZE);
256:
257: config_found(self, &na_args, nubus_print);
258: }
259:
260: enable_nubus_intr();
261: }
262:
263: static int
264: nubus_print(aux, pnp)
265: void *aux;
266: const char *pnp;
267: {
268: struct nubus_attach_args *na = (struct nubus_attach_args *)aux;
269: bus_space_tag_t bst = na->na_tag;
270: bus_space_handle_t bsh;
271:
272: if (pnp) {
273: printf("%s slot %x", pnp, na->slot);
274: if (bus_space_map(bst,
275: NUBUS_SLOT2PA(na->slot), NBMEMSIZE, 0, &bsh) == 0) {
276: printf(": %s", nubus_get_card_name(bst, bsh, na->fmt));
277: printf(" (Vendor: %s,", nubus_get_vendor(bst, bsh,
278: na->fmt, NUBUS_RSRC_VEND_ID));
279: printf(" Part: %s)", nubus_get_vendor(bst, bsh,
280: na->fmt, NUBUS_RSRC_VEND_PART));
281:
282: bus_space_unmap(bst, bsh, NBMEMSIZE);
283: }
284: #ifdef DIAGNOSTIC
285: else
286: printf(":");
287: printf(" Type: %04x %04x %04x %04x",
288: na->category, na->type, na->drsw, na->drhw);
289: #endif
290: } else {
291: printf(" slot %x", na->slot);
292: }
293: return (UNCONF);
294: }
295:
296: static int
297: nubus_video_resource(slot)
298: int slot;
299: {
300: extern u_int16_t mac68k_vrsrc_vec[];
301: int i;
302:
303: for (i = 0 ; i < 6 ; i++)
304: if ((mac68k_vrsrc_vec[i] & 0xff) == slot)
305: return ((mac68k_vrsrc_vec[i] >> 8) & 0xff);
306: return (-1);
307: }
308:
309: /*
310: * Probe a given nubus slot. If a card is there and we can get the
311: * format block from its clutching decl. ROMs, fill the format block
312: * and return non-zero. If we can't find a card there with a valid
313: * decl. ROM, return 0.
314: *
315: * First, we check to see if we can access the memory at the tail
316: * end of the slot. If so, then we check for a bytelanes byte. We
317: * could probably just return a failure status if we bus error on
318: * the first try, but there really is little reason not to go ahead
319: * and check the other three locations in case there's a weird card
320: * out there.
321: *
322: * Checking for a card involves locating the "bytelanes" byte which
323: * tells us how to interpret the declaration ROM's data. The format
324: * block is at the top of the card's standard memory space and the
325: * bytelanes byte is at the end of that block.
326: *
327: * After some inspection of the bytelanes byte, it appears that it
328: * takes the form 0xXY where Y is a bitmask of the bytelanes in use
329: * and X is a bitmask of the lanes to ignore. Hence, (X ^ Y) == 0
330: * and (less obviously), Y will have the upper N bits clear if it is
331: * found N bytes from the last possible location. Both that and
332: * the exclusive-or check are made.
333: *
334: * If a valid
335: */
336: static u_int8_t nbits[] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
337: static int
338: nubus_probe_slot(bst, bsh, slot, fmt)
339: bus_space_tag_t bst;
340: bus_space_handle_t bsh;
341: int slot;
342: nubus_slot *fmt;
343: {
344: u_long ofs, hdr;
345: int i, j, found, hdr_size;
346: u_int8_t lanes;
347:
348: #ifdef DEBUG
349: if (nubus_debug & NDB_PROBE)
350: printf("probing slot %x\n", slot);
351: #endif
352:
353: /*
354: * The idea behind this glorious work of art is to probe for only
355: * valid bytelanes values at appropriate locations (see DC&D p. 159
356: * for a list). Note the pattern: the first 8 values are at offset
357: * 0xffffff in the slot's space; the next 4 values at 0xfffffe; the
358: * next 2 values at 0xfffffd; and the last one at 0xfffffc.
359: *
360: * The nested loops implement an efficient search of this space,
361: * probing first for a valid address, then checking for each of the
362: * valid bytelanes values at that address.
363: */
364: ofs = NBMEMSIZE;
365: lanes = 0xf;
366:
367: for (j = 8, found = 0; j > 0 && !found; j >>= 1) {
368: ofs--;
369: for (i = j; i > 0; i--, lanes--) {
370: if (!mac68k_bus_space_probe(bst, bsh, ofs, 1)) {
371: lanes -= i;
372: break;
373: }
374: if (bus_space_read_1(bst, bsh, ofs) ==
375: (((~lanes & 0xf) << 4) | lanes)) {
376: found = 1;
377: break;
378: }
379: }
380: }
381:
382: if (!found) {
383: #ifdef DEBUG
384: if (nubus_debug & NDB_PROBE)
385: printf("bytelanes not found for slot %x\n", slot);
386: #endif
387: return 0;
388: }
389:
390: fmt->bytelanes = lanes;
391: fmt->step = nbits[(lanes & 0x0f)];
392: fmt->slot = slot; /* XXX redundant; get rid of this someday */
393:
394: #ifdef DEBUG
395: if (nubus_debug & NDB_PROBE)
396: printf("bytelanes of 0x%x found for slot 0x%x.\n",
397: fmt->bytelanes, slot);
398: #endif
399:
400: /*
401: * Go ahead and attempt to load format header.
402: * First, we need to find the first byte beyond memory that
403: * would be valid. This is necessary for NUBUS_ROM_offset()
404: * to work.
405: */
406: hdr = NBMEMSIZE;
407: hdr_size = 20;
408:
409: i = 0x10 | (lanes & 0x0f);
410: while ((i & 1) == 0) {
411: hdr++;
412: i >>= 1;
413: }
414: fmt->top = hdr;
415: hdr = nubus_adjust_ptr(lanes, hdr, -hdr_size);
416: #ifdef DEBUG
417: if (nubus_debug & NDB_PROBE)
418: printf("fmt->top is 0x%lx, that minus 0x%x puts us at 0x%lx.\n",
419: fmt->top, hdr_size, hdr);
420: if (nubus_debug & NDB_ARITH)
421: for (i = 1 ; i < 8 ; i++)
422: printf("0x%lx - 0x%x = 0x%lx, + 0x%x = 0x%lx.\n",
423: hdr, i, nubus_adjust_ptr(lanes, hdr, -i),
424: i, nubus_adjust_ptr(lanes, hdr, i));
425: #endif
426:
427: fmt->directory_offset =
428: 0xff000000 | nubus_read_4(bst, bsh, lanes, hdr);
429: hdr = nubus_adjust_ptr(lanes, hdr, 4);
430: fmt->length = nubus_read_4(bst, bsh, lanes, hdr);
431: hdr = nubus_adjust_ptr(lanes, hdr, 4);
432: fmt->crc = nubus_read_4(bst, bsh, lanes, hdr);
433: hdr = nubus_adjust_ptr(lanes, hdr, 4);
434: fmt->revision_level = nubus_read_1(bst, bsh, lanes, hdr);
435: hdr = nubus_adjust_ptr(lanes, hdr, 1);
436: fmt->format = nubus_read_1(bst, bsh, lanes, hdr);
437: hdr = nubus_adjust_ptr(lanes, hdr, 1);
438: fmt->test_pattern = nubus_read_4(bst, bsh, lanes, hdr);
439:
440: #ifdef DEBUG
441: if (nubus_debug & NDB_PROBE) {
442: printf("Directory offset 0x%x\t", fmt->directory_offset);
443: printf("Length 0x%x\t", fmt->length);
444: printf("CRC 0x%x\n", fmt->crc);
445: printf("Revision level 0x%x\t", fmt->revision_level);
446: printf("Format 0x%x\t", fmt->format);
447: printf("Test Pattern 0x%x\n", fmt->test_pattern);
448: }
449: #endif
450:
451: if ((fmt->directory_offset & 0x00ff0000) == 0) {
452: printf("Invalid looking directory offset (0x%x)!\n",
453: fmt->directory_offset);
454: return 0;
455: }
456: if (fmt->test_pattern != NUBUS_ROM_TEST_PATTERN) {
457: printf("Nubus--test pattern invalid:\n");
458: printf(" slot 0x%x, bytelanes 0x%x?\n", fmt->slot, lanes);
459: printf(" read test 0x%x, compare with 0x%x.\n",
460: fmt->test_pattern, NUBUS_ROM_TEST_PATTERN);
461: return 0;
462: }
463:
464: /* Perform CRC */
465: if (fmt->crc != nubus_calc_CRC(bst, bsh, fmt)) {
466: printf("Nubus--crc check failed, slot 0x%x.\n", fmt->slot);
467: return 0;
468: }
469:
470: return 1;
471: }
472:
473: static u_int32_t
474: nubus_calc_CRC(bst, bsh, fmt)
475: bus_space_tag_t bst;
476: bus_space_handle_t bsh;
477: nubus_slot *fmt;
478: {
479: #if 0
480: u_long base, ptr, crc_loc;
481: u_int32_t sum;
482: u_int8_t lanes = fmt->bytelanes;
483:
484: base = fmt->top;
485: crc_loc = NUBUS_ROM_offset(fmt, base, -12);
486: ptr = NUBUS_ROM_offset(fmt, base, -fmt->length);
487:
488: sum = 0;
489: while (ptr < base)
490: roll #1, sum
491: if (ptr == crc_loc) {
492: roll #3, sum
493: ptr = nubus_adjust_ptr(lanes, ptr, 3);
494: } else {
495: sum += nubus_read_1(bst, bsh, lanes, ptr);
496: }
497: ptr = nubus_adjust_ptr(lanes, ptr, 1);
498: }
499:
500: return sum;
501: #endif
502: return fmt->crc;
503: }
504:
505: /*
506: * Compute byte offset on card, taking into account bytelanes.
507: * Base must be on a valid bytelane for this function to work.
508: * Return the new address.
509: *
510: * XXX -- There has GOT to be a better way to do this.
511: */
512: static u_long
513: nubus_adjust_ptr(lanes, base, amt)
514: u_int8_t lanes;
515: u_long base;
516: long amt;
517: {
518: u_int8_t b, t;
519:
520: if (!amt)
521: return base;
522:
523: if (amt < 0) {
524: amt = -amt;
525: b = lanes;
526: t = (b << 4);
527: b <<= (3 - (base & 0x3));
528: while (amt) {
529: b <<= 1;
530: if (b == t)
531: b = lanes;
532: if (b & 0x08)
533: amt--;
534: base--;
535: }
536: return base;
537: }
538:
539: t = (lanes & 0xf) | 0x10;
540: b = t >> (base & 0x3);
541: while (amt) {
542: b >>= 1;
543: if (b == 1)
544: b = t;
545: if (b & 1)
546: amt--;
547: base++;
548: }
549:
550: return base;
551: }
552:
553: static u_int8_t
554: nubus_read_1(bst, bsh, lanes, ofs)
555: bus_space_tag_t bst;
556: bus_space_handle_t bsh;
557: u_int8_t lanes;
558: u_long ofs;
559: {
560: return bus_space_read_1(bst, bsh, ofs);
561: }
562:
563: #ifdef notyet
564: /* Nothing uses this, yet */
565: static u_int16_t
566: nubus_read_2(bst, bsh, lanes, ofs)
567: bus_space_tag_t bst;
568: bus_space_handle_t bsh;
569: u_int8_t lanes;
570: u_long ofs;
571: {
572: u_int16_t s;
573:
574: s = (nubus_read_1(bst, bsh, lanes, ofs) << 8);
575: ofs = nubus_adjust_ptr(lanes, ofs, 1);
576: s |= nubus_read_1(bst, bsh, lanes, ofs);
577: return s;
578: }
579: #endif
580:
581: static u_int32_t
582: nubus_read_4(bst, bsh, lanes, ofs)
583: bus_space_tag_t bst;
584: bus_space_handle_t bsh;
585: u_int8_t lanes;
586: u_long ofs;
587: {
588: u_int32_t l;
589: int i;
590:
591: l = 0;
592: for (i = 0; i < 4; i++) {
593: l = (l << 8) | nubus_read_1(bst, bsh, lanes, ofs);
594: ofs = nubus_adjust_ptr(lanes, ofs, 1);
595: }
596: return l;
597: }
598:
599: void
600: nubus_get_main_dir(fmt, dir_return)
601: nubus_slot *fmt;
602: nubus_dir *dir_return;
603: {
604: #ifdef DEBUG
605: if (nubus_debug & NDB_FOLLOW)
606: printf("nubus_get_main_dir(%p, %p)\n",
607: fmt, dir_return);
608: #endif
609: dir_return->dirbase = nubus_adjust_ptr(fmt->bytelanes, fmt->top,
610: fmt->directory_offset - 20);
611: dir_return->curr_ent = dir_return->dirbase;
612: }
613:
614: void
615: nubus_get_dir_from_rsrc(fmt, dirent, dir_return)
616: nubus_slot *fmt;
617: nubus_dirent *dirent;
618: nubus_dir *dir_return;
619: {
620: u_long loc;
621:
622: #ifdef DEBUG
623: if (nubus_debug & NDB_FOLLOW)
624: printf("nubus_get_dir_from_rsrc(%p, %p, %p).\n",
625: fmt, dirent, dir_return);
626: #endif
627: if ((loc = dirent->offset) & 0x800000) {
628: loc |= 0xff000000;
629: }
630: dir_return->dirbase =
631: nubus_adjust_ptr(fmt->bytelanes, dirent->myloc, loc);
632: dir_return->curr_ent = dir_return->dirbase;
633: }
634:
635: int
636: nubus_find_rsrc(bst, bsh, fmt, dir, rsrcid, dirent_return)
637: bus_space_tag_t bst;
638: bus_space_handle_t bsh;
639: nubus_slot *fmt;
640: nubus_dir *dir;
641: u_int8_t rsrcid;
642: nubus_dirent *dirent_return;
643: {
644: u_long entry;
645: u_int8_t byte, lanes = fmt->bytelanes;
646:
647: #ifdef DEBUG
648: if (nubus_debug & NDB_FOLLOW)
649: printf("nubus_find_rsrc(%p, %p, 0x%x, %p)\n",
650: fmt, dir, rsrcid, dirent_return);
651: #endif
652: if (fmt->test_pattern != NUBUS_ROM_TEST_PATTERN)
653: return -1;
654:
655: entry = dir->curr_ent;
656: do {
657: byte = nubus_read_1(bst, bsh, lanes, entry);
658: #ifdef DEBUG
659: if (nubus_debug & NDB_FOLLOW)
660: printf("\tFound rsrc 0x%x.\n", byte);
661: #endif
662: if (byte == rsrcid) {
663: dirent_return->myloc = entry;
664: dirent_return->rsrc_id = rsrcid;
665: entry = nubus_read_4(bst, bsh, lanes, entry);
666: dirent_return->offset = (entry & 0x00ffffff);
667: return 1;
668: }
669: if (byte == 0xff) {
670: entry = dir->dirbase;
671: } else {
672: entry = nubus_adjust_ptr(lanes, entry, 4);
673: }
674: } while (entry != (u_long)dir->curr_ent);
675: return 0;
676: }
677:
678: int
679: nubus_get_ind_data(bst, bsh, fmt, dirent, data_return, nbytes)
680: bus_space_tag_t bst;
681: bus_space_handle_t bsh;
682: nubus_slot *fmt;
683: nubus_dirent *dirent;
684: caddr_t data_return;
685: int nbytes;
686: {
687: u_long loc;
688: u_int8_t lanes = fmt->bytelanes;
689:
690: #ifdef DEBUG
691: if (nubus_debug & NDB_FOLLOW)
692: printf("nubus_get_ind_data(%p, %p, %p, %d).\n",
693: fmt, dirent, data_return, nbytes);
694: #endif
695: if ((loc = dirent->offset) & 0x800000) {
696: loc |= 0xff000000;
697: }
698: loc = nubus_adjust_ptr(lanes, dirent->myloc, loc);
699:
700: while (nbytes--) {
701: *data_return++ = nubus_read_1(bst, bsh, lanes, loc);
702: loc = nubus_adjust_ptr(lanes, loc, 1);
703: }
704: return 1;
705: }
706:
707: int
708: nubus_get_c_string(bst, bsh, fmt, dirent, data_return, max_bytes)
709: bus_space_tag_t bst;
710: bus_space_handle_t bsh;
711: nubus_slot *fmt;
712: nubus_dirent *dirent;
713: caddr_t data_return;
714: int max_bytes;
715: {
716: u_long loc;
717: u_int8_t lanes = fmt->bytelanes;
718:
719: #ifdef DEBUG
720: if (nubus_debug & NDB_FOLLOW)
721: printf("nubus_get_c_string(%p, %p, %p, %d).\n",
722: fmt, dirent, data_return, max_bytes);
723: #endif
724: if ((loc = dirent->offset) & 0x800000)
725: loc |= 0xff000000;
726:
727: loc = nubus_adjust_ptr(lanes, dirent->myloc, loc);
728:
729: *data_return = '\0';
730: while (max_bytes--) {
731: if ((*data_return++ =
732: nubus_read_1(bst, bsh, lanes, loc)) == 0)
733: return 1;
734: loc = nubus_adjust_ptr(lanes, loc, 1);
735: }
736: *(data_return-1) = '\0';
737: return 0;
738: }
739:
740: /*
741: * Get list of address ranges for an sMemory resource
742: * -> DC&D, p.171
743: */
744: int
745: nubus_get_smem_addr_rangelist(bst, bsh, fmt, dirent, data_return)
746: bus_space_tag_t bst;
747: bus_space_handle_t bsh;
748: nubus_slot *fmt;
749: nubus_dirent *dirent;
750: caddr_t data_return;
751: {
752: u_long loc;
753: u_int8_t lanes = fmt->bytelanes;
754: long blocklen;
755: caddr_t blocklist;
756:
757: #ifdef DEBUG
758: if (nubus_debug & NDB_FOLLOW)
759: printf("nubus_get_smem_addr_rangelist(%p, %p, %p).\n",
760: fmt, dirent, data_return);
761: #endif
762: if ((loc = dirent->offset) & 0x800000) {
763: loc |= 0xff000000;
764: }
765: loc = nubus_adjust_ptr(lanes, dirent->myloc, loc);
766:
767: /* Obtain the block length from the head of the list */
768: blocklen = nubus_read_4(bst, bsh, lanes, loc);
769:
770: /*
771: * malloc a block of (blocklen) bytes
772: * caller must recycle block after use
773: */
774: MALLOC(blocklist,caddr_t,blocklen,M_TEMP,M_WAITOK);
775:
776: /* read ((blocklen - 4) / 8) (length,offset) pairs into block */
777: nubus_get_ind_data(bst, bsh, fmt, dirent, blocklist, blocklen);
778: #ifdef DEBUG
779: if (nubus_debug & NDB_FOLLOW) {
780: int ii;
781: nubus_smem_rangelist *rlist;
782:
783: rlist = (nubus_smem_rangelist *)blocklist;
784: printf("\tblock@%p, len 0x0%X\n", rlist, rlist->length);
785:
786: for (ii=0; ii < ((blocklen - 4) / 8); ii++) {
787: printf("\tRange %d: base addr 0x%X [0x%X]\n", ii,
788: rlist->range[ii].offset, rlist->range[ii].length);
789: }
790: }
791: #endif
792: *(caddr_t *)data_return = blocklist;
793:
794: return 1;
795: }
796:
797: static char *huh = "???";
798:
799: char *
800: nubus_get_vendor(bst, bsh, fmt, rsrc)
801: bus_space_tag_t bst;
802: bus_space_handle_t bsh;
803: nubus_slot *fmt;
804: int rsrc;
805: {
806: static char str_ret[64];
807: nubus_dir dir;
808: nubus_dirent ent;
809:
810: #ifdef DEBUG
811: if (nubus_debug & NDB_FOLLOW)
812: printf("nubus_get_vendor(%p, 0x%x).\n", fmt, rsrc);
813: #endif
814: nubus_get_main_dir(fmt, &dir);
815: if (nubus_find_rsrc(bst, bsh, fmt, &dir, 1, &ent) <= 0)
816: return huh;
817: nubus_get_dir_from_rsrc(fmt, &ent, &dir);
818:
819: if (nubus_find_rsrc(bst, bsh, fmt, &dir, NUBUS_RSRC_VENDORINFO, &ent)
820: <= 0)
821: return huh;
822: nubus_get_dir_from_rsrc(fmt, &ent, &dir);
823:
824: if (nubus_find_rsrc(bst, bsh, fmt, &dir, rsrc, &ent) <= 0)
825: return huh;
826:
827: nubus_get_c_string(bst, bsh, fmt, &ent, str_ret, 64);
828:
829: return str_ret;
830: }
831:
832: char *
833: nubus_get_card_name(bst, bsh, fmt)
834: bus_space_tag_t bst;
835: bus_space_handle_t bsh;
836: nubus_slot *fmt;
837: {
838: static char name_ret[64];
839: nubus_dir dir;
840: nubus_dirent ent;
841:
842: #ifdef DEBUG
843: if (nubus_debug & NDB_FOLLOW)
844: printf("nubus_get_card_name(%p).\n", fmt);
845: #endif
846: nubus_get_main_dir(fmt, &dir);
847:
848: if (nubus_find_rsrc(bst, bsh, fmt, &dir, 1, &ent) <= 0)
849: return huh;
850:
851: nubus_get_dir_from_rsrc(fmt, &ent, &dir);
852:
853: if (nubus_find_rsrc(bst, bsh, fmt, &dir, NUBUS_RSRC_NAME, &ent) <= 0)
854: return huh;
855:
856: nubus_get_c_string(bst, bsh, fmt, &ent, name_ret, 64);
857:
858: return name_ret;
859: }
860:
861: #ifdef DEBUG
862: void
863: nubus_scan_slot(bst, slotno)
864: bus_space_tag_t bst;
865: int slotno;
866: {
867: int i=0, state=0;
868: char twirl[] = "-\\|/";
869: bus_space_handle_t sc_bsh;
870:
871: if (bus_space_map(bst, NUBUS_SLOT2PA(slotno), NBMEMSIZE, 0, &sc_bsh)) {
872: printf("nubus_scan_slot: failed to map slot %x\n", slotno);
873: return;
874: }
875:
876: printf("Scanning slot %c for accessible regions:\n",
877: slotno == 9 ? '9' : slotno - 10 + 'A');
878: for (i=0 ; i<NBMEMSIZE; i++) {
879: if (mac68k_bus_space_probe(bst, sc_bsh, i, 1)) {
880: if (state == 0) {
881: printf("\t0x%x-", i);
882: state = 1;
883: }
884: } else {
885: if (state) {
886: printf("0x%x\n", i);
887: state = 0;
888: }
889: }
890: if (i%100 == 0) {
891: printf("%c\b", twirl[(i/100)%4]);
892: }
893: }
894: if (state) {
895: printf("0x%x\n", i);
896: }
897: return;
898: }
899: #endif