USB: serial: kl5kusb105: clean up urb->status usage
[linux-2.6] / drivers / nubus / nubus.c
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  */
9
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>
24
25 extern void via_nubus_init(void);
26 extern void oss_nubus_init(void);
27
28 /* Constants */
29
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
34
35 #define NUBUS_TEST_PATTERN 0x5A932BC7
36
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
41
42 /* This sometimes helps combat failure to boot */
43 #undef TRY_TO_DODGE_WSOD
44
45 /* Globals */
46
47 struct nubus_dev*   nubus_devices;
48 struct nubus_board* nubus_boards;
49
50 /* Meaning of "bytelanes":
51
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:
57
58    A map of 0x0f, as found in the MacOS ROM, means that all bytelanes
59    are valid.
60
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)
63
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)
67
68    A map of 0x78 means that only the LSB of each long word is valid.
69
70    Etcetera, etcetera.  Hopefully this clears up some confusion over
71    what the following code actually does.  */
72  
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 }
81  
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;
87
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 }
99
100 static void nubus_rewind(unsigned char **ptr, int len, int map)
101 {
102         unsigned char *p=*ptr;
103
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 }
118
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 }
133
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 }
141
142 /* Now, functions to read the sResource tree */
143
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. */
148
149 static inline long nubus_expand32(long foo)
150 {
151         if(foo & 0x00800000)    /* 24bit negative */
152                 foo |= 0xFF000000;
153         return foo;
154 }
155
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 }
164
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 }
174
175 /* These two are for pulling resource data blocks (i.e. stuff that's
176    pointed to with offsets) out of the card ROM. */
177
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 }
189
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 }
203
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 }
212
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 }
222
223 int nubus_get_board_dir(const struct nubus_board* board,
224                         struct nubus_dir* dir)
225 {
226         struct nubus_dirent ent;
227         
228         dir->ptr = dir->base = board->directory;
229         dir->done = 0;
230         dir->mask = board->lanes;
231
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 }
240
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 }
249
250 int nubus_readdir(struct nubus_dir *nd, struct nubus_dirent *ent)
251 {
252         u32 resid;
253         if (nd->done)
254                 return -1;
255
256         /* Do this first, otherwise nubus_rewind & co are off by 4 */
257         ent->base = nd->ptr;
258
259         /* This moves nd->ptr forward */
260         resid = nubus_get_rom(&nd->ptr, 4, nd->mask);
261
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         }
269
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 }
277
278 int nubus_rewinddir(struct nubus_dir* dir)
279 {
280         dir->ptr = dir->base;
281         return 0;
282 }
283
284 /* Driver interface functions, more or less like in pci.c */
285
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;
295
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 }
306
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;
314
315         while (itor) {
316                 if (itor->category == category
317                     && itor->type == type)
318                         return itor;
319                 itor = itor->next;
320         }
321         return NULL;
322 }
323
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;
330         
331         while (itor) {
332                 if (itor->board->slot == slot)
333                         return itor;
334                 itor = itor->next;
335         }
336         return NULL;
337 }
338
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 }
349
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. */
353
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. */
358
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 }
376
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;
385                 
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 }
400
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 }
427
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 }
447
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;
456         
457         printk(KERN_INFO "  Function 0x%02x:\n", parent->type);
458         nubus_get_subdir(parent, &dir);
459
460         /* Apple seems to have botched the ROM on the IIx */
461         if (slot == 0 && (unsigned long)dir.base % 2)
462                 dir.base += 1;
463         
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);
467
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;
475         
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         }
539                 
540         return dev;
541 }
542
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         };
557
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);
563
564         while(nubus_readdir(&dir, &ent) != -1)
565         {
566                 struct vidmode mode;
567                 u32 size;
568
569                 /* First get the length */
570                 nubus_get_rsrc_mem(&size, &ent, 4);
571                 
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 }
582
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;
590         
591         nubus_get_rsrc_mem(&icon, ent, 128);
592         printk(KERN_INFO "    icon:\n");
593
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 }
610
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"};
618
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);
624
625         while(nubus_readdir(&dir, &ent) != -1)
626         {
627                 char name[64];
628                 
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 }
638
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;
644         
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);
649
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 }
709
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;
718
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         }
730
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;
740
741         /* This one points to an "Unknown Macintosh" directory */
742         if (nubus_readdir(&dir, &ent) == -1)
743                 goto badrom;
744
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);
753
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);
759
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);
774         
775         /* Bwahahahaha... */
776         nubus_get_subdir(&ent, &dir);
777         board->directory = dir.base;
778         return;
779         
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 }
786
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;
792
793         unsigned char *rp;
794         unsigned long dpat;
795         struct nubus_dir dir;
796         struct nubus_dirent ent;
797
798         /* Move to the start of the format block */
799         rp = nubus_rom_addr(slot);              
800         nubus_rewind(&rp, FORMAT_BLOCK_SIZE, bytelanes);
801
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;
807
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         }
823         
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;
838
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);
845                 
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          */
852
853         /* Attempt to work around slot zero weirdness */
854         nubus_find_rom_dir(board);
855         nubus_get_root_dir(board, &dir);        
856
857         /* We're ready to rock */
858         printk(KERN_INFO "Slot %X:\n", slot);
859
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         }
873
874         /* Aaaarrrrgghh!  The LC III motherboard has *two* board
875            resources.  I have no idea WTF to do about this. */
876
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;
883
884                 /* We zeroed this out above */
885                 if (board->first_dev == NULL)
886                         board->first_dev = dev;
887                 
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         }
894
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;
900         
901         return board;
902 }
903
904 void __init nubus_probe_slot(int slot)
905 {
906         unsigned char dp;
907         unsigned char* rp;
908         int i;
909
910         rp = nubus_rom_addr(slot);      
911         for(i = 4; i; i--)
912         {
913                 unsigned long flags;
914                 int card_present;
915
916                 rp--;
917                 local_irq_save(flags);
918                 card_present = hwreg_present(rp);
919                 local_irq_restore(flags);
920                
921                 if (!card_present)
922                         continue;
923
924                 printk(KERN_DEBUG "Now probing slot %X at %p\n", slot, rp);
925                 dp = *rp;
926                 if(dp == 0)
927                         continue;
928
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;
938
939                 /* Looks promising.  Let's put it on the list. */
940                 nubus_add_board(slot, dp);
941
942                 return;
943         }
944 }
945
946 #if defined(CONFIG_PROC_FS)
947
948 /* /proc/nubus stuff */
949
950 static int sprint_nubus_board(struct nubus_board* board, char* ptr, int len)
951 {
952         if(len < 100)
953                 return -1;
954         
955         sprintf(ptr, "Slot %X: %s\n",
956                 board->slot, board->name);
957         
958         return strlen(ptr);
959 }
960
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;
967         
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
995
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++)
1004         {
1005                 nubus_probe_slot(slot);
1006         }
1007 }
1008
1009 static int __init nubus_init(void)
1010 {
1011         if (!MACH_IS_MAC) 
1012                 return 0;
1013
1014         /* Initialize the NuBus interrupts */
1015         if (oss_present) {
1016                 oss_nubus_init();
1017         } else {
1018                 via_nubus_init();
1019         }
1020
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
1027         
1028         /* And probe */
1029         printk("NuBus: Scanning NuBus slots.\n");
1030         nubus_devices = NULL;
1031         nubus_boards  = NULL;
1032         nubus_scan_bus();
1033
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;
1039 }
1040
1041 subsys_initcall(nubus_init);