Lines Matching +full:ctrl +full:- +full:module
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2011-2017, The Linux Foundation
22 while (id->manf_id != 0 || id->prod_code != 0) {
23 if (id->manf_id == sbdev->e_addr.manf_id &&
24 id->prod_code == sbdev->e_addr.prod_code &&
25 id->dev_index == sbdev->e_addr.dev_index &&
26 id->instance == sbdev->e_addr.instance)
42 return !!slim_match(sbdrv->id_table, sbdev);
50 if (sbdev->status == status)
53 sbdev->status = status;
54 if (!sbdev->dev.driver)
57 sbdrv = to_slim_driver(sbdev->dev.driver);
58 if (sbdrv->device_status)
59 sbdrv->device_status(sbdev, sbdev->status);
65 struct slim_driver *sbdrv = to_slim_driver(dev->driver);
68 ret = sbdrv->probe(sbdev);
77 dev_err(&sbdev->dev, "Failed to get logical address\n");
78 ret = -EPROBE_DEFER;
89 if (dev->driver) {
90 sbdrv = to_slim_driver(dev->driver);
91 if (sbdrv->remove)
92 sbdrv->remove(sbdev);
100 return add_uevent_var(env, "MODALIAS=slim:%s", dev_name(&sbdev->dev));
113 * __slim_driver_register() - Client driver registration with SLIMbus
115 * @drv:Client driver to be associated with client-device.
116 * @owner: owning module/driver
119 * It is called from the driver's module-init function.
121 int __slim_driver_register(struct slim_driver *drv, struct module *owner)
124 if (!(drv->driver.of_match_table || drv->id_table) || !drv->probe)
125 return -EINVAL;
127 drv->driver.bus = &slimbus_bus;
128 drv->driver.owner = owner;
130 return driver_register(&drv->driver);
135 * slim_driver_unregister() - Undo effect of slim_driver_register
141 driver_unregister(&drv->driver);
152 static int slim_add_device(struct slim_controller *ctrl,
156 sbdev->dev.bus = &slimbus_bus;
157 sbdev->dev.parent = ctrl->dev;
158 sbdev->dev.release = slim_dev_release;
159 sbdev->dev.driver = NULL;
160 sbdev->ctrl = ctrl;
161 INIT_LIST_HEAD(&sbdev->stream_list);
162 spin_lock_init(&sbdev->stream_list_lock);
163 sbdev->dev.of_node = of_node_get(node);
164 sbdev->dev.fwnode = of_fwnode_handle(node);
166 dev_set_name(&sbdev->dev, "%x:%x:%x:%x",
167 sbdev->e_addr.manf_id,
168 sbdev->e_addr.prod_code,
169 sbdev->e_addr.dev_index,
170 sbdev->e_addr.instance);
172 return device_register(&sbdev->dev);
175 static struct slim_device *slim_alloc_device(struct slim_controller *ctrl,
186 sbdev->e_addr = *eaddr;
187 ret = slim_add_device(ctrl, sbdev, node);
189 put_device(&sbdev->dev);
196 static void of_register_slim_devices(struct slim_controller *ctrl)
198 struct device *dev = ctrl->dev;
201 if (!ctrl->dev->of_node)
204 for_each_child_of_node(ctrl->dev->of_node, node) {
234 sbdev = slim_alloc_device(ctrl, &e_addr, node);
241 * slim_register_controller() - Controller bring-up and registration.
243 * @ctrl: Controller to be registered.
249 int slim_register_controller(struct slim_controller *ctrl)
257 ctrl->id = id;
259 if (!ctrl->min_cg)
260 ctrl->min_cg = SLIM_MIN_CLK_GEAR;
261 if (!ctrl->max_cg)
262 ctrl->max_cg = SLIM_MAX_CLK_GEAR;
264 ida_init(&ctrl->laddr_ida);
265 idr_init(&ctrl->tid_idr);
266 mutex_init(&ctrl->lock);
267 mutex_init(&ctrl->sched.m_reconf);
268 init_completion(&ctrl->sched.pause_comp);
269 spin_lock_init(&ctrl->txn_lock);
271 dev_dbg(ctrl->dev, "Bus [%s] registered:dev:%p\n",
272 ctrl->name, ctrl->dev);
274 of_register_slim_devices(ctrl);
283 of_node_put(sbdev->dev.of_node);
284 device_unregister(&sbdev->dev);
294 * slim_unregister_controller() - Controller tear-down.
296 * @ctrl: Controller to tear-down.
298 int slim_unregister_controller(struct slim_controller *ctrl)
301 device_for_each_child(ctrl->dev, NULL, slim_ctrl_remove_device);
302 ida_free(&ctrl_ida, ctrl->id);
309 * slim_report_absent() - Controller calls this function when a device
316 struct slim_controller *ctrl = sbdev->ctrl;
318 if (!ctrl)
322 mutex_lock(&ctrl->lock);
323 sbdev->is_laddr_valid = false;
324 mutex_unlock(&ctrl->lock);
325 if (!ctrl->get_laddr)
326 ida_free(&ctrl->laddr_ida, sbdev->laddr);
334 return (a->manf_id == b->manf_id &&
335 a->prod_code == b->prod_code &&
336 a->dev_index == b->dev_index &&
337 a->instance == b->instance);
345 return slim_eaddr_equal(&sbdev->e_addr, e_addr);
348 static struct slim_device *find_slim_device(struct slim_controller *ctrl,
354 dev = device_find_child(ctrl->dev, eaddr, slim_match_dev);
364 * slim_get_device() - get handle to a device.
366 * @ctrl: Controller on which this device will be added/queried
372 struct slim_device *slim_get_device(struct slim_controller *ctrl,
377 sbdev = find_slim_device(ctrl, e_addr);
379 sbdev = slim_alloc_device(ctrl, e_addr, NULL);
381 return ERR_PTR(-ENOMEM);
388 static struct slim_device *of_find_slim_device(struct slim_controller *ctrl,
394 dev = device_find_child(ctrl->dev, np, device_match_of_node);
404 * of_slim_get_device() - get handle to a device using dt node.
406 * @ctrl: Controller on which this device will be added/queried
412 struct slim_device *of_slim_get_device(struct slim_controller *ctrl,
415 return of_find_slim_device(ctrl, np);
422 struct slim_controller *ctrl = sbdev->ctrl;
426 mutex_lock(&ctrl->lock);
427 if (ctrl->get_laddr) {
428 ret = ctrl->get_laddr(ctrl, &sbdev->e_addr, &laddr);
432 ret = ida_alloc_max(&ctrl->laddr_ida,
433 SLIM_LA_MANAGER - 1, GFP_KERNEL);
439 ret = -EINVAL;
443 if (ctrl->set_laddr) {
444 ret = ctrl->set_laddr(ctrl, &sbdev->e_addr, laddr);
446 ret = -EINVAL;
451 sbdev->laddr = laddr;
452 sbdev->is_laddr_valid = true;
453 mutex_unlock(&ctrl->lock);
457 dev_dbg(ctrl->dev, "setting slimbus l-addr:%x, ea:%x,%x,%x,%x\n",
458 laddr, sbdev->e_addr.manf_id, sbdev->e_addr.prod_code,
459 sbdev->e_addr.dev_index, sbdev->e_addr.instance);
464 mutex_unlock(&ctrl->lock);
470 * slim_device_report_present() - Report enumerated device.
472 * @ctrl: Controller with which device is enumerated.
478 * Function returns -EXFULL to indicate that all logical addresses are already
481 int slim_device_report_present(struct slim_controller *ctrl,
487 ret = pm_runtime_get_sync(ctrl->dev);
489 if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {
490 dev_err(ctrl->dev, "slim ctrl not active,state:%d, ret:%d\n",
491 ctrl->sched.clk_state, ret);
495 sbdev = slim_get_device(ctrl, e_addr);
497 return -ENODEV;
499 if (sbdev->is_laddr_valid) {
500 *laddr = sbdev->laddr;
507 pm_runtime_mark_last_busy(ctrl->dev);
508 pm_runtime_put_autosuspend(ctrl->dev);
514 * slim_get_logical_addr() - get/allocate logical address of a SLIMbus device.
523 if (!sbdev->is_laddr_valid)