~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/spmi.h

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /include/linux/spmi.h (Version linux-6.12-rc7) and /include/linux/spmi.h (Version linux-5.13.19)


  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php