drivers/base/class.c

   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/config.h>
  14 #include <linux/device.h>
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/string.h>
  18 #include "base.h"
  19
  20 #define to_class_attr(_attr) container_of(_attr,struct class_attribute,attr)
  21 #define to_class(obj) container_of(obj,struct class,subsys.kset.kobj)
  22
  23 static ssize_t
  24 class_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
  25 {
  26         struct class_attribute * class_attr = to_class_attr(attr);
  27         struct class * dc = to_class(kobj);
  28         ssize_t ret = 0;
  29
  30         if (class_attr->show)
  31                 ret = class_attr->show(dc,buf);
  32         return ret;
  33 }
  34
  35 static ssize_t
  36 class_attr_store(struct kobject * kobj, struct attribute * attr,
  37                  const char * buf, size_t count)
  38 {
  39         struct class_attribute * class_attr = to_class_attr(attr);
  40         struct class * dc = to_class(kobj);
  41         ssize_t ret = 0;
  42
  43         if (class_attr->store)
  44                 ret = class_attr->store(dc,buf,count);
  45         return ret;
  46 }
  47
  48 static void class_release(struct kobject * kobj)
  49 {
  50         struct class *class = to_class(kobj);
  51
  52         pr_debug("class '%s': release.\n", class->name);
  53
  54         if (class->class_release)
  55                 class->class_release(class);
  56         else
  57                 pr_debug("class '%s' does not have a release() function, "
  58                          "be careful\n", class->name);
  59 }
  60
  61 static struct sysfs_ops class_sysfs_ops = {
  62         .show   = class_attr_show,
  63         .store  = class_attr_store,
  64 };
  65
  66 static struct kobj_type ktype_class = {
  67         .sysfs_ops      = &class_sysfs_ops,
  68         .release        = class_release,
  69 };
  70
  71 /* Hotplug events for classes go to the class_obj subsys */
  72 static decl_subsys(class,&ktype_class,NULL);
  73
  74
  75 int class_create_file(struct class * cls, const struct class_attribute * attr)
  76 {
  77         int error;
  78         if (cls) {
  79                 error = sysfs_create_file(&cls->subsys.kset.kobj,&attr->attr);
  80         } else
  81                 error = -EINVAL;
  82         return error;
  83 }
  84
  85 void class_remove_file(struct class * cls, const struct class_attribute * attr)
  86 {
  87         if (cls)
  88                 sysfs_remove_file(&cls->subsys.kset.kobj,&attr->attr);
  89 }
  90
  91 struct class * class_get(struct class * cls)
  92 {
  93         if (cls)
  94                 return container_of(subsys_get(&cls->subsys),struct class,subsys);
  95         return NULL;
  96 }
  97
  98 void class_put(struct class * cls)
  99 {
 100         subsys_put(&cls->subsys);
 101 }
 102
 103 int class_register(struct class * cls)
 104 {
 105         int error;
 106
 107         pr_debug("device class '%s': registering\n",cls->name);
 108
 109         INIT_LIST_HEAD(&cls->children);
 110         INIT_LIST_HEAD(&cls->interfaces);
 111         error = kobject_set_name(&cls->subsys.kset.kobj,cls->name);
 112         if (error)
 113                 return error;
 114
 115         subsys_set_kset(cls,class_subsys);
 116
 117         error = subsystem_register(&cls->subsys);
 118         if (error)
 119                 return error;
 120
 121         return 0;
 122 }
 123
 124 void class_unregister(struct class * cls)
 125 {
 126         pr_debug("device class '%s': unregistering\n",cls->name);
 127         subsystem_unregister(&cls->subsys);
 128 }
 129
 130 /* Class Device Stuff */
 131
 132 int class_device_create_file(struct class_device * class_dev,
 133                              const struct class_device_attribute * attr)
 134 {
 135         int error = -EINVAL;
 136         if (class_dev)
 137                 error = sysfs_create_file(&class_dev->kobj, &attr->attr);
 138         return error;
 139 }
 140
 141 void class_device_remove_file(struct class_device * class_dev,
 142                               const struct class_device_attribute * attr)
 143 {
 144         if (class_dev)
 145                 sysfs_remove_file(&class_dev->kobj, &attr->attr);
 146 }
 147
 148 static int class_device_dev_link(struct class_device * class_dev)
 149 {
 150         if (class_dev->dev)
 151                 return sysfs_create_link(&class_dev->kobj,
 152                                          &class_dev->dev->kobj, "device");
 153         return 0;
 154 }
 155
 156 static void class_device_dev_unlink(struct class_device * class_dev)
 157 {
 158         sysfs_remove_link(&class_dev->kobj, "device");
 159 }
 160
 161 static int class_device_driver_link(struct class_device * class_dev)
 162 {
 163         if ((class_dev->dev) && (class_dev->dev->driver))
 164                 return sysfs_create_link(&class_dev->kobj,
 165                                          &class_dev->dev->driver->kobj, "driver");
 166         return 0;
 167 }
 168
 169 static void class_device_driver_unlink(struct class_device * class_dev)
 170 {
 171         sysfs_remove_link(&class_dev->kobj, "driver");
 172 }
 173
 174
 175 static ssize_t
 176 class_device_attr_show(struct kobject * kobj, struct attribute * attr,
 177                        char * buf)
 178 {
 179         struct class_device_attribute * class_dev_attr = to_class_dev_attr(attr);
 180         struct class_device * cd = to_class_dev(kobj);
 181         ssize_t ret = 0;
 182
 183         if (class_dev_attr->show)
 184                 ret = class_dev_attr->show(cd,buf);
 185         return ret;
 186 }
 187
 188 static ssize_t
 189 class_device_attr_store(struct kobject * kobj, struct attribute * attr,
 190                         const char * buf, size_t count)
 191 {
 192         struct class_device_attribute * class_dev_attr = to_class_dev_attr(attr);
 193         struct class_device * cd = to_class_dev(kobj);
 194         ssize_t ret = 0;
 195
 196         if (class_dev_attr->store)
 197                 ret = class_dev_attr->store(cd,buf,count);
 198         return ret;
 199 }
 200
 201 static struct sysfs_ops class_dev_sysfs_ops = {
 202         .show   = class_device_attr_show,
 203         .store  = class_device_attr_store,
 204 };
 205
 206 static void class_dev_release(struct kobject * kobj)
 207 {
 208         struct class_device *cd = to_class_dev(kobj);
 209         struct class * cls = cd->class;
 210
 211         pr_debug("device class '%s': release.\n",cd->class_id);
 212
 213         if (cls->release)
 214                 cls->release(cd);
 215         else {
 216                 printk(KERN_ERR "Device class '%s' does not have a release() function, "
 217                         "it is broken and must be fixed.\n",
 218                         cd->class_id);
 219                 WARN_ON(1);
 220         }
 221 }
 222
 223 static struct kobj_type ktype_class_device = {
 224         .sysfs_ops      = &class_dev_sysfs_ops,
 225         .release        = class_dev_release,
 226 };
 227
 228 static int class_hotplug_filter(struct kset *kset, struct kobject *kobj)
 229 {
 230         struct kobj_type *ktype = get_ktype(kobj);
 231
 232         if (ktype == &ktype_class_device) {
 233                 struct class_device *class_dev = to_class_dev(kobj);
 234                 if (class_dev->class)
 235                         return 1;
 236         }
 237         return 0;
 238 }
 239
 240 static char *class_hotplug_name(struct kset *kset, struct kobject *kobj)
 241 {
 242         struct class_device *class_dev = to_class_dev(kobj);
 243
 244         return class_dev->class->name;
 245 }
 246
 247 static int class_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
 248                          int num_envp, char *buffer, int buffer_size)
 249 {
 250         struct class_device *class_dev = to_class_dev(kobj);
 251         int retval = 0;
 252
 253         pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
 254         if (class_dev->class->hotplug) {
 255                 /* have the bus specific function add its stuff */
 256                 retval = class_dev->class->hotplug (class_dev, envp, num_envp,
 257                                                     buffer, buffer_size);
 258                         if (retval) {
 259                         pr_debug ("%s - hotplug() returned %d\n",
 260                                   __FUNCTION__, retval);
 261                 }
 262         }
 263
 264         return retval;
 265 }
 266
 267 static struct kset_hotplug_ops class_hotplug_ops = {
 268         .filter =       class_hotplug_filter,
 269         .name =         class_hotplug_name,
 270         .hotplug =      class_hotplug,
 271 };
 272
 273 static decl_subsys(class_obj, &ktype_class_device, &class_hotplug_ops);
 274
 275 void class_device_initialize(struct class_device *class_dev)
 276 {
 277         kobj_set_kset_s(class_dev, class_obj_subsys);
 278         kobject_init(&class_dev->kobj);
 279         INIT_LIST_HEAD(&class_dev->node);
 280 }
 281
 282 int class_device_add(struct class_device *class_dev)
 283 {
 284         struct class * parent;
 285         struct class_interface * class_intf;
 286         int error;
 287
 288         class_dev = class_device_get(class_dev);
 289         if (!class_dev || !strlen(class_dev->class_id))
 290                 return -EINVAL;
 291
 292         parent = class_get(class_dev->class);
 293
 294         pr_debug("CLASS: registering class device: ID = '%s'\n",
 295                  class_dev->class_id);
 296
 297         /* first, register with generic layer. */
 298         kobject_set_name(&class_dev->kobj, class_dev->class_id);
 299         if (parent)
 300                 class_dev->kobj.parent = &parent->subsys.kset.kobj;
 301
 302         if ((error = kobject_add(&class_dev->kobj)))
 303                 goto register_done;
 304
 305         /* now take care of our own registration */
 306         if (parent) {
 307                 down_write(&parent->subsys.rwsem);
 308                 list_add_tail(&class_dev->node, &parent->children);
 309                 list_for_each_entry(class_intf, &parent->interfaces, node)
 310                         if (class_intf->add)
 311                                 class_intf->add(class_dev);
 312                 up_write(&parent->subsys.rwsem);
 313         }
 314
 315         class_device_dev_link(class_dev);
 316         class_device_driver_link(class_dev);
 317
 318  register_done:
 319         if (error && parent)
 320                 class_put(parent);
 321         class_device_put(class_dev);
 322         return error;
 323 }
 324
 325 int class_device_register(struct class_device *class_dev)
 326 {
 327         class_device_initialize(class_dev);
 328         return class_device_add(class_dev);
 329 }
 330
 331 void class_device_del(struct class_device *class_dev)
 332 {
 333         struct class * parent = class_dev->class;
 334         struct class_interface * class_intf;
 335
 336         if (parent) {
 337                 down_write(&parent->subsys.rwsem);
 338                 list_del_init(&class_dev->node);
 339                 list_for_each_entry(class_intf, &parent->interfaces, node)
 340                         if (class_intf->remove)
 341                                 class_intf->remove(class_dev);
 342                 up_write(&parent->subsys.rwsem);
 343         }
 344
 345         class_device_dev_unlink(class_dev);
 346         class_device_driver_unlink(class_dev);
 347
 348         kobject_del(&class_dev->kobj);
 349
 350         if (parent)
 351                 class_put(parent);
 352 }
 353
 354 void class_device_unregister(struct class_device *class_dev)
 355 {
 356         pr_debug("CLASS: Unregistering class device. ID = '%s'\n",
 357                  class_dev->class_id);
 358         class_device_del(class_dev);
 359         class_device_put(class_dev);
 360 }
 361
 362 int class_device_rename(struct class_device *class_dev, char *new_name)
 363 {
 364         int error = 0;
 365
 366         class_dev = class_device_get(class_dev);
 367         if (!class_dev)
 368                 return -EINVAL;
 369
 370         pr_debug("CLASS: renaming '%s' to '%s'\n", class_dev->class_id,
 371                  new_name);
 372
 373         strlcpy(class_dev->class_id, new_name, KOBJ_NAME_LEN);
 374
 375         error = kobject_rename(&class_dev->kobj, new_name);
 376
 377         class_device_put(class_dev);
 378
 379         return error;
 380 }
 381
 382 struct class_device * class_device_get(struct class_device *class_dev)
 383 {
 384         if (class_dev)
 385                 return to_class_dev(kobject_get(&class_dev->kobj));
 386         return NULL;
 387 }
 388
 389 void class_device_put(struct class_device *class_dev)
 390 {
 391         kobject_put(&class_dev->kobj);
 392 }
 393
 394
 395 int class_interface_register(struct class_interface *class_intf)
 396 {
 397         struct class * parent;
 398         struct class_device * class_dev;
 399
 400         if (!class_intf || !class_intf->class)
 401                 return -ENODEV;
 402
 403         parent = class_get(class_intf->class);
 404         if (!parent)
 405                 return -EINVAL;
 406
 407         down_write(&parent->subsys.rwsem);
 408         list_add_tail(&class_intf->node, &parent->interfaces);
 409
 410         if (class_intf->add) {
 411                 list_for_each_entry(class_dev, &parent->children, node)
 412                         class_intf->add(class_dev);
 413         }
 414         up_write(&parent->subsys.rwsem);
 415
 416         return 0;
 417 }
 418
 419 void class_interface_unregister(struct class_interface *class_intf)
 420 {
 421         struct class * parent = class_intf->class;
 422         struct class_device *class_dev;
 423
 424         if (!parent)
 425                 return;
 426
 427         down_write(&parent->subsys.rwsem);
 428         list_del_init(&class_intf->node);
 429
 430         if (class_intf->remove) {
 431                 list_for_each_entry(class_dev, &parent->children, node)
 432                         class_intf->remove(class_dev);
 433         }
 434         up_write(&parent->subsys.rwsem);
 435
 436         class_put(parent);
 437 }
 438
 439
 440
 441 int __init classes_init(void)
 442 {
 443         int retval;
 444
 445         retval = subsystem_register(&class_subsys);
 446         if (retval)
 447                 return retval;
 448
 449         /* ick, this is ugly, the things we go through to keep from showing up
 450          * in sysfs... */
 451         subsystem_init(&class_obj_subsys);
 452         if (!class_obj_subsys.kset.subsys)
 453                         class_obj_subsys.kset.subsys = &class_obj_subsys;
 454         return 0;
 455 }
 456
 457 EXPORT_SYMBOL(class_create_file);
 458 EXPORT_SYMBOL(class_remove_file);
 459 EXPORT_SYMBOL(class_register);
 460 EXPORT_SYMBOL(class_unregister);
 461 EXPORT_SYMBOL(class_get);
 462 EXPORT_SYMBOL(class_put);
 463
 464 EXPORT_SYMBOL(class_device_register);
 465 EXPORT_SYMBOL(class_device_unregister);
 466 EXPORT_SYMBOL(class_device_initialize);
 467 EXPORT_SYMBOL(class_device_add);
 468 EXPORT_SYMBOL(class_device_del);
 469 EXPORT_SYMBOL(class_device_get);
 470 EXPORT_SYMBOL(class_device_put);
 471 EXPORT_SYMBOL(class_device_create_file);
 472 EXPORT_SYMBOL(class_device_remove_file);
 473
 474 EXPORT_SYMBOL(class_interface_register);
 475 EXPORT_SYMBOL(class_interface_unregister);