1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * MFD core driver for Rockchip RK808/RK818
4 *
5 * Copyright (c) 2014-2018, Fuzhou Rockchip Electronics Co., Ltd
6 *
7 * Author: Chris Zhong <zyw@rock-chips.com>
8 * Author: Zhang Qing <zhangqing@rock-chips.com>
9 *
10 * Copyright (C) 2016 PHYTEC Messtechnik GmbH
11 *
12 * Author: Wadim Egorov <w.egorov@phytec.de>
13 */
14
15 #include <linux/i2c.h>
16 #include <linux/interrupt.h>
17 #include <linux/mfd/rk808.h>
18 #include <linux/mfd/core.h>
19 #include <linux/module.h>
20 #include <linux/of_device.h>
21 #include <linux/reboot.h>
22 #include <linux/regmap.h>
23 #include <linux/syscore_ops.h>
24 #include <linux/pinctrl/consumer.h>
25 #include <linux/pinctrl/devinfo.h>
26
27 struct rk808_reg_data {
28 int addr;
29 int mask;
30 int value;
31 };
32
rk808_is_volatile_reg(struct device * dev,unsigned int reg)33 static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg)
34 {
35 /*
36 * Notes:
37 * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
38 * we don't use that feature. It's better to cache.
39 * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
40 * bits are cleared in case when we shutoff anyway, but better safe.
41 */
42
43 switch (reg) {
44 case RK808_SECONDS_REG ... RK808_WEEKS_REG:
45 case RK808_RTC_STATUS_REG:
46 case RK808_VB_MON_REG:
47 case RK808_THERMAL_REG:
48 case RK808_DCDC_UV_STS_REG:
49 case RK808_LDO_UV_STS_REG:
50 case RK808_DCDC_PG_REG:
51 case RK808_LDO_PG_REG:
52 case RK808_DEVCTRL_REG:
53 case RK808_INT_STS_REG1:
54 case RK808_INT_STS_REG2:
55 return true;
56 }
57
58 return false;
59 }
60
rk817_is_volatile_reg(struct device * dev,unsigned int reg)61 static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg)
62 {
63 /*
64 * Notes:
65 * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
66 * we don't use that feature. It's better to cache.
67 */
68
69 switch (reg) {
70 case RK817_SECONDS_REG ... RK817_WEEKS_REG:
71 case RK817_RTC_STATUS_REG:
72 case RK817_ADC_CONFIG0 ... RK817_CURE_ADC_K0:
73 case RK817_CHRG_STS:
74 case RK817_CHRG_OUT:
75 case RK817_CHRG_IN:
76 case RK817_SYS_STS:
77 case RK817_INT_STS_REG0:
78 case RK817_INT_STS_REG1:
79 case RK817_INT_STS_REG2:
80 return true;
81 }
82
83 return false;
84 }
85
rk818_is_volatile_reg(struct device * dev,unsigned int reg)86 static bool rk818_is_volatile_reg(struct device *dev, unsigned int reg)
87 {
88 /*
89 * Notes:
90 * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
91 * we don't use that feature. It's better to cache.
92 * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
93 * bits are cleared in case when we shutoff anyway, but better safe.
94 */
95
96 switch (reg) {
97 case RK808_SECONDS_REG ... RK808_WEEKS_REG:
98 case RK808_RTC_STATUS_REG:
99 case RK808_VB_MON_REG:
100 case RK808_THERMAL_REG:
101 case RK808_DCDC_EN_REG:
102 case RK808_LDO_EN_REG:
103 case RK808_DCDC_UV_STS_REG:
104 case RK808_LDO_UV_STS_REG:
105 case RK808_DCDC_PG_REG:
106 case RK808_LDO_PG_REG:
107 case RK808_DEVCTRL_REG:
108 case RK808_INT_STS_REG1:
109 case RK808_INT_STS_REG2:
110 case RK808_INT_STS_MSK_REG1:
111 case RK808_INT_STS_MSK_REG2:
112 case RK816_INT_STS_REG1:
113 case RK816_INT_STS_MSK_REG1:
114 case RK818_SUP_STS_REG ... RK818_SAVE_DATA19:
115 return true;
116 }
117
118 return false;
119 }
120
121 static const struct regmap_config rk818_regmap_config = {
122 .reg_bits = 8,
123 .val_bits = 8,
124 .max_register = RK818_SAVE_DATA19,
125 .cache_type = REGCACHE_RBTREE,
126 .volatile_reg = rk818_is_volatile_reg,
127 };
128
129 static const struct regmap_config rk805_regmap_config = {
130 .reg_bits = 8,
131 .val_bits = 8,
132 .max_register = RK805_OFF_SOURCE_REG,
133 .cache_type = REGCACHE_RBTREE,
134 .volatile_reg = rk808_is_volatile_reg,
135 };
136
137 static const struct regmap_config rk808_regmap_config = {
138 .reg_bits = 8,
139 .val_bits = 8,
140 .max_register = RK808_IO_POL_REG,
141 .cache_type = REGCACHE_RBTREE,
142 .volatile_reg = rk808_is_volatile_reg,
143 };
144
145 static const struct regmap_config rk816_regmap_config = {
146 .reg_bits = 8,
147 .val_bits = 8,
148 .max_register = RK816_DATA18_REG,
149 .cache_type = REGCACHE_RBTREE,
150 .volatile_reg = rk818_is_volatile_reg,
151 };
152
153 static const struct regmap_config rk817_regmap_config = {
154 .reg_bits = 8,
155 .val_bits = 8,
156 .max_register = RK817_GPIO_INT_CFG,
157 .num_reg_defaults_raw = RK817_GPIO_INT_CFG + 1,
158 .cache_type = REGCACHE_RBTREE,
159 .volatile_reg = rk817_is_volatile_reg,
160 };
161
162 static const struct resource rtc_resources[] = {
163 DEFINE_RES_IRQ(RK808_IRQ_RTC_ALARM),
164 };
165
166 static const struct resource rk816_rtc_resources[] = {
167 DEFINE_RES_IRQ(RK816_IRQ_RTC_ALARM),
168 };
169
170 static const struct resource rk817_rtc_resources[] = {
171 DEFINE_RES_IRQ(RK817_IRQ_RTC_ALARM),
172 };
173
174 static const struct resource rk805_key_resources[] = {
175 DEFINE_RES_IRQ(RK805_IRQ_PWRON_FALL),
176 DEFINE_RES_IRQ(RK805_IRQ_PWRON_RISE),
177 };
178
179 static const struct resource rk816_pwrkey_resources[] = {
180 DEFINE_RES_IRQ(RK816_IRQ_PWRON_FALL),
181 DEFINE_RES_IRQ(RK816_IRQ_PWRON_RISE),
182 };
183
184 static const struct resource rk817_pwrkey_resources[] = {
185 DEFINE_RES_IRQ(RK817_IRQ_PWRON_FALL),
186 DEFINE_RES_IRQ(RK817_IRQ_PWRON_RISE),
187 };
188
189 static const struct mfd_cell rk805s[] = {
190 { .name = "rk808-clkout", },
191 { .name = "rk808-regulator", },
192 { .name = "rk805-pinctrl", },
193 {
194 .name = "rk808-rtc",
195 .num_resources = ARRAY_SIZE(rtc_resources),
196 .resources = &rtc_resources[0],
197 },
198 { .name = "rk805-pwrkey",
199 .num_resources = ARRAY_SIZE(rk805_key_resources),
200 .resources = &rk805_key_resources[0],
201 },
202 };
203
204 static const struct mfd_cell rk808s[] = {
205 { .name = "rk808-clkout", },
206 { .name = "rk808-regulator", },
207 {
208 .name = "rk808-rtc",
209 .num_resources = ARRAY_SIZE(rtc_resources),
210 .resources = rtc_resources,
211 },
212 };
213
214 static const struct mfd_cell rk816s[] = {
215 { .name = "rk808-clkout", },
216 { .name = "rk808-regulator", },
217 { .name = "rk805-pinctrl", },
218 { .name = "rk816-battery", .of_compatible = "rk816-battery", },
219 {
220 .name = "rk805-pwrkey",
221 .num_resources = ARRAY_SIZE(rk816_pwrkey_resources),
222 .resources = &rk816_pwrkey_resources[0],
223 },
224 {
225 .name = "rk808-rtc",
226 .num_resources = ARRAY_SIZE(rk816_rtc_resources),
227 .resources = &rk816_rtc_resources[0],
228 },
229 };
230
231 static const struct mfd_cell rk817s[] = {
232 { .name = "rk808-clkout",},
233 { .name = "rk808-regulator",},
234 { .name = "rk817-battery", .of_compatible = "rk817,battery", },
235 { .name = "rk817-charger", .of_compatible = "rk817,charger", },
236 {
237 .name = "rk805-pwrkey",
238 .num_resources = ARRAY_SIZE(rk817_pwrkey_resources),
239 .resources = &rk817_pwrkey_resources[0],
240 },
241 {
242 .name = "rk808-rtc",
243 .num_resources = ARRAY_SIZE(rk817_rtc_resources),
244 .resources = &rk817_rtc_resources[0],
245 },
246 {
247 .name = "rk817-codec",
248 .of_compatible = "rockchip,rk817-codec",
249 },
250 };
251
252 static const struct mfd_cell rk818s[] = {
253 { .name = "rk808-clkout", },
254 { .name = "rk808-regulator", },
255 { .name = "rk818-battery", .of_compatible = "rk818-battery", },
256 { .name = "rk818-charger", },
257 {
258 .name = "rk808-rtc",
259 .num_resources = ARRAY_SIZE(rtc_resources),
260 .resources = rtc_resources,
261 },
262 };
263
264 static const struct rk808_reg_data rk805_pre_init_reg[] = {
265 {RK805_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_400MA},
266 {RK805_GPIO_IO_POL_REG, SLP_SD_MSK, SLEEP_FUN},
267 {RK805_THERMAL_REG, TEMP_HOTDIE_MSK, TEMP115C},
268 {RK808_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
269 };
270
271 static struct rk808_reg_data rk805_suspend_reg[] = {
272 {RK805_BUCK3_CONFIG_REG, PWM_MODE_MSK, AUTO_PWM_MODE},
273 };
274
275 static struct rk808_reg_data rk805_resume_reg[] = {
276 {RK805_BUCK3_CONFIG_REG, PWM_MODE_MSK, FPWM_MODE},
277 };
278
279 static const struct rk808_reg_data rk808_pre_init_reg[] = {
280 { RK808_BUCK3_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_150MA },
281 { RK808_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_200MA },
282 { RK808_BOOST_CONFIG_REG, BOOST_ILMIN_MASK, BOOST_ILMIN_100MA },
283 { RK808_BUCK1_CONFIG_REG, BUCK1_RATE_MASK, BUCK_ILMIN_200MA },
284 { RK808_BUCK2_CONFIG_REG, BUCK2_RATE_MASK, BUCK_ILMIN_200MA },
285 { RK808_DCDC_UV_ACT_REG, BUCK_UV_ACT_MASK, BUCK_UV_ACT_DISABLE},
286 { RK808_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
287 { RK808_VB_MON_REG, MASK_ALL, VB_LO_ACT |
288 VB_LO_SEL_3500MV },
289 };
290
291 static const struct rk808_reg_data rk816_pre_init_reg[] = {
292 /* buck4 Max ILMIT*/
293 { RK816_BUCK4_CONFIG_REG, REG_WRITE_MSK, BUCK4_MAX_ILIMIT },
294 /* hotdie temperature: 105c*/
295 { RK816_THERMAL_REG, REG_WRITE_MSK, TEMP105C },
296 /* set buck 12.5mv/us */
297 { RK816_BUCK1_CONFIG_REG, BUCK_RATE_MSK, BUCK_RATE_12_5MV_US },
298 { RK816_BUCK2_CONFIG_REG, BUCK_RATE_MSK, BUCK_RATE_12_5MV_US },
299 /* enable RTC_PERIOD & RTC_ALARM int */
300 { RK816_INT_STS_MSK_REG2, REG_WRITE_MSK, RTC_PERIOD_ALARM_INT_EN },
301 /* set bat 3.0 low and act shutdown */
302 { RK816_VB_MON_REG, VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK,
303 RK816_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN },
304 /* enable PWRON rising/faling int */
305 { RK816_INT_STS_MSK_REG1, REG_WRITE_MSK, RK816_PWRON_FALL_RISE_INT_EN },
306 /* enable PLUG IN/OUT int */
307 { RK816_INT_STS_MSK_REG3, REG_WRITE_MSK, PLUGIN_OUT_INT_EN },
308 /* clear int flags */
309 { RK816_INT_STS_REG1, REG_WRITE_MSK, ALL_INT_FLAGS_ST },
310 { RK816_INT_STS_REG2, REG_WRITE_MSK, ALL_INT_FLAGS_ST },
311 { RK816_INT_STS_REG3, REG_WRITE_MSK, ALL_INT_FLAGS_ST },
312 { RK816_DCDC_EN_REG2, BOOST_EN_MASK, BOOST_DISABLE },
313 /* set write mask bit 1, otherwise 'is_enabled()' get wrong status */
314 { RK816_LDO_EN_REG1, REGS_WMSK, REGS_WMSK },
315 { RK816_LDO_EN_REG2, REGS_WMSK, REGS_WMSK },
316 };
317
318 static const struct rk808_reg_data rk817_pre_init_reg[] = {
319 {RK817_SYS_CFG(3), RK817_SLPPOL_MSK, RK817_SLPPOL_L},
320 {RK817_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
321 {RK817_GPIO_INT_CFG, RK817_INT_POL_MSK, RK817_INT_POL_L},
322 {RK817_SYS_CFG(1), RK817_HOTDIE_TEMP_MSK | RK817_TSD_TEMP_MSK,
323 RK817_HOTDIE_105 | RK817_TSD_140},
324 };
325
326 static const struct rk808_reg_data rk818_pre_init_reg[] = {
327 /* improve efficiency */
328 { RK818_BUCK2_CONFIG_REG, BUCK2_RATE_MASK, BUCK_ILMIN_250MA },
329 { RK818_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_250MA },
330 { RK818_BOOST_CONFIG_REG, BOOST_ILMIN_MASK, BOOST_ILMIN_100MA },
331 { RK818_USB_CTRL_REG, RK818_USB_ILIM_SEL_MASK,
332 RK818_USB_ILMIN_2000MA },
333 /* close charger when usb lower then 3.4V */
334 { RK818_USB_CTRL_REG, RK818_USB_CHG_SD_VSEL_MASK,
335 (0x7 << 4) },
336 /* no action when vref */
337 { RK818_H5V_EN_REG, BIT(1), RK818_REF_RDY_CTRL },
338 /* enable HDMI 5V */
339 { RK818_H5V_EN_REG, BIT(0), RK818_H5V_EN },
340 { RK808_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
341 { RK808_VB_MON_REG, MASK_ALL, VB_LO_ACT |
342 VB_LO_SEL_3500MV },
343 {RK808_CLK32OUT_REG, CLK32KOUT2_FUNC_MASK, CLK32KOUT2_FUNC},
344 };
345
346 static const struct regmap_irq rk805_irqs[] = {
347 [RK805_IRQ_PWRON_RISE] = {
348 .mask = RK805_IRQ_PWRON_RISE_MSK,
349 .reg_offset = 0,
350 },
351 [RK805_IRQ_VB_LOW] = {
352 .mask = RK805_IRQ_VB_LOW_MSK,
353 .reg_offset = 0,
354 },
355 [RK805_IRQ_PWRON] = {
356 .mask = RK805_IRQ_PWRON_MSK,
357 .reg_offset = 0,
358 },
359 [RK805_IRQ_PWRON_LP] = {
360 .mask = RK805_IRQ_PWRON_LP_MSK,
361 .reg_offset = 0,
362 },
363 [RK805_IRQ_HOTDIE] = {
364 .mask = RK805_IRQ_HOTDIE_MSK,
365 .reg_offset = 0,
366 },
367 [RK805_IRQ_RTC_ALARM] = {
368 .mask = RK805_IRQ_RTC_ALARM_MSK,
369 .reg_offset = 0,
370 },
371 [RK805_IRQ_RTC_PERIOD] = {
372 .mask = RK805_IRQ_RTC_PERIOD_MSK,
373 .reg_offset = 0,
374 },
375 [RK805_IRQ_PWRON_FALL] = {
376 .mask = RK805_IRQ_PWRON_FALL_MSK,
377 .reg_offset = 0,
378 },
379 };
380
381 static const struct regmap_irq rk808_irqs[] = {
382 /* INT_STS */
383 [RK808_IRQ_VOUT_LO] = {
384 .mask = RK808_IRQ_VOUT_LO_MSK,
385 .reg_offset = 0,
386 },
387 [RK808_IRQ_VB_LO] = {
388 .mask = RK808_IRQ_VB_LO_MSK,
389 .reg_offset = 0,
390 },
391 [RK808_IRQ_PWRON] = {
392 .mask = RK808_IRQ_PWRON_MSK,
393 .reg_offset = 0,
394 },
395 [RK808_IRQ_PWRON_LP] = {
396 .mask = RK808_IRQ_PWRON_LP_MSK,
397 .reg_offset = 0,
398 },
399 [RK808_IRQ_HOTDIE] = {
400 .mask = RK808_IRQ_HOTDIE_MSK,
401 .reg_offset = 0,
402 },
403 [RK808_IRQ_RTC_ALARM] = {
404 .mask = RK808_IRQ_RTC_ALARM_MSK,
405 .reg_offset = 0,
406 },
407 [RK808_IRQ_RTC_PERIOD] = {
408 .mask = RK808_IRQ_RTC_PERIOD_MSK,
409 .reg_offset = 0,
410 },
411
412 /* INT_STS2 */
413 [RK808_IRQ_PLUG_IN_INT] = {
414 .mask = RK808_IRQ_PLUG_IN_INT_MSK,
415 .reg_offset = 1,
416 },
417 [RK808_IRQ_PLUG_OUT_INT] = {
418 .mask = RK808_IRQ_PLUG_OUT_INT_MSK,
419 .reg_offset = 1,
420 },
421 };
422
423 static struct rk808_reg_data rk816_suspend_reg[] = {
424 /* set bat 3.4v low and act irq */
425 { RK816_VB_MON_REG, VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK,
426 RK816_VBAT_LOW_3V4 | EN_VBAT_LOW_IRQ },
427 };
428
429 static struct rk808_reg_data rk816_resume_reg[] = {
430 /* set bat 3.0v low and act shutdown */
431 { RK816_VB_MON_REG, VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK,
432 RK816_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN },
433 };
434
435 static const struct regmap_irq rk816_irqs[] = {
436 /* INT_STS */
437 [RK816_IRQ_PWRON_FALL] = {
438 .mask = RK816_IRQ_PWRON_FALL_MSK,
439 .reg_offset = 0,
440 },
441 [RK816_IRQ_PWRON_RISE] = {
442 .mask = RK816_IRQ_PWRON_RISE_MSK,
443 .reg_offset = 0,
444 },
445 [RK816_IRQ_VB_LOW] = {
446 .mask = RK816_IRQ_VB_LOW_MSK,
447 .reg_offset = 1,
448 },
449 [RK816_IRQ_PWRON] = {
450 .mask = RK816_IRQ_PWRON_MSK,
451 .reg_offset = 1,
452 },
453 [RK816_IRQ_PWRON_LP] = {
454 .mask = RK816_IRQ_PWRON_LP_MSK,
455 .reg_offset = 1,
456 },
457 [RK816_IRQ_HOTDIE] = {
458 .mask = RK816_IRQ_HOTDIE_MSK,
459 .reg_offset = 1,
460 },
461 [RK816_IRQ_RTC_ALARM] = {
462 .mask = RK816_IRQ_RTC_ALARM_MSK,
463 .reg_offset = 1,
464 },
465 [RK816_IRQ_RTC_PERIOD] = {
466 .mask = RK816_IRQ_RTC_PERIOD_MSK,
467 .reg_offset = 1,
468 },
469 [RK816_IRQ_USB_OV] = {
470 .mask = RK816_IRQ_USB_OV_MSK,
471 .reg_offset = 1,
472 },
473 };
474
475 static struct rk808_reg_data rk818_suspend_reg[] = {
476 /* set bat 3.4v low and act irq */
477 { RK808_VB_MON_REG, VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK,
478 RK808_VBAT_LOW_3V4 | EN_VBAT_LOW_IRQ },
479 };
480
481 static struct rk808_reg_data rk818_resume_reg[] = {
482 /* set bat 3.0v low and act shutdown */
483 { RK808_VB_MON_REG, VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK,
484 RK808_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN },
485 };
486
487 static const struct regmap_irq rk818_irqs[] = {
488 /* INT_STS */
489 [RK818_IRQ_VOUT_LO] = {
490 .mask = RK818_IRQ_VOUT_LO_MSK,
491 .reg_offset = 0,
492 },
493 [RK818_IRQ_VB_LO] = {
494 .mask = RK818_IRQ_VB_LO_MSK,
495 .reg_offset = 0,
496 },
497 [RK818_IRQ_PWRON] = {
498 .mask = RK818_IRQ_PWRON_MSK,
499 .reg_offset = 0,
500 },
501 [RK818_IRQ_PWRON_LP] = {
502 .mask = RK818_IRQ_PWRON_LP_MSK,
503 .reg_offset = 0,
504 },
505 [RK818_IRQ_HOTDIE] = {
506 .mask = RK818_IRQ_HOTDIE_MSK,
507 .reg_offset = 0,
508 },
509 [RK818_IRQ_RTC_ALARM] = {
510 .mask = RK818_IRQ_RTC_ALARM_MSK,
511 .reg_offset = 0,
512 },
513 [RK818_IRQ_RTC_PERIOD] = {
514 .mask = RK818_IRQ_RTC_PERIOD_MSK,
515 .reg_offset = 0,
516 },
517 [RK818_IRQ_USB_OV] = {
518 .mask = RK818_IRQ_USB_OV_MSK,
519 .reg_offset = 0,
520 },
521
522 /* INT_STS2 */
523 [RK818_IRQ_PLUG_IN] = {
524 .mask = RK818_IRQ_PLUG_IN_MSK,
525 .reg_offset = 1,
526 },
527 [RK818_IRQ_PLUG_OUT] = {
528 .mask = RK818_IRQ_PLUG_OUT_MSK,
529 .reg_offset = 1,
530 },
531 [RK818_IRQ_CHG_OK] = {
532 .mask = RK818_IRQ_CHG_OK_MSK,
533 .reg_offset = 1,
534 },
535 [RK818_IRQ_CHG_TE] = {
536 .mask = RK818_IRQ_CHG_TE_MSK,
537 .reg_offset = 1,
538 },
539 [RK818_IRQ_CHG_TS1] = {
540 .mask = RK818_IRQ_CHG_TS1_MSK,
541 .reg_offset = 1,
542 },
543 [RK818_IRQ_TS2] = {
544 .mask = RK818_IRQ_TS2_MSK,
545 .reg_offset = 1,
546 },
547 [RK818_IRQ_CHG_CVTLIM] = {
548 .mask = RK818_IRQ_CHG_CVTLIM_MSK,
549 .reg_offset = 1,
550 },
551 [RK818_IRQ_DISCHG_ILIM] = {
552 .mask = RK818_IRQ_DISCHG_ILIM_MSK,
553 .reg_offset = 1,
554 },
555 };
556
557 static const struct regmap_irq rk817_irqs[RK817_IRQ_END] = {
558 REGMAP_IRQ_REG_LINE(0, 8),
559 REGMAP_IRQ_REG_LINE(1, 8),
560 REGMAP_IRQ_REG_LINE(2, 8),
561 REGMAP_IRQ_REG_LINE(3, 8),
562 REGMAP_IRQ_REG_LINE(4, 8),
563 REGMAP_IRQ_REG_LINE(5, 8),
564 REGMAP_IRQ_REG_LINE(6, 8),
565 REGMAP_IRQ_REG_LINE(7, 8),
566 REGMAP_IRQ_REG_LINE(8, 8),
567 REGMAP_IRQ_REG_LINE(9, 8),
568 REGMAP_IRQ_REG_LINE(10, 8),
569 REGMAP_IRQ_REG_LINE(11, 8),
570 REGMAP_IRQ_REG_LINE(12, 8),
571 REGMAP_IRQ_REG_LINE(13, 8),
572 REGMAP_IRQ_REG_LINE(14, 8),
573 REGMAP_IRQ_REG_LINE(15, 8),
574 REGMAP_IRQ_REG_LINE(16, 8),
575 REGMAP_IRQ_REG_LINE(17, 8),
576 REGMAP_IRQ_REG_LINE(18, 8),
577 REGMAP_IRQ_REG_LINE(19, 8),
578 REGMAP_IRQ_REG_LINE(20, 8),
579 REGMAP_IRQ_REG_LINE(21, 8),
580 REGMAP_IRQ_REG_LINE(22, 8),
581 REGMAP_IRQ_REG_LINE(23, 8)
582 };
583
584 static const struct regmap_irq_chip rk805_irq_chip = {
585 .name = "rk805",
586 .irqs = rk805_irqs,
587 .num_irqs = ARRAY_SIZE(rk805_irqs),
588 .num_regs = 1,
589 .status_base = RK805_INT_STS_REG,
590 .mask_base = RK805_INT_STS_MSK_REG,
591 .ack_base = RK805_INT_STS_REG,
592 .init_ack_masked = true,
593 };
594
595 static const struct regmap_irq_chip rk808_irq_chip = {
596 .name = "rk808",
597 .irqs = rk808_irqs,
598 .num_irqs = ARRAY_SIZE(rk808_irqs),
599 .num_regs = 2,
600 .irq_reg_stride = 2,
601 .status_base = RK808_INT_STS_REG1,
602 .mask_base = RK808_INT_STS_MSK_REG1,
603 .ack_base = RK808_INT_STS_REG1,
604 .init_ack_masked = true,
605 };
606
607 static const struct regmap_irq rk816_battery_irqs[] = {
608 /* INT_STS */
609 [RK816_IRQ_PLUG_IN] = {
610 .mask = RK816_IRQ_PLUG_IN_MSK,
611 .reg_offset = 0,
612 },
613 [RK816_IRQ_PLUG_OUT] = {
614 .mask = RK816_IRQ_PLUG_OUT_MSK,
615 .reg_offset = 0,
616 },
617 [RK816_IRQ_CHG_OK] = {
618 .mask = RK816_IRQ_CHG_OK_MSK,
619 .reg_offset = 0,
620 },
621 [RK816_IRQ_CHG_TE] = {
622 .mask = RK816_IRQ_CHG_TE_MSK,
623 .reg_offset = 0,
624 },
625 [RK816_IRQ_CHG_TS] = {
626 .mask = RK816_IRQ_CHG_TS_MSK,
627 .reg_offset = 0,
628 },
629 [RK816_IRQ_CHG_CVTLIM] = {
630 .mask = RK816_IRQ_CHG_CVTLIM_MSK,
631 .reg_offset = 0,
632 },
633 [RK816_IRQ_DISCHG_ILIM] = {
634 .mask = RK816_IRQ_DISCHG_ILIM_MSK,
635 .reg_offset = 0,
636 },
637 };
638
639 static const struct regmap_irq_chip rk816_irq_chip = {
640 .name = "rk816",
641 .irqs = rk816_irqs,
642 .num_irqs = ARRAY_SIZE(rk816_irqs),
643 .num_regs = 2,
644 .irq_reg_stride = 3,
645 .status_base = RK816_INT_STS_REG1,
646 .mask_base = RK816_INT_STS_MSK_REG1,
647 .ack_base = RK816_INT_STS_REG1,
648 .init_ack_masked = true,
649 };
650
651 static const struct regmap_irq_chip rk816_battery_irq_chip = {
652 .name = "rk816_battery",
653 .irqs = rk816_battery_irqs,
654 .num_irqs = ARRAY_SIZE(rk816_battery_irqs),
655 .num_regs = 1,
656 .status_base = RK816_INT_STS_REG3,
657 .mask_base = RK816_INT_STS_MSK_REG3,
658 .ack_base = RK816_INT_STS_REG3,
659 .init_ack_masked = true,
660 };
661
662 static const struct regmap_irq_chip rk817_irq_chip = {
663 .name = "rk817",
664 .irqs = rk817_irqs,
665 .num_irqs = ARRAY_SIZE(rk817_irqs),
666 .num_regs = 3,
667 .irq_reg_stride = 2,
668 .status_base = RK817_INT_STS_REG0,
669 .mask_base = RK817_INT_STS_MSK_REG0,
670 .ack_base = RK817_INT_STS_REG0,
671 .init_ack_masked = true,
672 };
673
674 static const struct regmap_irq_chip rk818_irq_chip = {
675 .name = "rk818",
676 .irqs = rk818_irqs,
677 .num_irqs = ARRAY_SIZE(rk818_irqs),
678 .num_regs = 2,
679 .irq_reg_stride = 2,
680 .status_base = RK818_INT_STS_REG1,
681 .mask_base = RK818_INT_STS_MSK_REG1,
682 .ack_base = RK818_INT_STS_REG1,
683 .init_ack_masked = true,
684 };
685
686 static struct i2c_client *rk808_i2c_client;
687 static struct rk808_reg_data *suspend_reg, *resume_reg;
688 static int suspend_reg_num, resume_reg_num;
689
rk805_device_shutdown_prepare(void)690 static void rk805_device_shutdown_prepare(void)
691 {
692 int ret;
693 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
694
695 if (!rk808)
696 return;
697
698 ret = regmap_update_bits(rk808->regmap,
699 RK805_GPIO_IO_POL_REG,
700 SLP_SD_MSK, SHUTDOWN_FUN);
701 if (ret)
702 dev_err(&rk808_i2c_client->dev, "Failed to shutdown device!\n");
703 }
704
rk817_shutdown_prepare(void)705 static void rk817_shutdown_prepare(void)
706 {
707 int ret;
708 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
709
710 /* close rtc int when power off */
711 regmap_update_bits(rk808->regmap,
712 RK817_INT_STS_MSK_REG0,
713 (0x3 << 5), (0x3 << 5));
714 regmap_update_bits(rk808->regmap,
715 RK817_RTC_INT_REG,
716 (0x3 << 2), (0x0 << 2));
717
718 if (rk808->pins && rk808->pins->p && rk808->pins->power_off) {
719 ret = regmap_update_bits(rk808->regmap,
720 RK817_SYS_CFG(3),
721 RK817_SLPPIN_FUNC_MSK,
722 SLPPIN_NULL_FUN);
723 if (ret)
724 pr_err("shutdown: config SLPPIN_NULL_FUN error!\n");
725
726 ret = regmap_update_bits(rk808->regmap,
727 RK817_SYS_CFG(3),
728 RK817_SLPPOL_MSK,
729 RK817_SLPPOL_H);
730 if (ret)
731 pr_err("shutdown: config RK817_SLPPOL_H error!\n");
732
733 ret = pinctrl_select_state(rk808->pins->p,
734 rk808->pins->power_off);
735 if (ret)
736 pr_info("%s:failed to activate pwroff state\n",
737 __func__);
738 }
739
740 /* pmic sleep shutdown function */
741 ret = regmap_update_bits(rk808->regmap,
742 RK817_SYS_CFG(3),
743 RK817_SLPPIN_FUNC_MSK, SLPPIN_DN_FUN);
744 if (ret)
745 dev_err(&rk808_i2c_client->dev, "Failed to shutdown device!\n");
746 /* pmic need the SCL clock to synchronize register */
747 mdelay(2);
748 }
749
rk8xx_device_shutdown(void)750 static void rk8xx_device_shutdown(void)
751 {
752 int ret;
753 unsigned int reg, bit;
754 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
755
756 switch (rk808->variant) {
757 case RK805_ID:
758 reg = RK805_DEV_CTRL_REG;
759 bit = DEV_OFF;
760 break;
761 case RK808_ID:
762 reg = RK808_DEVCTRL_REG,
763 bit = DEV_OFF_RST;
764 break;
765 case RK816_ID:
766 reg = RK816_DEV_CTRL_REG;
767 bit = DEV_OFF;
768 break;
769 case RK818_ID:
770 reg = RK818_DEVCTRL_REG;
771 bit = DEV_OFF;
772 break;
773 default:
774 return;
775 }
776
777 ret = regmap_update_bits(rk808->regmap, reg, bit, bit);
778 if (ret)
779 dev_err(&rk808_i2c_client->dev, "Failed to shutdown device!\n");
780 }
781
782 /* Called in syscore shutdown */
783 static void (*pm_shutdown)(void);
784
rk8xx_syscore_shutdown(void)785 static void rk8xx_syscore_shutdown(void)
786 {
787 int ret;
788 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
789
790 if (!rk808) {
791 dev_warn(&rk808_i2c_client->dev,
792 "have no rk808, so do nothing here\n");
793 return;
794 }
795
796 /* close rtc int when power off */
797 regmap_update_bits(rk808->regmap,
798 RK808_INT_STS_MSK_REG1,
799 (0x3 << 5), (0x3 << 5));
800 regmap_update_bits(rk808->regmap,
801 RK808_RTC_INT_REG,
802 (0x3 << 2), (0x0 << 2));
803 /*
804 * For PMIC that power off supplies by write register via i2c bus,
805 * it's better to do power off at syscore shutdown here.
806 *
807 * Because when run to kernel's "pm_power_off" call, i2c may has
808 * been stopped or PMIC may not be able to get i2c transfer while
809 * there are too many devices are competiting.
810 */
811 if (system_state == SYSTEM_POWER_OFF) {
812 if (rk808->variant == RK809_ID || rk808->variant == RK817_ID) {
813 ret = regmap_update_bits(rk808->regmap,
814 RK817_SYS_CFG(3),
815 RK817_SLPPIN_FUNC_MSK,
816 SLPPIN_DN_FUN);
817 if (ret) {
818 dev_warn(&rk808_i2c_client->dev,
819 "Cannot switch to power down function\n");
820 }
821 }
822
823 if (pm_shutdown) {
824 dev_info(&rk808_i2c_client->dev, "System power off\n");
825 pm_shutdown();
826 mdelay(10);
827 dev_info(&rk808_i2c_client->dev,
828 "Power off failed !\n");
829 while (1)
830 ;
831 }
832 }
833 }
834
835 static struct syscore_ops rk808_syscore_ops = {
836 .shutdown = rk8xx_syscore_shutdown,
837 };
838
839 /*
840 * RK8xx PMICs would do real power off in syscore shutdown, if "pm_power_off"
841 * is not assigned(e.g. PSCI is not enabled), we have to provide a dummy
842 * callback for it, otherwise there comes a halt in Reboot system call:
843 *
844 * if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
845 * cmd = LINUX_REBOOT_CMD_HALT;
846 */
rk808_pm_power_off_dummy(void)847 static void rk808_pm_power_off_dummy(void)
848 {
849 pr_info("Dummy power off for RK8xx PMICs, should never reach here!\n");
850
851 while (1)
852 ;
853 }
854
rk8xx_dbg_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)855 static ssize_t rk8xx_dbg_store(struct device *dev,
856 struct device_attribute *attr,
857 const char *buf, size_t count)
858 {
859 int ret;
860 char cmd;
861 u32 input[2], addr, data;
862 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
863
864 ret = sscanf(buf, "%c ", &cmd);
865 if (ret != 1) {
866 pr_err("Unknown command\n");
867 goto out;
868 }
869 switch (cmd) {
870 case 'w':
871 ret = sscanf(buf, "%c %x %x ", &cmd, &input[0], &input[1]);
872 if (ret != 3) {
873 pr_err("error! cmd format: echo w [addr] [value]\n");
874 goto out;
875 };
876 addr = input[0] & 0xff;
877 data = input[1] & 0xff;
878 pr_info("cmd : %c %x %x\n\n", cmd, input[0], input[1]);
879 regmap_write(rk808->regmap, addr, data);
880 regmap_read(rk808->regmap, addr, &data);
881 pr_info("new: %x %x\n", addr, data);
882 break;
883 case 'r':
884 ret = sscanf(buf, "%c %x ", &cmd, &input[0]);
885 if (ret != 2) {
886 pr_err("error! cmd format: echo r [addr]\n");
887 goto out;
888 };
889 pr_info("cmd : %c %x\n\n", cmd, input[0]);
890 addr = input[0] & 0xff;
891 regmap_read(rk808->regmap, addr, &data);
892 pr_info("%x %x\n", input[0], data);
893 break;
894 default:
895 pr_err("Unknown command\n");
896 break;
897 }
898
899 out:
900 return count;
901 }
902
rk817_pinctrl_init(struct device * dev,struct rk808 * rk808)903 static int rk817_pinctrl_init(struct device *dev, struct rk808 *rk808)
904 {
905 int ret;
906 struct platform_device *pinctrl_dev;
907 struct pinctrl_state *default_st;
908
909 pinctrl_dev = platform_device_alloc("rk805-pinctrl", -1);
910 if (!pinctrl_dev) {
911 dev_err(dev, "Alloc pinctrl dev failed!\n");
912 return -ENOMEM;
913 }
914
915 pinctrl_dev->dev.parent = dev;
916
917 ret = platform_device_add(pinctrl_dev);
918
919 if (ret) {
920 platform_device_put(pinctrl_dev);
921 dev_err(dev, "Add rk805-pinctrl dev failed!\n");
922 return ret;
923 }
924 if (dev->pins && !IS_ERR(dev->pins->p)) {
925 dev_info(dev, "had get a pinctrl!\n");
926 return 0;
927 }
928
929 rk808->pins = devm_kzalloc(dev, sizeof(struct rk808_pin_info),
930 GFP_KERNEL);
931 if (!rk808->pins)
932 return -ENOMEM;
933
934 rk808->pins->p = devm_pinctrl_get(dev);
935 if (IS_ERR(rk808->pins->p)) {
936 rk808->pins->p = NULL;
937 dev_err(dev, "no pinctrl handle\n");
938 return 0;
939 }
940
941 default_st = pinctrl_lookup_state(rk808->pins->p,
942 PINCTRL_STATE_DEFAULT);
943
944 if (IS_ERR(default_st)) {
945 dev_dbg(dev, "no default pinctrl state\n");
946 return -EINVAL;
947 }
948
949 ret = pinctrl_select_state(rk808->pins->p, default_st);
950 if (ret) {
951 dev_dbg(dev, "failed to activate default pinctrl state\n");
952 return -EINVAL;
953 }
954
955 rk808->pins->power_off = pinctrl_lookup_state(rk808->pins->p,
956 "pmic-power-off");
957 if (IS_ERR(rk808->pins->power_off)) {
958 rk808->pins->power_off = NULL;
959 dev_dbg(dev, "no power-off pinctrl state\n");
960 }
961
962 rk808->pins->sleep = pinctrl_lookup_state(rk808->pins->p,
963 "pmic-sleep");
964 if (IS_ERR(rk808->pins->sleep)) {
965 rk808->pins->sleep = NULL;
966 dev_dbg(dev, "no sleep-setting state\n");
967 }
968
969 rk808->pins->reset = pinctrl_lookup_state(rk808->pins->p,
970 "pmic-reset");
971 if (IS_ERR(rk808->pins->reset)) {
972 rk808->pins->reset = NULL;
973 dev_dbg(dev, "no reset-setting pinctrl state\n");
974 return 0;
975 }
976
977 ret = pinctrl_select_state(rk808->pins->p, rk808->pins->reset);
978
979 if (ret)
980 dev_dbg(dev, "failed to activate reset-setting pinctrl state\n");
981
982 return 0;
983 }
984
985 struct rk817_reboot_data_t {
986 struct rk808 *rk808;
987 struct notifier_block reboot_notifier;
988 };
989
990 static struct rk817_reboot_data_t rk817_reboot_data;
991
rk817_reboot_notifier_handler(struct notifier_block * nb,unsigned long action,void * cmd)992 static int rk817_reboot_notifier_handler(struct notifier_block *nb,
993 unsigned long action, void *cmd)
994 {
995 struct rk817_reboot_data_t *data;
996 struct device *dev;
997 int value, power_en_active0, power_en_active1;
998 int ret, i;
999 static const char * const pmic_rst_reg_only_cmd[] = {
1000 "loader", "bootloader", "fastboot", "recovery",
1001 "ums", "panic", "watchdog", "charge",
1002 };
1003
1004 data = container_of(nb, struct rk817_reboot_data_t, reboot_notifier);
1005 dev = &data->rk808->i2c->dev;
1006
1007 regmap_read(data->rk808->regmap, RK817_POWER_EN_SAVE0,
1008 &power_en_active0);
1009 if (power_en_active0 != 0) {
1010 regmap_read(data->rk808->regmap, RK817_POWER_EN_SAVE1,
1011 &power_en_active1);
1012 value = power_en_active0 & 0x0f;
1013 regmap_write(data->rk808->regmap,
1014 RK817_POWER_EN_REG(0),
1015 value | 0xf0);
1016 value = (power_en_active0 & 0xf0) >> 4;
1017 regmap_write(data->rk808->regmap,
1018 RK817_POWER_EN_REG(1),
1019 value | 0xf0);
1020 value = power_en_active1 & 0x0f;
1021 regmap_write(data->rk808->regmap,
1022 RK817_POWER_EN_REG(2),
1023 value | 0xf0);
1024 value = (power_en_active1 & 0xf0) >> 4;
1025 regmap_write(data->rk808->regmap,
1026 RK817_POWER_EN_REG(3),
1027 value | 0xf0);
1028 } else {
1029 dev_info(dev, "reboot: not restore POWER_EN\n");
1030 }
1031
1032 if (action != SYS_RESTART || !cmd)
1033 return NOTIFY_OK;
1034
1035 /*
1036 * When system restart, there are two rst actions of PMIC sleep if
1037 * board hardware support:
1038 *
1039 * 0b'00: reset the PMIC itself completely.
1040 * 0b'01: reset the 'RST' related register only.
1041 *
1042 * In the case of 0b'00, PMIC reset itself which triggers SoC NPOR-reset
1043 * at the same time, so the command: reboot load/bootload/recovery, etc
1044 * is not effect any more.
1045 *
1046 * Here we check if this reboot cmd is what we expect for 0b'01.
1047 */
1048 for (i = 0; i < ARRAY_SIZE(pmic_rst_reg_only_cmd); i++) {
1049 if (!strcmp(cmd, pmic_rst_reg_only_cmd[i])) {
1050 ret = regmap_update_bits(data->rk808->regmap,
1051 RK817_SYS_CFG(3),
1052 RK817_RST_FUNC_MSK,
1053 RK817_RST_FUNC_REG);
1054 if (ret)
1055 dev_err(dev, "reboot: force RK817_RST_FUNC_REG error!\n");
1056 else
1057 dev_info(dev, "reboot: force RK817_RST_FUNC_REG ok!\n");
1058 break;
1059 }
1060 }
1061
1062 return NOTIFY_OK;
1063 }
1064
rk817_of_property_prepare(struct rk808 * rk808,struct device * dev)1065 static void rk817_of_property_prepare(struct rk808 *rk808, struct device *dev)
1066 {
1067 u32 inner;
1068 int ret, func, msk, val;
1069 struct device_node *np = dev->of_node;
1070
1071 ret = of_property_read_u32_index(np, "fb-inner-reg-idxs", 0, &inner);
1072 if (!ret && inner == RK817_ID_DCDC3)
1073 regmap_update_bits(rk808->regmap, RK817_POWER_CONFIG,
1074 RK817_BUCK3_FB_RES_MSK,
1075 RK817_BUCK3_FB_RES_INTER);
1076 else
1077 regmap_update_bits(rk808->regmap, RK817_POWER_CONFIG,
1078 RK817_BUCK3_FB_RES_MSK,
1079 RK817_BUCK3_FB_RES_EXT);
1080 dev_info(dev, "support dcdc3 fb mode:%d, %d\n", ret, inner);
1081
1082 ret = of_property_read_u32(np, "pmic-reset-func", &func);
1083
1084 msk = RK817_SLPPIN_FUNC_MSK | RK817_RST_FUNC_MSK;
1085 val = SLPPIN_NULL_FUN;
1086
1087 if (!ret && func < RK817_RST_FUNC_CNT) {
1088 val |= RK817_RST_FUNC_MSK &
1089 (func << RK817_RST_FUNC_SFT);
1090 } else {
1091 val |= RK817_RST_FUNC_REG;
1092 }
1093
1094 regmap_update_bits(rk808->regmap, RK817_SYS_CFG(3), msk, val);
1095
1096 dev_info(dev, "support pmic reset mode:%d,%d\n", ret, func);
1097
1098 rk817_reboot_data.rk808 = rk808;
1099 rk817_reboot_data.reboot_notifier.notifier_call =
1100 rk817_reboot_notifier_handler;
1101 ret = register_reboot_notifier(&rk817_reboot_data.reboot_notifier);
1102 if (ret)
1103 dev_err(dev, "failed to register reboot nb\n");
1104 }
1105
1106 static struct kobject *rk8xx_kobj;
1107 static struct device_attribute rk8xx_attrs =
1108 __ATTR(rk8xx_dbg, 0200, NULL, rk8xx_dbg_store);
1109
1110 static const struct of_device_id rk808_of_match[] = {
1111 { .compatible = "rockchip,rk805" },
1112 { .compatible = "rockchip,rk808" },
1113 { .compatible = "rockchip,rk809" },
1114 { .compatible = "rockchip,rk816" },
1115 { .compatible = "rockchip,rk817" },
1116 { .compatible = "rockchip,rk818" },
1117 { },
1118 };
1119 MODULE_DEVICE_TABLE(of, rk808_of_match);
1120
rk808_probe(struct i2c_client * client,const struct i2c_device_id * id)1121 static int rk808_probe(struct i2c_client *client,
1122 const struct i2c_device_id *id)
1123 {
1124 struct device_node *np = client->dev.of_node;
1125 struct rk808 *rk808;
1126 const struct rk808_reg_data *pre_init_reg;
1127 const struct regmap_irq_chip *battery_irq_chip = NULL;
1128 const struct mfd_cell *cells;
1129 unsigned char pmic_id_msb, pmic_id_lsb;
1130 u8 on_source = 0, off_source = 0;
1131 unsigned int on, off;
1132 int pm_off = 0, msb, lsb;
1133 int nr_pre_init_regs;
1134 int nr_cells;
1135 int ret;
1136 int i;
1137 void (*of_property_prepare_fn)(struct rk808 *rk808,
1138 struct device *dev) = NULL;
1139 int (*pinctrl_init)(struct device *dev, struct rk808 *rk808) = NULL;
1140 void (*device_shutdown_fn)(void) = NULL;
1141
1142 rk808 = devm_kzalloc(&client->dev, sizeof(*rk808), GFP_KERNEL);
1143 if (!rk808)
1144 return -ENOMEM;
1145
1146 if (of_device_is_compatible(np, "rockchip,rk817") ||
1147 of_device_is_compatible(np, "rockchip,rk809")) {
1148 pmic_id_msb = RK817_ID_MSB;
1149 pmic_id_lsb = RK817_ID_LSB;
1150 } else {
1151 pmic_id_msb = RK808_ID_MSB;
1152 pmic_id_lsb = RK808_ID_LSB;
1153 }
1154
1155 /* Read chip variant */
1156 msb = i2c_smbus_read_byte_data(client, pmic_id_msb);
1157 if (msb < 0) {
1158 dev_err(&client->dev, "failed to read the chip id at 0x%x\n",
1159 RK808_ID_MSB);
1160 return msb;
1161 }
1162
1163 lsb = i2c_smbus_read_byte_data(client, pmic_id_lsb);
1164 if (lsb < 0) {
1165 dev_err(&client->dev, "failed to read the chip id at 0x%x\n",
1166 RK808_ID_LSB);
1167 return lsb;
1168 }
1169
1170 rk808->variant = ((msb << 8) | lsb) & RK8XX_ID_MSK;
1171 dev_info(&client->dev, "chip id: 0x%x\n", (unsigned int)rk808->variant);
1172
1173 switch (rk808->variant) {
1174 case RK805_ID:
1175 rk808->regmap_cfg = &rk805_regmap_config;
1176 rk808->regmap_irq_chip = &rk805_irq_chip;
1177 pre_init_reg = rk805_pre_init_reg;
1178 nr_pre_init_regs = ARRAY_SIZE(rk805_pre_init_reg);
1179 cells = rk805s;
1180 nr_cells = ARRAY_SIZE(rk805s);
1181 on_source = RK805_ON_SOURCE_REG;
1182 off_source = RK805_OFF_SOURCE_REG;
1183 suspend_reg = rk805_suspend_reg;
1184 suspend_reg_num = ARRAY_SIZE(rk805_suspend_reg);
1185 resume_reg = rk805_resume_reg;
1186 resume_reg_num = ARRAY_SIZE(rk805_resume_reg);
1187 device_shutdown_fn = rk8xx_device_shutdown;
1188 rk808->pm_pwroff_prep_fn = rk805_device_shutdown_prepare;
1189 break;
1190 case RK808_ID:
1191 rk808->regmap_cfg = &rk808_regmap_config;
1192 rk808->regmap_irq_chip = &rk808_irq_chip;
1193 pre_init_reg = rk808_pre_init_reg;
1194 nr_pre_init_regs = ARRAY_SIZE(rk808_pre_init_reg);
1195 cells = rk808s;
1196 nr_cells = ARRAY_SIZE(rk808s);
1197 device_shutdown_fn = rk8xx_device_shutdown;
1198 break;
1199 case RK816_ID:
1200 rk808->regmap_cfg = &rk816_regmap_config;
1201 rk808->regmap_irq_chip = &rk816_irq_chip;
1202 battery_irq_chip = &rk816_battery_irq_chip;
1203 pre_init_reg = rk816_pre_init_reg;
1204 nr_pre_init_regs = ARRAY_SIZE(rk816_pre_init_reg);
1205 cells = rk816s;
1206 nr_cells = ARRAY_SIZE(rk816s);
1207 on_source = RK816_ON_SOURCE_REG;
1208 off_source = RK816_OFF_SOURCE_REG;
1209 suspend_reg = rk816_suspend_reg;
1210 suspend_reg_num = ARRAY_SIZE(rk816_suspend_reg);
1211 resume_reg = rk816_resume_reg;
1212 resume_reg_num = ARRAY_SIZE(rk816_resume_reg);
1213 device_shutdown_fn = rk8xx_device_shutdown;
1214 break;
1215 case RK818_ID:
1216 rk808->regmap_cfg = &rk818_regmap_config;
1217 rk808->regmap_irq_chip = &rk818_irq_chip;
1218 pre_init_reg = rk818_pre_init_reg;
1219 nr_pre_init_regs = ARRAY_SIZE(rk818_pre_init_reg);
1220 cells = rk818s;
1221 nr_cells = ARRAY_SIZE(rk818s);
1222 on_source = RK818_ON_SOURCE_REG;
1223 off_source = RK818_OFF_SOURCE_REG;
1224 suspend_reg = rk818_suspend_reg;
1225 suspend_reg_num = ARRAY_SIZE(rk818_suspend_reg);
1226 resume_reg = rk818_resume_reg;
1227 resume_reg_num = ARRAY_SIZE(rk818_resume_reg);
1228 device_shutdown_fn = rk8xx_device_shutdown;
1229 break;
1230 case RK809_ID:
1231 case RK817_ID:
1232 rk808->regmap_cfg = &rk817_regmap_config;
1233 rk808->regmap_irq_chip = &rk817_irq_chip;
1234 pre_init_reg = rk817_pre_init_reg;
1235 nr_pre_init_regs = ARRAY_SIZE(rk817_pre_init_reg);
1236 cells = rk817s;
1237 nr_cells = ARRAY_SIZE(rk817s);
1238 on_source = RK817_ON_SOURCE_REG;
1239 off_source = RK817_OFF_SOURCE_REG;
1240 rk808->pm_pwroff_prep_fn = rk817_shutdown_prepare;
1241 of_property_prepare_fn = rk817_of_property_prepare;
1242 pinctrl_init = rk817_pinctrl_init;
1243 break;
1244 default:
1245 dev_err(&client->dev, "Unsupported RK8XX ID %lu\n",
1246 rk808->variant);
1247 return -EINVAL;
1248 }
1249
1250 rk808->i2c = client;
1251 rk808_i2c_client = client;
1252 i2c_set_clientdata(client, rk808);
1253
1254 rk808->regmap = devm_regmap_init_i2c(client, rk808->regmap_cfg);
1255 if (IS_ERR(rk808->regmap)) {
1256 dev_err(&client->dev, "regmap initialization failed\n");
1257 return PTR_ERR(rk808->regmap);
1258 }
1259
1260 if (on_source && off_source) {
1261 ret = regmap_read(rk808->regmap, on_source, &on);
1262 if (ret) {
1263 dev_err(&client->dev, "read 0x%x failed\n", on_source);
1264 return ret;
1265 }
1266
1267 ret = regmap_read(rk808->regmap, off_source, &off);
1268 if (ret) {
1269 dev_err(&client->dev, "read 0x%x failed\n", off_source);
1270 return ret;
1271 }
1272
1273 dev_info(&client->dev, "source: on=0x%02x, off=0x%02x\n",
1274 on, off);
1275 }
1276
1277 if (!client->irq) {
1278 dev_err(&client->dev, "No interrupt support, no core IRQ\n");
1279 return -EINVAL;
1280 }
1281
1282 if (of_property_prepare_fn)
1283 of_property_prepare_fn(rk808, &client->dev);
1284
1285 for (i = 0; i < nr_pre_init_regs; i++) {
1286 ret = regmap_update_bits(rk808->regmap,
1287 pre_init_reg[i].addr,
1288 pre_init_reg[i].mask,
1289 pre_init_reg[i].value);
1290 if (ret) {
1291 dev_err(&client->dev,
1292 "0x%x write err\n",
1293 pre_init_reg[i].addr);
1294 return ret;
1295 }
1296 }
1297
1298 if (pinctrl_init) {
1299 ret = pinctrl_init(&client->dev, rk808);
1300 if (ret)
1301 return ret;
1302 }
1303
1304 ret = regmap_add_irq_chip(rk808->regmap, client->irq,
1305 IRQF_ONESHOT | IRQF_SHARED, -1,
1306 rk808->regmap_irq_chip, &rk808->irq_data);
1307 if (ret) {
1308 dev_err(&client->dev, "Failed to add irq_chip %d\n", ret);
1309 return ret;
1310 }
1311
1312 if (battery_irq_chip) {
1313 ret = regmap_add_irq_chip(rk808->regmap, client->irq,
1314 IRQF_ONESHOT | IRQF_SHARED, -1,
1315 battery_irq_chip,
1316 &rk808->battery_irq_data);
1317 if (ret) {
1318 dev_err(&client->dev,
1319 "Failed to add batterry irq_chip %d\n", ret);
1320 regmap_del_irq_chip(client->irq, rk808->irq_data);
1321 return ret;
1322 }
1323 }
1324
1325 ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE,
1326 cells, nr_cells, NULL, 0,
1327 regmap_irq_get_domain(rk808->irq_data));
1328 if (ret) {
1329 dev_err(&client->dev, "failed to add MFD devices %d\n", ret);
1330 goto err_irq;
1331 }
1332
1333 pm_off = of_property_read_bool(np, "rockchip,system-power-controller");
1334 if (pm_off) {
1335 if (!pm_power_off_prepare)
1336 pm_power_off_prepare = rk808->pm_pwroff_prep_fn;
1337
1338 if (device_shutdown_fn) {
1339 register_syscore_ops(&rk808_syscore_ops);
1340 /* power off system in the syscore shutdown ! */
1341 pm_shutdown = device_shutdown_fn;
1342 }
1343 }
1344
1345 rk8xx_kobj = kobject_create_and_add("rk8xx", NULL);
1346 if (rk8xx_kobj) {
1347 ret = sysfs_create_file(rk8xx_kobj, &rk8xx_attrs.attr);
1348 if (ret)
1349 dev_err(&client->dev, "create rk8xx sysfs error\n");
1350 }
1351
1352 if (!pm_power_off)
1353 pm_power_off = rk808_pm_power_off_dummy;
1354
1355 return 0;
1356
1357 err_irq:
1358 regmap_del_irq_chip(client->irq, rk808->irq_data);
1359 if (battery_irq_chip)
1360 regmap_del_irq_chip(client->irq, rk808->battery_irq_data);
1361 return ret;
1362 }
1363
rk808_remove(struct i2c_client * client)1364 static int rk808_remove(struct i2c_client *client)
1365 {
1366 struct rk808 *rk808 = i2c_get_clientdata(client);
1367
1368 regmap_del_irq_chip(client->irq, rk808->irq_data);
1369
1370 /**
1371 * pm_power_off may points to a function from another module.
1372 * Check if the pointer is set by us and only then overwrite it.
1373 */
1374 if (pm_power_off == rk808_pm_power_off_dummy)
1375 pm_power_off = NULL;
1376
1377 /**
1378 * As above, check if the pointer is set by us before overwrite.
1379 */
1380 if (rk808->pm_pwroff_prep_fn &&
1381 pm_power_off_prepare == rk808->pm_pwroff_prep_fn)
1382 pm_power_off_prepare = NULL;
1383
1384 if (pm_shutdown)
1385 unregister_syscore_ops(&rk808_syscore_ops);
1386
1387 return 0;
1388 }
1389
rk8xx_suspend(struct device * dev)1390 static int __maybe_unused rk8xx_suspend(struct device *dev)
1391 {
1392 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
1393 int i, ret = 0;
1394 int value;
1395
1396 for (i = 0; i < suspend_reg_num; i++) {
1397 ret = regmap_update_bits(rk808->regmap,
1398 suspend_reg[i].addr,
1399 suspend_reg[i].mask,
1400 suspend_reg[i].value);
1401 if (ret) {
1402 dev_err(dev, "0x%x write err\n",
1403 suspend_reg[i].addr);
1404 return ret;
1405 }
1406 }
1407
1408 switch (rk808->variant) {
1409 case RK805_ID:
1410 ret = regmap_update_bits(rk808->regmap,
1411 RK805_GPIO_IO_POL_REG,
1412 SLP_SD_MSK,
1413 SLEEP_FUN);
1414 break;
1415 case RK809_ID:
1416 case RK817_ID:
1417 if (rk808->pins && rk808->pins->p && rk808->pins->sleep) {
1418 ret = regmap_update_bits(rk808->regmap,
1419 RK817_SYS_CFG(3),
1420 RK817_SLPPIN_FUNC_MSK,
1421 SLPPIN_NULL_FUN);
1422 if (ret) {
1423 dev_err(dev, "suspend: config SLPPIN_NULL_FUN error!\n");
1424 return ret;
1425 }
1426
1427 ret = regmap_update_bits(rk808->regmap,
1428 RK817_SYS_CFG(3),
1429 RK817_SLPPOL_MSK,
1430 RK817_SLPPOL_H);
1431 if (ret) {
1432 dev_err(dev, "suspend: config RK817_SLPPOL_H error!\n");
1433 return ret;
1434 }
1435
1436 /* pmic need the SCL clock to synchronize register */
1437 regmap_read(rk808->regmap, RK817_SYS_STS, &value);
1438 mdelay(2);
1439 ret = pinctrl_select_state(rk808->pins->p, rk808->pins->sleep);
1440 if (ret) {
1441 dev_err(dev, "failed to act slp pinctrl state\n");
1442 return ret;
1443 }
1444 }
1445 break;
1446 default:
1447 break;
1448 }
1449
1450 return ret;
1451 }
1452
rk8xx_resume(struct device * dev)1453 static int __maybe_unused rk8xx_resume(struct device *dev)
1454 {
1455 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
1456 int i, ret = 0;
1457 int value;
1458
1459 for (i = 0; i < resume_reg_num; i++) {
1460 ret = regmap_update_bits(rk808->regmap,
1461 resume_reg[i].addr,
1462 resume_reg[i].mask,
1463 resume_reg[i].value);
1464 if (ret) {
1465 dev_err(dev, "0x%x write err\n",
1466 resume_reg[i].addr);
1467 return ret;
1468 }
1469 }
1470
1471 switch (rk808->variant) {
1472 case RK809_ID:
1473 case RK817_ID:
1474 if (rk808->pins && rk808->pins->p && rk808->pins->reset) {
1475 ret = regmap_update_bits(rk808->regmap,
1476 RK817_SYS_CFG(3),
1477 RK817_SLPPIN_FUNC_MSK,
1478 SLPPIN_NULL_FUN);
1479 if (ret) {
1480 dev_err(dev, "resume: config SLPPIN_NULL_FUN error!\n");
1481 return ret;
1482 }
1483
1484 ret = regmap_update_bits(rk808->regmap,
1485 RK817_SYS_CFG(3),
1486 RK817_SLPPOL_MSK,
1487 RK817_SLPPOL_L);
1488 if (ret) {
1489 dev_err(dev, "resume: config RK817_SLPPOL_L error!\n");
1490 return ret;
1491 }
1492
1493 /* pmic need the SCL clock to synchronize register */
1494 regmap_read(rk808->regmap, RK817_SYS_STS, &value);
1495 mdelay(2);
1496 ret = pinctrl_select_state(rk808->pins->p, rk808->pins->reset);
1497 if (ret)
1498 dev_dbg(dev, "failed to act reset pinctrl state\n");
1499 }
1500 break;
1501 default:
1502 break;
1503 }
1504
1505 return ret;
1506 }
1507 SIMPLE_DEV_PM_OPS(rk8xx_pm_ops, rk8xx_suspend, rk8xx_resume);
1508
1509 static struct i2c_driver rk808_i2c_driver = {
1510 .driver = {
1511 .name = "rk808",
1512 .of_match_table = rk808_of_match,
1513 .pm = &rk8xx_pm_ops,
1514 },
1515 .probe = rk808_probe,
1516 .remove = rk808_remove,
1517 };
1518
1519 #ifdef CONFIG_ROCKCHIP_THUNDER_BOOT
rk808_i2c_driver_init(void)1520 static int __init rk808_i2c_driver_init(void)
1521 {
1522 return i2c_add_driver(&rk808_i2c_driver);
1523 }
1524 subsys_initcall(rk808_i2c_driver_init);
1525
rk808_i2c_driver_exit(void)1526 static void __exit rk808_i2c_driver_exit(void)
1527 {
1528 i2c_del_driver(&rk808_i2c_driver);
1529 }
1530 module_exit(rk808_i2c_driver_exit);
1531 #else
1532 module_i2c_driver(rk808_i2c_driver);
1533 #endif
1534
1535 MODULE_LICENSE("GPL");
1536 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
1537 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
1538 MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
1539 MODULE_DESCRIPTION("RK808/RK818 PMIC driver");
1540