1 /* 2 * Copyright (C) 2014-2015 Samsung Electronics 3 * Przemyslaw Marczak <p.marczak@samsung.com> 4 * 5 * Copyright (C) 2011-2012 Samsung Electronics 6 * Lukasz Majewski <l.majewski@samsung.com> 7 * 8 * SPDX-License-Identifier: GPL-2.0+ 9 */ 10 11 #ifndef __CORE_PMIC_H_ 12 #define __CORE_PMIC_H_ 13 14 #include <i2c.h> 15 #include <linux/list.h> 16 #include <power/power_chrg.h> 17 18 enum { PMIC_I2C, PMIC_SPI, PMIC_NONE}; 19 20 #ifdef CONFIG_POWER 21 enum { I2C_PMIC, I2C_NUM, }; 22 enum { PMIC_READ, PMIC_WRITE, }; 23 enum { PMIC_SENSOR_BYTE_ORDER_LITTLE, PMIC_SENSOR_BYTE_ORDER_BIG, }; 24 25 enum { 26 PMIC_CHARGER_DISABLE, 27 PMIC_CHARGER_ENABLE, 28 }; 29 30 struct p_i2c { 31 unsigned char addr; 32 unsigned char *buf; 33 unsigned char tx_num; 34 }; 35 36 struct p_spi { 37 unsigned int cs; 38 unsigned int mode; 39 unsigned int bitlen; 40 unsigned int clk; 41 unsigned int flags; 42 u32 (*prepare_tx)(u32 reg, u32 *val, u32 write); 43 }; 44 45 struct pmic; 46 struct power_fg { 47 int (*fg_battery_check) (struct pmic *p, struct pmic *bat); 48 int (*fg_battery_update) (struct pmic *p, struct pmic *bat); 49 }; 50 51 struct power_chrg { 52 int (*chrg_type) (struct pmic *p); 53 int (*chrg_bat_present) (struct pmic *p); 54 int (*chrg_state) (struct pmic *p, int state, int current); 55 }; 56 57 struct power_battery { 58 struct battery *bat; 59 int (*battery_init) (struct pmic *bat, struct pmic *p1, 60 struct pmic *p2, struct pmic *p3); 61 int (*battery_charge) (struct pmic *bat); 62 /* Keep info about power devices involved with battery operation */ 63 struct pmic *chrg, *fg, *muic; 64 }; 65 66 struct pmic { 67 const char *name; 68 unsigned char bus; 69 unsigned char interface; 70 unsigned char sensor_byte_order; 71 unsigned int number_of_regs; 72 union hw { 73 struct p_i2c i2c; 74 struct p_spi spi; 75 } hw; 76 77 void (*low_power_mode) (void); 78 struct power_battery *pbat; 79 struct power_chrg *chrg; 80 struct power_fg *fg; 81 82 struct pmic *parent; 83 struct list_head list; 84 }; 85 #endif /* CONFIG_POWER */ 86 87 #ifdef CONFIG_DM_PMIC 88 /** 89 * U-Boot PMIC Framework 90 * ===================== 91 * 92 * UCLASS_PMIC - This is designed to provide an I/O interface for PMIC devices. 93 * 94 * For the multi-function PMIC devices, this can be used as parent I/O device 95 * for each IC's interface. Then, each child uses its parent for read/write. 96 * 97 * The driver model tree could look like this: 98 * 99 *_ root device 100 * |_ BUS 0 device (e.g. I2C0) - UCLASS_I2C/SPI/... 101 * | |_ PMIC device (READ/WRITE ops) - UCLASS_PMIC 102 * | |_ REGULATOR device (ldo/buck/... ops) - UCLASS_REGULATOR 103 * | |_ CHARGER device (charger ops) - UCLASS_CHARGER (in the future) 104 * | |_ MUIC device (microUSB connector ops) - UCLASS_MUIC (in the future) 105 * | |_ ... 106 * | 107 * |_ BUS 1 device (e.g. I2C1) - UCLASS_I2C/SPI/... 108 * |_ PMIC device (READ/WRITE ops) - UCLASS_PMIC 109 * |_ RTC device (rtc ops) - UCLASS_RTC (in the future) 110 * 111 * We can find two PMIC cases in boards design: 112 * - single I/O interface 113 * - multiple I/O interfaces 114 * We bind a single PMIC device for each interface, to provide an I/O for 115 * its child devices. And each child usually implements a different function, 116 * controlled by the same interface. 117 * 118 * The binding should be done automatically. If device tree nodes/subnodes are 119 * proper defined, then: 120 * 121 * |_ the ROOT driver will bind the device for I2C/SPI node: 122 * |_ the I2C/SPI driver should bind a device for pmic node: 123 * |_ the PMIC driver should bind devices for its childs: 124 * |_ regulator (child) 125 * |_ charger (child) 126 * |_ other (child) 127 * 128 * The same for other device nodes, for multi-interface PMIC. 129 * 130 * Note: 131 * Each PMIC interface driver should use a different compatible string. 132 * 133 * If a PMIC child device driver needs access the PMIC-specific registers, 134 * it need know only the register address and the access can be done through 135 * the parent pmic driver. Like in the example: 136 * 137 *_ root driver 138 * |_ dev: bus I2C0 - UCLASS_I2C 139 * | |_ dev: my_pmic (read/write) (is parent) - UCLASS_PMIC 140 * | |_ dev: my_regulator (set value/etc..) (is child) - UCLASS_REGULATOR 141 * 142 * To ensure such device relationship, the pmic device driver should also bind 143 * all its child devices, like in the example below. It can be done by calling 144 * the 'pmic_bind_children()' - please refer to the function description, which 145 * can be found in this header file. This function, should be called inside the 146 * driver's bind() method. 147 * 148 * For the example driver, please refer the MAX77686 driver: 149 * - 'drivers/power/pmic/max77686.c' 150 */ 151 152 /** 153 * struct dm_pmic_ops - PMIC device I/O interface 154 * 155 * Should be implemented by UCLASS_PMIC device drivers. The standard 156 * device operations provides the I/O interface for it's childs. 157 * 158 * @reg_count: device's register count 159 * @read: read 'len' bytes at "reg" and store it into the 'buffer' 160 * @write: write 'len' bytes from the 'buffer' to the register at 'reg' address 161 */ 162 struct dm_pmic_ops { 163 int (*reg_count)(struct udevice *dev); 164 int (*read)(struct udevice *dev, uint reg, uint8_t *buffer, int len); 165 int (*write)(struct udevice *dev, uint reg, const uint8_t *buffer, 166 int len); 167 int (*shutdown)(struct udevice *dev); 168 }; 169 170 /** 171 * enum pmic_op_type - used for various pmic devices operation calls, 172 * for reduce a number of lines with the same code for read/write or get/set. 173 * 174 * @PMIC_OP_GET - get operation 175 * @PMIC_OP_SET - set operation 176 */ 177 enum pmic_op_type { 178 PMIC_OP_GET, 179 PMIC_OP_SET, 180 }; 181 182 /** 183 * struct pmic_child_info - basic device's child info for bind child nodes with 184 * the driver by the node name prefix and driver name. This is a helper struct 185 * for function: pmic_bind_children(). 186 * 187 * @prefix - child node name prefix (or its name if is unique or single) 188 * @driver - driver name for the sub-node with prefix 189 */ 190 struct pmic_child_info { 191 const char *prefix; 192 const char *driver; 193 }; 194 195 /* drivers/power/pmic-uclass.c */ 196 197 /** 198 * pmic_bind_children() - bind drivers for given parent pmic, using child info 199 * found in 'child_info' array. 200 * 201 * @pmic - pmic device - the parent of found child's 202 * @child_info - N-childs info array 203 * @return a positive number of childs, or 0 if no child found (error) 204 * 205 * Note: For N-childs the child_info array should have N+1 entries and the last 206 * entry prefix should be NULL - the same as for drivers compatible. 207 * 208 * For example, a single prefix info (N=1): 209 * static const struct pmic_child_info bind_info[] = { 210 * { .prefix = "ldo", .driver = "ldo_driver" }, 211 * { }, 212 * }; 213 * 214 * This function is useful for regulator sub-nodes: 215 * my_regulator@0xa { 216 * reg = <0xa>; 217 * (pmic - bind automatically by compatible) 218 * compatible = "my_pmic"; 219 * ... 220 * (pmic's childs - bind by pmic_bind_children()) 221 * (nodes prefix: "ldo", driver: "my_regulator_ldo") 222 * ldo1 { ... }; 223 * ldo2 { ... }; 224 * 225 * (nodes prefix: "buck", driver: "my_regulator_buck") 226 * buck1 { ... }; 227 * buck2 { ... }; 228 * }; 229 */ 230 int pmic_bind_children(struct udevice *pmic, ofnode parent, 231 const struct pmic_child_info *child_info); 232 233 /** 234 * pmic_get: get the pmic device using its name 235 * 236 * @name - device name 237 * @devp - returned pointer to the pmic device 238 * @return 0 on success or negative value of errno. 239 * 240 * The returned devp device can be used with pmic_read/write calls 241 */ 242 int pmic_get(const char *name, struct udevice **devp); 243 244 /** 245 * pmic_reg_count: get the pmic register count 246 * 247 * The required pmic device can be obtained by 'pmic_get()' 248 * 249 * @dev - pointer to the UCLASS_PMIC device 250 * @return register count value on success or negative value of errno. 251 */ 252 int pmic_reg_count(struct udevice *dev); 253 254 /** 255 * pmic_read/write: read/write to the UCLASS_PMIC device 256 * 257 * The required pmic device can be obtained by 'pmic_get()' 258 * 259 * @pmic - pointer to the UCLASS_PMIC device 260 * @reg - device register offset 261 * @buffer - pointer to read/write buffer 262 * @len - byte count for read/write 263 * @return 0 on success or negative value of errno. 264 */ 265 int pmic_read(struct udevice *dev, uint reg, uint8_t *buffer, int len); 266 int pmic_write(struct udevice *dev, uint reg, const uint8_t *buffer, int len); 267 268 /** 269 * pmic_reg_read() - read a PMIC register value 270 * 271 * @dev: PMIC device to read 272 * @reg: Register to read 273 * @return value read on success or negative value of errno. 274 */ 275 int pmic_reg_read(struct udevice *dev, uint reg); 276 277 /** 278 * pmic_reg_write() - write a PMIC register value 279 * 280 * @dev: PMIC device to write 281 * @reg: Register to write 282 * @value: Value to write 283 * @return 0 on success or negative value of errno. 284 */ 285 int pmic_reg_write(struct udevice *dev, uint reg, uint value); 286 287 /** 288 * pmic_clrsetbits() - clear and set bits in a PMIC register 289 * 290 * This reads a register, optionally clears some bits, optionally sets some 291 * bits, then writes the register. 292 * 293 * @dev: PMIC device to update 294 * @reg: Register to update 295 * @clr: Bit mask to clear (set those bits that you want cleared) 296 * @set: Bit mask to set (set those bits that you want set) 297 * @return 0 on success or negative value of errno. 298 */ 299 int pmic_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set); 300 301 /** 302 * pmic_shutdown() - power off supplies of PMIC 303 * 304 * @dev: PMIC device to update 305 * @return 0 on success or negative value of errno. 306 */ 307 int pmic_shutdown(struct udevice *dev); 308 309 #endif /* CONFIG_DM_PMIC */ 310 311 #ifdef CONFIG_POWER 312 int pmic_init(unsigned char bus); 313 int power_init_board(void); 314 int pmic_dialog_init(unsigned char bus); 315 int check_reg(struct pmic *p, u32 reg); 316 struct pmic *pmic_alloc(void); 317 struct pmic *pmic_get(const char *s); 318 int pmic_probe(struct pmic *p); 319 int pmic_reg_read(struct pmic *p, u32 reg, u32 *val); 320 int pmic_reg_write(struct pmic *p, u32 reg, u32 val); 321 int pmic_set_output(struct pmic *p, u32 reg, int ldo, int on); 322 #endif 323 324 #define pmic_i2c_addr (p->hw.i2c.addr) 325 #define pmic_i2c_tx_num (p->hw.i2c.tx_num) 326 327 #define pmic_spi_bitlen (p->hw.spi.bitlen) 328 #define pmic_spi_flags (p->hw.spi.flags) 329 330 #endif /* __CORE_PMIC_H_ */ 331