sysfs EISA support

Base patch adding sysfs support for the EISA bus

arch/alpha/Kconfig

@@ -535,6 +535,7 @@ config VERBOSE_MCHECK
 	bool "Verbose Machine Checks"
 
 source "drivers/pci/Kconfig"
+source "drivers/eisa/Kconfig"
 
 config HOTPLUG
 	bool "Support for hot-pluggable devices"

arch/i386/Kconfig

@@ -1181,6 +1181,8 @@ config EISA
 
 	  Otherwise, say N.
 
+source "drivers/eisa/Kconfig"
+
 config MCA
 	bool "MCA support"
 	depends on !(X86_VISWS || X86_VOYAGER)

drivers/Makefile

@@ -44,3 +44,4 @@ obj-$(CONFIG_BT)		+= bluetooth/
 obj-$(CONFIG_HOTPLUG_PCI)	+= hotplug/
 obj-$(CONFIG_ISDN_BOOL)		+= isdn/
 obj-$(CONFIG_MCA)		+= mca/
+obj-$(CONFIG_EISA)		+= eisa/

drivers/eisa/Kconfig

+#
+# PCI configuration
+#
+config EISA_NAMES
+	bool "EISA device name database"
+	depends on EISA
+	default y
+	---help---
+	  By default, the kernel contains a database of all known EISA
+	  device names to make the information in sysfs comprehensible
+	  to the user. This database increases size of the kernel
+	  image by about 40KB, but it gets freed after the system
+	  boots up, so it doesn't take up kernel memory. Anyway, if
+	  you are building an installation floppy or kernel for an
+	  embedded system where kernel image size really matters, you
+	  can disable this feature and you'll get device ID instead of
+	  names.
+
+	  When in doubt, say Y.
+

drivers/eisa/Makefile

+# Makefile for the Linux device tree
+
+obj-$(CONFIG_EISA)	+= eisa-bus.o
+
+export-objs	:= eisa-bus.o
+
+clean-files:= devlist.h
+
+# Ugly hack to get DEVICE_NAME_SIZE value...
+DEVICE_NAME_SIZE:=$(shell awk '$$1=="\#define" && $$2=="DEVICE_NAME_SIZE" {print $$3-1}' $(srctree)/include/linux/device.h)
+
+$(obj)/eisa-bus.o: $(obj)/devlist.h
+
+$(obj)/devlist.h: $(src)/eisa.ids $(srctree)/include/linux/device.h
+	sed -e '/^#/D' -e 's/^\([[:alnum:]]\{7\}\) \+"\([^"]\{1,$(DEVICE_NAME_SIZE)\}\).*"/EISA_DEVINFO ("\1", "\2"),/' $< > $@
+
+$(src)/eisa.ids:
+	touch $@

drivers/eisa/eisa-bus.c

+/*
+ * EISA bus support functions for sysfs.
+ *
+ * (C) 2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
+ *
+ * This code is released under the GPL version 2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/eisa.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <asm/io.h>
+
+#define EISA_DEVINFO(i,s) { .id = { .sig = i }, .name = s }
+
+struct eisa_device_info {
+	struct eisa_device_id id;
+	char name[DEVICE_NAME_SIZE];
+};
+
+struct eisa_device_info __initdata eisa_table[] = {
+#ifdef CONFIG_EISA_NAMES
+#include "devlist.h"
+#endif
+};
+
+#define EISA_INFOS (sizeof (eisa_table) / (sizeof (struct eisa_device_info)))
+
+static void __init eisa_name_device (struct eisa_device *edev)
+{
+	int i;
+
+	for (i = 0; i < EISA_INFOS; i++) {
+		if (!strcmp (edev->id.sig, eisa_table[i].id.sig)) {
+			strncpy (edev->dev.name,
+				 eisa_table[i].name,
+				 DEVICE_NAME_SIZE - 1);
+			return;
+		}
+	}
+
+	/* No name was found */
+	sprintf (edev->dev.name, "EISA device %.7s", edev->id.sig);
+}
+
+static char __init *decode_eisa_sig(unsigned long addr)
+{
+        static char sig_str[EISA_SIG_LEN];
+	u8 sig[4];
+        u16 rev;
+	int i;
+
+	sig[0] = inb (addr);
+
+	if (sig[0] & 0x80)
+                return NULL;
+
+	for (i = 1; i < 4; i++)
+		sig[i] = inb (addr + i);
+	
+        sig_str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
+        sig_str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
+        sig_str[2] = (sig[1] & 0x1f) + ('A' - 1);
+        rev = (sig[2] << 8) | sig[3];
+        sprintf(sig_str + 3, "%04X", rev);
+
+        return sig_str;
+}
+
+static int eisa_bus_match (struct device *dev, struct device_driver *drv)
+{
+	struct eisa_device *edev = to_eisa_device (dev);
+	struct eisa_driver *edrv = to_eisa_driver (drv);
+	const struct eisa_device_id *eids = edrv->id_table;
+
+	if (!eids)
+		return 0;
+
+	while (strlen (eids->sig)) {
+		if (!strcmp (eids->sig, edev->id.sig))
+			return 1;
+
+		eids++;
+	}
+
+	return 0;
+}
+
+struct bus_type eisa_bus_type = {
+	.name  = "eisa",
+	.match = eisa_bus_match,
+};
+
+/* The default EISA device parent (virtual root device). */
+static struct device eisa_bus_root = {
+       .name           = "EISA Bridge",
+       .bus_id         = "eisa",
+};
+
+int eisa_driver_register (struct eisa_driver *edrv)
+{
+	int r;
+	
+	edrv->driver.bus = &eisa_bus_type;
+	if ((r = driver_register (&edrv->driver)) < 0)
+		return r;
+
+	return 1;
+}
+
+void eisa_driver_unregister (struct eisa_driver *edrv)
+{
+	bus_remove_driver (&edrv->driver);
+	driver_unregister (&edrv->driver);
+}
+
+static ssize_t eisa_show_sig (struct device *dev, char *buf)
+{
+        struct eisa_device *edev = to_eisa_device (dev);
+        return sprintf (buf,"%s\n", edev->id.sig);
+}
+
+static DEVICE_ATTR(signature, S_IRUGO, eisa_show_sig, NULL);
+
+static void __init eisa_register_device (char *sig, int slot)
+{
+	struct eisa_device *edev;
+
+	if (!(edev = kmalloc (sizeof (*edev), GFP_KERNEL)))
+		return;
+
+	memset (edev, 0, sizeof (*edev));
+	memcpy (edev->id.sig, sig, 7);
+	edev->slot = slot;
+	edev->base_addr = 0x1000 * slot;
+	eisa_name_device (edev);
+	edev->dev.parent = &eisa_bus_root;
+	edev->dev.bus = &eisa_bus_type;
+	sprintf (edev->dev.bus_id, "00:%02X", slot);
+
+	/* Don't register resource for slot 0, since this will surely
+	 * fail... :-( */
+
+	if (slot) {
+		edev->res.name  = edev->dev.name;
+		edev->res.start = edev->base_addr;
+		edev->res.end   = edev->res.start + 0xfff;
+		edev->res.flags = IORESOURCE_IO;
+
+		if (request_resource (&ioport_resource, &edev->res)) {
+			printk (KERN_WARNING \
+				"Cannot allocate resource for EISA slot %d\n",
+				slot);
+			kfree (edev);
+			return;
+		}
+	}
+	
+	if (device_register (&edev->dev)) {
+		kfree (edev);
+		return;
+	}
+
+	device_create_file (&edev->dev, &dev_attr_signature);
+}
+
+static int __init eisa_probe (void)
+{
+        int i, c;
+        char *str;
+        unsigned long slot_addr;
+
+        printk (KERN_INFO "EISA: Probing bus...\n");
+        for (c = 0, i = 0; i <= EISA_MAX_SLOTS; i++) {
+                slot_addr = (0x1000 * i) + EISA_VENDOR_ID_OFFSET;
+                if ((str = decode_eisa_sig (slot_addr))) {
+			if (!i)
+				printk (KERN_INFO "EISA: Motherboard %s detected\n",
+					str);
+			else {
+				printk (KERN_INFO "EISA: slot %d : %s detected.\n",
+					i, str);
+
+				c++;
+			}
+
+			eisa_register_device (str, i);
+                }
+        }
+        printk (KERN_INFO "EISA: Detected %d card%s.\n", c, c < 2 ? "" : "s");
+
+	return 0;
+}
+
+static int __init eisa_init (void)
+{
+	int r;
+	
+	if ((r = bus_register (&eisa_bus_type)))
+		return r;
+	
+	if ((r = device_register (&eisa_bus_root))) {
+		bus_unregister (&eisa_bus_type);
+		return r;
+	}
+
+	printk (KERN_INFO "EISA bus registered\n");
+	return eisa_probe ();
+}
+
+postcore_initcall (eisa_init);
+
+EXPORT_SYMBOL (eisa_bus_type);
+EXPORT_SYMBOL (eisa_driver_register);
+EXPORT_SYMBOL (eisa_driver_unregister);

drivers/parisc/Kconfig

@@ -54,6 +54,8 @@ config EISA
 	  supports both the Mongoose & Wax EISA adapters.  It is sadly
 	  incomplete and lacks support for card-to-host DMA.
 
+source "drivers/eisa/Kconfig"
+
 config ISA
 	bool
 	depends on EISA

include/linux/eisa.h

+#ifndef _LINUX_EISA_H
+#define _LINUX_EISA_H
+
+#define EISA_SIG_LEN   8
+#define EISA_MAX_SLOTS 8
+
+/* A few EISA constants/offsets... */
+
+#define EISA_DMA1_STATUS            8
+#define EISA_INT1_CTRL           0x20
+#define EISA_INT1_MASK           0x21
+#define EISA_INT2_CTRL           0xA0
+#define EISA_INT2_MASK           0xA1
+#define EISA_DMA2_STATUS         0xD0
+#define EISA_DMA2_WRITE_SINGLE   0xD4
+#define EISA_EXT_NMI_RESET_CTRL 0x461
+#define EISA_INT1_EDGE_LEVEL    0x4D0
+#define EISA_INT2_EDGE_LEVEL    0x4D1
+#define EISA_VENDOR_ID_OFFSET   0xC80
+
+/* The EISA signature, in ASCII form, null terminated */
+struct eisa_device_id {
+	char sig[EISA_SIG_LEN];
+};
+
+/* There is not much we can say about an EISA device, apart from
+ * signature, slot number, and base address */
+struct eisa_device {
+	struct eisa_device_id id;
+	int                   slot;
+	unsigned long         base_addr;
+	struct resource       res;
+	struct device         dev; /* generic device */
+};
+
+#define to_eisa_device(n) container_of(n, struct eisa_device, dev)
+
+struct eisa_driver {
+	const struct eisa_device_id *id_table;
+	struct device_driver         driver;
+};
+
+#define to_eisa_driver(drv) container_of(drv,struct eisa_driver, driver)
+
+extern struct bus_type eisa_bus_type;
+int eisa_driver_register (struct eisa_driver *edrv);
+void eisa_driver_unregister (struct eisa_driver *edrv);
+
+/* Mimics pci.h... */
+static inline void *eisa_get_drvdata (struct eisa_device *edev)
+{
+        return edev->dev.driver_data;
+}
+
+static inline void eisa_set_drvdata (struct eisa_device *edev, void *data)
+{
+        edev->dev.driver_data = data;
+}
+
+#endif