Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/regulator/ti-abb-regulator.c

  1 /*
  2  * Texas Instruments SoC Adaptive Body Bias(ABB) Regulator
  3  *
  4  * Copyright (C) 2011 Texas Instruments, Inc.
  5  * Mike Turquette <mturquette@ti.com>
  6  *
  7  * Copyright (C) 2012-2013 Texas Instruments, Inc.
  8  * Andrii Tseglytskyi <andrii.tseglytskyi@ti.com>
  9  * Nishanth Menon <nm@ti.com>
 10  *
 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.
 14  *
 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.
 19  */
 20 #include <linux/clk.h>
 21 #include <linux/delay.h>
 22 #include <linux/err.h>
 23 #include <linux/io.h>
 24 #include <linux/module.h>
 25 #include <linux/of_device.h>
 26 #include <linux/of.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>
 31 
 32 /*
 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
 37  */
 38 #define TI_ABB_NOMINAL_OPP      0
 39 #define TI_ABB_FAST_OPP         1
 40 #define TI_ABB_SLOW_OPP         3
 41 
 42 /**
 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.
 46  *
 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)
 49  */
 50 struct ti_abb_info {
 51         u32 opp_sel;
 52         u32 vset;
 53 };
 54 
 55 /**
 56  * struct ti_abb_reg - Register description for ABB block
 57  * @setup_off:                  setup register offset from base
 58  * @control_off:                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
 65  */
 66 struct ti_abb_reg {
 67         u32 setup_off;
 68         u32 control_off;
 69 
 70         /* Setup register fields */
 71         u32 sr2_wtcnt_value_mask;
 72         u32 fbb_sel_mask;
 73         u32 rbb_sel_mask;
 74         u32 sr2_en_mask;
 75 
 76         /* Control register fields */
 77         u32 opp_change_mask;
 78         u32 opp_sel_mask;
 79 };
 80 
 81 /**
 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  * @setup_reg:                  setup register of ABB block
 87  * @control_reg:                control register of ABB block
 88  * @int_base:                   interrupt register base address
 89  * @efuse_base:                 (optional) efuse base address for ABB modes
 90  * @ldo_base:                   (optional) LDOVBB vset override base address
 91  * @regs:                       pointer to struct ti_abb_reg for ABB block
 92  * @txdone_mask:                mask on int_base for tranxdone interrupt
 93  * @ldovbb_override_mask:       mask to ldo_base for overriding default LDO VBB
 94  *                              vset with value from efuse
 95  * @ldovbb_vset_mask:           mask to ldo_base for providing the VSET override
 96  * @info:                       array to per voltage ABB configuration
 97  * @current_info_idx:           current index to info
 98  * @settling_time:              SoC specific settling time for LDO VBB
 99  */
100 struct ti_abb {
101         struct regulator_desc rdesc;
102         struct clk *clk;
103         void __iomem *base;
104         void __iomem *setup_reg;
105         void __iomem *control_reg;
106         void __iomem *int_base;
107         void __iomem *efuse_base;
108         void __iomem *ldo_base;
109 
110         const struct ti_abb_reg *regs;
111         u32 txdone_mask;
112         u32 ldovbb_override_mask;
113         u32 ldovbb_vset_mask;
114 
115         struct ti_abb_info *info;
116         int current_info_idx;
117 
118         u32 settling_time;
119 };
120 
121 /**
122  * ti_abb_rmw() - handy wrapper to set specific register bits
123  * @mask:       mask for register field
124  * @value:      value shifted to mask location and written
125  * @reg:        register address
126  *
127  * Return: final register value (may be unused)
128  */
129 static inline u32 ti_abb_rmw(u32 mask, u32 value, void __iomem *reg)
130 {
131         u32 val;
132 
133         val = readl(reg);
134         val &= ~mask;
135         val |= (value << __ffs(mask)) & mask;
136         writel(val, reg);
137 
138         return val;
139 }
140 
141 /**
142  * ti_abb_check_txdone() - handy wrapper to check ABB tranxdone status
143  * @abb:        pointer to the abb instance
144  *
145  * Return: true or false
146  */
147 static inline bool ti_abb_check_txdone(const struct ti_abb *abb)
148 {
149         return !!(readl(abb->int_base) & abb->txdone_mask);
150 }
151 
152 /**
153  * ti_abb_clear_txdone() - handy wrapper to clear ABB tranxdone status
154  * @abb:        pointer to the abb instance
155  */
156 static inline void ti_abb_clear_txdone(const struct ti_abb *abb)
157 {
158         writel(abb->txdone_mask, abb->int_base);
159 };
160 
161 /**
162  * ti_abb_wait_tranx() - waits for ABB tranxdone event
163  * @dev:        device
164  * @abb:        pointer to the abb instance
165  *
166  * Return: 0 on success or -ETIMEDOUT if the event is not cleared on time.
167  */
168 static int ti_abb_wait_txdone(struct device *dev, struct ti_abb *abb)
169 {
170         int timeout = 0;
171         bool status;
172 
173         while (timeout++ <= abb->settling_time) {
174                 status = ti_abb_check_txdone(abb);
175                 if (status)
176                         break;
177 
178                 udelay(1);
179         }
180 
181         if (timeout > abb->settling_time) {
182                 dev_warn_ratelimited(dev,
183                                      "%s:TRANXDONE timeout(%duS) int=0x%08x\n",
184                                      __func__, timeout, readl(abb->int_base));
185                 return -ETIMEDOUT;
186         }
187 
188         return 0;
189 }
190 
191 /**
192  * ti_abb_clear_all_txdone() - clears ABB tranxdone event
193  * @dev:        device
194  * @abb:        pointer to the abb instance
195  *
196  * Return: 0 on success or -ETIMEDOUT if the event is not cleared on time.
197  */
198 static int ti_abb_clear_all_txdone(struct device *dev, const struct ti_abb *abb)
199 {
200         int timeout = 0;
201         bool status;
202 
203         while (timeout++ <= abb->settling_time) {
204                 ti_abb_clear_txdone(abb);
205 
206                 status = ti_abb_check_txdone(abb);
207                 if (!status)
208                         break;
209 
210                 udelay(1);
211         }
212 
213         if (timeout > abb->settling_time) {
214                 dev_warn_ratelimited(dev,
215                                      "%s:TRANXDONE timeout(%duS) int=0x%08x\n",
216                                      __func__, timeout, readl(abb->int_base));
217                 return -ETIMEDOUT;
218         }
219 
220         return 0;
221 }
222 
223 /**
224  * ti_abb_program_ldovbb() - program LDOVBB register for override value
225  * @dev:        device
226  * @abb:        pointer to the abb instance
227  * @info:       ABB info to program
228  */
229 static void ti_abb_program_ldovbb(struct device *dev, const struct ti_abb *abb,
230                                   struct ti_abb_info *info)
231 {
232         u32 val;
233 
234         val = readl(abb->ldo_base);
235         /* clear up previous values */
236         val &= ~(abb->ldovbb_override_mask | abb->ldovbb_vset_mask);
237 
238         switch (info->opp_sel) {
239         case TI_ABB_SLOW_OPP:
240         case TI_ABB_FAST_OPP:
241                 val |= abb->ldovbb_override_mask;
242                 val |= info->vset << __ffs(abb->ldovbb_vset_mask);
243                 break;
244         }
245 
246         writel(val, abb->ldo_base);
247 }
248 
249 /**
250  * ti_abb_set_opp() - Setup ABB and LDO VBB for required bias
251  * @rdev:       regulator device
252  * @abb:        pointer to the abb instance
253  * @info:       ABB info to program
254  *
255  * Return: 0 on success or appropriate error value when fails
256  */
257 static int ti_abb_set_opp(struct regulator_dev *rdev, struct ti_abb *abb,
258                           struct ti_abb_info *info)
259 {
260         const struct ti_abb_reg *regs = abb->regs;
261         struct device *dev = &rdev->dev;
262         int ret;
263 
264         ret = ti_abb_clear_all_txdone(dev, abb);
265         if (ret)
266                 goto out;
267 
268         ti_abb_rmw(regs->fbb_sel_mask | regs->rbb_sel_mask, 0, abb->setup_reg);
269 
270         switch (info->opp_sel) {
271         case TI_ABB_SLOW_OPP:
272                 ti_abb_rmw(regs->rbb_sel_mask, 1, abb->setup_reg);
273                 break;
274         case TI_ABB_FAST_OPP:
275                 ti_abb_rmw(regs->fbb_sel_mask, 1, abb->setup_reg);
276                 break;
277         }
278 
279         /* program next state of ABB ldo */
280         ti_abb_rmw(regs->opp_sel_mask, info->opp_sel, abb->control_reg);
281 
282         /*
283          * program LDO VBB vset override if needed for !bypass mode
284          * XXX: Do not switch sequence - for !bypass, LDO override reset *must*
285          * be performed *before* switch to bias mode else VBB glitches.
286          */
287         if (abb->ldo_base && info->opp_sel != TI_ABB_NOMINAL_OPP)
288                 ti_abb_program_ldovbb(dev, abb, info);
289 
290         /* Initiate ABB ldo change */
291         ti_abb_rmw(regs->opp_change_mask, 1, abb->control_reg);
292 
293         /* Wait for ABB LDO to complete transition to new Bias setting */
294         ret = ti_abb_wait_txdone(dev, abb);
295         if (ret)
296                 goto out;
297 
298         ret = ti_abb_clear_all_txdone(dev, abb);
299         if (ret)
300                 goto out;
301 
302         /*
303          * Reset LDO VBB vset override bypass mode
304          * XXX: Do not switch sequence - for bypass, LDO override reset *must*
305          * be performed *after* switch to bypass else VBB glitches.
306          */
307         if (abb->ldo_base && info->opp_sel == TI_ABB_NOMINAL_OPP)
308                 ti_abb_program_ldovbb(dev, abb, info);
309 
310 out:
311         return ret;
312 }
313 
314 /**
315  * ti_abb_set_voltage_sel() - regulator accessor function to set ABB LDO
316  * @rdev:       regulator device
317  * @sel:        selector to index into required ABB LDO settings (maps to
318  *              regulator descriptor's volt_table)
319  *
320  * Return: 0 on success or appropriate error value when fails
321  */
322 static int ti_abb_set_voltage_sel(struct regulator_dev *rdev, unsigned sel)
323 {
324         const struct regulator_desc *desc = rdev->desc;
325         struct ti_abb *abb = rdev_get_drvdata(rdev);
326         struct device *dev = &rdev->dev;
327         struct ti_abb_info *info, *oinfo;
328         int ret = 0;
329 
330         if (!abb) {
331                 dev_err_ratelimited(dev, "%s: No regulator drvdata\n",
332                                     __func__);
333                 return -ENODEV;
334         }
335 
336         if (!desc->n_voltages || !abb->info) {
337                 dev_err_ratelimited(dev,
338                                     "%s: No valid voltage table entries?\n",
339                                     __func__);
340                 return -EINVAL;
341         }
342 
343         if (sel >= desc->n_voltages) {
344                 dev_err(dev, "%s: sel idx(%d) >= n_voltages(%d)\n", __func__,
345                         sel, desc->n_voltages);
346                 return -EINVAL;
347         }
348 
349         /* If we are in the same index as we were, nothing to do here! */
350         if (sel == abb->current_info_idx) {
351                 dev_dbg(dev, "%s: Already at sel=%d\n", __func__, sel);
352                 return ret;
353         }
354 
355         /* If data is exactly the same, then just update index, no change */
356         info = &abb->info[sel];
357         oinfo = &abb->info[abb->current_info_idx];
358         if (!memcmp(info, oinfo, sizeof(*info))) {
359                 dev_dbg(dev, "%s: Same data new idx=%d, old idx=%d\n", __func__,
360                         sel, abb->current_info_idx);
361                 goto out;
362         }
363 
364         ret = ti_abb_set_opp(rdev, abb, info);
365 
366 out:
367         if (!ret)
368                 abb->current_info_idx = sel;
369         else
370                 dev_err_ratelimited(dev,
371                                     "%s: Volt[%d] idx[%d] mode[%d] Fail(%d)\n",
372                                     __func__, desc->volt_table[sel], sel,
373                                     info->opp_sel, ret);
374         return ret;
375 }
376 
377 /**
378  * ti_abb_get_voltage_sel() - Regulator accessor to get current ABB LDO setting
379  * @rdev:       regulator device
380  *
381  * Return: 0 on success or appropriate error value when fails
382  */
383 static int ti_abb_get_voltage_sel(struct regulator_dev *rdev)
384 {
385         const struct regulator_desc *desc = rdev->desc;
386         struct ti_abb *abb = rdev_get_drvdata(rdev);
387         struct device *dev = &rdev->dev;
388 
389         if (!abb) {
390                 dev_err_ratelimited(dev, "%s: No regulator drvdata\n",
391                                     __func__);
392                 return -ENODEV;
393         }
394 
395         if (!desc->n_voltages || !abb->info) {
396                 dev_err_ratelimited(dev,
397                                     "%s: No valid voltage table entries?\n",
398                                     __func__);
399                 return -EINVAL;
400         }
401 
402         if (abb->current_info_idx >= (int)desc->n_voltages) {
403                 dev_err(dev, "%s: Corrupted data? idx(%d) >= n_voltages(%d)\n",
404                         __func__, abb->current_info_idx, desc->n_voltages);
405                 return -EINVAL;
406         }
407 
408         return abb->current_info_idx;
409 }
410 
411 /**
412  * ti_abb_init_timings() - setup ABB clock timing for the current platform
413  * @dev:        device
414  * @abb:        pointer to the abb instance
415  *
416  * Return: 0 if timing is updated, else returns error result.
417  */
418 static int ti_abb_init_timings(struct device *dev, struct ti_abb *abb)
419 {
420         u32 clock_cycles;
421         u32 clk_rate, sr2_wt_cnt_val, cycle_rate;
422         const struct ti_abb_reg *regs = abb->regs;
423         int ret;
424         char *pname = "ti,settling-time";
425 
426         /* read device tree properties */
427         ret = of_property_read_u32(dev->of_node, pname, &abb->settling_time);
428         if (ret) {
429                 dev_err(dev, "Unable to get property '%s'(%d)\n", pname, ret);
430                 return ret;
431         }
432 
433         /* ABB LDO cannot be settle in 0 time */
434         if (!abb->settling_time) {
435                 dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
436                 return -EINVAL;
437         }
438 
439         pname = "ti,clock-cycles";
440         ret = of_property_read_u32(dev->of_node, pname, &clock_cycles);
441         if (ret) {
442                 dev_err(dev, "Unable to get property '%s'(%d)\n", pname, ret);
443                 return ret;
444         }
445         /* ABB LDO cannot be settle in 0 clock cycles */
446         if (!clock_cycles) {
447                 dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
448                 return -EINVAL;
449         }
450 
451         abb->clk = devm_clk_get(dev, NULL);
452         if (IS_ERR(abb->clk)) {
453                 ret = PTR_ERR(abb->clk);
454                 dev_err(dev, "%s: Unable to get clk(%d)\n", __func__, ret);
455                 return ret;
456         }
457 
458         /*
459          * SR2_WTCNT_VALUE is the settling time for the ABB ldo after a
460          * transition and must be programmed with the correct time at boot.
461          * The value programmed into the register is the number of SYS_CLK
462          * clock cycles that match a given wall time profiled for the ldo.
463          * This value depends on:
464          * settling time of ldo in micro-seconds (varies per OMAP family)
465          * # of clock cycles per SYS_CLK period (varies per OMAP family)
466          * the SYS_CLK frequency in MHz (varies per board)
467          * The formula is:
468          *
469          *                      ldo settling time (in micro-seconds)
470          * SR2_WTCNT_VALUE = ------------------------------------------
471          *                   (# system clock cycles) * (sys_clk period)
472          *
473          * Put another way:
474          *
475          * SR2_WTCNT_VALUE = settling time / (# SYS_CLK cycles / SYS_CLK rate))
476          *
477          * To avoid dividing by zero multiply both "# clock cycles" and
478          * "settling time" by 10 such that the final result is the one we want.
479          */
480 
481         /* Convert SYS_CLK rate to MHz & prevent divide by zero */
482         clk_rate = DIV_ROUND_CLOSEST(clk_get_rate(abb->clk), 1000000);
483 
484         /* Calculate cycle rate */
485         cycle_rate = DIV_ROUND_CLOSEST(clock_cycles * 10, clk_rate);
486 
487         /* Calulate SR2_WTCNT_VALUE */
488         sr2_wt_cnt_val = DIV_ROUND_CLOSEST(abb->settling_time * 10, cycle_rate);
489 
490         dev_dbg(dev, "%s: Clk_rate=%ld, sr2_cnt=0x%08x\n", __func__,
491                 clk_get_rate(abb->clk), sr2_wt_cnt_val);
492 
493         ti_abb_rmw(regs->sr2_wtcnt_value_mask, sr2_wt_cnt_val, abb->setup_reg);
494 
495         return 0;
496 }
497 
498 /**
499  * ti_abb_init_table() - Initialize ABB table from device tree
500  * @dev:        device
501  * @abb:        pointer to the abb instance
502  * @rinit_data: regulator initdata
503  *
504  * Return: 0 on success or appropriate error value when fails
505  */
506 static int ti_abb_init_table(struct device *dev, struct ti_abb *abb,
507                              struct regulator_init_data *rinit_data)
508 {
509         struct ti_abb_info *info;
510         const u32 num_values = 6;
511         char *pname = "ti,abb_info";
512         u32 i;
513         unsigned int *volt_table;
514         int num_entries, min_uV = INT_MAX, max_uV = 0;
515         struct regulation_constraints *c = &rinit_data->constraints;
516 
517         /*
518          * Each abb_info is a set of n-tuple, where n is num_values, consisting
519          * of voltage and a set of detection logic for ABB information for that
520          * voltage to apply.
521          */
522         num_entries = of_property_count_u32_elems(dev->of_node, pname);
523         if (num_entries < 0) {
524                 dev_err(dev, "No '%s' property?\n", pname);
525                 return num_entries;
526         }
527 
528         if (!num_entries || (num_entries % num_values)) {
529                 dev_err(dev, "All '%s' list entries need %d vals\n", pname,
530                         num_values);
531                 return -EINVAL;
532         }
533         num_entries /= num_values;
534 
535         info = devm_kzalloc(dev, sizeof(*info) * num_entries, GFP_KERNEL);
536         if (!info)
537                 return -ENOMEM;
538 
539         abb->info = info;
540 
541         volt_table = devm_kzalloc(dev, sizeof(unsigned int) * num_entries,
542                                   GFP_KERNEL);
543         if (!volt_table)
544                 return -ENOMEM;
545 
546         abb->rdesc.n_voltages = num_entries;
547         abb->rdesc.volt_table = volt_table;
548         /* We do not know where the OPP voltage is at the moment */
549         abb->current_info_idx = -EINVAL;
550 
551         for (i = 0; i < num_entries; i++, info++, volt_table++) {
552                 u32 efuse_offset, rbb_mask, fbb_mask, vset_mask;
553                 u32 efuse_val;
554 
555                 /* NOTE: num_values should equal to entries picked up here */
556                 of_property_read_u32_index(dev->of_node, pname, i * num_values,
557                                            volt_table);
558                 of_property_read_u32_index(dev->of_node, pname,
559                                            i * num_values + 1, &info->opp_sel);
560                 of_property_read_u32_index(dev->of_node, pname,
561                                            i * num_values + 2, &efuse_offset);
562                 of_property_read_u32_index(dev->of_node, pname,
563                                            i * num_values + 3, &rbb_mask);
564                 of_property_read_u32_index(dev->of_node, pname,
565                                            i * num_values + 4, &fbb_mask);
566                 of_property_read_u32_index(dev->of_node, pname,
567                                            i * num_values + 5, &vset_mask);
568 
569                 dev_dbg(dev,
570                         "[%d]v=%d ABB=%d ef=0x%x rbb=0x%x fbb=0x%x vset=0x%x\n",
571                         i, *volt_table, info->opp_sel, efuse_offset, rbb_mask,
572                         fbb_mask, vset_mask);
573 
574                 /* Find min/max for voltage set */
575                 if (min_uV > *volt_table)
576                         min_uV = *volt_table;
577                 if (max_uV < *volt_table)
578                         max_uV = *volt_table;
579 
580                 if (!abb->efuse_base) {
581                         /* Ignore invalid data, but warn to help cleanup */
582                         if (efuse_offset || rbb_mask || fbb_mask || vset_mask)
583                                 dev_err(dev, "prop '%s': v=%d,bad efuse/mask\n",
584                                         pname, *volt_table);
585                         goto check_abb;
586                 }
587 
588                 efuse_val = readl(abb->efuse_base + efuse_offset);
589 
590                 /* Use ABB recommendation from Efuse */
591                 if (efuse_val & rbb_mask)
592                         info->opp_sel = TI_ABB_SLOW_OPP;
593                 else if (efuse_val & fbb_mask)
594                         info->opp_sel = TI_ABB_FAST_OPP;
595                 else if (rbb_mask || fbb_mask)
596                         info->opp_sel = TI_ABB_NOMINAL_OPP;
597 
598                 dev_dbg(dev,
599                         "[%d]v=%d efusev=0x%x final ABB=%d\n",
600                         i, *volt_table, efuse_val, info->opp_sel);
601 
602                 /* Use recommended Vset bits from Efuse */
603                 if (!abb->ldo_base) {
604                         if (vset_mask)
605                                 dev_err(dev, "prop'%s':v=%d vst=%x LDO base?\n",
606                                         pname, *volt_table, vset_mask);
607                         continue;
608                 }
609                 info->vset = (efuse_val & vset_mask) >> __ffs(vset_mask);
610                 dev_dbg(dev, "[%d]v=%d vset=%x\n", i, *volt_table, info->vset);
611 check_abb:
612                 switch (info->opp_sel) {
613                 case TI_ABB_NOMINAL_OPP:
614                 case TI_ABB_FAST_OPP:
615                 case TI_ABB_SLOW_OPP:
616                         /* Valid values */
617                         break;
618                 default:
619                         dev_err(dev, "%s:[%d]v=%d, ABB=%d is invalid! Abort!\n",
620                                 __func__, i, *volt_table, info->opp_sel);
621                         return -EINVAL;
622                 }
623         }
624 
625         /* Setup the min/max voltage constraints from the supported list */
626         c->min_uV = min_uV;
627         c->max_uV = max_uV;
628 
629         return 0;
630 }
631 
632 static struct regulator_ops ti_abb_reg_ops = {
633         .list_voltage = regulator_list_voltage_table,
634 
635         .set_voltage_sel = ti_abb_set_voltage_sel,
636         .get_voltage_sel = ti_abb_get_voltage_sel,
637 };
638 
639 /* Default ABB block offsets, IF this changes in future, create new one */
640 static const struct ti_abb_reg abb_regs_v1 = {
641         /* WARNING: registers are wrongly documented in TRM */
642         .setup_off              = 0x04,
643         .control_off            = 0x00,
644 
645         .sr2_wtcnt_value_mask   = (0xff << 8),
646         .fbb_sel_mask           = (0x01 << 2),
647         .rbb_sel_mask           = (0x01 << 1),
648         .sr2_en_mask            = (0x01 << 0),
649 
650         .opp_change_mask        = (0x01 << 2),
651         .opp_sel_mask           = (0x03 << 0),
652 };
653 
654 static const struct ti_abb_reg abb_regs_v2 = {
655         .setup_off              = 0x00,
656         .control_off            = 0x04,
657 
658         .sr2_wtcnt_value_mask   = (0xff << 8),
659         .fbb_sel_mask           = (0x01 << 2),
660         .rbb_sel_mask           = (0x01 << 1),
661         .sr2_en_mask            = (0x01 << 0),
662 
663         .opp_change_mask        = (0x01 << 2),
664         .opp_sel_mask           = (0x03 << 0),
665 };
666 
667 static const struct ti_abb_reg abb_regs_generic = {
668         .sr2_wtcnt_value_mask   = (0xff << 8),
669         .fbb_sel_mask           = (0x01 << 2),
670         .rbb_sel_mask           = (0x01 << 1),
671         .sr2_en_mask            = (0x01 << 0),
672 
673         .opp_change_mask        = (0x01 << 2),
674         .opp_sel_mask           = (0x03 << 0),
675 };
676 
677 static const struct of_device_id ti_abb_of_match[] = {
678         {.compatible = "ti,abb-v1", .data = &abb_regs_v1},
679         {.compatible = "ti,abb-v2", .data = &abb_regs_v2},
680         {.compatible = "ti,abb-v3", .data = &abb_regs_generic},
681         { },
682 };
683 
684 MODULE_DEVICE_TABLE(of, ti_abb_of_match);
685 
686 /**
687  * ti_abb_probe() - Initialize an ABB ldo instance
688  * @pdev: ABB platform device
689  *
690  * Initializes an individual ABB LDO for required Body-Bias. ABB is used to
691  * addional bias supply to SoC modules for power savings or mandatory stability
692  * configuration at certain Operating Performance Points(OPPs).
693  *
694  * Return: 0 on success or appropriate error value when fails
695  */
696 static int ti_abb_probe(struct platform_device *pdev)
697 {
698         struct device *dev = &pdev->dev;
699         const struct of_device_id *match;
700         struct resource *res;
701         struct ti_abb *abb;
702         struct regulator_init_data *initdata = NULL;
703         struct regulator_dev *rdev = NULL;
704         struct regulator_desc *desc;
705         struct regulation_constraints *c;
706         struct regulator_config config = { };
707         char *pname;
708         int ret = 0;
709 
710         match = of_match_device(ti_abb_of_match, dev);
711         if (!match) {
712                 /* We do not expect this to happen */
713                 dev_err(dev, "%s: Unable to match device\n", __func__);
714                 return -ENODEV;
715         }
716         if (!match->data) {
717                 dev_err(dev, "%s: Bad data in match\n", __func__);
718                 return -EINVAL;
719         }
720 
721         abb = devm_kzalloc(dev, sizeof(struct ti_abb), GFP_KERNEL);
722         if (!abb)
723                 return -ENOMEM;
724         abb->regs = match->data;
725 
726         /* Map ABB resources */
727         if (abb->regs->setup_off || abb->regs->control_off) {
728                 pname = "base-address";
729                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
730                 abb->base = devm_ioremap_resource(dev, res);
731                 if (IS_ERR(abb->base))
732                         return PTR_ERR(abb->base);
733 
734                 abb->setup_reg = abb->base + abb->regs->setup_off;
735                 abb->control_reg = abb->base + abb->regs->control_off;
736 
737         } else {
738                 pname = "control-address";
739                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
740                 abb->control_reg = devm_ioremap_resource(dev, res);
741                 if (IS_ERR(abb->control_reg))
742                         return PTR_ERR(abb->control_reg);
743 
744                 pname = "setup-address";
745                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
746                 abb->setup_reg = devm_ioremap_resource(dev, res);
747                 if (IS_ERR(abb->setup_reg))
748                         return PTR_ERR(abb->setup_reg);
749         }
750 
751         pname = "int-address";
752         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
753         if (!res) {
754                 dev_err(dev, "Missing '%s' IO resource\n", pname);
755                 return -ENODEV;
756         }
757         /*
758          * We may have shared interrupt register offsets which are
759          * write-1-to-clear between domains ensuring exclusivity.
760          */
761         abb->int_base = devm_ioremap_nocache(dev, res->start,
762                                              resource_size(res));
763         if (!abb->int_base) {
764                 dev_err(dev, "Unable to map '%s'\n", pname);
765                 return -ENOMEM;
766         }
767 
768         /* Map Optional resources */
769         pname = "efuse-address";
770         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
771         if (!res) {
772                 dev_dbg(dev, "Missing '%s' IO resource\n", pname);
773                 ret = -ENODEV;
774                 goto skip_opt;
775         }
776 
777         /*
778          * We may have shared efuse register offsets which are read-only
779          * between domains
780          */
781         abb->efuse_base = devm_ioremap_nocache(dev, res->start,
782                                                resource_size(res));
783         if (!abb->efuse_base) {
784                 dev_err(dev, "Unable to map '%s'\n", pname);
785                 return -ENOMEM;
786         }
787 
788         pname = "ldo-address";
789         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
790         if (!res) {
791                 dev_dbg(dev, "Missing '%s' IO resource\n", pname);
792                 ret = -ENODEV;
793                 goto skip_opt;
794         }
795         abb->ldo_base = devm_ioremap_resource(dev, res);
796         if (IS_ERR(abb->ldo_base))
797                 return PTR_ERR(abb->ldo_base);
798 
799         /* IF ldo_base is set, the following are mandatory */
800         pname = "ti,ldovbb-override-mask";
801         ret =
802             of_property_read_u32(pdev->dev.of_node, pname,
803                                  &abb->ldovbb_override_mask);
804         if (ret) {
805                 dev_err(dev, "Missing '%s' (%d)\n", pname, ret);
806                 return ret;
807         }
808         if (!abb->ldovbb_override_mask) {
809                 dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
810                 return -EINVAL;
811         }
812 
813         pname = "ti,ldovbb-vset-mask";
814         ret =
815             of_property_read_u32(pdev->dev.of_node, pname,
816                                  &abb->ldovbb_vset_mask);
817         if (ret) {
818                 dev_err(dev, "Missing '%s' (%d)\n", pname, ret);
819                 return ret;
820         }
821         if (!abb->ldovbb_vset_mask) {
822                 dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
823                 return -EINVAL;
824         }
825 
826 skip_opt:
827         pname = "ti,tranxdone-status-mask";
828         ret =
829             of_property_read_u32(pdev->dev.of_node, pname,
830                                  &abb->txdone_mask);
831         if (ret) {
832                 dev_err(dev, "Missing '%s' (%d)\n", pname, ret);
833                 return ret;
834         }
835         if (!abb->txdone_mask) {
836                 dev_err(dev, "Invalid property:'%s' set as 0!\n", pname);
837                 return -EINVAL;
838         }
839 
840         initdata = of_get_regulator_init_data(dev, pdev->dev.of_node);
841         if (!initdata) {
842                 dev_err(dev, "%s: Unable to alloc regulator init data\n",
843                         __func__);
844                 return -ENOMEM;
845         }
846 
847         /* init ABB opp_sel table */
848         ret = ti_abb_init_table(dev, abb, initdata);
849         if (ret)
850                 return ret;
851 
852         /* init ABB timing */
853         ret = ti_abb_init_timings(dev, abb);
854         if (ret)
855                 return ret;
856 
857         desc = &abb->rdesc;
858         desc->name = dev_name(dev);
859         desc->owner = THIS_MODULE;
860         desc->type = REGULATOR_VOLTAGE;
861         desc->ops = &ti_abb_reg_ops;
862 
863         c = &initdata->constraints;
864         if (desc->n_voltages > 1)
865                 c->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE;
866         c->always_on = true;
867 
868         config.dev = dev;
869         config.init_data = initdata;
870         config.driver_data = abb;
871         config.of_node = pdev->dev.of_node;
872 
873         rdev = devm_regulator_register(dev, desc, &config);
874         if (IS_ERR(rdev)) {
875                 ret = PTR_ERR(rdev);
876                 dev_err(dev, "%s: failed to register regulator(%d)\n",
877                         __func__, ret);
878                 return ret;
879         }
880         platform_set_drvdata(pdev, rdev);
881 
882         /* Enable the ldo if not already done by bootloader */
883         ti_abb_rmw(abb->regs->sr2_en_mask, 1, abb->setup_reg);
884 
885         return 0;
886 }
887 
888 MODULE_ALIAS("platform:ti_abb");
889 
890 static struct platform_driver ti_abb_driver = {
891         .probe = ti_abb_probe,
892         .driver = {
893                    .name = "ti_abb",
894                    .owner = THIS_MODULE,
895                    .of_match_table = of_match_ptr(ti_abb_of_match),
896                    },
897 };
898 module_platform_driver(ti_abb_driver);
899 
900 MODULE_DESCRIPTION("Texas Instruments ABB LDO regulator driver");
901 MODULE_AUTHOR("Texas Instruments Inc.");
902 MODULE_LICENSE("GPL v2");
903 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us