drivers/iio/adc/rcar-gyroadc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Renesas R-Car GyroADC driver
   4  *
   5  * Copyright 2016 Marek Vasut <[email protected]>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/delay.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/io.h>
  14 #include <linux/clk.h>
  15 #include <linux/of.h>
  16 #include <linux/of_irq.h>
  17 #include <linux/regulator/consumer.h>
  18 #include <linux/of_platform.h>
  19 #include <linux/err.h>
  20 #include <linux/pm_runtime.h>
  21
  22 #include <linux/iio/iio.h>
  23 #include <linux/iio/sysfs.h>
  24 #include <linux/iio/trigger.h>
  25
  26 #define DRIVER_NAME                             "rcar-gyroadc"
  27
  28 /* GyroADC registers. */
  29 #define RCAR_GYROADC_MODE_SELECT                0x00
  30 #define RCAR_GYROADC_MODE_SELECT_1_MB88101A     0x0
  31 #define RCAR_GYROADC_MODE_SELECT_2_ADCS7476     0x1
  32 #define RCAR_GYROADC_MODE_SELECT_3_MAX1162      0x3
  33
  34 #define RCAR_GYROADC_START_STOP                 0x04
  35 #define RCAR_GYROADC_START_STOP_START           BIT(0)
  36
  37 #define RCAR_GYROADC_CLOCK_LENGTH               0x08
  38 #define RCAR_GYROADC_1_25MS_LENGTH              0x0c
  39
  40 #define RCAR_GYROADC_REALTIME_DATA(ch)          (0x10 + ((ch) * 4))
  41 #define RCAR_GYROADC_100MS_ADDED_DATA(ch)       (0x30 + ((ch) * 4))
  42 #define RCAR_GYROADC_10MS_AVG_DATA(ch)          (0x50 + ((ch) * 4))
  43
  44 #define RCAR_GYROADC_FIFO_STATUS                0x70
  45 #define RCAR_GYROADC_FIFO_STATUS_EMPTY(ch)      BIT(0 + (4 * (ch)))
  46 #define RCAR_GYROADC_FIFO_STATUS_FULL(ch)       BIT(1 + (4 * (ch)))
  47 #define RCAR_GYROADC_FIFO_STATUS_ERROR(ch)      BIT(2 + (4 * (ch)))
  48
  49 #define RCAR_GYROADC_INTR                       0x74
  50 #define RCAR_GYROADC_INTR_INT                   BIT(0)
  51
  52 #define RCAR_GYROADC_INTENR                     0x78
  53 #define RCAR_GYROADC_INTENR_INTEN               BIT(0)
  54
  55 #define RCAR_GYROADC_SAMPLE_RATE                800     /* Hz */
  56
  57 #define RCAR_GYROADC_RUNTIME_PM_DELAY_MS        2000
  58
  59 enum rcar_gyroadc_model {
  60         RCAR_GYROADC_MODEL_DEFAULT,
  61         RCAR_GYROADC_MODEL_R8A7792,
  62 };
  63
  64 struct rcar_gyroadc {
  65         struct device                   *dev;
  66         void __iomem                    *regs;
  67         struct clk                      *clk;
  68         struct regulator                *vref[8];
  69         unsigned int                    num_channels;
  70         enum rcar_gyroadc_model         model;
  71         unsigned int                    mode;
  72         unsigned int                    sample_width;
  73 };
  74
  75 static void rcar_gyroadc_hw_init(struct rcar_gyroadc *priv)
  76 {
  77         const unsigned long clk_mhz = clk_get_rate(priv->clk) / 1000000;
  78         const unsigned long clk_mul =
  79                 (priv->mode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) ? 10 : 5;
  80         unsigned long clk_len = clk_mhz * clk_mul;
  81
  82         /*
  83          * According to the R-Car Gen2 datasheet Rev. 1.01, Sept 08 2014,
  84          * page 77-7, clock length must be even number. If it's odd number,
  85          * add one.
  86          */
  87         if (clk_len & 1)
  88                 clk_len++;
  89
  90         /* Stop the GyroADC. */
  91         writel(0, priv->regs + RCAR_GYROADC_START_STOP);
  92
  93         /* Disable IRQ on V2H. */
  94         if (priv->model == RCAR_GYROADC_MODEL_R8A7792)
  95                 writel(0, priv->regs + RCAR_GYROADC_INTENR);
  96
  97         /* Set mode and timing. */
  98         writel(priv->mode, priv->regs + RCAR_GYROADC_MODE_SELECT);
  99         writel(clk_len, priv->regs + RCAR_GYROADC_CLOCK_LENGTH);
 100         writel(clk_mhz * 1250, priv->regs + RCAR_GYROADC_1_25MS_LENGTH);
 101 }
 102
 103 static void rcar_gyroadc_hw_start(struct rcar_gyroadc *priv)
 104 {
 105         /* Start sampling. */
 106         writel(RCAR_GYROADC_START_STOP_START,
 107                priv->regs + RCAR_GYROADC_START_STOP);
 108
 109         /*
 110          * Wait for the first conversion to complete. This is longer than
 111          * the 1.25 mS in the datasheet because 1.25 mS is not enough for
 112          * the hardware to deliver the first sample and the hardware does
 113          * then return zeroes instead of valid data.
 114          */
 115         mdelay(3);
 116 }
 117
 118 static void rcar_gyroadc_hw_stop(struct rcar_gyroadc *priv)
 119 {
 120         /* Stop the GyroADC. */
 121         writel(0, priv->regs + RCAR_GYROADC_START_STOP);
 122 }
 123
 124 #define RCAR_GYROADC_CHAN(_idx) {                               \
 125         .type                   = IIO_VOLTAGE,                  \
 126         .indexed                = 1,                            \
 127         .channel                = (_idx),                       \
 128         .info_mask_separate     = BIT(IIO_CHAN_INFO_RAW) |      \
 129                                   BIT(IIO_CHAN_INFO_SCALE),     \
 130         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 131 }
 132
 133 static const struct iio_chan_spec rcar_gyroadc_iio_channels_1[] = {
 134         RCAR_GYROADC_CHAN(0),
 135         RCAR_GYROADC_CHAN(1),
 136         RCAR_GYROADC_CHAN(2),
 137         RCAR_GYROADC_CHAN(3),
 138 };
 139
 140 static const struct iio_chan_spec rcar_gyroadc_iio_channels_2[] = {
 141         RCAR_GYROADC_CHAN(0),
 142         RCAR_GYROADC_CHAN(1),
 143         RCAR_GYROADC_CHAN(2),
 144         RCAR_GYROADC_CHAN(3),
 145         RCAR_GYROADC_CHAN(4),
 146         RCAR_GYROADC_CHAN(5),
 147         RCAR_GYROADC_CHAN(6),
 148         RCAR_GYROADC_CHAN(7),
 149 };
 150
 151 static const struct iio_chan_spec rcar_gyroadc_iio_channels_3[] = {
 152         RCAR_GYROADC_CHAN(0),
 153         RCAR_GYROADC_CHAN(1),
 154         RCAR_GYROADC_CHAN(2),
 155         RCAR_GYROADC_CHAN(3),
 156         RCAR_GYROADC_CHAN(4),
 157         RCAR_GYROADC_CHAN(5),
 158         RCAR_GYROADC_CHAN(6),
 159         RCAR_GYROADC_CHAN(7),
 160 };
 161
 162 static int rcar_gyroadc_set_power(struct rcar_gyroadc *priv, bool on)
 163 {
 164         struct device *dev = priv->dev;
 165
 166         if (on) {
 167                 return pm_runtime_resume_and_get(dev);
 168         } else {
 169                 pm_runtime_mark_last_busy(dev);
 170                 return pm_runtime_put_autosuspend(dev);
 171         }
 172 }
 173
 174 static int rcar_gyroadc_read_raw(struct iio_dev *indio_dev,
 175                                  struct iio_chan_spec const *chan,
 176                                  int *val, int *val2, long mask)
 177 {
 178         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 179         struct regulator *consumer;
 180         unsigned int datareg = RCAR_GYROADC_REALTIME_DATA(chan->channel);
 181         unsigned int vref;
 182         int ret;
 183
 184         /*
 185          * MB88101 is special in that it has only single regulator for
 186          * all four channels.
 187          */
 188         if (priv->mode == RCAR_GYROADC_MODE_SELECT_1_MB88101A)
 189                 consumer = priv->vref[0];
 190         else
 191                 consumer = priv->vref[chan->channel];
 192
 193         switch (mask) {
 194         case IIO_CHAN_INFO_RAW:
 195                 if (chan->type != IIO_VOLTAGE)
 196                         return -EINVAL;
 197
 198                 /* Channel not connected. */
 199                 if (!consumer)
 200                         return -EINVAL;
 201
 202                 ret = iio_device_claim_direct_mode(indio_dev);
 203                 if (ret)
 204                         return ret;
 205
 206                 ret = rcar_gyroadc_set_power(priv, true);
 207                 if (ret < 0) {
 208                         iio_device_release_direct_mode(indio_dev);
 209                         return ret;
 210                 }
 211
 212                 *val = readl(priv->regs + datareg);
 213                 *val &= BIT(priv->sample_width) - 1;
 214
 215                 ret = rcar_gyroadc_set_power(priv, false);
 216                 iio_device_release_direct_mode(indio_dev);
 217                 if (ret < 0)
 218                         return ret;
 219
 220                 return IIO_VAL_INT;
 221         case IIO_CHAN_INFO_SCALE:
 222                 /* Channel not connected. */
 223                 if (!consumer)
 224                         return -EINVAL;
 225
 226                 vref = regulator_get_voltage(consumer);
 227                 *val = vref / 1000;
 228                 *val2 = 1 << priv->sample_width;
 229
 230                 return IIO_VAL_FRACTIONAL;
 231         case IIO_CHAN_INFO_SAMP_FREQ:
 232                 *val = RCAR_GYROADC_SAMPLE_RATE;
 233
 234                 return IIO_VAL_INT;
 235         default:
 236                 return -EINVAL;
 237         }
 238 }
 239
 240 static int rcar_gyroadc_reg_access(struct iio_dev *indio_dev,
 241                                    unsigned int reg, unsigned int writeval,
 242                                    unsigned int *readval)
 243 {
 244         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 245         unsigned int maxreg = RCAR_GYROADC_FIFO_STATUS;
 246
 247         if (readval == NULL)
 248                 return -EINVAL;
 249
 250         if (reg % 4)
 251                 return -EINVAL;
 252
 253         /* Handle the V2H case with extra interrupt block. */
 254         if (priv->model == RCAR_GYROADC_MODEL_R8A7792)
 255                 maxreg = RCAR_GYROADC_INTENR;
 256
 257         if (reg > maxreg)
 258                 return -EINVAL;
 259
 260         *readval = readl(priv->regs + reg);
 261
 262         return 0;
 263 }
 264
 265 static const struct iio_info rcar_gyroadc_iio_info = {
 266         .read_raw               = rcar_gyroadc_read_raw,
 267         .debugfs_reg_access     = rcar_gyroadc_reg_access,
 268 };
 269
 270 static const struct of_device_id rcar_gyroadc_match[] = {
 271         {
 272                 /* R-Car compatible GyroADC */
 273                 .compatible     = "renesas,rcar-gyroadc",
 274                 .data           = (void *)RCAR_GYROADC_MODEL_DEFAULT,
 275         }, {
 276                 /* R-Car V2H specialty with interrupt registers. */
 277                 .compatible     = "renesas,r8a7792-gyroadc",
 278                 .data           = (void *)RCAR_GYROADC_MODEL_R8A7792,
 279         }, {
 280                 /* sentinel */
 281         }
 282 };
 283
 284 MODULE_DEVICE_TABLE(of, rcar_gyroadc_match);
 285
 286 static const struct of_device_id rcar_gyroadc_child_match[] __maybe_unused = {
 287         /* Mode 1 ADCs */
 288         {
 289                 .compatible     = "fujitsu,mb88101a",
 290                 .data           = (void *)RCAR_GYROADC_MODE_SELECT_1_MB88101A,
 291         },
 292         /* Mode 2 ADCs */
 293         {
 294                 .compatible     = "ti,adcs7476",
 295                 .data           = (void *)RCAR_GYROADC_MODE_SELECT_2_ADCS7476,
 296         }, {
 297                 .compatible     = "ti,adc121",
 298                 .data           = (void *)RCAR_GYROADC_MODE_SELECT_2_ADCS7476,
 299         }, {
 300                 .compatible     = "adi,ad7476",
 301                 .data           = (void *)RCAR_GYROADC_MODE_SELECT_2_ADCS7476,
 302         },
 303         /* Mode 3 ADCs */
 304         {
 305                 .compatible     = "maxim,max1162",
 306                 .data           = (void *)RCAR_GYROADC_MODE_SELECT_3_MAX1162,
 307         }, {
 308                 .compatible     = "maxim,max11100",
 309                 .data           = (void *)RCAR_GYROADC_MODE_SELECT_3_MAX1162,
 310         },
 311         { /* sentinel */ }
 312 };
 313
 314 static int rcar_gyroadc_parse_subdevs(struct iio_dev *indio_dev)
 315 {
 316         const struct of_device_id *of_id;
 317         const struct iio_chan_spec *channels;
 318         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 319         struct device *dev = priv->dev;
 320         struct device_node *np = dev->of_node;
 321         struct regulator *vref;
 322         unsigned int reg;
 323         unsigned int adcmode = -1, childmode;
 324         unsigned int sample_width;
 325         unsigned int num_channels;
 326         int ret, first = 1;
 327
 328         for_each_available_child_of_node_scoped(np, child) {
 329                 of_id = of_match_node(rcar_gyroadc_child_match, child);
 330                 if (!of_id) {
 331                         dev_err(dev, "Ignoring unsupported ADC \"%pOFn\".",
 332                                 child);
 333                         continue;
 334                 }
 335
 336                 childmode = (uintptr_t)of_id->data;
 337                 switch (childmode) {
 338                 case RCAR_GYROADC_MODE_SELECT_1_MB88101A:
 339                         sample_width = 12;
 340                         channels = rcar_gyroadc_iio_channels_1;
 341                         num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_1);
 342                         break;
 343                 case RCAR_GYROADC_MODE_SELECT_2_ADCS7476:
 344                         sample_width = 15;
 345                         channels = rcar_gyroadc_iio_channels_2;
 346                         num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_2);
 347                         break;
 348                 case RCAR_GYROADC_MODE_SELECT_3_MAX1162:
 349                         sample_width = 16;
 350                         channels = rcar_gyroadc_iio_channels_3;
 351                         num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_3);
 352                         break;
 353                 default:
 354                         return -EINVAL;
 355                 }
 356
 357                 /*
 358                  * MB88101 is special in that it's only a single chip taking
 359                  * up all the CHS lines. Thus, the DT binding is also special
 360                  * and has no reg property. If we run into such ADC, handle
 361                  * it here.
 362                  */
 363                 if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
 364                         reg = 0;
 365                 } else {
 366                         ret = of_property_read_u32(child, "reg", &reg);
 367                         if (ret) {
 368                                 dev_err(dev,
 369                                         "Failed to get child reg property of ADC \"%pOFn\".\n",
 370                                         child);
 371                                 return ret;
 372                         }
 373
 374                         /* Channel number is too high. */
 375                         if (reg >= num_channels) {
 376                                 dev_err(dev,
 377                                         "Only %i channels supported with %pOFn, but reg = <%i>.\n",
 378                                         num_channels, child, reg);
 379                                 return -EINVAL;
 380                         }
 381                 }
 382
 383                 /* Child node selected different mode than the rest. */
 384                 if (!first && (adcmode != childmode)) {
 385                         dev_err(dev,
 386                                 "Channel %i uses different ADC mode than the rest.\n",
 387                                 reg);
 388                         return -EINVAL;
 389                 }
 390
 391                 /* Channel is valid, grab the regulator. */
 392                 dev->of_node = child;
 393                 vref = devm_regulator_get(dev, "vref");
 394                 dev->of_node = np;
 395                 if (IS_ERR(vref)) {
 396                         dev_dbg(dev, "Channel %i 'vref' supply not connected.\n",
 397                                 reg);
 398                         return PTR_ERR(vref);
 399                 }
 400
 401                 priv->vref[reg] = vref;
 402
 403                 if (!first)
 404                         continue;
 405
 406                 /* First child node which passed sanity tests. */
 407                 adcmode = childmode;
 408                 first = 0;
 409
 410                 priv->num_channels = num_channels;
 411                 priv->mode = childmode;
 412                 priv->sample_width = sample_width;
 413
 414                 indio_dev->channels = channels;
 415                 indio_dev->num_channels = num_channels;
 416
 417                 /*
 418                  * MB88101 is special and we only have one such device
 419                  * attached to the GyroADC at a time, so if we found it,
 420                  * we can stop parsing here.
 421                  */
 422                 if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
 423                         break;
 424                 }
 425         }
 426
 427         if (first) {
 428                 dev_err(dev, "No valid ADC channels found, aborting.\n");
 429                 return -EINVAL;
 430         }
 431
 432         return 0;
 433 }
 434
 435 static void rcar_gyroadc_deinit_supplies(struct iio_dev *indio_dev)
 436 {
 437         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 438         unsigned int i;
 439
 440         for (i = 0; i < priv->num_channels; i++) {
 441                 if (!priv->vref[i])
 442                         continue;
 443
 444                 regulator_disable(priv->vref[i]);
 445         }
 446 }
 447
 448 static int rcar_gyroadc_init_supplies(struct iio_dev *indio_dev)
 449 {
 450         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 451         struct device *dev = priv->dev;
 452         unsigned int i;
 453         int ret;
 454
 455         for (i = 0; i < priv->num_channels; i++) {
 456                 if (!priv->vref[i])
 457                         continue;
 458
 459                 ret = regulator_enable(priv->vref[i]);
 460                 if (ret) {
 461                         dev_err(dev, "Failed to enable regulator %i (ret=%i)\n",
 462                                 i, ret);
 463                         goto err;
 464                 }
 465         }
 466
 467         return 0;
 468
 469 err:
 470         rcar_gyroadc_deinit_supplies(indio_dev);
 471         return ret;
 472 }
 473
 474 static int rcar_gyroadc_probe(struct platform_device *pdev)
 475 {
 476         struct device *dev = &pdev->dev;
 477         struct rcar_gyroadc *priv;
 478         struct iio_dev *indio_dev;
 479         int ret;
 480
 481         indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
 482         if (!indio_dev)
 483                 return -ENOMEM;
 484
 485         priv = iio_priv(indio_dev);
 486         priv->dev = dev;
 487
 488         priv->regs = devm_platform_ioremap_resource(pdev, 0);
 489         if (IS_ERR(priv->regs))
 490                 return PTR_ERR(priv->regs);
 491
 492         priv->clk = devm_clk_get(dev, "fck");
 493         if (IS_ERR(priv->clk))
 494                 return dev_err_probe(dev, PTR_ERR(priv->clk),
 495                                      "Failed to get IF clock\n");
 496
 497         ret = rcar_gyroadc_parse_subdevs(indio_dev);
 498         if (ret)
 499                 return ret;
 500
 501         ret = rcar_gyroadc_init_supplies(indio_dev);
 502         if (ret)
 503                 return ret;
 504
 505         priv->model = (uintptr_t)of_device_get_match_data(&pdev->dev);
 506
 507         platform_set_drvdata(pdev, indio_dev);
 508
 509         indio_dev->name = DRIVER_NAME;
 510         indio_dev->info = &rcar_gyroadc_iio_info;
 511         indio_dev->modes = INDIO_DIRECT_MODE;
 512
 513         ret = clk_prepare_enable(priv->clk);
 514         if (ret) {
 515                 dev_err(dev, "Could not prepare or enable the IF clock.\n");
 516                 goto err_clk_if_enable;
 517         }
 518
 519         pm_runtime_set_autosuspend_delay(dev, RCAR_GYROADC_RUNTIME_PM_DELAY_MS);
 520         pm_runtime_use_autosuspend(dev);
 521         pm_runtime_enable(dev);
 522
 523         ret = pm_runtime_resume_and_get(dev);
 524         if (ret)
 525                 goto err_power_up;
 526
 527         rcar_gyroadc_hw_init(priv);
 528         rcar_gyroadc_hw_start(priv);
 529
 530         ret = iio_device_register(indio_dev);
 531         if (ret) {
 532                 dev_err(dev, "Couldn't register IIO device.\n");
 533                 goto err_iio_device_register;
 534         }
 535
 536         pm_runtime_put_sync(dev);
 537
 538         return 0;
 539
 540 err_iio_device_register:
 541         rcar_gyroadc_hw_stop(priv);
 542         pm_runtime_put_sync(dev);
 543 err_power_up:
 544         pm_runtime_disable(dev);
 545         pm_runtime_set_suspended(dev);
 546         clk_disable_unprepare(priv->clk);
 547 err_clk_if_enable:
 548         rcar_gyroadc_deinit_supplies(indio_dev);
 549
 550         return ret;
 551 }
 552
 553 static void rcar_gyroadc_remove(struct platform_device *pdev)
 554 {
 555         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 556         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 557         struct device *dev = priv->dev;
 558
 559         iio_device_unregister(indio_dev);
 560         pm_runtime_get_sync(dev);
 561         rcar_gyroadc_hw_stop(priv);
 562         pm_runtime_put_sync(dev);
 563         pm_runtime_disable(dev);
 564         pm_runtime_set_suspended(dev);
 565         clk_disable_unprepare(priv->clk);
 566         rcar_gyroadc_deinit_supplies(indio_dev);
 567 }
 568
 569 static int rcar_gyroadc_suspend(struct device *dev)
 570 {
 571         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 572         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 573
 574         rcar_gyroadc_hw_stop(priv);
 575
 576         return 0;
 577 }
 578
 579 static int rcar_gyroadc_resume(struct device *dev)
 580 {
 581         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 582         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 583
 584         rcar_gyroadc_hw_start(priv);
 585
 586         return 0;
 587 }
 588
 589 static const struct dev_pm_ops rcar_gyroadc_pm_ops = {
 590         RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL)
 591 };
 592
 593 static struct platform_driver rcar_gyroadc_driver = {
 594         .probe          = rcar_gyroadc_probe,
 595         .remove         = rcar_gyroadc_remove,
 596         .driver         = {
 597                 .name           = DRIVER_NAME,
 598                 .of_match_table = rcar_gyroadc_match,
 599                 .pm             = pm_ptr(&rcar_gyroadc_pm_ops),
 600         },
 601 };
 602
 603 module_platform_driver(rcar_gyroadc_driver);
 604
 605 MODULE_AUTHOR("Marek Vasut <[email protected]>");
 606 MODULE_DESCRIPTION("Renesas R-Car GyroADC driver");
 607 MODULE_LICENSE("GPL");