| 1 | |
| 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 |
|
| 20 | #define SPMI_MAX_SLAVE_ID 16
|
| 21 |
|
| 22 |
|
| 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
|