LXR linux/include/linux/spmi.h

   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 */
  39struct spmi_device {
  40        struct device           dev;
  41        struct spmi_controller  *ctrl;
  42        u8                      usid;
  43};
  44
  45static inline struct spmi_device *to_spmi_device(struct device *d)
  46{
  47        return container_of(d, struct spmi_device, dev);
  48}
  49
  50static inline void *spmi_device_get_drvdata(const struct spmi_device *sdev)
  51{
  52        return dev_get_drvdata(&sdev->dev);
  53}
  54
  55static inline void spmi_device_set_drvdata(struct spmi_device *sdev, void *data)
  56{
  57        dev_set_drvdata(&sdev->dev, data);
  58}
  59
  60struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl);
  61
  62static inline void spmi_device_put(struct spmi_device *sdev)
  63{
  64        if (sdev)
  65                put_device(&sdev->dev);
  66}
  67
  68int spmi_device_add(struct spmi_device *sdev);
  69
  70void 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 */
  80struct 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
  90static inline struct spmi_controller *to_spmi_controller(struct device *d)
  91{
  92        return container_of(d, struct spmi_controller, dev);
  93}
  94
  95static inline
  96void *spmi_controller_get_drvdata(const struct spmi_controller *ctrl)
  97{
  98        return dev_get_drvdata(&ctrl->dev);
  99}
 100
 101static inline void spmi_controller_set_drvdata(struct spmi_controller *ctrl,
 102                                               void *data)
 103{
 104        dev_set_drvdata(&ctrl->dev, data);
 105}
 106
 107struct 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 */
 114static inline void spmi_controller_put(struct spmi_controller *ctrl)
 115{
 116        if (ctrl)
 117                put_device(&ctrl->dev);
 118}
 119
 120int spmi_controller_add(struct spmi_controller *ctrl);
 121void 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 */
 137struct 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
 144static 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)
 151int __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 */
 157static 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
 167int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf);
 168int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf,
 169                           size_t len);
 170int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf,
 171                            size_t len);
 172int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data);
 173int spmi_register_zero_write(struct spmi_device *sdev, u8 data);
 174int spmi_ext_register_write(struct spmi_device *sdev, u8 addr,
 175                            const u8 *buf, size_t len);
 176int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr,
 177                             const u8 *buf, size_t len);
 178int spmi_command_reset(struct spmi_device *sdev);
 179int spmi_command_sleep(struct spmi_device *sdev);
 180int spmi_command_wakeup(struct spmi_device *sdev);
 181int spmi_command_shutdown(struct spmi_device *sdev);
 182
 183#endif
 184