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