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 <marek.vasut@gmail.com>
   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[] = {
 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 device_node *child;
 322         struct regulator *vref;
 323         unsigned int reg;
 324         unsigned int adcmode = -1, childmode;
 325         unsigned int sample_width;
 326         unsigned int num_channels;
 327         int ret, first = 1;
 328
 329         for_each_child_of_node(np, child) {
 330                 of_id = of_match_node(rcar_gyroadc_child_match, child);
 331                 if (!of_id) {
 332                         dev_err(dev, "Ignoring unsupported ADC \"%pOFn\".",
 333                                 child);
 334                         continue;
 335                 }
 336
 337                 childmode = (uintptr_t)of_id->data;
 338                 switch (childmode) {
 339                 case RCAR_GYROADC_MODE_SELECT_1_MB88101A:
 340                         sample_width = 12;
 341                         channels = rcar_gyroadc_iio_channels_1;
 342                         num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_1);
 343                         break;
 344                 case RCAR_GYROADC_MODE_SELECT_2_ADCS7476:
 345                         sample_width = 15;
 346                         channels = rcar_gyroadc_iio_channels_2;
 347                         num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_2);
 348                         break;
 349                 case RCAR_GYROADC_MODE_SELECT_3_MAX1162:
 350                         sample_width = 16;
 351                         channels = rcar_gyroadc_iio_channels_3;
 352                         num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_3);
 353                         break;
 354                 default:
 355                         goto err_e_inval;
 356                 }
 357
 358                 /*
 359                  * MB88101 is special in that it's only a single chip taking
 360                  * up all the CHS lines. Thus, the DT binding is also special
 361                  * and has no reg property. If we run into such ADC, handle
 362                  * it here.
 363                  */
 364                 if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
 365                         reg = 0;
 366                 } else {
 367                         ret = of_property_read_u32(child, "reg", &reg);
 368                         if (ret) {
 369                                 dev_err(dev,
 370                                         "Failed to get child reg property of ADC \"%pOFn\".\n",
 371                                         child);
 372                                 goto err_of_node_put;
 373                         }
 374
 375                         /* Channel number is too high. */
 376                         if (reg >= num_channels) {
 377                                 dev_err(dev,
 378                                         "Only %i channels supported with %pOFn, but reg = <%i>.\n",
 379                                         num_channels, child, reg);
 380                                 goto err_e_inval;
 381                         }
 382                 }
 383
 384                 /* Child node selected different mode than the rest. */
 385                 if (!first && (adcmode != childmode)) {
 386                         dev_err(dev,
 387                                 "Channel %i uses different ADC mode than the rest.\n",
 388                                 reg);
 389                         goto err_e_inval;
 390                 }
 391
 392                 /* Channel is valid, grab the regulator. */
 393                 dev->of_node = child;
 394                 vref = devm_regulator_get(dev, "vref");
 395                 dev->of_node = np;
 396                 if (IS_ERR(vref)) {
 397                         dev_dbg(dev, "Channel %i 'vref' supply not connected.\n",
 398                                 reg);
 399                         ret = PTR_ERR(vref);
 400                         goto err_of_node_put;
 401                 }
 402
 403                 priv->vref[reg] = vref;
 404
 405                 if (!first)
 406                         continue;
 407
 408                 /* First child node which passed sanity tests. */
 409                 adcmode = childmode;
 410                 first = 0;
 411
 412                 priv->num_channels = num_channels;
 413                 priv->mode = childmode;
 414                 priv->sample_width = sample_width;
 415
 416                 indio_dev->channels = channels;
 417                 indio_dev->num_channels = num_channels;
 418
 419                 /*
 420                  * MB88101 is special and we only have one such device
 421                  * attached to the GyroADC at a time, so if we found it,
 422                  * we can stop parsing here.
 423                  */
 424                 if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
 425                         of_node_put(child);
 426                         break;
 427                 }
 428         }
 429
 430         if (first) {
 431                 dev_err(dev, "No valid ADC channels found, aborting.\n");
 432                 return -EINVAL;
 433         }
 434
 435         return 0;
 436
 437 err_e_inval:
 438         ret = -EINVAL;
 439 err_of_node_put:
 440         of_node_put(child);
 441         return ret;
 442 }
 443
 444 static void rcar_gyroadc_deinit_supplies(struct iio_dev *indio_dev)
 445 {
 446         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 447         unsigned int i;
 448
 449         for (i = 0; i < priv->num_channels; i++) {
 450                 if (!priv->vref[i])
 451                         continue;
 452
 453                 regulator_disable(priv->vref[i]);
 454         }
 455 }
 456
 457 static int rcar_gyroadc_init_supplies(struct iio_dev *indio_dev)
 458 {
 459         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 460         struct device *dev = priv->dev;
 461         unsigned int i;
 462         int ret;
 463
 464         for (i = 0; i < priv->num_channels; i++) {
 465                 if (!priv->vref[i])
 466                         continue;
 467
 468                 ret = regulator_enable(priv->vref[i]);
 469                 if (ret) {
 470                         dev_err(dev, "Failed to enable regulator %i (ret=%i)\n",
 471                                 i, ret);
 472                         goto err;
 473                 }
 474         }
 475
 476         return 0;
 477
 478 err:
 479         rcar_gyroadc_deinit_supplies(indio_dev);
 480         return ret;
 481 }
 482
 483 static int rcar_gyroadc_probe(struct platform_device *pdev)
 484 {
 485         struct device *dev = &pdev->dev;
 486         struct rcar_gyroadc *priv;
 487         struct iio_dev *indio_dev;
 488         int ret;
 489
 490         indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
 491         if (!indio_dev)
 492                 return -ENOMEM;
 493
 494         priv = iio_priv(indio_dev);
 495         priv->dev = dev;
 496
 497         priv->regs = devm_platform_ioremap_resource(pdev, 0);
 498         if (IS_ERR(priv->regs))
 499                 return PTR_ERR(priv->regs);
 500
 501         priv->clk = devm_clk_get(dev, "fck");
 502         if (IS_ERR(priv->clk))
 503                 return dev_err_probe(dev, PTR_ERR(priv->clk),
 504                                      "Failed to get IF clock\n");
 505
 506         ret = rcar_gyroadc_parse_subdevs(indio_dev);
 507         if (ret)
 508                 return ret;
 509
 510         ret = rcar_gyroadc_init_supplies(indio_dev);
 511         if (ret)
 512                 return ret;
 513
 514         priv->model = (uintptr_t)of_device_get_match_data(&pdev->dev);
 515
 516         platform_set_drvdata(pdev, indio_dev);
 517
 518         indio_dev->name = DRIVER_NAME;
 519         indio_dev->info = &rcar_gyroadc_iio_info;
 520         indio_dev->modes = INDIO_DIRECT_MODE;
 521
 522         ret = clk_prepare_enable(priv->clk);
 523         if (ret) {
 524                 dev_err(dev, "Could not prepare or enable the IF clock.\n");
 525                 goto err_clk_if_enable;
 526         }
 527
 528         pm_runtime_set_autosuspend_delay(dev, RCAR_GYROADC_RUNTIME_PM_DELAY_MS);
 529         pm_runtime_use_autosuspend(dev);
 530         pm_runtime_enable(dev);
 531
 532         ret = pm_runtime_resume_and_get(dev);
 533         if (ret)
 534                 goto err_power_up;
 535
 536         rcar_gyroadc_hw_init(priv);
 537         rcar_gyroadc_hw_start(priv);
 538
 539         ret = iio_device_register(indio_dev);
 540         if (ret) {
 541                 dev_err(dev, "Couldn't register IIO device.\n");
 542                 goto err_iio_device_register;
 543         }
 544
 545         pm_runtime_put_sync(dev);
 546
 547         return 0;
 548
 549 err_iio_device_register:
 550         rcar_gyroadc_hw_stop(priv);
 551         pm_runtime_put_sync(dev);
 552 err_power_up:
 553         pm_runtime_disable(dev);
 554         pm_runtime_set_suspended(dev);
 555         clk_disable_unprepare(priv->clk);
 556 err_clk_if_enable:
 557         rcar_gyroadc_deinit_supplies(indio_dev);
 558
 559         return ret;
 560 }
 561
 562 static int rcar_gyroadc_remove(struct platform_device *pdev)
 563 {
 564         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 565         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 566         struct device *dev = priv->dev;
 567
 568         iio_device_unregister(indio_dev);
 569         pm_runtime_get_sync(dev);
 570         rcar_gyroadc_hw_stop(priv);
 571         pm_runtime_put_sync(dev);
 572         pm_runtime_disable(dev);
 573         pm_runtime_set_suspended(dev);
 574         clk_disable_unprepare(priv->clk);
 575         rcar_gyroadc_deinit_supplies(indio_dev);
 576
 577         return 0;
 578 }
 579
 580 static int rcar_gyroadc_suspend(struct device *dev)
 581 {
 582         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 583         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 584
 585         rcar_gyroadc_hw_stop(priv);
 586
 587         return 0;
 588 }
 589
 590 static int rcar_gyroadc_resume(struct device *dev)
 591 {
 592         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 593         struct rcar_gyroadc *priv = iio_priv(indio_dev);
 594
 595         rcar_gyroadc_hw_start(priv);
 596
 597         return 0;
 598 }
 599
 600 static const struct dev_pm_ops rcar_gyroadc_pm_ops = {
 601         RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL)
 602 };
 603
 604 static struct platform_driver rcar_gyroadc_driver = {
 605         .probe          = rcar_gyroadc_probe,
 606         .remove         = rcar_gyroadc_remove,
 607         .driver         = {
 608                 .name           = DRIVER_NAME,
 609                 .of_match_table = rcar_gyroadc_match,
 610                 .pm             = pm_ptr(&rcar_gyroadc_pm_ops),
 611         },
 612 };
 613
 614 module_platform_driver(rcar_gyroadc_driver);
 615
 616 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
 617 MODULE_DESCRIPTION("Renesas R-Car GyroADC driver");
 618 MODULE_LICENSE("GPL");