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