1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Bus for USB Type-C Alternate Modes 4 * 5 * Copyright (C) 2018 Intel Corporation 6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 7 */ 8 9 #include <linux/usb/pd_vdo.h> 10 11 #include "bus.h" 12 13 static inline int 14 typec_altmode_set_mux(struct altmode *alt, unsigned long conf, void *data) 15 { 16 struct typec_mux_state state; 17 18 if (!alt->mux) 19 return 0; 20 21 state.alt = &alt->adev; 22 state.mode = conf; 23 state.data = data; 24 25 return alt->mux->set(alt->mux, &state); 26 } 27 28 static int typec_altmode_set_state(struct typec_altmode *adev, 29 unsigned long conf, void *data) 30 { 31 bool is_port = is_typec_port(adev->dev.parent); 32 struct altmode *port_altmode; 33 34 port_altmode = is_port ? to_altmode(adev) : to_altmode(adev)->partner; 35 36 return typec_altmode_set_mux(port_altmode, conf, data); 37 } 38 39 /* -------------------------------------------------------------------------- */ 40 /* Common API */ 41 42 /** 43 * typec_altmode_notify - Communication between the OS and alternate mode driver 44 * @adev: Handle to the alternate mode 45 * @conf: Alternate mode specific configuration value 46 * @data: Alternate mode specific data 47 * 48 * The primary purpose for this function is to allow the alternate mode drivers 49 * to tell which pin configuration has been negotiated with the partner. That 50 * information will then be used for example to configure the muxes. 51 * Communication to the other direction is also possible, and low level device 52 * drivers can also send notifications to the alternate mode drivers. The actual 53 * communication will be specific for every SVID. 54 */ 55 int typec_altmode_notify(struct typec_altmode *adev, 56 unsigned long conf, void *data) 57 { 58 bool is_port; 59 struct altmode *altmode; 60 struct altmode *partner; 61 int ret; 62 63 if (!adev) 64 return 0; 65 66 altmode = to_altmode(adev); 67 68 if (!altmode->partner) 69 return -ENODEV; 70 71 is_port = is_typec_port(adev->dev.parent); 72 partner = altmode->partner; 73 74 ret = typec_altmode_set_mux(is_port ? altmode : partner, conf, data); 75 if (ret) 76 return ret; 77 78 if (partner->adev.ops && partner->adev.ops->notify) 79 return partner->adev.ops->notify(&partner->adev, conf, data); 80 81 return 0; 82 } 83 EXPORT_SYMBOL_GPL(typec_altmode_notify); 84 85 /** 86 * typec_altmode_enter - Enter Mode 87 * @adev: The alternate mode 88 * @vdo: VDO for the Enter Mode command 89 * 90 * The alternate mode drivers use this function to enter mode. The port drivers 91 * use this to inform the alternate mode drivers that the partner has initiated 92 * Enter Mode command. If the alternate mode does not require VDO, @vdo must be 93 * NULL. 94 */ 95 int typec_altmode_enter(struct typec_altmode *adev, u32 *vdo) 96 { 97 struct altmode *partner = to_altmode(adev)->partner; 98 struct typec_altmode *pdev = &partner->adev; 99 int ret; 100 101 if (!adev || adev->active) 102 return 0; 103 104 if (!pdev->ops || !pdev->ops->enter) 105 return -EOPNOTSUPP; 106 107 if (is_typec_port(pdev->dev.parent) && !pdev->active) 108 return -EPERM; 109 110 /* Moving to USB Safe State */ 111 ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE, NULL); 112 if (ret) 113 return ret; 114 115 /* Enter Mode */ 116 return pdev->ops->enter(pdev, vdo); 117 } 118 EXPORT_SYMBOL_GPL(typec_altmode_enter); 119 120 /** 121 * typec_altmode_exit - Exit Mode 122 * @adev: The alternate mode 123 * 124 * The partner of @adev has initiated Exit Mode command. 125 */ 126 int typec_altmode_exit(struct typec_altmode *adev) 127 { 128 struct altmode *partner = to_altmode(adev)->partner; 129 struct typec_altmode *pdev = &partner->adev; 130 int ret; 131 132 if (!adev || !adev->active) 133 return 0; 134 135 if (!pdev->ops || !pdev->ops->enter) 136 return -EOPNOTSUPP; 137 138 /* Moving to USB Safe State */ 139 ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE, NULL); 140 if (ret) 141 return ret; 142 143 /* Exit Mode command */ 144 return pdev->ops->exit(pdev); 145 } 146 EXPORT_SYMBOL_GPL(typec_altmode_exit); 147 148 /** 149 * typec_altmode_attention - Attention command 150 * @adev: The alternate mode 151 * @vdo: VDO for the Attention command 152 * 153 * Notifies the partner of @adev about Attention command. 154 */ 155 void typec_altmode_attention(struct typec_altmode *adev, u32 vdo) 156 { 157 struct typec_altmode *pdev = &to_altmode(adev)->partner->adev; 158 159 if (pdev->ops && pdev->ops->attention) 160 pdev->ops->attention(pdev, vdo); 161 } 162 EXPORT_SYMBOL_GPL(typec_altmode_attention); 163 164 /** 165 * typec_altmode_vdm - Send Vendor Defined Messages (VDM) to the partner 166 * @adev: Alternate mode handle 167 * @header: VDM Header 168 * @vdo: Array of Vendor Defined Data Objects 169 * @count: Number of Data Objects 170 * 171 * The alternate mode drivers use this function for SVID specific communication 172 * with the partner. The port drivers use it to deliver the Structured VDMs 173 * received from the partners to the alternate mode drivers. 174 */ 175 int typec_altmode_vdm(struct typec_altmode *adev, 176 const u32 header, const u32 *vdo, int count) 177 { 178 struct typec_altmode *pdev; 179 struct altmode *altmode; 180 181 if (!adev) 182 return 0; 183 184 altmode = to_altmode(adev); 185 186 if (!altmode->partner) 187 return -ENODEV; 188 189 pdev = &altmode->partner->adev; 190 191 if (!pdev->ops || !pdev->ops->vdm) 192 return -EOPNOTSUPP; 193 194 return pdev->ops->vdm(pdev, header, vdo, count); 195 } 196 EXPORT_SYMBOL_GPL(typec_altmode_vdm); 197 198 const struct typec_altmode * 199 typec_altmode_get_partner(struct typec_altmode *adev) 200 { 201 if (!adev || !to_altmode(adev)->partner) 202 return NULL; 203 204 return &to_altmode(adev)->partner->adev; 205 } 206 EXPORT_SYMBOL_GPL(typec_altmode_get_partner); 207 208 /* -------------------------------------------------------------------------- */ 209 /* API for the alternate mode drivers */ 210 211 /** 212 * typec_altmode_get_plug - Find cable plug alternate mode 213 * @adev: Handle to partner alternate mode 214 * @index: Cable plug index 215 * 216 * Increment reference count for cable plug alternate mode device. Returns 217 * handle to the cable plug alternate mode, or NULL if none is found. 218 */ 219 struct typec_altmode *typec_altmode_get_plug(struct typec_altmode *adev, 220 enum typec_plug_index index) 221 { 222 struct altmode *port = to_altmode(adev)->partner; 223 224 if (port->plug[index]) { 225 get_device(&port->plug[index]->adev.dev); 226 return &port->plug[index]->adev; 227 } 228 229 return NULL; 230 } 231 EXPORT_SYMBOL_GPL(typec_altmode_get_plug); 232 233 /** 234 * typec_altmode_put_plug - Decrement cable plug alternate mode reference count 235 * @plug: Handle to the cable plug alternate mode 236 */ 237 void typec_altmode_put_plug(struct typec_altmode *plug) 238 { 239 if (plug) 240 put_device(&plug->dev); 241 } 242 EXPORT_SYMBOL_GPL(typec_altmode_put_plug); 243 244 int __typec_altmode_register_driver(struct typec_altmode_driver *drv, 245 struct module *module) 246 { 247 if (!drv->probe) 248 return -EINVAL; 249 250 drv->driver.owner = module; 251 drv->driver.bus = &typec_bus; 252 253 return driver_register(&drv->driver); 254 } 255 EXPORT_SYMBOL_GPL(__typec_altmode_register_driver); 256 257 void typec_altmode_unregister_driver(struct typec_altmode_driver *drv) 258 { 259 driver_unregister(&drv->driver); 260 } 261 EXPORT_SYMBOL_GPL(typec_altmode_unregister_driver); 262 263 /* -------------------------------------------------------------------------- */ 264 /* API for the port drivers */ 265 266 /** 267 * typec_match_altmode - Match SVID and mode to an array of alternate modes 268 * @altmodes: Array of alternate modes 269 * @n: Number of elements in the array, or -1 for NULL terminated arrays 270 * @svid: Standard or Vendor ID to match with 271 * @mode: Mode to match with 272 * 273 * Return pointer to an alternate mode with SVID matching @svid, or NULL when no 274 * match is found. 275 */ 276 struct typec_altmode *typec_match_altmode(struct typec_altmode **altmodes, 277 size_t n, u16 svid, u8 mode) 278 { 279 int i; 280 281 for (i = 0; i < n; i++) { 282 if (!altmodes[i]) 283 break; 284 if (altmodes[i]->svid == svid && altmodes[i]->mode == mode) 285 return altmodes[i]; 286 } 287 288 return NULL; 289 } 290 EXPORT_SYMBOL_GPL(typec_match_altmode); 291 292 /* -------------------------------------------------------------------------- */ 293 294 static ssize_t 295 description_show(struct device *dev, struct device_attribute *attr, char *buf) 296 { 297 struct typec_altmode *alt = to_typec_altmode(dev); 298 299 return sprintf(buf, "%s\n", alt->desc ? alt->desc : ""); 300 } 301 static DEVICE_ATTR_RO(description); 302 303 static struct attribute *typec_attrs[] = { 304 &dev_attr_description.attr, 305 NULL 306 }; 307 ATTRIBUTE_GROUPS(typec); 308 309 static int typec_match(struct device *dev, struct device_driver *driver) 310 { 311 struct typec_altmode_driver *drv = to_altmode_driver(driver); 312 struct typec_altmode *altmode = to_typec_altmode(dev); 313 const struct typec_device_id *id; 314 315 for (id = drv->id_table; id->svid; id++) 316 if (id->svid == altmode->svid && 317 (id->mode == TYPEC_ANY_MODE || id->mode == altmode->mode)) 318 return 1; 319 return 0; 320 } 321 322 static int typec_uevent(struct device *dev, struct kobj_uevent_env *env) 323 { 324 struct typec_altmode *altmode = to_typec_altmode(dev); 325 326 if (add_uevent_var(env, "SVID=%04X", altmode->svid)) 327 return -ENOMEM; 328 329 if (add_uevent_var(env, "MODE=%u", altmode->mode)) 330 return -ENOMEM; 331 332 return add_uevent_var(env, "MODALIAS=typec:id%04Xm%02X", 333 altmode->svid, altmode->mode); 334 } 335 336 static int typec_altmode_create_links(struct altmode *alt) 337 { 338 struct device *port_dev = &alt->partner->adev.dev; 339 struct device *dev = &alt->adev.dev; 340 int err; 341 342 err = sysfs_create_link(&dev->kobj, &port_dev->kobj, "port"); 343 if (err) 344 return err; 345 346 err = sysfs_create_link(&port_dev->kobj, &dev->kobj, "partner"); 347 if (err) 348 sysfs_remove_link(&dev->kobj, "port"); 349 350 return err; 351 } 352 353 static void typec_altmode_remove_links(struct altmode *alt) 354 { 355 sysfs_remove_link(&alt->partner->adev.dev.kobj, "partner"); 356 sysfs_remove_link(&alt->adev.dev.kobj, "port"); 357 } 358 359 static int typec_probe(struct device *dev) 360 { 361 struct typec_altmode_driver *drv = to_altmode_driver(dev->driver); 362 struct typec_altmode *adev = to_typec_altmode(dev); 363 struct altmode *altmode = to_altmode(adev); 364 int ret; 365 366 /* Fail if the port does not support the alternate mode */ 367 if (!altmode->partner) 368 return -ENODEV; 369 370 ret = typec_altmode_create_links(altmode); 371 if (ret) { 372 dev_warn(dev, "failed to create symlinks\n"); 373 return ret; 374 } 375 376 ret = drv->probe(adev); 377 if (ret) 378 typec_altmode_remove_links(altmode); 379 380 return ret; 381 } 382 383 static int typec_remove(struct device *dev) 384 { 385 struct typec_altmode_driver *drv = to_altmode_driver(dev->driver); 386 struct typec_altmode *adev = to_typec_altmode(dev); 387 struct altmode *altmode = to_altmode(adev); 388 389 typec_altmode_remove_links(altmode); 390 391 if (drv->remove) 392 drv->remove(to_typec_altmode(dev)); 393 394 if (adev->active) { 395 WARN_ON(typec_altmode_set_state(adev, TYPEC_STATE_SAFE, NULL)); 396 typec_altmode_update_active(adev, false); 397 } 398 399 adev->desc = NULL; 400 adev->ops = NULL; 401 402 return 0; 403 } 404 405 struct bus_type typec_bus = { 406 .name = "typec", 407 .dev_groups = typec_groups, 408 .match = typec_match, 409 .uevent = typec_uevent, 410 .probe = typec_probe, 411 .remove = typec_remove, 412 }; 413