drivers/spmi/spmi.c

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