1 /*
2  * Power capping class
3  * Copyright (c) 2013, Intel Corporation.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms and conditions of the GNU General Public License,
7  * version 2, as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc.
16  *
17  */
18 
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/err.h>
22 #include <linux/slab.h>
23 #include <linux/powercap.h>
24 
25 #define to_powercap_zone(n) container_of(n, struct powercap_zone, dev)
26 #define to_powercap_control_type(n) \
27 			container_of(n, struct powercap_control_type, dev)
28 
29 /* Power zone show function */
30 #define define_power_zone_show(_attr)		\
31 static ssize_t _attr##_show(struct device *dev, \
32 					struct device_attribute *dev_attr,\
33 					char *buf) \
34 { \
35 	u64 value; \
36 	ssize_t len = -EINVAL; \
37 	struct powercap_zone *power_zone = to_powercap_zone(dev); \
38 	\
39 	if (power_zone->ops->get_##_attr) { \
40 		if (!power_zone->ops->get_##_attr(power_zone, &value)) \
41 			len = sprintf(buf, "%lld\n", value); \
42 	} \
43 	\
44 	return len; \
45 }
46 
47 /* The only meaningful input is 0 (reset), others are silently ignored */
48 #define define_power_zone_store(_attr)		\
49 static ssize_t _attr##_store(struct device *dev,\
50 				struct device_attribute *dev_attr, \
51 				const char *buf, size_t count) \
52 { \
53 	int err; \
54 	struct powercap_zone *power_zone = to_powercap_zone(dev); \
55 	u64 value; \
56 	\
57 	err = kstrtoull(buf, 10, &value); \
58 	if (err) \
59 		return -EINVAL; \
60 	if (value) \
61 		return count; \
62 	if (power_zone->ops->reset_##_attr) { \
63 		if (!power_zone->ops->reset_##_attr(power_zone)) \
64 			return count; \
65 	} \
66 	\
67 	return -EINVAL; \
68 }
69 
70 /* Power zone constraint show function */
71 #define define_power_zone_constraint_show(_attr) \
72 static ssize_t show_constraint_##_attr(struct device *dev, \
73 				struct device_attribute *dev_attr,\
74 				char *buf) \
75 { \
76 	u64 value; \
77 	ssize_t len = -ENODATA; \
78 	struct powercap_zone *power_zone = to_powercap_zone(dev); \
79 	int id; \
80 	struct powercap_zone_constraint *pconst;\
81 	\
82 	if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \
83 		return -EINVAL; \
84 	if (id >= power_zone->const_id_cnt)	\
85 		return -EINVAL; \
86 	pconst = &power_zone->constraints[id]; \
87 	if (pconst && pconst->ops && pconst->ops->get_##_attr) { \
88 		if (!pconst->ops->get_##_attr(power_zone, id, &value)) \
89 			len = sprintf(buf, "%lld\n", value); \
90 	} \
91 	\
92 	return len; \
93 }
94 
95 /* Power zone constraint store function */
96 #define define_power_zone_constraint_store(_attr) \
97 static ssize_t store_constraint_##_attr(struct device *dev,\
98 				struct device_attribute *dev_attr, \
99 				const char *buf, size_t count) \
100 { \
101 	int err; \
102 	u64 value; \
103 	struct powercap_zone *power_zone = to_powercap_zone(dev); \
104 	int id; \
105 	struct powercap_zone_constraint *pconst;\
106 	\
107 	if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \
108 		return -EINVAL; \
109 	if (id >= power_zone->const_id_cnt)	\
110 		return -EINVAL; \
111 	pconst = &power_zone->constraints[id]; \
112 	err = kstrtoull(buf, 10, &value); \
113 	if (err) \
114 		return -EINVAL; \
115 	if (pconst && pconst->ops && pconst->ops->set_##_attr) { \
116 		if (!pconst->ops->set_##_attr(power_zone, id, value)) \
117 			return count; \
118 	} \
119 	\
120 	return -ENODATA; \
121 }
122 
123 /* Power zone information callbacks */
124 define_power_zone_show(power_uw);
125 define_power_zone_show(max_power_range_uw);
126 define_power_zone_show(energy_uj);
127 define_power_zone_store(energy_uj);
128 define_power_zone_show(max_energy_range_uj);
129 
130 /* Power zone attributes */
131 static DEVICE_ATTR_RO(max_power_range_uw);
132 static DEVICE_ATTR_RO(power_uw);
133 static DEVICE_ATTR_RO(max_energy_range_uj);
134 static DEVICE_ATTR_RW(energy_uj);
135 
136 /* Power zone constraint attributes callbacks */
137 define_power_zone_constraint_show(power_limit_uw);
138 define_power_zone_constraint_store(power_limit_uw);
139 define_power_zone_constraint_show(time_window_us);
140 define_power_zone_constraint_store(time_window_us);
141 define_power_zone_constraint_show(max_power_uw);
142 define_power_zone_constraint_show(min_power_uw);
143 define_power_zone_constraint_show(max_time_window_us);
144 define_power_zone_constraint_show(min_time_window_us);
145 
146 /* For one time seeding of constraint device attributes */
147 struct powercap_constraint_attr {
148 	struct device_attribute power_limit_attr;
149 	struct device_attribute time_window_attr;
150 	struct device_attribute max_power_attr;
151 	struct device_attribute min_power_attr;
152 	struct device_attribute max_time_window_attr;
153 	struct device_attribute min_time_window_attr;
154 	struct device_attribute name_attr;
155 };
156 
157 static struct powercap_constraint_attr
158 				constraint_attrs[MAX_CONSTRAINTS_PER_ZONE];
159 
160 /* A list of powercap control_types */
161 static LIST_HEAD(powercap_cntrl_list);
162 /* Mutex to protect list of powercap control_types */
163 static DEFINE_MUTEX(powercap_cntrl_list_lock);
164 
165 #define POWERCAP_CONSTRAINT_NAME_LEN	30 /* Some limit to avoid overflow */
166 static ssize_t show_constraint_name(struct device *dev,
167 				struct device_attribute *dev_attr,
168 				char *buf)
169 {
170 	const char *name;
171 	struct powercap_zone *power_zone = to_powercap_zone(dev);
172 	int id;
173 	ssize_t len = -ENODATA;
174 	struct powercap_zone_constraint *pconst;
175 
176 	if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id))
177 		return -EINVAL;
178 	if (id >= power_zone->const_id_cnt)
179 		return -EINVAL;
180 	pconst = &power_zone->constraints[id];
181 
182 	if (pconst && pconst->ops && pconst->ops->get_name) {
183 		name = pconst->ops->get_name(power_zone, id);
184 		if (name) {
185 			snprintf(buf, POWERCAP_CONSTRAINT_NAME_LEN,
186 								"%s\n", name);
187 			buf[POWERCAP_CONSTRAINT_NAME_LEN] = '\0';
188 			len = strlen(buf);
189 		}
190 	}
191 
192 	return len;
193 }
194 
195 static int create_constraint_attribute(int id, const char *name,
196 				int mode,
197 				struct device_attribute *dev_attr,
198 				ssize_t (*show)(struct device *,
199 					struct device_attribute *, char *),
200 				ssize_t (*store)(struct device *,
201 					struct device_attribute *,
202 				const char *, size_t)
203 				)
204 {
205 
206 	dev_attr->attr.name = kasprintf(GFP_KERNEL, "constraint_%d_%s",
207 								id, name);
208 	if (!dev_attr->attr.name)
209 		return -ENOMEM;
210 	dev_attr->attr.mode = mode;
211 	dev_attr->show = show;
212 	dev_attr->store = store;
213 
214 	return 0;
215 }
216 
217 static void free_constraint_attributes(void)
218 {
219 	int i;
220 
221 	for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) {
222 		kfree(constraint_attrs[i].power_limit_attr.attr.name);
223 		kfree(constraint_attrs[i].time_window_attr.attr.name);
224 		kfree(constraint_attrs[i].name_attr.attr.name);
225 		kfree(constraint_attrs[i].max_power_attr.attr.name);
226 		kfree(constraint_attrs[i].min_power_attr.attr.name);
227 		kfree(constraint_attrs[i].max_time_window_attr.attr.name);
228 		kfree(constraint_attrs[i].min_time_window_attr.attr.name);
229 	}
230 }
231 
232 static int seed_constraint_attributes(void)
233 {
234 	int i;
235 	int ret;
236 
237 	for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) {
238 		ret = create_constraint_attribute(i, "power_limit_uw",
239 					S_IWUSR | S_IRUGO,
240 					&constraint_attrs[i].power_limit_attr,
241 					show_constraint_power_limit_uw,
242 					store_constraint_power_limit_uw);
243 		if (ret)
244 			goto err_alloc;
245 		ret = create_constraint_attribute(i, "time_window_us",
246 					S_IWUSR | S_IRUGO,
247 					&constraint_attrs[i].time_window_attr,
248 					show_constraint_time_window_us,
249 					store_constraint_time_window_us);
250 		if (ret)
251 			goto err_alloc;
252 		ret = create_constraint_attribute(i, "name", S_IRUGO,
253 				&constraint_attrs[i].name_attr,
254 				show_constraint_name,
255 				NULL);
256 		if (ret)
257 			goto err_alloc;
258 		ret = create_constraint_attribute(i, "max_power_uw", S_IRUGO,
259 				&constraint_attrs[i].max_power_attr,
260 				show_constraint_max_power_uw,
261 				NULL);
262 		if (ret)
263 			goto err_alloc;
264 		ret = create_constraint_attribute(i, "min_power_uw", S_IRUGO,
265 				&constraint_attrs[i].min_power_attr,
266 				show_constraint_min_power_uw,
267 				NULL);
268 		if (ret)
269 			goto err_alloc;
270 		ret = create_constraint_attribute(i, "max_time_window_us",
271 				S_IRUGO,
272 				&constraint_attrs[i].max_time_window_attr,
273 				show_constraint_max_time_window_us,
274 				NULL);
275 		if (ret)
276 			goto err_alloc;
277 		ret = create_constraint_attribute(i, "min_time_window_us",
278 				S_IRUGO,
279 				&constraint_attrs[i].min_time_window_attr,
280 				show_constraint_min_time_window_us,
281 				NULL);
282 		if (ret)
283 			goto err_alloc;
284 
285 	}
286 
287 	return 0;
288 
289 err_alloc:
290 	free_constraint_attributes();
291 
292 	return ret;
293 }
294 
295 static int create_constraints(struct powercap_zone *power_zone,
296 			int nr_constraints,
297 			const struct powercap_zone_constraint_ops *const_ops)
298 {
299 	int i;
300 	int ret = 0;
301 	int count;
302 	struct powercap_zone_constraint *pconst;
303 
304 	if (!power_zone || !const_ops || !const_ops->get_power_limit_uw ||
305 					!const_ops->set_power_limit_uw ||
306 					!const_ops->get_time_window_us ||
307 					!const_ops->set_time_window_us)
308 		return -EINVAL;
309 
310 	count = power_zone->zone_attr_count;
311 	for (i = 0; i < nr_constraints; ++i) {
312 		pconst = &power_zone->constraints[i];
313 		pconst->ops = const_ops;
314 		pconst->id = power_zone->const_id_cnt;
315 		power_zone->const_id_cnt++;
316 		power_zone->zone_dev_attrs[count++] =
317 				&constraint_attrs[i].power_limit_attr.attr;
318 		power_zone->zone_dev_attrs[count++] =
319 				&constraint_attrs[i].time_window_attr.attr;
320 		if (pconst->ops->get_name)
321 			power_zone->zone_dev_attrs[count++] =
322 				&constraint_attrs[i].name_attr.attr;
323 		if (pconst->ops->get_max_power_uw)
324 			power_zone->zone_dev_attrs[count++] =
325 				&constraint_attrs[i].max_power_attr.attr;
326 		if (pconst->ops->get_min_power_uw)
327 			power_zone->zone_dev_attrs[count++] =
328 				&constraint_attrs[i].min_power_attr.attr;
329 		if (pconst->ops->get_max_time_window_us)
330 			power_zone->zone_dev_attrs[count++] =
331 				&constraint_attrs[i].max_time_window_attr.attr;
332 		if (pconst->ops->get_min_time_window_us)
333 			power_zone->zone_dev_attrs[count++] =
334 				&constraint_attrs[i].min_time_window_attr.attr;
335 	}
336 	power_zone->zone_attr_count = count;
337 
338 	return ret;
339 }
340 
341 static bool control_type_valid(void *control_type)
342 {
343 	struct powercap_control_type *pos = NULL;
344 	bool found = false;
345 
346 	mutex_lock(&powercap_cntrl_list_lock);
347 
348 	list_for_each_entry(pos, &powercap_cntrl_list, node) {
349 		if (pos == control_type) {
350 			found = true;
351 			break;
352 		}
353 	}
354 	mutex_unlock(&powercap_cntrl_list_lock);
355 
356 	return found;
357 }
358 
359 static ssize_t name_show(struct device *dev,
360 				struct device_attribute *attr,
361 				char *buf)
362 {
363 	struct powercap_zone *power_zone = to_powercap_zone(dev);
364 
365 	return sprintf(buf, "%s\n", power_zone->name);
366 }
367 
368 static DEVICE_ATTR_RO(name);
369 
370 /* Create zone and attributes in sysfs */
371 static void create_power_zone_common_attributes(
372 					struct powercap_zone *power_zone)
373 {
374 	int count = 0;
375 
376 	power_zone->zone_dev_attrs[count++] = &dev_attr_name.attr;
377 	if (power_zone->ops->get_max_energy_range_uj)
378 		power_zone->zone_dev_attrs[count++] =
379 					&dev_attr_max_energy_range_uj.attr;
380 	if (power_zone->ops->get_energy_uj) {
381 		if (power_zone->ops->reset_energy_uj)
382 			dev_attr_energy_uj.attr.mode = S_IWUSR | S_IRUGO;
383 		else
384 			dev_attr_energy_uj.attr.mode = S_IRUGO;
385 		power_zone->zone_dev_attrs[count++] =
386 					&dev_attr_energy_uj.attr;
387 	}
388 	if (power_zone->ops->get_power_uw)
389 		power_zone->zone_dev_attrs[count++] =
390 					&dev_attr_power_uw.attr;
391 	if (power_zone->ops->get_max_power_range_uw)
392 		power_zone->zone_dev_attrs[count++] =
393 					&dev_attr_max_power_range_uw.attr;
394 	power_zone->zone_dev_attrs[count] = NULL;
395 	power_zone->zone_attr_count = count;
396 }
397 
398 static void powercap_release(struct device *dev)
399 {
400 	bool allocated;
401 
402 	if (dev->parent) {
403 		struct powercap_zone *power_zone = to_powercap_zone(dev);
404 
405 		/* Store flag as the release() may free memory */
406 		allocated = power_zone->allocated;
407 		/* Remove id from parent idr struct */
408 		idr_remove(power_zone->parent_idr, power_zone->id);
409 		/* Destroy idrs allocated for this zone */
410 		idr_destroy(&power_zone->idr);
411 		kfree(power_zone->name);
412 		kfree(power_zone->zone_dev_attrs);
413 		kfree(power_zone->constraints);
414 		if (power_zone->ops->release)
415 			power_zone->ops->release(power_zone);
416 		if (allocated)
417 			kfree(power_zone);
418 	} else {
419 		struct powercap_control_type *control_type =
420 						to_powercap_control_type(dev);
421 
422 		/* Store flag as the release() may free memory */
423 		allocated = control_type->allocated;
424 		idr_destroy(&control_type->idr);
425 		mutex_destroy(&control_type->lock);
426 		if (control_type->ops && control_type->ops->release)
427 			control_type->ops->release(control_type);
428 		if (allocated)
429 			kfree(control_type);
430 	}
431 }
432 
433 static ssize_t enabled_show(struct device *dev,
434 				struct device_attribute *attr,
435 				char *buf)
436 {
437 	bool mode = true;
438 
439 	/* Default is enabled */
440 	if (dev->parent) {
441 		struct powercap_zone *power_zone = to_powercap_zone(dev);
442 		if (power_zone->ops->get_enable)
443 			if (power_zone->ops->get_enable(power_zone, &mode))
444 				mode = false;
445 	} else {
446 		struct powercap_control_type *control_type =
447 						to_powercap_control_type(dev);
448 		if (control_type->ops && control_type->ops->get_enable)
449 			if (control_type->ops->get_enable(control_type, &mode))
450 				mode = false;
451 	}
452 
453 	return sprintf(buf, "%d\n", mode);
454 }
455 
456 static ssize_t enabled_store(struct device *dev,
457 				struct device_attribute *attr,
458 				const char *buf,  size_t len)
459 {
460 	bool mode;
461 
462 	if (strtobool(buf, &mode))
463 		return -EINVAL;
464 	if (dev->parent) {
465 		struct powercap_zone *power_zone = to_powercap_zone(dev);
466 		if (power_zone->ops->set_enable)
467 			if (!power_zone->ops->set_enable(power_zone, mode))
468 				return len;
469 	} else {
470 		struct powercap_control_type *control_type =
471 						to_powercap_control_type(dev);
472 		if (control_type->ops && control_type->ops->set_enable)
473 			if (!control_type->ops->set_enable(control_type, mode))
474 				return len;
475 	}
476 
477 	return -ENOSYS;
478 }
479 
480 static DEVICE_ATTR_RW(enabled);
481 
482 static struct attribute *powercap_attrs[] = {
483 	&dev_attr_enabled.attr,
484 	NULL,
485 };
486 ATTRIBUTE_GROUPS(powercap);
487 
488 static struct class powercap_class = {
489 	.name = "powercap",
490 	.dev_release = powercap_release,
491 	.dev_groups = powercap_groups,
492 };
493 
494 struct powercap_zone *powercap_register_zone(
495 			struct powercap_zone *power_zone,
496 			struct powercap_control_type *control_type,
497 			const char *name,
498 			struct powercap_zone *parent,
499 			const struct powercap_zone_ops *ops,
500 			int nr_constraints,
501 			const struct powercap_zone_constraint_ops *const_ops)
502 {
503 	int result;
504 	int nr_attrs;
505 
506 	if (!name || !control_type || !ops ||
507 			nr_constraints > MAX_CONSTRAINTS_PER_ZONE ||
508 			(!ops->get_energy_uj && !ops->get_power_uw) ||
509 			!control_type_valid(control_type))
510 		return ERR_PTR(-EINVAL);
511 
512 	if (power_zone) {
513 		if (!ops->release)
514 			return ERR_PTR(-EINVAL);
515 		memset(power_zone, 0, sizeof(*power_zone));
516 	} else {
517 		power_zone = kzalloc(sizeof(*power_zone), GFP_KERNEL);
518 		if (!power_zone)
519 			return ERR_PTR(-ENOMEM);
520 		power_zone->allocated = true;
521 	}
522 	power_zone->ops = ops;
523 	power_zone->control_type_inst = control_type;
524 	if (!parent) {
525 		power_zone->dev.parent = &control_type->dev;
526 		power_zone->parent_idr = &control_type->idr;
527 	} else {
528 		power_zone->dev.parent = &parent->dev;
529 		power_zone->parent_idr = &parent->idr;
530 	}
531 	power_zone->dev.class = &powercap_class;
532 
533 	mutex_lock(&control_type->lock);
534 	/* Using idr to get the unique id */
535 	result = idr_alloc(power_zone->parent_idr, NULL, 0, 0, GFP_KERNEL);
536 	if (result < 0)
537 		goto err_idr_alloc;
538 
539 	power_zone->id = result;
540 	idr_init(&power_zone->idr);
541 	power_zone->name = kstrdup(name, GFP_KERNEL);
542 	if (!power_zone->name)
543 		goto err_name_alloc;
544 	dev_set_name(&power_zone->dev, "%s:%x",
545 					dev_name(power_zone->dev.parent),
546 					power_zone->id);
547 	power_zone->constraints = kzalloc(sizeof(*power_zone->constraints) *
548 					 nr_constraints, GFP_KERNEL);
549 	if (!power_zone->constraints)
550 		goto err_const_alloc;
551 
552 	nr_attrs = nr_constraints * POWERCAP_CONSTRAINTS_ATTRS +
553 						POWERCAP_ZONE_MAX_ATTRS + 1;
554 	power_zone->zone_dev_attrs = kzalloc(sizeof(void *) *
555 						nr_attrs, GFP_KERNEL);
556 	if (!power_zone->zone_dev_attrs)
557 		goto err_attr_alloc;
558 	create_power_zone_common_attributes(power_zone);
559 	result = create_constraints(power_zone, nr_constraints, const_ops);
560 	if (result)
561 		goto err_dev_ret;
562 
563 	power_zone->zone_dev_attrs[power_zone->zone_attr_count] = NULL;
564 	power_zone->dev_zone_attr_group.attrs = power_zone->zone_dev_attrs;
565 	power_zone->dev_attr_groups[0] = &power_zone->dev_zone_attr_group;
566 	power_zone->dev_attr_groups[1] = NULL;
567 	power_zone->dev.groups = power_zone->dev_attr_groups;
568 	result = device_register(&power_zone->dev);
569 	if (result)
570 		goto err_dev_ret;
571 
572 	control_type->nr_zones++;
573 	mutex_unlock(&control_type->lock);
574 
575 	return power_zone;
576 
577 err_dev_ret:
578 	kfree(power_zone->zone_dev_attrs);
579 err_attr_alloc:
580 	kfree(power_zone->constraints);
581 err_const_alloc:
582 	kfree(power_zone->name);
583 err_name_alloc:
584 	idr_remove(power_zone->parent_idr, power_zone->id);
585 err_idr_alloc:
586 	if (power_zone->allocated)
587 		kfree(power_zone);
588 	mutex_unlock(&control_type->lock);
589 
590 	return ERR_PTR(result);
591 }
592 EXPORT_SYMBOL_GPL(powercap_register_zone);
593 
594 int powercap_unregister_zone(struct powercap_control_type *control_type,
595 				struct powercap_zone *power_zone)
596 {
597 	if (!power_zone || !control_type)
598 		return -EINVAL;
599 
600 	mutex_lock(&control_type->lock);
601 	control_type->nr_zones--;
602 	mutex_unlock(&control_type->lock);
603 
604 	device_unregister(&power_zone->dev);
605 
606 	return 0;
607 }
608 EXPORT_SYMBOL_GPL(powercap_unregister_zone);
609 
610 struct powercap_control_type *powercap_register_control_type(
611 				struct powercap_control_type *control_type,
612 				const char *name,
613 				const struct powercap_control_type_ops *ops)
614 {
615 	int result;
616 
617 	if (!name)
618 		return ERR_PTR(-EINVAL);
619 	if (control_type) {
620 		if (!ops || !ops->release)
621 			return ERR_PTR(-EINVAL);
622 		memset(control_type, 0, sizeof(*control_type));
623 	} else {
624 		control_type = kzalloc(sizeof(*control_type), GFP_KERNEL);
625 		if (!control_type)
626 			return ERR_PTR(-ENOMEM);
627 		control_type->allocated = true;
628 	}
629 	mutex_init(&control_type->lock);
630 	control_type->ops = ops;
631 	INIT_LIST_HEAD(&control_type->node);
632 	control_type->dev.class = &powercap_class;
633 	dev_set_name(&control_type->dev, "%s", name);
634 	result = device_register(&control_type->dev);
635 	if (result) {
636 		if (control_type->allocated)
637 			kfree(control_type);
638 		return ERR_PTR(result);
639 	}
640 	idr_init(&control_type->idr);
641 
642 	mutex_lock(&powercap_cntrl_list_lock);
643 	list_add_tail(&control_type->node, &powercap_cntrl_list);
644 	mutex_unlock(&powercap_cntrl_list_lock);
645 
646 	return control_type;
647 }
648 EXPORT_SYMBOL_GPL(powercap_register_control_type);
649 
650 int powercap_unregister_control_type(struct powercap_control_type *control_type)
651 {
652 	struct powercap_control_type *pos = NULL;
653 
654 	if (control_type->nr_zones) {
655 		dev_err(&control_type->dev, "Zones of this type still not freed\n");
656 		return -EINVAL;
657 	}
658 	mutex_lock(&powercap_cntrl_list_lock);
659 	list_for_each_entry(pos, &powercap_cntrl_list, node) {
660 		if (pos == control_type) {
661 			list_del(&control_type->node);
662 			mutex_unlock(&powercap_cntrl_list_lock);
663 			device_unregister(&control_type->dev);
664 			return 0;
665 		}
666 	}
667 	mutex_unlock(&powercap_cntrl_list_lock);
668 
669 	return -ENODEV;
670 }
671 EXPORT_SYMBOL_GPL(powercap_unregister_control_type);
672 
673 static int __init powercap_init(void)
674 {
675 	int result = 0;
676 
677 	result = seed_constraint_attributes();
678 	if (result)
679 		return result;
680 
681 	result = class_register(&powercap_class);
682 
683 	return result;
684 }
685 
686 device_initcall(powercap_init);
687 
688 MODULE_DESCRIPTION("PowerCap sysfs Driver");
689 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
690 MODULE_LICENSE("GPL v2");
691