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  */
39 struct spmi_device {
40 	struct device		dev;
41 	struct spmi_controller	*ctrl;
42 	u8			usid;
43 };
44 
to_spmi_device(struct device * d)45 static inline struct spmi_device *to_spmi_device(struct device *d)
46 {
47 	return container_of(d, struct spmi_device, dev);
48 }
49 
spmi_device_get_drvdata(const struct spmi_device * sdev)50 static inline void *spmi_device_get_drvdata(const struct spmi_device *sdev)
51 {
52 	return dev_get_drvdata(&sdev->dev);
53 }
54 
spmi_device_set_drvdata(struct spmi_device * sdev,void * data)55 static inline void spmi_device_set_drvdata(struct spmi_device *sdev, void *data)
56 {
57 	dev_set_drvdata(&sdev->dev, data);
58 }
59 
60 struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl);
61 
spmi_device_put(struct spmi_device * sdev)62 static inline void spmi_device_put(struct spmi_device *sdev)
63 {
64 	if (sdev)
65 		put_device(&sdev->dev);
66 }
67 
68 int spmi_device_add(struct spmi_device *sdev);
69 
70 void 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  */
80 struct 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 
to_spmi_controller(struct device * d)90 static inline struct spmi_controller *to_spmi_controller(struct device *d)
91 {
92 	return container_of(d, struct spmi_controller, dev);
93 }
94 
95 static inline
spmi_controller_get_drvdata(const struct spmi_controller * ctrl)96 void *spmi_controller_get_drvdata(const struct spmi_controller *ctrl)
97 {
98 	return dev_get_drvdata(&ctrl->dev);
99 }
100 
spmi_controller_set_drvdata(struct spmi_controller * ctrl,void * data)101 static inline void spmi_controller_set_drvdata(struct spmi_controller *ctrl,
102 					       void *data)
103 {
104 	dev_set_drvdata(&ctrl->dev, data);
105 }
106 
107 struct 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  */
spmi_controller_put(struct spmi_controller * ctrl)114 static inline void spmi_controller_put(struct spmi_controller *ctrl)
115 {
116 	if (ctrl)
117 		put_device(&ctrl->dev);
118 }
119 
120 int spmi_controller_add(struct spmi_controller *ctrl);
121 void spmi_controller_remove(struct spmi_controller *ctrl);
122 
123 /**
124  * struct spmi_driver - SPMI slave device driver
125  * @driver:	SPMI device drivers should initialize name and owner field of
126  *		this structure.
127  * @probe:	binds this driver to a SPMI device.
128  * @remove:	unbinds this driver from the SPMI device.
129  *
130  * If PM runtime support is desired for a slave, a device driver can call
131  * pm_runtime_put() from their probe() routine (and a balancing
132  * pm_runtime_get() in remove()).  PM runtime support for a slave is
133  * implemented by issuing a SLEEP command to the slave on runtime_suspend(),
134  * transitioning the slave into the SLEEP state.  On runtime_resume(), a WAKEUP
135  * command is sent to the slave to bring it back to ACTIVE.
136  */
137 struct spmi_driver {
138 	struct device_driver driver;
139 	int	(*probe)(struct spmi_device *sdev);
140 	void	(*remove)(struct spmi_device *sdev);
141 	void	(*shutdown)(struct spmi_device *sdev);
142 };
143 
to_spmi_driver(struct device_driver * d)144 static inline struct spmi_driver *to_spmi_driver(struct device_driver *d)
145 {
146 	return container_of(d, struct spmi_driver, driver);
147 }
148 
149 #define spmi_driver_register(sdrv) \
150 	__spmi_driver_register(sdrv, THIS_MODULE)
151 int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner);
152 
153 /**
154  * spmi_driver_unregister() - unregister an SPMI client driver
155  * @sdrv:	the driver to unregister
156  */
spmi_driver_unregister(struct spmi_driver * sdrv)157 static inline void spmi_driver_unregister(struct spmi_driver *sdrv)
158 {
159 	if (sdrv)
160 		driver_unregister(&sdrv->driver);
161 }
162 
163 #define module_spmi_driver(__spmi_driver) \
164 	module_driver(__spmi_driver, spmi_driver_register, \
165 			spmi_driver_unregister)
166 
167 struct device_node;
168 
169 struct spmi_device *spmi_device_from_of(struct device_node *np);
170 int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf);
171 int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf,
172 			   size_t len);
173 int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf,
174 			    size_t len);
175 int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data);
176 int spmi_register_zero_write(struct spmi_device *sdev, u8 data);
177 int spmi_ext_register_write(struct spmi_device *sdev, u8 addr,
178 			    const u8 *buf, size_t len);
179 int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr,
180 			     const u8 *buf, size_t len);
181 int spmi_command_reset(struct spmi_device *sdev);
182 int spmi_command_sleep(struct spmi_device *sdev);
183 int spmi_command_wakeup(struct spmi_device *sdev);
184 int spmi_command_shutdown(struct spmi_device *sdev);
185 
186 #endif
187