| /***************************************************************************** |
| * Copyright 2011 Broadcom Corporation. All rights reserved. |
| * |
| * Unless you and Broadcom execute a separate written software license |
| * agreement governing use of this software, this software is licensed to you |
| * under the terms of the GNU General Public License version 2, available at |
| * http://www.broadcom.com/licenses/GPLv2.php (the "GPL"). |
| * |
| * Notwithstanding the above, under no circumstances may you combine this |
| * software in any way with any other Broadcom software provided under a |
| * license other than the GPL, without Broadcom's express prior written |
| * consent. |
| *****************************************************************************/ |
| |
| /* |
| * A driver to monitor the MAX17040 or ADC121C021, the AC power and charge state |
| * of the battery. |
| * |
| * Driver works in conjunction with frameworks defined in linux/power_supply.h |
| * and linux/pm.h. |
| * |
| * 2 power_supply devices - power and battery are registered/unregistered with |
| * power supply(PSY) framework and report properties to PSY. The list of |
| * properties supported by this driver is defined in battery_data_props and |
| * power_data_props arrays. |
| * |
| * Another PSY - USB is added to comply with Android's expectations. For now |
| * this is a mock PSY, that provides one propery - "online" that is always set |
| * to false. In the future boards (when the USB supply/charger is available) |
| * this will be changed. |
| * |
| * Driver works in cooperation with battery monitor that registers with the |
| * driver via exported register_battery_monitor function. Driver relies on |
| * battery monitor for methods to determine volatage and charge and for supply |
| * of some essential data such as GPIO values. Only one battery monitor may be |
| * registered at a time. Battery driver will be nonfunctional if there is no |
| * battery monitor registered. |
| * |
| * Platform information is passed into the driver via the platform_data pointer. |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/platform_device.h> |
| #include <linux/delay.h> |
| #include <linux/power_supply.h> |
| #include <linux/pm.h> |
| #include <linux/spinlock.h> |
| #include <linux/interrupt.h> |
| #include <linux/irq.h> |
| #include <linux/gpio.h> |
| #include <linux/wakelock.h> |
| #include <linux/slab.h> |
| #include <linux/workqueue.h> |
| #include <linux/i2c.h> |
| |
| #include <linux/broadcom/cmp_battery_multi.h> |
| |
| EXPORT_SYMBOL(register_battery_monitor); |
| |
| /* ---- Public Functions ------------------------------------------------- */ |
| /* after power_supply devices are registered, these functions are used to get |
| * power and battery properies */ |
| static int battery_get_property(struct power_supply *psy, |
| enum power_supply_property psp, |
| union power_supply_propval *val); |
| static int power_get_property(struct power_supply *psy, |
| enum power_supply_property psp, |
| union power_supply_propval *val); |
| |
| static int usbpower_get_property(struct power_supply *psy, |
| enum power_supply_property psp, |
| union power_supply_propval *val); |
| |
| static void battery_external_power_changed(struct power_supply *psy); |
| |
| /* ---- Private Constants and Types -------------------------------------- */ |
| |
| /* Main structure used in this driver. */ |
| struct multi_data |
| { |
| /* Battery PSY */ |
| struct power_supply battery_psy; |
| |
| /* AC power PSY */ |
| struct power_supply ac_power_psy; |
| |
| /* task to handle AC power plug / remove. */ |
| struct work_struct t_ac_power_work; |
| |
| /* task to periodically send battery uEvent */ |
| struct delayed_work t_battery_dwork; |
| |
| /* battery monitor instance and data that is registered with the driver */ |
| struct battery_monitor *pt_battery_monitor; |
| void *pt_battery_monitor_data; |
| |
| /* wake lock. When taken keeps device awake */ |
| struct wake_lock wakelock; |
| |
| /* Reference to platform_data passed in by probe. */ |
| struct cbm_platform_data *pt_platform_data; |
| }; |
| |
| #define DEBOUNCE_TIME_USECS 128000 |
| #define MULTI_WAIT_PERIOD (30*HZ) |
| #define MULTI_NO_WAIT 0 |
| |
| #define INT_SETUP_SLEEP_MSECS 50 |
| |
| /* ---- Private Variables ------------------------------------------------ */ |
| |
| /* Debug macro */ |
| #define PRINT_DEBUG(format, args...) \ |
| do { if (mod_debug) printk(KERN_WARNING "[cmp_battery_multi]: " format, ## args); } while (0) |
| |
| /* define mod_debug module parameter to enable/disable debug messages */ |
| static int mod_debug = 0x0; |
| module_param(mod_debug, int, 0644); |
| |
| static const __devinitconst char gBanner[] = |
| KERN_INFO "Multi Battery Driver: 1.02\n"; |
| |
| /* workqueue and work task for debouncing power input signal */ |
| static struct workqueue_struct *isr_wq; |
| |
| static const char *wake_lock_name = "multi_battery_driver"; |
| |
| static char *power_supplied_to[] = |
| { |
| "battery", |
| }; |
| |
| /* array of properties supported by battery PSY */ |
| static enum power_supply_property battery_data_props[] = |
| { |
| POWER_SUPPLY_PROP_STATUS, /* charging, discharging ... */ |
| POWER_SUPPLY_PROP_HEALTH, /* good, overheat, dead ... */ |
| POWER_SUPPLY_PROP_PRESENT, /* */ |
| POWER_SUPPLY_PROP_TECHNOLOGY, /* NiMH|LION|... */ |
| POWER_SUPPLY_PROP_VOLTAGE_MAX, /* battery_max */ |
| POWER_SUPPLY_PROP_VOLTAGE_MIN, /* battery_min */ |
| POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, /* */ |
| POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, /* */ |
| POWER_SUPPLY_PROP_VOLTAGE_NOW, /* battery voltage(mV) */ |
| POWER_SUPPLY_PROP_CAPACITY, /* Capacity in percent */ |
| POWER_SUPPLY_PROP_TEMP, /* Degrees celsius */ |
| }; |
| |
| /* array of properties supported by AC power PSY */ |
| static enum power_supply_property power_data_props[] = { |
| POWER_SUPPLY_PROP_ONLINE, /* AC plugged in or not */ |
| }; |
| |
| /* array of properties supported by USB power PSY */ |
| static enum power_supply_property usbpower_data_props[] = { |
| POWER_SUPPLY_PROP_ONLINE, /* USB power plugged in or not */ |
| }; |
| |
| /* initialize PSY in multi_data struct */ |
| static struct multi_data g_multi_data = |
| { |
| .battery_psy = |
| { |
| .name = "battery", |
| .type = POWER_SUPPLY_TYPE_BATTERY, |
| .properties = battery_data_props, |
| .num_properties = ARRAY_SIZE(battery_data_props), |
| .get_property = battery_get_property, |
| .external_power_changed = battery_external_power_changed, |
| .use_for_apm = 1, |
| }, |
| |
| .ac_power_psy = |
| { |
| .name = "power", |
| .type = POWER_SUPPLY_TYPE_MAINS, |
| .supplied_to = power_supplied_to, |
| .num_supplicants = ARRAY_SIZE(power_supplied_to), |
| .properties = power_data_props, |
| .num_properties = ARRAY_SIZE(power_data_props), |
| .get_property = power_get_property, |
| }, |
| }; |
| |
| /* initialize usb power PSY */ |
| static struct power_supply usb_power_psy = |
| { |
| .name = "usbpower", |
| .type = POWER_SUPPLY_TYPE_USB, |
| .supplied_to = power_supplied_to, |
| .num_supplicants = ARRAY_SIZE(power_supplied_to), |
| .properties = usbpower_data_props, |
| .num_properties = ARRAY_SIZE(power_data_props), |
| .get_property = usbpower_get_property, |
| }; |
| |
| static int g_gpio_power_control = -1; |
| |
| /* flag inidicating if the driver is ready for battery monitor drivers |
| to register */ |
| static bool g_is_driver_ok = false; |
| |
| /* ---- Private Function Prototypes -------------------------------------- */ |
| static void cmp_battery_multi_power_off(void); |
| static bool is_ac_connected (void); |
| static void multi_battery_work (struct work_struct *p_work); |
| static int setup_gpios (struct battery_monitor *pt_battery_monitor); |
| static void close_gpios (struct battery_monitor *pt_battery_monitor); |
| static void ac_power_isr_handler_work (struct work_struct *p_work); |
| static int get_voltage(void); |
| static int get_charge(void); |
| |
| /* ---- Public Functions ------------------------------------------------- */ |
| |
| /* this is exported function that is called by battery monitor to register with |
| the battery driver */ |
| int register_battery_monitor(struct battery_monitor *p_monitor, void *p_data) |
| { |
| int rc; |
| |
| if (g_is_driver_ok == false) |
| { |
| printk(KERN_ERR "%s() battery monitor %s cannot register. " |
| "Battery driver is not ready.\n", __FUNCTION__, p_monitor->name); |
| return -ENODATA; |
| } |
| |
| /* Check the fundamental assumption that the AC power GPIO must be supplied |
| by the battery monitor. Note that after this check we do not need to |
| check AC power gpio presence again */ |
| if (p_monitor->gpio_ac_power < 0) |
| { |
| printk(KERN_ERR "%s() battery monitor %s did not supply " |
| "valid AC power GPIO. The value is %d\n", |
| __FUNCTION__, p_monitor->name, p_monitor->gpio_ac_power); |
| return -ENODATA; |
| } |
| |
| printk(KERN_INFO "%s() battery monitor %s successfully registered " |
| "with multi battery driver\n", __FUNCTION__, p_monitor->name); |
| |
| /* store monitor and monitor data in multi struct */ |
| g_multi_data.pt_battery_monitor = p_monitor; |
| g_multi_data.pt_battery_monitor_data = p_data; |
| |
| /* initialize ISR work */ |
| INIT_WORK(&g_multi_data.t_ac_power_work, ac_power_isr_handler_work); |
| |
| /* setup GPIOs. Note that setup_gpios also sets up AC power interrupt so this |
| should be done after t_ac_power_work is initialized */ |
| if ((rc = setup_gpios(p_monitor)) != 0) |
| { |
| printk(KERN_ERR "%s() setup_gpios() returned %d\n", __FUNCTION__, rc); |
| return rc; |
| } |
| |
| /* take wakelock if the AC power is connected */ |
| if (is_ac_connected()) |
| { |
| wake_lock(&g_multi_data.wakelock); |
| printk(KERN_INFO "%s() taking wake lock\n", __FUNCTION__); |
| } |
| |
| /* schedule delayed work for battery PSY */ |
| schedule_delayed_work(&g_multi_data.t_battery_dwork, MULTI_NO_WAIT); |
| return 0; |
| } |
| |
| /* ---- Private Functions ------------------------------------------------ */ |
| |
| static bool is_ac_connected(void) |
| { |
| /* Note that this function may be called before battery monitor is |
| registered */ |
| if (g_multi_data.pt_battery_monitor == NULL) |
| return false; |
| |
| int ac_gpio_level = |
| gpio_get_value(g_multi_data.pt_battery_monitor->gpio_ac_power); |
| |
| /* AC power GPIO level differs between boards. */ |
| |
| /* if GPIO high indicates AC power is connected. */ |
| if (g_multi_data.pt_battery_monitor->ac_power_on_level > 0) |
| return (ac_gpio_level > 0) ? true : false; |
| else |
| /* GPIO low indicates AC power is connected. */ |
| return (ac_gpio_level > 0) ? false : true; |
| } |
| |
| /* get battery charging status */ |
| /* Note that the P11 tablet uses MAX 17040 monitor that does not have charge |
| indicator pin */ |
| static int get_battery_status(void) |
| { |
| /* Note that this function may be called before battery monitor is |
| registered */ |
| if (g_multi_data.pt_battery_monitor == NULL) |
| return POWER_SUPPLY_STATUS_UNKNOWN; |
| |
| /* if AC power is disconnected */ |
| if (!is_ac_connected()) |
| return POWER_SUPPLY_STATUS_DISCHARGING; |
| |
| /* else if there is charging pin that does not indicate charging */ |
| /* note that we are assuming that charging GPIO set to high indicates full |
| charge (no charging) */ |
| else if (g_multi_data.pt_battery_monitor->gpio_charger != -1 && |
| gpio_get_value(g_multi_data.pt_battery_monitor->gpio_charger)) |
| return POWER_SUPPLY_STATUS_NOT_CHARGING; |
| else |
| return POWER_SUPPLY_STATUS_CHARGING; |
| } |
| |
| static int get_voltage(void) |
| { |
| int voltage; |
| struct battery_monitor *pt_battery_monitor = g_multi_data.pt_battery_monitor; |
| |
| /* if monitor provides function to access voltage */ |
| if (pt_battery_monitor != NULL && pt_battery_monitor->get_voltage_fn != NULL) |
| { |
| /* get value from the monitor */ |
| voltage = pt_battery_monitor->get_voltage_fn( |
| g_multi_data.pt_battery_monitor_data)*1000; |
| |
| /* do not want to return 0, may cause tablet to restart */ |
| if (voltage == 0) |
| { |
| voltage = g_multi_data.pt_platform_data->battery_min_voltage*1000; |
| } |
| |
| PRINT_DEBUG("%s() battery_voltage: %d\n", __FUNCTION__, voltage); |
| } |
| else |
| { |
| PRINT_DEBUG("%s() battery monitor get_battery_voltage_fn() " |
| "not configured\n", __FUNCTION__); |
| voltage = g_multi_data.pt_platform_data->battery_max_voltage*1000; |
| } |
| return voltage; |
| } |
| |
| static int get_charge() |
| { |
| int charge_percent; |
| struct battery_monitor *pt_battery_monitor = g_multi_data.pt_battery_monitor; |
| |
| /* if monitor provides function to access charge */ |
| if (pt_battery_monitor != NULL && pt_battery_monitor->get_charge_fn != NULL) |
| { |
| charge_percent = |
| pt_battery_monitor->get_charge_fn(g_multi_data.pt_battery_monitor_data); |
| PRINT_DEBUG("%s() battery_charge: %d\n", __FUNCTION__, charge_percent); |
| } |
| else |
| { |
| PRINT_DEBUG("%s() battery monitor get_charge_fn() not configured\n", |
| __FUNCTION__); |
| |
| /* calculate charge */ |
| charge_percent = |
| (get_voltage() - g_multi_data.pt_platform_data->battery_min_voltage)*100/ |
| (g_multi_data.pt_platform_data->battery_max_voltage - |
| g_multi_data.pt_platform_data->battery_min_voltage); |
| } |
| |
| /* |
| * It is important that the charge level of the battery returned by |
| * POWER_SUPPLY_PROP_CAPACITY never be accidentally set to zero. This might |
| * cause a reboot by the parent OS. It is also bad if the value is greater |
| * than 100. |
| */ |
| if (charge_percent <= 0 || charge_percent > 100) |
| { |
| /* Need to keep this value in range. */ |
| charge_percent = 100; |
| PRINT_DEBUG("%s() charge out of range %d, setting to 100\n", |
| __FUNCTION__, charge_percent); |
| } |
| return charge_percent; |
| } |
| |
| static int battery_get_property(struct power_supply *pt_power_supply, |
| enum power_supply_property psp, |
| union power_supply_propval *val) |
| { |
| int ret = 0; |
| PRINT_DEBUG("%s() requested property: %d\n", __FUNCTION__, psp); |
| |
| switch (psp) |
| { |
| case POWER_SUPPLY_PROP_STATUS: |
| val->intval = get_battery_status(); |
| break; |
| case POWER_SUPPLY_PROP_HEALTH: |
| val->intval = POWER_SUPPLY_HEALTH_GOOD; |
| break; |
| case POWER_SUPPLY_PROP_PRESENT: |
| /* assume that the battery is always present */ |
| /* this assumption is valid for tablet */ |
| val->intval = 1; |
| break; |
| case POWER_SUPPLY_PROP_TECHNOLOGY: |
| val->intval = g_multi_data.pt_platform_data->battery_technology; |
| break; |
| case POWER_SUPPLY_PROP_VOLTAGE_MAX: |
| val->intval = g_multi_data.pt_platform_data->battery_max_voltage*1000; |
| break; |
| case POWER_SUPPLY_PROP_VOLTAGE_MIN: |
| val->intval = g_multi_data.pt_platform_data->battery_min_voltage*1000; |
| break; |
| case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: |
| val->intval = g_multi_data.pt_platform_data->battery_max_voltage*1000; |
| break; |
| case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: |
| val->intval = g_multi_data.pt_platform_data->battery_min_voltage*1000; |
| break; |
| case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
| val->intval = get_voltage(); |
| break; |
| case POWER_SUPPLY_PROP_CAPACITY: |
| val->intval = get_charge(); |
| break; |
| case POWER_SUPPLY_PROP_TEMP: |
| /* current battery monitors do not supply this data */ |
| val->intval = 0; |
| break; |
| default: |
| ret = -EINVAL; |
| break; |
| } |
| |
| PRINT_DEBUG("%s() property: %d value: %d\n", __FUNCTION__, psp, val->intval); |
| return ret; |
| } |
| |
| static int power_get_property(struct power_supply *pt_power_supply, |
| enum power_supply_property psp, |
| union power_supply_propval *val) |
| { |
| switch (psp) |
| { |
| case POWER_SUPPLY_PROP_ONLINE: |
| val->intval = is_ac_connected(); |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| PRINT_DEBUG("%s() property: %d value: %d\n", |
| __FUNCTION__, psp, val->intval); |
| return 0; |
| } |
| |
| static int usbpower_get_property(struct power_supply *pt_power_supply, |
| enum power_supply_property psp, |
| union power_supply_propval *val) |
| { |
| switch (psp) |
| { |
| case POWER_SUPPLY_PROP_ONLINE: |
| val->intval = 0; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| PRINT_DEBUG("%s() property: %d value: %d\n", |
| __FUNCTION__, psp, val->intval); |
| return 0; |
| } |
| |
| /* Called when the device is plugged into or removed from an AC supply. */ |
| static irqreturn_t ac_power_gpio_isr(int irq, void *data) |
| { |
| struct multi_data *pt_multi_data = (struct multi_data *)data; |
| |
| if (pt_multi_data == NULL) |
| { |
| printk(KERN_ERR "%s() pt_multi_data == NULL!\n", __FUNCTION__); |
| return IRQ_HANDLED; |
| } |
| |
| queue_work(isr_wq, &pt_multi_data->t_ac_power_work); |
| return IRQ_HANDLED; |
| } |
| |
| /* battery PSY delayed work. */ |
| static void multi_battery_work(struct work_struct *p_work) |
| { |
| /* send uEvent indicating that battery PSY has been changed. Note that we |
| are not attempting (at the driver level) to check if any of the battery |
| properties changed, leaving it to the uEvent handler to do all the analysis */ |
| power_supply_changed(&g_multi_data.battery_psy); |
| |
| /* reschedule delayed work to keep periodic uEvent sending */ |
| schedule_delayed_work(&g_multi_data.t_battery_dwork, MULTI_WAIT_PERIOD); |
| } |
| |
| /* AC power change ISR work */ |
| static void ac_power_isr_handler_work(struct work_struct *p_work) |
| { |
| /* if AC power is connected */ |
| if (is_ac_connected()) |
| { |
| wake_lock(&g_multi_data.wakelock); |
| PRINT_DEBUG("%s() taking wake lock\n", __FUNCTION__); |
| } |
| else |
| { |
| wake_unlock(&g_multi_data.wakelock); |
| PRINT_DEBUG("%s() releasing wake lock\n", __FUNCTION__); |
| } |
| |
| /* send uEvent indicating that power PSY has been changed */ |
| power_supply_changed(&g_multi_data.ac_power_psy); |
| } |
| |
| static void battery_external_power_changed(struct power_supply *t_power_supply) |
| { |
| PRINT_DEBUG("%s() called\n", __FUNCTION__); |
| } |
| |
| static void cmp_battery_multi_power_off(void) |
| { |
| printk(KERN_INFO "%s() power off called\n", __FUNCTION__); |
| gpio_set_value(g_gpio_power_control, 0); |
| } |
| |
| static int setup_gpios(struct battery_monitor *pt_battery_monitor) |
| { |
| int rc; |
| |
| printk(KERN_INFO "%s() power on/off gpio: %d ac power gpio: %d " |
| "charger gpio: %d\n", |
| __FUNCTION__, |
| g_gpio_power_control, |
| pt_battery_monitor->gpio_ac_power, |
| pt_battery_monitor->gpio_charger); |
| |
| if (g_gpio_power_control >= 0) |
| { |
| rc = gpio_request_one(g_gpio_power_control, |
| GPIOF_OUT_INIT_HIGH, "switch off"); |
| if (rc) |
| { |
| close_gpios(pt_battery_monitor); |
| return rc; |
| } |
| } |
| |
| if (pt_battery_monitor->gpio_charger >= 0) |
| { |
| rc = gpio_request_one(pt_battery_monitor->gpio_charger, |
| GPIOF_IN, "charger"); |
| if (rc) |
| { |
| close_gpios(pt_battery_monitor); |
| return rc; |
| } |
| } |
| |
| /* handle AC power gpio. We are assuming that its presence was already |
| checked */ |
| rc = gpio_request_one(pt_battery_monitor->gpio_ac_power, |
| GPIOF_IN, "ac power"); |
| if (rc) |
| { |
| close_gpios(pt_battery_monitor); |
| return rc; |
| } |
| |
| /* |
| * power on/off gpio signal bounces up and down before settling in either |
| * case, so we need to debounce it. |
| */ |
| rc = gpio_set_debounce(pt_battery_monitor->gpio_ac_power, |
| DEBOUNCE_TIME_USECS); |
| if (rc < 0) { |
| pr_err("%s: gpio_ac_power set debounce failed. gpio: %d, return: %d\n", |
| __FUNCTION__, pt_battery_monitor->gpio_ac_power, rc); |
| close_gpios(pt_battery_monitor); |
| return rc; |
| } |
| |
| /* |
| * Setup the interrupt to detect if external power is plugged in or not. |
| * IRQF_TRIGGER_FALLING - external power is connected |
| * IRQF_TRIGGER_RISING - external power is disconnected |
| */ |
| rc = request_irq(gpio_to_irq(pt_battery_monitor->gpio_ac_power), |
| ac_power_gpio_isr, |
| IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| "ac detect", &g_multi_data); |
| if (rc) |
| { |
| printk(KERN_ERR "%s(): request_irq(gpio_to_irq(%d)) returned %d\n", |
| __FUNCTION__, pt_battery_monitor->gpio_ac_power, rc); |
| close_gpios(pt_battery_monitor); |
| return rc; |
| } |
| |
| return 0; |
| } |
| |
| static void close_gpios(struct battery_monitor *pt_battery_monitor) |
| { |
| if (pt_battery_monitor->gpio_ac_power >= 0) { |
| free_irq(gpio_to_irq(pt_battery_monitor->gpio_ac_power), &g_multi_data); |
| gpio_free(pt_battery_monitor->gpio_ac_power); |
| } |
| |
| if (g_gpio_power_control >= 0) |
| gpio_free(g_gpio_power_control); |
| |
| if (pt_battery_monitor->gpio_charger >= 0) |
| gpio_free(pt_battery_monitor->gpio_charger); |
| } |
| |
| #ifdef CONFIG_PM |
| static int battery_suspend(struct platform_device *p_dev, pm_message_t state) |
| { |
| /* flush pending ISR work */ |
| flush_scheduled_work(); |
| flush_workqueue(isr_wq); |
| |
| /* flush delayed work. */ |
| cancel_delayed_work_sync(&g_multi_data.t_battery_dwork); |
| return 0; |
| } |
| |
| static int battery_resume(struct platform_device *p_dev) |
| { |
| /* take wakelock if AC is connected. This is needed as we do not know what |
| was happening when we were suspended */ |
| if (is_ac_connected()) |
| { |
| wake_lock(&g_multi_data.wakelock); |
| printk(KERN_INFO "%s() taking wake lock\n", __FUNCTION__); |
| } |
| |
| /* How to do in a SMP centric safe manner? */ |
| schedule_delayed_work(&g_multi_data.t_battery_dwork, MULTI_WAIT_PERIOD); |
| return 0; |
| } |
| #endif |
| |
| static int __devinit battery_probe(struct platform_device *p_dev) |
| { |
| int ret; |
| /* CBM (C)mp (B)attery (M)ulti. */ |
| struct cbm_platform_data *pt_cbm_platform_data; |
| |
| printk(gBanner); |
| |
| if (p_dev->dev.platform_data == NULL) |
| { /* Need this information. */ |
| printk(KERN_ERR "%s() error p_dev->dev.platform_data == NULL\n", |
| __FUNCTION__); |
| return -ENODATA; |
| } |
| |
| pt_cbm_platform_data = (struct cbm_platform_data *)p_dev->dev.platform_data; |
| |
| printk(KERN_INFO "%s() battery max voltage: %d battery min voltage: %d\n", |
| __FUNCTION__, |
| pt_cbm_platform_data->battery_max_voltage, |
| pt_cbm_platform_data->battery_min_voltage); |
| |
| /* Needed to turn off the device. */ |
| g_gpio_power_control = pt_cbm_platform_data->gpio_power_control; |
| |
| /* store platform data */ |
| g_multi_data.pt_platform_data = pt_cbm_platform_data; |
| |
| /* Tell the system how to turn off the power. */ |
| /* pm_power_off is a global function pointer. It is declared as external in |
| linux/pm.h. Somehow this is called when Tablet is powered off */ |
| pm_power_off = cmp_battery_multi_power_off; |
| |
| isr_wq = create_workqueue("multi_isr_wq"); |
| if (isr_wq == NULL) |
| { |
| printk(KERN_ERR "%s() Can not create ISR workqueue\n", __FUNCTION__); |
| ret = -1; |
| goto err_isr_wq; |
| } |
| |
| /* Use a wake lock to keep the tablet awake. */ |
| wake_lock_init(&g_multi_data.wakelock, WAKE_LOCK_SUSPEND, wake_lock_name); |
| |
| /* Prepare to start the delayed work. */ |
| INIT_DELAYED_WORK_DEFERRABLE(&g_multi_data.t_battery_dwork, |
| multi_battery_work); |
| |
| /* register battery PSY with power supply framework */ |
| ret = power_supply_register(&p_dev->dev, &g_multi_data.battery_psy); |
| if (ret) |
| goto err_psy_reg_battery; |
| |
| /* register AC power PSY with power supply framework */ |
| ret = power_supply_register(&p_dev->dev, &g_multi_data.ac_power_psy); |
| if (ret) |
| goto err_psy_reg_power; |
| |
| /* register USB power PSY with power supply framework */ |
| ret = power_supply_register(&p_dev->dev, &usb_power_psy); |
| if (ret) |
| goto err_psy_reg_usbpower; |
| |
| /* return success */ |
| g_is_driver_ok = true; |
| return 0; |
| |
| err_psy_reg_usbpower: |
| power_supply_unregister(&g_multi_data.ac_power_psy); |
| |
| err_psy_reg_power: |
| power_supply_unregister(&g_multi_data.battery_psy); |
| |
| err_psy_reg_battery: |
| wake_lock_destroy(&g_multi_data.wakelock); |
| |
| /* see comment in battery_remove */ |
| flush_scheduled_work(); |
| flush_workqueue(isr_wq); |
| destroy_workqueue(isr_wq); |
| err_isr_wq: |
| pm_power_off = NULL; |
| return ret; |
| } |
| |
| static int __devexit battery_remove(struct platform_device *p_dev) |
| { |
| /* unregister power supplies from PSY framework */ |
| power_supply_unregister(&g_multi_data.battery_psy); |
| power_supply_unregister(&g_multi_data.ac_power_psy); |
| power_supply_unregister(&usb_power_psy); |
| |
| /* |
| * now flush all pending work. |
| * we won't get any more schedules, since all |
| * sources (isr and external_power_changed) |
| * are unregistered now. |
| */ |
| flush_scheduled_work(); |
| flush_workqueue(isr_wq); |
| destroy_workqueue(isr_wq); |
| |
| /* flush the delayed work. */ |
| cancel_delayed_work_sync(&g_multi_data.t_battery_dwork); |
| |
| pm_power_off = NULL; |
| g_is_driver_ok = false; |
| |
| if (g_multi_data.pt_battery_monitor != NULL) |
| close_gpios(g_multi_data.pt_battery_monitor); |
| |
| wake_lock_destroy(&g_multi_data.wakelock); |
| return 0; |
| } |
| |
| static struct platform_driver battery_driver = |
| { |
| .driver.name = HW_CMP_MULTI_DRIVER_NAME, |
| .driver.owner = THIS_MODULE, |
| .probe = battery_probe, |
| .remove = __devexit_p(battery_remove), |
| #ifdef CONFIG_PM |
| .suspend = battery_suspend, |
| .resume = battery_resume, |
| #endif |
| }; |
| |
| static int __init battery_init(void) |
| { |
| int ret; |
| |
| ret = platform_driver_register(&battery_driver); |
| if (ret) |
| { |
| printk(KERN_ERR "%s(): platform_driver_register failed %d\n", |
| __FUNCTION__, ret); |
| return ret; |
| } |
| return 0; |
| } |
| |
| static void __exit battery_exit(void) |
| { |
| platform_driver_unregister(&battery_driver); |
| } |
| |
| module_init(battery_init); |
| module_exit(battery_exit); |
| |
| MODULE_AUTHOR("Broadcom"); |
| MODULE_DESCRIPTION("Broadcom CMP Battery Multi Driver"); |
| MODULE_LICENSE("GPL"); |
| MODULE_VERSION("1.02"); |
