drivers/slimbus/core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2011-2017, The Linux Foundation
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/errno.h>
   8 #include <linux/slab.h>
   9 #include <linux/init.h>
  10 #include <linux/idr.h>
  11 #include <linux/of.h>
  12 #include <linux/of_device.h>
  13 #include <linux/pm_runtime.h>
  14 #include <linux/slimbus.h>
  15 #include "slimbus.h"
  16
  17 static DEFINE_IDA(ctrl_ida);
  18
  19 static const struct slim_device_id *slim_match(const struct slim_device_id *id,
  20                                                const struct slim_device *sbdev)
  21 {
  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)
  27                         return id;
  28                 id++;
  29         }
  30         return NULL;
  31 }
  32
  33 static int slim_device_match(struct device *dev, struct device_driver *drv)
  34 {
  35         struct slim_device *sbdev = to_slim_device(dev);
  36         struct slim_driver *sbdrv = to_slim_driver(drv);
  37
  38         /* Attempt an OF style match first */
  39         if (of_driver_match_device(dev, drv))
  40                 return 1;
  41
  42         return !!slim_match(sbdrv->id_table, sbdev);
  43 }
  44
  45 static void slim_device_update_status(struct slim_device *sbdev,
  46                                       enum slim_device_status status)
  47 {
  48         struct slim_driver *sbdrv;
  49
  50         if (sbdev->status == status)
  51                 return;
  52
  53         sbdev->status = status;
  54         if (!sbdev->dev.driver)
  55                 return;
  56
  57         sbdrv = to_slim_driver(sbdev->dev.driver);
  58         if (sbdrv->device_status)
  59                 sbdrv->device_status(sbdev, sbdev->status);
  60 }
  61
  62 static int slim_device_probe(struct device *dev)
  63 {
  64         struct slim_device      *sbdev = to_slim_device(dev);
  65         struct slim_driver      *sbdrv = to_slim_driver(dev->driver);
  66         int ret;
  67
  68         ret = sbdrv->probe(sbdev);
  69         if (ret)
  70                 return ret;
  71
  72         /* try getting the logical address after probe */
  73         ret = slim_get_logical_addr(sbdev);
  74         if (!ret) {
  75                 slim_device_update_status(sbdev, SLIM_DEVICE_STATUS_UP);
  76         } else {
  77                 dev_err(&sbdev->dev, "Failed to get logical address\n");
  78                 ret = -EPROBE_DEFER;
  79         }
  80
  81         return ret;
  82 }
  83
  84 static int slim_device_remove(struct device *dev)
  85 {
  86         struct slim_device *sbdev = to_slim_device(dev);
  87         struct slim_driver *sbdrv;
  88
  89         if (dev->driver) {
  90                 sbdrv = to_slim_driver(dev->driver);
  91                 if (sbdrv->remove)
  92                         sbdrv->remove(sbdev);
  93         }
  94
  95         return 0;
  96 }
  97
  98 static int slim_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  99 {
 100         struct slim_device *sbdev = to_slim_device(dev);
 101         int ret;
 102
 103         ret = of_device_uevent_modalias(dev, env);
 104         if (ret != -ENODEV)
 105                 return ret;
 106
 107         return add_uevent_var(env, "MODALIAS=slim:%s", dev_name(&sbdev->dev));
 108 }
 109
 110 struct bus_type slimbus_bus = {
 111         .name           = "slimbus",
 112         .match          = slim_device_match,
 113         .probe          = slim_device_probe,
 114         .remove         = slim_device_remove,
 115         .uevent         = slim_device_uevent,
 116 };
 117 EXPORT_SYMBOL_GPL(slimbus_bus);
 118
 119 /*
 120  * __slim_driver_register() - Client driver registration with SLIMbus
 121  *
 122  * @drv:Client driver to be associated with client-device.
 123  * @owner: owning module/driver
 124  *
 125  * This API will register the client driver with the SLIMbus
 126  * It is called from the driver's module-init function.
 127  */
 128 int __slim_driver_register(struct slim_driver *drv, struct module *owner)
 129 {
 130         /* ID table and probe are mandatory */
 131         if (!(drv->driver.of_match_table || drv->id_table) || !drv->probe)
 132                 return -EINVAL;
 133
 134         drv->driver.bus = &slimbus_bus;
 135         drv->driver.owner = owner;
 136
 137         return driver_register(&drv->driver);
 138 }
 139 EXPORT_SYMBOL_GPL(__slim_driver_register);
 140
 141 /*
 142  * slim_driver_unregister() - Undo effect of slim_driver_register
 143  *
 144  * @drv: Client driver to be unregistered
 145  */
 146 void slim_driver_unregister(struct slim_driver *drv)
 147 {
 148         driver_unregister(&drv->driver);
 149 }
 150 EXPORT_SYMBOL_GPL(slim_driver_unregister);
 151
 152 static void slim_dev_release(struct device *dev)
 153 {
 154         struct slim_device *sbdev = to_slim_device(dev);
 155
 156         kfree(sbdev);
 157 }
 158
 159 static int slim_add_device(struct slim_controller *ctrl,
 160                            struct slim_device *sbdev,
 161                            struct device_node *node)
 162 {
 163         sbdev->dev.bus = &slimbus_bus;
 164         sbdev->dev.parent = ctrl->dev;
 165         sbdev->dev.release = slim_dev_release;
 166         sbdev->dev.driver = NULL;
 167         sbdev->ctrl = ctrl;
 168         INIT_LIST_HEAD(&sbdev->stream_list);
 169         spin_lock_init(&sbdev->stream_list_lock);
 170
 171         if (node)
 172                 sbdev->dev.of_node = of_node_get(node);
 173
 174         dev_set_name(&sbdev->dev, "%x:%x:%x:%x",
 175                                   sbdev->e_addr.manf_id,
 176                                   sbdev->e_addr.prod_code,
 177                                   sbdev->e_addr.dev_index,
 178                                   sbdev->e_addr.instance);
 179
 180         return device_register(&sbdev->dev);
 181 }
 182
 183 static struct slim_device *slim_alloc_device(struct slim_controller *ctrl,
 184                                              struct slim_eaddr *eaddr,
 185                                              struct device_node *node)
 186 {
 187         struct slim_device *sbdev;
 188         int ret;
 189
 190         sbdev = kzalloc(sizeof(*sbdev), GFP_KERNEL);
 191         if (!sbdev)
 192                 return NULL;
 193
 194         sbdev->e_addr = *eaddr;
 195         ret = slim_add_device(ctrl, sbdev, node);
 196         if (ret) {
 197                 put_device(&sbdev->dev);
 198                 return NULL;
 199         }
 200
 201         return sbdev;
 202 }
 203
 204 static void of_register_slim_devices(struct slim_controller *ctrl)
 205 {
 206         struct device *dev = ctrl->dev;
 207         struct device_node *node;
 208
 209         if (!ctrl->dev->of_node)
 210                 return;
 211
 212         for_each_child_of_node(ctrl->dev->of_node, node) {
 213                 struct slim_device *sbdev;
 214                 struct slim_eaddr e_addr;
 215                 const char *compat = NULL;
 216                 int reg[2], ret;
 217                 int manf_id, prod_code;
 218
 219                 compat = of_get_property(node, "compatible", NULL);
 220                 if (!compat)
 221                         continue;
 222
 223                 ret = sscanf(compat, "slim%x,%x", &manf_id, &prod_code);
 224                 if (ret != 2) {
 225                         dev_err(dev, "Manf ID & Product code not found %s\n",
 226                                 compat);
 227                         continue;
 228                 }
 229
 230                 ret = of_property_read_u32_array(node, "reg", reg, 2);
 231                 if (ret) {
 232                         dev_err(dev, "Device and Instance id not found:%d\n",
 233                                 ret);
 234                         continue;
 235                 }
 236
 237                 e_addr.dev_index = reg[0];
 238                 e_addr.instance = reg[1];
 239                 e_addr.manf_id = manf_id;
 240                 e_addr.prod_code = prod_code;
 241
 242                 sbdev = slim_alloc_device(ctrl, &e_addr, node);
 243                 if (!sbdev)
 244                         continue;
 245         }
 246 }
 247
 248 /*
 249  * slim_register_controller() - Controller bring-up and registration.
 250  *
 251  * @ctrl: Controller to be registered.
 252  *
 253  * A controller is registered with the framework using this API.
 254  * If devices on a controller were registered before controller,
 255  * this will make sure that they get probed when controller is up
 256  */
 257 int slim_register_controller(struct slim_controller *ctrl)
 258 {
 259         int id;
 260
 261         id = ida_simple_get(&ctrl_ida, 0, 0, GFP_KERNEL);
 262         if (id < 0)
 263                 return id;
 264
 265         ctrl->id = id;
 266
 267         if (!ctrl->min_cg)
 268                 ctrl->min_cg = SLIM_MIN_CLK_GEAR;
 269         if (!ctrl->max_cg)
 270                 ctrl->max_cg = SLIM_MAX_CLK_GEAR;
 271
 272         ida_init(&ctrl->laddr_ida);
 273         idr_init(&ctrl->tid_idr);
 274         mutex_init(&ctrl->lock);
 275         mutex_init(&ctrl->sched.m_reconf);
 276         init_completion(&ctrl->sched.pause_comp);
 277         spin_lock_init(&ctrl->txn_lock);
 278
 279         dev_dbg(ctrl->dev, "Bus [%s] registered:dev:%p\n",
 280                 ctrl->name, ctrl->dev);
 281
 282         of_register_slim_devices(ctrl);
 283
 284         return 0;
 285 }
 286 EXPORT_SYMBOL_GPL(slim_register_controller);
 287
 288 /* slim_remove_device: Remove the effect of slim_add_device() */
 289 static void slim_remove_device(struct slim_device *sbdev)
 290 {
 291         device_unregister(&sbdev->dev);
 292 }
 293
 294 static int slim_ctrl_remove_device(struct device *dev, void *null)
 295 {
 296         slim_remove_device(to_slim_device(dev));
 297         return 0;
 298 }
 299
 300 /**
 301  * slim_unregister_controller() - Controller tear-down.
 302  *
 303  * @ctrl: Controller to tear-down.
 304  */
 305 int slim_unregister_controller(struct slim_controller *ctrl)
 306 {
 307         /* Remove all clients */
 308         device_for_each_child(ctrl->dev, NULL, slim_ctrl_remove_device);
 309         /* Enter Clock Pause */
 310         slim_ctrl_clk_pause(ctrl, false, 0);
 311         ida_simple_remove(&ctrl_ida, ctrl->id);
 312
 313         return 0;
 314 }
 315 EXPORT_SYMBOL_GPL(slim_unregister_controller);
 316
 317 /**
 318  * slim_report_absent() - Controller calls this function when a device
 319  *      reports absent, OR when the device cannot be communicated with
 320  *
 321  * @sbdev: Device that cannot be reached, or sent report absent
 322  */
 323 void slim_report_absent(struct slim_device *sbdev)
 324 {
 325         struct slim_controller *ctrl = sbdev->ctrl;
 326
 327         if (!ctrl)
 328                 return;
 329
 330         /* invalidate logical addresses */
 331         mutex_lock(&ctrl->lock);
 332         sbdev->is_laddr_valid = false;
 333         mutex_unlock(&ctrl->lock);
 334
 335         ida_simple_remove(&ctrl->laddr_ida, sbdev->laddr);
 336         slim_device_update_status(sbdev, SLIM_DEVICE_STATUS_DOWN);
 337 }
 338 EXPORT_SYMBOL_GPL(slim_report_absent);
 339
 340 static bool slim_eaddr_equal(struct slim_eaddr *a, struct slim_eaddr *b)
 341 {
 342         return (a->manf_id == b->manf_id &&
 343                 a->prod_code == b->prod_code &&
 344                 a->dev_index == b->dev_index &&
 345                 a->instance == b->instance);
 346 }
 347
 348 static int slim_match_dev(struct device *dev, void *data)
 349 {
 350         struct slim_eaddr *e_addr = data;
 351         struct slim_device *sbdev = to_slim_device(dev);
 352
 353         return slim_eaddr_equal(&sbdev->e_addr, e_addr);
 354 }
 355
 356 static struct slim_device *find_slim_device(struct slim_controller *ctrl,
 357                                             struct slim_eaddr *eaddr)
 358 {
 359         struct slim_device *sbdev;
 360         struct device *dev;
 361
 362         dev = device_find_child(ctrl->dev, eaddr, slim_match_dev);
 363         if (dev) {
 364                 sbdev = to_slim_device(dev);
 365                 return sbdev;
 366         }
 367
 368         return NULL;
 369 }
 370
 371 /**
 372  * slim_get_device() - get handle to a device.
 373  *
 374  * @ctrl: Controller on which this device will be added/queried
 375  * @e_addr: Enumeration address of the device to be queried
 376  *
 377  * Return: pointer to a device if it has already reported. Creates a new
 378  * device and returns pointer to it if the device has not yet enumerated.
 379  */
 380 struct slim_device *slim_get_device(struct slim_controller *ctrl,
 381                                     struct slim_eaddr *e_addr)
 382 {
 383         struct slim_device *sbdev;
 384
 385         sbdev = find_slim_device(ctrl, e_addr);
 386         if (!sbdev) {
 387                 sbdev = slim_alloc_device(ctrl, e_addr, NULL);
 388                 if (!sbdev)
 389                         return ERR_PTR(-ENOMEM);
 390         }
 391
 392         return sbdev;
 393 }
 394 EXPORT_SYMBOL_GPL(slim_get_device);
 395
 396 static int of_slim_match_dev(struct device *dev, void *data)
 397 {
 398         struct device_node *np = data;
 399         struct slim_device *sbdev = to_slim_device(dev);
 400
 401         return (sbdev->dev.of_node == np);
 402 }
 403
 404 static struct slim_device *of_find_slim_device(struct slim_controller *ctrl,
 405                                                struct device_node *np)
 406 {
 407         struct slim_device *sbdev;
 408         struct device *dev;
 409
 410         dev = device_find_child(ctrl->dev, np, of_slim_match_dev);
 411         if (dev) {
 412                 sbdev = to_slim_device(dev);
 413                 return sbdev;
 414         }
 415
 416         return NULL;
 417 }
 418
 419 /**
 420  * of_slim_get_device() - get handle to a device using dt node.
 421  *
 422  * @ctrl: Controller on which this device will be added/queried
 423  * @np: node pointer to device
 424  *
 425  * Return: pointer to a device if it has already reported. Creates a new
 426  * device and returns pointer to it if the device has not yet enumerated.
 427  */
 428 struct slim_device *of_slim_get_device(struct slim_controller *ctrl,
 429                                        struct device_node *np)
 430 {
 431         return of_find_slim_device(ctrl, np);
 432 }
 433 EXPORT_SYMBOL_GPL(of_slim_get_device);
 434
 435 static int slim_device_alloc_laddr(struct slim_device *sbdev,
 436                                    bool report_present)
 437 {
 438         struct slim_controller *ctrl = sbdev->ctrl;
 439         u8 laddr;
 440         int ret;
 441
 442         mutex_lock(&ctrl->lock);
 443         if (ctrl->get_laddr) {
 444                 ret = ctrl->get_laddr(ctrl, &sbdev->e_addr, &laddr);
 445                 if (ret < 0)
 446                         goto err;
 447         } else if (report_present) {
 448                 ret = ida_simple_get(&ctrl->laddr_ida,
 449                                      0, SLIM_LA_MANAGER - 1, GFP_KERNEL);
 450                 if (ret < 0)
 451                         goto err;
 452
 453                 laddr = ret;
 454         } else {
 455                 ret = -EINVAL;
 456                 goto err;
 457         }
 458
 459         if (ctrl->set_laddr) {
 460                 ret = ctrl->set_laddr(ctrl, &sbdev->e_addr, laddr);
 461                 if (ret) {
 462                         ret = -EINVAL;
 463                         goto err;
 464                 }
 465         }
 466
 467         sbdev->laddr = laddr;
 468         sbdev->is_laddr_valid = true;
 469         mutex_unlock(&ctrl->lock);
 470
 471         slim_device_update_status(sbdev, SLIM_DEVICE_STATUS_UP);
 472
 473         dev_dbg(ctrl->dev, "setting slimbus l-addr:%x, ea:%x,%x,%x,%x\n",
 474                 laddr, sbdev->e_addr.manf_id, sbdev->e_addr.prod_code,
 475                 sbdev->e_addr.dev_index, sbdev->e_addr.instance);
 476
 477         return 0;
 478
 479 err:
 480         mutex_unlock(&ctrl->lock);
 481         return ret;
 482
 483 }
 484
 485 /**
 486  * slim_device_report_present() - Report enumerated device.
 487  *
 488  * @ctrl: Controller with which device is enumerated.
 489  * @e_addr: Enumeration address of the device.
 490  * @laddr: Return logical address (if valid flag is false)
 491  *
 492  * Called by controller in response to REPORT_PRESENT. Framework will assign
 493  * a logical address to this enumeration address.
 494  * Function returns -EXFULL to indicate that all logical addresses are already
 495  * taken.
 496  */
 497 int slim_device_report_present(struct slim_controller *ctrl,
 498                                struct slim_eaddr *e_addr, u8 *laddr)
 499 {
 500         struct slim_device *sbdev;
 501         int ret;
 502
 503         ret = pm_runtime_get_sync(ctrl->dev);
 504
 505         if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {
 506                 dev_err(ctrl->dev, "slim ctrl not active,state:%d, ret:%d\n",
 507                                     ctrl->sched.clk_state, ret);
 508                 goto slimbus_not_active;
 509         }
 510
 511         sbdev = slim_get_device(ctrl, e_addr);
 512         if (IS_ERR(sbdev))
 513                 return -ENODEV;
 514
 515         if (sbdev->is_laddr_valid) {
 516                 *laddr = sbdev->laddr;
 517                 return 0;
 518         }
 519
 520         ret = slim_device_alloc_laddr(sbdev, true);
 521
 522 slimbus_not_active:
 523         pm_runtime_mark_last_busy(ctrl->dev);
 524         pm_runtime_put_autosuspend(ctrl->dev);
 525         return ret;
 526 }
 527 EXPORT_SYMBOL_GPL(slim_device_report_present);
 528
 529 /**
 530  * slim_get_logical_addr() - get/allocate logical address of a SLIMbus device.
 531  *
 532  * @sbdev: client handle requesting the address.
 533  *
 534  * Return: zero if a logical address is valid or a new logical address
 535  * has been assigned. error code in case of error.
 536  */
 537 int slim_get_logical_addr(struct slim_device *sbdev)
 538 {
 539         if (!sbdev->is_laddr_valid)
 540                 return slim_device_alloc_laddr(sbdev, false);
 541
 542         return 0;
 543 }
 544 EXPORT_SYMBOL_GPL(slim_get_logical_addr);
 545
 546 static void __exit slimbus_exit(void)
 547 {
 548         bus_unregister(&slimbus_bus);
 549 }
 550 module_exit(slimbus_exit);
 551
 552 static int __init slimbus_init(void)
 553 {
 554         return bus_register(&slimbus_bus);
 555 }
 556 postcore_initcall(slimbus_init);
 557
 558 MODULE_LICENSE("GPL v2");
 559 MODULE_DESCRIPTION("SLIMbus core");