drivers/usb/typec/retimer.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2022 Google LLC
   4  *
   5  * USB Type-C Retimer support.
   6  * Author: Prashant Malani <pmalani@chromium.org>
   7  *
   8  */
   9
  10 #include <linux/device.h>
  11 #include <linux/list.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/property.h>
  15 #include <linux/slab.h>
  16
  17 #include "class.h"
  18 #include "retimer.h"
  19
  20 static int retimer_fwnode_match(struct device *dev, const void *fwnode)
  21 {
  22         return is_typec_retimer(dev) && device_match_fwnode(dev, fwnode);
  23 }
  24
  25 static void *typec_retimer_match(const struct fwnode_handle *fwnode, const char *id, void *data)
  26 {
  27         struct device *dev;
  28
  29         if (id && !fwnode_property_present(fwnode, id))
  30                 return NULL;
  31
  32         dev = class_find_device(&retimer_class, NULL, fwnode,
  33                                 retimer_fwnode_match);
  34
  35         return dev ? to_typec_retimer(dev) : ERR_PTR(-EPROBE_DEFER);
  36 }
  37
  38 /**
  39  * fwnode_typec_retimer_get - Find USB Type-C retimer.
  40  * @fwnode: The caller device node.
  41  *
  42  * Finds a retimer linked to the caller. This function is primarily meant for the
  43  * Type-C drivers. Returns a reference to the retimer on success, NULL if no
  44  * matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a connection
  45  * was found but the retimer has not been enumerated yet.
  46  */
  47 struct typec_retimer *fwnode_typec_retimer_get(struct fwnode_handle *fwnode)
  48 {
  49         struct typec_retimer *retimer;
  50
  51         retimer = fwnode_connection_find_match(fwnode, "retimer-switch", NULL, typec_retimer_match);
  52         if (!IS_ERR_OR_NULL(retimer))
  53                 WARN_ON(!try_module_get(retimer->dev.parent->driver->owner));
  54
  55         return retimer;
  56 }
  57 EXPORT_SYMBOL_GPL(fwnode_typec_retimer_get);
  58
  59 /**
  60  * typec_retimer_put - Release handle to a retimer.
  61  * @retimer: USB Type-C Connector Retimer.
  62  *
  63  * Decrements reference count for @retimer.
  64  */
  65 void typec_retimer_put(struct typec_retimer *retimer)
  66 {
  67         if (!IS_ERR_OR_NULL(retimer)) {
  68                 module_put(retimer->dev.parent->driver->owner);
  69                 put_device(&retimer->dev);
  70         }
  71 }
  72 EXPORT_SYMBOL_GPL(typec_retimer_put);
  73
  74 int typec_retimer_set(struct typec_retimer *retimer, struct typec_retimer_state *state)
  75 {
  76         if (IS_ERR_OR_NULL(retimer))
  77                 return 0;
  78
  79         return retimer->set(retimer, state);
  80 }
  81 EXPORT_SYMBOL_GPL(typec_retimer_set);
  82
  83 static void typec_retimer_release(struct device *dev)
  84 {
  85         kfree(to_typec_retimer(dev));
  86 }
  87
  88 const struct device_type typec_retimer_dev_type = {
  89         .name = "typec_retimer",
  90         .release = typec_retimer_release,
  91 };
  92
  93 /**
  94  * typec_retimer_register - Register a retimer device.
  95  * @parent: Parent device.
  96  * @desc: Retimer description.
  97  *
  98  * Some USB Type-C connectors have their physical lines routed through retimers before they
  99  * reach muxes or host controllers. In some cases (for example: using alternate modes)
 100  * these retimers need to be reconfigured appropriately. This function registers retimer
 101  * switches which route and potentially modify the signals on the Type C physical lines
 102  * enroute to the host controllers.
 103  */
 104 struct typec_retimer *
 105 typec_retimer_register(struct device *parent, const struct typec_retimer_desc *desc)
 106 {
 107         struct typec_retimer *retimer;
 108         int ret;
 109
 110         if (!desc || !desc->set)
 111                 return ERR_PTR(-EINVAL);
 112
 113         retimer = kzalloc(sizeof(*retimer), GFP_KERNEL);
 114         if (!retimer)
 115                 return ERR_PTR(-ENOMEM);
 116
 117         retimer->set = desc->set;
 118
 119         device_initialize(&retimer->dev);
 120         retimer->dev.parent = parent;
 121         retimer->dev.fwnode = desc->fwnode;
 122         retimer->dev.class = &retimer_class;
 123         retimer->dev.type = &typec_retimer_dev_type;
 124         retimer->dev.driver_data = desc->drvdata;
 125         dev_set_name(&retimer->dev, "%s-retimer",
 126                      desc->name ? desc->name : dev_name(parent));
 127
 128         ret = device_add(&retimer->dev);
 129         if (ret) {
 130                 dev_err(parent, "failed to register retimer (%d)\n", ret);
 131                 put_device(&retimer->dev);
 132                 return ERR_PTR(ret);
 133         }
 134
 135         return retimer;
 136 }
 137 EXPORT_SYMBOL_GPL(typec_retimer_register);
 138
 139 /**
 140  * typec_retimer_unregister - Unregister retimer device.
 141  * @retimer: USB Type-C Connector retimer.
 142  *
 143  * Unregister retimer that was registered with typec_retimer_register().
 144  */
 145 void typec_retimer_unregister(struct typec_retimer *retimer)
 146 {
 147         if (!IS_ERR_OR_NULL(retimer))
 148                 device_unregister(&retimer->dev);
 149 }
 150 EXPORT_SYMBOL_GPL(typec_retimer_unregister);
 151
 152 void *typec_retimer_get_drvdata(struct typec_retimer *retimer)
 153 {
 154         return dev_get_drvdata(&retimer->dev);
 155 }
 156 EXPORT_SYMBOL_GPL(typec_retimer_get_drvdata);
 157
 158 struct class retimer_class = {
 159         .name = "retimer",
 160         .owner = THIS_MODULE,
 161 };