[linux-2.6-block.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/init.h>
#include <linux/module.h>

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

static int
get_nubus_dev_info(char *buf, char **start, off_t pos, int count)
{
	struct nubus_dev *dev = nubus_devices;
	off_t at = 0;
	int len, cnt;

	cnt = 0;
	while (dev && count > cnt) {
		len = sprintf(buf, "%x\t%04x %04x %04x %04x",
			      dev->board->slot,
			      dev->category,
			      dev->type,
			      dev->dr_sw,
			      dev->dr_hw);
		len += sprintf(buf+len,
			       "\t%08lx",
			       dev->board->slot_addr);
		buf[len++] = '\n';
		at += len;
		if (at >= pos) {
			if (!*start) {
				*start = buf + (pos - (at - len));
				cnt = at - pos;
			} else
				cnt += len;
			buf += len;
		}
		dev = dev->next;
	}
	return (count > cnt) ? cnt : count;
}

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);
	create_proc_info_entry("devices", 0, proc_bus_nubus_dir,
				get_nubus_dev_info);
	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>
	24	#include <linux/init.h>
99ffab81 AB	25	#include <linux/module.h>
99ffab81 AB	26
1da177e4 LT	27	#include <asm/uaccess.h>
	28	#include <asm/byteorder.h>
	29
	30	static int
	31	get_nubus_dev_info(char buf, char *start, off_t pos, int count)
	32	{
	33	struct nubus_dev *dev = nubus_devices;
	34	off_t at = 0;
	35	int len, cnt;
	36
	37	cnt = 0;
	38	while (dev && count > cnt) {
	39	len = sprintf(buf, "%x\t%04x %04x %04x %04x",
	40	dev->board->slot,
	41	dev->category,
	42	dev->type,
	43	dev->dr_sw,
	44	dev->dr_hw);
	45	len += sprintf(buf+len,
	46	"\t%08lx",
	47	dev->board->slot_addr);
	48	buf[len++] = '\n';
	49	at += len;
	50	if (at >= pos) {
	51	if (!*start) {
	52	*start = buf + (pos - (at - len));
	53	cnt = at - pos;
	54	} else
	55	cnt += len;
	56	buf += len;
	57	}
	58	dev = dev->next;
	59	}
	60	return (count > cnt) ? cnt : count;
	61	}
	62
	63	static struct proc_dir_entry *proc_bus_nubus_dir;
	64
	65	static void nubus_proc_subdir(struct nubus_dev* dev,
	66	struct proc_dir_entry* parent,
	67	struct nubus_dir* dir)
	68	{
	69	struct nubus_dirent ent;
	70
	71	/* Some of these are directories, others aren't */
	72	while (nubus_readdir(dir, &ent) != -1) {
	73	char name[8];
	74	struct proc_dir_entry* e;
	75
	76	sprintf(name, "%x", ent.type);
	77	e = create_proc_entry(name, S_IFREG \| S_IRUGO \|
	78	S_IWUSR, parent);
	79	if (!e) return;
	80	}
	81	}
	82
	83	/* Can't do this recursively since the root directory is structured
	84	somewhat differently from the subdirectories */
	85	static void nubus_proc_populate(struct nubus_dev* dev,
	86	struct proc_dir_entry* parent,
	87	struct nubus_dir* root)
	88	{
	89	struct nubus_dirent ent;
	90
91	/* We know these are all directories (board resource + one or
92	more functional resources) */
93	while (nubus_readdir(root, &ent) != -1) {
94	char name[8];
95	struct proc_dir_entry* e;
96	struct nubus_dir dir;
97
98	sprintf(name, "%x", ent.type);
99	e = proc_mkdir(name, parent);
100	if (!e) return;
101
102	/* And descend */
103	if (nubus_get_subdir(&ent, &dir) == -1) {
104	/* This shouldn't happen */
105	printk(KERN_ERR "NuBus root directory node %x:%x has no subdir!\n",
106	dev->board->slot, ent.type);
107	continue;
108	} else {
109	nubus_proc_subdir(dev, e, &dir);
110	}
111	}
112	}
113
114	int nubus_proc_attach_device(struct nubus_dev *dev)
115	{
116	struct proc_dir_entry *e;
117	struct nubus_dir root;
118	char name[8];
119
120	if (dev == NULL) {
121	printk(KERN_ERR
122	"NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
123	return -1;
124	}
125
126	if (dev->board == NULL) {
127	printk(KERN_ERR
128	"NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
129	printk("dev = %p, dev->board = %p\n", dev, dev->board);
130	return -1;
131	}
132
133	/* Create a directory */
134	sprintf(name, "%x", dev->board->slot);
135	e = dev->procdir = proc_mkdir(name, proc_bus_nubus_dir);
136	if (!e)
137	return -ENOMEM;
138
139	/* Now recursively populate it with files */
140	nubus_get_root_dir(dev->board, &root);
141	nubus_proc_populate(dev, e, &root);
142
143	return 0;
144	}
99ffab81	145	EXPORT_SYMBOL(nubus_proc_attach_device);
1da177e4 LT	146
	147	/* FIXME: this is certainly broken! */
	148	int nubus_proc_detach_device(struct nubus_dev *dev)
	149	{
	150	struct proc_dir_entry *e;
	151
	152	if ((e = dev->procdir)) {
	153	if (atomic_read(&e->count))
	154	return -EBUSY;
	155	remove_proc_entry(e->name, proc_bus_nubus_dir);
	156	dev->procdir = NULL;
	157	}
	158	return 0;
	159	}
99ffab81	160	EXPORT_SYMBOL(nubus_proc_detach_device);
1da177e4 LT	161
	162	void __init proc_bus_nubus_add_devices(void)
	163	{
	164	struct nubus_dev *dev;
	165
	166	for(dev = nubus_devices; dev; dev = dev->next)
	167	nubus_proc_attach_device(dev);
	168	}
	169
	170	void __init nubus_proc_init(void)
	171	{
	172	if (!MACH_IS_MAC)
	173	return;
9c37066d	174	proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
1da177e4 LT	175	create_proc_info_entry("devices", 0, proc_bus_nubus_dir,
	176	get_nubus_dev_info);
	177	proc_bus_nubus_add_devices();
	178	}