pinctrl single support for SoC specific features

Let's replace is_pinconf with flags and add struct pcs_soc so we can support also other features like pin wake-up events. Let's export the probe so the SoC specific modules can pass their SoC specific data to pinctrl-single if needed.

Done in collaboration with Roger Quadros <[email protected]>.

Cc Haojian Zhuang <[email protected]>

Cc Peter Ujfalusi <[email protected]>

Cc devicetree-discuss at lists.ozlabs.org

Signed-off-by Roger Quadros <[email protected]>

Signed-off-by Tony Lindgren <[email protected]>

---
 drivers/pinctrl/pinctrl-single.c |   53 +++++++++++++++++++++++++++-----------
 drivers/pinctrl/pinctrl-single.h |   15 +++++++++++
 2 files changed, 52 insertions(+), 16 deletions(-)
 create mode 100644 drivers/pinctrl/pinctrl-single.h

drivers/pinctrl/pinctrl-single.c +5 -2

index b9fa046..0f178d1 100644
@@ -1368,7 +1367,8 @@ static int pcs_probe(struct platform_device *pdev)
        INIT_LIST_HEAD(&pcs->pingroups);
        INIT_LIST_HEAD(&pcs->functions);
        INIT_LIST_HEAD(&pcs->gpiofuncs);
-       pcs->is_pinconf = match->data;
+       pcs->flags = soc->flags;
+       pcs->soc = soc;
 
        PCS_GET_PROP_U32("pinctrl-single,register-width", &pcs->width,
                         "register width not specified\n");

@@ -1437,7 +1437,7 @@ static int pcs_probe(struct platform_device *pdev)
        pcs->desc.name = DRIVER_NAME;
        pcs->desc.pctlops = &pcs_pinctrl_ops;
        pcs->desc.pmxops = &pcs_pinmux_ops;
-       if (pcs->is_pinconf)
+       if (pcs->flags & PCS_HAS_PINCONF)
                pcs->desc.confops = &pcs_pinconf_ops;
        pcs->desc.owner = THIS_MODULE;
 

@@ -1466,8 +1466,20 @@ free:
 
        return ret;
 }
+EXPORT_SYMBOL_GPL(pinctrl_single_probe);
+

drivers/pinctrl/pinctrl-single.h new file +15 -0

+#define PCS_HAS_PINCONF         (1 << 0)
+
+/**
+ * struct pcs_soc - SoC specific interface to pinctrl-single
+ * @data:      SoC specific data pointer
+ * @flags:     mask of PCS_HAS_xxx values
+ */
+struct pcs_soc {
+       void *data;
+       unsigned flags;
+};
+
+extern int pinctrl_single_probe(struct platform_device *pdev,
+                               const struct pcs_soc *soc);
+extern int pinctrl_single_remove(struct platform_device *pdev);

Manjunathappa's pinctrl-single patch on enhancing bits is already merged. This patch conflicts with his patch.

Could you rebase your patches?

Quoted 5 lines · Haojian Zhuang

Manjunathappa's pinctrl-single patch on enhancing bits is already merged. This patch conflicts with his patch.

Could you rebase your patches?

Sure. Looks like Linus W forgot to push out the branch as I don't see it yet in the pinctrl tree. Here's a version of this one against current Linux next + Manjunathappa's patches.

Regards,

Tony

Subject: [PATCH] pinctrl: single: Prepare for supporting SoC specific features

Let's replace is_pinconf with flags and add struct pcs_soc so we can support also other features like pin wake-up events. Let's export the probe so the SoC specific modules can pass their SoC specific data to pinctrl-single if needed.

Quoted 6 lines · Tony Lindgren

Subject: [PATCH] pinctrl: single: Prepare for supporting SoC specific features

Let's replace is_pinconf with flags and add struct pcs_soc so we can support also other features like pin wake-up events. Let's export the probe so the SoC specific modules can pass their SoC specific data to pinctrl-single if needed.

I don't quite understand this motivation. Can this be more verbose and include a bit about the mechanics?

- Why is this necessary? For example, pinctrl-single already supports generic pinconf, and we can surely add a PIN_CONFIG_WAKEUP to include/linux/pinctrl/pinconf-generic.h.

- Also: how does this cooperate with irq_set_wake()? If a pin is set to GPIO it is often backed by a GPIO driver (which is calling pinctrl_request_gpio() etc), maybe we should just add a pinctrl_set_wake() then that the irqchip portions of the GPIO drivers can call down to so the pinctrl driver sets this bit if need be?

At least on omaps, each board typically has at least one device configured as wake-up capable from deeper idle modes. In the deeper idle modes the normal interrupt wake-up path won't work as the logic is powered off and separate wake-up hardware is available either via IO ring or GPIO hardware. The wake-up event can be device specific, or may need to be dynamically remuxed to GPIO input for wake-up events. When the wake-up event happens, it's IRQ need to be called so the device won't lose interrupts.

Allow supporting IRQ and GPIO wake-up events if a hardware spefific module is registered for the enable and disable calls.

Done in collaboration with Roger Quadros <[email protected]>.

Cc Haojian Zhuang <[email protected]>

Cc Peter Ujfalusi <[email protected]>

Cc devicetree-discuss at lists.ozlabs.org

Signed-off-by Roger Quadros <[email protected]>

Signed-off-by Tony Lindgren <[email protected]>

---
 .../devicetree/bindings/pinctrl/pinctrl-single.txt |    5 +
 drivers/pinctrl/pinctrl-single.c                   |  104 +++++++++++++++++---
 drivers/pinctrl/pinctrl-single.h                   |   28 +++++
 3 files changed, 123 insertions(+), 14 deletions(-)

Documentation/devicetree/bindings/pinctrl/pinctrl-single.txt +5 -0

index 08f0c3d..5dfd74b 100644
@@ -68,6 +68,10 @@ Optional properties:
   The number of parameters is depend on #pinctrl-single,gpio-range-cells
   property.
 
+- interrrupts : the interrupt that a function may have for a wake-up event
+
+- gpios: the gpio that a function may have for a wake-up event
+
                /* pin base, nr pins & gpio function */
                pinctrl-single,gpio-range = <&range 0 3 0 &range 3 9 1>;
 

@@ -204,6 +208,7 @@ pmx_gpio: pinmux at d401e000 {
                        0xdc 0x118
                        0xde 0
                >;
+               interrupts = <74>;
        };
 };
 

drivers/pinctrl/pinctrl-single.c +51 -14

index 0f178d1..7cb7940 100644
@@ -19,6 +19,8 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_address.h>
+#include <linux/of_gpio.h>
+#include <linux/of_irq.h>
 
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/pinctrl/pinmux.h>

@@ -95,6 +97,8 @@ struct pcs_conf_type {
  * @nvals:     number of entries in vals array
  * @pgnames:   array of pingroup names the function uses
  * @npgnames:  number of pingroup names the function uses
+ * @irq:       optional irq associated with the function
+ * @gpio:      optional gpio associated with the function
  * @node:      list node
  */
 struct pcs_function {

@@ -105,6 +109,8 @@ struct pcs_function {
        int npgnames;
        struct pcs_conf_vals *conf;
        int nconfs;
+       int irq;
+       int gpio;
        struct list_head node;
 };
 

@@ -410,6 +416,18 @@ static int pcs_get_function(struct pinctrl_dev *pctldev, unsigned pin,
        return 0;
 }
 
+static void pcs_reg_init(struct pcs_reg *p, struct pcs_device *pcs,
+                        struct pcs_function *func,
+                        void __iomem *reg, unsigned val)
+{
+       p->read = pcs->read;
+       p->write = pcs->write;
+       p->irq = func->irq;
+       p->gpio = func->gpio;
+       p->reg = reg;
+       p->val = val;
+}
+
 static int pcs_enable(struct pinctrl_dev *pctldev, unsigned fselector,
        unsigned group)
 {

@@ -442,6 +460,12 @@ static int pcs_enable(struct pinctrl_dev *pctldev, unsigned fselector,
                val &= ~mask;
                val |= (vals->val & mask);
                pcs->write(val, vals->reg);
+               if ((func->irq || func->gpio) && pcs->soc && pcs->soc->enable) {
+                       struct pcs_reg pcsr;
+
+                       pcs_reg_init(&pcsr, pcs, func, vals->reg, val);
+                       pcs->soc->enable(pcs->soc, &pcsr);
+               }
        }
 
        return 0;

@@ -466,18 +490,6 @@ static void pcs_disable(struct pinctrl_dev *pctldev, unsigned fselector,
                return;
        }
 
-       /*
-        * Ignore disable if function-off is not specified. Some hardware
-        * does not have clearly defined disable function. For pin specific
-        * off modes, you can use alternate named states as described in
-        * pinctrl-bindings.txt.
-        */
-       if (pcs->foff == PCS_OFF_DISABLED) {
-               dev_dbg(pcs->dev, "ignoring disable for %s function%i\n",
-                       func->name, fselector);
-               return;
-       }
-
        dev_dbg(pcs->dev, "disabling function%i %s\n",
                fselector, func->name);
 

@@ -488,8 +500,28 @@ static void pcs_disable(struct pinctrl_dev *pctldev, unsigned fselector,
                vals = &func->vals[i];
                val = pcs->read(vals->reg);
                val &= ~pcs->fmask;
-               val |= pcs->foff << pcs->fshift;
-               pcs->write(val, vals->reg);
+
+               /*
+                * Ignore disable if function-off is not specified. Some
+                * hardware does not have clearly defined disable function.
+                * For pin specific off modes, you can use alternate named
+                * states as described in pinctrl-bindings.txt.
+                */
+               if (pcs->foff == PCS_OFF_DISABLED) {
+                       dev_dbg(pcs->dev, "ignoring disable for %s function%i\n",
+                               func->name, fselector);
+               } else {
+                       val |= pcs->foff << pcs->fshift;
+                       pcs->write(val, vals->reg);
+               }
+
+               if ((func->irq || func->gpio) &&
+                   pcs->soc && pcs->soc->disable) {
+                       struct pcs_reg pcsr;
+
+                       pcs_reg_init(&pcsr, pcs, func, vals->reg, val);
+                       pcs->soc->disable(pcs->soc, &pcsr);
+               }
        }
 }
 

@@ -1007,6 +1039,32 @@ static void pcs_add_conf4(struct pcs_device *pcs, struct device_node *np,
        add_setting(settings, param, ret);
 }
 
+static int pcs_parse_wakeup(struct pcs_device *pcs, struct device_node *np,
+                            struct pcs_function *function)
+{
+       struct pcs_reg pcsr;
+       int i, ret = 0;

drivers/pinctrl/pinctrl-single.c +29 -0

+
+               pcs_reg_init(&pcsr, pcs, function, vals->reg,
+                            vals->val & mask);
+               ret = pcs->soc->reg_init(pcs->soc, &pcsr);
+               if (ret)
+                       break;
+       }
+
+       return ret;
+}
+
 static int pcs_parse_pinconf(struct pcs_device *pcs, struct device_node *np,
                             struct pcs_function *func,
                             struct pinctrl_map **map)

@@ -1176,6 +1234,24 @@ static int pcs_parse_one_pinctrl_entry(struct pcs_device *pcs,
        } else {
                *num_maps = 1;
        }
+
+       if (pcs->flags & PCS_HAS_FUNCTION_IRQ)
+               function->irq = irq_of_parse_and_map(np, 0);
+
+       if (pcs->flags & PCS_HAS_FUNCTION_GPIO) {
+               function->gpio = of_get_gpio(np, 0);
+               if (function->gpio > 0 && !function->irq) {
+                       if (gpio_is_valid(function->gpio))
+                               function->irq = gpio_to_irq(function->gpio);
+               }
+       }
+
+       if (function->irq > 0 && pcs->soc && pcs->soc->reg_init) {
+               res = pcs_parse_wakeup(pcs, np, function);
+               if (res)
+                       goto free_pingroups;
+       }
+
        return 0;
 
 free_pingroups:

drivers/pinctrl/pinctrl-single.h +25 -0

index 18f3205..c2dcc7a 100644
@@ -1,13 +1,41 @@
+/**
+ * struct pcs_reg - pinctrl register
+ * @read:      pinctrl-single provided register read function
+ * @write:     pinctrl-single provided register write function
+ * @reg:       virtual address of a register
+ * @val:       pinctrl configured value of the register
+ * @irq:       optional irq specified for wake-up for example
+ * @gpio:      optional gpio specified for wake-up for example
+ * @node:      optional list
+ */
+struct pcs_reg {
+       unsigned (*read)(void __iomem *reg);
+       void (*write)(unsigned val, void __iomem *reg);
+       void __iomem *reg;
+       unsigned val;
+       int irq;
+       int gpio;
+       struct list_head node;
+};
+
+#define PCS_HAS_FUNCTION_GPIO   (1 << 2)
+#define PCS_HAS_FUNCTION_IRQ    (1 << 1)
 #define PCS_HAS_PINCONF         (1 << 0)
 
 /**
  * struct pcs_soc - SoC specific interface to pinctrl-single
  * @data:      SoC specific data pointer
  * @flags:     mask of PCS_HAS_xxx values
+ * @reg_init:  SoC specific register init function
+ * @enable:    SoC specific enable function
+ * @disable:   SoC specific disable function

I assume that this patch is used in both v1 & v2 version. Since Manjunathappa changed the logic of distinguishing bits and pins in blew.

if (pcs->bits_per_mux)

      mask = vals->mask;
else
     mask = pcs->fmask

Would you like to sync with his style?

At least on omaps, each board typically has at least one device configured as wake-up capable from deeper idle modes. In the deeper idle modes the normal interrupt wake-up path won't work as the logic is powered off and separate wake-up hardware is available either via IO ring or GPIO hardware.

The wake-up
event can be device specific, or may need to be dynamically remuxed to GPIO input for wake-up events. When the wake-up event happens, it's IRQ need to be called so the device won't lose interrupts.

Allow supporting IRQ and GPIO wake-up events if a hardware spefific module is registered for the enable and disable

calls.

Done in collaboration with Roger Quadros <[email protected]>.

Cc Haojian Zhuang <[email protected]>

Cc Peter Ujfalusi <[email protected]>

Cc devicetree-discuss at lists.ozlabs.org

Signed-off-by Roger Quadros <[email protected]>

Signed-off-by Tony Lindgren <[email protected]>

+- interrrupts : the interrupt that a function may have for a wake-up event

+
+- gpios: the gpio that a function may have for a wake-up event

drivers/pinctrl/pinctrl-single.c +7 -0

@@ -1183,6 +1241,24 @@ static int pcs_parse_one_pinctrl_entry(struct pcs_device *pcs,
        } else {
                *num_maps = 1;
        }
+
+       if (pcs->flags & PCS_HAS_FUNCTION_IRQ)
+               function->irq = irq_of_parse_and_map(np, 0);
+
+       if (pcs->flags & PCS_HAS_FUNCTION_GPIO) {
+               function->gpio = of_get_gpio(np, 0);
+               if (function->gpio > 0 && !function->irq) {

drivers/pinctrl/pinctrl-single.c +16 -0

+ * @irq:       optional irq specified for wake-up for example
+ * @gpio:      optional gpio specified for wake-up for example
+ * @node:      optional list
+ */
+struct pcs_reg {
+       unsigned (*read)(void __iomem *reg);
+       void (*write)(unsigned val, void __iomem *reg);
+       void __iomem *reg;
+       unsigned val;
+       int irq;
+       int gpio;
+       struct list_head node;
+};
+
+#define PCS_HAS_FUNCTION_GPIO   (1 << 2)
+#define PCS_HAS_FUNCTION_IRQ    (1 << 1)
 #define PCS_HAS_PINCONF         (1 << 0)
 
 /**
  * struct pcs_soc - SoC specific interface to pinctrl-single
  * @data:      SoC specific data pointer
  * @flags:     mask of PCS_HAS_xxx values

Quoted 5 lines · Tony Lindgren

At least on omaps, each board typically has at least one device configured as wake-up capable from deeper idle modes. In the deeper idle modes the normal interrupt wake-up path won't work as the logic is powered off and separate wake-up hardware is available either via IO ring or GPIO hardware.

What I do not understand is why the irq_set_wake() should not fall through to that IO ring / GPIO hardware.

For example: a composite GPIO+irqchip driver should surely set the wake up for a certain line for irq_set_wake()?

Quoted 5 lines

The wake-up
event can be device specific, or may need to be dynamically remuxed to GPIO input for wake-up events. When the wake-up event happens, it's IRQ need to be called so the device won't lose interrupts.

I recognize this hardware type. The name I use for these things are "latent interrupts".

What I think is that they should maybe be modeled as irqchip from end to end, so that we don't orthogonally use any pinctrl states to set this up.

For wake-up events from deeper idle modes we need to check the configured padconf registers for the wake-up bit and then call the related interrupt handler.

Done in collaboration with Roger Quadros <[email protected]>.

Cc Haojian Zhuang <[email protected]>

Cc Peter Ujfalusi <[email protected]>

Cc devicetree-discuss at lists.ozlabs.org

Signed-off-by Roger Quadros <[email protected]>

Signed-off-by Tony Lindgren <[email protected]>

---
 drivers/pinctrl/Makefile                          |    3
 drivers/pinctrl/pinctrl-single-omap.c             |  287 +++++++++++++++++++++
 include/linux/platform_data/pinctrl-single-omap.h |    4
 3 files changed, 293 insertions(+), 1 deletion(-)
 create mode 100644 drivers/pinctrl/pinctrl-single-omap.c
 create mode 100644 include/linux/platform_data/pinctrl-single-omap.h

(quoted diff) +9 -0

+
+static int __init pcs_omap_init(void)
+{
+       platform_driver_register(&pcs_omap_soc_driver);
+       platform_driver_register(&pcs_omap_driver);
+
+       return 0;
+}
+module_init(pcs_omap_init);

It seems this has to be moved to an earlier place (e.g. subsys_initcall) else the pinctrl core fails to find the pinctrl device at the device creation time and bails out with -EPROBE_DEFER. Also, that device is never created again, so -EPROBE_DEFER doesn't seem to work there.

Quoted 10 lines · Quadros, Roger

(quoted diff) +9 -0

+
+static int __init pcs_omap_init(void)
+{
+       platform_driver_register(&pcs_omap_soc_driver);
+       platform_driver_register(&pcs_omap_driver);
+
+       return 0;
+}
+module_init(pcs_omap_init);

Quoted 4 lines

It seems this has to be moved to an earlier place (e.g. subsys_initcall) else the pinctrl core fails to find the pinctrl device at the device creation time and bails out with -EPROBE_DEFER. Also, that device is never created again, so -EPROBE_DEFER doesn't seem to work there.

Ah here, found your other comment :)

That's not needed, the real fix is to make twl-core.c and friends to be regular module_init. There are already patches queued for that.

Quoted 18 lines · Tony Lindgren

Quoted 10 lines · Quadros, Roger

(quoted diff) +9 -0

+
+static int __init pcs_omap_init(void)
+{
+       platform_driver_register(&pcs_omap_soc_driver);
+       platform_driver_register(&pcs_omap_driver);
+
+       return 0;
+}
+module_init(pcs_omap_init);

Quoted 4 lines

It seems this has to be moved to an earlier place (e.g. subsys_initcall) else the pinctrl core fails to find the pinctrl device at the device creation time and bails out with -EPROBE_DEFER. Also, that device is never created again, so -EPROBE_DEFER doesn't seem to work there.

Ah here, found your other comment :)

Quoted 2 lines

That's not needed, the real fix is to make twl-core.c and friends to be regular module_init. There are already patches queued for that.

OK. I was testing with USB host driver and it seems to be loaded as fs_initcall() which is the root of the problem. I will fix up the usb host driver to be loaded as module_init()

drivers/pinctrl/pinctrl-single-omap.c new file +12 -0

+static irqreturn_t pcs_omap_handle_irq(int irq, void *data)
+{
+       struct pcs_omap *pcso = data;
+       struct list_head *pos;
+       unsigned int wakeirq;
+
+       list_for_each(pos, &pcso->wakeirqs) {
+               struct pcs_reg *pcsoi;
+               u16 val;
+
+               pcsoi = list_entry(pos, struct pcs_reg, node);
+               wakeirq = pcsoi->irq;

For wake-up events from deeper idle modes we need to check the configured padconf registers for the wake-up bit and then call the related interrupt handler.

Done in collaboration with Roger Quadros <[email protected]>.

Cc Haojian Zhuang <[email protected]>

Cc Peter Ujfalusi <[email protected]>

Cc devicetree-discuss at lists.ozlabs.org

Signed-off-by Roger Quadros <[email protected]>

Signed-off-by Tony Lindgren <[email protected]>

+ pcsoi->gpio = r->gpio;

Now pinctrl-single-omap can handle the wake-up events for us now as long as the events are configured in the .dts files.

Quoted 2 lines · Tony Lindgren

Now pinctrl-single-omap can handle the wake-up events for us now as long as the events are configured in the .dts files.

This patch I should queue separately, the rest should go via the pinctrl tree.

Hi Tony, (sorry, on Outlook web)

(quoted diff) +1 -1

-                       compatible = "ti,omap4-padconf", "pinctrl-single";
+                       compatible = "ti,omap4-padconf";

This change is not necessary if we make sure the pinctrl-single-omap driver gets registered early enough, before the pinctrl devices are probed.
(e.g. subsys_initcall())

I've commented about this in the other patch.

Quoted 8 lines · Quadros, Roger

Hi Tony, (sorry, on Outlook web)

(quoted diff) +1 -1

-                       compatible = "ti,omap4-padconf", "pinctrl-single";
+                       compatible = "ti,omap4-padconf";

This change is not necessary if we make sure the pinctrl-single-omap driver gets registered early enough, before the pinctrl devices are probed.
(e.g. subsys_initcall())

I'd rather make everything just module_init, there should not be any need to tinker with the init call ordering any longer with deferred probe. And by making everything into regular device drivers we actually see real error messages without DEBUG_LL and earlyprintk if something goes wrong.

Note that there are patches queued to make twl-core.c just regular module_init as well, so that should fix any issues you might be related it probing before pinctrl.

Quoted 1 line

I've commented about this in the other patch.

Sorry can you clarify, which other patch? The other message I saw in this thread was empty. Or at least I have not seen it yet.

Hi all,

Here are few patches to add support for SoC specific features to pinctrl-single. This is needed at least for omaps to support IO chain wake-up events from deeper idle states.

With this patch series, device drivers can request named pinctrl states like active and idle from the PM runtime suspend and resume calls to set the wake enable bits for selected pins. Further the device driver can toggle the wake-up feature as needed based on the device_may_wakeup() state set by the standard sysfs power/wakeup entry.

This is implemented in a separate pinctrl-single-omap driver that works together with pinctrl-single. This way the SoC specific are separated from the common pinctrl-single, and allows a relatively easy way to implement SoC specific things like wake-up events, pin interrupts, and GPIO.

Hi Tony,

Quoted 13 lines · Tony Lindgren

Hi all,

Here are few patches to add support for SoC specific features to pinctrl-single. This is needed at least for omaps to support IO chain wake-up events from deeper idle states.

With this patch series, device drivers can request named pinctrl states like active and idle from the PM runtime suspend and resume calls to set the wake enable bits for selected pins. Further the device driver can toggle the wake-up feature as needed based on the device_may_wakeup() state set by the standard sysfs power/wakeup entry.

Quoted 5 lines

This is implemented in a separate pinctrl-single-omap driver that works together with pinctrl-single. This way the SoC specific are separated from the common pinctrl-single, and allows a relatively easy way to implement SoC specific things like wake-up events, pin interrupts, and GPIO.

What's the status of this? Would be nice to get it in 3.12. I'm basing the OMAP USB host wakeup support on this.

Quoted 22 lines · Roger Quadros

Hi Tony,

Quoted 18 lines · Tony Lindgren

Hi all,

Here are few patches to add support for SoC specific features to pinctrl-single. This is needed at least for omaps to support IO chain wake-up events from deeper idle states.

With this patch series, device drivers can request named pinctrl states like active and idle from the PM runtime suspend and resume calls to set the wake enable bits for selected pins. Further the device driver can toggle the wake-up feature as needed based on the device_may_wakeup() state set by the standard sysfs power/wakeup entry.

This is implemented in a separate pinctrl-single-omap driver that works together with pinctrl-single. This way the SoC specific are separated from the common pinctrl-single, and allows a relatively easy way to implement SoC specific things like wake-up events, pin interrupts, and GPIO.

Quoted 2 lines

What's the status of this? Would be nice to get it in 3.12. I'm basing the OMAP USB host wakeup support on this.

How about I'll push an immutable branch against v3.11-rc1 when it's tagged and send a pull request to Linus W for the first three patches?

That way we can base other branches on this if needed.

How about I'll push an immutable branch against v3.11-rc1 when it's tagged and send a pull request to Linus W for the first three patches?

That way we can base other branches on this if needed.

Linus, does that sound OK to you?

Quoted 6 lines · Tony Lindgren

How about I'll push an immutable branch against v3.11-rc1 when it's tagged and send a pull request to Linus W for the first three patches?

That way we can base other branches on this if needed.

Linus, does that sound OK to you?

OK but I still need to look closer at them as well, so no guarantee I will pull it...