drivers/spmi/spmi.c

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