GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / mfd / max77620.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Maxim MAX77620 MFD Driver
4  *
5  * Copyright (C) 2016 NVIDIA CORPORATION. All rights reserved.
6  *
7  * Author:
8  *      Laxman Dewangan <ldewangan@nvidia.com>
9  *      Chaitanya Bandi <bandik@nvidia.com>
10  *      Mallikarjun Kasoju <mkasoju@nvidia.com>
11  */
12
13 /****************** Teminology used in driver ********************
14  * Here are some terminology used from datasheet for quick reference:
15  * Flexible Power Sequence (FPS):
16  * The Flexible Power Sequencer (FPS) allows each regulator to power up under
17  * hardware or software control. Additionally, each regulator can power on
18  * independently or among a group of other regulators with an adjustable
19  * power-up and power-down delays (sequencing). GPIO1, GPIO2, and GPIO3 can
20  * be programmed to be part of a sequence allowing external regulators to be
21  * sequenced along with internal regulators. 32KHz clock can be programmed to
22  * be part of a sequence.
23  * There is 3 FPS confguration registers and all resources are configured to
24  * any of these FPS or no FPS.
25  */
26
27 #include <linux/i2c.h>
28 #include <linux/interrupt.h>
29 #include <linux/mfd/core.h>
30 #include <linux/mfd/max77620.h>
31 #include <linux/init.h>
32 #include <linux/of.h>
33 #include <linux/of_device.h>
34 #include <linux/regmap.h>
35 #include <linux/slab.h>
36
37 static struct max77620_chip *max77620_scratch;
38
39 static const struct resource gpio_resources[] = {
40         DEFINE_RES_IRQ(MAX77620_IRQ_TOP_GPIO),
41 };
42
43 static const struct resource power_resources[] = {
44         DEFINE_RES_IRQ(MAX77620_IRQ_LBT_MBATLOW),
45 };
46
47 static const struct resource rtc_resources[] = {
48         DEFINE_RES_IRQ(MAX77620_IRQ_TOP_RTC),
49 };
50
51 static const struct resource thermal_resources[] = {
52         DEFINE_RES_IRQ(MAX77620_IRQ_LBT_TJALRM1),
53         DEFINE_RES_IRQ(MAX77620_IRQ_LBT_TJALRM2),
54 };
55
56 static const struct regmap_irq max77620_top_irqs[] = {
57         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_GLBL, 0, MAX77620_IRQ_TOP_GLBL_MASK),
58         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_SD, 0, MAX77620_IRQ_TOP_SD_MASK),
59         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_LDO, 0, MAX77620_IRQ_TOP_LDO_MASK),
60         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_GPIO, 0, MAX77620_IRQ_TOP_GPIO_MASK),
61         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_RTC, 0, MAX77620_IRQ_TOP_RTC_MASK),
62         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_32K, 0, MAX77620_IRQ_TOP_32K_MASK),
63         REGMAP_IRQ_REG(MAX77620_IRQ_TOP_ONOFF, 0, MAX77620_IRQ_TOP_ONOFF_MASK),
64         REGMAP_IRQ_REG(MAX77620_IRQ_LBT_MBATLOW, 1, MAX77620_IRQ_LBM_MASK),
65         REGMAP_IRQ_REG(MAX77620_IRQ_LBT_TJALRM1, 1, MAX77620_IRQ_TJALRM1_MASK),
66         REGMAP_IRQ_REG(MAX77620_IRQ_LBT_TJALRM2, 1, MAX77620_IRQ_TJALRM2_MASK),
67 };
68
69 static const struct mfd_cell max77620_children[] = {
70         { .name = "max77620-pinctrl", },
71         { .name = "max77620-clock", },
72         { .name = "max77620-pmic", },
73         { .name = "max77620-watchdog", },
74         {
75                 .name = "max77620-gpio",
76                 .resources = gpio_resources,
77                 .num_resources = ARRAY_SIZE(gpio_resources),
78         }, {
79                 .name = "max77620-rtc",
80                 .resources = rtc_resources,
81                 .num_resources = ARRAY_SIZE(rtc_resources),
82         }, {
83                 .name = "max77620-power",
84                 .resources = power_resources,
85                 .num_resources = ARRAY_SIZE(power_resources),
86         }, {
87                 .name = "max77620-thermal",
88                 .resources = thermal_resources,
89                 .num_resources = ARRAY_SIZE(thermal_resources),
90         },
91 };
92
93 static const struct mfd_cell max20024_children[] = {
94         { .name = "max20024-pinctrl", },
95         { .name = "max77620-clock", },
96         { .name = "max20024-pmic", },
97         { .name = "max77620-watchdog", },
98         {
99                 .name = "max77620-gpio",
100                 .resources = gpio_resources,
101                 .num_resources = ARRAY_SIZE(gpio_resources),
102         }, {
103                 .name = "max77620-rtc",
104                 .resources = rtc_resources,
105                 .num_resources = ARRAY_SIZE(rtc_resources),
106         }, {
107                 .name = "max20024-power",
108                 .resources = power_resources,
109                 .num_resources = ARRAY_SIZE(power_resources),
110         },
111 };
112
113 static const struct mfd_cell max77663_children[] = {
114         { .name = "max77620-pinctrl", },
115         { .name = "max77620-clock", },
116         { .name = "max77663-pmic", },
117         { .name = "max77620-watchdog", },
118         {
119                 .name = "max77620-gpio",
120                 .resources = gpio_resources,
121                 .num_resources = ARRAY_SIZE(gpio_resources),
122         }, {
123                 .name = "max77620-rtc",
124                 .resources = rtc_resources,
125                 .num_resources = ARRAY_SIZE(rtc_resources),
126         }, {
127                 .name = "max77663-power",
128                 .resources = power_resources,
129                 .num_resources = ARRAY_SIZE(power_resources),
130         },
131 };
132
133 static const struct regmap_range max77620_readable_ranges[] = {
134         regmap_reg_range(MAX77620_REG_CNFGGLBL1, MAX77620_REG_DVSSD4),
135 };
136
137 static const struct regmap_access_table max77620_readable_table = {
138         .yes_ranges = max77620_readable_ranges,
139         .n_yes_ranges = ARRAY_SIZE(max77620_readable_ranges),
140 };
141
142 static const struct regmap_range max20024_readable_ranges[] = {
143         regmap_reg_range(MAX77620_REG_CNFGGLBL1, MAX77620_REG_DVSSD4),
144         regmap_reg_range(MAX20024_REG_MAX_ADD, MAX20024_REG_MAX_ADD),
145 };
146
147 static const struct regmap_access_table max20024_readable_table = {
148         .yes_ranges = max20024_readable_ranges,
149         .n_yes_ranges = ARRAY_SIZE(max20024_readable_ranges),
150 };
151
152 static const struct regmap_range max77620_writable_ranges[] = {
153         regmap_reg_range(MAX77620_REG_CNFGGLBL1, MAX77620_REG_DVSSD4),
154 };
155
156 static const struct regmap_access_table max77620_writable_table = {
157         .yes_ranges = max77620_writable_ranges,
158         .n_yes_ranges = ARRAY_SIZE(max77620_writable_ranges),
159 };
160
161 static const struct regmap_range max77620_cacheable_ranges[] = {
162         regmap_reg_range(MAX77620_REG_SD0_CFG, MAX77620_REG_LDO_CFG3),
163         regmap_reg_range(MAX77620_REG_FPS_CFG0, MAX77620_REG_FPS_SD3),
164 };
165
166 static const struct regmap_access_table max77620_volatile_table = {
167         .no_ranges = max77620_cacheable_ranges,
168         .n_no_ranges = ARRAY_SIZE(max77620_cacheable_ranges),
169 };
170
171 static const struct regmap_config max77620_regmap_config = {
172         .name = "power-slave",
173         .reg_bits = 8,
174         .val_bits = 8,
175         .max_register = MAX77620_REG_DVSSD4 + 1,
176         .cache_type = REGCACHE_RBTREE,
177         .rd_table = &max77620_readable_table,
178         .wr_table = &max77620_writable_table,
179         .volatile_table = &max77620_volatile_table,
180         .use_single_write = true,
181 };
182
183 static const struct regmap_config max20024_regmap_config = {
184         .name = "power-slave",
185         .reg_bits = 8,
186         .val_bits = 8,
187         .max_register = MAX20024_REG_MAX_ADD + 1,
188         .cache_type = REGCACHE_RBTREE,
189         .rd_table = &max20024_readable_table,
190         .wr_table = &max77620_writable_table,
191         .volatile_table = &max77620_volatile_table,
192 };
193
194 static const struct regmap_range max77663_readable_ranges[] = {
195         regmap_reg_range(MAX77620_REG_CNFGGLBL1, MAX77620_REG_CID5),
196 };
197
198 static const struct regmap_access_table max77663_readable_table = {
199         .yes_ranges = max77663_readable_ranges,
200         .n_yes_ranges = ARRAY_SIZE(max77663_readable_ranges),
201 };
202
203 static const struct regmap_range max77663_writable_ranges[] = {
204         regmap_reg_range(MAX77620_REG_CNFGGLBL1, MAX77620_REG_CID5),
205 };
206
207 static const struct regmap_access_table max77663_writable_table = {
208         .yes_ranges = max77663_writable_ranges,
209         .n_yes_ranges = ARRAY_SIZE(max77663_writable_ranges),
210 };
211
212 static const struct regmap_config max77663_regmap_config = {
213         .name = "power-slave",
214         .reg_bits = 8,
215         .val_bits = 8,
216         .max_register = MAX77620_REG_CID5 + 1,
217         .cache_type = REGCACHE_RBTREE,
218         .rd_table = &max77663_readable_table,
219         .wr_table = &max77663_writable_table,
220         .volatile_table = &max77620_volatile_table,
221 };
222
223 /*
224  * MAX77620 and MAX20024 has the following steps of the interrupt handling
225  * for TOP interrupts:
226  * 1. When interrupt occurs from PMIC, mask the PMIC interrupt by setting GLBLM.
227  * 2. Read IRQTOP and service the interrupt.
228  * 3. Once all interrupts has been checked and serviced, the interrupt service
229  *    routine un-masks the hardware interrupt line by clearing GLBLM.
230  */
231 static int max77620_irq_global_mask(void *irq_drv_data)
232 {
233         struct max77620_chip *chip = irq_drv_data;
234         int ret;
235
236         ret = regmap_update_bits(chip->rmap, MAX77620_REG_INTENLBT,
237                                  MAX77620_GLBLM_MASK, MAX77620_GLBLM_MASK);
238         if (ret < 0)
239                 dev_err(chip->dev, "Failed to set GLBLM: %d\n", ret);
240
241         return ret;
242 }
243
244 static int max77620_irq_global_unmask(void *irq_drv_data)
245 {
246         struct max77620_chip *chip = irq_drv_data;
247         int ret;
248
249         ret = regmap_update_bits(chip->rmap, MAX77620_REG_INTENLBT,
250                                  MAX77620_GLBLM_MASK, 0);
251         if (ret < 0)
252                 dev_err(chip->dev, "Failed to reset GLBLM: %d\n", ret);
253
254         return ret;
255 }
256
257 static struct regmap_irq_chip max77620_top_irq_chip = {
258         .name = "max77620-top",
259         .irqs = max77620_top_irqs,
260         .num_irqs = ARRAY_SIZE(max77620_top_irqs),
261         .num_regs = 2,
262         .status_base = MAX77620_REG_IRQTOP,
263         .mask_base = MAX77620_REG_IRQTOPM,
264         .handle_pre_irq = max77620_irq_global_mask,
265         .handle_post_irq = max77620_irq_global_unmask,
266 };
267
268 /* max77620_get_fps_period_reg_value:  Get FPS bit field value from
269  *                                     requested periods.
270  * MAX77620 supports the FPS period of 40, 80, 160, 320, 540, 1280, 2560
271  * and 5120 microseconds. MAX20024 supports the FPS period of 20, 40, 80,
272  * 160, 320, 540, 1280 and 2560 microseconds.
273  * The FPS register has 3 bits field to set the FPS period as
274  * bits         max77620                max20024
275  * 000          40                      20
276  * 001          80                      40
277  * :::
278 */
279 static int max77620_get_fps_period_reg_value(struct max77620_chip *chip,
280                                              int tperiod)
281 {
282         int fps_min_period;
283         int i;
284
285         switch (chip->chip_id) {
286         case MAX20024:
287                 fps_min_period = MAX20024_FPS_PERIOD_MIN_US;
288                 break;
289         case MAX77620:
290                 fps_min_period = MAX77620_FPS_PERIOD_MIN_US;
291                 break;
292         case MAX77663:
293                 fps_min_period = MAX20024_FPS_PERIOD_MIN_US;
294                 break;
295         default:
296                 return -EINVAL;
297         }
298
299         for (i = 0; i < 7; i++) {
300                 if (fps_min_period >= tperiod)
301                         return i;
302                 fps_min_period *= 2;
303         }
304
305         return i;
306 }
307
308 /* max77620_config_fps: Configure FPS configuration registers
309  *                      based on platform specific information.
310  */
311 static int max77620_config_fps(struct max77620_chip *chip,
312                                struct device_node *fps_np)
313 {
314         struct device *dev = chip->dev;
315         unsigned int mask = 0, config = 0;
316         u32 fps_max_period;
317         u32 param_val;
318         int tperiod, fps_id;
319         int ret;
320         char fps_name[10];
321
322         switch (chip->chip_id) {
323         case MAX20024:
324                 fps_max_period = MAX20024_FPS_PERIOD_MAX_US;
325                 break;
326         case MAX77620:
327                 fps_max_period = MAX77620_FPS_PERIOD_MAX_US;
328                 break;
329         case MAX77663:
330                 fps_max_period = MAX20024_FPS_PERIOD_MAX_US;
331                 break;
332         default:
333                 return -EINVAL;
334         }
335
336         for (fps_id = 0; fps_id < MAX77620_FPS_COUNT; fps_id++) {
337                 sprintf(fps_name, "fps%d", fps_id);
338                 if (of_node_name_eq(fps_np, fps_name))
339                         break;
340         }
341
342         if (fps_id == MAX77620_FPS_COUNT) {
343                 dev_err(dev, "FPS node name %pOFn is not valid\n", fps_np);
344                 return -EINVAL;
345         }
346
347         ret = of_property_read_u32(fps_np, "maxim,shutdown-fps-time-period-us",
348                                    &param_val);
349         if (!ret) {
350                 mask |= MAX77620_FPS_TIME_PERIOD_MASK;
351                 chip->shutdown_fps_period[fps_id] = min(param_val,
352                                                         fps_max_period);
353                 tperiod = max77620_get_fps_period_reg_value(chip,
354                                 chip->shutdown_fps_period[fps_id]);
355                 config |= tperiod << MAX77620_FPS_TIME_PERIOD_SHIFT;
356         }
357
358         ret = of_property_read_u32(fps_np, "maxim,suspend-fps-time-period-us",
359                                    &param_val);
360         if (!ret)
361                 chip->suspend_fps_period[fps_id] = min(param_val,
362                                                        fps_max_period);
363
364         ret = of_property_read_u32(fps_np, "maxim,fps-event-source",
365                                    &param_val);
366         if (!ret) {
367                 if (param_val > 2) {
368                         dev_err(dev, "FPS%d event-source invalid\n", fps_id);
369                         return -EINVAL;
370                 }
371                 mask |= MAX77620_FPS_EN_SRC_MASK;
372                 config |= param_val << MAX77620_FPS_EN_SRC_SHIFT;
373                 if (param_val == 2) {
374                         mask |= MAX77620_FPS_ENFPS_SW_MASK;
375                         config |= MAX77620_FPS_ENFPS_SW;
376                 }
377         }
378
379         if (!chip->sleep_enable && !chip->enable_global_lpm) {
380                 ret = of_property_read_u32(fps_np,
381                                 "maxim,device-state-on-disabled-event",
382                                 &param_val);
383                 if (!ret) {
384                         if (param_val == 0)
385                                 chip->sleep_enable = true;
386                         else if (param_val == 1)
387                                 chip->enable_global_lpm = true;
388                 }
389         }
390
391         ret = regmap_update_bits(chip->rmap, MAX77620_REG_FPS_CFG0 + fps_id,
392                                  mask, config);
393         if (ret < 0) {
394                 dev_err(dev, "Failed to update FPS CFG: %d\n", ret);
395                 return ret;
396         }
397
398         return 0;
399 }
400
401 static int max77620_initialise_fps(struct max77620_chip *chip)
402 {
403         struct device *dev = chip->dev;
404         struct device_node *fps_np, *fps_child;
405         u8 config;
406         int fps_id;
407         int ret;
408
409         for (fps_id = 0; fps_id < MAX77620_FPS_COUNT; fps_id++) {
410                 chip->shutdown_fps_period[fps_id] = -1;
411                 chip->suspend_fps_period[fps_id] = -1;
412         }
413
414         fps_np = of_get_child_by_name(dev->of_node, "fps");
415         if (!fps_np)
416                 goto skip_fps;
417
418         for_each_child_of_node(fps_np, fps_child) {
419                 ret = max77620_config_fps(chip, fps_child);
420                 if (ret < 0) {
421                         of_node_put(fps_child);
422                         of_node_put(fps_np);
423                         return ret;
424                 }
425         }
426         of_node_put(fps_np);
427
428         config = chip->enable_global_lpm ? MAX77620_ONOFFCNFG2_SLP_LPM_MSK : 0;
429         ret = regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG2,
430                                  MAX77620_ONOFFCNFG2_SLP_LPM_MSK, config);
431         if (ret < 0) {
432                 dev_err(dev, "Failed to update SLP_LPM: %d\n", ret);
433                 return ret;
434         }
435
436 skip_fps:
437         if (chip->chip_id == MAX77663)
438                 return 0;
439
440         /* Enable wake on EN0 pin */
441         ret = regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG2,
442                                  MAX77620_ONOFFCNFG2_WK_EN0,
443                                  MAX77620_ONOFFCNFG2_WK_EN0);
444         if (ret < 0) {
445                 dev_err(dev, "Failed to update WK_EN0: %d\n", ret);
446                 return ret;
447         }
448
449         /* For MAX20024, SLPEN will be POR reset if CLRSE is b11 */
450         if ((chip->chip_id == MAX20024) && chip->sleep_enable) {
451                 config = MAX77620_ONOFFCNFG1_SLPEN | MAX20024_ONOFFCNFG1_CLRSE;
452                 ret = regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG1,
453                                          config, config);
454                 if (ret < 0) {
455                         dev_err(dev, "Failed to update SLPEN: %d\n", ret);
456                         return ret;
457                 }
458         }
459
460         return 0;
461 }
462
463 static int max77620_read_es_version(struct max77620_chip *chip)
464 {
465         unsigned int val;
466         u8 cid_val[6];
467         int i;
468         int ret;
469
470         for (i = MAX77620_REG_CID0; i <= MAX77620_REG_CID5; i++) {
471                 ret = regmap_read(chip->rmap, i, &val);
472                 if (ret < 0) {
473                         dev_err(chip->dev, "Failed to read CID: %d\n", ret);
474                         return ret;
475                 }
476                 dev_dbg(chip->dev, "CID%d: 0x%02x\n",
477                         i - MAX77620_REG_CID0, val);
478                 cid_val[i - MAX77620_REG_CID0] = val;
479         }
480
481         /* CID4 is OTP Version  and CID5 is ES version */
482         dev_info(chip->dev, "PMIC Version OTP:0x%02X and ES:0x%X\n",
483                  cid_val[4], MAX77620_CID5_DIDM(cid_val[5]));
484
485         return ret;
486 }
487
488 static void max77620_pm_power_off(void)
489 {
490         struct max77620_chip *chip = max77620_scratch;
491
492         regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG1,
493                            MAX77620_ONOFFCNFG1_SFT_RST,
494                            MAX77620_ONOFFCNFG1_SFT_RST);
495 }
496
497 static int max77620_probe(struct i2c_client *client,
498                           const struct i2c_device_id *id)
499 {
500         const struct regmap_config *rmap_config;
501         struct max77620_chip *chip;
502         const struct mfd_cell *mfd_cells;
503         int n_mfd_cells;
504         bool pm_off;
505         int ret;
506
507         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
508         if (!chip)
509                 return -ENOMEM;
510
511         i2c_set_clientdata(client, chip);
512         chip->dev = &client->dev;
513         chip->chip_irq = client->irq;
514         chip->chip_id = (enum max77620_chip_id)id->driver_data;
515
516         switch (chip->chip_id) {
517         case MAX77620:
518                 mfd_cells = max77620_children;
519                 n_mfd_cells = ARRAY_SIZE(max77620_children);
520                 rmap_config = &max77620_regmap_config;
521                 break;
522         case MAX20024:
523                 mfd_cells = max20024_children;
524                 n_mfd_cells = ARRAY_SIZE(max20024_children);
525                 rmap_config = &max20024_regmap_config;
526                 break;
527         case MAX77663:
528                 mfd_cells = max77663_children;
529                 n_mfd_cells = ARRAY_SIZE(max77663_children);
530                 rmap_config = &max77663_regmap_config;
531                 break;
532         default:
533                 dev_err(chip->dev, "ChipID is invalid %d\n", chip->chip_id);
534                 return -EINVAL;
535         }
536
537         chip->rmap = devm_regmap_init_i2c(client, rmap_config);
538         if (IS_ERR(chip->rmap)) {
539                 ret = PTR_ERR(chip->rmap);
540                 dev_err(chip->dev, "Failed to initialise regmap: %d\n", ret);
541                 return ret;
542         }
543
544         ret = max77620_read_es_version(chip);
545         if (ret < 0)
546                 return ret;
547
548         max77620_top_irq_chip.irq_drv_data = chip;
549         ret = devm_regmap_add_irq_chip(chip->dev, chip->rmap, client->irq,
550                                        IRQF_ONESHOT | IRQF_SHARED, 0,
551                                        &max77620_top_irq_chip,
552                                        &chip->top_irq_data);
553         if (ret < 0) {
554                 dev_err(chip->dev, "Failed to add regmap irq: %d\n", ret);
555                 return ret;
556         }
557
558         ret = max77620_initialise_fps(chip);
559         if (ret < 0)
560                 return ret;
561
562         ret =  devm_mfd_add_devices(chip->dev, PLATFORM_DEVID_NONE,
563                                     mfd_cells, n_mfd_cells, NULL, 0,
564                                     regmap_irq_get_domain(chip->top_irq_data));
565         if (ret < 0) {
566                 dev_err(chip->dev, "Failed to add MFD children: %d\n", ret);
567                 return ret;
568         }
569
570         pm_off = of_device_is_system_power_controller(client->dev.of_node);
571         if (pm_off && !pm_power_off) {
572                 max77620_scratch = chip;
573                 pm_power_off = max77620_pm_power_off;
574         }
575
576         return 0;
577 }
578
579 #ifdef CONFIG_PM_SLEEP
580 static int max77620_set_fps_period(struct max77620_chip *chip,
581                                    int fps_id, int time_period)
582 {
583         int period = max77620_get_fps_period_reg_value(chip, time_period);
584         int ret;
585
586         ret = regmap_update_bits(chip->rmap, MAX77620_REG_FPS_CFG0 + fps_id,
587                                  MAX77620_FPS_TIME_PERIOD_MASK,
588                                  period << MAX77620_FPS_TIME_PERIOD_SHIFT);
589         if (ret < 0) {
590                 dev_err(chip->dev, "Failed to update FPS period: %d\n", ret);
591                 return ret;
592         }
593
594         return 0;
595 }
596
597 static int max77620_i2c_suspend(struct device *dev)
598 {
599         struct max77620_chip *chip = dev_get_drvdata(dev);
600         struct i2c_client *client = to_i2c_client(dev);
601         unsigned int config;
602         int fps;
603         int ret;
604
605         for (fps = 0; fps < MAX77620_FPS_COUNT; fps++) {
606                 if (chip->suspend_fps_period[fps] < 0)
607                         continue;
608
609                 ret = max77620_set_fps_period(chip, fps,
610                                               chip->suspend_fps_period[fps]);
611                 if (ret < 0)
612                         return ret;
613         }
614
615         /*
616          * For MAX20024: No need to configure SLPEN on suspend as
617          * it will be configured on Init.
618          */
619         if (chip->chip_id == MAX20024)
620                 goto out;
621
622         config = (chip->sleep_enable) ? MAX77620_ONOFFCNFG1_SLPEN : 0;
623         ret = regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG1,
624                                  MAX77620_ONOFFCNFG1_SLPEN,
625                                  config);
626         if (ret < 0) {
627                 dev_err(dev, "Failed to configure sleep in suspend: %d\n", ret);
628                 return ret;
629         }
630
631         if (chip->chip_id == MAX77663)
632                 goto out;
633
634         /* Disable WK_EN0 */
635         ret = regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG2,
636                                  MAX77620_ONOFFCNFG2_WK_EN0, 0);
637         if (ret < 0) {
638                 dev_err(dev, "Failed to configure WK_EN in suspend: %d\n", ret);
639                 return ret;
640         }
641
642 out:
643         disable_irq(client->irq);
644
645         return 0;
646 }
647
648 static int max77620_i2c_resume(struct device *dev)
649 {
650         struct max77620_chip *chip = dev_get_drvdata(dev);
651         struct i2c_client *client = to_i2c_client(dev);
652         int ret;
653         int fps;
654
655         for (fps = 0; fps < MAX77620_FPS_COUNT; fps++) {
656                 if (chip->shutdown_fps_period[fps] < 0)
657                         continue;
658
659                 ret = max77620_set_fps_period(chip, fps,
660                                               chip->shutdown_fps_period[fps]);
661                 if (ret < 0)
662                         return ret;
663         }
664
665         /*
666          * For MAX20024: No need to configure WKEN0 on resume as
667          * it is configured on Init.
668          */
669         if (chip->chip_id == MAX20024 || chip->chip_id == MAX77663)
670                 goto out;
671
672         /* Enable WK_EN0 */
673         ret = regmap_update_bits(chip->rmap, MAX77620_REG_ONOFFCNFG2,
674                                  MAX77620_ONOFFCNFG2_WK_EN0,
675                                  MAX77620_ONOFFCNFG2_WK_EN0);
676         if (ret < 0) {
677                 dev_err(dev, "Failed to configure WK_EN0 n resume: %d\n", ret);
678                 return ret;
679         }
680
681 out:
682         enable_irq(client->irq);
683
684         return 0;
685 }
686 #endif
687
688 static const struct i2c_device_id max77620_id[] = {
689         {"max77620", MAX77620},
690         {"max20024", MAX20024},
691         {"max77663", MAX77663},
692         {},
693 };
694
695 static const struct dev_pm_ops max77620_pm_ops = {
696         SET_SYSTEM_SLEEP_PM_OPS(max77620_i2c_suspend, max77620_i2c_resume)
697 };
698
699 static struct i2c_driver max77620_driver = {
700         .driver = {
701                 .name = "max77620",
702                 .pm = &max77620_pm_ops,
703         },
704         .probe = max77620_probe,
705         .id_table = max77620_id,
706 };
707 builtin_i2c_driver(max77620_driver);