GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / mfd / da9055-core.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Device access for Dialog DA9055 PMICs.
4  *
5  * Copyright(c) 2012 Dialog Semiconductor Ltd.
6  *
7  * Author: David Dajun Chen <dchen@diasemi.com>
8  */
9
10 #include <linux/module.h>
11 #include <linux/device.h>
12 #include <linux/input.h>
13 #include <linux/irq.h>
14 #include <linux/mutex.h>
15
16 #include <linux/mfd/core.h>
17 #include <linux/mfd/da9055/core.h>
18 #include <linux/mfd/da9055/pdata.h>
19 #include <linux/mfd/da9055/reg.h>
20
21 #define DA9055_IRQ_NONKEY_MASK          0x01
22 #define DA9055_IRQ_ALM_MASK             0x02
23 #define DA9055_IRQ_TICK_MASK            0x04
24 #define DA9055_IRQ_ADC_MASK             0x08
25 #define DA9055_IRQ_BUCK_ILIM_MASK       0x08
26
27 static bool da9055_register_readable(struct device *dev, unsigned int reg)
28 {
29         switch (reg) {
30         case DA9055_REG_STATUS_A:
31         case DA9055_REG_STATUS_B:
32         case DA9055_REG_EVENT_A:
33         case DA9055_REG_EVENT_B:
34         case DA9055_REG_EVENT_C:
35         case DA9055_REG_IRQ_MASK_A:
36         case DA9055_REG_IRQ_MASK_B:
37         case DA9055_REG_IRQ_MASK_C:
38
39         case DA9055_REG_CONTROL_A:
40         case DA9055_REG_CONTROL_B:
41         case DA9055_REG_CONTROL_C:
42         case DA9055_REG_CONTROL_D:
43         case DA9055_REG_CONTROL_E:
44
45         case DA9055_REG_ADC_MAN:
46         case DA9055_REG_ADC_CONT:
47         case DA9055_REG_VSYS_MON:
48         case DA9055_REG_ADC_RES_L:
49         case DA9055_REG_ADC_RES_H:
50         case DA9055_REG_VSYS_RES:
51         case DA9055_REG_ADCIN1_RES:
52         case DA9055_REG_ADCIN2_RES:
53         case DA9055_REG_ADCIN3_RES:
54
55         case DA9055_REG_COUNT_S:
56         case DA9055_REG_COUNT_MI:
57         case DA9055_REG_COUNT_H:
58         case DA9055_REG_COUNT_D:
59         case DA9055_REG_COUNT_MO:
60         case DA9055_REG_COUNT_Y:
61         case DA9055_REG_ALARM_H:
62         case DA9055_REG_ALARM_D:
63         case DA9055_REG_ALARM_MI:
64         case DA9055_REG_ALARM_MO:
65         case DA9055_REG_ALARM_Y:
66
67         case DA9055_REG_GPIO0_1:
68         case DA9055_REG_GPIO2:
69         case DA9055_REG_GPIO_MODE0_2:
70
71         case DA9055_REG_BCORE_CONT:
72         case DA9055_REG_BMEM_CONT:
73         case DA9055_REG_LDO1_CONT:
74         case DA9055_REG_LDO2_CONT:
75         case DA9055_REG_LDO3_CONT:
76         case DA9055_REG_LDO4_CONT:
77         case DA9055_REG_LDO5_CONT:
78         case DA9055_REG_LDO6_CONT:
79         case DA9055_REG_BUCK_LIM:
80         case DA9055_REG_BCORE_MODE:
81         case DA9055_REG_VBCORE_A:
82         case DA9055_REG_VBMEM_A:
83         case DA9055_REG_VLDO1_A:
84         case DA9055_REG_VLDO2_A:
85         case DA9055_REG_VLDO3_A:
86         case DA9055_REG_VLDO4_A:
87         case DA9055_REG_VLDO5_A:
88         case DA9055_REG_VLDO6_A:
89         case DA9055_REG_VBCORE_B:
90         case DA9055_REG_VBMEM_B:
91         case DA9055_REG_VLDO1_B:
92         case DA9055_REG_VLDO2_B:
93         case DA9055_REG_VLDO3_B:
94         case DA9055_REG_VLDO4_B:
95         case DA9055_REG_VLDO5_B:
96         case DA9055_REG_VLDO6_B:
97                 return true;
98         default:
99                 return false;
100         }
101 }
102
103 static bool da9055_register_writeable(struct device *dev, unsigned int reg)
104 {
105         switch (reg) {
106         case DA9055_REG_STATUS_A:
107         case DA9055_REG_STATUS_B:
108         case DA9055_REG_EVENT_A:
109         case DA9055_REG_EVENT_B:
110         case DA9055_REG_EVENT_C:
111         case DA9055_REG_IRQ_MASK_A:
112         case DA9055_REG_IRQ_MASK_B:
113         case DA9055_REG_IRQ_MASK_C:
114
115         case DA9055_REG_CONTROL_A:
116         case DA9055_REG_CONTROL_B:
117         case DA9055_REG_CONTROL_C:
118         case DA9055_REG_CONTROL_D:
119         case DA9055_REG_CONTROL_E:
120
121         case DA9055_REG_ADC_MAN:
122         case DA9055_REG_ADC_CONT:
123         case DA9055_REG_VSYS_MON:
124         case DA9055_REG_ADC_RES_L:
125         case DA9055_REG_ADC_RES_H:
126         case DA9055_REG_VSYS_RES:
127         case DA9055_REG_ADCIN1_RES:
128         case DA9055_REG_ADCIN2_RES:
129         case DA9055_REG_ADCIN3_RES:
130
131         case DA9055_REG_COUNT_S:
132         case DA9055_REG_COUNT_MI:
133         case DA9055_REG_COUNT_H:
134         case DA9055_REG_COUNT_D:
135         case DA9055_REG_COUNT_MO:
136         case DA9055_REG_COUNT_Y:
137         case DA9055_REG_ALARM_H:
138         case DA9055_REG_ALARM_D:
139         case DA9055_REG_ALARM_MI:
140         case DA9055_REG_ALARM_MO:
141         case DA9055_REG_ALARM_Y:
142
143         case DA9055_REG_GPIO0_1:
144         case DA9055_REG_GPIO2:
145         case DA9055_REG_GPIO_MODE0_2:
146
147         case DA9055_REG_BCORE_CONT:
148         case DA9055_REG_BMEM_CONT:
149         case DA9055_REG_LDO1_CONT:
150         case DA9055_REG_LDO2_CONT:
151         case DA9055_REG_LDO3_CONT:
152         case DA9055_REG_LDO4_CONT:
153         case DA9055_REG_LDO5_CONT:
154         case DA9055_REG_LDO6_CONT:
155         case DA9055_REG_BUCK_LIM:
156         case DA9055_REG_BCORE_MODE:
157         case DA9055_REG_VBCORE_A:
158         case DA9055_REG_VBMEM_A:
159         case DA9055_REG_VLDO1_A:
160         case DA9055_REG_VLDO2_A:
161         case DA9055_REG_VLDO3_A:
162         case DA9055_REG_VLDO4_A:
163         case DA9055_REG_VLDO5_A:
164         case DA9055_REG_VLDO6_A:
165         case DA9055_REG_VBCORE_B:
166         case DA9055_REG_VBMEM_B:
167         case DA9055_REG_VLDO1_B:
168         case DA9055_REG_VLDO2_B:
169         case DA9055_REG_VLDO3_B:
170         case DA9055_REG_VLDO4_B:
171         case DA9055_REG_VLDO5_B:
172         case DA9055_REG_VLDO6_B:
173                 return true;
174         default:
175                 return false;
176         }
177 }
178
179 static bool da9055_register_volatile(struct device *dev, unsigned int reg)
180 {
181         switch (reg) {
182         case DA9055_REG_STATUS_A:
183         case DA9055_REG_STATUS_B:
184         case DA9055_REG_EVENT_A:
185         case DA9055_REG_EVENT_B:
186         case DA9055_REG_EVENT_C:
187
188         case DA9055_REG_CONTROL_A:
189         case DA9055_REG_CONTROL_E:
190
191         case DA9055_REG_ADC_MAN:
192         case DA9055_REG_ADC_RES_L:
193         case DA9055_REG_ADC_RES_H:
194         case DA9055_REG_VSYS_RES:
195         case DA9055_REG_ADCIN1_RES:
196         case DA9055_REG_ADCIN2_RES:
197         case DA9055_REG_ADCIN3_RES:
198
199         case DA9055_REG_COUNT_S:
200         case DA9055_REG_COUNT_MI:
201         case DA9055_REG_COUNT_H:
202         case DA9055_REG_COUNT_D:
203         case DA9055_REG_COUNT_MO:
204         case DA9055_REG_COUNT_Y:
205         case DA9055_REG_ALARM_MI:
206
207         case DA9055_REG_BCORE_CONT:
208         case DA9055_REG_BMEM_CONT:
209         case DA9055_REG_LDO1_CONT:
210         case DA9055_REG_LDO2_CONT:
211         case DA9055_REG_LDO3_CONT:
212         case DA9055_REG_LDO4_CONT:
213         case DA9055_REG_LDO5_CONT:
214         case DA9055_REG_LDO6_CONT:
215                 return true;
216         default:
217                 return false;
218         }
219 }
220
221 static const struct regmap_irq da9055_irqs[] = {
222         [DA9055_IRQ_NONKEY] = {
223                 .reg_offset = 0,
224                 .mask = DA9055_IRQ_NONKEY_MASK,
225         },
226         [DA9055_IRQ_ALARM] = {
227                 .reg_offset = 0,
228                 .mask = DA9055_IRQ_ALM_MASK,
229         },
230         [DA9055_IRQ_TICK] = {
231                 .reg_offset = 0,
232                 .mask = DA9055_IRQ_TICK_MASK,
233         },
234         [DA9055_IRQ_HWMON] = {
235                 .reg_offset = 0,
236                 .mask = DA9055_IRQ_ADC_MASK,
237         },
238         [DA9055_IRQ_REGULATOR] = {
239                 .reg_offset = 1,
240                 .mask = DA9055_IRQ_BUCK_ILIM_MASK,
241         },
242 };
243
244 const struct regmap_config da9055_regmap_config = {
245         .reg_bits = 8,
246         .val_bits = 8,
247
248         .cache_type = REGCACHE_RBTREE,
249
250         .max_register = DA9055_MAX_REGISTER_CNT,
251         .readable_reg = da9055_register_readable,
252         .writeable_reg = da9055_register_writeable,
253         .volatile_reg = da9055_register_volatile,
254 };
255 EXPORT_SYMBOL_GPL(da9055_regmap_config);
256
257 static struct resource da9055_onkey_resource = {
258         .name = "ONKEY",
259         .start = DA9055_IRQ_NONKEY,
260         .end   = DA9055_IRQ_NONKEY,
261         .flags = IORESOURCE_IRQ,
262 };
263
264 static struct resource da9055_rtc_resource[] = {
265         {
266                 .name = "ALM",
267                 .start = DA9055_IRQ_ALARM,
268                 .end   = DA9055_IRQ_ALARM,
269                 .flags = IORESOURCE_IRQ,
270         },
271         {
272                 .name = "TICK",
273                 .start = DA9055_IRQ_TICK,
274                 .end   = DA9055_IRQ_TICK,
275                 .flags = IORESOURCE_IRQ,
276         },
277 };
278
279 static struct resource da9055_hwmon_resource = {
280         .name = "HWMON",
281         .start = DA9055_IRQ_HWMON,
282         .end   = DA9055_IRQ_HWMON,
283         .flags = IORESOURCE_IRQ,
284 };
285
286 static struct resource da9055_ld05_6_resource = {
287         .name = "REGULATOR",
288         .start = DA9055_IRQ_REGULATOR,
289         .end   = DA9055_IRQ_REGULATOR,
290         .flags = IORESOURCE_IRQ,
291 };
292
293 static const struct mfd_cell da9055_devs[] = {
294         {
295                 .of_compatible = "dlg,da9055-gpio",
296                 .name = "da9055-gpio",
297         },
298         {
299                 .of_compatible = "dlg,da9055-regulator",
300                 .name = "da9055-regulator",
301                 .id = 1,
302         },
303         {
304                 .of_compatible = "dlg,da9055-regulator",
305                 .name = "da9055-regulator",
306                 .id = 2,
307         },
308         {
309                 .of_compatible = "dlg,da9055-regulator",
310                 .name = "da9055-regulator",
311                 .id = 3,
312         },
313         {
314                 .of_compatible = "dlg,da9055-regulator",
315                 .name = "da9055-regulator",
316                 .id = 4,
317         },
318         {
319                 .of_compatible = "dlg,da9055-regulator",
320                 .name = "da9055-regulator",
321                 .id = 5,
322         },
323         {
324                 .of_compatible = "dlg,da9055-regulator",
325                 .name = "da9055-regulator",
326                 .id = 6,
327         },
328         {
329                 .of_compatible = "dlg,da9055-regulator",
330                 .name = "da9055-regulator",
331                 .id = 7,
332                 .resources = &da9055_ld05_6_resource,
333                 .num_resources = 1,
334         },
335         {
336                 .of_compatible = "dlg,da9055-regulator",
337                 .name = "da9055-regulator",
338                 .resources = &da9055_ld05_6_resource,
339                 .num_resources = 1,
340                 .id = 8,
341         },
342         {
343                 .of_compatible = "dlg,da9055-onkey",
344                 .name = "da9055-onkey",
345                 .resources = &da9055_onkey_resource,
346                 .num_resources = 1,
347         },
348         {
349                 .of_compatible = "dlg,da9055-rtc",
350                 .name = "da9055-rtc",
351                 .resources = da9055_rtc_resource,
352                 .num_resources = ARRAY_SIZE(da9055_rtc_resource),
353         },
354         {
355                 .of_compatible = "dlg,da9055-hwmon",
356                 .name = "da9055-hwmon",
357                 .resources = &da9055_hwmon_resource,
358                 .num_resources = 1,
359         },
360         {
361                 .of_compatible = "dlg,da9055-watchdog",
362                 .name = "da9055-watchdog",
363         },
364 };
365
366 static const struct regmap_irq_chip da9055_regmap_irq_chip = {
367         .name = "da9055_irq",
368         .status_base = DA9055_REG_EVENT_A,
369         .mask_base = DA9055_REG_IRQ_MASK_A,
370         .ack_base = DA9055_REG_EVENT_A,
371         .num_regs = 3,
372         .irqs = da9055_irqs,
373         .num_irqs = ARRAY_SIZE(da9055_irqs),
374 };
375
376 int da9055_device_init(struct da9055 *da9055)
377 {
378         struct da9055_pdata *pdata = dev_get_platdata(da9055->dev);
379         int ret;
380         uint8_t clear_events[3] = {0xFF, 0xFF, 0xFF};
381
382         if (pdata && pdata->init != NULL)
383                 pdata->init(da9055);
384
385         if (!pdata || !pdata->irq_base)
386                 da9055->irq_base = -1;
387         else
388                 da9055->irq_base = pdata->irq_base;
389
390         ret = da9055_group_write(da9055, DA9055_REG_EVENT_A, 3, clear_events);
391         if (ret < 0)
392                 return ret;
393
394         ret = regmap_add_irq_chip(da9055->regmap, da9055->chip_irq,
395                                   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
396                                   da9055->irq_base, &da9055_regmap_irq_chip,
397                                   &da9055->irq_data);
398         if (ret < 0)
399                 return ret;
400
401         da9055->irq_base = regmap_irq_chip_get_base(da9055->irq_data);
402
403         ret = mfd_add_devices(da9055->dev, -1,
404                               da9055_devs, ARRAY_SIZE(da9055_devs),
405                               NULL, da9055->irq_base, NULL);
406         if (ret)
407                 goto err;
408
409         return 0;
410
411 err:
412         mfd_remove_devices(da9055->dev);
413         return ret;
414 }
415
416 void da9055_device_exit(struct da9055 *da9055)
417 {
418         regmap_del_irq_chip(da9055->chip_irq, da9055->irq_data);
419         mfd_remove_devices(da9055->dev);
420 }
421
422 MODULE_DESCRIPTION("Core support for the DA9055 PMIC");
423 MODULE_LICENSE("GPL");
424 MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");