![Finn Thain](/assets/img/avatar_default.png)
This patch brings basic support for the Linux Driver Model to the NuBus subsystem. For flexibility, the matching of boards with drivers is left up to the drivers. This is also the approach taken by NetBSD. A board may have many functions, and drivers may have to consider many functional resources and board resources in order to match a device. This implementation does not bind drivers to resources (nor does it bind many drivers to the same board). Apple's NuBus declaration ROM design is flexible enough to allow that, but I don't see a need to support it as we don't use the "slot zero" resources (in the main logic board ROM). Eliminate the global nubus_boards linked list by rewriting the procfs board iterator around bus_for_each_dev(). Hence the nubus device refcount can be used to determine the lifespan of board objects. Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Tested-by: Stan Johnson <userm57@yahoo.com> Signed-off-by: Finn Thain <fthain@telegraphics.com.au> Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
222 lines
5.5 KiB
C
222 lines
5.5 KiB
C
// 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 int nubus_devices_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, nubus_devices_proc_show, NULL);
|
|
}
|
|
|
|
static const struct file_operations nubus_devices_proc_fops = {
|
|
.open = nubus_devices_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
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_proc_rsrc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, nubus_proc_rsrc_show, inode);
|
|
}
|
|
|
|
static const struct file_operations nubus_proc_rsrc_fops = {
|
|
.open = nubus_proc_rsrc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.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_proc_rsrc_fops, 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_proc_rsrc_fops,
|
|
nubus_proc_alloc_pde_data(data, 0));
|
|
}
|
|
|
|
/*
|
|
* /proc/nubus stuff
|
|
*/
|
|
|
|
static int nubus_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, nubus_proc_show, NULL);
|
|
}
|
|
|
|
static const struct file_operations nubus_proc_fops = {
|
|
.open = nubus_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
void __init nubus_proc_init(void)
|
|
{
|
|
proc_create("nubus", 0, NULL, &nubus_proc_fops);
|
|
proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
|
|
if (!proc_bus_nubus_dir)
|
|
return;
|
|
proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops);
|
|
}
|