// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved. */ #include <linux/kernel.h> #include <linux/errno.h> #include <linux/idr.h> #include <linux/slab.h> #include <linux/module.h> #include <linux/of.h> #include <linux/of_device.h> #include <linux/platform_device.h> #include <linux/spmi.h> #include <linux/pm_runtime.h> #include <dt-bindings/spmi/spmi.h> #define CREATE_TRACE_POINTS #include <trace/events/spmi.h> static bool is_registered; static DEFINE_IDA(ctrl_ida); static void spmi_dev_release(struct device *dev) { … } static const struct device_type spmi_dev_type = …; static void spmi_ctrl_release(struct device *dev) { … } static const struct device_type spmi_ctrl_type = …; static int spmi_device_match(struct device *dev, const struct device_driver *drv) { … } /** * spmi_device_add() - add a device previously constructed via spmi_device_alloc() * @sdev: spmi_device to be added */ int spmi_device_add(struct spmi_device *sdev) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_device_remove(): remove an SPMI device * @sdev: spmi_device to be removed */ void spmi_device_remove(struct spmi_device *sdev) { … } EXPORT_SYMBOL_GPL(…); static inline int spmi_cmd(struct spmi_controller *ctrl, u8 opcode, u8 sid) { … } static inline int spmi_read_cmd(struct spmi_controller *ctrl, u8 opcode, u8 sid, u16 addr, u8 *buf, size_t len) { … } static inline int spmi_write_cmd(struct spmi_controller *ctrl, u8 opcode, u8 sid, u16 addr, const u8 *buf, size_t len) { … } /** * spmi_register_read() - register read * @sdev: SPMI device. * @addr: slave register address (5-bit address). * @buf: buffer to be populated with data from the Slave. * * Reads 1 byte of data from a Slave device register. */ int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_ext_register_read() - extended register read * @sdev: SPMI device. * @addr: slave register address (8-bit address). * @buf: buffer to be populated with data from the Slave. * @len: the request number of bytes to read (up to 16 bytes). * * Reads up to 16 bytes of data from the extended register space on a * Slave device. */ int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf, size_t len) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_ext_register_readl() - extended register read long * @sdev: SPMI device. * @addr: slave register address (16-bit address). * @buf: buffer to be populated with data from the Slave. * @len: the request number of bytes to read (up to 8 bytes). * * Reads up to 8 bytes of data from the extended register space on a * Slave device using 16-bit address. */ int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf, size_t len) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_register_write() - register write * @sdev: SPMI device * @addr: slave register address (5-bit address). * @data: buffer containing the data to be transferred to the Slave. * * Writes 1 byte of data to a Slave device register. */ int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_register_zero_write() - register zero write * @sdev: SPMI device. * @data: the data to be written to register 0 (7-bits). * * Writes data to register 0 of the Slave device. */ int spmi_register_zero_write(struct spmi_device *sdev, u8 data) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_ext_register_write() - extended register write * @sdev: SPMI device. * @addr: slave register address (8-bit address). * @buf: buffer containing the data to be transferred to the Slave. * @len: the request number of bytes to read (up to 16 bytes). * * Writes up to 16 bytes of data to the extended register space of a * Slave device. */ int spmi_ext_register_write(struct spmi_device *sdev, u8 addr, const u8 *buf, size_t len) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_ext_register_writel() - extended register write long * @sdev: SPMI device. * @addr: slave register address (16-bit address). * @buf: buffer containing the data to be transferred to the Slave. * @len: the request number of bytes to read (up to 8 bytes). * * Writes up to 8 bytes of data to the extended register space of a * Slave device using 16-bit address. */ int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr, const u8 *buf, size_t len) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_command_reset() - sends RESET command to the specified slave * @sdev: SPMI device. * * The Reset command initializes the Slave and forces all registers to * their reset values. The Slave shall enter the STARTUP state after * receiving a Reset command. */ int spmi_command_reset(struct spmi_device *sdev) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_command_sleep() - sends SLEEP command to the specified SPMI device * @sdev: SPMI device. * * The Sleep command causes the Slave to enter the user defined SLEEP state. */ int spmi_command_sleep(struct spmi_device *sdev) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_command_wakeup() - sends WAKEUP command to the specified SPMI device * @sdev: SPMI device. * * The Wakeup command causes the Slave to move from the SLEEP state to * the ACTIVE state. */ int spmi_command_wakeup(struct spmi_device *sdev) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_command_shutdown() - sends SHUTDOWN command to the specified SPMI device * @sdev: SPMI device. * * The Shutdown command causes the Slave to enter the SHUTDOWN state. */ int spmi_command_shutdown(struct spmi_device *sdev) { … } EXPORT_SYMBOL_GPL(…); static int spmi_drv_probe(struct device *dev) { … } static void spmi_drv_remove(struct device *dev) { … } static void spmi_drv_shutdown(struct device *dev) { … } static int spmi_drv_uevent(const struct device *dev, struct kobj_uevent_env *env) { … } static const struct bus_type spmi_bus_type = …; /** * spmi_find_device_by_of_node() - look up an SPMI device from a device node * * @np: device node * * Takes a reference to the embedded struct device which needs to be dropped * after use. * * Returns the struct spmi_device associated with a device node or NULL. */ struct spmi_device *spmi_find_device_by_of_node(struct device_node *np) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_device_alloc() - Allocate a new SPMI device * @ctrl: associated controller * * Caller is responsible for either calling spmi_device_add() to add the * newly allocated controller, or calling spmi_device_put() to discard it. */ struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl) { … } EXPORT_SYMBOL_GPL(…); /** * spmi_controller_alloc() - Allocate a new SPMI controller * @parent: parent device * @size: size of private data * * Caller is responsible for either calling spmi_controller_add() to add the * newly allocated controller, or calling spmi_controller_put() to discard it. * The allocated private data region may be accessed via * spmi_controller_get_drvdata() */ struct spmi_controller *spmi_controller_alloc(struct device *parent, size_t size) { … } EXPORT_SYMBOL_GPL(…); static void of_spmi_register_devices(struct spmi_controller *ctrl) { … } /** * spmi_controller_add() - Add an SPMI controller * @ctrl: controller to be registered. * * Register a controller previously allocated via spmi_controller_alloc() with * the SPMI core. */ int spmi_controller_add(struct spmi_controller *ctrl) { int ret; /* Can't register until after driver model init */ if (WARN_ON(!is_registered)) return -EAGAIN; ret = device_add(&ctrl->dev); if (ret) return ret; if (IS_ENABLED(CONFIG_OF)) of_spmi_register_devices(ctrl); dev_dbg(&ctrl->dev, "spmi-%d registered: dev:%p\n", ctrl->nr, &ctrl->dev); return 0; }; EXPORT_SYMBOL_GPL(…); /* Remove a device associated with a controller */ static int spmi_ctrl_remove_device(struct device *dev, void *data) { … } /** * spmi_controller_remove(): remove an SPMI controller * @ctrl: controller to remove * * Remove a SPMI controller. Caller is responsible for calling * spmi_controller_put() to discard the allocated controller. */ void spmi_controller_remove(struct spmi_controller *ctrl) { … } EXPORT_SYMBOL_GPL(…); /** * __spmi_driver_register() - Register client driver with SPMI core * @sdrv: client driver to be associated with client-device. * @owner: module owner * * This API will register the client driver with the SPMI framework. * It is typically called from the driver's module-init function. */ int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner) { … } EXPORT_SYMBOL_GPL(…); static void __exit spmi_exit(void) { … } module_exit(spmi_exit); static int __init spmi_init(void) { … } postcore_initcall(spmi_init); MODULE_LICENSE(…) …; MODULE_DESCRIPTION(…) …; MODULE_ALIAS(…) …;
Codebase Browser
linux