From 2c3c1048746a4622d8c89a29670120dc8fab93c4 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:49:45 +0200 Subject: Adding upstream version 6.1.76. Signed-off-by: Daniel Baumann --- drivers/dio/Makefile | 6 + drivers/dio/dio-driver.c | 142 +++++++++++++++++++++++ drivers/dio/dio-sysfs.c | 82 ++++++++++++++ drivers/dio/dio.c | 287 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 517 insertions(+) create mode 100644 drivers/dio/Makefile create mode 100644 drivers/dio/dio-driver.c create mode 100644 drivers/dio/dio-sysfs.c create mode 100644 drivers/dio/dio.c (limited to 'drivers/dio') diff --git a/drivers/dio/Makefile b/drivers/dio/Makefile new file mode 100644 index 000000000..11202f2bb --- /dev/null +++ b/drivers/dio/Makefile @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# 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 000000000..69c46935f --- /dev/null +++ b/drivers/dio/dio-driver.c @@ -0,0 +1,142 @@ +/* + * 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 +#include +#include + + +/** + * 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 + * @d: 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 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 zero or a negative error value. + */ + +int dio_register_driver(struct dio_driver *drv) +{ + /* initialize common driver fields */ + drv->driver.name = drv->name; + drv->driver.bus = &dio_bus_type; + + /* register with core */ + return driver_register(&drv->driver); +} + + +/** + * 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 + * @dev: the DIO device structure to match against + * @drv: the &device_driver that points to the array of DIO device id structures to search + * + * Used by the driver core to check whether a DIO device present in the + * system is in a driver's list of supported devices. Returns 1 if supported, + * and 0 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; + + return dio_match_device(ids, d) ? 1 : 0; +} + + +struct bus_type dio_bus_type = { + .name = "dio", + .match = dio_bus_match, + .probe = dio_device_probe, +}; + + +static int __init dio_driver_init(void) +{ + return bus_register(&dio_bus_type); +} + +postcore_initcall(dio_driver_init); + +EXPORT_SYMBOL(dio_register_driver); +EXPORT_SYMBOL(dio_unregister_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 000000000..ee1a3b59b --- /dev/null +++ b/drivers/dio/dio-sysfs.c @@ -0,0 +1,82 @@ +/* + * 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 +#include +#include + +/* show configuration fields */ + +static ssize_t dio_show_id(struct device *dev, struct device_attribute *attr, 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, struct device_attribute *attr, 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, struct device_attribute *attr, 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, struct device_attribute *attr, 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, struct device_attribute *attr, char *buf) +{ + struct dio_dev *d = to_dio_dev(dev); + + return sprintf(buf, "0x%08lx 0x%08lx 0x%08lx\n", + (unsigned long)dio_resource_start(d), + (unsigned long)dio_resource_end(d), + dio_resource_flags(d)); +} +static DEVICE_ATTR(resource, S_IRUGO, dio_show_resource, NULL); + +int dio_create_sysfs_dev_files(struct dio_dev *d) +{ + struct device *dev = &d->dev; + int error; + + /* current configuration's attributes */ + if ((error = device_create_file(dev, &dev_attr_id)) || + (error = device_create_file(dev, &dev_attr_ipl)) || + (error = device_create_file(dev, &dev_attr_secid)) || + (error = device_create_file(dev, &dev_attr_name)) || + (error = device_create_file(dev, &dev_attr_resource))) + return error; + + return 0; +} + diff --git a/drivers/dio/dio.c b/drivers/dio/dio.c new file mode 100644 index 000000000..0a051d656 --- /dev/null +++ b/drivers/dio/dio.c @@ -0,0 +1,287 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Code to support devices on the DIO and DIO-II bus + * Copyright (C) 05/1998 Peter Maydell + * Copyright (C) 2004 Jochen Friedrich + * + * 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 +#include +#include +#include +#include +#include +#include /* kmalloc() */ +#include +#include /* 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 + +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 < ARRAY_SIZE(names); 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 */ + +static void dio_dev_release(struct device *dev) +{ + struct dio_dev *ddev = container_of(dev, typeof(struct dio_dev), dev); + kfree(ddev); +} + +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; + + 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); + + if (copy_from_kernel_nofault(&i, + (unsigned char *)va + DIO_IDOFF, 1)) { + if (scode >= DIOII_SCBASE) + iounmap(va); + continue; /* no board present at that select code */ + } + + 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; + int i; + struct dio_dev *dev; + int error; + + if (!MACH_IS_HP300) + return 0; + + printk(KERN_INFO "Scanning for DIO devices...\n"); + + /* Initialize the DIO bus */ + INIT_LIST_HEAD(&dio_bus.devices); + dev_set_name(&dio_bus.dev, "dio"); + error = device_register(&dio_bus.dev); + if (error) { + pr_err("DIO: Error registering dio_bus\n"); + return error; + } + + /* 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); + + if (copy_from_kernel_nofault(&i, + (unsigned char *)va + DIO_IDOFF, 1)) { + if (scode >= DIOII_SCBASE) + iounmap(va); + continue; /* no board present at that select code */ + } + + /* Found a board, allocate it an entry in the list */ + dev = kzalloc(sizeof(struct dio_dev), GFP_KERNEL); + if (!dev) { + if (scode >= DIOII_SCBASE) + iounmap(va); + return -ENOMEM; + } + + dev->bus = &dio_bus; + dev->dev.parent = &dio_bus.dev; + dev->dev.bus = &dio_bus_type; + dev->dev.release = dio_dev_release; + dev->scode = scode; + dev->resource.start = pa; + dev->resource.end = pa + DIO_SIZE(scode, va); + dev_set_name(&dev->dev, "%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); + error = device_register(&dev->dev); + if (error) { + pr_err("DIO: Error registering device %s\n", + dev->name); + put_device(&dev->dev); + continue; + } + error = dio_create_sysfs_dev_files(dev); + if (error) + dev_err(&dev->dev, "Error creating sysfs files\n"); + } + 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); +} -- cgit v1.2.3