1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved. 4 */ 5 #include <linux/kernel.h> 6 #include <linux/errno.h> 7 #include <linux/idr.h> 8 #include <linux/slab.h> 9 #include <linux/module.h> 10 #include <linux/of.h> 11 #include <linux/of_device.h> 12 #include <linux/platform_device.h> 13 #include <linux/spmi.h> 14 #include <linux/pm_runtime.h> 15 16 #include <dt-bindings/spmi/spmi.h> 17 #define CREATE_TRACE_POINTS 18 #include <trace/events/spmi.h> 19 20 static bool is_registered; 21 static DEFINE_IDA(ctrl_ida); 22 23 static void spmi_dev_release(struct device *dev) 24 { 25 struct spmi_device *sdev = to_spmi_device(dev); 26 27 kfree(sdev); 28 } 29 30 static const struct device_type spmi_dev_type = { 31 .release = spmi_dev_release, 32 }; 33 34 static void spmi_ctrl_release(struct device *dev) 35 { 36 struct spmi_controller *ctrl = to_spmi_controller(dev); 37 38 ida_free(&ctrl_ida, ctrl->nr); 39 kfree(ctrl); 40 } 41 42 static const struct device_type spmi_ctrl_type = { 43 .release = spmi_ctrl_release, 44 }; 45 46 static int spmi_device_match(struct device *dev, struct device_driver *drv) 47 { 48 if (of_driver_match_device(dev, drv)) 49 return 1; 50 51 if (drv->name) 52 return strncmp(dev_name(dev), drv->name, 53 SPMI_NAME_SIZE) == 0; 54 55 return 0; 56 } 57 58 /** 59 * spmi_device_add() - add a device previously constructed via spmi_device_alloc() 60 * @sdev: spmi_device to be added 61 */ 62 int spmi_device_add(struct spmi_device *sdev) 63 { 64 struct spmi_controller *ctrl = sdev->ctrl; 65 int err; 66 67 dev_set_name(&sdev->dev, "%d-%02x", ctrl->nr, sdev->usid); 68 69 err = device_add(&sdev->dev); 70 if (err < 0) { 71 dev_err(&sdev->dev, "Can't add %s, status %d\n", 72 dev_name(&sdev->dev), err); 73 goto err_device_add; 74 } 75 76 dev_dbg(&sdev->dev, "device %s registered\n", dev_name(&sdev->dev)); 77 78 err_device_add: 79 return err; 80 } 81 EXPORT_SYMBOL_GPL(spmi_device_add); 82 83 /** 84 * spmi_device_remove(): remove an SPMI device 85 * @sdev: spmi_device to be removed 86 */ 87 void spmi_device_remove(struct spmi_device *sdev) 88 { 89 device_unregister(&sdev->dev); 90 } 91 EXPORT_SYMBOL_GPL(spmi_device_remove); 92 93 static inline int 94 spmi_cmd(struct spmi_controller *ctrl, u8 opcode, u8 sid) 95 { 96 int ret; 97 98 if (!ctrl || !ctrl->cmd || ctrl->dev.type != &spmi_ctrl_type) 99 return -EINVAL; 100 101 ret = ctrl->cmd(ctrl, opcode, sid); 102 trace_spmi_cmd(opcode, sid, ret); 103 return ret; 104 } 105 106 static inline int spmi_read_cmd(struct spmi_controller *ctrl, u8 opcode, 107 u8 sid, u16 addr, u8 *buf, size_t len) 108 { 109 int ret; 110 111 if (!ctrl || !ctrl->read_cmd || ctrl->dev.type != &spmi_ctrl_type) 112 return -EINVAL; 113 114 trace_spmi_read_begin(opcode, sid, addr); 115 ret = ctrl->read_cmd(ctrl, opcode, sid, addr, buf, len); 116 trace_spmi_read_end(opcode, sid, addr, ret, len, buf); 117 return ret; 118 } 119 120 static inline int spmi_write_cmd(struct spmi_controller *ctrl, u8 opcode, 121 u8 sid, u16 addr, const u8 *buf, size_t len) 122 { 123 int ret; 124 125 if (!ctrl || !ctrl->write_cmd || ctrl->dev.type != &spmi_ctrl_type) 126 return -EINVAL; 127 128 trace_spmi_write_begin(opcode, sid, addr, len, buf); 129 ret = ctrl->write_cmd(ctrl, opcode, sid, addr, buf, len); 130 trace_spmi_write_end(opcode, sid, addr, ret); 131 return ret; 132 } 133 134 /** 135 * spmi_register_read() - register read 136 * @sdev: SPMI device. 137 * @addr: slave register address (5-bit address). 138 * @buf: buffer to be populated with data from the Slave. 139 * 140 * Reads 1 byte of data from a Slave device register. 141 */ 142 int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf) 143 { 144 /* 5-bit register address */ 145 if (addr > 0x1F) 146 return -EINVAL; 147 148 return spmi_read_cmd(sdev->ctrl, SPMI_CMD_READ, sdev->usid, addr, 149 buf, 1); 150 } 151 EXPORT_SYMBOL_GPL(spmi_register_read); 152 153 /** 154 * spmi_ext_register_read() - extended register read 155 * @sdev: SPMI device. 156 * @addr: slave register address (8-bit address). 157 * @buf: buffer to be populated with data from the Slave. 158 * @len: the request number of bytes to read (up to 16 bytes). 159 * 160 * Reads up to 16 bytes of data from the extended register space on a 161 * Slave device. 162 */ 163 int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf, 164 size_t len) 165 { 166 /* 8-bit register address, up to 16 bytes */ 167 if (len == 0 || len > 16) 168 return -EINVAL; 169 170 return spmi_read_cmd(sdev->ctrl, SPMI_CMD_EXT_READ, sdev->usid, addr, 171 buf, len); 172 } 173 EXPORT_SYMBOL_GPL(spmi_ext_register_read); 174 175 /** 176 * spmi_ext_register_readl() - extended register read long 177 * @sdev: SPMI device. 178 * @addr: slave register address (16-bit address). 179 * @buf: buffer to be populated with data from the Slave. 180 * @len: the request number of bytes to read (up to 8 bytes). 181 * 182 * Reads up to 8 bytes of data from the extended register space on a 183 * Slave device using 16-bit address. 184 */ 185 int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf, 186 size_t len) 187 { 188 /* 16-bit register address, up to 8 bytes */ 189 if (len == 0 || len > 8) 190 return -EINVAL; 191 192 return spmi_read_cmd(sdev->ctrl, SPMI_CMD_EXT_READL, sdev->usid, addr, 193 buf, len); 194 } 195 EXPORT_SYMBOL_GPL(spmi_ext_register_readl); 196 197 /** 198 * spmi_register_write() - register write 199 * @sdev: SPMI device 200 * @addr: slave register address (5-bit address). 201 * @data: buffer containing the data to be transferred to the Slave. 202 * 203 * Writes 1 byte of data to a Slave device register. 204 */ 205 int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data) 206 { 207 /* 5-bit register address */ 208 if (addr > 0x1F) 209 return -EINVAL; 210 211 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_WRITE, sdev->usid, addr, 212 &data, 1); 213 } 214 EXPORT_SYMBOL_GPL(spmi_register_write); 215 216 /** 217 * spmi_register_zero_write() - register zero write 218 * @sdev: SPMI device. 219 * @data: the data to be written to register 0 (7-bits). 220 * 221 * Writes data to register 0 of the Slave device. 222 */ 223 int spmi_register_zero_write(struct spmi_device *sdev, u8 data) 224 { 225 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_ZERO_WRITE, sdev->usid, 0, 226 &data, 1); 227 } 228 EXPORT_SYMBOL_GPL(spmi_register_zero_write); 229 230 /** 231 * spmi_ext_register_write() - extended register write 232 * @sdev: SPMI device. 233 * @addr: slave register address (8-bit address). 234 * @buf: buffer containing the data to be transferred to the Slave. 235 * @len: the request number of bytes to read (up to 16 bytes). 236 * 237 * Writes up to 16 bytes of data to the extended register space of a 238 * Slave device. 239 */ 240 int spmi_ext_register_write(struct spmi_device *sdev, u8 addr, const u8 *buf, 241 size_t len) 242 { 243 /* 8-bit register address, up to 16 bytes */ 244 if (len == 0 || len > 16) 245 return -EINVAL; 246 247 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_EXT_WRITE, sdev->usid, addr, 248 buf, len); 249 } 250 EXPORT_SYMBOL_GPL(spmi_ext_register_write); 251 252 /** 253 * spmi_ext_register_writel() - extended register write long 254 * @sdev: SPMI device. 255 * @addr: slave register address (16-bit address). 256 * @buf: buffer containing the data to be transferred to the Slave. 257 * @len: the request number of bytes to read (up to 8 bytes). 258 * 259 * Writes up to 8 bytes of data to the extended register space of a 260 * Slave device using 16-bit address. 261 */ 262 int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr, const u8 *buf, 263 size_t len) 264 { 265 /* 4-bit Slave Identifier, 16-bit register address, up to 8 bytes */ 266 if (len == 0 || len > 8) 267 return -EINVAL; 268 269 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_EXT_WRITEL, sdev->usid, 270 addr, buf, len); 271 } 272 EXPORT_SYMBOL_GPL(spmi_ext_register_writel); 273 274 /** 275 * spmi_command_reset() - sends RESET command to the specified slave 276 * @sdev: SPMI device. 277 * 278 * The Reset command initializes the Slave and forces all registers to 279 * their reset values. The Slave shall enter the STARTUP state after 280 * receiving a Reset command. 281 */ 282 int spmi_command_reset(struct spmi_device *sdev) 283 { 284 return spmi_cmd(sdev->ctrl, SPMI_CMD_RESET, sdev->usid); 285 } 286 EXPORT_SYMBOL_GPL(spmi_command_reset); 287 288 /** 289 * spmi_command_sleep() - sends SLEEP command to the specified SPMI device 290 * @sdev: SPMI device. 291 * 292 * The Sleep command causes the Slave to enter the user defined SLEEP state. 293 */ 294 int spmi_command_sleep(struct spmi_device *sdev) 295 { 296 return spmi_cmd(sdev->ctrl, SPMI_CMD_SLEEP, sdev->usid); 297 } 298 EXPORT_SYMBOL_GPL(spmi_command_sleep); 299 300 /** 301 * spmi_command_wakeup() - sends WAKEUP command to the specified SPMI device 302 * @sdev: SPMI device. 303 * 304 * The Wakeup command causes the Slave to move from the SLEEP state to 305 * the ACTIVE state. 306 */ 307 int spmi_command_wakeup(struct spmi_device *sdev) 308 { 309 return spmi_cmd(sdev->ctrl, SPMI_CMD_WAKEUP, sdev->usid); 310 } 311 EXPORT_SYMBOL_GPL(spmi_command_wakeup); 312 313 /** 314 * spmi_command_shutdown() - sends SHUTDOWN command to the specified SPMI device 315 * @sdev: SPMI device. 316 * 317 * The Shutdown command causes the Slave to enter the SHUTDOWN state. 318 */ 319 int spmi_command_shutdown(struct spmi_device *sdev) 320 { 321 return spmi_cmd(sdev->ctrl, SPMI_CMD_SHUTDOWN, sdev->usid); 322 } 323 EXPORT_SYMBOL_GPL(spmi_command_shutdown); 324 325 static int spmi_drv_probe(struct device *dev) 326 { 327 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver); 328 struct spmi_device *sdev = to_spmi_device(dev); 329 int err; 330 331 pm_runtime_get_noresume(dev); 332 pm_runtime_set_active(dev); 333 pm_runtime_enable(dev); 334 335 err = sdrv->probe(sdev); 336 if (err) 337 goto fail_probe; 338 339 return 0; 340 341 fail_probe: 342 pm_runtime_disable(dev); 343 pm_runtime_set_suspended(dev); 344 pm_runtime_put_noidle(dev); 345 return err; 346 } 347 348 static void spmi_drv_remove(struct device *dev) 349 { 350 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver); 351 352 pm_runtime_get_sync(dev); 353 if (sdrv->remove) 354 sdrv->remove(to_spmi_device(dev)); 355 pm_runtime_put_noidle(dev); 356 357 pm_runtime_disable(dev); 358 pm_runtime_set_suspended(dev); 359 pm_runtime_put_noidle(dev); 360 } 361 362 static void spmi_drv_shutdown(struct device *dev) 363 { 364 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver); 365 366 if (sdrv && sdrv->shutdown) 367 sdrv->shutdown(to_spmi_device(dev)); 368 } 369 370 static int spmi_drv_uevent(const struct device *dev, struct kobj_uevent_env *env) 371 { 372 int ret; 373 374 ret = of_device_uevent_modalias(dev, env); 375 if (ret != -ENODEV) 376 return ret; 377 378 return 0; 379 } 380 381 static struct bus_type spmi_bus_type = { 382 .name = "spmi", 383 .match = spmi_device_match, 384 .probe = spmi_drv_probe, 385 .remove = spmi_drv_remove, 386 .shutdown = spmi_drv_shutdown, 387 .uevent = spmi_drv_uevent, 388 }; 389 390 /** 391 * spmi_find_device_by_of_node() - look up an SPMI device from a device node 392 * 393 * @np: device node 394 * 395 * Takes a reference to the embedded struct device which needs to be dropped 396 * after use. 397 * 398 * Returns the struct spmi_device associated with a device node or NULL. 399 */ 400 struct spmi_device *spmi_find_device_by_of_node(struct device_node *np) 401 { 402 struct device *dev = bus_find_device_by_of_node(&spmi_bus_type, np); 403 404 if (dev) 405 return to_spmi_device(dev); 406 return NULL; 407 } 408 EXPORT_SYMBOL_GPL(spmi_find_device_by_of_node); 409 410 /** 411 * spmi_device_alloc() - Allocate a new SPMI device 412 * @ctrl: associated controller 413 * 414 * Caller is responsible for either calling spmi_device_add() to add the 415 * newly allocated controller, or calling spmi_device_put() to discard it. 416 */ 417 struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl) 418 { 419 struct spmi_device *sdev; 420 421 sdev = kzalloc(sizeof(*sdev), GFP_KERNEL); 422 if (!sdev) 423 return NULL; 424 425 sdev->ctrl = ctrl; 426 device_initialize(&sdev->dev); 427 sdev->dev.parent = &ctrl->dev; 428 sdev->dev.bus = &spmi_bus_type; 429 sdev->dev.type = &spmi_dev_type; 430 return sdev; 431 } 432 EXPORT_SYMBOL_GPL(spmi_device_alloc); 433 434 /** 435 * spmi_controller_alloc() - Allocate a new SPMI controller 436 * @parent: parent device 437 * @size: size of private data 438 * 439 * Caller is responsible for either calling spmi_controller_add() to add the 440 * newly allocated controller, or calling spmi_controller_put() to discard it. 441 * The allocated private data region may be accessed via 442 * spmi_controller_get_drvdata() 443 */ 444 struct spmi_controller *spmi_controller_alloc(struct device *parent, 445 size_t size) 446 { 447 struct spmi_controller *ctrl; 448 int id; 449 450 if (WARN_ON(!parent)) 451 return NULL; 452 453 ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL); 454 if (!ctrl) 455 return NULL; 456 457 device_initialize(&ctrl->dev); 458 ctrl->dev.type = &spmi_ctrl_type; 459 ctrl->dev.bus = &spmi_bus_type; 460 ctrl->dev.parent = parent; 461 ctrl->dev.of_node = parent->of_node; 462 spmi_controller_set_drvdata(ctrl, &ctrl[1]); 463 464 id = ida_alloc(&ctrl_ida, GFP_KERNEL); 465 if (id < 0) { 466 dev_err(parent, 467 "unable to allocate SPMI controller identifier.\n"); 468 spmi_controller_put(ctrl); 469 return NULL; 470 } 471 472 ctrl->nr = id; 473 dev_set_name(&ctrl->dev, "spmi-%d", id); 474 475 dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id); 476 return ctrl; 477 } 478 EXPORT_SYMBOL_GPL(spmi_controller_alloc); 479 480 static void of_spmi_register_devices(struct spmi_controller *ctrl) 481 { 482 struct device_node *node; 483 int err; 484 485 if (!ctrl->dev.of_node) 486 return; 487 488 for_each_available_child_of_node(ctrl->dev.of_node, node) { 489 struct spmi_device *sdev; 490 u32 reg[2]; 491 492 dev_dbg(&ctrl->dev, "adding child %pOF\n", node); 493 494 err = of_property_read_u32_array(node, "reg", reg, 2); 495 if (err) { 496 dev_err(&ctrl->dev, 497 "node %pOF err (%d) does not have 'reg' property\n", 498 node, err); 499 continue; 500 } 501 502 if (reg[1] != SPMI_USID) { 503 dev_err(&ctrl->dev, 504 "node %pOF contains unsupported 'reg' entry\n", 505 node); 506 continue; 507 } 508 509 if (reg[0] >= SPMI_MAX_SLAVE_ID) { 510 dev_err(&ctrl->dev, "invalid usid on node %pOF\n", node); 511 continue; 512 } 513 514 dev_dbg(&ctrl->dev, "read usid %02x\n", reg[0]); 515 516 sdev = spmi_device_alloc(ctrl); 517 if (!sdev) 518 continue; 519 520 sdev->dev.of_node = node; 521 sdev->usid = (u8)reg[0]; 522 523 err = spmi_device_add(sdev); 524 if (err) { 525 dev_err(&sdev->dev, 526 "failure adding device. status %d\n", err); 527 spmi_device_put(sdev); 528 } 529 } 530 } 531 532 /** 533 * spmi_controller_add() - Add an SPMI controller 534 * @ctrl: controller to be registered. 535 * 536 * Register a controller previously allocated via spmi_controller_alloc() with 537 * the SPMI core. 538 */ 539 int spmi_controller_add(struct spmi_controller *ctrl) 540 { 541 int ret; 542 543 /* Can't register until after driver model init */ 544 if (WARN_ON(!is_registered)) 545 return -EAGAIN; 546 547 ret = device_add(&ctrl->dev); 548 if (ret) 549 return ret; 550 551 if (IS_ENABLED(CONFIG_OF)) 552 of_spmi_register_devices(ctrl); 553 554 dev_dbg(&ctrl->dev, "spmi-%d registered: dev:%p\n", 555 ctrl->nr, &ctrl->dev); 556 557 return 0; 558 }; 559 EXPORT_SYMBOL_GPL(spmi_controller_add); 560 561 /* Remove a device associated with a controller */ 562 static int spmi_ctrl_remove_device(struct device *dev, void *data) 563 { 564 struct spmi_device *spmidev = to_spmi_device(dev); 565 566 if (dev->type == &spmi_dev_type) 567 spmi_device_remove(spmidev); 568 return 0; 569 } 570 571 /** 572 * spmi_controller_remove(): remove an SPMI controller 573 * @ctrl: controller to remove 574 * 575 * Remove a SPMI controller. Caller is responsible for calling 576 * spmi_controller_put() to discard the allocated controller. 577 */ 578 void spmi_controller_remove(struct spmi_controller *ctrl) 579 { 580 if (!ctrl) 581 return; 582 583 device_for_each_child(&ctrl->dev, NULL, spmi_ctrl_remove_device); 584 device_del(&ctrl->dev); 585 } 586 EXPORT_SYMBOL_GPL(spmi_controller_remove); 587 588 /** 589 * __spmi_driver_register() - Register client driver with SPMI core 590 * @sdrv: client driver to be associated with client-device. 591 * @owner: module owner 592 * 593 * This API will register the client driver with the SPMI framework. 594 * It is typically called from the driver's module-init function. 595 */ 596 int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner) 597 { 598 sdrv->driver.bus = &spmi_bus_type; 599 sdrv->driver.owner = owner; 600 return driver_register(&sdrv->driver); 601 } 602 EXPORT_SYMBOL_GPL(__spmi_driver_register); 603 604 static void __exit spmi_exit(void) 605 { 606 bus_unregister(&spmi_bus_type); 607 } 608 module_exit(spmi_exit); 609 610 static int __init spmi_init(void) 611 { 612 int ret; 613 614 ret = bus_register(&spmi_bus_type); 615 if (ret) 616 return ret; 617 618 is_registered = true; 619 return 0; 620 } 621 postcore_initcall(spmi_init); 622 623 MODULE_LICENSE("GPL v2"); 624 MODULE_DESCRIPTION("SPMI module"); 625 MODULE_ALIAS("platform:spmi"); 626