ia64/linux-2.6.18-xen.hg

view drivers/nubus/nubus.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 * Macintosh Nubus Interface Code
3 *
4 * Originally by Alan Cox
5 *
6 * Mostly rewritten by David Huggins-Daines, C. Scott Ananian,
7 * and others.
8 */
10 #include <linux/types.h>
11 #include <linux/kernel.h>
12 #include <linux/string.h>
13 #include <linux/nubus.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <asm/setup.h>
18 #include <asm/system.h>
19 #include <asm/page.h>
20 #include <asm/hwtest.h>
21 #include <linux/proc_fs.h>
22 #include <asm/mac_via.h>
23 #include <asm/mac_oss.h>
25 extern void via_nubus_init(void);
26 extern void oss_nubus_init(void);
28 /* Constants */
30 /* This is, of course, the size in bytelanes, rather than the size in
31 actual bytes */
32 #define FORMAT_BLOCK_SIZE 20
33 #define ROM_DIR_OFFSET 0x24
35 #define NUBUS_TEST_PATTERN 0x5A932BC7
37 /* Define this if you like to live dangerously - it is known not to
38 work on pretty much every machine except the Quadra 630 and the LC
39 III. */
40 #undef I_WANT_TO_PROBE_SLOT_ZERO
42 /* This sometimes helps combat failure to boot */
43 #undef TRY_TO_DODGE_WSOD
45 /* Globals */
47 struct nubus_dev* nubus_devices;
48 struct nubus_board* nubus_boards;
50 /* Meaning of "bytelanes":
52 The card ROM may appear on any or all bytes of each long word in
53 NuBus memory. The low 4 bits of the "map" value found in the
54 format block (at the top of the slot address space, as well as at
55 the top of the MacOS ROM) tells us which bytelanes, i.e. which byte
56 offsets within each longword, are valid. Thus:
58 A map of 0x0f, as found in the MacOS ROM, means that all bytelanes
59 are valid.
61 A map of 0xf0 means that no bytelanes are valid (We pray that we
62 will never encounter this, but stranger things have happened)
64 A map of 0xe1 means that only the MSB of each long word is actually
65 part of the card ROM. (We hope to never encounter NuBus on a
66 little-endian machine. Again, stranger things have happened)
68 A map of 0x78 means that only the LSB of each long word is valid.
70 Etcetera, etcetera. Hopefully this clears up some confusion over
71 what the following code actually does. */
73 static inline int not_useful(void *p, int map)
74 {
75 unsigned long pv=(unsigned long)p;
76 pv &= 3;
77 if(map & (1<<pv))
78 return 0;
79 return 1;
80 }
82 static unsigned long nubus_get_rom(unsigned char **ptr, int len, int map)
83 {
84 /* This will hold the result */
85 unsigned long v = 0;
86 unsigned char *p = *ptr;
88 while(len)
89 {
90 v <<= 8;
91 while(not_useful(p,map))
92 p++;
93 v |= *p++;
94 len--;
95 }
96 *ptr = p;
97 return v;
98 }
100 static void nubus_rewind(unsigned char **ptr, int len, int map)
101 {
102 unsigned char *p=*ptr;
104 /* Sanity check */
105 if(len > 65536)
106 printk(KERN_ERR "rewind of 0x%08x!\n", len);
107 while(len)
108 {
109 do
110 {
111 p--;
112 }
113 while(not_useful(p, map));
114 len--;
115 }
116 *ptr=p;
117 }
119 static void nubus_advance(unsigned char **ptr, int len, int map)
120 {
121 unsigned char *p = *ptr;
122 if(len>65536)
123 printk(KERN_ERR "advance of 0x%08x!\n", len);
124 while(len)
125 {
126 while(not_useful(p,map))
127 p++;
128 p++;
129 len--;
130 }
131 *ptr = p;
132 }
134 static void nubus_move(unsigned char **ptr, int len, int map)
135 {
136 if(len > 0)
137 nubus_advance(ptr, len, map);
138 else if(len < 0)
139 nubus_rewind(ptr, -len, map);
140 }
142 /* Now, functions to read the sResource tree */
144 /* Each sResource entry consists of a 1-byte ID and a 3-byte data
145 field. If that data field contains an offset, then obviously we
146 have to expand it from a 24-bit signed number to a 32-bit signed
147 number. */
149 static inline long nubus_expand32(long foo)
150 {
151 if(foo & 0x00800000) /* 24bit negative */
152 foo |= 0xFF000000;
153 return foo;
154 }
156 static inline void *nubus_rom_addr(int slot)
157 {
158 /*
159 * Returns the first byte after the card. We then walk
160 * backwards to get the lane register and the config
161 */
162 return (void *)(0xF1000000+(slot<<24));
163 }
165 static unsigned char *nubus_dirptr(const struct nubus_dirent *nd)
166 {
167 unsigned char *p = nd->base;
168 /* Essentially, just step over the bytelanes using whatever
169 offset we might have found */
170 nubus_move(&p, nubus_expand32(nd->data), nd->mask);
171 /* And return the value */
172 return p;
173 }
175 /* These two are for pulling resource data blocks (i.e. stuff that's
176 pointed to with offsets) out of the card ROM. */
178 void nubus_get_rsrc_mem(void *dest, const struct nubus_dirent* dirent,
179 int len)
180 {
181 unsigned char *t = (unsigned char *)dest;
182 unsigned char *p = nubus_dirptr(dirent);
183 while(len)
184 {
185 *t++ = nubus_get_rom(&p, 1, dirent->mask);
186 len--;
187 }
188 }
190 void nubus_get_rsrc_str(void *dest, const struct nubus_dirent* dirent,
191 int len)
192 {
193 unsigned char *t=(unsigned char *)dest;
194 unsigned char *p = nubus_dirptr(dirent);
195 while(len)
196 {
197 *t = nubus_get_rom(&p, 1, dirent->mask);
198 if(!*t++)
199 break;
200 len--;
201 }
202 }
204 int nubus_get_root_dir(const struct nubus_board* board,
205 struct nubus_dir* dir)
206 {
207 dir->ptr = dir->base = board->directory;
208 dir->done = 0;
209 dir->mask = board->lanes;
210 return 0;
211 }
213 /* This is a slyly renamed version of the above */
214 int nubus_get_func_dir(const struct nubus_dev* dev,
215 struct nubus_dir* dir)
216 {
217 dir->ptr = dir->base = dev->directory;
218 dir->done = 0;
219 dir->mask = dev->board->lanes;
220 return 0;
221 }
223 int nubus_get_board_dir(const struct nubus_board* board,
224 struct nubus_dir* dir)
225 {
226 struct nubus_dirent ent;
228 dir->ptr = dir->base = board->directory;
229 dir->done = 0;
230 dir->mask = board->lanes;
232 /* Now dereference it (the first directory is always the board
233 directory) */
234 if (nubus_readdir(dir, &ent) == -1)
235 return -1;
236 if (nubus_get_subdir(&ent, dir) == -1)
237 return -1;
238 return 0;
239 }
241 int nubus_get_subdir(const struct nubus_dirent *ent,
242 struct nubus_dir *dir)
243 {
244 dir->ptr = dir->base = nubus_dirptr(ent);
245 dir->done = 0;
246 dir->mask = ent->mask;
247 return 0;
248 }
250 int nubus_readdir(struct nubus_dir *nd, struct nubus_dirent *ent)
251 {
252 u32 resid;
253 if (nd->done)
254 return -1;
256 /* Do this first, otherwise nubus_rewind & co are off by 4 */
257 ent->base = nd->ptr;
259 /* This moves nd->ptr forward */
260 resid = nubus_get_rom(&nd->ptr, 4, nd->mask);
262 /* EOL marker, as per the Apple docs */
263 if((resid&0xff000000) == 0xff000000)
264 {
265 /* Mark it as done */
266 nd->done = 1;
267 return -1;
268 }
270 /* First byte is the resource ID */
271 ent->type = resid >> 24;
272 /* Low 3 bytes might contain data (or might not) */
273 ent->data = resid & 0xffffff;
274 ent->mask = nd->mask;
275 return 0;
276 }
278 int nubus_rewinddir(struct nubus_dir* dir)
279 {
280 dir->ptr = dir->base;
281 return 0;
282 }
284 /* Driver interface functions, more or less like in pci.c */
286 struct nubus_dev*
287 nubus_find_device(unsigned short category,
288 unsigned short type,
289 unsigned short dr_hw,
290 unsigned short dr_sw,
291 const struct nubus_dev* from)
292 {
293 struct nubus_dev* itor =
294 from ? from->next : nubus_devices;
296 while (itor) {
297 if (itor->category == category
298 && itor->type == type
299 && itor->dr_hw == dr_hw
300 && itor->dr_sw == dr_sw)
301 return itor;
302 itor = itor->next;
303 }
304 return NULL;
305 }
307 struct nubus_dev*
308 nubus_find_type(unsigned short category,
309 unsigned short type,
310 const struct nubus_dev* from)
311 {
312 struct nubus_dev* itor =
313 from ? from->next : nubus_devices;
315 while (itor) {
316 if (itor->category == category
317 && itor->type == type)
318 return itor;
319 itor = itor->next;
320 }
321 return NULL;
322 }
324 struct nubus_dev*
325 nubus_find_slot(unsigned int slot,
326 const struct nubus_dev* from)
327 {
328 struct nubus_dev* itor =
329 from ? from->next : nubus_devices;
331 while (itor) {
332 if (itor->board->slot == slot)
333 return itor;
334 itor = itor->next;
335 }
336 return NULL;
337 }
339 int
340 nubus_find_rsrc(struct nubus_dir* dir, unsigned char rsrc_type,
341 struct nubus_dirent* ent)
342 {
343 while (nubus_readdir(dir, ent) != -1) {
344 if (ent->type == rsrc_type)
345 return 0;
346 }
347 return -1;
348 }
350 /* Initialization functions - decide which slots contain stuff worth
351 looking at, and print out lots and lots of information from the
352 resource blocks. */
354 /* FIXME: A lot of this stuff will eventually be useful after
355 initializaton, for intelligently probing Ethernet and video chips,
356 among other things. The rest of it should go in the /proc code.
357 For now, we just use it to give verbose boot logs. */
359 static int __init nubus_show_display_resource(struct nubus_dev* dev,
360 const struct nubus_dirent* ent)
361 {
362 switch (ent->type) {
363 case NUBUS_RESID_GAMMADIR:
364 printk(KERN_INFO " gamma directory offset: 0x%06x\n", ent->data);
365 break;
366 case 0x0080 ... 0x0085:
367 printk(KERN_INFO " mode %02X info offset: 0x%06x\n",
368 ent->type, ent->data);
369 break;
370 default:
371 printk(KERN_INFO " unknown resource %02X, data 0x%06x\n",
372 ent->type, ent->data);
373 }
374 return 0;
375 }
377 static int __init nubus_show_network_resource(struct nubus_dev* dev,
378 const struct nubus_dirent* ent)
379 {
380 switch (ent->type) {
381 case NUBUS_RESID_MAC_ADDRESS:
382 {
383 char addr[6];
384 int i;
386 nubus_get_rsrc_mem(addr, ent, 6);
387 printk(KERN_INFO " MAC address: ");
388 for (i = 0; i < 6; i++)
389 printk("%02x%s", addr[i] & 0xff,
390 i == 5 ? "" : ":");
391 printk("\n");
392 break;
393 }
394 default:
395 printk(KERN_INFO " unknown resource %02X, data 0x%06x\n",
396 ent->type, ent->data);
397 }
398 return 0;
399 }
401 static int __init nubus_show_cpu_resource(struct nubus_dev* dev,
402 const struct nubus_dirent* ent)
403 {
404 switch (ent->type) {
405 case NUBUS_RESID_MEMINFO:
406 {
407 unsigned long meminfo[2];
408 nubus_get_rsrc_mem(&meminfo, ent, 8);
409 printk(KERN_INFO " memory: [ 0x%08lx 0x%08lx ]\n",
410 meminfo[0], meminfo[1]);
411 break;
412 }
413 case NUBUS_RESID_ROMINFO:
414 {
415 unsigned long rominfo[2];
416 nubus_get_rsrc_mem(&rominfo, ent, 8);
417 printk(KERN_INFO " ROM: [ 0x%08lx 0x%08lx ]\n",
418 rominfo[0], rominfo[1]);
419 break;
420 }
421 default:
422 printk(KERN_INFO " unknown resource %02X, data 0x%06x\n",
423 ent->type, ent->data);
424 }
425 return 0;
426 }
428 static int __init nubus_show_private_resource(struct nubus_dev* dev,
429 const struct nubus_dirent* ent)
430 {
431 switch (dev->category) {
432 case NUBUS_CAT_DISPLAY:
433 nubus_show_display_resource(dev, ent);
434 break;
435 case NUBUS_CAT_NETWORK:
436 nubus_show_network_resource(dev, ent);
437 break;
438 case NUBUS_CAT_CPU:
439 nubus_show_cpu_resource(dev, ent);
440 break;
441 default:
442 printk(KERN_INFO " unknown resource %02X, data 0x%06x\n",
443 ent->type, ent->data);
444 }
445 return 0;
446 }
448 static struct nubus_dev* __init
449 nubus_get_functional_resource(struct nubus_board* board,
450 int slot,
451 const struct nubus_dirent* parent)
452 {
453 struct nubus_dir dir;
454 struct nubus_dirent ent;
455 struct nubus_dev* dev;
457 printk(KERN_INFO " Function 0x%02x:\n", parent->type);
458 nubus_get_subdir(parent, &dir);
460 /* Apple seems to have botched the ROM on the IIx */
461 if (slot == 0 && (unsigned long)dir.base % 2)
462 dir.base += 1;
464 if (console_loglevel >= 10)
465 printk(KERN_DEBUG "nubus_get_functional_resource: parent is 0x%p, dir is 0x%p\n",
466 parent->base, dir.base);
468 /* Actually we should probably panic if this fails */
469 if ((dev = kmalloc(sizeof(*dev), GFP_ATOMIC)) == NULL)
470 return NULL;
471 memset(dev, 0, sizeof(*dev));
472 dev->resid = parent->type;
473 dev->directory = dir.base;
474 dev->board = board;
476 while (nubus_readdir(&dir, &ent) != -1)
477 {
478 switch(ent.type)
479 {
480 case NUBUS_RESID_TYPE:
481 {
482 unsigned short nbtdata[4];
483 nubus_get_rsrc_mem(nbtdata, &ent, 8);
484 dev->category = nbtdata[0];
485 dev->type = nbtdata[1];
486 dev->dr_sw = nbtdata[2];
487 dev->dr_hw = nbtdata[3];
488 printk(KERN_INFO " type: [cat 0x%x type 0x%x hw 0x%x sw 0x%x]\n",
489 nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[3]);
490 break;
491 }
492 case NUBUS_RESID_NAME:
493 {
494 nubus_get_rsrc_str(dev->name, &ent, 64);
495 printk(KERN_INFO " name: %s\n", dev->name);
496 break;
497 }
498 case NUBUS_RESID_DRVRDIR:
499 {
500 /* MacOS driver. If we were NetBSD we might
501 use this :-) */
502 struct nubus_dir drvr_dir;
503 struct nubus_dirent drvr_ent;
504 nubus_get_subdir(&ent, &drvr_dir);
505 nubus_readdir(&drvr_dir, &drvr_ent);
506 dev->driver = nubus_dirptr(&drvr_ent);
507 printk(KERN_INFO " driver at: 0x%p\n",
508 dev->driver);
509 break;
510 }
511 case NUBUS_RESID_MINOR_BASEOS:
512 /* We will need this in order to support
513 multiple framebuffers. It might be handy
514 for Ethernet as well */
515 nubus_get_rsrc_mem(&dev->iobase, &ent, 4);
516 printk(KERN_INFO " memory offset: 0x%08lx\n",
517 dev->iobase);
518 break;
519 case NUBUS_RESID_MINOR_LENGTH:
520 /* Ditto */
521 nubus_get_rsrc_mem(&dev->iosize, &ent, 4);
522 printk(KERN_INFO " memory length: 0x%08lx\n",
523 dev->iosize);
524 break;
525 case NUBUS_RESID_FLAGS:
526 dev->flags = ent.data;
527 printk(KERN_INFO " flags: 0x%06x\n", dev->flags);
528 break;
529 case NUBUS_RESID_HWDEVID:
530 dev->hwdevid = ent.data;
531 printk(KERN_INFO " hwdevid: 0x%06x\n", dev->hwdevid);
532 break;
533 default:
534 /* Local/Private resources have their own
535 function */
536 nubus_show_private_resource(dev, &ent);
537 }
538 }
540 return dev;
541 }
543 /* This is cool. */
544 static int __init nubus_get_vidnames(struct nubus_board* board,
545 const struct nubus_dirent* parent)
546 {
547 struct nubus_dir dir;
548 struct nubus_dirent ent;
549 /* FIXME: obviously we want to put this in a header file soon */
550 struct vidmode {
551 u32 size;
552 /* Don't know what this is yet */
553 u16 id;
554 /* Longest one I've seen so far is 26 characters */
555 char name[32];
556 };
558 printk(KERN_INFO " video modes supported:\n");
559 nubus_get_subdir(parent, &dir);
560 if (console_loglevel >= 10)
561 printk(KERN_DEBUG "nubus_get_vidnames: parent is 0x%p, dir is 0x%p\n",
562 parent->base, dir.base);
564 while(nubus_readdir(&dir, &ent) != -1)
565 {
566 struct vidmode mode;
567 u32 size;
569 /* First get the length */
570 nubus_get_rsrc_mem(&size, &ent, 4);
572 /* Now clobber the whole thing */
573 if (size > sizeof(mode) - 1)
574 size = sizeof(mode) - 1;
575 memset(&mode, 0, sizeof(mode));
576 nubus_get_rsrc_mem(&mode, &ent, size);
577 printk (KERN_INFO " %02X: (%02X) %s\n", ent.type,
578 mode.id, mode.name);
579 }
580 return 0;
581 }
583 /* This is *really* cool. */
584 static int __init nubus_get_icon(struct nubus_board* board,
585 const struct nubus_dirent* ent)
586 {
587 /* Should be 32x32 if my memory serves me correctly */
588 unsigned char icon[128];
589 int x, y;
591 nubus_get_rsrc_mem(&icon, ent, 128);
592 printk(KERN_INFO " icon:\n");
594 /* We should actually plot these somewhere in the framebuffer
595 init. This is just to demonstrate that they do, in fact,
596 exist */
597 for (y = 0; y < 32; y++) {
598 printk(KERN_INFO " ");
599 for (x = 0; x < 32; x++) {
600 if (icon[y*4 + x/8]
601 & (0x80 >> (x%8)))
602 printk("*");
603 else
604 printk(" ");
605 }
606 printk("\n");
607 }
608 return 0;
609 }
611 static int __init nubus_get_vendorinfo(struct nubus_board* board,
612 const struct nubus_dirent* parent)
613 {
614 struct nubus_dir dir;
615 struct nubus_dirent ent;
616 static char* vendor_fields[6] = {"ID", "serial", "revision",
617 "part", "date", "unknown field"};
619 printk(KERN_INFO " vendor info:\n");
620 nubus_get_subdir(parent, &dir);
621 if (console_loglevel >= 10)
622 printk(KERN_DEBUG "nubus_get_vendorinfo: parent is 0x%p, dir is 0x%p\n",
623 parent->base, dir.base);
625 while(nubus_readdir(&dir, &ent) != -1)
626 {
627 char name[64];
629 /* These are all strings, we think */
630 nubus_get_rsrc_str(name, &ent, 64);
631 if (ent.type > 5)
632 ent.type = 5;
633 printk(KERN_INFO " %s: %s\n",
634 vendor_fields[ent.type-1], name);
635 }
636 return 0;
637 }
639 static int __init nubus_get_board_resource(struct nubus_board* board, int slot,
640 const struct nubus_dirent* parent)
641 {
642 struct nubus_dir dir;
643 struct nubus_dirent ent;
645 nubus_get_subdir(parent, &dir);
646 if (console_loglevel >= 10)
647 printk(KERN_DEBUG "nubus_get_board_resource: parent is 0x%p, dir is 0x%p\n",
648 parent->base, dir.base);
650 while(nubus_readdir(&dir, &ent) != -1)
651 {
652 switch (ent.type) {
653 case NUBUS_RESID_TYPE:
654 {
655 unsigned short nbtdata[4];
656 /* This type is always the same, and is not
657 useful except insofar as it tells us that
658 we really are looking at a board resource. */
659 nubus_get_rsrc_mem(nbtdata, &ent, 8);
660 printk(KERN_INFO " type: [cat 0x%x type 0x%x hw 0x%x sw 0x%x]\n",
661 nbtdata[0], nbtdata[1], nbtdata[2],
662 nbtdata[3]);
663 if (nbtdata[0] != 1 || nbtdata[1] != 0 ||
664 nbtdata[2] != 0 || nbtdata[3] != 0)
665 printk(KERN_ERR "this sResource is not a board resource!\n");
666 break;
667 }
668 case NUBUS_RESID_NAME:
669 nubus_get_rsrc_str(board->name, &ent, 64);
670 printk(KERN_INFO " name: %s\n", board->name);
671 break;
672 case NUBUS_RESID_ICON:
673 nubus_get_icon(board, &ent);
674 break;
675 case NUBUS_RESID_BOARDID:
676 printk(KERN_INFO " board id: 0x%x\n", ent.data);
677 break;
678 case NUBUS_RESID_PRIMARYINIT:
679 printk(KERN_INFO " primary init offset: 0x%06x\n", ent.data);
680 break;
681 case NUBUS_RESID_VENDORINFO:
682 nubus_get_vendorinfo(board, &ent);
683 break;
684 case NUBUS_RESID_FLAGS:
685 printk(KERN_INFO " flags: 0x%06x\n", ent.data);
686 break;
687 case NUBUS_RESID_HWDEVID:
688 printk(KERN_INFO " hwdevid: 0x%06x\n", ent.data);
689 break;
690 case NUBUS_RESID_SECONDINIT:
691 printk(KERN_INFO " secondary init offset: 0x%06x\n", ent.data);
692 break;
693 /* WTF isn't this in the functional resources? */
694 case NUBUS_RESID_VIDNAMES:
695 nubus_get_vidnames(board, &ent);
696 break;
697 /* Same goes for this */
698 case NUBUS_RESID_VIDMODES:
699 printk(KERN_INFO " video mode parameter directory offset: 0x%06x\n",
700 ent.data);
701 break;
702 default:
703 printk(KERN_INFO " unknown resource %02X, data 0x%06x\n",
704 ent.type, ent.data);
705 }
706 }
707 return 0;
708 }
710 /* Attempt to bypass the somewhat non-obvious arrangement of
711 sResources in the motherboard ROM */
712 static void __init nubus_find_rom_dir(struct nubus_board* board)
713 {
714 unsigned char* rp;
715 unsigned char* romdir;
716 struct nubus_dir dir;
717 struct nubus_dirent ent;
719 /* Check for the extra directory just under the format block */
720 rp = board->fblock;
721 nubus_rewind(&rp, 4, board->lanes);
722 if (nubus_get_rom(&rp, 4, board->lanes) != NUBUS_TEST_PATTERN) {
723 /* OK, the ROM was telling the truth */
724 board->directory = board->fblock;
725 nubus_move(&board->directory,
726 nubus_expand32(board->doffset),
727 board->lanes);
728 return;
729 }
731 /* On "slot zero", you have to walk down a few more
732 directories to get to the equivalent of a real card's root
733 directory. We don't know what they were smoking when they
734 came up with this. */
735 romdir = nubus_rom_addr(board->slot);
736 nubus_rewind(&romdir, ROM_DIR_OFFSET, board->lanes);
737 dir.base = dir.ptr = romdir;
738 dir.done = 0;
739 dir.mask = board->lanes;
741 /* This one points to an "Unknown Macintosh" directory */
742 if (nubus_readdir(&dir, &ent) == -1)
743 goto badrom;
745 if (console_loglevel >= 10)
746 printk(KERN_INFO "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
747 /* This one takes us to where we want to go. */
748 if (nubus_readdir(&dir, &ent) == -1)
749 goto badrom;
750 if (console_loglevel >= 10)
751 printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
752 nubus_get_subdir(&ent, &dir);
754 /* Resource ID 01, also an "Unknown Macintosh" */
755 if (nubus_readdir(&dir, &ent) == -1)
756 goto badrom;
757 if (console_loglevel >= 10)
758 printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
760 /* FIXME: the first one is *not* always the right one. We
761 suspect this has something to do with the ROM revision.
762 "The HORROR ROM" (LC-series) uses 0x7e, while "The HORROR
763 Continues" (Q630) uses 0x7b. The DAFB Macs evidently use
764 something else. Please run "Slots" on your Mac (see
765 include/linux/nubus.h for where to get this program) and
766 tell us where the 'SiDirPtr' for Slot 0 is. If you feel
767 brave, you should also use MacsBug to walk down the ROM
768 directories like this function does and try to find the
769 path to that address... */
770 if (nubus_readdir(&dir, &ent) == -1)
771 goto badrom;
772 if (console_loglevel >= 10)
773 printk(KERN_DEBUG "nubus_get_rom_dir: entry %02x %06x\n", ent.type, ent.data);
775 /* Bwahahahaha... */
776 nubus_get_subdir(&ent, &dir);
777 board->directory = dir.base;
778 return;
780 /* Even more evil laughter... */
781 badrom:
782 board->directory = board->fblock;
783 nubus_move(&board->directory, nubus_expand32(board->doffset), board->lanes);
784 printk(KERN_ERR "nubus_get_rom_dir: ROM weirdness! Notify the developers...\n");
785 }
787 /* Add a board (might be many devices) to the list */
788 static struct nubus_board* __init nubus_add_board(int slot, int bytelanes)
789 {
790 struct nubus_board* board;
791 struct nubus_board** boardp;
793 unsigned char *rp;
794 unsigned long dpat;
795 struct nubus_dir dir;
796 struct nubus_dirent ent;
798 /* Move to the start of the format block */
799 rp = nubus_rom_addr(slot);
800 nubus_rewind(&rp, FORMAT_BLOCK_SIZE, bytelanes);
802 /* Actually we should probably panic if this fails */
803 if ((board = kmalloc(sizeof(*board), GFP_ATOMIC)) == NULL)
804 return NULL;
805 memset(board, 0, sizeof(*board));
806 board->fblock = rp;
808 /* Dump the format block for debugging purposes */
809 if (console_loglevel >= 10) {
810 int i;
811 printk(KERN_DEBUG "Slot %X, format block at 0x%p\n",
812 slot, rp);
813 printk(KERN_DEBUG "Format block: ");
814 for (i = 0; i < FORMAT_BLOCK_SIZE; i += 4) {
815 unsigned short foo, bar;
816 foo = nubus_get_rom(&rp, 2, bytelanes);
817 bar = nubus_get_rom(&rp, 2, bytelanes);
818 printk("%04x %04x ", foo, bar);
819 }
820 printk("\n");
821 rp = board->fblock;
822 }
824 board->slot = slot;
825 board->slot_addr = (unsigned long) nubus_slot_addr(slot);
826 board->doffset = nubus_get_rom(&rp, 4, bytelanes);
827 /* rom_length is *supposed* to be the total length of the
828 * ROM. In practice it is the "amount of ROM used to compute
829 * the CRC." So some jokers decide to set it to zero and
830 * set the crc to zero so they don't have to do any math.
831 * See the Performa 460 ROM, for example. Those Apple "engineers".
832 */
833 board->rom_length = nubus_get_rom(&rp, 4, bytelanes);
834 board->crc = nubus_get_rom(&rp, 4, bytelanes);
835 board->rev = nubus_get_rom(&rp, 1, bytelanes);
836 board->format = nubus_get_rom(&rp,1, bytelanes);
837 board->lanes = bytelanes;
839 /* Directory offset should be small and negative... */
840 if(!(board->doffset & 0x00FF0000))
841 printk(KERN_WARNING "Dodgy doffset!\n");
842 dpat = nubus_get_rom(&rp, 4, bytelanes);
843 if(dpat != NUBUS_TEST_PATTERN)
844 printk(KERN_WARNING "Wrong test pattern %08lx!\n", dpat);
846 /*
847 * I wonder how the CRC is meant to work -
848 * any takers ?
849 * CSA: According to MAC docs, not all cards pass the CRC anyway,
850 * since the initial Macintosh ROM releases skipped the check.
851 */
853 /* Attempt to work around slot zero weirdness */
854 nubus_find_rom_dir(board);
855 nubus_get_root_dir(board, &dir);
857 /* We're ready to rock */
858 printk(KERN_INFO "Slot %X:\n", slot);
860 /* Each slot should have one board resource and any number of
861 functional resources. So we'll fill in some fields in the
862 struct nubus_board from the board resource, then walk down
863 the list of functional resources, spinning out a nubus_dev
864 for each of them. */
865 if (nubus_readdir(&dir, &ent) == -1) {
866 /* We can't have this! */
867 printk(KERN_ERR "Board resource not found!\n");
868 return NULL;
869 } else {
870 printk(KERN_INFO " Board resource:\n");
871 nubus_get_board_resource(board, slot, &ent);
872 }
874 /* Aaaarrrrgghh! The LC III motherboard has *two* board
875 resources. I have no idea WTF to do about this. */
877 while (nubus_readdir(&dir, &ent) != -1) {
878 struct nubus_dev* dev;
879 struct nubus_dev** devp;
880 dev = nubus_get_functional_resource(board, slot, &ent);
881 if (dev == NULL)
882 continue;
884 /* We zeroed this out above */
885 if (board->first_dev == NULL)
886 board->first_dev = dev;
888 /* Put it on the global NuBus device chain. Keep entries in order. */
889 for (devp=&nubus_devices; *devp!=NULL; devp=&((*devp)->next))
890 /* spin */;
891 *devp = dev;
892 dev->next = NULL;
893 }
895 /* Put it on the global NuBus board chain. Keep entries in order. */
896 for (boardp=&nubus_boards; *boardp!=NULL; boardp=&((*boardp)->next))
897 /* spin */;
898 *boardp = board;
899 board->next = NULL;
901 return board;
902 }
904 void __init nubus_probe_slot(int slot)
905 {
906 unsigned char dp;
907 unsigned char* rp;
908 int i;
910 rp = nubus_rom_addr(slot);
911 for(i = 4; i; i--)
912 {
913 unsigned long flags;
914 int card_present;
916 rp--;
917 local_irq_save(flags);
918 card_present = hwreg_present(rp);
919 local_irq_restore(flags);
921 if (!card_present)
922 continue;
924 printk(KERN_DEBUG "Now probing slot %X at %p\n", slot, rp);
925 dp = *rp;
926 if(dp == 0)
927 continue;
929 /* The last byte of the format block consists of two
930 nybbles which are "mirror images" of each other.
931 These show us the valid bytelanes */
932 if ((((dp>>4) ^ dp) & 0x0F) != 0x0F)
933 continue;
934 /* Check that this value is actually *on* one of the
935 bytelanes it claims are valid! */
936 if ((dp & 0x0F) >= (1<<i))
937 continue;
939 /* Looks promising. Let's put it on the list. */
940 nubus_add_board(slot, dp);
942 return;
943 }
944 }
946 #if defined(CONFIG_PROC_FS)
948 /* /proc/nubus stuff */
950 static int sprint_nubus_board(struct nubus_board* board, char* ptr, int len)
951 {
952 if(len < 100)
953 return -1;
955 sprintf(ptr, "Slot %X: %s\n",
956 board->slot, board->name);
958 return strlen(ptr);
959 }
961 static int nubus_read_proc(char *page, char **start, off_t off,
962 int count, int *eof, void *data)
963 {
964 int nprinted, len, begin = 0;
965 int size = PAGE_SIZE;
966 struct nubus_board* board;
968 len = sprintf(page, "Nubus devices found:\n");
969 /* Walk the list of NuBus boards */
970 for (board = nubus_boards; board != NULL; board = board->next)
971 {
972 nprinted = sprint_nubus_board(board, page + len, size - len);
973 if (nprinted < 0)
974 break;
975 len += nprinted;
976 if (len+begin < off) {
977 begin += len;
978 len = 0;
979 }
980 if (len+begin >= off+count)
981 break;
982 }
983 if (len+begin < off)
984 *eof = 1;
985 off -= begin;
986 *start = page + off;
987 len -= off;
988 if (len>count)
989 len = count;
990 if (len<0)
991 len = 0;
992 return len;
993 }
994 #endif
996 void __init nubus_scan_bus(void)
997 {
998 int slot;
999 /* This might not work on your machine */
1000 #ifdef I_WANT_TO_PROBE_SLOT_ZERO
1001 nubus_probe_slot(0);
1002 #endif
1003 for(slot = 9; slot < 15; slot++)
1005 nubus_probe_slot(slot);
1009 static int __init nubus_init(void)
1011 if (!MACH_IS_MAC)
1012 return 0;
1014 /* Initialize the NuBus interrupts */
1015 if (oss_present) {
1016 oss_nubus_init();
1017 } else {
1018 via_nubus_init();
1021 #ifdef TRY_TO_DODGE_WSOD
1022 /* Rogue Ethernet interrupts can kill the machine if we don't
1023 do this. Obviously this is bogus. Hopefully the local VIA
1024 gurus can fix the real cause of the problem. */
1025 mdelay(1000);
1026 #endif
1028 /* And probe */
1029 printk("NuBus: Scanning NuBus slots.\n");
1030 nubus_devices = NULL;
1031 nubus_boards = NULL;
1032 nubus_scan_bus();
1034 #ifdef CONFIG_PROC_FS
1035 create_proc_read_entry("nubus", 0, NULL, nubus_read_proc, NULL);
1036 nubus_proc_init();
1037 #endif
1038 return 0;
1041 subsys_initcall(nubus_init);