2 * da9211-regulator.c - Regulator device driver for DA9211/DA9213
3 * Copyright (C) 2014 Dialog Semiconductor Ltd.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
16 #include <linux/err.h>
17 #include <linux/gpio.h>
18 #include <linux/i2c.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/regulator/driver.h>
23 #include <linux/regulator/machine.h>
24 #include <linux/regmap.h>
25 #include <linux/irq.h>
26 #include <linux/interrupt.h>
27 #include <linux/of_gpio.h>
28 #include <linux/regulator/of_regulator.h>
29 #include <linux/regulator/da9211.h>
30 #include "da9211-regulator.h"
33 #define DA9211_DEVICE_ID 0x22
34 #define DA9213_DEVICE_ID 0x23
36 #define DA9211_BUCK_MODE_SLEEP 1
37 #define DA9211_BUCK_MODE_SYNC 2
38 #define DA9211_BUCK_MODE_AUTO 3
40 /* DA9211 REGULATOR IDs */
41 #define DA9211_ID_BUCKA 0
42 #define DA9211_ID_BUCKB 1
46 struct regmap
*regmap
;
47 struct da9211_pdata
*pdata
;
48 struct regulator_dev
*rdev
[DA9211_MAX_REGULATORS
];
54 static const struct regmap_range_cfg da9211_regmap_range
[] = {
56 .selector_reg
= DA9211_REG_PAGE_CON
,
57 .selector_mask
= DA9211_REG_PAGE_MASK
,
58 .selector_shift
= DA9211_REG_PAGE_SHIFT
,
66 static const struct regmap_config da9211_regmap_config
= {
69 .max_register
= 5 * 128,
70 .ranges
= da9211_regmap_range
,
71 .num_ranges
= ARRAY_SIZE(da9211_regmap_range
),
74 /* Default limits measured in millivolts and milliamps */
75 #define DA9211_MIN_MV 300
76 #define DA9211_MAX_MV 1570
77 #define DA9211_STEP_MV 10
79 /* Current limits for DA9211 buck (uA) indices
80 * corresponds with register values
82 static const int da9211_current_limits
[] = {
83 2000000, 2200000, 2400000, 2600000, 2800000, 3000000, 3200000, 3400000,
84 3600000, 3800000, 4000000, 4200000, 4400000, 4600000, 4800000, 5000000
86 /* Current limits for DA9213 buck (uA) indices
87 * corresponds with register values
89 static const int da9213_current_limits
[] = {
90 3000000, 3200000, 3400000, 3600000, 3800000, 4000000, 4200000, 4400000,
91 4600000, 4800000, 5000000, 5200000, 5400000, 5600000, 5800000, 6000000
94 static unsigned int da9211_buck_get_mode(struct regulator_dev
*rdev
)
96 int id
= rdev_get_id(rdev
);
97 struct da9211
*chip
= rdev_get_drvdata(rdev
);
101 ret
= regmap_read(chip
->regmap
, DA9211_REG_BUCKA_CONF
+id
, &data
);
105 switch (data
& 0x03) {
106 case DA9211_BUCK_MODE_SYNC
:
107 mode
= REGULATOR_MODE_FAST
;
109 case DA9211_BUCK_MODE_AUTO
:
110 mode
= REGULATOR_MODE_NORMAL
;
112 case DA9211_BUCK_MODE_SLEEP
:
113 mode
= REGULATOR_MODE_STANDBY
;
120 static int da9211_buck_set_mode(struct regulator_dev
*rdev
,
123 int id
= rdev_get_id(rdev
);
124 struct da9211
*chip
= rdev_get_drvdata(rdev
);
128 case REGULATOR_MODE_FAST
:
129 val
= DA9211_BUCK_MODE_SYNC
;
131 case REGULATOR_MODE_NORMAL
:
132 val
= DA9211_BUCK_MODE_AUTO
;
134 case REGULATOR_MODE_STANDBY
:
135 val
= DA9211_BUCK_MODE_SLEEP
;
139 return regmap_update_bits(chip
->regmap
, DA9211_REG_BUCKA_CONF
+id
,
143 static int da9211_set_current_limit(struct regulator_dev
*rdev
, int min
,
146 int id
= rdev_get_id(rdev
);
147 struct da9211
*chip
= rdev_get_drvdata(rdev
);
149 const int *current_limits
;
151 switch (chip
->chip_id
) {
153 current_limits
= da9211_current_limits
;
154 max_size
= ARRAY_SIZE(da9211_current_limits
)-1;
157 current_limits
= da9213_current_limits
;
158 max_size
= ARRAY_SIZE(da9213_current_limits
)-1;
164 /* search for closest to maximum */
165 for (i
= max_size
; i
>= 0; i
--) {
166 if (min
<= current_limits
[i
] &&
167 max
>= current_limits
[i
]) {
168 return regmap_update_bits(chip
->regmap
,
169 DA9211_REG_BUCK_ILIM
,
170 (0x0F << id
*4), (i
<< id
*4));
177 static int da9211_get_current_limit(struct regulator_dev
*rdev
)
179 int id
= rdev_get_id(rdev
);
180 struct da9211
*chip
= rdev_get_drvdata(rdev
);
183 const int *current_limits
;
185 switch (chip
->chip_id
) {
187 current_limits
= da9211_current_limits
;
190 current_limits
= da9213_current_limits
;
196 ret
= regmap_read(chip
->regmap
, DA9211_REG_BUCK_ILIM
, &data
);
200 /* select one of 16 values: 0000 (2000mA or 3000mA)
201 * to 1111 (5000mA or 6000mA).
203 data
= (data
>> id
*4) & 0x0F;
204 return current_limits
[data
];
207 static struct regulator_ops da9211_buck_ops
= {
208 .get_mode
= da9211_buck_get_mode
,
209 .set_mode
= da9211_buck_set_mode
,
210 .enable
= regulator_enable_regmap
,
211 .disable
= regulator_disable_regmap
,
212 .is_enabled
= regulator_is_enabled_regmap
,
213 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
214 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
215 .list_voltage
= regulator_list_voltage_linear
,
216 .set_current_limit
= da9211_set_current_limit
,
217 .get_current_limit
= da9211_get_current_limit
,
220 #define DA9211_BUCK(_id) \
223 .ops = &da9211_buck_ops,\
224 .type = REGULATOR_VOLTAGE,\
225 .id = DA9211_ID_##_id,\
226 .n_voltages = (DA9211_MAX_MV - DA9211_MIN_MV) / DA9211_STEP_MV + 1,\
227 .min_uV = (DA9211_MIN_MV * 1000),\
228 .uV_step = (DA9211_STEP_MV * 1000),\
229 .enable_reg = DA9211_REG_BUCKA_CONT + DA9211_ID_##_id,\
230 .enable_mask = DA9211_BUCKA_EN,\
231 .vsel_reg = DA9211_REG_VBUCKA_A + DA9211_ID_##_id * 2,\
232 .vsel_mask = DA9211_VBUCK_MASK,\
233 .owner = THIS_MODULE,\
236 static struct regulator_desc da9211_regulators
[] = {
242 static struct of_regulator_match da9211_matches
[] = {
243 [DA9211_ID_BUCKA
] = { .name
= "BUCKA" },
244 [DA9211_ID_BUCKB
] = { .name
= "BUCKB" },
247 static struct da9211_pdata
*da9211_parse_regulators_dt(
250 struct da9211_pdata
*pdata
;
251 struct device_node
*node
;
254 node
= of_get_child_by_name(dev
->of_node
, "regulators");
256 dev_err(dev
, "regulators node not found\n");
257 return ERR_PTR(-ENODEV
);
260 num
= of_regulator_match(dev
, node
, da9211_matches
,
261 ARRAY_SIZE(da9211_matches
));
264 dev_err(dev
, "Failed to match regulators\n");
265 return ERR_PTR(-EINVAL
);
268 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
270 return ERR_PTR(-ENOMEM
);
272 pdata
->num_buck
= num
;
275 for (i
= 0; i
< ARRAY_SIZE(da9211_matches
); i
++) {
276 if (!da9211_matches
[i
].init_data
)
279 pdata
->init_data
[n
] = da9211_matches
[i
].init_data
;
280 pdata
->reg_node
[n
] = da9211_matches
[i
].of_node
;
282 of_get_named_gpio(da9211_matches
[i
].of_node
,
290 static struct da9211_pdata
*da9211_parse_regulators_dt(
293 return ERR_PTR(-ENODEV
);
297 static irqreturn_t
da9211_irq_handler(int irq
, void *data
)
299 struct da9211
*chip
= data
;
300 int reg_val
, err
, ret
= IRQ_NONE
;
302 err
= regmap_read(chip
->regmap
, DA9211_REG_EVENT_B
, ®_val
);
306 if (reg_val
& DA9211_E_OV_CURR_A
) {
307 regulator_notifier_call_chain(chip
->rdev
[0],
308 REGULATOR_EVENT_OVER_CURRENT
, NULL
);
310 err
= regmap_write(chip
->regmap
, DA9211_REG_EVENT_B
,
318 if (reg_val
& DA9211_E_OV_CURR_B
) {
319 regulator_notifier_call_chain(chip
->rdev
[1],
320 REGULATOR_EVENT_OVER_CURRENT
, NULL
);
322 err
= regmap_write(chip
->regmap
, DA9211_REG_EVENT_B
,
333 dev_err(chip
->dev
, "I2C error : %d\n", err
);
337 static int da9211_regulator_init(struct da9211
*chip
)
339 struct regulator_config config
= { };
343 ret
= regmap_read(chip
->regmap
, DA9211_REG_CONFIG_E
, &data
);
345 dev_err(chip
->dev
, "Failed to read CONFIG_E reg: %d\n", ret
);
349 data
&= DA9211_SLAVE_SEL
;
350 /* If configuration for 1/2 bucks is different between platform data
351 * and the register, driver should exit.
353 if ((chip
->pdata
->num_buck
== 2 && data
== 0x40)
354 || (chip
->pdata
->num_buck
== 1 && data
== 0x00)) {
356 chip
->num_regulator
= 1;
358 chip
->num_regulator
= 2;
360 dev_err(chip
->dev
, "Configuration is mismatched\n");
364 for (i
= 0; i
< chip
->num_regulator
; i
++) {
365 config
.init_data
= chip
->pdata
->init_data
[i
];
366 config
.dev
= chip
->dev
;
367 config
.driver_data
= chip
;
368 config
.regmap
= chip
->regmap
;
369 config
.of_node
= chip
->pdata
->reg_node
[i
];
371 if (gpio_is_valid(chip
->pdata
->gpio_ren
[i
])) {
372 config
.ena_gpio
= chip
->pdata
->gpio_ren
[i
];
373 config
.ena_gpio_initialized
= true;
375 config
.ena_gpio
= -EINVAL
;
376 config
.ena_gpio_initialized
= false;
379 chip
->rdev
[i
] = devm_regulator_register(chip
->dev
,
380 &da9211_regulators
[i
], &config
);
381 if (IS_ERR(chip
->rdev
[i
])) {
383 "Failed to register DA9211 regulator\n");
384 return PTR_ERR(chip
->rdev
[i
]);
387 if (chip
->chip_irq
!= 0) {
388 ret
= regmap_update_bits(chip
->regmap
,
389 DA9211_REG_MASK_B
, DA9211_M_OV_CURR_A
<< i
, 0);
392 "Failed to update mask reg: %d\n", ret
);
402 * I2C driver interface functions
404 static int da9211_i2c_probe(struct i2c_client
*i2c
,
405 const struct i2c_device_id
*id
)
411 chip
= devm_kzalloc(&i2c
->dev
, sizeof(struct da9211
), GFP_KERNEL
);
415 chip
->dev
= &i2c
->dev
;
416 chip
->regmap
= devm_regmap_init_i2c(i2c
, &da9211_regmap_config
);
417 if (IS_ERR(chip
->regmap
)) {
418 error
= PTR_ERR(chip
->regmap
);
419 dev_err(chip
->dev
, "Failed to allocate register map: %d\n",
424 i2c_set_clientdata(i2c
, chip
);
426 chip
->pdata
= i2c
->dev
.platform_data
;
428 ret
= regmap_read(chip
->regmap
, DA9211_REG_DEVICE_ID
, &data
);
430 dev_err(chip
->dev
, "Failed to read DEVICE_ID reg: %d\n", ret
);
435 case DA9211_DEVICE_ID
:
436 chip
->chip_id
= DA9211
;
438 case DA9213_DEVICE_ID
:
439 chip
->chip_id
= DA9213
;
442 dev_err(chip
->dev
, "Unsupported device id = 0x%x.\n", data
);
447 chip
->pdata
= da9211_parse_regulators_dt(chip
->dev
);
449 if (IS_ERR(chip
->pdata
)) {
450 dev_err(chip
->dev
, "No regulators defined for the platform\n");
451 return PTR_ERR(chip
->pdata
);
454 chip
->chip_irq
= i2c
->irq
;
456 if (chip
->chip_irq
!= 0) {
457 ret
= devm_request_threaded_irq(chip
->dev
, chip
->chip_irq
, NULL
,
459 IRQF_TRIGGER_LOW
|IRQF_ONESHOT
,
462 dev_err(chip
->dev
, "Failed to request IRQ: %d\n",
467 dev_warn(chip
->dev
, "No IRQ configured\n");
470 ret
= da9211_regulator_init(chip
);
473 dev_err(chip
->dev
, "Failed to initialize regulator: %d\n", ret
);
478 static const struct i2c_device_id da9211_i2c_id
[] = {
483 MODULE_DEVICE_TABLE(i2c
, da9211_i2c_id
);
486 static const struct of_device_id da9211_dt_ids
[] = {
487 { .compatible
= "dlg,da9211", .data
= &da9211_i2c_id
[0] },
488 { .compatible
= "dlg,da9213", .data
= &da9211_i2c_id
[1] },
491 MODULE_DEVICE_TABLE(of
, da9211_dt_ids
);
494 static struct i2c_driver da9211_regulator_driver
= {
497 .owner
= THIS_MODULE
,
498 .of_match_table
= of_match_ptr(da9211_dt_ids
),
500 .probe
= da9211_i2c_probe
,
501 .id_table
= da9211_i2c_id
,
504 module_i2c_driver(da9211_regulator_driver
);
506 MODULE_AUTHOR("James Ban <James.Ban.opensource@diasemi.com>");
507 MODULE_DESCRIPTION("Regulator device driver for Dialog DA9211/DA9213");
508 MODULE_LICENSE("GPL v2");