1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * IIO driver for PAC1921 High-Side Power/Current Monitor 4 * 5 * Copyright (C) 2024 Matteo Martelli <matteomartelli3@gmail.com> 6 */ 7 8 #include <linux/unaligned.h> 9 #include <linux/bitfield.h> 10 #include <linux/i2c.h> 11 #include <linux/iio/events.h> 12 #include <linux/iio/iio.h> 13 #include <linux/iio/trigger_consumer.h> 14 #include <linux/iio/triggered_buffer.h> 15 #include <linux/limits.h> 16 #include <linux/regmap.h> 17 #include <linux/units.h> 18 19 /* pac1921 registers */ 20 #define PAC1921_REG_GAIN_CFG 0x00 21 #define PAC1921_REG_INT_CFG 0x01 22 #define PAC1921_REG_CONTROL 0x02 23 #define PAC1921_REG_VBUS 0x10 24 #define PAC1921_REG_VSENSE 0x12 25 #define PAC1921_REG_OVERFLOW_STS 0x1C 26 #define PAC1921_REG_VPOWER 0x1D 27 28 /* pac1921 gain configuration bits */ 29 #define PAC1921_GAIN_DI_GAIN_MASK GENMASK(5, 3) 30 #define PAC1921_GAIN_DV_GAIN_MASK GENMASK(2, 0) 31 32 /* pac1921 integration configuration bits */ 33 #define PAC1921_INT_CFG_SMPL_MASK GENMASK(7, 4) 34 #define PAC1921_INT_CFG_VSFEN BIT(3) 35 #define PAC1921_INT_CFG_VBFEN BIT(2) 36 #define PAC1921_INT_CFG_RIOV BIT(1) 37 #define PAC1921_INT_CFG_INTEN BIT(0) 38 39 /* pac1921 control bits */ 40 #define PAC1921_CONTROL_MXSL_MASK GENMASK(7, 6) 41 enum pac1921_mxsl { 42 PAC1921_MXSL_VPOWER_PIN = 0, 43 PAC1921_MXSL_VSENSE_FREE_RUN = 1, 44 PAC1921_MXSL_VBUS_FREE_RUN = 2, 45 PAC1921_MXSL_VPOWER_FREE_RUN = 3, 46 }; 47 #define PAC1921_CONTROL_SLEEP BIT(2) 48 49 /* pac1921 result registers mask and resolution */ 50 #define PAC1921_RES_MASK GENMASK(15, 6) 51 #define PAC1921_RES_RESOLUTION 1023 52 53 /* pac1921 overflow status bits */ 54 #define PAC1921_OVERFLOW_VSOV BIT(2) 55 #define PAC1921_OVERFLOW_VBOV BIT(1) 56 #define PAC1921_OVERFLOW_VPOV BIT(0) 57 58 /* pac1921 constants */ 59 #define PAC1921_MAX_VSENSE_MV 100 60 #define PAC1921_MAX_VBUS_V 32 61 /* Time to first communication after power up (tINT_T) */ 62 #define PAC1921_POWERUP_TIME_MS 20 63 /* Time from Sleep State to Start of Integration Period (tSLEEP_TO_INT) */ 64 #define PAC1921_SLEEP_TO_INT_TIME_US 86 65 66 /* pac1921 defaults */ 67 #define PAC1921_DEFAULT_DV_GAIN 0 /* 2^(value): 1x gain (HW default) */ 68 #define PAC1921_DEFAULT_DI_GAIN 0 /* 2^(value): 1x gain (HW default) */ 69 #define PAC1921_DEFAULT_NUM_SAMPLES 0 /* 2^(value): 1 sample (HW default) */ 70 71 #define PAC1921_ACPI_GET_uOHMS_VALS 0 72 #define PAC1921_ACPI_GET_LABEL 1 73 74 /* f7bb9932-86ee-4516-a236-7a7a742e55cb */ 75 static const guid_t pac1921_guid = 76 GUID_INIT(0xf7bb9932, 0x86ee, 0x4516, 0xa2, 77 0x36, 0x7a, 0x7a, 0x74, 0x2e, 0x55, 0xcb); 78 79 /* 80 * Pre-computed scale factors for BUS voltage 81 * format: IIO_VAL_INT_PLUS_NANO 82 * unit: mV 83 * 84 * Vbus scale (mV) = max_vbus (mV) / dv_gain / resolution 85 */ 86 static const int pac1921_vbus_scales[][2] = { 87 { 31, 280547409 }, /* dv_gain x1 */ 88 { 15, 640273704 }, /* dv_gain x2 */ 89 { 7, 820136852 }, /* dv_gain x4 */ 90 { 3, 910068426 }, /* dv_gain x8 */ 91 { 1, 955034213 }, /* dv_gain x16 */ 92 { 0, 977517106 }, /* dv_gain x32 */ 93 }; 94 95 /* 96 * Pre-computed scales for SENSE voltage 97 * format: IIO_VAL_INT_PLUS_NANO 98 * unit: mV 99 * 100 * Vsense scale (mV) = max_vsense (mV) / di_gain / resolution 101 */ 102 static const int pac1921_vsense_scales[][2] = { 103 { 0, 97751710 }, /* di_gain x1 */ 104 { 0, 48875855 }, /* di_gain x2 */ 105 { 0, 24437927 }, /* di_gain x4 */ 106 { 0, 12218963 }, /* di_gain x8 */ 107 { 0, 6109481 }, /* di_gain x16 */ 108 { 0, 3054740 }, /* di_gain x32 */ 109 { 0, 1527370 }, /* di_gain x64 */ 110 { 0, 763685 }, /* di_gain x128 */ 111 }; 112 113 /* 114 * Numbers of samples used to integrate measurements at the end of an 115 * integration period. 116 * 117 * Changing the number of samples affects the integration period: higher the 118 * number of samples, longer the integration period. 119 * 120 * These correspond to the oversampling ratios available exposed to userspace. 121 */ 122 static const int pac1921_int_num_samples[] = { 123 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048 124 }; 125 126 /* 127 * The integration period depends on the configuration of number of integration 128 * samples, measurement resolution and post filters. The following array 129 * contains integration periods, in microsecs unit, based on table 4-5 from 130 * datasheet considering power integration mode, 14-Bit resolution and post 131 * filters on. Each index corresponds to a specific number of samples from 1 132 * to 2048. 133 */ 134 static const unsigned int pac1921_int_periods_usecs[] = { 135 2720, /* 1 sample */ 136 4050, /* 2 samples */ 137 6790, /* 4 samples */ 138 12200, /* 8 samples */ 139 23000, /* 16 samples */ 140 46000, /* 32 samples */ 141 92000, /* 64 samples */ 142 184000, /* 128 samples */ 143 368000, /* 256 samples */ 144 736000, /* 512 samples */ 145 1471000, /* 1024 samples */ 146 2941000 /* 2048 samples */ 147 }; 148 149 /* pac1921 regmap configuration */ 150 static const struct regmap_range pac1921_regmap_wr_ranges[] = { 151 regmap_reg_range(PAC1921_REG_GAIN_CFG, PAC1921_REG_CONTROL), 152 }; 153 154 static const struct regmap_access_table pac1921_regmap_wr_table = { 155 .yes_ranges = pac1921_regmap_wr_ranges, 156 .n_yes_ranges = ARRAY_SIZE(pac1921_regmap_wr_ranges), 157 }; 158 159 static const struct regmap_range pac1921_regmap_rd_ranges[] = { 160 regmap_reg_range(PAC1921_REG_GAIN_CFG, PAC1921_REG_CONTROL), 161 regmap_reg_range(PAC1921_REG_VBUS, PAC1921_REG_VPOWER + 1), 162 }; 163 164 static const struct regmap_access_table pac1921_regmap_rd_table = { 165 .yes_ranges = pac1921_regmap_rd_ranges, 166 .n_yes_ranges = ARRAY_SIZE(pac1921_regmap_rd_ranges), 167 }; 168 169 static const struct regmap_config pac1921_regmap_config = { 170 .reg_bits = 8, 171 .val_bits = 8, 172 .rd_table = &pac1921_regmap_rd_table, 173 .wr_table = &pac1921_regmap_wr_table, 174 }; 175 176 enum pac1921_channels { 177 PAC1921_CHAN_VBUS = 0, 178 PAC1921_CHAN_VSENSE = 1, 179 PAC1921_CHAN_CURRENT = 2, 180 PAC1921_CHAN_POWER = 3, 181 }; 182 #define PAC1921_NUM_MEAS_CHANS 4 183 184 struct pac1921_priv { 185 struct i2c_client *client; 186 struct regmap *regmap; 187 struct regulator *vdd; 188 struct iio_info iio_info; 189 190 /* 191 * Synchronize access to private members, and ensure atomicity of 192 * consecutive regmap operations. 193 */ 194 struct mutex lock; 195 196 u32 rshunt_uohm; /* uOhm */ 197 u8 dv_gain; 198 u8 di_gain; 199 u8 n_samples; 200 u8 prev_ovf_flags; 201 u8 ovf_enabled_events; 202 203 bool first_integr_started; 204 bool first_integr_done; 205 unsigned long integr_started_time_jiffies; 206 unsigned int integr_period_usecs; 207 208 int current_scales[ARRAY_SIZE(pac1921_vsense_scales)][2]; 209 210 struct { 211 u16 chan[PAC1921_NUM_MEAS_CHANS]; 212 aligned_s64 timestamp; 213 } scan; 214 }; 215 216 /* 217 * Check if first integration after configuration update has completed. 218 * 219 * Must be called with lock held. 220 */ 221 static bool pac1921_data_ready(struct pac1921_priv *priv) 222 { 223 if (!priv->first_integr_started) 224 return false; 225 226 if (!priv->first_integr_done) { 227 unsigned long t_ready; 228 229 /* 230 * Data valid after the device entered into integration state, 231 * considering worst case where the device was in sleep state, 232 * and completed the first integration period. 233 */ 234 t_ready = priv->integr_started_time_jiffies + 235 usecs_to_jiffies(PAC1921_SLEEP_TO_INT_TIME_US) + 236 usecs_to_jiffies(priv->integr_period_usecs); 237 238 if (time_before(jiffies, t_ready)) 239 return false; 240 241 priv->first_integr_done = true; 242 } 243 244 return true; 245 } 246 247 static inline void pac1921_calc_scale(int dividend, int divisor, int *val, 248 int *val2) 249 { 250 s64 tmp; 251 252 tmp = div_s64(dividend * (s64)NANO, divisor); 253 *val = div_s64_rem(tmp, NANO, val2); 254 } 255 256 /* 257 * Fill the table of scale factors for current 258 * format: IIO_VAL_INT_PLUS_NANO 259 * unit: mA 260 * 261 * Vsense LSB (nV) = max_vsense (nV) * di_gain / resolution 262 * Current scale (mA) = Vsense LSB (nV) / shunt (uOhm) 263 * 264 * Must be called with held lock when updating after first initialization. 265 */ 266 static void pac1921_calc_current_scales(struct pac1921_priv *priv) 267 { 268 for (unsigned int i = 0; i < ARRAY_SIZE(priv->current_scales); i++) { 269 int max = (PAC1921_MAX_VSENSE_MV * MICRO) >> i; 270 int vsense_lsb = DIV_ROUND_CLOSEST(max, PAC1921_RES_RESOLUTION); 271 272 pac1921_calc_scale(vsense_lsb, priv->rshunt_uohm, 273 &priv->current_scales[i][0], 274 &priv->current_scales[i][1]); 275 } 276 } 277 278 /* 279 * Check if overflow occurred and if so, push the corresponding events. 280 * 281 * Must be called with lock held. 282 */ 283 static int pac1921_check_push_overflow(struct iio_dev *indio_dev, s64 timestamp) 284 { 285 struct pac1921_priv *priv = iio_priv(indio_dev); 286 unsigned int flags; 287 int ret; 288 289 ret = regmap_read(priv->regmap, PAC1921_REG_OVERFLOW_STS, &flags); 290 if (ret) 291 return ret; 292 293 if (flags & PAC1921_OVERFLOW_VBOV && 294 !(priv->prev_ovf_flags & PAC1921_OVERFLOW_VBOV) && 295 priv->ovf_enabled_events & PAC1921_OVERFLOW_VBOV) { 296 iio_push_event(indio_dev, 297 IIO_UNMOD_EVENT_CODE( 298 IIO_VOLTAGE, PAC1921_CHAN_VBUS, 299 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 300 timestamp); 301 } 302 if (flags & PAC1921_OVERFLOW_VSOV && 303 !(priv->prev_ovf_flags & PAC1921_OVERFLOW_VSOV) && 304 priv->ovf_enabled_events & PAC1921_OVERFLOW_VSOV) { 305 iio_push_event(indio_dev, 306 IIO_UNMOD_EVENT_CODE( 307 IIO_VOLTAGE, PAC1921_CHAN_VSENSE, 308 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 309 timestamp); 310 iio_push_event(indio_dev, 311 IIO_UNMOD_EVENT_CODE( 312 IIO_CURRENT, PAC1921_CHAN_CURRENT, 313 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 314 timestamp); 315 } 316 if (flags & PAC1921_OVERFLOW_VPOV && 317 !(priv->prev_ovf_flags & PAC1921_OVERFLOW_VPOV) && 318 priv->ovf_enabled_events & PAC1921_OVERFLOW_VPOV) { 319 iio_push_event(indio_dev, 320 IIO_UNMOD_EVENT_CODE( 321 IIO_POWER, PAC1921_CHAN_POWER, 322 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING), 323 timestamp); 324 } 325 326 priv->prev_ovf_flags = flags; 327 328 return 0; 329 } 330 331 /* 332 * Read the value from a result register 333 * 334 * Result registers contain the most recent averaged values of Vbus, Vsense and 335 * Vpower. Each value is 10 bits wide and spread across two consecutive 8 bit 336 * registers, with 6 bit LSB zero padding. 337 */ 338 static int pac1921_read_res(struct pac1921_priv *priv, unsigned long reg, 339 u16 *val) 340 { 341 int ret = regmap_bulk_read(priv->regmap, reg, val, sizeof(*val)); 342 if (ret) 343 return ret; 344 345 *val = FIELD_GET(PAC1921_RES_MASK, get_unaligned_be16(val)); 346 347 return 0; 348 } 349 350 static int pac1921_read_raw(struct iio_dev *indio_dev, 351 struct iio_chan_spec const *chan, int *val, 352 int *val2, long mask) 353 { 354 struct pac1921_priv *priv = iio_priv(indio_dev); 355 356 guard(mutex)(&priv->lock); 357 358 switch (mask) { 359 case IIO_CHAN_INFO_RAW: { 360 s64 ts; 361 u16 res_val; 362 int ret; 363 364 if (!pac1921_data_ready(priv)) 365 return -EBUSY; 366 367 ts = iio_get_time_ns(indio_dev); 368 369 ret = pac1921_check_push_overflow(indio_dev, ts); 370 if (ret) 371 return ret; 372 373 ret = pac1921_read_res(priv, chan->address, &res_val); 374 if (ret) 375 return ret; 376 377 *val = res_val; 378 379 return IIO_VAL_INT; 380 } 381 case IIO_CHAN_INFO_SCALE: 382 switch (chan->channel) { 383 case PAC1921_CHAN_VBUS: 384 *val = pac1921_vbus_scales[priv->dv_gain][0]; 385 *val2 = pac1921_vbus_scales[priv->dv_gain][1]; 386 return IIO_VAL_INT_PLUS_NANO; 387 388 case PAC1921_CHAN_VSENSE: 389 *val = pac1921_vsense_scales[priv->di_gain][0]; 390 *val2 = pac1921_vsense_scales[priv->di_gain][1]; 391 return IIO_VAL_INT_PLUS_NANO; 392 393 case PAC1921_CHAN_CURRENT: 394 *val = priv->current_scales[priv->di_gain][0]; 395 *val2 = priv->current_scales[priv->di_gain][1]; 396 return IIO_VAL_INT_PLUS_NANO; 397 398 case PAC1921_CHAN_POWER: { 399 /* 400 * Power scale factor in mW: 401 * Current scale (mA) * max_vbus (V) / dv_gain 402 */ 403 404 /* Get current scale based on di_gain */ 405 int *curr_scale = priv->current_scales[priv->di_gain]; 406 407 /* Convert current_scale from INT_PLUS_NANO to INT */ 408 s64 tmp = curr_scale[0] * (s64)NANO + curr_scale[1]; 409 410 /* Multiply by max_vbus (V) / dv_gain */ 411 tmp *= PAC1921_MAX_VBUS_V >> priv->dv_gain; 412 413 /* Convert back to INT_PLUS_NANO */ 414 *val = div_s64_rem(tmp, NANO, val2); 415 416 return IIO_VAL_INT_PLUS_NANO; 417 } 418 default: 419 return -EINVAL; 420 } 421 422 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 423 *val = pac1921_int_num_samples[priv->n_samples]; 424 return IIO_VAL_INT; 425 426 case IIO_CHAN_INFO_SAMP_FREQ: 427 /* 428 * The sampling frequency (Hz) is read-only and corresponds to 429 * how often the device provides integrated measurements into 430 * the result registers, thus it's 1/integration_period. 431 * The integration period depends on the number of integration 432 * samples, measurement resolution and post filters. 433 * 434 * 1/(integr_period_usecs/MICRO) = MICRO/integr_period_usecs 435 */ 436 *val = MICRO; 437 *val2 = priv->integr_period_usecs; 438 return IIO_VAL_FRACTIONAL; 439 440 default: 441 return -EINVAL; 442 } 443 } 444 445 static int pac1921_read_avail(struct iio_dev *indio_dev, 446 struct iio_chan_spec const *chan, 447 const int **vals, int *type, int *length, 448 long mask) 449 { 450 switch (mask) { 451 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 452 *type = IIO_VAL_INT; 453 *vals = pac1921_int_num_samples; 454 *length = ARRAY_SIZE(pac1921_int_num_samples); 455 return IIO_AVAIL_LIST; 456 default: 457 return -EINVAL; 458 } 459 } 460 461 /* 462 * Perform configuration update sequence: set the device into read state, then 463 * write the config register and set the device back into integration state. 464 * Also reset integration start time and mark first integration to be yet 465 * completed. 466 * 467 * Must be called with lock held. 468 */ 469 static int pac1921_update_cfg_reg(struct pac1921_priv *priv, unsigned int reg, 470 unsigned int mask, unsigned int val) 471 { 472 /* Enter READ state before configuration */ 473 int ret = regmap_update_bits(priv->regmap, PAC1921_REG_INT_CFG, 474 PAC1921_INT_CFG_INTEN, 0); 475 if (ret) 476 return ret; 477 478 /* Update configuration value */ 479 ret = regmap_update_bits(priv->regmap, reg, mask, val); 480 if (ret) 481 return ret; 482 483 /* Re-enable integration */ 484 ret = regmap_update_bits(priv->regmap, PAC1921_REG_INT_CFG, 485 PAC1921_INT_CFG_INTEN, PAC1921_INT_CFG_INTEN); 486 if (ret) 487 return ret; 488 489 /* 490 * Reset integration started time and mark this integration period as 491 * the first one so that new measurements will be considered as valid 492 * only at the end of this integration period. 493 */ 494 priv->integr_started_time_jiffies = jiffies; 495 priv->first_integr_done = false; 496 497 return 0; 498 } 499 500 /* 501 * Retrieve the index of the given scale (represented by scale_val and 502 * scale_val2) from scales_tbl. The returned index (if found) is the log2 of 503 * the gain corresponding to the given scale. 504 * 505 * Must be called with lock held if the scales_tbl can change runtime (e.g. for 506 * the current scales table) 507 */ 508 static int pac1921_lookup_scale(const int (*const scales_tbl)[2], size_t size, 509 int scale_val, int scale_val2) 510 { 511 for (unsigned int i = 0; i < size; i++) 512 if (scales_tbl[i][0] == scale_val && 513 scales_tbl[i][1] == scale_val2) 514 return i; 515 516 return -EINVAL; 517 } 518 519 /* 520 * Configure device with the given gain (only if changed) 521 * 522 * Must be called with lock held. 523 */ 524 static int pac1921_update_gain(struct pac1921_priv *priv, u8 *priv_val, u8 gain, 525 unsigned int mask) 526 { 527 unsigned int reg_val; 528 int ret; 529 530 if (*priv_val == gain) 531 return 0; 532 533 reg_val = (gain << __ffs(mask)) & mask; 534 ret = pac1921_update_cfg_reg(priv, PAC1921_REG_GAIN_CFG, mask, reg_val); 535 if (ret) 536 return ret; 537 538 *priv_val = gain; 539 540 return 0; 541 } 542 543 /* 544 * Given a scale factor represented by scale_val and scale_val2 with format 545 * IIO_VAL_INT_PLUS_NANO, find the corresponding gain value and write it to the 546 * device. 547 * 548 * Must be called with lock held. 549 */ 550 static int pac1921_update_gain_from_scale(struct pac1921_priv *priv, 551 struct iio_chan_spec const *chan, 552 int scale_val, int scale_val2) 553 { 554 int ret; 555 556 switch (chan->channel) { 557 case PAC1921_CHAN_VBUS: 558 ret = pac1921_lookup_scale(pac1921_vbus_scales, 559 ARRAY_SIZE(pac1921_vbus_scales), 560 scale_val, scale_val2); 561 if (ret < 0) 562 return ret; 563 564 return pac1921_update_gain(priv, &priv->dv_gain, ret, 565 PAC1921_GAIN_DV_GAIN_MASK); 566 case PAC1921_CHAN_VSENSE: 567 ret = pac1921_lookup_scale(pac1921_vsense_scales, 568 ARRAY_SIZE(pac1921_vsense_scales), 569 scale_val, scale_val2); 570 if (ret < 0) 571 return ret; 572 573 return pac1921_update_gain(priv, &priv->di_gain, ret, 574 PAC1921_GAIN_DI_GAIN_MASK); 575 case PAC1921_CHAN_CURRENT: 576 ret = pac1921_lookup_scale(priv->current_scales, 577 ARRAY_SIZE(priv->current_scales), 578 scale_val, scale_val2); 579 if (ret < 0) 580 return ret; 581 582 return pac1921_update_gain(priv, &priv->di_gain, ret, 583 PAC1921_GAIN_DI_GAIN_MASK); 584 default: 585 return -EINVAL; 586 } 587 } 588 589 /* 590 * Retrieve the index of the given number of samples from the constant table. 591 * The returned index (if found) is the log2 of the given num_samples. 592 */ 593 static int pac1921_lookup_int_num_samples(int num_samples) 594 { 595 for (unsigned int i = 0; i < ARRAY_SIZE(pac1921_int_num_samples); i++) 596 if (pac1921_int_num_samples[i] == num_samples) 597 return i; 598 599 return -EINVAL; 600 } 601 602 /* 603 * Update the device with the given number of integration samples. 604 * 605 * Must be called with lock held. 606 */ 607 static int pac1921_update_int_num_samples(struct pac1921_priv *priv, 608 int num_samples) 609 { 610 unsigned int reg_val; 611 u8 n_samples; 612 int ret; 613 614 ret = pac1921_lookup_int_num_samples(num_samples); 615 if (ret < 0) 616 return ret; 617 618 n_samples = ret; 619 620 if (priv->n_samples == n_samples) 621 return 0; 622 623 reg_val = FIELD_PREP(PAC1921_INT_CFG_SMPL_MASK, n_samples); 624 625 ret = pac1921_update_cfg_reg(priv, PAC1921_REG_INT_CFG, 626 PAC1921_INT_CFG_SMPL_MASK, reg_val); 627 if (ret) 628 return ret; 629 630 priv->n_samples = n_samples; 631 632 priv->integr_period_usecs = pac1921_int_periods_usecs[priv->n_samples]; 633 634 return 0; 635 } 636 637 static int pac1921_write_raw_get_fmt(struct iio_dev *indio_dev, 638 struct iio_chan_spec const *chan, 639 long info) 640 { 641 switch (info) { 642 case IIO_CHAN_INFO_SCALE: 643 return IIO_VAL_INT_PLUS_NANO; 644 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 645 return IIO_VAL_INT; 646 default: 647 return -EINVAL; 648 } 649 } 650 651 static int pac1921_write_raw(struct iio_dev *indio_dev, 652 struct iio_chan_spec const *chan, int val, 653 int val2, long mask) 654 { 655 struct pac1921_priv *priv = iio_priv(indio_dev); 656 657 guard(mutex)(&priv->lock); 658 659 switch (mask) { 660 case IIO_CHAN_INFO_SCALE: 661 return pac1921_update_gain_from_scale(priv, chan, val, val2); 662 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 663 return pac1921_update_int_num_samples(priv, val); 664 default: 665 return -EINVAL; 666 } 667 } 668 669 static int pac1921_read_label(struct iio_dev *indio_dev, 670 struct iio_chan_spec const *chan, char *label) 671 { 672 switch (chan->channel) { 673 case PAC1921_CHAN_VBUS: 674 return sprintf(label, "vbus\n"); 675 case PAC1921_CHAN_VSENSE: 676 return sprintf(label, "vsense\n"); 677 case PAC1921_CHAN_CURRENT: 678 return sprintf(label, "current\n"); 679 case PAC1921_CHAN_POWER: 680 return sprintf(label, "power\n"); 681 default: 682 return -EINVAL; 683 } 684 } 685 686 static int pac1921_read_event_config(struct iio_dev *indio_dev, 687 const struct iio_chan_spec *chan, 688 enum iio_event_type type, 689 enum iio_event_direction dir) 690 { 691 struct pac1921_priv *priv = iio_priv(indio_dev); 692 693 guard(mutex)(&priv->lock); 694 695 switch (chan->channel) { 696 case PAC1921_CHAN_VBUS: 697 return !!(priv->ovf_enabled_events & PAC1921_OVERFLOW_VBOV); 698 case PAC1921_CHAN_VSENSE: 699 case PAC1921_CHAN_CURRENT: 700 return !!(priv->ovf_enabled_events & PAC1921_OVERFLOW_VSOV); 701 case PAC1921_CHAN_POWER: 702 return !!(priv->ovf_enabled_events & PAC1921_OVERFLOW_VPOV); 703 default: 704 return -EINVAL; 705 } 706 } 707 708 static int pac1921_write_event_config(struct iio_dev *indio_dev, 709 const struct iio_chan_spec *chan, 710 enum iio_event_type type, 711 enum iio_event_direction dir, 712 bool state) 713 { 714 struct pac1921_priv *priv = iio_priv(indio_dev); 715 u8 ovf_bit; 716 717 guard(mutex)(&priv->lock); 718 719 switch (chan->channel) { 720 case PAC1921_CHAN_VBUS: 721 ovf_bit = PAC1921_OVERFLOW_VBOV; 722 break; 723 case PAC1921_CHAN_VSENSE: 724 case PAC1921_CHAN_CURRENT: 725 ovf_bit = PAC1921_OVERFLOW_VSOV; 726 break; 727 case PAC1921_CHAN_POWER: 728 ovf_bit = PAC1921_OVERFLOW_VPOV; 729 break; 730 default: 731 return -EINVAL; 732 } 733 734 if (state) 735 priv->ovf_enabled_events |= ovf_bit; 736 else 737 priv->ovf_enabled_events &= ~ovf_bit; 738 739 return 0; 740 } 741 742 static int pac1921_read_event_value(struct iio_dev *indio_dev, 743 const struct iio_chan_spec *chan, 744 enum iio_event_type type, 745 enum iio_event_direction dir, 746 enum iio_event_info info, int *val, 747 int *val2) 748 { 749 switch (info) { 750 case IIO_EV_INFO_VALUE: 751 *val = PAC1921_RES_RESOLUTION; 752 return IIO_VAL_INT; 753 default: 754 return -EINVAL; 755 } 756 } 757 758 static const struct iio_info pac1921_iio = { 759 .read_raw = pac1921_read_raw, 760 .read_avail = pac1921_read_avail, 761 .write_raw = pac1921_write_raw, 762 .write_raw_get_fmt = pac1921_write_raw_get_fmt, 763 .read_label = pac1921_read_label, 764 .read_event_config = pac1921_read_event_config, 765 .write_event_config = pac1921_write_event_config, 766 .read_event_value = pac1921_read_event_value, 767 }; 768 769 static ssize_t pac1921_read_shunt_resistor(struct iio_dev *indio_dev, 770 uintptr_t private, 771 const struct iio_chan_spec *chan, 772 char *buf) 773 { 774 struct pac1921_priv *priv = iio_priv(indio_dev); 775 int vals[2]; 776 777 if (chan->channel != PAC1921_CHAN_CURRENT) 778 return -EINVAL; 779 780 guard(mutex)(&priv->lock); 781 782 vals[0] = priv->rshunt_uohm; 783 vals[1] = MICRO; 784 785 return iio_format_value(buf, IIO_VAL_FRACTIONAL, 1, vals); 786 } 787 788 static ssize_t pac1921_write_shunt_resistor(struct iio_dev *indio_dev, 789 uintptr_t private, 790 const struct iio_chan_spec *chan, 791 const char *buf, size_t len) 792 { 793 struct pac1921_priv *priv = iio_priv(indio_dev); 794 u32 rshunt_uohm; 795 int val, val_fract; 796 int ret; 797 798 if (chan->channel != PAC1921_CHAN_CURRENT) 799 return -EINVAL; 800 801 ret = iio_str_to_fixpoint(buf, 100000, &val, &val_fract); 802 if (ret) 803 return ret; 804 805 /* 806 * This check validates the shunt is not zero and does not surpass 807 * INT_MAX. The check is done before calculating in order to avoid 808 * val * MICRO overflowing. 809 */ 810 if ((!val && !val_fract) || val > INT_MAX / MICRO || 811 (val == INT_MAX / MICRO && val_fract > INT_MAX % MICRO)) 812 return -EINVAL; 813 814 rshunt_uohm = val * MICRO + val_fract; 815 816 guard(mutex)(&priv->lock); 817 818 priv->rshunt_uohm = rshunt_uohm; 819 820 pac1921_calc_current_scales(priv); 821 822 return len; 823 } 824 825 /* 826 * Emit on sysfs the list of available scales contained in scales_tbl 827 * 828 * TODO:: this function can be replaced with iio_format_avail_list() if the 829 * latter will ever be exported. 830 * 831 * Must be called with lock held if the scales_tbl can change runtime (e.g. for 832 * the current scales table) 833 */ 834 static ssize_t pac1921_format_scale_avail(const int (*const scales_tbl)[2], 835 size_t size, char *buf) 836 { 837 ssize_t len = 0; 838 839 for (unsigned int i = 0; i < size; i++) { 840 if (i != 0) { 841 len += sysfs_emit_at(buf, len, " "); 842 if (len >= PAGE_SIZE) 843 return -EFBIG; 844 } 845 len += sysfs_emit_at(buf, len, "%d.%09d", scales_tbl[i][0], 846 scales_tbl[i][1]); 847 if (len >= PAGE_SIZE) 848 return -EFBIG; 849 } 850 851 len += sysfs_emit_at(buf, len, "\n"); 852 return len; 853 } 854 855 /* 856 * Read available scales for a specific channel 857 * 858 * NOTE: using extended info insted of iio.read_avail() because access to 859 * current scales must be locked as they depend on shunt resistor which may 860 * change runtime. Caller of iio.read_avail() would access the table unlocked 861 * instead. 862 */ 863 static ssize_t pac1921_read_scale_avail(struct iio_dev *indio_dev, 864 uintptr_t private, 865 const struct iio_chan_spec *chan, 866 char *buf) 867 { 868 struct pac1921_priv *priv = iio_priv(indio_dev); 869 const int (*scales_tbl)[2]; 870 size_t size; 871 872 switch (chan->channel) { 873 case PAC1921_CHAN_VBUS: 874 scales_tbl = pac1921_vbus_scales; 875 size = ARRAY_SIZE(pac1921_vbus_scales); 876 return pac1921_format_scale_avail(scales_tbl, size, buf); 877 878 case PAC1921_CHAN_VSENSE: 879 scales_tbl = pac1921_vsense_scales; 880 size = ARRAY_SIZE(pac1921_vsense_scales); 881 return pac1921_format_scale_avail(scales_tbl, size, buf); 882 883 case PAC1921_CHAN_CURRENT: { 884 guard(mutex)(&priv->lock); 885 scales_tbl = priv->current_scales; 886 size = ARRAY_SIZE(priv->current_scales); 887 return pac1921_format_scale_avail(scales_tbl, size, buf); 888 } 889 default: 890 return -EINVAL; 891 } 892 } 893 894 #define PAC1921_EXT_INFO_SCALE_AVAIL { \ 895 .name = "scale_available", \ 896 .read = pac1921_read_scale_avail, \ 897 .shared = IIO_SEPARATE, \ 898 } 899 900 static const struct iio_chan_spec_ext_info pac1921_ext_info_voltage[] = { 901 PAC1921_EXT_INFO_SCALE_AVAIL, 902 {} 903 }; 904 905 static const struct iio_chan_spec_ext_info pac1921_ext_info_current[] = { 906 PAC1921_EXT_INFO_SCALE_AVAIL, 907 { 908 .name = "shunt_resistor", 909 .read = pac1921_read_shunt_resistor, 910 .write = pac1921_write_shunt_resistor, 911 .shared = IIO_SEPARATE, 912 }, 913 {} 914 }; 915 916 static const struct iio_event_spec pac1921_overflow_event[] = { 917 { 918 .type = IIO_EV_TYPE_THRESH, 919 .dir = IIO_EV_DIR_RISING, 920 .mask_shared_by_all = BIT(IIO_EV_INFO_VALUE), 921 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 922 }, 923 }; 924 925 static const struct iio_chan_spec pac1921_channels[] = { 926 { 927 .type = IIO_VOLTAGE, 928 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 929 BIT(IIO_CHAN_INFO_SCALE), 930 .info_mask_shared_by_all = 931 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 932 BIT(IIO_CHAN_INFO_SAMP_FREQ), 933 .info_mask_shared_by_all_available = 934 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 935 .channel = PAC1921_CHAN_VBUS, 936 .address = PAC1921_REG_VBUS, 937 .scan_index = PAC1921_CHAN_VBUS, 938 .scan_type = { 939 .sign = 'u', 940 .realbits = 10, 941 .storagebits = 16, 942 .endianness = IIO_CPU 943 }, 944 .indexed = 1, 945 .event_spec = pac1921_overflow_event, 946 .num_event_specs = ARRAY_SIZE(pac1921_overflow_event), 947 .ext_info = pac1921_ext_info_voltage, 948 }, 949 { 950 .type = IIO_VOLTAGE, 951 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 952 BIT(IIO_CHAN_INFO_SCALE), 953 .info_mask_shared_by_all = 954 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 955 BIT(IIO_CHAN_INFO_SAMP_FREQ), 956 .info_mask_shared_by_all_available = 957 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 958 .channel = PAC1921_CHAN_VSENSE, 959 .address = PAC1921_REG_VSENSE, 960 .scan_index = PAC1921_CHAN_VSENSE, 961 .scan_type = { 962 .sign = 'u', 963 .realbits = 10, 964 .storagebits = 16, 965 .endianness = IIO_CPU 966 }, 967 .indexed = 1, 968 .event_spec = pac1921_overflow_event, 969 .num_event_specs = ARRAY_SIZE(pac1921_overflow_event), 970 .ext_info = pac1921_ext_info_voltage, 971 }, 972 { 973 .type = IIO_CURRENT, 974 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 975 BIT(IIO_CHAN_INFO_SCALE), 976 .info_mask_shared_by_all = 977 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 978 BIT(IIO_CHAN_INFO_SAMP_FREQ), 979 .info_mask_shared_by_all_available = 980 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 981 .channel = PAC1921_CHAN_CURRENT, 982 .address = PAC1921_REG_VSENSE, 983 .scan_index = PAC1921_CHAN_CURRENT, 984 .scan_type = { 985 .sign = 'u', 986 .realbits = 10, 987 .storagebits = 16, 988 .endianness = IIO_CPU 989 }, 990 .event_spec = pac1921_overflow_event, 991 .num_event_specs = ARRAY_SIZE(pac1921_overflow_event), 992 .ext_info = pac1921_ext_info_current, 993 }, 994 { 995 .type = IIO_POWER, 996 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 997 BIT(IIO_CHAN_INFO_SCALE), 998 .info_mask_shared_by_all = 999 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 1000 BIT(IIO_CHAN_INFO_SAMP_FREQ), 1001 .info_mask_shared_by_all_available = 1002 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 1003 .channel = PAC1921_CHAN_POWER, 1004 .address = PAC1921_REG_VPOWER, 1005 .scan_index = PAC1921_CHAN_POWER, 1006 .scan_type = { 1007 .sign = 'u', 1008 .realbits = 10, 1009 .storagebits = 16, 1010 .endianness = IIO_CPU 1011 }, 1012 .event_spec = pac1921_overflow_event, 1013 .num_event_specs = ARRAY_SIZE(pac1921_overflow_event), 1014 }, 1015 IIO_CHAN_SOFT_TIMESTAMP(PAC1921_NUM_MEAS_CHANS), 1016 }; 1017 1018 static irqreturn_t pac1921_trigger_handler(int irq, void *p) 1019 { 1020 struct iio_poll_func *pf = p; 1021 struct iio_dev *idev = pf->indio_dev; 1022 struct pac1921_priv *priv = iio_priv(idev); 1023 int ret; 1024 int bit; 1025 int ch = 0; 1026 1027 guard(mutex)(&priv->lock); 1028 1029 if (!pac1921_data_ready(priv)) 1030 goto done; 1031 1032 ret = pac1921_check_push_overflow(idev, pf->timestamp); 1033 if (ret) 1034 goto done; 1035 1036 iio_for_each_active_channel(idev, bit) { 1037 u16 val; 1038 1039 ret = pac1921_read_res(priv, idev->channels[ch].address, &val); 1040 if (ret) 1041 goto done; 1042 1043 priv->scan.chan[ch++] = val; 1044 } 1045 1046 iio_push_to_buffers_with_timestamp(idev, &priv->scan, pf->timestamp); 1047 1048 done: 1049 iio_trigger_notify_done(idev->trig); 1050 1051 return IRQ_HANDLED; 1052 } 1053 1054 /* 1055 * Initialize device by writing initial configuration and putting it into 1056 * integration state. 1057 * 1058 * Must be called with lock held when called after first initialization 1059 * (e.g. from pm resume) 1060 */ 1061 static int pac1921_init(struct pac1921_priv *priv) 1062 { 1063 unsigned int val; 1064 int ret; 1065 1066 /* Enter READ state before configuration */ 1067 ret = regmap_update_bits(priv->regmap, PAC1921_REG_INT_CFG, 1068 PAC1921_INT_CFG_INTEN, 0); 1069 if (ret) 1070 return ret; 1071 1072 /* Configure gains, use 14-bits measurement resolution (HW default) */ 1073 val = FIELD_PREP(PAC1921_GAIN_DI_GAIN_MASK, priv->di_gain) | 1074 FIELD_PREP(PAC1921_GAIN_DV_GAIN_MASK, priv->dv_gain); 1075 ret = regmap_write(priv->regmap, PAC1921_REG_GAIN_CFG, val); 1076 if (ret) 1077 return ret; 1078 1079 /* 1080 * Configure integration: 1081 * - num of integration samples 1082 * - filters enabled (HW default) 1083 * - set READ/INT pin override (RIOV) to control operation mode via 1084 * register instead of pin 1085 */ 1086 val = FIELD_PREP(PAC1921_INT_CFG_SMPL_MASK, priv->n_samples) | 1087 PAC1921_INT_CFG_VSFEN | PAC1921_INT_CFG_VBFEN | 1088 PAC1921_INT_CFG_RIOV; 1089 ret = regmap_write(priv->regmap, PAC1921_REG_INT_CFG, val); 1090 if (ret) 1091 return ret; 1092 1093 /* 1094 * Init control register: 1095 * - VPower free run integration mode 1096 * - OUT pin full scale range: 3V (HW default) 1097 * - no timeout, no sleep, no sleep override, no recalc (HW defaults) 1098 */ 1099 val = FIELD_PREP(PAC1921_CONTROL_MXSL_MASK, 1100 PAC1921_MXSL_VPOWER_FREE_RUN); 1101 ret = regmap_write(priv->regmap, PAC1921_REG_CONTROL, val); 1102 if (ret) 1103 return ret; 1104 1105 /* Enable integration */ 1106 ret = regmap_update_bits(priv->regmap, PAC1921_REG_INT_CFG, 1107 PAC1921_INT_CFG_INTEN, PAC1921_INT_CFG_INTEN); 1108 if (ret) 1109 return ret; 1110 1111 priv->first_integr_started = true; 1112 priv->integr_started_time_jiffies = jiffies; 1113 priv->integr_period_usecs = pac1921_int_periods_usecs[priv->n_samples]; 1114 1115 return 0; 1116 } 1117 1118 static int pac1921_suspend(struct device *dev) 1119 { 1120 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1121 struct pac1921_priv *priv = iio_priv(indio_dev); 1122 int ret; 1123 1124 guard(mutex)(&priv->lock); 1125 1126 priv->first_integr_started = false; 1127 priv->first_integr_done = false; 1128 1129 ret = regmap_update_bits(priv->regmap, PAC1921_REG_INT_CFG, 1130 PAC1921_INT_CFG_INTEN, 0); 1131 if (ret) 1132 return ret; 1133 1134 ret = regmap_update_bits(priv->regmap, PAC1921_REG_CONTROL, 1135 PAC1921_CONTROL_SLEEP, PAC1921_CONTROL_SLEEP); 1136 if (ret) 1137 return ret; 1138 1139 return regulator_disable(priv->vdd); 1140 1141 } 1142 1143 static int pac1921_resume(struct device *dev) 1144 { 1145 struct iio_dev *indio_dev = dev_get_drvdata(dev); 1146 struct pac1921_priv *priv = iio_priv(indio_dev); 1147 int ret; 1148 1149 guard(mutex)(&priv->lock); 1150 1151 ret = regulator_enable(priv->vdd); 1152 if (ret) 1153 return ret; 1154 1155 msleep(PAC1921_POWERUP_TIME_MS); 1156 1157 return pac1921_init(priv); 1158 } 1159 1160 static DEFINE_SIMPLE_DEV_PM_OPS(pac1921_pm_ops, pac1921_suspend, 1161 pac1921_resume); 1162 1163 static void pac1921_regulator_disable(void *data) 1164 { 1165 struct regulator *regulator = data; 1166 1167 regulator_disable(regulator); 1168 } 1169 1170 /* 1171 * Documentation related to the ACPI device definition 1172 * https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ApplicationNotes/ApplicationNotes/PAC193X-Integration-Notes-for-Microsoft-Windows-10-and-Windows-11-Driver-Support-DS00002534.pdf 1173 */ 1174 static int pac1921_match_acpi_device(struct iio_dev *indio_dev) 1175 { 1176 acpi_handle handle; 1177 union acpi_object *status; 1178 char *label; 1179 struct pac1921_priv *priv = iio_priv(indio_dev); 1180 struct device *dev = &priv->client->dev; 1181 1182 handle = ACPI_HANDLE(dev); 1183 1184 status = acpi_evaluate_dsm(handle, &pac1921_guid, 1, 1185 PAC1921_ACPI_GET_uOHMS_VALS, NULL); 1186 if (!status) 1187 return dev_err_probe(dev, -EINVAL, 1188 "Could not read shunt from ACPI table\n"); 1189 1190 priv->rshunt_uohm = status->package.elements[0].integer.value; 1191 ACPI_FREE(status); 1192 1193 status = acpi_evaluate_dsm(handle, &pac1921_guid, 1, 1194 PAC1921_ACPI_GET_LABEL, NULL); 1195 if (!status) 1196 return dev_err_probe(dev, -EINVAL, 1197 "Could not read label from ACPI table\n"); 1198 1199 label = devm_kstrdup(dev, status->package.elements[0].string.pointer, 1200 GFP_KERNEL); 1201 if (!label) 1202 return -ENOMEM; 1203 1204 indio_dev->label = label; 1205 ACPI_FREE(status); 1206 1207 return 0; 1208 } 1209 1210 static int pac1921_parse_of_fw(struct iio_dev *indio_dev) 1211 { 1212 int ret; 1213 struct pac1921_priv *priv = iio_priv(indio_dev); 1214 struct device *dev = &priv->client->dev; 1215 1216 ret = device_property_read_u32(dev, "shunt-resistor-micro-ohms", 1217 &priv->rshunt_uohm); 1218 if (ret) 1219 return dev_err_probe(dev, ret, 1220 "Cannot read shunt resistor property\n"); 1221 1222 return 0; 1223 } 1224 1225 static int pac1921_probe(struct i2c_client *client) 1226 { 1227 struct device *dev = &client->dev; 1228 struct pac1921_priv *priv; 1229 struct iio_dev *indio_dev; 1230 int ret; 1231 1232 indio_dev = devm_iio_device_alloc(dev, sizeof(*priv)); 1233 if (!indio_dev) 1234 return -ENOMEM; 1235 1236 priv = iio_priv(indio_dev); 1237 priv->client = client; 1238 i2c_set_clientdata(client, indio_dev); 1239 1240 priv->regmap = devm_regmap_init_i2c(client, &pac1921_regmap_config); 1241 if (IS_ERR(priv->regmap)) 1242 return dev_err_probe(dev, PTR_ERR(priv->regmap), 1243 "Cannot initialize register map\n"); 1244 1245 ret = devm_mutex_init(dev, &priv->lock); 1246 if (ret) 1247 return ret; 1248 1249 priv->dv_gain = PAC1921_DEFAULT_DV_GAIN; 1250 priv->di_gain = PAC1921_DEFAULT_DI_GAIN; 1251 priv->n_samples = PAC1921_DEFAULT_NUM_SAMPLES; 1252 1253 if (is_acpi_device_node(dev->fwnode)) 1254 ret = pac1921_match_acpi_device(indio_dev); 1255 else 1256 ret = pac1921_parse_of_fw(indio_dev); 1257 if (ret) 1258 return dev_err_probe(dev, ret, 1259 "Parameter parsing error\n"); 1260 1261 if (priv->rshunt_uohm == 0 || priv->rshunt_uohm > INT_MAX) 1262 return dev_err_probe(dev, -EINVAL, 1263 "Invalid shunt resistor: %u\n", 1264 priv->rshunt_uohm); 1265 1266 pac1921_calc_current_scales(priv); 1267 1268 priv->vdd = devm_regulator_get(dev, "vdd"); 1269 if (IS_ERR(priv->vdd)) 1270 return dev_err_probe(dev, PTR_ERR(priv->vdd), 1271 "Cannot get vdd regulator\n"); 1272 1273 ret = regulator_enable(priv->vdd); 1274 if (ret) 1275 return dev_err_probe(dev, ret, "Cannot enable vdd regulator\n"); 1276 1277 ret = devm_add_action_or_reset(dev, pac1921_regulator_disable, 1278 priv->vdd); 1279 if (ret) 1280 return dev_err_probe(dev, ret, 1281 "Cannot add action for vdd regulator disposal\n"); 1282 1283 msleep(PAC1921_POWERUP_TIME_MS); 1284 1285 ret = pac1921_init(priv); 1286 if (ret) 1287 return dev_err_probe(dev, ret, "Cannot initialize device\n"); 1288 1289 priv->iio_info = pac1921_iio; 1290 1291 indio_dev->name = "pac1921"; 1292 indio_dev->info = &priv->iio_info; 1293 indio_dev->modes = INDIO_DIRECT_MODE; 1294 indio_dev->channels = pac1921_channels; 1295 indio_dev->num_channels = ARRAY_SIZE(pac1921_channels); 1296 1297 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 1298 &iio_pollfunc_store_time, 1299 &pac1921_trigger_handler, NULL); 1300 if (ret) 1301 return dev_err_probe(dev, ret, 1302 "Cannot setup IIO triggered buffer\n"); 1303 1304 ret = devm_iio_device_register(dev, indio_dev); 1305 if (ret) 1306 return dev_err_probe(dev, ret, "Cannot register IIO device\n"); 1307 1308 return 0; 1309 } 1310 1311 static const struct i2c_device_id pac1921_id[] = { 1312 { .name = "pac1921", 0 }, 1313 { } 1314 }; 1315 MODULE_DEVICE_TABLE(i2c, pac1921_id); 1316 1317 static const struct of_device_id pac1921_of_match[] = { 1318 { .compatible = "microchip,pac1921" }, 1319 { } 1320 }; 1321 MODULE_DEVICE_TABLE(of, pac1921_of_match); 1322 1323 static const struct acpi_device_id pac1921_acpi_match[] = { 1324 { "MCHP1921" }, 1325 { } 1326 }; 1327 MODULE_DEVICE_TABLE(acpi, pac1921_acpi_match); 1328 1329 static struct i2c_driver pac1921_driver = { 1330 .driver = { 1331 .name = "pac1921", 1332 .pm = pm_sleep_ptr(&pac1921_pm_ops), 1333 .of_match_table = pac1921_of_match, 1334 .acpi_match_table = pac1921_acpi_match, 1335 }, 1336 .probe = pac1921_probe, 1337 .id_table = pac1921_id, 1338 }; 1339 1340 module_i2c_driver(pac1921_driver); 1341 1342 MODULE_AUTHOR("Matteo Martelli <matteomartelli3@gmail.com>"); 1343 MODULE_DESCRIPTION("IIO driver for PAC1921 High-Side Power/Current Monitor"); 1344 MODULE_LICENSE("GPL"); 1345