mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 00:40:03 +00:00
![Uwe Kleine-König](/assets/img/avatar_default.png)
The driver core ignores the return value of this callback because there is only little it can do when a device disappears. This is the final bit of a long lasting cleanup quest where several buses were converted to also return void from their remove callback. Additionally some resource leaks were fixed that were caused by drivers returning an error code in the expectation that the driver won't go away. With struct bus_type::remove returning void it's prevented that newly implemented buses return an ignored error code and so don't anticipate wrong expectations for driver authors. Reviewed-by: Tom Rix <trix@redhat.com> (For fpga) Reviewed-by: Mathieu Poirier <mathieu.poirier@linaro.org> Reviewed-by: Cornelia Huck <cohuck@redhat.com> (For drivers/s390 and drivers/vfio) Acked-by: Russell King (Oracle) <rmk+kernel@armlinux.org.uk> (For ARM, Amba and related parts) Acked-by: Mark Brown <broonie@kernel.org> Acked-by: Chen-Yu Tsai <wens@csie.org> (for sunxi-rsb) Acked-by: Pali Rohár <pali@kernel.org> Acked-by: Mauro Carvalho Chehab <mchehab@kernel.org> (for media) Acked-by: Hans de Goede <hdegoede@redhat.com> (For drivers/platform) Acked-by: Alexandre Belloni <alexandre.belloni@bootlin.com> Acked-By: Vinod Koul <vkoul@kernel.org> Acked-by: Juergen Gross <jgross@suse.com> (For xen) Acked-by: Lee Jones <lee.jones@linaro.org> (For mfd) Acked-by: Johannes Thumshirn <jth@kernel.org> (For mcb) Acked-by: Johan Hovold <johan@kernel.org> Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> (For slimbus) Acked-by: Kirti Wankhede <kwankhede@nvidia.com> (For vfio) Acked-by: Maximilian Luz <luzmaximilian@gmail.com> Acked-by: Heikki Krogerus <heikki.krogerus@linux.intel.com> (For ulpi and typec) Acked-by: Samuel Iglesias Gonsálvez <siglesias@igalia.com> (For ipack) Acked-by: Geoff Levand <geoff@infradead.org> (For ps3) Acked-by: Yehezkel Bernat <YehezkelShB@gmail.com> (For thunderbolt) Acked-by: Alexander Shishkin <alexander.shishkin@linux.intel.com> (For intel_th) Acked-by: Dominik Brodowski <linux@dominikbrodowski.net> (For pcmcia) Acked-by: Rafael J. Wysocki <rafael@kernel.org> (For ACPI) Acked-by: Bjorn Andersson <bjorn.andersson@linaro.org> (rpmsg and apr) Acked-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com> (For intel-ish-hid) Acked-by: Dan Williams <dan.j.williams@intel.com> (For CXL, DAX, and NVDIMM) Acked-by: William Breathitt Gray <vilhelm.gray@gmail.com> (For isa) Acked-by: Stefan Richter <stefanr@s5r6.in-berlin.de> (For firewire) Acked-by: Benjamin Tissoires <benjamin.tissoires@redhat.com> (For hid) Acked-by: Thorsten Scherer <t.scherer@eckelmann.de> (For siox) Acked-by: Sven Van Asbroeck <TheSven73@gmail.com> (For anybuss) Acked-by: Ulf Hansson <ulf.hansson@linaro.org> (For MMC) Acked-by: Wolfram Sang <wsa@kernel.org> # for I2C Acked-by: Sudeep Holla <sudeep.holla@arm.com> Acked-by: Geert Uytterhoeven <geert@linux-m68k.org> Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> Acked-by: Finn Thain <fthain@linux-m68k.org> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Link: https://lore.kernel.org/r/20210713193522.1770306-6-u.kleine-koenig@pengutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
550 lines
13 KiB
C
550 lines
13 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2011-2017, The Linux Foundation
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/init.h>
|
|
#include <linux/idr.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/slimbus.h>
|
|
#include "slimbus.h"
|
|
|
|
static DEFINE_IDA(ctrl_ida);
|
|
|
|
static const struct slim_device_id *slim_match(const struct slim_device_id *id,
|
|
const struct slim_device *sbdev)
|
|
{
|
|
while (id->manf_id != 0 || id->prod_code != 0) {
|
|
if (id->manf_id == sbdev->e_addr.manf_id &&
|
|
id->prod_code == sbdev->e_addr.prod_code &&
|
|
id->dev_index == sbdev->e_addr.dev_index &&
|
|
id->instance == sbdev->e_addr.instance)
|
|
return id;
|
|
id++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int slim_device_match(struct device *dev, struct device_driver *drv)
|
|
{
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
struct slim_driver *sbdrv = to_slim_driver(drv);
|
|
|
|
/* Attempt an OF style match first */
|
|
if (of_driver_match_device(dev, drv))
|
|
return 1;
|
|
|
|
return !!slim_match(sbdrv->id_table, sbdev);
|
|
}
|
|
|
|
static void slim_device_update_status(struct slim_device *sbdev,
|
|
enum slim_device_status status)
|
|
{
|
|
struct slim_driver *sbdrv;
|
|
|
|
if (sbdev->status == status)
|
|
return;
|
|
|
|
sbdev->status = status;
|
|
if (!sbdev->dev.driver)
|
|
return;
|
|
|
|
sbdrv = to_slim_driver(sbdev->dev.driver);
|
|
if (sbdrv->device_status)
|
|
sbdrv->device_status(sbdev, sbdev->status);
|
|
}
|
|
|
|
static int slim_device_probe(struct device *dev)
|
|
{
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
struct slim_driver *sbdrv = to_slim_driver(dev->driver);
|
|
int ret;
|
|
|
|
ret = sbdrv->probe(sbdev);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* try getting the logical address after probe */
|
|
ret = slim_get_logical_addr(sbdev);
|
|
if (!ret) {
|
|
slim_device_update_status(sbdev, SLIM_DEVICE_STATUS_UP);
|
|
} else {
|
|
dev_err(&sbdev->dev, "Failed to get logical address\n");
|
|
ret = -EPROBE_DEFER;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void slim_device_remove(struct device *dev)
|
|
{
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
struct slim_driver *sbdrv;
|
|
|
|
if (dev->driver) {
|
|
sbdrv = to_slim_driver(dev->driver);
|
|
if (sbdrv->remove)
|
|
sbdrv->remove(sbdev);
|
|
}
|
|
}
|
|
|
|
static int slim_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
{
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
|
|
return add_uevent_var(env, "MODALIAS=slim:%s", dev_name(&sbdev->dev));
|
|
}
|
|
|
|
struct bus_type slimbus_bus = {
|
|
.name = "slimbus",
|
|
.match = slim_device_match,
|
|
.probe = slim_device_probe,
|
|
.remove = slim_device_remove,
|
|
.uevent = slim_device_uevent,
|
|
};
|
|
EXPORT_SYMBOL_GPL(slimbus_bus);
|
|
|
|
/*
|
|
* __slim_driver_register() - Client driver registration with SLIMbus
|
|
*
|
|
* @drv:Client driver to be associated with client-device.
|
|
* @owner: owning module/driver
|
|
*
|
|
* This API will register the client driver with the SLIMbus
|
|
* It is called from the driver's module-init function.
|
|
*/
|
|
int __slim_driver_register(struct slim_driver *drv, struct module *owner)
|
|
{
|
|
/* ID table and probe are mandatory */
|
|
if (!(drv->driver.of_match_table || drv->id_table) || !drv->probe)
|
|
return -EINVAL;
|
|
|
|
drv->driver.bus = &slimbus_bus;
|
|
drv->driver.owner = owner;
|
|
|
|
return driver_register(&drv->driver);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__slim_driver_register);
|
|
|
|
/*
|
|
* slim_driver_unregister() - Undo effect of slim_driver_register
|
|
*
|
|
* @drv: Client driver to be unregistered
|
|
*/
|
|
void slim_driver_unregister(struct slim_driver *drv)
|
|
{
|
|
driver_unregister(&drv->driver);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_driver_unregister);
|
|
|
|
static void slim_dev_release(struct device *dev)
|
|
{
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
|
|
kfree(sbdev);
|
|
}
|
|
|
|
static int slim_add_device(struct slim_controller *ctrl,
|
|
struct slim_device *sbdev,
|
|
struct device_node *node)
|
|
{
|
|
sbdev->dev.bus = &slimbus_bus;
|
|
sbdev->dev.parent = ctrl->dev;
|
|
sbdev->dev.release = slim_dev_release;
|
|
sbdev->dev.driver = NULL;
|
|
sbdev->ctrl = ctrl;
|
|
INIT_LIST_HEAD(&sbdev->stream_list);
|
|
spin_lock_init(&sbdev->stream_list_lock);
|
|
sbdev->dev.of_node = of_node_get(node);
|
|
sbdev->dev.fwnode = of_fwnode_handle(node);
|
|
|
|
dev_set_name(&sbdev->dev, "%x:%x:%x:%x",
|
|
sbdev->e_addr.manf_id,
|
|
sbdev->e_addr.prod_code,
|
|
sbdev->e_addr.dev_index,
|
|
sbdev->e_addr.instance);
|
|
|
|
return device_register(&sbdev->dev);
|
|
}
|
|
|
|
static struct slim_device *slim_alloc_device(struct slim_controller *ctrl,
|
|
struct slim_eaddr *eaddr,
|
|
struct device_node *node)
|
|
{
|
|
struct slim_device *sbdev;
|
|
int ret;
|
|
|
|
sbdev = kzalloc(sizeof(*sbdev), GFP_KERNEL);
|
|
if (!sbdev)
|
|
return NULL;
|
|
|
|
sbdev->e_addr = *eaddr;
|
|
ret = slim_add_device(ctrl, sbdev, node);
|
|
if (ret) {
|
|
put_device(&sbdev->dev);
|
|
return NULL;
|
|
}
|
|
|
|
return sbdev;
|
|
}
|
|
|
|
static void of_register_slim_devices(struct slim_controller *ctrl)
|
|
{
|
|
struct device *dev = ctrl->dev;
|
|
struct device_node *node;
|
|
|
|
if (!ctrl->dev->of_node)
|
|
return;
|
|
|
|
for_each_child_of_node(ctrl->dev->of_node, node) {
|
|
struct slim_device *sbdev;
|
|
struct slim_eaddr e_addr;
|
|
const char *compat = NULL;
|
|
int reg[2], ret;
|
|
int manf_id, prod_code;
|
|
|
|
compat = of_get_property(node, "compatible", NULL);
|
|
if (!compat)
|
|
continue;
|
|
|
|
ret = sscanf(compat, "slim%x,%x", &manf_id, &prod_code);
|
|
if (ret != 2) {
|
|
dev_err(dev, "Manf ID & Product code not found %s\n",
|
|
compat);
|
|
continue;
|
|
}
|
|
|
|
ret = of_property_read_u32_array(node, "reg", reg, 2);
|
|
if (ret) {
|
|
dev_err(dev, "Device and Instance id not found:%d\n",
|
|
ret);
|
|
continue;
|
|
}
|
|
|
|
e_addr.dev_index = reg[0];
|
|
e_addr.instance = reg[1];
|
|
e_addr.manf_id = manf_id;
|
|
e_addr.prod_code = prod_code;
|
|
|
|
sbdev = slim_alloc_device(ctrl, &e_addr, node);
|
|
if (!sbdev)
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* slim_register_controller() - Controller bring-up and registration.
|
|
*
|
|
* @ctrl: Controller to be registered.
|
|
*
|
|
* A controller is registered with the framework using this API.
|
|
* If devices on a controller were registered before controller,
|
|
* this will make sure that they get probed when controller is up
|
|
*/
|
|
int slim_register_controller(struct slim_controller *ctrl)
|
|
{
|
|
int id;
|
|
|
|
id = ida_simple_get(&ctrl_ida, 0, 0, GFP_KERNEL);
|
|
if (id < 0)
|
|
return id;
|
|
|
|
ctrl->id = id;
|
|
|
|
if (!ctrl->min_cg)
|
|
ctrl->min_cg = SLIM_MIN_CLK_GEAR;
|
|
if (!ctrl->max_cg)
|
|
ctrl->max_cg = SLIM_MAX_CLK_GEAR;
|
|
|
|
ida_init(&ctrl->laddr_ida);
|
|
idr_init(&ctrl->tid_idr);
|
|
mutex_init(&ctrl->lock);
|
|
mutex_init(&ctrl->sched.m_reconf);
|
|
init_completion(&ctrl->sched.pause_comp);
|
|
spin_lock_init(&ctrl->txn_lock);
|
|
|
|
dev_dbg(ctrl->dev, "Bus [%s] registered:dev:%p\n",
|
|
ctrl->name, ctrl->dev);
|
|
|
|
of_register_slim_devices(ctrl);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_register_controller);
|
|
|
|
/* slim_remove_device: Remove the effect of slim_add_device() */
|
|
static void slim_remove_device(struct slim_device *sbdev)
|
|
{
|
|
of_node_put(sbdev->dev.of_node);
|
|
device_unregister(&sbdev->dev);
|
|
}
|
|
|
|
static int slim_ctrl_remove_device(struct device *dev, void *null)
|
|
{
|
|
slim_remove_device(to_slim_device(dev));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* slim_unregister_controller() - Controller tear-down.
|
|
*
|
|
* @ctrl: Controller to tear-down.
|
|
*/
|
|
int slim_unregister_controller(struct slim_controller *ctrl)
|
|
{
|
|
/* Remove all clients */
|
|
device_for_each_child(ctrl->dev, NULL, slim_ctrl_remove_device);
|
|
ida_simple_remove(&ctrl_ida, ctrl->id);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_unregister_controller);
|
|
|
|
/**
|
|
* slim_report_absent() - Controller calls this function when a device
|
|
* reports absent, OR when the device cannot be communicated with
|
|
*
|
|
* @sbdev: Device that cannot be reached, or sent report absent
|
|
*/
|
|
void slim_report_absent(struct slim_device *sbdev)
|
|
{
|
|
struct slim_controller *ctrl = sbdev->ctrl;
|
|
|
|
if (!ctrl)
|
|
return;
|
|
|
|
/* invalidate logical addresses */
|
|
mutex_lock(&ctrl->lock);
|
|
sbdev->is_laddr_valid = false;
|
|
mutex_unlock(&ctrl->lock);
|
|
if (!ctrl->get_laddr)
|
|
ida_simple_remove(&ctrl->laddr_ida, sbdev->laddr);
|
|
slim_device_update_status(sbdev, SLIM_DEVICE_STATUS_DOWN);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_report_absent);
|
|
|
|
static bool slim_eaddr_equal(struct slim_eaddr *a, struct slim_eaddr *b)
|
|
{
|
|
return (a->manf_id == b->manf_id &&
|
|
a->prod_code == b->prod_code &&
|
|
a->dev_index == b->dev_index &&
|
|
a->instance == b->instance);
|
|
}
|
|
|
|
static int slim_match_dev(struct device *dev, void *data)
|
|
{
|
|
struct slim_eaddr *e_addr = data;
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
|
|
return slim_eaddr_equal(&sbdev->e_addr, e_addr);
|
|
}
|
|
|
|
static struct slim_device *find_slim_device(struct slim_controller *ctrl,
|
|
struct slim_eaddr *eaddr)
|
|
{
|
|
struct slim_device *sbdev;
|
|
struct device *dev;
|
|
|
|
dev = device_find_child(ctrl->dev, eaddr, slim_match_dev);
|
|
if (dev) {
|
|
sbdev = to_slim_device(dev);
|
|
return sbdev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* slim_get_device() - get handle to a device.
|
|
*
|
|
* @ctrl: Controller on which this device will be added/queried
|
|
* @e_addr: Enumeration address of the device to be queried
|
|
*
|
|
* Return: pointer to a device if it has already reported. Creates a new
|
|
* device and returns pointer to it if the device has not yet enumerated.
|
|
*/
|
|
struct slim_device *slim_get_device(struct slim_controller *ctrl,
|
|
struct slim_eaddr *e_addr)
|
|
{
|
|
struct slim_device *sbdev;
|
|
|
|
sbdev = find_slim_device(ctrl, e_addr);
|
|
if (!sbdev) {
|
|
sbdev = slim_alloc_device(ctrl, e_addr, NULL);
|
|
if (!sbdev)
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
return sbdev;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_get_device);
|
|
|
|
static int of_slim_match_dev(struct device *dev, void *data)
|
|
{
|
|
struct device_node *np = data;
|
|
struct slim_device *sbdev = to_slim_device(dev);
|
|
|
|
return (sbdev->dev.of_node == np);
|
|
}
|
|
|
|
static struct slim_device *of_find_slim_device(struct slim_controller *ctrl,
|
|
struct device_node *np)
|
|
{
|
|
struct slim_device *sbdev;
|
|
struct device *dev;
|
|
|
|
dev = device_find_child(ctrl->dev, np, of_slim_match_dev);
|
|
if (dev) {
|
|
sbdev = to_slim_device(dev);
|
|
return sbdev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* of_slim_get_device() - get handle to a device using dt node.
|
|
*
|
|
* @ctrl: Controller on which this device will be added/queried
|
|
* @np: node pointer to device
|
|
*
|
|
* Return: pointer to a device if it has already reported. Creates a new
|
|
* device and returns pointer to it if the device has not yet enumerated.
|
|
*/
|
|
struct slim_device *of_slim_get_device(struct slim_controller *ctrl,
|
|
struct device_node *np)
|
|
{
|
|
return of_find_slim_device(ctrl, np);
|
|
}
|
|
EXPORT_SYMBOL_GPL(of_slim_get_device);
|
|
|
|
static int slim_device_alloc_laddr(struct slim_device *sbdev,
|
|
bool report_present)
|
|
{
|
|
struct slim_controller *ctrl = sbdev->ctrl;
|
|
u8 laddr;
|
|
int ret;
|
|
|
|
mutex_lock(&ctrl->lock);
|
|
if (ctrl->get_laddr) {
|
|
ret = ctrl->get_laddr(ctrl, &sbdev->e_addr, &laddr);
|
|
if (ret < 0)
|
|
goto err;
|
|
} else if (report_present) {
|
|
ret = ida_simple_get(&ctrl->laddr_ida,
|
|
0, SLIM_LA_MANAGER - 1, GFP_KERNEL);
|
|
if (ret < 0)
|
|
goto err;
|
|
|
|
laddr = ret;
|
|
} else {
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
|
|
if (ctrl->set_laddr) {
|
|
ret = ctrl->set_laddr(ctrl, &sbdev->e_addr, laddr);
|
|
if (ret) {
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
sbdev->laddr = laddr;
|
|
sbdev->is_laddr_valid = true;
|
|
mutex_unlock(&ctrl->lock);
|
|
|
|
slim_device_update_status(sbdev, SLIM_DEVICE_STATUS_UP);
|
|
|
|
dev_dbg(ctrl->dev, "setting slimbus l-addr:%x, ea:%x,%x,%x,%x\n",
|
|
laddr, sbdev->e_addr.manf_id, sbdev->e_addr.prod_code,
|
|
sbdev->e_addr.dev_index, sbdev->e_addr.instance);
|
|
|
|
return 0;
|
|
|
|
err:
|
|
mutex_unlock(&ctrl->lock);
|
|
return ret;
|
|
|
|
}
|
|
|
|
/**
|
|
* slim_device_report_present() - Report enumerated device.
|
|
*
|
|
* @ctrl: Controller with which device is enumerated.
|
|
* @e_addr: Enumeration address of the device.
|
|
* @laddr: Return logical address (if valid flag is false)
|
|
*
|
|
* Called by controller in response to REPORT_PRESENT. Framework will assign
|
|
* a logical address to this enumeration address.
|
|
* Function returns -EXFULL to indicate that all logical addresses are already
|
|
* taken.
|
|
*/
|
|
int slim_device_report_present(struct slim_controller *ctrl,
|
|
struct slim_eaddr *e_addr, u8 *laddr)
|
|
{
|
|
struct slim_device *sbdev;
|
|
int ret;
|
|
|
|
ret = pm_runtime_get_sync(ctrl->dev);
|
|
|
|
if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {
|
|
dev_err(ctrl->dev, "slim ctrl not active,state:%d, ret:%d\n",
|
|
ctrl->sched.clk_state, ret);
|
|
goto slimbus_not_active;
|
|
}
|
|
|
|
sbdev = slim_get_device(ctrl, e_addr);
|
|
if (IS_ERR(sbdev))
|
|
return -ENODEV;
|
|
|
|
if (sbdev->is_laddr_valid) {
|
|
*laddr = sbdev->laddr;
|
|
return 0;
|
|
}
|
|
|
|
ret = slim_device_alloc_laddr(sbdev, true);
|
|
|
|
slimbus_not_active:
|
|
pm_runtime_mark_last_busy(ctrl->dev);
|
|
pm_runtime_put_autosuspend(ctrl->dev);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_device_report_present);
|
|
|
|
/**
|
|
* slim_get_logical_addr() - get/allocate logical address of a SLIMbus device.
|
|
*
|
|
* @sbdev: client handle requesting the address.
|
|
*
|
|
* Return: zero if a logical address is valid or a new logical address
|
|
* has been assigned. error code in case of error.
|
|
*/
|
|
int slim_get_logical_addr(struct slim_device *sbdev)
|
|
{
|
|
if (!sbdev->is_laddr_valid)
|
|
return slim_device_alloc_laddr(sbdev, false);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_get_logical_addr);
|
|
|
|
static void __exit slimbus_exit(void)
|
|
{
|
|
bus_unregister(&slimbus_bus);
|
|
}
|
|
module_exit(slimbus_exit);
|
|
|
|
static int __init slimbus_init(void)
|
|
{
|
|
return bus_register(&slimbus_bus);
|
|
}
|
|
postcore_initcall(slimbus_init);
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_DESCRIPTION("SLIMbus core");
|