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 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", ®); 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_new = 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 <marek.vasut@gmail.com>"); 606 MODULE_DESCRIPTION("Renesas R-Car GyroADC driver"); 607 MODULE_LICENSE("GPL"); 608