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) { 333 if (ret == -ENODEV) 334 stmfx->vdd = NULL; 335 else 336 return dev_err_probe(&client->dev, ret, "Failed to get VDD regulator\n"); 337 } 338 339 if (stmfx->vdd) { 340 ret = regulator_enable(stmfx->vdd); 341 if (ret) { 342 dev_err(&client->dev, "VDD enable failed: %d\n", ret); 343 return ret; 344 } 345 } 346 347 ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id); 348 if (ret) { 349 dev_err(&client->dev, "Error reading chip ID: %d\n", ret); 350 goto err; 351 } 352 353 /* 354 * Check that ID is the complement of the I2C address: 355 * STMFX I2C address follows the 7-bit format (MSB), that's why 356 * client->addr is shifted. 357 * 358 * STMFX_I2C_ADDR| STMFX | Linux 359 * input pin | I2C device address | I2C device address 360 *--------------------------------------------------------- 361 * 0 | b: 1000 010x h:0x84 | 0x42 362 * 1 | b: 1000 011x h:0x86 | 0x43 363 */ 364 if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) { 365 dev_err(&client->dev, "Unknown chip ID: %#x\n", id); 366 ret = -EINVAL; 367 goto err; 368 } 369 370 ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB, 371 version, ARRAY_SIZE(version)); 372 if (ret) { 373 dev_err(&client->dev, "Error reading FW version: %d\n", ret); 374 goto err; 375 } 376 377 dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n", 378 id, version[0], version[1]); 379 380 ret = stmfx_chip_reset(stmfx); 381 if (ret) { 382 dev_err(&client->dev, "Failed to reset chip: %d\n", ret); 383 goto err; 384 } 385 386 return 0; 387 388 err: 389 if (stmfx->vdd) 390 return regulator_disable(stmfx->vdd); 391 392 return ret; 393 } 394 395 static void stmfx_chip_exit(struct i2c_client *client) 396 { 397 struct stmfx *stmfx = i2c_get_clientdata(client); 398 399 regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0); 400 regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0); 401 402 if (stmfx->vdd) { 403 int ret; 404 405 ret = regulator_disable(stmfx->vdd); 406 if (ret) 407 dev_err(&client->dev, 408 "Failed to disable vdd regulator: %pe\n", 409 ERR_PTR(ret)); 410 } 411 } 412 413 static int stmfx_probe(struct i2c_client *client, 414 const struct i2c_device_id *id) 415 { 416 struct device *dev = &client->dev; 417 struct stmfx *stmfx; 418 int ret; 419 420 stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL); 421 if (!stmfx) 422 return -ENOMEM; 423 424 i2c_set_clientdata(client, stmfx); 425 426 stmfx->dev = dev; 427 428 stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config); 429 if (IS_ERR(stmfx->map)) { 430 ret = PTR_ERR(stmfx->map); 431 dev_err(dev, "Failed to allocate register map: %d\n", ret); 432 return ret; 433 } 434 435 mutex_init(&stmfx->lock); 436 437 ret = stmfx_chip_init(client); 438 if (ret) { 439 if (ret == -ETIMEDOUT) 440 return -EPROBE_DEFER; 441 return ret; 442 } 443 444 if (client->irq < 0) { 445 dev_err(dev, "Failed to get IRQ: %d\n", client->irq); 446 ret = client->irq; 447 goto err_chip_exit; 448 } 449 450 ret = stmfx_irq_init(client); 451 if (ret) 452 goto err_chip_exit; 453 454 ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE, 455 stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL, 456 0, stmfx->irq_domain); 457 if (ret) 458 goto err_irq_exit; 459 460 return 0; 461 462 err_irq_exit: 463 stmfx_irq_exit(client); 464 err_chip_exit: 465 stmfx_chip_exit(client); 466 467 return ret; 468 } 469 470 static int stmfx_remove(struct i2c_client *client) 471 { 472 stmfx_irq_exit(client); 473 474 stmfx_chip_exit(client); 475 476 return 0; 477 } 478 479 #ifdef CONFIG_PM_SLEEP 480 static int stmfx_suspend(struct device *dev) 481 { 482 struct stmfx *stmfx = dev_get_drvdata(dev); 483 int ret; 484 485 ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL, 486 &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl)); 487 if (ret) 488 return ret; 489 490 ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN, 491 &stmfx->bkp_irqoutpin, 492 sizeof(stmfx->bkp_irqoutpin)); 493 if (ret) 494 return ret; 495 496 disable_irq(stmfx->irq); 497 498 if (stmfx->vdd) 499 return regulator_disable(stmfx->vdd); 500 501 return 0; 502 } 503 504 static int stmfx_resume(struct device *dev) 505 { 506 struct stmfx *stmfx = dev_get_drvdata(dev); 507 int ret; 508 509 if (stmfx->vdd) { 510 ret = regulator_enable(stmfx->vdd); 511 if (ret) { 512 dev_err(stmfx->dev, 513 "VDD enable failed: %d\n", ret); 514 return ret; 515 } 516 } 517 518 /* Reset STMFX - supply has been stopped during suspend */ 519 ret = stmfx_chip_reset(stmfx); 520 if (ret) { 521 dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret); 522 return ret; 523 } 524 525 ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL, 526 &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl)); 527 if (ret) 528 return ret; 529 530 ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, 531 &stmfx->bkp_irqoutpin, 532 sizeof(stmfx->bkp_irqoutpin)); 533 if (ret) 534 return ret; 535 536 ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 537 &stmfx->irq_src, sizeof(stmfx->irq_src)); 538 if (ret) 539 return ret; 540 541 enable_irq(stmfx->irq); 542 543 return 0; 544 } 545 #endif 546 547 static SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume); 548 549 static const struct of_device_id stmfx_of_match[] = { 550 { .compatible = "st,stmfx-0300", }, 551 {}, 552 }; 553 MODULE_DEVICE_TABLE(of, stmfx_of_match); 554 555 static struct i2c_driver stmfx_driver = { 556 .driver = { 557 .name = "stmfx-core", 558 .of_match_table = stmfx_of_match, 559 .pm = &stmfx_dev_pm_ops, 560 }, 561 .probe = stmfx_probe, 562 .remove = stmfx_remove, 563 }; 564 module_i2c_driver(stmfx_driver); 565 566 MODULE_DESCRIPTION("STMFX core driver"); 567 MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>"); 568 MODULE_LICENSE("GPL v2"); 569