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[] __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 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", ®); 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"); 619