[Feature] add GA346 baseline version
Change-Id: Ic62933698569507dcf98240cdf5d9931ae34348f
diff --git a/src/kernel/linux/v4.19/drivers/nubus/Makefile b/src/kernel/linux/v4.19/drivers/nubus/Makefile
new file mode 100644
index 0000000..6d063cd
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/nubus/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the nubus specific drivers.
+#
+
+obj-y := nubus.o bus.o
+
+obj-$(CONFIG_PROC_FS) += proc.o
diff --git a/src/kernel/linux/v4.19/drivers/nubus/bus.c b/src/kernel/linux/v4.19/drivers/nubus/bus.c
new file mode 100644
index 0000000..ad3d17c
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/nubus/bus.c
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-2.0
+//
+// Bus implementation for the NuBus subsystem.
+//
+// Copyright (C) 2017 Finn Thain
+
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/list.h>
+#include <linux/nubus.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+
+#define to_nubus_board(d) container_of(d, struct nubus_board, dev)
+#define to_nubus_driver(d) container_of(d, struct nubus_driver, driver)
+
+static int nubus_bus_match(struct device *dev, struct device_driver *driver)
+{
+ return 1;
+}
+
+static int nubus_device_probe(struct device *dev)
+{
+ struct nubus_driver *ndrv = to_nubus_driver(dev->driver);
+ int err = -ENODEV;
+
+ if (ndrv->probe)
+ err = ndrv->probe(to_nubus_board(dev));
+ return err;
+}
+
+static int nubus_device_remove(struct device *dev)
+{
+ struct nubus_driver *ndrv = to_nubus_driver(dev->driver);
+ int err = -ENODEV;
+
+ if (dev->driver && ndrv->remove)
+ err = ndrv->remove(to_nubus_board(dev));
+ return err;
+}
+
+struct bus_type nubus_bus_type = {
+ .name = "nubus",
+ .match = nubus_bus_match,
+ .probe = nubus_device_probe,
+ .remove = nubus_device_remove,
+};
+EXPORT_SYMBOL(nubus_bus_type);
+
+int nubus_driver_register(struct nubus_driver *ndrv)
+{
+ ndrv->driver.bus = &nubus_bus_type;
+ return driver_register(&ndrv->driver);
+}
+EXPORT_SYMBOL(nubus_driver_register);
+
+void nubus_driver_unregister(struct nubus_driver *ndrv)
+{
+ driver_unregister(&ndrv->driver);
+}
+EXPORT_SYMBOL(nubus_driver_unregister);
+
+static struct device nubus_parent = {
+ .init_name = "nubus",
+};
+
+static int __init nubus_bus_register(void)
+{
+ return bus_register(&nubus_bus_type);
+}
+postcore_initcall(nubus_bus_register);
+
+int __init nubus_parent_device_register(void)
+{
+ return device_register(&nubus_parent);
+}
+
+static void nubus_device_release(struct device *dev)
+{
+ struct nubus_board *board = to_nubus_board(dev);
+ struct nubus_rsrc *fres, *tmp;
+
+ list_for_each_entry_safe(fres, tmp, &nubus_func_rsrcs, list)
+ if (fres->board == board) {
+ list_del(&fres->list);
+ kfree(fres);
+ }
+ kfree(board);
+}
+
+int nubus_device_register(struct nubus_board *board)
+{
+ board->dev.parent = &nubus_parent;
+ board->dev.release = nubus_device_release;
+ board->dev.bus = &nubus_bus_type;
+ dev_set_name(&board->dev, "slot.%X", board->slot);
+ board->dev.dma_mask = &board->dev.coherent_dma_mask;
+ dma_set_mask(&board->dev, DMA_BIT_MASK(32));
+ return device_register(&board->dev);
+}
+
+static int nubus_print_device_name_fn(struct device *dev, void *data)
+{
+ struct nubus_board *board = to_nubus_board(dev);
+ struct seq_file *m = data;
+
+ seq_printf(m, "Slot %X: %s\n", board->slot, board->name);
+ return 0;
+}
+
+int nubus_proc_show(struct seq_file *m, void *data)
+{
+ return bus_for_each_dev(&nubus_bus_type, NULL, m,
+ nubus_print_device_name_fn);
+}
diff --git a/src/kernel/linux/v4.19/drivers/nubus/nubus.c b/src/kernel/linux/v4.19/drivers/nubus/nubus.c
new file mode 100644
index 0000000..bb0d63a
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/nubus/nubus.c
@@ -0,0 +1,885 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Macintosh Nubus Interface Code
+ *
+ * Originally by Alan Cox
+ *
+ * Mostly rewritten by David Huggins-Daines, C. Scott Ananian,
+ * and others.
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/nubus.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <asm/setup.h>
+#include <asm/page.h>
+#include <asm/hwtest.h>
+
+/* Constants */
+
+/* This is, of course, the size in bytelanes, rather than the size in
+ actual bytes */
+#define FORMAT_BLOCK_SIZE 20
+#define ROM_DIR_OFFSET 0x24
+
+#define NUBUS_TEST_PATTERN 0x5A932BC7
+
+/* Globals */
+
+LIST_HEAD(nubus_func_rsrcs);
+
+/* Meaning of "bytelanes":
+
+ The card ROM may appear on any or all bytes of each long word in
+ NuBus memory. The low 4 bits of the "map" value found in the
+ format block (at the top of the slot address space, as well as at
+ the top of the MacOS ROM) tells us which bytelanes, i.e. which byte
+ offsets within each longword, are valid. Thus:
+
+ A map of 0x0f, as found in the MacOS ROM, means that all bytelanes
+ are valid.
+
+ A map of 0xf0 means that no bytelanes are valid (We pray that we
+ will never encounter this, but stranger things have happened)
+
+ A map of 0xe1 means that only the MSB of each long word is actually
+ part of the card ROM. (We hope to never encounter NuBus on a
+ little-endian machine. Again, stranger things have happened)
+
+ A map of 0x78 means that only the LSB of each long word is valid.
+
+ Etcetera, etcetera. Hopefully this clears up some confusion over
+ what the following code actually does. */
+
+static inline int not_useful(void *p, int map)
+{
+ unsigned long pv = (unsigned long)p;
+
+ pv &= 3;
+ if (map & (1 << pv))
+ return 0;
+ return 1;
+}
+
+static unsigned long nubus_get_rom(unsigned char **ptr, int len, int map)
+{
+ /* This will hold the result */
+ unsigned long v = 0;
+ unsigned char *p = *ptr;
+
+ while (len) {
+ v <<= 8;
+ while (not_useful(p, map))
+ p++;
+ v |= *p++;
+ len--;
+ }
+ *ptr = p;
+ return v;
+}
+
+static void nubus_rewind(unsigned char **ptr, int len, int map)
+{
+ unsigned char *p = *ptr;
+
+ while (len) {
+ do {
+ p--;
+ } while (not_useful(p, map));
+ len--;
+ }
+ *ptr = p;
+}
+
+static void nubus_advance(unsigned char **ptr, int len, int map)
+{
+ unsigned char *p = *ptr;
+
+ while (len) {
+ while (not_useful(p, map))
+ p++;
+ p++;
+ len--;
+ }
+ *ptr = p;
+}
+
+static void nubus_move(unsigned char **ptr, int len, int map)
+{
+ unsigned long slot_space = (unsigned long)*ptr & 0xFF000000;
+
+ if (len > 0)
+ nubus_advance(ptr, len, map);
+ else if (len < 0)
+ nubus_rewind(ptr, -len, map);
+
+ if (((unsigned long)*ptr & 0xFF000000) != slot_space)
+ pr_err("%s: moved out of slot address space!\n", __func__);
+}
+
+/* Now, functions to read the sResource tree */
+
+/* Each sResource entry consists of a 1-byte ID and a 3-byte data
+ field. If that data field contains an offset, then obviously we
+ have to expand it from a 24-bit signed number to a 32-bit signed
+ number. */
+
+static inline long nubus_expand32(long foo)
+{
+ if (foo & 0x00800000) /* 24bit negative */
+ foo |= 0xFF000000;
+ return foo;
+}
+
+static inline void *nubus_rom_addr(int slot)
+{
+ /*
+ * Returns the first byte after the card. We then walk
+ * backwards to get the lane register and the config
+ */
+ return (void *)(0xF1000000 + (slot << 24));
+}
+
+unsigned char *nubus_dirptr(const struct nubus_dirent *nd)
+{
+ unsigned char *p = nd->base;
+
+ /* Essentially, just step over the bytelanes using whatever
+ offset we might have found */
+ nubus_move(&p, nubus_expand32(nd->data), nd->mask);
+ /* And return the value */
+ return p;
+}
+
+/* These two are for pulling resource data blocks (i.e. stuff that's
+ pointed to with offsets) out of the card ROM. */
+
+void nubus_get_rsrc_mem(void *dest, const struct nubus_dirent *dirent,
+ unsigned int len)
+{
+ unsigned char *t = (unsigned char *)dest;
+ unsigned char *p = nubus_dirptr(dirent);
+
+ while (len) {
+ *t++ = nubus_get_rom(&p, 1, dirent->mask);
+ len--;
+ }
+}
+EXPORT_SYMBOL(nubus_get_rsrc_mem);
+
+unsigned int nubus_get_rsrc_str(char *dest, const struct nubus_dirent *dirent,
+ unsigned int len)
+{
+ char *t = dest;
+ unsigned char *p = nubus_dirptr(dirent);
+
+ while (len > 1) {
+ unsigned char c = nubus_get_rom(&p, 1, dirent->mask);
+
+ if (!c)
+ break;
+ *t++ = c;
+ len--;
+ }
+ if (len > 0)
+ *t = '\0';
+ return t - dest;
+}
+EXPORT_SYMBOL(nubus_get_rsrc_str);
+
+void nubus_seq_write_rsrc_mem(struct seq_file *m,
+ const struct nubus_dirent *dirent,
+ unsigned int len)
+{
+ unsigned long buf[32];
+ unsigned int buf_size = sizeof(buf);
+ unsigned char *p = nubus_dirptr(dirent);
+
+ /* If possible, write out full buffers */
+ while (len >= buf_size) {
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(buf); i++)
+ buf[i] = nubus_get_rom(&p, sizeof(buf[0]),
+ dirent->mask);
+ seq_write(m, buf, buf_size);
+ len -= buf_size;
+ }
+ /* If not, write out individual bytes */
+ while (len--)
+ seq_putc(m, nubus_get_rom(&p, 1, dirent->mask));
+}
+
+int nubus_get_root_dir(const struct nubus_board *board,
+ struct nubus_dir *dir)
+{
+ dir->ptr = dir->base = board->directory;
+ dir->done = 0;
+ dir->mask = board->lanes;
+ return 0;
+}
+EXPORT_SYMBOL(nubus_get_root_dir);
+
+/* This is a slyly renamed version of the above */
+int nubus_get_func_dir(const struct nubus_rsrc *fres, struct nubus_dir *dir)
+{
+ dir->ptr = dir->base = fres->directory;
+ dir->done = 0;
+ dir->mask = fres->board->lanes;
+ return 0;
+}
+EXPORT_SYMBOL(nubus_get_func_dir);
+
+int nubus_get_board_dir(const struct nubus_board *board,
+ struct nubus_dir *dir)
+{
+ struct nubus_dirent ent;
+
+ dir->ptr = dir->base = board->directory;
+ dir->done = 0;
+ dir->mask = board->lanes;
+
+ /* Now dereference it (the first directory is always the board
+ directory) */
+ if (nubus_readdir(dir, &ent) == -1)
+ return -1;
+ if (nubus_get_subdir(&ent, dir) == -1)
+ return -1;
+ return 0;
+}
+EXPORT_SYMBOL(nubus_get_board_dir);
+
+int nubus_get_subdir(const struct nubus_dirent *ent,
+ struct nubus_dir *dir)
+{
+ dir->ptr = dir->base = nubus_dirptr(ent);
+ dir->done = 0;
+ dir->mask = ent->mask;
+ return 0;
+}
+EXPORT_SYMBOL(nubus_get_subdir);
+
+int nubus_readdir(struct nubus_dir *nd, struct nubus_dirent *ent)
+{
+ u32 resid;
+
+ if (nd->done)
+ return -1;
+
+ /* Do this first, otherwise nubus_rewind & co are off by 4 */
+ ent->base = nd->ptr;
+
+ /* This moves nd->ptr forward */
+ resid = nubus_get_rom(&nd->ptr, 4, nd->mask);
+
+ /* EOL marker, as per the Apple docs */
+ if ((resid & 0xff000000) == 0xff000000) {
+ /* Mark it as done */
+ nd->done = 1;
+ return -1;
+ }
+
+ /* First byte is the resource ID */
+ ent->type = resid >> 24;
+ /* Low 3 bytes might contain data (or might not) */
+ ent->data = resid & 0xffffff;
+ ent->mask = nd->mask;
+ return 0;
+}
+EXPORT_SYMBOL(nubus_readdir);
+
+int nubus_rewinddir(struct nubus_dir *dir)
+{
+ dir->ptr = dir->base;
+ dir->done = 0;
+ return 0;
+}
+EXPORT_SYMBOL(nubus_rewinddir);
+
+/* Driver interface functions, more or less like in pci.c */
+
+struct nubus_rsrc *nubus_first_rsrc_or_null(void)
+{
+ return list_first_entry_or_null(&nubus_func_rsrcs, struct nubus_rsrc,
+ list);
+}
+EXPORT_SYMBOL(nubus_first_rsrc_or_null);
+
+struct nubus_rsrc *nubus_next_rsrc_or_null(struct nubus_rsrc *from)
+{
+ if (list_is_last(&from->list, &nubus_func_rsrcs))
+ return NULL;
+ return list_next_entry(from, list);
+}
+EXPORT_SYMBOL(nubus_next_rsrc_or_null);
+
+int
+nubus_find_rsrc(struct nubus_dir *dir, unsigned char rsrc_type,
+ struct nubus_dirent *ent)
+{
+ while (nubus_readdir(dir, ent) != -1) {
+ if (ent->type == rsrc_type)
+ return 0;
+ }
+ return -1;
+}
+EXPORT_SYMBOL(nubus_find_rsrc);
+
+/* Initialization functions - decide which slots contain stuff worth
+ looking at, and print out lots and lots of information from the
+ resource blocks. */
+
+static int __init nubus_get_block_rsrc_dir(struct nubus_board *board,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *parent)
+{
+ struct nubus_dir dir;
+ struct nubus_dirent ent;
+
+ nubus_get_subdir(parent, &dir);
+ dir.procdir = nubus_proc_add_rsrc_dir(procdir, parent, board);
+
+ while (nubus_readdir(&dir, &ent) != -1) {
+ u32 size;
+
+ nubus_get_rsrc_mem(&size, &ent, 4);
+ pr_debug(" block (0x%x), size %d\n", ent.type, size);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, size);
+ }
+ return 0;
+}
+
+static int __init nubus_get_display_vidmode(struct nubus_board *board,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *parent)
+{
+ struct nubus_dir dir;
+ struct nubus_dirent ent;
+
+ nubus_get_subdir(parent, &dir);
+ dir.procdir = nubus_proc_add_rsrc_dir(procdir, parent, board);
+
+ while (nubus_readdir(&dir, &ent) != -1) {
+ switch (ent.type) {
+ case 1: /* mVidParams */
+ case 2: /* mTable */
+ {
+ u32 size;
+
+ nubus_get_rsrc_mem(&size, &ent, 4);
+ pr_debug(" block (0x%x), size %d\n", ent.type,
+ size);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, size);
+ break;
+ }
+ default:
+ pr_debug(" unknown resource 0x%02x, data 0x%06x\n",
+ ent.type, ent.data);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, 0);
+ }
+ }
+ return 0;
+}
+
+static int __init nubus_get_display_resource(struct nubus_rsrc *fres,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent)
+{
+ switch (ent->type) {
+ case NUBUS_RESID_GAMMADIR:
+ pr_debug(" gamma directory offset: 0x%06x\n", ent->data);
+ nubus_get_block_rsrc_dir(fres->board, procdir, ent);
+ break;
+ case 0x0080 ... 0x0085:
+ pr_debug(" mode 0x%02x info offset: 0x%06x\n",
+ ent->type, ent->data);
+ nubus_get_display_vidmode(fres->board, procdir, ent);
+ break;
+ default:
+ pr_debug(" unknown resource 0x%02x, data 0x%06x\n",
+ ent->type, ent->data);
+ nubus_proc_add_rsrc_mem(procdir, ent, 0);
+ }
+ return 0;
+}
+
+static int __init nubus_get_network_resource(struct nubus_rsrc *fres,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent)
+{
+ switch (ent->type) {
+ case NUBUS_RESID_MAC_ADDRESS:
+ {
+ char addr[6];
+
+ nubus_get_rsrc_mem(addr, ent, 6);
+ pr_debug(" MAC address: %pM\n", addr);
+ nubus_proc_add_rsrc_mem(procdir, ent, 6);
+ break;
+ }
+ default:
+ pr_debug(" unknown resource 0x%02x, data 0x%06x\n",
+ ent->type, ent->data);
+ nubus_proc_add_rsrc_mem(procdir, ent, 0);
+ }
+ return 0;
+}
+
+static int __init nubus_get_cpu_resource(struct nubus_rsrc *fres,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent)
+{
+ switch (ent->type) {
+ case NUBUS_RESID_MEMINFO:
+ {
+ unsigned long meminfo[2];
+
+ nubus_get_rsrc_mem(&meminfo, ent, 8);
+ pr_debug(" memory: [ 0x%08lx 0x%08lx ]\n",
+ meminfo[0], meminfo[1]);
+ nubus_proc_add_rsrc_mem(procdir, ent, 8);
+ break;
+ }
+ case NUBUS_RESID_ROMINFO:
+ {
+ unsigned long rominfo[2];
+
+ nubus_get_rsrc_mem(&rominfo, ent, 8);
+ pr_debug(" ROM: [ 0x%08lx 0x%08lx ]\n",
+ rominfo[0], rominfo[1]);
+ nubus_proc_add_rsrc_mem(procdir, ent, 8);
+ break;
+ }
+ default:
+ pr_debug(" unknown resource 0x%02x, data 0x%06x\n",
+ ent->type, ent->data);
+ nubus_proc_add_rsrc_mem(procdir, ent, 0);
+ }
+ return 0;
+}
+
+static int __init nubus_get_private_resource(struct nubus_rsrc *fres,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent)
+{
+ switch (fres->category) {
+ case NUBUS_CAT_DISPLAY:
+ nubus_get_display_resource(fres, procdir, ent);
+ break;
+ case NUBUS_CAT_NETWORK:
+ nubus_get_network_resource(fres, procdir, ent);
+ break;
+ case NUBUS_CAT_CPU:
+ nubus_get_cpu_resource(fres, procdir, ent);
+ break;
+ default:
+ pr_debug(" unknown resource 0x%02x, data 0x%06x\n",
+ ent->type, ent->data);
+ nubus_proc_add_rsrc_mem(procdir, ent, 0);
+ }
+ return 0;
+}
+
+static struct nubus_rsrc * __init
+nubus_get_functional_resource(struct nubus_board *board, int slot,
+ const struct nubus_dirent *parent)
+{
+ struct nubus_dir dir;
+ struct nubus_dirent ent;
+ struct nubus_rsrc *fres;
+
+ pr_debug(" Functional resource 0x%02x:\n", parent->type);
+ nubus_get_subdir(parent, &dir);
+ dir.procdir = nubus_proc_add_rsrc_dir(board->procdir, parent, board);
+
+ /* Actually we should probably panic if this fails */
+ fres = kzalloc(sizeof(*fres), GFP_ATOMIC);
+ if (!fres)
+ return NULL;
+ fres->resid = parent->type;
+ fres->directory = dir.base;
+ fres->board = board;
+
+ while (nubus_readdir(&dir, &ent) != -1) {
+ switch (ent.type) {
+ case NUBUS_RESID_TYPE:
+ {
+ unsigned short nbtdata[4];
+
+ nubus_get_rsrc_mem(nbtdata, &ent, 8);
+ fres->category = nbtdata[0];
+ fres->type = nbtdata[1];
+ fres->dr_sw = nbtdata[2];
+ fres->dr_hw = nbtdata[3];
+ pr_debug(" type: [cat 0x%x type 0x%x sw 0x%x hw 0x%x]\n",
+ nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[3]);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, 8);
+ break;
+ }
+ case NUBUS_RESID_NAME:
+ {
+ char name[64];
+ unsigned int len;
+
+ len = nubus_get_rsrc_str(name, &ent, sizeof(name));
+ pr_debug(" name: %s\n", name);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, len + 1);
+ break;
+ }
+ case NUBUS_RESID_DRVRDIR:
+ {
+ /* MacOS driver. If we were NetBSD we might
+ use this :-) */
+ pr_debug(" driver directory offset: 0x%06x\n",
+ ent.data);
+ nubus_get_block_rsrc_dir(board, dir.procdir, &ent);
+ break;
+ }
+ case NUBUS_RESID_MINOR_BASEOS:
+ {
+ /* We will need this in order to support
+ multiple framebuffers. It might be handy
+ for Ethernet as well */
+ u32 base_offset;
+
+ nubus_get_rsrc_mem(&base_offset, &ent, 4);
+ pr_debug(" memory offset: 0x%08x\n", base_offset);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, 4);
+ break;
+ }
+ case NUBUS_RESID_MINOR_LENGTH:
+ {
+ /* Ditto */
+ u32 length;
+
+ nubus_get_rsrc_mem(&length, &ent, 4);
+ pr_debug(" memory length: 0x%08x\n", length);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, 4);
+ break;
+ }
+ case NUBUS_RESID_FLAGS:
+ pr_debug(" flags: 0x%06x\n", ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_HWDEVID:
+ pr_debug(" hwdevid: 0x%06x\n", ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ default:
+ /* Local/Private resources have their own
+ function */
+ nubus_get_private_resource(fres, dir.procdir, &ent);
+ }
+ }
+
+ return fres;
+}
+
+/* This is *really* cool. */
+static int __init nubus_get_icon(struct nubus_board *board,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent)
+{
+ /* Should be 32x32 if my memory serves me correctly */
+ u32 icon[32];
+ int i;
+
+ nubus_get_rsrc_mem(&icon, ent, 128);
+ pr_debug(" icon:\n");
+ for (i = 0; i < 8; i++)
+ pr_debug(" %08x %08x %08x %08x\n",
+ icon[i * 4 + 0], icon[i * 4 + 1],
+ icon[i * 4 + 2], icon[i * 4 + 3]);
+ nubus_proc_add_rsrc_mem(procdir, ent, 128);
+
+ return 0;
+}
+
+static int __init nubus_get_vendorinfo(struct nubus_board *board,
+ struct proc_dir_entry *procdir,
+ const struct nubus_dirent *parent)
+{
+ struct nubus_dir dir;
+ struct nubus_dirent ent;
+ static char *vendor_fields[6] = { "ID", "serial", "revision",
+ "part", "date", "unknown field" };
+
+ pr_debug(" vendor info:\n");
+ nubus_get_subdir(parent, &dir);
+ dir.procdir = nubus_proc_add_rsrc_dir(procdir, parent, board);
+
+ while (nubus_readdir(&dir, &ent) != -1) {
+ char name[64];
+ unsigned int len;
+
+ /* These are all strings, we think */
+ len = nubus_get_rsrc_str(name, &ent, sizeof(name));
+ if (ent.type < 1 || ent.type > 5)
+ ent.type = 5;
+ pr_debug(" %s: %s\n", vendor_fields[ent.type - 1], name);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, len + 1);
+ }
+ return 0;
+}
+
+static int __init nubus_get_board_resource(struct nubus_board *board, int slot,
+ const struct nubus_dirent *parent)
+{
+ struct nubus_dir dir;
+ struct nubus_dirent ent;
+
+ pr_debug(" Board resource 0x%02x:\n", parent->type);
+ nubus_get_subdir(parent, &dir);
+ dir.procdir = nubus_proc_add_rsrc_dir(board->procdir, parent, board);
+
+ while (nubus_readdir(&dir, &ent) != -1) {
+ switch (ent.type) {
+ case NUBUS_RESID_TYPE:
+ {
+ unsigned short nbtdata[4];
+ /* This type is always the same, and is not
+ useful except insofar as it tells us that
+ we really are looking at a board resource. */
+ nubus_get_rsrc_mem(nbtdata, &ent, 8);
+ pr_debug(" type: [cat 0x%x type 0x%x sw 0x%x hw 0x%x]\n",
+ nbtdata[0], nbtdata[1], nbtdata[2], nbtdata[3]);
+ if (nbtdata[0] != 1 || nbtdata[1] != 0 ||
+ nbtdata[2] != 0 || nbtdata[3] != 0)
+ pr_err("Slot %X: sResource is not a board resource!\n",
+ slot);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, 8);
+ break;
+ }
+ case NUBUS_RESID_NAME:
+ {
+ unsigned int len;
+
+ len = nubus_get_rsrc_str(board->name, &ent,
+ sizeof(board->name));
+ pr_debug(" name: %s\n", board->name);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, len + 1);
+ break;
+ }
+ case NUBUS_RESID_ICON:
+ nubus_get_icon(board, dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_BOARDID:
+ pr_debug(" board id: 0x%x\n", ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_PRIMARYINIT:
+ pr_debug(" primary init offset: 0x%06x\n", ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_VENDORINFO:
+ nubus_get_vendorinfo(board, dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_FLAGS:
+ pr_debug(" flags: 0x%06x\n", ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_HWDEVID:
+ pr_debug(" hwdevid: 0x%06x\n", ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ case NUBUS_RESID_SECONDINIT:
+ pr_debug(" secondary init offset: 0x%06x\n",
+ ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ /* WTF isn't this in the functional resources? */
+ case NUBUS_RESID_VIDNAMES:
+ pr_debug(" vidnames directory offset: 0x%06x\n",
+ ent.data);
+ nubus_get_block_rsrc_dir(board, dir.procdir, &ent);
+ break;
+ /* Same goes for this */
+ case NUBUS_RESID_VIDMODES:
+ pr_debug(" video mode parameter directory offset: 0x%06x\n",
+ ent.data);
+ nubus_proc_add_rsrc(dir.procdir, &ent);
+ break;
+ default:
+ pr_debug(" unknown resource 0x%02x, data 0x%06x\n",
+ ent.type, ent.data);
+ nubus_proc_add_rsrc_mem(dir.procdir, &ent, 0);
+ }
+ }
+ return 0;
+}
+
+static void __init nubus_add_board(int slot, int bytelanes)
+{
+ struct nubus_board *board;
+ unsigned char *rp;
+ unsigned long dpat;
+ struct nubus_dir dir;
+ struct nubus_dirent ent;
+ int prev_resid = -1;
+
+ /* Move to the start of the format block */
+ rp = nubus_rom_addr(slot);
+ nubus_rewind(&rp, FORMAT_BLOCK_SIZE, bytelanes);
+
+ /* Actually we should probably panic if this fails */
+ if ((board = kzalloc(sizeof(*board), GFP_ATOMIC)) == NULL)
+ return;
+ board->fblock = rp;
+
+ /* Dump the format block for debugging purposes */
+ pr_debug("Slot %X, format block at 0x%p:\n", slot, rp);
+ pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
+ pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
+ pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
+ pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
+ pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
+ pr_debug("%08lx\n", nubus_get_rom(&rp, 4, bytelanes));
+ pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
+ pr_debug("%02lx\n", nubus_get_rom(&rp, 1, bytelanes));
+ rp = board->fblock;
+
+ board->slot = slot;
+ board->slot_addr = (unsigned long)nubus_slot_addr(slot);
+ board->doffset = nubus_get_rom(&rp, 4, bytelanes);
+ /* rom_length is *supposed* to be the total length of the
+ * ROM. In practice it is the "amount of ROM used to compute
+ * the CRC." So some jokers decide to set it to zero and
+ * set the crc to zero so they don't have to do any math.
+ * See the Performa 460 ROM, for example. Those Apple "engineers".
+ */
+ board->rom_length = nubus_get_rom(&rp, 4, bytelanes);
+ board->crc = nubus_get_rom(&rp, 4, bytelanes);
+ board->rev = nubus_get_rom(&rp, 1, bytelanes);
+ board->format = nubus_get_rom(&rp, 1, bytelanes);
+ board->lanes = bytelanes;
+
+ /* Directory offset should be small and negative... */
+ if (!(board->doffset & 0x00FF0000))
+ pr_warn("Slot %X: Dodgy doffset!\n", slot);
+ dpat = nubus_get_rom(&rp, 4, bytelanes);
+ if (dpat != NUBUS_TEST_PATTERN)
+ pr_warn("Slot %X: Wrong test pattern %08lx!\n", slot, dpat);
+
+ /*
+ * I wonder how the CRC is meant to work -
+ * any takers ?
+ * CSA: According to MAC docs, not all cards pass the CRC anyway,
+ * since the initial Macintosh ROM releases skipped the check.
+ */
+
+ /* Set up the directory pointer */
+ board->directory = board->fblock;
+ nubus_move(&board->directory, nubus_expand32(board->doffset),
+ board->lanes);
+
+ nubus_get_root_dir(board, &dir);
+
+ /* We're ready to rock */
+ pr_debug("Slot %X resources:\n", slot);
+
+ /* Each slot should have one board resource and any number of
+ * functional resources. So we'll fill in some fields in the
+ * struct nubus_board from the board resource, then walk down
+ * the list of functional resources, spinning out a nubus_rsrc
+ * for each of them.
+ */
+ if (nubus_readdir(&dir, &ent) == -1) {
+ /* We can't have this! */
+ pr_err("Slot %X: Board resource not found!\n", slot);
+ kfree(board);
+ return;
+ }
+
+ if (ent.type < 1 || ent.type > 127)
+ pr_warn("Slot %X: Board resource ID is invalid!\n", slot);
+
+ board->procdir = nubus_proc_add_board(board);
+
+ nubus_get_board_resource(board, slot, &ent);
+
+ while (nubus_readdir(&dir, &ent) != -1) {
+ struct nubus_rsrc *fres;
+
+ fres = nubus_get_functional_resource(board, slot, &ent);
+ if (fres == NULL)
+ continue;
+
+ /* Resources should appear in ascending ID order. This sanity
+ * check prevents duplicate resource IDs.
+ */
+ if (fres->resid <= prev_resid) {
+ kfree(fres);
+ continue;
+ }
+ prev_resid = fres->resid;
+
+ list_add_tail(&fres->list, &nubus_func_rsrcs);
+ }
+
+ if (nubus_device_register(board))
+ put_device(&board->dev);
+}
+
+static void __init nubus_probe_slot(int slot)
+{
+ unsigned char dp;
+ unsigned char *rp;
+ int i;
+
+ rp = nubus_rom_addr(slot);
+ for (i = 4; i; i--) {
+ rp--;
+ if (!hwreg_present(rp))
+ continue;
+
+ dp = *rp;
+
+ /* The last byte of the format block consists of two
+ nybbles which are "mirror images" of each other.
+ These show us the valid bytelanes */
+ if ((((dp >> 4) ^ dp) & 0x0F) != 0x0F)
+ continue;
+ /* Check that this value is actually *on* one of the
+ bytelanes it claims are valid! */
+ if (not_useful(rp, dp))
+ continue;
+
+ /* Looks promising. Let's put it on the list. */
+ nubus_add_board(slot, dp);
+
+ return;
+ }
+}
+
+static void __init nubus_scan_bus(void)
+{
+ int slot;
+
+ pr_info("NuBus: Scanning NuBus slots.\n");
+ for (slot = 9; slot < 15; slot++) {
+ nubus_probe_slot(slot);
+ }
+}
+
+static int __init nubus_init(void)
+{
+ int err;
+
+ if (!MACH_IS_MAC)
+ return 0;
+
+ nubus_proc_init();
+ err = nubus_parent_device_register();
+ if (err)
+ return err;
+ nubus_scan_bus();
+ return 0;
+}
+
+subsys_initcall(nubus_init);
diff --git a/src/kernel/linux/v4.19/drivers/nubus/proc.c b/src/kernel/linux/v4.19/drivers/nubus/proc.c
new file mode 100644
index 0000000..88e1f9a
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/nubus/proc.c
@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: GPL-2.0
+/* drivers/nubus/proc.c: Proc FS interface for NuBus.
+
+ By David Huggins-Daines <dhd@debian.org>
+
+ Much code and many ideas from drivers/pci/proc.c:
+ Copyright (c) 1997, 1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
+
+ This is initially based on the Zorro and PCI interfaces. However,
+ it works somewhat differently. The intent is to provide a
+ structure in /proc analogous to the structure of the NuBus ROM
+ resources.
+
+ Therefore each board function gets a directory, which may in turn
+ contain subdirectories. Each slot resource is a file. Unrecognized
+ resources are empty files, since every resource ID requires a special
+ case (e.g. if the resource ID implies a directory or block, then its
+ value has to be interpreted as a slot ROM pointer etc.).
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/nubus.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <asm/byteorder.h>
+
+/*
+ * /proc/bus/nubus/devices stuff
+ */
+
+static int
+nubus_devices_proc_show(struct seq_file *m, void *v)
+{
+ struct nubus_rsrc *fres;
+
+ for_each_func_rsrc(fres)
+ seq_printf(m, "%x\t%04x %04x %04x %04x\t%08lx\n",
+ fres->board->slot, fres->category, fres->type,
+ fres->dr_sw, fres->dr_hw, fres->board->slot_addr);
+ return 0;
+}
+
+static struct proc_dir_entry *proc_bus_nubus_dir;
+
+/*
+ * /proc/bus/nubus/x/ stuff
+ */
+
+struct proc_dir_entry *nubus_proc_add_board(struct nubus_board *board)
+{
+ char name[2];
+
+ if (!proc_bus_nubus_dir)
+ return NULL;
+ snprintf(name, sizeof(name), "%x", board->slot);
+ return proc_mkdir(name, proc_bus_nubus_dir);
+}
+
+/* The PDE private data for any directory under /proc/bus/nubus/x/
+ * is the bytelanes value for the board in slot x.
+ */
+
+struct proc_dir_entry *nubus_proc_add_rsrc_dir(struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent,
+ struct nubus_board *board)
+{
+ char name[9];
+ int lanes = board->lanes;
+
+ if (!procdir)
+ return NULL;
+ snprintf(name, sizeof(name), "%x", ent->type);
+ return proc_mkdir_data(name, 0555, procdir, (void *)lanes);
+}
+
+/* The PDE private data for a file under /proc/bus/nubus/x/ is a pointer to
+ * an instance of the following structure, which gives the location and size
+ * of the resource data in the slot ROM. For slot resources which hold only a
+ * small integer, this integer value is stored directly and size is set to 0.
+ * A NULL private data pointer indicates an unrecognized resource.
+ */
+
+struct nubus_proc_pde_data {
+ unsigned char *res_ptr;
+ unsigned int res_size;
+};
+
+static struct nubus_proc_pde_data *
+nubus_proc_alloc_pde_data(unsigned char *ptr, unsigned int size)
+{
+ struct nubus_proc_pde_data *pde_data;
+
+ pde_data = kmalloc(sizeof(*pde_data), GFP_KERNEL);
+ if (!pde_data)
+ return NULL;
+
+ pde_data->res_ptr = ptr;
+ pde_data->res_size = size;
+ return pde_data;
+}
+
+static int nubus_proc_rsrc_show(struct seq_file *m, void *v)
+{
+ struct inode *inode = m->private;
+ struct nubus_proc_pde_data *pde_data;
+
+ pde_data = PDE_DATA(inode);
+ if (!pde_data)
+ return 0;
+
+ if (pde_data->res_size > m->size)
+ return -EFBIG;
+
+ if (pde_data->res_size) {
+ int lanes = (int)proc_get_parent_data(inode);
+ struct nubus_dirent ent;
+
+ if (!lanes)
+ return 0;
+
+ ent.mask = lanes;
+ ent.base = pde_data->res_ptr;
+ ent.data = 0;
+ nubus_seq_write_rsrc_mem(m, &ent, pde_data->res_size);
+ } else {
+ unsigned int data = (unsigned int)pde_data->res_ptr;
+
+ seq_putc(m, data >> 16);
+ seq_putc(m, data >> 8);
+ seq_putc(m, data >> 0);
+ }
+ return 0;
+}
+
+void nubus_proc_add_rsrc_mem(struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent,
+ unsigned int size)
+{
+ char name[9];
+ struct nubus_proc_pde_data *pde_data;
+
+ if (!procdir)
+ return;
+
+ snprintf(name, sizeof(name), "%x", ent->type);
+ if (size)
+ pde_data = nubus_proc_alloc_pde_data(nubus_dirptr(ent), size);
+ else
+ pde_data = NULL;
+ proc_create_single_data(name, S_IFREG | 0444, procdir,
+ nubus_proc_rsrc_show, pde_data);
+}
+
+void nubus_proc_add_rsrc(struct proc_dir_entry *procdir,
+ const struct nubus_dirent *ent)
+{
+ char name[9];
+ unsigned char *data = (unsigned char *)ent->data;
+
+ if (!procdir)
+ return;
+
+ snprintf(name, sizeof(name), "%x", ent->type);
+ proc_create_single_data(name, S_IFREG | 0444, procdir,
+ nubus_proc_rsrc_show,
+ nubus_proc_alloc_pde_data(data, 0));
+}
+
+/*
+ * /proc/nubus stuff
+ */
+
+void __init nubus_proc_init(void)
+{
+ proc_create_single("nubus", 0, NULL, nubus_proc_show);
+ proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
+ if (!proc_bus_nubus_dir)
+ return;
+ proc_create_single("devices", 0, proc_bus_nubus_dir,
+ nubus_devices_proc_show);
+}