diff options
Diffstat (limited to 'drivers/dio')
| -rw-r--r-- | drivers/dio/Makefile | 5 | ||||
| -rw-r--r-- | drivers/dio/dio-driver.c | 163 | ||||
| -rw-r--r-- | drivers/dio/dio-sysfs.c | 77 | ||||
| -rw-r--r-- | drivers/dio/dio.c | 279 |
4 files changed, 524 insertions, 0 deletions
diff --git a/drivers/dio/Makefile b/drivers/dio/Makefile new file mode 100644 index 0000000..ae92d17 --- /dev/null +++ b/drivers/dio/Makefile @@ -0,0 +1,5 @@ +# +# Makefile for the linux kernel. +# + +obj-y := dio.o dio-driver.o dio-sysfs.o diff --git a/drivers/dio/dio-driver.c b/drivers/dio/dio-driver.c new file mode 100644 index 0000000..ffe6f44 --- /dev/null +++ b/drivers/dio/dio-driver.c @@ -0,0 +1,163 @@ +/* + * DIO Driver Services + * + * Copyright (C) 2004 Jochen Friedrich + * + * Loosely based on drivers/pci/pci-driver.c and drivers/zorro/zorro-driver.c + * + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file COPYING in the main directory of this archive + * for more details. + */ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/dio.h> + + + /** + * dio_match_device - Tell if a DIO device structure has a matching + * DIO device id structure + * @ids: array of DIO device id structures to search in + * @dev: the DIO device structure to match against + * + * Used by a driver to check whether a DIO device present in the + * system is in its list of supported devices. Returns the matching + * dio_device_id structure or %NULL if there is no match. + */ + +const struct dio_device_id * +dio_match_device(const struct dio_device_id *ids, + const struct dio_dev *d) +{ + while (ids->id) { + if (ids->id == DIO_WILDCARD) + return ids; + if (DIO_NEEDSSECID(ids->id & 0xff)) { + if (ids->id == d->id) + return ids; + } else { + if ((ids->id & 0xff) == (d->id & 0xff)) + return ids; + } + ids++; + } + return NULL; +} + +static int dio_device_probe(struct device *dev) +{ + int error = 0; + struct dio_driver *drv = to_dio_driver(dev->driver); + struct dio_dev *d = to_dio_dev(dev); + + if (!d->driver && drv->probe) { + const struct dio_device_id *id; + + id = dio_match_device(drv->id_table, d); + if (id) + error = drv->probe(d, id); + if (error >= 0) { + d->driver = drv; + error = 0; + } + } + return error; +} + + + /** + * dio_register_driver - register a new DIO driver + * @drv: the driver structure to register + * + * Adds the driver structure to the list of registered drivers + * Returns the number of DIO devices which were claimed by the driver + * during registration. The driver remains registered even if the + * return value is zero. + */ + +int dio_register_driver(struct dio_driver *drv) +{ + int count = 0; + + /* initialize common driver fields */ + drv->driver.name = drv->name; + drv->driver.bus = &dio_bus_type; + drv->driver.probe = dio_device_probe; + + /* register with core */ + count = driver_register(&drv->driver); + return count ? count : 1; +} + + + /** + * dio_unregister_driver - unregister a DIO driver + * @drv: the driver structure to unregister + * + * Deletes the driver structure from the list of registered DIO drivers, + * gives it a chance to clean up by calling its remove() function for + * each device it was responsible for, and marks those devices as + * driverless. + */ + +void dio_unregister_driver(struct dio_driver *drv) +{ + driver_unregister(&drv->driver); +} + + + /** + * dio_bus_match - Tell if a DIO device structure has a matching DIO + * device id structure + * @ids: array of DIO device id structures to search in + * @dev: the DIO device structure to match against + * + * Used by a driver to check whether a DIO device present in the + * system is in its list of supported devices. Returns the matching + * dio_device_id structure or %NULL if there is no match. + */ + +static int dio_bus_match(struct device *dev, struct device_driver *drv) +{ + struct dio_dev *d = to_dio_dev(dev); + struct dio_driver *dio_drv = to_dio_driver(drv); + const struct dio_device_id *ids = dio_drv->id_table; + + if (!ids) + return 0; + + while (ids->id) { + if (ids->id == DIO_WILDCARD) + return 1; + if (DIO_NEEDSSECID(ids->id & 0xff)) { + if (ids->id == d->id) + return 1; + } else { + if ((ids->id & 0xff) == (d->id & 0xff)) + return 1; + } + ids++; + } + return 0; +} + + +struct bus_type dio_bus_type = { + .name = "dio", + .match = dio_bus_match +}; + + +static int __init dio_driver_init(void) +{ + return bus_register(&dio_bus_type); +} + +postcore_initcall(dio_driver_init); + +EXPORT_SYMBOL(dio_match_device); +EXPORT_SYMBOL(dio_register_driver); +EXPORT_SYMBOL(dio_unregister_driver); +EXPORT_SYMBOL(dio_dev_driver); +EXPORT_SYMBOL(dio_bus_type); diff --git a/drivers/dio/dio-sysfs.c b/drivers/dio/dio-sysfs.c new file mode 100644 index 0000000..d30591f --- /dev/null +++ b/drivers/dio/dio-sysfs.c @@ -0,0 +1,77 @@ +/* + * File Attributes for DIO Devices + * + * Copyright (C) 2004 Jochen Friedrich + * + * Loosely based on drivers/pci/pci-sysfs.c and drivers/zorro/zorro-sysfs.c + * + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file COPYING in the main directory of this archive + * for more details. + */ + + +#include <linux/kernel.h> +#include <linux/dio.h> +#include <linux/stat.h> + +/* show configuration fields */ + +static ssize_t dio_show_id(struct device *dev, char *buf) +{ + struct dio_dev *d; + + d = to_dio_dev(dev); + return sprintf(buf, "0x%02x\n", (d->id & 0xff)); +} +static DEVICE_ATTR(id, S_IRUGO, dio_show_id, NULL); + +static ssize_t dio_show_ipl(struct device *dev, char *buf) +{ + struct dio_dev *d; + + d = to_dio_dev(dev); + return sprintf(buf, "0x%02x\n", d->ipl); +} +static DEVICE_ATTR(ipl, S_IRUGO, dio_show_ipl, NULL); + +static ssize_t dio_show_secid(struct device *dev, char *buf) +{ + struct dio_dev *d; + + d = to_dio_dev(dev); + return sprintf(buf, "0x%02x\n", ((d->id >> 8)& 0xff)); +} +static DEVICE_ATTR(secid, S_IRUGO, dio_show_secid, NULL); + +static ssize_t dio_show_name(struct device *dev, char *buf) +{ + struct dio_dev *d; + + d = to_dio_dev(dev); + return sprintf(buf, "%s\n", d->name); +} +static DEVICE_ATTR(name, S_IRUGO, dio_show_name, NULL); + +static ssize_t dio_show_resource(struct device *dev, char *buf) +{ + struct dio_dev *d = to_dio_dev(dev); + + return sprintf(buf, "0x%08lx 0x%08lx 0x%08lx\n", + dio_resource_start(d), dio_resource_end(d), + dio_resource_flags(d)); +} +static DEVICE_ATTR(resource, S_IRUGO, dio_show_resource, NULL); + +void dio_create_sysfs_dev_files(struct dio_dev *d) +{ + struct device *dev = &d->dev; + + /* current configuration's attributes */ + device_create_file(dev, &dev_attr_id); + device_create_file(dev, &dev_attr_ipl); + device_create_file(dev, &dev_attr_secid); + device_create_file(dev, &dev_attr_name); + device_create_file(dev, &dev_attr_resource); +} + diff --git a/drivers/dio/dio.c b/drivers/dio/dio.c new file mode 100644 index 0000000..a620f7d --- /dev/null +++ b/drivers/dio/dio.c @@ -0,0 +1,279 @@ +/* Code to support devices on the DIO and DIO-II bus + * Copyright (C) 05/1998 Peter Maydell <pmaydell@chiark.greenend.org.uk> + * Copyright (C) 2004 Jochen Friedrich <jochen@scram.de> + * + * This code has basically these routines at the moment: + * int dio_find(u_int deviceid) + * Search the list of DIO devices and return the select code + * of the next unconfigured device found that matches the given device ID. + * Note that the deviceid parameter should be the encoded ID. + * This means that framebuffers should pass it as + * DIO_ENCODE_ID(DIO_ID_FBUFFER,DIO_ID2_TOPCAT) + * (or whatever); everybody else just uses DIO_ID_FOOBAR. + * unsigned long dio_scodetophysaddr(int scode) + * Return the physical address corresponding to the given select code. + * int dio_scodetoipl(int scode) + * Every DIO card has a fixed interrupt priority level. This function + * returns it, whatever it is. + * const char *dio_scodetoname(int scode) + * Return a character string describing this board [might be "" if + * not CONFIG_DIO_CONSTANTS] + * void dio_config_board(int scode) mark board as configured in the list + * void dio_unconfig_board(int scode) mark board as no longer configured + * + * This file is based on the way the Amiga port handles Zorro II cards, + * although we aren't so complicated... + */ +#include <linux/module.h> +#include <linux/string.h> +#include <linux/types.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/dio.h> +#include <linux/slab.h> /* kmalloc() */ +#include <asm/uaccess.h> +#include <asm/io.h> /* readb() */ + +struct dio_bus dio_bus = { + .resources = { + /* DIO range */ + { .name = "DIO mem", .start = 0x00600000, .end = 0x007fffff }, + /* DIO-II range */ + { .name = "DIO-II mem", .start = 0x01000000, .end = 0x1fffffff } + }, + .name = "DIO bus" +}; + +/* not a real config option yet! */ +#define CONFIG_DIO_CONSTANTS + +#ifdef CONFIG_DIO_CONSTANTS +/* We associate each numeric ID with an appropriate descriptive string + * using a constant array of these structs. + * FIXME: we should be able to arrange to throw away most of the strings + * using the initdata stuff. Then we wouldn't need to worry about + * carrying them around... + * I think we do this by copying them into newly kmalloc()ed memory and + * marking the names[] array as .initdata ? + */ +struct dioname +{ + int id; + const char *name; +}; + +/* useful macro */ +#define DIONAME(x) { DIO_ID_##x, DIO_DESC_##x } +#define DIOFBNAME(x) { DIO_ENCODE_ID( DIO_ID_FBUFFER, DIO_ID2_##x), DIO_DESC2_##x } + +static struct dioname names[] = +{ + DIONAME(DCA0), DIONAME(DCA0REM), DIONAME(DCA1), DIONAME(DCA1REM), + DIONAME(DCM), DIONAME(DCMREM), + DIONAME(LAN), + DIONAME(FHPIB), DIONAME(NHPIB), + DIONAME(SCSI0), DIONAME(SCSI1), DIONAME(SCSI2), DIONAME(SCSI3), + DIONAME(FBUFFER), + DIONAME(PARALLEL), DIONAME(VME), DIONAME(DCL), DIONAME(DCLREM), + DIONAME(MISC0), DIONAME(MISC1), DIONAME(MISC2), DIONAME(MISC3), + DIONAME(MISC4), DIONAME(MISC5), DIONAME(MISC6), DIONAME(MISC7), + DIONAME(MISC8), DIONAME(MISC9), DIONAME(MISC10), DIONAME(MISC11), + DIONAME(MISC12), DIONAME(MISC13), + DIOFBNAME(GATORBOX), DIOFBNAME(TOPCAT), DIOFBNAME(RENAISSANCE), + DIOFBNAME(LRCATSEYE), DIOFBNAME(HRCCATSEYE), DIOFBNAME(HRMCATSEYE), + DIOFBNAME(DAVINCI), DIOFBNAME(XXXCATSEYE), DIOFBNAME(HYPERION), + DIOFBNAME(XGENESIS), DIOFBNAME(TIGER), DIOFBNAME(YGENESIS) +}; + +#undef DIONAME +#undef DIOFBNAME + +#define NUMNAMES (sizeof(names) / sizeof(struct dioname)) + +static const char *unknowndioname + = "unknown DIO board -- please email <linux-m68k@lists.linux-m68k.org>!"; + +static const char *dio_getname(int id) +{ + /* return pointer to a constant string describing the board with given ID */ + unsigned int i; + for (i = 0; i < NUMNAMES; i++) + if (names[i].id == id) + return names[i].name; + + return unknowndioname; +} + +#else + +static char dio_no_name[] = { 0 }; +#define dio_getname(_id) (dio_no_name) + +#endif /* CONFIG_DIO_CONSTANTS */ + +int __init dio_find(int deviceid) +{ + /* Called to find a DIO device before the full bus scan has run. + * Only used by the console driver. + */ + int scode, id; + u_char prid, secid, i; + mm_segment_t fs; + + for (scode = 0; scode < DIO_SCMAX; scode++) { + void *va; + unsigned long pa; + + if (DIO_SCINHOLE(scode)) + continue; + + pa = dio_scodetophysaddr(scode); + + if (!pa) + continue; + + if (scode < DIOII_SCBASE) + va = (void *)(pa + DIO_VIRADDRBASE); + else + va = ioremap(pa, PAGE_SIZE); + + fs = get_fs(); + set_fs(KERNEL_DS); + + if (get_user(i, (unsigned char *)va + DIO_IDOFF)) { + set_fs(fs); + if (scode >= DIOII_SCBASE) + iounmap(va); + continue; /* no board present at that select code */ + } + + set_fs(fs); + prid = DIO_ID(va); + + if (DIO_NEEDSSECID(prid)) { + secid = DIO_SECID(va); + id = DIO_ENCODE_ID(prid, secid); + } else + id = prid; + + if (id == deviceid) { + if (scode >= DIOII_SCBASE) + iounmap(va); + return scode; + } + } + + return -1; +} + +/* This is the function that scans the DIO space and works out what + * hardware is actually present. + */ +static int __init dio_init(void) +{ + int scode; + mm_segment_t fs; + int i; + struct dio_dev *dev; + + if (!MACH_IS_HP300) + return 0; + + printk(KERN_INFO "Scanning for DIO devices...\n"); + + /* Initialize the DIO bus */ + INIT_LIST_HEAD(&dio_bus.devices); + strcpy(dio_bus.dev.bus_id, "dio"); + device_register(&dio_bus.dev); + + /* Request all resources */ + dio_bus.num_resources = (hp300_model == HP_320 ? 1 : 2); + for (i = 0; i < dio_bus.num_resources; i++) + request_resource(&iomem_resource, &dio_bus.resources[i]); + + /* Register all devices */ + for (scode = 0; scode < DIO_SCMAX; ++scode) + { + u_char prid, secid = 0; /* primary, secondary ID bytes */ + u_char *va; + unsigned long pa; + + if (DIO_SCINHOLE(scode)) + continue; + + pa = dio_scodetophysaddr(scode); + + if (!pa) + continue; + + if (scode < DIOII_SCBASE) + va = (void *)(pa + DIO_VIRADDRBASE); + else + va = ioremap(pa, PAGE_SIZE); + + fs = get_fs(); + set_fs(KERNEL_DS); + + if (get_user(i, (unsigned char *)va + DIO_IDOFF)) { + set_fs(fs); + if (scode >= DIOII_SCBASE) + iounmap(va); + continue; /* no board present at that select code */ + } + + set_fs(fs); + + /* Found a board, allocate it an entry in the list */ + dev = kmalloc(sizeof(struct dio_dev), GFP_KERNEL); + if (!dev) + return 0; + + memset(dev, 0, sizeof(struct dio_dev)); + dev->bus = &dio_bus; + dev->dev.parent = &dio_bus.dev; + dev->dev.bus = &dio_bus_type; + dev->scode = scode; + dev->resource.start = pa; + dev->resource.end = pa + DIO_SIZE(scode, va); + sprintf(dev->dev.bus_id,"%02x", scode); + + /* read the ID byte(s) and encode if necessary. */ + prid = DIO_ID(va); + + if (DIO_NEEDSSECID(prid)) { + secid = DIO_SECID(va); + dev->id = DIO_ENCODE_ID(prid, secid); + } else + dev->id = prid; + + dev->ipl = DIO_IPL(va); + strcpy(dev->name,dio_getname(dev->id)); + printk(KERN_INFO "select code %3d: ipl %d: ID %02X", dev->scode, dev->ipl, prid); + if (DIO_NEEDSSECID(prid)) + printk(":%02X", secid); + printk(": %s\n", dev->name); + + if (scode >= DIOII_SCBASE) + iounmap(va); + device_register(&dev->dev); + dio_create_sysfs_dev_files(dev); + } + return 0; +} + +subsys_initcall(dio_init); + +/* Bear in mind that this is called in the very early stages of initialisation + * in order to get the address of the serial port for the console... + */ +unsigned long dio_scodetophysaddr(int scode) +{ + if (scode >= DIOII_SCBASE) { + return (DIOII_BASE + (scode - 132) * DIOII_DEVSIZE); + } else if (scode > DIO_SCMAX || scode < 0) + return 0; + else if (DIO_SCINHOLE(scode)) + return 0; + + return (DIO_BASE + scode * DIO_DEVSIZE); +} |
