Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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 
 28 struct goldfish_battery_data {
 29         void __iomem *reg_base;
 30         int irq;
 31         spinlock_t lock;
 32 
 33         struct power_supply battery;
 34         struct power_supply ac;
 35 };
 36 
 37 #define GOLDFISH_BATTERY_READ(data, addr) \
 38         (readl(data->reg_base + addr))
 39 #define GOLDFISH_BATTERY_WRITE(data, addr, x) \
 40         (writel(x, data->reg_base + addr))
 41 
 42 /*
 43  * Temporary variable used between goldfish_battery_probe() and
 44  * goldfish_battery_open().
 45  */
 46 static struct goldfish_battery_data *battery_data;
 47 
 48 enum {
 49         /* status register */
 50         BATTERY_INT_STATUS          = 0x00,
 51         /* set this to enable IRQ */
 52         BATTERY_INT_ENABLE          = 0x04,
 53 
 54         BATTERY_AC_ONLINE       = 0x08,
 55         BATTERY_STATUS          = 0x0C,
 56         BATTERY_HEALTH          = 0x10,
 57         BATTERY_PRESENT         = 0x14,
 58         BATTERY_CAPACITY        = 0x18,
 59 
 60         BATTERY_STATUS_CHANGED  = 1U << 0,
 61         AC_STATUS_CHANGED       = 1U << 1,
 62         BATTERY_INT_MASK        = BATTERY_STATUS_CHANGED | AC_STATUS_CHANGED,
 63 };
 64 
 65 
 66 static int goldfish_ac_get_property(struct power_supply *psy,
 67                         enum power_supply_property psp,
 68                         union power_supply_propval *val)
 69 {
 70         struct goldfish_battery_data *data = container_of(psy,
 71                 struct goldfish_battery_data, ac);
 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 = container_of(psy,
 90                 struct goldfish_battery_data, battery);
 91         int ret = 0;
 92 
 93         switch (psp) {
 94         case POWER_SUPPLY_PROP_STATUS:
 95                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);
 96                 break;
 97         case POWER_SUPPLY_PROP_HEALTH:
 98                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);
 99                 break;
100         case POWER_SUPPLY_PROP_PRESENT:
101                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);
102                 break;
103         case POWER_SUPPLY_PROP_TECHNOLOGY:
104                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
105                 break;
106         case POWER_SUPPLY_PROP_CAPACITY:
107                 val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);
108                 break;
109         default:
110                 ret = -EINVAL;
111                 break;
112         }
113 
114         return ret;
115 }
116 
117 static enum power_supply_property goldfish_battery_props[] = {
118         POWER_SUPPLY_PROP_STATUS,
119         POWER_SUPPLY_PROP_HEALTH,
120         POWER_SUPPLY_PROP_PRESENT,
121         POWER_SUPPLY_PROP_TECHNOLOGY,
122         POWER_SUPPLY_PROP_CAPACITY,
123 };
124 
125 static enum power_supply_property goldfish_ac_props[] = {
126         POWER_SUPPLY_PROP_ONLINE,
127 };
128 
129 static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)
130 {
131         unsigned long irq_flags;
132         struct goldfish_battery_data *data = dev_id;
133         uint32_t status;
134 
135         spin_lock_irqsave(&data->lock, irq_flags);
136 
137         /* read status flags, which will clear the interrupt */
138         status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);
139         status &= BATTERY_INT_MASK;
140 
141         if (status & BATTERY_STATUS_CHANGED)
142                 power_supply_changed(&data->battery);
143         if (status & AC_STATUS_CHANGED)
144                 power_supply_changed(&data->ac);
145 
146         spin_unlock_irqrestore(&data->lock, irq_flags);
147         return status ? IRQ_HANDLED : IRQ_NONE;
148 }
149 
150 
151 static int goldfish_battery_probe(struct platform_device *pdev)
152 {
153         int ret;
154         struct resource *r;
155         struct goldfish_battery_data *data;
156 
157         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
158         if (data == NULL)
159                 return -ENOMEM;
160 
161         spin_lock_init(&data->lock);
162 
163         data->battery.properties = goldfish_battery_props;
164         data->battery.num_properties = ARRAY_SIZE(goldfish_battery_props);
165         data->battery.get_property = goldfish_battery_get_property;
166         data->battery.name = "battery";
167         data->battery.type = POWER_SUPPLY_TYPE_BATTERY;
168 
169         data->ac.properties = goldfish_ac_props;
170         data->ac.num_properties = ARRAY_SIZE(goldfish_ac_props);
171         data->ac.get_property = goldfish_ac_get_property;
172         data->ac.name = "ac";
173         data->ac.type = POWER_SUPPLY_TYPE_MAINS;
174 
175         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
176         if (r == NULL) {
177                 dev_err(&pdev->dev, "platform_get_resource failed\n");
178                 return -ENODEV;
179         }
180 
181         data->reg_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
182         if (data->reg_base == NULL) {
183                 dev_err(&pdev->dev, "unable to remap MMIO\n");
184                 return -ENOMEM;
185         }
186 
187         data->irq = platform_get_irq(pdev, 0);
188         if (data->irq < 0) {
189                 dev_err(&pdev->dev, "platform_get_irq failed\n");
190                 return -ENODEV;
191         }
192 
193         ret = devm_request_irq(&pdev->dev, data->irq, goldfish_battery_interrupt,
194                                                 IRQF_SHARED, pdev->name, data);
195         if (ret)
196                 return ret;
197 
198         ret = power_supply_register(&pdev->dev, &data->ac);
199         if (ret)
200                 return ret;
201 
202         ret = power_supply_register(&pdev->dev, &data->battery);
203         if (ret) {
204                 power_supply_unregister(&data->ac);
205                 return ret;
206         }
207 
208         platform_set_drvdata(pdev, data);
209         battery_data = data;
210 
211         GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);
212         return 0;
213 }
214 
215 static int goldfish_battery_remove(struct platform_device *pdev)
216 {
217         struct goldfish_battery_data *data = platform_get_drvdata(pdev);
218 
219         power_supply_unregister(&data->battery);
220         power_supply_unregister(&data->ac);
221         battery_data = NULL;
222         return 0;
223 }
224 
225 static struct platform_driver goldfish_battery_device = {
226         .probe          = goldfish_battery_probe,
227         .remove         = goldfish_battery_remove,
228         .driver = {
229                 .name = "goldfish-battery"
230         }
231 };
232 module_platform_driver(goldfish_battery_device);
233 
234 MODULE_AUTHOR("Mike Lockwood lockwood@android.com");
235 MODULE_LICENSE("GPL");
236 MODULE_DESCRIPTION("Battery driver for the Goldfish emulator");
237 

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