1 /* $NetBSD: subr_device.c,v 1.13 2022/03/28 12:38:59 riastradh Exp $ */ 2 3 /* 4 * Copyright (c) 2006, 2021 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: subr_device.c,v 1.13 2022/03/28 12:38:59 riastradh Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/device.h> 34 #include <sys/device_impl.h> 35 #include <sys/systm.h> 36 37 #include <sys/device_calls.h> 38 39 /* Root device. */ 40 device_t root_device; 41 42 /* 43 * devhandle_t accessors / mutators. 44 */ 45 46 static bool 47 devhandle_is_valid_internal(const devhandle_t * const handlep) 48 { 49 if (handlep->impl == NULL) { 50 return false; 51 } 52 return handlep->impl->type != DEVHANDLE_TYPE_INVALID; 53 } 54 55 bool 56 devhandle_is_valid(devhandle_t handle) 57 { 58 return devhandle_is_valid_internal(&handle); 59 } 60 61 devhandle_t 62 devhandle_invalid(void) 63 { 64 static const devhandle_t invalid_devhandle = { 65 .impl = NULL, 66 .uintptr = 0, 67 }; 68 return invalid_devhandle; 69 } 70 71 devhandle_type_t 72 devhandle_type(devhandle_t handle) 73 { 74 if (!devhandle_is_valid_internal(&handle)) { 75 return DEVHANDLE_TYPE_INVALID; 76 } 77 78 return handle.impl->type; 79 } 80 81 int 82 devhandle_compare(devhandle_t handle1, devhandle_t handle2) 83 { 84 devhandle_type_t type1 = devhandle_type(handle1); 85 devhandle_type_t type2 = devhandle_type(handle2); 86 87 if (type1 == DEVHANDLE_TYPE_INVALID) { 88 return -1; 89 } 90 if (type2 == DEVHANDLE_TYPE_INVALID) { 91 return 1; 92 } 93 94 if (type1 < type2) { 95 return -1; 96 } 97 if (type1 > type2) { 98 return 1; 99 } 100 101 /* For private handles, we also compare the impl pointers. */ 102 if (type1 == DEVHANDLE_TYPE_PRIVATE) { 103 intptr_t impl1 = (intptr_t)handle1.impl; 104 intptr_t impl2 = (intptr_t)handle2.impl; 105 106 if (impl1 < impl2) { 107 return -1; 108 } 109 if (impl1 > impl2) { 110 return 1; 111 } 112 } 113 114 if (handle1.integer < handle2.integer) { 115 return -1; 116 } 117 if (handle1.integer > handle2.integer) { 118 return 1; 119 } 120 121 return 0; 122 } 123 124 device_call_t 125 devhandle_lookup_device_call(devhandle_t handle, const char *name, 126 devhandle_t *call_handlep) 127 { 128 const struct devhandle_impl *impl; 129 device_call_t call; 130 131 /* 132 * The back-end can override the handle to use for the call, 133 * if needed. 134 */ 135 *call_handlep = handle; 136 137 for (impl = handle.impl; impl != NULL; impl = impl->super) { 138 if (impl->lookup_device_call != NULL) { 139 call = impl->lookup_device_call(handle, name, 140 call_handlep); 141 if (call != NULL) { 142 return call; 143 } 144 } 145 } 146 return NULL; 147 } 148 149 void 150 devhandle_impl_inherit(struct devhandle_impl *impl, 151 const struct devhandle_impl *super) 152 { 153 memcpy(impl, super, sizeof(*impl)); 154 impl->super = super; 155 } 156 157 /* 158 * Accessor functions for the device_t type. 159 */ 160 161 devclass_t 162 device_class(device_t dev) 163 { 164 165 return dev->dv_class; 166 } 167 168 cfdata_t 169 device_cfdata(device_t dev) 170 { 171 172 return dev->dv_cfdata; 173 } 174 175 cfdriver_t 176 device_cfdriver(device_t dev) 177 { 178 179 return dev->dv_cfdriver; 180 } 181 182 cfattach_t 183 device_cfattach(device_t dev) 184 { 185 186 return dev->dv_cfattach; 187 } 188 189 int 190 device_unit(device_t dev) 191 { 192 193 return dev->dv_unit; 194 } 195 196 const char * 197 device_xname(device_t dev) 198 { 199 200 return dev->dv_xname; 201 } 202 203 device_t 204 device_parent(device_t dev) 205 { 206 207 return dev->dv_parent; 208 } 209 210 bool 211 device_activation(device_t dev, devact_level_t level) 212 { 213 int active_flags; 214 215 active_flags = DVF_ACTIVE; 216 switch (level) { 217 case DEVACT_LEVEL_FULL: 218 active_flags |= DVF_CLASS_SUSPENDED; 219 /*FALLTHROUGH*/ 220 case DEVACT_LEVEL_DRIVER: 221 active_flags |= DVF_DRIVER_SUSPENDED; 222 /*FALLTHROUGH*/ 223 case DEVACT_LEVEL_BUS: 224 active_flags |= DVF_BUS_SUSPENDED; 225 break; 226 } 227 228 return (dev->dv_flags & active_flags) == DVF_ACTIVE; 229 } 230 231 bool 232 device_is_active(device_t dev) 233 { 234 int active_flags; 235 236 active_flags = DVF_ACTIVE; 237 active_flags |= DVF_CLASS_SUSPENDED; 238 active_flags |= DVF_DRIVER_SUSPENDED; 239 active_flags |= DVF_BUS_SUSPENDED; 240 241 return (dev->dv_flags & active_flags) == DVF_ACTIVE; 242 } 243 244 bool 245 device_is_enabled(device_t dev) 246 { 247 return (dev->dv_flags & DVF_ACTIVE) == DVF_ACTIVE; 248 } 249 250 bool 251 device_has_power(device_t dev) 252 { 253 int active_flags; 254 255 active_flags = DVF_ACTIVE | DVF_BUS_SUSPENDED; 256 257 return (dev->dv_flags & active_flags) == DVF_ACTIVE; 258 } 259 260 int 261 device_locator(device_t dev, u_int locnum) 262 { 263 264 KASSERT(dev->dv_locators != NULL); 265 return dev->dv_locators[locnum]; 266 } 267 268 void * 269 device_private(device_t dev) 270 { 271 272 /* 273 * The reason why device_private(NULL) is allowed is to simplify the 274 * work of a lot of userspace request handlers (i.e., c/bdev 275 * handlers) which grab cfdriver_t->cd_units[n]. 276 * It avoids having them test for it to be NULL and only then calling 277 * device_private. 278 */ 279 return dev == NULL ? NULL : dev->dv_private; 280 } 281 282 void 283 device_set_private(device_t dev, void *private) 284 { 285 286 KASSERTMSG(dev->dv_private == NULL, "device_set_private(%p, %p):" 287 " device %s already has private set to %p", 288 dev, private, device_xname(dev), device_private(dev)); 289 KASSERT(private != NULL); 290 dev->dv_private = private; 291 } 292 293 prop_dictionary_t 294 device_properties(device_t dev) 295 { 296 297 return dev->dv_properties; 298 } 299 300 /* 301 * device_is_a: 302 * 303 * Returns true if the device is an instance of the specified 304 * driver. 305 */ 306 bool 307 device_is_a(device_t dev, const char *dname) 308 { 309 if (dev == NULL || dev->dv_cfdriver == NULL) { 310 return false; 311 } 312 313 return strcmp(dev->dv_cfdriver->cd_name, dname) == 0; 314 } 315 316 /* 317 * device_attached_to_iattr: 318 * 319 * Returns true if the device attached to the specified interface 320 * attribute. 321 */ 322 bool 323 device_attached_to_iattr(device_t dev, const char *iattr) 324 { 325 cfdata_t cfdata = device_cfdata(dev); 326 const struct cfparent *pspec; 327 328 if (cfdata == NULL || (pspec = cfdata->cf_pspec) == NULL) { 329 return false; 330 } 331 332 return strcmp(pspec->cfp_iattr, iattr) == 0; 333 } 334 335 void 336 device_set_handle(device_t dev, devhandle_t handle) 337 { 338 dev->dv_handle = handle; 339 } 340 341 devhandle_t 342 device_handle(device_t dev) 343 { 344 return dev->dv_handle; 345 } 346 347 int 348 device_call_generic(device_t dev, const struct device_call_generic *gen) 349 { 350 devhandle_t handle = device_handle(dev); 351 device_call_t call; 352 devhandle_t call_handle; 353 354 call = devhandle_lookup_device_call(handle, gen->name, &call_handle); 355 if (call == NULL) { 356 return ENOTSUP; 357 } 358 return call(dev, call_handle, gen->args); 359 } 360 361 int 362 device_enumerate_children(device_t dev, 363 bool (*callback)(device_t, devhandle_t, void *), 364 void *callback_arg) 365 { 366 struct device_enumerate_children_args args = { 367 .callback = callback, 368 .callback_arg = callback_arg, 369 }; 370 371 return device_call(dev, DEVICE_ENUMERATE_CHILDREN(&args)); 372 } 373