Initial Contribution
msm-2.6.38: tag AU_LINUX_ANDROID_GINGERBREAD.02.03.04.00.142
Signed-off-by: Bryan Huntsman <bryanh@codeaurora.org>
diff --git a/drivers/power/qci_battery.c b/drivers/power/qci_battery.c
new file mode 100644
index 0000000..724bcba
--- /dev/null
+++ b/drivers/power/qci_battery.c
@@ -0,0 +1,662 @@
+/* Quanta I2C Battery Driver
+ *
+ * Copyright (C) 2009 Quanta Computer Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+/*
+ *
+ * The Driver with I/O communications via the I2C Interface for ST15 platform.
+ * And it is only working on the nuvoTon WPCE775x Embedded Controller.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+#include <linux/sched.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+#include <linux/wpce775x.h>
+#include <linux/delay.h>
+
+#include "qci_battery.h"
+
+#define QCIBAT_DEFAULT_CHARGE_FULL_CAPACITY 2200 /* 2200 mAh */
+#define QCIBAT_DEFAULT_CHARGE_FULL_DESIGN 2200
+#define QCIBAT_DEFAULT_VOLTAGE_DESIGN 10800 /* 10.8 V */
+#define QCIBAT_STRING_SIZE 16
+
+/* General structure to hold the driver data */
+struct i2cbat_drv_data {
+ struct i2c_client *bi2c_client;
+ struct work_struct work;
+ unsigned int qcibat_irq;
+ unsigned int qcibat_gpio;
+ u8 battery_state;
+ u8 battery_dev_name[QCIBAT_STRING_SIZE];
+ u8 serial_number[QCIBAT_STRING_SIZE];
+ u8 manufacturer_name[QCIBAT_STRING_SIZE];
+ unsigned int charge_full;
+ unsigned int charge_full_design;
+ unsigned int voltage_full_design;
+ unsigned int energy_full;
+};
+
+static struct i2cbat_drv_data context;
+static struct mutex qci_i2c_lock;
+static struct mutex qci_transaction_lock;
+/*********************************************************************
+ * Power
+ *********************************************************************/
+
+static int get_bat_info(u8 ec_data)
+{
+ u8 byte_read;
+
+ mutex_lock(&qci_i2c_lock);
+ i2c_smbus_write_byte(context.bi2c_client, ec_data);
+ byte_read = i2c_smbus_read_byte(context.bi2c_client);
+ mutex_unlock(&qci_i2c_lock);
+ return byte_read;
+}
+
+static int qci_ac_get_prop(struct power_supply *psy,
+ enum power_supply_property psp,
+ union power_supply_propval *val)
+{
+ int ret = 0;
+ switch (psp) {
+ case POWER_SUPPLY_PROP_ONLINE:
+ if (get_bat_info(ECRAM_POWER_SOURCE) & EC_FLAG_ADAPTER_IN)
+ val->intval = EC_ADAPTER_PRESENT;
+ else
+ val->intval = EC_ADAPTER_NOT_PRESENT;
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+ return ret;
+}
+
+static enum power_supply_property qci_ac_props[] = {
+ POWER_SUPPLY_PROP_ONLINE,
+};
+
+static enum power_supply_property qci_bat_props[] = {
+ POWER_SUPPLY_PROP_STATUS,
+ POWER_SUPPLY_PROP_PRESENT,
+ POWER_SUPPLY_PROP_HEALTH,
+ POWER_SUPPLY_PROP_TECHNOLOGY,
+ POWER_SUPPLY_PROP_VOLTAGE_AVG,
+ POWER_SUPPLY_PROP_CURRENT_AVG,
+ POWER_SUPPLY_PROP_CAPACITY,
+ POWER_SUPPLY_PROP_TEMP,
+ POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
+ POWER_SUPPLY_PROP_CHARGE_FULL,
+ POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
+ POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
+ POWER_SUPPLY_PROP_MODEL_NAME,
+ POWER_SUPPLY_PROP_MANUFACTURER,
+ POWER_SUPPLY_PROP_SERIAL_NUMBER,
+ POWER_SUPPLY_PROP_CHARGE_COUNTER,
+ POWER_SUPPLY_PROP_ENERGY_NOW,
+ POWER_SUPPLY_PROP_ENERGY_FULL,
+ POWER_SUPPLY_PROP_ENERGY_EMPTY,
+};
+
+static int read_data_from_battery(u8 smb_cmd, u8 smb_prtcl)
+{
+ if (context.battery_state & MAIN_BATTERY_STATUS_BAT_IN) {
+ mutex_lock(&qci_i2c_lock);
+ i2c_smbus_write_byte_data(context.bi2c_client,
+ ECRAM_SMB_STS, 0);
+ i2c_smbus_write_byte_data(context.bi2c_client, ECRAM_SMB_ADDR,
+ BATTERY_SLAVE_ADDRESS);
+ i2c_smbus_write_byte_data(context.bi2c_client,
+ ECRAM_SMB_CMD, smb_cmd);
+ i2c_smbus_write_byte_data(context.bi2c_client,
+ ECRAM_SMB_PRTCL, smb_prtcl);
+ mutex_unlock(&qci_i2c_lock);
+ msleep(100);
+ return get_bat_info(ECRAM_SMB_STS);
+ } else
+ return SMBUS_DEVICE_NOACK;
+}
+
+static int qbat_get_status(union power_supply_propval *val)
+{
+ int status;
+
+ status = get_bat_info(ECRAM_BATTERY_STATUS);
+
+ if ((status & MAIN_BATTERY_STATUS_BAT_IN) == 0x0)
+ val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
+ else if (status & MAIN_BATTERY_STATUS_BAT_CHARGING)
+ val->intval = POWER_SUPPLY_STATUS_CHARGING;
+ else if (status & MAIN_BATTERY_STATUS_BAT_FULL)
+ val->intval = POWER_SUPPLY_STATUS_FULL;
+ else if (status & MAIN_BATTERY_STATUS_BAT_DISCHRG)
+ val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
+ else
+ val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
+
+ return 0;
+}
+
+static int qbat_get_present(union power_supply_propval *val)
+{
+ if (context.battery_state & MAIN_BATTERY_STATUS_BAT_IN)
+ val->intval = EC_BAT_PRESENT;
+ else
+ val->intval = EC_BAT_NOT_PRESENT;
+ return 0;
+}
+
+static int qbat_get_health(union power_supply_propval *val)
+{
+ u8 health;
+
+ health = get_bat_info(ECRAM_CHARGER_ALARM);
+ if (!(context.battery_state & MAIN_BATTERY_STATUS_BAT_IN))
+ val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
+ else if (health & ALARM_OVER_TEMP)
+ val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
+ else if (health & ALARM_REMAIN_CAPACITY)
+ val->intval = POWER_SUPPLY_HEALTH_DEAD;
+ else if (health & ALARM_OVER_CHARGE)
+ val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+ else
+ val->intval = POWER_SUPPLY_HEALTH_GOOD;
+ return 0;
+}
+
+static int qbat_get_voltage_avg(union power_supply_propval *val)
+{
+ val->intval = (get_bat_info(ECRAM_BATTERY_VOLTAGE_MSB) << 8 |
+ get_bat_info(ECRAM_BATTERY_VOLTAGE_LSB)) * 1000;
+ return 0;
+}
+
+static int qbat_get_current_avg(union power_supply_propval *val)
+{
+ val->intval = (get_bat_info(ECRAM_BATTERY_CURRENT_MSB) << 8 |
+ get_bat_info(ECRAM_BATTERY_CURRENT_LSB));
+ return 0;
+}
+
+static int qbat_get_capacity(union power_supply_propval *val)
+{
+ if (!(context.battery_state & MAIN_BATTERY_STATUS_BAT_IN))
+ val->intval = 0xFF;
+ else
+ val->intval = get_bat_info(ECRAM_BATTERY_CAPACITY);
+ return 0;
+}
+
+static int qbat_get_temp_avg(union power_supply_propval *val)
+{
+ int temp;
+ int rc = 0;
+
+ if (!(context.battery_state & MAIN_BATTERY_STATUS_BAT_IN)) {
+ val->intval = 0xFFFF;
+ rc = -ENODATA;
+ } else {
+ temp = (get_bat_info(ECRAM_BATTERY_TEMP_MSB) << 8) |
+ get_bat_info(ECRAM_BATTERY_TEMP_LSB);
+ val->intval = (temp - 2730) / 10;
+ }
+ return rc;
+}
+
+static int qbat_get_charge_full_design(union power_supply_propval *val)
+{
+ val->intval = context.charge_full_design;
+ return 0;
+}
+
+static int qbat_get_charge_full(union power_supply_propval *val)
+{
+ val->intval = context.charge_full;
+ return 0;
+}
+
+static int qbat_get_charge_counter(union power_supply_propval *val)
+{
+ u16 charge = 0;
+ int rc = 0;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_CYCLE_COUNT,
+ SMBUS_READ_WORD_PRTCL) == SMBUS_DONE) {
+ charge = get_bat_info(ECRAM_SMB_DATA1);
+ charge = charge << 8;
+ charge |= get_bat_info(ECRAM_SMB_DATA0);
+ } else
+ rc = -ENODATA;
+ mutex_unlock(&qci_transaction_lock);
+ val->intval = charge;
+ return rc;
+}
+
+static int qbat_get_time_empty_avg(union power_supply_propval *val)
+{
+ u16 avg = 0;
+ int rc = 0;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_AVERAGE_TIME_TO_EMPTY,
+ SMBUS_READ_WORD_PRTCL) == SMBUS_DONE) {
+ avg = get_bat_info(ECRAM_SMB_DATA1);
+ avg = avg << 8;
+ avg |= get_bat_info(ECRAM_SMB_DATA0);
+ } else
+ rc = -ENODATA;
+ mutex_unlock(&qci_transaction_lock);
+ val->intval = avg;
+ return rc;
+}
+
+static int qbat_get_time_full_avg(union power_supply_propval *val)
+{
+ u16 avg = 0;
+ int rc = 0;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_AVERAGE_TIME_TO_FULL,
+ SMBUS_READ_WORD_PRTCL) == SMBUS_DONE) {
+ avg = get_bat_info(ECRAM_SMB_DATA1);
+ avg = avg << 8;
+ avg |= get_bat_info(ECRAM_SMB_DATA0);
+ } else
+ rc = -ENODATA;
+ mutex_unlock(&qci_transaction_lock);
+ val->intval = avg;
+ return rc;
+}
+
+static int qbat_get_model_name(union power_supply_propval *val)
+{
+ unsigned char i, size;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_DEVICE_NAME,
+ SMBUS_READ_BLOCK_PRTCL) == SMBUS_DONE) {
+ size = min(get_bat_info(ECRAM_SMB_BCNT), QCIBAT_STRING_SIZE);
+ for (i = 0; i < size; i++) {
+ context.battery_dev_name[i] =
+ get_bat_info(ECRAM_SMB_DATA_START + i);
+ }
+ val->strval = context.battery_dev_name;
+ } else
+ val->strval = "Unknown";
+ mutex_unlock(&qci_transaction_lock);
+ return 0;
+}
+
+static int qbat_get_manufacturer_name(union power_supply_propval *val)
+{
+ val->strval = context.manufacturer_name;
+ return 0;
+}
+
+static int qbat_get_serial_number(union power_supply_propval *val)
+{
+ val->strval = context.serial_number;
+ return 0;
+}
+
+static int qbat_get_technology(union power_supply_propval *val)
+{
+ val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
+ return 0;
+}
+
+static int qbat_get_energy_now(union power_supply_propval *val)
+{
+ if (!(get_bat_info(ECRAM_BATTERY_STATUS) & MAIN_BATTERY_STATUS_BAT_IN))
+ val->intval = 0;
+ else
+ val->intval = (get_bat_info(ECRAM_BATTERY_CAPACITY) *
+ context.energy_full) / 100;
+ return 0;
+}
+
+static int qbat_get_energy_full(union power_supply_propval *val)
+{
+ val->intval = context.energy_full;
+ return 0;
+}
+
+static int qbat_get_energy_empty(union power_supply_propval *val)
+{
+ val->intval = 0;
+ return 0;
+}
+
+static void qbat_init_get_charge_full(void)
+{
+ u16 charge = QCIBAT_DEFAULT_CHARGE_FULL_CAPACITY;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_FULL_CAPACITY,
+ SMBUS_READ_WORD_PRTCL) == SMBUS_DONE) {
+ charge = get_bat_info(ECRAM_SMB_DATA1);
+ charge = charge << 8;
+ charge |= get_bat_info(ECRAM_SMB_DATA0);
+ }
+ mutex_unlock(&qci_transaction_lock);
+ context.charge_full = charge;
+}
+
+static void qbat_init_get_charge_full_design(void)
+{
+ u16 charge = QCIBAT_DEFAULT_CHARGE_FULL_DESIGN;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_DESIGN_CAPACITY,
+ SMBUS_READ_WORD_PRTCL) == SMBUS_DONE) {
+ charge = get_bat_info(ECRAM_SMB_DATA1);
+ charge = charge << 8;
+ charge |= get_bat_info(ECRAM_SMB_DATA0);
+ }
+ mutex_unlock(&qci_transaction_lock);
+ context.charge_full_design = charge;
+}
+
+static void qbat_init_get_voltage_full_design(void)
+{
+ u16 voltage = QCIBAT_DEFAULT_VOLTAGE_DESIGN;
+
+ mutex_lock(&qci_transaction_lock);
+ if (read_data_from_battery(BATTERY_DESIGN_VOLTAGE,
+ SMBUS_READ_WORD_PRTCL) == SMBUS_DONE) {
+ voltage = get_bat_info(ECRAM_SMB_DATA1);
+ voltage = voltage << 8;
+ voltage |= get_bat_info(ECRAM_SMB_DATA0);
+ }
+ mutex_unlock(&qci_transaction_lock);
+ context.voltage_full_design = voltage;
+}
+
+static void qbat_init_get_manufacturer_name(void)
+{
+ u8 size;
+ u8 i;
+ int rc;
+
+ mutex_lock(&qci_transaction_lock);
+ rc = read_data_from_battery(BATTERY_MANUFACTURE_NAME,
+ SMBUS_READ_BLOCK_PRTCL);
+ if (rc == SMBUS_DONE) {
+ size = min(get_bat_info(ECRAM_SMB_BCNT), QCIBAT_STRING_SIZE);
+ for (i = 0; i < size; i++) {
+ context.manufacturer_name[i] =
+ get_bat_info(ECRAM_SMB_DATA_START + i);
+ }
+ } else
+ strcpy(context.manufacturer_name, "Unknown");
+ mutex_unlock(&qci_transaction_lock);
+}
+
+static void qbat_init_get_serial_number(void)
+{
+ u8 size;
+ u8 i;
+ int rc;
+
+ mutex_lock(&qci_transaction_lock);
+ rc = read_data_from_battery(BATTERY_SERIAL_NUMBER,
+ SMBUS_READ_BLOCK_PRTCL);
+ if (rc == SMBUS_DONE) {
+ size = min(get_bat_info(ECRAM_SMB_BCNT), QCIBAT_STRING_SIZE);
+ for (i = 0; i < size; i++) {
+ context.serial_number[i] =
+ get_bat_info(ECRAM_SMB_DATA_START + i);
+ }
+ } else
+ strcpy(context.serial_number, "Unknown");
+ mutex_unlock(&qci_transaction_lock);
+}
+
+static void init_battery_stats(void)
+{
+ int i;
+
+ context.battery_state = get_bat_info(ECRAM_BATTERY_STATUS);
+ if (!(context.battery_state & MAIN_BATTERY_STATUS_BAT_IN))
+ return;
+ /* EC bug? needs some initial priming */
+ for (i = 0; i < 5; i++) {
+ read_data_from_battery(BATTERY_DESIGN_CAPACITY,
+ SMBUS_READ_WORD_PRTCL);
+ }
+
+ qbat_init_get_charge_full_design();
+ qbat_init_get_charge_full();
+ qbat_init_get_voltage_full_design();
+
+ context.energy_full = context.voltage_full_design *
+ context.charge_full;
+
+ qbat_init_get_serial_number();
+ qbat_init_get_manufacturer_name();
+}
+
+/*********************************************************************
+ * Battery properties
+ *********************************************************************/
+static int qbat_get_property(struct power_supply *psy,
+ enum power_supply_property psp,
+ union power_supply_propval *val)
+{
+ int ret = 0;
+
+ switch (psp) {
+ case POWER_SUPPLY_PROP_STATUS:
+ ret = qbat_get_status(val);
+ break;
+ case POWER_SUPPLY_PROP_PRESENT:
+ ret = qbat_get_present(val);
+ break;
+ case POWER_SUPPLY_PROP_HEALTH:
+ ret = qbat_get_health(val);
+ break;
+ case POWER_SUPPLY_PROP_MANUFACTURER:
+ ret = qbat_get_manufacturer_name(val);
+ break;
+ case POWER_SUPPLY_PROP_TECHNOLOGY:
+ ret = qbat_get_technology(val);
+ break;
+ case POWER_SUPPLY_PROP_VOLTAGE_AVG:
+ ret = qbat_get_voltage_avg(val);
+ break;
+ case POWER_SUPPLY_PROP_CURRENT_AVG:
+ ret = qbat_get_current_avg(val);
+ break;
+ case POWER_SUPPLY_PROP_CAPACITY:
+ ret = qbat_get_capacity(val);
+ break;
+ case POWER_SUPPLY_PROP_TEMP:
+ ret = qbat_get_temp_avg(val);
+ break;
+ case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
+ ret = qbat_get_charge_full_design(val);
+ break;
+ case POWER_SUPPLY_PROP_CHARGE_FULL:
+ ret = qbat_get_charge_full(val);
+ break;
+ case POWER_SUPPLY_PROP_CHARGE_COUNTER:
+ ret = qbat_get_charge_counter(val);
+ break;
+ case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
+ ret = qbat_get_time_empty_avg(val);
+ break;
+ case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
+ ret = qbat_get_time_full_avg(val);
+ break;
+ case POWER_SUPPLY_PROP_MODEL_NAME:
+ ret = qbat_get_model_name(val);
+ break;
+ case POWER_SUPPLY_PROP_SERIAL_NUMBER:
+ ret = qbat_get_serial_number(val);
+ break;
+ case POWER_SUPPLY_PROP_ENERGY_NOW:
+ ret = qbat_get_energy_now(val);
+ break;
+ case POWER_SUPPLY_PROP_ENERGY_FULL:
+ ret = qbat_get_energy_full(val);
+ break;
+ case POWER_SUPPLY_PROP_ENERGY_EMPTY:
+ ret = qbat_get_energy_empty(val);
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+/*********************************************************************
+ * Initialisation
+ *********************************************************************/
+
+static struct power_supply qci_ac = {
+ .name = "ac",
+ .type = POWER_SUPPLY_TYPE_MAINS,
+ .properties = qci_ac_props,
+ .num_properties = ARRAY_SIZE(qci_ac_props),
+ .get_property = qci_ac_get_prop,
+};
+
+static struct power_supply qci_bat = {
+ .name = "battery",
+ .type = POWER_SUPPLY_TYPE_BATTERY,
+ .properties = qci_bat_props,
+ .num_properties = ARRAY_SIZE(qci_bat_props),
+ .get_property = qbat_get_property,
+ .use_for_apm = 1,
+};
+
+static irqreturn_t qbat_interrupt(int irq, void *dev_id)
+{
+ struct i2cbat_drv_data *ibat_drv_data = dev_id;
+ schedule_work(&ibat_drv_data->work);
+ return IRQ_HANDLED;
+}
+
+static void qbat_work(struct work_struct *_work)
+{
+ u8 status;
+
+ status = get_bat_info(ECRAM_BATTERY_EVENTS);
+ if (status & EC_EVENT_AC) {
+ context.battery_state = get_bat_info(ECRAM_BATTERY_STATUS);
+ power_supply_changed(&qci_ac);
+ }
+
+ if (status & (EC_EVENT_BATTERY | EC_EVENT_CHARGER | EC_EVENT_TIMER)) {
+ context.battery_state = get_bat_info(ECRAM_BATTERY_STATUS);
+ power_supply_changed(&qci_bat);
+ if (status & EC_EVENT_BATTERY)
+ init_battery_stats();
+ }
+}
+
+static struct platform_device *bat_pdev;
+
+static int __init qbat_init(void)
+{
+ int err = 0;
+
+ mutex_init(&qci_i2c_lock);
+ mutex_init(&qci_transaction_lock);
+
+ context.bi2c_client = wpce_get_i2c_client();
+ if (context.bi2c_client == NULL)
+ return -1;
+
+ i2c_set_clientdata(context.bi2c_client, &context);
+ context.qcibat_gpio = context.bi2c_client->irq;
+
+ /*battery device register*/
+ bat_pdev = platform_device_register_simple("battery", 0, NULL, 0);
+ if (IS_ERR(bat_pdev))
+ return PTR_ERR(bat_pdev);
+
+ err = power_supply_register(&bat_pdev->dev, &qci_ac);
+ if (err)
+ goto ac_failed;
+
+ qci_bat.name = bat_pdev->name;
+ err = power_supply_register(&bat_pdev->dev, &qci_bat);
+ if (err)
+ goto battery_failed;
+
+ /*battery irq configure*/
+ INIT_WORK(&context.work, qbat_work);
+ err = gpio_request(context.qcibat_gpio, "qci-bat");
+ if (err) {
+ dev_err(&context.bi2c_client->dev,
+ "[BAT] err gpio request\n");
+ goto gpio_request_fail;
+ }
+ context.qcibat_irq = gpio_to_irq(context.qcibat_gpio);
+ err = request_irq(context.qcibat_irq, qbat_interrupt,
+ IRQF_TRIGGER_FALLING, BATTERY_ID_NAME, &context);
+ if (err) {
+ dev_err(&context.bi2c_client->dev,
+ "[BAT] unable to get IRQ\n");
+ goto request_irq_fail;
+ }
+
+ init_battery_stats();
+ goto success;
+
+request_irq_fail:
+ gpio_free(context.qcibat_gpio);
+
+gpio_request_fail:
+ power_supply_unregister(&qci_bat);
+
+battery_failed:
+ power_supply_unregister(&qci_ac);
+
+ac_failed:
+ platform_device_unregister(bat_pdev);
+
+ i2c_set_clientdata(context.bi2c_client, NULL);
+success:
+ return err;
+}
+
+static void __exit qbat_exit(void)
+{
+ free_irq(context.qcibat_irq, &context);
+ gpio_free(context.qcibat_gpio);
+ power_supply_unregister(&qci_bat);
+ power_supply_unregister(&qci_ac);
+ platform_device_unregister(bat_pdev);
+ i2c_set_clientdata(context.bi2c_client, NULL);
+}
+
+late_initcall(qbat_init);
+module_exit(qbat_exit);
+
+MODULE_AUTHOR("Quanta Computer Inc.");
+MODULE_DESCRIPTION("Quanta Embedded Controller I2C Battery Driver");
+MODULE_LICENSE("GPL v2");
+