Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1760851Ab2JaVzW (ORCPT ); Wed, 31 Oct 2012 17:55:22 -0400 Received: from mail-ee0-f46.google.com ([74.125.83.46]:53864 "EHLO mail-ee0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759992Ab2JaVzU (ORCPT ); Wed, 31 Oct 2012 17:55:20 -0400 MIME-Version: 1.0 In-Reply-To: <1351702333-8456-2-git-send-email-panto@antoniou-consulting.com> References: <1351702333-8456-1-git-send-email-panto@antoniou-consulting.com> <1351702333-8456-2-git-send-email-panto@antoniou-consulting.com> Date: Wed, 31 Oct 2012 14:55:18 -0700 X-Google-Sender-Auth: c-nfS4JKqHxfYhKptSuB2heCC5M Message-ID: Subject: Re: [RFC 1/7] capebus: Core capebus support From: Russ Dill To: Pantelis Antoniou Cc: Tony Lindgren , linux-arm-kernel@lists.infradead.org, devicetree-discuss@lists.ozlabs.org, linux-kernel@vger.kernel.org, Koen Kooi , Matt Porter , linux-omap@vger.kernel.org Content-Type: text/plain; charset=UTF-8 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 47677 Lines: 1408 On Wed, Oct 31, 2012 at 9:52 AM, Pantelis Antoniou wrote: > Introducing capebus; a bus that allows small boards (capes) to connect > to a complex SoC using simple expansion connectors. > > Up to now to support these kind of boards, one had to hack the board files, > and do all sort of gymnastics to handle all the different cases of > conflict resolution. > > Capebus provides abstractions that keep the pain to a minimum. > > This part of the series is introducing the core capebus functionality > dealing with the basic bus & driver probe functions. > > Signed-off-by: Pantelis Antoniou > --- > drivers/Kconfig | 2 + > drivers/Makefile | 3 + > drivers/capebus/Kconfig | 17 ++ > drivers/capebus/Makefile | 8 + > drivers/capebus/capebus-driver.c | 608 +++++++++++++++++++++++++++++++++++++++ > drivers/capebus/capebus-probe.c | 320 +++++++++++++++++++++ > drivers/capebus/capebus-sysfs.c | 52 ++++ > include/linux/capebus.h | 298 +++++++++++++++++++ > 8 files changed, 1308 insertions(+) > create mode 100644 drivers/capebus/Kconfig > create mode 100644 drivers/capebus/Makefile > create mode 100644 drivers/capebus/capebus-driver.c > create mode 100644 drivers/capebus/capebus-probe.c > create mode 100644 drivers/capebus/capebus-sysfs.c > create mode 100644 include/linux/capebus.h > > diff --git a/drivers/Kconfig b/drivers/Kconfig > index dbdefa3..bfbe1d1 100644 > --- a/drivers/Kconfig > +++ b/drivers/Kconfig > @@ -156,4 +156,6 @@ source "drivers/pwm/Kconfig" > > source "drivers/irqchip/Kconfig" > > +source "drivers/capebus/Kconfig" > + > endmenu > diff --git a/drivers/Makefile b/drivers/Makefile > index a16a8d0..d7a103b 100644 > --- a/drivers/Makefile > +++ b/drivers/Makefile > @@ -145,3 +145,6 @@ obj-$(CONFIG_EXTCON) += extcon/ > obj-$(CONFIG_MEMORY) += memory/ > obj-$(CONFIG_IIO) += iio/ > obj-$(CONFIG_VME_BUS) += vme/ > + > +# Capebus > +obj-$(CONFIG_CAPEBUS) += capebus/ > diff --git a/drivers/capebus/Kconfig b/drivers/capebus/Kconfig > new file mode 100644 > index 0000000..cea1b68 > --- /dev/null > +++ b/drivers/capebus/Kconfig > @@ -0,0 +1,17 @@ > +# > +# Capebus core support > +# > + > +menu "CAPEBUS support" > + > +config CAPEBUS > + bool "Capebus support" > + default n > + help > + Enable to support capebus devices. > + > +source "drivers/capebus/boards/Kconfig" > + > +source "drivers/capebus/capes/Kconfig" > + > +endmenu > diff --git a/drivers/capebus/Makefile b/drivers/capebus/Makefile > new file mode 100644 > index 0000000..45aa303 > --- /dev/null > +++ b/drivers/capebus/Makefile > @@ -0,0 +1,8 @@ > +# > +# Makefile for CAPEBUS devices > +# > + > +obj-$(CONFIG_CAPEBUS) += capebus-probe.o \ > + capebus-driver.o capebus-sysfs.o > +obj-$(CONFIG_CAPEBUS) += boards/ > +obj-$(CONFIG_CAPEBUS) += capes/ > diff --git a/drivers/capebus/capebus-driver.c b/drivers/capebus/capebus-driver.c > new file mode 100644 > index 0000000..82b1d1b > --- /dev/null > +++ b/drivers/capebus/capebus-driver.c > @@ -0,0 +1,608 @@ > +/* > + * Capebus driver infrastructure > + * > + * Copyright (C) 2012 Pantelis Antoniou > + * Copyright (C) 2012 Texas Instruments Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > + > +#include > + > +/** > + * capebus_match_device - Tell if a cape device structure has a > + * matching cape device id structure > + * @drv: the cape driver to match against > + * @dev: the cape device structure to match against > + * > + * Used by a driver to check whether a cape device present in the > + * system is in its list of supported devices. Returns the matching > + * cape_device_id structure or %NULL if there is no match. > + */ > +static const struct cape_device_id *capebus_match_device( > + struct cape_driver *drv, struct cape_dev *dev) > +{ > + struct cape_bus *bus = dev->bus; > + struct cape_slot *slot = dev->slot; > + > + BUG_ON(bus == NULL); > + BUG_ON(slot == NULL); > + BUG_ON(bus->ops == NULL); > + BUG_ON(bus->ops->get_dev_id == NULL); > + > + return bus->ops->get_dev_id(slot); > +} > + > +/** > + * capebus_device_probe - check if a driver wants to claim a > + * specific cape device > + * @dev: cape device being probed > + * > + * returns 0 on success, else error. > + * side-effect: cape_dev->driver is set to drv when drv claims cape_dev. > + */ > +static int capebus_device_probe(struct device *dev) > +{ > + const struct cape_device_id *id; > + int error = 0; > + struct cape_driver *drv; > + struct cape_dev *cape_dev; > + struct device *parent; > + > + drv = to_cape_driver(dev->driver); > + cape_dev = to_cape_dev(dev); > + cape_dev = capebus_dev_get(cape_dev); > + > + /* sanity checks */ > + if (cape_dev == NULL || > + cape_dev->bus == NULL || cape_dev->bus->ops == NULL || > + cape_dev->driver != NULL || drv->probe == NULL) { > + error = -EINVAL; > + goto err_no_sanity; > + } > + > + id = capebus_match_device(drv, cape_dev); > + if (!id) { > + error = -ENODEV; > + goto err_no_match; > + } > + > + /* The parent device must be in active state when probing */ > + parent = cape_dev->dev.parent; > + if (parent) > + pm_runtime_get_sync(parent); > + > + /* Unbound cape devices are always set to disabled and suspended. > + * During probe, the device is set to enabled and active and the > + * usage count is incremented. If the driver supports runtime PM, > + * it should call pm_runtime_put_noidle() in its probe routine and > + * pm_runtime_get_noresume() in its remove routine. > + */ > + pm_runtime_get_noresume(&cape_dev->dev); > + pm_runtime_set_active(&cape_dev->dev); > + pm_runtime_enable(&cape_dev->dev); > + > + /* call the driver's probe method */ > + error = drv->probe(cape_dev, id); > + > + /* release the parent no matter what */ > + if (parent) > + pm_runtime_put(parent); > + > + if (error != 0) > + goto err_probe_fail; > + > + /* call the probed bus method */ > + if (cape_dev->bus->ops->dev_probed != NULL) { > + error = cape_dev->bus->ops->dev_probed(cape_dev); > + if (error != 0) > + goto err_dev_probed_fail; > + } > + > + /* all is fine... */ > + cape_dev->driver = drv; > + cape_dev->added = 1; > + > + return 0; > + > +err_dev_probed_fail: > + if (drv->remove) { > + pm_runtime_get_sync(&cape_dev->dev); > + drv->remove(cape_dev); > + pm_runtime_put_noidle(&cape_dev->dev); > + } > +err_probe_fail: > + pm_runtime_disable(&cape_dev->dev); > + pm_runtime_set_suspended(&cape_dev->dev); > + pm_runtime_put_noidle(&cape_dev->dev); > +err_no_match: > + /* nothing */ > +err_no_sanity: > + capebus_dev_put(cape_dev); > + return error; > +} > + > +static int capebus_device_remove(struct device *dev) > +{ > + struct cape_dev *cape_dev = to_cape_dev(dev); > + struct cape_driver *drv = cape_dev->driver; > + > + if (drv) { > + /* call the removed bus method (if added prev.) */ > + if (cape_dev->added) { > + BUG_ON(cape_dev->bus == NULL); > + BUG_ON(cape_dev->bus->ops == NULL); > + if (cape_dev->bus->ops->dev_removed) > + cape_dev->bus->ops->dev_removed(cape_dev); > + cape_dev->added = 0; > + } Is there any case where added will not track drv? > + if (drv->remove) { > + pm_runtime_get_sync(dev); > + drv->remove(cape_dev); > + pm_runtime_put_noidle(dev); > + } > + cape_dev->driver = NULL; > + } > + > + /* Undo the runtime PM settings in local_capebus_probe() */ > + pm_runtime_disable(dev); > + pm_runtime_set_suspended(dev); > + pm_runtime_put_noidle(dev); > + > + capebus_dev_put(cape_dev); > + return 0; > +} > + > +static void capebus_device_shutdown(struct device *dev) > +{ > + struct cape_dev *cape_dev = to_cape_dev(dev); > + struct cape_driver *drv = cape_dev->driver; > + > + if (drv && drv->shutdown) > + drv->shutdown(cape_dev); > + > + capebus_disable_device(cape_dev); > + > + if (!device_may_wakeup(dev)) > + capebus_enable_wake(cape_dev, false); > +} > + > +static int capebus_bus_match(struct device *dev, struct device_driver *drv); > +static int capebus_device_probe(struct device *dev); > +static int capebus_device_remove(struct device *dev); > +static void capebus_device_shutdown(struct device *dev); > + > +struct bus_type capebus_bus_type = { > + .name = "capebus", > + .match = capebus_bus_match, > + .probe = capebus_device_probe, > + .remove = capebus_device_remove, > + .shutdown = capebus_device_shutdown, > + .dev_attrs = capebus_dev_attrs, > + .bus_attrs = capebus_bus_attrs, > + .pm = NULL, /* No PM for now */ > +}; > +EXPORT_SYMBOL(capebus_bus_type); > + > +/** > + * __capebus_register_driver - register a new capebus driver > + * @drv: the driver structure to register > + * @owner: owner module of drv > + * @mod_name: module name string > + * > + * Adds the driver structure to the list of registered drivers. > + * Returns a negative value on error, otherwise 0. > + * If no error occurred, the driver remains registered even if > + * no device was claimed during registration. > + */ > +int __capebus_register_driver(struct cape_driver *drv, struct module *owner, > + const char *mod_name) > +{ > + /* initialize common driver fields */ > + drv->driver.bus = &capebus_bus_type; > + drv->driver.owner = owner; > + drv->driver.mod_name = mod_name; > + > + /* register with core */ > + return driver_register(&drv->driver); > +} > +EXPORT_SYMBOL(__capebus_register_driver); > + > +/** > + * capebus_unregister_driver - unregister a capebus driver > + * @drv: the driver structure to unregister > + * > + * Deletes the driver structure from the list of registered cape 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 > +capebus_unregister_driver(struct cape_driver *drv) > +{ > + /* TODO: not really working properly */ > + driver_unregister(&drv->driver); > +} > +EXPORT_SYMBOL(capebus_unregister_driver); > + > +/** > + * capebus_bus_match - Tell if a cape device structure has a matching > + * cape device id structure > + * @dev: the cape device structure to match against > + * @drv: the device driver to search for matching cape device id structures > + * > + * Used by a driver to check whether a cape device present in the > + * system is in its list of supported devices. Returns the matching > + * cape_device_id structure or %NULL if there is no match. > + */ > +static int capebus_bus_match(struct device *dev, struct device_driver *drv) > +{ > + struct cape_dev *cape_dev = to_cape_dev(dev); > + struct cape_driver *cape_drv = to_cape_driver(drv); > + const struct cape_device_id *found_id; > + > + found_id = capebus_match_device(cape_drv, cape_dev); > + if (found_id) > + return 1; > + > + return 0; > +} > + > +/** > + * capebus_dev_get - increments the reference count of the capebus > + * device structure > + * @dev: the device being referenced > + * > + * Each live reference to a device should be refcounted. > + * > + * Drivers for cape devices should normally record such references in > + * their probe() methods, when they bind to a device, and release > + * them by calling capebus_dev_put(), in their disconnect() methods. > + * > + * A pointer to the device with the incremented reference counter is returned. > + */ > +struct cape_dev *capebus_dev_get(struct cape_dev *dev) > +{ > + if (dev) > + get_device(&dev->dev); > + return dev; > +} > +EXPORT_SYMBOL(capebus_dev_get); > + > +/** > + * capebus_dev_put - release a use of the capebus device structure > + * @dev: device that's been disconnected > + * > + * Must be called when a user of a device is finished with it. When the last > + * user of the device calls this function, the memory of the device is freed. > + */ > +void capebus_dev_put(struct cape_dev *dev) > +{ > + if (dev) > + put_device(&dev->dev); > +} > +EXPORT_SYMBOL(capebus_dev_put); > + > +static int __init capebus_driver_init(void) > +{ > + return bus_register(&capebus_bus_type); > +} > + > +postcore_initcall(capebus_driver_init); > + > +const struct of_device_id * > +capebus_of_match_device(struct cape_dev *cdev, > + const char *property, const char *value) > +{ > + struct cape_bus *bus = cdev->bus; > + struct device *dev = &cdev->dev; > + struct device_node *pnode = cape_bus_to_parent_of_node(bus); > + struct device_node *node; > + const struct of_device_id *match; > + const char* cp; > + int cplen, l; > + > + dev_dbg(dev, "Iterating on parent of node " > + "name='%s' type='%s' full_name='%s'\n", > + pnode->name, pnode->type, pnode->full_name); > + > + match = NULL; > + for_each_child_of_node(pnode, node) { > + > + dev->of_node = node; > + match = of_match_device(dev->driver->of_match_table, dev); > + if (!match) > + goto next_node; > + > + cp = of_get_property(node, property, &cplen); > + if (cp == NULL) > + goto next_node; > + > + while (cplen > 0) { > + if (of_compat_cmp(cp, value, strlen(value)) == 0) > + break; > + l = strlen(cp) + 1; > + cp += l; > + cplen -= l; > + } > + > + /* matched */ > + if (cplen > 0) > + break; > +next_node: > + match = NULL; > + dev->of_node = NULL; > + } > + > + if (match == NULL) { > + dev_dbg(dev, "Failed to find matching child-node\n"); > + return NULL; > + } > + > + dev_dbg(dev, "Found matching child node " > + "name='%s' type='%s' " > + "full_name='%s' (compatible='%s')\n", > + node->name, node->type, node->full_name, > + match->compatible); > + > + return match; > +} > +EXPORT_SYMBOL(capebus_of_match_device); > + > +struct device_node * > +capebus_of_compatible_device_property_match(struct cape_dev *dev, > + const struct of_device_id *matches, > + const char *prop, const char *prop_value) > +{ > + const struct of_device_id *match; > + struct device_node *node, *cnode; > + const char* cp; > + int cplen, l; > + > + if (prop == NULL || prop_value == NULL) > + goto try_non_property; > + > + /* at first try secondary match */ > + for_each_child_of_node(dev->dev.of_node, node) { > + > + cp = of_get_property(node, prop, &cplen); > + if (cp == NULL) > + continue; > + > + while (cplen > 0) { > + if (of_compat_cmp(cp, prop_value, > + strlen(prop_value)) == 0) > + break; > + l = strlen(cp) + 1; > + cp += l; > + cplen -= l; > + } > + > + /* not matched */ > + if (cplen <= 0) > + continue; > + > + /* now iterate in the children nodes */ > + for_each_child_of_node(node, cnode) { > + > + match = of_match_node(matches, cnode); > + if (match) { > + /* release reference to parent, keep this one */ > + of_node_put(node); > + return cnode; > + } > + } > + } > + > +try_non_property: > + for_each_child_of_node(dev->dev.of_node, node) { > + > + match = of_match_node(matches, node); > + if (match) > + return node; > + } > + > + return NULL; > +} > +EXPORT_SYMBOL(capebus_of_compatible_device_property_match); > + > +struct platform_device * > +capebus_of_platform_compatible_device_create(struct cape_dev *dev, > + const struct of_device_id *matches, > + const char *pdev_name, > + const char *prop, const char *prop_value) > +{ > + struct device_node *node; > + struct platform_device *pdev; > + > + node = capebus_of_compatible_device_property_match(dev, matches, prop, > + prop_value); > + if (node == NULL) > + return ERR_PTR(-ENXIO); > + > + pdev = of_platform_device_create(node, pdev_name, dev->bus->dev.parent); > + > + /* release the reference to the node */ > + of_node_put(node); > + node = NULL; > + > + if (pdev == NULL) { > + dev_err(&dev->dev, "Failed to create platform device '%s'\n", > + pdev_name); > + return ERR_PTR(-ENODEV); > + } > + > + return pdev; > +} > +EXPORT_SYMBOL(capebus_of_platform_compatible_device_create); > + > +struct device_node * > +capebus_of_find_property_node(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name) > +{ > + struct device_node *node; > + const char* cp; > + int cplen, l; > + struct property *pp; > + > + node = NULL; > + if (prop == NULL || prop_value == NULL) > + goto find_direct; > + > + /* at first try secondary match */ > + for_each_child_of_node(dev->dev.of_node, node) { > + > + cp = of_get_property(node, prop, &cplen); > + if (cp == NULL) > + continue; > + > + while (cplen > 0) { > + if (of_compat_cmp(cp, prop_value, > + strlen(prop_value)) == 0) > + break; > + l = strlen(cp) + 1; > + cp += l; > + cplen -= l; > + } > + > + /* not matched */ > + if (cplen <= 0) > + continue; > + > + /* found ? */ > + pp = of_find_property(node, name, NULL); > + if (pp != NULL) > + return node; > + } > +find_direct: > + pp = of_find_property(dev->dev.of_node, name, NULL); > + if (pp == NULL) > + return NULL; > + > + return of_node_get(dev->dev.of_node); > +} > +EXPORT_SYMBOL_GPL(capebus_of_find_property_node); > + > +struct property * > +capebus_of_find_property(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, int *lenp) > +{ > + struct device_node *node; > + struct property *pp; > + > + node = capebus_of_find_property_node(dev, prop, prop_value, name); > + if (node == NULL) > + return NULL; > + > + pp = of_find_property(node, name, lenp); > + > + of_node_put(node); > + > + return pp; > +} > +EXPORT_SYMBOL_GPL(capebus_of_find_property); > + > +const void *capebus_of_get_property(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, int *lenp) > +{ > + struct property *pp; > + > + pp = capebus_of_find_property(dev, prop, prop_value, name, lenp); > + return pp ? pp->value : NULL; > +} > +EXPORT_SYMBOL_GPL(capebus_of_get_property); > + > +/* node exists, but it's not available? make it so */ > +int capebus_of_device_node_enable(struct device_node *node) > +{ > + struct property *prop; > + int ret; > + > + prop = kzalloc(sizeof(*prop), GFP_KERNEL); > + if (prop == NULL) > + goto err_no_prop_mem; > + > + prop->name = kstrdup("status", GFP_KERNEL); > + if (prop->name == NULL) > + goto err_no_name_mem; > + > + prop->value = kstrdup("okay", GFP_KERNEL); > + if (prop->value == NULL) > + goto err_no_value_mem; > + > + prop->length = strlen(prop->value) + 1; > + set_bit(OF_DYNAMIC, &prop->_flags); > + > + ret = prom_update_property(node, prop); > + if (ret != 0) > + goto err_update_failed; > + > + return 0; > + > +err_update_failed: > + kfree(prop->value); > +err_no_value_mem: > + kfree(prop->name); > +err_no_name_mem: > + kfree(prop); > +err_no_prop_mem: > + return -ENOMEM; > +} > +EXPORT_SYMBOL_GPL(capebus_of_device_node_enable); > + > +/* Make sure this node is activated (even if it was disabled) */ > +int capebus_of_platform_device_enable(struct device_node *node) > +{ > + struct platform_device *pdev, *ppdev; > + int ret; > + > + if (of_device_is_available(node)) > + return 0; > + > + ret = capebus_of_device_node_enable(node); > + if (ret != 0) > + return ret; > + > + /* now we need to find the parent of the node */ > + ppdev = of_find_device_by_node(node->parent); > + > + pdev = of_platform_device_create(node, NULL, > + ppdev ? &ppdev->dev : NULL); > + if (IS_ERR_OR_NULL(pdev)) { > + ret = pdev ? PTR_ERR(pdev) : -ENODEV; > + return ret; > + } > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(capebus_of_platform_device_enable); > diff --git a/drivers/capebus/capebus-probe.c b/drivers/capebus/capebus-probe.c > new file mode 100644 > index 0000000..b46e915 > --- /dev/null > +++ b/drivers/capebus/capebus-probe.c > @@ -0,0 +1,320 @@ > +/* > + * Capebus bus infrastructure > + * > + * Copyright (C) 2012 Pantelis Antoniou > + * Copyright (C) 2012 Texas Instruments Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +LIST_HEAD(cape_buses); > +EXPORT_SYMBOL(cape_buses); > + > +DEFINE_MUTEX(cape_buses_mutex); > +EXPORT_SYMBOL(cape_buses_mutex); > + > +/* > + * Cape Bus Class > + */ > +static void release_capebus_dev(struct device *dev) > +{ > + struct cape_dev *cape_dev = to_cape_dev(dev); > + > + kfree(cape_dev); > +} > + > +static struct class capebus_class = { > + .name = "capebus", > + .dev_release = &release_capebus_dev, > +}; > + > +static int __init capebus_class_init(void) > +{ > + return class_register(&capebus_class); > +} > +postcore_initcall(capebus_class_init); > + > +static struct cape_bus *cape_bus_find(const char *name, int busno) > +{ > + struct cape_bus *bus; > + int found; > + > + if (busno < 0) > + return NULL; > + > + found = 0; > + cape_bus_for_each(bus) { > + if (strcmp(name, bus->name) == 0 && bus->busno == busno) { > + found = 1; > + break; > + } > + } > + return found ? bus : NULL; > +} > + > +static int cape_bus_pick_busno(const char *name, int busno) > +{ > + struct cape_bus *bus; > + > + BUG_ON(name == NULL); > + > + /* fixed id */ > + if (busno >= 0) > + return busno; > + > + /* dynamic id */ > + busno = -1; > + cape_bus_for_each(bus) { > + /* name must match */ > + if (strcmp(name, bus->name) != 0) > + continue; > + busno = max(busno, bus->busno); > + } > + return busno + 1; > +} > + > +int cape_bus_register(struct cape_bus *bus, const char *name, int busno, > + struct device *parent, struct cape_bus_ops *ops) > +{ > + struct cape_bus *b2; > + int r; > + > + if (name == NULL) > + return -EINVAL; > + > + INIT_LIST_HEAD(&bus->node); > + INIT_LIST_HEAD(&bus->devices); > + INIT_LIST_HEAD(&bus->slots); > + > + /* do everything under lock */ > + mutex_lock(&cape_buses_mutex); > + > + b2 = cape_bus_find(name, busno); > + if (b2 != NULL) { > + if (parent != NULL) > + dev_err(parent, "capebus %s:%d in use\n", name, busno); > + else > + pr_err("capebus %s:%d in use\n", name, busno); > + r = -EBUSY; > + goto err_unlock; > + } > + bus->name = name; > + bus->busno = cape_bus_pick_busno(name, busno); > + bus->ops = ops; > + > + bus->dev.class = &capebus_class; > + bus->dev.parent = parent; > + dev_set_name(&bus->dev, "%s:%d", bus->name, bus->busno); > + r = device_register(&bus->dev); > + if (r != 0) { > + if (parent != NULL) > + dev_err(parent, "capebus #%d failed to register dev\n", > + bus->busno); > + else > + pr_err("capebus #%d failed to register dev\n", > + bus->busno); > + goto err_unlock; > + } > + > + list_add_tail(&bus->node, &cape_buses); > + mutex_unlock(&cape_buses_mutex); > + > + dev_info(&bus->dev, "Registered\n"); > + > + return 0; > +err_unlock: > + mutex_unlock(&cape_buses_mutex); > + return r; > +} > + > +int cape_bus_deregister(struct cape_bus *bus) > +{ > + return -EINVAL; /* not yet supported */ > +} > + > +/* must have cape_buses_mutex */ > +struct cape_slot *cape_slot_find(struct cape_bus *bus, int slotno) > +{ > + struct cape_slot *slot; > + int found; > + > + found = 0; > + cape_slot_for_each(bus, slot) { > + if (slot->slotno == slotno) { > + found = 1; > + break; > + } > + } > + return found ? slot : NULL; > +} > + > +/** > + * cape_bus_release_dev - free a cape device structure when all users > + * of it are finished. > + * @dev: device that's been disconnected > + * > + * Will be called only by the device core when all users of this cape device are > + * done. > + */ > +static void cape_bus_release_dev(struct device *dev) > +{ > + struct cape_dev *cdev; > + > + cdev = to_cape_dev(dev); > + /* cape_release_capabilities(cdev); TODO */ > + /* cape_release_of_node(cdev); TODO */ > + kfree(cdev); > +} > + > +/* mutex lock must be held */ > +static struct cape_dev *cape_bus_scan_slot(struct cape_slot *slot) > +{ > + struct cape_bus *bus = slot->bus; > + struct cape_dev *dev; > + const struct cape_device_id *id; > + > + /* get the ID (if a device exists) */ > + id = bus->ops->get_dev_id(slot); > + if (id == NULL) > + return ERR_PTR(-ENODEV); > + > + /* slot must not have a device yet */ > + dev = slot->dev; > + if (dev == NULL) { > + dev = kzalloc(sizeof(*dev), GFP_KERNEL); > + if (dev == NULL) { > + dev_info(&bus->dev, "Failed to allocate cape device " > + "for slot #%d\n", slot->slotno); > + return ERR_PTR(-ENOMEM); > + } > + > + INIT_LIST_HEAD(&dev->bus_list); > + dev->bus = bus; > + dev->slot = slot; > + } > + > + dev->id = id; > + dev->text_id = bus->ops->get_text_dev_id(slot); > + > + /* capebus_set_of_node(dev); TODO */ > + > + return dev; > +} > + > +int cape_bus_scan_one_slot(struct cape_bus *bus, struct cape_slot *slot) > +{ > + struct cape_dev *dev; > + int r; > + > + mutex_lock(&cape_buses_mutex); > + > + dev = slot->dev; > + if (dev == NULL) { > + > + dev = cape_bus_scan_slot(slot); > + if (IS_ERR(dev)) { > + r = PTR_ERR(dev); > + goto err_out; > + } > + > + dev_info(&bus->dev, "Slot #%d id='%s'\n", slot->slotno, > + dev->text_id ? dev->text_id : ""); > + > + slot->dev = dev; > + > + dev->dev.release = cape_bus_release_dev; > + dev->dev.parent = &dev->bus->dev; > + dev->dev.bus = &capebus_bus_type; > + dev_set_name(&dev->dev, "%s-%d:%d", > + dev->bus->name, dev->bus->busno, > + dev->slot->slotno); > + > + list_add_tail(&dev->bus_list, &bus->devices); > + > + } else { > + dev_info(&bus->dev, "Slot #%d id='%s' - rescan\n", slot->slotno, > + dev->text_id ? dev->text_id : ""); > + > + if (dev->added) { > + r = -EEXIST; > + goto err_out; > + } > + } > + > + r = device_register(&dev->dev); > + if (r != 0) { > + dev_info(&bus->dev, "Slot #%d id='%s' - " > + "Failed to register\n", > + slot->slotno, > + dev->text_id ? dev->text_id : ""); > + r = 0; > + } else { > + if (dev->bus->ops->dev_registered) > + dev->bus->ops->dev_registered(dev); > + } > + > +err_out: > + mutex_unlock(&cape_buses_mutex); > + > + return r; > +} > + > +int cape_bus_register_slot(struct cape_bus *bus, struct cape_slot *slot, > + int slotno) > +{ > + struct cape_slot *s2; > + int r; > + > + r = 0; > + > + /* invalid (slot must always be numbered - no hotplug) */ > + if (slotno < 0) { > + dev_err(&bus->dev, "Slot registration #%d failed\n", slotno); > + return -EINVAL; > + } > + > + mutex_lock(&cape_buses_mutex); > + s2 = cape_slot_find(bus, slotno); > + if (s2 != NULL) { > + dev_err(&bus->dev, "Slot #%d already exists\n", slotno); > + mutex_unlock(&cape_buses_mutex); > + return -EINVAL; > + } > + > + INIT_LIST_HEAD(&slot->node); > + slot->bus = bus; > + list_add(&slot->node, &bus->slots); > + slot->slotno = slotno; > + slot->dev = NULL; > + mutex_unlock(&cape_buses_mutex); > + > + dev_info(&bus->dev, "Slot #%d registered\n", slot->slotno); > + > + return cape_bus_scan_one_slot(bus, slot); > +} > diff --git a/drivers/capebus/capebus-sysfs.c b/drivers/capebus/capebus-sysfs.c > new file mode 100644 > index 0000000..81c21fe > --- /dev/null > +++ b/drivers/capebus/capebus-sysfs.c > @@ -0,0 +1,52 @@ > +/* > + * drivers/capebus/capebus-sysfs.c > + * > + * sysfs for capebus devices > + * > + * Copyright (C) 2012 Pantelis Antoniou > + * Copyright (C) 2012 Texas Instruments Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + * > + * Modeled after PCI's pci-sysfs.c > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +static ssize_t id_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + struct cape_dev *cdev; > + > + cdev = to_cape_dev(dev); > + return sprintf(buf, "%s\n", cdev->text_id); > +} > + > +struct device_attribute capebus_dev_attrs[] = { > + __ATTR_RO(id), > + __ATTR_NULL, > +}; > + > +struct bus_attribute capebus_bus_attrs[] = { > + __ATTR_NULL > +}; > diff --git a/include/linux/capebus.h b/include/linux/capebus.h > new file mode 100644 > index 0000000..7524401 > --- /dev/null > +++ b/include/linux/capebus.h > @@ -0,0 +1,298 @@ > +/* > + * capebus.h > + * > + * Cape bus defines and function prototypes > + * > + * Copyright (C) 2012 Pantelis Antoniou > + * Copyright (C) 2012 Texas Instruments Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + */ > +#ifndef LINUX_CAPEBUS_H > +#define LINUX_CAPEBUS_H > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +struct cape_device_id { > + const char *cntrlboard; /* controlling board; i.e. "beaglebone" */ > + int len; /* opaque addressing data */ > + const void *data; > +}; > + > +struct cape_dev; > +struct cape_bus; > +struct cape_slot; > + > +struct cape_slot { > + struct list_head node; > + struct cape_bus *bus; /* the bus this slot is on */ > + int slotno; /* index of this slot */ > + struct cape_dev *dev; /* the device (if found) */ > +}; > + > +struct cape_driver { > + struct list_head node; > + int (*probe)(struct cape_dev *dev, const struct cape_device_id *id); > + void (*remove)(struct cape_dev *dev); > + int (*suspend) (struct cape_dev *dev, pm_message_t state); > + int (*suspend_late) (struct cape_dev *dev, pm_message_t state); > + int (*resume_early) (struct cape_dev *dev); > + int (*resume) (struct cape_dev *dev); > + void (*shutdown) (struct cape_dev *dev); > + struct device_driver driver; > +}; > + > +/* > + * capebus_register_driver must be a macro so that > + * KBUILD_MODNAME can be expanded > + */ > +#define capebus_register_driver(driver) \ > + __capebus_register_driver(driver, THIS_MODULE, KBUILD_MODNAME) > + > +int __capebus_register_driver(struct cape_driver *drv, struct module *owner, > + const char *mod_name); > + > +void capebus_unregister_driver(struct cape_driver *dev); > + > +/** > + * module_capebus_driver() - Helper macro for registering a capebus driver > + * @__capebus_driver: capebus_driver struct > + * > + * Helper macro for capebus drivers which do not do anything special in module > + * init/exit. This eliminates a lot of boilerplate. Each module may only > + * use this macro once, and calling it replaces module_init() and module_exit() > + */ > +#define module_capebus_driver(__capebus_driver) \ > + module_driver(__capebus_driver, capebus_register_driver, \ > + capebus_unregister_driver) > + > +#define to_cape_driver(n) container_of(n, struct cape_driver, driver) > + > +struct cape_bus_ops { > + const struct cape_device_id *(*get_dev_id)(struct cape_slot *slot); > + const char *(*get_text_dev_id)(struct cape_slot *slot); > + int (*dev_probed)(struct cape_dev *dev); /* probed succesfully */ > + void (*dev_removed)(struct cape_dev *dev); /* removed */ > + int (*dev_registered)(struct cape_dev *dev); /* registered OK */ > +}; > + > +struct cape_bus { > + struct list_head node; > + const char *name; > + struct list_head devices; > + struct cape_dev *self; > + struct list_head slots; > + struct cape_bus_ops *ops; > + int busno; > + struct device dev; > + /* TODO: resources.... */ > +}; > + > +#define to_cape_bus(n) container_of(n, struct cape_bus, dev) > + > +#define cape_bus_to_parent_of_node(n) ((n)->dev.parent->of_node) > + > +struct cape_dev { > + struct list_head bus_list; /* node in per-bus list */ > + struct cape_bus *bus; /* bus this device is on */ > + struct cape_slot *slot; /* cape slot of this device */ > + struct cape_driver *driver; /* driver of this device */ > + struct device dev; > + atomic_t enable_cnt; /* capebus_enable_device */ > + /* has been called */ > + const struct cape_device_id *id; > + const char *text_id; > + unsigned int added : 1; /* device has been added */ > + void *drv_priv; /* driver private data */ > +}; > + > +#define to_cape_dev(n) container_of(n, struct cape_dev, dev) > + > +struct cape_dev *capebus_dev_get(struct cape_dev *dev); > +void capebus_dev_put(struct cape_dev *dev); > + > +/* must have cape_buses_mutex */ > +#define cape_bus_for_each(_bus) \ > + list_for_each_entry(_bus, &cape_buses, node) > + > +#define cape_bus_for_each_safe(_bus, _busn) \ > + list_for_each_entry_safe(_bus, _busn, &cape_buses, node) > + > +int cape_bus_register(struct cape_bus *bus, const char *name, int busno, > + struct device *parent, struct cape_bus_ops *ops); > + > +/* must have cape_buses_mutex */ > +#define cape_slot_for_each(_bus, _slot) \ > + list_for_each_entry(_slot, &(_bus)->slots, node) > + > +#define cape_slot_for_each_safe(_bus, _slot, _slotn) \ > + list_for_each_entry_safe(_slot, _slotn, &(_bus)->slots, node) > + > +int cape_bus_register_slot(struct cape_bus *bus, > + struct cape_slot *slot, int slotno); > + > +int cape_bus_scan_one_slot(struct cape_bus *bus, struct cape_slot *slot); > +int cape_bus_scan(struct cape_bus *bus); > + > +extern struct list_head cape_buses; > +extern struct mutex cape_buses_mutex; > + > +static inline int capebus_is_enabled(struct cape_dev *cdev) > +{ > + return atomic_read(&cdev->enable_cnt) > 0; > +} > + > +static inline int capebus_enable_device(struct cape_dev *cdev) > +{ > + if (atomic_add_return(1, &cdev->enable_cnt) > 1) > + return 0; /* already enabled */ > + > + /* XXX do enable */ > + > + return 0; > +} > + > +static inline void capebus_disable_device(struct cape_dev *cdev) > +{ > + if (atomic_sub_return(1, &cdev->enable_cnt) != 0) > + return; > + > + /* callback to disable device? */ > +} > + > +static inline int capebus_enable_wake(struct cape_dev *dev, int what) > +{ > + return 0; > +} > + > +extern struct device_attribute capebus_dev_attrs[]; > +extern struct bus_attribute capebus_bus_attrs[]; > + > +extern struct bus_type capebus_bus_type; > + > +const struct of_device_id * > +capebus_of_match_device(struct cape_dev *cdev, > + const char *property, const char *value); > + > +struct device_node * > +capebus_of_compatible_device_property_match(struct cape_dev *dev, > + const struct of_device_id *matches, > + const char *prop, const char *prop_value); > + > +struct platform_device * > +capebus_of_platform_compatible_device_create(struct cape_dev *dev, > + const struct of_device_id *matches, > + const char *pdev_name, > + const char *prop, const char *prop_value); > + > +/* of tree support */ > + > +struct device_node * > +capebus_of_find_property_node(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name); > + > +struct property * > +capebus_of_find_property(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, int *lenp); > + > +const void *capebus_of_get_property(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, int *lenp); > + > +static inline int capebus_of_property_read_u32_array(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, u32 *out_values, size_t sz) > +{ > + struct device_node *node; > + int ret; > + > + node = capebus_of_find_property_node(dev, prop, prop_value, name); > + ret = of_property_read_u32_array(node, name, out_values, sz); > + of_node_put(node); > + return ret; > +} > + > +static inline int capebus_of_property_read_u32(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, u32 *out_value) > +{ > + return capebus_of_property_read_u32_array(dev, prop, > + prop_value, name, out_value, 1); > +} > + > +static inline bool capebus_of_property_read_bool(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name) > +{ > + struct device_node *node; > + bool ret; > + > + node = capebus_of_find_property_node(dev, prop, prop_value, name); > + ret = of_property_read_bool(node, name); > + of_node_put(node); > + return ret; > +} > + > +static inline int capebus_of_property_read_string(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, const char **out_string) > +{ > + struct device_node *node; > + int ret; > + > + node = capebus_of_find_property_node(dev, prop, prop_value, name); > + ret = of_property_read_string(node, name, out_string); > + of_node_put(node); > + return ret; > +} > + > +static inline int capebus_of_property_read_string_index(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, int index, const char **out_string) > +{ > + struct device_node *node; > + int ret; > + > + node = capebus_of_find_property_node(dev, prop, prop_value, name); > + ret = of_property_read_string_index(node, name, index, out_string); > + of_node_put(node); > + return ret; > +} > + > +static inline int capebus_of_property_read_u64(struct cape_dev *dev, > + const char *prop, const char *prop_value, > + const char *name, u64 *out_value) > +{ > + struct device_node *node; > + int ret; > + > + node = capebus_of_find_property_node(dev, prop, prop_value, name); > + ret = of_property_read_u64(node, name, out_value); > + of_node_put(node); > + return ret; > +} > + > +int capebus_of_device_node_enable(struct device_node *node); > +int capebus_of_platform_device_enable(struct device_node *node); > + > +#endif > -- > 1.7.12 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-omap" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/