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