2 * Texas Instruments SoC Adaptive Body Bias(ABB) Regulator
4 * Copyright (C) 2011 Texas Instruments, Inc.
5 * Mike Turquette <mturquette@ti.com>
7 * Copyright (C) 2012-2013 Texas Instruments, Inc.
8 * Andrii Tseglytskyi <andrii.tseglytskyi@ti.com>
9 * Nishanth Menon <nm@ti.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
16 * kind, whether express or implied; without even the implied warranty
17 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 #include <linux/clk.h>
21 #include <linux/delay.h>
22 #include <linux/err.h>
24 #include <linux/module.h>
25 #include <linux/of_device.h>
27 #include <linux/platform_device.h>
28 #include <linux/regulator/driver.h>
29 #include <linux/regulator/machine.h>
30 #include <linux/regulator/of_regulator.h>
33 * ABB LDO operating states:
34 * NOMINAL_OPP: bypasses the ABB LDO
35 * FAST_OPP: sets ABB LDO to Forward Body-Bias
36 * SLOW_OPP: sets ABB LDO to Reverse Body-Bias
38 #define TI_ABB_NOMINAL_OPP 0
39 #define TI_ABB_FAST_OPP 1
40 #define TI_ABB_SLOW_OPP 3
43 * struct ti_abb_info - ABB information per voltage setting
44 * @opp_sel: one of TI_ABB macro
45 * @vset: (optional) vset value that LDOVBB needs to be overriden with.
47 * Array of per voltage entries organized in the same order as regulator_desc's
48 * volt_table list. (selector is used to index from this array)
56 * struct ti_abb_reg - Register description for ABB block
57 * @setup_reg: setup register offset from base
58 * @control_reg: control register offset from base
59 * @sr2_wtcnt_value_mask: setup register- sr2_wtcnt_value mask
60 * @fbb_sel_mask: setup register- FBB sel mask
61 * @rbb_sel_mask: setup register- RBB sel mask
62 * @sr2_en_mask: setup register- enable mask
63 * @opp_change_mask: control register - mask to trigger LDOVBB change
64 * @opp_sel_mask: control register - mask for mode to operate
70 /* Setup register fields */
71 u32 sr2_wtcnt_value_mask
;
76 /* Control register fields */
82 * struct ti_abb - ABB instance data
83 * @rdesc: regulator descriptor
84 * @clk: clock(usually sysclk) supplying ABB block
85 * @base: base address of ABB block
86 * @int_base: interrupt register base address
87 * @efuse_base: (optional) efuse base address for ABB modes
88 * @ldo_base: (optional) LDOVBB vset override base address
89 * @regs: pointer to struct ti_abb_reg for ABB block
90 * @txdone_mask: mask on int_base for tranxdone interrupt
91 * @ldovbb_override_mask: mask to ldo_base for overriding default LDO VBB
92 * vset with value from efuse
93 * @ldovbb_vset_mask: mask to ldo_base for providing the VSET override
94 * @info: array to per voltage ABB configuration
95 * @current_info_idx: current index to info
96 * @settling_time: SoC specific settling time for LDO VBB
99 struct regulator_desc rdesc
;
102 void __iomem
*int_base
;
103 void __iomem
*efuse_base
;
104 void __iomem
*ldo_base
;
106 const struct ti_abb_reg
*regs
;
108 u32 ldovbb_override_mask
;
109 u32 ldovbb_vset_mask
;
111 struct ti_abb_info
*info
;
112 int current_info_idx
;
118 * ti_abb_rmw() - handy wrapper to set specific register bits
119 * @mask: mask for register field
120 * @value: value shifted to mask location and written
121 * @offset: offset of register
122 * @base: base address
124 * Return: final register value (may be unused)
126 static inline u32
ti_abb_rmw(u32 mask
, u32 value
, u32 offset
,
131 val
= readl(base
+ offset
);
133 val
|= (value
<< __ffs(mask
)) & mask
;
134 writel(val
, base
+ offset
);
140 * ti_abb_check_txdone() - handy wrapper to check ABB tranxdone status
141 * @abb: pointer to the abb instance
143 * Return: true or false
145 static inline bool ti_abb_check_txdone(const struct ti_abb
*abb
)
147 return !!(readl(abb
->int_base
) & abb
->txdone_mask
);
151 * ti_abb_clear_txdone() - handy wrapper to clear ABB tranxdone status
152 * @abb: pointer to the abb instance
154 static inline void ti_abb_clear_txdone(const struct ti_abb
*abb
)
156 writel(abb
->txdone_mask
, abb
->int_base
);
160 * ti_abb_wait_tranx() - waits for ABB tranxdone event
162 * @abb: pointer to the abb instance
164 * Return: 0 on success or -ETIMEDOUT if the event is not cleared on time.
166 static int ti_abb_wait_txdone(struct device
*dev
, struct ti_abb
*abb
)
171 while (timeout
++ <= abb
->settling_time
) {
172 status
= ti_abb_check_txdone(abb
);
179 if (timeout
> abb
->settling_time
) {
180 dev_warn_ratelimited(dev
,
181 "%s:TRANXDONE timeout(%duS) int=0x%08x\n",
182 __func__
, timeout
, readl(abb
->int_base
));
190 * ti_abb_clear_all_txdone() - clears ABB tranxdone event
192 * @abb: pointer to the abb instance
194 * Return: 0 on success or -ETIMEDOUT if the event is not cleared on time.
196 static int ti_abb_clear_all_txdone(struct device
*dev
, const struct ti_abb
*abb
)
201 while (timeout
++ <= abb
->settling_time
) {
202 ti_abb_clear_txdone(abb
);
204 status
= ti_abb_check_txdone(abb
);
211 if (timeout
> abb
->settling_time
) {
212 dev_warn_ratelimited(dev
,
213 "%s:TRANXDONE timeout(%duS) int=0x%08x\n",
214 __func__
, timeout
, readl(abb
->int_base
));
222 * ti_abb_program_ldovbb() - program LDOVBB register for override value
224 * @abb: pointer to the abb instance
225 * @info: ABB info to program
227 static void ti_abb_program_ldovbb(struct device
*dev
, const struct ti_abb
*abb
,
228 struct ti_abb_info
*info
)
232 val
= readl(abb
->ldo_base
);
233 /* clear up previous values */
234 val
&= ~(abb
->ldovbb_override_mask
| abb
->ldovbb_vset_mask
);
236 switch (info
->opp_sel
) {
237 case TI_ABB_SLOW_OPP
:
238 case TI_ABB_FAST_OPP
:
239 val
|= abb
->ldovbb_override_mask
;
240 val
|= info
->vset
<< __ffs(abb
->ldovbb_vset_mask
);
244 writel(val
, abb
->ldo_base
);
248 * ti_abb_set_opp() - Setup ABB and LDO VBB for required bias
249 * @rdev: regulator device
250 * @abb: pointer to the abb instance
251 * @info: ABB info to program
253 * Return: 0 on success or appropriate error value when fails
255 static int ti_abb_set_opp(struct regulator_dev
*rdev
, struct ti_abb
*abb
,
256 struct ti_abb_info
*info
)
258 const struct ti_abb_reg
*regs
= abb
->regs
;
259 struct device
*dev
= &rdev
->dev
;
262 ret
= ti_abb_clear_all_txdone(dev
, abb
);
266 ti_abb_rmw(regs
->fbb_sel_mask
| regs
->rbb_sel_mask
, 0, regs
->setup_reg
,
269 switch (info
->opp_sel
) {
270 case TI_ABB_SLOW_OPP
:
271 ti_abb_rmw(regs
->rbb_sel_mask
, 1, regs
->setup_reg
, abb
->base
);
273 case TI_ABB_FAST_OPP
:
274 ti_abb_rmw(regs
->fbb_sel_mask
, 1, regs
->setup_reg
, abb
->base
);
278 /* program next state of ABB ldo */
279 ti_abb_rmw(regs
->opp_sel_mask
, info
->opp_sel
, regs
->control_reg
,
282 /* program LDO VBB vset override if needed */
284 ti_abb_program_ldovbb(dev
, abb
, info
);
286 /* Initiate ABB ldo change */
287 ti_abb_rmw(regs
->opp_change_mask
, 1, regs
->control_reg
, abb
->base
);
289 /* Wait for ABB LDO to complete transition to new Bias setting */
290 ret
= ti_abb_wait_txdone(dev
, abb
);
294 ret
= ti_abb_clear_all_txdone(dev
, abb
);
303 * ti_abb_set_voltage_sel() - regulator accessor function to set ABB LDO
304 * @rdev: regulator device
305 * @sel: selector to index into required ABB LDO settings (maps to
306 * regulator descriptor's volt_table)
308 * Return: 0 on success or appropriate error value when fails
310 static int ti_abb_set_voltage_sel(struct regulator_dev
*rdev
, unsigned sel
)
312 const struct regulator_desc
*desc
= rdev
->desc
;
313 struct ti_abb
*abb
= rdev_get_drvdata(rdev
);
314 struct device
*dev
= &rdev
->dev
;
315 struct ti_abb_info
*info
, *oinfo
;
319 dev_err_ratelimited(dev
, "%s: No regulator drvdata\n",
324 if (!desc
->n_voltages
|| !abb
->info
) {
325 dev_err_ratelimited(dev
,
326 "%s: No valid voltage table entries?\n",
331 if (sel
>= desc
->n_voltages
) {
332 dev_err(dev
, "%s: sel idx(%d) >= n_voltages(%d)\n", __func__
,
333 sel
, desc
->n_voltages
);
337 /* If we are in the same index as we were, nothing to do here! */
338 if (sel
== abb
->current_info_idx
) {
339 dev_dbg(dev
, "%s: Already at sel=%d\n", __func__
, sel
);
343 /* If data is exactly the same, then just update index, no change */
344 info
= &abb
->info
[sel
];
345 oinfo
= &abb
->info
[abb
->current_info_idx
];
346 if (!memcmp(info
, oinfo
, sizeof(*info
))) {
347 dev_dbg(dev
, "%s: Same data new idx=%d, old idx=%d\n", __func__
,
348 sel
, abb
->current_info_idx
);
352 ret
= ti_abb_set_opp(rdev
, abb
, info
);
356 abb
->current_info_idx
= sel
;
358 dev_err_ratelimited(dev
,
359 "%s: Volt[%d] idx[%d] mode[%d] Fail(%d)\n",
360 __func__
, desc
->volt_table
[sel
], sel
,
366 * ti_abb_get_voltage_sel() - Regulator accessor to get current ABB LDO setting
367 * @rdev: regulator device
369 * Return: 0 on success or appropriate error value when fails
371 static int ti_abb_get_voltage_sel(struct regulator_dev
*rdev
)
373 const struct regulator_desc
*desc
= rdev
->desc
;
374 struct ti_abb
*abb
= rdev_get_drvdata(rdev
);
375 struct device
*dev
= &rdev
->dev
;
378 dev_err_ratelimited(dev
, "%s: No regulator drvdata\n",
383 if (!desc
->n_voltages
|| !abb
->info
) {
384 dev_err_ratelimited(dev
,
385 "%s: No valid voltage table entries?\n",
390 if (abb
->current_info_idx
>= (int)desc
->n_voltages
) {
391 dev_err(dev
, "%s: Corrupted data? idx(%d) >= n_voltages(%d)\n",
392 __func__
, abb
->current_info_idx
, desc
->n_voltages
);
396 return abb
->current_info_idx
;
400 * ti_abb_init_timings() - setup ABB clock timing for the current platform
402 * @abb: pointer to the abb instance
404 * Return: 0 if timing is updated, else returns error result.
406 static int ti_abb_init_timings(struct device
*dev
, struct ti_abb
*abb
)
409 u32 clk_rate
, sr2_wt_cnt_val
, cycle_rate
;
410 const struct ti_abb_reg
*regs
= abb
->regs
;
412 char *pname
= "ti,settling-time";
414 /* read device tree properties */
415 ret
= of_property_read_u32(dev
->of_node
, pname
, &abb
->settling_time
);
417 dev_err(dev
, "Unable to get property '%s'(%d)\n", pname
, ret
);
421 /* ABB LDO cannot be settle in 0 time */
422 if (!abb
->settling_time
) {
423 dev_err(dev
, "Invalid property:'%s' set as 0!\n", pname
);
427 pname
= "ti,clock-cycles";
428 ret
= of_property_read_u32(dev
->of_node
, pname
, &clock_cycles
);
430 dev_err(dev
, "Unable to get property '%s'(%d)\n", pname
, ret
);
433 /* ABB LDO cannot be settle in 0 clock cycles */
435 dev_err(dev
, "Invalid property:'%s' set as 0!\n", pname
);
439 abb
->clk
= devm_clk_get(dev
, NULL
);
440 if (IS_ERR(abb
->clk
)) {
441 ret
= PTR_ERR(abb
->clk
);
442 dev_err(dev
, "%s: Unable to get clk(%d)\n", __func__
, ret
);
447 * SR2_WTCNT_VALUE is the settling time for the ABB ldo after a
448 * transition and must be programmed with the correct time at boot.
449 * The value programmed into the register is the number of SYS_CLK
450 * clock cycles that match a given wall time profiled for the ldo.
451 * This value depends on:
452 * settling time of ldo in micro-seconds (varies per OMAP family)
453 * # of clock cycles per SYS_CLK period (varies per OMAP family)
454 * the SYS_CLK frequency in MHz (varies per board)
457 * ldo settling time (in micro-seconds)
458 * SR2_WTCNT_VALUE = ------------------------------------------
459 * (# system clock cycles) * (sys_clk period)
463 * SR2_WTCNT_VALUE = settling time / (# SYS_CLK cycles / SYS_CLK rate))
465 * To avoid dividing by zero multiply both "# clock cycles" and
466 * "settling time" by 10 such that the final result is the one we want.
469 /* Convert SYS_CLK rate to MHz & prevent divide by zero */
470 clk_rate
= DIV_ROUND_CLOSEST(clk_get_rate(abb
->clk
), 1000000);
472 /* Calculate cycle rate */
473 cycle_rate
= DIV_ROUND_CLOSEST(clock_cycles
* 10, clk_rate
);
475 /* Calulate SR2_WTCNT_VALUE */
476 sr2_wt_cnt_val
= DIV_ROUND_CLOSEST(abb
->settling_time
* 10, cycle_rate
);
478 dev_dbg(dev
, "%s: Clk_rate=%ld, sr2_cnt=0x%08x\n", __func__
,
479 clk_get_rate(abb
->clk
), sr2_wt_cnt_val
);
481 ti_abb_rmw(regs
->sr2_wtcnt_value_mask
, sr2_wt_cnt_val
, regs
->setup_reg
,
488 * ti_abb_init_table() - Initialize ABB table from device tree
490 * @abb: pointer to the abb instance
491 * @rinit_data: regulator initdata
493 * Return: 0 on success or appropriate error value when fails
495 static int ti_abb_init_table(struct device
*dev
, struct ti_abb
*abb
,
496 struct regulator_init_data
*rinit_data
)
498 struct ti_abb_info
*info
;
499 const struct property
*prop
;
500 const __be32
*abb_info
;
501 const u32 num_values
= 6;
502 char *pname
= "ti,abb_info";
504 unsigned int *volt_table
;
505 int min_uV
= INT_MAX
, max_uV
= 0;
506 struct regulation_constraints
*c
= &rinit_data
->constraints
;
508 prop
= of_find_property(dev
->of_node
, pname
, NULL
);
510 dev_err(dev
, "No '%s' property?\n", pname
);
515 dev_err(dev
, "Empty '%s' property?\n", pname
);
520 * Each abb_info is a set of n-tuple, where n is num_values, consisting
521 * of voltage and a set of detection logic for ABB information for that
524 num_entries
= prop
->length
/ sizeof(u32
);
525 if (!num_entries
|| (num_entries
% num_values
)) {
526 dev_err(dev
, "All '%s' list entries need %d vals\n", pname
,
530 num_entries
/= num_values
;
532 info
= devm_kzalloc(dev
, sizeof(*info
) * num_entries
, GFP_KERNEL
);
534 dev_err(dev
, "Can't allocate info table for '%s' property\n",
540 volt_table
= devm_kzalloc(dev
, sizeof(unsigned int) * num_entries
,
543 dev_err(dev
, "Can't allocate voltage table for '%s' property\n",
548 abb
->rdesc
.n_voltages
= num_entries
;
549 abb
->rdesc
.volt_table
= volt_table
;
550 /* We do not know where the OPP voltage is at the moment */
551 abb
->current_info_idx
= -EINVAL
;
553 abb_info
= prop
->value
;
554 for (i
= 0; i
< num_entries
; i
++, info
++, volt_table
++) {
555 u32 efuse_offset
, rbb_mask
, fbb_mask
, vset_mask
;
558 /* NOTE: num_values should equal to entries picked up here */
559 *volt_table
= be32_to_cpup(abb_info
++);
560 info
->opp_sel
= be32_to_cpup(abb_info
++);
561 efuse_offset
= be32_to_cpup(abb_info
++);
562 rbb_mask
= be32_to_cpup(abb_info
++);
563 fbb_mask
= be32_to_cpup(abb_info
++);
564 vset_mask
= be32_to_cpup(abb_info
++);
567 "[%d]v=%d ABB=%d ef=0x%x rbb=0x%x fbb=0x%x vset=0x%x\n",
568 i
, *volt_table
, info
->opp_sel
, efuse_offset
, rbb_mask
,
569 fbb_mask
, vset_mask
);
571 /* Find min/max for voltage set */
572 if (min_uV
> *volt_table
)
573 min_uV
= *volt_table
;
574 if (max_uV
< *volt_table
)
575 max_uV
= *volt_table
;
577 if (!abb
->efuse_base
) {
578 /* Ignore invalid data, but warn to help cleanup */
579 if (efuse_offset
|| rbb_mask
|| fbb_mask
|| vset_mask
)
580 dev_err(dev
, "prop '%s': v=%d,bad efuse/mask\n",
585 efuse_val
= readl(abb
->efuse_base
+ efuse_offset
);
587 /* Use ABB recommendation from Efuse */
588 if (efuse_val
& rbb_mask
)
589 info
->opp_sel
= TI_ABB_SLOW_OPP
;
590 else if (efuse_val
& fbb_mask
)
591 info
->opp_sel
= TI_ABB_FAST_OPP
;
592 else if (rbb_mask
|| fbb_mask
)
593 info
->opp_sel
= TI_ABB_NOMINAL_OPP
;
596 "[%d]v=%d efusev=0x%x final ABB=%d\n",
597 i
, *volt_table
, efuse_val
, info
->opp_sel
);
599 /* Use recommended Vset bits from Efuse */
600 if (!abb
->ldo_base
) {
602 dev_err(dev
, "prop'%s':v=%d vst=%x LDO base?\n",
603 pname
, *volt_table
, vset_mask
);
606 info
->vset
= efuse_val
& vset_mask
>> __ffs(vset_mask
);
607 dev_dbg(dev
, "[%d]v=%d vset=%x\n", i
, *volt_table
, info
->vset
);
609 switch (info
->opp_sel
) {
610 case TI_ABB_NOMINAL_OPP
:
611 case TI_ABB_FAST_OPP
:
612 case TI_ABB_SLOW_OPP
:
616 dev_err(dev
, "%s:[%d]v=%d, ABB=%d is invalid! Abort!\n",
617 __func__
, i
, *volt_table
, info
->opp_sel
);
622 /* Setup the min/max voltage constraints from the supported list */
629 static struct regulator_ops ti_abb_reg_ops
= {
630 .list_voltage
= regulator_list_voltage_table
,
632 .set_voltage_sel
= ti_abb_set_voltage_sel
,
633 .get_voltage_sel
= ti_abb_get_voltage_sel
,
636 /* Default ABB block offsets, IF this changes in future, create new one */
637 static const struct ti_abb_reg abb_regs_v1
= {
638 /* WARNING: registers are wrongly documented in TRM */
642 .sr2_wtcnt_value_mask
= (0xff << 8),
643 .fbb_sel_mask
= (0x01 << 2),
644 .rbb_sel_mask
= (0x01 << 1),
645 .sr2_en_mask
= (0x01 << 0),
647 .opp_change_mask
= (0x01 << 2),
648 .opp_sel_mask
= (0x03 << 0),
651 static const struct ti_abb_reg abb_regs_v2
= {
655 .sr2_wtcnt_value_mask
= (0xff << 8),
656 .fbb_sel_mask
= (0x01 << 2),
657 .rbb_sel_mask
= (0x01 << 1),
658 .sr2_en_mask
= (0x01 << 0),
660 .opp_change_mask
= (0x01 << 2),
661 .opp_sel_mask
= (0x03 << 0),
664 static const struct of_device_id ti_abb_of_match
[] = {
665 {.compatible
= "ti,abb-v1", .data
= &abb_regs_v1
},
666 {.compatible
= "ti,abb-v2", .data
= &abb_regs_v2
},
670 MODULE_DEVICE_TABLE(of
, ti_abb_of_match
);
673 * ti_abb_probe() - Initialize an ABB ldo instance
674 * @pdev: ABB platform device
676 * Initializes an individual ABB LDO for required Body-Bias. ABB is used to
677 * addional bias supply to SoC modules for power savings or mandatory stability
678 * configuration at certain Operating Performance Points(OPPs).
680 * Return: 0 on success or appropriate error value when fails
682 static int ti_abb_probe(struct platform_device
*pdev
)
684 struct device
*dev
= &pdev
->dev
;
685 const struct of_device_id
*match
;
686 struct resource
*res
;
688 struct regulator_init_data
*initdata
= NULL
;
689 struct regulator_dev
*rdev
= NULL
;
690 struct regulator_desc
*desc
;
691 struct regulation_constraints
*c
;
692 struct regulator_config config
= { };
696 match
= of_match_device(ti_abb_of_match
, dev
);
698 /* We do not expect this to happen */
700 dev_err(dev
, "%s: Unable to match device\n", __func__
);
705 dev_err(dev
, "%s: Bad data in match\n", __func__
);
709 abb
= devm_kzalloc(dev
, sizeof(struct ti_abb
), GFP_KERNEL
);
711 dev_err(dev
, "%s: Unable to allocate ABB struct\n", __func__
);
715 abb
->regs
= match
->data
;
717 /* Map ABB resources */
718 pname
= "base-address";
719 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, pname
);
720 abb
->base
= devm_ioremap_resource(dev
, res
);
721 if (IS_ERR(abb
->base
)) {
722 ret
= PTR_ERR(abb
->base
);
726 pname
= "int-address";
727 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, pname
);
729 dev_err(dev
, "Missing '%s' IO resource\n", pname
);
734 * We may have shared interrupt register offsets which are
735 * write-1-to-clear between domains ensuring exclusivity.
737 abb
->int_base
= devm_ioremap_nocache(dev
, res
->start
,
739 if (!abb
->int_base
) {
740 dev_err(dev
, "Unable to map '%s'\n", pname
);
745 /* Map Optional resources */
746 pname
= "efuse-address";
747 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, pname
);
749 dev_dbg(dev
, "Missing '%s' IO resource\n", pname
);
755 * We may have shared efuse register offsets which are read-only
758 abb
->efuse_base
= devm_ioremap_nocache(dev
, res
->start
,
760 if (!abb
->efuse_base
) {
761 dev_err(dev
, "Unable to map '%s'\n", pname
);
766 pname
= "ldo-address";
767 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, pname
);
768 abb
->ldo_base
= devm_ioremap_resource(dev
, res
);
769 if (IS_ERR(abb
->ldo_base
)) {
770 ret
= PTR_ERR(abb
->ldo_base
);
774 /* IF ldo_base is set, the following are mandatory */
775 pname
= "ti,ldovbb-override-mask";
777 of_property_read_u32(pdev
->dev
.of_node
, pname
,
778 &abb
->ldovbb_override_mask
);
780 dev_err(dev
, "Missing '%s' (%d)\n", pname
, ret
);
783 if (!abb
->ldovbb_override_mask
) {
784 dev_err(dev
, "Invalid property:'%s' set as 0!\n", pname
);
789 pname
= "ti,ldovbb-vset-mask";
791 of_property_read_u32(pdev
->dev
.of_node
, pname
,
792 &abb
->ldovbb_vset_mask
);
794 dev_err(dev
, "Missing '%s' (%d)\n", pname
, ret
);
797 if (!abb
->ldovbb_vset_mask
) {
798 dev_err(dev
, "Invalid property:'%s' set as 0!\n", pname
);
804 pname
= "ti,tranxdone-status-mask";
806 of_property_read_u32(pdev
->dev
.of_node
, pname
,
809 dev_err(dev
, "Missing '%s' (%d)\n", pname
, ret
);
812 if (!abb
->txdone_mask
) {
813 dev_err(dev
, "Invalid property:'%s' set as 0!\n", pname
);
818 initdata
= of_get_regulator_init_data(dev
, pdev
->dev
.of_node
);
821 dev_err(dev
, "%s: Unable to alloc regulator init data\n",
826 /* init ABB opp_sel table */
827 ret
= ti_abb_init_table(dev
, abb
, initdata
);
831 /* init ABB timing */
832 ret
= ti_abb_init_timings(dev
, abb
);
837 desc
->name
= dev_name(dev
);
838 desc
->owner
= THIS_MODULE
;
839 desc
->type
= REGULATOR_VOLTAGE
;
840 desc
->ops
= &ti_abb_reg_ops
;
842 c
= &initdata
->constraints
;
843 if (desc
->n_voltages
> 1)
844 c
->valid_ops_mask
|= REGULATOR_CHANGE_VOLTAGE
;
848 config
.init_data
= initdata
;
849 config
.driver_data
= abb
;
850 config
.of_node
= pdev
->dev
.of_node
;
852 rdev
= regulator_register(desc
, &config
);
855 dev_err(dev
, "%s: failed to register regulator(%d)\n",
859 platform_set_drvdata(pdev
, rdev
);
861 /* Enable the ldo if not already done by bootloader */
862 ti_abb_rmw(abb
->regs
->sr2_en_mask
, 1, abb
->regs
->setup_reg
, abb
->base
);
867 dev_err(dev
, "%s: Failed to initialize(%d)\n", __func__
, ret
);
872 * ti_abb_remove() - cleanups
873 * @pdev: ABB platform device
877 static int ti_abb_remove(struct platform_device
*pdev
)
879 struct regulator_dev
*rdev
= platform_get_drvdata(pdev
);
881 regulator_unregister(rdev
);
885 MODULE_ALIAS("platform:ti_abb");
887 static struct platform_driver ti_abb_driver
= {
888 .probe
= ti_abb_probe
,
889 .remove
= ti_abb_remove
,
892 .owner
= THIS_MODULE
,
893 .of_match_table
= of_match_ptr(ti_abb_of_match
),
896 module_platform_driver(ti_abb_driver
);
898 MODULE_DESCRIPTION("Texas Instruments ABB LDO regulator driver");
899 MODULE_AUTHOR("Texas Instruments Inc.");
900 MODULE_LICENSE("GPL v2");