608 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * Renesas R-Car GyroADC driver4 *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 0x0030#define RCAR_GYROADC_MODE_SELECT_1_MB88101A 0x031#define RCAR_GYROADC_MODE_SELECT_2_ADCS7476 0x132#define RCAR_GYROADC_MODE_SELECT_3_MAX1162 0x333 34#define RCAR_GYROADC_START_STOP 0x0435#define RCAR_GYROADC_START_STOP_START BIT(0)36 37#define RCAR_GYROADC_CLOCK_LENGTH 0x0838#define RCAR_GYROADC_1_25MS_LENGTH 0x0c39 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 0x7045#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 0x7450#define RCAR_GYROADC_INTR_INT BIT(0)51 52#define RCAR_GYROADC_INTENR 0x7853#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 200058 59enum rcar_gyroadc_model {60 RCAR_GYROADC_MODEL_DEFAULT,61 RCAR_GYROADC_MODEL_R8A7792,62};63 64struct 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 75static 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 103static 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 than111 * the 1.25 mS in the datasheet because 1.25 mS is not enough for112 * the hardware to deliver the first sample and the hardware does113 * then return zeroes instead of valid data.114 */115 mdelay(3);116}117 118static 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 133static 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 140static 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 151static 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 162static 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 174static 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 for186 * all four channels.187 */188 if (priv->mode == RCAR_GYROADC_MODE_SELECT_1_MB88101A)189 consumer = priv->vref[0];190 else191 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 240static 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 265static 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 270static 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 284MODULE_DEVICE_TABLE(of, rcar_gyroadc_match);285 286static 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 314static 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 taking359 * up all the CHS lines. Thus, the DT binding is also special360 * and has no reg property. If we run into such ADC, handle361 * 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 device419 * 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 435static 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 448static 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 469err:470 rcar_gyroadc_deinit_supplies(indio_dev);471 return ret;472}473 474static 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 540err_iio_device_register:541 rcar_gyroadc_hw_stop(priv);542 pm_runtime_put_sync(dev);543err_power_up:544 pm_runtime_disable(dev);545 pm_runtime_set_suspended(dev);546 clk_disable_unprepare(priv->clk);547err_clk_if_enable:548 rcar_gyroadc_deinit_supplies(indio_dev);549 550 return ret;551}552 553static 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 569static 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 579static 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 589static const struct dev_pm_ops rcar_gyroadc_pm_ops = {590 RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL)591};592 593static 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 603module_platform_driver(rcar_gyroadc_driver);604 605MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");606MODULE_DESCRIPTION("Renesas R-Car GyroADC driver");607MODULE_LICENSE("GPL");608