← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/power/test_power.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/power/test_power.c
 
1
/*
 
2
 * Power supply driver for testing.
 
3
 *
 
4
 * Copyright 2010  Anton Vorontsov <cbouatmailru@gmail.com>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License version 2 as
 
8
 * published by the Free Software Foundation.
 
9
 */
 
10
 
 
11
#include <linux/kernel.h>
 
12
#include <linux/module.h>
 
13
#include <linux/power_supply.h>
 
14
#include <linux/errno.h>
 
15
#include <linux/delay.h>
 
16
#include <linux/vermagic.h>
 
17
 
 
18
static int test_power_ac_online = 1;
 
19
static int test_power_battery_status = POWER_SUPPLY_STATUS_CHARGING;
 
20
 
 
21
static int test_power_get_ac_property(struct power_supply *psy,
 
22
                                      enum power_supply_property psp,
 
23
                                      union power_supply_propval *val)
 
24
{
 
25
        switch (psp) {
 
26
        case POWER_SUPPLY_PROP_ONLINE:
 
27
                val->intval = test_power_ac_online;
 
28
                break;
 
29
        default:
 
30
                return -EINVAL;
 
31
        }
 
32
        return 0;
 
33
}
 
34
 
 
35
static int test_power_get_battery_property(struct power_supply *psy,
 
36
                                           enum power_supply_property psp,
 
37
                                           union power_supply_propval *val)
 
38
{
 
39
        switch (psp) {
 
40
        case POWER_SUPPLY_PROP_MODEL_NAME:
 
41
                val->strval = "Test battery";
 
42
                break;
 
43
        case POWER_SUPPLY_PROP_MANUFACTURER:
 
44
                val->strval = "Linux";
 
45
                break;
 
46
        case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 
47
                val->strval = UTS_RELEASE;
 
48
                break;
 
49
        case POWER_SUPPLY_PROP_STATUS:
 
50
                val->intval = test_power_battery_status;
 
51
                break;
 
52
        case POWER_SUPPLY_PROP_CHARGE_TYPE:
 
53
                val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
 
54
                break;
 
55
        case POWER_SUPPLY_PROP_HEALTH:
 
56
                val->intval = POWER_SUPPLY_HEALTH_GOOD;
 
57
                break;
 
58
        case POWER_SUPPLY_PROP_TECHNOLOGY:
 
59
                val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 
60
                break;
 
61
        case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 
62
                val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 
63
                break;
 
64
        case POWER_SUPPLY_PROP_CAPACITY:
 
65
                val->intval = 50;
 
66
                break;
 
67
        case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 
68
        case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
 
69
                val->intval = 3600;
 
70
                break;
 
71
        default:
 
72
                pr_info("%s: some properties deliberately report errors.\n",
 
73
                        __func__);
 
74
                return -EINVAL;
 
75
        }
 
76
        return 0;
 
77
}
 
78
 
 
79
static enum power_supply_property test_power_ac_props[] = {
 
80
        POWER_SUPPLY_PROP_ONLINE,
 
81
};
 
82
 
 
83
static enum power_supply_property test_power_battery_props[] = {
 
84
        POWER_SUPPLY_PROP_STATUS,
 
85
        POWER_SUPPLY_PROP_CHARGE_TYPE,
 
86
        POWER_SUPPLY_PROP_HEALTH,
 
87
        POWER_SUPPLY_PROP_TECHNOLOGY,
 
88
        POWER_SUPPLY_PROP_CHARGE_FULL,
 
89
        POWER_SUPPLY_PROP_CHARGE_EMPTY,
 
90
        POWER_SUPPLY_PROP_CAPACITY,
 
91
        POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 
92
        POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
 
93
        POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
 
94
        POWER_SUPPLY_PROP_MODEL_NAME,
 
95
        POWER_SUPPLY_PROP_MANUFACTURER,
 
96
        POWER_SUPPLY_PROP_SERIAL_NUMBER,
 
97
};
 
98
 
 
99
static char *test_power_ac_supplied_to[] = {
 
100
        "test_battery",
 
101
};
 
102
 
 
103
static struct power_supply test_power_supplies[] = {
 
104
        {
 
105
                .name = "test_ac",
 
106
                .type = POWER_SUPPLY_TYPE_MAINS,
 
107
                .supplied_to = test_power_ac_supplied_to,
 
108
                .num_supplicants = ARRAY_SIZE(test_power_ac_supplied_to),
 
109
                .properties = test_power_ac_props,
 
110
                .num_properties = ARRAY_SIZE(test_power_ac_props),
 
111
                .get_property = test_power_get_ac_property,
 
112
        }, {
 
113
                .name = "test_battery",
 
114
                .type = POWER_SUPPLY_TYPE_BATTERY,
 
115
                .properties = test_power_battery_props,
 
116
                .num_properties = ARRAY_SIZE(test_power_battery_props),
 
117
                .get_property = test_power_get_battery_property,
 
118
        },
 
119
};
 
120
 
 
121
static int __init test_power_init(void)
 
122
{
 
123
        int i;
 
124
        int ret;
 
125
 
 
126
        for (i = 0; i < ARRAY_SIZE(test_power_supplies); i++) {
 
127
                ret = power_supply_register(NULL, &test_power_supplies[i]);
 
128
                if (ret) {
 
129
                        pr_err("%s: failed to register %s\n", __func__,
 
130
                                test_power_supplies[i].name);
 
131
                        goto failed;
 
132
                }
 
133
        }
 
134
 
 
135
        return 0;
 
136
failed:
 
137
        while (--i >= 0)
 
138
                power_supply_unregister(&test_power_supplies[i]);
 
139
        return ret;
 
140
}
 
141
module_init(test_power_init);
 
142
 
 
143
static void __exit test_power_exit(void)
 
144
{
 
145
        int i;
 
146
 
 
147
        /* Let's see how we handle changes... */
 
148
        test_power_ac_online = 0;
 
149
        test_power_battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
 
150
        for (i = 0; i < ARRAY_SIZE(test_power_supplies); i++)
 
151
                power_supply_changed(&test_power_supplies[i]);
 
152
        pr_info("%s: 'changed' event sent, sleeping for 10 seconds...\n",
 
153
                __func__);
 
154
        ssleep(10);
 
155
 
 
156
        for (i = 0; i < ARRAY_SIZE(test_power_supplies); i++)
 
157
                power_supply_unregister(&test_power_supplies[i]);
 
158
}
 
159
module_exit(test_power_exit);
 
160
 
 
161
MODULE_DESCRIPTION("Power supply driver for testing");
 
162
MODULE_AUTHOR("Anton Vorontsov <cbouatmailru@gmail.com>");
 
163
MODULE_LICENSE("GPL");