2 * da9211-regulator.c - Regulator device driver for DA9211/DA9212
3 * /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225
4 * Copyright (C) 2015 Dialog Semiconductor Ltd.
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
17 #include <linux/err.h>
18 #include <linux/gpio.h>
19 #include <linux/i2c.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/slab.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regmap.h>
26 #include <linux/irq.h>
27 #include <linux/interrupt.h>
28 #include <linux/of_gpio.h>
29 #include <linux/regulator/of_regulator.h>
30 #include <linux/regulator/da9211.h>
31 #include "da9211-regulator.h"
34 #define DA9211_DEVICE_ID 0x22
35 #define DA9213_DEVICE_ID 0x23
36 #define DA9215_DEVICE_ID 0x24
38 #define DA9211_BUCK_MODE_SLEEP 1
39 #define DA9211_BUCK_MODE_SYNC 2
40 #define DA9211_BUCK_MODE_AUTO 3
42 /* DA9211 REGULATOR IDs */
43 #define DA9211_ID_BUCKA 0
44 #define DA9211_ID_BUCKB 1
48 struct regmap
*regmap
;
49 struct da9211_pdata
*pdata
;
50 struct regulator_dev
*rdev
[DA9211_MAX_REGULATORS
];
56 static const struct regmap_range_cfg da9211_regmap_range
[] = {
58 .selector_reg
= DA9211_REG_PAGE_CON
,
59 .selector_mask
= DA9211_REG_PAGE_MASK
,
60 .selector_shift
= DA9211_REG_PAGE_SHIFT
,
68 static const struct regmap_config da9211_regmap_config
= {
71 .max_register
= 5 * 128,
72 .ranges
= da9211_regmap_range
,
73 .num_ranges
= ARRAY_SIZE(da9211_regmap_range
),
76 /* Default limits measured in millivolts and milliamps */
77 #define DA9211_MIN_MV 300
78 #define DA9211_MAX_MV 1570
79 #define DA9211_STEP_MV 10
81 /* Current limits for DA9211 buck (uA) indices
82 * corresponds with register values
84 static const int da9211_current_limits
[] = {
85 2000000, 2200000, 2400000, 2600000, 2800000, 3000000, 3200000, 3400000,
86 3600000, 3800000, 4000000, 4200000, 4400000, 4600000, 4800000, 5000000
88 /* Current limits for DA9213 buck (uA) indices
89 * corresponds with register values
91 static const int da9213_current_limits
[] = {
92 3000000, 3200000, 3400000, 3600000, 3800000, 4000000, 4200000, 4400000,
93 4600000, 4800000, 5000000, 5200000, 5400000, 5600000, 5800000, 6000000
95 /* Current limits for DA9215 buck (uA) indices
96 * corresponds with register values
98 static const int da9215_current_limits
[] = {
99 4000000, 4200000, 4400000, 4600000, 4800000, 5000000, 5200000, 5400000,
100 5600000, 5800000, 6000000, 6200000, 6400000, 6600000, 6800000, 7000000
103 static unsigned int da9211_buck_get_mode(struct regulator_dev
*rdev
)
105 int id
= rdev_get_id(rdev
);
106 struct da9211
*chip
= rdev_get_drvdata(rdev
);
110 ret
= regmap_read(chip
->regmap
, DA9211_REG_BUCKA_CONF
+id
, &data
);
114 switch (data
& 0x03) {
115 case DA9211_BUCK_MODE_SYNC
:
116 mode
= REGULATOR_MODE_FAST
;
118 case DA9211_BUCK_MODE_AUTO
:
119 mode
= REGULATOR_MODE_NORMAL
;
121 case DA9211_BUCK_MODE_SLEEP
:
122 mode
= REGULATOR_MODE_STANDBY
;
129 static int da9211_buck_set_mode(struct regulator_dev
*rdev
,
132 int id
= rdev_get_id(rdev
);
133 struct da9211
*chip
= rdev_get_drvdata(rdev
);
137 case REGULATOR_MODE_FAST
:
138 val
= DA9211_BUCK_MODE_SYNC
;
140 case REGULATOR_MODE_NORMAL
:
141 val
= DA9211_BUCK_MODE_AUTO
;
143 case REGULATOR_MODE_STANDBY
:
144 val
= DA9211_BUCK_MODE_SLEEP
;
148 return regmap_update_bits(chip
->regmap
, DA9211_REG_BUCKA_CONF
+id
,
152 static int da9211_set_current_limit(struct regulator_dev
*rdev
, int min
,
155 int id
= rdev_get_id(rdev
);
156 struct da9211
*chip
= rdev_get_drvdata(rdev
);
158 const int *current_limits
;
160 switch (chip
->chip_id
) {
162 current_limits
= da9211_current_limits
;
163 max_size
= ARRAY_SIZE(da9211_current_limits
)-1;
166 current_limits
= da9213_current_limits
;
167 max_size
= ARRAY_SIZE(da9213_current_limits
)-1;
170 current_limits
= da9215_current_limits
;
171 max_size
= ARRAY_SIZE(da9215_current_limits
)-1;
177 /* search for closest to maximum */
178 for (i
= max_size
; i
>= 0; i
--) {
179 if (min
<= current_limits
[i
] &&
180 max
>= current_limits
[i
]) {
181 return regmap_update_bits(chip
->regmap
,
182 DA9211_REG_BUCK_ILIM
,
183 (0x0F << id
*4), (i
<< id
*4));
190 static int da9211_get_current_limit(struct regulator_dev
*rdev
)
192 int id
= rdev_get_id(rdev
);
193 struct da9211
*chip
= rdev_get_drvdata(rdev
);
196 const int *current_limits
;
198 switch (chip
->chip_id
) {
200 current_limits
= da9211_current_limits
;
203 current_limits
= da9213_current_limits
;
206 current_limits
= da9215_current_limits
;
212 ret
= regmap_read(chip
->regmap
, DA9211_REG_BUCK_ILIM
, &data
);
216 /* select one of 16 values: 0000 (2000mA or 3000mA)
217 * to 1111 (5000mA or 6000mA).
219 data
= (data
>> id
*4) & 0x0F;
220 return current_limits
[data
];
223 static const struct regulator_ops da9211_buck_ops
= {
224 .get_mode
= da9211_buck_get_mode
,
225 .set_mode
= da9211_buck_set_mode
,
226 .enable
= regulator_enable_regmap
,
227 .disable
= regulator_disable_regmap
,
228 .is_enabled
= regulator_is_enabled_regmap
,
229 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
230 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
231 .list_voltage
= regulator_list_voltage_linear
,
232 .set_current_limit
= da9211_set_current_limit
,
233 .get_current_limit
= da9211_get_current_limit
,
236 #define DA9211_BUCK(_id) \
239 .ops = &da9211_buck_ops,\
240 .type = REGULATOR_VOLTAGE,\
241 .id = DA9211_ID_##_id,\
242 .n_voltages = (DA9211_MAX_MV - DA9211_MIN_MV) / DA9211_STEP_MV + 1,\
243 .min_uV = (DA9211_MIN_MV * 1000),\
244 .uV_step = (DA9211_STEP_MV * 1000),\
245 .enable_reg = DA9211_REG_BUCKA_CONT + DA9211_ID_##_id,\
246 .enable_mask = DA9211_BUCKA_EN,\
247 .vsel_reg = DA9211_REG_VBUCKA_A + DA9211_ID_##_id * 2,\
248 .vsel_mask = DA9211_VBUCK_MASK,\
249 .owner = THIS_MODULE,\
252 static struct regulator_desc da9211_regulators
[] = {
258 static struct of_regulator_match da9211_matches
[] = {
259 [DA9211_ID_BUCKA
] = { .name
= "BUCKA" },
260 [DA9211_ID_BUCKB
] = { .name
= "BUCKB" },
263 static struct da9211_pdata
*da9211_parse_regulators_dt(
266 struct da9211_pdata
*pdata
;
267 struct device_node
*node
;
270 node
= of_get_child_by_name(dev
->of_node
, "regulators");
272 dev_err(dev
, "regulators node not found\n");
273 return ERR_PTR(-ENODEV
);
276 num
= of_regulator_match(dev
, node
, da9211_matches
,
277 ARRAY_SIZE(da9211_matches
));
280 dev_err(dev
, "Failed to match regulators\n");
281 return ERR_PTR(-EINVAL
);
284 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
286 return ERR_PTR(-ENOMEM
);
288 pdata
->num_buck
= num
;
291 for (i
= 0; i
< ARRAY_SIZE(da9211_matches
); i
++) {
292 if (!da9211_matches
[i
].init_data
)
295 pdata
->init_data
[n
] = da9211_matches
[i
].init_data
;
296 pdata
->reg_node
[n
] = da9211_matches
[i
].of_node
;
298 of_get_named_gpio(da9211_matches
[i
].of_node
,
306 static struct da9211_pdata
*da9211_parse_regulators_dt(
309 return ERR_PTR(-ENODEV
);
313 static irqreturn_t
da9211_irq_handler(int irq
, void *data
)
315 struct da9211
*chip
= data
;
316 int reg_val
, err
, ret
= IRQ_NONE
;
318 err
= regmap_read(chip
->regmap
, DA9211_REG_EVENT_B
, ®_val
);
322 if (reg_val
& DA9211_E_OV_CURR_A
) {
323 regulator_notifier_call_chain(chip
->rdev
[0],
324 REGULATOR_EVENT_OVER_CURRENT
, NULL
);
326 err
= regmap_write(chip
->regmap
, DA9211_REG_EVENT_B
,
334 if (reg_val
& DA9211_E_OV_CURR_B
) {
335 regulator_notifier_call_chain(chip
->rdev
[1],
336 REGULATOR_EVENT_OVER_CURRENT
, NULL
);
338 err
= regmap_write(chip
->regmap
, DA9211_REG_EVENT_B
,
349 dev_err(chip
->dev
, "I2C error : %d\n", err
);
353 static int da9211_regulator_init(struct da9211
*chip
)
355 struct regulator_config config
= { };
359 ret
= regmap_read(chip
->regmap
, DA9211_REG_CONFIG_E
, &data
);
361 dev_err(chip
->dev
, "Failed to read CONFIG_E reg: %d\n", ret
);
365 data
&= DA9211_SLAVE_SEL
;
366 /* If configuration for 1/2 bucks is different between platform data
367 * and the register, driver should exit.
369 if (chip
->pdata
->num_buck
== 1 && data
== 0x00)
370 chip
->num_regulator
= 1;
371 else if (chip
->pdata
->num_buck
== 2 && data
!= 0x00)
372 chip
->num_regulator
= 2;
374 dev_err(chip
->dev
, "Configuration is mismatched\n");
378 for (i
= 0; i
< chip
->num_regulator
; i
++) {
379 config
.init_data
= chip
->pdata
->init_data
[i
];
380 config
.dev
= chip
->dev
;
381 config
.driver_data
= chip
;
382 config
.regmap
= chip
->regmap
;
383 config
.of_node
= chip
->pdata
->reg_node
[i
];
385 if (gpio_is_valid(chip
->pdata
->gpio_ren
[i
])) {
386 config
.ena_gpio
= chip
->pdata
->gpio_ren
[i
];
387 config
.ena_gpio_initialized
= true;
389 config
.ena_gpio
= -EINVAL
;
390 config
.ena_gpio_initialized
= false;
393 chip
->rdev
[i
] = devm_regulator_register(chip
->dev
,
394 &da9211_regulators
[i
], &config
);
395 if (IS_ERR(chip
->rdev
[i
])) {
397 "Failed to register DA9211 regulator\n");
398 return PTR_ERR(chip
->rdev
[i
]);
401 if (chip
->chip_irq
!= 0) {
402 ret
= regmap_update_bits(chip
->regmap
,
403 DA9211_REG_MASK_B
, DA9211_M_OV_CURR_A
<< i
, 0);
406 "Failed to update mask reg: %d\n", ret
);
416 * I2C driver interface functions
418 static int da9211_i2c_probe(struct i2c_client
*i2c
,
419 const struct i2c_device_id
*id
)
425 chip
= devm_kzalloc(&i2c
->dev
, sizeof(struct da9211
), GFP_KERNEL
);
429 chip
->dev
= &i2c
->dev
;
430 chip
->regmap
= devm_regmap_init_i2c(i2c
, &da9211_regmap_config
);
431 if (IS_ERR(chip
->regmap
)) {
432 error
= PTR_ERR(chip
->regmap
);
433 dev_err(chip
->dev
, "Failed to allocate register map: %d\n",
438 i2c_set_clientdata(i2c
, chip
);
440 chip
->pdata
= i2c
->dev
.platform_data
;
442 ret
= regmap_read(chip
->regmap
, DA9211_REG_DEVICE_ID
, &data
);
444 dev_err(chip
->dev
, "Failed to read DEVICE_ID reg: %d\n", ret
);
449 case DA9211_DEVICE_ID
:
450 chip
->chip_id
= DA9211
;
452 case DA9213_DEVICE_ID
:
453 chip
->chip_id
= DA9213
;
455 case DA9215_DEVICE_ID
:
456 chip
->chip_id
= DA9215
;
459 dev_err(chip
->dev
, "Unsupported device id = 0x%x.\n", data
);
464 chip
->pdata
= da9211_parse_regulators_dt(chip
->dev
);
466 if (IS_ERR(chip
->pdata
)) {
467 dev_err(chip
->dev
, "No regulators defined for the platform\n");
468 return PTR_ERR(chip
->pdata
);
471 chip
->chip_irq
= i2c
->irq
;
473 if (chip
->chip_irq
!= 0) {
474 ret
= devm_request_threaded_irq(chip
->dev
, chip
->chip_irq
, NULL
,
476 IRQF_TRIGGER_LOW
|IRQF_ONESHOT
,
479 dev_err(chip
->dev
, "Failed to request IRQ: %d\n",
484 dev_warn(chip
->dev
, "No IRQ configured\n");
487 ret
= da9211_regulator_init(chip
);
490 dev_err(chip
->dev
, "Failed to initialize regulator: %d\n", ret
);
495 static const struct i2c_device_id da9211_i2c_id
[] = {
506 MODULE_DEVICE_TABLE(i2c
, da9211_i2c_id
);
509 static const struct of_device_id da9211_dt_ids
[] = {
510 { .compatible
= "dlg,da9211", .data
= &da9211_i2c_id
[0] },
511 { .compatible
= "dlg,da9212", .data
= &da9211_i2c_id
[1] },
512 { .compatible
= "dlg,da9213", .data
= &da9211_i2c_id
[2] },
513 { .compatible
= "dlg,da9223", .data
= &da9211_i2c_id
[3] },
514 { .compatible
= "dlg,da9214", .data
= &da9211_i2c_id
[4] },
515 { .compatible
= "dlg,da9224", .data
= &da9211_i2c_id
[5] },
516 { .compatible
= "dlg,da9215", .data
= &da9211_i2c_id
[6] },
517 { .compatible
= "dlg,da9225", .data
= &da9211_i2c_id
[7] },
520 MODULE_DEVICE_TABLE(of
, da9211_dt_ids
);
523 static struct i2c_driver da9211_regulator_driver
= {
526 .of_match_table
= of_match_ptr(da9211_dt_ids
),
528 .probe
= da9211_i2c_probe
,
529 .id_table
= da9211_i2c_id
,
532 module_i2c_driver(da9211_regulator_driver
);
534 MODULE_AUTHOR("James Ban <James.Ban.opensource@diasemi.com>");
535 MODULE_DESCRIPTION("DA9211/DA9212/DA9213/DA9223/DA9214/DA9224/DA9215/DA9225 regulator driver");
536 MODULE_LICENSE("GPL");