arch/arm/mach-omap2/vp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/init.h>
   4
   5 #include "common.h"
   6
   7 #include "voltage.h"
   8 #include "vp.h"
   9 #include "prm-regbits-34xx.h"
  10 #include "prm-regbits-44xx.h"
  11 #include "prm44xx.h"
  12
  13 static u32 _vp_set_init_voltage(struct voltagedomain *voltdm, u32 volt)
  14 {
  15         struct omap_vp_instance *vp = voltdm->vp;
  16         u32 vpconfig;
  17         char vsel;
  18
  19         vsel = voltdm->pmic->uv_to_vsel(volt);
  20
  21         vpconfig = voltdm->read(vp->vpconfig);
  22         vpconfig &= ~(vp->common->vpconfig_initvoltage_mask |
  23                       vp->common->vpconfig_forceupdate |
  24                       vp->common->vpconfig_initvdd);
  25         vpconfig |= vsel << __ffs(vp->common->vpconfig_initvoltage_mask);
  26         voltdm->write(vpconfig, vp->vpconfig);
  27
  28         /* Trigger initVDD value copy to voltage processor */
  29         voltdm->write((vpconfig | vp->common->vpconfig_initvdd),
  30                        vp->vpconfig);
  31
  32         /* Clear initVDD copy trigger bit */
  33         voltdm->write(vpconfig, vp->vpconfig);
  34
  35         return vpconfig;
  36 }
  37
  38 /* Generic voltage init functions */
  39 void __init omap_vp_init(struct voltagedomain *voltdm)
  40 {
  41         struct omap_vp_instance *vp = voltdm->vp;
  42         u32 val, sys_clk_rate, timeout, waittime;
  43         u32 vddmin, vddmax, vstepmin, vstepmax;
  44
  45         if (!voltdm->pmic || !voltdm->pmic->uv_to_vsel) {
  46                 pr_err("%s: No PMIC info for vdd_%s\n", __func__, voltdm->name);
  47                 return;
  48         }
  49
  50         if (!voltdm->read || !voltdm->write) {
  51                 pr_err("%s: No read/write API for accessing vdd_%s regs\n",
  52                         __func__, voltdm->name);
  53                 return;
  54         }
  55
  56         vp->enabled = false;
  57
  58         /* Divide to avoid overflow */
  59         sys_clk_rate = voltdm->sys_clk.rate / 1000;
  60
  61         timeout = (sys_clk_rate * voltdm->pmic->vp_timeout_us) / 1000;
  62         vddmin = max(voltdm->vp_param->vddmin, voltdm->pmic->vddmin);
  63         vddmax = min(voltdm->vp_param->vddmax, voltdm->pmic->vddmax);
  64         vddmin = voltdm->pmic->uv_to_vsel(vddmin);
  65         vddmax = voltdm->pmic->uv_to_vsel(vddmax);
  66
  67         waittime = DIV_ROUND_UP(voltdm->pmic->step_size * sys_clk_rate,
  68                                 1000 * voltdm->pmic->slew_rate);
  69         vstepmin = voltdm->pmic->vp_vstepmin;
  70         vstepmax = voltdm->pmic->vp_vstepmax;
  71
  72         /*
  73          * VP_CONFIG: error gain is not set here, it will be updated
  74          * on each scale, based on OPP.
  75          */
  76         val = (voltdm->pmic->vp_erroroffset <<
  77                __ffs(voltdm->vp->common->vpconfig_erroroffset_mask)) |
  78                 vp->common->vpconfig_timeouten;
  79         voltdm->write(val, vp->vpconfig);
  80
  81         /* VSTEPMIN */
  82         val = (waittime << vp->common->vstepmin_smpswaittimemin_shift) |
  83                 (vstepmin <<  vp->common->vstepmin_stepmin_shift);
  84         voltdm->write(val, vp->vstepmin);
  85
  86         /* VSTEPMAX */
  87         val = (vstepmax << vp->common->vstepmax_stepmax_shift) |
  88                 (waittime << vp->common->vstepmax_smpswaittimemax_shift);
  89         voltdm->write(val, vp->vstepmax);
  90
  91         /* VLIMITTO */
  92         val = (vddmax << vp->common->vlimitto_vddmax_shift) |
  93                 (vddmin << vp->common->vlimitto_vddmin_shift) |
  94                 (timeout <<  vp->common->vlimitto_timeout_shift);
  95         voltdm->write(val, vp->vlimitto);
  96 }
  97
  98 int omap_vp_update_errorgain(struct voltagedomain *voltdm,
  99                              unsigned long target_volt)
 100 {
 101         struct omap_volt_data *volt_data;
 102
 103         if (!voltdm->vp)
 104                 return -EINVAL;
 105
 106         /* Get volt_data corresponding to target_volt */
 107         volt_data = omap_voltage_get_voltdata(voltdm, target_volt);
 108         if (IS_ERR(volt_data))
 109                 return -EINVAL;
 110
 111         /* Setting vp errorgain based on the voltage */
 112         voltdm->rmw(voltdm->vp->common->vpconfig_errorgain_mask,
 113                     volt_data->vp_errgain <<
 114                     __ffs(voltdm->vp->common->vpconfig_errorgain_mask),
 115                     voltdm->vp->vpconfig);
 116
 117         return 0;
 118 }
 119
 120 /* VP force update method of voltage scaling */
 121 int omap_vp_forceupdate_scale(struct voltagedomain *voltdm,
 122                               unsigned long target_volt)
 123 {
 124         struct omap_vp_instance *vp = voltdm->vp;
 125         u32 vpconfig;
 126         u8 target_vsel, current_vsel;
 127         int ret, timeout = 0;
 128
 129         ret = omap_vc_pre_scale(voltdm, target_volt, &target_vsel, &current_vsel);
 130         if (ret)
 131                 return ret;
 132
 133         /*
 134          * Clear all pending TransactionDone interrupt/status. Typical latency
 135          * is <3us
 136          */
 137         while (timeout++ < VP_TRANXDONE_TIMEOUT) {
 138                 vp->common->ops->clear_txdone(vp->id);
 139                 if (!vp->common->ops->check_txdone(vp->id))
 140                         break;
 141                 udelay(1);
 142         }
 143         if (timeout >= VP_TRANXDONE_TIMEOUT) {
 144                 pr_warn("%s: vdd_%s TRANXDONE timeout exceeded. Voltage change aborted\n",
 145                         __func__, voltdm->name);
 146                 return -ETIMEDOUT;
 147         }
 148
 149         vpconfig = _vp_set_init_voltage(voltdm, target_volt);
 150
 151         /* Force update of voltage */
 152         voltdm->write(vpconfig | vp->common->vpconfig_forceupdate,
 153                       voltdm->vp->vpconfig);
 154
 155         /*
 156          * Wait for TransactionDone. Typical latency is <200us.
 157          * Depends on SMPSWAITTIMEMIN/MAX and voltage change
 158          */
 159         timeout = 0;
 160         omap_test_timeout(vp->common->ops->check_txdone(vp->id),
 161                           VP_TRANXDONE_TIMEOUT, timeout);
 162         if (timeout >= VP_TRANXDONE_TIMEOUT)
 163                 pr_err("%s: vdd_%s TRANXDONE timeout exceeded. TRANXDONE never got set after the voltage update\n",
 164                        __func__, voltdm->name);
 165
 166         omap_vc_post_scale(voltdm, target_volt, target_vsel, current_vsel);
 167
 168         /*
 169          * Disable TransactionDone interrupt , clear all status, clear
 170          * control registers
 171          */
 172         timeout = 0;
 173         while (timeout++ < VP_TRANXDONE_TIMEOUT) {
 174                 vp->common->ops->clear_txdone(vp->id);
 175                 if (!vp->common->ops->check_txdone(vp->id))
 176                         break;
 177                 udelay(1);
 178         }
 179
 180         if (timeout >= VP_TRANXDONE_TIMEOUT)
 181                 pr_warn("%s: vdd_%s TRANXDONE timeout exceeded while trying to clear the TRANXDONE status\n",
 182                         __func__, voltdm->name);
 183
 184         /* Clear force bit */
 185         voltdm->write(vpconfig, vp->vpconfig);
 186
 187         return 0;
 188 }
 189
 190 /**
 191  * omap_vp_enable() - API to enable a particular VP
 192  * @voltdm:     pointer to the VDD whose VP is to be enabled.
 193  *
 194  * This API enables a particular voltage processor. Needed by the smartreflex
 195  * class drivers.
 196  */
 197 void omap_vp_enable(struct voltagedomain *voltdm)
 198 {
 199         struct omap_vp_instance *vp;
 200         u32 vpconfig, volt;
 201
 202         if (!voltdm || IS_ERR(voltdm)) {
 203                 pr_warn("%s: VDD specified does not exist!\n", __func__);
 204                 return;
 205         }
 206
 207         vp = voltdm->vp;
 208         if (!voltdm->read || !voltdm->write) {
 209                 pr_err("%s: No read/write API for accessing vdd_%s regs\n",
 210                         __func__, voltdm->name);
 211                 return;
 212         }
 213
 214         /* If VP is already enabled, do nothing. Return */
 215         if (vp->enabled)
 216                 return;
 217
 218         volt = voltdm_get_voltage(voltdm);
 219         if (!volt) {
 220                 pr_warn("%s: unable to find current voltage for %s\n",
 221                         __func__, voltdm->name);
 222                 return;
 223         }
 224
 225         vpconfig = _vp_set_init_voltage(voltdm, volt);
 226
 227         /* Enable VP */
 228         vpconfig |= vp->common->vpconfig_vpenable;
 229         voltdm->write(vpconfig, vp->vpconfig);
 230
 231         vp->enabled = true;
 232 }
 233
 234 /**
 235  * omap_vp_disable() - API to disable a particular VP
 236  * @voltdm:     pointer to the VDD whose VP is to be disabled.
 237  *
 238  * This API disables a particular voltage processor. Needed by the smartreflex
 239  * class drivers.
 240  */
 241 void omap_vp_disable(struct voltagedomain *voltdm)
 242 {
 243         struct omap_vp_instance *vp;
 244         u32 vpconfig;
 245         int timeout;
 246
 247         if (!voltdm || IS_ERR(voltdm)) {
 248                 pr_warn("%s: VDD specified does not exist!\n", __func__);
 249                 return;
 250         }
 251
 252         vp = voltdm->vp;
 253         if (!voltdm->read || !voltdm->write) {
 254                 pr_err("%s: No read/write API for accessing vdd_%s regs\n",
 255                         __func__, voltdm->name);
 256                 return;
 257         }
 258
 259         /* If VP is already disabled, do nothing. Return */
 260         if (!vp->enabled) {
 261                 pr_warn("%s: Trying to disable VP for vdd_%s when it is already disabled\n",
 262                         __func__, voltdm->name);
 263                 return;
 264         }
 265
 266         /* Disable VP */
 267         vpconfig = voltdm->read(vp->vpconfig);
 268         vpconfig &= ~vp->common->vpconfig_vpenable;
 269         voltdm->write(vpconfig, vp->vpconfig);
 270
 271         /*
 272          * Wait for VP idle Typical latency is <2us. Maximum latency is ~100us
 273          */
 274         omap_test_timeout((voltdm->read(vp->vstatus)),
 275                           VP_IDLE_TIMEOUT, timeout);
 276
 277         if (timeout >= VP_IDLE_TIMEOUT)
 278                 pr_warn("%s: vdd_%s idle timedout\n", __func__, voltdm->name);
 279
 280         vp->enabled = false;
 281
 282         return;
 283 }