target/linux/goldfish/patches-2.6.30/0126--ARM-goldfish-POWER-New-power-supply-driver-for-g.patch

   1 From 7041346d379e563e9ee66f9dd31277e4fb6b1b1f Mon Sep 17 00:00:00 2001
   2 From: Mike Lockwood <lockwood@android.com>
   3 Date: Wed, 6 Feb 2008 11:37:10 -0500
   4 Subject: [PATCH 126/134] [ARM] goldfish: POWER: New power supply driver for goldfish.
   5
   6 Signed-off-by: Mike A. Chan <mikechan@google.com>
   7 ---
   8  drivers/power/Kconfig            |    5 +
   9  drivers/power/Makefile           |    3 +-
  10  drivers/power/goldfish_battery.c |  254 ++++++++++++++++++++++++++++++++++++++
  11  3 files changed, 261 insertions(+), 1 deletions(-)
  12  create mode 100644 drivers/power/goldfish_battery.c
  13
  14 --- a/drivers/power/Kconfig
  15 +++ b/drivers/power/Kconfig
  16 @@ -88,4 +88,9 @@ config CHARGER_PCF50633
  17         help
  18          Say Y to include support for NXP PCF50633 Main Battery Charger.
  19
  20 +config BATTERY_GOLDFISH
  21 +       tristate "Goldfish battery driver"
  22 +       help
  23 +         Say Y to enable support for the battery and AC power in the Goldfish emulator.
  24 +
  25  endif # POWER_SUPPLY
  26 --- a/drivers/power/Makefile
  27 +++ b/drivers/power/Makefile
  28 @@ -19,10 +19,11 @@ obj-$(CONFIG_APM_POWER)             += apm_power.o
  29  obj-$(CONFIG_WM8350_POWER)     += wm8350_power.o
  30
  31  obj-$(CONFIG_BATTERY_DS2760)   += ds2760_battery.o
  32 +obj-$(CONFIG_BATTERY_GOLDFISH) += goldfish_battery.o
  33  obj-$(CONFIG_BATTERY_PMU)      += pmu_battery.o
  34  obj-$(CONFIG_BATTERY_OLPC)     += olpc_battery.o
  35  obj-$(CONFIG_BATTERY_TOSA)     += tosa_battery.o
  36  obj-$(CONFIG_BATTERY_WM97XX)   += wm97xx_battery.o
  37  obj-$(CONFIG_BATTERY_BQ27x00)  += bq27x00_battery.o
  38  obj-$(CONFIG_BATTERY_DA9030)   += da9030_battery.o
  39 -obj-$(CONFIG_CHARGER_PCF50633) += pcf50633-charger.o
  40 \ No newline at end of file
  41 +obj-$(CONFIG_CHARGER_PCF50633) += pcf50633-charger.o
  42 --- /dev/null
  43 +++ b/drivers/power/goldfish_battery.c
  44 @@ -0,0 +1,254 @@
  45 +/* drivers/power/goldfish_battery.c
  46 + *
  47 + * Power supply driver for the goldfish emulator
  48 + *
  49 + * Copyright (C) 2008 Google, Inc.
  50 + * Author: Mike Lockwood <lockwood@android.com>
  51 + *
  52 + * This software is licensed under the terms of the GNU General Public
  53 + * License version 2, as published by the Free Software Foundation, and
  54 + * may be copied, distributed, and modified under those terms.
  55 + *
  56 + * This program is distributed in the hope that it will be useful,
  57 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  58 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  59 + * GNU General Public License for more details.
  60 + *
  61 + */
  62 +
  63 +#include <linux/module.h>
  64 +#include <linux/err.h>
  65 +#include <linux/platform_device.h>
  66 +#include <linux/power_supply.h>
  67 +#include <linux/types.h>
  68 +#include <linux/pci.h>
  69 +#include <linux/interrupt.h>
  70 +#include <asm/io.h>
  71 +
  72 +
  73 +struct goldfish_battery_data {
  74 +       uint32_t reg_base;
  75 +       int irq;
  76 +       spinlock_t lock;
  77 +
  78 +       struct power_supply battery;
  79 +       struct power_supply ac;
  80 +};
  81 +
  82 +#define GOLDFISH_BATTERY_READ(data, addr)   (readl(data->reg_base + addr))
  83 +#define GOLDFISH_BATTERY_WRITE(data, addr, x)   (writel(x, data->reg_base + addr))
  84 +
  85 +
  86 +/* temporary variable used between goldfish_battery_probe() and goldfish_battery_open() */
  87 +static struct goldfish_battery_data *battery_data;
  88 +
  89 +enum {
  90 +       /* status register */
  91 +       BATTERY_INT_STATUS          = 0x00,
  92 +       /* set this to enable IRQ */
  93 +       BATTERY_INT_ENABLE          = 0x04,
  94 +
  95 +       BATTERY_AC_ONLINE       = 0x08,
  96 +       BATTERY_STATUS          = 0x0C,
  97 +       BATTERY_HEALTH          = 0x10,
  98 +       BATTERY_PRESENT         = 0x14,
  99 +       BATTERY_CAPACITY        = 0x18,
 100 +
 101 +       BATTERY_STATUS_CHANGED  = 1U << 0,
 102 +       AC_STATUS_CHANGED       = 1U << 1,
 103 +       BATTERY_INT_MASK        = BATTERY_STATUS_CHANGED | AC_STATUS_CHANGED,
 104 +};
 105 +
 106 +
 107 +static int goldfish_ac_get_property(struct power_supply *psy,
 108 +                       enum power_supply_property psp,
 109 +                       union power_supply_propval *val)
 110 +{
 111 +       struct goldfish_battery_data *data = container_of(psy,
 112 +               struct goldfish_battery_data, ac);
 113 +       int ret = 0;
 114 +
 115 +       switch (psp) {
 116 +       case POWER_SUPPLY_PROP_ONLINE:
 117 +               val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_AC_ONLINE);
 118 +               break;
 119 +       default:
 120 +               ret = -EINVAL;
 121 +               break;
 122 +       }
 123 +       return ret;
 124 +}
 125 +
 126 +static int goldfish_battery_get_property(struct power_supply *psy,
 127 +                                enum power_supply_property psp,
 128 +                                union power_supply_propval *val)
 129 +{
 130 +       struct goldfish_battery_data *data = container_of(psy,
 131 +               struct goldfish_battery_data, battery);
 132 +       int ret = 0;
 133 +
 134 +       switch (psp) {
 135 +       case POWER_SUPPLY_PROP_STATUS:
 136 +               val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);
 137 +               break;
 138 +       case POWER_SUPPLY_PROP_HEALTH:
 139 +               val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);
 140 +               break;
 141 +       case POWER_SUPPLY_PROP_PRESENT:
 142 +               val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);
 143 +               break;
 144 +       case POWER_SUPPLY_PROP_TECHNOLOGY:
 145 +               val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 146 +               break;
 147 +       case POWER_SUPPLY_PROP_CAPACITY:
 148 +               val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);
 149 +               break;
 150 +       default:
 151 +               ret = -EINVAL;
 152 +               break;
 153 +       }
 154 +
 155 +       return ret;
 156 +}
 157 +
 158 +static enum power_supply_property goldfish_battery_props[] = {
 159 +       POWER_SUPPLY_PROP_STATUS,
 160 +       POWER_SUPPLY_PROP_HEALTH,
 161 +       POWER_SUPPLY_PROP_PRESENT,
 162 +       POWER_SUPPLY_PROP_TECHNOLOGY,
 163 +       POWER_SUPPLY_PROP_CAPACITY,
 164 +};
 165 +
 166 +static enum power_supply_property goldfish_ac_props[] = {
 167 +       POWER_SUPPLY_PROP_ONLINE,
 168 +};
 169 +
 170 +static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)
 171 +{
 172 +       unsigned long irq_flags;
 173 +       struct goldfish_battery_data *data = dev_id;
 174 +       uint32_t status;
 175 +
 176 +       spin_lock_irqsave(&data->lock, irq_flags);
 177 +
 178 +       /* read status flags, which will clear the interrupt */
 179 +       status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);
 180 +       status &= BATTERY_INT_MASK;
 181 +
 182 +       if (status & BATTERY_STATUS_CHANGED)
 183 +               power_supply_changed(&data->battery);
 184 +       if (status & AC_STATUS_CHANGED)
 185 +               power_supply_changed(&data->ac);
 186 +
 187 +       spin_unlock_irqrestore(&data->lock, irq_flags);
 188 +       return status ? IRQ_HANDLED : IRQ_NONE;
 189 +}
 190 +
 191 +
 192 +static int goldfish_battery_probe(struct platform_device *pdev)
 193 +{
 194 +       int ret;
 195 +       struct resource *r;
 196 +       struct goldfish_battery_data *data;
 197 +
 198 +       data = kzalloc(sizeof(*data), GFP_KERNEL);
 199 +       if (data == NULL) {
 200 +               ret = -ENOMEM;
 201 +               goto err_data_alloc_failed;
 202 +       }
 203 +       spin_lock_init(&data->lock);
 204 +
 205 +       data->battery.properties = goldfish_battery_props;
 206 +       data->battery.num_properties = ARRAY_SIZE(goldfish_battery_props);
 207 +       data->battery.get_property = goldfish_battery_get_property;
 208 +       data->battery.name = "battery";
 209 +       data->battery.type = POWER_SUPPLY_TYPE_BATTERY;
 210 +
 211 +       data->ac.properties = goldfish_ac_props;
 212 +       data->ac.num_properties = ARRAY_SIZE(goldfish_ac_props);
 213 +       data->ac.get_property = goldfish_ac_get_property;
 214 +       data->ac.name = "ac";
 215 +       data->ac.type = POWER_SUPPLY_TYPE_MAINS;
 216 +
 217 +       r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 218 +       if (r == NULL) {
 219 +               printk(KERN_ERR "%s: platform_get_resource failed\n", pdev->name);
 220 +               ret = -ENODEV;
 221 +               goto err_no_io_base;
 222 +       }
 223 +       data->reg_base = IO_ADDRESS(r->start - IO_START);
 224 +
 225 +       data->irq = platform_get_irq(pdev, 0);
 226 +       if (data->irq < 0) {
 227 +               printk(KERN_ERR "%s: platform_get_irq failed\n", pdev->name);
 228 +               ret = -ENODEV;
 229 +               goto err_no_irq;
 230 +       }
 231 +
 232 +       ret = request_irq(data->irq, goldfish_battery_interrupt, IRQF_SHARED, pdev->name, data);
 233 +       if (ret)
 234 +               goto err_request_irq_failed;
 235 +
 236 +       ret = power_supply_register(&pdev->dev, &data->ac);
 237 +       if (ret)
 238 +               goto err_ac_failed;
 239 +
 240 +       ret = power_supply_register(&pdev->dev, &data->battery);
 241 +       if (ret)
 242 +               goto err_battery_failed;
 243 +
 244 +       platform_set_drvdata(pdev, data);
 245 +       battery_data = data;
 246 +
 247 +       GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);
 248 +       return 0;
 249 +
 250 +err_battery_failed:
 251 +       power_supply_unregister(&data->ac);
 252 +err_ac_failed:
 253 +       free_irq(data->irq, data);
 254 +err_request_irq_failed:
 255 +err_no_irq:
 256 +err_no_io_base:
 257 +       kfree(data);
 258 +err_data_alloc_failed:
 259 +       return ret;
 260 +}
 261 +
 262 +static int goldfish_battery_remove(struct platform_device *pdev)
 263 +{
 264 +       struct goldfish_battery_data *data = platform_get_drvdata(pdev);
 265 +
 266 +       power_supply_unregister(&data->battery);
 267 +       power_supply_unregister(&data->ac);
 268 +
 269 +       free_irq(data->irq, data);
 270 +       kfree(data);
 271 +       battery_data = NULL;
 272 +       return 0;
 273 +}
 274 +
 275 +static struct platform_driver goldfish_battery_device = {
 276 +       .probe          = goldfish_battery_probe,
 277 +       .remove         = goldfish_battery_remove,
 278 +       .driver = {
 279 +               .name = "goldfish-battery"
 280 +       }
 281 +};
 282 +
 283 +static int __init goldfish_battery_init(void)
 284 +{
 285 +       return platform_driver_register(&goldfish_battery_device);
 286 +}
 287 +
 288 +static void __exit goldfish_battery_exit(void)
 289 +{
 290 +       platform_driver_unregister(&goldfish_battery_device);
 291 +}
 292 +
 293 +module_init(goldfish_battery_init);
 294 +module_exit(goldfish_battery_exit);
 295 +
 296 +MODULE_AUTHOR("Mike Lockwood lockwood@android.com");
 297 +MODULE_LICENSE("GPL");
 298 +MODULE_DESCRIPTION("Battery driver for the Goldfish emulator");