Commit 0f9b85ed authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

power: remove pda_power supply driver 



This driver was used for a couple of Intel PXA and Samsung S3C24xx
based PDAs, but all of those are now removed from the kernel, so
the driver itself is no longer useful.

Cc: Anton Vorontsov <cbou@mail.ru>
Cc: linux-pm@vger.kernel.org
Acked-by: default avatarSebastian Reichel <sebastian.reichel@collabora.com>
Acked-by: default avatarRobert Jarzmik <robert.jarzmik@free.fr>
Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
parent b401d1fd

Documentation/power/power_supply_class.rst

+2 −2
Original line number Diff line number Diff line
@@ -40,8 +40,8 @@ kind of power supply, and can process/present them to a user in consistent 
manner. Results for different power supplies and machines are also directly

comparable.



See drivers/power/supply/ds2760_battery.c and drivers/power/supply/pda_power.c

for the example how to declare and handle attributes.

See drivers/power/supply/ds2760_battery.c for the example how to declare

and handle attributes.





Units

arch/arm/mach-tegra/tegra.c

+0 −1
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 
#include <linux/of_fdt.h>

#include <linux/of.h>

#include <linux/of_platform.h>

#include <linux/pda_power.h>

#include <linux/platform_device.h>

#include <linux/serial_8250.h>

#include <linux/slab.h>

drivers/power/supply/Kconfig

+0 −9
Original line number Diff line number Diff line
@@ -28,15 +28,6 @@ config POWER_SUPPLY_HWMON 
	  Say 'Y' here if you want power supplies to

	  have hwmon sysfs interface too.





config PDA_POWER

	tristate "Generic PDA/phone power driver"

	depends on !S390

	help

	  Say Y here to enable generic power driver for PDAs and phones with

	  one or two external power supplies (AC/USB) connected to main and

	  backup batteries, and optional builtin charger.



config APM_POWER

	tristate "APM emulation for class batteries"

	depends on APM_EMULATION

drivers/power/supply/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -9,7 +9,6 @@ obj-$(CONFIG_POWER_SUPPLY) += power_supply.o 
obj-$(CONFIG_POWER_SUPPLY_HWMON) += power_supply_hwmon.o

obj-$(CONFIG_GENERIC_ADC_BATTERY)	+= generic-adc-battery.o



obj-$(CONFIG_PDA_POWER)		+= pda_power.o

obj-$(CONFIG_APM_POWER)		+= apm_power.o

obj-$(CONFIG_AXP20X_POWER)	+= axp20x_usb_power.o

obj-$(CONFIG_IP5XXX_POWER)	+= ip5xxx_power.o

drivers/power/supply/pda_power.c

deleted100644 → 0
+0 −520
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Common power driver for PDAs and phones with one or two external

 * power supplies (AC/USB) connected to main and backup batteries,

 * and optional builtin charger.

 *

 * Copyright © 2007 Anton Vorontsov <cbou@mail.ru>

 */



#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/err.h>

#include <linux/interrupt.h>

#include <linux/notifier.h>

#include <linux/power_supply.h>

#include <linux/pda_power.h>

#include <linux/regulator/consumer.h>

#include <linux/timer.h>

#include <linux/jiffies.h>

#include <linux/usb/otg.h>



static inline unsigned int get_irq_flags(struct resource *res)

{

	return IRQF_SHARED | (res->flags & IRQF_TRIGGER_MASK);

}



static struct device *dev;

static struct pda_power_pdata *pdata;

static struct resource *ac_irq, *usb_irq;

static struct delayed_work charger_work;

static struct delayed_work polling_work;

static struct delayed_work supply_work;

static int polling;

static struct power_supply *pda_psy_ac, *pda_psy_usb;



#if IS_ENABLED(CONFIG_USB_PHY)

static struct usb_phy *transceiver;

static struct notifier_block otg_nb;

#endif



static struct regulator *ac_draw;



enum {

	PDA_PSY_OFFLINE = 0,

	PDA_PSY_ONLINE = 1,

	PDA_PSY_TO_CHANGE,

};

static int new_ac_status = -1;

static int new_usb_status = -1;

static int ac_status = -1;

static int usb_status = -1;



static int pda_power_get_property(struct power_supply *psy,

				  enum power_supply_property psp,

				  union power_supply_propval *val)

{

	switch (psp) {

	case POWER_SUPPLY_PROP_ONLINE:

		if (psy->desc->type == POWER_SUPPLY_TYPE_MAINS)

			val->intval = pdata->is_ac_online ?

				      pdata->is_ac_online() : 0;

		else

			val->intval = pdata->is_usb_online ?

				      pdata->is_usb_online() : 0;

		break;

	default:

		return -EINVAL;

	}

	return 0;

}



static enum power_supply_property pda_power_props[] = {

	POWER_SUPPLY_PROP_ONLINE,

};



static char *pda_power_supplied_to[] = {

	"main-battery",

	"backup-battery",

};



static const struct power_supply_desc pda_psy_ac_desc = {

	.name = "ac",

	.type = POWER_SUPPLY_TYPE_MAINS,

	.properties = pda_power_props,

	.num_properties = ARRAY_SIZE(pda_power_props),

	.get_property = pda_power_get_property,

};



static const struct power_supply_desc pda_psy_usb_desc = {

	.name = "usb",

	.type = POWER_SUPPLY_TYPE_USB,

	.properties = pda_power_props,

	.num_properties = ARRAY_SIZE(pda_power_props),

	.get_property = pda_power_get_property,

};



static void update_status(void)

{

	if (pdata->is_ac_online)

		new_ac_status = !!pdata->is_ac_online();



	if (pdata->is_usb_online)

		new_usb_status = !!pdata->is_usb_online();

}



static void update_charger(void)

{

	static int regulator_enabled;

	int max_uA = pdata->ac_max_uA;



	if (pdata->set_charge) {

		if (new_ac_status > 0) {

			dev_dbg(dev, "charger on (AC)\n");

			pdata->set_charge(PDA_POWER_CHARGE_AC);

		} else if (new_usb_status > 0) {

			dev_dbg(dev, "charger on (USB)\n");

			pdata->set_charge(PDA_POWER_CHARGE_USB);

		} else {

			dev_dbg(dev, "charger off\n");

			pdata->set_charge(0);

		}

	} else if (ac_draw) {

		if (new_ac_status > 0) {

			regulator_set_current_limit(ac_draw, max_uA, max_uA);

			if (!regulator_enabled) {

				dev_dbg(dev, "charger on (AC)\n");

				WARN_ON(regulator_enable(ac_draw));

				regulator_enabled = 1;

			}

		} else {

			if (regulator_enabled) {

				dev_dbg(dev, "charger off\n");

				WARN_ON(regulator_disable(ac_draw));

				regulator_enabled = 0;

			}

		}

	}

}



static void supply_work_func(struct work_struct *work)

{

	if (ac_status == PDA_PSY_TO_CHANGE) {

		ac_status = new_ac_status;

		power_supply_changed(pda_psy_ac);

	}



	if (usb_status == PDA_PSY_TO_CHANGE) {

		usb_status = new_usb_status;

		power_supply_changed(pda_psy_usb);

	}

}



static void psy_changed(void)

{

	update_charger();



	/*

	 * Okay, charger set. Now wait a bit before notifying supplicants,

	 * charge power should stabilize.

	 */

	cancel_delayed_work(&supply_work);

	schedule_delayed_work(&supply_work,

			      msecs_to_jiffies(pdata->wait_for_charger));

}



static void charger_work_func(struct work_struct *work)

{

	update_status();

	psy_changed();

}



static irqreturn_t power_changed_isr(int irq, void *power_supply)

{

	if (power_supply == pda_psy_ac)

		ac_status = PDA_PSY_TO_CHANGE;

	else if (power_supply == pda_psy_usb)

		usb_status = PDA_PSY_TO_CHANGE;

	else

		return IRQ_NONE;



	/*

	 * Wait a bit before reading ac/usb line status and setting charger,

	 * because ac/usb status readings may lag from irq.

	 */

	cancel_delayed_work(&charger_work);

	schedule_delayed_work(&charger_work,

			      msecs_to_jiffies(pdata->wait_for_status));



	return IRQ_HANDLED;

}



static void polling_work_func(struct work_struct *work)

{

	int changed = 0;



	dev_dbg(dev, "polling...\n");



	update_status();



	if (!ac_irq && new_ac_status != ac_status) {

		ac_status = PDA_PSY_TO_CHANGE;

		changed = 1;

	}



	if (!usb_irq && new_usb_status != usb_status) {

		usb_status = PDA_PSY_TO_CHANGE;

		changed = 1;

	}



	if (changed)

		psy_changed();



	cancel_delayed_work(&polling_work);

	schedule_delayed_work(&polling_work,

			      msecs_to_jiffies(pdata->polling_interval));

}



#if IS_ENABLED(CONFIG_USB_PHY)

static int otg_is_usb_online(void)

{

	return (transceiver->last_event == USB_EVENT_VBUS ||

		transceiver->last_event == USB_EVENT_ENUMERATED);

}



static int otg_is_ac_online(void)

{

	return (transceiver->last_event == USB_EVENT_CHARGER);

}



static int otg_handle_notification(struct notifier_block *nb,

		unsigned long event, void *unused)

{

	switch (event) {

	case USB_EVENT_CHARGER:

		ac_status = PDA_PSY_TO_CHANGE;

		break;

	case USB_EVENT_VBUS:

	case USB_EVENT_ENUMERATED:

		usb_status = PDA_PSY_TO_CHANGE;

		break;

	case USB_EVENT_NONE:

		ac_status = PDA_PSY_TO_CHANGE;

		usb_status = PDA_PSY_TO_CHANGE;

		break;

	default:

		return NOTIFY_OK;

	}



	/*

	 * Wait a bit before reading ac/usb line status and setting charger,

	 * because ac/usb status readings may lag from irq.

	 */

	cancel_delayed_work(&charger_work);

	schedule_delayed_work(&charger_work,

			      msecs_to_jiffies(pdata->wait_for_status));



	return NOTIFY_OK;

}

#endif



static int pda_power_probe(struct platform_device *pdev)

{

	struct power_supply_config psy_cfg = {};

	int ret = 0;



	dev = &pdev->dev;



	if (pdev->id != -1) {

		dev_err(dev, "it's meaningless to register several "

			"pda_powers; use id = -1\n");

		ret = -EINVAL;

		goto wrongid;

	}



	pdata = pdev->dev.platform_data;



	if (pdata->init) {

		ret = pdata->init(dev);

		if (ret < 0)

			goto init_failed;

	}



	ac_draw = regulator_get(dev, "ac_draw");

	if (IS_ERR(ac_draw)) {

		dev_dbg(dev, "couldn't get ac_draw regulator\n");

		ac_draw = NULL;

	}



	update_status();

	update_charger();



	if (!pdata->wait_for_status)

		pdata->wait_for_status = 500;



	if (!pdata->wait_for_charger)

		pdata->wait_for_charger = 500;



	if (!pdata->polling_interval)

		pdata->polling_interval = 2000;



	if (!pdata->ac_max_uA)

		pdata->ac_max_uA = 500000;



	INIT_DELAYED_WORK(&charger_work, charger_work_func);

	INIT_DELAYED_WORK(&supply_work, supply_work_func);



	ac_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ac");

	usb_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "usb");



	if (pdata->supplied_to) {

		psy_cfg.supplied_to = pdata->supplied_to;

		psy_cfg.num_supplicants = pdata->num_supplicants;

	} else {

		psy_cfg.supplied_to = pda_power_supplied_to;

		psy_cfg.num_supplicants = ARRAY_SIZE(pda_power_supplied_to);

	}



#if IS_ENABLED(CONFIG_USB_PHY)

	transceiver = usb_get_phy(USB_PHY_TYPE_USB2);

	if (!IS_ERR_OR_NULL(transceiver)) {

		if (!pdata->is_usb_online)

			pdata->is_usb_online = otg_is_usb_online;

		if (!pdata->is_ac_online)

			pdata->is_ac_online = otg_is_ac_online;

	}

#endif



	if (pdata->is_ac_online) {

		pda_psy_ac = power_supply_register(&pdev->dev,

						   &pda_psy_ac_desc, &psy_cfg);

		if (IS_ERR(pda_psy_ac)) {

			dev_err(dev, "failed to register %s power supply\n",

				pda_psy_ac_desc.name);

			ret = PTR_ERR(pda_psy_ac);

			goto ac_supply_failed;

		}



		if (ac_irq) {

			ret = request_irq(ac_irq->start, power_changed_isr,

					  get_irq_flags(ac_irq), ac_irq->name,

					  pda_psy_ac);

			if (ret) {

				dev_err(dev, "request ac irq failed\n");

				goto ac_irq_failed;

			}

		} else {

			polling = 1;

		}

	}



	if (pdata->is_usb_online) {

		pda_psy_usb = power_supply_register(&pdev->dev,

						    &pda_psy_usb_desc,

						    &psy_cfg);

		if (IS_ERR(pda_psy_usb)) {

			dev_err(dev, "failed to register %s power supply\n",

				pda_psy_usb_desc.name);

			ret = PTR_ERR(pda_psy_usb);

			goto usb_supply_failed;

		}



		if (usb_irq) {

			ret = request_irq(usb_irq->start, power_changed_isr,

					  get_irq_flags(usb_irq),

					  usb_irq->name, pda_psy_usb);

			if (ret) {

				dev_err(dev, "request usb irq failed\n");

				goto usb_irq_failed;

			}

		} else {

			polling = 1;

		}

	}



#if IS_ENABLED(CONFIG_USB_PHY)

	if (!IS_ERR_OR_NULL(transceiver) && pdata->use_otg_notifier) {

		otg_nb.notifier_call = otg_handle_notification;

		ret = usb_register_notifier(transceiver, &otg_nb);

		if (ret) {

			dev_err(dev, "failure to register otg notifier\n");

			goto otg_reg_notifier_failed;

		}

		polling = 0;

	}

#endif



	if (polling) {

		dev_dbg(dev, "will poll for status\n");

		INIT_DELAYED_WORK(&polling_work, polling_work_func);

		cancel_delayed_work(&polling_work);

		schedule_delayed_work(&polling_work,

				      msecs_to_jiffies(pdata->polling_interval));

	}



	if (ac_irq || usb_irq)

		device_init_wakeup(&pdev->dev, 1);



	return 0;



#if IS_ENABLED(CONFIG_USB_PHY)

otg_reg_notifier_failed:

	if (pdata->is_usb_online && usb_irq)

		free_irq(usb_irq->start, pda_psy_usb);

#endif

usb_irq_failed:

	if (pdata->is_usb_online)

		power_supply_unregister(pda_psy_usb);

usb_supply_failed:

	if (pdata->is_ac_online && ac_irq)

		free_irq(ac_irq->start, pda_psy_ac);

#if IS_ENABLED(CONFIG_USB_PHY)

	if (!IS_ERR_OR_NULL(transceiver))

		usb_put_phy(transceiver);

#endif

ac_irq_failed:

	if (pdata->is_ac_online)

		power_supply_unregister(pda_psy_ac);

ac_supply_failed:

	if (ac_draw) {

		regulator_put(ac_draw);

		ac_draw = NULL;

	}

	if (pdata->exit)

		pdata->exit(dev);

init_failed:

wrongid:

	return ret;

}



static int pda_power_remove(struct platform_device *pdev)

{

#if IS_ENABLED(CONFIG_USB_PHY)

	if (!IS_ERR_OR_NULL(transceiver) && pdata->use_otg_notifier)

		usb_unregister_notifier(transceiver, &otg_nb);

#endif

	if (pdata->is_usb_online && usb_irq)

		free_irq(usb_irq->start, pda_psy_usb);

	if (pdata->is_ac_online && ac_irq)

		free_irq(ac_irq->start, pda_psy_ac);



	if (polling)

		cancel_delayed_work_sync(&polling_work);

	cancel_delayed_work_sync(&charger_work);

	cancel_delayed_work_sync(&supply_work);



	if (pdata->is_usb_online)

		power_supply_unregister(pda_psy_usb);

	if (pdata->is_ac_online)

		power_supply_unregister(pda_psy_ac);

#if IS_ENABLED(CONFIG_USB_PHY)

	if (!IS_ERR_OR_NULL(transceiver))

		usb_put_phy(transceiver);

#endif

	if (ac_draw) {

		regulator_put(ac_draw);

		ac_draw = NULL;

	}

	if (pdata->exit)

		pdata->exit(dev);



	return 0;

}



#ifdef CONFIG_PM

static int ac_wakeup_enabled;

static int usb_wakeup_enabled;



static int pda_power_suspend(struct platform_device *pdev, pm_message_t state)

{

	if (pdata->suspend) {

		int ret = pdata->suspend(state);



		if (ret)

			return ret;

	}



	if (device_may_wakeup(&pdev->dev)) {

		if (ac_irq)

			ac_wakeup_enabled = !enable_irq_wake(ac_irq->start);

		if (usb_irq)

			usb_wakeup_enabled = !enable_irq_wake(usb_irq->start);

	}



	return 0;

}



static int pda_power_resume(struct platform_device *pdev)

{

	if (device_may_wakeup(&pdev->dev)) {

		if (usb_irq && usb_wakeup_enabled)

			disable_irq_wake(usb_irq->start);

		if (ac_irq && ac_wakeup_enabled)

			disable_irq_wake(ac_irq->start);

	}



	if (pdata->resume)

		return pdata->resume();



	return 0;

}

#else

#define pda_power_suspend NULL

#define pda_power_resume NULL

#endif /* CONFIG_PM */



static struct platform_driver pda_power_pdrv = {

	.driver = {

		.name = "pda-power",

	},

	.probe = pda_power_probe,

	.remove = pda_power_remove,

	.suspend = pda_power_suspend,

	.resume = pda_power_resume,

};



module_platform_driver(pda_power_pdrv);



MODULE_LICENSE("GPL");

MODULE_AUTHOR("Anton Vorontsov <cbou@mail.ru>");

MODULE_ALIAS("platform:pda-power");