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_simple_remove(&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 sdrv->remove(to_spmi_device(dev)); 354 pm_runtime_put_noidle(dev); 355 356 pm_runtime_disable(dev); 357 pm_runtime_set_suspended(dev); 358 pm_runtime_put_noidle(dev); 359 } 360 361 static void spmi_drv_shutdown(struct device *dev) 362 { 363 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver); 364 365 if (sdrv && sdrv->shutdown) 366 sdrv->shutdown(to_spmi_device(dev)); 367 } 368 369 static int spmi_drv_uevent(struct device *dev, struct kobj_uevent_env *env) 370 { 371 int ret; 372 373 ret = of_device_uevent_modalias(dev, env); 374 if (ret != -ENODEV) 375 return ret; 376 377 return 0; 378 } 379 380 static struct bus_type spmi_bus_type = { 381 .name = "spmi", 382 .match = spmi_device_match, 383 .probe = spmi_drv_probe, 384 .remove = spmi_drv_remove, 385 .shutdown = spmi_drv_shutdown, 386 .uevent = spmi_drv_uevent, 387 }; 388 389 /** 390 * spmi_controller_alloc() - Allocate a new SPMI device 391 * @ctrl: associated controller 392 * 393 * Caller is responsible for either calling spmi_device_add() to add the 394 * newly allocated controller, or calling spmi_device_put() to discard it. 395 */ 396 struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl) 397 { 398 struct spmi_device *sdev; 399 400 sdev = kzalloc(sizeof(*sdev), GFP_KERNEL); 401 if (!sdev) 402 return NULL; 403 404 sdev->ctrl = ctrl; 405 device_initialize(&sdev->dev); 406 sdev->dev.parent = &ctrl->dev; 407 sdev->dev.bus = &spmi_bus_type; 408 sdev->dev.type = &spmi_dev_type; 409 return sdev; 410 } 411 EXPORT_SYMBOL_GPL(spmi_device_alloc); 412 413 /** 414 * spmi_controller_alloc() - Allocate a new SPMI controller 415 * @parent: parent device 416 * @size: size of private data 417 * 418 * Caller is responsible for either calling spmi_controller_add() to add the 419 * newly allocated controller, or calling spmi_controller_put() to discard it. 420 * The allocated private data region may be accessed via 421 * spmi_controller_get_drvdata() 422 */ 423 struct spmi_controller *spmi_controller_alloc(struct device *parent, 424 size_t size) 425 { 426 struct spmi_controller *ctrl; 427 int id; 428 429 if (WARN_ON(!parent)) 430 return NULL; 431 432 ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL); 433 if (!ctrl) 434 return NULL; 435 436 device_initialize(&ctrl->dev); 437 ctrl->dev.type = &spmi_ctrl_type; 438 ctrl->dev.bus = &spmi_bus_type; 439 ctrl->dev.parent = parent; 440 ctrl->dev.of_node = parent->of_node; 441 spmi_controller_set_drvdata(ctrl, &ctrl[1]); 442 443 id = ida_simple_get(&ctrl_ida, 0, 0, GFP_KERNEL); 444 if (id < 0) { 445 dev_err(parent, 446 "unable to allocate SPMI controller identifier.\n"); 447 spmi_controller_put(ctrl); 448 return NULL; 449 } 450 451 ctrl->nr = id; 452 dev_set_name(&ctrl->dev, "spmi-%d", id); 453 454 dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id); 455 return ctrl; 456 } 457 EXPORT_SYMBOL_GPL(spmi_controller_alloc); 458 459 static void of_spmi_register_devices(struct spmi_controller *ctrl) 460 { 461 struct device_node *node; 462 int err; 463 464 if (!ctrl->dev.of_node) 465 return; 466 467 for_each_available_child_of_node(ctrl->dev.of_node, node) { 468 struct spmi_device *sdev; 469 u32 reg[2]; 470 471 dev_dbg(&ctrl->dev, "adding child %pOF\n", node); 472 473 err = of_property_read_u32_array(node, "reg", reg, 2); 474 if (err) { 475 dev_err(&ctrl->dev, 476 "node %pOF err (%d) does not have 'reg' property\n", 477 node, err); 478 continue; 479 } 480 481 if (reg[1] != SPMI_USID) { 482 dev_err(&ctrl->dev, 483 "node %pOF contains unsupported 'reg' entry\n", 484 node); 485 continue; 486 } 487 488 if (reg[0] >= SPMI_MAX_SLAVE_ID) { 489 dev_err(&ctrl->dev, "invalid usid on node %pOF\n", node); 490 continue; 491 } 492 493 dev_dbg(&ctrl->dev, "read usid %02x\n", reg[0]); 494 495 sdev = spmi_device_alloc(ctrl); 496 if (!sdev) 497 continue; 498 499 sdev->dev.of_node = node; 500 sdev->usid = (u8)reg[0]; 501 502 err = spmi_device_add(sdev); 503 if (err) { 504 dev_err(&sdev->dev, 505 "failure adding device. status %d\n", err); 506 spmi_device_put(sdev); 507 } 508 } 509 } 510 511 /** 512 * spmi_controller_add() - Add an SPMI controller 513 * @ctrl: controller to be registered. 514 * 515 * Register a controller previously allocated via spmi_controller_alloc() with 516 * the SPMI core. 517 */ 518 int spmi_controller_add(struct spmi_controller *ctrl) 519 { 520 int ret; 521 522 /* Can't register until after driver model init */ 523 if (WARN_ON(!is_registered)) 524 return -EAGAIN; 525 526 ret = device_add(&ctrl->dev); 527 if (ret) 528 return ret; 529 530 if (IS_ENABLED(CONFIG_OF)) 531 of_spmi_register_devices(ctrl); 532 533 dev_dbg(&ctrl->dev, "spmi-%d registered: dev:%p\n", 534 ctrl->nr, &ctrl->dev); 535 536 return 0; 537 }; 538 EXPORT_SYMBOL_GPL(spmi_controller_add); 539 540 /* Remove a device associated with a controller */ 541 static int spmi_ctrl_remove_device(struct device *dev, void *data) 542 { 543 struct spmi_device *spmidev = to_spmi_device(dev); 544 545 if (dev->type == &spmi_dev_type) 546 spmi_device_remove(spmidev); 547 return 0; 548 } 549 550 /** 551 * spmi_controller_remove(): remove an SPMI controller 552 * @ctrl: controller to remove 553 * 554 * Remove a SPMI controller. Caller is responsible for calling 555 * spmi_controller_put() to discard the allocated controller. 556 */ 557 void spmi_controller_remove(struct spmi_controller *ctrl) 558 { 559 if (!ctrl) 560 return; 561 562 device_for_each_child(&ctrl->dev, NULL, spmi_ctrl_remove_device); 563 device_del(&ctrl->dev); 564 } 565 EXPORT_SYMBOL_GPL(spmi_controller_remove); 566 567 /** 568 * spmi_driver_register() - Register client driver with SPMI core 569 * @sdrv: client driver to be associated with client-device. 570 * 571 * This API will register the client driver with the SPMI framework. 572 * It is typically called from the driver's module-init function. 573 */ 574 int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner) 575 { 576 sdrv->driver.bus = &spmi_bus_type; 577 sdrv->driver.owner = owner; 578 return driver_register(&sdrv->driver); 579 } 580 EXPORT_SYMBOL_GPL(__spmi_driver_register); 581 582 static void __exit spmi_exit(void) 583 { 584 bus_unregister(&spmi_bus_type); 585 } 586 module_exit(spmi_exit); 587 588 static int __init spmi_init(void) 589 { 590 int ret; 591 592 ret = bus_register(&spmi_bus_type); 593 if (ret) 594 return ret; 595 596 is_registered = true; 597 return 0; 598 } 599 postcore_initcall(spmi_init); 600 601 MODULE_LICENSE("GPL v2"); 602 MODULE_DESCRIPTION("SPMI module"); 603 MODULE_ALIAS("platform:spmi"); 604