drivers/mfd/stmfx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
   4  *
   5  * Copyright (C) 2019 STMicroelectronics
   6  * Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
   7  */
   8 #include <linux/bitfield.h>
   9 #include <linux/i2c.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/irq.h>
  12 #include <linux/mfd/core.h>
  13 #include <linux/mfd/stmfx.h>
  14 #include <linux/module.h>
  15 #include <linux/regulator/consumer.h>
  16
  17 static bool stmfx_reg_volatile(struct device *dev, unsigned int reg)
  18 {
  19         switch (reg) {
  20         case STMFX_REG_SYS_CTRL:
  21         case STMFX_REG_IRQ_SRC_EN:
  22         case STMFX_REG_IRQ_PENDING:
  23         case STMFX_REG_IRQ_GPI_PENDING1:
  24         case STMFX_REG_IRQ_GPI_PENDING2:
  25         case STMFX_REG_IRQ_GPI_PENDING3:
  26         case STMFX_REG_GPIO_STATE1:
  27         case STMFX_REG_GPIO_STATE2:
  28         case STMFX_REG_GPIO_STATE3:
  29         case STMFX_REG_IRQ_GPI_SRC1:
  30         case STMFX_REG_IRQ_GPI_SRC2:
  31         case STMFX_REG_IRQ_GPI_SRC3:
  32         case STMFX_REG_GPO_SET1:
  33         case STMFX_REG_GPO_SET2:
  34         case STMFX_REG_GPO_SET3:
  35         case STMFX_REG_GPO_CLR1:
  36         case STMFX_REG_GPO_CLR2:
  37         case STMFX_REG_GPO_CLR3:
  38                 return true;
  39         default:
  40                 return false;
  41         }
  42 }
  43
  44 static bool stmfx_reg_writeable(struct device *dev, unsigned int reg)
  45 {
  46         return (reg >= STMFX_REG_SYS_CTRL);
  47 }
  48
  49 static const struct regmap_config stmfx_regmap_config = {
  50         .reg_bits       = 8,
  51         .reg_stride     = 1,
  52         .val_bits       = 8,
  53         .max_register   = STMFX_REG_MAX,
  54         .volatile_reg   = stmfx_reg_volatile,
  55         .writeable_reg  = stmfx_reg_writeable,
  56         .cache_type     = REGCACHE_RBTREE,
  57 };
  58
  59 static const struct resource stmfx_pinctrl_resources[] = {
  60         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_GPIO),
  61 };
  62
  63 static const struct resource stmfx_idd_resources[] = {
  64         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_IDD),
  65         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_ERROR),
  66 };
  67
  68 static const struct resource stmfx_ts_resources[] = {
  69         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_DET),
  70         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_NE),
  71         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_TH),
  72         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_FULL),
  73         DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_OVF),
  74 };
  75
  76 static struct mfd_cell stmfx_cells[] = {
  77         {
  78                 .of_compatible = "st,stmfx-0300-pinctrl",
  79                 .name = "stmfx-pinctrl",
  80                 .resources = stmfx_pinctrl_resources,
  81                 .num_resources = ARRAY_SIZE(stmfx_pinctrl_resources),
  82         },
  83         {
  84                 .of_compatible = "st,stmfx-0300-idd",
  85                 .name = "stmfx-idd",
  86                 .resources = stmfx_idd_resources,
  87                 .num_resources = ARRAY_SIZE(stmfx_idd_resources),
  88         },
  89         {
  90                 .of_compatible = "st,stmfx-0300-ts",
  91                 .name = "stmfx-ts",
  92                 .resources = stmfx_ts_resources,
  93                 .num_resources = ARRAY_SIZE(stmfx_ts_resources),
  94         },
  95 };
  96
  97 static u8 stmfx_func_to_mask(u32 func)
  98 {
  99         u8 mask = 0;
 100
 101         if (func & STMFX_FUNC_GPIO)
 102                 mask |= STMFX_REG_SYS_CTRL_GPIO_EN;
 103
 104         if ((func & STMFX_FUNC_ALTGPIO_LOW) || (func & STMFX_FUNC_ALTGPIO_HIGH))
 105                 mask |= STMFX_REG_SYS_CTRL_ALTGPIO_EN;
 106
 107         if (func & STMFX_FUNC_TS)
 108                 mask |= STMFX_REG_SYS_CTRL_TS_EN;
 109
 110         if (func & STMFX_FUNC_IDD)
 111                 mask |= STMFX_REG_SYS_CTRL_IDD_EN;
 112
 113         return mask;
 114 }
 115
 116 int stmfx_function_enable(struct stmfx *stmfx, u32 func)
 117 {
 118         u32 sys_ctrl;
 119         u8 mask;
 120         int ret;
 121
 122         ret = regmap_read(stmfx->map, STMFX_REG_SYS_CTRL, &sys_ctrl);
 123         if (ret)
 124                 return ret;
 125
 126         /*
 127          * IDD and TS have priority in STMFX FW, so if IDD and TS are enabled,
 128          * ALTGPIO function is disabled by STMFX FW. If IDD or TS is enabled,
 129          * the number of aGPIO available decreases. To avoid GPIO management
 130          * disturbance, abort IDD or TS function enable in this case.
 131          */
 132         if (((func & STMFX_FUNC_IDD) || (func & STMFX_FUNC_TS)) &&
 133             (sys_ctrl & STMFX_REG_SYS_CTRL_ALTGPIO_EN)) {
 134                 dev_err(stmfx->dev, "ALTGPIO function already enabled\n");
 135                 return -EBUSY;
 136         }
 137
 138         /* If TS is enabled, aGPIO[3:0] cannot be used */
 139         if ((func & STMFX_FUNC_ALTGPIO_LOW) &&
 140             (sys_ctrl & STMFX_REG_SYS_CTRL_TS_EN)) {
 141                 dev_err(stmfx->dev, "TS in use, aGPIO[3:0] unavailable\n");
 142                 return -EBUSY;
 143         }
 144
 145         /* If IDD is enabled, aGPIO[7:4] cannot be used */
 146         if ((func & STMFX_FUNC_ALTGPIO_HIGH) &&
 147             (sys_ctrl & STMFX_REG_SYS_CTRL_IDD_EN)) {
 148                 dev_err(stmfx->dev, "IDD in use, aGPIO[7:4] unavailable\n");
 149                 return -EBUSY;
 150         }
 151
 152         mask = stmfx_func_to_mask(func);
 153
 154         return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, mask);
 155 }
 156 EXPORT_SYMBOL_GPL(stmfx_function_enable);
 157
 158 int stmfx_function_disable(struct stmfx *stmfx, u32 func)
 159 {
 160         u8 mask = stmfx_func_to_mask(func);
 161
 162         return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, 0);
 163 }
 164 EXPORT_SYMBOL_GPL(stmfx_function_disable);
 165
 166 static void stmfx_irq_bus_lock(struct irq_data *data)
 167 {
 168         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
 169
 170         mutex_lock(&stmfx->lock);
 171 }
 172
 173 static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
 174 {
 175         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
 176
 177         regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, stmfx->irq_src);
 178
 179         mutex_unlock(&stmfx->lock);
 180 }
 181
 182 static void stmfx_irq_mask(struct irq_data *data)
 183 {
 184         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
 185
 186         stmfx->irq_src &= ~BIT(data->hwirq % 8);
 187 }
 188
 189 static void stmfx_irq_unmask(struct irq_data *data)
 190 {
 191         struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
 192
 193         stmfx->irq_src |= BIT(data->hwirq % 8);
 194 }
 195
 196 static struct irq_chip stmfx_irq_chip = {
 197         .name                   = "stmfx-core",
 198         .irq_bus_lock           = stmfx_irq_bus_lock,
 199         .irq_bus_sync_unlock    = stmfx_irq_bus_sync_unlock,
 200         .irq_mask               = stmfx_irq_mask,
 201         .irq_unmask             = stmfx_irq_unmask,
 202 };
 203
 204 static irqreturn_t stmfx_irq_handler(int irq, void *data)
 205 {
 206         struct stmfx *stmfx = data;
 207         unsigned long bits;
 208         u32 pending, ack;
 209         int n, ret;
 210
 211         ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING, &pending);
 212         if (ret)
 213                 return IRQ_NONE;
 214
 215         /*
 216          * There is no ACK for GPIO, MFX_REG_IRQ_PENDING_GPIO is a logical OR
 217          * of MFX_REG_IRQ_GPI _PENDING1/_PENDING2/_PENDING3
 218          */
 219         ack = pending & ~BIT(STMFX_REG_IRQ_SRC_EN_GPIO);
 220         if (ack) {
 221                 ret = regmap_write(stmfx->map, STMFX_REG_IRQ_ACK, ack);
 222                 if (ret)
 223                         return IRQ_NONE;
 224         }
 225
 226         bits = pending;
 227         for_each_set_bit(n, &bits, STMFX_REG_IRQ_SRC_MAX)
 228                 handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));
 229
 230         return IRQ_HANDLED;
 231 }
 232
 233 static int stmfx_irq_map(struct irq_domain *d, unsigned int virq,
 234                          irq_hw_number_t hwirq)
 235 {
 236         irq_set_chip_data(virq, d->host_data);
 237         irq_set_chip_and_handler(virq, &stmfx_irq_chip, handle_simple_irq);
 238         irq_set_nested_thread(virq, 1);
 239         irq_set_noprobe(virq);
 240
 241         return 0;
 242 }
 243
 244 static void stmfx_irq_unmap(struct irq_domain *d, unsigned int virq)
 245 {
 246         irq_set_chip_and_handler(virq, NULL, NULL);
 247         irq_set_chip_data(virq, NULL);
 248 }
 249
 250 static const struct irq_domain_ops stmfx_irq_ops = {
 251         .map    = stmfx_irq_map,
 252         .unmap  = stmfx_irq_unmap,
 253 };
 254
 255 static void stmfx_irq_exit(struct i2c_client *client)
 256 {
 257         struct stmfx *stmfx = i2c_get_clientdata(client);
 258         int hwirq;
 259
 260         for (hwirq = 0; hwirq < STMFX_REG_IRQ_SRC_MAX; hwirq++)
 261                 irq_dispose_mapping(irq_find_mapping(stmfx->irq_domain, hwirq));
 262
 263         irq_domain_remove(stmfx->irq_domain);
 264 }
 265
 266 static int stmfx_irq_init(struct i2c_client *client)
 267 {
 268         struct stmfx *stmfx = i2c_get_clientdata(client);
 269         u32 irqoutpin = 0, irqtrigger;
 270         int ret;
 271
 272         stmfx->irq_domain = irq_domain_add_simple(stmfx->dev->of_node,
 273                                                   STMFX_REG_IRQ_SRC_MAX, 0,
 274                                                   &stmfx_irq_ops, stmfx);
 275         if (!stmfx->irq_domain) {
 276                 dev_err(stmfx->dev, "Failed to create IRQ domain\n");
 277                 return -EINVAL;
 278         }
 279
 280         if (!of_property_read_bool(stmfx->dev->of_node, "drive-open-drain"))
 281                 irqoutpin |= STMFX_REG_IRQ_OUT_PIN_TYPE;
 282
 283         irqtrigger = irq_get_trigger_type(client->irq);
 284         if ((irqtrigger & IRQ_TYPE_EDGE_RISING) ||
 285             (irqtrigger & IRQ_TYPE_LEVEL_HIGH))
 286                 irqoutpin |= STMFX_REG_IRQ_OUT_PIN_POL;
 287
 288         ret = regmap_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin);
 289         if (ret)
 290                 goto irq_exit;
 291
 292         ret = devm_request_threaded_irq(stmfx->dev, client->irq,
 293                                         NULL, stmfx_irq_handler,
 294                                         irqtrigger | IRQF_ONESHOT,
 295                                         "stmfx", stmfx);
 296         if (ret)
 297                 goto irq_exit;
 298
 299         stmfx->irq = client->irq;
 300
 301         return 0;
 302
 303 irq_exit:
 304         stmfx_irq_exit(client);
 305
 306         return ret;
 307 }
 308
 309 static int stmfx_chip_reset(struct stmfx *stmfx)
 310 {
 311         int ret;
 312
 313         ret = regmap_write(stmfx->map, STMFX_REG_SYS_CTRL,
 314                            STMFX_REG_SYS_CTRL_SWRST);
 315         if (ret)
 316                 return ret;
 317
 318         msleep(STMFX_BOOT_TIME_MS);
 319
 320         return ret;
 321 }
 322
 323 static int stmfx_chip_init(struct i2c_client *client)
 324 {
 325         struct stmfx *stmfx = i2c_get_clientdata(client);
 326         u32 id;
 327         u8 version[2];
 328         int ret;
 329
 330         stmfx->vdd = devm_regulator_get_optional(&client->dev, "vdd");
 331         ret = PTR_ERR_OR_ZERO(stmfx->vdd);
 332         if (ret == -ENODEV) {
 333                 stmfx->vdd = NULL;
 334         } else if (ret == -EPROBE_DEFER) {
 335                 return ret;
 336         } else if (ret) {
 337                 dev_err(&client->dev, "Failed to get VDD regulator: %d\n", ret);
 338                 return ret;
 339         }
 340
 341         if (stmfx->vdd) {
 342                 ret = regulator_enable(stmfx->vdd);
 343                 if (ret) {
 344                         dev_err(&client->dev, "VDD enable failed: %d\n", ret);
 345                         return ret;
 346                 }
 347         }
 348
 349         ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id);
 350         if (ret) {
 351                 dev_err(&client->dev, "Error reading chip ID: %d\n", ret);
 352                 goto err;
 353         }
 354
 355         /*
 356          * Check that ID is the complement of the I2C address:
 357          * STMFX I2C address follows the 7-bit format (MSB), that's why
 358          * client->addr is shifted.
 359          *
 360          * STMFX_I2C_ADDR|       STMFX         |        Linux
 361          *   input pin   | I2C device address  | I2C device address
 362          *---------------------------------------------------------
 363          *       0       | b: 1000 010x h:0x84 |       0x42
 364          *       1       | b: 1000 011x h:0x86 |       0x43
 365          */
 366         if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) {
 367                 dev_err(&client->dev, "Unknown chip ID: %#x\n", id);
 368                 ret = -EINVAL;
 369                 goto err;
 370         }
 371
 372         ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB,
 373                                version, ARRAY_SIZE(version));
 374         if (ret) {
 375                 dev_err(&client->dev, "Error reading FW version: %d\n", ret);
 376                 goto err;
 377         }
 378
 379         dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n",
 380                  id, version[0], version[1]);
 381
 382         ret = stmfx_chip_reset(stmfx);
 383         if (ret) {
 384                 dev_err(&client->dev, "Failed to reset chip: %d\n", ret);
 385                 goto err;
 386         }
 387
 388         return 0;
 389
 390 err:
 391         if (stmfx->vdd)
 392                 return regulator_disable(stmfx->vdd);
 393
 394         return ret;
 395 }
 396
 397 static int stmfx_chip_exit(struct i2c_client *client)
 398 {
 399         struct stmfx *stmfx = i2c_get_clientdata(client);
 400
 401         regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
 402         regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0);
 403
 404         if (stmfx->vdd)
 405                 return regulator_disable(stmfx->vdd);
 406
 407         return 0;
 408 }
 409
 410 static int stmfx_probe(struct i2c_client *client,
 411                        const struct i2c_device_id *id)
 412 {
 413         struct device *dev = &client->dev;
 414         struct stmfx *stmfx;
 415         int ret;
 416
 417         stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL);
 418         if (!stmfx)
 419                 return -ENOMEM;
 420
 421         i2c_set_clientdata(client, stmfx);
 422
 423         stmfx->dev = dev;
 424
 425         stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
 426         if (IS_ERR(stmfx->map)) {
 427                 ret = PTR_ERR(stmfx->map);
 428                 dev_err(dev, "Failed to allocate register map: %d\n", ret);
 429                 return ret;
 430         }
 431
 432         mutex_init(&stmfx->lock);
 433
 434         ret = stmfx_chip_init(client);
 435         if (ret) {
 436                 if (ret == -ETIMEDOUT)
 437                         return -EPROBE_DEFER;
 438                 return ret;
 439         }
 440
 441         if (client->irq < 0) {
 442                 dev_err(dev, "Failed to get IRQ: %d\n", client->irq);
 443                 ret = client->irq;
 444                 goto err_chip_exit;
 445         }
 446
 447         ret = stmfx_irq_init(client);
 448         if (ret)
 449                 goto err_chip_exit;
 450
 451         ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
 452                                    stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
 453                                    0, stmfx->irq_domain);
 454         if (ret)
 455                 goto err_irq_exit;
 456
 457         return 0;
 458
 459 err_irq_exit:
 460         stmfx_irq_exit(client);
 461 err_chip_exit:
 462         stmfx_chip_exit(client);
 463
 464         return ret;
 465 }
 466
 467 static int stmfx_remove(struct i2c_client *client)
 468 {
 469         stmfx_irq_exit(client);
 470
 471         return stmfx_chip_exit(client);
 472 }
 473
 474 #ifdef CONFIG_PM_SLEEP
 475 static int stmfx_suspend(struct device *dev)
 476 {
 477         struct stmfx *stmfx = dev_get_drvdata(dev);
 478         int ret;
 479
 480         ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL,
 481                               &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
 482         if (ret)
 483                 return ret;
 484
 485         ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
 486                               &stmfx->bkp_irqoutpin,
 487                               sizeof(stmfx->bkp_irqoutpin));
 488         if (ret)
 489                 return ret;
 490
 491         disable_irq(stmfx->irq);
 492
 493         if (stmfx->vdd)
 494                 return regulator_disable(stmfx->vdd);
 495
 496         return 0;
 497 }
 498
 499 static int stmfx_resume(struct device *dev)
 500 {
 501         struct stmfx *stmfx = dev_get_drvdata(dev);
 502         int ret;
 503
 504         if (stmfx->vdd) {
 505                 ret = regulator_enable(stmfx->vdd);
 506                 if (ret) {
 507                         dev_err(stmfx->dev,
 508                                 "VDD enable failed: %d\n", ret);
 509                         return ret;
 510                 }
 511         }
 512
 513         /* Reset STMFX - supply has been stopped during suspend */
 514         ret = stmfx_chip_reset(stmfx);
 515         if (ret) {
 516                 dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret);
 517                 return ret;
 518         }
 519
 520         ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL,
 521                                &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
 522         if (ret)
 523                 return ret;
 524
 525         ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
 526                                &stmfx->bkp_irqoutpin,
 527                                sizeof(stmfx->bkp_irqoutpin));
 528         if (ret)
 529                 return ret;
 530
 531         ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN,
 532                                &stmfx->irq_src, sizeof(stmfx->irq_src));
 533         if (ret)
 534                 return ret;
 535
 536         enable_irq(stmfx->irq);
 537
 538         return 0;
 539 }
 540 #endif
 541
 542 static SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume);
 543
 544 static const struct of_device_id stmfx_of_match[] = {
 545         { .compatible = "st,stmfx-0300", },
 546         {},
 547 };
 548 MODULE_DEVICE_TABLE(of, stmfx_of_match);
 549
 550 static struct i2c_driver stmfx_driver = {
 551         .driver = {
 552                 .name = "stmfx-core",
 553                 .of_match_table = of_match_ptr(stmfx_of_match),
 554                 .pm = &stmfx_dev_pm_ops,
 555         },
 556         .probe = stmfx_probe,
 557         .remove = stmfx_remove,
 558 };
 559 module_i2c_driver(stmfx_driver);
 560
 561 MODULE_DESCRIPTION("STMFX core driver");
 562 MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
 563 MODULE_LICENSE("GPL v2");