* [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2015-12-08 8:36 ` Baolin Wang 0 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2015-12-08 8:36 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel Currently the Linux kernel does not provide any standard integration of this feature that integrates the USB subsystem with the system power regulation provided by PMICs meaning that either vendors must add this in their kernels or USB gadget devices based on Linux (such as mobile phones) may not behave as they should. Thus provide a standard framework for doing this in kernel. Now introduce one user with wm831x_power to support and test the usb charger, which is pending testing. Moreover there may be other potential users will use it in future. Changes since v5: - Remove the notifier chain things from the gadget and introduce one callback function to report to the usb charger when the gadget state is changed. - Flesh out the port type detection which combines the USB negotiation and PMICs detection. - Supply the notification mechanism to userspace when charger state is changed. - Integrate with the vbus staff in the gadget API. - Spilt up the functionality for userspace with one file per USB charger type. Baolin Wang (4): gadget: Introduce the usb charger framework gadget: Support for the usb charger framework gadget: Integrate with the usb gadget supporting for usb charger power: wm831x_power: Support USB charger current limit management drivers/power/wm831x_power.c | 69 ++++ drivers/usb/gadget/Kconfig | 7 + drivers/usb/gadget/Makefile | 1 + drivers/usb/gadget/charger.c | 708 +++++++++++++++++++++++++++++++++++++ drivers/usb/gadget/udc/udc-core.c | 11 + include/linux/mfd/wm831x/pdata.h | 3 + include/linux/usb/gadget.h | 11 + include/linux/usb/usb_charger.h | 164 +++++++++ 8 files changed, 974 insertions(+) create mode 100644 drivers/usb/gadget/charger.c create mode 100644 include/linux/usb/usb_charger.h -- 1.7.9.5 ^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2015-12-08 8:36 ` Baolin Wang 0 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2015-12-08 8:36 UTC (permalink / raw) To: balbi-l0cyMroinI0, gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r, sre-DgEjT+Ai2ygdnm+yROfE0A, dbaryshkov-Re5JQEeQqe8AvxtiuMwx3w, dwmw2-wEGCiKHe2LqWVfeAwA7xHQ Cc: peter.chen-KZfg59tc24xl57MIdRCFDg, stern-nwvwT67g6+6dFdvTe/nMLpVzexx5G7lz, r.baldyga-Sze3O3UU22JBDgjK7y7TUQ, yoshihiro.shimoda.uh-zM6kxYcvzFBBDgjK7y7TUQ, lee.jones-QSEj5FYQhm4dnm+yROfE0A, broonie-DgEjT+Ai2ygdnm+yROfE0A, ckeepax-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, patches-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, baolin.wang-QSEj5FYQhm4dnm+yROfE0A, linux-pm-u79uwXL29TY76Z2rM5mHXA, linux-usb-u79uwXL29TY76Z2rM5mHXA, device-mainlining-cunTk1MwBs98uUxBSJOaYoYkZiVZrdSR2LY78lusg7I, linux-kernel-u79uwXL29TY76Z2rM5mHXA Currently the Linux kernel does not provide any standard integration of this feature that integrates the USB subsystem with the system power regulation provided by PMICs meaning that either vendors must add this in their kernels or USB gadget devices based on Linux (such as mobile phones) may not behave as they should. Thus provide a standard framework for doing this in kernel. Now introduce one user with wm831x_power to support and test the usb charger, which is pending testing. Moreover there may be other potential users will use it in future. Changes since v5: - Remove the notifier chain things from the gadget and introduce one callback function to report to the usb charger when the gadget state is changed. - Flesh out the port type detection which combines the USB negotiation and PMICs detection. - Supply the notification mechanism to userspace when charger state is changed. - Integrate with the vbus staff in the gadget API. - Spilt up the functionality for userspace with one file per USB charger type. Baolin Wang (4): gadget: Introduce the usb charger framework gadget: Support for the usb charger framework gadget: Integrate with the usb gadget supporting for usb charger power: wm831x_power: Support USB charger current limit management drivers/power/wm831x_power.c | 69 ++++ drivers/usb/gadget/Kconfig | 7 + drivers/usb/gadget/Makefile | 1 + drivers/usb/gadget/charger.c | 708 +++++++++++++++++++++++++++++++++++++ drivers/usb/gadget/udc/udc-core.c | 11 + include/linux/mfd/wm831x/pdata.h | 3 + include/linux/usb/gadget.h | 11 + include/linux/usb/usb_charger.h | 164 +++++++++ 8 files changed, 974 insertions(+) create mode 100644 drivers/usb/gadget/charger.c create mode 100644 include/linux/usb/usb_charger.h -- 1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-usb" in the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org More majordomo info at http://vger.kernel.org/majordomo-info.html ^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH v7 1/4] gadget: Introduce the usb charger framework 2015-12-08 8:36 ` Baolin Wang (?) @ 2015-12-08 8:36 ` Baolin Wang -1 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2015-12-08 8:36 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel This patch introduces the usb charger driver based on usb gadget that makes an enhancement to a power driver. It works well in practice but that requires a system with suitable hardware. The basic conception of the usb charger is that, when one usb charger is added or removed by reporting from the usb gadget state change or the extcon device state change, the usb charger will report to power user to set the current limitation. The usb charger will register notifiees on the usb gadget or the extcon device to get notified the usb charger state. It also supplies the notification mechanism to userspace When the usb charger state is changed. Power user will register a notifiee on the usb charger to get notified by status changes from the usb charger. It will report to power user to set the current limitation when detecting the usb charger is added or removed from extcon device state or usb gadget state. This patch doesn't yet integrate with the gadget code, so some functions which rely on the 'gadget' are not completed, that will be implemented in the following patches. Signed-off-by: Baolin Wang <baolin.wang@linaro.org> --- drivers/usb/gadget/Kconfig | 7 + drivers/usb/gadget/Makefile | 1 + drivers/usb/gadget/charger.c | 669 +++++++++++++++++++++++++++++++++++++++ include/linux/usb/usb_charger.h | 164 ++++++++++ 4 files changed, 841 insertions(+) create mode 100644 drivers/usb/gadget/charger.c create mode 100644 include/linux/usb/usb_charger.h diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig index 33834aa..8d69dca 100644 --- a/drivers/usb/gadget/Kconfig +++ b/drivers/usb/gadget/Kconfig @@ -127,6 +127,13 @@ config USB_GADGET_STORAGE_NUM_BUFFERS a module parameter as well. If unsure, say 2. +config USB_CHARGER + bool "USB charger support" + help + The usb charger driver based on the usb gadget that makes an + enhancement to a power driver which can set the current limitation + when the usb charger is added or removed. + source "drivers/usb/gadget/udc/Kconfig" # diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile index 598a67d..1e421c1 100644 --- a/drivers/usb/gadget/Makefile +++ b/drivers/usb/gadget/Makefile @@ -10,3 +10,4 @@ libcomposite-y := usbstring.o config.o epautoconf.o libcomposite-y += composite.o functions.o configfs.o u_f.o obj-$(CONFIG_USB_GADGET) += udc/ function/ legacy/ +obj-$(CONFIG_USB_CHARGER) += charger.o diff --git a/drivers/usb/gadget/charger.c b/drivers/usb/gadget/charger.c new file mode 100644 index 0000000..82a9973 --- /dev/null +++ b/drivers/usb/gadget/charger.c @@ -0,0 +1,669 @@ +/* + * charger.c -- USB charger driver + * + * Copyright (C) 2015 Linaro Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include <linux/device.h> +#include <linux/err.h> +#include <linux/extcon.h> +#include <linux/export.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/of_device.h> +#include <linux/of_address.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/usb.h> +#include <linux/usb/ch9.h> +#include <linux/usb/gadget.h> +#include <linux/usb/usb_charger.h> +#include <linux/power_supply.h> + +#define DEFAULT_CUR_PROTECT (50) +#define DEFAULT_SDP_CUR_LIMIT (500 - DEFAULT_CUR_PROTECT) +#define DEFAULT_DCP_CUR_LIMIT (1500 - DEFAULT_CUR_PROTECT) +#define DEFAULT_CDP_CUR_LIMIT (1500 - DEFAULT_CUR_PROTECT) +#define DEFAULT_ACA_CUR_LIMIT (1500 - DEFAULT_CUR_PROTECT) +#define UCHGER_STATE_LENGTH (50) + +static DEFINE_IDA(usb_charger_ida); +static struct bus_type usb_charger_subsys = { + .name = "usb-charger", + .dev_name = "usb-charger", +}; + +static struct usb_charger *dev_to_uchger(struct device *udev) +{ + return container_of(udev, struct usb_charger, dev); +} + +static ssize_t sdp_limit_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + + return sprintf(buf, "%d\n", uchger->cur_limit.sdp_cur_limit); +} + +static ssize_t sdp_limit_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + unsigned int sdp_limit; + int ret; + + ret = kstrtouint(buf, 10, &sdp_limit); + if (ret < 0) + return ret; + + ret = usb_charger_set_cur_limit_by_type(uchger, SDP_TYPE, sdp_limit); + if (ret < 0) + return ret; + + return count; +} +static DEVICE_ATTR_RW(sdp_limit); + +static ssize_t dcp_limit_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + + return sprintf(buf, "%d\n", uchger->cur_limit.dcp_cur_limit); +} + +static ssize_t dcp_limit_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + unsigned int dcp_limit; + int ret; + + ret = kstrtouint(buf, 10, &dcp_limit); + if (ret < 0) + return ret; + + ret = usb_charger_set_cur_limit_by_type(uchger, DCP_TYPE, dcp_limit); + if (ret < 0) + return ret; + + return count; +} +static DEVICE_ATTR_RW(dcp_limit); + +static ssize_t cdp_limit_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + + return sprintf(buf, "%d\n", uchger->cur_limit.cdp_cur_limit); +} + +static ssize_t cdp_limit_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + unsigned int cdp_limit; + int ret; + + ret = kstrtouint(buf, 10, &cdp_limit); + if (ret < 0) + return ret; + + ret = usb_charger_set_cur_limit_by_type(uchger, CDP_TYPE, cdp_limit); + if (ret < 0) + return ret; + + return count; +} +static DEVICE_ATTR_RW(cdp_limit); + +static ssize_t aca_limit_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + + return sprintf(buf, "%d\n", uchger->cur_limit.aca_cur_limit); +} + +static ssize_t aca_limit_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct usb_charger *uchger = dev_to_uchger(dev); + unsigned int aca_limit; + int ret; + + ret = kstrtouint(buf, 10, &aca_limit); + if (ret < 0) + return ret; + + ret = usb_charger_set_cur_limit_by_type(uchger, ACA_TYPE, aca_limit); + if (ret < 0) + return ret; + + return count; +} +static DEVICE_ATTR_RW(aca_limit); + +static struct attribute *usb_charger_attrs[] = { + &dev_attr_sdp_limit.attr, + &dev_attr_dcp_limit.attr, + &dev_attr_cdp_limit.attr, + &dev_attr_aca_limit.attr, + NULL +}; +ATTRIBUTE_GROUPS(usb_charger); + +/* + * usb_charger_find_by_name - Get the usb charger device by name. + * @name - usb charger device name. + * + * return the instance of usb charger device, the device must be + * released with usb_charger_put(). + */ +struct usb_charger *usb_charger_find_by_name(const char *name) +{ + struct device *udev; + + if (!name) + return ERR_PTR(-EINVAL); + + udev = bus_find_device_by_name(&usb_charger_subsys, NULL, name); + if (!udev) + return ERR_PTR(-ENODEV); + + return dev_to_uchger(udev); +} +EXPORT_SYMBOL_GPL(usb_charger_find_by_name); + +/* + * usb_charger_get() - Reference a usb charger. + * @uchger - usb charger + */ +struct usb_charger *usb_charger_get(struct usb_charger *uchger) +{ + return (uchger && get_device(&uchger->dev)) ? uchger : NULL; +} +EXPORT_SYMBOL_GPL(usb_charger_get); + +/* + * usb_charger_put() - Dereference a usb charger. + * @uchger - charger to release + */ +void usb_charger_put(struct usb_charger *uchger) +{ + if (uchger) + put_device(&uchger->dev); +} +EXPORT_SYMBOL_GPL(usb_charger_put); + +/* + * usb_charger_register_notify() - Register a notifiee to get notified by + * any attach status changes from the usb charger detection. + * @uchger - the usb charger device which is monitored. + * @nb - a notifier block to be registered. + */ +int usb_charger_register_notify(struct usb_charger *uchger, + struct notifier_block *nb) +{ + int ret; + + if (!uchger || !nb) + return -EINVAL; + + mutex_lock(&uchger->lock); + ret = raw_notifier_chain_register(&uchger->uchger_nh, nb); + + /* Generate an initial notify so users start in the right state */ + if (!ret) { + usb_charger_detect_type(uchger); + raw_notifier_call_chain(&uchger->uchger_nh, + usb_charger_get_cur_limit(uchger), + uchger); + } + mutex_unlock(&uchger->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(usb_charger_register_notify); + +/* + * usb_charger_unregister_notify() - Unregister a notifiee from the usb charger. + * @uchger - the usb charger device which is monitored. + * @nb - a notifier block to be unregistered. + */ +int usb_charger_unregister_notify(struct usb_charger *uchger, + struct notifier_block *nb) +{ + int ret; + + if (!uchger || !nb) + return -EINVAL; + + mutex_lock(&uchger->lock); + ret = raw_notifier_chain_unregister(&uchger->uchger_nh, nb); + mutex_unlock(&uchger->lock); + + return ret; +} +EXPORT_SYMBOL_GPL(usb_charger_unregister_notify); + +/* + * usb_charger_detect_type() - Get the usb charger type by the callback + * which is implemented by gadget operations. + * @uchger - the usb charger device. + * + * return the usb charger type. + */ +enum usb_charger_type +usb_charger_detect_type(struct usb_charger *uchger) +{ + if (uchger->psy) { + union power_supply_propval val; + + power_supply_get_property(uchger->psy, + POWER_SUPPLY_PROP_CHARGE_TYPE, + &val); + switch (val.intval) { + case POWER_SUPPLY_TYPE_USB: + uchger->type = SDP_TYPE; + break; + case POWER_SUPPLY_TYPE_USB_DCP: + uchger->type = DCP_TYPE; + break; + case POWER_SUPPLY_TYPE_USB_CDP: + uchger->type = CDP_TYPE; + break; + case POWER_SUPPLY_TYPE_USB_ACA: + uchger->type = ACA_TYPE; + break; + default: + uchger->type = UNKNOWN_TYPE; + break; + } + } else if (uchger->get_charger_type) { + uchger->type = uchger->get_charger_type(uchger); + } else { + uchger->type = UNKNOWN_TYPE; + } + + return uchger->type; +} +EXPORT_SYMBOL_GPL(usb_charger_detect_type); + +/* + * usb_charger_set_cur_limit_by_type() - Set the current limitation + * by charger type. + * @uchger - the usb charger device. + * @type - the usb charger type. + * @cur_limit - the current limitation. + */ +int usb_charger_set_cur_limit_by_type(struct usb_charger *uchger, + enum usb_charger_type type, + unsigned int cur_limit) +{ + if (!uchger) + return -EINVAL; + + switch (type) { + case SDP_TYPE: + uchger->cur_limit.sdp_cur_limit = cur_limit; + break; + case DCP_TYPE: + uchger->cur_limit.dcp_cur_limit = cur_limit; + break; + case CDP_TYPE: + uchger->cur_limit.cdp_cur_limit = cur_limit; + break; + case ACA_TYPE: + uchger->cur_limit.aca_cur_limit = cur_limit; + break; + default: + return -EINVAL; + } + + return 0; +} +EXPORT_SYMBOL_GPL(usb_charger_set_cur_limit_by_type); + +/* + * usb_charger_set_cur_limit() - Set the current limitation. + * @uchger - the usb charger device. + * @cur_limit_set - the current limitation. + */ +int usb_charger_set_cur_limit(struct usb_charger *uchger, + struct usb_charger_cur_limit *cur_limit_set) +{ + if (!uchger || !cur_limit_set) + return -EINVAL; + + uchger->cur_limit.sdp_cur_limit = cur_limit_set->sdp_cur_limit; + uchger->cur_limit.dcp_cur_limit = cur_limit_set->dcp_cur_limit; + uchger->cur_limit.cdp_cur_limit = cur_limit_set->cdp_cur_limit; + uchger->cur_limit.aca_cur_limit = cur_limit_set->aca_cur_limit; + return 0; +} +EXPORT_SYMBOL_GPL(usb_charger_set_cur_limit); + +/* + * usb_charger_get_cur_limit() - Get the current limitation by + * different usb charger type. + * @uchger - the usb charger device. + * + * return the current limitation to set. + */ +unsigned int +usb_charger_get_cur_limit(struct usb_charger *uchger) +{ + enum usb_charger_type uchger_type = usb_charger_detect_type(uchger); + unsigned int cur_limit; + + switch (uchger_type) { + case SDP_TYPE: + cur_limit = uchger->cur_limit.sdp_cur_limit; + break; + case DCP_TYPE: + cur_limit = uchger->cur_limit.dcp_cur_limit; + break; + case CDP_TYPE: + cur_limit = uchger->cur_limit.cdp_cur_limit; + break; + case ACA_TYPE: + cur_limit = uchger->cur_limit.aca_cur_limit; + break; + default: + return 0; + } + + return cur_limit; +} +EXPORT_SYMBOL_GPL(usb_charger_get_cur_limit); + +/* + * usb_charger_notifier_others() - It will notify other device registered + * on usb charger when the usb charger state is changed. + * @uchger - the usb charger device. + * @state - the state of the usb charger. + */ +static void +usb_charger_notify_others(struct usb_charger *uchger, + enum usb_charger_state state) +{ + char uchger_state[UCHGER_STATE_LENGTH]; + char *envp[] = { uchger_state, NULL }; + + mutex_lock(&uchger->lock); + uchger->state = state; + + switch (state) { + case USB_CHARGER_PRESENT: + usb_charger_detect_type(uchger); + raw_notifier_call_chain(&uchger->uchger_nh, + usb_charger_get_cur_limit(uchger), + uchger); + snprintf(uchger_state, UCHGER_STATE_LENGTH, + "USB_CHARGER_STATE=%s", "USB_CHARGER_PRESENT"); + break; + case USB_CHARGER_REMOVE: + uchger->type = UNKNOWN_TYPE; + raw_notifier_call_chain(&uchger->uchger_nh, 0, uchger); + snprintf(uchger_state, UCHGER_STATE_LENGTH, + "USB_CHARGER_STATE=%s", "USB_CHARGER_REMOVE"); + break; + default: + dev_warn(&uchger->dev, "Unknown USB charger state: %d\n", + state); + mutex_unlock(&uchger->lock); + return; + } + + kobject_uevent_env(&uchger->dev.kobj, KOBJ_CHANGE, envp); + mutex_unlock(&uchger->lock); +} + +/* + * usb_charger_plug_by_extcon() - The notifier call function which is registered + * on the extcon device. + * @nb - the notifier block that notified by extcon device. + * @state - the extcon device state. + * @data - here specify a extcon device. + * + * return the notify flag. + */ +static int +usb_charger_plug_by_extcon(struct notifier_block *nb, + unsigned long state, void *data) +{ + struct usb_charger_nb *extcon_nb = + container_of(nb, struct usb_charger_nb, nb); + struct usb_charger *uchger = extcon_nb->uchger; + enum usb_charger_state uchger_state; + + if (!uchger) + return NOTIFY_BAD; + + /* Report event to power to setting the current limitation + * for this usb charger when one usb charger is added or removed + * with detecting by extcon device. + */ + if (state) + uchger_state = USB_CHARGER_PRESENT; + else + uchger_state = USB_CHARGER_REMOVE; + + usb_charger_notify_others(uchger, uchger_state); + + return NOTIFY_OK; +} + +/* + * usb_charger_plug_by_gadget() - Set the usb charger current limitation + * according to the usb gadget device state. + * @gadget - the usb gadget device. + * @state - the usb gadget state. + */ +int usb_charger_plug_by_gadget(struct usb_gadget *gadget, + unsigned long state) +{ + return 0; +} +EXPORT_SYMBOL_GPL(usb_charger_plug_by_gadget); + +static int devm_uchger_dev_match(struct device *dev, void *res, void *data) +{ + struct usb_charger **r = res; + + if (WARN_ON(!r || !*r)) + return 0; + + return *r == data; +} + +static void usb_charger_release(struct device *dev) +{ + struct usb_charger *uchger = dev_get_drvdata(dev); + + kfree(uchger); +} + +/* + * usb_charger_unregister() - Unregister a usb charger device. + * @uchger - the usb charger to be unregistered. + */ +static int usb_charger_unregister(struct usb_charger *uchger) +{ + if (!uchger) + return -EINVAL; + + device_unregister(&uchger->dev); + return 0; +} + +static void devm_uchger_dev_unreg(struct device *dev, void *res) +{ + usb_charger_unregister(*(struct usb_charger **)res); +} + +void devm_usb_charger_unregister(struct device *dev, + struct usb_charger *uchger) +{ + devres_release(dev, devm_uchger_dev_unreg, + devm_uchger_dev_match, uchger); +} + +/* + * usb_charger_register() - Register a new usb charger device + * which is created by the usb charger framework. + * @parent - the parent device of the new usb charger. + * @uchger - the new usb charger device. + */ +static int usb_charger_register(struct device *parent, + struct usb_charger *uchger) +{ + int ret; + + if (!uchger) + return -EINVAL; + + uchger->dev.parent = parent; + uchger->dev.release = usb_charger_release; + uchger->dev.bus = &usb_charger_subsys; + uchger->dev.groups = usb_charger_groups; + + ret = ida_simple_get(&usb_charger_ida, 0, 0, GFP_KERNEL); + if (ret < 0) + goto fail_ida; + + uchger->id = ret; + dev_set_name(&uchger->dev, "usb-charger.%d", uchger->id); + dev_set_drvdata(&uchger->dev, uchger); + + ret = device_register(&uchger->dev); + if (ret) + goto fail_register; + + return 0; + +fail_register: + put_device(&uchger->dev); + ida_simple_remove(&usb_charger_ida, uchger->id); + uchger->id = -1; +fail_ida: + dev_err(parent, "Failed to register usb charger: %d\n", ret); + return ret; +} + +int devm_usb_charger_register(struct device *dev, + struct usb_charger *uchger) +{ + struct usb_charger **ptr; + int ret; + + ptr = devres_alloc(devm_uchger_dev_unreg, sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return -ENOMEM; + + ret = usb_charger_register(dev, uchger); + if (ret) { + devres_free(ptr); + return ret; + } + + *ptr = uchger; + devres_add(dev, ptr); + + return 0; +} + +int usb_charger_init(struct usb_gadget *ugadget) +{ + struct usb_charger *uchger; + struct extcon_dev *edev; + struct power_supply *psy; + int ret; + + if (!ugadget) + return -EINVAL; + + uchger = kzalloc(sizeof(struct usb_charger), GFP_KERNEL); + if (!uchger) + return -ENOMEM; + + uchger->type = UNKNOWN_TYPE; + uchger->state = USB_CHARGER_DEFAULT; + uchger->id = -1; + uchger->cur_limit.sdp_cur_limit = DEFAULT_SDP_CUR_LIMIT; + uchger->cur_limit.dcp_cur_limit = DEFAULT_DCP_CUR_LIMIT; + uchger->cur_limit.cdp_cur_limit = DEFAULT_CDP_CUR_LIMIT; + uchger->cur_limit.aca_cur_limit = DEFAULT_ACA_CUR_LIMIT; + uchger->get_charger_type = NULL; + + mutex_init(&uchger->lock); + RAW_INIT_NOTIFIER_HEAD(&uchger->uchger_nh); + + /* register a notifier on a extcon device if it is exsited */ + edev = extcon_get_edev_by_phandle(ugadget->dev.parent, 0); + if (!IS_ERR_OR_NULL(edev)) { + uchger->extcon_dev = edev; + uchger->extcon_nb.nb.notifier_call = usb_charger_plug_by_extcon; + uchger->extcon_nb.uchger = uchger; + extcon_register_notifier(edev, EXTCON_USB, + &uchger->extcon_nb.nb); + } + + /* to check if the usb charger is link to a power supply */ + psy = devm_power_supply_get_by_phandle(ugadget->dev.parent, + "power-supplies"); + if (!IS_ERR_OR_NULL(psy)) + uchger->psy = psy; + else + uchger->psy = NULL; + + /* register a notifier on a usb gadget device */ + uchger->gadget = ugadget; + uchger->old_gadget_state = ugadget->state; + + /* register a new usb charger */ + ret = usb_charger_register(&ugadget->dev, uchger); + if (ret) + goto fail; + + return 0; + +fail: + if (uchger->extcon_dev) + extcon_unregister_notifier(uchger->extcon_dev, + EXTCON_USB, &uchger->extcon_nb.nb); + + kfree(uchger); + return ret; +} + +int usb_charger_exit(struct usb_gadget *ugadget) +{ + return 0; +} + +static int __init usb_charger_sysfs_init(void) +{ + return subsys_system_register(&usb_charger_subsys, NULL); +} +core_initcall(usb_charger_sysfs_init); + +MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org>"); +MODULE_DESCRIPTION("USB charger driver"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/usb/usb_charger.h b/include/linux/usb/usb_charger.h new file mode 100644 index 0000000..eed422f --- /dev/null +++ b/include/linux/usb/usb_charger.h @@ -0,0 +1,164 @@ +#ifndef __LINUX_USB_CHARGER_H__ +#define __LINUX_USB_CHARGER_H__ + +#include <uapi/linux/usb/ch9.h> + +/* USB charger type: + * SDP (Standard Downstream Port) + * DCP (Dedicated Charging Port) + * CDP (Charging Downstream Port) + * ACA (Accessory Charger Adapters) + */ +enum usb_charger_type { + UNKNOWN_TYPE, + SDP_TYPE, + DCP_TYPE, + CDP_TYPE, + ACA_TYPE, +}; + +/* USB charger state */ +enum usb_charger_state { + USB_CHARGER_DEFAULT, + USB_CHARGER_PRESENT, + USB_CHARGER_REMOVE, +}; + +/* Current limitation by charger type */ +struct usb_charger_cur_limit { + unsigned int sdp_cur_limit; + unsigned int dcp_cur_limit; + unsigned int cdp_cur_limit; + unsigned int aca_cur_limit; +}; + +struct usb_charger_nb { + struct notifier_block nb; + struct usb_charger *uchger; +}; + +struct usb_charger { + struct device dev; + struct raw_notifier_head uchger_nh; + /* protect the notifier head */ + struct mutex lock; + int id; + enum usb_charger_type type; + enum usb_charger_state state; + + /* for supporting extcon usb gpio */ + struct extcon_dev *extcon_dev; + struct usb_charger_nb extcon_nb; + + /* for supporting usb gadget */ + struct usb_gadget *gadget; + enum usb_device_state old_gadget_state; + + /* for supporting power supply */ + struct power_supply *psy; + + /* user can get charger type by implementing this callback */ + enum usb_charger_type (*get_charger_type)(struct usb_charger *); + + /* current limitation */ + struct usb_charger_cur_limit cur_limit; +}; + +#ifdef CONFIG_USB_CHARGER +extern struct usb_charger *usb_charger_find_by_name(const char *name); + +extern struct usb_charger *usb_charger_get(struct usb_charger *uchger); +extern void usb_charger_put(struct usb_charger *uchger); + +extern int usb_charger_register_notify(struct usb_charger *uchger, + struct notifier_block *nb); +extern int usb_charger_unregister_notify(struct usb_charger *uchger, + struct notifier_block *nb); + +extern int usb_charger_set_cur_limit(struct usb_charger *uchger, + struct usb_charger_cur_limit *cur_limit_set); +extern int usb_charger_set_cur_limit_by_type(struct usb_charger *uchger, + enum usb_charger_type type, + unsigned int cur_limit); +extern unsigned int usb_charger_get_cur_limit(struct usb_charger *uchger); + +extern enum usb_charger_type usb_charger_detect_type(struct usb_charger *uchger); +extern int usb_charger_plug_by_gadget(struct usb_gadget *gadget, + unsigned long state); + +extern int usb_charger_init(struct usb_gadget *ugadget); +extern int usb_charger_exit(struct usb_gadget *ugadget); +#else +static inline struct usb_charger *usb_charger_find_by_name(const char *name) +{ + return ERR_PTR(-ENODEV); +} + +static inline struct usb_charger *usb_charger_get(struct usb_charger *uchger) +{ + return NULL; +} + +static inline void usb_charger_put(struct usb_charger *uchger) +{ +} + +static inline int +usb_charger_register_notify(struct usb_charger *uchger, + struct notifier_block *nb) +{ + return 0; +} + +static inline int +usb_charger_unregister_notify(struct usb_charger *uchger, + struct notifier_block *nb) +{ + return 0; +} + +static inline int +usb_charger_set_cur_limit(struct usb_charger *uchger, + struct usb_charger_cur_limit *cur_limit_set) +{ + return 0; +} + +static inline int +usb_charger_set_cur_limit_by_type(struct usb_charger *uchger, + enum usb_charger_type type, + unsigned int cur_limit) +{ + return 0; +} + +static inline unsigned int +usb_charger_get_cur_limit(struct usb_charger *uchger) +{ + return 0; +} + +static inline enum usb_charger_type +usb_charger_detect_type(struct usb_charger *uchger) +{ + return UNKNOWN_TYPE; +} + +static inline int +usb_charger_plug_by_gadget(struct usb_gadget *gadget, unsigned long state) +{ + return 0; +} + +static inline int usb_charger_init(struct usb_gadget *ugadget) +{ + return 0; +} + +static inline int usb_charger_exit(struct usb_gadget *ugadget) +{ + return 0; +} +#endif + +#endif /* __LINUX_USB_CHARGER_H__ */ -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 24+ messages in thread
* [PATCH v7 2/4] gadget: Support for the usb charger framework 2015-12-08 8:36 ` Baolin Wang (?) (?) @ 2015-12-08 8:36 ` Baolin Wang 2015-12-08 15:54 ` kbuild test robot -1 siblings, 1 reply; 24+ messages in thread From: Baolin Wang @ 2015-12-08 8:36 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel For supporting the usb charger, it adds the usb_charger_init() and usb_charger_exit() functions for usb charger initialization and exit. It will report to the usb charger when the gadget state is changed, then the usb charger can do the power things. Introduce a callback 'get_charger_type' which will implemented by user for usb gadget operations to get the usb charger type. Signed-off-by: Baolin Wang <baolin.wang@linaro.org> --- drivers/usb/gadget/udc/udc-core.c | 11 +++++++++++ include/linux/usb/gadget.h | 11 +++++++++++ 2 files changed, 22 insertions(+) diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c index f660afb..2727f01 100644 --- a/drivers/usb/gadget/udc/udc-core.c +++ b/drivers/usb/gadget/udc/udc-core.c @@ -28,6 +28,7 @@ #include <linux/usb/ch9.h> #include <linux/usb/gadget.h> #include <linux/usb.h> +#include <linux/usb/usb_charger.h> /** * struct usb_udc - describes one usb device controller @@ -226,6 +227,9 @@ static void usb_gadget_state_work(struct work_struct *work) struct usb_gadget *gadget = work_to_gadget(work); struct usb_udc *udc = gadget->udc; + /* when the gadget state is changed, then report to USB charger */ + usb_charger_plug_by_gadget(gadget, gadget->state); + if (udc) sysfs_notify(&udc->dev.kobj, NULL, "state"); } @@ -405,8 +409,14 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget, mutex_unlock(&udc_lock); + ret = usb_charger_init(gadget); + if (ret) + goto err5; + return 0; +err5: + device_del(&udc->dev); err4: list_del(&udc->list); mutex_unlock(&udc_lock); @@ -481,6 +491,7 @@ void usb_del_gadget_udc(struct usb_gadget *gadget) kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE); flush_work(&gadget->work); device_unregister(&udc->dev); + usb_charger_exit(gadget); device_unregister(&gadget->dev); } EXPORT_SYMBOL_GPL(usb_del_gadget_udc); diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h index 3d583a1..52c19b1 100644 --- a/include/linux/usb/gadget.h +++ b/include/linux/usb/gadget.h @@ -24,6 +24,7 @@ #include <linux/types.h> #include <linux/workqueue.h> #include <linux/usb/ch9.h> +#include <linux/usb/usb_charger.h> struct usb_ep; @@ -560,6 +561,7 @@ struct usb_gadget_ops { struct usb_ep *(*match_ep)(struct usb_gadget *, struct usb_endpoint_descriptor *, struct usb_ss_ep_comp_descriptor *); + enum usb_charger_type (*get_charger_type)(struct usb_gadget *); }; /** @@ -632,6 +634,8 @@ struct usb_gadget { unsigned out_epnum; unsigned in_epnum; struct usb_otg_caps *otg_caps; + /* negotiate the power with the usb charger */ + struct usb_charger *charger; unsigned sg_supported:1; unsigned is_otg:1; @@ -836,10 +840,17 @@ static inline int usb_gadget_vbus_connect(struct usb_gadget *gadget) * reporting how much power the device may consume. For example, this * could affect how quickly batteries are recharged. * + * It will also notify the USB charger how much power the device may + * consume if there is a USB charger linking with the gadget. + * * Returns zero on success, else negative errno. */ static inline int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA) { + if (gadget->charger) + usb_charger_set_cur_limit_by_type(gadget->charger, + usb_charger_detect_type(gadget->charger), mA); + if (!gadget->ops->vbus_draw) return -EOPNOTSUPP; return gadget->ops->vbus_draw(gadget, mA); -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 24+ messages in thread
* Re: [PATCH v7 2/4] gadget: Support for the usb charger framework @ 2015-12-08 15:54 ` kbuild test robot 0 siblings, 0 replies; 24+ messages in thread From: kbuild test robot @ 2015-12-08 15:54 UTC (permalink / raw) To: Baolin Wang Cc: kbuild-all, balbi, gregkh, sre, dbaryshkov, dwmw2, peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1401 bytes --] Hi Baolin, [auto build test ERROR on balbi-usb/next] [also build test ERROR on v4.4-rc4 next-20151208] url: https://github.com/0day-ci/linux/commits/Baolin-Wang/gadget-Introduce-the-usb-charger-framework/20151208-163942 base: https://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git next config: m68k-allmodconfig (attached as .config) reproduce: wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree make.cross ARCH=m68k All errors (new ones prefixed by >>): ERROR: "usb_charger_init" [drivers/usb/gadget/udc/udc-core.ko] undefined! ERROR: "usb_charger_plug_by_gadget" [drivers/usb/gadget/udc/udc-core.ko] undefined! ERROR: "usb_charger_exit" [drivers/usb/gadget/udc/udc-core.ko] undefined! ERROR: "usb_charger_set_cur_limit_by_type" [drivers/usb/gadget/libcomposite.ko] undefined! >> ERROR: "usb_charger_detect_type" [drivers/usb/gadget/libcomposite.ko] undefined! ERROR: "usb_charger_set_cur_limit_by_type" [drivers/usb/gadget/legacy/gadgetfs.ko] undefined! >> ERROR: "usb_charger_detect_type" [drivers/usb/gadget/legacy/gadgetfs.ko] undefined! --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation [-- Attachment #2: .config.gz --] [-- Type: application/octet-stream, Size: 34882 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 2/4] gadget: Support for the usb charger framework @ 2015-12-08 15:54 ` kbuild test robot 0 siblings, 0 replies; 24+ messages in thread From: kbuild test robot @ 2015-12-08 15:54 UTC (permalink / raw) Cc: kbuild-all-JC7UmRfGjtg, balbi-l0cyMroinI0, gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r, sre-DgEjT+Ai2ygdnm+yROfE0A, dbaryshkov-Re5JQEeQqe8AvxtiuMwx3w, dwmw2-wEGCiKHe2LqWVfeAwA7xHQ, peter.chen-KZfg59tc24xl57MIdRCFDg, stern-nwvwT67g6+6dFdvTe/nMLpVzexx5G7lz, r.baldyga-Sze3O3UU22JBDgjK7y7TUQ, yoshihiro.shimoda.uh-zM6kxYcvzFBBDgjK7y7TUQ, lee.jones-QSEj5FYQhm4dnm+yROfE0A, broonie-DgEjT+Ai2ygdnm+yROfE0A, ckeepax-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, patches-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, baolin.wang-QSEj5FYQhm4dnm+yROfE0A, linux-pm-u79uwXL29TY76Z2rM5mHXA, linux-usb-u79uwXL29TY76Z2rM5mHXA, device-mainlining-cunTk1MwBs98uUxBSJOaYoYkZiVZrdSR2LY78lusg7I, linux-kernel-u79uwXL29TY76Z2rM5mHXA [-- Attachment #1: Type: text/plain, Size: 1401 bytes --] Hi Baolin, [auto build test ERROR on balbi-usb/next] [also build test ERROR on v4.4-rc4 next-20151208] url: https://github.com/0day-ci/linux/commits/Baolin-Wang/gadget-Introduce-the-usb-charger-framework/20151208-163942 base: https://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git next config: m68k-allmodconfig (attached as .config) reproduce: wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree make.cross ARCH=m68k All errors (new ones prefixed by >>): ERROR: "usb_charger_init" [drivers/usb/gadget/udc/udc-core.ko] undefined! ERROR: "usb_charger_plug_by_gadget" [drivers/usb/gadget/udc/udc-core.ko] undefined! ERROR: "usb_charger_exit" [drivers/usb/gadget/udc/udc-core.ko] undefined! ERROR: "usb_charger_set_cur_limit_by_type" [drivers/usb/gadget/libcomposite.ko] undefined! >> ERROR: "usb_charger_detect_type" [drivers/usb/gadget/libcomposite.ko] undefined! ERROR: "usb_charger_set_cur_limit_by_type" [drivers/usb/gadget/legacy/gadgetfs.ko] undefined! >> ERROR: "usb_charger_detect_type" [drivers/usb/gadget/legacy/gadgetfs.ko] undefined! --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation [-- Attachment #2: .config.gz --] [-- Type: application/octet-stream, Size: 34882 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH v7 3/4] gadget: Integrate with the usb gadget supporting for usb charger 2015-12-08 8:36 ` Baolin Wang ` (2 preceding siblings ...) (?) @ 2015-12-08 8:36 ` Baolin Wang -1 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2015-12-08 8:36 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel When the usb gadget supporting for usb charger is ready, the usb charger should get the type by the 'get_charger_type' callback which is implemented by the usb gadget operations, and get the usb charger pointer from struct 'usb_gadget'. Signed-off-by: Baolin Wang <baolin.wang@linaro.org> --- drivers/usb/gadget/charger.c | 43 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/drivers/usb/gadget/charger.c b/drivers/usb/gadget/charger.c index 82a9973..76e1a6f 100644 --- a/drivers/usb/gadget/charger.c +++ b/drivers/usb/gadget/charger.c @@ -272,7 +272,11 @@ EXPORT_SYMBOL_GPL(usb_charger_unregister_notify); enum usb_charger_type usb_charger_detect_type(struct usb_charger *uchger) { - if (uchger->psy) { + if (uchger->gadget && uchger->gadget->ops + && uchger->gadget->ops->get_charger_type) { + uchger->type = + uchger->gadget->ops->get_charger_type(uchger->gadget); + } else if (uchger->psy) { union power_supply_propval val; power_supply_get_property(uchger->psy, @@ -479,6 +483,29 @@ usb_charger_plug_by_extcon(struct notifier_block *nb, int usb_charger_plug_by_gadget(struct usb_gadget *gadget, unsigned long state) { + struct usb_charger *uchger = gadget->charger; + enum usb_charger_state uchger_state; + + if (!uchger) + return -EINVAL; + + /* Report event to power to setting the current limitation + * for this usb charger when one usb charger state is changed + * with detecting by usb gadget state. + */ + if (uchger->old_gadget_state != state) { + uchger->old_gadget_state = state; + + if (state >= USB_STATE_ATTACHED) + uchger_state = USB_CHARGER_PRESENT; + else if (state == USB_STATE_NOTATTACHED) + uchger_state = USB_CHARGER_REMOVE; + else + uchger_state = USB_CHARGER_DEFAULT; + + usb_charger_notify_others(uchger, uchger_state); + } + return 0; } EXPORT_SYMBOL_GPL(usb_charger_plug_by_gadget); @@ -635,6 +662,7 @@ int usb_charger_init(struct usb_gadget *ugadget) /* register a notifier on a usb gadget device */ uchger->gadget = ugadget; + ugadget->charger = uchger; uchger->old_gadget_state = ugadget->state; /* register a new usb charger */ @@ -655,7 +683,18 @@ fail: int usb_charger_exit(struct usb_gadget *ugadget) { - return 0; + struct usb_charger *uchger = ugadget->charger; + + if (!uchger) + return -EINVAL; + + if (uchger->extcon_dev) + extcon_unregister_notifier(uchger->extcon_dev, + EXTCON_USB, &uchger->extcon_nb.nb); + + ida_simple_remove(&usb_charger_ida, uchger->id); + + return usb_charger_unregister(uchger); } static int __init usb_charger_sysfs_init(void) -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 24+ messages in thread
* [PATCH v7 4/4] power: wm831x_power: Support USB charger current limit management 2015-12-08 8:36 ` Baolin Wang ` (3 preceding siblings ...) (?) @ 2015-12-08 8:36 ` Baolin Wang -1 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2015-12-08 8:36 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel Integrate with the newly added USB charger interface to limit the current we draw from the USB input based on the input device configuration identified by the USB stack, allowing us to charge more quickly from high current inputs without drawing more current than specified from others. Signed-off-by: Mark Brown <broonie@kernel.org> Signed-off-by: Baolin Wang <baolin.wang@linaro.org> Acked-by: Lee Jones <lee.jones@linaro.org> Acked-by: Charles Keepax <ckeepax@opensource.wolfsonmicro.com> Acked-by: Peter Chen <peter.chen@freescale.com> Acked-by: Sebastian Reichel <sre@kernel.org> --- drivers/power/wm831x_power.c | 69 ++++++++++++++++++++++++++++++++++++++ include/linux/mfd/wm831x/pdata.h | 3 ++ 2 files changed, 72 insertions(+) diff --git a/drivers/power/wm831x_power.c b/drivers/power/wm831x_power.c index 7082301..043f1f4 100644 --- a/drivers/power/wm831x_power.c +++ b/drivers/power/wm831x_power.c @@ -13,6 +13,7 @@ #include <linux/platform_device.h> #include <linux/power_supply.h> #include <linux/slab.h> +#include <linux/usb/usb_charger.h> #include <linux/mfd/wm831x/core.h> #include <linux/mfd/wm831x/auxadc.h> @@ -31,6 +32,8 @@ struct wm831x_power { char usb_name[20]; char battery_name[20]; bool have_battery; + struct usb_charger *usb_charger; + struct notifier_block usb_notify; }; static int wm831x_power_check_online(struct wm831x *wm831x, int supply, @@ -125,6 +128,43 @@ static enum power_supply_property wm831x_usb_props[] = { POWER_SUPPLY_PROP_VOLTAGE_NOW, }; +/* In milliamps */ +static unsigned int wm831x_usb_limits[] = { + 0, + 2, + 100, + 500, + 900, + 1500, + 1800, + 550, +}; + +static int wm831x_usb_limit_change(struct notifier_block *nb, + unsigned long limit, void *data) +{ + struct wm831x_power *wm831x_power = container_of(nb, + struct wm831x_power, + usb_notify); + int i, best; + + /* Find the highest supported limit */ + best = 0; + for (i = 0; i < ARRAY_SIZE(wm831x_usb_limits); i++) { + if (limit >= wm831x_usb_limits[i] && + wm831x_usb_limits[best] < wm831x_usb_limits[i]) + best = i; + } + + dev_dbg(wm831x_power->wm831x->dev, + "Limiting USB current to %dmA", wm831x_usb_limits[best]); + + wm831x_set_bits(wm831x_power->wm831x, WM831X_POWER_STATE, + WM831X_USB_ILIM_MASK, best); + + return 0; +} + /********************************************************************* * Battery properties *********************************************************************/ @@ -607,8 +647,31 @@ static int wm831x_power_probe(struct platform_device *pdev) } } + if (wm831x_pdata && wm831x_pdata->usb_gadget) { + power->usb_charger = + usb_charger_find_by_name(wm831x_pdata->usb_gadget); + if (IS_ERR(power->usb_charger)) { + ret = PTR_ERR(power->usb_charger); + dev_err(&pdev->dev, + "Failed to find USB gadget: %d\n", ret); + goto err_bat_irq; + } + + power->usb_notify.notifier_call = wm831x_usb_limit_change; + + ret = usb_charger_register_notify(power->usb_charger, + &power->usb_notify); + if (ret != 0) { + dev_err(&pdev->dev, + "Failed to register notifier: %d\n", ret); + goto err_usb_charger; + } + } + return ret; +err_usb_charger: + /* put_device on charger */ err_bat_irq: --i; for (; i >= 0; i--) { @@ -637,6 +700,12 @@ static int wm831x_power_remove(struct platform_device *pdev) struct wm831x *wm831x = wm831x_power->wm831x; int irq, i; + if (wm831x_power->usb_charger) { + usb_charger_unregister_notify(wm831x_power->usb_charger, + &wm831x_power->usb_notify); + /* Free charger */ + } + for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) { irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, diff --git a/include/linux/mfd/wm831x/pdata.h b/include/linux/mfd/wm831x/pdata.h index dcc9631..5af8399 100644 --- a/include/linux/mfd/wm831x/pdata.h +++ b/include/linux/mfd/wm831x/pdata.h @@ -126,6 +126,9 @@ struct wm831x_pdata { /** The driver should initiate a power off sequence during shutdown */ bool soft_shutdown; + /** dev_name of USB charger gadget to integrate with */ + const char *usb_gadget; + int irq_base; int gpio_base; int gpio_defaults[WM831X_GPIO_NUM]; -- 1.7.9.5 ^ permalink raw reply related [flat|nested] 24+ messages in thread
* [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-01-04 3:04 Baolin Wang [not found] ` <CAGjg+kHzt7pxxU=OdTd3sLWETiA7P6iMBmNs6dNvSCzFZiwv4w@mail.gmail.com> ` (2 more replies) 0 siblings, 3 replies; 24+ messages in thread From: Baolin Wang @ 2016-01-04 3:04 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel Currently the Linux kernel does not provide any standard integration of this feature that integrates the USB subsystem with the system power regulation provided by PMICs meaning that either vendors must add this in their kernels or USB gadget devices based on Linux (such as mobile phones) may not behave as they should. Thus provide a standard framework for doing this in kernel. Now introduce one user with wm831x_power to support and test the usb charger, which is pending testing. Moreover there may be other potential users will use it in future. Changes since v5: - Remove the notifier chain things from the gadget and introduce one callback function to report to the usb charger when the gadget state is changed. - Flesh out the port type detection which combines the USB negotiation and PMICs detection. - Supply the notification mechanism to userspace when charger state is changed. - Integrate with the vbus staff in the gadget API. - Spilt up the functionality for userspace with one file per USB charger type. - Rebase on "4.4-rc7". Baolin Wang (4): gadget: Introduce the usb charger framework gadget: Support for the usb charger framework gadget: Integrate with the usb gadget supporting for usb charger power: wm831x_power: Support USB charger current limit management drivers/power/wm831x_power.c | 69 ++++ drivers/usb/gadget/Kconfig | 7 + drivers/usb/gadget/Makefile | 1 + drivers/usb/gadget/charger.c | 708 +++++++++++++++++++++++++++++++++++++ drivers/usb/gadget/udc/udc-core.c | 11 + include/linux/mfd/wm831x/pdata.h | 3 + include/linux/usb/gadget.h | 11 + include/linux/usb/usb_charger.h | 164 +++++++++ 8 files changed, 974 insertions(+) create mode 100644 drivers/usb/gadget/charger.c create mode 100644 include/linux/usb/usb_charger.h -- 1.7.9.5 ^ permalink raw reply [flat|nested] 24+ messages in thread
[parent not found: <CAGjg+kHzt7pxxU=OdTd3sLWETiA7P6iMBmNs6dNvSCzFZiwv4w@mail.gmail.com>]
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-01-07 11:54 ` Baolin Wang 0 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2016-01-07 11:54 UTC (permalink / raw) To: Alex Shi Cc: Felipe Balbi, Greg Kroah-Hartman, Sebastian Reichel, Dmitry Eremin-Solenikov, David Woodhouse, Peter Chen, Alan Stern, r.baldyga, yoshihiro.shimoda.uh, Lee Jones, Mark Brown, ckeepax, patches, linux-pm, USB, device-mainlining, lkml On 7 January 2016 at 19:25, Alex Shi <lkml.alex@gmail.com> wrote: > Hi, Baolin, > > There is similar gadget/charger driver on QC msm tree, > git://codeaurora.org/quic/la/kernel/msm-3.10 msm-3.10 > You may check that as a reference. > OK. Thanks. -- Baolin.wang Best Regards ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-01-07 11:54 ` Baolin Wang 0 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2016-01-07 11:54 UTC (permalink / raw) To: Alex Shi Cc: Felipe Balbi, Greg Kroah-Hartman, Sebastian Reichel, Dmitry Eremin-Solenikov, David Woodhouse, Peter Chen, Alan Stern, r.baldyga-Sze3O3UU22JBDgjK7y7TUQ, yoshihiro.shimoda.uh-zM6kxYcvzFBBDgjK7y7TUQ, Lee Jones, Mark Brown, ckeepax-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, patches-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, linux-pm-u79uwXL29TY76Z2rM5mHXA, USB, device-mainlining-cunTk1MwBs98uUxBSJOaYoYkZiVZrdSR2LY78lusg7I, lkml On 7 January 2016 at 19:25, Alex Shi <lkml.alex-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> wrote: > Hi, Baolin, > > There is similar gadget/charger driver on QC msm tree, > git://codeaurora.org/quic/la/kernel/msm-3.10 msm-3.10 > You may check that as a reference. > OK. Thanks. -- Baolin.wang Best Regards -- To unsubscribe from this list: send the line "unsubscribe linux-usb" in the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org More majordomo info at http://vger.kernel.org/majordomo-info.html ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-01-04 3:04 [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation Baolin Wang [not found] ` <CAGjg+kHzt7pxxU=OdTd3sLWETiA7P6iMBmNs6dNvSCzFZiwv4w@mail.gmail.com> @ 2016-01-25 3:44 ` Greg KH 2016-01-25 4:14 ` Baolin Wang 2016-02-29 14:22 ` Mark Brown 2 siblings, 1 reply; 24+ messages in thread From: Greg KH @ 2016-01-25 3:44 UTC (permalink / raw) To: Baolin Wang Cc: balbi, sre, dbaryshkov, dwmw2, peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, linux-pm, linux-usb, device-mainlining, linux-kernel On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: > Currently the Linux kernel does not provide any standard integration of this > feature that integrates the USB subsystem with the system power regulation > provided by PMICs meaning that either vendors must add this in their kernels > or USB gadget devices based on Linux (such as mobile phones) may not behave > as they should. Thus provide a standard framework for doing this in kernel. > > Now introduce one user with wm831x_power to support and test the usb charger, > which is pending testing. Moreover there may be other potential users will use > it in future. > > Changes since v5: > - Remove the notifier chain things from the gadget and introduce one callback > function to report to the usb charger when the gadget state is changed. > - Flesh out the port type detection which combines the USB negotiation and > PMICs detection. > - Supply the notification mechanism to userspace when charger state is changed. > - Integrate with the vbus staff in the gadget API. > - Spilt up the functionality for userspace with one file per USB charger type. > - Rebase on "4.4-rc7". You already sent out v7, so this should be v8, right? What changed since v7? Why resend it if nothing changed? confused, greg k-h ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-01-25 3:44 ` Greg KH @ 2016-01-25 4:14 ` Baolin Wang 0 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2016-01-25 4:14 UTC (permalink / raw) To: Greg KH Cc: Felipe Balbi, Sebastian Reichel, Dmitry Eremin-Solenikov, David Woodhouse, Peter Chen, Alan Stern, r.baldyga, yoshihiro.shimoda.uh, Lee Jones, Mark Brown, ckeepax, patches, linux-pm, USB, device-mainlining, LKML On 25 January 2016 at 11:44, Greg KH <gregkh@linuxfoundation.org> wrote: > On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: >> Currently the Linux kernel does not provide any standard integration of this >> feature that integrates the USB subsystem with the system power regulation >> provided by PMICs meaning that either vendors must add this in their kernels >> or USB gadget devices based on Linux (such as mobile phones) may not behave >> as they should. Thus provide a standard framework for doing this in kernel. >> >> Now introduce one user with wm831x_power to support and test the usb charger, >> which is pending testing. Moreover there may be other potential users will use >> it in future. >> >> Changes since v5: >> - Remove the notifier chain things from the gadget and introduce one callback >> function to report to the usb charger when the gadget state is changed. >> - Flesh out the port type detection which combines the USB negotiation and >> PMICs detection. >> - Supply the notification mechanism to userspace when charger state is changed. >> - Integrate with the vbus staff in the gadget API. >> - Spilt up the functionality for userspace with one file per USB charger type. >> - Rebase on "4.4-rc7". > > You already sent out v7, so this should be v8, right? What changed > since v7? Why resend it if nothing changed? I'm sorry for confusing, This is v7 without any changing, but I'm not sure maintainers have seen the big improvements since v5, so I resend it for catching attentions. Sorry again for confusing. > > confused, > > greg k-h -- Baolin.wang Best Regards ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-02-29 14:22 ` Mark Brown 0 siblings, 0 replies; 24+ messages in thread From: Mark Brown @ 2016-02-29 14:22 UTC (permalink / raw) To: Baolin Wang Cc: balbi, gregkh, sre, dbaryshkov, dwmw2, peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, ckeepax, patches, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1140 bytes --] On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: > Currently the Linux kernel does not provide any standard integration of this > feature that integrates the USB subsystem with the system power regulation > provided by PMICs meaning that either vendors must add this in their kernels > or USB gadget devices based on Linux (such as mobile phones) may not behave > as they should. Thus provide a standard framework for doing this in kernel. So, the review of this seems to have ground to a bit of a halt - we're really not seeing any engagement or comments here, people aren't raising any problems or suggesting alternative approaches but this isn't moving forwards either. This means that nothing running mainline that isn't totally offloaded to hardware can charge at even 500mA, let alone more, which seems like a failure to me. What do we need to move this forwards? If there are concerns around ABI we could either make sure it's as basic as possible (so that it'll be easy to maintain compatibility if we think of something better) or just hide things from userspace so that we just have the in kernel implementation. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 473 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-02-29 14:22 ` Mark Brown 0 siblings, 0 replies; 24+ messages in thread From: Mark Brown @ 2016-02-29 14:22 UTC (permalink / raw) To: Baolin Wang Cc: balbi-l0cyMroinI0, gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r, sre-DgEjT+Ai2ygdnm+yROfE0A, dbaryshkov-Re5JQEeQqe8AvxtiuMwx3w, dwmw2-wEGCiKHe2LqWVfeAwA7xHQ, peter.chen-KZfg59tc24xl57MIdRCFDg, stern-nwvwT67g6+6dFdvTe/nMLpVzexx5G7lz, r.baldyga-Sze3O3UU22JBDgjK7y7TUQ, yoshihiro.shimoda.uh-zM6kxYcvzFBBDgjK7y7TUQ, lee.jones-QSEj5FYQhm4dnm+yROfE0A, ckeepax-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, patches-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, linux-pm-u79uwXL29TY76Z2rM5mHXA, linux-usb-u79uwXL29TY76Z2rM5mHXA, device-mainlining-cunTk1MwBs98uUxBSJOaYoYkZiVZrdSR2LY78lusg7I, linux-kernel-u79uwXL29TY76Z2rM5mHXA [-- Attachment #1: Type: text/plain, Size: 1140 bytes --] On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: > Currently the Linux kernel does not provide any standard integration of this > feature that integrates the USB subsystem with the system power regulation > provided by PMICs meaning that either vendors must add this in their kernels > or USB gadget devices based on Linux (such as mobile phones) may not behave > as they should. Thus provide a standard framework for doing this in kernel. So, the review of this seems to have ground to a bit of a halt - we're really not seeing any engagement or comments here, people aren't raising any problems or suggesting alternative approaches but this isn't moving forwards either. This means that nothing running mainline that isn't totally offloaded to hardware can charge at even 500mA, let alone more, which seems like a failure to me. What do we need to move this forwards? If there are concerns around ABI we could either make sure it's as basic as possible (so that it'll be easy to maintain compatibility if we think of something better) or just hide things from userspace so that we just have the in kernel implementation. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 473 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-03-15 16:39 ` Mark Brown 0 siblings, 0 replies; 24+ messages in thread From: Mark Brown @ 2016-03-15 16:39 UTC (permalink / raw) To: Baolin Wang Cc: balbi, gregkh, sre, dbaryshkov, dwmw2, peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, ckeepax, patches, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1345 bytes --] On Mon, Feb 29, 2016 at 11:22:12PM +0900, Mark Brown wrote: > On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: I see Felipe is no longer at TI so his e-mail was bouncing - let's resend this with his kernel.org address: > > Currently the Linux kernel does not provide any standard integration of this > > feature that integrates the USB subsystem with the system power regulation > > provided by PMICs meaning that either vendors must add this in their kernels > > or USB gadget devices based on Linux (such as mobile phones) may not behave > > as they should. Thus provide a standard framework for doing this in kernel. > So, the review of this seems to have ground to a bit of a halt - we're > really not seeing any engagement or comments here, people aren't raising > any problems or suggesting alternative approaches but this isn't moving > forwards either. This means that nothing running mainline that isn't > totally offloaded to hardware can charge at even 500mA, let alone more, > which seems like a failure to me. What do we need to move this > forwards? > If there are concerns around ABI we could either make sure it's as basic > as possible (so that it'll be easy to maintain compatibility if we think > of something better) or just hide things from userspace so that we just > have the in kernel implementation. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 473 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-03-15 16:39 ` Mark Brown 0 siblings, 0 replies; 24+ messages in thread From: Mark Brown @ 2016-03-15 16:39 UTC (permalink / raw) To: Baolin Wang Cc: balbi-DgEjT+Ai2ygdnm+yROfE0A, gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r, sre-DgEjT+Ai2ygdnm+yROfE0A, dbaryshkov-Re5JQEeQqe8AvxtiuMwx3w, dwmw2-wEGCiKHe2LqWVfeAwA7xHQ, peter.chen-KZfg59tc24xl57MIdRCFDg, stern-nwvwT67g6+6dFdvTe/nMLpVzexx5G7lz, r.baldyga-Sze3O3UU22JBDgjK7y7TUQ, yoshihiro.shimoda.uh-zM6kxYcvzFBBDgjK7y7TUQ, lee.jones-QSEj5FYQhm4dnm+yROfE0A, ckeepax-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, patches-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E, linux-pm-u79uwXL29TY76Z2rM5mHXA, linux-usb-u79uwXL29TY76Z2rM5mHXA, device-mainlining-cunTk1MwBs98uUxBSJOaYoYkZiVZrdSR2LY78lusg7I, linux-kernel-u79uwXL29TY76Z2rM5mHXA [-- Attachment #1: Type: text/plain, Size: 1345 bytes --] On Mon, Feb 29, 2016 at 11:22:12PM +0900, Mark Brown wrote: > On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: I see Felipe is no longer at TI so his e-mail was bouncing - let's resend this with his kernel.org address: > > Currently the Linux kernel does not provide any standard integration of this > > feature that integrates the USB subsystem with the system power regulation > > provided by PMICs meaning that either vendors must add this in their kernels > > or USB gadget devices based on Linux (such as mobile phones) may not behave > > as they should. Thus provide a standard framework for doing this in kernel. > So, the review of this seems to have ground to a bit of a halt - we're > really not seeing any engagement or comments here, people aren't raising > any problems or suggesting alternative approaches but this isn't moving > forwards either. This means that nothing running mainline that isn't > totally offloaded to hardware can charge at even 500mA, let alone more, > which seems like a failure to me. What do we need to move this > forwards? > If there are concerns around ABI we could either make sure it's as basic > as possible (so that it'll be easy to maintain compatibility if we think > of something better) or just hide things from userspace so that we just > have the in kernel implementation. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 473 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-03-15 16:39 ` Mark Brown (?) @ 2016-03-16 11:05 ` Felipe Balbi 2016-03-16 11:20 ` Mark Brown -1 siblings, 1 reply; 24+ messages in thread From: Felipe Balbi @ 2016-03-16 11:05 UTC (permalink / raw) To: Mark Brown, Baolin Wang Cc: gregkh, sre, dbaryshkov, dwmw2, peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, ckeepax, patches, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 443 bytes --] Hi, Mark Brown <broonie@kernel.org> writes: > [ text/plain ] > On Mon, Feb 29, 2016 at 11:22:12PM +0900, Mark Brown wrote: >> On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: > > I see Felipe is no longer at TI so his e-mail was bouncing - let's > resend this with his kernel.org address: I don't have the patches on my inbox. Neither on kernel.org nor on my linux.intel.com account. Care to resend ? -- balbi [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 818 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-03-16 11:05 ` Felipe Balbi @ 2016-03-16 11:20 ` Mark Brown 2016-03-16 11:27 ` Baolin Wang 0 siblings, 1 reply; 24+ messages in thread From: Mark Brown @ 2016-03-16 11:20 UTC (permalink / raw) To: Felipe Balbi Cc: Baolin Wang, gregkh, sre, dbaryshkov, dwmw2, peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, ckeepax, patches, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 615 bytes --] On Wed, Mar 16, 2016 at 01:05:27PM +0200, Felipe Balbi wrote: > Mark Brown <broonie@kernel.org> writes: > > On Mon, Feb 29, 2016 at 11:22:12PM +0900, Mark Brown wrote: > >> On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: > > I see Felipe is no longer at TI so his e-mail was bouncing - let's > > resend this with his kernel.org address: > I don't have the patches on my inbox. Neither on kernel.org nor on my Right, they were last posted in January before you updated MAINTAINERS so they'll have gone to your TI address. > linux.intel.com account. Care to resend ? Baolin, can you do that please? [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 473 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-03-16 11:20 ` Mark Brown @ 2016-03-16 11:27 ` Baolin Wang 0 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2016-03-16 11:27 UTC (permalink / raw) To: Mark Brown Cc: Felipe Balbi, Greg KH, Sebastian Reichel, Dmitry Eremin-Solenikov, David Woodhouse, Peter Chen, Alan Stern, r.baldyga, yoshihiro.shimoda.uh, Lee Jones, ckeepax, patches, linux-pm, USB, device-mainlining, LKML On 16 March 2016 at 19:20, Mark Brown <broonie@kernel.org> wrote: > On Wed, Mar 16, 2016 at 01:05:27PM +0200, Felipe Balbi wrote: >> Mark Brown <broonie@kernel.org> writes: >> > On Mon, Feb 29, 2016 at 11:22:12PM +0900, Mark Brown wrote: >> >> On Mon, Jan 04, 2016 at 11:04:26AM +0800, Baolin Wang wrote: > >> > I see Felipe is no longer at TI so his e-mail was bouncing - let's >> > resend this with his kernel.org address: > >> I don't have the patches on my inbox. Neither on kernel.org nor on my > > Right, they were last posted in January before you updated MAINTAINERS > so they'll have gone to your TI address. > >> linux.intel.com account. Care to resend ? > > Baolin, can you do that please? OK. I'd like to do it again. -- Baolin.wang Best Regards ^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-03-16 11:46 Baolin Wang 2016-03-16 11:48 ` Felipe Balbi 0 siblings, 1 reply; 24+ messages in thread From: Baolin Wang @ 2016-03-16 11:46 UTC (permalink / raw) To: balbi, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel Currently the Linux kernel does not provide any standard integration of this feature that integrates the USB subsystem with the system power regulation provided by PMICs meaning that either vendors must add this in their kernels or USB gadget devices based on Linux (such as mobile phones) may not behave as they should. Thus provide a standard framework for doing this in kernel. Now introduce one user with wm831x_power to support and test the usb charger, which is pending testing. Moreover there may be other potential users will use it in future. Changes since v5: - Remove the notifier chain things from the gadget and introduce one callback function to report to the usb charger when the gadget state is changed. - Flesh out the port type detection which combines the USB negotiation and PMICs detection. - Supply the notification mechanism to userspace when charger state is changed. - Integrate with the vbus staff in the gadget API. - Spilt up the functionality for userspace with one file per USB charger type. - Rebase on "4.5-rc4". Baolin Wang (4): gadget: Introduce the usb charger framework gadget: Support for the usb charger framework gadget: Integrate with the usb gadget supporting for usb charger power: wm831x_power: Support USB charger current limit management drivers/power/wm831x_power.c | 69 ++++ drivers/usb/gadget/Kconfig | 7 + drivers/usb/gadget/Makefile | 1 + drivers/usb/gadget/charger.c | 708 +++++++++++++++++++++++++++++++++++++ drivers/usb/gadget/udc/udc-core.c | 11 + include/linux/mfd/wm831x/pdata.h | 3 + include/linux/usb/gadget.h | 11 + include/linux/usb/usb_charger.h | 164 +++++++++ 8 files changed, 974 insertions(+) create mode 100644 drivers/usb/gadget/charger.c create mode 100644 include/linux/usb/usb_charger.h -- 1.7.9.5 ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-03-16 11:46 Baolin Wang @ 2016-03-16 11:48 ` Felipe Balbi 0 siblings, 0 replies; 24+ messages in thread From: Felipe Balbi @ 2016-03-16 11:48 UTC (permalink / raw) To: Baolin Wang, gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1596 bytes --] Hi Baolin, Baolin Wang <baolin.wang@linaro.org> writes: > [ text/plain ] > Currently the Linux kernel does not provide any standard integration of this > feature that integrates the USB subsystem with the system power regulation > provided by PMICs meaning that either vendors must add this in their kernels > or USB gadget devices based on Linux (such as mobile phones) may not behave > as they should. Thus provide a standard framework for doing this in kernel. > > Now introduce one user with wm831x_power to support and test the usb charger, > which is pending testing. Moreover there may be other potential users will use > it in future. > > Changes since v5: > - Remove the notifier chain things from the gadget and introduce one callback > function to report to the usb charger when the gadget state is changed. > - Flesh out the port type detection which combines the USB negotiation and > PMICs detection. > - Supply the notification mechanism to userspace when charger state is changed. > - Integrate with the vbus staff in the gadget API. > - Spilt up the functionality for userspace with one file per USB charger type. > - Rebase on "4.5-rc4". > > Baolin Wang (4): > gadget: Introduce the usb charger framework > gadget: Support for the usb charger framework > gadget: Integrate with the usb gadget supporting for usb charger > power: wm831x_power: Support USB charger current limit management Thank you for resending this. I'll review it ASAP (probably tomorrow when I get to the office. If I have time, still today) -- balbi [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 818 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation @ 2016-03-16 11:48 ` Felipe Balbi 0 siblings, 0 replies; 24+ messages in thread From: Felipe Balbi @ 2016-03-16 11:48 UTC (permalink / raw) To: gregkh, sre, dbaryshkov, dwmw2 Cc: peter.chen, stern, r.baldyga, yoshihiro.shimoda.uh, lee.jones, broonie, ckeepax, patches, baolin.wang, linux-pm, linux-usb, device-mainlining, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1596 bytes --] Hi Baolin, Baolin Wang <baolin.wang@linaro.org> writes: > [ text/plain ] > Currently the Linux kernel does not provide any standard integration of this > feature that integrates the USB subsystem with the system power regulation > provided by PMICs meaning that either vendors must add this in their kernels > or USB gadget devices based on Linux (such as mobile phones) may not behave > as they should. Thus provide a standard framework for doing this in kernel. > > Now introduce one user with wm831x_power to support and test the usb charger, > which is pending testing. Moreover there may be other potential users will use > it in future. > > Changes since v5: > - Remove the notifier chain things from the gadget and introduce one callback > function to report to the usb charger when the gadget state is changed. > - Flesh out the port type detection which combines the USB negotiation and > PMICs detection. > - Supply the notification mechanism to userspace when charger state is changed. > - Integrate with the vbus staff in the gadget API. > - Spilt up the functionality for userspace with one file per USB charger type. > - Rebase on "4.5-rc4". > > Baolin Wang (4): > gadget: Introduce the usb charger framework > gadget: Support for the usb charger framework > gadget: Integrate with the usb gadget supporting for usb charger > power: wm831x_power: Support USB charger current limit management Thank you for resending this. I'll review it ASAP (probably tomorrow when I get to the office. If I have time, still today) -- balbi [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 818 bytes --] ^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation 2016-03-16 11:48 ` Felipe Balbi (?) @ 2016-03-16 11:56 ` Baolin Wang -1 siblings, 0 replies; 24+ messages in thread From: Baolin Wang @ 2016-03-16 11:56 UTC (permalink / raw) To: Felipe Balbi Cc: Greg KH, Sebastian Reichel, Dmitry Eremin-Solenikov, David Woodhouse, Peter Chen, Alan Stern, r.baldyga, yoshihiro.shimoda.uh, Lee Jones, Mark Brown, ckeepax, patches, linux-pm, USB, device-mainlining, LKML On 16 March 2016 at 19:48, Felipe Balbi <balbi@kernel.org> wrote: > > Hi Baolin, > > Baolin Wang <baolin.wang@linaro.org> writes: >> [ text/plain ] >> Currently the Linux kernel does not provide any standard integration of this >> feature that integrates the USB subsystem with the system power regulation >> provided by PMICs meaning that either vendors must add this in their kernels >> or USB gadget devices based on Linux (such as mobile phones) may not behave >> as they should. Thus provide a standard framework for doing this in kernel. >> >> Now introduce one user with wm831x_power to support and test the usb charger, >> which is pending testing. Moreover there may be other potential users will use >> it in future. >> >> Changes since v5: >> - Remove the notifier chain things from the gadget and introduce one callback >> function to report to the usb charger when the gadget state is changed. >> - Flesh out the port type detection which combines the USB negotiation and >> PMICs detection. >> - Supply the notification mechanism to userspace when charger state is changed. >> - Integrate with the vbus staff in the gadget API. >> - Spilt up the functionality for userspace with one file per USB charger type. >> - Rebase on "4.5-rc4". >> >> Baolin Wang (4): >> gadget: Introduce the usb charger framework >> gadget: Support for the usb charger framework >> gadget: Integrate with the usb gadget supporting for usb charger >> power: wm831x_power: Support USB charger current limit management > > Thank you for resending this. I'll review it ASAP (probably tomorrow > when I get to the office. If I have time, still today) OK. Thanks:) > > -- > balbi -- Baolin.wang Best Regards ^ permalink raw reply [flat|nested] 24+ messages in thread
end of thread, other threads:[~2016-03-16 11:56 UTC | newest] Thread overview: 24+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2015-12-08 8:36 [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation Baolin Wang 2015-12-08 8:36 ` Baolin Wang 2015-12-08 8:36 ` [PATCH v7 1/4] gadget: Introduce the usb charger framework Baolin Wang 2015-12-08 8:36 ` [PATCH v7 2/4] gadget: Support for " Baolin Wang 2015-12-08 15:54 ` kbuild test robot 2015-12-08 15:54 ` kbuild test robot 2015-12-08 8:36 ` [PATCH v7 3/4] gadget: Integrate with the usb gadget supporting for usb charger Baolin Wang 2015-12-08 8:36 ` [PATCH v7 4/4] power: wm831x_power: Support USB charger current limit management Baolin Wang 2016-01-04 3:04 [PATCH v7 0/4] Introduce usb charger framework to deal with the usb gadget power negotation Baolin Wang [not found] ` <CAGjg+kHzt7pxxU=OdTd3sLWETiA7P6iMBmNs6dNvSCzFZiwv4w@mail.gmail.com> 2016-01-07 11:54 ` Baolin Wang 2016-01-07 11:54 ` Baolin Wang 2016-01-25 3:44 ` Greg KH 2016-01-25 4:14 ` Baolin Wang 2016-02-29 14:22 ` Mark Brown 2016-02-29 14:22 ` Mark Brown 2016-03-15 16:39 ` Mark Brown 2016-03-15 16:39 ` Mark Brown 2016-03-16 11:05 ` Felipe Balbi 2016-03-16 11:20 ` Mark Brown 2016-03-16 11:27 ` Baolin Wang 2016-03-16 11:46 Baolin Wang 2016-03-16 11:48 ` Felipe Balbi 2016-03-16 11:48 ` Felipe Balbi 2016-03-16 11:56 ` Baolin Wang
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.