1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * USB Type-C Multiplexer/DeMultiplexer Switch support 4 * 5 * Copyright (C) 2018 Intel Corporation 6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 7 * Hans de Goede <hdegoede@redhat.com> 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 #include <linux/usb/typec_mux.h> 17 18 #include "bus.h" 19 20 static bool dev_name_ends_with(struct device *dev, const char *suffix) 21 { 22 const char *name = dev_name(dev); 23 const int name_len = strlen(name); 24 const int suffix_len = strlen(suffix); 25 26 if (suffix_len > name_len) 27 return false; 28 29 return strcmp(name + (name_len - suffix_len), suffix) == 0; 30 } 31 32 static int switch_fwnode_match(struct device *dev, const void *fwnode) 33 { 34 return dev_fwnode(dev) == fwnode && dev_name_ends_with(dev, "-switch"); 35 } 36 37 static void *typec_switch_match(struct fwnode_handle *fwnode, const char *id, 38 void *data) 39 { 40 struct device *dev; 41 42 if (id && !fwnode_property_present(fwnode, id)) 43 return NULL; 44 45 dev = class_find_device(&typec_mux_class, NULL, fwnode, 46 switch_fwnode_match); 47 48 return dev ? to_typec_switch(dev) : ERR_PTR(-EPROBE_DEFER); 49 } 50 51 /** 52 * fwnode_typec_switch_get - Find USB Type-C orientation switch 53 * @fwnode: The caller device node 54 * 55 * Finds a switch linked with @dev. Returns a reference to the switch on 56 * success, NULL if no matching connection was found, or 57 * ERR_PTR(-EPROBE_DEFER) when a connection was found but the switch 58 * has not been enumerated yet. 59 */ 60 struct typec_switch *fwnode_typec_switch_get(struct fwnode_handle *fwnode) 61 { 62 struct typec_switch *sw; 63 64 sw = fwnode_connection_find_match(fwnode, "orientation-switch", NULL, 65 typec_switch_match); 66 if (!IS_ERR_OR_NULL(sw)) 67 WARN_ON(!try_module_get(sw->dev.parent->driver->owner)); 68 69 return sw; 70 } 71 EXPORT_SYMBOL_GPL(fwnode_typec_switch_get); 72 73 /** 74 * typec_switch_put - Release USB Type-C orientation switch 75 * @sw: USB Type-C orientation switch 76 * 77 * Decrement reference count for @sw. 78 */ 79 void typec_switch_put(struct typec_switch *sw) 80 { 81 if (!IS_ERR_OR_NULL(sw)) { 82 module_put(sw->dev.parent->driver->owner); 83 put_device(&sw->dev); 84 } 85 } 86 EXPORT_SYMBOL_GPL(typec_switch_put); 87 88 static void typec_switch_release(struct device *dev) 89 { 90 kfree(to_typec_switch(dev)); 91 } 92 93 static const struct device_type typec_switch_dev_type = { 94 .name = "orientation_switch", 95 .release = typec_switch_release, 96 }; 97 98 /** 99 * typec_switch_register - Register USB Type-C orientation switch 100 * @parent: Parent device 101 * @desc: Orientation switch description 102 * 103 * This function registers a switch that can be used for routing the correct 104 * data pairs depending on the cable plug orientation from the USB Type-C 105 * connector to the USB controllers. USB Type-C plugs can be inserted 106 * right-side-up or upside-down. 107 */ 108 struct typec_switch * 109 typec_switch_register(struct device *parent, 110 const struct typec_switch_desc *desc) 111 { 112 struct typec_switch *sw; 113 int ret; 114 115 if (!desc || !desc->set) 116 return ERR_PTR(-EINVAL); 117 118 sw = kzalloc(sizeof(*sw), GFP_KERNEL); 119 if (!sw) 120 return ERR_PTR(-ENOMEM); 121 122 sw->set = desc->set; 123 124 device_initialize(&sw->dev); 125 sw->dev.parent = parent; 126 sw->dev.fwnode = desc->fwnode; 127 sw->dev.class = &typec_mux_class; 128 sw->dev.type = &typec_switch_dev_type; 129 sw->dev.driver_data = desc->drvdata; 130 dev_set_name(&sw->dev, "%s-switch", 131 desc->name ? desc->name : dev_name(parent)); 132 133 ret = device_add(&sw->dev); 134 if (ret) { 135 dev_err(parent, "failed to register switch (%d)\n", ret); 136 put_device(&sw->dev); 137 return ERR_PTR(ret); 138 } 139 140 return sw; 141 } 142 EXPORT_SYMBOL_GPL(typec_switch_register); 143 144 int typec_switch_set(struct typec_switch *sw, 145 enum typec_orientation orientation) 146 { 147 if (IS_ERR_OR_NULL(sw)) 148 return 0; 149 150 return sw->set(sw, orientation); 151 } 152 EXPORT_SYMBOL_GPL(typec_switch_set); 153 154 /** 155 * typec_switch_unregister - Unregister USB Type-C orientation switch 156 * @sw: USB Type-C orientation switch 157 * 158 * Unregister switch that was registered with typec_switch_register(). 159 */ 160 void typec_switch_unregister(struct typec_switch *sw) 161 { 162 if (!IS_ERR_OR_NULL(sw)) 163 device_unregister(&sw->dev); 164 } 165 EXPORT_SYMBOL_GPL(typec_switch_unregister); 166 167 void typec_switch_set_drvdata(struct typec_switch *sw, void *data) 168 { 169 dev_set_drvdata(&sw->dev, data); 170 } 171 EXPORT_SYMBOL_GPL(typec_switch_set_drvdata); 172 173 void *typec_switch_get_drvdata(struct typec_switch *sw) 174 { 175 return dev_get_drvdata(&sw->dev); 176 } 177 EXPORT_SYMBOL_GPL(typec_switch_get_drvdata); 178 179 /* ------------------------------------------------------------------------- */ 180 181 static int mux_fwnode_match(struct device *dev, const void *fwnode) 182 { 183 return dev_fwnode(dev) == fwnode && dev_name_ends_with(dev, "-mux"); 184 } 185 186 static void *typec_mux_match(struct fwnode_handle *fwnode, const char *id, 187 void *data) 188 { 189 const struct typec_altmode_desc *desc = data; 190 struct device *dev; 191 bool match; 192 int nval; 193 u16 *val; 194 int i; 195 196 /* 197 * Check has the identifier already been "consumed". If it 198 * has, no need to do any extra connection identification. 199 */ 200 match = !id; 201 if (match) 202 goto find_mux; 203 204 /* Accessory Mode muxes */ 205 if (!desc) { 206 match = fwnode_property_present(fwnode, "accessory"); 207 if (match) 208 goto find_mux; 209 return NULL; 210 } 211 212 /* Alternate Mode muxes */ 213 nval = fwnode_property_count_u16(fwnode, "svid"); 214 if (nval <= 0) 215 return NULL; 216 217 val = kcalloc(nval, sizeof(*val), GFP_KERNEL); 218 if (!val) 219 return ERR_PTR(-ENOMEM); 220 221 nval = fwnode_property_read_u16_array(fwnode, "svid", val, nval); 222 if (nval < 0) { 223 kfree(val); 224 return ERR_PTR(nval); 225 } 226 227 for (i = 0; i < nval; i++) { 228 match = val[i] == desc->svid; 229 if (match) { 230 kfree(val); 231 goto find_mux; 232 } 233 } 234 kfree(val); 235 return NULL; 236 237 find_mux: 238 dev = class_find_device(&typec_mux_class, NULL, fwnode, 239 mux_fwnode_match); 240 241 return dev ? to_typec_switch(dev) : ERR_PTR(-EPROBE_DEFER); 242 } 243 244 /** 245 * fwnode_typec_mux_get - Find USB Type-C Multiplexer 246 * @fwnode: The caller device node 247 * @desc: Alt Mode description 248 * 249 * Finds a mux linked to the caller. This function is primarily meant for the 250 * Type-C drivers. Returns a reference to the mux on success, NULL if no 251 * matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a connection 252 * was found but the mux has not been enumerated yet. 253 */ 254 struct typec_mux *fwnode_typec_mux_get(struct fwnode_handle *fwnode, 255 const struct typec_altmode_desc *desc) 256 { 257 struct typec_mux *mux; 258 259 mux = fwnode_connection_find_match(fwnode, "mode-switch", (void *)desc, 260 typec_mux_match); 261 if (!IS_ERR_OR_NULL(mux)) 262 WARN_ON(!try_module_get(mux->dev.parent->driver->owner)); 263 264 return mux; 265 } 266 EXPORT_SYMBOL_GPL(fwnode_typec_mux_get); 267 268 /** 269 * typec_mux_put - Release handle to a Multiplexer 270 * @mux: USB Type-C Connector Multiplexer/DeMultiplexer 271 * 272 * Decrements reference count for @mux. 273 */ 274 void typec_mux_put(struct typec_mux *mux) 275 { 276 if (!IS_ERR_OR_NULL(mux)) { 277 module_put(mux->dev.parent->driver->owner); 278 put_device(&mux->dev); 279 } 280 } 281 EXPORT_SYMBOL_GPL(typec_mux_put); 282 283 int typec_mux_set(struct typec_mux *mux, struct typec_mux_state *state) 284 { 285 if (IS_ERR_OR_NULL(mux)) 286 return 0; 287 288 return mux->set(mux, state); 289 } 290 EXPORT_SYMBOL_GPL(typec_mux_set); 291 292 static void typec_mux_release(struct device *dev) 293 { 294 kfree(to_typec_mux(dev)); 295 } 296 297 static const struct device_type typec_mux_dev_type = { 298 .name = "mode_switch", 299 .release = typec_mux_release, 300 }; 301 302 /** 303 * typec_mux_register - Register Multiplexer routing USB Type-C pins 304 * @parent: Parent device 305 * @desc: Multiplexer description 306 * 307 * USB Type-C connectors can be used for alternate modes of operation besides 308 * USB when Accessory/Alternate Modes are supported. With some of those modes, 309 * the pins on the connector need to be reconfigured. This function registers 310 * multiplexer switches routing the pins on the connector. 311 */ 312 struct typec_mux * 313 typec_mux_register(struct device *parent, const struct typec_mux_desc *desc) 314 { 315 struct typec_mux *mux; 316 int ret; 317 318 if (!desc || !desc->set) 319 return ERR_PTR(-EINVAL); 320 321 mux = kzalloc(sizeof(*mux), GFP_KERNEL); 322 if (!mux) 323 return ERR_PTR(-ENOMEM); 324 325 mux->set = desc->set; 326 327 device_initialize(&mux->dev); 328 mux->dev.parent = parent; 329 mux->dev.fwnode = desc->fwnode; 330 mux->dev.class = &typec_mux_class; 331 mux->dev.type = &typec_mux_dev_type; 332 mux->dev.driver_data = desc->drvdata; 333 dev_set_name(&mux->dev, "%s-mux", 334 desc->name ? desc->name : dev_name(parent)); 335 336 ret = device_add(&mux->dev); 337 if (ret) { 338 dev_err(parent, "failed to register mux (%d)\n", ret); 339 put_device(&mux->dev); 340 return ERR_PTR(ret); 341 } 342 343 return mux; 344 } 345 EXPORT_SYMBOL_GPL(typec_mux_register); 346 347 /** 348 * typec_mux_unregister - Unregister Multiplexer Switch 349 * @mux: USB Type-C Connector Multiplexer/DeMultiplexer 350 * 351 * Unregister mux that was registered with typec_mux_register(). 352 */ 353 void typec_mux_unregister(struct typec_mux *mux) 354 { 355 if (!IS_ERR_OR_NULL(mux)) 356 device_unregister(&mux->dev); 357 } 358 EXPORT_SYMBOL_GPL(typec_mux_unregister); 359 360 void typec_mux_set_drvdata(struct typec_mux *mux, void *data) 361 { 362 dev_set_drvdata(&mux->dev, data); 363 } 364 EXPORT_SYMBOL_GPL(typec_mux_set_drvdata); 365 366 void *typec_mux_get_drvdata(struct typec_mux *mux) 367 { 368 return dev_get_drvdata(&mux->dev); 369 } 370 EXPORT_SYMBOL_GPL(typec_mux_get_drvdata); 371 372 struct class typec_mux_class = { 373 .name = "typec_mux", 374 .owner = THIS_MODULE, 375 }; 376