Merge git://git.infradead.org/battery-2.6 (48e902f0) · Commits · 戴 / test

arch/arm/mach-s3c2442/mach-gta02.c

+3 −0

Original line number	Diff line number	Diff line
		@@ -268,6 +268,9 @@ struct pcf50633_platform_data gta02_pcf_pdata = {

		.batteries = gta02_batteries,
		.num_batteries = ARRAY_SIZE(gta02_batteries),

		.charger_reference_current_ma = 1000,

		.reg_init_data = {
		[PCF50633_REGULATOR_AUTO] = {
		.constraints = {

drivers/mfd/wm831x-core.c

+9 −0

Original line number	Diff line number	Diff line
		@@ -808,6 +808,9 @@ static struct resource wm831x_wdt_resources[] = {
		};

		static struct mfd_cell wm8310_devs[] = {
		{
		.name = "wm831x-backup",
		},
		{
		.name = "wm831x-buckv",
		.id = 1,
		@@ -961,6 +964,9 @@ static struct mfd_cell wm8310_devs[] = {
		};

		static struct mfd_cell wm8311_devs[] = {
		{
		.name = "wm831x-backup",
		},
		{
		.name = "wm831x-buckv",
		.id = 1,
		@@ -1095,6 +1101,9 @@ static struct mfd_cell wm8311_devs[] = {
		};

		static struct mfd_cell wm8312_devs[] = {
		{
		.name = "wm831x-backup",
		},
		{
		.name = "wm831x-buckv",
		.id = 1,

drivers/power/Kconfig

+7 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,13 @@ config APM_POWER
		Say Y here to enable support APM status emulation using
		battery class devices.

		config WM831X_BACKUP
		tristate "WM831X backup battery charger support"
		depends on MFD_WM831X
		help
		Say Y here to enable support for the backup battery charger
		in the Wolfson Microelectronics WM831x PMICs.

		config WM831X_POWER
		tristate "WM831X PMU support"
		depends on MFD_WM831X

drivers/power/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@ obj-$(CONFIG_POWER_SUPPLY) += power_supply.o

		obj-$(CONFIG_PDA_POWER) += pda_power.o
		obj-$(CONFIG_APM_POWER) += apm_power.o
		obj-$(CONFIG_WM831X_BACKUP) += wm831x_backup.o
		obj-$(CONFIG_WM831X_POWER) += wm831x_power.o
		obj-$(CONFIG_WM8350_POWER) += wm8350_power.o

drivers/power/pcf50633-charger.c

+153 −75

Original line number	Diff line number	Diff line
		@@ -29,15 +29,12 @@
		struct pcf50633_mbc {
		struct pcf50633 *pcf;

		int adapter_active;
		int adapter_online;
		int usb_active;
		int usb_online;

		struct power_supply usb;
		struct power_supply adapter;

		struct delayed_work charging_restart_work;
		struct power_supply ac;
		};

		int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
		@@ -47,16 +44,21 @@ int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
		u8 bits;
		int charging_start = 1;
		u8 mbcs2, chgmod;
		unsigned int mbcc5;

		if (ma >= 1000)
		if (ma >= 1000) {
		bits = PCF50633_MBCC7_USB_1000mA;
		else if (ma >= 500)
		ma = 1000;
		} else if (ma >= 500) {
		bits = PCF50633_MBCC7_USB_500mA;
		else if (ma >= 100)
		ma = 500;
		} else if (ma >= 100) {
		bits = PCF50633_MBCC7_USB_100mA;
		else {
		ma = 100;
		} else {
		bits = PCF50633_MBCC7_USB_SUSPEND;
		charging_start = 0;
		ma = 0;
		}

		ret = pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC7,
		@@ -66,21 +68,40 @@ int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
		else
		dev_info(pcf->dev, "usb curlim to %d mA\n", ma);

		/* Manual charging start */
		mbcs2 = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
		/*
		* We limit the charging current to be the USB current limit.
		* The reason is that on pcf50633, when it enters PMU Standby mode,
		* which it does when the device goes "off", the USB current limit
		* reverts to the variant default. In at least one common case, that
		* default is 500mA. By setting the charging current to be the same
		* as the USB limit we set here before PMU standby, we enforce it only
		* using the correct amount of current even when the USB current limit
		* gets reset to the wrong thing
		*/

		if (mbc->pcf->pdata->charger_reference_current_ma) {
		mbcc5 = (ma << 8) / mbc->pcf->pdata->charger_reference_current_ma;
		if (mbcc5 > 255)
		mbcc5 = 255;
		pcf50633_reg_write(mbc->pcf, PCF50633_REG_MBCC5, mbcc5);
		}

		mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
		chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);

		/* If chgmod == BATFULL, setting chgena has no effect.
		* We need to set resume instead.
		* Datasheet says we need to set resume instead but when autoresume is
		* used resume doesn't work. Clear and set chgena instead.
		*/
		if (chgmod != PCF50633_MBCS2_MBC_BAT_FULL)
		pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC1,
		PCF50633_MBCC1_CHGENA, PCF50633_MBCC1_CHGENA);
		else
		else {
		pcf50633_reg_clear_bits(pcf, PCF50633_REG_MBCC1,
		PCF50633_MBCC1_CHGENA);
		pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC1,
		PCF50633_MBCC1_RESUME, PCF50633_MBCC1_RESUME);

		mbc->usb_active = charging_start;
		PCF50633_MBCC1_CHGENA, PCF50633_MBCC1_CHGENA);
		}

		power_supply_changed(&mbc->usb);

		@@ -92,20 +113,44 @@ int pcf50633_mbc_get_status(struct pcf50633 *pcf)
		{
		struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
		int status = 0;
		u8 chgmod;

		if (!mbc)
		return 0;

		chgmod = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2)
		& PCF50633_MBCS2_MBC_MASK;

		if (mbc->usb_online)
		status \|= PCF50633_MBC_USB_ONLINE;
		if (mbc->usb_active)
		if (chgmod == PCF50633_MBCS2_MBC_USB_PRE \|\|
		chgmod == PCF50633_MBCS2_MBC_USB_PRE_WAIT \|\|
		chgmod == PCF50633_MBCS2_MBC_USB_FAST \|\|
		chgmod == PCF50633_MBCS2_MBC_USB_FAST_WAIT)
		status \|= PCF50633_MBC_USB_ACTIVE;
		if (mbc->adapter_online)
		status \|= PCF50633_MBC_ADAPTER_ONLINE;
		if (mbc->adapter_active)
		if (chgmod == PCF50633_MBCS2_MBC_ADP_PRE \|\|
		chgmod == PCF50633_MBCS2_MBC_ADP_PRE_WAIT \|\|
		chgmod == PCF50633_MBCS2_MBC_ADP_FAST \|\|
		chgmod == PCF50633_MBCS2_MBC_ADP_FAST_WAIT)
		status \|= PCF50633_MBC_ADAPTER_ACTIVE;

		return status;
		}
		EXPORT_SYMBOL_GPL(pcf50633_mbc_get_status);

		int pcf50633_mbc_get_usb_online_status(struct pcf50633 *pcf)
		{
		struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);

		if (!mbc)
		return 0;

		return mbc->usb_online;
		}
		EXPORT_SYMBOL_GPL(pcf50633_mbc_get_usb_online_status);

		static ssize_t
		show_chgmode(struct device dev, struct device_attribute attr, char *buf)
		{
		@@ -156,9 +201,55 @@ static ssize_t set_usblim(struct device *dev,

		static DEVICE_ATTR(usb_curlim, S_IRUGO \| S_IWUSR, show_usblim, set_usblim);

		static ssize_t
		show_chglim(struct device dev, struct device_attribute attr, char *buf)
		{
		struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
		u8 mbcc5 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC5);
		unsigned int ma;

		if (!mbc->pcf->pdata->charger_reference_current_ma)
		return -ENODEV;

		ma = (mbc->pcf->pdata->charger_reference_current_ma * mbcc5) >> 8;

		return sprintf(buf, "%u\n", ma);
		}

		static ssize_t set_chglim(struct device *dev,
		struct device_attribute attr, const char buf, size_t count)
		{
		struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
		unsigned long ma;
		unsigned int mbcc5;
		int ret;

		if (!mbc->pcf->pdata->charger_reference_current_ma)
		return -ENODEV;

		ret = strict_strtoul(buf, 10, &ma);
		if (ret)
		return -EINVAL;

		mbcc5 = (ma << 8) / mbc->pcf->pdata->charger_reference_current_ma;
		if (mbcc5 > 255)
		mbcc5 = 255;
		pcf50633_reg_write(mbc->pcf, PCF50633_REG_MBCC5, mbcc5);

		return count;
		}

		/*
		* This attribute allows to change MBC charging limit on the fly
		* independently of usb current limit. It also gets set automatically every
		* time usb current limit is changed.
		*/
		static DEVICE_ATTR(chg_curlim, S_IRUGO \| S_IWUSR, show_chglim, set_chglim);

		static struct attribute *pcf50633_mbc_sysfs_entries[] = {
		&dev_attr_chgmode.attr,
		&dev_attr_usb_curlim.attr,
		&dev_attr_chg_curlim.attr,
		NULL,
		};

		@@ -167,76 +258,26 @@ static struct attribute_group mbc_attr_group = {
		.attrs = pcf50633_mbc_sysfs_entries,
		};

		/* MBC state machine switches into charging mode when the battery voltage
		* falls below 96% of a battery float voltage. But the voltage drop in Li-ion
		* batteries is marginal(1~2 %) till about 80% of its capacity - which means,
		* after a BATFULL, charging won't be restarted until 80%.
		*
		* This work_struct function restarts charging at regular intervals to make
		* sure we don't discharge too much
		*/

		static void pcf50633_mbc_charging_restart(struct work_struct *work)
		{
		struct pcf50633_mbc *mbc;
		u8 mbcs2, chgmod;

		mbc = container_of(work, struct pcf50633_mbc,
		charging_restart_work.work);

		mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
		chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);

		if (chgmod != PCF50633_MBCS2_MBC_BAT_FULL)
		return;

		/* Restart charging */
		pcf50633_reg_set_bit_mask(mbc->pcf, PCF50633_REG_MBCC1,
		PCF50633_MBCC1_RESUME, PCF50633_MBCC1_RESUME);
		mbc->usb_active = 1;
		power_supply_changed(&mbc->usb);

		dev_info(mbc->pcf->dev, "Charging restarted\n");
		}

		static void
		pcf50633_mbc_irq_handler(int irq, void *data)
		{
		struct pcf50633_mbc *mbc = data;
		int chg_restart_interval =
		mbc->pcf->pdata->charging_restart_interval;

		/* USB */
		if (irq == PCF50633_IRQ_USBINS) {
		mbc->usb_online = 1;
		} else if (irq == PCF50633_IRQ_USBREM) {
		mbc->usb_online = 0;
		mbc->usb_active = 0;
		pcf50633_mbc_usb_curlim_set(mbc->pcf, 0);
		cancel_delayed_work_sync(&mbc->charging_restart_work);
		}

		/* Adapter */
		if (irq == PCF50633_IRQ_ADPINS) {
		if (irq == PCF50633_IRQ_ADPINS)
		mbc->adapter_online = 1;
		mbc->adapter_active = 1;
		} else if (irq == PCF50633_IRQ_ADPREM) {
		else if (irq == PCF50633_IRQ_ADPREM)
		mbc->adapter_online = 0;
		mbc->adapter_active = 0;
		}

		if (irq == PCF50633_IRQ_BATFULL) {
		mbc->usb_active = 0;
		mbc->adapter_active = 0;

		if (chg_restart_interval > 0)
		schedule_delayed_work(&mbc->charging_restart_work,
		chg_restart_interval);
		} else if (irq == PCF50633_IRQ_USBLIMON)
		mbc->usb_active = 0;
		else if (irq == PCF50633_IRQ_USBLIMOFF)
		mbc->usb_active = 1;

		power_supply_changed(&mbc->ac);
		power_supply_changed(&mbc->usb);
		power_supply_changed(&mbc->adapter);

		@@ -269,10 +310,34 @@ static int usb_get_property(struct power_supply *psy,
		{
		struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, usb);
		int ret = 0;
		u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
		PCF50633_MBCC7_USB_MASK;

		switch (psp) {
		case POWER_SUPPLY_PROP_ONLINE:
		val->intval = mbc->usb_online;
		val->intval = mbc->usb_online &&
		(usblim <= PCF50633_MBCC7_USB_500mA);
		break;
		default:
		ret = -EINVAL;
		break;
		}
		return ret;
		}

		static int ac_get_property(struct power_supply *psy,
		enum power_supply_property psp,
		union power_supply_propval *val)
		{
		struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, ac);
		int ret = 0;
		u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
		PCF50633_MBCC7_USB_MASK;

		switch (psp) {
		case POWER_SUPPLY_PROP_ONLINE:
		val->intval = mbc->usb_online &&
		(usblim == PCF50633_MBCC7_USB_1000mA);
		break;
		default:
		ret = -EINVAL;
		@@ -336,6 +401,14 @@ static int __devinit pcf50633_mbc_probe(struct platform_device *pdev)
		mbc->usb.supplied_to = mbc->pcf->pdata->batteries;
		mbc->usb.num_supplicants = mbc->pcf->pdata->num_batteries;

		mbc->ac.name = "ac";
		mbc->ac.type = POWER_SUPPLY_TYPE_MAINS;
		mbc->ac.properties = power_props;
		mbc->ac.num_properties = ARRAY_SIZE(power_props);
		mbc->ac.get_property = ac_get_property;
		mbc->ac.supplied_to = mbc->pcf->pdata->batteries;
		mbc->ac.num_supplicants = mbc->pcf->pdata->num_batteries;

		ret = power_supply_register(&pdev->dev, &mbc->adapter);
		if (ret) {
		dev_err(mbc->pcf->dev, "failed to register adapter\n");
		@@ -351,8 +424,14 @@ static int __devinit pcf50633_mbc_probe(struct platform_device *pdev)
		return ret;
		}

		INIT_DELAYED_WORK(&mbc->charging_restart_work,
		pcf50633_mbc_charging_restart);
		ret = power_supply_register(&pdev->dev, &mbc->ac);
		if (ret) {
		dev_err(mbc->pcf->dev, "failed to register ac\n");
		power_supply_unregister(&mbc->adapter);
		power_supply_unregister(&mbc->usb);
		kfree(mbc);
		return ret;
		}

		ret = sysfs_create_group(&pdev->dev.kobj, &mbc_attr_group);
		if (ret)
		@@ -378,8 +457,7 @@ static int __devexit pcf50633_mbc_remove(struct platform_device *pdev)

		power_supply_unregister(&mbc->usb);
		power_supply_unregister(&mbc->adapter);

		cancel_delayed_work_sync(&mbc->charging_restart_work);
		power_supply_unregister(&mbc->ac);

		kfree(mbc);

Admin message