| Message ID | 1353047903-14363-2-git-send-email-acourbot@nvidia.com (mailing list archive) |
|---|---|
| State | Not Applicable, archived |
| Headers | show |
Hi Alexandre, The code looks neat, thanks for you work! Just a couple of comments... On Fri, Nov 16, 2012 at 03:38:21PM +0900, Alexandre Courbot wrote: [...] > + > +#include "power_seq_delay.c" > +#include "power_seq_regulator.c" > +#include "power_seq_pwm.c" > +#include "power_seq_gpio.c" This is odd, although I remember you already explained why you have to include the .c files, instead of linking them separately. But I forgot the reason. :) I think this deserves a comment in the code. > +static int of_power_seq_parse_step(struct device *dev, > + struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + struct list_head *resources) > +{ > + struct power_seq_step *step = &seq->steps[step_nbr]; > + struct power_seq_resource res, *res2; > + const char *type; > + int i, err; nit: one variable declaration per line. Thanks, Anton. -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Alex, I am looking forward for this feature to be mainlined, but I have comment on the way the types are tied up to power seq infrastructure. I know your use case are limited to using type "delay", "pwm" and "gpio" and "regulator", However there are instances where the devices can be powered up or reset by writing to special registers or sysconfs or something else. So My suggestion would be to make these type register them selfs dynamically with the power_seq infrastructure so that in future this can be extended to other types as-well. This trivial change can make a lot of difference for the future chips which do thing bit differently. ST Microelectronics chips fit it in these category and I guess other Vendors have this similar chips. What do you think? Thanks, srini On 16/11/12 06:38, Alexandre Courbot wrote: > Some device drivers (e.g. panel or backlights) need to follow precise > sequences for powering on and off, involving GPIOs, regulators, PWMs > with a precise powering order and delays to respect between steps. > These sequences are device-specific, and do not belong to a particular > driver - therefore they have been performed by board-specific hook > functions to far. > > With the advent of the device tree and of ARM kernels that are not > board-tied, we cannot rely on these board-specific hooks anymore but > need a way to implement these sequences in a portable manner. This patch > introduces a simple interpreter that can execute such power sequences > encoded either as platform data or within the device tree. > > Signed-off-by: Alexandre Courbot <acourbot@nvidia.com> > Reviewed-by: Stephen Warren <swarren@wwwdotorg.org> > Reviewed-by: Mark Brown <broonie@opensource.wolfsonmicro.com> > --- > .../devicetree/bindings/power/power_seq.txt | 121 +++++++ > Documentation/power/power_seq.txt | 253 ++++++++++++++ > drivers/power/Kconfig | 1 + > drivers/power/Makefile | 1 + > drivers/power/power_seq/Kconfig | 2 + > drivers/power/power_seq/Makefile | 1 + > drivers/power/power_seq/power_seq.c | 376 +++++++++++++++++++++ > drivers/power/power_seq/power_seq_delay.c | 65 ++++ > drivers/power/power_seq/power_seq_gpio.c | 94 ++++++ > drivers/power/power_seq/power_seq_pwm.c | 82 +++++ > drivers/power/power_seq/power_seq_regulator.c | 83 +++++ > include/linux/power_seq.h | 203 +++++++++++ > 12 files changed, 1282 insertions(+) > create mode 100644 Documentation/devicetree/bindings/power/power_seq.txt > create mode 100644 Documentation/power/power_seq.txt > create mode 100644 drivers/power/power_seq/Kconfig > create mode 100644 drivers/power/power_seq/Makefile > create mode 100644 drivers/power/power_seq/power_seq.c > create mode 100644 drivers/power/power_seq/power_seq_delay.c > create mode 100644 drivers/power/power_seq/power_seq_gpio.c > create mode 100644 drivers/power/power_seq/power_seq_pwm.c > create mode 100644 drivers/power/power_seq/power_seq_regulator.c > create mode 100644 include/linux/power_seq.h > > diff --git a/Documentation/devicetree/bindings/power/power_seq.txt b/Documentation/devicetree/bindings/power/power_seq.txt > new file mode 100644 > index 0000000..7880a6c > --- /dev/null > +++ b/Documentation/devicetree/bindings/power/power_seq.txt > @@ -0,0 +1,121 @@ > +Runtime Interpreted Power Sequences > +=================================== > + > +Power sequences are sequential descriptions of actions to be performed on > +power-related resources. Having these descriptions in a well-defined data format > +allows us to take much of the board- or device- specific power control code out > +of the kernel and place it into the device tree instead, making kernels less > +board-dependant. > + > +A device typically makes use of multiple power sequences, for different purposes > +such as powering on and off. All the power sequences of a given device are > +grouped into a set. In the device tree, this set is a sub-node of the device > +node named "power-sequences". > + > +Power Sequences Structure > +------------------------- > +Every device that makes use of power sequences must have a "power-sequences" > +node into which individual power sequences are declared as sub-nodes. The name > +of the node becomes the name of the sequence within the power sequences > +framework. > + > +Similarly, each power sequence declares its steps as sub-nodes of itself. Steps > +must be named sequentially, with the first step named step0, the second step1, > +etc. Failure to follow this rule will result in a parsing error. > + > +Power Sequences Steps > +--------------------- > +Steps of a sequence describe an action to be performed on a resource. They > +always include a "type" property which indicates what kind of resource this > +step works on. Depending on the resource type, additional properties are defined > +to control the action to be performed. > + > +"delay" type required properties: > + - delay: delay to wait (in microseconds) > + > +"regulator" type required properties: > + - id: name of the regulator to use. > + - enable / disable: one of these two empty properties must be present to > + enable or disable the resource > + > +"pwm" type required properties: > + - id: name of the PWM to use. > + - enable / disable: one of these two empty properties must be present to > + enable or disable the resource > + > +"gpio" type required properties: > + - gpio: phandle of the GPIO to use. > + - value: value this GPIO should take. Must be 0 or 1. > + > +Example > +------- > +Here are example sequences declared within a backlight device that use all the > +supported resources types: > + > + backlight { > + compatible = "pwm-backlight"; > + ... > + > + /* resources used by the power sequences */ > + pwms = <&pwm 2 5000000>; > + pwm-names = "backlight"; > + power-supply = <&backlight_reg>; > + > + power-sequences { > + power-on { > + step0 { > + type = "regulator"; > + id = "power"; > + enable; > + }; > + step1 { > + type = "delay"; > + delay = <10000>; > + }; > + step2 { > + type = "pwm"; > + id = "backlight"; > + enable; > + }; > + step3 { > + type = "gpio"; > + gpio = <&gpio 28 0>; > + value = <1>; > + }; > + }; > + > + power-off { > + step0 { > + type = "gpio"; > + gpio = <&gpio 28 0>; > + value = <0>; > + }; > + step1 { > + type = "pwm"; > + id = "backlight"; > + disable; > + }; > + step2 { > + type = "delay"; > + delay = <10000>; > + }; > + step3 { > + type = "regulator"; > + id = "power"; > + disable; > + }; > + }; > + }; > + }; > + > +The first part lists the PWM and regulator resources used by the sequences. > +These resources will be requested on behalf of the backlight device when the > +sequences are built and are declared according to their own bindings (for > +instance, regulators and pwms are resolved by name - note though that name > +declaration is done differently by the two frameworks). > + > +After the resources declaration, two sequences follow for powering the backlight > +on and off. Their names are specified by the pwm-backlight device bindings. Once > +the sequences are built by calling devm_of_parse_power_seq_set() on the > +backlight device, they can be added to a set using > +power_seq_set_add_sequences(). > diff --git a/Documentation/power/power_seq.txt b/Documentation/power/power_seq.txt > new file mode 100644 > index 0000000..8be0570 > --- /dev/null > +++ b/Documentation/power/power_seq.txt > @@ -0,0 +1,253 @@ > +Runtime Interpreted Power Sequences > +=================================== > + > +Problem > +------- > +Very commonly, boards need the help of out-of-driver code to turn some of their > +devices on and off. For instance, SoC boards might use a GPIO (abstracted to a > +regulator or not) to control the power supply of a backlight. The GPIO that > +should be used, however, as well as the exact power sequence that may also > +involve other resources, is board-dependent and thus unknown to the driver. > + > +This was previously addressed by having hooks in the device's platform data that > +are called whenever the state of the device might need a power status change. > +This approach, however, introduces board-dependant code into the kernel and is > +not compatible with the device tree. > + > +The Runtime Interpreted Power Sequences (or power sequences for short) aim at > +turning this code into platform data or device tree nodes. Power sequences are > +described using a simple format and run by a lightweight interpreter whenever > +needed. This allows device drivers to work without power callbacks and makes the > +kernel less board-dependant. > + > +What are Power Sequences? > +------------------------- > +A power sequence is an array of sequential steps describing an action to be > +performed on a resource. The supported resources and actions operations are: > +- delay (just wait for a given number of microseconds) > +- GPIO (set to 0 or 1) > +- regulator (enable or disable) > +- PWM (enable or disable) > + > +When a power sequence is run, its steps is executed one after the other until > +one step fails or the end of the sequence is reached. > + > +Power sequences are named, and grouped into "sets" which contain all the > +sequences of a device as well as the resources they use. > + > +Power sequences can be declared as platform data or in the device tree. > + > +Platform Data Format > +-------------------- > +All relevant data structures for declaring power sequences are located in > +include/linux/power_seq.h. > + > +The platform data for a device may include an instance of platform_power_seq_set > +which references all the power sequences used for a device. The power sequences > +reference resources in their steps, and setup the union member that corresponds > +to the resource's type. Resources, similarly, have a union which relevant member > +depends on their type. > + > +Note that the only "platform data" per se here is platform_power_seq_set. Other > +structures (power_seq and power_seq_resource) will be used at runtime and thus > +*must* survive initialization, so do not declare them with the __initdata > +attribute. > + > +The following example should make it clear how the platform data for power > +sequences is defined. It declares two power sequences named "power-on" and > +"power-off" for a backlight device. The "power-on" sequence enables the "power" > +regulator of the device, waits for 10ms, and then enables PWM "backlight" and > +set GPIO 28 to 1. "power-off" does the opposite. > + > +struct power_seq_resource reg_res = { > + .type = POWER_SEQ_REGULATOR, > + .regulator.id = "power", > +}; > + > +struct power_seq_resource gpio_res = { > + .type = POWER_SEQ_GPIO, > + .gpio.gpio = 28, > +}; > + > +struct power_seq_resource pwm_res = { > + .type = POWER_SEQ_PWM, > + .pwm.id = "backlight", > +}; > + > +struct power_seq_resource delay_res = { > + .type = POWER_SEQ_DELAY, > +}; > + > +struct power_seq power_on_seq = { > + .id = "power-on", > + .num_steps = 4, > + .steps = { > + { > + .resource = ®_res, > + .regulator.enable = true, > + }, { > + .resource = &delay_res, > + .delay.delay = 10000, > + }, { > + .resource = &pwm_res, > + .pwm.enable = true, > + }, { > + .resource = &gpio_res, > + .gpio.value = 1, > + }, > + }, > +}; > + > +struct power_seq power_off_seq = { > + .id = "power-off", > + .num_steps = 4, > + .steps = { > + { > + .resource = &gpio_res, > + .gpio.value = 0, > + }, { > + .resource = &pwm_res, > + .pwm.enable = false, > + }, { > + .resource = &delay_res, > + .delay.delay = 10000, > + }, { > + .resource = ®_res, > + .regulator.enable = false, > + }, > + }, > +}; > + > +struct platform_power_seq_set backlight_power_seqs __initdata = { > + .num_seqs = 2, > + .seqs = { > + &power_on_seq, > + &power_off_seq, > + }, > +}; > + > +"backlight_power_seqs" can then be passed to power_seq_set_add_sequences() in > +order to add the sequences to a set and allocate all the necessary resources. > +More on this later in this document. > + > +Device Tree > +----------- > +Power sequences can also be encoded as device tree nodes. The following > +properties and nodes are equivalent to the platform data defined previously: > + > +pwms = <&pwm 2 5000000>; > +pwm-names = "backlight"; > +power-supply = <&vdd_bl_reg>; > + > +power-sequences { > + power-on { > + step0 { > + type = "regulator"; > + id = "power"; > + enable; > + }; > + step1 { > + type = "delay"; > + delay = <10000>; > + }; > + step2 { > + type = "pwm"; > + id = "backlight"; > + enable; > + }; > + step3 { > + type = "gpio"; > + gpio = <&gpio 28 0>; > + value = <1>; > + }; > + }; > + > + power-off { > + step0 { > + type = "gpio"; > + gpio = <&gpio 28 0>; > + value = <0>; > + }; > + step1 { > + type = "pwm"; > + id = "backlight"; > + disable; > + }; > + step2 { > + type = "delay"; > + delay = <10000>; > + }; > + step3 { > + type = "regulator"; > + id = "power"; > + disable; > + }; > + }; > +}; > + > +See Documentation/devicetree/bindings/power/power_seq.txt for the complete > +syntax of the DT bindings. > + > +Use by Drivers and Resources Management > +--------------------------------------- > +Power sequences make use of resources that must be properly allocated and > +managed. The power_seq_set structure manages the sequences and resources for a > +particular device. A driver willing to use power sequences will thus declare one > +instance of power_seq_set per device and initialize it at probe time: > + > +struct my_device_data { > + struct device *dev; > + ... > + struct power_set_set power_seqs; > + ... > +}; > + > +power_seq_set_init(&my_device->power_seqs, my_device->dev); > + > +The power_seq_set_add_sequence() and power_seq_set_add_sequences() functions are > +then used to add one or several sequences to a set. These functions will also > +allocate all the resources used by the sequence(s) and make sure they are ready > +to be run. All resources are allocated through devm and will thus be freed when > +the set's device is removed. > + > + int power_seq_set_add_sequence(struct power_seq_set *set, > + struct power_seq *seq); > + int power_seq_set_add_sequences(struct power_seq_set *set, > + struct platform_power_seq_set *seqs); > + > +Power sequences added to a set can then be resolved by their name using > +power_seq_lookup(): > + > + struct power_seq *power_seq_lookup(struct power_seq_set *seqs, > + const char *id); > + > +power_seq_lookup() returns a ready-to-run pointer to the power sequence which > +name matches the id parameter. > + > +A retrieved power sequence can then be executed by power_seq_run: > + > + int power_seq_run(struct power_seq *seq); > + > +It returns 0 if the sequence has successfully been run, or an error code if a > +problem occurred. > + > +Sometimes, you may want to browse the list of resources allocated for the > +sequences of a device, for instance to ensure that a resource of a given type is > +present. The power_seq_for_each_resource() macro does this: > + > + power_seq_for_each_resource(pos, seqs) > + > +Here "pos" will be a pointer to a struct power_seq_resource. This structure > +contains the type of the resource, the information used for identifying it, and > +the resolved resource itself. > + > +Finally, users of the device tree can obtain a platform_power_seq_set structure > +built from the device's node using devm_of_parse_power_seq_set: > + > + struct platform_power_seq_set *devm_of_parse_power_seq_set(struct device *dev); > + > +The power sequences must be declared under a "power-sequences" node directly > +declared under the device's node. Detailed syntax contained in Documentation/devicetree/bindings/power/power_seq.txt. As the function name > +states, all memory is allocated through devm. The returned > +platform_power_seq_set can be freed after being added to a set, but the > +sequences themselves must be preserved until they are freed by devm. > \ No newline at end of file > diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig > index 49a8939..f20d449 100644 > --- a/drivers/power/Kconfig > +++ b/drivers/power/Kconfig > @@ -338,3 +338,4 @@ config AB8500_BATTERY_THERM_ON_BATCTRL > endif # POWER_SUPPLY > > source "drivers/power/avs/Kconfig" > +source "drivers/power/power_seq/Kconfig" > diff --git a/drivers/power/Makefile b/drivers/power/Makefile > index b949cf8..883ad4d 100644 > --- a/drivers/power/Makefile > +++ b/drivers/power/Makefile > @@ -49,3 +49,4 @@ obj-$(CONFIG_CHARGER_MAX8997) += max8997_charger.o > obj-$(CONFIG_CHARGER_MAX8998) += max8998_charger.o > obj-$(CONFIG_POWER_AVS) += avs/ > obj-$(CONFIG_CHARGER_SMB347) += smb347-charger.o > +obj-$(CONFIG_POWER_SEQ) += power_seq/ > diff --git a/drivers/power/power_seq/Kconfig b/drivers/power/power_seq/Kconfig > new file mode 100644 > index 0000000..3bff26e > --- /dev/null > +++ b/drivers/power/power_seq/Kconfig > @@ -0,0 +1,2 @@ > +config POWER_SEQ > + bool > diff --git a/drivers/power/power_seq/Makefile b/drivers/power/power_seq/Makefile > new file mode 100644 > index 0000000..f77a359 > --- /dev/null > +++ b/drivers/power/power_seq/Makefile > @@ -0,0 +1 @@ > +obj-$(CONFIG_POWER_SEQ) += power_seq.o > diff --git a/drivers/power/power_seq/power_seq.c b/drivers/power/power_seq/power_seq.c > new file mode 100644 > index 0000000..255b1a0 > --- /dev/null > +++ b/drivers/power/power_seq/power_seq.c > @@ -0,0 +1,376 @@ > +/* > + * power_seq.c - power sequence interpreter for platform devices and device tree > + * > + * Author: Alexandre Courbot <acourbot@nvidia.com> > + * > + * Copyright (c) 2012 NVIDIA Corporation. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + */ > + > +#include <linux/power_seq.h> > +#include <linux/module.h> > +#include <linux/err.h> > +#include <linux/device.h> > + > +#include <linux/of.h> > + > +#define power_seq_err(seq, step_nbr, format, ...) \ > + dev_err(seq->set->dev, "%s[%d]: " format, seq->id, step_nbr, \ > + ##__VA_ARGS__); > + > +/** > + * struct power_seq_res_ops - operators for power sequences resources > + * @name: Name of the resource type. Set to null when a resource > + * type support is not compiled in > + * @of_parse: Parse a step for this kind of resource from a device > + * tree node. The result of parsing must be written into > + * step step_nbr of seq > + * @step_run: Run a step for this kind of resource > + * @res_compare: Return true if the resource used by the resource is the > + * same as the one referenced by the step, false otherwise. > + * @res_alloc: Resolve and allocate a resource. Return error code if > + * the resource cannot be allocated, 0 otherwise > + */ > +struct power_seq_res_ops { > + const char *name; > + int (*of_parse)(struct device_node *node, struct power_seq *seq, > + unsigned int step_nbr, struct power_seq_resource *res); > + int (*step_run)(struct power_seq_step *step); > + bool (*res_compare)(struct power_seq_resource *res, > + struct power_seq_resource *res2); > + int (*res_alloc)(struct device *dev, > + struct power_seq_resource *res); > +}; > + > +static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES]; > + > +#ifdef CONFIG_OF > +static int of_power_seq_parse_enable_properties(struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + bool *enable) > +{ > + if (of_find_property(node, "enable", NULL)) { > + *enable = true; > + } else if (of_find_property(node, "disable", NULL)) { > + *enable = false; > + } else { > + power_seq_err(seq, step_nbr, > + "missing enable or disable property\n"); > + return -EINVAL; > + } > + > + return 0; > +} > + > +static int of_power_seq_parse_step(struct device *dev, > + struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + struct list_head *resources) > +{ > + struct power_seq_step *step = &seq->steps[step_nbr]; > + struct power_seq_resource res, *res2; > + const char *type; > + int i, err; > + > + err = of_property_read_string(node, "type", &type); > + if (err < 0) { > + power_seq_err(seq, step_nbr, "cannot read type property\n"); > + return err; > + } > + for (i = 0; i < POWER_SEQ_NUM_TYPES; i++) { > + if (power_seq_ops[i].name == NULL) > + continue; > + if (!strcmp(type, power_seq_ops[i].name)) > + break; > + } > + if (i >= POWER_SEQ_NUM_TYPES) { > + power_seq_err(seq, step_nbr, "unknown type %s\n", type); > + return -EINVAL; > + } > + memset(&res, 0, sizeof(res)); > + res.type = i; > + err = power_seq_ops[res.type].of_parse(node, seq, step_nbr, &res); > + if (err < 0) > + return err; > + > + /* Use the same instance of the resource if met before */ > + list_for_each_entry(res2, resources, list) { > + if (res.type == res2->type && > + power_seq_ops[res.type].res_compare(&res, res2)) > + break; > + } > + /* Resource never met before, create it */ > + if (&res2->list == resources) { > + res2 = devm_kzalloc(dev, sizeof(*res2), GFP_KERNEL); > + if (!res2) > + return -ENOMEM; > + memcpy(res2, &res, sizeof(res)); > + list_add_tail(&res2->list, resources); > + } > + step->resource = res2; > + > + return 0; > +} > + > +static struct power_seq *of_parse_power_seq(struct device *dev, > + struct device_node *node, > + struct list_head *resources) > +{ > + struct device_node *child = NULL; > + struct power_seq *pseq; > + int num_steps, sz; > + int err; > + > + if (!node) > + return ERR_PTR(-EINVAL); > + > + num_steps = of_get_child_count(node); > + sz = sizeof(*pseq) + sizeof(pseq->steps[0]) * num_steps; > + pseq = devm_kzalloc(dev, sz, GFP_KERNEL); > + if (!pseq) > + return ERR_PTR(-ENOMEM); > + pseq->id = node->name; > + pseq->num_steps = num_steps; > + > + for_each_child_of_node(node, child) { > + unsigned int pos; > + > + /* Check that the name's format is correct and within bounds */ > + if (strncmp("step", child->name, 4)) { > + err = -EINVAL; > + goto parse_error; > + } > + > + err = kstrtouint(child->name + 4, 10, &pos); > + if (err < 0) > + goto parse_error; > + > + /* Invalid step index or step already parsed? */ > + if (pos >= num_steps || pseq->steps[pos].resource != NULL) { > + err = -EINVAL; > + goto parse_error; > + } > + > + err = of_power_seq_parse_step(dev, child, pseq, pos, resources); > + if (err) > + return ERR_PTR(err); > + } > + > + return pseq; > + > +parse_error: > + dev_err(dev, "%s: invalid power step name %s!\n", pseq->id, > + child->name); > + return ERR_PTR(err); > +} > + > +/** > + * devm_of_parse_power_seq_set - build a power_seq_set from the device tree > + * @dev: Device to parse the power sequences of > + * > + * Sequences must be contained into a subnode named "power-sequences" of the > + * device root node. > + * > + * Memory for the sequence is allocated using devm_kzalloc on dev. The returned > + * platform_power_seq_set can be freed by devm_kfree after the sequences have > + * been added, but the sequences themselves must be preserved. > + * > + * Returns the built set on success, or an error code in case of failure. > + */ > +struct platform_power_seq_set *devm_of_parse_power_seq_set(struct device *dev) > +{ > + struct platform_power_seq_set *set; > + struct device_node *root = dev->of_node; > + struct device_node *seq; > + struct list_head resources; > + int n, sz; > + > + if (!root) > + return NULL; > + > + root = of_find_node_by_name(root, "power-sequences"); > + if (!root) > + return NULL; > + > + n = of_get_child_count(root); > + sz = sizeof(*set) + sizeof(struct power_seq *) * n; > + set = devm_kzalloc(dev, sz, GFP_KERNEL); > + if (!set) > + return ERR_PTR(-ENOMEM); > + set->num_seqs = n; > + > + n = 0; > + INIT_LIST_HEAD(&resources); > + for_each_child_of_node(root, seq) { > + struct power_seq *pseq; > + > + pseq = of_parse_power_seq(dev, seq, &resources); > + if (IS_ERR(pseq)) > + return (void *)pseq; > + > + set->seqs[n++] = pseq; > + } > + > + return set; > +} > +EXPORT_SYMBOL_GPL(devm_of_parse_power_seq_set); > +#endif /* CONFIG_OF */ > + > +/** > + * power_seq_set_init - initialize a power_seq_set > + * @set: Set to initialize > + * @dev: Device this set is going to belong to > + */ > +void power_seq_set_init(struct power_seq_set *set, struct device *dev) > +{ > + set->dev = dev; > + INIT_LIST_HEAD(&set->resources); > + INIT_LIST_HEAD(&set->seqs); > +} > +EXPORT_SYMBOL_GPL(power_seq_set_init); > + > +/** > + * power_seq_add_sequence - add a power sequence to a set > + * @set: Set to add the sequence to > + * @seq: Sequence to add > + * > + * This step will check that all the resources used by the sequence are > + * allocated. If they are not, an attempt to allocate them is made. This > + * operation can fail and and return an error code. > + * > + * Returns 0 on success, error code if a resource initialization failed. > + */ > +int power_seq_add_sequence(struct power_seq_set *set, struct power_seq *seq) > +{ > + struct power_seq_resource *res; > + int i, err; > + > + for (i = 0; i < seq->num_steps; i++) { > + struct power_seq_step *step = &seq->steps[i]; > + struct power_seq_resource *step_res = step->resource; > + list_for_each_entry(res, &set->resources, list) { > + if (res == step_res) > + break; > + } > + /* resource not allocated yet, allocate and add it */ > + if (&res->list == &set->resources) { > + err = power_seq_ops[step_res->type].res_alloc(set->dev, > + step_res); > + if (err) > + return err; > + list_add_tail(&step->resource->list, &set->resources); > + } > + } > + > + list_add_tail(&seq->list, &set->seqs); > + seq->set = set; > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(power_seq_add_sequence); > + > +/** > + * power_seq_add_sequences - add power sequences defined as platform data > + * @set: Set to add the sequences to > + * @seqs: Sequences to add > + * > + * See power_seq_add_sequence for more details. > + * > + * Returns 0 on success, error code if a resource initialization failed. > + */ > +int power_seq_set_add_sequences(struct power_seq_set *set, > + struct platform_power_seq_set *seqs) > +{ > + int i, ret; > + > + for (i = 0; i < seqs->num_seqs; i++) { > + ret = power_seq_add_sequence(set, seqs->seqs[i]); > + if (ret < 0) > + return ret; > + } > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(power_seq_set_add_sequences); > + > +/** > + * power_seq_lookup - Lookup a power sequence by name from a set > + * @seqs: The set to look in > + * @id: Name to look after > + * > + * Returns a matching power sequence if it exists, NULL if it does not. > + */ > +struct power_seq *power_seq_lookup(struct power_seq_set *set, const char *id) > +{ > + struct power_seq *seq; > + > + list_for_each_entry(seq, &set->seqs, list) { > + if (!strcmp(seq->id, id)) > + return seq; > + } > + > + return NULL; > +} > +EXPORT_SYMBOL_GPL(power_seq_lookup); > + > +/** > + * power_seq_run() - run a power sequence > + * @seq: The power sequence to run > + * > + * Returns 0 on success, error code in case of failure. > + */ > +int power_seq_run(struct power_seq *seq) > +{ > + unsigned int i; > + int err; > + > + if (!seq) > + return 0; > + > + if (!seq->set) { > + pr_err("cannot run a sequence not added to a set"); > + return -EINVAL; > + } > + > + for (i = 0; i < seq->num_steps; i++) { > + unsigned int type = seq->steps[i].resource->type; > + > + err = power_seq_ops[type].step_run(&seq->steps[i]); > + if (err) { > + power_seq_err(seq, i, > + "error %d while running power sequence step\n", > + err); > + return err; > + } > + } > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(power_seq_run); > + > +#include "power_seq_delay.c" > +#include "power_seq_regulator.c" > +#include "power_seq_pwm.c" > +#include "power_seq_gpio.c" > + > +static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES] = { > + [POWER_SEQ_DELAY] = POWER_SEQ_DELAY_TYPE, > + [POWER_SEQ_REGULATOR] = POWER_SEQ_REGULATOR_TYPE, > + [POWER_SEQ_PWM] = POWER_SEQ_PWM_TYPE, > + [POWER_SEQ_GPIO] = POWER_SEQ_GPIO_TYPE, > +}; > + > +MODULE_AUTHOR("Alexandre Courbot <acourbot@nvidia.com>"); > +MODULE_DESCRIPTION("Runtime Interpreted Power Sequences"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/power/power_seq/power_seq_delay.c b/drivers/power/power_seq/power_seq_delay.c > new file mode 100644 > index 0000000..5bb0a46 > --- /dev/null > +++ b/drivers/power/power_seq/power_seq_delay.c > @@ -0,0 +1,65 @@ > +/* > + * Copyright (c) 2012 NVIDIA Corporation. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + */ > + > +#include <linux/delay.h> > + > +#ifdef CONFIG_OF > +static int of_power_seq_parse_delay(struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + struct power_seq_resource *res) > +{ > + struct power_seq_step *step = &seq->steps[step_nbr]; > + int err; > + > + err = of_property_read_u32(node, "delay", > + &step->delay.delay); > + if (err < 0) > + power_seq_err(seq, step_nbr, "error reading delay property\n"); > + > + return err; > +} > +#else > +#define of_power_seq_parse_delay NULL > +#endif > + > +static bool power_seq_res_compare_delay(struct power_seq_resource *res, > + struct power_seq_resource *res2) > +{ > + /* Delay resources are just here to hold the type of steps, so they are > + * all equivalent. */ > + return true; > +} > + > +static int power_seq_res_alloc_delay(struct device *dev, > + struct power_seq_resource *res) > +{ > + return 0; > +} > + > +static int power_seq_step_run_delay(struct power_seq_step *step) > +{ > + usleep_range(step->delay.delay, > + step->delay.delay + 1000); > + > + return 0; > +} > + > +#define POWER_SEQ_DELAY_TYPE { \ > + .name = "delay", \ > + .of_parse = of_power_seq_parse_delay, \ > + .step_run = power_seq_step_run_delay, \ > + .res_compare = power_seq_res_compare_delay, \ > + .res_alloc = power_seq_res_alloc_delay, \ > +} > diff --git a/drivers/power/power_seq/power_seq_gpio.c b/drivers/power/power_seq/power_seq_gpio.c > new file mode 100644 > index 0000000..028a4cc > --- /dev/null > +++ b/drivers/power/power_seq/power_seq_gpio.c > @@ -0,0 +1,94 @@ > +/* > + * Copyright (c) 2012 NVIDIA Corporation. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + */ > + > +#include <linux/gpio.h> > +#include <linux/of_gpio.h> > + > +#ifdef CONFIG_OF > +static int of_power_seq_parse_gpio(struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + struct power_seq_resource *res) > +{ > + struct power_seq_step *step = &seq->steps[step_nbr]; > + int gpio; > + int err; > + > + gpio = of_get_named_gpio(node, "gpio", 0); > + if (gpio < 0) { > + power_seq_err(seq, step_nbr, "error reading gpio property\n"); > + return gpio; > + } > + res->gpio.gpio = gpio; > + > + err = of_property_read_u32(node, "value", &step->gpio.value); > + if (err < 0) { > + power_seq_err(seq, step_nbr, "error reading value property\n"); > + } else if (step->gpio.value < 0 || step->gpio.value > 1) { > + power_seq_err(seq, step_nbr, > + "value out of range (must be 0 or 1)\n"); > + err = -EINVAL; > + } > + > + return err; > +} > +#else > +#define of_power_seq_parse_gpio NULL > +#endif > + > +static bool power_seq_res_compare_gpio(struct power_seq_resource *res, > + struct power_seq_resource *res2) > +{ > + return res->gpio.gpio == res2->gpio.gpio; > +} > + > +static int power_seq_res_alloc_gpio(struct device *dev, > + struct power_seq_resource *res) > +{ > + int err; > + > + err = devm_gpio_request(dev, res->gpio.gpio, dev_name(dev)); > + if (err) { > + dev_err(dev, "cannot get gpio %d\n", res->gpio.gpio); > + return err; > + } > + > + return 0; > +} > + > +static int power_seq_step_run_gpio(struct power_seq_step *step) > +{ > + struct power_seq_resource *res = step->resource; > + > + /* set the GPIO direction at first use */ > + if (!res->gpio.is_set) { > + int err = gpio_direction_output(res->gpio.gpio, > + step->gpio.value); > + if (err) > + return err; > + res->gpio.is_set = true; > + } else { > + gpio_set_value_cansleep(res->gpio.gpio, step->gpio.value); > + } > + > + return 0; > +} > + > +#define POWER_SEQ_GPIO_TYPE { \ > + .name = "gpio", \ > + .of_parse = of_power_seq_parse_gpio, \ > + .step_run = power_seq_step_run_gpio, \ > + .res_compare = power_seq_res_compare_gpio, \ > + .res_alloc = power_seq_res_alloc_gpio, \ > +} > diff --git a/drivers/power/power_seq/power_seq_pwm.c b/drivers/power/power_seq/power_seq_pwm.c > new file mode 100644 > index 0000000..e61acdd > --- /dev/null > +++ b/drivers/power/power_seq/power_seq_pwm.c > @@ -0,0 +1,82 @@ > +/* > + * Copyright (c) 2012 NVIDIA Corporation. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + */ > + > +#ifdef CONFIG_PWM > + > +#include <linux/pwm.h> > + > +#ifdef CONFIG_OF > +static int of_power_seq_parse_pwm(struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + struct power_seq_resource *res) > +{ > + struct power_seq_step *step = &seq->steps[step_nbr]; > + int err; > + > + err = of_property_read_string(node, "id", &res->pwm.id); > + if (err) { > + power_seq_err(seq, step_nbr, "error reading id property\n"); > + return err; > + } > + > + err = of_power_seq_parse_enable_properties(node, seq, step_nbr, > + &step->pwm.enable); > + return err; > +} > +#else > +#define of_power_seq_parse_pwm NULL > +#endif > + > +static bool power_seq_res_compare_pwm(struct power_seq_resource *res, > + struct power_seq_resource *res2) > +{ > + return !strcmp(res->pwm.id, res2->pwm.id); > +} > + > +static int power_seq_res_alloc_pwm(struct device *dev, > + struct power_seq_resource *res) > +{ > + res->pwm.pwm = devm_pwm_get(dev, res->pwm.id); > + if (IS_ERR(res->pwm.pwm)) { > + dev_err(dev, "cannot get pwm \"%s\"\n", res->pwm.id); > + return PTR_ERR(res->pwm.pwm); > + } > + > + return 0; > +} > + > +static int power_seq_step_run_pwm(struct power_seq_step *step) > +{ > + if (step->pwm.enable) { > + return pwm_enable(step->resource->pwm.pwm); > + } else { > + pwm_disable(step->resource->pwm.pwm); > + return 0; > + } > +} > + > +#define POWER_SEQ_PWM_TYPE { \ > + .name = "pwm", \ > + .of_parse = of_power_seq_parse_pwm, \ > + .step_run = power_seq_step_run_pwm, \ > + .res_compare = power_seq_res_compare_pwm, \ > + .res_alloc = power_seq_res_alloc_pwm, \ > +} > + > +#else > + > +#define POWER_SEQ_PWM_TYPE {} > + > +#endif > diff --git a/drivers/power/power_seq/power_seq_regulator.c b/drivers/power/power_seq/power_seq_regulator.c > new file mode 100644 > index 0000000..2025155 > --- /dev/null > +++ b/drivers/power/power_seq/power_seq_regulator.c > @@ -0,0 +1,83 @@ > +/* > + * Copyright (c) 2012 NVIDIA Corporation. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + */ > + > +#ifdef CONFIG_REGULATOR > + > +#include <linux/regulator/consumer.h> > + > +#ifdef CONFIG_OF > +static int of_power_seq_parse_regulator(struct device_node *node, > + struct power_seq *seq, > + unsigned int step_nbr, > + struct power_seq_resource *res) > +{ > + struct power_seq_step *step = &seq->steps[step_nbr]; > + int err; > + > + err = of_property_read_string(node, "id", > + &res->regulator.id); > + if (err) { > + power_seq_err(seq, step_nbr, "error reading id property\n"); > + return err; > + } > + > + err = of_power_seq_parse_enable_properties(node, seq, step_nbr, > + &step->regulator.enable); > + return err; > +} > +#else > +#define of_power_seq_parse_regulator NULL > +#endif > + > +static bool > +power_seq_res_compare_regulator(struct power_seq_resource *res, > + struct power_seq_resource *res2) > +{ > + return !strcmp(res->regulator.id, res2->regulator.id); > +} > + > +static int power_seq_res_alloc_regulator(struct device *dev, > + struct power_seq_resource *res) > +{ > + res->regulator.regulator = devm_regulator_get(dev, res->regulator.id); > + if (IS_ERR(res->regulator.regulator)) { > + dev_err(dev, "cannot get regulator \"%s\"\n", > + res->regulator.id); > + return PTR_ERR(res->regulator.regulator); > + } > + > + return 0; > +} > + > +static int power_seq_step_run_regulator(struct power_seq_step *step) > +{ > + if (step->regulator.enable) > + return regulator_enable(step->resource->regulator.regulator); > + else > + return regulator_disable(step->resource->regulator.regulator); > +} > + > +#define POWER_SEQ_REGULATOR_TYPE { \ > + .name = "regulator", \ > + .of_parse = of_power_seq_parse_regulator, \ > + .step_run = power_seq_step_run_regulator, \ > + .res_compare = power_seq_res_compare_regulator, \ > + .res_alloc = power_seq_res_alloc_regulator, \ > +} > + > +#else > + > +#define POWER_SEQ_REGULATOR_TYPE {} > + > +#endif > diff --git a/include/linux/power_seq.h b/include/linux/power_seq.h > new file mode 100644 > index 0000000..21b95b6 > --- /dev/null > +++ b/include/linux/power_seq.h > @@ -0,0 +1,203 @@ > +/* > + * power_seq.h > + * > + * Simple interpreter for power sequences defined as platform data or device > + * tree properties. > + * > + * Power sequences are designed to replace the callbacks typically used in > + * board-specific files that implement board- or device- specific power > + * sequences (such as those of backlights). A power sequence is an array of > + * steps referencing resources (regulators, GPIOs, PWMs, ...) with an action to > + * perform on them. By having the power sequences interpreted, it becomes > + * possible to describe them in the device tree and thus to remove > + * board-specific files from the kernel. > + * > + * See Documentation/power/power_seqs.txt for detailed information. > + * > + * Author: Alexandre Courbot <acourbot@nvidia.com> > + * > + * Copyright (c) 2012 NVIDIA Corporation. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + */ > + > +#ifndef __LINUX_POWER_SEQ_H > +#define __LINUX_POWER_SEQ_H > + > +#include <linux/types.h> > +#include <linux/list.h> > + > +struct device; > +struct regulator; > +struct pwm_device; > + > +/** > + * The different kinds of resources that can be controlled by the sequences > + */ > +enum power_seq_res_type { > + POWER_SEQ_DELAY, > + POWER_SEQ_REGULATOR, > + POWER_SEQ_PWM, > + POWER_SEQ_GPIO, > + POWER_SEQ_NUM_TYPES, > +}; > + > +/** > + * struct power_seq_regulator_resource > + * @id: name of the regulator > + * @regulator: resolved regulator. Written during resource resolution. > + */ > +struct power_seq_regulator_resource { > + const char *id; > + struct regulator *regulator; > +}; > + > +/** > + * struct power_seq_pwm_resource > + * @id: name of the PWM > + * @regulator: resolved PWM. Written during resource resolution. > + */ > +struct power_seq_pwm_resource { > + const char *id; > + struct pwm_device *pwm; > +}; > + > +/** > + * struct power_seq_gpio_resource > + * @gpio: number of the GPIO > + * @is_set: track GPIO state to set its direction at first use > + */ > +struct power_seq_gpio_resource { > + int gpio; > + bool is_set; > +}; > + > +/** > + * struct power_seq_resource - resource used by power sequences > + * @type: type of the resource. This decides which member of the union is > + * used for this resource > + * @list: link resources together in power_seq_set > + * @regulator: used if @type == POWER_SEQ_REGULATOR > + * @pwm: used if @type == POWER_SEQ_PWM > + * @gpio: used if @type == POWER_SEQ_GPIO > + */ > +struct power_seq_resource { > + enum power_seq_res_type type; > + struct list_head list; > + union { > + struct power_seq_regulator_resource regulator; > + struct power_seq_pwm_resource pwm; > + struct power_seq_gpio_resource gpio; > + }; > +}; > +#define power_seq_for_each_resource(pos, set) \ > + list_for_each_entry(pos, &(set)->resources, list) > + > +/** > + * struct power_seq_delay_step - action data for delay steps > + * @delay: amount of time to wait, in microseconds > + */ > +struct power_seq_delay_step { > + unsigned int delay; > +}; > + > +/** > + * struct power_seq_regulator_step - platform data for regulator steps > + * @enable: whether to enable or disable the regulator during this step > + */ > +struct power_seq_regulator_step { > + bool enable; > +}; > + > +/** > + * struct power_seq_pwm_step - action data for PWM steps > + * @enable: whether to enable or disable the PWM during this step > + */ > +struct power_seq_pwm_step { > + bool enable; > +}; > + > +/** > + * struct power_seq_gpio_step - action data for GPIO steps > + * @enable: whether to enable or disable the GPIO during this step > + */ > +struct power_seq_gpio_step { > + int value; > +}; > + > +/** > + * struct power_seq_step - data for power sequences steps > + * @resource: resource used by this step > + * @delay: used if resource->type == POWER_SEQ_DELAY > + * @regulator: used if resource->type == POWER_SEQ_REGULATOR > + * @pwm: used if resource->type == POWER_SEQ_PWN > + * @gpio: used if resource->type == POWER_SEQ_GPIO > + */ > +struct power_seq_step { > + struct power_seq_resource *resource; > + union { > + struct power_seq_delay_step delay; > + struct power_seq_regulator_step regulator; > + struct power_seq_pwm_step pwm; > + struct power_seq_gpio_step gpio; > + }; > +}; > + > +struct power_seq_set; > + > +/** > + * struct power_seq - single power sequence > + * @id: name of this sequence > + * @list: link sequences together in power_seq_set. Leave as-is > + * @set: set this sequence belongs to. Written when added to a set > + * @num_steps: number of steps in the sequence > + * @steps: array of steps that make the sequence > + */ > +struct power_seq { > + const char *id; > + struct list_head list; > + struct power_seq_set *set; > + unsigned int num_steps; > + struct power_seq_step steps[]; > +}; > + > +/** > + * struct power_seq_set - power sequences and resources used by a device > + * @dev: device this set belongs to > + * @resources: list of resources used by power sequences > + * @seqs: list of power sequences > + */ > +struct power_seq_set { > + struct device *dev; > + struct list_head resources; > + struct list_head seqs; > +}; > + > +/** > + * struct platform_power_seq_set - define power sequences as platform data > + * @num_seqs: number of sequences defined > + * @seqs: array of num_seqs power sequences > + */ > +struct platform_power_seq_set { > + unsigned int num_seqs; > + struct power_seq *seqs[]; > +}; > + > +struct platform_power_seq_set *devm_of_parse_power_seq_set(struct device *dev); > +void power_seq_set_init(struct power_seq_set *set, struct device *dev); > +int power_seq_set_add_sequence(struct power_seq_set *set, > + struct power_seq *seq); > +int power_seq_set_add_sequences(struct power_seq_set *set, > + struct platform_power_seq_set *seqs); > +struct power_seq *power_seq_lookup(struct power_seq_set *seqs, const char *id); > +int power_seq_run(struct power_seq *seq); > + > +#endif -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Srinivas, On Friday 16 November 2012 15:58:29 Srinivas KANDAGATLA wrote: > Hi Alex, > I am looking forward for this feature to be mainlined, *cough* Ack *cough* :) > but I have > comment on the way the types are tied up to power seq infrastructure. > I know your use case are limited to using type "delay", "pwm" and "gpio" > and "regulator", However there are instances where the devices can be > powered up or reset by writing to special registers or sysconfs or > something else. > So My suggestion would be to make these type register them selfs > dynamically with the power_seq infrastructure so that in future this can > be extended to other types as-well. > This trivial change can make a lot of difference for the future chips > which do thing bit differently. > ST Microelectronics chips fit it in these category and I guess other > Vendors have this similar chips. The current implementation is (purposedly) minimal and will certainly be extended. There are other aspects of regulators for instance that should also be controllable (voltage comes to mind). And I am totally open to supporting new kinds of resources as usage broadens. For this first version I just wanted to introduce the feature and minimize the impact should anything (DT bindings?) need to change. I am a little bit skeptical about the purpose of directly accessing registers (or any part of the address space) from power sequences. It should at least be possible to involve some kind of abstraction. Not necessarily one of the currently supported types - but at least something. The reason is that I'd like to try and avoid direct references to resources within sequences as much as possible to make them reusable. If your system has two identical devices, you should not need to duplicate their sequences just to change a register range from the few steps that make use of it. If you can do the same job with, say, a regulator, you can just give it a name, get it at runtime using regulator_get() and define it outside of the sequence, in our device node. Of course there might be scenarios where you really need to access a register and there is no way to do otherwise, in this case I am open to discussion. But before resorting to this I'd like to make that the existing abstraction cannot cover the case already. Alex. -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 16/11/12 08:31, Alex Courbot wrote: > Hi Srinivas, > > On Friday 16 November 2012 15:58:29 Srinivas KANDAGATLA wrote: >> Hi Alex, >> I am looking forward for this feature to be mainlined, > *cough* Ack *cough* :) :-) >> but I have >> comment on the way the types are tied up to power seq infrastructure. >> I know your use case are limited to using type "delay", "pwm" and "gpio" >> and "regulator", However there are instances where the devices can be >> powered up or reset by writing to special registers or sysconfs or >> something else. >> So My suggestion would be to make these type register them selfs >> dynamically with the power_seq infrastructure so that in future this can >> be extended to other types as-well. >> This trivial change can make a lot of difference for the future chips >> which do thing bit differently. >> ST Microelectronics chips fit it in these category and I guess other >> Vendors have this similar chips. > The current implementation is (purposedly) minimal and will certainly be > extended. There are other aspects of regulators for instance that should also > be controllable (voltage comes to mind). And I am totally open to supporting > new kinds of resources as usage broadens. For this first version I just wanted > to introduce the feature and minimize the impact should anything (DT > bindings?) need to change. Ok I agree. I was thinking more of to fit few things specific to our chip via power-seqs. > > I am a little bit skeptical about the purpose of directly accessing registers > (or any part of the address space) from power sequences. It should at least be > possible to involve some kind of abstraction. Not necessarily one of the > currently supported types - but at least something. Yes, There is a level of abstraction (aka sysconf) in our case.. again it is not mainlined yet. > > The reason is that I'd like to try and avoid direct references to resources > within sequences as much as possible to make them reusable. If your system has > two identical devices, you should not need to duplicate their sequences just > to change a register range from the few steps that make use of it. If you can > do the same job with, say, a regulator, you can just give it a name, get it at > runtime using regulator_get() and define it outside of the sequence, in our > device node. > > Of course there might be scenarios where you really need to access a register > and there is no way to do otherwise, in this case I am open to discussion. But > before resorting to this I'd like to make that the existing abstraction cannot > cover the case already. yep. thanks, srini > > Alex. > > -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 11/16/2012 04:26 PM, Anton Vorontsov wrote: >> +#include "power_seq_delay.c" >> +#include "power_seq_regulator.c" >> +#include "power_seq_pwm.c" >> +#include "power_seq_gpio.c" > > This is odd, although I remember you already explained why you have to > include the .c files, instead of linking them separately. But I forgot the > reason. :) I think this deserves a comment in the code. This is because of the table right after these includes: static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES] = { [POWER_SEQ_DELAY] = POWER_SEQ_DELAY_TYPE, [POWER_SEQ_REGULATOR] = POWER_SEQ_REGULATOR_TYPE, [POWER_SEQ_PWM] = POWER_SEQ_PWM_TYPE, [POWER_SEQ_GPIO] = POWER_SEQ_GPIO_TYPE, }; The POWER_SEQ_*_TYPE macros are defined in the C files. It's the simplest way to initialize this table, and the code inside these C files is short and simple enough that I thought I would be forgiven. :) At first everything was in power_seq.c and it was fine, then I thought it would be better to move resource support code into their own filesm and now everybody is asking. :P But yeah, maybe it would be even better to not stop halfway and use dynamic linking. Comment added for the time being. ;) >> +static int of_power_seq_parse_step(struct device *dev, >> + struct device_node *node, >> + struct power_seq *seq, >> + unsigned int step_nbr, >> + struct list_head *resources) >> +{ >> + struct power_seq_step *step = &seq->steps[step_nbr]; >> + struct power_seq_resource res, *res2; >> + const char *type; >> + int i, err; > > nit: one variable declaration per line. Fair enough - but is that a convention? checkpatch.pl was happy with these. Thanks, Alex. -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Nov 16, 2012 at 06:38:21AM +0000, Alexandre Courbot wrote: > Some device drivers (e.g. panel or backlights) need to follow precise > sequences for powering on and off, involving GPIOs, regulators, PWMs > with a precise powering order and delays to respect between steps. > These sequences are device-specific, and do not belong to a particular > driver - therefore they have been performed by board-specific hook > functions to far. > > With the advent of the device tree and of ARM kernels that are not > board-tied, we cannot rely on these board-specific hooks anymore but > need a way to implement these sequences in a portable manner. This patch > introduces a simple interpreter that can execute such power sequences > encoded either as platform data or within the device tree. Given there are several ARM platforms that may have an interest in this, please consider posting this to the ARM mailing list: linux-arm-kernel@lists.infradead.org. > Signed-off-by: Alexandre Courbot <acourbot@nvidia.com> > Reviewed-by: Stephen Warren <swarren@wwwdotorg.org> > Reviewed-by: Mark Brown <broonie@opensource.wolfsonmicro.com> > --- > .../devicetree/bindings/power/power_seq.txt | 121 +++++++ > Documentation/power/power_seq.txt | 253 ++++++++++++++ > drivers/power/Kconfig | 1 + > drivers/power/Makefile | 1 + > drivers/power/power_seq/Kconfig | 2 + > drivers/power/power_seq/Makefile | 1 + > drivers/power/power_seq/power_seq.c | 376 +++++++++++++++++++++ > drivers/power/power_seq/power_seq_delay.c | 65 ++++ > drivers/power/power_seq/power_seq_gpio.c | 94 ++++++ > drivers/power/power_seq/power_seq_pwm.c | 82 +++++ > drivers/power/power_seq/power_seq_regulator.c | 83 +++++ > include/linux/power_seq.h | 203 +++++++++++ > 12 files changed, 1282 insertions(+) > create mode 100644 Documentation/devicetree/bindings/power/power_seq.txt > create mode 100644 Documentation/power/power_seq.txt > create mode 100644 drivers/power/power_seq/Kconfig > create mode 100644 drivers/power/power_seq/Makefile > create mode 100644 drivers/power/power_seq/power_seq.c > create mode 100644 drivers/power/power_seq/power_seq_delay.c > create mode 100644 drivers/power/power_seq/power_seq_gpio.c > create mode 100644 drivers/power/power_seq/power_seq_pwm.c > create mode 100644 drivers/power/power_seq/power_seq_regulator.c > create mode 100644 include/linux/power_seq.h > > diff --git a/Documentation/devicetree/bindings/power/power_seq.txt b/Documentation/devicetree/bindings/power/power_seq.txt > new file mode 100644 > index 0000000..7880a6c > --- /dev/null > +++ b/Documentation/devicetree/bindings/power/power_seq.txt > @@ -0,0 +1,121 @@ > +Runtime Interpreted Power Sequences > +=================================== > + > +Power sequences are sequential descriptions of actions to be performed on > +power-related resources. Having these descriptions in a well-defined data format > +allows us to take much of the board- or device- specific power control code out > +of the kernel and place it into the device tree instead, making kernels less > +board-dependant. > + > +A device typically makes use of multiple power sequences, for different purposes > +such as powering on and off. All the power sequences of a given device are > +grouped into a set. In the device tree, this set is a sub-node of the device > +node named "power-sequences". > + > +Power Sequences Structure > +------------------------- > +Every device that makes use of power sequences must have a "power-sequences" > +node into which individual power sequences are declared as sub-nodes. The name > +of the node becomes the name of the sequence within the power sequences > +framework. > + > +Similarly, each power sequence declares its steps as sub-nodes of itself. Steps > +must be named sequentially, with the first step named step0, the second step1, > +etc. Failure to follow this rule will result in a parsing error. Could we not encode the step number in the unit-address? i.e. step@N rather than stepN. If we ever add additional (non step) data to sequences it might make it easier to filter, as we only reserve one name rather than a class of names. > + > +Power Sequences Steps > +--------------------- > +Steps of a sequence describe an action to be performed on a resource. They > +always include a "type" property which indicates what kind of resource this > +step works on. Depending on the resource type, additional properties are defined > +to control the action to be performed. > + > +"delay" type required properties: > + - delay: delay to wait (in microseconds) > + > +"regulator" type required properties: > + - id: name of the regulator to use. > + - enable / disable: one of these two empty properties must be present to > + enable or disable the resource > + > +"pwm" type required properties: > + - id: name of the PWM to use. > + - enable / disable: one of these two empty properties must be present to > + enable or disable the resource > + > +"gpio" type required properties: > + - gpio: phandle of the GPIO to use. > + - value: value this GPIO should take. Must be 0 or 1. Is there any reason for id to be a name rather than a phandle? It seems inconsistent with the gpio case. I also see from the example below that the gpio property is not just a phandle, as it has the gpio-specifier appended. Is there a better way of describing this format in the documentation? > +Example > +------- > +Here are example sequences declared within a backlight device that use all the > +supported resources types: > + > + backlight { > + compatible = "pwm-backlight"; > + ... > + > + /* resources used by the power sequences */ > + pwms = <&pwm 2 5000000>; > + pwm-names = "backlight"; > + power-supply = <&backlight_reg>; > + > + power-sequences { > + power-on { > + step0 { > + type = "regulator"; > + id = "power"; > + enable; > + }; > + step1 { > + type = "delay"; > + delay = <10000>; > + }; > + step2 { > + type = "pwm"; > + id = "backlight"; > + enable; > + }; > + step3 { > + type = "gpio"; > + gpio = <&gpio 28 0>; > + value = <1>; > + }; > + }; > + > + power-off { > + step0 { > + type = "gpio"; > + gpio = <&gpio 28 0>; > + value = <0>; > + }; > + step1 { > + type = "pwm"; > + id = "backlight"; > + disable; > + }; > + step2 { > + type = "delay"; > + delay = <10000>; > + }; > + step3 { > + type = "regulator"; > + id = "power"; > + disable; > + }; > + }; > + }; > + }; Thanks, Mark -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Nov 16, 2012 at 06:44:22PM +0900, Alex Courbot wrote: > On 11/16/2012 04:26 PM, Anton Vorontsov wrote: > >>+#include "power_seq_delay.c" > >>+#include "power_seq_regulator.c" > >>+#include "power_seq_pwm.c" > >>+#include "power_seq_gpio.c" > > > >This is odd, although I remember you already explained why you have to > >include the .c files, instead of linking them separately. But I forgot the > >reason. :) I think this deserves a comment in the code. > > This is because of the table right after these includes: > > static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES] = { > [POWER_SEQ_DELAY] = POWER_SEQ_DELAY_TYPE, > [POWER_SEQ_REGULATOR] = POWER_SEQ_REGULATOR_TYPE, > [POWER_SEQ_PWM] = POWER_SEQ_PWM_TYPE, > [POWER_SEQ_GPIO] = POWER_SEQ_GPIO_TYPE, > }; > > The POWER_SEQ_*_TYPE macros are defined in the C files. It's the > simplest way to initialize this table, and the code inside these C > files is short and simple enough that I thought I would be forgiven. > :) I think in the header file you could just write extern ..... power_seq_delay_type; #ifndef ... #define power_seq_delay_type NULL #endif And then, in the .c file: static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES] = { [POWER_SEQ_DELAY] = power_seq_delay_type, ... }; And then you can stop including the .c files directly, and link them instead. > At first everything was in power_seq.c and it was fine, then I > thought it would be better to move resource support code into their > own filesm and now everybody is asking. :P > > But yeah, maybe it would be even better to not stop halfway and use > dynamic linking. > > Comment added for the time being. ;) > > >>+static int of_power_seq_parse_step(struct device *dev, > >>+ struct device_node *node, > >>+ struct power_seq *seq, > >>+ unsigned int step_nbr, > >>+ struct list_head *resources) > >>+{ > >>+ struct power_seq_step *step = &seq->steps[step_nbr]; > >>+ struct power_seq_resource res, *res2; > >>+ const char *type; > >>+ int i, err; > > > >nit: one variable declaration per line. > > Fair enough - but is that a convention? checkpatch.pl was happy with these. It's not a rule, although there is a small passage about it in CodingStyle file when it describes commenting style. Though, some folks choose to ignore this suggestion quite frequently, especially if variables have no comments. Often, the multiple declarations per line are used to hide ugly functions w/ tons of variables, or just to confuse the reader for the fun of it. There are exceptions, of course. E.g. int i, j, k; /* Our iterators. */ Is perfectly fine. But int i, err; At least to me seems weird, this stuff is logically disjunct. Only human can truly differentiate when the stuff "looks better" together or apart, so that's why checkpatch doesn't complain. Personally, I use this rule of thumb: when in doubt, use just one declaration per line, it is always OK. :) Thanks, Anton. -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Mark, On Fri, Nov 16, 2012 at 7:35 PM, Mark Rutland <mark.rutland@arm.com> wrote: > Given there are several ARM platforms that may have an interest in this, please > consider posting this to the ARM mailing list: > linux-arm-kernel@lists.infradead.org. That's right. New revision on the way. >> +Similarly, each power sequence declares its steps as sub-nodes of itself. Steps >> +must be named sequentially, with the first step named step0, the second step1, >> +etc. Failure to follow this rule will result in a parsing error. > > Could we not encode the step number in the unit-address? i.e. step@N rather than > stepN. That was the way I did it initially, but it has been pointed out that doing so would require to have #address-cells and #size-cells in every power sequence, as well as a "reg" property in every step (see https://lkml.org/lkml/2012/7/31/454 ). Although I'd prefer to use the @ notation too (and neither dtc nor the kernel complained when I did it), I tend to think the current solution is less burdensome than having these redundant properties. >> +"gpio" type required properties: >> + - gpio: phandle of the GPIO to use. >> + - value: value this GPIO should take. Must be 0 or 1. > > Is there any reason for id to be a name rather than a phandle? It seems > inconsistent with the gpio case. That's another long story. But to make it short, I'd like to make it possible for power sequences to be referenced and shared between devices of the same type (as everybody knows, copy/pasting is bad). If we use phandles in steps, the power sequence becomes tied to the referred resources and thus cannot be shared with another instance of the same device. On the other hand, using an identifier that is resolved at runtime (through e.g. regulator_get(device *, char *) leverages the existing frameworks and makes things more flexible. GPIO is currently the exception. It is the only framework for which you cannot currently resolve a resource from a device and an identifier. So at the moment we have to use a phandle - but we are also working with Linus Walleij to provide an alternative GPIO API that will be more like what we have for regulators/pinctrl/PWM/etc. Another problem with phandles is that some of the functions that resolve them are not publicly exported (i.e. AFAIK there is no public function that returns a regulator from a phandle - the only to obtain one is through regulator_get) > I also see from the example below that the gpio property is not just a phandle, > as it has the gpio-specifier appended. Is there a better way of describing this > format in the documentation? This is already clearly be defined in Documentation/devicetree/bindings/gpio/, isn't it? Thanks, Alex. -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Nov 16, 2012 at 9:25 PM, Anton Vorontsov <cbouatmailru@gmail.com> wrote: >> The POWER_SEQ_*_TYPE macros are defined in the C files. It's the >> simplest way to initialize this table, and the code inside these C >> files is short and simple enough that I thought I would be forgiven. >> :) > > I think in the header file you could just write > > extern ..... power_seq_delay_type; > #ifndef ... > #define power_seq_delay_type NULL > #endif > > And then, in the .c file: > > static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES] = { > [POWER_SEQ_DELAY] = power_seq_delay_type, > ... > }; > > And then you can stop including the .c files directly, and link them > instead. I have done something similar, but that avoids exporting resource ops into the header file. I am still not satisfied with it though - I'd rather have one init function per resource file that changes the pointer of the ops table from NULL to its own set of functions. That way the core could live without knowing anything about the different resources, and that would be nicer. Unfortunately modules only support one init function, so this is not doable here. >> >nit: one variable declaration per line. >> >> Fair enough - but is that a convention? checkpatch.pl was happy with these. > > It's not a rule, although there is a small passage about it in CodingStyle > file when it describes commenting style. Though, some folks choose to > ignore this suggestion quite frequently, especially if variables have no > comments. > > Often, the multiple declarations per line are used to hide ugly functions > w/ tons of variables, or just to confuse the reader for the fun of it. > > There are exceptions, of course. E.g. > > int i, j, k; /* Our iterators. */ > > Is perfectly fine. > > But > int i, err; > > At least to me seems weird, this stuff is logically disjunct. > > Only human can truly differentiate when the stuff "looks better" together > or apart, so that's why checkpatch doesn't complain. Personally, I use > this rule of thumb: when in doubt, use just one declaration per line, it > is always OK. :) That totally makes sense - thanks for the precision. Prepping another patchset with audience extended to linux-arm-kernel as Mark suggested. Alex. -- To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
diff --git a/Documentation/devicetree/bindings/power/power_seq.txt b/Documentation/devicetree/bindings/power/power_seq.txt new file mode 100644 index 0000000..7880a6c --- /dev/null +++ b/Documentation/devicetree/bindings/power/power_seq.txt @@ -0,0 +1,121 @@ +Runtime Interpreted Power Sequences +=================================== + +Power sequences are sequential descriptions of actions to be performed on +power-related resources. Having these descriptions in a well-defined data format +allows us to take much of the board- or device- specific power control code out +of the kernel and place it into the device tree instead, making kernels less +board-dependant. + +A device typically makes use of multiple power sequences, for different purposes +such as powering on and off. All the power sequences of a given device are +grouped into a set. In the device tree, this set is a sub-node of the device +node named "power-sequences". + +Power Sequences Structure +------------------------- +Every device that makes use of power sequences must have a "power-sequences" +node into which individual power sequences are declared as sub-nodes. The name +of the node becomes the name of the sequence within the power sequences +framework. + +Similarly, each power sequence declares its steps as sub-nodes of itself. Steps +must be named sequentially, with the first step named step0, the second step1, +etc. Failure to follow this rule will result in a parsing error. + +Power Sequences Steps +--------------------- +Steps of a sequence describe an action to be performed on a resource. They +always include a "type" property which indicates what kind of resource this +step works on. Depending on the resource type, additional properties are defined +to control the action to be performed. + +"delay" type required properties: + - delay: delay to wait (in microseconds) + +"regulator" type required properties: + - id: name of the regulator to use. + - enable / disable: one of these two empty properties must be present to + enable or disable the resource + +"pwm" type required properties: + - id: name of the PWM to use. + - enable / disable: one of these two empty properties must be present to + enable or disable the resource + +"gpio" type required properties: + - gpio: phandle of the GPIO to use. + - value: value this GPIO should take. Must be 0 or 1. + +Example +------- +Here are example sequences declared within a backlight device that use all the +supported resources types: + + backlight { + compatible = "pwm-backlight"; + ... + + /* resources used by the power sequences */ + pwms = <&pwm 2 5000000>; + pwm-names = "backlight"; + power-supply = <&backlight_reg>; + + power-sequences { + power-on { + step0 { + type = "regulator"; + id = "power"; + enable; + }; + step1 { + type = "delay"; + delay = <10000>; + }; + step2 { + type = "pwm"; + id = "backlight"; + enable; + }; + step3 { + type = "gpio"; + gpio = <&gpio 28 0>; + value = <1>; + }; + }; + + power-off { + step0 { + type = "gpio"; + gpio = <&gpio 28 0>; + value = <0>; + }; + step1 { + type = "pwm"; + id = "backlight"; + disable; + }; + step2 { + type = "delay"; + delay = <10000>; + }; + step3 { + type = "regulator"; + id = "power"; + disable; + }; + }; + }; + }; + +The first part lists the PWM and regulator resources used by the sequences. +These resources will be requested on behalf of the backlight device when the +sequences are built and are declared according to their own bindings (for +instance, regulators and pwms are resolved by name - note though that name +declaration is done differently by the two frameworks). + +After the resources declaration, two sequences follow for powering the backlight +on and off. Their names are specified by the pwm-backlight device bindings. Once +the sequences are built by calling devm_of_parse_power_seq_set() on the +backlight device, they can be added to a set using +power_seq_set_add_sequences(). diff --git a/Documentation/power/power_seq.txt b/Documentation/power/power_seq.txt new file mode 100644 index 0000000..8be0570 --- /dev/null +++ b/Documentation/power/power_seq.txt @@ -0,0 +1,253 @@ +Runtime Interpreted Power Sequences +=================================== + +Problem +------- +Very commonly, boards need the help of out-of-driver code to turn some of their +devices on and off. For instance, SoC boards might use a GPIO (abstracted to a +regulator or not) to control the power supply of a backlight. The GPIO that +should be used, however, as well as the exact power sequence that may also +involve other resources, is board-dependent and thus unknown to the driver. + +This was previously addressed by having hooks in the device's platform data that +are called whenever the state of the device might need a power status change. +This approach, however, introduces board-dependant code into the kernel and is +not compatible with the device tree. + +The Runtime Interpreted Power Sequences (or power sequences for short) aim at +turning this code into platform data or device tree nodes. Power sequences are +described using a simple format and run by a lightweight interpreter whenever +needed. This allows device drivers to work without power callbacks and makes the +kernel less board-dependant. + +What are Power Sequences? +------------------------- +A power sequence is an array of sequential steps describing an action to be +performed on a resource. The supported resources and actions operations are: +- delay (just wait for a given number of microseconds) +- GPIO (set to 0 or 1) +- regulator (enable or disable) +- PWM (enable or disable) + +When a power sequence is run, its steps is executed one after the other until +one step fails or the end of the sequence is reached. + +Power sequences are named, and grouped into "sets" which contain all the +sequences of a device as well as the resources they use. + +Power sequences can be declared as platform data or in the device tree. + +Platform Data Format +-------------------- +All relevant data structures for declaring power sequences are located in +include/linux/power_seq.h. + +The platform data for a device may include an instance of platform_power_seq_set +which references all the power sequences used for a device. The power sequences +reference resources in their steps, and setup the union member that corresponds +to the resource's type. Resources, similarly, have a union which relevant member +depends on their type. + +Note that the only "platform data" per se here is platform_power_seq_set. Other +structures (power_seq and power_seq_resource) will be used at runtime and thus +*must* survive initialization, so do not declare them with the __initdata +attribute. + +The following example should make it clear how the platform data for power +sequences is defined. It declares two power sequences named "power-on" and +"power-off" for a backlight device. The "power-on" sequence enables the "power" +regulator of the device, waits for 10ms, and then enables PWM "backlight" and +set GPIO 28 to 1. "power-off" does the opposite. + +struct power_seq_resource reg_res = { + .type = POWER_SEQ_REGULATOR, + .regulator.id = "power", +}; + +struct power_seq_resource gpio_res = { + .type = POWER_SEQ_GPIO, + .gpio.gpio = 28, +}; + +struct power_seq_resource pwm_res = { + .type = POWER_SEQ_PWM, + .pwm.id = "backlight", +}; + +struct power_seq_resource delay_res = { + .type = POWER_SEQ_DELAY, +}; + +struct power_seq power_on_seq = { + .id = "power-on", + .num_steps = 4, + .steps = { + { + .resource = ®_res, + .regulator.enable = true, + }, { + .resource = &delay_res, + .delay.delay = 10000, + }, { + .resource = &pwm_res, + .pwm.enable = true, + }, { + .resource = &gpio_res, + .gpio.value = 1, + }, + }, +}; + +struct power_seq power_off_seq = { + .id = "power-off", + .num_steps = 4, + .steps = { + { + .resource = &gpio_res, + .gpio.value = 0, + }, { + .resource = &pwm_res, + .pwm.enable = false, + }, { + .resource = &delay_res, + .delay.delay = 10000, + }, { + .resource = ®_res, + .regulator.enable = false, + }, + }, +}; + +struct platform_power_seq_set backlight_power_seqs __initdata = { + .num_seqs = 2, + .seqs = { + &power_on_seq, + &power_off_seq, + }, +}; + +"backlight_power_seqs" can then be passed to power_seq_set_add_sequences() in +order to add the sequences to a set and allocate all the necessary resources. +More on this later in this document. + +Device Tree +----------- +Power sequences can also be encoded as device tree nodes. The following +properties and nodes are equivalent to the platform data defined previously: + +pwms = <&pwm 2 5000000>; +pwm-names = "backlight"; +power-supply = <&vdd_bl_reg>; + +power-sequences { + power-on { + step0 { + type = "regulator"; + id = "power"; + enable; + }; + step1 { + type = "delay"; + delay = <10000>; + }; + step2 { + type = "pwm"; + id = "backlight"; + enable; + }; + step3 { + type = "gpio"; + gpio = <&gpio 28 0>; + value = <1>; + }; + }; + + power-off { + step0 { + type = "gpio"; + gpio = <&gpio 28 0>; + value = <0>; + }; + step1 { + type = "pwm"; + id = "backlight"; + disable; + }; + step2 { + type = "delay"; + delay = <10000>; + }; + step3 { + type = "regulator"; + id = "power"; + disable; + }; + }; +}; + +See Documentation/devicetree/bindings/power/power_seq.txt for the complete +syntax of the DT bindings. + +Use by Drivers and Resources Management +--------------------------------------- +Power sequences make use of resources that must be properly allocated and +managed. The power_seq_set structure manages the sequences and resources for a +particular device. A driver willing to use power sequences will thus declare one +instance of power_seq_set per device and initialize it at probe time: + +struct my_device_data { + struct device *dev; + ... + struct power_set_set power_seqs; + ... +}; + +power_seq_set_init(&my_device->power_seqs, my_device->dev); + +The power_seq_set_add_sequence() and power_seq_set_add_sequences() functions are +then used to add one or several sequences to a set. These functions will also +allocate all the resources used by the sequence(s) and make sure they are ready +to be run. All resources are allocated through devm and will thus be freed when +the set's device is removed. + + int power_seq_set_add_sequence(struct power_seq_set *set, + struct power_seq *seq); + int power_seq_set_add_sequences(struct power_seq_set *set, + struct platform_power_seq_set *seqs); + +Power sequences added to a set can then be resolved by their name using +power_seq_lookup(): + + struct power_seq *power_seq_lookup(struct power_seq_set *seqs, + const char *id); + +power_seq_lookup() returns a ready-to-run pointer to the power sequence which +name matches the id parameter. + +A retrieved power sequence can then be executed by power_seq_run: + + int power_seq_run(struct power_seq *seq); + +It returns 0 if the sequence has successfully been run, or an error code if a +problem occurred. + +Sometimes, you may want to browse the list of resources allocated for the +sequences of a device, for instance to ensure that a resource of a given type is +present. The power_seq_for_each_resource() macro does this: + + power_seq_for_each_resource(pos, seqs) + +Here "pos" will be a pointer to a struct power_seq_resource. This structure +contains the type of the resource, the information used for identifying it, and +the resolved resource itself. + +Finally, users of the device tree can obtain a platform_power_seq_set structure +built from the device's node using devm_of_parse_power_seq_set: + + struct platform_power_seq_set *devm_of_parse_power_seq_set(struct device *dev); + +The power sequences must be declared under a "power-sequences" node directly +declared under the device's node. Detailed syntax contained in Documentation/devicetree/bindings/power/power_seq.txt. As the function name +states, all memory is allocated through devm. The returned +platform_power_seq_set can be freed after being added to a set, but the +sequences themselves must be preserved until they are freed by devm. \ No newline at end of file diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig index 49a8939..f20d449 100644 --- a/drivers/power/Kconfig +++ b/drivers/power/Kconfig @@ -338,3 +338,4 @@ config AB8500_BATTERY_THERM_ON_BATCTRL endif # POWER_SUPPLY source "drivers/power/avs/Kconfig" +source "drivers/power/power_seq/Kconfig" diff --git a/drivers/power/Makefile b/drivers/power/Makefile index b949cf8..883ad4d 100644 --- a/drivers/power/Makefile +++ b/drivers/power/Makefile @@ -49,3 +49,4 @@ obj-$(CONFIG_CHARGER_MAX8997) += max8997_charger.o obj-$(CONFIG_CHARGER_MAX8998) += max8998_charger.o obj-$(CONFIG_POWER_AVS) += avs/ obj-$(CONFIG_CHARGER_SMB347) += smb347-charger.o +obj-$(CONFIG_POWER_SEQ) += power_seq/ diff --git a/drivers/power/power_seq/Kconfig b/drivers/power/power_seq/Kconfig new file mode 100644 index 0000000..3bff26e --- /dev/null +++ b/drivers/power/power_seq/Kconfig @@ -0,0 +1,2 @@ +config POWER_SEQ + bool diff --git a/drivers/power/power_seq/Makefile b/drivers/power/power_seq/Makefile new file mode 100644 index 0000000..f77a359 --- /dev/null +++ b/drivers/power/power_seq/Makefile @@ -0,0 +1 @@ +obj-$(CONFIG_POWER_SEQ) += power_seq.o diff --git a/drivers/power/power_seq/power_seq.c b/drivers/power/power_seq/power_seq.c new file mode 100644 index 0000000..255b1a0 --- /dev/null +++ b/drivers/power/power_seq/power_seq.c @@ -0,0 +1,376 @@ +/* + * power_seq.c - power sequence interpreter for platform devices and device tree + * + * Author: Alexandre Courbot <acourbot@nvidia.com> + * + * Copyright (c) 2012 NVIDIA Corporation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + */ + +#include <linux/power_seq.h> +#include <linux/module.h> +#include <linux/err.h> +#include <linux/device.h> + +#include <linux/of.h> + +#define power_seq_err(seq, step_nbr, format, ...) \ + dev_err(seq->set->dev, "%s[%d]: " format, seq->id, step_nbr, \ + ##__VA_ARGS__); + +/** + * struct power_seq_res_ops - operators for power sequences resources + * @name: Name of the resource type. Set to null when a resource + * type support is not compiled in + * @of_parse: Parse a step for this kind of resource from a device + * tree node. The result of parsing must be written into + * step step_nbr of seq + * @step_run: Run a step for this kind of resource + * @res_compare: Return true if the resource used by the resource is the + * same as the one referenced by the step, false otherwise. + * @res_alloc: Resolve and allocate a resource. Return error code if + * the resource cannot be allocated, 0 otherwise + */ +struct power_seq_res_ops { + const char *name; + int (*of_parse)(struct device_node *node, struct power_seq *seq, + unsigned int step_nbr, struct power_seq_resource *res); + int (*step_run)(struct power_seq_step *step); + bool (*res_compare)(struct power_seq_resource *res, + struct power_seq_resource *res2); + int (*res_alloc)(struct device *dev, + struct power_seq_resource *res); +}; + +static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES]; + +#ifdef CONFIG_OF +static int of_power_seq_parse_enable_properties(struct device_node *node, + struct power_seq *seq, + unsigned int step_nbr, + bool *enable) +{ + if (of_find_property(node, "enable", NULL)) { + *enable = true; + } else if (of_find_property(node, "disable", NULL)) { + *enable = false; + } else { + power_seq_err(seq, step_nbr, + "missing enable or disable property\n"); + return -EINVAL; + } + + return 0; +} + +static int of_power_seq_parse_step(struct device *dev, + struct device_node *node, + struct power_seq *seq, + unsigned int step_nbr, + struct list_head *resources) +{ + struct power_seq_step *step = &seq->steps[step_nbr]; + struct power_seq_resource res, *res2; + const char *type; + int i, err; + + err = of_property_read_string(node, "type", &type); + if (err < 0) { + power_seq_err(seq, step_nbr, "cannot read type property\n"); + return err; + } + for (i = 0; i < POWER_SEQ_NUM_TYPES; i++) { + if (power_seq_ops[i].name == NULL) + continue; + if (!strcmp(type, power_seq_ops[i].name)) + break; + } + if (i >= POWER_SEQ_NUM_TYPES) { + power_seq_err(seq, step_nbr, "unknown type %s\n", type); + return -EINVAL; + } + memset(&res, 0, sizeof(res)); + res.type = i; + err = power_seq_ops[res.type].of_parse(node, seq, step_nbr, &res); + if (err < 0) + return err; + + /* Use the same instance of the resource if met before */ + list_for_each_entry(res2, resources, list) { + if (res.type == res2->type && + power_seq_ops[res.type].res_compare(&res, res2)) + break; + } + /* Resource never met before, create it */ + if (&res2->list == resources) { + res2 = devm_kzalloc(dev, sizeof(*res2), GFP_KERNEL); + if (!res2) + return -ENOMEM; + memcpy(res2, &res, sizeof(res)); + list_add_tail(&res2->list, resources); + } + step->resource = res2; + + return 0; +} + +static struct power_seq *of_parse_power_seq(struct device *dev, + struct device_node *node, + struct list_head *resources) +{ + struct device_node *child = NULL; + struct power_seq *pseq; + int num_steps, sz; + int err; + + if (!node) + return ERR_PTR(-EINVAL); + + num_steps = of_get_child_count(node); + sz = sizeof(*pseq) + sizeof(pseq->steps[0]) * num_steps; + pseq = devm_kzalloc(dev, sz, GFP_KERNEL); + if (!pseq) + return ERR_PTR(-ENOMEM); + pseq->id = node->name; + pseq->num_steps = num_steps; + + for_each_child_of_node(node, child) { + unsigned int pos; + + /* Check that the name's format is correct and within bounds */ + if (strncmp("step", child->name, 4)) { + err = -EINVAL; + goto parse_error; + } + + err = kstrtouint(child->name + 4, 10, &pos); + if (err < 0) + goto parse_error; + + /* Invalid step index or step already parsed? */ + if (pos >= num_steps || pseq->steps[pos].resource != NULL) { + err = -EINVAL; + goto parse_error; + } + + err = of_power_seq_parse_step(dev, child, pseq, pos, resources); + if (err) + return ERR_PTR(err); + } + + return pseq; + +parse_error: + dev_err(dev, "%s: invalid power step name %s!\n", pseq->id, + child->name); + return ERR_PTR(err); +} + +/** + * devm_of_parse_power_seq_set - build a power_seq_set from the device tree + * @dev: Device to parse the power sequences of + * + * Sequences must be contained into a subnode named "power-sequences" of the + * device root node. + * + * Memory for the sequence is allocated using devm_kzalloc on dev. The returned + * platform_power_seq_set can be freed by devm_kfree after the sequences have + * been added, but the sequences themselves must be preserved. + * + * Returns the built set on success, or an error code in case of failure. + */ +struct platform_power_seq_set *devm_of_parse_power_seq_set(struct device *dev) +{ + struct platform_power_seq_set *set; + struct device_node *root = dev->of_node; + struct device_node *seq; + struct list_head resources; + int n, sz; + + if (!root) + return NULL; + + root = of_find_node_by_name(root, "power-sequences"); + if (!root) + return NULL; + + n = of_get_child_count(root); + sz = sizeof(*set) + sizeof(struct power_seq *) * n; + set = devm_kzalloc(dev, sz, GFP_KERNEL); + if (!set) + return ERR_PTR(-ENOMEM); + set->num_seqs = n; + + n = 0; + INIT_LIST_HEAD(&resources); + for_each_child_of_node(root, seq) { + struct power_seq *pseq; + + pseq = of_parse_power_seq(dev, seq, &resources); + if (IS_ERR(pseq)) + return (void *)pseq; + + set->seqs[n++] = pseq; + } + + return set; +} +EXPORT_SYMBOL_GPL(devm_of_parse_power_seq_set); +#endif /* CONFIG_OF */ + +/** + * power_seq_set_init - initialize a power_seq_set + * @set: Set to initialize + * @dev: Device this set is going to belong to + */ +void power_seq_set_init(struct power_seq_set *set, struct device *dev) +{ + set->dev = dev; + INIT_LIST_HEAD(&set->resources); + INIT_LIST_HEAD(&set->seqs); +} +EXPORT_SYMBOL_GPL(power_seq_set_init); + +/** + * power_seq_add_sequence - add a power sequence to a set + * @set: Set to add the sequence to + * @seq: Sequence to add + * + * This step will check that all the resources used by the sequence are + * allocated. If they are not, an attempt to allocate them is made. This + * operation can fail and and return an error code. + * + * Returns 0 on success, error code if a resource initialization failed. + */ +int power_seq_add_sequence(struct power_seq_set *set, struct power_seq *seq) +{ + struct power_seq_resource *res; + int i, err; + + for (i = 0; i < seq->num_steps; i++) { + struct power_seq_step *step = &seq->steps[i]; + struct power_seq_resource *step_res = step->resource; + list_for_each_entry(res, &set->resources, list) { + if (res == step_res) + break; + } + /* resource not allocated yet, allocate and add it */ + if (&res->list == &set->resources) { + err = power_seq_ops[step_res->type].res_alloc(set->dev, + step_res); + if (err) + return err; + list_add_tail(&step->resource->list, &set->resources); + } + } + + list_add_tail(&seq->list, &set->seqs); + seq->set = set; + + return 0; +} +EXPORT_SYMBOL_GPL(power_seq_add_sequence); + +/** + * power_seq_add_sequences - add power sequences defined as platform data + * @set: Set to add the sequences to + * @seqs: Sequences to add + * + * See power_seq_add_sequence for more details. + * + * Returns 0 on success, error code if a resource initialization failed. + */ +int power_seq_set_add_sequences(struct power_seq_set *set, + struct platform_power_seq_set *seqs) +{ + int i, ret; + + for (i = 0; i < seqs->num_seqs; i++) { + ret = power_seq_add_sequence(set, seqs->seqs[i]); + if (ret < 0) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(power_seq_set_add_sequences); + +/** + * power_seq_lookup - Lookup a power sequence by name from a set + * @seqs: The set to look in + * @id: Name to look after + * + * Returns a matching power sequence if it exists, NULL if it does not. + */ +struct power_seq *power_seq_lookup(struct power_seq_set *set, const char *id) +{ + struct power_seq *seq; + + list_for_each_entry(seq, &set->seqs, list) { + if (!strcmp(seq->id, id)) + return seq; + } + + return NULL; +} +EXPORT_SYMBOL_GPL(power_seq_lookup); + +/** + * power_seq_run() - run a power sequence + * @seq: The power sequence to run + * + * Returns 0 on success, error code in case of failure. + */ +int power_seq_run(struct power_seq *seq) +{ + unsigned int i; + int err; + + if (!seq) + return 0; + + if (!seq->set) { + pr_err("cannot run a sequence not added to a set"); + return -EINVAL; + } + + for (i = 0; i < seq->num_steps; i++) { + unsigned int type = seq->steps[i].resource->type; + + err = power_seq_ops[type].step_run(&seq->steps[i]); + if (err) { + power_seq_err(seq, i, + "error %d while running power sequence step\n", + err); + return err; + } + } + + return 0; +} +EXPORT_SYMBOL_GPL(power_seq_run); + +#include "power_seq_delay.c" +#include "power_seq_regulator.c" +#include "power_seq_pwm.c" +#include "power_seq_gpio.c" + +static const struct power_seq_res_ops power_seq_ops[POWER_SEQ_NUM_TYPES] = { + [POWER_SEQ_DELAY] = POWER_SEQ_DELAY_TYPE, + [POWER_SEQ_REGULATOR] = POWER_SEQ_REGULATOR_TYPE, + [POWER_SEQ_PWM] = POWER_SEQ_PWM_TYPE, + [POWER_SEQ_GPIO] = POWER_SEQ_GPIO_TYPE, +}; + +MODULE_AUTHOR("Alexandre Courbot <acourbot@nvidia.com>"); +MODULE_DESCRIPTION("Runtime Interpreted Power Sequences"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/power/power_seq/power_seq_delay.c b/drivers/power/power_seq/power_seq_delay.c new file mode 100644 index 0000000..5bb0a46 --- /dev/null +++ b/drivers/power/power_seq/power_seq_delay.c @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2012 NVIDIA Corporation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + */ + +#include <linux/delay.h> + +#ifdef CONFIG_OF +static int of_power_seq_parse_delay(struct device_node *node, + struct power_seq *seq, + unsigned int step_nbr, + struct power_seq_resource *res) +{ + struct power_seq_step *step = &seq->steps[step_nbr]; + int err; + + err = of_property_read_u32(node, "delay", + &step->delay.delay); + if (err < 0) + power_seq_err(seq, step_nbr, "error reading delay property\n"); + + return err; +} +#else +#define of_power_seq_parse_delay NULL +#endif + +static bool power_seq_res_compare_delay(struct power_seq_resource *res, + struct power_seq_resource *res2) +{ + /* Delay resources are just here to hold the type of steps, so they are + * all equivalent. */ + return true; +} + +static int power_seq_res_alloc_delay(struct device *dev, + struct power_seq_resource *res) +{ + return 0; +} + +static int power_seq_step_run_delay(struct power_seq_step *step) +{ + usleep_range(step->delay.delay, + step->delay.delay + 1000); + + return 0; +} + +#define POWER_SEQ_DELAY_TYPE { \ + .name = "delay", \ + .of_parse = of_power_seq_parse_delay, \ + .step_run = power_seq_step_run_delay, \ + .res_compare = power_seq_res_compare_delay, \ + .res_alloc = power_seq_res_alloc_delay, \ +} diff --git a/drivers/power/power_seq/power_seq_gpio.c b/drivers/power/power_seq/power_seq_gpio.c new file mode 100644 index 0000000..028a4cc --- /dev/null +++ b/drivers/power/power_seq/power_seq_gpio.c @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2012 NVIDIA Corporation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + */ + +#include <linux/gpio.h> +#include <linux/of_gpio.h> + +#ifdef CONFIG_OF +static int of_power_seq_parse_gpio(struct device_node *node, + struct power_seq *seq, + unsigned int step_nbr, + struct power_seq_resource *res) +{ + struct power_seq_step *step = &seq->steps[step_nbr]; + int gpio; + int err; + + gpio = of_get_named_gpio(node, "gpio", 0); + if (gpio < 0) { + power_seq_err(seq, step_nbr, "error reading gpio property\n"); + return gpio; + } + res->gpio.gpio = gpio; + + err = of_property_read_u32(node, "value", &step->gpio.value); + if (err < 0) { + power_seq_err(seq, step_nbr, "error reading value property\n"); + } else if (step->gpio.value < 0 || step->gpio.value > 1) { + power_seq_err(seq, step_nbr, + "value out of range (must be 0 or 1)\n"); + err = -EINVAL; + } + + return err; +} +#else +#define of_power_seq_parse_gpio NULL +#endif + +static bool power_seq_res_compare_gpio(struct power_seq_resource *res, + struct power_seq_resource *res2) +{ + return res->gpio.gpio == res2->gpio.gpio; +} + +static int power_seq_res_alloc_gpio(struct device *dev, + struct power_seq_resource *res) +{ + int err; + + err = devm_gpio_request(dev, res->gpio.gpio, dev_name(dev)); + if (err) { + dev_err(dev, "cannot get gpio %d\n", res->gpio.gpio); + return err; + } + + return 0; +} + +static int power_seq_step_run_gpio(struct power_seq_step *step) +{ + struct power_seq_resource *res = step->resource; + + /* set the GPIO direction at first use */ + if (!res->gpio.is_set) { + int err = gpio_direction_output(res->gpio.gpio, + step->gpio.value); + if (err) + return err; + res->gpio.is_set = true; + } else { + gpio_set_value_cansleep(res->gpio.gpio, step->gpio.value); + } + + return 0; +} + +#define POWER_SEQ_GPIO_TYPE { \ + .name = "gpio", \ + .of_parse = of_power_seq_parse_gpio, \ + .step_run = power_seq_step_run_gpio, \ + .res_compare = power_seq_res_compare_gpio, \ + .res_alloc = power_seq_res_alloc_gpio, \ +} diff --git a/drivers/power/power_seq/power_seq_pwm.c b/drivers/power/power_seq/power_seq_pwm.c new file mode 100644 index 0000000..e61acdd --- /dev/null +++ b/drivers/power/power_seq/power_seq_pwm.c @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2012 NVIDIA Corporation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + */ + +#ifdef CONFIG_PWM + +#include <linux/pwm.h> + +#ifdef CONFIG_OF +static int of_power_seq_parse_pwm(struct device_node *node, + struct power_seq *seq, + unsigned int step_nbr, + struct power_seq_resource *res) +{ + struct power_seq_step *step = &seq->steps[step_nbr]; + int err; + + err = of_property_read_string(node, "id", &res->pwm.id); + if (err) { + power_seq_err(seq, step_nbr, "error reading id property\n"); + return err; + } + + err = of_power_seq_parse_enable_properties(node, seq, step_nbr, + &step->pwm.enable); + return err; +} +#else +#define of_power_seq_parse_pwm NULL +#endif + +static bool power_seq_res_compare_pwm(struct power_seq_resource *res, + struct power_seq_resource *res2) +{ + return !strcmp(res->pwm.id, res2->pwm.id); +} + +static int power_seq_res_alloc_pwm(struct device *dev, + struct power_seq_resource *res) +{ + res->pwm.pwm = devm_pwm_get(dev, res->pwm.id); + if (IS_ERR(res->pwm.pwm)) { + dev_err(dev, "cannot get pwm \"%s\"\n", res->pwm.id); + return PTR_ERR(res->pwm.pwm); + } + + return 0; +} + +static int power_seq_step_run_pwm(struct power_seq_step *step) +{ + if (step->pwm.enable) { + return pwm_enable(step->resource->pwm.pwm); + } else { + pwm_disable(step->resource->pwm.pwm); + return 0; + } +} + +#define POWER_SEQ_PWM_TYPE { \ + .name = "pwm", \ + .of_parse = of_power_seq_parse_pwm, \ + .step_run = power_seq_step_run_pwm, \ + .res_compare = power_seq_res_compare_pwm, \ + .res_alloc = power_seq_res_alloc_pwm, \ +} + +#else + +#define POWER_SEQ_PWM_TYPE {} + +#endif diff --git a/drivers/power/power_seq/power_seq_regulator.c b/drivers/power/power_seq/power_seq_regulator.c new file mode 100644 index 0000000..2025155 --- /dev/null +++ b/drivers/power/power_seq/power_seq_regulator.c @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2012 NVIDIA Corporation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + */ + +#ifdef CONFIG_REGULATOR + +#include <linux/regulator/consumer.h> + +#ifdef CONFIG_OF +static int of_power_seq_parse_regulator(struct device_node *node, + struct power_seq *seq, + unsigned int step_nbr, + struct power_seq_resource *res) +{ + struct power_seq_step *step = &seq->steps[step_nbr]; + int err; + + err = of_property_read_string(node, "id", + &res->regulator.id); + if (err) { + power_seq_err(seq, step_nbr, "error reading id property\n"); + return err; + } + + err = of_power_seq_parse_enable_properties(node, seq, step_nbr, + &step->regulator.enable); + return err; +} +#else +#define of_power_seq_parse_regulator NULL +#endif + +static bool +power_seq_res_compare_regulator(struct power_seq_resource *res, + struct power_seq_resource *res2) +{ + return !strcmp(res->regulator.id, res2->regulator.id); +} + +static int power_seq_res_alloc_regulator(struct device *dev, + struct power_seq_resource *res) +{ + res->regulator.regulator = devm_regulator_get(dev, res->regulator.id); + if (IS_ERR(res->regulator.regulator)) { + dev_err(dev, "cannot get regulator \"%s\"\n", + res->regulator.id); + return PTR_ERR(res->regulator.regulator); + } + + return 0; +} + +static int power_seq_step_run_regulator(struct power_seq_step *step) +{ + if (step->regulator.enable) + return regulator_enable(step->resource->regulator.regulator); + else + return regulator_disable(step->resource->regulator.regulator); +} + +#define POWER_SEQ_REGULATOR_TYPE { \ + .name = "regulator", \ + .of_parse = of_power_seq_parse_regulator, \ + .step_run = power_seq_step_run_regulator, \ + .res_compare = power_seq_res_compare_regulator, \ + .res_alloc = power_seq_res_alloc_regulator, \ +} + +#else + +#define POWER_SEQ_REGULATOR_TYPE {} + +#endif diff --git a/include/linux/power_seq.h b/include/linux/power_seq.h new file mode 100644 index 0000000..21b95b6 --- /dev/null +++ b/include/linux/power_seq.h @@ -0,0 +1,203 @@ +/* + * power_seq.h + * + * Simple interpreter for power sequences defined as platform data or device + * tree properties. + * + * Power sequences are designed to replace the callbacks typically used in + * board-specific files that implement board- or device- specific power + * sequences (such as those of backlights). A power sequence is an array of + * steps referencing resources (regulators, GPIOs, PWMs, ...) with an action to + * perform on them. By having the power sequences interpreted, it becomes + * possible to describe them in the device tree and thus to remove + * board-specific files from the kernel. + * + * See Documentation/power/power_seqs.txt for detailed information. + * + * Author: Alexandre Courbot <acourbot@nvidia.com> + * + * Copyright (c) 2012 NVIDIA Corporation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + */ + +#ifndef __LINUX_POWER_SEQ_H +#define __LINUX_POWER_SEQ_H + +#include <linux/types.h> +#include <linux/list.h> + +struct device; +struct regulator; +struct pwm_device; + +/** + * The different kinds of resources that can be controlled by the sequences + */ +enum power_seq_res_type { + POWER_SEQ_DELAY, + POWER_SEQ_REGULATOR, + POWER_SEQ_PWM, + POWER_SEQ_GPIO, + POWER_SEQ_NUM_TYPES, +}; + +/** + * struct power_seq_regulator_resource + * @id: name of the regulator + * @regulator: resolved regulator. Written during resource resolution. + */ +struct power_seq_regulator_resource { + const char *id; + struct regulator *regulator; +}; + +/** + * struct power_seq_pwm_resource + * @id: name of the PWM + * @regulator: resolved PWM. Written during resource resolution. + */ +struct power_seq_pwm_resource { + const char *id; + struct pwm_device *pwm; +}; + +/** + * struct power_seq_gpio_resource + * @gpio: number of the GPIO + * @is_set: track GPIO state to set its direction at first use + */ +struct power_seq_gpio_resource { + int gpio; + bool is_set; +}; + +/** + * struct power_seq_resource - resource used by power sequences + * @type: type of the resource. This decides which member of the union is + * used for this resource + * @list: link resources together in power_seq_set + * @regulator: used if @type == POWER_SEQ_REGULATOR + * @pwm: used if @type == POWER_SEQ_PWM + * @gpio: used if @type == POWER_SEQ_GPIO + */ +struct power_seq_resource { + enum power_seq_res_type type; + struct list_head list; + union { + struct power_seq_regulator_resource regulator; + struct power_seq_pwm_resource pwm; + struct power_seq_gpio_resource gpio; + }; +}; +#define power_seq_for_each_resource(pos, set) \ + list_for_each_entry(pos, &(set)->resources, list) + +/** + * struct power_seq_delay_step - action data for delay steps + * @delay: amount of time to wait, in microseconds + */ +struct power_seq_delay_step { + unsigned int delay; +}; + +/** + * struct power_seq_regulator_step - platform data for regulator steps + * @enable: whether to enable or disable the regulator during this step + */ +struct power_seq_regulator_step { + bool enable; +}; + +/** + * struct power_seq_pwm_step - action data for PWM steps + * @enable: whether to enable or disable the PWM during this step + */ +struct power_seq_pwm_step { + bool enable; +}; + +/** + * struct power_seq_gpio_step - action data for GPIO steps + * @enable: whether to enable or disable the GPIO during this step + */ +struct power_seq_gpio_step { + int value; +}; + +/** + * struct power_seq_step - data for power sequences steps + * @resource: resource used by this step + * @delay: used if resource->type == POWER_SEQ_DELAY + * @regulator: used if resource->type == POWER_SEQ_REGULATOR + * @pwm: used if resource->type == POWER_SEQ_PWN + * @gpio: used if resource->type == POWER_SEQ_GPIO + */ +struct power_seq_step { + struct power_seq_resource *resource; + union { + struct power_seq_delay_step delay; + struct power_seq_regulator_step regulator; + struct power_seq_pwm_step pwm; + struct power_seq_gpio_step gpio; + }; +}; + +struct power_seq_set; + +/** + * struct power_seq - single power sequence + * @id: name of this sequence + * @list: link sequences together in power_seq_set. Leave as-is + * @set: set this sequence belongs to. Written when added to a set + * @num_steps: number of steps in the sequence + * @steps: array of steps that make the sequence + */ +struct power_seq { + const char *id; + struct list_head list; + struct power_seq_set *set; + unsigned int num_steps; + struct power_seq_step steps[]; +}; + +/** + * struct power_seq_set - power sequences and resources used by a device + * @dev: device this set belongs to + * @resources: list of resources used by power sequences + * @seqs: list of power sequences + */ +struct power_seq_set { + struct device *dev; + struct list_head resources; + struct list_head seqs; +}; + +/** + * struct platform_power_seq_set - define power sequences as platform data + * @num_seqs: number of sequences defined + * @seqs: array of num_seqs power sequences + */ +struct platform_power_seq_set { + unsigned int num_seqs; + struct power_seq *seqs[]; +}; + +struct platform_power_seq_set *devm_of_parse_power_seq_set(struct device *dev); +void power_seq_set_init(struct power_seq_set *set, struct device *dev); +int power_seq_set_add_sequence(struct power_seq_set *set, + struct power_seq *seq); +int power_seq_set_add_sequences(struct power_seq_set *set, + struct platform_power_seq_set *seqs); +struct power_seq *power_seq_lookup(struct power_seq_set *seqs, const char *id); +int power_seq_run(struct power_seq *seq); + +#endif