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