Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 1 | /* |
| 2 | * OMAP Voltage Controller (VC) interface |
| 3 | * |
| 4 | * Copyright (C) 2011 Texas Instruments, Inc. |
| 5 | * |
| 6 | * This file is licensed under the terms of the GNU General Public |
| 7 | * License version 2. This program is licensed "as is" without any |
| 8 | * warranty of any kind, whether express or implied. |
| 9 | */ |
| 10 | #include <linux/kernel.h> |
| 11 | #include <linux/delay.h> |
| 12 | #include <linux/init.h> |
Tony Lindgren | 4647ca5 | 2012-03-08 10:20:14 -0800 | [diff] [blame] | 13 | #include <linux/bug.h> |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 14 | |
Tony Lindgren | dbc0416 | 2012-08-31 10:59:07 -0700 | [diff] [blame] | 15 | #include "soc.h" |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 16 | #include "voltage.h" |
| 17 | #include "vc.h" |
| 18 | #include "prm-regbits-34xx.h" |
| 19 | #include "prm-regbits-44xx.h" |
| 20 | #include "prm44xx.h" |
| 21 | |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 22 | /** |
| 23 | * struct omap_vc_channel_cfg - describe the cfg_channel bitfield |
| 24 | * @sa: bit for slave address |
| 25 | * @rav: bit for voltage configuration register |
| 26 | * @rac: bit for command configuration register |
| 27 | * @racen: enable bit for RAC |
| 28 | * @cmd: bit for command value set selection |
| 29 | * |
| 30 | * Channel configuration bits, common for OMAP3+ |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 31 | * OMAP3 register: PRM_VC_CH_CONF |
| 32 | * OMAP4 register: PRM_VC_CFG_CHANNEL |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 33 | * OMAP5 register: PRM_VC_SMPS_<voltdm>_CONFIG |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 34 | */ |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 35 | struct omap_vc_channel_cfg { |
| 36 | u8 sa; |
| 37 | u8 rav; |
| 38 | u8 rac; |
| 39 | u8 racen; |
| 40 | u8 cmd; |
| 41 | }; |
| 42 | |
| 43 | static struct omap_vc_channel_cfg vc_default_channel_cfg = { |
| 44 | .sa = BIT(0), |
| 45 | .rav = BIT(1), |
| 46 | .rac = BIT(2), |
| 47 | .racen = BIT(3), |
| 48 | .cmd = BIT(4), |
| 49 | }; |
| 50 | |
| 51 | /* |
| 52 | * On OMAP3+, all VC channels have the above default bitfield |
| 53 | * configuration, except the OMAP4 MPU channel. This appears |
| 54 | * to be a freak accident as every other VC channel has the |
| 55 | * default configuration, thus creating a mutant channel config. |
| 56 | */ |
| 57 | static struct omap_vc_channel_cfg vc_mutant_channel_cfg = { |
| 58 | .sa = BIT(0), |
| 59 | .rav = BIT(2), |
| 60 | .rac = BIT(3), |
| 61 | .racen = BIT(4), |
| 62 | .cmd = BIT(1), |
| 63 | }; |
| 64 | |
| 65 | static struct omap_vc_channel_cfg *vc_cfg_bits; |
| 66 | #define CFG_CHANNEL_MASK 0x1f |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 67 | |
| 68 | /** |
| 69 | * omap_vc_config_channel - configure VC channel to PMIC mappings |
| 70 | * @voltdm: pointer to voltagdomain defining the desired VC channel |
| 71 | * |
| 72 | * Configures the VC channel to PMIC mappings for the following |
| 73 | * PMIC settings |
| 74 | * - i2c slave address (SA) |
| 75 | * - voltage configuration address (RAV) |
| 76 | * - command configuration address (RAC) and enable bit (RACEN) |
| 77 | * - command values for ON, ONLP, RET and OFF (CMD) |
| 78 | * |
| 79 | * This function currently only allows flexible configuration of the |
| 80 | * non-default channel. Starting with OMAP4, there are more than 2 |
| 81 | * channels, with one defined as the default (on OMAP4, it's MPU.) |
| 82 | * Only the non-default channel can be configured. |
| 83 | */ |
| 84 | static int omap_vc_config_channel(struct voltagedomain *voltdm) |
| 85 | { |
| 86 | struct omap_vc_channel *vc = voltdm->vc; |
| 87 | |
| 88 | /* |
| 89 | * For default channel, the only configurable bit is RACEN. |
| 90 | * All others must stay at zero (see function comment above.) |
| 91 | */ |
| 92 | if (vc->flags & OMAP_VC_CHANNEL_DEFAULT) |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 93 | vc->cfg_channel &= vc_cfg_bits->racen; |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 94 | |
| 95 | voltdm->rmw(CFG_CHANNEL_MASK << vc->cfg_channel_sa_shift, |
| 96 | vc->cfg_channel << vc->cfg_channel_sa_shift, |
Kevin Hilman | 5876c94 | 2011-07-20 16:35:46 -0700 | [diff] [blame] | 97 | vc->cfg_channel_reg); |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 98 | |
| 99 | return 0; |
| 100 | } |
| 101 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 102 | /* Voltage scale and accessory APIs */ |
| 103 | int omap_vc_pre_scale(struct voltagedomain *voltdm, |
| 104 | unsigned long target_volt, |
| 105 | u8 *target_vsel, u8 *current_vsel) |
| 106 | { |
Kevin Hilman | d84adcf | 2011-03-22 16:14:57 -0700 | [diff] [blame] | 107 | struct omap_vc_channel *vc = voltdm->vc; |
Kevin Hilman | 76ea742 | 2011-04-05 15:15:31 -0700 | [diff] [blame] | 108 | u32 vc_cmdval; |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 109 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 110 | /* Check if sufficient pmic info is available for this vdd */ |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 111 | if (!voltdm->pmic) { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 112 | pr_err("%s: Insufficient pmic info to scale the vdd_%s\n", |
| 113 | __func__, voltdm->name); |
| 114 | return -EINVAL; |
| 115 | } |
| 116 | |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 117 | if (!voltdm->pmic->uv_to_vsel) { |
Paul Walmsley | 7852ec0 | 2012-07-26 00:54:26 -0600 | [diff] [blame] | 118 | pr_err("%s: PMIC function to convert voltage in uV to vsel not registered. Hence unable to scale voltage for vdd_%s\n", |
| 119 | __func__, voltdm->name); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 120 | return -ENODATA; |
| 121 | } |
| 122 | |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 123 | if (!voltdm->read || !voltdm->write) { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 124 | pr_err("%s: No read/write API for accessing vdd_%s regs\n", |
| 125 | __func__, voltdm->name); |
| 126 | return -EINVAL; |
| 127 | } |
| 128 | |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 129 | *target_vsel = voltdm->pmic->uv_to_vsel(target_volt); |
Kevin Hilman | 7590f60 | 2011-04-05 16:55:22 -0700 | [diff] [blame] | 130 | *current_vsel = voltdm->pmic->uv_to_vsel(voltdm->nominal_volt); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 131 | |
| 132 | /* Setting the ON voltage to the new target voltage */ |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 133 | vc_cmdval = voltdm->read(vc->cmdval_reg); |
Kevin Hilman | d84adcf | 2011-03-22 16:14:57 -0700 | [diff] [blame] | 134 | vc_cmdval &= ~vc->common->cmd_on_mask; |
| 135 | vc_cmdval |= (*target_vsel << vc->common->cmd_on_shift); |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 136 | voltdm->write(vc_cmdval, vc->cmdval_reg); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 137 | |
Kevin Hilman | 76ea742 | 2011-04-05 15:15:31 -0700 | [diff] [blame] | 138 | omap_vp_update_errorgain(voltdm, target_volt); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 139 | |
| 140 | return 0; |
| 141 | } |
| 142 | |
| 143 | void omap_vc_post_scale(struct voltagedomain *voltdm, |
| 144 | unsigned long target_volt, |
| 145 | u8 target_vsel, u8 current_vsel) |
| 146 | { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 147 | u32 smps_steps = 0, smps_delay = 0; |
| 148 | |
| 149 | smps_steps = abs(target_vsel - current_vsel); |
| 150 | /* SMPS slew rate / step size. 2us added as buffer. */ |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 151 | smps_delay = ((smps_steps * voltdm->pmic->step_size) / |
| 152 | voltdm->pmic->slew_rate) + 2; |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 153 | udelay(smps_delay); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 154 | } |
| 155 | |
Kevin Hilman | d84adcf | 2011-03-22 16:14:57 -0700 | [diff] [blame] | 156 | /* vc_bypass_scale - VC bypass method of voltage scaling */ |
| 157 | int omap_vc_bypass_scale(struct voltagedomain *voltdm, |
| 158 | unsigned long target_volt) |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 159 | { |
Kevin Hilman | d84adcf | 2011-03-22 16:14:57 -0700 | [diff] [blame] | 160 | struct omap_vc_channel *vc = voltdm->vc; |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 161 | u32 loop_cnt = 0, retries_cnt = 0; |
| 162 | u32 vc_valid, vc_bypass_val_reg, vc_bypass_value; |
| 163 | u8 target_vsel, current_vsel; |
| 164 | int ret; |
| 165 | |
| 166 | ret = omap_vc_pre_scale(voltdm, target_volt, &target_vsel, ¤t_vsel); |
| 167 | if (ret) |
| 168 | return ret; |
| 169 | |
Kevin Hilman | d84adcf | 2011-03-22 16:14:57 -0700 | [diff] [blame] | 170 | vc_valid = vc->common->valid; |
| 171 | vc_bypass_val_reg = vc->common->bypass_val_reg; |
| 172 | vc_bypass_value = (target_vsel << vc->common->data_shift) | |
Kevin Hilman | 78614e0 | 2011-03-29 14:24:47 -0700 | [diff] [blame] | 173 | (vc->volt_reg_addr << vc->common->regaddr_shift) | |
| 174 | (vc->i2c_slave_addr << vc->common->slaveaddr_shift); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 175 | |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 176 | voltdm->write(vc_bypass_value, vc_bypass_val_reg); |
| 177 | voltdm->write(vc_bypass_value | vc_valid, vc_bypass_val_reg); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 178 | |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 179 | vc_bypass_value = voltdm->read(vc_bypass_val_reg); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 180 | /* |
| 181 | * Loop till the bypass command is acknowledged from the SMPS. |
| 182 | * NOTE: This is legacy code. The loop count and retry count needs |
| 183 | * to be revisited. |
| 184 | */ |
| 185 | while (!(vc_bypass_value & vc_valid)) { |
| 186 | loop_cnt++; |
| 187 | |
| 188 | if (retries_cnt > 10) { |
| 189 | pr_warning("%s: Retry count exceeded\n", __func__); |
| 190 | return -ETIMEDOUT; |
| 191 | } |
| 192 | |
| 193 | if (loop_cnt > 50) { |
| 194 | retries_cnt++; |
| 195 | loop_cnt = 0; |
| 196 | udelay(10); |
| 197 | } |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 198 | vc_bypass_value = voltdm->read(vc_bypass_val_reg); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | omap_vc_post_scale(voltdm, target_volt, target_vsel, current_vsel); |
| 202 | return 0; |
| 203 | } |
| 204 | |
| 205 | static void __init omap3_vfsm_init(struct voltagedomain *voltdm) |
| 206 | { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 207 | /* |
| 208 | * Voltage Manager FSM parameters init |
| 209 | * XXX This data should be passed in from the board file |
| 210 | */ |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 211 | voltdm->write(OMAP3_CLKSETUP, OMAP3_PRM_CLKSETUP_OFFSET); |
| 212 | voltdm->write(OMAP3_VOLTOFFSET, OMAP3_PRM_VOLTOFFSET_OFFSET); |
| 213 | voltdm->write(OMAP3_VOLTSETUP2, OMAP3_PRM_VOLTSETUP2_OFFSET); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 214 | } |
| 215 | |
| 216 | static void __init omap3_vc_init_channel(struct voltagedomain *voltdm) |
| 217 | { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 218 | static bool is_initialized; |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 219 | |
| 220 | if (is_initialized) |
| 221 | return; |
| 222 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 223 | omap3_vfsm_init(voltdm); |
| 224 | |
| 225 | is_initialized = true; |
| 226 | } |
| 227 | |
| 228 | |
| 229 | /* OMAP4 specific voltage init functions */ |
| 230 | static void __init omap4_vc_init_channel(struct voltagedomain *voltdm) |
| 231 | { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 232 | static bool is_initialized; |
| 233 | u32 vc_val; |
| 234 | |
| 235 | if (is_initialized) |
| 236 | return; |
| 237 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 238 | /* XXX These are magic numbers and do not belong! */ |
| 239 | vc_val = (0x60 << OMAP4430_SCLL_SHIFT | 0x26 << OMAP4430_SCLH_SHIFT); |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 240 | voltdm->write(vc_val, OMAP4_PRM_VC_CFG_I2C_CLK_OFFSET); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 241 | |
| 242 | is_initialized = true; |
| 243 | } |
| 244 | |
Kevin Hilman | f539548 | 2011-03-30 16:36:30 -0700 | [diff] [blame] | 245 | /** |
| 246 | * omap_vc_i2c_init - initialize I2C interface to PMIC |
| 247 | * @voltdm: voltage domain containing VC data |
| 248 | * |
Russell King | 2d5b479 | 2012-02-07 10:13:02 +0000 | [diff] [blame] | 249 | * Use PMIC supplied settings for I2C high-speed mode and |
Kevin Hilman | f539548 | 2011-03-30 16:36:30 -0700 | [diff] [blame] | 250 | * master code (if set) and program the VC I2C configuration |
| 251 | * register. |
| 252 | * |
| 253 | * The VC I2C configuration is common to all VC channels, |
| 254 | * so this function only configures I2C for the first VC |
| 255 | * channel registers. All other VC channels will use the |
| 256 | * same configuration. |
| 257 | */ |
| 258 | static void __init omap_vc_i2c_init(struct voltagedomain *voltdm) |
| 259 | { |
| 260 | struct omap_vc_channel *vc = voltdm->vc; |
| 261 | static bool initialized; |
| 262 | static bool i2c_high_speed; |
| 263 | u8 mcode; |
| 264 | |
| 265 | if (initialized) { |
| 266 | if (voltdm->pmic->i2c_high_speed != i2c_high_speed) |
Kevin Hilman | 43993e4 | 2012-10-25 10:30:34 -0700 | [diff] [blame] | 267 | pr_warn("%s: I2C config for vdd_%s does not match other channels (%u).\n", |
Russell King | 0bf68f5 | 2012-02-07 10:23:43 +0000 | [diff] [blame] | 268 | __func__, voltdm->name, i2c_high_speed); |
Kevin Hilman | f539548 | 2011-03-30 16:36:30 -0700 | [diff] [blame] | 269 | return; |
| 270 | } |
| 271 | |
| 272 | i2c_high_speed = voltdm->pmic->i2c_high_speed; |
| 273 | if (i2c_high_speed) |
| 274 | voltdm->rmw(vc->common->i2c_cfg_hsen_mask, |
| 275 | vc->common->i2c_cfg_hsen_mask, |
| 276 | vc->common->i2c_cfg_reg); |
| 277 | |
| 278 | mcode = voltdm->pmic->i2c_mcode; |
| 279 | if (mcode) |
| 280 | voltdm->rmw(vc->common->i2c_mcode_mask, |
| 281 | mcode << __ffs(vc->common->i2c_mcode_mask), |
| 282 | vc->common->i2c_cfg_reg); |
| 283 | |
| 284 | initialized = true; |
| 285 | } |
| 286 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 287 | void __init omap_vc_init_channel(struct voltagedomain *voltdm) |
| 288 | { |
Kevin Hilman | d84adcf | 2011-03-22 16:14:57 -0700 | [diff] [blame] | 289 | struct omap_vc_channel *vc = voltdm->vc; |
Kevin Hilman | 08d1c9a | 2011-03-29 15:14:38 -0700 | [diff] [blame] | 290 | u8 on_vsel, onlp_vsel, ret_vsel, off_vsel; |
| 291 | u32 val; |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 292 | |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 293 | if (!voltdm->pmic || !voltdm->pmic->uv_to_vsel) { |
Russell King | 2d5b479 | 2012-02-07 10:13:02 +0000 | [diff] [blame] | 294 | pr_err("%s: No PMIC info for vdd_%s\n", __func__, voltdm->name); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 295 | return; |
| 296 | } |
| 297 | |
Kevin Hilman | 4bcc475 | 2011-03-28 10:40:15 -0700 | [diff] [blame] | 298 | if (!voltdm->read || !voltdm->write) { |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 299 | pr_err("%s: No read/write API for accessing vdd_%s regs\n", |
| 300 | __func__, voltdm->name); |
| 301 | return; |
| 302 | } |
| 303 | |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 304 | vc->cfg_channel = 0; |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 305 | if (vc->flags & OMAP_VC_CHANNEL_CFG_MUTANT) |
| 306 | vc_cfg_bits = &vc_mutant_channel_cfg; |
| 307 | else |
| 308 | vc_cfg_bits = &vc_default_channel_cfg; |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 309 | |
Kevin Hilman | ba112a4 | 2011-03-29 14:02:36 -0700 | [diff] [blame] | 310 | /* get PMIC/board specific settings */ |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 311 | vc->i2c_slave_addr = voltdm->pmic->i2c_slave_addr; |
| 312 | vc->volt_reg_addr = voltdm->pmic->volt_reg_addr; |
| 313 | vc->cmd_reg_addr = voltdm->pmic->cmd_reg_addr; |
| 314 | vc->setup_time = voltdm->pmic->volt_setup_time; |
Kevin Hilman | ba112a4 | 2011-03-29 14:02:36 -0700 | [diff] [blame] | 315 | |
| 316 | /* Configure the i2c slave address for this VC */ |
| 317 | voltdm->rmw(vc->smps_sa_mask, |
| 318 | vc->i2c_slave_addr << __ffs(vc->smps_sa_mask), |
Kevin Hilman | 5876c94 | 2011-07-20 16:35:46 -0700 | [diff] [blame] | 319 | vc->smps_sa_reg); |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 320 | vc->cfg_channel |= vc_cfg_bits->sa; |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 321 | |
Kevin Hilman | e4e021c | 2011-06-09 11:01:55 -0700 | [diff] [blame] | 322 | /* |
| 323 | * Configure the PMIC register addresses. |
| 324 | */ |
| 325 | voltdm->rmw(vc->smps_volra_mask, |
| 326 | vc->volt_reg_addr << __ffs(vc->smps_volra_mask), |
Kevin Hilman | 5876c94 | 2011-07-20 16:35:46 -0700 | [diff] [blame] | 327 | vc->smps_volra_reg); |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 328 | vc->cfg_channel |= vc_cfg_bits->rav; |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 329 | |
| 330 | if (vc->cmd_reg_addr) { |
Kevin Hilman | e4e021c | 2011-06-09 11:01:55 -0700 | [diff] [blame] | 331 | voltdm->rmw(vc->smps_cmdra_mask, |
| 332 | vc->cmd_reg_addr << __ffs(vc->smps_cmdra_mask), |
Kevin Hilman | 5876c94 | 2011-07-20 16:35:46 -0700 | [diff] [blame] | 333 | vc->smps_cmdra_reg); |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 334 | vc->cfg_channel |= vc_cfg_bits->rac | vc_cfg_bits->racen; |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 335 | } |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 336 | |
Kevin Hilman | 08d1c9a | 2011-03-29 15:14:38 -0700 | [diff] [blame] | 337 | /* Set up the on, inactive, retention and off voltage */ |
Kevin Hilman | ce8ebe0 | 2011-03-30 11:01:10 -0700 | [diff] [blame] | 338 | on_vsel = voltdm->pmic->uv_to_vsel(voltdm->pmic->on_volt); |
| 339 | onlp_vsel = voltdm->pmic->uv_to_vsel(voltdm->pmic->onlp_volt); |
| 340 | ret_vsel = voltdm->pmic->uv_to_vsel(voltdm->pmic->ret_volt); |
| 341 | off_vsel = voltdm->pmic->uv_to_vsel(voltdm->pmic->off_volt); |
Kevin Hilman | 08d1c9a | 2011-03-29 15:14:38 -0700 | [diff] [blame] | 342 | val = ((on_vsel << vc->common->cmd_on_shift) | |
| 343 | (onlp_vsel << vc->common->cmd_onlp_shift) | |
| 344 | (ret_vsel << vc->common->cmd_ret_shift) | |
| 345 | (off_vsel << vc->common->cmd_off_shift)); |
| 346 | voltdm->write(val, vc->cmdval_reg); |
Kevin Hilman | 8abc0b5 | 2011-06-02 17:28:13 -0700 | [diff] [blame] | 347 | vc->cfg_channel |= vc_cfg_bits->cmd; |
Kevin Hilman | 24d3194 | 2011-03-29 15:57:16 -0700 | [diff] [blame] | 348 | |
| 349 | /* Channel configuration */ |
| 350 | omap_vc_config_channel(voltdm); |
Kevin Hilman | 08d1c9a | 2011-03-29 15:14:38 -0700 | [diff] [blame] | 351 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 352 | /* Configure the setup times */ |
Kevin Hilman | 5892bb1 | 2011-03-29 14:36:04 -0700 | [diff] [blame] | 353 | voltdm->rmw(voltdm->vfsm->voltsetup_mask, |
| 354 | vc->setup_time << __ffs(voltdm->vfsm->voltsetup_mask), |
| 355 | voltdm->vfsm->voltsetup_reg); |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 356 | |
Kevin Hilman | f539548 | 2011-03-30 16:36:30 -0700 | [diff] [blame] | 357 | omap_vc_i2c_init(voltdm); |
| 358 | |
Kevin Hilman | ccd5ca7 | 2011-03-21 14:08:55 -0700 | [diff] [blame] | 359 | if (cpu_is_omap34xx()) |
| 360 | omap3_vc_init_channel(voltdm); |
| 361 | else if (cpu_is_omap44xx()) |
| 362 | omap4_vc_init_channel(voltdm); |
| 363 | } |
| 364 | |