1 /* 2 * class.c - basic device class management 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * Copyright (c) 2003-2004 Greg Kroah-Hartman 7 * Copyright (c) 2003-2004 IBM Corp. 8 * 9 * This file is released under the GPLv2 10 * 11 */ 12 13 #include <linux/device.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/string.h> 17 #include <linux/kdev_t.h> 18 #include <linux/err.h> 19 #include <linux/slab.h> 20 #include <linux/genhd.h> 21 #include <linux/mutex.h> 22 #include "base.h" 23 24 #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr) 25 26 static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr, 27 char *buf) 28 { 29 struct class_attribute *class_attr = to_class_attr(attr); 30 struct class_private *cp = to_class(kobj); 31 ssize_t ret = -EIO; 32 33 if (class_attr->show) 34 ret = class_attr->show(cp->class, class_attr, buf); 35 return ret; 36 } 37 38 static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr, 39 const char *buf, size_t count) 40 { 41 struct class_attribute *class_attr = to_class_attr(attr); 42 struct class_private *cp = to_class(kobj); 43 ssize_t ret = -EIO; 44 45 if (class_attr->store) 46 ret = class_attr->store(cp->class, class_attr, buf, count); 47 return ret; 48 } 49 50 static void class_release(struct kobject *kobj) 51 { 52 struct class_private *cp = to_class(kobj); 53 struct class *class = cp->class; 54 55 pr_debug("class '%s': release.\n", class->name); 56 57 if (class->class_release) 58 class->class_release(class); 59 else 60 pr_debug("class '%s' does not have a release() function, " 61 "be careful\n", class->name); 62 63 kfree(cp); 64 } 65 66 static const struct kobj_ns_type_operations *class_child_ns_type(struct kobject *kobj) 67 { 68 struct class_private *cp = to_class(kobj); 69 struct class *class = cp->class; 70 71 return class->ns_type; 72 } 73 74 static const struct sysfs_ops class_sysfs_ops = { 75 .show = class_attr_show, 76 .store = class_attr_store, 77 }; 78 79 static struct kobj_type class_ktype = { 80 .sysfs_ops = &class_sysfs_ops, 81 .release = class_release, 82 .child_ns_type = class_child_ns_type, 83 }; 84 85 /* Hotplug events for classes go to the class class_subsys */ 86 static struct kset *class_kset; 87 88 89 int class_create_file(struct class *cls, const struct class_attribute *attr) 90 { 91 int error; 92 if (cls) 93 error = sysfs_create_file(&cls->p->class_subsys.kobj, 94 &attr->attr); 95 else 96 error = -EINVAL; 97 return error; 98 } 99 100 void class_remove_file(struct class *cls, const struct class_attribute *attr) 101 { 102 if (cls) 103 sysfs_remove_file(&cls->p->class_subsys.kobj, &attr->attr); 104 } 105 106 static struct class *class_get(struct class *cls) 107 { 108 if (cls) 109 kset_get(&cls->p->class_subsys); 110 return cls; 111 } 112 113 static void class_put(struct class *cls) 114 { 115 if (cls) 116 kset_put(&cls->p->class_subsys); 117 } 118 119 static int add_class_attrs(struct class *cls) 120 { 121 int i; 122 int error = 0; 123 124 if (cls->class_attrs) { 125 for (i = 0; attr_name(cls->class_attrs[i]); i++) { 126 error = class_create_file(cls, &cls->class_attrs[i]); 127 if (error) 128 goto error; 129 } 130 } 131 done: 132 return error; 133 error: 134 while (--i >= 0) 135 class_remove_file(cls, &cls->class_attrs[i]); 136 goto done; 137 } 138 139 static void remove_class_attrs(struct class *cls) 140 { 141 int i; 142 143 if (cls->class_attrs) { 144 for (i = 0; attr_name(cls->class_attrs[i]); i++) 145 class_remove_file(cls, &cls->class_attrs[i]); 146 } 147 } 148 149 static void klist_class_dev_get(struct klist_node *n) 150 { 151 struct device *dev = container_of(n, struct device, knode_class); 152 153 get_device(dev); 154 } 155 156 static void klist_class_dev_put(struct klist_node *n) 157 { 158 struct device *dev = container_of(n, struct device, knode_class); 159 160 put_device(dev); 161 } 162 163 int __class_register(struct class *cls, struct lock_class_key *key) 164 { 165 struct class_private *cp; 166 int error; 167 168 pr_debug("device class '%s': registering\n", cls->name); 169 170 cp = kzalloc(sizeof(*cp), GFP_KERNEL); 171 if (!cp) 172 return -ENOMEM; 173 klist_init(&cp->class_devices, klist_class_dev_get, klist_class_dev_put); 174 INIT_LIST_HEAD(&cp->class_interfaces); 175 kset_init(&cp->class_dirs); 176 __mutex_init(&cp->class_mutex, "struct class mutex", key); 177 error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name); 178 if (error) { 179 kfree(cp); 180 return error; 181 } 182 183 /* set the default /sys/dev directory for devices of this class */ 184 if (!cls->dev_kobj) 185 cls->dev_kobj = sysfs_dev_char_kobj; 186 187 #if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK) 188 /* let the block class directory show up in the root of sysfs */ 189 if (cls != &block_class) 190 cp->class_subsys.kobj.kset = class_kset; 191 #else 192 cp->class_subsys.kobj.kset = class_kset; 193 #endif 194 cp->class_subsys.kobj.ktype = &class_ktype; 195 cp->class = cls; 196 cls->p = cp; 197 198 error = kset_register(&cp->class_subsys); 199 if (error) { 200 kfree(cp); 201 return error; 202 } 203 error = add_class_attrs(class_get(cls)); 204 class_put(cls); 205 return error; 206 } 207 EXPORT_SYMBOL_GPL(__class_register); 208 209 void class_unregister(struct class *cls) 210 { 211 pr_debug("device class '%s': unregistering\n", cls->name); 212 remove_class_attrs(cls); 213 kset_unregister(&cls->p->class_subsys); 214 } 215 216 static void class_create_release(struct class *cls) 217 { 218 pr_debug("%s called for %s\n", __func__, cls->name); 219 kfree(cls); 220 } 221 222 /** 223 * class_create - create a struct class structure 224 * @owner: pointer to the module that is to "own" this struct class 225 * @name: pointer to a string for the name of this class. 226 * @key: the lock_class_key for this class; used by mutex lock debugging 227 * 228 * This is used to create a struct class pointer that can then be used 229 * in calls to device_create(). 230 * 231 * Returns &struct class pointer on success, or ERR_PTR() on error. 232 * 233 * Note, the pointer created here is to be destroyed when finished by 234 * making a call to class_destroy(). 235 */ 236 struct class *__class_create(struct module *owner, const char *name, 237 struct lock_class_key *key) 238 { 239 struct class *cls; 240 int retval; 241 242 cls = kzalloc(sizeof(*cls), GFP_KERNEL); 243 if (!cls) { 244 retval = -ENOMEM; 245 goto error; 246 } 247 248 cls->name = name; 249 cls->owner = owner; 250 cls->class_release = class_create_release; 251 252 retval = __class_register(cls, key); 253 if (retval) 254 goto error; 255 256 return cls; 257 258 error: 259 kfree(cls); 260 return ERR_PTR(retval); 261 } 262 EXPORT_SYMBOL_GPL(__class_create); 263 264 /** 265 * class_destroy - destroys a struct class structure 266 * @cls: pointer to the struct class that is to be destroyed 267 * 268 * Note, the pointer to be destroyed must have been created with a call 269 * to class_create(). 270 */ 271 void class_destroy(struct class *cls) 272 { 273 if ((cls == NULL) || (IS_ERR(cls))) 274 return; 275 276 class_unregister(cls); 277 } 278 279 #ifdef CONFIG_SYSFS_DEPRECATED 280 char *make_class_name(const char *name, struct kobject *kobj) 281 { 282 char *class_name; 283 int size; 284 285 size = strlen(name) + strlen(kobject_name(kobj)) + 2; 286 287 class_name = kmalloc(size, GFP_KERNEL); 288 if (!class_name) 289 return NULL; 290 291 strcpy(class_name, name); 292 strcat(class_name, ":"); 293 strcat(class_name, kobject_name(kobj)); 294 return class_name; 295 } 296 #endif 297 298 /** 299 * class_dev_iter_init - initialize class device iterator 300 * @iter: class iterator to initialize 301 * @class: the class we wanna iterate over 302 * @start: the device to start iterating from, if any 303 * @type: device_type of the devices to iterate over, NULL for all 304 * 305 * Initialize class iterator @iter such that it iterates over devices 306 * of @class. If @start is set, the list iteration will start there, 307 * otherwise if it is NULL, the iteration starts at the beginning of 308 * the list. 309 */ 310 void class_dev_iter_init(struct class_dev_iter *iter, struct class *class, 311 struct device *start, const struct device_type *type) 312 { 313 struct klist_node *start_knode = NULL; 314 315 if (start) 316 start_knode = &start->knode_class; 317 klist_iter_init_node(&class->p->class_devices, &iter->ki, start_knode); 318 iter->type = type; 319 } 320 EXPORT_SYMBOL_GPL(class_dev_iter_init); 321 322 /** 323 * class_dev_iter_next - iterate to the next device 324 * @iter: class iterator to proceed 325 * 326 * Proceed @iter to the next device and return it. Returns NULL if 327 * iteration is complete. 328 * 329 * The returned device is referenced and won't be released till 330 * iterator is proceed to the next device or exited. The caller is 331 * free to do whatever it wants to do with the device including 332 * calling back into class code. 333 */ 334 struct device *class_dev_iter_next(struct class_dev_iter *iter) 335 { 336 struct klist_node *knode; 337 struct device *dev; 338 339 while (1) { 340 knode = klist_next(&iter->ki); 341 if (!knode) 342 return NULL; 343 dev = container_of(knode, struct device, knode_class); 344 if (!iter->type || iter->type == dev->type) 345 return dev; 346 } 347 } 348 EXPORT_SYMBOL_GPL(class_dev_iter_next); 349 350 /** 351 * class_dev_iter_exit - finish iteration 352 * @iter: class iterator to finish 353 * 354 * Finish an iteration. Always call this function after iteration is 355 * complete whether the iteration ran till the end or not. 356 */ 357 void class_dev_iter_exit(struct class_dev_iter *iter) 358 { 359 klist_iter_exit(&iter->ki); 360 } 361 EXPORT_SYMBOL_GPL(class_dev_iter_exit); 362 363 /** 364 * class_for_each_device - device iterator 365 * @class: the class we're iterating 366 * @start: the device to start with in the list, if any. 367 * @data: data for the callback 368 * @fn: function to be called for each device 369 * 370 * Iterate over @class's list of devices, and call @fn for each, 371 * passing it @data. If @start is set, the list iteration will start 372 * there, otherwise if it is NULL, the iteration starts at the 373 * beginning of the list. 374 * 375 * We check the return of @fn each time. If it returns anything 376 * other than 0, we break out and return that value. 377 * 378 * @fn is allowed to do anything including calling back into class 379 * code. There's no locking restriction. 380 */ 381 int class_for_each_device(struct class *class, struct device *start, 382 void *data, int (*fn)(struct device *, void *)) 383 { 384 struct class_dev_iter iter; 385 struct device *dev; 386 int error = 0; 387 388 if (!class) 389 return -EINVAL; 390 if (!class->p) { 391 WARN(1, "%s called for class '%s' before it was initialized", 392 __func__, class->name); 393 return -EINVAL; 394 } 395 396 class_dev_iter_init(&iter, class, start, NULL); 397 while ((dev = class_dev_iter_next(&iter))) { 398 error = fn(dev, data); 399 if (error) 400 break; 401 } 402 class_dev_iter_exit(&iter); 403 404 return error; 405 } 406 EXPORT_SYMBOL_GPL(class_for_each_device); 407 408 /** 409 * class_find_device - device iterator for locating a particular device 410 * @class: the class we're iterating 411 * @start: Device to begin with 412 * @data: data for the match function 413 * @match: function to check device 414 * 415 * This is similar to the class_for_each_dev() function above, but it 416 * returns a reference to a device that is 'found' for later use, as 417 * determined by the @match callback. 418 * 419 * The callback should return 0 if the device doesn't match and non-zero 420 * if it does. If the callback returns non-zero, this function will 421 * return to the caller and not iterate over any more devices. 422 * 423 * Note, you will need to drop the reference with put_device() after use. 424 * 425 * @fn is allowed to do anything including calling back into class 426 * code. There's no locking restriction. 427 */ 428 struct device *class_find_device(struct class *class, struct device *start, 429 void *data, 430 int (*match)(struct device *, void *)) 431 { 432 struct class_dev_iter iter; 433 struct device *dev; 434 435 if (!class) 436 return NULL; 437 if (!class->p) { 438 WARN(1, "%s called for class '%s' before it was initialized", 439 __func__, class->name); 440 return NULL; 441 } 442 443 class_dev_iter_init(&iter, class, start, NULL); 444 while ((dev = class_dev_iter_next(&iter))) { 445 if (match(dev, data)) { 446 get_device(dev); 447 break; 448 } 449 } 450 class_dev_iter_exit(&iter); 451 452 return dev; 453 } 454 EXPORT_SYMBOL_GPL(class_find_device); 455 456 int class_interface_register(struct class_interface *class_intf) 457 { 458 struct class *parent; 459 struct class_dev_iter iter; 460 struct device *dev; 461 462 if (!class_intf || !class_intf->class) 463 return -ENODEV; 464 465 parent = class_get(class_intf->class); 466 if (!parent) 467 return -EINVAL; 468 469 mutex_lock(&parent->p->class_mutex); 470 list_add_tail(&class_intf->node, &parent->p->class_interfaces); 471 if (class_intf->add_dev) { 472 class_dev_iter_init(&iter, parent, NULL, NULL); 473 while ((dev = class_dev_iter_next(&iter))) 474 class_intf->add_dev(dev, class_intf); 475 class_dev_iter_exit(&iter); 476 } 477 mutex_unlock(&parent->p->class_mutex); 478 479 return 0; 480 } 481 482 void class_interface_unregister(struct class_interface *class_intf) 483 { 484 struct class *parent = class_intf->class; 485 struct class_dev_iter iter; 486 struct device *dev; 487 488 if (!parent) 489 return; 490 491 mutex_lock(&parent->p->class_mutex); 492 list_del_init(&class_intf->node); 493 if (class_intf->remove_dev) { 494 class_dev_iter_init(&iter, parent, NULL, NULL); 495 while ((dev = class_dev_iter_next(&iter))) 496 class_intf->remove_dev(dev, class_intf); 497 class_dev_iter_exit(&iter); 498 } 499 mutex_unlock(&parent->p->class_mutex); 500 501 class_put(parent); 502 } 503 504 ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 505 char *buf) 506 { 507 struct class_attribute_string *cs; 508 cs = container_of(attr, struct class_attribute_string, attr); 509 return snprintf(buf, PAGE_SIZE, "%s\n", cs->str); 510 } 511 512 EXPORT_SYMBOL_GPL(show_class_attr_string); 513 514 struct class_compat { 515 struct kobject *kobj; 516 }; 517 518 /** 519 * class_compat_register - register a compatibility class 520 * @name: the name of the class 521 * 522 * Compatibility class are meant as a temporary user-space compatibility 523 * workaround when converting a family of class devices to a bus devices. 524 */ 525 struct class_compat *class_compat_register(const char *name) 526 { 527 struct class_compat *cls; 528 529 cls = kmalloc(sizeof(struct class_compat), GFP_KERNEL); 530 if (!cls) 531 return NULL; 532 cls->kobj = kobject_create_and_add(name, &class_kset->kobj); 533 if (!cls->kobj) { 534 kfree(cls); 535 return NULL; 536 } 537 return cls; 538 } 539 EXPORT_SYMBOL_GPL(class_compat_register); 540 541 /** 542 * class_compat_unregister - unregister a compatibility class 543 * @cls: the class to unregister 544 */ 545 void class_compat_unregister(struct class_compat *cls) 546 { 547 kobject_put(cls->kobj); 548 kfree(cls); 549 } 550 EXPORT_SYMBOL_GPL(class_compat_unregister); 551 552 /** 553 * class_compat_create_link - create a compatibility class device link to 554 * a bus device 555 * @cls: the compatibility class 556 * @dev: the target bus device 557 * @device_link: an optional device to which a "device" link should be created 558 */ 559 int class_compat_create_link(struct class_compat *cls, struct device *dev, 560 struct device *device_link) 561 { 562 int error; 563 564 error = sysfs_create_link(cls->kobj, &dev->kobj, dev_name(dev)); 565 if (error) 566 return error; 567 568 /* 569 * Optionally add a "device" link (typically to the parent), as a 570 * class device would have one and we want to provide as much 571 * backwards compatibility as possible. 572 */ 573 if (device_link) { 574 error = sysfs_create_link(&dev->kobj, &device_link->kobj, 575 "device"); 576 if (error) 577 sysfs_remove_link(cls->kobj, dev_name(dev)); 578 } 579 580 return error; 581 } 582 EXPORT_SYMBOL_GPL(class_compat_create_link); 583 584 /** 585 * class_compat_remove_link - remove a compatibility class device link to 586 * a bus device 587 * @cls: the compatibility class 588 * @dev: the target bus device 589 * @device_link: an optional device to which a "device" link was previously 590 * created 591 */ 592 void class_compat_remove_link(struct class_compat *cls, struct device *dev, 593 struct device *device_link) 594 { 595 if (device_link) 596 sysfs_remove_link(&dev->kobj, "device"); 597 sysfs_remove_link(cls->kobj, dev_name(dev)); 598 } 599 EXPORT_SYMBOL_GPL(class_compat_remove_link); 600 601 int __init classes_init(void) 602 { 603 class_kset = kset_create_and_add("class", NULL, NULL); 604 if (!class_kset) 605 return -ENOMEM; 606 return 0; 607 } 608 609 EXPORT_SYMBOL_GPL(class_create_file); 610 EXPORT_SYMBOL_GPL(class_remove_file); 611 EXPORT_SYMBOL_GPL(class_unregister); 612 EXPORT_SYMBOL_GPL(class_destroy); 613 614 EXPORT_SYMBOL_GPL(class_interface_register); 615 EXPORT_SYMBOL_GPL(class_interface_unregister); 616