Commit | Line | Data |
---|---|---|
919261c0 AS |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // | |
3 | // MCP16502 PMIC driver | |
4 | // | |
5 | // Copyright (C) 2018 Microchip Technology Inc. and its subsidiaries | |
6 | // | |
7 | // Author: Andrei Stefanescu <andrei.stefanescu@microchip.com> | |
8 | // | |
9 | // Inspired from tps65086-regulator.c | |
10 | ||
11 | #include <linux/gpio.h> | |
12 | #include <linux/i2c.h> | |
13 | #include <linux/init.h> | |
14 | #include <linux/kernel.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/of.h> | |
17 | #include <linux/regmap.h> | |
18 | #include <linux/regulator/driver.h> | |
19 | #include <linux/suspend.h> | |
f3c6a1a1 | 20 | #include <linux/gpio/consumer.h> |
919261c0 AS |
21 | |
22 | #define VDD_LOW_SEL 0x0D | |
23 | #define VDD_HIGH_SEL 0x3F | |
24 | ||
322eb866 CB |
25 | #define MCP16502_FLT BIT(7) |
26 | #define MCP16502_DVSR GENMASK(3, 2) | |
27 | #define MCP16502_ENS BIT(0) | |
919261c0 AS |
28 | |
29 | /* | |
30 | * The PMIC has four sets of registers corresponding to four power modes: | |
31 | * Performance, Active, Low-power, Hibernate. | |
32 | * | |
33 | * Registers: | |
34 | * Each regulator has a register for each power mode. To access a register | |
35 | * for a specific regulator and mode BASE_* and OFFSET_* need to be added. | |
36 | * | |
37 | * Operating modes: | |
38 | * In order for the PMIC to transition to operating modes it has to be | |
39 | * controlled via GPIO lines called LPM and HPM. | |
40 | * | |
41 | * The registers are fully configurable such that you can put all regulators in | |
42 | * a low-power state while the PMIC is in Active mode. They are supposed to be | |
43 | * configured at startup and then simply transition to/from a global low-power | |
44 | * state by setting the GPIO lpm pin high/low. | |
45 | * | |
46 | * This driver keeps the PMIC in Active mode, Low-power state is set for the | |
47 | * regulators by enabling/disabling operating mode (FPWM or Auto PFM). | |
48 | * | |
49 | * The PMIC's Low-power and Hibernate modes are used during standby/suspend. | |
50 | * To enter standby/suspend the PMIC will go to Low-power mode. From there, it | |
51 | * will transition to Hibernate when the PWRHLD line is set to low by the MPU. | |
52 | */ | |
53 | ||
54 | /* | |
55 | * This function is useful for iterating over all regulators and accessing their | |
56 | * registers in a generic way or accessing a regulator device by its id. | |
57 | */ | |
3e5532a0 | 58 | #define MCP16502_REG_BASE(i, r) ((((i) + 1) << 4) + MCP16502_REG_##r) |
919261c0 AS |
59 | #define MCP16502_STAT_BASE(i) ((i) + 5) |
60 | ||
919261c0 AS |
61 | #define MCP16502_OPMODE_ACTIVE REGULATOR_MODE_NORMAL |
62 | #define MCP16502_OPMODE_LPM REGULATOR_MODE_IDLE | |
63 | #define MCP16502_OPMODE_HIB REGULATOR_MODE_STANDBY | |
64 | ||
65 | #define MCP16502_MODE_AUTO_PFM 0 | |
66 | #define MCP16502_MODE_FPWM BIT(6) | |
67 | ||
68 | #define MCP16502_VSEL 0x3F | |
69 | #define MCP16502_EN BIT(7) | |
70 | #define MCP16502_MODE BIT(6) | |
71 | ||
72 | #define MCP16502_MIN_REG 0x0 | |
73 | #define MCP16502_MAX_REG 0x65 | |
74 | ||
3e5532a0 CB |
75 | /** |
76 | * enum mcp16502_reg - MCP16502 regulators's registers | |
77 | * @MCP16502_REG_A: active state register | |
78 | * @MCP16502_REG_LPM: low power mode state register | |
79 | * @MCP16502_REG_HIB: hibernate state register | |
84c13763 | 80 | * @MCP16502_REG_HPM: high-performance mode register |
3e5532a0 CB |
81 | * @MCP16502_REG_SEQ: startup sequence register |
82 | * @MCP16502_REG_CFG: configuration register | |
83 | */ | |
84 | enum mcp16502_reg { | |
85 | MCP16502_REG_A, | |
86 | MCP16502_REG_LPM, | |
87 | MCP16502_REG_HIB, | |
88 | MCP16502_REG_HPM, | |
89 | MCP16502_REG_SEQ, | |
90 | MCP16502_REG_CFG, | |
91 | }; | |
92 | ||
322eb866 | 93 | /* Ramp delay (uV/us) for buck1, ldo1, ldo2. */ |
96ec5afe AL |
94 | static const unsigned int mcp16502_ramp_b1l12[] = { |
95 | 6250, 3125, 2083, 1563 | |
96 | }; | |
322eb866 CB |
97 | |
98 | /* Ramp delay (uV/us) for buck2, buck3, buck4. */ | |
96ec5afe AL |
99 | static const unsigned int mcp16502_ramp_b234[] = { |
100 | 3125, 1563, 1042, 781 | |
101 | }; | |
322eb866 | 102 | |
919261c0 AS |
103 | static unsigned int mcp16502_of_map_mode(unsigned int mode) |
104 | { | |
105 | if (mode == REGULATOR_MODE_NORMAL || mode == REGULATOR_MODE_IDLE) | |
106 | return mode; | |
107 | ||
108 | return REGULATOR_MODE_INVALID; | |
109 | } | |
110 | ||
96ec5afe | 111 | #define MCP16502_REGULATOR(_name, _id, _ranges, _ops, _ramp_table) \ |
919261c0 AS |
112 | [_id] = { \ |
113 | .name = _name, \ | |
114 | .regulators_node = of_match_ptr("regulators"), \ | |
115 | .id = _id, \ | |
116 | .ops = &(_ops), \ | |
117 | .type = REGULATOR_VOLTAGE, \ | |
118 | .owner = THIS_MODULE, \ | |
f4c8f980 | 119 | .n_voltages = MCP16502_VSEL + 1, \ |
919261c0 | 120 | .linear_ranges = _ranges, \ |
478f8089 | 121 | .linear_min_sel = VDD_LOW_SEL, \ |
919261c0 AS |
122 | .n_linear_ranges = ARRAY_SIZE(_ranges), \ |
123 | .of_match = of_match_ptr(_name), \ | |
124 | .of_map_mode = mcp16502_of_map_mode, \ | |
125 | .vsel_reg = (((_id) + 1) << 4), \ | |
126 | .vsel_mask = MCP16502_VSEL, \ | |
127 | .enable_reg = (((_id) + 1) << 4), \ | |
128 | .enable_mask = MCP16502_EN, \ | |
96ec5afe AL |
129 | .ramp_reg = MCP16502_REG_BASE(_id, CFG), \ |
130 | .ramp_mask = MCP16502_DVSR, \ | |
131 | .ramp_delay_table = _ramp_table, \ | |
132 | .n_ramp_values = ARRAY_SIZE(_ramp_table), \ | |
919261c0 AS |
133 | } |
134 | ||
135 | enum { | |
136 | BUCK1 = 0, | |
137 | BUCK2, | |
138 | BUCK3, | |
139 | BUCK4, | |
140 | LDO1, | |
141 | LDO2, | |
142 | NUM_REGULATORS | |
143 | }; | |
144 | ||
145 | /* | |
146 | * struct mcp16502 - PMIC representation | |
919261c0 AS |
147 | * @lpm: LPM GPIO descriptor |
148 | */ | |
149 | struct mcp16502 { | |
919261c0 AS |
150 | struct gpio_desc *lpm; |
151 | }; | |
152 | ||
153 | /* | |
154 | * mcp16502_gpio_set_mode() - set the GPIO corresponding value | |
155 | * | |
156 | * Used to prepare transitioning into hibernate or resuming from it. | |
157 | */ | |
158 | static void mcp16502_gpio_set_mode(struct mcp16502 *mcp, int mode) | |
159 | { | |
160 | switch (mode) { | |
161 | case MCP16502_OPMODE_ACTIVE: | |
162 | gpiod_set_value(mcp->lpm, 0); | |
163 | break; | |
164 | case MCP16502_OPMODE_LPM: | |
165 | case MCP16502_OPMODE_HIB: | |
166 | gpiod_set_value(mcp->lpm, 1); | |
167 | break; | |
168 | default: | |
169 | pr_err("%s: %d invalid\n", __func__, mode); | |
170 | } | |
171 | } | |
172 | ||
173 | /* | |
3e5532a0 | 174 | * mcp16502_get_reg() - get the PMIC's state configuration register for opmode |
919261c0 AS |
175 | * |
176 | * @rdev: the regulator whose register we are searching | |
177 | * @opmode: the PMIC's operating mode ACTIVE, Low-power, Hibernate | |
178 | */ | |
3e5532a0 | 179 | static int mcp16502_get_state_reg(struct regulator_dev *rdev, int opmode) |
919261c0 | 180 | { |
919261c0 AS |
181 | switch (opmode) { |
182 | case MCP16502_OPMODE_ACTIVE: | |
3e5532a0 | 183 | return MCP16502_REG_BASE(rdev_get_id(rdev), A); |
919261c0 | 184 | case MCP16502_OPMODE_LPM: |
3e5532a0 | 185 | return MCP16502_REG_BASE(rdev_get_id(rdev), LPM); |
919261c0 | 186 | case MCP16502_OPMODE_HIB: |
3e5532a0 | 187 | return MCP16502_REG_BASE(rdev_get_id(rdev), HIB); |
919261c0 AS |
188 | default: |
189 | return -EINVAL; | |
190 | } | |
191 | } | |
192 | ||
193 | /* | |
194 | * mcp16502_get_mode() - return the current operating mode of a regulator | |
195 | * | |
196 | * Note: all functions that are not part of entering/exiting standby/suspend | |
197 | * use the Active mode registers. | |
198 | * | |
199 | * Note: this is different from the PMIC's operatig mode, it is the | |
200 | * MODE bit from the regulator's register. | |
201 | */ | |
202 | static unsigned int mcp16502_get_mode(struct regulator_dev *rdev) | |
203 | { | |
204 | unsigned int val; | |
205 | int ret, reg; | |
919261c0 | 206 | |
3e5532a0 | 207 | reg = mcp16502_get_state_reg(rdev, MCP16502_OPMODE_ACTIVE); |
919261c0 AS |
208 | if (reg < 0) |
209 | return reg; | |
210 | ||
4cf46953 | 211 | ret = regmap_read(rdev->regmap, reg, &val); |
919261c0 AS |
212 | if (ret) |
213 | return ret; | |
214 | ||
215 | switch (val & MCP16502_MODE) { | |
216 | case MCP16502_MODE_FPWM: | |
217 | return REGULATOR_MODE_NORMAL; | |
218 | case MCP16502_MODE_AUTO_PFM: | |
219 | return REGULATOR_MODE_IDLE; | |
220 | default: | |
221 | return REGULATOR_MODE_INVALID; | |
222 | } | |
223 | } | |
224 | ||
225 | /* | |
226 | * _mcp16502_set_mode() - helper for set_mode and set_suspend_mode | |
227 | * | |
228 | * @rdev: the regulator for which we are setting the mode | |
229 | * @mode: the regulator's mode (the one from MODE bit) | |
230 | * @opmode: the PMIC's operating mode: Active/Low-power/Hibernate | |
231 | */ | |
232 | static int _mcp16502_set_mode(struct regulator_dev *rdev, unsigned int mode, | |
233 | unsigned int op_mode) | |
234 | { | |
235 | int val; | |
236 | int reg; | |
919261c0 | 237 | |
3e5532a0 | 238 | reg = mcp16502_get_state_reg(rdev, op_mode); |
919261c0 AS |
239 | if (reg < 0) |
240 | return reg; | |
241 | ||
242 | switch (mode) { | |
243 | case REGULATOR_MODE_NORMAL: | |
244 | val = MCP16502_MODE_FPWM; | |
245 | break; | |
246 | case REGULATOR_MODE_IDLE: | |
247 | val = MCP16502_MODE_AUTO_PFM; | |
248 | break; | |
249 | default: | |
250 | return -EINVAL; | |
251 | } | |
252 | ||
4cf46953 | 253 | reg = regmap_update_bits(rdev->regmap, reg, MCP16502_MODE, val); |
919261c0 AS |
254 | return reg; |
255 | } | |
256 | ||
257 | /* | |
258 | * mcp16502_set_mode() - regulator_ops set_mode | |
259 | */ | |
260 | static int mcp16502_set_mode(struct regulator_dev *rdev, unsigned int mode) | |
261 | { | |
262 | return _mcp16502_set_mode(rdev, mode, MCP16502_OPMODE_ACTIVE); | |
263 | } | |
264 | ||
265 | /* | |
266 | * mcp16502_get_status() - regulator_ops get_status | |
267 | */ | |
268 | static int mcp16502_get_status(struct regulator_dev *rdev) | |
269 | { | |
270 | int ret; | |
271 | unsigned int val; | |
919261c0 | 272 | |
4cf46953 | 273 | ret = regmap_read(rdev->regmap, MCP16502_STAT_BASE(rdev_get_id(rdev)), |
919261c0 AS |
274 | &val); |
275 | if (ret) | |
276 | return ret; | |
277 | ||
278 | if (val & MCP16502_FLT) | |
279 | return REGULATOR_STATUS_ERROR; | |
280 | else if (val & MCP16502_ENS) | |
281 | return REGULATOR_STATUS_ON; | |
282 | else if (!(val & MCP16502_ENS)) | |
283 | return REGULATOR_STATUS_OFF; | |
284 | ||
285 | return REGULATOR_STATUS_UNDEFINED; | |
286 | } | |
287 | ||
322eb866 CB |
288 | static int mcp16502_set_voltage_time_sel(struct regulator_dev *rdev, |
289 | unsigned int old_sel, | |
290 | unsigned int new_sel) | |
291 | { | |
292 | static const u8 us_ramp[] = { 8, 16, 24, 32 }; | |
293 | int id = rdev_get_id(rdev); | |
294 | unsigned int uV_delta, val; | |
295 | int ret; | |
296 | ||
297 | ret = regmap_read(rdev->regmap, MCP16502_REG_BASE(id, CFG), &val); | |
298 | if (ret) | |
299 | return ret; | |
300 | ||
301 | val = (val & MCP16502_DVSR) >> 2; | |
302 | uV_delta = abs(new_sel * rdev->desc->linear_ranges->step - | |
303 | old_sel * rdev->desc->linear_ranges->step); | |
304 | switch (id) { | |
305 | case BUCK1: | |
306 | case LDO1: | |
307 | case LDO2: | |
308 | ret = DIV_ROUND_CLOSEST(uV_delta * us_ramp[val], | |
309 | mcp16502_ramp_b1l12[val]); | |
310 | break; | |
311 | ||
312 | case BUCK2: | |
313 | case BUCK3: | |
314 | case BUCK4: | |
315 | ret = DIV_ROUND_CLOSEST(uV_delta * us_ramp[val], | |
316 | mcp16502_ramp_b234[val]); | |
317 | break; | |
318 | ||
319 | default: | |
320 | return -EINVAL; | |
321 | } | |
322 | ||
323 | return ret; | |
324 | } | |
325 | ||
919261c0 AS |
326 | #ifdef CONFIG_SUSPEND |
327 | /* | |
328 | * mcp16502_suspend_get_target_reg() - get the reg of the target suspend PMIC | |
329 | * mode | |
330 | */ | |
331 | static int mcp16502_suspend_get_target_reg(struct regulator_dev *rdev) | |
332 | { | |
333 | switch (pm_suspend_target_state) { | |
334 | case PM_SUSPEND_STANDBY: | |
3e5532a0 | 335 | return mcp16502_get_state_reg(rdev, MCP16502_OPMODE_LPM); |
919261c0 AS |
336 | case PM_SUSPEND_ON: |
337 | case PM_SUSPEND_MEM: | |
3e5532a0 | 338 | return mcp16502_get_state_reg(rdev, MCP16502_OPMODE_HIB); |
919261c0 AS |
339 | default: |
340 | dev_err(&rdev->dev, "invalid suspend target: %d\n", | |
341 | pm_suspend_target_state); | |
342 | } | |
343 | ||
344 | return -EINVAL; | |
345 | } | |
346 | ||
347 | /* | |
348 | * mcp16502_set_suspend_voltage() - regulator_ops set_suspend_voltage | |
349 | */ | |
350 | static int mcp16502_set_suspend_voltage(struct regulator_dev *rdev, int uV) | |
351 | { | |
919261c0 AS |
352 | int sel = regulator_map_voltage_linear_range(rdev, uV, uV); |
353 | int reg = mcp16502_suspend_get_target_reg(rdev); | |
354 | ||
355 | if (sel < 0) | |
356 | return sel; | |
357 | ||
358 | if (reg < 0) | |
359 | return reg; | |
360 | ||
4cf46953 | 361 | return regmap_update_bits(rdev->regmap, reg, MCP16502_VSEL, sel); |
919261c0 AS |
362 | } |
363 | ||
364 | /* | |
365 | * mcp16502_set_suspend_mode() - regulator_ops set_suspend_mode | |
366 | */ | |
367 | static int mcp16502_set_suspend_mode(struct regulator_dev *rdev, | |
368 | unsigned int mode) | |
369 | { | |
370 | switch (pm_suspend_target_state) { | |
371 | case PM_SUSPEND_STANDBY: | |
372 | return _mcp16502_set_mode(rdev, mode, MCP16502_OPMODE_LPM); | |
373 | case PM_SUSPEND_ON: | |
374 | case PM_SUSPEND_MEM: | |
375 | return _mcp16502_set_mode(rdev, mode, MCP16502_OPMODE_HIB); | |
376 | default: | |
377 | dev_err(&rdev->dev, "invalid suspend target: %d\n", | |
378 | pm_suspend_target_state); | |
379 | } | |
380 | ||
381 | return -EINVAL; | |
382 | } | |
383 | ||
384 | /* | |
385 | * mcp16502_set_suspend_enable() - regulator_ops set_suspend_enable | |
386 | */ | |
387 | static int mcp16502_set_suspend_enable(struct regulator_dev *rdev) | |
388 | { | |
919261c0 AS |
389 | int reg = mcp16502_suspend_get_target_reg(rdev); |
390 | ||
391 | if (reg < 0) | |
392 | return reg; | |
393 | ||
4cf46953 | 394 | return regmap_update_bits(rdev->regmap, reg, MCP16502_EN, MCP16502_EN); |
919261c0 AS |
395 | } |
396 | ||
397 | /* | |
398 | * mcp16502_set_suspend_disable() - regulator_ops set_suspend_disable | |
399 | */ | |
400 | static int mcp16502_set_suspend_disable(struct regulator_dev *rdev) | |
401 | { | |
919261c0 AS |
402 | int reg = mcp16502_suspend_get_target_reg(rdev); |
403 | ||
404 | if (reg < 0) | |
405 | return reg; | |
406 | ||
4cf46953 | 407 | return regmap_update_bits(rdev->regmap, reg, MCP16502_EN, 0); |
919261c0 AS |
408 | } |
409 | #endif /* CONFIG_SUSPEND */ | |
410 | ||
411 | static const struct regulator_ops mcp16502_buck_ops = { | |
412 | .list_voltage = regulator_list_voltage_linear_range, | |
413 | .map_voltage = regulator_map_voltage_linear_range, | |
414 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
415 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
416 | .enable = regulator_enable_regmap, | |
417 | .disable = regulator_disable_regmap, | |
418 | .is_enabled = regulator_is_enabled_regmap, | |
419 | .get_status = mcp16502_get_status, | |
322eb866 | 420 | .set_voltage_time_sel = mcp16502_set_voltage_time_sel, |
96ec5afe | 421 | .set_ramp_delay = regulator_set_ramp_delay_regmap, |
919261c0 AS |
422 | |
423 | .set_mode = mcp16502_set_mode, | |
424 | .get_mode = mcp16502_get_mode, | |
425 | ||
426 | #ifdef CONFIG_SUSPEND | |
427 | .set_suspend_voltage = mcp16502_set_suspend_voltage, | |
428 | .set_suspend_mode = mcp16502_set_suspend_mode, | |
429 | .set_suspend_enable = mcp16502_set_suspend_enable, | |
430 | .set_suspend_disable = mcp16502_set_suspend_disable, | |
431 | #endif /* CONFIG_SUSPEND */ | |
432 | }; | |
433 | ||
434 | /* | |
435 | * LDOs cannot change operating modes. | |
436 | */ | |
437 | static const struct regulator_ops mcp16502_ldo_ops = { | |
438 | .list_voltage = regulator_list_voltage_linear_range, | |
439 | .map_voltage = regulator_map_voltage_linear_range, | |
440 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
441 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
442 | .enable = regulator_enable_regmap, | |
443 | .disable = regulator_disable_regmap, | |
444 | .is_enabled = regulator_is_enabled_regmap, | |
445 | .get_status = mcp16502_get_status, | |
322eb866 | 446 | .set_voltage_time_sel = mcp16502_set_voltage_time_sel, |
96ec5afe | 447 | .set_ramp_delay = regulator_set_ramp_delay_regmap, |
919261c0 AS |
448 | |
449 | #ifdef CONFIG_SUSPEND | |
450 | .set_suspend_voltage = mcp16502_set_suspend_voltage, | |
451 | .set_suspend_enable = mcp16502_set_suspend_enable, | |
452 | .set_suspend_disable = mcp16502_set_suspend_disable, | |
453 | #endif /* CONFIG_SUSPEND */ | |
454 | }; | |
455 | ||
456 | static const struct of_device_id mcp16502_ids[] = { | |
457 | { .compatible = "microchip,mcp16502", }, | |
458 | {} | |
459 | }; | |
460 | MODULE_DEVICE_TABLE(of, mcp16502_ids); | |
461 | ||
60ab7f41 | 462 | static const struct linear_range b1l12_ranges[] = { |
919261c0 AS |
463 | REGULATOR_LINEAR_RANGE(1200000, VDD_LOW_SEL, VDD_HIGH_SEL, 50000), |
464 | }; | |
465 | ||
60ab7f41 | 466 | static const struct linear_range b234_ranges[] = { |
919261c0 AS |
467 | REGULATOR_LINEAR_RANGE(600000, VDD_LOW_SEL, VDD_HIGH_SEL, 25000), |
468 | }; | |
469 | ||
470 | static const struct regulator_desc mcp16502_desc[] = { | |
96ec5afe AL |
471 | /* MCP16502_REGULATOR(_name, _id, ranges, regulator_ops, ramp_table) */ |
472 | MCP16502_REGULATOR("VDD_IO", BUCK1, b1l12_ranges, mcp16502_buck_ops, | |
473 | mcp16502_ramp_b1l12), | |
474 | MCP16502_REGULATOR("VDD_DDR", BUCK2, b234_ranges, mcp16502_buck_ops, | |
475 | mcp16502_ramp_b234), | |
476 | MCP16502_REGULATOR("VDD_CORE", BUCK3, b234_ranges, mcp16502_buck_ops, | |
477 | mcp16502_ramp_b234), | |
478 | MCP16502_REGULATOR("VDD_OTHER", BUCK4, b234_ranges, mcp16502_buck_ops, | |
479 | mcp16502_ramp_b234), | |
480 | MCP16502_REGULATOR("LDO1", LDO1, b1l12_ranges, mcp16502_ldo_ops, | |
481 | mcp16502_ramp_b1l12), | |
482 | MCP16502_REGULATOR("LDO2", LDO2, b1l12_ranges, mcp16502_ldo_ops, | |
483 | mcp16502_ramp_b1l12) | |
919261c0 AS |
484 | }; |
485 | ||
486 | static const struct regmap_range mcp16502_ranges[] = { | |
487 | regmap_reg_range(MCP16502_MIN_REG, MCP16502_MAX_REG) | |
488 | }; | |
489 | ||
490 | static const struct regmap_access_table mcp16502_yes_reg_table = { | |
491 | .yes_ranges = mcp16502_ranges, | |
492 | .n_yes_ranges = ARRAY_SIZE(mcp16502_ranges), | |
493 | }; | |
494 | ||
495 | static const struct regmap_config mcp16502_regmap_config = { | |
496 | .reg_bits = 8, | |
497 | .val_bits = 8, | |
498 | .max_register = MCP16502_MAX_REG, | |
499 | .cache_type = REGCACHE_NONE, | |
500 | .rd_table = &mcp16502_yes_reg_table, | |
501 | .wr_table = &mcp16502_yes_reg_table, | |
502 | }; | |
503 | ||
1d15b3e6 | 504 | static int mcp16502_probe(struct i2c_client *client) |
919261c0 AS |
505 | { |
506 | struct regulator_config config = { }; | |
784c24c3 | 507 | struct regulator_dev *rdev; |
919261c0 AS |
508 | struct device *dev; |
509 | struct mcp16502 *mcp; | |
4cf46953 | 510 | struct regmap *rmap; |
784c24c3 | 511 | int i, ret; |
919261c0 AS |
512 | |
513 | dev = &client->dev; | |
514 | config.dev = dev; | |
515 | ||
516 | mcp = devm_kzalloc(dev, sizeof(*mcp), GFP_KERNEL); | |
517 | if (!mcp) | |
518 | return -ENOMEM; | |
519 | ||
4cf46953 AL |
520 | rmap = devm_regmap_init_i2c(client, &mcp16502_regmap_config); |
521 | if (IS_ERR(rmap)) { | |
522 | ret = PTR_ERR(rmap); | |
919261c0 AS |
523 | dev_err(dev, "regmap init failed: %d\n", ret); |
524 | return ret; | |
525 | } | |
526 | ||
527 | i2c_set_clientdata(client, mcp); | |
4cf46953 | 528 | config.regmap = rmap; |
919261c0 AS |
529 | config.driver_data = mcp; |
530 | ||
3c42728c | 531 | mcp->lpm = devm_gpiod_get_optional(dev, "lpm", GPIOD_OUT_LOW); |
919261c0 AS |
532 | if (IS_ERR(mcp->lpm)) { |
533 | dev_err(dev, "failed to get lpm pin: %ld\n", PTR_ERR(mcp->lpm)); | |
534 | return PTR_ERR(mcp->lpm); | |
535 | } | |
536 | ||
784c24c3 AL |
537 | for (i = 0; i < NUM_REGULATORS; i++) { |
538 | rdev = devm_regulator_register(dev, &mcp16502_desc[i], &config); | |
539 | if (IS_ERR(rdev)) { | |
540 | dev_err(dev, | |
541 | "failed to register %s regulator %ld\n", | |
542 | mcp16502_desc[i].name, PTR_ERR(rdev)); | |
543 | return PTR_ERR(rdev); | |
544 | } | |
545 | } | |
919261c0 AS |
546 | |
547 | mcp16502_gpio_set_mode(mcp, MCP16502_OPMODE_ACTIVE); | |
548 | ||
549 | return 0; | |
550 | } | |
551 | ||
4906d091 | 552 | #ifdef CONFIG_PM_SLEEP |
fc401cb9 AS |
553 | static int mcp16502_suspend_noirq(struct device *dev) |
554 | { | |
555 | struct i2c_client *client = to_i2c_client(dev); | |
556 | struct mcp16502 *mcp = i2c_get_clientdata(client); | |
557 | ||
558 | mcp16502_gpio_set_mode(mcp, MCP16502_OPMODE_LPM); | |
559 | ||
560 | return 0; | |
561 | } | |
562 | ||
563 | static int mcp16502_resume_noirq(struct device *dev) | |
564 | { | |
565 | struct i2c_client *client = to_i2c_client(dev); | |
566 | struct mcp16502 *mcp = i2c_get_clientdata(client); | |
567 | ||
568 | mcp16502_gpio_set_mode(mcp, MCP16502_OPMODE_ACTIVE); | |
569 | ||
570 | return 0; | |
571 | } | |
4906d091 | 572 | #endif |
fc401cb9 AS |
573 | |
574 | #ifdef CONFIG_PM | |
575 | static const struct dev_pm_ops mcp16502_pm_ops = { | |
576 | SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(mcp16502_suspend_noirq, | |
308144ce | 577 | mcp16502_resume_noirq) |
fc401cb9 AS |
578 | }; |
579 | #endif | |
919261c0 AS |
580 | static const struct i2c_device_id mcp16502_i2c_id[] = { |
581 | { "mcp16502", 0 }, | |
582 | { } | |
583 | }; | |
584 | MODULE_DEVICE_TABLE(i2c, mcp16502_i2c_id); | |
585 | ||
586 | static struct i2c_driver mcp16502_drv = { | |
964e1865 | 587 | .probe = mcp16502_probe, |
919261c0 AS |
588 | .driver = { |
589 | .name = "mcp16502-regulator", | |
d3b81d97 | 590 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
919261c0 | 591 | .of_match_table = of_match_ptr(mcp16502_ids), |
fc401cb9 AS |
592 | #ifdef CONFIG_PM |
593 | .pm = &mcp16502_pm_ops, | |
594 | #endif | |
919261c0 AS |
595 | }, |
596 | .id_table = mcp16502_i2c_id, | |
597 | }; | |
598 | ||
599 | module_i2c_driver(mcp16502_drv); | |
600 | ||
919261c0 AS |
601 | MODULE_LICENSE("GPL v2"); |
602 | MODULE_DESCRIPTION("MCP16502 PMIC driver"); | |
603 | MODULE_AUTHOR("Andrei Stefanescu andrei.stefanescu@microchip.com"); |