drivers/iio/adc/axp20x_adc.c

   1 /* ADC driver for AXP20X and AXP22X PMICs
   2  *
   3  * Copyright (c) 2016 Free Electrons NextThing Co.
   4  *      Quentin Schulz <quentin.schulz@free-electrons.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it under
   7  * the terms of the GNU General Public License version 2 as published by the
   8  * Free Software Foundation.
   9  */
  10
  11 #include <linux/completion.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/of_device.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/regmap.h>
  20 #include <linux/thermal.h>
  21
  22 #include <linux/iio/iio.h>
  23 #include <linux/iio/driver.h>
  24 #include <linux/iio/machine.h>
  25 #include <linux/mfd/axp20x.h>
  26
  27 #define AXP20X_ADC_EN1_MASK                     GENMASK(7, 0)
  28
  29 #define AXP20X_ADC_EN2_MASK                     (GENMASK(3, 2) | BIT(7))
  30 #define AXP22X_ADC_EN1_MASK                     (GENMASK(7, 5) | BIT(0))
  31
  32 #define AXP20X_GPIO10_IN_RANGE_GPIO0            BIT(0)
  33 #define AXP20X_GPIO10_IN_RANGE_GPIO1            BIT(1)
  34 #define AXP20X_GPIO10_IN_RANGE_GPIO0_VAL(x)     ((x) & BIT(0))
  35 #define AXP20X_GPIO10_IN_RANGE_GPIO1_VAL(x)     (((x) & BIT(0)) << 1)
  36
  37 #define AXP20X_ADC_RATE_MASK                    GENMASK(7, 6)
  38 #define AXP813_V_I_ADC_RATE_MASK                GENMASK(5, 4)
  39 #define AXP813_ADC_RATE_MASK                    (AXP20X_ADC_RATE_MASK | AXP813_V_I_ADC_RATE_MASK)
  40 #define AXP20X_ADC_RATE_HZ(x)                   ((ilog2((x) / 25) << 6) & AXP20X_ADC_RATE_MASK)
  41 #define AXP22X_ADC_RATE_HZ(x)                   ((ilog2((x) / 100) << 6) & AXP20X_ADC_RATE_MASK)
  42 #define AXP813_TS_GPIO0_ADC_RATE_HZ(x)          AXP20X_ADC_RATE_HZ(x)
  43 #define AXP813_V_I_ADC_RATE_HZ(x)               ((ilog2((x) / 100) << 4) & AXP813_V_I_ADC_RATE_MASK)
  44 #define AXP813_ADC_RATE_HZ(x)                   (AXP20X_ADC_RATE_HZ(x) | AXP813_V_I_ADC_RATE_HZ(x))
  45
  46 #define AXP20X_ADC_CHANNEL(_channel, _name, _type, _reg)        \
  47         {                                                       \
  48                 .type = _type,                                  \
  49                 .indexed = 1,                                   \
  50                 .channel = _channel,                            \
  51                 .address = _reg,                                \
  52                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
  53                                       BIT(IIO_CHAN_INFO_SCALE), \
  54                 .datasheet_name = _name,                        \
  55         }
  56
  57 #define AXP20X_ADC_CHANNEL_OFFSET(_channel, _name, _type, _reg) \
  58         {                                                       \
  59                 .type = _type,                                  \
  60                 .indexed = 1,                                   \
  61                 .channel = _channel,                            \
  62                 .address = _reg,                                \
  63                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
  64                                       BIT(IIO_CHAN_INFO_SCALE) |\
  65                                       BIT(IIO_CHAN_INFO_OFFSET),\
  66                 .datasheet_name = _name,                        \
  67         }
  68
  69 struct axp_data;
  70
  71 struct axp20x_adc_iio {
  72         struct regmap           *regmap;
  73         struct axp_data         *data;
  74 };
  75
  76 enum axp20x_adc_channel_v {
  77         AXP20X_ACIN_V = 0,
  78         AXP20X_VBUS_V,
  79         AXP20X_TS_IN,
  80         AXP20X_GPIO0_V,
  81         AXP20X_GPIO1_V,
  82         AXP20X_IPSOUT_V,
  83         AXP20X_BATT_V,
  84 };
  85
  86 enum axp20x_adc_channel_i {
  87         AXP20X_ACIN_I = 0,
  88         AXP20X_VBUS_I,
  89         AXP20X_BATT_CHRG_I,
  90         AXP20X_BATT_DISCHRG_I,
  91 };
  92
  93 enum axp22x_adc_channel_v {
  94         AXP22X_TS_IN = 0,
  95         AXP22X_BATT_V,
  96 };
  97
  98 enum axp22x_adc_channel_i {
  99         AXP22X_BATT_CHRG_I = 1,
 100         AXP22X_BATT_DISCHRG_I,
 101 };
 102
 103 enum axp813_adc_channel_v {
 104         AXP813_TS_IN = 0,
 105         AXP813_GPIO0_V,
 106         AXP813_BATT_V,
 107 };
 108
 109 static struct iio_map axp20x_maps[] = {
 110         {
 111                 .consumer_dev_name = "axp20x-usb-power-supply",
 112                 .consumer_channel = "vbus_v",
 113                 .adc_channel_label = "vbus_v",
 114         }, {
 115                 .consumer_dev_name = "axp20x-usb-power-supply",
 116                 .consumer_channel = "vbus_i",
 117                 .adc_channel_label = "vbus_i",
 118         }, {
 119                 .consumer_dev_name = "axp20x-ac-power-supply",
 120                 .consumer_channel = "acin_v",
 121                 .adc_channel_label = "acin_v",
 122         }, {
 123                 .consumer_dev_name = "axp20x-ac-power-supply",
 124                 .consumer_channel = "acin_i",
 125                 .adc_channel_label = "acin_i",
 126         }, {
 127                 .consumer_dev_name = "axp20x-battery-power-supply",
 128                 .consumer_channel = "batt_v",
 129                 .adc_channel_label = "batt_v",
 130         }, {
 131                 .consumer_dev_name = "axp20x-battery-power-supply",
 132                 .consumer_channel = "batt_chrg_i",
 133                 .adc_channel_label = "batt_chrg_i",
 134         }, {
 135                 .consumer_dev_name = "axp20x-battery-power-supply",
 136                 .consumer_channel = "batt_dischrg_i",
 137                 .adc_channel_label = "batt_dischrg_i",
 138         }, { /* sentinel */ }
 139 };
 140
 141 static struct iio_map axp22x_maps[] = {
 142         {
 143                 .consumer_dev_name = "axp20x-battery-power-supply",
 144                 .consumer_channel = "batt_v",
 145                 .adc_channel_label = "batt_v",
 146         }, {
 147                 .consumer_dev_name = "axp20x-battery-power-supply",
 148                 .consumer_channel = "batt_chrg_i",
 149                 .adc_channel_label = "batt_chrg_i",
 150         }, {
 151                 .consumer_dev_name = "axp20x-battery-power-supply",
 152                 .consumer_channel = "batt_dischrg_i",
 153                 .adc_channel_label = "batt_dischrg_i",
 154         }, { /* sentinel */ }
 155 };
 156
 157 /*
 158  * Channels are mapped by physical system. Their channels share the same index.
 159  * i.e. acin_i is in_current0_raw and acin_v is in_voltage0_raw.
 160  * The only exception is for the battery. batt_v will be in_voltage6_raw and
 161  * charge current in_current6_raw and discharge current will be in_current7_raw.
 162  */
 163 static const struct iio_chan_spec axp20x_adc_channels[] = {
 164         AXP20X_ADC_CHANNEL(AXP20X_ACIN_V, "acin_v", IIO_VOLTAGE,
 165                            AXP20X_ACIN_V_ADC_H),
 166         AXP20X_ADC_CHANNEL(AXP20X_ACIN_I, "acin_i", IIO_CURRENT,
 167                            AXP20X_ACIN_I_ADC_H),
 168         AXP20X_ADC_CHANNEL(AXP20X_VBUS_V, "vbus_v", IIO_VOLTAGE,
 169                            AXP20X_VBUS_V_ADC_H),
 170         AXP20X_ADC_CHANNEL(AXP20X_VBUS_I, "vbus_i", IIO_CURRENT,
 171                            AXP20X_VBUS_I_ADC_H),
 172         {
 173                 .type = IIO_TEMP,
 174                 .address = AXP20X_TEMP_ADC_H,
 175                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 176                                       BIT(IIO_CHAN_INFO_SCALE) |
 177                                       BIT(IIO_CHAN_INFO_OFFSET),
 178                 .datasheet_name = "pmic_temp",
 179         },
 180         AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO0_V, "gpio0_v", IIO_VOLTAGE,
 181                                   AXP20X_GPIO0_V_ADC_H),
 182         AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO1_V, "gpio1_v", IIO_VOLTAGE,
 183                                   AXP20X_GPIO1_V_ADC_H),
 184         AXP20X_ADC_CHANNEL(AXP20X_IPSOUT_V, "ipsout_v", IIO_VOLTAGE,
 185                            AXP20X_IPSOUT_V_HIGH_H),
 186         AXP20X_ADC_CHANNEL(AXP20X_BATT_V, "batt_v", IIO_VOLTAGE,
 187                            AXP20X_BATT_V_H),
 188         AXP20X_ADC_CHANNEL(AXP20X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
 189                            AXP20X_BATT_CHRG_I_H),
 190         AXP20X_ADC_CHANNEL(AXP20X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
 191                            AXP20X_BATT_DISCHRG_I_H),
 192 };
 193
 194 static const struct iio_chan_spec axp22x_adc_channels[] = {
 195         {
 196                 .type = IIO_TEMP,
 197                 .address = AXP22X_PMIC_TEMP_H,
 198                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 199                                       BIT(IIO_CHAN_INFO_SCALE) |
 200                                       BIT(IIO_CHAN_INFO_OFFSET),
 201                 .datasheet_name = "pmic_temp",
 202         },
 203         AXP20X_ADC_CHANNEL(AXP22X_BATT_V, "batt_v", IIO_VOLTAGE,
 204                            AXP20X_BATT_V_H),
 205         AXP20X_ADC_CHANNEL(AXP22X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
 206                            AXP20X_BATT_CHRG_I_H),
 207         AXP20X_ADC_CHANNEL(AXP22X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
 208                            AXP20X_BATT_DISCHRG_I_H),
 209 };
 210
 211 static const struct iio_chan_spec axp813_adc_channels[] = {
 212         {
 213                 .type = IIO_TEMP,
 214                 .address = AXP22X_PMIC_TEMP_H,
 215                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 216                                       BIT(IIO_CHAN_INFO_SCALE) |
 217                                       BIT(IIO_CHAN_INFO_OFFSET),
 218                 .datasheet_name = "pmic_temp",
 219         },
 220         AXP20X_ADC_CHANNEL(AXP813_GPIO0_V, "gpio0_v", IIO_VOLTAGE,
 221                            AXP288_GP_ADC_H),
 222         AXP20X_ADC_CHANNEL(AXP813_BATT_V, "batt_v", IIO_VOLTAGE,
 223                            AXP20X_BATT_V_H),
 224         AXP20X_ADC_CHANNEL(AXP22X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
 225                            AXP20X_BATT_CHRG_I_H),
 226         AXP20X_ADC_CHANNEL(AXP22X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
 227                            AXP20X_BATT_DISCHRG_I_H),
 228 };
 229
 230 static int axp20x_adc_raw(struct iio_dev *indio_dev,
 231                           struct iio_chan_spec const *chan, int *val)
 232 {
 233         struct axp20x_adc_iio *info = iio_priv(indio_dev);
 234         int size = 12;
 235
 236         /*
 237          * N.B.:  Unlike the Chinese datasheets tell, the charging current is
 238          * stored on 12 bits, not 13 bits. Only discharging current is on 13
 239          * bits.
 240          */
 241         if (chan->type == IIO_CURRENT && chan->channel == AXP20X_BATT_DISCHRG_I)
 242                 size = 13;
 243         else
 244                 size = 12;
 245
 246         *val = axp20x_read_variable_width(info->regmap, chan->address, size);
 247         if (*val < 0)
 248                 return *val;
 249
 250         return IIO_VAL_INT;
 251 }
 252
 253 static int axp22x_adc_raw(struct iio_dev *indio_dev,
 254                           struct iio_chan_spec const *chan, int *val)
 255 {
 256         struct axp20x_adc_iio *info = iio_priv(indio_dev);
 257
 258         *val = axp20x_read_variable_width(info->regmap, chan->address, 12);
 259         if (*val < 0)
 260                 return *val;
 261
 262         return IIO_VAL_INT;
 263 }
 264
 265 static int axp813_adc_raw(struct iio_dev *indio_dev,
 266                           struct iio_chan_spec const *chan, int *val)
 267 {
 268         struct axp20x_adc_iio *info = iio_priv(indio_dev);
 269
 270         *val = axp20x_read_variable_width(info->regmap, chan->address, 12);
 271         if (*val < 0)
 272                 return *val;
 273
 274         return IIO_VAL_INT;
 275 }
 276
 277 static int axp20x_adc_scale_voltage(int channel, int *val, int *val2)
 278 {
 279         switch (channel) {
 280         case AXP20X_ACIN_V:
 281         case AXP20X_VBUS_V:
 282                 *val = 1;
 283                 *val2 = 700000;
 284                 return IIO_VAL_INT_PLUS_MICRO;
 285
 286         case AXP20X_GPIO0_V:
 287         case AXP20X_GPIO1_V:
 288                 *val = 0;
 289                 *val2 = 500000;
 290                 return IIO_VAL_INT_PLUS_MICRO;
 291
 292         case AXP20X_BATT_V:
 293                 *val = 1;
 294                 *val2 = 100000;
 295                 return IIO_VAL_INT_PLUS_MICRO;
 296
 297         case AXP20X_IPSOUT_V:
 298                 *val = 1;
 299                 *val2 = 400000;
 300                 return IIO_VAL_INT_PLUS_MICRO;
 301
 302         default:
 303                 return -EINVAL;
 304         }
 305 }
 306
 307 static int axp813_adc_scale_voltage(int channel, int *val, int *val2)
 308 {
 309         switch (channel) {
 310         case AXP813_GPIO0_V:
 311                 *val = 0;
 312                 *val2 = 800000;
 313                 return IIO_VAL_INT_PLUS_MICRO;
 314
 315         case AXP813_BATT_V:
 316                 *val = 1;
 317                 *val2 = 100000;
 318                 return IIO_VAL_INT_PLUS_MICRO;
 319
 320         default:
 321                 return -EINVAL;
 322         }
 323 }
 324
 325 static int axp20x_adc_scale_current(int channel, int *val, int *val2)
 326 {
 327         switch (channel) {
 328         case AXP20X_ACIN_I:
 329                 *val = 0;
 330                 *val2 = 625000;
 331                 return IIO_VAL_INT_PLUS_MICRO;
 332
 333         case AXP20X_VBUS_I:
 334                 *val = 0;
 335                 *val2 = 375000;
 336                 return IIO_VAL_INT_PLUS_MICRO;
 337
 338         case AXP20X_BATT_DISCHRG_I:
 339         case AXP20X_BATT_CHRG_I:
 340                 *val = 0;
 341                 *val2 = 500000;
 342                 return IIO_VAL_INT_PLUS_MICRO;
 343
 344         default:
 345                 return -EINVAL;
 346         }
 347 }
 348
 349 static int axp20x_adc_scale(struct iio_chan_spec const *chan, int *val,
 350                             int *val2)
 351 {
 352         switch (chan->type) {
 353         case IIO_VOLTAGE:
 354                 return axp20x_adc_scale_voltage(chan->channel, val, val2);
 355
 356         case IIO_CURRENT:
 357                 return axp20x_adc_scale_current(chan->channel, val, val2);
 358
 359         case IIO_TEMP:
 360                 *val = 100;
 361                 return IIO_VAL_INT;
 362
 363         default:
 364                 return -EINVAL;
 365         }
 366 }
 367
 368 static int axp22x_adc_scale(struct iio_chan_spec const *chan, int *val,
 369                             int *val2)
 370 {
 371         switch (chan->type) {
 372         case IIO_VOLTAGE:
 373                 if (chan->channel != AXP22X_BATT_V)
 374                         return -EINVAL;
 375
 376                 *val = 1;
 377                 *val2 = 100000;
 378                 return IIO_VAL_INT_PLUS_MICRO;
 379
 380         case IIO_CURRENT:
 381                 *val = 1;
 382                 return IIO_VAL_INT;
 383
 384         case IIO_TEMP:
 385                 *val = 100;
 386                 return IIO_VAL_INT;
 387
 388         default:
 389                 return -EINVAL;
 390         }
 391 }
 392
 393 static int axp813_adc_scale(struct iio_chan_spec const *chan, int *val,
 394                             int *val2)
 395 {
 396         switch (chan->type) {
 397         case IIO_VOLTAGE:
 398                 return axp813_adc_scale_voltage(chan->channel, val, val2);
 399
 400         case IIO_CURRENT:
 401                 *val = 1;
 402                 return IIO_VAL_INT;
 403
 404         case IIO_TEMP:
 405                 *val = 100;
 406                 return IIO_VAL_INT;
 407
 408         default:
 409                 return -EINVAL;
 410         }
 411 }
 412
 413 static int axp20x_adc_offset_voltage(struct iio_dev *indio_dev, int channel,
 414                                      int *val)
 415 {
 416         struct axp20x_adc_iio *info = iio_priv(indio_dev);
 417         int ret;
 418
 419         ret = regmap_read(info->regmap, AXP20X_GPIO10_IN_RANGE, val);
 420         if (ret < 0)
 421                 return ret;
 422
 423         switch (channel) {
 424         case AXP20X_GPIO0_V:
 425                 *val &= AXP20X_GPIO10_IN_RANGE_GPIO0;
 426                 break;
 427
 428         case AXP20X_GPIO1_V:
 429                 *val &= AXP20X_GPIO10_IN_RANGE_GPIO1;
 430                 break;
 431
 432         default:
 433                 return -EINVAL;
 434         }
 435
 436         *val = *val ? 700000 : 0;
 437
 438         return IIO_VAL_INT;
 439 }
 440
 441 static int axp20x_adc_offset(struct iio_dev *indio_dev,
 442                              struct iio_chan_spec const *chan, int *val)
 443 {
 444         switch (chan->type) {
 445         case IIO_VOLTAGE:
 446                 return axp20x_adc_offset_voltage(indio_dev, chan->channel, val);
 447
 448         case IIO_TEMP:
 449                 *val = -1447;
 450                 return IIO_VAL_INT;
 451
 452         default:
 453                 return -EINVAL;
 454         }
 455 }
 456
 457 static int axp20x_read_raw(struct iio_dev *indio_dev,
 458                            struct iio_chan_spec const *chan, int *val,
 459                            int *val2, long mask)
 460 {
 461         switch (mask) {
 462         case IIO_CHAN_INFO_OFFSET:
 463                 return axp20x_adc_offset(indio_dev, chan, val);
 464
 465         case IIO_CHAN_INFO_SCALE:
 466                 return axp20x_adc_scale(chan, val, val2);
 467
 468         case IIO_CHAN_INFO_RAW:
 469                 return axp20x_adc_raw(indio_dev, chan, val);
 470
 471         default:
 472                 return -EINVAL;
 473         }
 474 }
 475
 476 static int axp22x_read_raw(struct iio_dev *indio_dev,
 477                            struct iio_chan_spec const *chan, int *val,
 478                            int *val2, long mask)
 479 {
 480         switch (mask) {
 481         case IIO_CHAN_INFO_OFFSET:
 482                 *val = -2677;
 483                 return IIO_VAL_INT;
 484
 485         case IIO_CHAN_INFO_SCALE:
 486                 return axp22x_adc_scale(chan, val, val2);
 487
 488         case IIO_CHAN_INFO_RAW:
 489                 return axp22x_adc_raw(indio_dev, chan, val);
 490
 491         default:
 492                 return -EINVAL;
 493         }
 494 }
 495
 496 static int axp813_read_raw(struct iio_dev *indio_dev,
 497                            struct iio_chan_spec const *chan, int *val,
 498                            int *val2, long mask)
 499 {
 500         switch (mask) {
 501         case IIO_CHAN_INFO_OFFSET:
 502                 *val = -2667;
 503                 return IIO_VAL_INT;
 504
 505         case IIO_CHAN_INFO_SCALE:
 506                 return axp813_adc_scale(chan, val, val2);
 507
 508         case IIO_CHAN_INFO_RAW:
 509                 return axp813_adc_raw(indio_dev, chan, val);
 510
 511         default:
 512                 return -EINVAL;
 513         }
 514 }
 515
 516 static int axp20x_write_raw(struct iio_dev *indio_dev,
 517                             struct iio_chan_spec const *chan, int val, int val2,
 518                             long mask)
 519 {
 520         struct axp20x_adc_iio *info = iio_priv(indio_dev);
 521         unsigned int reg, regval;
 522
 523         /*
 524          * The AXP20X PMIC allows the user to choose between 0V and 0.7V offsets
 525          * for (independently) GPIO0 and GPIO1 when in ADC mode.
 526          */
 527         if (mask != IIO_CHAN_INFO_OFFSET)
 528                 return -EINVAL;
 529
 530         if (val != 0 && val != 700000)
 531                 return -EINVAL;
 532
 533         val = val ? 1 : 0;
 534
 535         switch (chan->channel) {
 536         case AXP20X_GPIO0_V:
 537                 reg = AXP20X_GPIO10_IN_RANGE_GPIO0;
 538                 regval = AXP20X_GPIO10_IN_RANGE_GPIO0_VAL(val);
 539                 break;
 540
 541         case AXP20X_GPIO1_V:
 542                 reg = AXP20X_GPIO10_IN_RANGE_GPIO1;
 543                 regval = AXP20X_GPIO10_IN_RANGE_GPIO1_VAL(val);
 544                 break;
 545
 546         default:
 547                 return -EINVAL;
 548         }
 549
 550         return regmap_update_bits(info->regmap, AXP20X_GPIO10_IN_RANGE, reg,
 551                                   regval);
 552 }
 553
 554 static const struct iio_info axp20x_adc_iio_info = {
 555         .read_raw = axp20x_read_raw,
 556         .write_raw = axp20x_write_raw,
 557 };
 558
 559 static const struct iio_info axp22x_adc_iio_info = {
 560         .read_raw = axp22x_read_raw,
 561 };
 562
 563 static const struct iio_info axp813_adc_iio_info = {
 564         .read_raw = axp813_read_raw,
 565 };
 566
 567 static int axp20x_adc_rate(struct axp20x_adc_iio *info, int rate)
 568 {
 569         return regmap_update_bits(info->regmap, AXP20X_ADC_RATE,
 570                                   AXP20X_ADC_RATE_MASK,
 571                                   AXP20X_ADC_RATE_HZ(rate));
 572 }
 573
 574 static int axp22x_adc_rate(struct axp20x_adc_iio *info, int rate)
 575 {
 576         return regmap_update_bits(info->regmap, AXP20X_ADC_RATE,
 577                                   AXP20X_ADC_RATE_MASK,
 578                                   AXP22X_ADC_RATE_HZ(rate));
 579 }
 580
 581 static int axp813_adc_rate(struct axp20x_adc_iio *info, int rate)
 582 {
 583         return regmap_update_bits(info->regmap, AXP813_ADC_RATE,
 584                                  AXP813_ADC_RATE_MASK,
 585                                  AXP813_ADC_RATE_HZ(rate));
 586 }
 587
 588 struct axp_data {
 589         const struct iio_info           *iio_info;
 590         int                             num_channels;
 591         struct iio_chan_spec const      *channels;
 592         unsigned long                   adc_en1_mask;
 593         int                             (*adc_rate)(struct axp20x_adc_iio *info,
 594                                                     int rate);
 595         bool                            adc_en2;
 596         struct iio_map                  *maps;
 597 };
 598
 599 static const struct axp_data axp20x_data = {
 600         .iio_info = &axp20x_adc_iio_info,
 601         .num_channels = ARRAY_SIZE(axp20x_adc_channels),
 602         .channels = axp20x_adc_channels,
 603         .adc_en1_mask = AXP20X_ADC_EN1_MASK,
 604         .adc_rate = axp20x_adc_rate,
 605         .adc_en2 = true,
 606         .maps = axp20x_maps,
 607 };
 608
 609 static const struct axp_data axp22x_data = {
 610         .iio_info = &axp22x_adc_iio_info,
 611         .num_channels = ARRAY_SIZE(axp22x_adc_channels),
 612         .channels = axp22x_adc_channels,
 613         .adc_en1_mask = AXP22X_ADC_EN1_MASK,
 614         .adc_rate = axp22x_adc_rate,
 615         .adc_en2 = false,
 616         .maps = axp22x_maps,
 617 };
 618
 619 static const struct axp_data axp813_data = {
 620         .iio_info = &axp813_adc_iio_info,
 621         .num_channels = ARRAY_SIZE(axp813_adc_channels),
 622         .channels = axp813_adc_channels,
 623         .adc_en1_mask = AXP22X_ADC_EN1_MASK,
 624         .adc_rate = axp813_adc_rate,
 625         .adc_en2 = false,
 626         .maps = axp22x_maps,
 627 };
 628
 629 static const struct of_device_id axp20x_adc_of_match[] = {
 630         { .compatible = "x-powers,axp209-adc", .data = (void *)&axp20x_data, },
 631         { .compatible = "x-powers,axp221-adc", .data = (void *)&axp22x_data, },
 632         { .compatible = "x-powers,axp813-adc", .data = (void *)&axp813_data, },
 633         { /* sentinel */ }
 634 };
 635 MODULE_DEVICE_TABLE(of, axp20x_adc_of_match);
 636
 637 static const struct platform_device_id axp20x_adc_id_match[] = {
 638         { .name = "axp20x-adc", .driver_data = (kernel_ulong_t)&axp20x_data, },
 639         { .name = "axp22x-adc", .driver_data = (kernel_ulong_t)&axp22x_data, },
 640         { .name = "axp813-adc", .driver_data = (kernel_ulong_t)&axp813_data, },
 641         { /* sentinel */ },
 642 };
 643 MODULE_DEVICE_TABLE(platform, axp20x_adc_id_match);
 644
 645 static int axp20x_probe(struct platform_device *pdev)
 646 {
 647         struct axp20x_adc_iio *info;
 648         struct iio_dev *indio_dev;
 649         struct axp20x_dev *axp20x_dev;
 650         int ret;
 651
 652         axp20x_dev = dev_get_drvdata(pdev->dev.parent);
 653
 654         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
 655         if (!indio_dev)
 656                 return -ENOMEM;
 657
 658         info = iio_priv(indio_dev);
 659         platform_set_drvdata(pdev, indio_dev);
 660
 661         info->regmap = axp20x_dev->regmap;
 662         indio_dev->dev.parent = &pdev->dev;
 663         indio_dev->dev.of_node = pdev->dev.of_node;
 664         indio_dev->modes = INDIO_DIRECT_MODE;
 665
 666         if (!pdev->dev.of_node) {
 667                 const struct platform_device_id *id;
 668
 669                 id = platform_get_device_id(pdev);
 670                 info->data = (struct axp_data *)id->driver_data;
 671         } else {
 672                 struct device *dev = &pdev->dev;
 673
 674                 info->data = (struct axp_data *)of_device_get_match_data(dev);
 675         }
 676
 677         indio_dev->name = platform_get_device_id(pdev)->name;
 678         indio_dev->info = info->data->iio_info;
 679         indio_dev->num_channels = info->data->num_channels;
 680         indio_dev->channels = info->data->channels;
 681
 682         /* Enable the ADCs on IP */
 683         regmap_write(info->regmap, AXP20X_ADC_EN1, info->data->adc_en1_mask);
 684
 685         if (info->data->adc_en2)
 686                 /* Enable GPIO0/1 and internal temperature ADCs */
 687                 regmap_update_bits(info->regmap, AXP20X_ADC_EN2,
 688                                    AXP20X_ADC_EN2_MASK, AXP20X_ADC_EN2_MASK);
 689
 690         /* Configure ADCs rate */
 691         info->data->adc_rate(info, 100);
 692
 693         ret = iio_map_array_register(indio_dev, info->data->maps);
 694         if (ret < 0) {
 695                 dev_err(&pdev->dev, "failed to register IIO maps: %d\n", ret);
 696                 goto fail_map;
 697         }
 698
 699         ret = iio_device_register(indio_dev);
 700         if (ret < 0) {
 701                 dev_err(&pdev->dev, "could not register the device\n");
 702                 goto fail_register;
 703         }
 704
 705         return 0;
 706
 707 fail_register:
 708         iio_map_array_unregister(indio_dev);
 709
 710 fail_map:
 711         regmap_write(info->regmap, AXP20X_ADC_EN1, 0);
 712
 713         if (info->data->adc_en2)
 714                 regmap_write(info->regmap, AXP20X_ADC_EN2, 0);
 715
 716         return ret;
 717 }
 718
 719 static int axp20x_remove(struct platform_device *pdev)
 720 {
 721         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 722         struct axp20x_adc_iio *info = iio_priv(indio_dev);
 723
 724         iio_device_unregister(indio_dev);
 725         iio_map_array_unregister(indio_dev);
 726
 727         regmap_write(info->regmap, AXP20X_ADC_EN1, 0);
 728
 729         if (info->data->adc_en2)
 730                 regmap_write(info->regmap, AXP20X_ADC_EN2, 0);
 731
 732         return 0;
 733 }
 734
 735 static struct platform_driver axp20x_adc_driver = {
 736         .driver = {
 737                 .name = "axp20x-adc",
 738                 .of_match_table = of_match_ptr(axp20x_adc_of_match),
 739         },
 740         .id_table = axp20x_adc_id_match,
 741         .probe = axp20x_probe,
 742         .remove = axp20x_remove,
 743 };
 744
 745 module_platform_driver(axp20x_adc_driver);
 746
 747 MODULE_DESCRIPTION("ADC driver for AXP20X and AXP22X PMICs");
 748 MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
 749 MODULE_LICENSE("GPL");