2 * Copyright (C) 2014-2015 Samsung Electronics
3 * Przemyslaw Marczak <p.marczak@samsung.com>
5 * Copyright (C) 2011-2012 Samsung Electronics
6 * Lukasz Majewski <l.majewski@samsung.com>
8 * SPDX-License-Identifier: GPL-2.0+
11 #ifndef __CORE_PMIC_H_
12 #define __CORE_PMIC_H_
14 #include <linux/list.h>
17 #include <power/power_chrg.h>
19 enum { PMIC_I2C, PMIC_SPI, PMIC_NONE};
22 enum { I2C_PMIC, I2C_NUM, };
23 enum { PMIC_READ, PMIC_WRITE, };
24 enum { PMIC_SENSOR_BYTE_ORDER_LITTLE, PMIC_SENSOR_BYTE_ORDER_BIG, };
43 u32 (*prepare_tx)(u32 reg, u32 *val, u32 write);
48 int (*fg_battery_check) (struct pmic *p, struct pmic *bat);
49 int (*fg_battery_update) (struct pmic *p, struct pmic *bat);
53 int (*chrg_type) (struct pmic *p);
54 int (*chrg_bat_present) (struct pmic *p);
55 int (*chrg_state) (struct pmic *p, int state, int current);
58 struct power_battery {
60 int (*battery_init) (struct pmic *bat, struct pmic *p1,
61 struct pmic *p2, struct pmic *p3);
62 int (*battery_charge) (struct pmic *bat);
63 /* Keep info about power devices involved with battery operation */
64 struct pmic *chrg, *fg, *muic;
70 unsigned char interface;
71 unsigned char sensor_byte_order;
72 unsigned int number_of_regs;
78 void (*low_power_mode) (void);
79 struct power_battery *pbat;
80 struct power_chrg *chrg;
84 struct list_head list;
86 #endif /* CONFIG_POWER */
90 * U-Boot PMIC Framework
91 * =====================
93 * UCLASS_PMIC - The is designed to provide an I/O interface for PMIC devices.
95 * For the multi-function PMIC devices, this can be used as parent I/O device
96 * for each IC's interface. Then, each children uses its parent for read/write.
98 * The driver model tree could look like this:
101 * |_ BUS 0 device (e.g. I2C0) - UCLASS_I2C/SPI/...
102 * | |_ PMIC device (READ/WRITE ops) - UCLASS_PMIC
103 * | |_ REGULATOR device (ldo/buck/... ops) - UCLASS_REGULATOR
104 * | |_ CHARGER device (charger ops) - UCLASS_CHARGER (in the future)
105 * | |_ MUIC device (microUSB connector ops) - UCLASS_MUIC (in the future)
108 * |_ BUS 1 device (e.g. I2C1) - UCLASS_I2C/SPI/...
109 * |_ PMIC device (READ/WRITE ops) - UCLASS_PMIC
110 * |_ RTC device (rtc ops) - UCLASS_RTC (in the future)
112 * We can find two PMIC cases in boards design:
113 * - single I/O interface
114 * - multiple I/O interfaces
115 * We bind single PMIC device for each interface, to provide an I/O as a parent,
116 * of proper child devices. Each child usually implements a different function,
117 * controlled by the same interface.
119 * The binding should be done automatically. If device tree nodes/subnodes are
120 * proper defined, then:
122 * |_ the ROOT driver will bind the device for I2C/SPI node:
123 * |_ the I2C/SPI driver should bind a device for pmic node:
124 * |_ the PMIC driver should bind devices for its childs:
125 * |_ regulator (child)
129 * The same for other device nodes, for multi-interface PMIC.
132 * Each PMIC interface driver should use a different compatible string.
134 * If each pmic child device driver need access the PMIC-specific registers,
135 * it need know only the register address and the access can be done through
136 * the parent pmic driver. Like in the example:
139 * |_ dev: bus I2C0 - UCLASS_I2C
140 * | |_ dev: my_pmic (read/write) (is parent) - UCLASS_PMIC
141 * | |_ dev: my_regulator (set value/etc..) (is child) - UCLASS_REGULATOR
143 * To ensure such device relationship, the pmic device driver should also bind
144 * all its child devices, like in the example below. It should be done by call
145 * the 'pmic_bind_childs()' - please refer to the description of this function
146 * in this header file. This function, should be called in the driver's '.bind'
149 * For the example driver, please refer the MAX77686 driver:
150 * - 'drivers/power/pmic/max77686.c'
154 * struct dm_pmic_ops - PMIC device I/O interface
156 * Should be implemented by UCLASS_PMIC device drivers. The standard
157 * device operations provides the I/O interface for it's childs.
159 * @reg_count: devices register count
160 * @read: read 'len' bytes at "reg" and store it into the 'buffer'
161 * @write: write 'len' bytes from the 'buffer' to the register at 'reg' address
165 int (*read)(struct udevice *dev, uint reg, uint8_t *buffer, int len);
166 int (*write)(struct udevice *dev, uint reg, const uint8_t *buffer,
170 /* enum pmic_op_type - used for various pmic devices operation calls,
171 * for reduce a number of lines with the same code for read/write or get/set.
173 * @PMIC_OP_GET - get operation
174 * @PMIC_OP_SET - set operation
182 * struct pmic_child_info - basic device's child info for bind child nodes with
183 * the driver by the node name prefix and driver name. This is a helper struct
184 * for function: pmic_bind_childs().
186 * @prefix - child node name prefix (or its name if is unique or single)
187 * @driver - driver name for the sub-node with prefix
189 struct pmic_child_info {
194 /* drivers/power/pmic-uclass.c */
197 * pmic_bind_childs() - bind drivers for given parent pmic, using child info
198 * found in 'child_info' array.
200 * @pmic - pmic device - the parent of found child's
201 * @child_info - N-childs info array
202 * @return a positive number of childs, or 0 if no child found (error)
204 * Note: For N-childs the child_info array should have N+1 entries and the last
205 * entry prefix should be NULL - the same as for drivers compatible.
207 * For example, a single prefix info (N=1):
208 * static const struct pmic_child_info bind_info[] = {
209 * { .prefix = "ldo", .driver = "ldo_driver" },
213 * This function is useful for regulator sub-nodes:
216 * (pmic - bind automatically by compatible)
217 * compatible = "my_pmic";
219 * (pmic's childs - bind by pmic_bind_childs())
220 * (nodes prefix: "ldo", driver: "my_regulator_ldo")
224 * (nodes prefix: "buck", driver: "my_regulator_buck")
229 int pmic_bind_childs(struct udevice *pmic, int offset,
230 const struct pmic_child_info *child_info);
233 * pmic_get: get the pmic device using its name
235 * @name - device name
236 * @devp - returned pointer to the pmic device
237 * @return 0 on success or negative value of errno.
239 * The returned devp device can be used with pmic_read/write calls
241 int pmic_get(const char *name, struct udevice **devp);
244 * pmic_reg_count: get the pmic register count
246 * The required pmic device can be obtained by 'pmic_get()'
248 * @dev - pointer to the UCLASS_PMIC device
249 * @return register count value on success or negative value of errno.
251 int pmic_reg_count(struct udevice *dev);
254 * pmic_read/write: read/write to the UCLASS_PMIC device
256 * The required pmic device can be obtained by 'pmic_get()'
258 * @pmic - pointer to the UCLASS_PMIC device
259 * @reg - device register offset
260 * @buffer - pointer to read/write buffer
261 * @len - byte count for read/write
262 * @return 0 on success or negative value of errno.
264 int pmic_read(struct udevice *dev, uint reg, uint8_t *buffer, int len);
265 int pmic_write(struct udevice *dev, uint reg, const uint8_t *buffer, int len);
266 #endif /* CONFIG_DM_PMIC */
269 int pmic_init(unsigned char bus);
270 int power_init_board(void);
271 int pmic_dialog_init(unsigned char bus);
272 int check_reg(struct pmic *p, u32 reg);
273 struct pmic *pmic_alloc(void);
274 struct pmic *pmic_get(const char *s);
275 int pmic_probe(struct pmic *p);
276 int pmic_reg_read(struct pmic *p, u32 reg, u32 *val);
277 int pmic_reg_write(struct pmic *p, u32 reg, u32 val);
278 int pmic_set_output(struct pmic *p, u32 reg, int ldo, int on);
281 #define pmic_i2c_addr (p->hw.i2c.addr)
282 #define pmic_i2c_tx_num (p->hw.i2c.tx_num)
284 #define pmic_spi_bitlen (p->hw.spi.bitlen)
285 #define pmic_spi_flags (p->hw.spi.flags)
287 #endif /* __CORE_PMIC_H_ */