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 <linux/list.h> 15 #include <spi.h> 16 #include <i2c.h> 17 #include <power/power_chrg.h> 18 19 enum { PMIC_I2C, PMIC_SPI, PMIC_NONE}; 20 21 #ifdef CONFIG_POWER 22 enum { I2C_PMIC, I2C_NUM, }; 23 enum { PMIC_READ, PMIC_WRITE, }; 24 enum { PMIC_SENSOR_BYTE_ORDER_LITTLE, PMIC_SENSOR_BYTE_ORDER_BIG, }; 25 26 enum { 27 PMIC_CHARGER_DISABLE, 28 PMIC_CHARGER_ENABLE, 29 }; 30 31 struct p_i2c { 32 unsigned char addr; 33 unsigned char *buf; 34 unsigned char tx_num; 35 }; 36 37 struct p_spi { 38 unsigned int cs; 39 unsigned int mode; 40 unsigned int bitlen; 41 unsigned int clk; 42 unsigned int flags; 43 u32 (*prepare_tx)(u32 reg, u32 *val, u32 write); 44 }; 45 46 struct pmic; 47 struct power_fg { 48 int (*fg_battery_check) (struct pmic *p, struct pmic *bat); 49 int (*fg_battery_update) (struct pmic *p, struct pmic *bat); 50 }; 51 52 struct power_chrg { 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); 56 }; 57 58 struct power_battery { 59 struct battery *bat; 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; 65 }; 66 67 struct pmic { 68 const char *name; 69 unsigned char bus; 70 unsigned char interface; 71 unsigned char sensor_byte_order; 72 unsigned int number_of_regs; 73 union hw { 74 struct p_i2c i2c; 75 struct p_spi spi; 76 } hw; 77 78 void (*low_power_mode) (void); 79 struct power_battery *pbat; 80 struct power_chrg *chrg; 81 struct power_fg *fg; 82 83 struct pmic *parent; 84 struct list_head list; 85 }; 86 #endif /* CONFIG_POWER */ 87 88 #ifdef CONFIG_DM_PMIC 89 /** 90 * U-Boot PMIC Framework 91 * ===================== 92 * 93 * UCLASS_PMIC - The is designed to provide an I/O interface for PMIC devices. 94 * 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. 97 * 98 * The driver model tree could look like this: 99 * 100 *_ root device 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) 106 * | |_ ... 107 * | 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) 111 * 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. 118 * 119 * The binding should be done automatically. If device tree nodes/subnodes are 120 * proper defined, then: 121 * 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) 126 * |_ charger (child) 127 * |_ other (child) 128 * 129 * The same for other device nodes, for multi-interface PMIC. 130 * 131 * Note: 132 * Each PMIC interface driver should use a different compatible string. 133 * 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: 137 * 138 *_ root driver 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 142 * 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' 147 * method. 148 * 149 * For the example driver, please refer the MAX77686 driver: 150 * - 'drivers/power/pmic/max77686.c' 151 */ 152 153 /** 154 * struct dm_pmic_ops - PMIC device I/O interface 155 * 156 * Should be implemented by UCLASS_PMIC device drivers. The standard 157 * device operations provides the I/O interface for it's childs. 158 * 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 162 */ 163 struct dm_pmic_ops { 164 int reg_count; 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, 167 int len); 168 }; 169 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. 172 * 173 * @PMIC_OP_GET - get operation 174 * @PMIC_OP_SET - set operation 175 */ 176 enum pmic_op_type { 177 PMIC_OP_GET, 178 PMIC_OP_SET, 179 }; 180 181 /** 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(). 185 * 186 * @prefix - child node name prefix (or its name if is unique or single) 187 * @driver - driver name for the sub-node with prefix 188 */ 189 struct pmic_child_info { 190 const char *prefix; 191 const char *driver; 192 }; 193 194 /* drivers/power/pmic-uclass.c */ 195 196 /** 197 * pmic_bind_childs() - bind drivers for given parent pmic, using child info 198 * found in 'child_info' array. 199 * 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) 203 * 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. 206 * 207 * For example, a single prefix info (N=1): 208 * static const struct pmic_child_info bind_info[] = { 209 * { .prefix = "ldo", .driver = "ldo_driver" }, 210 * { }, 211 * }; 212 * 213 * This function is useful for regulator sub-nodes: 214 * my_regulator@0xa { 215 * reg = <0xa>; 216 * (pmic - bind automatically by compatible) 217 * compatible = "my_pmic"; 218 * ... 219 * (pmic's childs - bind by pmic_bind_childs()) 220 * (nodes prefix: "ldo", driver: "my_regulator_ldo") 221 * ldo1 { ... }; 222 * ldo2 { ... }; 223 * 224 * (nodes prefix: "buck", driver: "my_regulator_buck") 225 * buck1 { ... }; 226 * buck2 { ... }; 227 * }; 228 */ 229 int pmic_bind_childs(struct udevice *pmic, int offset, 230 const struct pmic_child_info *child_info); 231 232 /** 233 * pmic_get: get the pmic device using its name 234 * 235 * @name - device name 236 * @devp - returned pointer to the pmic device 237 * @return 0 on success or negative value of errno. 238 * 239 * The returned devp device can be used with pmic_read/write calls 240 */ 241 int pmic_get(const char *name, struct udevice **devp); 242 243 /** 244 * pmic_reg_count: get the pmic register count 245 * 246 * The required pmic device can be obtained by 'pmic_get()' 247 * 248 * @dev - pointer to the UCLASS_PMIC device 249 * @return register count value on success or negative value of errno. 250 */ 251 int pmic_reg_count(struct udevice *dev); 252 253 /** 254 * pmic_read/write: read/write to the UCLASS_PMIC device 255 * 256 * The required pmic device can be obtained by 'pmic_get()' 257 * 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. 263 */ 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 */ 267 268 #ifdef CONFIG_POWER 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); 279 #endif 280 281 #define pmic_i2c_addr (p->hw.i2c.addr) 282 #define pmic_i2c_tx_num (p->hw.i2c.tx_num) 283 284 #define pmic_spi_bitlen (p->hw.spi.bitlen) 285 #define pmic_spi_flags (p->hw.spi.flags) 286 287 #endif /* __CORE_PMIC_H_ */ 288