Lines Matching +full:ctrl +full:- +full:module
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
9 #include <linux/module.h>
16 #include <dt-bindings/spmi/spmi.h>
36 struct spmi_controller *ctrl = to_spmi_controller(dev);
38 ida_free(&ctrl_ida, ctrl->nr);
39 kfree(ctrl);
51 if (drv->name)
52 return strncmp(dev_name(dev), drv->name,
59 * spmi_device_add() - add a device previously constructed via spmi_device_alloc()
64 struct spmi_controller *ctrl = sdev->ctrl;
67 dev_set_name(&sdev->dev, "%d-%02x", ctrl->nr, sdev->usid);
69 err = device_add(&sdev->dev);
71 dev_err(&sdev->dev, "Can't add %s, status %d\n",
72 dev_name(&sdev->dev), err);
76 dev_dbg(&sdev->dev, "device %s registered\n", dev_name(&sdev->dev));
89 device_unregister(&sdev->dev);
94 spmi_cmd(struct spmi_controller *ctrl, u8 opcode, u8 sid)
98 if (!ctrl || !ctrl->cmd || ctrl->dev.type != &spmi_ctrl_type)
99 return -EINVAL;
101 ret = ctrl->cmd(ctrl, opcode, sid);
106 static inline int spmi_read_cmd(struct spmi_controller *ctrl, u8 opcode,
111 if (!ctrl || !ctrl->read_cmd || ctrl->dev.type != &spmi_ctrl_type)
112 return -EINVAL;
115 ret = ctrl->read_cmd(ctrl, opcode, sid, addr, buf, len);
120 static inline int spmi_write_cmd(struct spmi_controller *ctrl, u8 opcode,
125 if (!ctrl || !ctrl->write_cmd || ctrl->dev.type != &spmi_ctrl_type)
126 return -EINVAL;
129 ret = ctrl->write_cmd(ctrl, opcode, sid, addr, buf, len);
135 * spmi_register_read() - register read
137 * @addr: slave register address (5-bit address).
144 /* 5-bit register address */
146 return -EINVAL;
148 return spmi_read_cmd(sdev->ctrl, SPMI_CMD_READ, sdev->usid, addr,
154 * spmi_ext_register_read() - extended register read
156 * @addr: slave register address (8-bit address).
166 /* 8-bit register address, up to 16 bytes */
168 return -EINVAL;
170 return spmi_read_cmd(sdev->ctrl, SPMI_CMD_EXT_READ, sdev->usid, addr,
176 * spmi_ext_register_readl() - extended register read long
178 * @addr: slave register address (16-bit address).
183 * Slave device using 16-bit address.
188 /* 16-bit register address, up to 8 bytes */
190 return -EINVAL;
192 return spmi_read_cmd(sdev->ctrl, SPMI_CMD_EXT_READL, sdev->usid, addr,
198 * spmi_register_write() - register write
200 * @addr: slave register address (5-bit address).
207 /* 5-bit register address */
209 return -EINVAL;
211 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_WRITE, sdev->usid, addr,
217 * spmi_register_zero_write() - register zero write
219 * @data: the data to be written to register 0 (7-bits).
225 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_ZERO_WRITE, sdev->usid, 0,
231 * spmi_ext_register_write() - extended register write
233 * @addr: slave register address (8-bit address).
243 /* 8-bit register address, up to 16 bytes */
245 return -EINVAL;
247 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_EXT_WRITE, sdev->usid, addr,
253 * spmi_ext_register_writel() - extended register write long
255 * @addr: slave register address (16-bit address).
260 * Slave device using 16-bit address.
265 /* 4-bit Slave Identifier, 16-bit register address, up to 8 bytes */
267 return -EINVAL;
269 return spmi_write_cmd(sdev->ctrl, SPMI_CMD_EXT_WRITEL, sdev->usid,
275 * spmi_command_reset() - sends RESET command to the specified slave
284 return spmi_cmd(sdev->ctrl, SPMI_CMD_RESET, sdev->usid);
289 * spmi_command_sleep() - sends SLEEP command to the specified SPMI device
296 return spmi_cmd(sdev->ctrl, SPMI_CMD_SLEEP, sdev->usid);
301 * spmi_command_wakeup() - sends WAKEUP command to the specified SPMI device
309 return spmi_cmd(sdev->ctrl, SPMI_CMD_WAKEUP, sdev->usid);
314 * spmi_command_shutdown() - sends SHUTDOWN command to the specified SPMI device
321 return spmi_cmd(sdev->ctrl, SPMI_CMD_SHUTDOWN, sdev->usid);
327 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver);
335 err = sdrv->probe(sdev);
350 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver);
353 if (sdrv->remove)
354 sdrv->remove(to_spmi_device(dev));
364 const struct spmi_driver *sdrv = to_spmi_driver(dev->driver);
366 if (sdrv && sdrv->shutdown)
367 sdrv->shutdown(to_spmi_device(dev));
375 if (ret != -ENODEV)
391 * spmi_find_device_by_of_node() - look up an SPMI device from a device node
411 * spmi_device_alloc() - Allocate a new SPMI device
412 * @ctrl: associated controller
417 struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl)
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;
435 * spmi_controller_alloc() - Allocate a new SPMI controller
447 struct spmi_controller *ctrl;
451 return ERR_PTR(-EINVAL);
453 ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL);
454 if (!ctrl)
455 return ERR_PTR(-ENOMEM);
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]);
468 spmi_controller_put(ctrl);
472 ctrl->nr = id;
473 dev_set_name(&ctrl->dev, "spmi-%d", id);
475 dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id);
476 return ctrl;
480 static void of_spmi_register_devices(struct spmi_controller *ctrl)
485 if (!ctrl->dev.of_node)
488 for_each_available_child_of_node(ctrl->dev.of_node, node) {
492 dev_dbg(&ctrl->dev, "adding child %pOF\n", node);
496 dev_err(&ctrl->dev,
503 dev_err(&ctrl->dev,
510 dev_err(&ctrl->dev, "invalid usid on node %pOF\n", node);
514 dev_dbg(&ctrl->dev, "read usid %02x\n", reg[0]);
516 sdev = spmi_device_alloc(ctrl);
520 device_set_node(&sdev->dev, of_fwnode_handle(node));
521 sdev->usid = (u8)reg[0];
525 dev_err(&sdev->dev,
533 * spmi_controller_add() - Add an SPMI controller
534 * @ctrl: controller to be registered.
539 int spmi_controller_add(struct spmi_controller *ctrl)
545 return -EAGAIN;
547 ret = device_add(&ctrl->dev);
552 of_spmi_register_devices(ctrl);
554 dev_dbg(&ctrl->dev, "spmi-%d registered: dev:%p\n",
555 ctrl->nr, &ctrl->dev);
566 if (dev->type == &spmi_dev_type)
573 * @ctrl: controller to remove
578 void spmi_controller_remove(struct spmi_controller *ctrl)
580 if (!ctrl)
583 device_for_each_child(&ctrl->dev, NULL, spmi_ctrl_remove_device);
584 device_del(&ctrl->dev);
589 * __spmi_driver_register() - Register client driver with SPMI core
590 * @sdrv: client driver to be associated with client-device.
591 * @owner: module owner
594 * It is typically called from the driver's module-init function.
596 int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner)
598 sdrv->driver.bus = &spmi_bus_type;
599 sdrv->driver.owner = owner;
600 return driver_register(&sdrv->driver);
624 MODULE_DESCRIPTION("SPMI module");