2 * Universal power supply monitor class
4 * Copyright © 2007 Anton Vorontsov <cbou@mail.ru>
5 * Copyright © 2004 Szabolcs Gyurko
6 * Copyright © 2003 Ian Molton <spyro@f2s.com>
8 * Modified: 2004, Oct Szabolcs Gyurko
10 * You may use this code as per GPL version 2
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/device.h>
18 #include <linux/notifier.h>
19 #include <linux/err.h>
20 #include <linux/power_supply.h>
21 #include <linux/thermal.h>
22 #include "power_supply.h"
24 /* exported for the APM Power driver, APM emulation */
25 struct class *power_supply_class
;
26 EXPORT_SYMBOL_GPL(power_supply_class
);
28 ATOMIC_NOTIFIER_HEAD(power_supply_notifier
);
29 EXPORT_SYMBOL_GPL(power_supply_notifier
);
31 static struct device_type power_supply_dev_type
;
33 static bool __power_supply_is_supplied_by(struct power_supply
*supplier
,
34 struct power_supply
*supply
)
38 if (!supply
->supplied_from
&& !supplier
->supplied_to
)
41 /* Support both supplied_to and supplied_from modes */
42 if (supply
->supplied_from
) {
43 if (!supplier
->desc
->name
)
45 for (i
= 0; i
< supply
->num_supplies
; i
++)
46 if (!strcmp(supplier
->desc
->name
, supply
->supplied_from
[i
]))
49 if (!supply
->desc
->name
)
51 for (i
= 0; i
< supplier
->num_supplicants
; i
++)
52 if (!strcmp(supplier
->supplied_to
[i
], supply
->desc
->name
))
59 static int __power_supply_changed_work(struct device
*dev
, void *data
)
61 struct power_supply
*psy
= data
;
62 struct power_supply
*pst
= dev_get_drvdata(dev
);
64 if (__power_supply_is_supplied_by(psy
, pst
)) {
65 if (pst
->desc
->external_power_changed
)
66 pst
->desc
->external_power_changed(pst
);
72 static void power_supply_changed_work(struct work_struct
*work
)
75 struct power_supply
*psy
= container_of(work
, struct power_supply
,
78 dev_dbg(&psy
->dev
, "%s\n", __func__
);
80 spin_lock_irqsave(&psy
->changed_lock
, flags
);
82 * Check 'changed' here to avoid issues due to race between
83 * power_supply_changed() and this routine. In worst case
84 * power_supply_changed() can be called again just before we take above
85 * lock. During the first call of this routine we will mark 'changed' as
86 * false and it will stay false for the next call as well.
88 if (likely(psy
->changed
)) {
90 spin_unlock_irqrestore(&psy
->changed_lock
, flags
);
91 class_for_each_device(power_supply_class
, NULL
, psy
,
92 __power_supply_changed_work
);
93 power_supply_update_leds(psy
);
94 atomic_notifier_call_chain(&power_supply_notifier
,
95 PSY_EVENT_PROP_CHANGED
, psy
);
96 kobject_uevent(&psy
->dev
.kobj
, KOBJ_CHANGE
);
97 spin_lock_irqsave(&psy
->changed_lock
, flags
);
101 * Hold the wakeup_source until all events are processed.
102 * power_supply_changed() might have called again and have set 'changed'
105 if (likely(!psy
->changed
))
107 spin_unlock_irqrestore(&psy
->changed_lock
, flags
);
110 void power_supply_changed(struct power_supply
*psy
)
114 dev_dbg(&psy
->dev
, "%s\n", __func__
);
116 spin_lock_irqsave(&psy
->changed_lock
, flags
);
118 pm_stay_awake(&psy
->dev
);
119 spin_unlock_irqrestore(&psy
->changed_lock
, flags
);
120 schedule_work(&psy
->changed_work
);
122 EXPORT_SYMBOL_GPL(power_supply_changed
);
125 #include <linux/of.h>
127 static int __power_supply_populate_supplied_from(struct device
*dev
,
130 struct power_supply
*psy
= data
;
131 struct power_supply
*epsy
= dev_get_drvdata(dev
);
132 struct device_node
*np
;
136 np
= of_parse_phandle(psy
->of_node
, "power-supplies", i
++);
140 if (np
== epsy
->of_node
) {
141 dev_info(&psy
->dev
, "%s: Found supply : %s\n",
142 psy
->desc
->name
, epsy
->desc
->name
);
143 psy
->supplied_from
[i
-1] = (char *)epsy
->desc
->name
;
154 static int power_supply_populate_supplied_from(struct power_supply
*psy
)
158 error
= class_for_each_device(power_supply_class
, NULL
, psy
,
159 __power_supply_populate_supplied_from
);
161 dev_dbg(&psy
->dev
, "%s %d\n", __func__
, error
);
166 static int __power_supply_find_supply_from_node(struct device
*dev
,
169 struct device_node
*np
= data
;
170 struct power_supply
*epsy
= dev_get_drvdata(dev
);
172 /* returning non-zero breaks out of class_for_each_device loop */
173 if (epsy
->of_node
== np
)
179 static int power_supply_find_supply_from_node(struct device_node
*supply_node
)
184 * class_for_each_device() either returns its own errors or values
185 * returned by __power_supply_find_supply_from_node().
187 * __power_supply_find_supply_from_node() will return 0 (no match)
190 * We return 0 if class_for_each_device() returned 1, -EPROBE_DEFER if
191 * it returned 0, or error as returned by it.
193 error
= class_for_each_device(power_supply_class
, NULL
, supply_node
,
194 __power_supply_find_supply_from_node
);
196 return error
? (error
== 1 ? 0 : error
) : -EPROBE_DEFER
;
199 static int power_supply_check_supplies(struct power_supply
*psy
)
201 struct device_node
*np
;
204 /* If there is already a list honor it */
205 if (psy
->supplied_from
&& psy
->num_supplies
> 0)
208 /* No device node found, nothing to do */
215 np
= of_parse_phandle(psy
->of_node
, "power-supplies", cnt
++);
219 ret
= power_supply_find_supply_from_node(np
);
223 dev_dbg(&psy
->dev
, "Failed to find supply!\n");
228 /* Missing valid "power-supplies" entries */
232 /* All supplies found, allocate char ** array for filling */
233 psy
->supplied_from
= devm_kzalloc(&psy
->dev
, sizeof(psy
->supplied_from
),
235 if (!psy
->supplied_from
) {
236 dev_err(&psy
->dev
, "Couldn't allocate memory for supply list\n");
240 *psy
->supplied_from
= devm_kzalloc(&psy
->dev
,
241 sizeof(char *) * (cnt
- 1),
243 if (!*psy
->supplied_from
) {
244 dev_err(&psy
->dev
, "Couldn't allocate memory for supply list\n");
248 return power_supply_populate_supplied_from(psy
);
251 static inline int power_supply_check_supplies(struct power_supply
*psy
)
257 static int __power_supply_am_i_supplied(struct device
*dev
, void *data
)
259 union power_supply_propval ret
= {0,};
260 struct power_supply
*psy
= data
;
261 struct power_supply
*epsy
= dev_get_drvdata(dev
);
263 if (__power_supply_is_supplied_by(epsy
, psy
))
264 if (!epsy
->desc
->get_property(epsy
, POWER_SUPPLY_PROP_ONLINE
,
271 int power_supply_am_i_supplied(struct power_supply
*psy
)
275 error
= class_for_each_device(power_supply_class
, NULL
, psy
,
276 __power_supply_am_i_supplied
);
278 dev_dbg(&psy
->dev
, "%s %d\n", __func__
, error
);
282 EXPORT_SYMBOL_GPL(power_supply_am_i_supplied
);
284 static int __power_supply_is_system_supplied(struct device
*dev
, void *data
)
286 union power_supply_propval ret
= {0,};
287 struct power_supply
*psy
= dev_get_drvdata(dev
);
288 unsigned int *count
= data
;
291 if (psy
->desc
->type
!= POWER_SUPPLY_TYPE_BATTERY
)
292 if (!psy
->desc
->get_property(psy
, POWER_SUPPLY_PROP_ONLINE
,
299 int power_supply_is_system_supplied(void)
302 unsigned int count
= 0;
304 error
= class_for_each_device(power_supply_class
, NULL
, &count
,
305 __power_supply_is_system_supplied
);
308 * If no power class device was found at all, most probably we are
309 * running on a desktop system, so assume we are on mains power.
316 EXPORT_SYMBOL_GPL(power_supply_is_system_supplied
);
318 int power_supply_set_battery_charged(struct power_supply
*psy
)
320 if (atomic_read(&psy
->use_cnt
) >= 0 &&
321 psy
->desc
->type
== POWER_SUPPLY_TYPE_BATTERY
&&
322 psy
->desc
->set_charged
) {
323 psy
->desc
->set_charged(psy
);
329 EXPORT_SYMBOL_GPL(power_supply_set_battery_charged
);
331 static int power_supply_match_device_by_name(struct device
*dev
, const void *data
)
333 const char *name
= data
;
334 struct power_supply
*psy
= dev_get_drvdata(dev
);
336 return strcmp(psy
->desc
->name
, name
) == 0;
340 * power_supply_get_by_name() - Search for a power supply and returns its ref
341 * @name: Power supply name to fetch
343 * If power supply was found, it increases reference count for the
344 * internal power supply's device. The user should power_supply_put()
347 * Return: On success returns a reference to a power supply with
348 * matching name equals to @name, a NULL otherwise.
350 struct power_supply
*power_supply_get_by_name(const char *name
)
352 struct power_supply
*psy
= NULL
;
353 struct device
*dev
= class_find_device(power_supply_class
, NULL
, name
,
354 power_supply_match_device_by_name
);
357 psy
= dev_get_drvdata(dev
);
358 atomic_inc(&psy
->use_cnt
);
363 EXPORT_SYMBOL_GPL(power_supply_get_by_name
);
366 * power_supply_put() - Drop reference obtained with power_supply_get_by_name
367 * @psy: Reference to put
369 * The reference to power supply should be put before unregistering
372 void power_supply_put(struct power_supply
*psy
)
376 atomic_dec(&psy
->use_cnt
);
377 put_device(&psy
->dev
);
379 EXPORT_SYMBOL_GPL(power_supply_put
);
382 static int power_supply_match_device_node(struct device
*dev
, const void *data
)
384 return dev
->parent
&& dev
->parent
->of_node
== data
;
388 * power_supply_get_by_phandle() - Search for a power supply and returns its ref
389 * @np: Pointer to device node holding phandle property
390 * @phandle_name: Name of property holding a power supply name
392 * If power supply was found, it increases reference count for the
393 * internal power supply's device. The user should power_supply_put()
396 * Return: On success returns a reference to a power supply with
397 * matching name equals to value under @property, NULL or ERR_PTR otherwise.
399 struct power_supply
*power_supply_get_by_phandle(struct device_node
*np
,
400 const char *property
)
402 struct device_node
*power_supply_np
;
403 struct power_supply
*psy
= NULL
;
406 power_supply_np
= of_parse_phandle(np
, property
, 0);
407 if (!power_supply_np
)
408 return ERR_PTR(-ENODEV
);
410 dev
= class_find_device(power_supply_class
, NULL
, power_supply_np
,
411 power_supply_match_device_node
);
413 of_node_put(power_supply_np
);
416 psy
= dev_get_drvdata(dev
);
417 atomic_inc(&psy
->use_cnt
);
422 EXPORT_SYMBOL_GPL(power_supply_get_by_phandle
);
423 #endif /* CONFIG_OF */
425 int power_supply_get_property(struct power_supply
*psy
,
426 enum power_supply_property psp
,
427 union power_supply_propval
*val
)
429 if (atomic_read(&psy
->use_cnt
) <= 0)
432 return psy
->desc
->get_property(psy
, psp
, val
);
434 EXPORT_SYMBOL_GPL(power_supply_get_property
);
436 int power_supply_set_property(struct power_supply
*psy
,
437 enum power_supply_property psp
,
438 const union power_supply_propval
*val
)
440 if (atomic_read(&psy
->use_cnt
) <= 0 || !psy
->desc
->set_property
)
443 return psy
->desc
->set_property(psy
, psp
, val
);
445 EXPORT_SYMBOL_GPL(power_supply_set_property
);
447 int power_supply_property_is_writeable(struct power_supply
*psy
,
448 enum power_supply_property psp
)
450 if (atomic_read(&psy
->use_cnt
) <= 0 ||
451 !psy
->desc
->property_is_writeable
)
454 return psy
->desc
->property_is_writeable(psy
, psp
);
456 EXPORT_SYMBOL_GPL(power_supply_property_is_writeable
);
458 void power_supply_external_power_changed(struct power_supply
*psy
)
460 if (atomic_read(&psy
->use_cnt
) <= 0 ||
461 !psy
->desc
->external_power_changed
)
464 psy
->desc
->external_power_changed(psy
);
466 EXPORT_SYMBOL_GPL(power_supply_external_power_changed
);
468 int power_supply_powers(struct power_supply
*psy
, struct device
*dev
)
470 return sysfs_create_link(&psy
->dev
.kobj
, &dev
->kobj
, "powers");
472 EXPORT_SYMBOL_GPL(power_supply_powers
);
474 static void power_supply_dev_release(struct device
*dev
)
476 struct power_supply
*psy
= container_of(dev
, struct power_supply
, dev
);
477 pr_debug("device: '%s': %s\n", dev_name(dev
), __func__
);
481 int power_supply_reg_notifier(struct notifier_block
*nb
)
483 return atomic_notifier_chain_register(&power_supply_notifier
, nb
);
485 EXPORT_SYMBOL_GPL(power_supply_reg_notifier
);
487 void power_supply_unreg_notifier(struct notifier_block
*nb
)
489 atomic_notifier_chain_unregister(&power_supply_notifier
, nb
);
491 EXPORT_SYMBOL_GPL(power_supply_unreg_notifier
);
493 #ifdef CONFIG_THERMAL
494 static int power_supply_read_temp(struct thermal_zone_device
*tzd
,
497 struct power_supply
*psy
;
498 union power_supply_propval val
;
501 WARN_ON(tzd
== NULL
);
503 ret
= psy
->desc
->get_property(psy
, POWER_SUPPLY_PROP_TEMP
, &val
);
505 /* Convert tenths of degree Celsius to milli degree Celsius. */
507 *temp
= val
.intval
* 100;
512 static struct thermal_zone_device_ops psy_tzd_ops
= {
513 .get_temp
= power_supply_read_temp
,
516 static int psy_register_thermal(struct power_supply
*psy
)
520 if (psy
->desc
->no_thermal
)
523 /* Register battery zone device psy reports temperature */
524 for (i
= 0; i
< psy
->desc
->num_properties
; i
++) {
525 if (psy
->desc
->properties
[i
] == POWER_SUPPLY_PROP_TEMP
) {
526 psy
->tzd
= thermal_zone_device_register(psy
->desc
->name
,
527 0, 0, psy
, &psy_tzd_ops
, NULL
, 0, 0);
528 return PTR_ERR_OR_ZERO(psy
->tzd
);
534 static void psy_unregister_thermal(struct power_supply
*psy
)
536 if (IS_ERR_OR_NULL(psy
->tzd
))
538 thermal_zone_device_unregister(psy
->tzd
);
541 /* thermal cooling device callbacks */
542 static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device
*tcd
,
543 unsigned long *state
)
545 struct power_supply
*psy
;
546 union power_supply_propval val
;
550 ret
= psy
->desc
->get_property(psy
,
551 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX
, &val
);
558 static int ps_get_cur_chrage_cntl_limit(struct thermal_cooling_device
*tcd
,
559 unsigned long *state
)
561 struct power_supply
*psy
;
562 union power_supply_propval val
;
566 ret
= psy
->desc
->get_property(psy
,
567 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT
, &val
);
574 static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device
*tcd
,
577 struct power_supply
*psy
;
578 union power_supply_propval val
;
583 ret
= psy
->desc
->set_property(psy
,
584 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT
, &val
);
589 static struct thermal_cooling_device_ops psy_tcd_ops
= {
590 .get_max_state
= ps_get_max_charge_cntl_limit
,
591 .get_cur_state
= ps_get_cur_chrage_cntl_limit
,
592 .set_cur_state
= ps_set_cur_charge_cntl_limit
,
595 static int psy_register_cooler(struct power_supply
*psy
)
599 /* Register for cooling device if psy can control charging */
600 for (i
= 0; i
< psy
->desc
->num_properties
; i
++) {
601 if (psy
->desc
->properties
[i
] ==
602 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT
) {
603 psy
->tcd
= thermal_cooling_device_register(
604 (char *)psy
->desc
->name
,
606 return PTR_ERR_OR_ZERO(psy
->tcd
);
612 static void psy_unregister_cooler(struct power_supply
*psy
)
614 if (IS_ERR_OR_NULL(psy
->tcd
))
616 thermal_cooling_device_unregister(psy
->tcd
);
619 static int psy_register_thermal(struct power_supply
*psy
)
624 static void psy_unregister_thermal(struct power_supply
*psy
)
628 static int psy_register_cooler(struct power_supply
*psy
)
633 static void psy_unregister_cooler(struct power_supply
*psy
)
638 static struct power_supply
*__must_check
639 __power_supply_register(struct device
*parent
,
640 const struct power_supply_desc
*desc
,
641 const struct power_supply_config
*cfg
,
645 struct power_supply
*psy
;
648 psy
= kzalloc(sizeof(*psy
), GFP_KERNEL
);
650 return ERR_PTR(-ENOMEM
);
654 device_initialize(dev
);
656 dev
->class = power_supply_class
;
657 dev
->type
= &power_supply_dev_type
;
658 dev
->parent
= parent
;
659 dev
->release
= power_supply_dev_release
;
660 dev_set_drvdata(dev
, psy
);
662 atomic_inc(&psy
->use_cnt
);
664 psy
->drv_data
= cfg
->drv_data
;
665 psy
->of_node
= cfg
->of_node
;
666 psy
->supplied_to
= cfg
->supplied_to
;
667 psy
->num_supplicants
= cfg
->num_supplicants
;
670 rc
= dev_set_name(dev
, "%s", desc
->name
);
672 goto dev_set_name_failed
;
674 INIT_WORK(&psy
->changed_work
, power_supply_changed_work
);
676 rc
= power_supply_check_supplies(psy
);
678 dev_info(dev
, "Not all required supplies found, defer probe\n");
679 goto check_supplies_failed
;
682 spin_lock_init(&psy
->changed_lock
);
683 rc
= device_init_wakeup(dev
, ws
);
685 goto wakeup_init_failed
;
687 rc
= device_add(dev
);
689 goto device_add_failed
;
691 rc
= psy_register_thermal(psy
);
693 goto register_thermal_failed
;
695 rc
= psy_register_cooler(psy
);
697 goto register_cooler_failed
;
699 rc
= power_supply_create_triggers(psy
);
701 goto create_triggers_failed
;
703 power_supply_changed(psy
);
707 create_triggers_failed
:
708 psy_unregister_cooler(psy
);
709 register_cooler_failed
:
710 psy_unregister_thermal(psy
);
711 register_thermal_failed
:
715 check_supplies_failed
:
722 * power_supply_register() - Register new power supply
723 * @parent: Device to be a parent of power supply's device
724 * @desc: Description of power supply, must be valid through whole
725 * lifetime of this power supply
726 * @cfg: Run-time specific configuration accessed during registering,
729 * Return: A pointer to newly allocated power_supply on success
730 * or ERR_PTR otherwise.
731 * Use power_supply_unregister() on returned power_supply pointer to release
734 struct power_supply
*__must_check
power_supply_register(struct device
*parent
,
735 const struct power_supply_desc
*desc
,
736 const struct power_supply_config
*cfg
)
738 return __power_supply_register(parent
, desc
, cfg
, true);
740 EXPORT_SYMBOL_GPL(power_supply_register
);
743 * power_supply_register() - Register new non-waking-source power supply
744 * @parent: Device to be a parent of power supply's device
745 * @desc: Description of power supply, must be valid through whole
746 * lifetime of this power supply
747 * @cfg: Run-time specific configuration accessed during registering,
750 * Return: A pointer to newly allocated power_supply on success
751 * or ERR_PTR otherwise.
752 * Use power_supply_unregister() on returned power_supply pointer to release
755 struct power_supply
*__must_check
756 power_supply_register_no_ws(struct device
*parent
,
757 const struct power_supply_desc
*desc
,
758 const struct power_supply_config
*cfg
)
760 return __power_supply_register(parent
, desc
, cfg
, false);
762 EXPORT_SYMBOL_GPL(power_supply_register_no_ws
);
764 static void devm_power_supply_release(struct device
*dev
, void *res
)
766 struct power_supply
**psy
= res
;
768 power_supply_unregister(*psy
);
772 * power_supply_register() - Register managed power supply
773 * @parent: Device to be a parent of power supply's device
774 * @desc: Description of power supply, must be valid through whole
775 * lifetime of this power supply
776 * @cfg: Run-time specific configuration accessed during registering,
779 * Return: A pointer to newly allocated power_supply on success
780 * or ERR_PTR otherwise.
781 * The returned power_supply pointer will be automatically unregistered
784 struct power_supply
*__must_check
785 devm_power_supply_register(struct device
*parent
,
786 const struct power_supply_desc
*desc
,
787 const struct power_supply_config
*cfg
)
789 struct power_supply
**ptr
, *psy
;
791 ptr
= devres_alloc(devm_power_supply_release
, sizeof(*ptr
), GFP_KERNEL
);
794 return ERR_PTR(-ENOMEM
);
795 psy
= __power_supply_register(parent
, desc
, cfg
, true);
800 devres_add(parent
, ptr
);
804 EXPORT_SYMBOL_GPL(devm_power_supply_register
);
807 * power_supply_register() - Register managed non-waking-source power supply
808 * @parent: Device to be a parent of power supply's device
809 * @desc: Description of power supply, must be valid through whole
810 * lifetime of this power supply
811 * @cfg: Run-time specific configuration accessed during registering,
814 * Return: A pointer to newly allocated power_supply on success
815 * or ERR_PTR otherwise.
816 * The returned power_supply pointer will be automatically unregistered
819 struct power_supply
*__must_check
820 devm_power_supply_register_no_ws(struct device
*parent
,
821 const struct power_supply_desc
*desc
,
822 const struct power_supply_config
*cfg
)
824 struct power_supply
**ptr
, *psy
;
826 ptr
= devres_alloc(devm_power_supply_release
, sizeof(*ptr
), GFP_KERNEL
);
829 return ERR_PTR(-ENOMEM
);
830 psy
= __power_supply_register(parent
, desc
, cfg
, false);
835 devres_add(parent
, ptr
);
839 EXPORT_SYMBOL_GPL(devm_power_supply_register_no_ws
);
842 * power_supply_unregister() - Remove this power supply from system
843 * @psy: Pointer to power supply to unregister
845 * Remove this power supply from the system. The resources of power supply
846 * will be freed here or on last power_supply_put() call.
848 void power_supply_unregister(struct power_supply
*psy
)
850 WARN_ON(atomic_dec_return(&psy
->use_cnt
));
851 cancel_work_sync(&psy
->changed_work
);
852 sysfs_remove_link(&psy
->dev
.kobj
, "powers");
853 power_supply_remove_triggers(psy
);
854 psy_unregister_cooler(psy
);
855 psy_unregister_thermal(psy
);
856 device_init_wakeup(&psy
->dev
, false);
857 device_unregister(&psy
->dev
);
859 EXPORT_SYMBOL_GPL(power_supply_unregister
);
861 void *power_supply_get_drvdata(struct power_supply
*psy
)
863 return psy
->drv_data
;
865 EXPORT_SYMBOL_GPL(power_supply_get_drvdata
);
867 static int __init
power_supply_class_init(void)
869 power_supply_class
= class_create(THIS_MODULE
, "power_supply");
871 if (IS_ERR(power_supply_class
))
872 return PTR_ERR(power_supply_class
);
874 power_supply_class
->dev_uevent
= power_supply_uevent
;
875 power_supply_init_attrs(&power_supply_dev_type
);
880 static void __exit
power_supply_class_exit(void)
882 class_destroy(power_supply_class
);
885 subsys_initcall(power_supply_class_init
);
886 module_exit(power_supply_class_exit
);
888 MODULE_DESCRIPTION("Universal power supply monitor class");
889 MODULE_AUTHOR("Ian Molton <spyro@f2s.com>, "
891 "Anton Vorontsov <cbou@mail.ru>");
892 MODULE_LICENSE("GPL");