| .. | .. |
|---|
| 1 | +// SPDX-License-Identifier: GPL-2.0-only |
|---|
| 1 | 2 | /* |
|---|
| 2 | 3 | * LP8755 High Performance Power Management Unit : System Interface Driver |
|---|
| 3 | 4 | * (based on rev. 0.26) |
|---|
| 4 | 5 | * Copyright 2012 Texas Instruments |
|---|
| 5 | 6 | * |
|---|
| 6 | 7 | * Author: Daniel(Geon Si) Jeong <daniel.jeong@ti.com> |
|---|
| 7 | | - * |
|---|
| 8 | | - * This program is free software; you can redistribute it and/or modify |
|---|
| 9 | | - * it under the terms of the GNU General Public License version 2 as |
|---|
| 10 | | - * published by the Free Software Foundation. |
|---|
| 11 | | - * |
|---|
| 12 | 8 | */ |
|---|
| 13 | 9 | |
|---|
| 14 | 10 | #include <linux/module.h> |
|---|
| .. | .. |
|---|
| 53 | 49 | struct regulator_dev *rdev[LP8755_BUCK_MAX]; |
|---|
| 54 | 50 | }; |
|---|
| 55 | 51 | |
|---|
| 56 | | -/** |
|---|
| 57 | | - *lp8755_read : read a single register value from lp8755. |
|---|
| 58 | | - *@pchip : device to read from |
|---|
| 59 | | - *@reg : register to read from |
|---|
| 60 | | - *@val : pointer to store read value |
|---|
| 61 | | - */ |
|---|
| 62 | | -static int lp8755_read(struct lp8755_chip *pchip, unsigned int reg, |
|---|
| 63 | | - unsigned int *val) |
|---|
| 64 | | -{ |
|---|
| 65 | | - return regmap_read(pchip->regmap, reg, val); |
|---|
| 66 | | -} |
|---|
| 67 | | - |
|---|
| 68 | | -/** |
|---|
| 69 | | - *lp8755_write : write a single register value to lp8755. |
|---|
| 70 | | - *@pchip : device to write to |
|---|
| 71 | | - *@reg : register to write to |
|---|
| 72 | | - *@val : value to be written |
|---|
| 73 | | - */ |
|---|
| 74 | | -static int lp8755_write(struct lp8755_chip *pchip, unsigned int reg, |
|---|
| 75 | | - unsigned int val) |
|---|
| 76 | | -{ |
|---|
| 77 | | - return regmap_write(pchip->regmap, reg, val); |
|---|
| 78 | | -} |
|---|
| 79 | | - |
|---|
| 80 | | -/** |
|---|
| 81 | | - *lp8755_update_bits : set the values of bit fields in lp8755 register. |
|---|
| 82 | | - *@pchip : device to read from |
|---|
| 83 | | - *@reg : register to update |
|---|
| 84 | | - *@mask : bitmask to be changed |
|---|
| 85 | | - *@val : value for bitmask |
|---|
| 86 | | - */ |
|---|
| 87 | | -static int lp8755_update_bits(struct lp8755_chip *pchip, unsigned int reg, |
|---|
| 88 | | - unsigned int mask, unsigned int val) |
|---|
| 89 | | -{ |
|---|
| 90 | | - return regmap_update_bits(pchip->regmap, reg, mask, val); |
|---|
| 91 | | -} |
|---|
| 92 | | - |
|---|
| 93 | 52 | static int lp8755_buck_enable_time(struct regulator_dev *rdev) |
|---|
| 94 | 53 | { |
|---|
| 95 | 54 | int ret; |
|---|
| 96 | 55 | unsigned int regval; |
|---|
| 97 | 56 | enum lp8755_bucks id = rdev_get_id(rdev); |
|---|
| 98 | | - struct lp8755_chip *pchip = rdev_get_drvdata(rdev); |
|---|
| 99 | 57 | |
|---|
| 100 | | - ret = lp8755_read(pchip, 0x12 + id, ®val); |
|---|
| 58 | + ret = regmap_read(rdev->regmap, 0x12 + id, ®val); |
|---|
| 101 | 59 | if (ret < 0) { |
|---|
| 102 | | - dev_err(pchip->dev, "i2c access error %s\n", __func__); |
|---|
| 60 | + dev_err(&rdev->dev, "i2c access error %s\n", __func__); |
|---|
| 103 | 61 | return ret; |
|---|
| 104 | 62 | } |
|---|
| 105 | 63 | return (regval & 0xff) * 100; |
|---|
| .. | .. |
|---|
| 119 | 77 | break; |
|---|
| 120 | 78 | case REGULATOR_MODE_NORMAL: |
|---|
| 121 | 79 | /* enable automatic pwm/pfm mode */ |
|---|
| 122 | | - ret = lp8755_update_bits(pchip, 0x08 + id, 0x20, 0x00); |
|---|
| 80 | + ret = regmap_update_bits(rdev->regmap, 0x08 + id, 0x20, 0x00); |
|---|
| 123 | 81 | if (ret < 0) |
|---|
| 124 | 82 | goto err_i2c; |
|---|
| 125 | 83 | break; |
|---|
| 126 | 84 | case REGULATOR_MODE_IDLE: |
|---|
| 127 | 85 | /* enable automatic pwm/pfm/lppfm mode */ |
|---|
| 128 | | - ret = lp8755_update_bits(pchip, 0x08 + id, 0x20, 0x20); |
|---|
| 86 | + ret = regmap_update_bits(rdev->regmap, 0x08 + id, 0x20, 0x20); |
|---|
| 129 | 87 | if (ret < 0) |
|---|
| 130 | 88 | goto err_i2c; |
|---|
| 131 | 89 | |
|---|
| 132 | | - ret = lp8755_update_bits(pchip, 0x10, 0x01, 0x01); |
|---|
| 90 | + ret = regmap_update_bits(rdev->regmap, 0x10, 0x01, 0x01); |
|---|
| 133 | 91 | if (ret < 0) |
|---|
| 134 | 92 | goto err_i2c; |
|---|
| 135 | 93 | break; |
|---|
| .. | .. |
|---|
| 139 | 97 | regbval = (0x01 << id); |
|---|
| 140 | 98 | } |
|---|
| 141 | 99 | |
|---|
| 142 | | - ret = lp8755_update_bits(pchip, 0x06, 0x01 << id, regbval); |
|---|
| 100 | + ret = regmap_update_bits(rdev->regmap, 0x06, 0x01 << id, regbval); |
|---|
| 143 | 101 | if (ret < 0) |
|---|
| 144 | 102 | goto err_i2c; |
|---|
| 145 | 103 | return ret; |
|---|
| 146 | 104 | err_i2c: |
|---|
| 147 | | - dev_err(pchip->dev, "i2c access error %s\n", __func__); |
|---|
| 105 | + dev_err(&rdev->dev, "i2c access error %s\n", __func__); |
|---|
| 148 | 106 | return ret; |
|---|
| 149 | 107 | } |
|---|
| 150 | 108 | |
|---|
| .. | .. |
|---|
| 153 | 111 | int ret; |
|---|
| 154 | 112 | unsigned int regval; |
|---|
| 155 | 113 | enum lp8755_bucks id = rdev_get_id(rdev); |
|---|
| 156 | | - struct lp8755_chip *pchip = rdev_get_drvdata(rdev); |
|---|
| 157 | 114 | |
|---|
| 158 | | - ret = lp8755_read(pchip, 0x06, ®val); |
|---|
| 115 | + ret = regmap_read(rdev->regmap, 0x06, ®val); |
|---|
| 159 | 116 | if (ret < 0) |
|---|
| 160 | 117 | goto err_i2c; |
|---|
| 161 | 118 | |
|---|
| .. | .. |
|---|
| 163 | 120 | if (regval & (0x01 << id)) |
|---|
| 164 | 121 | return REGULATOR_MODE_FAST; |
|---|
| 165 | 122 | |
|---|
| 166 | | - ret = lp8755_read(pchip, 0x08 + id, ®val); |
|---|
| 123 | + ret = regmap_read(rdev->regmap, 0x08 + id, ®val); |
|---|
| 167 | 124 | if (ret < 0) |
|---|
| 168 | 125 | goto err_i2c; |
|---|
| 169 | 126 | |
|---|
| .. | .. |
|---|
| 175 | 132 | return REGULATOR_MODE_NORMAL; |
|---|
| 176 | 133 | |
|---|
| 177 | 134 | err_i2c: |
|---|
| 178 | | - dev_err(pchip->dev, "i2c access error %s\n", __func__); |
|---|
| 135 | + dev_err(&rdev->dev, "i2c access error %s\n", __func__); |
|---|
| 179 | 136 | return 0; |
|---|
| 180 | 137 | } |
|---|
| 181 | 138 | |
|---|
| .. | .. |
|---|
| 184 | 141 | int ret; |
|---|
| 185 | 142 | unsigned int regval = 0x00; |
|---|
| 186 | 143 | enum lp8755_bucks id = rdev_get_id(rdev); |
|---|
| 187 | | - struct lp8755_chip *pchip = rdev_get_drvdata(rdev); |
|---|
| 188 | 144 | |
|---|
| 189 | 145 | /* uV/us */ |
|---|
| 190 | 146 | switch (ramp) { |
|---|
| .. | .. |
|---|
| 213 | 169 | regval = 0x00; |
|---|
| 214 | 170 | break; |
|---|
| 215 | 171 | default: |
|---|
| 216 | | - dev_err(pchip->dev, |
|---|
| 172 | + dev_err(&rdev->dev, |
|---|
| 217 | 173 | "Not supported ramp value %d %s\n", ramp, __func__); |
|---|
| 218 | 174 | return -EINVAL; |
|---|
| 219 | 175 | } |
|---|
| 220 | 176 | |
|---|
| 221 | | - ret = lp8755_update_bits(pchip, 0x07 + id, 0x07, regval); |
|---|
| 177 | + ret = regmap_update_bits(rdev->regmap, 0x07 + id, 0x07, regval); |
|---|
| 222 | 178 | if (ret < 0) |
|---|
| 223 | 179 | goto err_i2c; |
|---|
| 224 | 180 | return ret; |
|---|
| 225 | 181 | err_i2c: |
|---|
| 226 | | - dev_err(pchip->dev, "i2c access error %s\n", __func__); |
|---|
| 182 | + dev_err(&rdev->dev, "i2c access error %s\n", __func__); |
|---|
| 227 | 183 | return ret; |
|---|
| 228 | 184 | } |
|---|
| 229 | 185 | |
|---|
| .. | .. |
|---|
| 282 | 238 | struct lp8755_platform_data *pdata = pchip->pdata; |
|---|
| 283 | 239 | |
|---|
| 284 | 240 | /* read back muti-phase configuration */ |
|---|
| 285 | | - ret = lp8755_read(pchip, 0x3D, ®val); |
|---|
| 241 | + ret = regmap_read(pchip->regmap, 0x3D, ®val); |
|---|
| 286 | 242 | if (ret < 0) |
|---|
| 287 | 243 | goto out_i2c_error; |
|---|
| 288 | 244 | pchip->mphase = regval & 0x0F; |
|---|
| .. | .. |
|---|
| 315 | 271 | .vsel_mask = LP8755_BUCK_VOUT_M,\ |
|---|
| 316 | 272 | } |
|---|
| 317 | 273 | |
|---|
| 318 | | -static struct regulator_desc lp8755_regulators[] = { |
|---|
| 274 | +static const struct regulator_desc lp8755_regulators[] = { |
|---|
| 319 | 275 | lp8755_buck_desc(0), |
|---|
| 320 | 276 | lp8755_buck_desc(1), |
|---|
| 321 | 277 | lp8755_buck_desc(2), |
|---|
| .. | .. |
|---|
| 360 | 316 | struct lp8755_chip *pchip = data; |
|---|
| 361 | 317 | |
|---|
| 362 | 318 | /* read flag0 register */ |
|---|
| 363 | | - ret = lp8755_read(pchip, 0x0D, &flag0); |
|---|
| 319 | + ret = regmap_read(pchip->regmap, 0x0D, &flag0); |
|---|
| 364 | 320 | if (ret < 0) |
|---|
| 365 | 321 | goto err_i2c; |
|---|
| 366 | 322 | /* clear flag register to pull up int. pin */ |
|---|
| 367 | | - ret = lp8755_write(pchip, 0x0D, 0x00); |
|---|
| 323 | + ret = regmap_write(pchip->regmap, 0x0D, 0x00); |
|---|
| 368 | 324 | if (ret < 0) |
|---|
| 369 | 325 | goto err_i2c; |
|---|
| 370 | 326 | |
|---|
| .. | .. |
|---|
| 372 | 328 | for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) |
|---|
| 373 | 329 | if ((flag0 & (0x4 << icnt)) |
|---|
| 374 | 330 | && (pchip->irqmask & (0x04 << icnt)) |
|---|
| 375 | | - && (pchip->rdev[icnt] != NULL)) |
|---|
| 331 | + && (pchip->rdev[icnt] != NULL)) { |
|---|
| 376 | 332 | regulator_notifier_call_chain(pchip->rdev[icnt], |
|---|
| 377 | 333 | LP8755_EVENT_PWR_FAULT, |
|---|
| 378 | 334 | NULL); |
|---|
| 335 | + } |
|---|
| 379 | 336 | |
|---|
| 380 | 337 | /* read flag1 register */ |
|---|
| 381 | | - ret = lp8755_read(pchip, 0x0E, &flag1); |
|---|
| 338 | + ret = regmap_read(pchip->regmap, 0x0E, &flag1); |
|---|
| 382 | 339 | if (ret < 0) |
|---|
| 383 | 340 | goto err_i2c; |
|---|
| 384 | 341 | /* clear flag register to pull up int. pin */ |
|---|
| 385 | | - ret = lp8755_write(pchip, 0x0E, 0x00); |
|---|
| 342 | + ret = regmap_write(pchip->regmap, 0x0E, 0x00); |
|---|
| 386 | 343 | if (ret < 0) |
|---|
| 387 | 344 | goto err_i2c; |
|---|
| 388 | 345 | |
|---|
| 389 | | - /* send OCP event to all regualtor devices */ |
|---|
| 346 | + /* send OCP event to all regulator devices */ |
|---|
| 390 | 347 | if ((flag1 & 0x01) && (pchip->irqmask & 0x01)) |
|---|
| 391 | 348 | for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) |
|---|
| 392 | | - if (pchip->rdev[icnt] != NULL) |
|---|
| 349 | + if (pchip->rdev[icnt] != NULL) { |
|---|
| 393 | 350 | regulator_notifier_call_chain(pchip->rdev[icnt], |
|---|
| 394 | 351 | LP8755_EVENT_OCP, |
|---|
| 395 | 352 | NULL); |
|---|
| 353 | + } |
|---|
| 396 | 354 | |
|---|
| 397 | | - /* send OVP event to all regualtor devices */ |
|---|
| 355 | + /* send OVP event to all regulator devices */ |
|---|
| 398 | 356 | if ((flag1 & 0x02) && (pchip->irqmask & 0x02)) |
|---|
| 399 | 357 | for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) |
|---|
| 400 | | - if (pchip->rdev[icnt] != NULL) |
|---|
| 358 | + if (pchip->rdev[icnt] != NULL) { |
|---|
| 401 | 359 | regulator_notifier_call_chain(pchip->rdev[icnt], |
|---|
| 402 | 360 | LP8755_EVENT_OVP, |
|---|
| 403 | 361 | NULL); |
|---|
| 362 | + } |
|---|
| 404 | 363 | return IRQ_HANDLED; |
|---|
| 405 | 364 | |
|---|
| 406 | 365 | err_i2c: |
|---|
| .. | .. |
|---|
| 418 | 377 | return 0; |
|---|
| 419 | 378 | } |
|---|
| 420 | 379 | |
|---|
| 421 | | - ret = lp8755_read(pchip, 0x0F, ®val); |
|---|
| 380 | + ret = regmap_read(pchip->regmap, 0x0F, ®val); |
|---|
| 422 | 381 | if (ret < 0) { |
|---|
| 423 | 382 | dev_err(pchip->dev, "i2c access error %s\n", __func__); |
|---|
| 424 | 383 | return ret; |
|---|
| .. | .. |
|---|
| 497 | 456 | err: |
|---|
| 498 | 457 | /* output disable */ |
|---|
| 499 | 458 | for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) |
|---|
| 500 | | - lp8755_write(pchip, icnt, 0x00); |
|---|
| 459 | + regmap_write(pchip->regmap, icnt, 0x00); |
|---|
| 501 | 460 | |
|---|
| 502 | 461 | return ret; |
|---|
| 503 | 462 | } |
|---|
| .. | .. |
|---|
| 508 | 467 | struct lp8755_chip *pchip = i2c_get_clientdata(client); |
|---|
| 509 | 468 | |
|---|
| 510 | 469 | for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) |
|---|
| 511 | | - lp8755_write(pchip, icnt, 0x00); |
|---|
| 470 | + regmap_write(pchip->regmap, icnt, 0x00); |
|---|
| 512 | 471 | |
|---|
| 513 | 472 | return 0; |
|---|
| 514 | 473 | } |
|---|