Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/power/goldfish_battery.c

  1 /*
  2  * Power supply driver for the goldfish emulator
  3  *
  4  * Copyright (C) 2008 Google, Inc.
  5  * Copyright (C) 2012 Intel, Inc.
  6  * Copyright (C) 2013 Intel, Inc.
  7  * Author: Mike Lockwood <lockwood@android.com>
  8  *
  9  * This software is licensed under the terms of the GNU General Public
 10  * License version 2, as published by the Free Software Foundation, and
 11  * may be copied, distributed, and modified under those terms.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  */
 18 
 19 #include <linux/module.h>
 20 #include <linux/err.h>
 21 #include <linux/platform_device.h>
 22 #include <linux/power_supply.h>
 23 #include <linux/types.h>
 24 #include <linux/pci.h>
 25 #include <linux/interrupt.h>
 26 #include <linux/io.h>
 27 #include <linux/acpi.h>
 28 
 29 struct goldfish_battery_data {
 30         void __iomem *reg_base;
 31         int irq;
 32         spinlock_t lock;
 33 
 34         struct power_supply *battery;
 35         struct power_supply *ac;
 36 };
 37 
 38 #define GOLDFISH_BATTERY_READ(data, addr) \
 39         (readl(data->reg_base + addr))
 40 #define GOLDFISH_BATTERY_WRITE(data, addr, x) \
 41         (writel(x, data->reg_base + addr))
 42 
 43 /*
 44  * Temporary variable used between goldfish_battery_probe() and
 45  * goldfish_battery_open().
 46  */
 47 static struct goldfish_battery_data *battery_data;
 48 
 49 enum {
 50         /* status register */
 51         BATTERY_INT_STATUS          = 0x00,
 52         /* set this to enable IRQ */
 53         BATTERY_INT_ENABLE          = 0x04,
 54 
 55         BATTERY_AC_ONLINE       = 0x08,
 56         BATTERY_STATUS          = 0x0C,
 57         BATTERY_HEALTH          = 0x10,
 58         BATTERY_PRESENT         = 0x14,
 59         BATTERY_CAPACITY        = 0x18,
 60 
 61         BATTERY_STATUS_CHANGED  = 1U << 0,
 62         AC_STATUS_CHANGED       = 1U << 1,
 63         BATTERY_INT_MASK        = BATTERY_STATUS_CHANGED | AC_STATUS_CHANGED,
 64 };
 65 
 66 
 67 static int goldfish_ac_get_property(struct power_supply *psy,
 68                         enum power_supply_property psp,
 69                         union power_supply_propval *val)
 70 {
 71         struct goldfish_battery_data *data = power_supply_get_drvdata(psy);
 72         int ret = 0;
 73 
 74         switch (psp) {
 75         case POWER_SUPPLY_PROP_ONLINE:
 76                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_AC_ONLINE);
 77                 break;
 78         default:
 79                 ret = -EINVAL;
 80                 break;
 81         }
 82         return ret;
 83 }
 84 
 85 static int goldfish_battery_get_property(struct power_supply *psy,
 86                                  enum power_supply_property psp,
 87                                  union power_supply_propval *val)
 88 {
 89         struct goldfish_battery_data *data = power_supply_get_drvdata(psy);
 90         int ret = 0;
 91 
 92         switch (psp) {
 93         case POWER_SUPPLY_PROP_STATUS:
 94                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);
 95                 break;
 96         case POWER_SUPPLY_PROP_HEALTH:
 97                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);
 98                 break;
 99         case POWER_SUPPLY_PROP_PRESENT:
100                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);
101                 break;
102         case POWER_SUPPLY_PROP_TECHNOLOGY:
103                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
104                 break;
105         case POWER_SUPPLY_PROP_CAPACITY:
106                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);
107                 break;
108         default:
109                 ret = -EINVAL;
110                 break;
111         }
112 
113         return ret;
114 }
115 
116 static enum power_supply_property goldfish_battery_props[] = {
117         POWER_SUPPLY_PROP_STATUS,
118         POWER_SUPPLY_PROP_HEALTH,
119         POWER_SUPPLY_PROP_PRESENT,
120         POWER_SUPPLY_PROP_TECHNOLOGY,
121         POWER_SUPPLY_PROP_CAPACITY,
122 };
123 
124 static enum power_supply_property goldfish_ac_props[] = {
125         POWER_SUPPLY_PROP_ONLINE,
126 };
127 
128 static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)
129 {
130         unsigned long irq_flags;
131         struct goldfish_battery_data *data = dev_id;
132         uint32_t status;
133 
134         spin_lock_irqsave(&data->lock, irq_flags);
135 
136         /* read status flags, which will clear the interrupt */
137         status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);
138         status &= BATTERY_INT_MASK;
139 
140         if (status & BATTERY_STATUS_CHANGED)
141                 power_supply_changed(data->battery);
142         if (status & AC_STATUS_CHANGED)
143                 power_supply_changed(data->ac);
144 
145         spin_unlock_irqrestore(&data->lock, irq_flags);
146         return status ? IRQ_HANDLED : IRQ_NONE;
147 }
148 
149 static const struct power_supply_desc battery_desc = {
150         .properties     = goldfish_battery_props,
151         .num_properties = ARRAY_SIZE(goldfish_battery_props),
152         .get_property   = goldfish_battery_get_property,
153         .name           = "battery",
154         .type           = POWER_SUPPLY_TYPE_BATTERY,
155 };
156 
157 static const struct power_supply_desc ac_desc = {
158         .properties     = goldfish_ac_props,
159         .num_properties = ARRAY_SIZE(goldfish_ac_props),
160         .get_property   = goldfish_ac_get_property,
161         .name           = "ac",
162         .type           = POWER_SUPPLY_TYPE_MAINS,
163 };
164 
165 static int goldfish_battery_probe(struct platform_device *pdev)
166 {
167         int ret;
168         struct resource *r;
169         struct goldfish_battery_data *data;
170         struct power_supply_config psy_cfg = {};
171 
172         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
173         if (data == NULL)
174                 return -ENOMEM;
175 
176         spin_lock_init(&data->lock);
177 
178         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
179         if (r == NULL) {
180                 dev_err(&pdev->dev, "platform_get_resource failed\n");
181                 return -ENODEV;
182         }
183 
184         data->reg_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
185         if (data->reg_base == NULL) {
186                 dev_err(&pdev->dev, "unable to remap MMIO\n");
187                 return -ENOMEM;
188         }
189 
190         data->irq = platform_get_irq(pdev, 0);
191         if (data->irq < 0) {
192                 dev_err(&pdev->dev, "platform_get_irq failed\n");
193                 return -ENODEV;
194         }
195 
196         ret = devm_request_irq(&pdev->dev, data->irq, goldfish_battery_interrupt,
197                                                 IRQF_SHARED, pdev->name, data);
198         if (ret)
199                 return ret;
200 
201         psy_cfg.drv_data = data;
202 
203         data->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg);
204         if (IS_ERR(data->ac))
205                 return PTR_ERR(data->ac);
206 
207         data->battery = power_supply_register(&pdev->dev, &battery_desc,
208                                                 &psy_cfg);
209         if (IS_ERR(data->battery)) {
210                 power_supply_unregister(data->ac);
211                 return PTR_ERR(data->battery);
212         }
213 
214         platform_set_drvdata(pdev, data);
215         battery_data = data;
216 
217         GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);
218         return 0;
219 }
220 
221 static int goldfish_battery_remove(struct platform_device *pdev)
222 {
223         struct goldfish_battery_data *data = platform_get_drvdata(pdev);
224 
225         power_supply_unregister(data->battery);
226         power_supply_unregister(data->ac);
227         battery_data = NULL;
228         return 0;
229 }
230 
231 static const struct of_device_id goldfish_battery_of_match[] = {
232         { .compatible = "google,goldfish-battery", },
233         {},
234 };
235 MODULE_DEVICE_TABLE(of, goldfish_battery_of_match);
236 
237 static const struct acpi_device_id goldfish_battery_acpi_match[] = {
238         { "GFSH0001", 0 },
239         { },
240 };
241 MODULE_DEVICE_TABLE(acpi, goldfish_battery_acpi_match);
242 
243 static struct platform_driver goldfish_battery_device = {
244         .probe          = goldfish_battery_probe,
245         .remove         = goldfish_battery_remove,
246         .driver = {
247                 .name = "goldfish-battery",
248                 .of_match_table = goldfish_battery_of_match,
249                 .acpi_match_table = ACPI_PTR(goldfish_battery_acpi_match),
250         }
251 };
252 module_platform_driver(goldfish_battery_device);
253 
254 MODULE_AUTHOR("Mike Lockwood lockwood@android.com");
255 MODULE_LICENSE("GPL");
256 MODULE_DESCRIPTION("Battery driver for the Goldfish emulator");
257 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us