sys.c 13.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * sys.c - pseudo-bus for system 'devices' (cpus, PICs, timers, etc)
 *
 * Copyright (c) 2002-3 Patrick Mochel
 *               2002-3 Open Source Development Lab
 *
 * This file is released under the GPLv2
 *
 * This exports a 'system' bus type.
 * By default, a 'sys' bus gets added to the root of the system. There will
 * always be core system devices. Devices can use sysdev_register() to
 * add themselves as children of the system bus.
 */

#include <linux/sysdev.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/string.h>
22
#include <linux/pm.h>
23
#include <linux/device.h>
24
#include <linux/mutex.h>
25
#include <linux/interrupt.h>
L
Linus Torvalds 已提交
26

27 28
#include "base.h"

L
Linus Torvalds 已提交
29 30 31 32 33
#define to_sysdev(k) container_of(k, struct sys_device, kobj)
#define to_sysdev_attr(a) container_of(a, struct sysdev_attribute, attr)


static ssize_t
34
sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
L
Linus Torvalds 已提交
35
{
36 37
	struct sys_device *sysdev = to_sysdev(kobj);
	struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
L
Linus Torvalds 已提交
38 39

	if (sysdev_attr->show)
40
		return sysdev_attr->show(sysdev, sysdev_attr, buffer);
41
	return -EIO;
L
Linus Torvalds 已提交
42 43 44 45
}


static ssize_t
46 47
sysdev_store(struct kobject *kobj, struct attribute *attr,
	     const char *buffer, size_t count)
L
Linus Torvalds 已提交
48
{
49 50
	struct sys_device *sysdev = to_sysdev(kobj);
	struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
L
Linus Torvalds 已提交
51 52

	if (sysdev_attr->store)
53
		return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
54
	return -EIO;
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63 64 65 66
}

static struct sysfs_ops sysfs_ops = {
	.show	= sysdev_show,
	.store	= sysdev_store,
};

static struct kobj_type ktype_sysdev = {
	.sysfs_ops	= &sysfs_ops,
};


67
int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
L
Linus Torvalds 已提交
68 69 70 71 72
{
	return sysfs_create_file(&s->kobj, &a->attr);
}


73
void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
L
Linus Torvalds 已提交
74 75 76 77 78 79 80
{
	sysfs_remove_file(&s->kobj, &a->attr);
}

EXPORT_SYMBOL_GPL(sysdev_create_file);
EXPORT_SYMBOL_GPL(sysdev_remove_file);

81 82 83 84 85 86 87
#define to_sysdev_class(k) container_of(k, struct sysdev_class, kset.kobj)
#define to_sysdev_class_attr(a) container_of(a, \
	struct sysdev_class_attribute, attr)

static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
				 char *buffer)
{
88
	struct sysdev_class *class = to_sysdev_class(kobj);
89 90 91 92 93 94 95 96 97 98
	struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);

	if (class_attr->show)
		return class_attr->show(class, buffer);
	return -EIO;
}

static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
				  const char *buffer, size_t count)
{
99 100
	struct sysdev_class *class = to_sysdev_class(kobj);
	struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129

	if (class_attr->store)
		return class_attr->store(class, buffer, count);
	return -EIO;
}

static struct sysfs_ops sysfs_class_ops = {
	.show	= sysdev_class_show,
	.store	= sysdev_class_store,
};

static struct kobj_type ktype_sysdev_class = {
	.sysfs_ops	= &sysfs_class_ops,
};

int sysdev_class_create_file(struct sysdev_class *c,
			     struct sysdev_class_attribute *a)
{
	return sysfs_create_file(&c->kset.kobj, &a->attr);
}
EXPORT_SYMBOL_GPL(sysdev_class_create_file);

void sysdev_class_remove_file(struct sysdev_class *c,
			      struct sysdev_class_attribute *a)
{
	sysfs_remove_file(&c->kset.kobj, &a->attr);
}
EXPORT_SYMBOL_GPL(sysdev_class_remove_file);

130
static struct kset *system_kset;
L
Linus Torvalds 已提交
131

132
int sysdev_class_register(struct sysdev_class *cls)
L
Linus Torvalds 已提交
133
{
134 135
	pr_debug("Registering sysdev class '%s'\n", cls->name);

L
Linus Torvalds 已提交
136
	INIT_LIST_HEAD(&cls->drivers);
137
	memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
138
	cls->kset.kobj.parent = &system_kset->kobj;
139
	cls->kset.kobj.ktype = &ktype_sysdev_class;
140
	cls->kset.kobj.kset = system_kset;
141
	kobject_set_name(&cls->kset.kobj, cls->name);
L
Linus Torvalds 已提交
142 143 144
	return kset_register(&cls->kset);
}

145
void sysdev_class_unregister(struct sysdev_class *cls)
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153 154
{
	pr_debug("Unregistering sysdev class '%s'\n",
		 kobject_name(&cls->kset.kobj));
	kset_unregister(&cls->kset);
}

EXPORT_SYMBOL_GPL(sysdev_class_register);
EXPORT_SYMBOL_GPL(sysdev_class_unregister);

155
static DEFINE_MUTEX(sysdev_drivers_lock);
L
Linus Torvalds 已提交
156 157 158

/**
 *	sysdev_driver_register - Register auxillary driver
159
 *	@cls:	Device class driver belongs to.
L
Linus Torvalds 已提交
160 161
 *	@drv:	Driver.
 *
162
 *	@drv is inserted into @cls->drivers to be
L
Linus Torvalds 已提交
163 164 165 166
 *	called on each operation on devices of that class. The refcount
 *	of @cls is incremented.
 */

167
int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
L
Linus Torvalds 已提交
168
{
169 170
	int err = 0;

171
	if (!cls) {
A
Arjan van de Ven 已提交
172
		WARN(1, KERN_WARNING "sysdev: invalid class passed to "
173 174 175 176 177
			"sysdev_driver_register!\n");
		return -EINVAL;
	}

	/* Check whether this driver has already been added to a class. */
A
Arjan van de Ven 已提交
178 179
	if (drv->entry.next && !list_empty(&drv->entry))
		WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
180 181 182
			" been registered to a class, something is wrong, but "
			"will forge on!\n", cls->name, drv);

183
	mutex_lock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
184 185 186 187 188 189 190 191 192
	if (cls && kset_get(&cls->kset)) {
		list_add_tail(&drv->entry, &cls->drivers);

		/* If devices of this class already exist, tell the driver */
		if (drv->add) {
			struct sys_device *dev;
			list_for_each_entry(dev, &cls->kset.list, kobj.entry)
				drv->add(dev);
		}
193 194
	} else {
		err = -EINVAL;
A
Arjan van de Ven 已提交
195
		WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
196
	}
197
	mutex_unlock(&sysdev_drivers_lock);
198
	return err;
L
Linus Torvalds 已提交
199 200 201 202 203 204 205 206
}


/**
 *	sysdev_driver_unregister - Remove an auxillary driver.
 *	@cls:	Class driver belongs to.
 *	@drv:	Driver.
 */
207 208
void sysdev_driver_unregister(struct sysdev_class *cls,
			      struct sysdev_driver *drv)
L
Linus Torvalds 已提交
209
{
210
	mutex_lock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
211 212 213 214 215 216 217 218 219
	list_del_init(&drv->entry);
	if (cls) {
		if (drv->remove) {
			struct sys_device *dev;
			list_for_each_entry(dev, &cls->kset.list, kobj.entry)
				drv->remove(dev);
		}
		kset_put(&cls->kset);
	}
220
	mutex_unlock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229 230 231 232
}

EXPORT_SYMBOL_GPL(sysdev_driver_register);
EXPORT_SYMBOL_GPL(sysdev_driver_unregister);



/**
 *	sysdev_register - add a system device to the tree
 *	@sysdev:	device in question
 *
 */
233
int sysdev_register(struct sys_device *sysdev)
L
Linus Torvalds 已提交
234 235
{
	int error;
236
	struct sysdev_class *cls = sysdev->cls;
L
Linus Torvalds 已提交
237 238 239 240

	if (!cls)
		return -EINVAL;

241 242
	pr_debug("Registering sys device of class '%s'\n",
		 kobject_name(&cls->kset.kobj));
243

244 245 246
	/* initialize the kobject to 0, in case it had previously been used */
	memset(&sysdev->kobj, 0x00, sizeof(struct kobject));

L
Linus Torvalds 已提交
247 248 249 250
	/* Make sure the kset is set */
	sysdev->kobj.kset = &cls->kset;

	/* Register the object */
251 252 253
	error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
				     "%s%d", kobject_name(&cls->kset.kobj),
				     sysdev->id);
L
Linus Torvalds 已提交
254 255

	if (!error) {
256
		struct sysdev_driver *drv;
L
Linus Torvalds 已提交
257

258 259 260
		pr_debug("Registering sys device '%s'\n",
			 kobject_name(&sysdev->kobj));

261
		mutex_lock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
262 263 264 265 266 267 268 269 270
		/* Generic notification is implicit, because it's that
		 * code that should have called us.
		 */

		/* Notify class auxillary drivers */
		list_for_each_entry(drv, &cls->drivers, entry) {
			if (drv->add)
				drv->add(sysdev);
		}
271
		mutex_unlock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
272
	}
273

274
	kobject_uevent(&sysdev->kobj, KOBJ_ADD);
L
Linus Torvalds 已提交
275 276 277
	return error;
}

278
void sysdev_unregister(struct sys_device *sysdev)
L
Linus Torvalds 已提交
279
{
280
	struct sysdev_driver *drv;
L
Linus Torvalds 已提交
281

282
	mutex_lock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
283 284 285 286
	list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
		if (drv->remove)
			drv->remove(sysdev);
	}
287
	mutex_unlock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
288

289
	kobject_put(&sysdev->kobj);
L
Linus Torvalds 已提交
290 291 292 293 294 295 296 297 298
}



/**
 *	sysdev_shutdown - Shut down all system devices.
 *
 *	Loop over each class of system devices, and the devices in each
 *	of those classes. For each device, we call the shutdown method for
299
 *	each driver registered for the device - the auxillaries,
L
Linus Torvalds 已提交
300 301 302 303 304 305 306 307 308
 *	and the class driver.
 *
 *	Note: The list is iterated in reverse order, so that we shut down
 *	child devices before we shut down thier parents. The list ordering
 *	is guaranteed by virtue of the fact that child devices are registered
 *	after their parents.
 */
void sysdev_shutdown(void)
{
309
	struct sysdev_class *cls;
L
Linus Torvalds 已提交
310 311 312

	pr_debug("Shutting Down System Devices\n");

313
	mutex_lock(&sysdev_drivers_lock);
314
	list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
315
		struct sys_device *sysdev;
L
Linus Torvalds 已提交
316 317 318 319 320

		pr_debug("Shutting down type '%s':\n",
			 kobject_name(&cls->kset.kobj));

		list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
321
			struct sysdev_driver *drv;
L
Linus Torvalds 已提交
322 323
			pr_debug(" %s\n", kobject_name(&sysdev->kobj));

324
			/* Call auxillary drivers first */
L
Linus Torvalds 已提交
325 326 327 328 329 330 331 332 333 334
			list_for_each_entry(drv, &cls->drivers, entry) {
				if (drv->shutdown)
					drv->shutdown(sysdev);
			}

			/* Now call the generic one */
			if (cls->shutdown)
				cls->shutdown(sysdev);
		}
	}
335
	mutex_unlock(&sysdev_drivers_lock);
L
Linus Torvalds 已提交
336 337
}

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
static void __sysdev_resume(struct sys_device *dev)
{
	struct sysdev_class *cls = dev->cls;
	struct sysdev_driver *drv;

	/* First, call the class-specific one */
	if (cls->resume)
		cls->resume(dev);

	/* Call auxillary drivers next. */
	list_for_each_entry(drv, &cls->drivers, entry) {
		if (drv->resume)
			drv->resume(dev);
	}
}
L
Linus Torvalds 已提交
353 354 355 356 357

/**
 *	sysdev_suspend - Suspend all system devices.
 *	@state:		Power state to enter.
 *
358
 *	We perform an almost identical operation as sysdev_shutdown()
L
Linus Torvalds 已提交
359 360 361 362 363 364 365
 *	above, though calling ->suspend() instead. Interrupts are disabled
 *	when this called. Devices are responsible for both saving state and
 *	quiescing or powering down the device.
 *
 *	This is only called by the device PM core, so we let them handle
 *	all synchronization.
 */
366
int sysdev_suspend(pm_message_t state)
L
Linus Torvalds 已提交
367
{
368
	struct sysdev_class *cls;
369 370 371
	struct sys_device *sysdev, *err_dev;
	struct sysdev_driver *drv, *err_drv;
	int ret;
L
Linus Torvalds 已提交
372

373 374 375 376 377 378 379
	pr_debug("Checking wake-up interrupts\n");

	/* Return error code if there are any wake-up interrupts pending */
	ret = check_wakeup_irqs();
	if (ret)
		return ret;

L
Linus Torvalds 已提交
380 381
	pr_debug("Suspending System Devices\n");

382
	list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
L
Linus Torvalds 已提交
383 384 385 386 387 388
		pr_debug("Suspending type '%s':\n",
			 kobject_name(&cls->kset.kobj));

		list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
			pr_debug(" %s\n", kobject_name(&sysdev->kobj));

389
			/* Call auxillary drivers first */
L
Linus Torvalds 已提交
390
			list_for_each_entry(drv, &cls->drivers, entry) {
391 392 393 394 395
				if (drv->suspend) {
					ret = drv->suspend(sysdev, state);
					if (ret)
						goto aux_driver;
				}
L
Linus Torvalds 已提交
396 397 398
			}

			/* Now call the generic one */
399 400 401 402 403
			if (cls->suspend) {
				ret = cls->suspend(sysdev, state);
				if (ret)
					goto cls_driver;
			}
L
Linus Torvalds 已提交
404 405 406
		}
	}
	return 0;
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
	/* resume current sysdev */
cls_driver:
	drv = NULL;
	printk(KERN_ERR "Class suspend failed for %s\n",
		kobject_name(&sysdev->kobj));

aux_driver:
	if (drv)
		printk(KERN_ERR "Class driver suspend failed for %s\n",
				kobject_name(&sysdev->kobj));
	list_for_each_entry(err_drv, &cls->drivers, entry) {
		if (err_drv == drv)
			break;
		if (err_drv->resume)
			err_drv->resume(sysdev);
	}

	/* resume other sysdevs in current class */
	list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
		if (err_dev == sysdev)
			break;
		pr_debug(" %s\n", kobject_name(&err_dev->kobj));
		__sysdev_resume(err_dev);
	}

	/* resume other classes */
433
	list_for_each_entry_continue(cls, &system_kset->list, kset.kobj.entry) {
434 435 436 437 438 439
		list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
			pr_debug(" %s\n", kobject_name(&err_dev->kobj));
			__sysdev_resume(err_dev);
		}
	}
	return ret;
L
Linus Torvalds 已提交
440
}
441
EXPORT_SYMBOL_GPL(sysdev_suspend);
L
Linus Torvalds 已提交
442 443 444 445

/**
 *	sysdev_resume - Bring system devices back to life.
 *
446
 *	Similar to sysdev_suspend(), but we iterate the list forwards
L
Linus Torvalds 已提交
447 448 449 450 451 452
 *	to guarantee that parent devices are resumed before their children.
 *
 *	Note: Interrupts are disabled when called.
 */
int sysdev_resume(void)
{
453
	struct sysdev_class *cls;
L
Linus Torvalds 已提交
454 455 456

	pr_debug("Resuming System Devices\n");

457
	list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
458
		struct sys_device *sysdev;
L
Linus Torvalds 已提交
459 460 461 462 463 464 465

		pr_debug("Resuming type '%s':\n",
			 kobject_name(&cls->kset.kobj));

		list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
			pr_debug(" %s\n", kobject_name(&sysdev->kobj));

466
			__sysdev_resume(sysdev);
L
Linus Torvalds 已提交
467 468 469 470
		}
	}
	return 0;
}
471
EXPORT_SYMBOL_GPL(sysdev_resume);
L
Linus Torvalds 已提交
472 473 474

int __init system_bus_init(void)
{
475 476 477 478
	system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
	if (!system_kset)
		return -ENOMEM;
	return 0;
L
Linus Torvalds 已提交
479 480 481 482
}

EXPORT_SYMBOL_GPL(sysdev_register);
EXPORT_SYMBOL_GPL(sysdev_unregister);
483 484 485 486 487 488 489 490 491 492 493 494 495

#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)

ssize_t sysdev_store_ulong(struct sys_device *sysdev,
			   struct sysdev_attribute *attr,
			   const char *buf, size_t size)
{
	struct sysdev_ext_attribute *ea = to_ext_attr(attr);
	char *end;
	unsigned long new = simple_strtoul(buf, &end, 0);
	if (end == buf)
		return -EINVAL;
	*(unsigned long *)(ea->var) = new;
496 497
	/* Always return full write size even if we didn't consume all */
	return size;
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
}
EXPORT_SYMBOL_GPL(sysdev_store_ulong);

ssize_t sysdev_show_ulong(struct sys_device *sysdev,
			  struct sysdev_attribute *attr,
			  char *buf)
{
	struct sysdev_ext_attribute *ea = to_ext_attr(attr);
	return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
}
EXPORT_SYMBOL_GPL(sysdev_show_ulong);

ssize_t sysdev_store_int(struct sys_device *sysdev,
			   struct sysdev_attribute *attr,
			   const char *buf, size_t size)
{
	struct sysdev_ext_attribute *ea = to_ext_attr(attr);
	char *end;
	long new = simple_strtol(buf, &end, 0);
	if (end == buf || new > INT_MAX || new < INT_MIN)
		return -EINVAL;
	*(int *)(ea->var) = new;
520 521
	/* Always return full write size even if we didn't consume all */
	return size;
522 523 524 525 526 527 528 529 530 531 532 533
}
EXPORT_SYMBOL_GPL(sysdev_store_int);

ssize_t sysdev_show_int(struct sys_device *sysdev,
			  struct sysdev_attribute *attr,
			  char *buf)
{
	struct sysdev_ext_attribute *ea = to_ext_attr(attr);
	return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
}
EXPORT_SYMBOL_GPL(sysdev_show_int);