1 /* 2 * drivers/base/core.c - core driver model code (device registration, etc) 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 7 * Copyright (c) 2006 Novell, Inc. 8 * 9 * This file is released under the GPLv2 10 * 11 */ 12 13 #include <linux/device.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/module.h> 17 #include <linux/slab.h> 18 #include <linux/string.h> 19 #include <linux/kdev_t.h> 20 #include <linux/notifier.h> 21 22 #include <asm/semaphore.h> 23 24 #include "base.h" 25 #include "power/power.h" 26 27 int (*platform_notify)(struct device * dev) = NULL; 28 int (*platform_notify_remove)(struct device * dev) = NULL; 29 30 /* 31 * sysfs bindings for devices. 32 */ 33 34 /** 35 * dev_driver_string - Return a device's driver name, if at all possible 36 * @dev: struct device to get the name of 37 * 38 * Will return the device's driver's name if it is bound to a device. If 39 * the device is not bound to a device, it will return the name of the bus 40 * it is attached to. If it is not attached to a bus either, an empty 41 * string will be returned. 42 */ 43 const char *dev_driver_string(struct device *dev) 44 { 45 return dev->driver ? dev->driver->name : 46 (dev->bus ? dev->bus->name : ""); 47 } 48 EXPORT_SYMBOL(dev_driver_string); 49 50 #define to_dev(obj) container_of(obj, struct device, kobj) 51 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 52 53 static ssize_t 54 dev_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) 55 { 56 struct device_attribute * dev_attr = to_dev_attr(attr); 57 struct device * dev = to_dev(kobj); 58 ssize_t ret = -EIO; 59 60 if (dev_attr->show) 61 ret = dev_attr->show(dev, dev_attr, buf); 62 return ret; 63 } 64 65 static ssize_t 66 dev_attr_store(struct kobject * kobj, struct attribute * attr, 67 const char * buf, size_t count) 68 { 69 struct device_attribute * dev_attr = to_dev_attr(attr); 70 struct device * dev = to_dev(kobj); 71 ssize_t ret = -EIO; 72 73 if (dev_attr->store) 74 ret = dev_attr->store(dev, dev_attr, buf, count); 75 return ret; 76 } 77 78 static struct sysfs_ops dev_sysfs_ops = { 79 .show = dev_attr_show, 80 .store = dev_attr_store, 81 }; 82 83 84 /** 85 * device_release - free device structure. 86 * @kobj: device's kobject. 87 * 88 * This is called once the reference count for the object 89 * reaches 0. We forward the call to the device's release 90 * method, which should handle actually freeing the structure. 91 */ 92 static void device_release(struct kobject * kobj) 93 { 94 struct device * dev = to_dev(kobj); 95 96 if (dev->release) 97 dev->release(dev); 98 else if (dev->type && dev->type->release) 99 dev->type->release(dev); 100 else if (dev->class && dev->class->dev_release) 101 dev->class->dev_release(dev); 102 else { 103 printk(KERN_ERR "Device '%s' does not have a release() function, " 104 "it is broken and must be fixed.\n", 105 dev->bus_id); 106 WARN_ON(1); 107 } 108 } 109 110 static struct kobj_type ktype_device = { 111 .release = device_release, 112 .sysfs_ops = &dev_sysfs_ops, 113 }; 114 115 116 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 117 { 118 struct kobj_type *ktype = get_ktype(kobj); 119 120 if (ktype == &ktype_device) { 121 struct device *dev = to_dev(kobj); 122 if (dev->bus) 123 return 1; 124 if (dev->class) 125 return 1; 126 } 127 return 0; 128 } 129 130 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 131 { 132 struct device *dev = to_dev(kobj); 133 134 if (dev->bus) 135 return dev->bus->name; 136 if (dev->class) 137 return dev->class->name; 138 return NULL; 139 } 140 141 static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp, 142 int num_envp, char *buffer, int buffer_size) 143 { 144 struct device *dev = to_dev(kobj); 145 int i = 0; 146 int length = 0; 147 int retval = 0; 148 149 /* add the major/minor if present */ 150 if (MAJOR(dev->devt)) { 151 add_uevent_var(envp, num_envp, &i, 152 buffer, buffer_size, &length, 153 "MAJOR=%u", MAJOR(dev->devt)); 154 add_uevent_var(envp, num_envp, &i, 155 buffer, buffer_size, &length, 156 "MINOR=%u", MINOR(dev->devt)); 157 } 158 159 if (dev->driver) 160 add_uevent_var(envp, num_envp, &i, 161 buffer, buffer_size, &length, 162 "DRIVER=%s", dev->driver->name); 163 164 #ifdef CONFIG_SYSFS_DEPRECATED 165 if (dev->class) { 166 struct device *parent = dev->parent; 167 168 /* find first bus device in parent chain */ 169 while (parent && !parent->bus) 170 parent = parent->parent; 171 if (parent && parent->bus) { 172 const char *path; 173 174 path = kobject_get_path(&parent->kobj, GFP_KERNEL); 175 add_uevent_var(envp, num_envp, &i, 176 buffer, buffer_size, &length, 177 "PHYSDEVPATH=%s", path); 178 kfree(path); 179 180 add_uevent_var(envp, num_envp, &i, 181 buffer, buffer_size, &length, 182 "PHYSDEVBUS=%s", parent->bus->name); 183 184 if (parent->driver) 185 add_uevent_var(envp, num_envp, &i, 186 buffer, buffer_size, &length, 187 "PHYSDEVDRIVER=%s", parent->driver->name); 188 } 189 } else if (dev->bus) { 190 add_uevent_var(envp, num_envp, &i, 191 buffer, buffer_size, &length, 192 "PHYSDEVBUS=%s", dev->bus->name); 193 194 if (dev->driver) 195 add_uevent_var(envp, num_envp, &i, 196 buffer, buffer_size, &length, 197 "PHYSDEVDRIVER=%s", dev->driver->name); 198 } 199 #endif 200 201 /* terminate, set to next free slot, shrink available space */ 202 envp[i] = NULL; 203 envp = &envp[i]; 204 num_envp -= i; 205 buffer = &buffer[length]; 206 buffer_size -= length; 207 208 if (dev->bus && dev->bus->uevent) { 209 /* have the bus specific function add its stuff */ 210 retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size); 211 if (retval) 212 pr_debug ("%s: bus uevent() returned %d\n", 213 __FUNCTION__, retval); 214 } 215 216 if (dev->class && dev->class->dev_uevent) { 217 /* have the class specific function add its stuff */ 218 retval = dev->class->dev_uevent(dev, envp, num_envp, buffer, buffer_size); 219 if (retval) 220 pr_debug("%s: class uevent() returned %d\n", 221 __FUNCTION__, retval); 222 } 223 224 if (dev->type && dev->type->uevent) { 225 /* have the device type specific fuction add its stuff */ 226 retval = dev->type->uevent(dev, envp, num_envp, buffer, buffer_size); 227 if (retval) 228 pr_debug("%s: dev_type uevent() returned %d\n", 229 __FUNCTION__, retval); 230 } 231 232 return retval; 233 } 234 235 static struct kset_uevent_ops device_uevent_ops = { 236 .filter = dev_uevent_filter, 237 .name = dev_uevent_name, 238 .uevent = dev_uevent, 239 }; 240 241 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr, 242 const char *buf, size_t count) 243 { 244 kobject_uevent(&dev->kobj, KOBJ_ADD); 245 return count; 246 } 247 248 static int device_add_groups(struct device *dev) 249 { 250 int i; 251 int error = 0; 252 253 if (dev->groups) { 254 for (i = 0; dev->groups[i]; i++) { 255 error = sysfs_create_group(&dev->kobj, dev->groups[i]); 256 if (error) { 257 while (--i >= 0) 258 sysfs_remove_group(&dev->kobj, dev->groups[i]); 259 goto out; 260 } 261 } 262 } 263 out: 264 return error; 265 } 266 267 static void device_remove_groups(struct device *dev) 268 { 269 int i; 270 if (dev->groups) { 271 for (i = 0; dev->groups[i]; i++) { 272 sysfs_remove_group(&dev->kobj, dev->groups[i]); 273 } 274 } 275 } 276 277 static int device_add_attrs(struct device *dev) 278 { 279 struct class *class = dev->class; 280 struct device_type *type = dev->type; 281 int error = 0; 282 int i; 283 284 if (class && class->dev_attrs) { 285 for (i = 0; attr_name(class->dev_attrs[i]); i++) { 286 error = device_create_file(dev, &class->dev_attrs[i]); 287 if (error) 288 break; 289 } 290 if (error) 291 while (--i >= 0) 292 device_remove_file(dev, &class->dev_attrs[i]); 293 } 294 295 if (type && type->attrs) { 296 for (i = 0; attr_name(type->attrs[i]); i++) { 297 error = device_create_file(dev, &type->attrs[i]); 298 if (error) 299 break; 300 } 301 if (error) 302 while (--i >= 0) 303 device_remove_file(dev, &type->attrs[i]); 304 } 305 306 return error; 307 } 308 309 static void device_remove_attrs(struct device *dev) 310 { 311 struct class *class = dev->class; 312 struct device_type *type = dev->type; 313 int i; 314 315 if (class && class->dev_attrs) { 316 for (i = 0; attr_name(class->dev_attrs[i]); i++) 317 device_remove_file(dev, &class->dev_attrs[i]); 318 } 319 320 if (type && type->attrs) { 321 for (i = 0; attr_name(type->attrs[i]); i++) 322 device_remove_file(dev, &type->attrs[i]); 323 } 324 } 325 326 327 static ssize_t show_dev(struct device *dev, struct device_attribute *attr, 328 char *buf) 329 { 330 return print_dev_t(buf, dev->devt); 331 } 332 333 /* 334 * devices_subsys - structure to be registered with kobject core. 335 */ 336 337 decl_subsys(devices, &ktype_device, &device_uevent_ops); 338 339 340 /** 341 * device_create_file - create sysfs attribute file for device. 342 * @dev: device. 343 * @attr: device attribute descriptor. 344 */ 345 346 int device_create_file(struct device * dev, struct device_attribute * attr) 347 { 348 int error = 0; 349 if (get_device(dev)) { 350 error = sysfs_create_file(&dev->kobj, &attr->attr); 351 put_device(dev); 352 } 353 return error; 354 } 355 356 /** 357 * device_remove_file - remove sysfs attribute file. 358 * @dev: device. 359 * @attr: device attribute descriptor. 360 */ 361 362 void device_remove_file(struct device * dev, struct device_attribute * attr) 363 { 364 if (get_device(dev)) { 365 sysfs_remove_file(&dev->kobj, &attr->attr); 366 put_device(dev); 367 } 368 } 369 370 /** 371 * device_create_bin_file - create sysfs binary attribute file for device. 372 * @dev: device. 373 * @attr: device binary attribute descriptor. 374 */ 375 int device_create_bin_file(struct device *dev, struct bin_attribute *attr) 376 { 377 int error = -EINVAL; 378 if (dev) 379 error = sysfs_create_bin_file(&dev->kobj, attr); 380 return error; 381 } 382 EXPORT_SYMBOL_GPL(device_create_bin_file); 383 384 /** 385 * device_remove_bin_file - remove sysfs binary attribute file 386 * @dev: device. 387 * @attr: device binary attribute descriptor. 388 */ 389 void device_remove_bin_file(struct device *dev, struct bin_attribute *attr) 390 { 391 if (dev) 392 sysfs_remove_bin_file(&dev->kobj, attr); 393 } 394 EXPORT_SYMBOL_GPL(device_remove_bin_file); 395 396 static void klist_children_get(struct klist_node *n) 397 { 398 struct device *dev = container_of(n, struct device, knode_parent); 399 400 get_device(dev); 401 } 402 403 static void klist_children_put(struct klist_node *n) 404 { 405 struct device *dev = container_of(n, struct device, knode_parent); 406 407 put_device(dev); 408 } 409 410 411 /** 412 * device_initialize - init device structure. 413 * @dev: device. 414 * 415 * This prepares the device for use by other layers, 416 * including adding it to the device hierarchy. 417 * It is the first half of device_register(), if called by 418 * that, though it can also be called separately, so one 419 * may use @dev's fields (e.g. the refcount). 420 */ 421 422 void device_initialize(struct device *dev) 423 { 424 kobj_set_kset_s(dev, devices_subsys); 425 kobject_init(&dev->kobj); 426 klist_init(&dev->klist_children, klist_children_get, 427 klist_children_put); 428 INIT_LIST_HEAD(&dev->dma_pools); 429 INIT_LIST_HEAD(&dev->node); 430 init_MUTEX(&dev->sem); 431 device_init_wakeup(dev, 0); 432 set_dev_node(dev, -1); 433 } 434 435 #ifdef CONFIG_SYSFS_DEPRECATED 436 static struct kobject * get_device_parent(struct device *dev, 437 struct device *parent) 438 { 439 /* Set the parent to the class, not the parent device */ 440 /* this keeps sysfs from having a symlink to make old udevs happy */ 441 if (dev->class) 442 return &dev->class->subsys.kset.kobj; 443 else if (parent) 444 return &parent->kobj; 445 446 return NULL; 447 } 448 #else 449 static struct kobject * virtual_device_parent(struct device *dev) 450 { 451 if (!dev->class) 452 return ERR_PTR(-ENODEV); 453 454 if (!dev->class->virtual_dir) { 455 static struct kobject *virtual_dir = NULL; 456 457 if (!virtual_dir) 458 virtual_dir = kobject_add_dir(&devices_subsys.kset.kobj, "virtual"); 459 dev->class->virtual_dir = kobject_add_dir(virtual_dir, dev->class->name); 460 } 461 462 return dev->class->virtual_dir; 463 } 464 465 static struct kobject * get_device_parent(struct device *dev, 466 struct device *parent) 467 { 468 /* if this is a class device, and has no parent, create one */ 469 if ((dev->class) && (parent == NULL)) { 470 return virtual_device_parent(dev); 471 } else if (parent) 472 return &parent->kobj; 473 return NULL; 474 } 475 476 #endif 477 static int setup_parent(struct device *dev, struct device *parent) 478 { 479 struct kobject *kobj; 480 kobj = get_device_parent(dev, parent); 481 if (IS_ERR(kobj)) 482 return PTR_ERR(kobj); 483 if (kobj) 484 dev->kobj.parent = kobj; 485 return 0; 486 } 487 488 /** 489 * device_add - add device to device hierarchy. 490 * @dev: device. 491 * 492 * This is part 2 of device_register(), though may be called 493 * separately _iff_ device_initialize() has been called separately. 494 * 495 * This adds it to the kobject hierarchy via kobject_add(), adds it 496 * to the global and sibling lists for the device, then 497 * adds it to the other relevant subsystems of the driver model. 498 */ 499 int device_add(struct device *dev) 500 { 501 struct device *parent = NULL; 502 char *class_name = NULL; 503 struct class_interface *class_intf; 504 int error = -EINVAL; 505 506 dev = get_device(dev); 507 if (!dev || !strlen(dev->bus_id)) 508 goto Error; 509 510 pr_debug("DEV: registering device: ID = '%s'\n", dev->bus_id); 511 512 parent = get_device(dev->parent); 513 514 error = setup_parent(dev, parent); 515 if (error) 516 goto Error; 517 518 /* first, register with generic layer. */ 519 kobject_set_name(&dev->kobj, "%s", dev->bus_id); 520 error = kobject_add(&dev->kobj); 521 if (error) 522 goto Error; 523 524 /* notify platform of device entry */ 525 if (platform_notify) 526 platform_notify(dev); 527 528 /* notify clients of device entry (new way) */ 529 if (dev->bus) 530 blocking_notifier_call_chain(&dev->bus->bus_notifier, 531 BUS_NOTIFY_ADD_DEVICE, dev); 532 533 dev->uevent_attr.attr.name = "uevent"; 534 dev->uevent_attr.attr.mode = S_IWUSR; 535 if (dev->driver) 536 dev->uevent_attr.attr.owner = dev->driver->owner; 537 dev->uevent_attr.store = store_uevent; 538 error = device_create_file(dev, &dev->uevent_attr); 539 if (error) 540 goto attrError; 541 542 if (MAJOR(dev->devt)) { 543 struct device_attribute *attr; 544 attr = kzalloc(sizeof(*attr), GFP_KERNEL); 545 if (!attr) { 546 error = -ENOMEM; 547 goto ueventattrError; 548 } 549 attr->attr.name = "dev"; 550 attr->attr.mode = S_IRUGO; 551 if (dev->driver) 552 attr->attr.owner = dev->driver->owner; 553 attr->show = show_dev; 554 error = device_create_file(dev, attr); 555 if (error) { 556 kfree(attr); 557 goto ueventattrError; 558 } 559 560 dev->devt_attr = attr; 561 } 562 563 if (dev->class) { 564 sysfs_create_link(&dev->kobj, &dev->class->subsys.kset.kobj, 565 "subsystem"); 566 /* If this is not a "fake" compatible device, then create the 567 * symlink from the class to the device. */ 568 if (dev->kobj.parent != &dev->class->subsys.kset.kobj) 569 sysfs_create_link(&dev->class->subsys.kset.kobj, 570 &dev->kobj, dev->bus_id); 571 #ifdef CONFIG_SYSFS_DEPRECATED 572 if (parent) { 573 sysfs_create_link(&dev->kobj, &dev->parent->kobj, 574 "device"); 575 class_name = make_class_name(dev->class->name, 576 &dev->kobj); 577 if (class_name) 578 sysfs_create_link(&dev->parent->kobj, 579 &dev->kobj, class_name); 580 } 581 #endif 582 } 583 584 if ((error = device_add_attrs(dev))) 585 goto AttrsError; 586 if ((error = device_add_groups(dev))) 587 goto GroupError; 588 if ((error = device_pm_add(dev))) 589 goto PMError; 590 if ((error = bus_add_device(dev))) 591 goto BusError; 592 if (!dev->uevent_suppress) 593 kobject_uevent(&dev->kobj, KOBJ_ADD); 594 if ((error = bus_attach_device(dev))) 595 goto AttachError; 596 if (parent) 597 klist_add_tail(&dev->knode_parent, &parent->klist_children); 598 599 if (dev->class) { 600 down(&dev->class->sem); 601 /* tie the class to the device */ 602 list_add_tail(&dev->node, &dev->class->devices); 603 604 /* notify any interfaces that the device is here */ 605 list_for_each_entry(class_intf, &dev->class->interfaces, node) 606 if (class_intf->add_dev) 607 class_intf->add_dev(dev, class_intf); 608 up(&dev->class->sem); 609 } 610 Done: 611 kfree(class_name); 612 put_device(dev); 613 return error; 614 AttachError: 615 bus_remove_device(dev); 616 BusError: 617 device_pm_remove(dev); 618 PMError: 619 if (dev->bus) 620 blocking_notifier_call_chain(&dev->bus->bus_notifier, 621 BUS_NOTIFY_DEL_DEVICE, dev); 622 device_remove_groups(dev); 623 GroupError: 624 device_remove_attrs(dev); 625 AttrsError: 626 if (dev->devt_attr) { 627 device_remove_file(dev, dev->devt_attr); 628 kfree(dev->devt_attr); 629 } 630 ueventattrError: 631 device_remove_file(dev, &dev->uevent_attr); 632 attrError: 633 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 634 kobject_del(&dev->kobj); 635 Error: 636 if (parent) 637 put_device(parent); 638 goto Done; 639 } 640 641 642 /** 643 * device_register - register a device with the system. 644 * @dev: pointer to the device structure 645 * 646 * This happens in two clean steps - initialize the device 647 * and add it to the system. The two steps can be called 648 * separately, but this is the easiest and most common. 649 * I.e. you should only call the two helpers separately if 650 * have a clearly defined need to use and refcount the device 651 * before it is added to the hierarchy. 652 */ 653 654 int device_register(struct device *dev) 655 { 656 device_initialize(dev); 657 return device_add(dev); 658 } 659 660 661 /** 662 * get_device - increment reference count for device. 663 * @dev: device. 664 * 665 * This simply forwards the call to kobject_get(), though 666 * we do take care to provide for the case that we get a NULL 667 * pointer passed in. 668 */ 669 670 struct device * get_device(struct device * dev) 671 { 672 return dev ? to_dev(kobject_get(&dev->kobj)) : NULL; 673 } 674 675 676 /** 677 * put_device - decrement reference count. 678 * @dev: device in question. 679 */ 680 void put_device(struct device * dev) 681 { 682 if (dev) 683 kobject_put(&dev->kobj); 684 } 685 686 687 /** 688 * device_del - delete device from system. 689 * @dev: device. 690 * 691 * This is the first part of the device unregistration 692 * sequence. This removes the device from the lists we control 693 * from here, has it removed from the other driver model 694 * subsystems it was added to in device_add(), and removes it 695 * from the kobject hierarchy. 696 * 697 * NOTE: this should be called manually _iff_ device_add() was 698 * also called manually. 699 */ 700 701 void device_del(struct device * dev) 702 { 703 struct device * parent = dev->parent; 704 struct class_interface *class_intf; 705 706 if (parent) 707 klist_del(&dev->knode_parent); 708 if (dev->devt_attr) { 709 device_remove_file(dev, dev->devt_attr); 710 kfree(dev->devt_attr); 711 } 712 if (dev->class) { 713 sysfs_remove_link(&dev->kobj, "subsystem"); 714 /* If this is not a "fake" compatible device, remove the 715 * symlink from the class to the device. */ 716 if (dev->kobj.parent != &dev->class->subsys.kset.kobj) 717 sysfs_remove_link(&dev->class->subsys.kset.kobj, 718 dev->bus_id); 719 #ifdef CONFIG_SYSFS_DEPRECATED 720 if (parent) { 721 char *class_name = make_class_name(dev->class->name, 722 &dev->kobj); 723 if (class_name) 724 sysfs_remove_link(&dev->parent->kobj, 725 class_name); 726 kfree(class_name); 727 sysfs_remove_link(&dev->kobj, "device"); 728 } 729 #endif 730 731 down(&dev->class->sem); 732 /* notify any interfaces that the device is now gone */ 733 list_for_each_entry(class_intf, &dev->class->interfaces, node) 734 if (class_intf->remove_dev) 735 class_intf->remove_dev(dev, class_intf); 736 /* remove the device from the class list */ 737 list_del_init(&dev->node); 738 up(&dev->class->sem); 739 } 740 device_remove_file(dev, &dev->uevent_attr); 741 device_remove_groups(dev); 742 device_remove_attrs(dev); 743 bus_remove_device(dev); 744 745 /* Notify the platform of the removal, in case they 746 * need to do anything... 747 */ 748 if (platform_notify_remove) 749 platform_notify_remove(dev); 750 if (dev->bus) 751 blocking_notifier_call_chain(&dev->bus->bus_notifier, 752 BUS_NOTIFY_DEL_DEVICE, dev); 753 device_pm_remove(dev); 754 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 755 kobject_del(&dev->kobj); 756 if (parent) 757 put_device(parent); 758 } 759 760 /** 761 * device_unregister - unregister device from system. 762 * @dev: device going away. 763 * 764 * We do this in two parts, like we do device_register(). First, 765 * we remove it from all the subsystems with device_del(), then 766 * we decrement the reference count via put_device(). If that 767 * is the final reference count, the device will be cleaned up 768 * via device_release() above. Otherwise, the structure will 769 * stick around until the final reference to the device is dropped. 770 */ 771 void device_unregister(struct device * dev) 772 { 773 pr_debug("DEV: Unregistering device. ID = '%s'\n", dev->bus_id); 774 device_del(dev); 775 put_device(dev); 776 } 777 778 779 static struct device * next_device(struct klist_iter * i) 780 { 781 struct klist_node * n = klist_next(i); 782 return n ? container_of(n, struct device, knode_parent) : NULL; 783 } 784 785 /** 786 * device_for_each_child - device child iterator. 787 * @parent: parent struct device. 788 * @data: data for the callback. 789 * @fn: function to be called for each device. 790 * 791 * Iterate over @parent's child devices, and call @fn for each, 792 * passing it @data. 793 * 794 * We check the return of @fn each time. If it returns anything 795 * other than 0, we break out and return that value. 796 */ 797 int device_for_each_child(struct device * parent, void * data, 798 int (*fn)(struct device *, void *)) 799 { 800 struct klist_iter i; 801 struct device * child; 802 int error = 0; 803 804 klist_iter_init(&parent->klist_children, &i); 805 while ((child = next_device(&i)) && !error) 806 error = fn(child, data); 807 klist_iter_exit(&i); 808 return error; 809 } 810 811 /** 812 * device_find_child - device iterator for locating a particular device. 813 * @parent: parent struct device 814 * @data: Data to pass to match function 815 * @match: Callback function to check device 816 * 817 * This is similar to the device_for_each_child() function above, but it 818 * returns a reference to a device that is 'found' for later use, as 819 * determined by the @match callback. 820 * 821 * The callback should return 0 if the device doesn't match and non-zero 822 * if it does. If the callback returns non-zero and a reference to the 823 * current device can be obtained, this function will return to the caller 824 * and not iterate over any more devices. 825 */ 826 struct device * device_find_child(struct device *parent, void *data, 827 int (*match)(struct device *, void *)) 828 { 829 struct klist_iter i; 830 struct device *child; 831 832 if (!parent) 833 return NULL; 834 835 klist_iter_init(&parent->klist_children, &i); 836 while ((child = next_device(&i))) 837 if (match(child, data) && get_device(child)) 838 break; 839 klist_iter_exit(&i); 840 return child; 841 } 842 843 int __init devices_init(void) 844 { 845 return subsystem_register(&devices_subsys); 846 } 847 848 EXPORT_SYMBOL_GPL(device_for_each_child); 849 EXPORT_SYMBOL_GPL(device_find_child); 850 851 EXPORT_SYMBOL_GPL(device_initialize); 852 EXPORT_SYMBOL_GPL(device_add); 853 EXPORT_SYMBOL_GPL(device_register); 854 855 EXPORT_SYMBOL_GPL(device_del); 856 EXPORT_SYMBOL_GPL(device_unregister); 857 EXPORT_SYMBOL_GPL(get_device); 858 EXPORT_SYMBOL_GPL(put_device); 859 860 EXPORT_SYMBOL_GPL(device_create_file); 861 EXPORT_SYMBOL_GPL(device_remove_file); 862 863 864 static void device_create_release(struct device *dev) 865 { 866 pr_debug("%s called for %s\n", __FUNCTION__, dev->bus_id); 867 kfree(dev); 868 } 869 870 /** 871 * device_create - creates a device and registers it with sysfs 872 * @class: pointer to the struct class that this device should be registered to 873 * @parent: pointer to the parent struct device of this new device, if any 874 * @devt: the dev_t for the char device to be added 875 * @fmt: string for the device's name 876 * 877 * This function can be used by char device classes. A struct device 878 * will be created in sysfs, registered to the specified class. 879 * 880 * A "dev" file will be created, showing the dev_t for the device, if 881 * the dev_t is not 0,0. 882 * If a pointer to a parent struct device is passed in, the newly created 883 * struct device will be a child of that device in sysfs. 884 * The pointer to the struct device will be returned from the call. 885 * Any further sysfs files that might be required can be created using this 886 * pointer. 887 * 888 * Note: the struct class passed to this function must have previously 889 * been created with a call to class_create(). 890 */ 891 struct device *device_create(struct class *class, struct device *parent, 892 dev_t devt, const char *fmt, ...) 893 { 894 va_list args; 895 struct device *dev = NULL; 896 int retval = -ENODEV; 897 898 if (class == NULL || IS_ERR(class)) 899 goto error; 900 901 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 902 if (!dev) { 903 retval = -ENOMEM; 904 goto error; 905 } 906 907 dev->devt = devt; 908 dev->class = class; 909 dev->parent = parent; 910 dev->release = device_create_release; 911 912 va_start(args, fmt); 913 vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args); 914 va_end(args); 915 retval = device_register(dev); 916 if (retval) 917 goto error; 918 919 return dev; 920 921 error: 922 kfree(dev); 923 return ERR_PTR(retval); 924 } 925 EXPORT_SYMBOL_GPL(device_create); 926 927 /** 928 * device_destroy - removes a device that was created with device_create() 929 * @class: pointer to the struct class that this device was registered with 930 * @devt: the dev_t of the device that was previously registered 931 * 932 * This call unregisters and cleans up a device that was created with a 933 * call to device_create(). 934 */ 935 void device_destroy(struct class *class, dev_t devt) 936 { 937 struct device *dev = NULL; 938 struct device *dev_tmp; 939 940 down(&class->sem); 941 list_for_each_entry(dev_tmp, &class->devices, node) { 942 if (dev_tmp->devt == devt) { 943 dev = dev_tmp; 944 break; 945 } 946 } 947 up(&class->sem); 948 949 if (dev) 950 device_unregister(dev); 951 } 952 EXPORT_SYMBOL_GPL(device_destroy); 953 954 /** 955 * device_rename - renames a device 956 * @dev: the pointer to the struct device to be renamed 957 * @new_name: the new name of the device 958 */ 959 int device_rename(struct device *dev, char *new_name) 960 { 961 char *old_class_name = NULL; 962 char *new_class_name = NULL; 963 char *old_symlink_name = NULL; 964 int error; 965 966 dev = get_device(dev); 967 if (!dev) 968 return -EINVAL; 969 970 pr_debug("DEVICE: renaming '%s' to '%s'\n", dev->bus_id, new_name); 971 972 #ifdef CONFIG_SYSFS_DEPRECATED 973 if ((dev->class) && (dev->parent)) 974 old_class_name = make_class_name(dev->class->name, &dev->kobj); 975 #endif 976 977 if (dev->class) { 978 old_symlink_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL); 979 if (!old_symlink_name) { 980 error = -ENOMEM; 981 goto out_free_old_class; 982 } 983 strlcpy(old_symlink_name, dev->bus_id, BUS_ID_SIZE); 984 } 985 986 strlcpy(dev->bus_id, new_name, BUS_ID_SIZE); 987 988 error = kobject_rename(&dev->kobj, new_name); 989 990 #ifdef CONFIG_SYSFS_DEPRECATED 991 if (old_class_name) { 992 new_class_name = make_class_name(dev->class->name, &dev->kobj); 993 if (new_class_name) { 994 sysfs_create_link(&dev->parent->kobj, &dev->kobj, 995 new_class_name); 996 sysfs_remove_link(&dev->parent->kobj, old_class_name); 997 } 998 } 999 #endif 1000 1001 if (dev->class) { 1002 sysfs_remove_link(&dev->class->subsys.kset.kobj, 1003 old_symlink_name); 1004 sysfs_create_link(&dev->class->subsys.kset.kobj, &dev->kobj, 1005 dev->bus_id); 1006 } 1007 put_device(dev); 1008 1009 kfree(new_class_name); 1010 kfree(old_symlink_name); 1011 out_free_old_class: 1012 kfree(old_class_name); 1013 1014 return error; 1015 } 1016 1017 1018 static int device_move_class_links(struct device *dev, 1019 struct device *old_parent, 1020 struct device *new_parent) 1021 { 1022 #ifdef CONFIG_SYSFS_DEPRECATED 1023 int error; 1024 char *class_name; 1025 1026 class_name = make_class_name(dev->class->name, &dev->kobj); 1027 if (!class_name) { 1028 error = -ENOMEM; 1029 goto out; 1030 } 1031 if (old_parent) { 1032 sysfs_remove_link(&dev->kobj, "device"); 1033 sysfs_remove_link(&old_parent->kobj, class_name); 1034 } 1035 if (new_parent) { 1036 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1037 "device"); 1038 if (error) 1039 goto out; 1040 error = sysfs_create_link(&new_parent->kobj, &dev->kobj, 1041 class_name); 1042 if (error) 1043 sysfs_remove_link(&dev->kobj, "device"); 1044 } 1045 else 1046 error = 0; 1047 out: 1048 kfree(class_name); 1049 return error; 1050 #else 1051 return 0; 1052 #endif 1053 } 1054 1055 /** 1056 * device_move - moves a device to a new parent 1057 * @dev: the pointer to the struct device to be moved 1058 * @new_parent: the new parent of the device (can by NULL) 1059 */ 1060 int device_move(struct device *dev, struct device *new_parent) 1061 { 1062 int error; 1063 struct device *old_parent; 1064 struct kobject *new_parent_kobj; 1065 1066 dev = get_device(dev); 1067 if (!dev) 1068 return -EINVAL; 1069 1070 new_parent = get_device(new_parent); 1071 new_parent_kobj = get_device_parent (dev, new_parent); 1072 if (IS_ERR(new_parent_kobj)) { 1073 error = PTR_ERR(new_parent_kobj); 1074 put_device(new_parent); 1075 goto out; 1076 } 1077 pr_debug("DEVICE: moving '%s' to '%s'\n", dev->bus_id, 1078 new_parent ? new_parent->bus_id : "<NULL>"); 1079 error = kobject_move(&dev->kobj, new_parent_kobj); 1080 if (error) { 1081 put_device(new_parent); 1082 goto out; 1083 } 1084 old_parent = dev->parent; 1085 dev->parent = new_parent; 1086 if (old_parent) 1087 klist_remove(&dev->knode_parent); 1088 if (new_parent) 1089 klist_add_tail(&dev->knode_parent, &new_parent->klist_children); 1090 if (!dev->class) 1091 goto out_put; 1092 error = device_move_class_links(dev, old_parent, new_parent); 1093 if (error) { 1094 /* We ignore errors on cleanup since we're hosed anyway... */ 1095 device_move_class_links(dev, new_parent, old_parent); 1096 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 1097 if (new_parent) 1098 klist_remove(&dev->knode_parent); 1099 if (old_parent) 1100 klist_add_tail(&dev->knode_parent, 1101 &old_parent->klist_children); 1102 } 1103 put_device(new_parent); 1104 goto out; 1105 } 1106 out_put: 1107 put_device(old_parent); 1108 out: 1109 put_device(dev); 1110 return error; 1111 } 1112 1113 EXPORT_SYMBOL_GPL(device_move); 1114