1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Greybus "Core" 4 * 5 * Copyright 2014-2015 Google Inc. 6 * Copyright 2014-2015 Linaro Ltd. 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #define CREATE_TRACE_POINTS 12 #include <linux/greybus.h> 13 #include "greybus_trace.h" 14 15 #define GB_BUNDLE_AUTOSUSPEND_MS 3000 16 17 /* Allow greybus to be disabled at boot if needed */ 18 static bool nogreybus; 19 #ifdef MODULE 20 module_param(nogreybus, bool, 0444); 21 #else 22 core_param(nogreybus, nogreybus, bool, 0444); 23 #endif 24 int greybus_disabled(void) 25 { 26 return nogreybus; 27 } 28 EXPORT_SYMBOL_GPL(greybus_disabled); 29 30 static int is_gb_host_device(const struct device *dev) 31 { 32 return dev->type == &greybus_hd_type; 33 } 34 35 static int is_gb_module(const struct device *dev) 36 { 37 return dev->type == &greybus_module_type; 38 } 39 40 static int is_gb_interface(const struct device *dev) 41 { 42 return dev->type == &greybus_interface_type; 43 } 44 45 static int is_gb_control(const struct device *dev) 46 { 47 return dev->type == &greybus_control_type; 48 } 49 50 static int is_gb_bundle(const struct device *dev) 51 { 52 return dev->type == &greybus_bundle_type; 53 } 54 55 static int is_gb_svc(const struct device *dev) 56 { 57 return dev->type == &greybus_svc_type; 58 } 59 60 static bool greybus_match_one_id(struct gb_bundle *bundle, 61 const struct greybus_bundle_id *id) 62 { 63 if ((id->match_flags & GREYBUS_ID_MATCH_VENDOR) && 64 (id->vendor != bundle->intf->vendor_id)) 65 return false; 66 67 if ((id->match_flags & GREYBUS_ID_MATCH_PRODUCT) && 68 (id->product != bundle->intf->product_id)) 69 return false; 70 71 if ((id->match_flags & GREYBUS_ID_MATCH_CLASS) && 72 (id->class != bundle->class)) 73 return false; 74 75 return true; 76 } 77 78 static const struct greybus_bundle_id * 79 greybus_match_id(struct gb_bundle *bundle, const struct greybus_bundle_id *id) 80 { 81 if (!id) 82 return NULL; 83 84 for (; id->vendor || id->product || id->class || id->driver_info; 85 id++) { 86 if (greybus_match_one_id(bundle, id)) 87 return id; 88 } 89 90 return NULL; 91 } 92 93 static int greybus_match_device(struct device *dev, const struct device_driver *drv) 94 { 95 const struct greybus_driver *driver = to_greybus_driver(drv); 96 struct gb_bundle *bundle; 97 const struct greybus_bundle_id *id; 98 99 if (!is_gb_bundle(dev)) 100 return 0; 101 102 bundle = to_gb_bundle(dev); 103 104 id = greybus_match_id(bundle, driver->id_table); 105 if (id) 106 return 1; 107 /* FIXME - Dynamic ids? */ 108 return 0; 109 } 110 111 static int greybus_uevent(const struct device *dev, struct kobj_uevent_env *env) 112 { 113 const struct gb_host_device *hd; 114 const struct gb_module *module = NULL; 115 const struct gb_interface *intf = NULL; 116 const struct gb_control *control = NULL; 117 const struct gb_bundle *bundle = NULL; 118 const struct gb_svc *svc = NULL; 119 120 if (is_gb_host_device(dev)) { 121 hd = to_gb_host_device(dev); 122 } else if (is_gb_module(dev)) { 123 module = to_gb_module(dev); 124 hd = module->hd; 125 } else if (is_gb_interface(dev)) { 126 intf = to_gb_interface(dev); 127 module = intf->module; 128 hd = intf->hd; 129 } else if (is_gb_control(dev)) { 130 control = to_gb_control(dev); 131 intf = control->intf; 132 module = intf->module; 133 hd = intf->hd; 134 } else if (is_gb_bundle(dev)) { 135 bundle = to_gb_bundle(dev); 136 intf = bundle->intf; 137 module = intf->module; 138 hd = intf->hd; 139 } else if (is_gb_svc(dev)) { 140 svc = to_gb_svc(dev); 141 hd = svc->hd; 142 } else { 143 dev_WARN(dev, "uevent for unknown greybus device \"type\"!\n"); 144 return -EINVAL; 145 } 146 147 if (add_uevent_var(env, "BUS=%u", hd->bus_id)) 148 return -ENOMEM; 149 150 if (module) { 151 if (add_uevent_var(env, "MODULE=%u", module->module_id)) 152 return -ENOMEM; 153 } 154 155 if (intf) { 156 if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id)) 157 return -ENOMEM; 158 if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x", 159 intf->vendor_id, intf->product_id)) 160 return -ENOMEM; 161 } 162 163 if (bundle) { 164 // FIXME 165 // add a uevent that can "load" a bundle type 166 // This is what we need to bind a driver to so use the info 167 // in gmod here as well 168 169 if (add_uevent_var(env, "BUNDLE=%u", bundle->id)) 170 return -ENOMEM; 171 if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class)) 172 return -ENOMEM; 173 } 174 175 return 0; 176 } 177 178 static void greybus_shutdown(struct device *dev) 179 { 180 if (is_gb_host_device(dev)) { 181 struct gb_host_device *hd; 182 183 hd = to_gb_host_device(dev); 184 gb_hd_shutdown(hd); 185 } 186 } 187 188 const struct bus_type greybus_bus_type = { 189 .name = "greybus", 190 .match = greybus_match_device, 191 .uevent = greybus_uevent, 192 .shutdown = greybus_shutdown, 193 }; 194 195 static int greybus_probe(struct device *dev) 196 { 197 struct greybus_driver *driver = to_greybus_driver(dev->driver); 198 struct gb_bundle *bundle = to_gb_bundle(dev); 199 const struct greybus_bundle_id *id; 200 int retval; 201 202 /* match id */ 203 id = greybus_match_id(bundle, driver->id_table); 204 if (!id) 205 return -ENODEV; 206 207 retval = pm_runtime_get_sync(&bundle->intf->dev); 208 if (retval < 0) { 209 pm_runtime_put_noidle(&bundle->intf->dev); 210 return retval; 211 } 212 213 retval = gb_control_bundle_activate(bundle->intf->control, bundle->id); 214 if (retval) { 215 pm_runtime_put(&bundle->intf->dev); 216 return retval; 217 } 218 219 /* 220 * Unbound bundle devices are always deactivated. During probe, the 221 * Runtime PM is set to enabled and active and the usage count is 222 * incremented. If the driver supports runtime PM, it should call 223 * pm_runtime_put() in its probe routine and pm_runtime_get_sync() 224 * in remove routine. 225 */ 226 pm_runtime_set_autosuspend_delay(dev, GB_BUNDLE_AUTOSUSPEND_MS); 227 pm_runtime_use_autosuspend(dev); 228 pm_runtime_get_noresume(dev); 229 pm_runtime_set_active(dev); 230 pm_runtime_enable(dev); 231 232 retval = driver->probe(bundle, id); 233 if (retval) { 234 /* 235 * Catch buggy drivers that fail to destroy their connections. 236 */ 237 WARN_ON(!list_empty(&bundle->connections)); 238 239 gb_control_bundle_deactivate(bundle->intf->control, bundle->id); 240 241 pm_runtime_disable(dev); 242 pm_runtime_set_suspended(dev); 243 pm_runtime_put_noidle(dev); 244 pm_runtime_dont_use_autosuspend(dev); 245 pm_runtime_put(&bundle->intf->dev); 246 247 return retval; 248 } 249 250 pm_runtime_put(&bundle->intf->dev); 251 252 return 0; 253 } 254 255 static int greybus_remove(struct device *dev) 256 { 257 struct greybus_driver *driver = to_greybus_driver(dev->driver); 258 struct gb_bundle *bundle = to_gb_bundle(dev); 259 struct gb_connection *connection; 260 int retval; 261 262 retval = pm_runtime_get_sync(dev); 263 if (retval < 0) 264 dev_err(dev, "failed to resume bundle: %d\n", retval); 265 266 /* 267 * Disable (non-offloaded) connections early in case the interface is 268 * already gone to avoid unceccessary operation timeouts during 269 * driver disconnect. Otherwise, only disable incoming requests. 270 */ 271 list_for_each_entry(connection, &bundle->connections, bundle_links) { 272 if (gb_connection_is_offloaded(connection)) 273 continue; 274 275 if (bundle->intf->disconnected) 276 gb_connection_disable_forced(connection); 277 else 278 gb_connection_disable_rx(connection); 279 } 280 281 driver->disconnect(bundle); 282 283 /* Catch buggy drivers that fail to destroy their connections. */ 284 WARN_ON(!list_empty(&bundle->connections)); 285 286 if (!bundle->intf->disconnected) 287 gb_control_bundle_deactivate(bundle->intf->control, bundle->id); 288 289 pm_runtime_put_noidle(dev); 290 pm_runtime_disable(dev); 291 pm_runtime_set_suspended(dev); 292 pm_runtime_dont_use_autosuspend(dev); 293 pm_runtime_put_noidle(dev); 294 295 return 0; 296 } 297 298 int greybus_register_driver(struct greybus_driver *driver, struct module *owner, 299 const char *mod_name) 300 { 301 int retval; 302 303 if (greybus_disabled()) 304 return -ENODEV; 305 306 driver->driver.bus = &greybus_bus_type; 307 driver->driver.name = driver->name; 308 driver->driver.probe = greybus_probe; 309 driver->driver.remove = greybus_remove; 310 driver->driver.owner = owner; 311 driver->driver.mod_name = mod_name; 312 313 retval = driver_register(&driver->driver); 314 if (retval) 315 return retval; 316 317 pr_info("registered new driver %s\n", driver->name); 318 return 0; 319 } 320 EXPORT_SYMBOL_GPL(greybus_register_driver); 321 322 void greybus_deregister_driver(struct greybus_driver *driver) 323 { 324 driver_unregister(&driver->driver); 325 } 326 EXPORT_SYMBOL_GPL(greybus_deregister_driver); 327 328 static int __init gb_init(void) 329 { 330 int retval; 331 332 if (greybus_disabled()) 333 return -ENODEV; 334 335 BUILD_BUG_ON(CPORT_ID_MAX >= (long)CPORT_ID_BAD); 336 337 gb_debugfs_init(); 338 339 retval = bus_register(&greybus_bus_type); 340 if (retval) { 341 pr_err("bus_register failed (%d)\n", retval); 342 goto error_bus; 343 } 344 345 retval = gb_hd_init(); 346 if (retval) { 347 pr_err("gb_hd_init failed (%d)\n", retval); 348 goto error_hd; 349 } 350 351 retval = gb_operation_init(); 352 if (retval) { 353 pr_err("gb_operation_init failed (%d)\n", retval); 354 goto error_operation; 355 } 356 return 0; /* Success */ 357 358 error_operation: 359 gb_hd_exit(); 360 error_hd: 361 bus_unregister(&greybus_bus_type); 362 error_bus: 363 gb_debugfs_cleanup(); 364 365 return retval; 366 } 367 module_init(gb_init); 368 369 static void __exit gb_exit(void) 370 { 371 gb_operation_exit(); 372 gb_hd_exit(); 373 bus_unregister(&greybus_bus_type); 374 gb_debugfs_cleanup(); 375 tracepoint_synchronize_unregister(); 376 } 377 module_exit(gb_exit); 378 MODULE_DESCRIPTION("Greybus core driver"); 379 MODULE_LICENSE("GPL v2"); 380 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org>"); 381