1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/i2c.h>
3 #include <linux/mfd/core.h>
4 #include <linux/module.h>
5 #include <linux/notifier.h>
6 #include <linux/of.h>
7 #include <linux/platform_device.h>
8 #include <linux/reboot.h>
9 #include <linux/regmap.h>
10
11 #include <linux/mfd/88pm886.h>
12
13 static const struct regmap_config pm886_regmap_config = {
14 .reg_bits = 8,
15 .val_bits = 8,
16 .max_register = PM886_REG_RTC_SPARE6,
17 };
18
19 static const struct regmap_config pm886_regmap_battery_config = {
20 .reg_bits = 8,
21 .val_bits = 8,
22 .max_register = PM886_REG_CLS_CONFIG1,
23 };
24
25 static const struct regmap_irq pm886_regmap_irqs[] = {
26 REGMAP_IRQ_REG(PM886_IRQ_ONKEY, 0, PM886_INT_ENA1_ONKEY),
27 };
28
29 static const struct regmap_irq_chip pm886_regmap_irq_chip = {
30 .name = "88pm886",
31 .irqs = pm886_regmap_irqs,
32 .num_irqs = ARRAY_SIZE(pm886_regmap_irqs),
33 .num_regs = 4,
34 .status_base = PM886_REG_INT_STATUS1,
35 .ack_base = PM886_REG_INT_STATUS1,
36 .unmask_base = PM886_REG_INT_ENA_1,
37 };
38
39 static const struct resource pm886_onkey_resources[] = {
40 DEFINE_RES_IRQ_NAMED(PM886_IRQ_ONKEY, "88pm886-onkey"),
41 };
42
43 static const struct mfd_cell pm886_devs[] = {
44 MFD_CELL_NAME("88pm886-gpadc"),
45 MFD_CELL_RES("88pm886-onkey", pm886_onkey_resources),
46 MFD_CELL_NAME("88pm886-regulator"),
47 MFD_CELL_NAME("88pm886-rtc"),
48 };
49
pm886_power_off_handler(struct sys_off_data * sys_off_data)50 static int pm886_power_off_handler(struct sys_off_data *sys_off_data)
51 {
52 struct pm886_chip *chip = sys_off_data->cb_data;
53 struct regmap *regmap = chip->regmap;
54 struct device *dev = &chip->client->dev;
55 int err;
56
57 err = regmap_update_bits(regmap, PM886_REG_MISC_CONFIG1, PM886_SW_PDOWN, PM886_SW_PDOWN);
58 if (err) {
59 dev_err(dev, "Failed to power off the device: %d\n", err);
60 return NOTIFY_BAD;
61 }
62 return NOTIFY_DONE;
63 }
64
pm886_setup_irq(struct pm886_chip * chip,struct regmap_irq_chip_data ** irq_data)65 static int pm886_setup_irq(struct pm886_chip *chip,
66 struct regmap_irq_chip_data **irq_data)
67 {
68 struct regmap *regmap = chip->regmap;
69 struct device *dev = &chip->client->dev;
70 int err;
71
72 /* Set interrupt clearing mode to clear on write. */
73 err = regmap_update_bits(regmap, PM886_REG_MISC_CONFIG2,
74 PM886_INT_INV | PM886_INT_CLEAR | PM886_INT_MASK_MODE,
75 PM886_INT_WC);
76 if (err) {
77 dev_err(dev, "Failed to set interrupt clearing mode: %d\n", err);
78 return err;
79 }
80
81 err = devm_regmap_add_irq_chip(dev, regmap, chip->client->irq,
82 IRQF_ONESHOT, 0, &pm886_regmap_irq_chip,
83 irq_data);
84 if (err) {
85 dev_err(dev, "Failed to request IRQ: %d\n", err);
86 return err;
87 }
88
89 return 0;
90 }
91
pm886_probe(struct i2c_client * client)92 static int pm886_probe(struct i2c_client *client)
93 {
94 struct regmap *regmap, *regmap_battery;
95 struct regmap_irq_chip_data *irq_data;
96 struct device *dev = &client->dev;
97 struct i2c_client *battery_page;
98 struct pm886_chip *chip;
99 unsigned int chip_id;
100 int err;
101
102 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
103 if (!chip)
104 return -ENOMEM;
105
106 chip->client = client;
107 chip->chip_id = (uintptr_t)device_get_match_data(dev);
108 i2c_set_clientdata(client, chip);
109
110 regmap = devm_regmap_init_i2c(client, &pm886_regmap_config);
111 if (IS_ERR(regmap))
112 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to initialize regmap\n");
113 chip->regmap = regmap;
114
115 err = regmap_read(regmap, PM886_REG_ID, &chip_id);
116 if (err)
117 return dev_err_probe(dev, err, "Failed to read chip ID\n");
118
119 if (chip->chip_id != chip_id)
120 return dev_err_probe(dev, -EINVAL, "Unsupported chip: 0x%x\n", chip_id);
121
122 battery_page = devm_i2c_new_dummy_device(dev, client->adapter,
123 client->addr + PM886_PAGE_OFFSET_BATTERY);
124 if (IS_ERR(battery_page))
125 return dev_err_probe(dev, PTR_ERR(battery_page),
126 "Failed to initialize battery page\n");
127
128 regmap_battery = devm_regmap_init_i2c(battery_page, &pm886_regmap_battery_config);
129 if (IS_ERR(regmap_battery))
130 return dev_err_probe(dev, PTR_ERR(regmap_battery),
131 "Failed to initialize battery regmap\n");
132 chip->regmap_battery = regmap_battery;
133
134 err = pm886_setup_irq(chip, &irq_data);
135 if (err)
136 return err;
137
138 err = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE, pm886_devs, ARRAY_SIZE(pm886_devs),
139 NULL, 0, regmap_irq_get_domain(irq_data));
140 if (err)
141 return dev_err_probe(dev, err, "Failed to add devices\n");
142
143 err = devm_register_power_off_handler(dev, pm886_power_off_handler, chip);
144 if (err)
145 return dev_err_probe(dev, err, "Failed to register power off handler\n");
146
147 if (device_property_read_bool(dev, "wakeup-source")) {
148 err = devm_device_init_wakeup(dev);
149 if (err)
150 return dev_err_probe(dev, err, "Failed to init wakeup\n");
151 }
152
153 return 0;
154 }
155
156 static const struct of_device_id pm886_of_match[] = {
157 { .compatible = "marvell,88pm886-a1", .data = (void *)PM886_A1_CHIP_ID },
158 { }
159 };
160 MODULE_DEVICE_TABLE(of, pm886_of_match);
161
162 static struct i2c_driver pm886_i2c_driver = {
163 .driver = {
164 .name = "88pm886",
165 .of_match_table = pm886_of_match,
166 },
167 .probe = pm886_probe,
168 };
169 module_i2c_driver(pm886_i2c_driver);
170
171 MODULE_DESCRIPTION("Marvell 88PM886 PMIC driver");
172 MODULE_AUTHOR("Karel Balej <balejk@matfyz.cz>");
173 MODULE_LICENSE("GPL");
174