spmi.h

  1/* SPDX-License-Identifier: GPL-2.0-only */
  2/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
  3 */
  4#ifndef _LINUX_SPMI_H
  5#define _LINUX_SPMI_H
  6
  7#include <linux/types.h>
  8#include <linux/device.h>
  9#include <linux/mod_devicetable.h>
 10
 11/* Maximum slave identifier */
 12#define SPMI_MAX_SLAVE_ID		16
 13
 14/* SPMI Commands */
 15#define SPMI_CMD_EXT_WRITE		0x00
 16#define SPMI_CMD_RESET			0x10
 17#define SPMI_CMD_SLEEP			0x11
 18#define SPMI_CMD_SHUTDOWN		0x12
 19#define SPMI_CMD_WAKEUP			0x13
 20#define SPMI_CMD_AUTHENTICATE		0x14
 21#define SPMI_CMD_MSTR_READ		0x15
 22#define SPMI_CMD_MSTR_WRITE		0x16
 23#define SPMI_CMD_TRANSFER_BUS_OWNERSHIP	0x1A
 24#define SPMI_CMD_DDB_MASTER_READ	0x1B
 25#define SPMI_CMD_DDB_SLAVE_READ		0x1C
 26#define SPMI_CMD_EXT_READ		0x20
 27#define SPMI_CMD_EXT_WRITEL		0x30
 28#define SPMI_CMD_EXT_READL		0x38
 29#define SPMI_CMD_WRITE			0x40
 30#define SPMI_CMD_READ			0x60
 31#define SPMI_CMD_ZERO_WRITE		0x80
 32
 33/**
 34 * struct spmi_device - Basic representation of an SPMI device
 35 * @dev:	Driver model representation of the device.
 36 * @ctrl:	SPMI controller managing the bus hosting this device.
 37 * @usid:	This devices' Unique Slave IDentifier.
 38 */
 39struct spmi_device {
 40	struct device		dev;
 41	struct spmi_controller	*ctrl;
 42	u8			usid;
 43};
 44
 45static inline struct spmi_device *to_spmi_device(struct device *d)
 46{
 47	return container_of(d, struct spmi_device, dev);
 48}
 49
 50static inline void *spmi_device_get_drvdata(const struct spmi_device *sdev)
 51{
 52	return dev_get_drvdata(&sdev->dev);
 53}
 54
 55static inline void spmi_device_set_drvdata(struct spmi_device *sdev, void *data)
 56{
 57	dev_set_drvdata(&sdev->dev, data);
 58}
 59
 60struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl);
 61
 62static inline void spmi_device_put(struct spmi_device *sdev)
 63{
 64	if (sdev)
 65		put_device(&sdev->dev);
 66}
 67
 68int spmi_device_add(struct spmi_device *sdev);
 69
 70void spmi_device_remove(struct spmi_device *sdev);
 71
 72/**
 73 * struct spmi_controller - interface to the SPMI master controller
 74 * @dev:	Driver model representation of the device.
 75 * @nr:		board-specific number identifier for this controller/bus
 76 * @cmd:	sends a non-data command sequence on the SPMI bus.
 77 * @read_cmd:	sends a register read command sequence on the SPMI bus.
 78 * @write_cmd:	sends a register write command sequence on the SPMI bus.
 79 */
 80struct spmi_controller {
 81	struct device		dev;
 82	unsigned int		nr;
 83	int	(*cmd)(struct spmi_controller *ctrl, u8 opcode, u8 sid);
 84	int	(*read_cmd)(struct spmi_controller *ctrl, u8 opcode,
 85			    u8 sid, u16 addr, u8 *buf, size_t len);
 86	int	(*write_cmd)(struct spmi_controller *ctrl, u8 opcode,
 87			     u8 sid, u16 addr, const u8 *buf, size_t len);
 88};
 89
 90static inline struct spmi_controller *to_spmi_controller(struct device *d)
 91{
 92	return container_of(d, struct spmi_controller, dev);
 93}
 94
 95static inline
 96void *spmi_controller_get_drvdata(const struct spmi_controller *ctrl)
 97{
 98	return dev_get_drvdata(&ctrl->dev);
 99}
100
101static inline void spmi_controller_set_drvdata(struct spmi_controller *ctrl,
102					       void *data)
103{
104	dev_set_drvdata(&ctrl->dev, data);
105}
106
107struct spmi_controller *spmi_controller_alloc(struct device *parent,
108					      size_t size);
109
110/**
111 * spmi_controller_put() - decrement controller refcount
112 * @ctrl	SPMI controller.
113 */
114static inline void spmi_controller_put(struct spmi_controller *ctrl)
115{
116	if (ctrl)
117		put_device(&ctrl->dev);
118}
119
120int spmi_controller_add(struct spmi_controller *ctrl);
121void spmi_controller_remove(struct spmi_controller *ctrl);
122
123struct spmi_controller *devm_spmi_controller_alloc(struct device *parent, size_t size);
124int devm_spmi_controller_add(struct device *parent, struct spmi_controller *ctrl);
125
126/**
127 * struct spmi_driver - SPMI slave device driver
128 * @driver:	SPMI device drivers should initialize name and owner field of
129 *		this structure.
130 * @probe:	binds this driver to a SPMI device.
131 * @remove:	unbinds this driver from the SPMI device.
132 *
133 * If PM runtime support is desired for a slave, a device driver can call
134 * pm_runtime_put() from their probe() routine (and a balancing
135 * pm_runtime_get() in remove()).  PM runtime support for a slave is
136 * implemented by issuing a SLEEP command to the slave on runtime_suspend(),
137 * transitioning the slave into the SLEEP state.  On runtime_resume(), a WAKEUP
138 * command is sent to the slave to bring it back to ACTIVE.
139 */
140struct spmi_driver {
141	struct device_driver driver;
142	int	(*probe)(struct spmi_device *sdev);
143	void	(*remove)(struct spmi_device *sdev);
144	void	(*shutdown)(struct spmi_device *sdev);
145};
146
147static inline struct spmi_driver *to_spmi_driver(struct device_driver *d)
148{
149	return container_of(d, struct spmi_driver, driver);
150}
151
152#define spmi_driver_register(sdrv) \
153	__spmi_driver_register(sdrv, THIS_MODULE)
154int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner);
155
156/**
157 * spmi_driver_unregister() - unregister an SPMI client driver
158 * @sdrv:	the driver to unregister
159 */
160static inline void spmi_driver_unregister(struct spmi_driver *sdrv)
161{
162	if (sdrv)
163		driver_unregister(&sdrv->driver);
164}
165
166#define module_spmi_driver(__spmi_driver) \
167	module_driver(__spmi_driver, spmi_driver_register, \
168			spmi_driver_unregister)
169
170struct device_node;
171
172struct spmi_device *spmi_find_device_by_of_node(struct device_node *np);
173int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf);
174int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf,
175			   size_t len);
176int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf,
177			    size_t len);
178int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data);
179int spmi_register_zero_write(struct spmi_device *sdev, u8 data);
180int spmi_ext_register_write(struct spmi_device *sdev, u8 addr,
181			    const u8 *buf, size_t len);
182int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr,
183			     const u8 *buf, size_t len);
184int spmi_command_reset(struct spmi_device *sdev);
185int spmi_command_sleep(struct spmi_device *sdev);
186int spmi_command_wakeup(struct spmi_device *sdev);
187int spmi_command_shutdown(struct spmi_device *sdev);
188
189#endif