drivers/gpu/drm/drm_dp_aux_bus.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2021 Google Inc.
   4  *
   5  * The DP AUX bus is used for devices that are connected over a DisplayPort
   6  * AUX bus. The devices on the far side of the bus are referred to as
   7  * endpoints in this code.
   8  *
   9  * Commonly there is only one device connected to the DP AUX bus: a panel.
  10  * Though historically panels (even DP panels) have been modeled as simple
  11  * platform devices, putting them under the DP AUX bus allows the panel driver
  12  * to perform transactions on that bus.
  13  */
  14
  15 #include <linux/init.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/of_device.h>
  19 #include <linux/pm_domain.h>
  20 #include <linux/pm_runtime.h>
  21
  22 #include <drm/drm_dp_aux_bus.h>
  23 #include <drm/drm_dp_helper.h>
  24
  25 /**
  26  * dp_aux_ep_match() - The match function for the dp_aux_bus.
  27  * @dev: The device to match.
  28  * @drv: The driver to try to match against.
  29  *
  30  * At the moment, we just match on device tree.
  31  *
  32  * Return: True if this driver matches this device; false otherwise.
  33  */
  34 static int dp_aux_ep_match(struct device *dev, struct device_driver *drv)
  35 {
  36         return !!of_match_device(drv->of_match_table, dev);
  37 }
  38
  39 /**
  40  * dp_aux_ep_probe() - The probe function for the dp_aux_bus.
  41  * @dev: The device to probe.
  42  *
  43  * Calls through to the endpoint driver probe.
  44  *
  45  * Return: 0 if no error or negative error code.
  46  */
  47 static int dp_aux_ep_probe(struct device *dev)
  48 {
  49         struct dp_aux_ep_driver *aux_ep_drv = to_dp_aux_ep_drv(dev->driver);
  50         struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(dev);
  51         int ret;
  52
  53         ret = dev_pm_domain_attach(dev, true);
  54         if (ret)
  55                 return dev_err_probe(dev, ret, "Failed to attach to PM Domain\n");
  56
  57         ret = aux_ep_drv->probe(aux_ep);
  58         if (ret)
  59                 dev_pm_domain_detach(dev, true);
  60
  61         return ret;
  62 }
  63
  64 /**
  65  * dp_aux_ep_remove() - The remove function for the dp_aux_bus.
  66  * @dev: The device to remove.
  67  *
  68  * Calls through to the endpoint driver remove.
  69  *
  70  */
  71 static void dp_aux_ep_remove(struct device *dev)
  72 {
  73         struct dp_aux_ep_driver *aux_ep_drv = to_dp_aux_ep_drv(dev->driver);
  74         struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(dev);
  75
  76         if (aux_ep_drv->remove)
  77                 aux_ep_drv->remove(aux_ep);
  78         dev_pm_domain_detach(dev, true);
  79 }
  80
  81 /**
  82  * dp_aux_ep_shutdown() - The shutdown function for the dp_aux_bus.
  83  * @dev: The device to shutdown.
  84  *
  85  * Calls through to the endpoint driver shutdown.
  86  */
  87 static void dp_aux_ep_shutdown(struct device *dev)
  88 {
  89         struct dp_aux_ep_driver *aux_ep_drv;
  90
  91         if (!dev->driver)
  92                 return;
  93
  94         aux_ep_drv = to_dp_aux_ep_drv(dev->driver);
  95         if (aux_ep_drv->shutdown)
  96                 aux_ep_drv->shutdown(to_dp_aux_ep_dev(dev));
  97 }
  98
  99 static struct bus_type dp_aux_bus_type = {
 100         .name           = "dp-aux",
 101         .match          = dp_aux_ep_match,
 102         .probe          = dp_aux_ep_probe,
 103         .remove         = dp_aux_ep_remove,
 104         .shutdown       = dp_aux_ep_shutdown,
 105 };
 106
 107 static ssize_t modalias_show(struct device *dev,
 108                              struct device_attribute *attr, char *buf)
 109 {
 110         return of_device_modalias(dev, buf, PAGE_SIZE);
 111 }
 112 static DEVICE_ATTR_RO(modalias);
 113
 114 static struct attribute *dp_aux_ep_dev_attrs[] = {
 115         &dev_attr_modalias.attr,
 116         NULL,
 117 };
 118 ATTRIBUTE_GROUPS(dp_aux_ep_dev);
 119
 120 /**
 121  * dp_aux_ep_dev_release() - Free memory for the dp_aux_ep device
 122  * @dev: The device to free.
 123  *
 124  * Return: 0 if no error or negative error code.
 125  */
 126 static void dp_aux_ep_dev_release(struct device *dev)
 127 {
 128         kfree(to_dp_aux_ep_dev(dev));
 129 }
 130
 131 static struct device_type dp_aux_device_type_type = {
 132         .groups         = dp_aux_ep_dev_groups,
 133         .uevent         = of_device_uevent_modalias,
 134         .release        = dp_aux_ep_dev_release,
 135 };
 136
 137 /**
 138  * of_dp_aux_ep_destroy() - Destroy an DP AUX endpoint device
 139  * @dev: The device to destroy.
 140  * @data: Not used
 141  *
 142  * This is just used as a callback by of_dp_aux_depopulate_ep_devices() and
 143  * is called for _all_ of the child devices of the device providing the AUX bus.
 144  * We'll only act on those that are of type "dp_aux_bus_type".
 145  *
 146  * This function is effectively an inverse of what's in the loop
 147  * in of_dp_aux_populate_ep_devices().
 148  *
 149  * Return: 0 if no error or negative error code.
 150  */
 151 static int of_dp_aux_ep_destroy(struct device *dev, void *data)
 152 {
 153         struct device_node *np = dev->of_node;
 154
 155         if (dev->bus != &dp_aux_bus_type)
 156                 return 0;
 157
 158         if (!of_node_check_flag(np, OF_POPULATED))
 159                 return 0;
 160
 161         of_node_clear_flag(np, OF_POPULATED);
 162         of_node_put(np);
 163
 164         device_unregister(dev);
 165
 166         return 0;
 167 }
 168
 169 /**
 170  * of_dp_aux_depopulate_ep_devices() - Undo of_dp_aux_populate_ep_devices
 171  * @aux: The AUX channel whose devices we want to depopulate
 172  *
 173  * This will destroy all devices that were created
 174  * by of_dp_aux_populate_ep_devices().
 175  */
 176 void of_dp_aux_depopulate_ep_devices(struct drm_dp_aux *aux)
 177 {
 178         device_for_each_child_reverse(aux->dev, NULL, of_dp_aux_ep_destroy);
 179 }
 180 EXPORT_SYMBOL_GPL(of_dp_aux_depopulate_ep_devices);
 181
 182 /**
 183  * of_dp_aux_populate_ep_devices() - Populate the endpoint devices on the DP AUX
 184  * @aux: The AUX channel whose devices we want to populate. It is required that
 185  *       drm_dp_aux_init() has already been called for this AUX channel.
 186  *
 187  * This will populate all the devices under the "aux-bus" node of the device
 188  * providing the AUX channel (AKA aux->dev).
 189  *
 190  * When this function finishes, it is _possible_ (but not guaranteed) that
 191  * our sub-devices will have finished probing. It should be noted that if our
 192  * sub-devices return -EPROBE_DEFER that we will not return any error codes
 193  * ourselves but our sub-devices will _not_ have actually probed successfully
 194  * yet. There may be other cases (maybe added in the future?) where sub-devices
 195  * won't have been probed yet when this function returns, so it's best not to
 196  * rely on that.
 197  *
 198  * If this function succeeds you should later make sure you call
 199  * of_dp_aux_depopulate_ep_devices() to undo it, or just use the devm version
 200  * of this function.
 201  *
 202  * Return: 0 if no error or negative error code.
 203  */
 204 int of_dp_aux_populate_ep_devices(struct drm_dp_aux *aux)
 205 {
 206         struct device_node *bus, *np;
 207         struct dp_aux_ep_device *aux_ep;
 208         int ret;
 209
 210         /* drm_dp_aux_init() should have been called already; warn if not */
 211         WARN_ON_ONCE(!aux->ddc.algo);
 212
 213         if (!aux->dev->of_node)
 214                 return 0;
 215
 216         bus = of_get_child_by_name(aux->dev->of_node, "aux-bus");
 217         if (!bus)
 218                 return 0;
 219
 220         for_each_available_child_of_node(bus, np) {
 221                 if (of_node_test_and_set_flag(np, OF_POPULATED))
 222                         continue;
 223
 224                 aux_ep = kzalloc(sizeof(*aux_ep), GFP_KERNEL);
 225                 if (!aux_ep)
 226                         continue;
 227                 aux_ep->aux = aux;
 228
 229                 aux_ep->dev.parent = aux->dev;
 230                 aux_ep->dev.bus = &dp_aux_bus_type;
 231                 aux_ep->dev.type = &dp_aux_device_type_type;
 232                 aux_ep->dev.of_node = of_node_get(np);
 233                 dev_set_name(&aux_ep->dev, "aux-%s", dev_name(aux->dev));
 234
 235                 ret = device_register(&aux_ep->dev);
 236                 if (ret) {
 237                         dev_err(aux->dev, "Failed to create AUX EP for %pOF: %d\n", np, ret);
 238                         of_node_clear_flag(np, OF_POPULATED);
 239                         of_node_put(np);
 240
 241                         /*
 242                          * As per docs of device_register(), call this instead
 243                          * of kfree() directly for error cases.
 244                          */
 245                         put_device(&aux_ep->dev);
 246
 247                         /*
 248                          * Following in the footsteps of of_i2c_register_devices(),
 249                          * we won't fail the whole function here--we'll just
 250                          * continue registering any other devices we find.
 251                          */
 252                 }
 253         }
 254
 255         of_node_put(bus);
 256
 257         return 0;
 258 }
 259
 260 static void of_dp_aux_depopulate_ep_devices_void(void *data)
 261 {
 262         of_dp_aux_depopulate_ep_devices(data);
 263 }
 264
 265 /**
 266  * devm_of_dp_aux_populate_ep_devices() - devm wrapper for of_dp_aux_populate_ep_devices()
 267  * @aux: The AUX channel whose devices we want to populate
 268  *
 269  * Handles freeing w/ devm on the device "aux->dev".
 270  *
 271  * Return: 0 if no error or negative error code.
 272  */
 273 int devm_of_dp_aux_populate_ep_devices(struct drm_dp_aux *aux)
 274 {
 275         int ret;
 276
 277         ret = of_dp_aux_populate_ep_devices(aux);
 278         if (ret)
 279                 return ret;
 280
 281         return devm_add_action_or_reset(aux->dev,
 282                                         of_dp_aux_depopulate_ep_devices_void,
 283                                         aux);
 284 }
 285 EXPORT_SYMBOL_GPL(devm_of_dp_aux_populate_ep_devices);
 286
 287 int __dp_aux_dp_driver_register(struct dp_aux_ep_driver *drv, struct module *owner)
 288 {
 289         drv->driver.owner = owner;
 290         drv->driver.bus = &dp_aux_bus_type;
 291
 292         return driver_register(&drv->driver);
 293 }
 294 EXPORT_SYMBOL_GPL(__dp_aux_dp_driver_register);
 295
 296 void dp_aux_dp_driver_unregister(struct dp_aux_ep_driver *drv)
 297 {
 298         driver_unregister(&drv->driver);
 299 }
 300 EXPORT_SYMBOL_GPL(dp_aux_dp_driver_unregister);
 301
 302 static int __init dp_aux_bus_init(void)
 303 {
 304         int ret;
 305
 306         ret = bus_register(&dp_aux_bus_type);
 307         if (ret)
 308                 return ret;
 309
 310         return 0;
 311 }
 312
 313 static void __exit dp_aux_bus_exit(void)
 314 {
 315         bus_unregister(&dp_aux_bus_type);
 316 }
 317
 318 subsys_initcall(dp_aux_bus_init);
 319 module_exit(dp_aux_bus_exit);
 320
 321 MODULE_AUTHOR("Douglas Anderson <[email protected]>");
 322 MODULE_DESCRIPTION("DRM DisplayPort AUX bus");
 323 MODULE_LICENSE("GPL v2");