2 * MFD core driver for Rockchip RK808
4 * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
6 * Author: Chris Zhong <zyw@rock-chips.com>
7 * Author: Zhang Qing <zhangqing@rock-chips.com>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms and conditions of the GNU General Public License,
11 * version 2, as published by the Free Software Foundation.
13 * This program is distributed in the hope it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 #include <linux/i2c.h>
20 #include <linux/interrupt.h>
21 #include <linux/kernel.h>
22 #include <linux/mfd/rk808.h>
23 #include <linux/mfd/core.h>
24 #include <linux/module.h>
25 #include <linux/of_device.h>
26 #include <linux/regmap.h>
27 #include <linux/of_gpio.h>
28 #include <linux/gpio.h>
29 #include <linux/delay.h>
31 struct rk808_reg_data {
37 static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg)
41 * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
42 * we don't use that feature. It's better to cache.
43 * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
44 * bits are cleared in case when we shutoff anyway, but better safe.
48 case RK808_SECONDS_REG ... RK808_WEEKS_REG:
49 case RK808_RTC_STATUS_REG:
50 case RK808_VB_MON_REG:
51 case RK808_THERMAL_REG:
52 case RK808_DCDC_UV_STS_REG:
53 case RK808_LDO_UV_STS_REG:
54 case RK808_DCDC_PG_REG:
55 case RK808_LDO_PG_REG:
56 case RK808_DEVCTRL_REG:
57 case RK808_INT_STS_REG1:
58 case RK808_INT_STS_REG2:
65 static int rk808_shutdown(struct regmap *regmap)
69 ret = regmap_update_bits(regmap,
73 printk("DEV_OFF error!\n");
76 ret = regmap_update_bits(regmap,
78 BUCK1_EN_MASK | BUCK2_EN_MASK | BUCK3_EN_MASK | BUCK4_EN_MASK, 0xf);
80 printk("RK808_DCDC_EN_REG error!\n");
81 ret = regmap_update_bits(regmap,
85 printk("RK808_LDO_EN_REG error!\n");
90 static int rk816_shutdown(struct regmap *regmap)
94 ret = regmap_update_bits(regmap,
100 static int rk818_shutdown(struct regmap *regmap)
104 ret = regmap_update_bits(regmap,
110 static int rk805_shutdown_prepare(struct regmap *regmap)
114 /* close rtc int when power off */
115 regmap_update_bits(regmap,
116 RK808_INT_STS_MSK_REG1,
117 (0x3 << 5), (0x3 << 5));
118 regmap_update_bits(regmap,
120 (0x3 << 2), (0x0 << 2));
122 /* pmic sleep shutdown function */
123 ret = regmap_update_bits(regmap,
124 RK805_GPIO_IO_POL_REG,
125 SLP_SD_MSK, SHUTDOWN_FUN);
129 static bool rk818_is_volatile_reg(struct device *dev, unsigned int reg)
133 * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
134 * we don't use that feature. It's better to cache.
135 * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
136 * bits are cleared in case when we shutoff anyway, but better safe.
140 case RK808_SECONDS_REG ... RK808_WEEKS_REG:
141 case RK808_RTC_STATUS_REG:
142 case RK808_VB_MON_REG:
143 case RK808_THERMAL_REG:
144 case RK808_DCDC_EN_REG:
145 case RK808_DCDC_UV_STS_REG:
146 case RK808_LDO_UV_STS_REG:
147 case RK808_DCDC_PG_REG:
148 case RK808_LDO_PG_REG:
149 case RK808_DEVCTRL_REG:
150 case RK808_INT_STS_REG1:
151 case RK808_INT_STS_REG2:
152 case RK808_INT_STS_MSK_REG1:
153 case RK808_INT_STS_MSK_REG2:
154 case RK818_SUP_STS_REG ... RK818_SAVE_DATA19:
161 static const struct regmap_config rk808_regmap_config = {
164 .max_register = RK808_IO_POL_REG,
165 .cache_type = REGCACHE_RBTREE,
166 .volatile_reg = rk808_is_volatile_reg,
169 static const struct regmap_config rk805_regmap_config = {
172 .max_register = RK805_OFF_SOURCE_REG,
173 .cache_type = REGCACHE_RBTREE,
174 .volatile_reg = rk808_is_volatile_reg,
177 static const struct regmap_config rk816_regmap_config = {
180 .max_register = RK816_DATA18_REG,
181 .cache_type = REGCACHE_RBTREE,
182 .volatile_reg = rk818_is_volatile_reg,
185 static const struct regmap_config rk818_regmap_config = {
188 .max_register = RK818_SAVE_DATA19,
189 .cache_type = REGCACHE_RBTREE,
190 .volatile_reg = rk818_is_volatile_reg,
193 static struct resource rtc_resources[] = {
195 .start = RK808_IRQ_RTC_ALARM,
196 .end = RK808_IRQ_RTC_ALARM,
197 .flags = IORESOURCE_IRQ,
201 static struct resource pwrkey_resources[] = {
203 .start = RK805_IRQ_PWRON_RISE,
204 .end = RK805_IRQ_PWRON_RISE,
205 .flags = IORESOURCE_IRQ,
208 .start = RK805_IRQ_PWRON_FALL,
209 .end = RK805_IRQ_PWRON_FALL,
210 .flags = IORESOURCE_IRQ,
214 static struct resource rk816_pwrkey_resources[] = {
216 .start = RK816_IRQ_PWRON_RISE,
217 .end = RK816_IRQ_PWRON_RISE,
218 .flags = IORESOURCE_IRQ,
221 .start = RK816_IRQ_PWRON_FALL,
222 .end = RK816_IRQ_PWRON_FALL,
223 .flags = IORESOURCE_IRQ,
227 static const struct mfd_cell rk808s[] = {
228 { .name = "rk808-clkout", },
229 { .name = "rk808-regulator", },
232 .num_resources = ARRAY_SIZE(rtc_resources),
233 .resources = &rtc_resources[0],
237 static const struct rk808_reg_data rk808_pre_init_reg[] = {
238 { RK808_BUCK3_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_150MA },
239 { RK808_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_200MA },
240 { RK808_BOOST_CONFIG_REG, BOOST_ILMIN_MASK, BOOST_ILMIN_100MA },
241 { RK808_BUCK1_CONFIG_REG, BUCK1_RATE_MASK, BUCK_ILMIN_200MA },
242 { RK808_BUCK2_CONFIG_REG, BUCK2_RATE_MASK, BUCK_ILMIN_200MA },
243 { RK808_DCDC_UV_ACT_REG, BUCK_UV_ACT_MASK, BUCK_UV_ACT_DISABLE},
244 { RK808_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
245 { RK808_VB_MON_REG, MASK_ALL, VB_LO_ACT |
249 static const struct regmap_irq rk808_irqs[] = {
251 [RK808_IRQ_VOUT_LO] = {
252 .mask = RK808_IRQ_VOUT_LO_MSK,
255 [RK808_IRQ_VB_LO] = {
256 .mask = RK808_IRQ_VB_LO_MSK,
259 [RK808_IRQ_PWRON] = {
260 .mask = RK808_IRQ_PWRON_MSK,
263 [RK808_IRQ_PWRON_LP] = {
264 .mask = RK808_IRQ_PWRON_LP_MSK,
267 [RK808_IRQ_HOTDIE] = {
268 .mask = RK808_IRQ_HOTDIE_MSK,
271 [RK808_IRQ_RTC_ALARM] = {
272 .mask = RK808_IRQ_RTC_ALARM_MSK,
275 [RK808_IRQ_RTC_PERIOD] = {
276 .mask = RK808_IRQ_RTC_PERIOD_MSK,
281 [RK808_IRQ_PLUG_IN_INT] = {
282 .mask = RK808_IRQ_PLUG_IN_INT_MSK,
285 [RK808_IRQ_PLUG_OUT_INT] = {
286 .mask = RK808_IRQ_PLUG_OUT_INT_MSK,
291 static struct regmap_irq_chip rk808_irq_chip = {
294 .num_irqs = ARRAY_SIZE(rk808_irqs),
297 .status_base = RK808_INT_STS_REG1,
298 .mask_base = RK808_INT_STS_MSK_REG1,
299 .ack_base = RK808_INT_STS_REG1,
300 .init_ack_masked = true,
303 static const struct mfd_cell rk816s[] = {
304 { .name = "rk808-clkout", },
305 { .name = "rk808-regulator", },
306 { .name = "rk8xx-gpio", },
308 .name = "rk8xx-pwrkey",
309 .num_resources = ARRAY_SIZE(rk816_pwrkey_resources),
310 .resources = &rk816_pwrkey_resources[0],
314 .num_resources = ARRAY_SIZE(rtc_resources),
315 .resources = &rtc_resources[0],
319 static const struct rk808_reg_data rk816_pre_init_reg[] = {
321 {RK816_BUCK4_CONFIG_REG, BUCK4_MAX_ILIMIT, REG_WRITE_MSK},
322 /* hotdie temperature: 105c*/
323 {RK816_THERMAL_REG, TEMP105C, REG_WRITE_MSK},
324 /* set buck 12.5mv/us */
325 {RK816_BUCK1_CONFIG_REG, BUCK_RATE_12_5MV_US, BUCK_RATE_MSK},
326 {RK816_BUCK2_CONFIG_REG, BUCK_RATE_12_5MV_US, BUCK_RATE_MSK},
327 /* enable RTC_PERIOD & RTC_ALARM int */
328 {RK816_INT_STS_MSK_REG2, RTC_PERIOD_ALARM_INT_EN, REG_WRITE_MSK},
329 /* set bat 3.0 low and act shutdown */
330 {RK816_VB_MON_REG, RK816_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN,
331 VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK},
332 /* enable PWRON rising/faling int */
333 {RK816_INT_STS_MSK_REG1, RK816_PWRON_FALL_RISE_INT_EN, REG_WRITE_MSK},
334 /* enable PLUG IN/OUT int */
335 {RK816_INT_STS_MSK_REG3, PLUGIN_OUT_INT_EN, REG_WRITE_MSK},
336 /* clear int flags */
337 {RK816_INT_STS_REG1, ALL_INT_FLAGS_ST, REG_WRITE_MSK},
338 {RK816_INT_STS_REG2, ALL_INT_FLAGS_ST, REG_WRITE_MSK},
339 {RK816_INT_STS_REG3, ALL_INT_FLAGS_ST, REG_WRITE_MSK},
340 {RK816_DCDC_EN_REG2, BOOST_DISABLE, BOOST_EN_MASK},
343 static const struct regmap_irq rk816_irqs[] = {
345 [RK816_IRQ_PWRON_FALL] = {
346 .mask = RK816_IRQ_PWRON_FALL_MSK,
349 [RK816_IRQ_PWRON_RISE] = {
350 .mask = RK816_IRQ_PWRON_RISE_MSK,
353 [RK816_IRQ_VB_LOW] = {
354 .mask = RK816_IRQ_VB_LOW_MSK,
357 [RK816_IRQ_PWRON] = {
358 .mask = RK816_IRQ_PWRON_MSK,
361 [RK816_IRQ_PWRON_LP] = {
362 .mask = RK816_IRQ_PWRON_LP_MSK,
365 [RK816_IRQ_HOTDIE] = {
366 .mask = RK816_IRQ_HOTDIE_MSK,
369 [RK816_IRQ_RTC_ALARM] = {
370 .mask = RK816_IRQ_RTC_ALARM_MSK,
373 [RK816_IRQ_RTC_PERIOD] = {
374 .mask = RK816_IRQ_RTC_PERIOD_MSK,
377 [RK816_IRQ_USB_OV] = {
378 .mask = RK816_IRQ_USB_OV_MSK,
383 static struct regmap_irq_chip rk816_irq_chip = {
386 .num_irqs = ARRAY_SIZE(rk816_irqs),
389 .status_base = RK816_INT_STS_REG1,
390 .mask_base = RK816_INT_STS_MSK_REG1,
391 .ack_base = RK816_INT_STS_REG1,
392 .init_ack_masked = true,
395 static const struct mfd_cell rk818s[] = {
396 { .name = "rk808-clkout", },
397 { .name = "rk808-regulator", },
398 { .name = "rk818-battery", .of_compatible = "rk818-battery", },
399 { .name = "rk818-charger", },
402 .num_resources = ARRAY_SIZE(rtc_resources),
403 .resources = &rtc_resources[0],
407 static const struct rk808_reg_data rk818_pre_init_reg[] = {
408 { RK818_H5V_EN_REG, REF_RDY_CTRL_ENABLE | H5V_EN_MASK,
409 REF_RDY_CTRL_ENABLE | H5V_EN_ENABLE },
410 { RK818_DCDC_EN_REG, BOOST_EN_MASK | SWITCH_EN_MASK,
411 BOOST_EN_ENABLE | SWITCH_EN_ENABLE },
412 { RK818_SLEEP_SET_OFF_REG1, OTG_SLP_SET_MASK, OTG_SLP_SET_OFF },
413 { RK818_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_250MA },
414 { RK808_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
417 static const struct regmap_irq rk818_irqs[] = {
419 [RK818_IRQ_VOUT_LO] = {
420 .mask = VOUT_LO_MASK,
423 [RK818_IRQ_VB_LO] = {
427 [RK818_IRQ_PWRON] = {
431 [RK818_IRQ_PWRON_LP] = {
432 .mask = PWRON_LP_MASK,
435 [RK818_IRQ_HOTDIE] = {
439 [RK818_IRQ_RTC_ALARM] = {
440 .mask = RTC_ALARM_MASK,
443 [RK818_IRQ_RTC_PERIOD] = {
444 .mask = RTC_PERIOD_MASK,
447 [RK818_IRQ_USB_OV] = {
452 [RK818_IRQ_PLUG_IN] = {
453 .mask = PLUG_IN_MASK,
456 [RK818_IRQ_PLUG_OUT] = {
457 .mask = PLUG_OUT_MASK,
460 [RK818_IRQ_CHG_OK] = {
464 [RK818_IRQ_CHG_TE] = {
468 [RK818_IRQ_CHG_TS1] = {
476 [RK818_IRQ_CHG_CVTLIM] = {
477 .mask = CHG_CVTLIM_MASK,
480 [RK818_IRQ_DISCHG_ILIM] = {
481 .mask = DISCHG_ILIM_MASK,
486 static struct regmap_irq_chip rk818_irq_chip = {
489 .num_irqs = ARRAY_SIZE(rk818_irqs),
492 .status_base = RK808_INT_STS_REG1,
493 .mask_base = RK808_INT_STS_MSK_REG1,
494 .ack_base = RK808_INT_STS_REG1,
495 .init_ack_masked = true,
498 static const struct regmap_irq rk805_irqs[] = {
499 [RK805_IRQ_PWRON_RISE] = {
500 .mask = RK805_IRQ_PWRON_RISE_MSK,
503 [RK805_IRQ_VB_LOW] = {
504 .mask = RK805_IRQ_VB_LOW_MSK,
507 [RK805_IRQ_PWRON] = {
508 .mask = RK805_IRQ_PWRON_MSK,
511 [RK805_IRQ_PWRON_LP] = {
512 .mask = RK805_IRQ_PWRON_LP_MSK,
515 [RK805_IRQ_HOTDIE] = {
516 .mask = RK805_IRQ_HOTDIE_MSK,
519 [RK805_IRQ_RTC_ALARM] = {
520 .mask = RK805_IRQ_RTC_ALARM_MSK,
523 [RK805_IRQ_RTC_PERIOD] = {
524 .mask = RK805_IRQ_RTC_PERIOD_MSK,
527 [RK805_IRQ_PWRON_FALL] = {
528 .mask = RK805_IRQ_PWRON_FALL_MSK,
533 static struct regmap_irq_chip rk805_irq_chip = {
536 .num_irqs = ARRAY_SIZE(rk805_irqs),
538 .status_base = RK805_INT_STS_REG,
539 .mask_base = RK805_INT_STS_MSK_REG,
540 .ack_base = RK805_INT_STS_REG,
541 .init_ack_masked = true,
544 static const struct mfd_cell rk805s[] = {
545 { .name = "rk808-clkout", },
546 { .name = "rk818-regulator", },
547 { .name = "rk8xx-gpio", },
549 .name = "rk8xx-pwrkey",
550 .num_resources = ARRAY_SIZE(pwrkey_resources),
551 .resources = &pwrkey_resources[0],
555 .num_resources = ARRAY_SIZE(rtc_resources),
556 .resources = &rtc_resources[0],
560 static const struct rk808_reg_data rk805_pre_init_reg[] = {
561 {RK805_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK, BUCK_ILMIN_400MA},
562 {RK805_GPIO_IO_POL_REG, SLP_SD_MSK, SLEEP_FUN},
563 {RK808_RTC_CTRL_REG, RTC_STOP, RTC_STOP},
564 {RK805_THERMAL_REG, TEMP_HOTDIE_MSK, TEMP115C},
567 static int (*pm_shutdown)(struct regmap *regmap);
568 static int (*pm_shutdown_prepare)(struct regmap *regmap);
569 static struct i2c_client *rk808_i2c_client;
571 static void rk808_device_shutdown_prepare(void)
574 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
576 if (gpio_is_valid(rk808->stby_gpio)) {
577 printk("rk808->stby_gpio(%d)=low\n", rk808->stby_gpio);
578 gpio_direction_output(rk808->stby_gpio, 0);
580 if (gpio_is_valid(rk808->hold_gpio)) {
581 printk("rk808->hold_gpio(%d)=low\n", rk808->hold_gpio);
582 gpio_direction_output(rk808->hold_gpio, 0);
586 dev_warn(&rk808_i2c_client->dev,
587 "have no rk808, so do nothing here\n");
591 if (pm_shutdown_prepare) {
592 ret = pm_shutdown_prepare(rk808->regmap);
594 dev_err(&rk808_i2c_client->dev,
595 "power off prepare error!\n");
599 static void rk808_device_shutdown(void)
602 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
605 dev_warn(&rk808_i2c_client->dev,
606 "have no rk808, so do nothing here\n");
610 /* close rtc int when power off */
612 regmap_update_bits(rk808->regmap,
613 RK808_INT_STS_MSK_REG1,
614 (0x3 << 5), (0x3 << 5));
615 regmap_update_bits(rk808->regmap,
617 (0x3 << 2), (0x0 << 2));
620 if (gpio_is_valid(rk808->stby_gpio)) {
621 printk("rk808->stby_gpio(%d)=low\n", rk808->stby_gpio);
622 gpio_direction_output(rk808->stby_gpio, 0);
624 if (gpio_is_valid(rk808->hold_gpio)) {
625 printk("rk808->hold_gpio(%d)=low\n", rk808->hold_gpio);
626 gpio_direction_output(rk808->hold_gpio, 0);
630 ret = pm_shutdown(rk808->regmap);
632 dev_err(&rk808_i2c_client->dev, "power off error!\n");
634 printk("%s-%d: pm_shutdown\n", __FUNCTION__, __LINE__);
637 static ssize_t rk8xx_dbg_store(struct device *dev,
638 struct device_attribute *attr,
639 const char *buf, size_t count)
643 u32 input[2], addr, data;
644 struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
646 ret = sscanf(buf, "%c ", &cmd);
649 ret = sscanf(buf, "%c %x %x ", &cmd, &input[0], &input[1]);
651 pr_err("erro! cmd format: echo w [addr] [value]\n");
654 addr = input[0] & 0xff;
655 data = input[1] & 0xff;
656 pr_info("cmd : %c %x %x\n\n", cmd, input[0], input[1]);
657 regmap_write(rk808->regmap, addr, data);
658 regmap_read(rk808->regmap, addr, &data);
659 pr_info("new: %x %x\n", addr, data);
662 ret = sscanf(buf, "%c %x ", &cmd, &input[0]);
664 pr_err("erro! cmd format: echo r [addr]\n");
667 pr_info("cmd : %c %x\n\n", cmd, input[0]);
668 addr = input[0] & 0xff;
669 regmap_read(rk808->regmap, addr, &data);
670 pr_info("%x %x\n", input[0], data);
673 pr_err("Unknown command\n");
681 static struct kobject *rk8xx_kobj;
682 static struct device_attribute rk8xx_attrs =
683 __ATTR(rk8xx_dbg, 0200, NULL, rk8xx_dbg_store);
685 static const struct of_device_id rk808_of_match[] = {
686 { .compatible = "rockchip,rk805" },
687 { .compatible = "rockchip,rk808" },
688 { .compatible = "rockchip,rk816" },
689 { .compatible = "rockchip,rk818" },
693 MODULE_DEVICE_TABLE(of, rk808_of_match);
695 static int rk808_probe(struct i2c_client *client,
696 const struct i2c_device_id *id)
698 struct device_node *np = client->dev.of_node;
700 int (*pm_shutdown_fn)(struct regmap *regmap) = NULL;
701 int (*pm_shutdown_prepare_fn)(struct regmap *regmap) = NULL;
702 const struct rk808_reg_data *pre_init_reg;
703 const struct regmap_config *regmap_config;
704 const struct regmap_irq_chip *irq_chip;
705 const struct mfd_cell *cell;
706 u8 on_source = 0, off_source = 0;
707 int msb, lsb, reg_num, cell_num;
708 int ret, i, pm_off = 0;
709 unsigned int on, off;
712 dev_err(&client->dev, "No interrupt support, no core IRQ\n");
716 rk808 = devm_kzalloc(&client->dev, sizeof(*rk808), GFP_KERNEL);
720 /* read Chip variant */
721 msb = i2c_smbus_read_byte_data(client, RK808_ID_MSB);
723 dev_err(&client->dev, "failed to read the chip id at 0x%x\n",
728 lsb = i2c_smbus_read_byte_data(client, RK808_ID_LSB);
730 dev_err(&client->dev, "failed to read the chip id at 0x%x\n",
735 rk808->variant = ((msb << 8) | lsb) & RK8XX_ID_MSK;
736 dev_info(&client->dev, "Pmic Chip id: 0x%lx\n", rk808->variant);
738 /* set Chip platform init data*/
739 switch (rk808->variant) {
742 cell_num = ARRAY_SIZE(rk818s);
743 pre_init_reg = rk818_pre_init_reg;
744 reg_num = ARRAY_SIZE(rk818_pre_init_reg);
745 regmap_config = &rk818_regmap_config;
746 irq_chip = &rk818_irq_chip;
747 pm_shutdown_fn = rk818_shutdown;
748 on_source = RK818_ON_SOURCE_REG;
749 off_source = RK818_OFF_SOURCE_REG;
753 cell_num = ARRAY_SIZE(rk816s);
754 pre_init_reg = rk816_pre_init_reg;
755 reg_num = ARRAY_SIZE(rk816_pre_init_reg);
756 regmap_config = &rk816_regmap_config;
757 irq_chip = &rk816_irq_chip;
758 pm_shutdown_fn = rk816_shutdown;
759 on_source = RK816_ON_SOURCE_REG;
760 off_source = RK816_OFF_SOURCE_REG;
764 cell_num = ARRAY_SIZE(rk808s);
765 pre_init_reg = rk808_pre_init_reg;
766 reg_num = ARRAY_SIZE(rk808_pre_init_reg);
767 regmap_config = &rk808_regmap_config;
768 irq_chip = &rk808_irq_chip;
769 pm_shutdown_fn = rk808_shutdown;
773 cell_num = ARRAY_SIZE(rk805s);
774 pre_init_reg = rk805_pre_init_reg;
775 reg_num = ARRAY_SIZE(rk805_pre_init_reg);
776 regmap_config = &rk805_regmap_config;
777 irq_chip = &rk805_irq_chip;
778 pm_shutdown_prepare_fn = rk805_shutdown_prepare;
779 on_source = RK805_ON_SOURCE_REG;
780 off_source = RK805_OFF_SOURCE_REG;
783 dev_err(&client->dev, "unsupported RK8XX ID 0x%lx\n",
788 rk808->regmap = devm_regmap_init_i2c(client, regmap_config);
789 if (IS_ERR(rk808->regmap)) {
790 dev_err(&client->dev, "regmap initialization failed\n");
791 return PTR_ERR(rk808->regmap);
794 /* on & off source */
795 if (on_source && off_source) {
796 ret = regmap_read(rk808->regmap, on_source, &on);
798 dev_err(&client->dev, "read 0x%x failed\n", on_source);
802 ret = regmap_read(rk808->regmap, off_source, &off);
804 dev_err(&client->dev, "read 0x%x failed\n", off_source);
808 dev_info(&client->dev, "source: on=0x%02x, off=0x%02x\n",
812 for (i = 0; i < reg_num; i++) {
813 ret = regmap_update_bits(rk808->regmap,
814 pre_init_reg[i].addr,
815 pre_init_reg[i].mask,
816 pre_init_reg[i].value);
818 dev_err(&client->dev,
820 pre_init_reg[i].addr);
825 ret = regmap_add_irq_chip(rk808->regmap, client->irq,
827 irq_chip, &rk808->irq_data);
829 dev_err(&client->dev, "Failed to add irq_chip %d\n", ret);
834 i2c_set_clientdata(client, rk808);
836 ret = mfd_add_devices(&client->dev, -1,
838 NULL, 0, regmap_irq_get_domain(rk808->irq_data));
840 dev_err(&client->dev, "failed to add MFD devices %d\n", ret);
844 pm_off = of_property_read_bool(np,
845 "rockchip,system-power-controller");
847 rk808_i2c_client = client;
848 if (pm_shutdown_prepare_fn) {
849 pm_shutdown_prepare = pm_shutdown_prepare_fn;
850 pm_power_off_prepare = rk808_device_shutdown_prepare;
852 if (pm_shutdown_fn) {
853 pm_shutdown = pm_shutdown_fn;
854 pm_power_off = rk808_device_shutdown;
858 rk8xx_kobj = kobject_create_and_add("rk8xx", NULL);
860 ret = sysfs_create_file(rk8xx_kobj, &rk8xx_attrs.attr);
862 dev_err(&client->dev, "create rk8xx sysfs error\n");
865 rk808->hold_gpio = of_get_named_gpio(np, "pmic,hold-gpio", 0);
866 if (gpio_is_valid(rk808->hold_gpio)) {
867 ret = devm_gpio_request(&client->dev, rk808->hold_gpio, "pmic-hold-gpio");
869 dev_err(&client->dev, "pmic-hold-gpio request ERROR\n");
872 dev_dbg(&client->dev, "hold_gpio(%d)=high\n", rk808->hold_gpio);
873 gpio_direction_output(rk808->hold_gpio, 1);
876 dev_err(&client->dev, "Can not read property pmic,hold-gpio\n");
881 rk808->stby_gpio = of_get_named_gpio(np, "pmic,stby-gpio", 0);
882 if (gpio_is_valid(rk808->stby_gpio)) {
883 ret = devm_gpio_request(&client->dev, rk808->stby_gpio, "pmic-stby-gpio");
885 dev_err(&client->dev, "devm_gpio_request pmic-stby-gpio request ERROR\n");
888 dev_dbg(&client->dev, "stby_gpio(%d)=low\n", rk808->stby_gpio);
889 gpio_direction_output(rk808->stby_gpio, 1);
891 dev_err(&client->dev, "Can not read property pmic,stby-gpio\n");
898 regmap_del_irq_chip(client->irq, rk808->irq_data);
902 static int rk808_remove(struct i2c_client *client)
904 struct rk808 *rk808 = i2c_get_clientdata(client);
906 regmap_del_irq_chip(client->irq, rk808->irq_data);
907 mfd_remove_devices(&client->dev);
908 if (pm_power_off == rk808_device_shutdown)
910 if (pm_power_off_prepare == rk808_device_shutdown_prepare)
911 pm_power_off_prepare = NULL;
916 static const struct i2c_device_id rk808_ids[] = {
923 MODULE_DEVICE_TABLE(i2c, rk808_ids);
925 static struct i2c_driver rk808_i2c_driver = {
928 .of_match_table = rk808_of_match,
930 .probe = rk808_probe,
931 .remove = rk808_remove,
932 .id_table = rk808_ids,
935 module_i2c_driver(rk808_i2c_driver);
937 MODULE_LICENSE("GPL");
938 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
939 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
940 MODULE_AUTHOR("Chen jianhong <chenjh@rock-chips.com>");
941 MODULE_DESCRIPTION("RK808 PMIC driver");