1
2
3#include <linux/device.h>
4#include <linux/kobject.h>
5#include <linux/string.h>
6#include <linux/export.h>
7#include <linux/pm_qos.h>
8#include <linux/pm_runtime.h>
9#include <linux/pm_wakeup.h>
10#include <linux/atomic.h>
11#include <linux/jiffies.h>
12#include "power.h"
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95const char power_group_name[] = "power";
96EXPORT_SYMBOL_GPL(power_group_name);
97
98static const char ctrl_auto[] = "auto";
99static const char ctrl_on[] = "on";
100
101static ssize_t control_show(struct device *dev, struct device_attribute *attr,
102 char *buf)
103{
104 return sysfs_emit(buf, "%s\n",
105 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
106}
107
108static ssize_t control_store(struct device * dev, struct device_attribute *attr,
109 const char * buf, size_t n)
110{
111 device_lock(dev);
112 if (sysfs_streq(buf, ctrl_auto))
113 pm_runtime_allow(dev);
114 else if (sysfs_streq(buf, ctrl_on))
115 pm_runtime_forbid(dev);
116 else
117 n = -EINVAL;
118 device_unlock(dev);
119 return n;
120}
121
122static DEVICE_ATTR_RW(control);
123
124static ssize_t runtime_active_time_show(struct device *dev,
125 struct device_attribute *attr,
126 char *buf)
127{
128 u64 tmp = pm_runtime_active_time(dev);
129
130 do_div(tmp, NSEC_PER_MSEC);
131
132 return sysfs_emit(buf, "%llu\n", tmp);
133}
134
135static DEVICE_ATTR_RO(runtime_active_time);
136
137static ssize_t runtime_suspended_time_show(struct device *dev,
138 struct device_attribute *attr,
139 char *buf)
140{
141 u64 tmp = pm_runtime_suspended_time(dev);
142
143 do_div(tmp, NSEC_PER_MSEC);
144
145 return sysfs_emit(buf, "%llu\n", tmp);
146}
147
148static DEVICE_ATTR_RO(runtime_suspended_time);
149
150static ssize_t runtime_status_show(struct device *dev,
151 struct device_attribute *attr, char *buf)
152{
153 const char *output;
154
155 if (dev->power.runtime_error) {
156 output = "error";
157 } else if (dev->power.disable_depth) {
158 output = "unsupported";
159 } else {
160 switch (dev->power.runtime_status) {
161 case RPM_SUSPENDED:
162 output = "suspended";
163 break;
164 case RPM_SUSPENDING:
165 output = "suspending";
166 break;
167 case RPM_RESUMING:
168 output = "resuming";
169 break;
170 case RPM_ACTIVE:
171 output = "active";
172 break;
173 default:
174 return -EIO;
175 }
176 }
177 return sysfs_emit(buf, "%s\n", output);
178}
179
180static DEVICE_ATTR_RO(runtime_status);
181
182static ssize_t autosuspend_delay_ms_show(struct device *dev,
183 struct device_attribute *attr,
184 char *buf)
185{
186 if (!dev->power.use_autosuspend)
187 return -EIO;
188
189 return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
190}
191
192static ssize_t autosuspend_delay_ms_store(struct device *dev,
193 struct device_attribute *attr, const char *buf, size_t n)
194{
195 long delay;
196
197 if (!dev->power.use_autosuspend)
198 return -EIO;
199
200 if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
201 return -EINVAL;
202
203 device_lock(dev);
204 pm_runtime_set_autosuspend_delay(dev, delay);
205 device_unlock(dev);
206 return n;
207}
208
209static DEVICE_ATTR_RW(autosuspend_delay_ms);
210
211static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
212 struct device_attribute *attr,
213 char *buf)
214{
215 s32 value = dev_pm_qos_requested_resume_latency(dev);
216
217 if (value == 0)
218 return sysfs_emit(buf, "n/a\n");
219 if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
220 value = 0;
221
222 return sysfs_emit(buf, "%d\n", value);
223}
224
225static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
226 struct device_attribute *attr,
227 const char *buf, size_t n)
228{
229 s32 value;
230 int ret;
231
232 if (!kstrtos32(buf, 0, &value)) {
233
234
235
236
237 if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
238 return -EINVAL;
239
240 if (value == 0)
241 value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
242 } else if (sysfs_streq(buf, "n/a")) {
243 value = 0;
244 } else {
245 return -EINVAL;
246 }
247
248 ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
249 value);
250 return ret < 0 ? ret : n;
251}
252
253static DEVICE_ATTR_RW(pm_qos_resume_latency_us);
254
255static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
256 struct device_attribute *attr,
257 char *buf)
258{
259 s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
260
261 if (value < 0)
262 return sysfs_emit(buf, "%s\n", "auto");
263 if (value == PM_QOS_LATENCY_ANY)
264 return sysfs_emit(buf, "%s\n", "any");
265
266 return sysfs_emit(buf, "%d\n", value);
267}
268
269static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
270 struct device_attribute *attr,
271 const char *buf, size_t n)
272{
273 s32 value;
274 int ret;
275
276 if (kstrtos32(buf, 0, &value) == 0) {
277
278 if (value < 0)
279 return -EINVAL;
280 } else {
281 if (sysfs_streq(buf, "auto"))
282 value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
283 else if (sysfs_streq(buf, "any"))
284 value = PM_QOS_LATENCY_ANY;
285 else
286 return -EINVAL;
287 }
288 ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
289 return ret < 0 ? ret : n;
290}
291
292static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us);
293
294static ssize_t pm_qos_no_power_off_show(struct device *dev,
295 struct device_attribute *attr,
296 char *buf)
297{
298 return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
299 & PM_QOS_FLAG_NO_POWER_OFF));
300}
301
302static ssize_t pm_qos_no_power_off_store(struct device *dev,
303 struct device_attribute *attr,
304 const char *buf, size_t n)
305{
306 int ret;
307
308 if (kstrtoint(buf, 0, &ret))
309 return -EINVAL;
310
311 if (ret != 0 && ret != 1)
312 return -EINVAL;
313
314 ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
315 return ret < 0 ? ret : n;
316}
317
318static DEVICE_ATTR_RW(pm_qos_no_power_off);
319
320#ifdef CONFIG_PM_SLEEP
321static const char _enabled[] = "enabled";
322static const char _disabled[] = "disabled";
323
324static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
325 char *buf)
326{
327 return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
328 ? (device_may_wakeup(dev) ? _enabled : _disabled)
329 : "");
330}
331
332static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
333 const char *buf, size_t n)
334{
335 if (!device_can_wakeup(dev))
336 return -EINVAL;
337
338 if (sysfs_streq(buf, _enabled))
339 device_set_wakeup_enable(dev, 1);
340 else if (sysfs_streq(buf, _disabled))
341 device_set_wakeup_enable(dev, 0);
342 else
343 return -EINVAL;
344 return n;
345}
346
347static DEVICE_ATTR_RW(wakeup);
348
349static ssize_t wakeup_count_show(struct device *dev,
350 struct device_attribute *attr, char *buf)
351{
352 unsigned long count;
353 bool enabled = false;
354
355 spin_lock_irq(&dev->power.lock);
356 if (dev->power.wakeup) {
357 count = dev->power.wakeup->wakeup_count;
358 enabled = true;
359 }
360 spin_unlock_irq(&dev->power.lock);
361
362 if (!enabled)
363 return sysfs_emit(buf, "\n");
364 return sysfs_emit(buf, "%lu\n", count);
365}
366
367static DEVICE_ATTR_RO(wakeup_count);
368
369static ssize_t wakeup_active_count_show(struct device *dev,
370 struct device_attribute *attr,
371 char *buf)
372{
373 unsigned long count;
374 bool enabled = false;
375
376 spin_lock_irq(&dev->power.lock);
377 if (dev->power.wakeup) {
378 count = dev->power.wakeup->active_count;
379 enabled = true;
380 }
381 spin_unlock_irq(&dev->power.lock);
382
383 if (!enabled)
384 return sysfs_emit(buf, "\n");
385 return sysfs_emit(buf, "%lu\n", count);
386}
387
388static DEVICE_ATTR_RO(wakeup_active_count);
389
390static ssize_t wakeup_abort_count_show(struct device *dev,
391 struct device_attribute *attr,
392 char *buf)
393{
394 unsigned long count;
395 bool enabled = false;
396
397 spin_lock_irq(&dev->power.lock);
398 if (dev->power.wakeup) {
399 count = dev->power.wakeup->wakeup_count;
400 enabled = true;
401 }
402 spin_unlock_irq(&dev->power.lock);
403
404 if (!enabled)
405 return sysfs_emit(buf, "\n");
406 return sysfs_emit(buf, "%lu\n", count);
407}
408
409static DEVICE_ATTR_RO(wakeup_abort_count);
410
411static ssize_t wakeup_expire_count_show(struct device *dev,
412 struct device_attribute *attr,
413 char *buf)
414{
415 unsigned long count;
416 bool enabled = false;
417
418 spin_lock_irq(&dev->power.lock);
419 if (dev->power.wakeup) {
420 count = dev->power.wakeup->expire_count;
421 enabled = true;
422 }
423 spin_unlock_irq(&dev->power.lock);
424
425 if (!enabled)
426 return sysfs_emit(buf, "\n");
427 return sysfs_emit(buf, "%lu\n", count);
428}
429
430static DEVICE_ATTR_RO(wakeup_expire_count);
431
432static ssize_t wakeup_active_show(struct device *dev,
433 struct device_attribute *attr, char *buf)
434{
435 unsigned int active;
436 bool enabled = false;
437
438 spin_lock_irq(&dev->power.lock);
439 if (dev->power.wakeup) {
440 active = dev->power.wakeup->active;
441 enabled = true;
442 }
443 spin_unlock_irq(&dev->power.lock);
444
445 if (!enabled)
446 return sysfs_emit(buf, "\n");
447 return sysfs_emit(buf, "%u\n", active);
448}
449
450static DEVICE_ATTR_RO(wakeup_active);
451
452static ssize_t wakeup_total_time_ms_show(struct device *dev,
453 struct device_attribute *attr,
454 char *buf)
455{
456 s64 msec;
457 bool enabled = false;
458
459 spin_lock_irq(&dev->power.lock);
460 if (dev->power.wakeup) {
461 msec = ktime_to_ms(dev->power.wakeup->total_time);
462 enabled = true;
463 }
464 spin_unlock_irq(&dev->power.lock);
465
466 if (!enabled)
467 return sysfs_emit(buf, "\n");
468 return sysfs_emit(buf, "%lld\n", msec);
469}
470
471static DEVICE_ATTR_RO(wakeup_total_time_ms);
472
473static ssize_t wakeup_max_time_ms_show(struct device *dev,
474 struct device_attribute *attr, char *buf)
475{
476 s64 msec;
477 bool enabled = false;
478
479 spin_lock_irq(&dev->power.lock);
480 if (dev->power.wakeup) {
481 msec = ktime_to_ms(dev->power.wakeup->max_time);
482 enabled = true;
483 }
484 spin_unlock_irq(&dev->power.lock);
485
486 if (!enabled)
487 return sysfs_emit(buf, "\n");
488 return sysfs_emit(buf, "%lld\n", msec);
489}
490
491static DEVICE_ATTR_RO(wakeup_max_time_ms);
492
493static ssize_t wakeup_last_time_ms_show(struct device *dev,
494 struct device_attribute *attr,
495 char *buf)
496{
497 s64 msec;
498 bool enabled = false;
499
500 spin_lock_irq(&dev->power.lock);
501 if (dev->power.wakeup) {
502 msec = ktime_to_ms(dev->power.wakeup->last_time);
503 enabled = true;
504 }
505 spin_unlock_irq(&dev->power.lock);
506
507 if (!enabled)
508 return sysfs_emit(buf, "\n");
509 return sysfs_emit(buf, "%lld\n", msec);
510}
511
512static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
513 kgid_t kgid)
514{
515 if (dev->power.wakeup && dev->power.wakeup->dev)
516 return device_change_owner(dev->power.wakeup->dev, kuid, kgid);
517 return 0;
518}
519
520static DEVICE_ATTR_RO(wakeup_last_time_ms);
521
522#ifdef CONFIG_PM_AUTOSLEEP
523static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
524 struct device_attribute *attr,
525 char *buf)
526{
527 s64 msec;
528 bool enabled = false;
529
530 spin_lock_irq(&dev->power.lock);
531 if (dev->power.wakeup) {
532 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
533 enabled = true;
534 }
535 spin_unlock_irq(&dev->power.lock);
536
537 if (!enabled)
538 return sysfs_emit(buf, "\n");
539 return sysfs_emit(buf, "%lld\n", msec);
540}
541
542static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
543#endif
544#else
545static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
546 kgid_t kgid)
547{
548 return 0;
549}
550#endif
551
552#ifdef CONFIG_PM_ADVANCED_DEBUG
553static ssize_t runtime_usage_show(struct device *dev,
554 struct device_attribute *attr, char *buf)
555{
556 return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
557}
558static DEVICE_ATTR_RO(runtime_usage);
559
560static ssize_t runtime_active_kids_show(struct device *dev,
561 struct device_attribute *attr,
562 char *buf)
563{
564 return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
565 0 : atomic_read(&dev->power.child_count));
566}
567static DEVICE_ATTR_RO(runtime_active_kids);
568
569static ssize_t runtime_enabled_show(struct device *dev,
570 struct device_attribute *attr, char *buf)
571{
572 const char *output;
573
574 if (dev->power.disable_depth && !dev->power.runtime_auto)
575 output = "disabled & forbidden";
576 else if (dev->power.disable_depth)
577 output = "disabled";
578 else if (!dev->power.runtime_auto)
579 output = "forbidden";
580 else
581 output = "enabled";
582
583 return sysfs_emit(buf, "%s\n", output);
584}
585static DEVICE_ATTR_RO(runtime_enabled);
586
587#ifdef CONFIG_PM_SLEEP
588static ssize_t async_show(struct device *dev, struct device_attribute *attr,
589 char *buf)
590{
591 return sysfs_emit(buf, "%s\n",
592 device_async_suspend_enabled(dev) ?
593 _enabled : _disabled);
594}
595
596static ssize_t async_store(struct device *dev, struct device_attribute *attr,
597 const char *buf, size_t n)
598{
599 if (sysfs_streq(buf, _enabled))
600 device_enable_async_suspend(dev);
601 else if (sysfs_streq(buf, _disabled))
602 device_disable_async_suspend(dev);
603 else
604 return -EINVAL;
605 return n;
606}
607
608static DEVICE_ATTR_RW(async);
609
610#endif
611#endif
612
613static struct attribute *power_attrs[] = {
614#ifdef CONFIG_PM_ADVANCED_DEBUG
615#ifdef CONFIG_PM_SLEEP
616 &dev_attr_async.attr,
617#endif
618 &dev_attr_runtime_status.attr,
619 &dev_attr_runtime_usage.attr,
620 &dev_attr_runtime_active_kids.attr,
621 &dev_attr_runtime_enabled.attr,
622#endif
623 NULL,
624};
625static const struct attribute_group pm_attr_group = {
626 .name = power_group_name,
627 .attrs = power_attrs,
628};
629
630static struct attribute *wakeup_attrs[] = {
631#ifdef CONFIG_PM_SLEEP
632 &dev_attr_wakeup.attr,
633 &dev_attr_wakeup_count.attr,
634 &dev_attr_wakeup_active_count.attr,
635 &dev_attr_wakeup_abort_count.attr,
636 &dev_attr_wakeup_expire_count.attr,
637 &dev_attr_wakeup_active.attr,
638 &dev_attr_wakeup_total_time_ms.attr,
639 &dev_attr_wakeup_max_time_ms.attr,
640 &dev_attr_wakeup_last_time_ms.attr,
641#ifdef CONFIG_PM_AUTOSLEEP
642 &dev_attr_wakeup_prevent_sleep_time_ms.attr,
643#endif
644#endif
645 NULL,
646};
647static const struct attribute_group pm_wakeup_attr_group = {
648 .name = power_group_name,
649 .attrs = wakeup_attrs,
650};
651
652static struct attribute *runtime_attrs[] = {
653#ifndef CONFIG_PM_ADVANCED_DEBUG
654 &dev_attr_runtime_status.attr,
655#endif
656 &dev_attr_control.attr,
657 &dev_attr_runtime_suspended_time.attr,
658 &dev_attr_runtime_active_time.attr,
659 &dev_attr_autosuspend_delay_ms.attr,
660 NULL,
661};
662static const struct attribute_group pm_runtime_attr_group = {
663 .name = power_group_name,
664 .attrs = runtime_attrs,
665};
666
667static struct attribute *pm_qos_resume_latency_attrs[] = {
668 &dev_attr_pm_qos_resume_latency_us.attr,
669 NULL,
670};
671static const struct attribute_group pm_qos_resume_latency_attr_group = {
672 .name = power_group_name,
673 .attrs = pm_qos_resume_latency_attrs,
674};
675
676static struct attribute *pm_qos_latency_tolerance_attrs[] = {
677 &dev_attr_pm_qos_latency_tolerance_us.attr,
678 NULL,
679};
680static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
681 .name = power_group_name,
682 .attrs = pm_qos_latency_tolerance_attrs,
683};
684
685static struct attribute *pm_qos_flags_attrs[] = {
686 &dev_attr_pm_qos_no_power_off.attr,
687 NULL,
688};
689static const struct attribute_group pm_qos_flags_attr_group = {
690 .name = power_group_name,
691 .attrs = pm_qos_flags_attrs,
692};
693
694int dpm_sysfs_add(struct device *dev)
695{
696 int rc;
697
698
699 if (device_pm_not_required(dev))
700 return 0;
701
702 rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
703 if (rc)
704 return rc;
705
706 if (!pm_runtime_has_no_callbacks(dev)) {
707 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
708 if (rc)
709 goto err_out;
710 }
711 if (device_can_wakeup(dev)) {
712 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
713 if (rc)
714 goto err_runtime;
715 }
716 if (dev->power.set_latency_tolerance) {
717 rc = sysfs_merge_group(&dev->kobj,
718 &pm_qos_latency_tolerance_attr_group);
719 if (rc)
720 goto err_wakeup;
721 }
722 rc = pm_wakeup_source_sysfs_add(dev);
723 if (rc)
724 goto err_latency;
725 return 0;
726
727 err_latency:
728 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
729 err_wakeup:
730 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
731 err_runtime:
732 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
733 err_out:
734 sysfs_remove_group(&dev->kobj, &pm_attr_group);
735 return rc;
736}
737
738int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
739{
740 int rc;
741
742 if (device_pm_not_required(dev))
743 return 0;
744
745 rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid);
746 if (rc)
747 return rc;
748
749 if (!pm_runtime_has_no_callbacks(dev)) {
750 rc = sysfs_group_change_owner(
751 &dev->kobj, &pm_runtime_attr_group, kuid, kgid);
752 if (rc)
753 return rc;
754 }
755
756 if (device_can_wakeup(dev)) {
757 rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group,
758 kuid, kgid);
759 if (rc)
760 return rc;
761
762 rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid);
763 if (rc)
764 return rc;
765 }
766
767 if (dev->power.set_latency_tolerance) {
768 rc = sysfs_group_change_owner(
769 &dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid,
770 kgid);
771 if (rc)
772 return rc;
773 }
774 return 0;
775}
776
777int wakeup_sysfs_add(struct device *dev)
778{
779 int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
780
781 if (!ret)
782 kobject_uevent(&dev->kobj, KOBJ_CHANGE);
783
784 return ret;
785}
786
787void wakeup_sysfs_remove(struct device *dev)
788{
789 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
790 kobject_uevent(&dev->kobj, KOBJ_CHANGE);
791}
792
793int pm_qos_sysfs_add_resume_latency(struct device *dev)
794{
795 return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
796}
797
798void pm_qos_sysfs_remove_resume_latency(struct device *dev)
799{
800 sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
801}
802
803int pm_qos_sysfs_add_flags(struct device *dev)
804{
805 return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
806}
807
808void pm_qos_sysfs_remove_flags(struct device *dev)
809{
810 sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
811}
812
813int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
814{
815 return sysfs_merge_group(&dev->kobj,
816 &pm_qos_latency_tolerance_attr_group);
817}
818
819void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
820{
821 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
822}
823
824void rpm_sysfs_remove(struct device *dev)
825{
826 sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
827}
828
829void dpm_sysfs_remove(struct device *dev)
830{
831 if (device_pm_not_required(dev))
832 return;
833 sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
834 dev_pm_qos_constraints_destroy(dev);
835 rpm_sysfs_remove(dev);
836 sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
837 sysfs_remove_group(&dev->kobj, &pm_attr_group);
838}
839