1 /* 2 * max8973-regulator.c -- Maxim max8973 3 * 4 * Regulator driver for MAXIM 8973 DC-DC step-down switching regulator. 5 * 6 * Copyright (c) 2012, NVIDIA Corporation. 7 * 8 * Author: Laxman Dewangan <ldewangan@nvidia.com> 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License as 12 * published by the Free Software Foundation version 2. 13 * 14 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind, 15 * whether express or implied; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 22 * 02111-1307, USA 23 */ 24 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/err.h> 29 #include <linux/of.h> 30 #include <linux/of_device.h> 31 #include <linux/platform_device.h> 32 #include <linux/regulator/driver.h> 33 #include <linux/regulator/machine.h> 34 #include <linux/regulator/max8973-regulator.h> 35 #include <linux/regulator/of_regulator.h> 36 #include <linux/gpio.h> 37 #include <linux/of_gpio.h> 38 #include <linux/i2c.h> 39 #include <linux/slab.h> 40 #include <linux/regmap.h> 41 #include <linux/thermal.h> 42 #include <linux/irq.h> 43 #include <linux/interrupt.h> 44 45 /* Register definitions */ 46 #define MAX8973_VOUT 0x0 47 #define MAX8973_VOUT_DVS 0x1 48 #define MAX8973_CONTROL1 0x2 49 #define MAX8973_CONTROL2 0x3 50 #define MAX8973_CHIPID1 0x4 51 #define MAX8973_CHIPID2 0x5 52 53 #define MAX8973_MAX_VOUT_REG 2 54 55 /* MAX8973_VOUT */ 56 #define MAX8973_VOUT_ENABLE BIT(7) 57 #define MAX8973_VOUT_MASK 0x7F 58 59 /* MAX8973_VOUT_DVS */ 60 #define MAX8973_DVS_VOUT_MASK 0x7F 61 62 /* MAX8973_CONTROL1 */ 63 #define MAX8973_SNS_ENABLE BIT(7) 64 #define MAX8973_FPWM_EN_M BIT(6) 65 #define MAX8973_NFSR_ENABLE BIT(5) 66 #define MAX8973_AD_ENABLE BIT(4) 67 #define MAX8973_BIAS_ENABLE BIT(3) 68 #define MAX8973_FREQSHIFT_9PER BIT(2) 69 70 #define MAX8973_RAMP_12mV_PER_US 0x0 71 #define MAX8973_RAMP_25mV_PER_US 0x1 72 #define MAX8973_RAMP_50mV_PER_US 0x2 73 #define MAX8973_RAMP_200mV_PER_US 0x3 74 #define MAX8973_RAMP_MASK 0x3 75 76 /* MAX8973_CONTROL2 */ 77 #define MAX8973_WDTMR_ENABLE BIT(6) 78 #define MAX8973_DISCH_ENBABLE BIT(5) 79 #define MAX8973_FT_ENABLE BIT(4) 80 #define MAX77621_T_JUNCTION_120 BIT(7) 81 82 #define MAX8973_CKKADV_TRIP_MASK 0xC 83 #define MAX8973_CKKADV_TRIP_DISABLE 0xC 84 #define MAX8973_CKKADV_TRIP_75mV_PER_US 0x0 85 #define MAX8973_CKKADV_TRIP_150mV_PER_US 0x4 86 #define MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS 0x8 87 #define MAX8973_CONTROL_CLKADV_TRIP_MASK 0x00030000 88 89 #define MAX8973_INDUCTOR_MIN_30_PER 0x0 90 #define MAX8973_INDUCTOR_NOMINAL 0x1 91 #define MAX8973_INDUCTOR_PLUS_30_PER 0x2 92 #define MAX8973_INDUCTOR_PLUS_60_PER 0x3 93 #define MAX8973_CONTROL_INDUCTOR_VALUE_MASK 0x00300000 94 95 #define MAX8973_MIN_VOLATGE 606250 96 #define MAX8973_MAX_VOLATGE 1400000 97 #define MAX8973_VOLATGE_STEP 6250 98 #define MAX8973_BUCK_N_VOLTAGE 0x80 99 100 #define MAX77621_CHIPID_TJINT_S BIT(0) 101 102 #define MAX77621_NORMAL_OPERATING_TEMP 100000 103 #define MAX77621_TJINT_WARNING_TEMP_120 120000 104 #define MAX77621_TJINT_WARNING_TEMP_140 140000 105 106 enum device_id { 107 MAX8973, 108 MAX77621 109 }; 110 111 /* Maxim 8973 chip information */ 112 struct max8973_chip { 113 struct device *dev; 114 struct regulator_desc desc; 115 struct regmap *regmap; 116 bool enable_external_control; 117 int enable_gpio; 118 int dvs_gpio; 119 int lru_index[MAX8973_MAX_VOUT_REG]; 120 int curr_vout_val[MAX8973_MAX_VOUT_REG]; 121 int curr_vout_reg; 122 int curr_gpio_val; 123 struct regulator_ops ops; 124 enum device_id id; 125 int junction_temp_warning; 126 int irq; 127 struct thermal_zone_device *tz_device; 128 }; 129 130 /* 131 * find_voltage_set_register: Find new voltage configuration register (VOUT). 132 * The finding of the new VOUT register will be based on the LRU mechanism. 133 * Each VOUT register will have different voltage configured . This 134 * Function will look if any of the VOUT register have requested voltage set 135 * or not. 136 * - If it is already there then it will make that register as most 137 * recently used and return as found so that caller need not to set 138 * the VOUT register but need to set the proper gpios to select this 139 * VOUT register. 140 * - If requested voltage is not found then it will use the least 141 * recently mechanism to get new VOUT register for new configuration 142 * and will return not_found so that caller need to set new VOUT 143 * register and then gpios (both). 144 */ 145 static bool find_voltage_set_register(struct max8973_chip *tps, 146 int req_vsel, int *vout_reg, int *gpio_val) 147 { 148 int i; 149 bool found = false; 150 int new_vout_reg = tps->lru_index[MAX8973_MAX_VOUT_REG - 1]; 151 int found_index = MAX8973_MAX_VOUT_REG - 1; 152 153 for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) { 154 if (tps->curr_vout_val[tps->lru_index[i]] == req_vsel) { 155 new_vout_reg = tps->lru_index[i]; 156 found_index = i; 157 found = true; 158 goto update_lru_index; 159 } 160 } 161 162 update_lru_index: 163 for (i = found_index; i > 0; i--) 164 tps->lru_index[i] = tps->lru_index[i - 1]; 165 166 tps->lru_index[0] = new_vout_reg; 167 *gpio_val = new_vout_reg; 168 *vout_reg = MAX8973_VOUT + new_vout_reg; 169 return found; 170 } 171 172 static int max8973_dcdc_get_voltage_sel(struct regulator_dev *rdev) 173 { 174 struct max8973_chip *max = rdev_get_drvdata(rdev); 175 unsigned int data; 176 int ret; 177 178 ret = regmap_read(max->regmap, max->curr_vout_reg, &data); 179 if (ret < 0) { 180 dev_err(max->dev, "register %d read failed, err = %d\n", 181 max->curr_vout_reg, ret); 182 return ret; 183 } 184 return data & MAX8973_VOUT_MASK; 185 } 186 187 static int max8973_dcdc_set_voltage_sel(struct regulator_dev *rdev, 188 unsigned vsel) 189 { 190 struct max8973_chip *max = rdev_get_drvdata(rdev); 191 int ret; 192 bool found = false; 193 int vout_reg = max->curr_vout_reg; 194 int gpio_val = max->curr_gpio_val; 195 196 /* 197 * If gpios are available to select the VOUT register then least 198 * recently used register for new configuration. 199 */ 200 if (gpio_is_valid(max->dvs_gpio)) 201 found = find_voltage_set_register(max, vsel, 202 &vout_reg, &gpio_val); 203 204 if (!found) { 205 ret = regmap_update_bits(max->regmap, vout_reg, 206 MAX8973_VOUT_MASK, vsel); 207 if (ret < 0) { 208 dev_err(max->dev, "register %d update failed, err %d\n", 209 vout_reg, ret); 210 return ret; 211 } 212 max->curr_vout_reg = vout_reg; 213 max->curr_vout_val[gpio_val] = vsel; 214 } 215 216 /* Select proper VOUT register vio gpios */ 217 if (gpio_is_valid(max->dvs_gpio)) { 218 gpio_set_value_cansleep(max->dvs_gpio, gpio_val & 0x1); 219 max->curr_gpio_val = gpio_val; 220 } 221 return 0; 222 } 223 224 static int max8973_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode) 225 { 226 struct max8973_chip *max = rdev_get_drvdata(rdev); 227 int ret; 228 int pwm; 229 230 /* Enable force PWM mode in FAST mode only. */ 231 switch (mode) { 232 case REGULATOR_MODE_FAST: 233 pwm = MAX8973_FPWM_EN_M; 234 break; 235 236 case REGULATOR_MODE_NORMAL: 237 pwm = 0; 238 break; 239 240 default: 241 return -EINVAL; 242 } 243 244 ret = regmap_update_bits(max->regmap, MAX8973_CONTROL1, 245 MAX8973_FPWM_EN_M, pwm); 246 if (ret < 0) 247 dev_err(max->dev, "register %d update failed, err %d\n", 248 MAX8973_CONTROL1, ret); 249 return ret; 250 } 251 252 static unsigned int max8973_dcdc_get_mode(struct regulator_dev *rdev) 253 { 254 struct max8973_chip *max = rdev_get_drvdata(rdev); 255 unsigned int data; 256 int ret; 257 258 ret = regmap_read(max->regmap, MAX8973_CONTROL1, &data); 259 if (ret < 0) { 260 dev_err(max->dev, "register %d read failed, err %d\n", 261 MAX8973_CONTROL1, ret); 262 return ret; 263 } 264 return (data & MAX8973_FPWM_EN_M) ? 265 REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL; 266 } 267 268 static int max8973_set_ramp_delay(struct regulator_dev *rdev, 269 int ramp_delay) 270 { 271 struct max8973_chip *max = rdev_get_drvdata(rdev); 272 unsigned int control; 273 int ret; 274 int ret_val; 275 276 /* Set ramp delay */ 277 if (ramp_delay < 25000) { 278 control = MAX8973_RAMP_12mV_PER_US; 279 ret_val = 12000; 280 } else if (ramp_delay < 50000) { 281 control = MAX8973_RAMP_25mV_PER_US; 282 ret_val = 25000; 283 } else if (ramp_delay < 200000) { 284 control = MAX8973_RAMP_50mV_PER_US; 285 ret_val = 50000; 286 } else { 287 control = MAX8973_RAMP_200mV_PER_US; 288 ret_val = 200000; 289 } 290 291 ret = regmap_update_bits(max->regmap, MAX8973_CONTROL1, 292 MAX8973_RAMP_MASK, control); 293 if (ret < 0) 294 dev_err(max->dev, "register %d update failed, %d", 295 MAX8973_CONTROL1, ret); 296 return ret; 297 } 298 299 static int max8973_set_current_limit(struct regulator_dev *rdev, 300 int min_ua, int max_ua) 301 { 302 struct max8973_chip *max = rdev_get_drvdata(rdev); 303 unsigned int val; 304 int ret; 305 306 if (max_ua <= 9000000) 307 val = MAX8973_CKKADV_TRIP_75mV_PER_US; 308 else if (max_ua <= 12000000) 309 val = MAX8973_CKKADV_TRIP_150mV_PER_US; 310 else 311 val = MAX8973_CKKADV_TRIP_DISABLE; 312 313 ret = regmap_update_bits(max->regmap, MAX8973_CONTROL2, 314 MAX8973_CKKADV_TRIP_MASK, val); 315 if (ret < 0) { 316 dev_err(max->dev, "register %d update failed: %d\n", 317 MAX8973_CONTROL2, ret); 318 return ret; 319 } 320 return 0; 321 } 322 323 static int max8973_get_current_limit(struct regulator_dev *rdev) 324 { 325 struct max8973_chip *max = rdev_get_drvdata(rdev); 326 unsigned int control2; 327 int ret; 328 329 ret = regmap_read(max->regmap, MAX8973_CONTROL2, &control2); 330 if (ret < 0) { 331 dev_err(max->dev, "register %d read failed: %d\n", 332 MAX8973_CONTROL2, ret); 333 return ret; 334 } 335 switch (control2 & MAX8973_CKKADV_TRIP_MASK) { 336 case MAX8973_CKKADV_TRIP_DISABLE: 337 return 15000000; 338 case MAX8973_CKKADV_TRIP_150mV_PER_US: 339 return 12000000; 340 case MAX8973_CKKADV_TRIP_75mV_PER_US: 341 return 9000000; 342 default: 343 break; 344 } 345 return 9000000; 346 } 347 348 static const struct regulator_ops max8973_dcdc_ops = { 349 .get_voltage_sel = max8973_dcdc_get_voltage_sel, 350 .set_voltage_sel = max8973_dcdc_set_voltage_sel, 351 .list_voltage = regulator_list_voltage_linear, 352 .set_mode = max8973_dcdc_set_mode, 353 .get_mode = max8973_dcdc_get_mode, 354 .set_voltage_time_sel = regulator_set_voltage_time_sel, 355 .set_ramp_delay = max8973_set_ramp_delay, 356 }; 357 358 static int max8973_init_dcdc(struct max8973_chip *max, 359 struct max8973_regulator_platform_data *pdata) 360 { 361 int ret; 362 uint8_t control1 = 0; 363 uint8_t control2 = 0; 364 unsigned int data; 365 366 ret = regmap_read(max->regmap, MAX8973_CONTROL1, &data); 367 if (ret < 0) { 368 dev_err(max->dev, "register %d read failed, err = %d", 369 MAX8973_CONTROL1, ret); 370 return ret; 371 } 372 control1 = data & MAX8973_RAMP_MASK; 373 switch (control1) { 374 case MAX8973_RAMP_12mV_PER_US: 375 max->desc.ramp_delay = 12000; 376 break; 377 case MAX8973_RAMP_25mV_PER_US: 378 max->desc.ramp_delay = 25000; 379 break; 380 case MAX8973_RAMP_50mV_PER_US: 381 max->desc.ramp_delay = 50000; 382 break; 383 case MAX8973_RAMP_200mV_PER_US: 384 max->desc.ramp_delay = 200000; 385 break; 386 } 387 388 if (pdata->control_flags & MAX8973_CONTROL_REMOTE_SENSE_ENABLE) 389 control1 |= MAX8973_SNS_ENABLE; 390 391 if (!(pdata->control_flags & MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE)) 392 control1 |= MAX8973_NFSR_ENABLE; 393 394 if (pdata->control_flags & MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE) 395 control1 |= MAX8973_AD_ENABLE; 396 397 if (pdata->control_flags & MAX8973_CONTROL_BIAS_ENABLE) { 398 control1 |= MAX8973_BIAS_ENABLE; 399 max->desc.enable_time = 20; 400 } else { 401 max->desc.enable_time = 240; 402 } 403 404 if (pdata->control_flags & MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE) 405 control1 |= MAX8973_FREQSHIFT_9PER; 406 407 if ((pdata->junction_temp_warning == MAX77621_TJINT_WARNING_TEMP_120) && 408 (max->id == MAX77621)) 409 control2 |= MAX77621_T_JUNCTION_120; 410 411 if (!(pdata->control_flags & MAX8973_CONTROL_PULL_DOWN_ENABLE)) 412 control2 |= MAX8973_DISCH_ENBABLE; 413 414 /* Clock advance trip configuration */ 415 switch (pdata->control_flags & MAX8973_CONTROL_CLKADV_TRIP_MASK) { 416 case MAX8973_CONTROL_CLKADV_TRIP_DISABLED: 417 control2 |= MAX8973_CKKADV_TRIP_DISABLE; 418 break; 419 420 case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US: 421 control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US; 422 break; 423 424 case MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US: 425 control2 |= MAX8973_CKKADV_TRIP_150mV_PER_US; 426 break; 427 428 case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US_HIST_DIS: 429 control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS; 430 break; 431 } 432 433 /* Configure inductor value */ 434 switch (pdata->control_flags & MAX8973_CONTROL_INDUCTOR_VALUE_MASK) { 435 case MAX8973_CONTROL_INDUCTOR_VALUE_NOMINAL: 436 control2 |= MAX8973_INDUCTOR_NOMINAL; 437 break; 438 439 case MAX8973_CONTROL_INDUCTOR_VALUE_MINUS_30_PER: 440 control2 |= MAX8973_INDUCTOR_MIN_30_PER; 441 break; 442 443 case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_30_PER: 444 control2 |= MAX8973_INDUCTOR_PLUS_30_PER; 445 break; 446 447 case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_60_PER: 448 control2 |= MAX8973_INDUCTOR_PLUS_60_PER; 449 break; 450 } 451 452 ret = regmap_write(max->regmap, MAX8973_CONTROL1, control1); 453 if (ret < 0) { 454 dev_err(max->dev, "register %d write failed, err = %d", 455 MAX8973_CONTROL1, ret); 456 return ret; 457 } 458 459 ret = regmap_write(max->regmap, MAX8973_CONTROL2, control2); 460 if (ret < 0) { 461 dev_err(max->dev, "register %d write failed, err = %d", 462 MAX8973_CONTROL2, ret); 463 return ret; 464 } 465 466 /* If external control is enabled then disable EN bit */ 467 if (max->enable_external_control && (max->id == MAX8973)) { 468 ret = regmap_update_bits(max->regmap, MAX8973_VOUT, 469 MAX8973_VOUT_ENABLE, 0); 470 if (ret < 0) 471 dev_err(max->dev, "register %d update failed, err = %d", 472 MAX8973_VOUT, ret); 473 } 474 return ret; 475 } 476 477 static int max8973_thermal_read_temp(void *data, int *temp) 478 { 479 struct max8973_chip *mchip = data; 480 unsigned int val; 481 int ret; 482 483 ret = regmap_read(mchip->regmap, MAX8973_CHIPID1, &val); 484 if (ret < 0) { 485 dev_err(mchip->dev, "Failed to read register CHIPID1, %d", ret); 486 return ret; 487 } 488 489 /* +1 degC to trigger cool devive */ 490 if (val & MAX77621_CHIPID_TJINT_S) 491 *temp = mchip->junction_temp_warning + 1000; 492 else 493 *temp = MAX77621_NORMAL_OPERATING_TEMP; 494 495 return 0; 496 } 497 498 static irqreturn_t max8973_thermal_irq(int irq, void *data) 499 { 500 struct max8973_chip *mchip = data; 501 502 thermal_zone_device_update(mchip->tz_device); 503 504 return IRQ_HANDLED; 505 } 506 507 static const struct thermal_zone_of_device_ops max77621_tz_ops = { 508 .get_temp = max8973_thermal_read_temp, 509 }; 510 511 static int max8973_thermal_init(struct max8973_chip *mchip) 512 { 513 struct thermal_zone_device *tzd; 514 struct irq_data *irq_data; 515 unsigned long irq_flags = 0; 516 int ret; 517 518 if (mchip->id != MAX77621) 519 return 0; 520 521 tzd = devm_thermal_zone_of_sensor_register(mchip->dev, 0, mchip, 522 &max77621_tz_ops); 523 if (IS_ERR(tzd)) { 524 ret = PTR_ERR(tzd); 525 dev_err(mchip->dev, "Failed to register thermal sensor: %d\n", 526 ret); 527 return ret; 528 } 529 530 if (mchip->irq <= 0) 531 return 0; 532 533 irq_data = irq_get_irq_data(mchip->irq); 534 if (irq_data) 535 irq_flags = irqd_get_trigger_type(irq_data); 536 537 ret = devm_request_threaded_irq(mchip->dev, mchip->irq, NULL, 538 max8973_thermal_irq, 539 IRQF_ONESHOT | IRQF_SHARED | irq_flags, 540 dev_name(mchip->dev), mchip); 541 if (ret < 0) { 542 dev_err(mchip->dev, "Failed to request irq %d, %d\n", 543 mchip->irq, ret); 544 return ret; 545 } 546 547 return 0; 548 } 549 550 static const struct regmap_config max8973_regmap_config = { 551 .reg_bits = 8, 552 .val_bits = 8, 553 .max_register = MAX8973_CHIPID2, 554 .cache_type = REGCACHE_RBTREE, 555 }; 556 557 static struct max8973_regulator_platform_data *max8973_parse_dt( 558 struct device *dev) 559 { 560 struct max8973_regulator_platform_data *pdata; 561 struct device_node *np = dev->of_node; 562 int ret; 563 u32 pval; 564 bool etr_enable; 565 bool etr_sensitivity_high; 566 567 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 568 if (!pdata) 569 return NULL; 570 571 pdata->enable_ext_control = of_property_read_bool(np, 572 "maxim,externally-enable"); 573 pdata->enable_gpio = of_get_named_gpio(np, "maxim,enable-gpio", 0); 574 pdata->dvs_gpio = of_get_named_gpio(np, "maxim,dvs-gpio", 0); 575 576 ret = of_property_read_u32(np, "maxim,dvs-default-state", &pval); 577 if (!ret) 578 pdata->dvs_def_state = pval; 579 580 if (of_property_read_bool(np, "maxim,enable-remote-sense")) 581 pdata->control_flags |= MAX8973_CONTROL_REMOTE_SENSE_ENABLE; 582 583 if (of_property_read_bool(np, "maxim,enable-falling-slew-rate")) 584 pdata->control_flags |= 585 MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE; 586 587 if (of_property_read_bool(np, "maxim,enable-active-discharge")) 588 pdata->control_flags |= 589 MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE; 590 591 if (of_property_read_bool(np, "maxim,enable-frequency-shift")) 592 pdata->control_flags |= MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE; 593 594 if (of_property_read_bool(np, "maxim,enable-bias-control")) 595 pdata->control_flags |= MAX8973_CONTROL_BIAS_ENABLE; 596 597 etr_enable = of_property_read_bool(np, "maxim,enable-etr"); 598 etr_sensitivity_high = of_property_read_bool(np, 599 "maxim,enable-high-etr-sensitivity"); 600 if (etr_sensitivity_high) 601 etr_enable = true; 602 603 if (etr_enable) { 604 if (etr_sensitivity_high) 605 pdata->control_flags |= 606 MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US; 607 else 608 pdata->control_flags |= 609 MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US; 610 } else { 611 pdata->control_flags |= MAX8973_CONTROL_CLKADV_TRIP_DISABLED; 612 } 613 614 pdata->junction_temp_warning = MAX77621_TJINT_WARNING_TEMP_140; 615 ret = of_property_read_u32(np, "junction-warn-millicelsius", &pval); 616 if (!ret && (pval <= MAX77621_TJINT_WARNING_TEMP_120)) 617 pdata->junction_temp_warning = MAX77621_TJINT_WARNING_TEMP_120; 618 619 return pdata; 620 } 621 622 static const struct of_device_id of_max8973_match_tbl[] = { 623 { .compatible = "maxim,max8973", .data = (void *)MAX8973, }, 624 { .compatible = "maxim,max77621", .data = (void *)MAX77621, }, 625 { }, 626 }; 627 MODULE_DEVICE_TABLE(of, of_max8973_match_tbl); 628 629 static int max8973_probe(struct i2c_client *client, 630 const struct i2c_device_id *id) 631 { 632 struct max8973_regulator_platform_data *pdata; 633 struct regulator_init_data *ridata; 634 struct regulator_config config = { }; 635 struct regulator_dev *rdev; 636 struct max8973_chip *max; 637 bool pdata_from_dt = false; 638 unsigned int chip_id; 639 int ret; 640 641 pdata = dev_get_platdata(&client->dev); 642 643 if (!pdata && client->dev.of_node) { 644 pdata = max8973_parse_dt(&client->dev); 645 pdata_from_dt = true; 646 } 647 648 if (!pdata) { 649 dev_err(&client->dev, "No Platform data"); 650 return -EIO; 651 } 652 653 if ((pdata->dvs_gpio == -EPROBE_DEFER) || 654 (pdata->enable_gpio == -EPROBE_DEFER)) 655 return -EPROBE_DEFER; 656 657 max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL); 658 if (!max) 659 return -ENOMEM; 660 661 max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config); 662 if (IS_ERR(max->regmap)) { 663 ret = PTR_ERR(max->regmap); 664 dev_err(&client->dev, "regmap init failed, err %d\n", ret); 665 return ret; 666 } 667 668 if (client->dev.of_node) { 669 const struct of_device_id *match; 670 671 match = of_match_device(of_match_ptr(of_max8973_match_tbl), 672 &client->dev); 673 if (!match) 674 return -ENODATA; 675 max->id = (u32)((uintptr_t)match->data); 676 } else { 677 max->id = id->driver_data; 678 } 679 680 ret = regmap_read(max->regmap, MAX8973_CHIPID1, &chip_id); 681 if (ret < 0) { 682 dev_err(&client->dev, "register CHIPID1 read failed, %d", ret); 683 return ret; 684 } 685 686 dev_info(&client->dev, "CHIP-ID OTP: 0x%02x ID_M: 0x%02x\n", 687 (chip_id >> 4) & 0xF, (chip_id >> 1) & 0x7); 688 689 i2c_set_clientdata(client, max); 690 max->ops = max8973_dcdc_ops; 691 max->dev = &client->dev; 692 max->desc.name = id->name; 693 max->desc.id = 0; 694 max->desc.ops = &max->ops; 695 max->desc.type = REGULATOR_VOLTAGE; 696 max->desc.owner = THIS_MODULE; 697 max->desc.min_uV = MAX8973_MIN_VOLATGE; 698 max->desc.uV_step = MAX8973_VOLATGE_STEP; 699 max->desc.n_voltages = MAX8973_BUCK_N_VOLTAGE; 700 701 max->dvs_gpio = (pdata->dvs_gpio) ? pdata->dvs_gpio : -EINVAL; 702 max->enable_gpio = (pdata->enable_gpio) ? pdata->enable_gpio : -EINVAL; 703 max->enable_external_control = pdata->enable_ext_control; 704 max->curr_gpio_val = pdata->dvs_def_state; 705 max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state; 706 max->junction_temp_warning = pdata->junction_temp_warning; 707 708 if (gpio_is_valid(max->enable_gpio)) 709 max->enable_external_control = true; 710 711 max->lru_index[0] = max->curr_vout_reg; 712 713 if (gpio_is_valid(max->dvs_gpio)) { 714 int gpio_flags; 715 int i; 716 717 gpio_flags = (pdata->dvs_def_state) ? 718 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; 719 ret = devm_gpio_request_one(&client->dev, max->dvs_gpio, 720 gpio_flags, "max8973-dvs"); 721 if (ret) { 722 dev_err(&client->dev, 723 "gpio_request for gpio %d failed, err = %d\n", 724 max->dvs_gpio, ret); 725 return ret; 726 } 727 728 /* 729 * Initialize the lru index with vout_reg id 730 * The index 0 will be most recently used and 731 * set with the max->curr_vout_reg */ 732 for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) 733 max->lru_index[i] = i; 734 max->lru_index[0] = max->curr_vout_reg; 735 max->lru_index[max->curr_vout_reg] = 0; 736 } else { 737 /* 738 * If there is no DVS GPIO, the VOUT register 739 * address is fixed. 740 */ 741 max->ops.set_voltage_sel = regulator_set_voltage_sel_regmap; 742 max->ops.get_voltage_sel = regulator_get_voltage_sel_regmap; 743 max->desc.vsel_reg = max->curr_vout_reg; 744 max->desc.vsel_mask = MAX8973_VOUT_MASK; 745 } 746 747 if (pdata_from_dt) 748 pdata->reg_init_data = of_get_regulator_init_data(&client->dev, 749 client->dev.of_node, &max->desc); 750 751 ridata = pdata->reg_init_data; 752 switch (max->id) { 753 case MAX8973: 754 if (!pdata->enable_ext_control) { 755 max->desc.enable_reg = MAX8973_VOUT; 756 max->desc.enable_mask = MAX8973_VOUT_ENABLE; 757 max->ops.enable = regulator_enable_regmap; 758 max->ops.disable = regulator_disable_regmap; 759 max->ops.is_enabled = regulator_is_enabled_regmap; 760 break; 761 } 762 763 if (gpio_is_valid(max->enable_gpio)) { 764 config.ena_gpio_flags = GPIOF_OUT_INIT_LOW; 765 if (ridata && (ridata->constraints.always_on || 766 ridata->constraints.boot_on)) 767 config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH; 768 config.ena_gpio = max->enable_gpio; 769 } 770 break; 771 772 case MAX77621: 773 if (gpio_is_valid(max->enable_gpio)) { 774 ret = devm_gpio_request_one(&client->dev, 775 max->enable_gpio, GPIOF_OUT_INIT_HIGH, 776 "max8973-en-gpio"); 777 if (ret) { 778 dev_err(&client->dev, 779 "gpio_request for gpio %d failed: %d\n", 780 max->enable_gpio, ret); 781 return ret; 782 } 783 } 784 785 max->desc.enable_reg = MAX8973_VOUT; 786 max->desc.enable_mask = MAX8973_VOUT_ENABLE; 787 max->ops.enable = regulator_enable_regmap; 788 max->ops.disable = regulator_disable_regmap; 789 max->ops.is_enabled = regulator_is_enabled_regmap; 790 max->ops.set_current_limit = max8973_set_current_limit; 791 max->ops.get_current_limit = max8973_get_current_limit; 792 break; 793 default: 794 break; 795 } 796 797 ret = max8973_init_dcdc(max, pdata); 798 if (ret < 0) { 799 dev_err(max->dev, "Max8973 Init failed, err = %d\n", ret); 800 return ret; 801 } 802 803 config.dev = &client->dev; 804 config.init_data = pdata->reg_init_data; 805 config.driver_data = max; 806 config.of_node = client->dev.of_node; 807 config.regmap = max->regmap; 808 809 /* Register the regulators */ 810 rdev = devm_regulator_register(&client->dev, &max->desc, &config); 811 if (IS_ERR(rdev)) { 812 ret = PTR_ERR(rdev); 813 dev_err(max->dev, "regulator register failed, err %d\n", ret); 814 return ret; 815 } 816 817 max8973_thermal_init(max); 818 return 0; 819 } 820 821 static const struct i2c_device_id max8973_id[] = { 822 {.name = "max8973", .driver_data = MAX8973}, 823 {.name = "max77621", .driver_data = MAX77621}, 824 {}, 825 }; 826 MODULE_DEVICE_TABLE(i2c, max8973_id); 827 828 static struct i2c_driver max8973_i2c_driver = { 829 .driver = { 830 .name = "max8973", 831 .of_match_table = of_max8973_match_tbl, 832 }, 833 .probe = max8973_probe, 834 .id_table = max8973_id, 835 }; 836 837 static int __init max8973_init(void) 838 { 839 return i2c_add_driver(&max8973_i2c_driver); 840 } 841 subsys_initcall(max8973_init); 842 843 static void __exit max8973_cleanup(void) 844 { 845 i2c_del_driver(&max8973_i2c_driver); 846 } 847 module_exit(max8973_cleanup); 848 849 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>"); 850 MODULE_DESCRIPTION("MAX8973 voltage regulator driver"); 851 MODULE_LICENSE("GPL v2"); 852