[net-next-2.6.git] / drivers / nubus / proc.c

/* 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 NuBus device is in fact a directory, which may in
   turn contain subdirectories.  The "files" correspond to NuBus
   resource records.  For those types of records which we know how to
   convert to formats that are meaningful to userspace (mostly just
   icons) these files will provide "cooked" data.  Otherwise they will
   simply provide raw access (read-only of course) to the ROM.  */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/nubus.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/module.h>

#include <asm/uaccess.h>
#include <asm/byteorder.h>

static int
nubus_devices_proc_show(struct seq_file *m, void *v)
{
	struct nubus_dev *dev = nubus_devices;

	while (dev) {
		seq_printf(m, "%x\t%04x %04x %04x %04x",
			      dev->board->slot,
			      dev->category,
			      dev->type,
			      dev->dr_sw,
			      dev->dr_hw);
		seq_printf(m, "\t%08lx\n", dev->board->slot_addr);
		dev = dev->next;
	}
	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 = {
	.owner		= THIS_MODULE,
	.open		= nubus_devices_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static struct proc_dir_entry *proc_bus_nubus_dir;

static void nubus_proc_subdir(struct nubus_dev* dev,
			      struct proc_dir_entry* parent,
			      struct nubus_dir* dir)
{
	struct nubus_dirent ent;

	/* Some of these are directories, others aren't */
	while (nubus_readdir(dir, &ent) != -1) {
		char name[8];
		struct proc_dir_entry* e;
		
		sprintf(name, "%x", ent.type);
		e = create_proc_entry(name, S_IFREG | S_IRUGO |
				      S_IWUSR, parent);
		if (!e) return;
	}
}

/* Can't do this recursively since the root directory is structured
   somewhat differently from the subdirectories */
static void nubus_proc_populate(struct nubus_dev* dev,
				struct proc_dir_entry* parent,
				struct nubus_dir* root)
{
	struct nubus_dirent ent;

	/* We know these are all directories (board resource + one or
	   more functional resources) */
	while (nubus_readdir(root, &ent) != -1) {
		char name[8];
		struct proc_dir_entry* e;
		struct nubus_dir dir;
		
		sprintf(name, "%x", ent.type);
		e = proc_mkdir(name, parent);
		if (!e) return;

		/* And descend */
		if (nubus_get_subdir(&ent, &dir) == -1) {
			/* This shouldn't happen */
			printk(KERN_ERR "NuBus root directory node %x:%x has no subdir!\n",
			       dev->board->slot, ent.type);
			continue;
		} else {
			nubus_proc_subdir(dev, e, &dir);
		}
	}
}

int nubus_proc_attach_device(struct nubus_dev *dev)
{
	struct proc_dir_entry *e;
	struct nubus_dir root;
	char name[8];

	if (dev == NULL) {
		printk(KERN_ERR
		       "NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
		return -1;
	}
		
	if (dev->board == NULL) {
		printk(KERN_ERR
		       "NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
		printk("dev = %p, dev->board = %p\n", dev, dev->board);
		return -1;
	}
		
	/* Create a directory */
	sprintf(name, "%x", dev->board->slot);
	e = dev->procdir = proc_mkdir(name, proc_bus_nubus_dir);
	if (!e)
		return -ENOMEM;

	/* Now recursively populate it with files */
	nubus_get_root_dir(dev->board, &root);
	nubus_proc_populate(dev, e, &root);

	return 0;
}
EXPORT_SYMBOL(nubus_proc_attach_device);

/* FIXME: this is certainly broken! */
int nubus_proc_detach_device(struct nubus_dev *dev)
{
	struct proc_dir_entry *e;

	if ((e = dev->procdir)) {
		if (atomic_read(&e->count))
			return -EBUSY;
		remove_proc_entry(e->name, proc_bus_nubus_dir);
		dev->procdir = NULL;
	}
	return 0;
}
EXPORT_SYMBOL(nubus_proc_detach_device);

void __init proc_bus_nubus_add_devices(void)
{
	struct nubus_dev *dev;
	
	for(dev = nubus_devices; dev; dev = dev->next)
		nubus_proc_attach_device(dev);
}

void __init nubus_proc_init(void)
{
	if (!MACH_IS_MAC)
		return;
	proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
	proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops);
	proc_bus_nubus_add_devices();
}
Commit	Line	Data
1da177e4 LT	1	/* drivers/nubus/proc.c: Proc FS interface for NuBus.
	2
	3	By David Huggins-Daines <dhd@debian.org>
	4
	5	Much code and many ideas from drivers/pci/proc.c:
	6	Copyright (c) 1997, 1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
	7
	8	This is initially based on the Zorro and PCI interfaces. However,
	9	it works somewhat differently. The intent is to provide a
	10	structure in /proc analogous to the structure of the NuBus ROM
	11	resources.
	12
	13	Therefore each NuBus device is in fact a directory, which may in
	14	turn contain subdirectories. The "files" correspond to NuBus
	15	resource records. For those types of records which we know how to
	16	convert to formats that are meaningful to userspace (mostly just
	17	icons) these files will provide "cooked" data. Otherwise they will
	18	simply provide raw access (read-only of course) to the ROM. */
	19
	20	#include <linux/types.h>
	21	#include <linux/kernel.h>
	22	#include <linux/nubus.h>
	23	#include <linux/proc_fs.h>
076ec04b	24	#include <linux/seq_file.h>
1da177e4	25	#include <linux/init.h>
99ffab81 AB	26	#include <linux/module.h>
99ffab81 AB	27
1da177e4 LT	28	#include <asm/uaccess.h>
	29	#include <asm/byteorder.h>
	30
	31	static int
076ec04b	32	nubus_devices_proc_show(struct seq_file m, void v)
1da177e4 LT	33	{
1da177e4 LT	34	struct nubus_dev *dev = nubus_devices;
1da177e4	35
076ec04b AD	36	while (dev) {
076ec04b AD	37	seq_printf(m, "%x\t%04x %04x %04x %04x",
1da177e4 LT	38	dev->board->slot,
	39	dev->category,
	40	dev->type,
	41	dev->dr_sw,
	42	dev->dr_hw);
076ec04b	43	seq_printf(m, "\t%08lx\n", dev->board->slot_addr);
1da177e4 LT	44	dev = dev->next;
1da177e4 LT	45	}
076ec04b AD	46	return 0;
	47	}
	48
	49	static int nubus_devices_proc_open(struct inode inode, struct file file)
	50	{
	51	return single_open(file, nubus_devices_proc_show, NULL);
1da177e4 LT	52	}
1da177e4 LT	53
076ec04b AD	54	static const struct file_operations nubus_devices_proc_fops = {
	55	.owner = THIS_MODULE,
	56	.open = nubus_devices_proc_open,
	57	.read = seq_read,
	58	.llseek = seq_lseek,
	59	.release = single_release,
	60	};
	61
1da177e4 LT	62	static struct proc_dir_entry *proc_bus_nubus_dir;
	63
	64	static void nubus_proc_subdir(struct nubus_dev* dev,
	65	struct proc_dir_entry* parent,
	66	struct nubus_dir* dir)
	67	{
	68	struct nubus_dirent ent;
	69
	70	/* Some of these are directories, others aren't */
	71	while (nubus_readdir(dir, &ent) != -1) {
	72	char name[8];
	73	struct proc_dir_entry* e;
	74
	75	sprintf(name, "%x", ent.type);
	76	e = create_proc_entry(name, S_IFREG \| S_IRUGO \|
	77	S_IWUSR, parent);
	78	if (!e) return;
	79	}
	80	}
	81
	82	/* Can't do this recursively since the root directory is structured
	83	somewhat differently from the subdirectories */
	84	static void nubus_proc_populate(struct nubus_dev* dev,
	85	struct proc_dir_entry* parent,
	86	struct nubus_dir* root)
	87	{
	88	struct nubus_dirent ent;
	89
	90	/* We know these are all directories (board resource + one or
	91	more functional resources) */
	92	while (nubus_readdir(root, &ent) != -1) {
	93	char name[8];
	94	struct proc_dir_entry* e;
	95	struct nubus_dir dir;
	96
	97	sprintf(name, "%x", ent.type);
	98	e = proc_mkdir(name, parent);
	99	if (!e) return;
	100
	101	/* And descend */
	102	if (nubus_get_subdir(&ent, &dir) == -1) {
	103	/* This shouldn't happen */
	104	printk(KERN_ERR "NuBus root directory node %x:%x has no subdir!\n",
	105	dev->board->slot, ent.type);
	106	continue;
	107	} else {
	108	nubus_proc_subdir(dev, e, &dir);
	109	}
	110	}
	111	}
	112
	113	int nubus_proc_attach_device(struct nubus_dev *dev)
	114	{
	115	struct proc_dir_entry *e;
	116	struct nubus_dir root;
	117	char name[8];
	118
	119	if (dev == NULL) {
	120	printk(KERN_ERR
	121	"NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
	122	return -1;
	123	}
	124
	125	if (dev->board == NULL) {
126	printk(KERN_ERR
127	"NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
128	printk("dev = %p, dev->board = %p\n", dev, dev->board);
129	return -1;
130	}
131
132	/* Create a directory */
133	sprintf(name, "%x", dev->board->slot);
134	e = dev->procdir = proc_mkdir(name, proc_bus_nubus_dir);
135	if (!e)
136	return -ENOMEM;
137
138	/* Now recursively populate it with files */
139	nubus_get_root_dir(dev->board, &root);
140	nubus_proc_populate(dev, e, &root);
141
142	return 0;
143	}
99ffab81	144	EXPORT_SYMBOL(nubus_proc_attach_device);
1da177e4 LT	145
	146	/* FIXME: this is certainly broken! */
	147	int nubus_proc_detach_device(struct nubus_dev *dev)
	148	{
	149	struct proc_dir_entry *e;
	150
	151	if ((e = dev->procdir)) {
	152	if (atomic_read(&e->count))
	153	return -EBUSY;
	154	remove_proc_entry(e->name, proc_bus_nubus_dir);
	155	dev->procdir = NULL;
	156	}
	157	return 0;
	158	}
99ffab81	159	EXPORT_SYMBOL(nubus_proc_detach_device);
1da177e4 LT	160
	161	void __init proc_bus_nubus_add_devices(void)
	162	{
	163	struct nubus_dev *dev;
	164
	165	for(dev = nubus_devices; dev; dev = dev->next)
	166	nubus_proc_attach_device(dev);
	167	}
	168
	169	void __init nubus_proc_init(void)
	170	{
	171	if (!MACH_IS_MAC)
	172	return;
9c37066d	173	proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
076ec04b	174	proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops);
1da177e4 LT	175	proc_bus_nubus_add_devices();
1da177e4 LT	176	}