diff options
Diffstat (limited to 'drivers/nubus')
| -rw-r--r-- | drivers/nubus/Makefile | 8 | ||||
| -rw-r--r-- | drivers/nubus/bus.c | 115 | ||||
| -rw-r--r-- | drivers/nubus/nubus.c | 885 | ||||
| -rw-r--r-- | drivers/nubus/proc.c | 198 |
4 files changed, 1206 insertions, 0 deletions
diff --git a/drivers/nubus/Makefile b/drivers/nubus/Makefile new file mode 100644 index 000000000..0f03032d2 --- /dev/null +++ b/drivers/nubus/Makefile @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# Makefile for the nubus specific drivers. +# + +obj-y := nubus.o bus.o + +obj-$(CONFIG_PROC_FS) += proc.o diff --git a/drivers/nubus/bus.c b/drivers/nubus/bus.c new file mode 100644 index 000000000..ad3d17c42 --- /dev/null +++ b/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/drivers/nubus/nubus.c b/drivers/nubus/nubus.c new file mode 100644 index 000000000..f70ba58db --- /dev/null +++ b/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 = 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/drivers/nubus/proc.c b/drivers/nubus/proc.c new file mode 100644 index 000000000..78cf0e7b5 --- /dev/null +++ b/drivers/nubus/proc.c @@ -0,0 +1,198 @@ +// 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; +} + +static int nubus_rsrc_proc_open(struct inode *inode, struct file *file) +{ + return single_open(file, nubus_proc_rsrc_show, inode); +} + +static const struct proc_ops nubus_rsrc_proc_ops = { + .proc_open = nubus_rsrc_proc_open, + .proc_read = seq_read, + .proc_lseek = seq_lseek, + .proc_release = single_release, +}; + +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_data(name, S_IFREG | 0444, procdir, + &nubus_rsrc_proc_ops, 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_data(name, S_IFREG | 0444, procdir, + &nubus_rsrc_proc_ops, + 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); +} |