1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // DA9121 Single-channel dual-phase 10A buck converter 4 // 5 // Copyright (C) 2020 Axis Communications AB 6 // 7 // DA9130 Single-channel dual-phase 10A buck converter (Automotive) 8 // DA9217 Single-channel dual-phase 6A buck converter 9 // DA9122 Dual-channel single-phase 5A buck converter 10 // DA9131 Dual-channel single-phase 5A buck converter (Automotive) 11 // DA9220 Dual-channel single-phase 3A buck converter 12 // DA9132 Dual-channel single-phase 3A buck converter (Automotive) 13 // 14 // Copyright (C) 2020 Dialog Semiconductor 15 16 #include <linux/of.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/regulator/of_regulator.h> 19 #include <linux/regulator/machine.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/module.h> 22 #include <linux/regmap.h> 23 #include <linux/err.h> 24 #include <linux/i2c.h> 25 #include <linux/regulator/da9121.h> 26 #include <linux/interrupt.h> 27 #include <linux/workqueue.h> 28 29 #include "da9121-regulator.h" 30 31 /* Chip data */ 32 struct da9121 { 33 struct device *dev; 34 struct delayed_work work; 35 struct da9121_pdata *pdata; 36 struct regmap *regmap; 37 struct regulator_dev *rdev[DA9121_IDX_MAX]; 38 unsigned int persistent[2]; 39 unsigned int passive_delay; 40 int chip_irq; 41 int variant_id; 42 int subvariant_id; 43 }; 44 45 /* Define ranges for different variants, enabling translation to/from 46 * registers. Maximums give scope to allow for transients. 47 */ 48 struct da9121_range { 49 int val_min; 50 int val_max; 51 int val_stp; 52 int reg_min; 53 int reg_max; 54 }; 55 56 static const struct da9121_range da9121_10A_2phase_current = { 57 .val_min = 7000000, 58 .val_max = 20000000, 59 .val_stp = 1000000, 60 .reg_min = 1, 61 .reg_max = 14, 62 }; 63 64 static const struct da9121_range da9121_6A_2phase_current = { 65 .val_min = 7000000, 66 .val_max = 12000000, 67 .val_stp = 1000000, 68 .reg_min = 1, 69 .reg_max = 6, 70 }; 71 72 static const struct da9121_range da9121_5A_1phase_current = { 73 .val_min = 3500000, 74 .val_max = 10000000, 75 .val_stp = 500000, 76 .reg_min = 1, 77 .reg_max = 14, 78 }; 79 80 static const struct da9121_range da9121_3A_1phase_current = { 81 .val_min = 3500000, 82 .val_max = 6000000, 83 .val_stp = 500000, 84 .reg_min = 1, 85 .reg_max = 6, 86 }; 87 88 static const struct da9121_range da914x_40A_4phase_current = { 89 .val_min = 26000000, 90 .val_max = 78000000, 91 .val_stp = 4000000, 92 .reg_min = 1, 93 .reg_max = 14, 94 }; 95 96 static const struct da9121_range da914x_20A_2phase_current = { 97 .val_min = 13000000, 98 .val_max = 39000000, 99 .val_stp = 2000000, 100 .reg_min = 1, 101 .reg_max = 14, 102 }; 103 104 struct da9121_variant_info { 105 int num_bucks; 106 int num_phases; 107 const struct da9121_range *current_range; 108 }; 109 110 static const struct da9121_variant_info variant_parameters[] = { 111 { 1, 2, &da9121_10A_2phase_current }, //DA9121_TYPE_DA9121_DA9130 112 { 2, 1, &da9121_3A_1phase_current }, //DA9121_TYPE_DA9220_DA9132 113 { 2, 1, &da9121_5A_1phase_current }, //DA9121_TYPE_DA9122_DA9131 114 { 1, 2, &da9121_6A_2phase_current }, //DA9121_TYPE_DA9217 115 { 1, 4, &da914x_40A_4phase_current }, //DA9121_TYPE_DA9141 116 { 1, 2, &da914x_20A_2phase_current }, //DA9121_TYPE_DA9142 117 }; 118 119 struct da9121_field { 120 unsigned int reg; 121 unsigned int msk; 122 }; 123 124 static const struct da9121_field da9121_current_field[2] = { 125 { DA9121_REG_BUCK_BUCK1_2, DA9121_MASK_BUCK_BUCKx_2_CHx_ILIM }, 126 { DA9xxx_REG_BUCK_BUCK2_2, DA9121_MASK_BUCK_BUCKx_2_CHx_ILIM }, 127 }; 128 129 static const struct da9121_field da9121_mode_field[2] = { 130 { DA9121_REG_BUCK_BUCK1_4, DA9121_MASK_BUCK_BUCKx_4_CHx_A_MODE }, 131 { DA9xxx_REG_BUCK_BUCK2_4, DA9121_MASK_BUCK_BUCKx_4_CHx_A_MODE }, 132 }; 133 134 struct status_event_data { 135 int buck_id; /* 0=core, 1/2-buck */ 136 int reg_index; /* index for status/event/mask register selection */ 137 int status_bit; /* bit masks... */ 138 int event_bit; 139 int mask_bit; 140 unsigned long notification; /* Notification for status inception */ 141 char *warn; /* if NULL, notify - otherwise dev_warn this string */ 142 }; 143 144 #define DA9121_STATUS(id, bank, name, notification, warning) \ 145 { id, bank, \ 146 DA9121_MASK_SYS_STATUS_##bank##_##name, \ 147 DA9121_MASK_SYS_EVENT_##bank##_E_##name, \ 148 DA9121_MASK_SYS_MASK_##bank##_M_##name, \ 149 notification, warning } 150 151 /* For second buck related event bits that are specific to DA9122, DA9220 variants */ 152 #define DA9xxx_STATUS(id, bank, name, notification, warning) \ 153 { id, bank, \ 154 DA9xxx_MASK_SYS_STATUS_##bank##_##name, \ 155 DA9xxx_MASK_SYS_EVENT_##bank##_E_##name, \ 156 DA9xxx_MASK_SYS_MASK_##bank##_M_##name, \ 157 notification, warning } 158 159 /* The status signals that may need servicing, depending on device variant. 160 * After assertion, they persist; so event is notified, the IRQ disabled, 161 * and status polled until clear again and IRQ is reenabled. 162 * 163 * SG/PG1/PG2 should be set when device first powers up and should never 164 * re-occur. When this driver starts, it is expected that these will have 165 * self-cleared for when the IRQs are enabled, so these should never be seen. 166 * If seen, the implication is that the device has reset. 167 * 168 * GPIO0/1/2 are not configured for use by default, so should not be seen. 169 */ 170 static const struct status_event_data status_event_handling[] = { 171 DA9xxx_STATUS(0, 0, SG, 0, "Handled E_SG\n"), 172 DA9121_STATUS(0, 0, TEMP_CRIT, (REGULATOR_EVENT_OVER_TEMP|REGULATOR_EVENT_DISABLE), NULL), 173 DA9121_STATUS(0, 0, TEMP_WARN, REGULATOR_EVENT_OVER_TEMP, NULL), 174 DA9121_STATUS(1, 1, PG1, 0, "Handled E_PG1\n"), 175 DA9121_STATUS(1, 1, OV1, REGULATOR_EVENT_REGULATION_OUT, NULL), 176 DA9121_STATUS(1, 1, UV1, REGULATOR_EVENT_UNDER_VOLTAGE, NULL), 177 DA9121_STATUS(1, 1, OC1, REGULATOR_EVENT_OVER_CURRENT, NULL), 178 DA9xxx_STATUS(2, 1, PG2, 0, "Handled E_PG2\n"), 179 DA9xxx_STATUS(2, 1, OV2, REGULATOR_EVENT_REGULATION_OUT, NULL), 180 DA9xxx_STATUS(2, 1, UV2, REGULATOR_EVENT_UNDER_VOLTAGE, NULL), 181 DA9xxx_STATUS(2, 1, OC2, REGULATOR_EVENT_OVER_CURRENT, NULL), 182 DA9121_STATUS(0, 2, GPIO0, 0, "Handled E_GPIO0\n"), 183 DA9121_STATUS(0, 2, GPIO1, 0, "Handled E_GPIO1\n"), 184 DA9121_STATUS(0, 2, GPIO2, 0, "Handled E_GPIO2\n"), 185 }; 186 187 static int da9121_get_current_limit(struct regulator_dev *rdev) 188 { 189 struct da9121 *chip = rdev_get_drvdata(rdev); 190 int id = rdev_get_id(rdev); 191 const struct da9121_range *range = 192 variant_parameters[chip->variant_id].current_range; 193 unsigned int val = 0; 194 int ret = 0; 195 196 ret = regmap_read(chip->regmap, da9121_current_field[id].reg, &val); 197 if (ret < 0) { 198 dev_err(chip->dev, "Cannot read BUCK register: %d\n", ret); 199 goto error; 200 } 201 202 if (val < range->reg_min) { 203 ret = -EACCES; 204 goto error; 205 } 206 207 if (val > range->reg_max) { 208 ret = -EINVAL; 209 goto error; 210 } 211 212 return range->val_min + (range->val_stp * (val - range->reg_min)); 213 error: 214 return ret; 215 } 216 217 static int da9121_ceiling_selector(struct regulator_dev *rdev, 218 int min, int max, 219 unsigned int *selector) 220 { 221 struct da9121 *chip = rdev_get_drvdata(rdev); 222 const struct da9121_range *range = 223 variant_parameters[chip->variant_id].current_range; 224 unsigned int level; 225 unsigned int i = 0; 226 unsigned int sel = 0; 227 int ret = 0; 228 229 if (range->val_min > max || range->val_max < min) { 230 dev_err(chip->dev, 231 "Requested current out of regulator capability\n"); 232 ret = -EINVAL; 233 goto error; 234 } 235 236 level = range->val_max; 237 for (i = range->reg_max; i >= range->reg_min; i--) { 238 if (level <= max) { 239 sel = i; 240 break; 241 } 242 level -= range->val_stp; 243 } 244 245 if (level < min) { 246 dev_err(chip->dev, 247 "Best match falls below minimum requested current\n"); 248 ret = -EINVAL; 249 goto error; 250 } 251 252 *selector = sel; 253 error: 254 return ret; 255 } 256 257 static int da9121_set_current_limit(struct regulator_dev *rdev, 258 int min_ua, int max_ua) 259 { 260 struct da9121 *chip = rdev_get_drvdata(rdev); 261 int id = rdev_get_id(rdev); 262 const struct da9121_range *range = 263 variant_parameters[chip->variant_id].current_range; 264 unsigned int sel = 0; 265 int ret = 0; 266 267 if (min_ua < range->val_min || 268 max_ua > range->val_max) { 269 ret = -EINVAL; 270 goto error; 271 } 272 273 if (rdev->desc->ops->is_enabled(rdev)) { 274 ret = -EBUSY; 275 goto error; 276 } 277 278 ret = da9121_ceiling_selector(rdev, min_ua, max_ua, &sel); 279 if (ret < 0) 280 goto error; 281 282 ret = regmap_update_bits(chip->regmap, 283 da9121_current_field[id].reg, 284 da9121_current_field[id].msk, 285 (unsigned int)sel); 286 if (ret < 0) 287 dev_err(chip->dev, "Cannot update BUCK current limit, err: %d\n", ret); 288 289 error: 290 return ret; 291 } 292 293 static unsigned int da9121_map_mode(unsigned int mode) 294 { 295 switch (mode) { 296 case DA9121_BUCK_MODE_FORCE_PWM: 297 return REGULATOR_MODE_FAST; 298 case DA9121_BUCK_MODE_FORCE_PWM_SHEDDING: 299 return REGULATOR_MODE_NORMAL; 300 case DA9121_BUCK_MODE_AUTO: 301 return REGULATOR_MODE_IDLE; 302 case DA9121_BUCK_MODE_FORCE_PFM: 303 return REGULATOR_MODE_STANDBY; 304 default: 305 return REGULATOR_MODE_INVALID; 306 } 307 } 308 309 static int da9121_buck_set_mode(struct regulator_dev *rdev, unsigned int mode) 310 { 311 struct da9121 *chip = rdev_get_drvdata(rdev); 312 int id = rdev_get_id(rdev); 313 unsigned int val; 314 315 switch (mode) { 316 case REGULATOR_MODE_FAST: 317 val = DA9121_BUCK_MODE_FORCE_PWM; 318 break; 319 case REGULATOR_MODE_NORMAL: 320 val = DA9121_BUCK_MODE_FORCE_PWM_SHEDDING; 321 break; 322 case REGULATOR_MODE_IDLE: 323 val = DA9121_BUCK_MODE_AUTO; 324 break; 325 case REGULATOR_MODE_STANDBY: 326 val = DA9121_BUCK_MODE_FORCE_PFM; 327 break; 328 default: 329 return -EINVAL; 330 } 331 332 return regmap_update_bits(chip->regmap, 333 da9121_mode_field[id].reg, 334 da9121_mode_field[id].msk, 335 val); 336 } 337 338 static unsigned int da9121_buck_get_mode(struct regulator_dev *rdev) 339 { 340 struct da9121 *chip = rdev_get_drvdata(rdev); 341 int id = rdev_get_id(rdev); 342 unsigned int val, mode; 343 int ret = 0; 344 345 ret = regmap_read(chip->regmap, da9121_mode_field[id].reg, &val); 346 if (ret < 0) { 347 dev_err(chip->dev, "Cannot read BUCK register: %d\n", ret); 348 return -EINVAL; 349 } 350 351 mode = da9121_map_mode(val & da9121_mode_field[id].msk); 352 if (mode == REGULATOR_MODE_INVALID) 353 return -EINVAL; 354 355 return mode; 356 } 357 358 static const struct regulator_ops da9121_buck_ops = { 359 .enable = regulator_enable_regmap, 360 .disable = regulator_disable_regmap, 361 .is_enabled = regulator_is_enabled_regmap, 362 .set_voltage_sel = regulator_set_voltage_sel_regmap, 363 .get_voltage_sel = regulator_get_voltage_sel_regmap, 364 .list_voltage = regulator_list_voltage_linear, 365 .get_current_limit = da9121_get_current_limit, 366 .set_current_limit = da9121_set_current_limit, 367 .set_mode = da9121_buck_set_mode, 368 .get_mode = da9121_buck_get_mode, 369 }; 370 371 static struct of_regulator_match da9121_matches[] = { 372 [DA9121_IDX_BUCK1] = { .name = "buck1" }, 373 [DA9121_IDX_BUCK2] = { .name = "buck2" }, 374 }; 375 376 static int da9121_of_parse_cb(struct device_node *np, 377 const struct regulator_desc *desc, 378 struct regulator_config *config) 379 { 380 struct da9121 *chip = config->driver_data; 381 struct da9121_pdata *pdata; 382 struct gpio_desc *ena_gpiod; 383 384 if (chip->pdata == NULL) { 385 pdata = devm_kzalloc(chip->dev, sizeof(*pdata), GFP_KERNEL); 386 if (!pdata) 387 return -ENOMEM; 388 } else { 389 pdata = chip->pdata; 390 } 391 392 pdata->num_buck++; 393 394 if (pdata->num_buck > variant_parameters[chip->variant_id].num_bucks) { 395 dev_err(chip->dev, "Error: excessive regulators for device\n"); 396 return -ENODEV; 397 } 398 399 ena_gpiod = fwnode_gpiod_get_index(of_fwnode_handle(np), "enable", 0, 400 GPIOD_OUT_HIGH | 401 GPIOD_FLAGS_BIT_NONEXCLUSIVE, 402 "da9121-enable"); 403 if (!IS_ERR(ena_gpiod)) { 404 if (of_property_read_bool(chip->dev->of_node, "dlg,no-gpio-control")) { 405 gpiod_put(ena_gpiod); 406 dev_err(chip->dev, "dlg,no-gpio-control conflicts with enable-gpios\n"); 407 return -EINVAL; 408 } 409 config->ena_gpiod = ena_gpiod; 410 } 411 412 if (variant_parameters[chip->variant_id].num_bucks == 2) { 413 uint32_t ripple_cancel; 414 uint32_t ripple_reg; 415 int ret; 416 417 if (of_property_read_u32(da9121_matches[pdata->num_buck-1].of_node, 418 "dlg,ripple-cancel", &ripple_cancel)) { 419 if (pdata->num_buck > 1) 420 ripple_reg = DA9xxx_REG_BUCK_BUCK2_7; 421 else 422 ripple_reg = DA9121_REG_BUCK_BUCK1_7; 423 424 ret = regmap_update_bits(chip->regmap, ripple_reg, 425 DA9xxx_MASK_BUCK_BUCKx_7_CHx_RIPPLE_CANCEL, 426 ripple_cancel); 427 if (ret < 0) 428 dev_err(chip->dev, "Cannot set ripple mode, err: %d\n", ret); 429 } 430 } 431 432 return 0; 433 } 434 435 #define DA9121_MIN_MV 300 436 #define DA9121_MAX_MV 1900 437 #define DA9121_STEP_MV 10 438 #define DA9121_MIN_SEL (DA9121_MIN_MV / DA9121_STEP_MV) 439 #define DA9121_N_VOLTAGES (((DA9121_MAX_MV - DA9121_MIN_MV) / DA9121_STEP_MV) \ 440 + 1 + DA9121_MIN_SEL) 441 442 static const struct regulator_desc da9121_reg = { 443 .id = DA9121_IDX_BUCK1, 444 .name = "da9121", 445 .of_match = "buck1", 446 .of_parse_cb = da9121_of_parse_cb, 447 .owner = THIS_MODULE, 448 .regulators_node = "regulators", 449 .of_map_mode = da9121_map_mode, 450 .ops = &da9121_buck_ops, 451 .type = REGULATOR_VOLTAGE, 452 .n_voltages = DA9121_N_VOLTAGES, 453 .min_uV = DA9121_MIN_MV * 1000, 454 .uV_step = DA9121_STEP_MV * 1000, 455 .linear_min_sel = DA9121_MIN_SEL, 456 .vsel_reg = DA9121_REG_BUCK_BUCK1_5, 457 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 458 .enable_reg = DA9121_REG_BUCK_BUCK1_0, 459 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 460 /* Default value of BUCK_BUCK1_0.CH1_SRC_DVC_UP */ 461 .ramp_delay = 20000, 462 /* tBUCK_EN */ 463 .enable_time = 20, 464 }; 465 466 static const struct regulator_desc da9220_reg[2] = { 467 { 468 .id = DA9121_IDX_BUCK1, 469 .name = "DA9220/DA9132 BUCK1", 470 .of_match = "buck1", 471 .of_parse_cb = da9121_of_parse_cb, 472 .owner = THIS_MODULE, 473 .regulators_node = "regulators", 474 .of_map_mode = da9121_map_mode, 475 .ops = &da9121_buck_ops, 476 .type = REGULATOR_VOLTAGE, 477 .n_voltages = DA9121_N_VOLTAGES, 478 .min_uV = DA9121_MIN_MV * 1000, 479 .uV_step = DA9121_STEP_MV * 1000, 480 .linear_min_sel = DA9121_MIN_SEL, 481 .enable_reg = DA9121_REG_BUCK_BUCK1_0, 482 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 483 .vsel_reg = DA9121_REG_BUCK_BUCK1_5, 484 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 485 }, 486 { 487 .id = DA9121_IDX_BUCK2, 488 .name = "DA9220/DA9132 BUCK2", 489 .of_match = "buck2", 490 .of_parse_cb = da9121_of_parse_cb, 491 .owner = THIS_MODULE, 492 .regulators_node = "regulators", 493 .of_map_mode = da9121_map_mode, 494 .ops = &da9121_buck_ops, 495 .type = REGULATOR_VOLTAGE, 496 .n_voltages = DA9121_N_VOLTAGES, 497 .min_uV = DA9121_MIN_MV * 1000, 498 .uV_step = DA9121_STEP_MV * 1000, 499 .linear_min_sel = DA9121_MIN_SEL, 500 .enable_reg = DA9xxx_REG_BUCK_BUCK2_0, 501 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 502 .vsel_reg = DA9xxx_REG_BUCK_BUCK2_5, 503 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 504 } 505 }; 506 507 static const struct regulator_desc da9122_reg[2] = { 508 { 509 .id = DA9121_IDX_BUCK1, 510 .name = "DA9122/DA9131 BUCK1", 511 .of_match = "buck1", 512 .of_parse_cb = da9121_of_parse_cb, 513 .owner = THIS_MODULE, 514 .regulators_node = "regulators", 515 .of_map_mode = da9121_map_mode, 516 .ops = &da9121_buck_ops, 517 .type = REGULATOR_VOLTAGE, 518 .n_voltages = DA9121_N_VOLTAGES, 519 .min_uV = DA9121_MIN_MV * 1000, 520 .uV_step = DA9121_STEP_MV * 1000, 521 .linear_min_sel = DA9121_MIN_SEL, 522 .enable_reg = DA9121_REG_BUCK_BUCK1_0, 523 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 524 .vsel_reg = DA9121_REG_BUCK_BUCK1_5, 525 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 526 }, 527 { 528 .id = DA9121_IDX_BUCK2, 529 .name = "DA9122/DA9131 BUCK2", 530 .of_match = "buck2", 531 .of_parse_cb = da9121_of_parse_cb, 532 .owner = THIS_MODULE, 533 .regulators_node = "regulators", 534 .of_map_mode = da9121_map_mode, 535 .ops = &da9121_buck_ops, 536 .type = REGULATOR_VOLTAGE, 537 .n_voltages = DA9121_N_VOLTAGES, 538 .min_uV = DA9121_MIN_MV * 1000, 539 .uV_step = DA9121_STEP_MV * 1000, 540 .linear_min_sel = DA9121_MIN_SEL, 541 .enable_reg = DA9xxx_REG_BUCK_BUCK2_0, 542 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 543 .vsel_reg = DA9xxx_REG_BUCK_BUCK2_5, 544 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 545 } 546 }; 547 548 static const struct regulator_desc da9217_reg = { 549 .id = DA9121_IDX_BUCK1, 550 .name = "DA9217 BUCK1", 551 .of_match = "buck1", 552 .of_parse_cb = da9121_of_parse_cb, 553 .owner = THIS_MODULE, 554 .regulators_node = "regulators", 555 .of_map_mode = da9121_map_mode, 556 .ops = &da9121_buck_ops, 557 .type = REGULATOR_VOLTAGE, 558 .n_voltages = DA9121_N_VOLTAGES, 559 .min_uV = DA9121_MIN_MV * 1000, 560 .uV_step = DA9121_STEP_MV * 1000, 561 .linear_min_sel = DA9121_MIN_SEL, 562 .enable_reg = DA9121_REG_BUCK_BUCK1_0, 563 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 564 .vsel_reg = DA9121_REG_BUCK_BUCK1_5, 565 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 566 }; 567 568 #define DA914X_MIN_MV 500 569 #define DA914X_MAX_MV 1300 570 #define DA914X_STEP_MV 10 571 #define DA914X_MIN_SEL (DA914X_MIN_MV / DA914X_STEP_MV) 572 #define DA914X_N_VOLTAGES (((DA914X_MAX_MV - DA914X_MIN_MV) / DA914X_STEP_MV) \ 573 + 1 + DA914X_MIN_SEL) 574 575 static const struct regulator_desc da9141_reg = { 576 .id = DA9121_IDX_BUCK1, 577 .name = "DA9141", 578 .of_match = "buck1", 579 .of_parse_cb = da9121_of_parse_cb, 580 .owner = THIS_MODULE, 581 .regulators_node = "regulators", 582 .of_map_mode = da9121_map_mode, 583 .ops = &da9121_buck_ops, 584 .type = REGULATOR_VOLTAGE, 585 .n_voltages = DA914X_N_VOLTAGES, 586 .min_uV = DA914X_MIN_MV * 1000, 587 .uV_step = DA914X_STEP_MV * 1000, 588 .linear_min_sel = DA914X_MIN_SEL, 589 .vsel_reg = DA9121_REG_BUCK_BUCK1_5, 590 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 591 .enable_reg = DA9121_REG_BUCK_BUCK1_0, 592 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 593 }; 594 595 static const struct regulator_desc da9142_reg = { 596 .id = DA9121_IDX_BUCK1, 597 .name = "DA9142 BUCK1", 598 .of_match = "buck1", 599 .of_parse_cb = da9121_of_parse_cb, 600 .owner = THIS_MODULE, 601 .regulators_node = "regulators", 602 .of_map_mode = da9121_map_mode, 603 .ops = &da9121_buck_ops, 604 .type = REGULATOR_VOLTAGE, 605 .n_voltages = DA914X_N_VOLTAGES, 606 .min_uV = DA914X_MIN_MV * 1000, 607 .uV_step = DA914X_STEP_MV * 1000, 608 .linear_min_sel = DA914X_MIN_SEL, 609 .enable_reg = DA9121_REG_BUCK_BUCK1_0, 610 .enable_mask = DA9121_MASK_BUCK_BUCKx_0_CHx_EN, 611 .vsel_reg = DA9121_REG_BUCK_BUCK1_5, 612 .vsel_mask = DA9121_MASK_BUCK_BUCKx_5_CHx_A_VOUT, 613 }; 614 615 616 static const struct regulator_desc *local_da9121_regulators[][DA9121_IDX_MAX] = { 617 [DA9121_TYPE_DA9121_DA9130] = { &da9121_reg, NULL }, 618 [DA9121_TYPE_DA9220_DA9132] = { &da9220_reg[0], &da9220_reg[1] }, 619 [DA9121_TYPE_DA9122_DA9131] = { &da9122_reg[0], &da9122_reg[1] }, 620 [DA9121_TYPE_DA9217] = { &da9217_reg, NULL }, 621 [DA9121_TYPE_DA9141] = { &da9141_reg, NULL }, 622 [DA9121_TYPE_DA9142] = { &da9142_reg, NULL }, 623 }; 624 625 static void da9121_status_poll_on(struct work_struct *work) 626 { 627 struct da9121 *chip = container_of(work, struct da9121, work.work); 628 int status[3] = {0}; 629 int clear[3] = {0}; 630 unsigned long delay; 631 int i; 632 int ret; 633 634 ret = regmap_bulk_read(chip->regmap, DA9121_REG_SYS_STATUS_0, status, 2); 635 if (ret < 0) { 636 dev_err(chip->dev, 637 "Failed to read STATUS registers: %d\n", ret); 638 goto error; 639 } 640 641 /* Possible events are tested to be within range for the variant, potentially 642 * masked by the IRQ handler (not just warned about), as having been masked, 643 * and the respective state cleared - then flagged to unmask for next IRQ. 644 */ 645 for (i = 0; i < ARRAY_SIZE(status_event_handling); i++) { 646 const struct status_event_data *item = &status_event_handling[i]; 647 int reg_idx = item->reg_index; 648 bool relevant = (item->buck_id <= variant_parameters[chip->variant_id].num_bucks); 649 bool supported = (item->warn == NULL); 650 bool persisting = (chip->persistent[reg_idx] & item->event_bit); 651 bool now_cleared = !(status[reg_idx] & item->status_bit); 652 653 if (relevant && supported && persisting && now_cleared) { 654 clear[reg_idx] |= item->mask_bit; 655 chip->persistent[reg_idx] &= ~item->event_bit; 656 } 657 } 658 659 for (i = 0; i < 2; i++) { 660 if (clear[i]) { 661 unsigned int reg = DA9121_REG_SYS_MASK_0 + i; 662 unsigned int mbit = clear[i]; 663 664 ret = regmap_update_bits(chip->regmap, reg, mbit, 0); 665 if (ret < 0) { 666 dev_err(chip->dev, 667 "Failed to unmask 0x%02x %d\n", 668 reg, ret); 669 goto error; 670 } 671 } 672 } 673 674 if (chip->persistent[0] | chip->persistent[1]) { 675 delay = msecs_to_jiffies(chip->passive_delay); 676 queue_delayed_work(system_freezable_wq, &chip->work, delay); 677 } 678 679 error: 680 return; 681 } 682 683 static irqreturn_t da9121_irq_handler(int irq, void *data) 684 { 685 struct da9121 *chip = data; 686 struct regulator_dev *rdev; 687 int event[3] = {0}; 688 int handled[3] = {0}; 689 int mask[3] = {0}; 690 int ret = IRQ_NONE; 691 int i; 692 int err; 693 694 err = regmap_bulk_read(chip->regmap, DA9121_REG_SYS_EVENT_0, event, 3); 695 if (err < 0) { 696 dev_err(chip->dev, "Failed to read EVENT registers %d\n", err); 697 ret = IRQ_NONE; 698 goto error; 699 } 700 701 err = regmap_bulk_read(chip->regmap, DA9121_REG_SYS_MASK_0, mask, 3); 702 if (err < 0) { 703 dev_err(chip->dev, 704 "Failed to read MASK registers: %d\n", ret); 705 ret = IRQ_NONE; 706 goto error; 707 } 708 709 rdev = chip->rdev[DA9121_IDX_BUCK1]; 710 711 /* Possible events are tested to be within range for the variant, currently 712 * enabled, and having triggered this IRQ. The event may then be notified, 713 * or a warning given for unexpected events - those from device POR, and 714 * currently unsupported GPIO configurations. 715 */ 716 for (i = 0; i < ARRAY_SIZE(status_event_handling); i++) { 717 const struct status_event_data *item = &status_event_handling[i]; 718 int reg_idx = item->reg_index; 719 bool relevant = (item->buck_id <= variant_parameters[chip->variant_id].num_bucks); 720 bool enabled = !(mask[reg_idx] & item->mask_bit); 721 bool active = (event[reg_idx] & item->event_bit); 722 bool notify = (item->warn == NULL); 723 724 if (relevant && enabled && active) { 725 if (notify) { 726 chip->persistent[reg_idx] |= item->event_bit; 727 regulator_notifier_call_chain(rdev, item->notification, NULL); 728 } else { 729 dev_warn(chip->dev, item->warn); 730 handled[reg_idx] |= item->event_bit; 731 ret = IRQ_HANDLED; 732 } 733 } 734 } 735 736 for (i = 0; i < 3; i++) { 737 if (event[i] != handled[i]) { 738 dev_warn(chip->dev, 739 "Unhandled event(s) in bank%d 0x%02x\n", i, 740 event[i] ^ handled[i]); 741 } 742 } 743 744 /* Mask the interrupts for persistent events OV, OC, UV, WARN, CRIT */ 745 for (i = 0; i < 2; i++) { 746 if (handled[i]) { 747 unsigned int reg = DA9121_REG_SYS_MASK_0 + i; 748 unsigned int mbit = handled[i]; 749 750 err = regmap_update_bits(chip->regmap, reg, mbit, mbit); 751 if (err < 0) { 752 dev_err(chip->dev, 753 "Failed to mask 0x%02x interrupt %d\n", 754 reg, err); 755 ret = IRQ_NONE; 756 goto error; 757 } 758 } 759 } 760 761 /* clear the events */ 762 if (handled[0] | handled[1] | handled[2]) { 763 err = regmap_bulk_write(chip->regmap, DA9121_REG_SYS_EVENT_0, handled, 3); 764 if (err < 0) { 765 dev_err(chip->dev, "Fail to write EVENTs %d\n", err); 766 ret = IRQ_NONE; 767 goto error; 768 } 769 } 770 771 queue_delayed_work(system_freezable_wq, &chip->work, 0); 772 error: 773 return ret; 774 } 775 776 static int da9121_set_regulator_config(struct da9121 *chip) 777 { 778 struct regulator_config config = { }; 779 unsigned int max_matches = variant_parameters[chip->variant_id].num_bucks; 780 int ret = 0; 781 int i; 782 783 for (i = 0; i < max_matches; i++) { 784 const struct regulator_desc *regl_desc = 785 local_da9121_regulators[chip->variant_id][i]; 786 787 config.dev = chip->dev; 788 config.driver_data = chip; 789 config.regmap = chip->regmap; 790 791 chip->rdev[i] = devm_regulator_register(chip->dev, 792 regl_desc, &config); 793 if (IS_ERR(chip->rdev[i])) { 794 dev_err(chip->dev, "Failed to register regulator %s, %d/%d\n", 795 regl_desc->name, (i+1), max_matches); 796 ret = PTR_ERR(chip->rdev[i]); 797 goto error; 798 } 799 } 800 801 error: 802 return ret; 803 } 804 805 /* DA9121 chip register model */ 806 static const struct regmap_range da9121_1ch_readable_ranges[] = { 807 regmap_reg_range(DA9121_REG_SYS_STATUS_0, DA9121_REG_SYS_MASK_3), 808 regmap_reg_range(DA9121_REG_SYS_CONFIG_2, DA9121_REG_SYS_CONFIG_3), 809 regmap_reg_range(DA9121_REG_SYS_GPIO0_0, DA9121_REG_SYS_GPIO2_1), 810 regmap_reg_range(DA9121_REG_BUCK_BUCK1_0, DA9121_REG_BUCK_BUCK1_6), 811 regmap_reg_range(DA9121_REG_OTP_DEVICE_ID, DA9121_REG_OTP_CONFIG_ID), 812 }; 813 814 static const struct regmap_access_table da9121_1ch_readable_table = { 815 .yes_ranges = da9121_1ch_readable_ranges, 816 .n_yes_ranges = ARRAY_SIZE(da9121_1ch_readable_ranges), 817 }; 818 819 static const struct regmap_range da9121_2ch_readable_ranges[] = { 820 regmap_reg_range(DA9121_REG_SYS_STATUS_0, DA9121_REG_SYS_MASK_3), 821 regmap_reg_range(DA9121_REG_SYS_CONFIG_2, DA9121_REG_SYS_CONFIG_3), 822 regmap_reg_range(DA9121_REG_SYS_GPIO0_0, DA9121_REG_SYS_GPIO2_1), 823 regmap_reg_range(DA9121_REG_BUCK_BUCK1_0, DA9121_REG_BUCK_BUCK1_7), 824 regmap_reg_range(DA9xxx_REG_BUCK_BUCK2_0, DA9xxx_REG_BUCK_BUCK2_7), 825 regmap_reg_range(DA9121_REG_OTP_DEVICE_ID, DA9121_REG_OTP_CONFIG_ID), 826 }; 827 828 static const struct regmap_access_table da9121_2ch_readable_table = { 829 .yes_ranges = da9121_2ch_readable_ranges, 830 .n_yes_ranges = ARRAY_SIZE(da9121_2ch_readable_ranges), 831 }; 832 833 static const struct regmap_range da9121_1ch_writeable_ranges[] = { 834 regmap_reg_range(DA9121_REG_SYS_EVENT_0, DA9121_REG_SYS_MASK_3), 835 regmap_reg_range(DA9121_REG_SYS_CONFIG_2, DA9121_REG_SYS_CONFIG_3), 836 regmap_reg_range(DA9121_REG_SYS_GPIO0_0, DA9121_REG_SYS_GPIO2_1), 837 regmap_reg_range(DA9121_REG_BUCK_BUCK1_0, DA9121_REG_BUCK_BUCK1_2), 838 regmap_reg_range(DA9121_REG_BUCK_BUCK1_4, DA9121_REG_BUCK_BUCK1_6), 839 }; 840 841 static const struct regmap_access_table da9121_1ch_writeable_table = { 842 .yes_ranges = da9121_1ch_writeable_ranges, 843 .n_yes_ranges = ARRAY_SIZE(da9121_1ch_writeable_ranges), 844 }; 845 846 static const struct regmap_range da9121_2ch_writeable_ranges[] = { 847 regmap_reg_range(DA9121_REG_SYS_EVENT_0, DA9121_REG_SYS_MASK_3), 848 regmap_reg_range(DA9121_REG_SYS_CONFIG_2, DA9121_REG_SYS_CONFIG_3), 849 regmap_reg_range(DA9121_REG_SYS_GPIO0_0, DA9121_REG_SYS_GPIO2_1), 850 regmap_reg_range(DA9121_REG_BUCK_BUCK1_0, DA9121_REG_BUCK_BUCK1_2), 851 regmap_reg_range(DA9121_REG_BUCK_BUCK1_4, DA9121_REG_BUCK_BUCK1_7), 852 regmap_reg_range(DA9xxx_REG_BUCK_BUCK2_0, DA9xxx_REG_BUCK_BUCK2_2), 853 regmap_reg_range(DA9xxx_REG_BUCK_BUCK2_4, DA9xxx_REG_BUCK_BUCK2_7), 854 }; 855 856 static const struct regmap_access_table da9121_2ch_writeable_table = { 857 .yes_ranges = da9121_2ch_writeable_ranges, 858 .n_yes_ranges = ARRAY_SIZE(da9121_2ch_writeable_ranges), 859 }; 860 861 862 static const struct regmap_range da9121_volatile_ranges[] = { 863 regmap_reg_range(DA9121_REG_SYS_STATUS_0, DA9121_REG_SYS_EVENT_2), 864 regmap_reg_range(DA9121_REG_SYS_GPIO0_0, DA9121_REG_SYS_GPIO2_1), 865 regmap_reg_range(DA9121_REG_BUCK_BUCK1_0, DA9121_REG_BUCK_BUCK1_6), 866 }; 867 868 static const struct regmap_access_table da9121_volatile_table = { 869 .yes_ranges = da9121_volatile_ranges, 870 .n_yes_ranges = ARRAY_SIZE(da9121_volatile_ranges), 871 }; 872 873 /* 874 * When GPIO functions DVC/RELOAD/EN are not used, the registers in the range 875 * DA9121_REG_BUCK_BUCK1_0 to DA9121_REG_BUCK_BUCK1_6 need not be volatile 876 * because register writes to these registers can only be performed via I2C. 877 */ 878 static const struct regmap_range da9121_volatile_ranges_no_gpio_ctrl[] = { 879 regmap_reg_range(DA9121_REG_SYS_STATUS_0, DA9121_REG_SYS_EVENT_2), 880 regmap_reg_range(DA9121_REG_SYS_GPIO0_0, DA9121_REG_SYS_GPIO2_1), 881 }; 882 883 static const struct regmap_access_table da9121_volatile_table_no_gpio_ctrl = { 884 .yes_ranges = da9121_volatile_ranges_no_gpio_ctrl, 885 .n_yes_ranges = ARRAY_SIZE(da9121_volatile_ranges_no_gpio_ctrl), 886 }; 887 888 /* DA9121 regmap config for 1 channel variants */ 889 static const struct regmap_config da9121_1ch_regmap_config = { 890 .reg_bits = 8, 891 .val_bits = 8, 892 .max_register = DA9121_REG_OTP_CONFIG_ID, 893 .rd_table = &da9121_1ch_readable_table, 894 .wr_table = &da9121_1ch_writeable_table, 895 .volatile_table = &da9121_volatile_table, 896 .cache_type = REGCACHE_MAPLE, 897 }; 898 899 /* DA9121 regmap config for 2 channel variants */ 900 static const struct regmap_config da9121_2ch_regmap_config = { 901 .reg_bits = 8, 902 .val_bits = 8, 903 .max_register = DA9121_REG_OTP_CONFIG_ID, 904 .rd_table = &da9121_2ch_readable_table, 905 .wr_table = &da9121_2ch_writeable_table, 906 .volatile_table = &da9121_volatile_table, 907 .cache_type = REGCACHE_MAPLE, 908 }; 909 910 static int da9121_check_device_type(struct i2c_client *i2c, struct da9121 *chip) 911 { 912 u32 device_id; 913 u32 variant_id; 914 u8 variant_mrc, variant_vrc; 915 char *type; 916 bool config_match = false; 917 int ret = 0; 918 919 ret = regmap_read(chip->regmap, DA9121_REG_OTP_DEVICE_ID, &device_id); 920 if (ret < 0) { 921 dev_err(chip->dev, "Cannot read device ID: %d\n", ret); 922 goto error; 923 } 924 925 ret = regmap_read(chip->regmap, DA9121_REG_OTP_VARIANT_ID, &variant_id); 926 if (ret < 0) { 927 dev_err(chip->dev, "Cannot read variant ID: %d\n", ret); 928 goto error; 929 } 930 931 if ((device_id != DA9121_DEVICE_ID) && (device_id != DA914x_DEVICE_ID)) { 932 dev_err(chip->dev, "Invalid device ID: 0x%02x\n", device_id); 933 ret = -ENODEV; 934 goto error; 935 } 936 937 variant_vrc = variant_id & DA9121_MASK_OTP_VARIANT_ID_VRC; 938 939 switch (chip->subvariant_id) { 940 case DA9121_SUBTYPE_DA9121: 941 type = "DA9121"; 942 config_match = (variant_vrc == DA9121_VARIANT_VRC); 943 break; 944 case DA9121_SUBTYPE_DA9130: 945 type = "DA9130"; 946 config_match = (variant_vrc == DA9130_VARIANT_VRC); 947 break; 948 case DA9121_SUBTYPE_DA9220: 949 type = "DA9220"; 950 config_match = (variant_vrc == DA9220_VARIANT_VRC); 951 break; 952 case DA9121_SUBTYPE_DA9132: 953 type = "DA9132"; 954 config_match = (variant_vrc == DA9132_VARIANT_VRC); 955 break; 956 case DA9121_SUBTYPE_DA9122: 957 type = "DA9122"; 958 config_match = (variant_vrc == DA9122_VARIANT_VRC); 959 break; 960 case DA9121_SUBTYPE_DA9131: 961 type = "DA9131"; 962 config_match = (variant_vrc == DA9131_VARIANT_VRC); 963 break; 964 case DA9121_SUBTYPE_DA9217: 965 type = "DA9217"; 966 config_match = (variant_vrc == DA9217_VARIANT_VRC); 967 break; 968 default: 969 type = "Unknown"; 970 break; 971 } 972 973 if (device_id == DA914x_DEVICE_ID) { 974 switch (chip->subvariant_id) { 975 case DA9121_SUBTYPE_DA9141: 976 type = "DA9141"; 977 config_match = (variant_vrc == DA9141_VARIANT_VRC); 978 break; 979 case DA9121_SUBTYPE_DA9142: 980 type = "DA9142"; 981 config_match = (variant_vrc == DA9142_VARIANT_VRC); 982 break; 983 default: 984 type = "Unknown"; 985 break; 986 } 987 } 988 989 dev_info(chip->dev, 990 "Device detected (device-ID: 0x%02X, var-ID: 0x%02X, %s)\n", 991 device_id, variant_id, type); 992 993 if (!config_match) { 994 dev_err(chip->dev, "Device tree configuration does not match detected device.\n"); 995 ret = -EINVAL; 996 goto error; 997 } 998 999 variant_mrc = (variant_id & DA9121_MASK_OTP_VARIANT_ID_MRC) 1000 >> DA9121_SHIFT_OTP_VARIANT_ID_MRC; 1001 1002 if (((device_id == DA9121_DEVICE_ID) && 1003 (variant_mrc < DA9121_VARIANT_MRC_BASE)) || 1004 ((device_id == DA914x_DEVICE_ID) && 1005 (variant_mrc != DA914x_VARIANT_MRC_BASE))) { 1006 dev_err(chip->dev, 1007 "Cannot support variant MRC: 0x%02X\n", variant_mrc); 1008 ret = -EINVAL; 1009 } 1010 error: 1011 return ret; 1012 } 1013 1014 static int da9121_assign_chip_model(struct i2c_client *i2c, 1015 struct da9121 *chip) 1016 { 1017 const struct regmap_config *regmap; 1018 struct regmap_config regmap_config_1ch = da9121_1ch_regmap_config; 1019 struct regmap_config regmap_config_2ch = da9121_2ch_regmap_config; 1020 1021 int ret = 0; 1022 1023 chip->dev = &i2c->dev; 1024 1025 if (of_property_read_bool(i2c->dev.of_node, "dlg,no-gpio-control")) { 1026 regmap_config_1ch.volatile_table = &da9121_volatile_table_no_gpio_ctrl; 1027 regmap_config_2ch.volatile_table = &da9121_volatile_table_no_gpio_ctrl; 1028 } 1029 1030 /* Use configured subtype to select the regulator descriptor index and 1031 * register map, common to both consumer and automotive grade variants 1032 */ 1033 switch (chip->subvariant_id) { 1034 case DA9121_SUBTYPE_DA9121: 1035 case DA9121_SUBTYPE_DA9130: 1036 chip->variant_id = DA9121_TYPE_DA9121_DA9130; 1037 regmap = ®map_config_1ch; 1038 break; 1039 case DA9121_SUBTYPE_DA9217: 1040 chip->variant_id = DA9121_TYPE_DA9217; 1041 regmap = ®map_config_1ch; 1042 break; 1043 case DA9121_SUBTYPE_DA9122: 1044 case DA9121_SUBTYPE_DA9131: 1045 chip->variant_id = DA9121_TYPE_DA9122_DA9131; 1046 regmap = ®map_config_2ch; 1047 break; 1048 case DA9121_SUBTYPE_DA9220: 1049 case DA9121_SUBTYPE_DA9132: 1050 chip->variant_id = DA9121_TYPE_DA9220_DA9132; 1051 regmap = ®map_config_2ch; 1052 break; 1053 case DA9121_SUBTYPE_DA9141: 1054 chip->variant_id = DA9121_TYPE_DA9141; 1055 regmap = ®map_config_1ch; 1056 break; 1057 case DA9121_SUBTYPE_DA9142: 1058 chip->variant_id = DA9121_TYPE_DA9142; 1059 regmap = ®map_config_2ch; 1060 break; 1061 default: 1062 return -EINVAL; 1063 } 1064 1065 /* Set these up for of_regulator_match call which may want .of_map_modes */ 1066 da9121_matches[0].desc = local_da9121_regulators[chip->variant_id][0]; 1067 da9121_matches[1].desc = local_da9121_regulators[chip->variant_id][1]; 1068 1069 chip->regmap = devm_regmap_init_i2c(i2c, regmap); 1070 if (IS_ERR(chip->regmap)) { 1071 ret = PTR_ERR(chip->regmap); 1072 dev_err(chip->dev, "Failed to configure a register map: %d\n", 1073 ret); 1074 return ret; 1075 } 1076 1077 ret = da9121_check_device_type(i2c, chip); 1078 1079 return ret; 1080 } 1081 1082 static int da9121_config_irq(struct i2c_client *i2c, 1083 struct da9121 *chip) 1084 { 1085 unsigned int p_delay = DA9121_DEFAULT_POLLING_PERIOD_MS; 1086 const int mask_all[4] = { 0, 0, 0xFF, 0xFF }; 1087 int ret = 0; 1088 1089 chip->chip_irq = i2c->irq; 1090 1091 if (chip->chip_irq != 0) { 1092 if (!of_property_read_u32(chip->dev->of_node, 1093 "dlg,irq-polling-delay-passive-ms", 1094 &p_delay)) { 1095 if (p_delay < DA9121_MIN_POLLING_PERIOD_MS || 1096 p_delay > DA9121_MAX_POLLING_PERIOD_MS) { 1097 dev_warn(chip->dev, 1098 "Out-of-range polling period %d ms\n", 1099 p_delay); 1100 p_delay = DA9121_DEFAULT_POLLING_PERIOD_MS; 1101 } 1102 } 1103 1104 chip->passive_delay = p_delay; 1105 1106 ret = request_threaded_irq(chip->chip_irq, NULL, 1107 da9121_irq_handler, 1108 IRQF_TRIGGER_LOW|IRQF_ONESHOT, 1109 "da9121", chip); 1110 if (ret != 0) { 1111 dev_err(chip->dev, "Failed IRQ request: %d\n", 1112 chip->chip_irq); 1113 goto error; 1114 } 1115 1116 ret = regmap_bulk_write(chip->regmap, DA9121_REG_SYS_MASK_0, mask_all, 4); 1117 if (ret != 0) { 1118 dev_err(chip->dev, "Failed to set IRQ masks: %d\n", 1119 ret); 1120 goto regmap_error; 1121 } 1122 1123 INIT_DELAYED_WORK(&chip->work, da9121_status_poll_on); 1124 dev_info(chip->dev, "Interrupt polling period set at %d ms\n", 1125 chip->passive_delay); 1126 } 1127 error: 1128 return ret; 1129 regmap_error: 1130 free_irq(chip->chip_irq, chip); 1131 return ret; 1132 } 1133 1134 static const struct of_device_id da9121_dt_ids[] = { 1135 { .compatible = "dlg,da9121", .data = (void *) DA9121_SUBTYPE_DA9121 }, 1136 { .compatible = "dlg,da9130", .data = (void *) DA9121_SUBTYPE_DA9130 }, 1137 { .compatible = "dlg,da9217", .data = (void *) DA9121_SUBTYPE_DA9217 }, 1138 { .compatible = "dlg,da9122", .data = (void *) DA9121_SUBTYPE_DA9122 }, 1139 { .compatible = "dlg,da9131", .data = (void *) DA9121_SUBTYPE_DA9131 }, 1140 { .compatible = "dlg,da9220", .data = (void *) DA9121_SUBTYPE_DA9220 }, 1141 { .compatible = "dlg,da9132", .data = (void *) DA9121_SUBTYPE_DA9132 }, 1142 { .compatible = "dlg,da9141", .data = (void *) DA9121_SUBTYPE_DA9141 }, 1143 { .compatible = "dlg,da9142", .data = (void *) DA9121_SUBTYPE_DA9142 }, 1144 { } 1145 }; 1146 MODULE_DEVICE_TABLE(of, da9121_dt_ids); 1147 1148 static int da9121_i2c_probe(struct i2c_client *i2c) 1149 { 1150 struct da9121 *chip; 1151 const int mask_all[4] = { 0xFF, 0xFF, 0xFF, 0xFF }; 1152 int ret = 0; 1153 1154 chip = devm_kzalloc(&i2c->dev, sizeof(struct da9121), GFP_KERNEL); 1155 if (!chip) { 1156 ret = -ENOMEM; 1157 goto error; 1158 } 1159 1160 chip->pdata = i2c->dev.platform_data; 1161 chip->subvariant_id = (kernel_ulong_t)i2c_get_match_data(i2c); 1162 1163 ret = da9121_assign_chip_model(i2c, chip); 1164 if (ret < 0) 1165 goto error; 1166 1167 ret = regmap_bulk_write(chip->regmap, DA9121_REG_SYS_MASK_0, mask_all, 4); 1168 if (ret != 0) { 1169 dev_err(chip->dev, "Failed to set IRQ masks: %d\n", ret); 1170 goto error; 1171 } 1172 1173 ret = da9121_set_regulator_config(chip); 1174 if (ret < 0) 1175 goto error; 1176 1177 ret = da9121_config_irq(i2c, chip); 1178 1179 error: 1180 return ret; 1181 } 1182 1183 static void da9121_i2c_remove(struct i2c_client *i2c) 1184 { 1185 struct da9121 *chip = i2c_get_clientdata(i2c); 1186 const int mask_all[4] = { 0xFF, 0xFF, 0xFF, 0xFF }; 1187 int ret; 1188 1189 free_irq(chip->chip_irq, chip); 1190 cancel_delayed_work_sync(&chip->work); 1191 1192 ret = regmap_bulk_write(chip->regmap, DA9121_REG_SYS_MASK_0, mask_all, 4); 1193 if (ret != 0) 1194 dev_err(chip->dev, "Failed to set IRQ masks: %d\n", ret); 1195 } 1196 1197 static const struct i2c_device_id da9121_i2c_id[] = { 1198 {"da9121", DA9121_TYPE_DA9121_DA9130}, 1199 {"da9130", DA9121_TYPE_DA9121_DA9130}, 1200 {"da9217", DA9121_TYPE_DA9217}, 1201 {"da9122", DA9121_TYPE_DA9122_DA9131}, 1202 {"da9131", DA9121_TYPE_DA9122_DA9131}, 1203 {"da9220", DA9121_TYPE_DA9220_DA9132}, 1204 {"da9132", DA9121_TYPE_DA9220_DA9132}, 1205 {"da9141", DA9121_TYPE_DA9141}, 1206 {"da9142", DA9121_TYPE_DA9142}, 1207 {}, 1208 }; 1209 MODULE_DEVICE_TABLE(i2c, da9121_i2c_id); 1210 1211 static struct i2c_driver da9121_regulator_driver = { 1212 .driver = { 1213 .name = "da9121", 1214 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1215 .of_match_table = da9121_dt_ids, 1216 }, 1217 .probe = da9121_i2c_probe, 1218 .remove = da9121_i2c_remove, 1219 .id_table = da9121_i2c_id, 1220 }; 1221 1222 module_i2c_driver(da9121_regulator_driver); 1223 1224 MODULE_DESCRIPTION("Dialog Semiconductor DA9121/DA9122/DA9220/DA9217/DA9130/DA9131/DA9132 regulator driver"); 1225 MODULE_LICENSE("GPL v2"); 1226