GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / mfd / stmfx.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
4  *
5  * Copyright (C) 2019 STMicroelectronics
6  * Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
7  */
8 #include <linux/bitfield.h>
9 #include <linux/i2c.h>
10 #include <linux/interrupt.h>
11 #include <linux/irq.h>
12 #include <linux/mfd/core.h>
13 #include <linux/mfd/stmfx.h>
14 #include <linux/module.h>
15 #include <linux/regulator/consumer.h>
16
17 static bool stmfx_reg_volatile(struct device *dev, unsigned int reg)
18 {
19         switch (reg) {
20         case STMFX_REG_SYS_CTRL:
21         case STMFX_REG_IRQ_SRC_EN:
22         case STMFX_REG_IRQ_PENDING:
23         case STMFX_REG_IRQ_GPI_PENDING1:
24         case STMFX_REG_IRQ_GPI_PENDING2:
25         case STMFX_REG_IRQ_GPI_PENDING3:
26         case STMFX_REG_GPIO_STATE1:
27         case STMFX_REG_GPIO_STATE2:
28         case STMFX_REG_GPIO_STATE3:
29         case STMFX_REG_IRQ_GPI_SRC1:
30         case STMFX_REG_IRQ_GPI_SRC2:
31         case STMFX_REG_IRQ_GPI_SRC3:
32         case STMFX_REG_GPO_SET1:
33         case STMFX_REG_GPO_SET2:
34         case STMFX_REG_GPO_SET3:
35         case STMFX_REG_GPO_CLR1:
36         case STMFX_REG_GPO_CLR2:
37         case STMFX_REG_GPO_CLR3:
38                 return true;
39         default:
40                 return false;
41         }
42 }
43
44 static bool stmfx_reg_writeable(struct device *dev, unsigned int reg)
45 {
46         return (reg >= STMFX_REG_SYS_CTRL);
47 }
48
49 static const struct regmap_config stmfx_regmap_config = {
50         .reg_bits       = 8,
51         .reg_stride     = 1,
52         .val_bits       = 8,
53         .max_register   = STMFX_REG_MAX,
54         .volatile_reg   = stmfx_reg_volatile,
55         .writeable_reg  = stmfx_reg_writeable,
56         .cache_type     = REGCACHE_RBTREE,
57 };
58
59 static const struct resource stmfx_pinctrl_resources[] = {
60         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_GPIO),
61 };
62
63 static const struct resource stmfx_idd_resources[] = {
64         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_IDD),
65         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_ERROR),
66 };
67
68 static const struct resource stmfx_ts_resources[] = {
69         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_DET),
70         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_NE),
71         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_TH),
72         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_FULL),
73         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_OVF),
74 };
75
76 static struct mfd_cell stmfx_cells[] = {
77         {
78                 .of_compatible = "st,stmfx-0300-pinctrl",
79                 .name = "stmfx-pinctrl",
80                 .resources = stmfx_pinctrl_resources,
81                 .num_resources = ARRAY_SIZE(stmfx_pinctrl_resources),
82         },
83         {
84                 .of_compatible = "st,stmfx-0300-idd",
85                 .name = "stmfx-idd",
86                 .resources = stmfx_idd_resources,
87                 .num_resources = ARRAY_SIZE(stmfx_idd_resources),
88         },
89         {
90                 .of_compatible = "st,stmfx-0300-ts",
91                 .name = "stmfx-ts",
92                 .resources = stmfx_ts_resources,
93                 .num_resources = ARRAY_SIZE(stmfx_ts_resources),
94         },
95 };
96
97 static u8 stmfx_func_to_mask(u32 func)
98 {
99         u8 mask = 0;
100
101         if (func & STMFX_FUNC_GPIO)
102                 mask |= STMFX_REG_SYS_CTRL_GPIO_EN;
103
104         if ((func & STMFX_FUNC_ALTGPIO_LOW) || (func & STMFX_FUNC_ALTGPIO_HIGH))
105                 mask |= STMFX_REG_SYS_CTRL_ALTGPIO_EN;
106
107         if (func & STMFX_FUNC_TS)
108                 mask |= STMFX_REG_SYS_CTRL_TS_EN;
109
110         if (func & STMFX_FUNC_IDD)
111                 mask |= STMFX_REG_SYS_CTRL_IDD_EN;
112
113         return mask;
114 }
115
116 int stmfx_function_enable(struct stmfx *stmfx, u32 func)
117 {
118         u32 sys_ctrl;
119         u8 mask;
120         int ret;
121
122         ret = regmap_read(stmfx->map, STMFX_REG_SYS_CTRL, &sys_ctrl);
123         if (ret)
124                 return ret;
125
126         /*
127          * IDD and TS have priority in STMFX FW, so if IDD and TS are enabled,
128          * ALTGPIO function is disabled by STMFX FW. If IDD or TS is enabled,
129          * the number of aGPIO available decreases. To avoid GPIO management
130          * disturbance, abort IDD or TS function enable in this case.
131          */
132         if (((func & STMFX_FUNC_IDD) || (func & STMFX_FUNC_TS)) &&
133             (sys_ctrl & STMFX_REG_SYS_CTRL_ALTGPIO_EN)) {
134                 dev_err(stmfx->dev, "ALTGPIO function already enabled\n");
135                 return -EBUSY;
136         }
137
138         /* If TS is enabled, aGPIO[3:0] cannot be used */
139         if ((func & STMFX_FUNC_ALTGPIO_LOW) &&
140             (sys_ctrl & STMFX_REG_SYS_CTRL_TS_EN)) {
141                 dev_err(stmfx->dev, "TS in use, aGPIO[3:0] unavailable\n");
142                 return -EBUSY;
143         }
144
145         /* If IDD is enabled, aGPIO[7:4] cannot be used */
146         if ((func & STMFX_FUNC_ALTGPIO_HIGH) &&
147             (sys_ctrl & STMFX_REG_SYS_CTRL_IDD_EN)) {
148                 dev_err(stmfx->dev, "IDD in use, aGPIO[7:4] unavailable\n");
149                 return -EBUSY;
150         }
151
152         mask = stmfx_func_to_mask(func);
153
154         return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, mask);
155 }
156 EXPORT_SYMBOL_GPL(stmfx_function_enable);
157
158 int stmfx_function_disable(struct stmfx *stmfx, u32 func)
159 {
160         u8 mask = stmfx_func_to_mask(func);
161
162         return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, 0);
163 }
164 EXPORT_SYMBOL_GPL(stmfx_function_disable);
165
166 static void stmfx_irq_bus_lock(struct irq_data *data)
167 {
168         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
169
170         mutex_lock(&stmfx->lock);
171 }
172
173 static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
174 {
175         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
176
177         regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, stmfx->irq_src);
178
179         mutex_unlock(&stmfx->lock);
180 }
181
182 static void stmfx_irq_mask(struct irq_data *data)
183 {
184         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
185
186         stmfx->irq_src &= ~BIT(data->hwirq % 8);
187 }
188
189 static void stmfx_irq_unmask(struct irq_data *data)
190 {
191         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
192
193         stmfx->irq_src |= BIT(data->hwirq % 8);
194 }
195
196 static struct irq_chip stmfx_irq_chip = {
197         .name                   = "stmfx-core",
198         .irq_bus_lock           = stmfx_irq_bus_lock,
199         .irq_bus_sync_unlock    = stmfx_irq_bus_sync_unlock,
200         .irq_mask               = stmfx_irq_mask,
201         .irq_unmask             = stmfx_irq_unmask,
202 };
203
204 static irqreturn_t stmfx_irq_handler(int irq, void *data)
205 {
206         struct stmfx *stmfx = data;
207         unsigned long bits;
208         u32 pending, ack;
209         int n, ret;
210
211         ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING, &pending);
212         if (ret)
213                 return IRQ_NONE;
214
215         /*
216          * There is no ACK for GPIO, MFX_REG_IRQ_PENDING_GPIO is a logical OR
217          * of MFX_REG_IRQ_GPI _PENDING1/_PENDING2/_PENDING3
218          */
219         ack = pending & ~BIT(STMFX_REG_IRQ_SRC_EN_GPIO);
220         if (ack) {
221                 ret = regmap_write(stmfx->map, STMFX_REG_IRQ_ACK, ack);
222                 if (ret)
223                         return IRQ_NONE;
224         }
225
226         bits = pending;
227         for_each_set_bit(n, &bits, STMFX_REG_IRQ_SRC_MAX)
228                 handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));
229
230         return IRQ_HANDLED;
231 }
232
233 static int stmfx_irq_map(struct irq_domain *d, unsigned int virq,
234                          irq_hw_number_t hwirq)
235 {
236         irq_set_chip_data(virq, d->host_data);
237         irq_set_chip_and_handler(virq, &stmfx_irq_chip, handle_simple_irq);
238         irq_set_nested_thread(virq, 1);
239         irq_set_noprobe(virq);
240
241         return 0;
242 }
243
244 static void stmfx_irq_unmap(struct irq_domain *d, unsigned int virq)
245 {
246         irq_set_chip_and_handler(virq, NULL, NULL);
247         irq_set_chip_data(virq, NULL);
248 }
249
250 static const struct irq_domain_ops stmfx_irq_ops = {
251         .map    = stmfx_irq_map,
252         .unmap  = stmfx_irq_unmap,
253 };
254
255 static void stmfx_irq_exit(struct i2c_client *client)
256 {
257         struct stmfx *stmfx = i2c_get_clientdata(client);
258         int hwirq;
259
260         for (hwirq = 0; hwirq < STMFX_REG_IRQ_SRC_MAX; hwirq++)
261                 irq_dispose_mapping(irq_find_mapping(stmfx->irq_domain, hwirq));
262
263         irq_domain_remove(stmfx->irq_domain);
264 }
265
266 static int stmfx_irq_init(struct i2c_client *client)
267 {
268         struct stmfx *stmfx = i2c_get_clientdata(client);
269         u32 irqoutpin = 0, irqtrigger;
270         int ret;
271
272         stmfx->irq_domain = irq_domain_add_simple(stmfx->dev->of_node,
273                                                   STMFX_REG_IRQ_SRC_MAX, 0,
274                                                   &stmfx_irq_ops, stmfx);
275         if (!stmfx->irq_domain) {
276                 dev_err(stmfx->dev, "Failed to create IRQ domain\n");
277                 return -EINVAL;
278         }
279
280         if (!of_property_read_bool(stmfx->dev->of_node, "drive-open-drain"))
281                 irqoutpin |= STMFX_REG_IRQ_OUT_PIN_TYPE;
282
283         irqtrigger = irq_get_trigger_type(client->irq);
284         if ((irqtrigger & IRQ_TYPE_EDGE_RISING) ||
285             (irqtrigger & IRQ_TYPE_LEVEL_HIGH))
286                 irqoutpin |= STMFX_REG_IRQ_OUT_PIN_POL;
287
288         ret = regmap_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin);
289         if (ret)
290                 goto irq_exit;
291
292         ret = devm_request_threaded_irq(stmfx->dev, client->irq,
293                                         NULL, stmfx_irq_handler,
294                                         irqtrigger | IRQF_ONESHOT,
295                                         "stmfx", stmfx);
296         if (ret)
297                 goto irq_exit;
298
299         stmfx->irq = client->irq;
300
301         return 0;
302
303 irq_exit:
304         stmfx_irq_exit(client);
305
306         return ret;
307 }
308
309 static int stmfx_chip_reset(struct stmfx *stmfx)
310 {
311         int ret;
312
313         ret = regmap_write(stmfx->map, STMFX_REG_SYS_CTRL,
314                            STMFX_REG_SYS_CTRL_SWRST);
315         if (ret)
316                 return ret;
317
318         msleep(STMFX_BOOT_TIME_MS);
319
320         return ret;
321 }
322
323 static int stmfx_chip_init(struct i2c_client *client)
324 {
325         struct stmfx *stmfx = i2c_get_clientdata(client);
326         u32 id;
327         u8 version[2];
328         int ret;
329
330         stmfx->vdd = devm_regulator_get_optional(&client->dev, "vdd");
331         ret = PTR_ERR_OR_ZERO(stmfx->vdd);
332         if (ret) {
333                 stmfx->vdd = NULL;
334                 if (ret != -ENODEV)
335                         return dev_err_probe(&client->dev, ret, "Failed to get VDD regulator\n");
336         }
337
338         if (stmfx->vdd) {
339                 ret = regulator_enable(stmfx->vdd);
340                 if (ret) {
341                         dev_err(&client->dev, "VDD enable failed: %d\n", ret);
342                         return ret;
343                 }
344         }
345
346         ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id);
347         if (ret) {
348                 dev_err(&client->dev, "Error reading chip ID: %d\n", ret);
349                 goto err;
350         }
351
352         /*
353          * Check that ID is the complement of the I2C address:
354          * STMFX I2C address follows the 7-bit format (MSB), that's why
355          * client->addr is shifted.
356          *
357          * STMFX_I2C_ADDR|       STMFX         |        Linux
358          *   input pin   | I2C device address  | I2C device address
359          *---------------------------------------------------------
360          *       0       | b: 1000 010x h:0x84 |       0x42
361          *       1       | b: 1000 011x h:0x86 |       0x43
362          */
363         if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) {
364                 dev_err(&client->dev, "Unknown chip ID: %#x\n", id);
365                 ret = -EINVAL;
366                 goto err;
367         }
368
369         ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB,
370                                version, ARRAY_SIZE(version));
371         if (ret) {
372                 dev_err(&client->dev, "Error reading FW version: %d\n", ret);
373                 goto err;
374         }
375
376         dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n",
377                  id, version[0], version[1]);
378
379         ret = stmfx_chip_reset(stmfx);
380         if (ret) {
381                 dev_err(&client->dev, "Failed to reset chip: %d\n", ret);
382                 goto err;
383         }
384
385         return 0;
386
387 err:
388         if (stmfx->vdd)
389                 regulator_disable(stmfx->vdd);
390
391         return ret;
392 }
393
394 static int stmfx_chip_exit(struct i2c_client *client)
395 {
396         struct stmfx *stmfx = i2c_get_clientdata(client);
397
398         regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
399         regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0);
400
401         if (stmfx->vdd)
402                 return regulator_disable(stmfx->vdd);
403
404         return 0;
405 }
406
407 static int stmfx_probe(struct i2c_client *client,
408                        const struct i2c_device_id *id)
409 {
410         struct device *dev = &client->dev;
411         struct stmfx *stmfx;
412         int ret;
413
414         stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL);
415         if (!stmfx)
416                 return -ENOMEM;
417
418         i2c_set_clientdata(client, stmfx);
419
420         stmfx->dev = dev;
421
422         stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
423         if (IS_ERR(stmfx->map)) {
424                 ret = PTR_ERR(stmfx->map);
425                 dev_err(dev, "Failed to allocate register map: %d\n", ret);
426                 return ret;
427         }
428
429         mutex_init(&stmfx->lock);
430
431         ret = stmfx_chip_init(client);
432         if (ret) {
433                 if (ret == -ETIMEDOUT)
434                         return -EPROBE_DEFER;
435                 return ret;
436         }
437
438         if (client->irq < 0) {
439                 dev_err(dev, "Failed to get IRQ: %d\n", client->irq);
440                 ret = client->irq;
441                 goto err_chip_exit;
442         }
443
444         ret = stmfx_irq_init(client);
445         if (ret)
446                 goto err_chip_exit;
447
448         ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
449                                    stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
450                                    0, stmfx->irq_domain);
451         if (ret)
452                 goto err_irq_exit;
453
454         return 0;
455
456 err_irq_exit:
457         stmfx_irq_exit(client);
458 err_chip_exit:
459         stmfx_chip_exit(client);
460
461         return ret;
462 }
463
464 static int stmfx_remove(struct i2c_client *client)
465 {
466         stmfx_irq_exit(client);
467
468         return stmfx_chip_exit(client);
469 }
470
471 #ifdef CONFIG_PM_SLEEP
472 static int stmfx_suspend(struct device *dev)
473 {
474         struct stmfx *stmfx = dev_get_drvdata(dev);
475         int ret;
476
477         ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL,
478                               &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
479         if (ret)
480                 return ret;
481
482         ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
483                               &stmfx->bkp_irqoutpin,
484                               sizeof(stmfx->bkp_irqoutpin));
485         if (ret)
486                 return ret;
487
488         disable_irq(stmfx->irq);
489
490         if (stmfx->vdd)
491                 return regulator_disable(stmfx->vdd);
492
493         return 0;
494 }
495
496 static int stmfx_resume(struct device *dev)
497 {
498         struct stmfx *stmfx = dev_get_drvdata(dev);
499         int ret;
500
501         if (stmfx->vdd) {
502                 ret = regulator_enable(stmfx->vdd);
503                 if (ret) {
504                         dev_err(stmfx->dev,
505                                 "VDD enable failed: %d\n", ret);
506                         return ret;
507                 }
508         }
509
510         /* Reset STMFX - supply has been stopped during suspend */
511         ret = stmfx_chip_reset(stmfx);
512         if (ret) {
513                 dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret);
514                 return ret;
515         }
516
517         ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL,
518                                &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
519         if (ret)
520                 return ret;
521
522         ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
523                                &stmfx->bkp_irqoutpin,
524                                sizeof(stmfx->bkp_irqoutpin));
525         if (ret)
526                 return ret;
527
528         ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN,
529                                &stmfx->irq_src, sizeof(stmfx->irq_src));
530         if (ret)
531                 return ret;
532
533         enable_irq(stmfx->irq);
534
535         return 0;
536 }
537 #endif
538
539 static SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume);
540
541 static const struct of_device_id stmfx_of_match[] = {
542         { .compatible = "st,stmfx-0300", },
543         {},
544 };
545 MODULE_DEVICE_TABLE(of, stmfx_of_match);
546
547 static struct i2c_driver stmfx_driver = {
548         .driver = {
549                 .name = "stmfx-core",
550                 .of_match_table = of_match_ptr(stmfx_of_match),
551                 .pm = &stmfx_dev_pm_ops,
552         },
553         .probe = stmfx_probe,
554         .remove = stmfx_remove,
555 };
556 module_i2c_driver(stmfx_driver);
557
558 MODULE_DESCRIPTION("STMFX core driver");
559 MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
560 MODULE_LICENSE("GPL v2");