From: Icenowy Zheng <icenowy-ymACFijhrKM@public.gmane.org> To: Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org> Cc: Michael Turquette <mturquette-rdvid1DuHRBWk0Htik3J/w@public.gmane.org>, Mark Rutland <mark.rutland-5wv7dgnIgG8@public.gmane.org>, Rob Herring <robh+dt-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>, linux-clk-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Stephen Boyd <sboyd-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org>, Maxime Ripard <maxime.ripard-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>, linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, linux-sunxi-/JYPxA39Uh5TLH3MbocFFw@public.gmane.org Subject: Re: [PATCH 07/11] clk: sunxi-ng: Add A80 Display Engine CCU Date: Tue, 24 Jan 2017 14:50:32 +0800 [thread overview] Message-ID: <20170124100509.53LGRxbi@smtp2m.mail.yandex.net> (raw) 2017年1月24日 10:32于 Chen-Yu Tsai <wens@csie.org>写道: > > Add support for the display engine clock controls found on the A80. > > Signed-off-by: Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org> > --- > .../devicetree/bindings/clock/sun9i-de.txt | 28 ++ > drivers/clk/sunxi-ng/Makefile | 1 + > drivers/clk/sunxi-ng/ccu-sun9i-a80-de.c | 283 +++++++++++++++++++++ > drivers/clk/sunxi-ng/ccu-sun9i-a80-de.h | 33 +++ > include/dt-bindings/clock/sun9i-a80-de.h | 80 ++++++ > include/dt-bindings/reset/sun9i-a80-de.h | 58 +++++ > 6 files changed, 483 insertions(+) > create mode 100644 Documentation/devicetree/bindings/clock/sun9i-de.txt > create mode 100644 drivers/clk/sunxi-ng/ccu-sun9i-a80-de.c > create mode 100644 drivers/clk/sunxi-ng/ccu-sun9i-a80-de.h > create mode 100644 include/dt-bindings/clock/sun9i-a80-de.h > create mode 100644 include/dt-bindings/reset/sun9i-a80-de.h > > diff --git a/Documentation/devicetree/bindings/clock/sun9i-de.txt b/Documentation/devicetree/bindings/clock/sun9i-de.txt > new file mode 100644 > index 000000000000..3a5e6df70677 > --- /dev/null > +++ b/Documentation/devicetree/bindings/clock/sun9i-de.txt > @@ -0,0 +1,28 @@ > +Allwinner A80 Display Engine Clock Control Binding > +------------------------------------ > + > +Required properties : > +- compatible: must contain one of the following compatibles: > + - "allwinner,sun9i-a80-de-clocks" > + > +- reg: Must contain the registers base address and length > +- clocks: phandle to the clocks feeding the display engine subsystem. > + Three are needed: > + - "mod": the display engine module clock > + - "dram": the DRAM bus clock for the system > + - "bus": the bus clock for the whole display engine subsystem > +- clock-names: Must contain the clock names described just above > +- resets: phandle to the reset control for the display engine subsystem. > +- #clock-cells : must contain 1 > +- #reset-cells : must contain 1 > + > +Example: > +de_clocks: clock@03000000 { > + compatible = "allwinner,sun9i-a80-de-clks"; Different from the compatible above... > + reg = <0x03000000 0x30>; > + clocks = <&ccu CLK_DE>, <&ccu CLK_SDRAM>, <&ccu CLK_BUS_DE>; > + clock-names = "mod", "dram", "bus"; > + resets = <&ccu RST_BUS_DE>; > + #clock-cells = <1>; > + #reset-cells = <1>; > +}; > diff --git a/drivers/clk/sunxi-ng/Makefile b/drivers/clk/sunxi-ng/Makefile > index 8f37ef7fb67d..6feaac0c5600 100644 > --- a/drivers/clk/sunxi-ng/Makefile > +++ b/drivers/clk/sunxi-ng/Makefile > @@ -26,4 +26,5 @@ obj-$(CONFIG_SUN8I_A33_CCU) += ccu-sun8i-a33.o > obj-$(CONFIG_SUN8I_H3_CCU) += ccu-sun8i-h3.o > obj-$(CONFIG_SUN8I_V3S_CCU) += ccu-sun8i-v3s.o > obj-$(CONFIG_SUN9I_A80_CCU) += ccu-sun9i-a80.o > +obj-$(CONFIG_SUN9I_A80_CCU) += ccu-sun9i-a80-de.o > obj-$(CONFIG_SUN9I_A80_CCU) += ccu-sun9i-a80-usb.o > diff --git a/drivers/clk/sunxi-ng/ccu-sun9i-a80-de.c b/drivers/clk/sunxi-ng/ccu-sun9i-a80-de.c > new file mode 100644 > index 000000000000..3fc27db0a49a > --- /dev/null > +++ b/drivers/clk/sunxi-ng/ccu-sun9i-a80-de.c > @@ -0,0 +1,283 @@ > +/* > + * Copyright (c) 2016 Chen-Yu Tsai. All rights reserved. > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * 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/clk.h> > +#include <linux/clk-provider.h> > +#include <linux/of_address.h> > +#include <linux/platform_device.h> > +#include <linux/reset.h> > + > +#include "ccu_common.h" > +#include "ccu_div.h" > +#include "ccu_gate.h" > +#include "ccu_reset.h" > + > +#include "ccu-sun9i-a80-de.h" > + > +static SUNXI_CCU_GATE(fe0_clk, "fe0", "fe0-div", > + 0x00, BIT(0), 0); > +static SUNXI_CCU_GATE(fe1_clk, "fe1", "fe1-div", > + 0x00, BIT(1), 0); > +static SUNXI_CCU_GATE(fe2_clk, "fe2", "fe2-div", > + 0x00, BIT(2), 0); > +static SUNXI_CCU_GATE(iep_deu0_clk, "iep-deu0", "de", > + 0x00, BIT(4), 0); > +static SUNXI_CCU_GATE(iep_deu1_clk, "iep-deu1", "de", > + 0x00, BIT(5), 0); > +static SUNXI_CCU_GATE(be0_clk, "be0", "be0-div", > + 0x00, BIT(8), 0); > +static SUNXI_CCU_GATE(be1_clk, "be1", "be1-div", > + 0x00, BIT(9), 0); > +static SUNXI_CCU_GATE(be2_clk, "be2", "be2-div", > + 0x00, BIT(10), 0); > +static SUNXI_CCU_GATE(iep_drc0_clk, "iep-drc0", "de", > + 0x00, BIT(12), 0); > +static SUNXI_CCU_GATE(iep_drc1_clk, "iep-drc1", "de", > + 0x00, BIT(13), 0); > +static SUNXI_CCU_GATE(merge_clk, "merge", "de", > + 0x00, BIT(20), 0); > + > +static SUNXI_CCU_GATE(dram_fe0_clk, "dram-fe0", "sdram", > + 0x04, BIT(0), 0); > +static SUNXI_CCU_GATE(dram_fe1_clk, "dram-fe1", "sdram", > + 0x04, BIT(1), 0); > +static SUNXI_CCU_GATE(dram_fe2_clk, "dram-fe2", "sdram", > + 0x04, BIT(2), 0); > +static SUNXI_CCU_GATE(dram_deu0_clk, "dram-deu0", "sdram", > + 0x04, BIT(4), 0); > +static SUNXI_CCU_GATE(dram_deu1_clk, "dram-deu1", "sdram", > + 0x04, BIT(5), 0); > +static SUNXI_CCU_GATE(dram_be0_clk, "dram-be0", "sdram", > + 0x04, BIT(8), 0); > +static SUNXI_CCU_GATE(dram_be1_clk, "dram-be1", "sdram", > + 0x04, BIT(9), 0); > +static SUNXI_CCU_GATE(dram_be2_clk, "dram-be2", "sdram", > + 0x04, BIT(10), 0); > +static SUNXI_CCU_GATE(dram_drc0_clk, "dram-drc0", "sdram", > + 0x04, BIT(12), 0); > +static SUNXI_CCU_GATE(dram_drc1_clk, "dram-drc1", "sdram", > + 0x04, BIT(13), 0); > + > +static SUNXI_CCU_GATE(bus_fe0_clk, "bus-fe0", "bus-de", > + 0x08, BIT(0), 0); > +static SUNXI_CCU_GATE(bus_fe1_clk, "bus-fe1", "bus-de", > + 0x08, BIT(1), 0); > +static SUNXI_CCU_GATE(bus_fe2_clk, "bus-fe2", "bus-de", > + 0x08, BIT(2), 0); > +static SUNXI_CCU_GATE(bus_deu0_clk, "bus-deu0", "bus-de", > + 0x08, BIT(4), 0); > +static SUNXI_CCU_GATE(bus_deu1_clk, "bus-deu1", "bus-de", > + 0x08, BIT(5), 0); > +static SUNXI_CCU_GATE(bus_be0_clk, "bus-be0", "bus-de", > + 0x08, BIT(8), 0); > +static SUNXI_CCU_GATE(bus_be1_clk, "bus-be1", "bus-de", > + 0x08, BIT(9), 0); > +static SUNXI_CCU_GATE(bus_be2_clk, "bus-be2", "bus-de", > + 0x08, BIT(10), 0); > +static SUNXI_CCU_GATE(bus_drc0_clk, "bus-drc0", "bus-de", > + 0x08, BIT(12), 0); > +static SUNXI_CCU_GATE(bus_drc1_clk, "bus-drc1", "bus-de", > + 0x08, BIT(13), 0); > + > +static SUNXI_CCU_M(fe0_div_clk, "fe0-div", "de", 0x20, 0, 4, 0); > +static SUNXI_CCU_M(fe1_div_clk, "fe1-div", "de", 0x20, 4, 4, 0); > +static SUNXI_CCU_M(fe2_div_clk, "fe2-div", "de", 0x20, 8, 4, 0); > +static SUNXI_CCU_M(be0_div_clk, "be0-div", "de", 0x20, 16, 4, 0); > +static SUNXI_CCU_M(be1_div_clk, "be1-div", "de", 0x20, 20, 4, 0); > +static SUNXI_CCU_M(be2_div_clk, "be2-div", "de", 0x20, 24, 4, 0); > + > +static struct ccu_common *sun9i_a80_de_clks[] = { > + &fe0_clk.common, > + &fe1_clk.common, > + &fe2_clk.common, > + &iep_deu0_clk.common, > + &iep_deu1_clk.common, > + &be0_clk.common, > + &be1_clk.common, > + &be2_clk.common, > + &iep_drc0_clk.common, > + &iep_drc1_clk.common, > + &merge_clk.common, > + > + &dram_fe0_clk.common, > + &dram_fe1_clk.common, > + &dram_fe2_clk.common, > + &dram_deu0_clk.common, > + &dram_deu1_clk.common, > + &dram_be0_clk.common, > + &dram_be1_clk.common, > + &dram_be2_clk.common, > + &dram_drc0_clk.common, > + &dram_drc1_clk.common, > + > + &bus_fe0_clk.common, > + &bus_fe1_clk.common, > + &bus_fe2_clk.common, > + &bus_deu0_clk.common, > + &bus_deu1_clk.common, > + &bus_be0_clk.common, > + &bus_be1_clk.common, > + &bus_be2_clk.common, > + &bus_drc0_clk.common, > + &bus_drc1_clk.common, > + > + &fe0_div_clk.common, > + &fe1_div_clk.common, > + &fe2_div_clk.common, > + &be0_div_clk.common, > + &be1_div_clk.common, > + &be2_div_clk.common, > +}; > + > +static struct clk_hw_onecell_data sun9i_a80_de_hw_clks = { > + .hws = { > + [CLK_FE0] = &fe0_clk.common.hw, > + [CLK_FE1] = &fe1_clk.common.hw, > + [CLK_FE2] = &fe2_clk.common.hw, > + [CLK_IEP_DEU0] = &iep_deu0_clk.common.hw, > + [CLK_IEP_DEU1] = &iep_deu1_clk.common.hw, > + [CLK_BE0] = &be0_clk.common.hw, > + [CLK_BE1] = &be1_clk.common.hw, > + [CLK_BE2] = &be2_clk.common.hw, > + [CLK_IEP_DRC0] = &iep_drc0_clk.common.hw, > + [CLK_IEP_DRC1] = &iep_drc1_clk.common.hw, > + [CLK_MERGE] = &merge_clk.common.hw, > + > + [CLK_DRAM_FE0] = &dram_fe0_clk.common.hw, > + [CLK_DRAM_FE1] = &dram_fe1_clk.common.hw, > + [CLK_DRAM_FE2] = &dram_fe2_clk.common.hw, > + [CLK_DRAM_DEU0] = &dram_deu0_clk.common.hw, > + [CLK_DRAM_DEU1] = &dram_deu1_clk.common.hw, > + [CLK_DRAM_BE0] = &dram_be0_clk.common.hw, > + [CLK_DRAM_BE1] = &dram_be1_clk.common.hw, > + [CLK_DRAM_BE2] = &dram_be2_clk.common.hw, > + [CLK_DRAM_DRC0] = &dram_drc0_clk.common.hw, > + [CLK_DRAM_DRC1] = &dram_drc1_clk.common.hw, > + > + [CLK_BUS_FE0] = &bus_fe0_clk.common.hw, > + [CLK_BUS_FE1] = &bus_fe1_clk.common.hw, > + [CLK_BUS_FE2] = &bus_fe2_clk.common.hw, > + [CLK_BUS_DEU0] = &bus_deu0_clk.common.hw, > + [CLK_BUS_DEU1] = &bus_deu1_clk.common.hw, > + [CLK_BUS_BE0] = &bus_be0_clk.common.hw, > + [CLK_BUS_BE1] = &bus_be1_clk.common.hw, > + [CLK_BUS_BE2] = &bus_be2_clk.common.hw, > + [CLK_BUS_DRC0] = &bus_drc0_clk.common.hw, > + [CLK_BUS_DRC1] = &bus_drc1_clk.common.hw, > + > + [CLK_FE0_DIV] = &fe0_div_clk.common.hw, > + [CLK_FE1_DIV] = &fe1_div_clk.common.hw, > + [CLK_FE2_DIV] = &fe2_div_clk.common.hw, > + [CLK_BE0_DIV] = &be0_div_clk.common.hw, > + [CLK_BE1_DIV] = &be1_div_clk.common.hw, > + [CLK_BE2_DIV] = &be2_div_clk.common.hw, > + }, > + .num = CLK_NUMBER, > +}; > + > +static struct ccu_reset_map sun9i_a80_de_resets[] = { > + [RST_FE0] = { 0x0c, BIT(0) }, > + [RST_FE1] = { 0x0c, BIT(1) }, > + [RST_FE2] = { 0x0c, BIT(2) }, > + [RST_DEU0] = { 0x0c, BIT(4) }, > + [RST_DEU1] = { 0x0c, BIT(5) }, > + [RST_BE0] = { 0x0c, BIT(8) }, > + [RST_BE1] = { 0x0c, BIT(9) }, > + [RST_BE2] = { 0x0c, BIT(10) }, > + [RST_DRC0] = { 0x0c, BIT(12) }, > + [RST_DRC1] = { 0x0c, BIT(13) }, > + [RST_MERGE] = { 0x0c, BIT(20) }, > +}; > + > +static const struct sunxi_ccu_desc sun9i_a80_de_clk_desc = { > + .ccu_clks = sun9i_a80_de_clks, > + .num_ccu_clks = ARRAY_SIZE(sun9i_a80_de_clks), > + > + .hw_clks = &sun9i_a80_de_hw_clks, > + > + .resets = sun9i_a80_de_resets, > + .num_resets = ARRAY_SIZE(sun9i_a80_de_resets), > +}; > + > +static int sun9i_a80_de_clk_probe(struct platform_device *pdev) > +{ > + struct resource *res; > + struct clk *bus_clk; > + struct reset_control *rstc; > + void __iomem *reg; > + int ret; > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + reg = devm_ioremap_resource(&pdev->dev, res); > + if (IS_ERR(reg)) > + return PTR_ERR(reg); > + > + bus_clk = devm_clk_get(&pdev->dev, "bus"); > + if (IS_ERR(bus_clk)) { > + ret = PTR_ERR(bus_clk); > + if (ret != -EPROBE_DEFER) > + dev_err(&pdev->dev, "Couldn't get bus clk: %d\n", ret); > + return ret; > + } > + > + rstc = devm_reset_control_get_exclusive(&pdev->dev, NULL); > + if (IS_ERR(rstc)) { > + ret = PTR_ERR(bus_clk); > + if (ret != -EPROBE_DEFER) > + dev_err(&pdev->dev, > + "Couldn't get reset control: %d\n", ret); > + return ret; > + } > + > + /* The bus clock needs to be enabled for us to access the registers */ > + ret = clk_prepare_enable(bus_clk); > + if (ret) { > + dev_err(&pdev->dev, "Couldn't enable bus clk: %d\n", ret); > + return ret; > + } > + > + /* The reset control needs to be asserted for the controls to work */ > + ret = reset_control_deassert(rstc); > + if (ret) { > + dev_err(&pdev->dev, > + "Couldn't deassert reset control: %d\n", ret); > + goto err_disable_clk; > + } > + > + ret = sunxi_ccu_probe(pdev->dev.of_node, reg, > + &sun9i_a80_de_clk_desc); > + if (ret) > + goto err_assert_reset; > + > + return 0; > + > +err_assert_reset: > + reset_control_assert(rstc); > +err_disable_clk: > + clk_disable_unprepare(bus_clk); > + return ret; > +} > + > +static const struct of_device_id sun9i_a80_de_clk_ids[] = { > + { .compatible = "allwinner,sun9i-a80-de-clks" }, > + { } > +}; > + > +static struct platform_driver sun9i_a80_de_clk_driver = { > + .probe = sun9i_a80_de_clk_probe, > + .driver = { > + .name = "sun9i-a80-de-clks", > + .of_match_table = sun9i_a80_de_clk_ids, > + }, > +}; > +builtin_platform_driver(sun9i_a80_de_clk_driver); > diff --git a/drivers/clk/sunxi-ng/ccu-sun9i-a80-de.h b/drivers/clk/sunxi-ng/ccu-sun9i-a80-de.h > new file mode 100644 > index 000000000000..a4769041e40f > --- /dev/null > +++ b/drivers/clk/sunxi-ng/ccu-sun9i-a80-de.h > @@ -0,0 +1,33 @@ > +/* > + * Copyright 2016 Chen-Yu Tsai > + * > + * Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org> > + * > + * 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; either version 2 of the License, or > + * (at your option) any later version. > + * > + * 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 _CCU_SUN9I_A80_DE_H_ > +#define _CCU_SUN9I_A80_DE_H_ > + > +#include <dt-bindings/clock/sun9i-a80-de.h> > +#include <dt-bindings/reset/sun9i-a80-de.h> > + > +/* Intermediary clock dividers are not exported */ > +#define CLK_FE0_DIV 31 > +#define CLK_FE1_DIV 32 > +#define CLK_FE2_DIV 33 > +#define CLK_BE0_DIV 34 > +#define CLK_BE1_DIV 35 > +#define CLK_BE2_DIV 36 > + > +#define CLK_NUMBER (CLK_BE2_DIV + 1) > + > +#endif /* _CCU_SUN9I_A80_DE_H_ */ > diff --git a/include/dt-bindings/clock/sun9i-a80-de.h b/include/dt-bindings/clock/sun9i-a80-de.h > new file mode 100644 > index 000000000000..3dad6c3cd131 > --- /dev/null > +++ b/include/dt-bindings/clock/sun9i-a80-de.h > @@ -0,0 +1,80 @@ > +/* > + * Copyright (C) 2016 Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org> > + * > + * This file is dual-licensed: you can use it either under the terms > + * of the GPL or the X11 license, at your option. Note that this dual > + * licensing only applies to this file, and not this project as a > + * whole. > + * > + * a) This file 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; either version 2 of the > + * License, or (at your option) any later version. > + * > + * This file 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. > + * > + * Or, alternatively, > + * > + * b) Permission is hereby granted, free of charge, to any person > + * obtaining a copy of this software and associated documentation > + * files (the "Software"), to deal in the Software without > + * restriction, including without limitation the rights to use, > + * copy, modify, merge, publish, distribute, sublicense, and/or > + * sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following > + * conditions: > + * > + * The above copyright notice and this permission notice shall be > + * included in all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, > + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES > + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND > + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT > + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, > + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING > + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR > + * OTHER DEALINGS IN THE SOFTWARE. > + */ > + > +#ifndef _DT_BINDINGS_CLOCK_SUN9I_A80_DE_H_ > +#define _DT_BINDINGS_CLOCK_SUN9I_A80_DE_H_ > + > +#define CLK_FE0 0 > +#define CLK_FE1 1 > +#define CLK_FE2 2 > +#define CLK_IEP_DEU0 3 > +#define CLK_IEP_DEU1 4 > +#define CLK_BE0 5 > +#define CLK_BE1 6 > +#define CLK_BE2 7 > +#define CLK_IEP_DRC0 8 > +#define CLK_IEP_DRC1 9 > +#define CLK_MERGE 10 > + > +#define CLK_DRAM_FE0 11 > +#define CLK_DRAM_FE1 12 > +#define CLK_DRAM_FE2 13 > +#define CLK_DRAM_DEU0 14 > +#define CLK_DRAM_DEU1 15 > +#define CLK_DRAM_BE0 16 > +#define CLK_DRAM_BE1 17 > +#define CLK_DRAM_BE2 18 > +#define CLK_DRAM_DRC0 19 > +#define CLK_DRAM_DRC1 20 > + > +#define CLK_BUS_FE0 21 > +#define CLK_BUS_FE1 22 > +#define CLK_BUS_FE2 23 > +#define CLK_BUS_DEU0 24 > +#define CLK_BUS_DEU1 25 > +#define CLK_BUS_BE0 26 > +#define CLK_BUS_BE1 27 > +#define CLK_BUS_BE2 28 > +#define CLK_BUS_DRC0 29 > +#define CLK_BUS_DRC1 30 > + > +#endif /* _DT_BINDINGS_CLOCK_SUN9I_A80_DE_H_ */ > diff --git a/include/dt-bindings/reset/sun9i-a80-de.h b/include/dt-bindings/reset/sun9i-a80-de.h > new file mode 100644 > index 000000000000..205072770171 > --- /dev/null > +++ b/include/dt-bindings/reset/sun9i-a80-de.h > @@ -0,0 +1,58 @@ > +/* > + * Copyright (C) 2016 Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org> > + * > + * This file is dual-licensed: you can use it either under the terms > + * of the GPL or the X11 license, at your option. Note that this dual > + * licensing only applies to this file, and not this project as a > + * whole. > + * > + * a) This file 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; either version 2 of the > + * License, or (at your option) any later version. > + * > + * This file 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. > + * > + * Or, alternatively, > + * > + * b) Permission is hereby granted, free of charge, to any person > + * obtaining a copy of this software and associated documentation > + * files (the "Software"), to deal in the Software without > + * restriction, including without limitation the rights to use, > + * copy, modify, merge, publish, distribute, sublicense, and/or > + * sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following > + * conditions: > + * > + * The above copyright notice and this permission notice shall be > + * included in all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, > + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES > + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND > + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT > + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, > + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING > + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR > + * OTHER DEALINGS IN THE SOFTWARE. > + */ > + > +#ifndef _DT_BINDINGS_RESET_SUN9I_A80_DE_H_ > +#define _DT_BINDINGS_RESET_SUN9I_A80_DE_H_ > + > +#define RST_FE0 0 > +#define RST_FE1 1 > +#define RST_FE2 2 > +#define RST_DEU0 3 > +#define RST_DEU1 4 > +#define RST_BE0 5 > +#define RST_BE1 6 > +#define RST_BE2 7 > +#define RST_DRC0 8 > +#define RST_DRC1 9 > +#define RST_MERGE 10 > + > +#endif /* _DT_BINDINGS_RESET_SUN9I_A80_DE_H_ */ > -- > 2.11.0 > > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel -- You received this message because you are subscribed to the Google Groups "linux-sunxi" group. To unsubscribe from this group and stop receiving emails from it, send an email to linux-sunxi+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/Ez6ZCGd0@public.gmane.org For more options, visit https://groups.google.com/d/optout.
WARNING: multiple messages have this Message-ID (diff)
From: Icenowy Zheng <icenowy@aosc.xyz> To: Chen-Yu Tsai <wens@csie.org> Cc: Michael Turquette <mturquette@baylibre.com>, Mark Rutland <mark.rutland@arm.com>, Rob Herring <robh+dt@kernel.org>, linux-clk@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, Stephen Boyd <sboyd@codeaurora.org>, Maxime Ripard <maxime.ripard@free-electrons.com>, linux-arm-kernel@lists.infradead.org, linux-sunxi@googlegroups.com Subject: Re: [PATCH 07/11] clk: sunxi-ng: Add A80 Display Engine CCU Date: Tue, 24 Jan 2017 14:50:32 +0800 [thread overview] Message-ID: <20170124100509.53LGRxbi@smtp2m.mail.yandex.net> (raw) CjIwMTflubQx5pyIMjTml6UgMTA6MzLkuo4gQ2hlbi1ZdSBUc2FpIDx3ZW5zQGNzaWUub3JnPuWG memBk++8mgo+Cj4gQWRkIHN1cHBvcnQgZm9yIHRoZSBkaXNwbGF5IGVuZ2luZSBjbG9jayBjb250 cm9scyBmb3VuZCBvbiB0aGUgQTgwLiAKPgo+IFNpZ25lZC1vZmYtYnk6IENoZW4tWXUgVHNhaSA8 d2Vuc0Bjc2llLm9yZz4gCj4gLS0tIAo+IC4uLi9kZXZpY2V0cmVlL2JpbmRpbmdzL2Nsb2NrL3N1 bjlpLWRlLnR4dMKgwqDCoMKgwqDCoMKgwqAgfMKgIDI4ICsrIAo+IGRyaXZlcnMvY2xrL3N1bnhp LW5nL01ha2VmaWxlwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzC oMKgIDEgKyAKPiBkcml2ZXJzL2Nsay9zdW54aS1uZy9jY3Utc3VuOWktYTgwLWRlLmPCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIHwgMjgzICsrKysrKysrKysrKysrKysrKysrKyAKPiBkcml2ZXJzL2Ns ay9zdW54aS1uZy9jY3Utc3VuOWktYTgwLWRlLmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoCAz MyArKysgCj4gaW5jbHVkZS9kdC1iaW5kaW5ncy9jbG9jay9zdW45aS1hODAtZGUuaMKgwqDCoMKg wqDCoMKgwqDCoMKgIHzCoCA4MCArKysrKysgCj4gaW5jbHVkZS9kdC1iaW5kaW5ncy9yZXNldC9z dW45aS1hODAtZGUuaMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoCA1OCArKysrKyAKPiA2IGZpbGVz IGNoYW5nZWQsIDQ4MyBpbnNlcnRpb25zKCspIAo+IGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVu dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY2xvY2svc3VuOWktZGUudHh0IAo+IGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2Nsay9zdW54aS1uZy9jY3Utc3VuOWktYTgwLWRlLmMgCj4gY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY2xrL3N1bnhpLW5nL2NjdS1zdW45aS1hODAtZGUuaCAK PiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9kdC1iaW5kaW5ncy9jbG9jay9zdW45aS1hODAt ZGUuaCAKPiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9kdC1iaW5kaW5ncy9yZXNldC9zdW45 aS1hODAtZGUuaCAKPgo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmlu ZGluZ3MvY2xvY2svc3VuOWktZGUudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRp bmdzL2Nsb2NrL3N1bjlpLWRlLnR4dCAKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NCAKPiBpbmRleCAw MDAwMDAwMDAwMDAuLjNhNWU2ZGY3MDY3NyAKPiAtLS0gL2Rldi9udWxsIAo+ICsrKyBiL0RvY3Vt ZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9jbG9jay9zdW45aS1kZS50eHQgCj4gQEAgLTAs MCArMSwyOCBAQCAKPiArQWxsd2lubmVyIEE4MCBEaXNwbGF5IEVuZ2luZSBDbG9jayBDb250cm9s IEJpbmRpbmcgCj4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAKPiArIAo+ ICtSZXF1aXJlZCBwcm9wZXJ0aWVzIDogCj4gKy0gY29tcGF0aWJsZTogbXVzdCBjb250YWluIG9u ZSBvZiB0aGUgZm9sbG93aW5nIGNvbXBhdGlibGVzOiAKPiArIC0gImFsbHdpbm5lcixzdW45aS1h ODAtZGUtY2xvY2tzIiAKPiArIAo+ICstIHJlZzogTXVzdCBjb250YWluIHRoZSByZWdpc3RlcnMg YmFzZSBhZGRyZXNzIGFuZCBsZW5ndGggCj4gKy0gY2xvY2tzOiBwaGFuZGxlIHRvIHRoZSBjbG9j a3MgZmVlZGluZyB0aGUgZGlzcGxheSBlbmdpbmUgc3Vic3lzdGVtLiAKPiArIMKgIFRocmVlIGFy ZSBuZWVkZWQ6IAo+ICvCoCAtICJtb2QiOiB0aGUgZGlzcGxheSBlbmdpbmUgbW9kdWxlIGNsb2Nr IAo+ICvCoCAtICJkcmFtIjogdGhlIERSQU0gYnVzIGNsb2NrIGZvciB0aGUgc3lzdGVtIAo+ICvC oCAtICJidXMiOiB0aGUgYnVzIGNsb2NrIGZvciB0aGUgd2hvbGUgZGlzcGxheSBlbmdpbmUgc3Vi c3lzdGVtIAo+ICstIGNsb2NrLW5hbWVzOiBNdXN0IGNvbnRhaW4gdGhlIGNsb2NrIG5hbWVzIGRl c2NyaWJlZCBqdXN0IGFib3ZlIAo+ICstIHJlc2V0czogcGhhbmRsZSB0byB0aGUgcmVzZXQgY29u dHJvbCBmb3IgdGhlIGRpc3BsYXkgZW5naW5lIHN1YnN5c3RlbS4gCj4gKy0gI2Nsb2NrLWNlbGxz IDogbXVzdCBjb250YWluIDEgCj4gKy0gI3Jlc2V0LWNlbGxzIDogbXVzdCBjb250YWluIDEgCj4g KyAKPiArRXhhbXBsZTogCj4gK2RlX2Nsb2NrczogY2xvY2tAMDMwMDAwMDAgeyAKPiArIGNvbXBh dGlibGUgPSAiYWxsd2lubmVyLHN1bjlpLWE4MC1kZS1jbGtzIjsgCgpEaWZmZXJlbnQgZnJvbSB0 aGUgY29tcGF0aWJsZSBhYm92ZS4uLgoKPiArIHJlZyA9IDwweDAzMDAwMDAwIDB4MzA+OyAKPiAr IGNsb2NrcyA9IDwmY2N1IENMS19ERT4sIDwmY2N1IENMS19TRFJBTT4sIDwmY2N1IENMS19CVVNf REU+OyAKPiArIGNsb2NrLW5hbWVzID0gIm1vZCIsICJkcmFtIiwgImJ1cyI7IAo+ICsgcmVzZXRz ID0gPCZjY3UgUlNUX0JVU19ERT47IAo+ICsgI2Nsb2NrLWNlbGxzID0gPDE+OyAKPiArICNyZXNl dC1jZWxscyA9IDwxPjsgCj4gK307IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsay9zdW54aS1u Zy9NYWtlZmlsZSBiL2RyaXZlcnMvY2xrL3N1bnhpLW5nL01ha2VmaWxlIAo+IGluZGV4IDhmMzdl ZjdmYjY3ZC4uNmZlYWFjMGM1NjAwIDEwMDY0NCAKPiAtLS0gYS9kcml2ZXJzL2Nsay9zdW54aS1u Zy9NYWtlZmlsZSAKPiArKysgYi9kcml2ZXJzL2Nsay9zdW54aS1uZy9NYWtlZmlsZSAKPiBAQCAt MjYsNCArMjYsNSBAQCBvYmotJChDT05GSUdfU1VOOElfQTMzX0NDVSkgKz0gY2N1LXN1bjhpLWEz My5vIAo+IG9iai0kKENPTkZJR19TVU44SV9IM19DQ1UpICs9IGNjdS1zdW44aS1oMy5vIAo+IG9i ai0kKENPTkZJR19TVU44SV9WM1NfQ0NVKSArPSBjY3Utc3VuOGktdjNzLm8gCj4gb2JqLSQoQ09O RklHX1NVTjlJX0E4MF9DQ1UpICs9IGNjdS1zdW45aS1hODAubyAKPiArb2JqLSQoQ09ORklHX1NV TjlJX0E4MF9DQ1UpICs9IGNjdS1zdW45aS1hODAtZGUubyAKPiBvYmotJChDT05GSUdfU1VOOUlf QTgwX0NDVSkgKz0gY2N1LXN1bjlpLWE4MC11c2IubyAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9j bGsvc3VueGktbmcvY2N1LXN1bjlpLWE4MC1kZS5jIGIvZHJpdmVycy9jbGsvc3VueGktbmcvY2N1 LXN1bjlpLWE4MC1kZS5jIAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0IAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uM2ZjMjdkYjBhNDlhIAo+IC0tLSAvZGV2L251bGwgCj4gKysrIGIvZHJpdmVycy9jbGsv c3VueGktbmcvY2N1LXN1bjlpLWE4MC1kZS5jIAo+IEBAIC0wLDAgKzEsMjgzIEBAIAo+ICsvKiAK PiArICogQ29weXJpZ2h0IChjKSAyMDE2IENoZW4tWXUgVHNhaS4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4gCj4gKyAqIAo+ICsgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIAo+ICsgKiBMaWNlbnNlIHZlcnNpb24gMiwgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGFuZCAKPiArICogbWF5 IGJlIGNvcGllZCwgZGlzdHJpYnV0ZWQsIGFuZCBtb2RpZmllZCB1bmRlciB0aG9zZSB0ZXJtcy4g Cj4gKyAqIAo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwgCj4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIAo+ICsgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuwqAgU2VlIHRoZSAKPiArICogR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4gCj4gKyAqLyAKPiArIAo+ ICsjaW5jbHVkZSA8bGludXgvY2xrLmg+IAo+ICsjaW5jbHVkZSA8bGludXgvY2xrLXByb3ZpZGVy Lmg+IAo+ICsjaW5jbHVkZSA8bGludXgvb2ZfYWRkcmVzcy5oPiAKPiArI2luY2x1ZGUgPGxpbnV4 L3BsYXRmb3JtX2RldmljZS5oPiAKPiArI2luY2x1ZGUgPGxpbnV4L3Jlc2V0Lmg+IAo+ICsgCj4g KyNpbmNsdWRlICJjY3VfY29tbW9uLmgiIAo+ICsjaW5jbHVkZSAiY2N1X2Rpdi5oIiAKPiArI2lu Y2x1ZGUgImNjdV9nYXRlLmgiIAo+ICsjaW5jbHVkZSAiY2N1X3Jlc2V0LmgiIAo+ICsgCj4gKyNp bmNsdWRlICJjY3Utc3VuOWktYTgwLWRlLmgiIAo+ICsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FU RShmZTBfY2xrLCAiZmUwIiwgImZlMC1kaXYiLCAKPiArIMKgwqDCoMKgwqAgMHgwMCwgQklUKDAp LCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShmZTFfY2xrLCAiZmUxIiwgImZlMS1kaXYi LCAKPiArIMKgwqDCoMKgwqAgMHgwMCwgQklUKDEpLCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1Vf R0FURShmZTJfY2xrLCAiZmUyIiwgImZlMi1kaXYiLCAKPiArIMKgwqDCoMKgwqAgMHgwMCwgQklU KDIpLCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShpZXBfZGV1MF9jbGssICJpZXAtZGV1 MCIsICJkZSIsIAo+ICsgwqDCoMKgwqDCoCAweDAwLCBCSVQoNCksIDApOyAKPiArc3RhdGljIFNV TlhJX0NDVV9HQVRFKGllcF9kZXUxX2NsaywgImllcC1kZXUxIiwgImRlIiwgCj4gKyDCoMKgwqDC oMKgIDB4MDAsIEJJVCg1KSwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX0dBVEUoYmUwX2Nsaywg ImJlMCIsICJiZTAtZGl2IiwgCj4gKyDCoMKgwqDCoMKgIDB4MDAsIEJJVCg4KSwgMCk7IAo+ICtz dGF0aWMgU1VOWElfQ0NVX0dBVEUoYmUxX2NsaywgImJlMSIsICJiZTEtZGl2IiwgCj4gKyDCoMKg wqDCoMKgIDB4MDAsIEJJVCg5KSwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX0dBVEUoYmUyX2Ns aywgImJlMiIsICJiZTItZGl2IiwgCj4gKyDCoMKgwqDCoMKgIDB4MDAsIEJJVCgxMCksIDApOyAK PiArc3RhdGljIFNVTlhJX0NDVV9HQVRFKGllcF9kcmMwX2NsaywgImllcC1kcmMwIiwgImRlIiwg Cj4gKyDCoMKgwqDCoMKgIDB4MDAsIEJJVCgxMiksIDApOyAKPiArc3RhdGljIFNVTlhJX0NDVV9H QVRFKGllcF9kcmMxX2NsaywgImllcC1kcmMxIiwgImRlIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDAs IEJJVCgxMyksIDApOyAKPiArc3RhdGljIFNVTlhJX0NDVV9HQVRFKG1lcmdlX2NsaywgIm1lcmdl IiwgImRlIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDAsIEJJVCgyMCksIDApOyAKPiArIAo+ICtzdGF0 aWMgU1VOWElfQ0NVX0dBVEUoZHJhbV9mZTBfY2xrLCAiZHJhbS1mZTAiLCAic2RyYW0iLCAKPiAr IMKgwqDCoMKgwqAgMHgwNCwgQklUKDApLCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShk cmFtX2ZlMV9jbGssICJkcmFtLWZlMSIsICJzZHJhbSIsIAo+ICsgwqDCoMKgwqDCoCAweDA0LCBC SVQoMSksIDApOyAKPiArc3RhdGljIFNVTlhJX0NDVV9HQVRFKGRyYW1fZmUyX2NsaywgImRyYW0t ZmUyIiwgInNkcmFtIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDQsIEJJVCgyKSwgMCk7IAo+ICtzdGF0 aWMgU1VOWElfQ0NVX0dBVEUoZHJhbV9kZXUwX2NsaywgImRyYW0tZGV1MCIsICJzZHJhbSIsIAo+ ICsgwqDCoMKgwqDCoCAweDA0LCBCSVQoNCksIDApOyAKPiArc3RhdGljIFNVTlhJX0NDVV9HQVRF KGRyYW1fZGV1MV9jbGssICJkcmFtLWRldTEiLCAic2RyYW0iLCAKPiArIMKgwqDCoMKgwqAgMHgw NCwgQklUKDUpLCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShkcmFtX2JlMF9jbGssICJk cmFtLWJlMCIsICJzZHJhbSIsIAo+ICsgwqDCoMKgwqDCoCAweDA0LCBCSVQoOCksIDApOyAKPiAr c3RhdGljIFNVTlhJX0NDVV9HQVRFKGRyYW1fYmUxX2NsaywgImRyYW0tYmUxIiwgInNkcmFtIiwg Cj4gKyDCoMKgwqDCoMKgIDB4MDQsIEJJVCg5KSwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX0dB VEUoZHJhbV9iZTJfY2xrLCAiZHJhbS1iZTIiLCAic2RyYW0iLCAKPiArIMKgwqDCoMKgwqAgMHgw NCwgQklUKDEwKSwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX0dBVEUoZHJhbV9kcmMwX2Nsaywg ImRyYW0tZHJjMCIsICJzZHJhbSIsIAo+ICsgwqDCoMKgwqDCoCAweDA0LCBCSVQoMTIpLCAwKTsg Cj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShkcmFtX2RyYzFfY2xrLCAiZHJhbS1kcmMxIiwgInNk cmFtIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDQsIEJJVCgxMyksIDApOyAKPiArIAo+ICtzdGF0aWMg U1VOWElfQ0NVX0dBVEUoYnVzX2ZlMF9jbGssICJidXMtZmUwIiwgImJ1cy1kZSIsIAo+ICsgwqDC oMKgwqDCoCAweDA4LCBCSVQoMCksIDApOyAKPiArc3RhdGljIFNVTlhJX0NDVV9HQVRFKGJ1c19m ZTFfY2xrLCAiYnVzLWZlMSIsICJidXMtZGUiLCAKPiArIMKgwqDCoMKgwqAgMHgwOCwgQklUKDEp LCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShidXNfZmUyX2NsaywgImJ1cy1mZTIiLCAi YnVzLWRlIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDgsIEJJVCgyKSwgMCk7IAo+ICtzdGF0aWMgU1VO WElfQ0NVX0dBVEUoYnVzX2RldTBfY2xrLCAiYnVzLWRldTAiLCAiYnVzLWRlIiwgCj4gKyDCoMKg wqDCoMKgIDB4MDgsIEJJVCg0KSwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX0dBVEUoYnVzX2Rl dTFfY2xrLCAiYnVzLWRldTEiLCAiYnVzLWRlIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDgsIEJJVCg1 KSwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX0dBVEUoYnVzX2JlMF9jbGssICJidXMtYmUwIiwg ImJ1cy1kZSIsIAo+ICsgwqDCoMKgwqDCoCAweDA4LCBCSVQoOCksIDApOyAKPiArc3RhdGljIFNV TlhJX0NDVV9HQVRFKGJ1c19iZTFfY2xrLCAiYnVzLWJlMSIsICJidXMtZGUiLCAKPiArIMKgwqDC oMKgwqAgMHgwOCwgQklUKDkpLCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfR0FURShidXNfYmUy X2NsaywgImJ1cy1iZTIiLCAiYnVzLWRlIiwgCj4gKyDCoMKgwqDCoMKgIDB4MDgsIEJJVCgxMCks IDApOyAKPiArc3RhdGljIFNVTlhJX0NDVV9HQVRFKGJ1c19kcmMwX2NsaywgImJ1cy1kcmMwIiwg ImJ1cy1kZSIsIAo+ICsgwqDCoMKgwqDCoCAweDA4LCBCSVQoMTIpLCAwKTsgCj4gK3N0YXRpYyBT VU5YSV9DQ1VfR0FURShidXNfZHJjMV9jbGssICJidXMtZHJjMSIsICJidXMtZGUiLCAKPiArIMKg wqDCoMKgwqAgMHgwOCwgQklUKDEzKSwgMCk7IAo+ICsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfTShm ZTBfZGl2X2NsaywgImZlMC1kaXYiLCAiZGUiLCAweDIwLCAwLCA0LCAwKTsgCj4gK3N0YXRpYyBT VU5YSV9DQ1VfTShmZTFfZGl2X2NsaywgImZlMS1kaXYiLCAiZGUiLCAweDIwLCA0LCA0LCAwKTsg Cj4gK3N0YXRpYyBTVU5YSV9DQ1VfTShmZTJfZGl2X2NsaywgImZlMi1kaXYiLCAiZGUiLCAweDIw LCA4LCA0LCAwKTsgCj4gK3N0YXRpYyBTVU5YSV9DQ1VfTShiZTBfZGl2X2NsaywgImJlMC1kaXYi LCAiZGUiLCAweDIwLCAxNiwgNCwgMCk7IAo+ICtzdGF0aWMgU1VOWElfQ0NVX00oYmUxX2Rpdl9j bGssICJiZTEtZGl2IiwgImRlIiwgMHgyMCwgMjAsIDQsIDApOyAKPiArc3RhdGljIFNVTlhJX0ND VV9NKGJlMl9kaXZfY2xrLCAiYmUyLWRpdiIsICJkZSIsIDB4MjAsIDI0LCA0LCAwKTsgCj4gKyAK PiArc3RhdGljIHN0cnVjdCBjY3VfY29tbW9uICpzdW45aV9hODBfZGVfY2xrc1tdID0geyAKPiAr ICZmZTBfY2xrLmNvbW1vbiwgCj4gKyAmZmUxX2Nsay5jb21tb24sIAo+ICsgJmZlMl9jbGsuY29t bW9uLCAKPiArICZpZXBfZGV1MF9jbGsuY29tbW9uLCAKPiArICZpZXBfZGV1MV9jbGsuY29tbW9u LCAKPiArICZiZTBfY2xrLmNvbW1vbiwgCj4gKyAmYmUxX2Nsay5jb21tb24sIAo+ICsgJmJlMl9j bGsuY29tbW9uLCAKPiArICZpZXBfZHJjMF9jbGsuY29tbW9uLCAKPiArICZpZXBfZHJjMV9jbGsu Y29tbW9uLCAKPiArICZtZXJnZV9jbGsuY29tbW9uLCAKPiArIAo+ICsgJmRyYW1fZmUwX2Nsay5j b21tb24sIAo+ICsgJmRyYW1fZmUxX2Nsay5jb21tb24sIAo+ICsgJmRyYW1fZmUyX2Nsay5jb21t b24sIAo+ICsgJmRyYW1fZGV1MF9jbGsuY29tbW9uLCAKPiArICZkcmFtX2RldTFfY2xrLmNvbW1v biwgCj4gKyAmZHJhbV9iZTBfY2xrLmNvbW1vbiwgCj4gKyAmZHJhbV9iZTFfY2xrLmNvbW1vbiwg Cj4gKyAmZHJhbV9iZTJfY2xrLmNvbW1vbiwgCj4gKyAmZHJhbV9kcmMwX2Nsay5jb21tb24sIAo+ ICsgJmRyYW1fZHJjMV9jbGsuY29tbW9uLCAKPiArIAo+ICsgJmJ1c19mZTBfY2xrLmNvbW1vbiwg Cj4gKyAmYnVzX2ZlMV9jbGsuY29tbW9uLCAKPiArICZidXNfZmUyX2Nsay5jb21tb24sIAo+ICsg JmJ1c19kZXUwX2Nsay5jb21tb24sIAo+ICsgJmJ1c19kZXUxX2Nsay5jb21tb24sIAo+ICsgJmJ1 c19iZTBfY2xrLmNvbW1vbiwgCj4gKyAmYnVzX2JlMV9jbGsuY29tbW9uLCAKPiArICZidXNfYmUy X2Nsay5jb21tb24sIAo+ICsgJmJ1c19kcmMwX2Nsay5jb21tb24sIAo+ICsgJmJ1c19kcmMxX2Ns ay5jb21tb24sIAo+ICsgCj4gKyAmZmUwX2Rpdl9jbGsuY29tbW9uLCAKPiArICZmZTFfZGl2X2Ns ay5jb21tb24sIAo+ICsgJmZlMl9kaXZfY2xrLmNvbW1vbiwgCj4gKyAmYmUwX2Rpdl9jbGsuY29t bW9uLCAKPiArICZiZTFfZGl2X2Nsay5jb21tb24sIAo+ICsgJmJlMl9kaXZfY2xrLmNvbW1vbiwg Cj4gK307IAo+ICsgCj4gK3N0YXRpYyBzdHJ1Y3QgY2xrX2h3X29uZWNlbGxfZGF0YSBzdW45aV9h ODBfZGVfaHdfY2xrcyA9IHsgCj4gKyAuaHdzID0geyAKPiArIFtDTEtfRkUwXSA9ICZmZTBfY2xr LmNvbW1vbi5odywgCj4gKyBbQ0xLX0ZFMV0gPSAmZmUxX2Nsay5jb21tb24uaHcsIAo+ICsgW0NM S19GRTJdID0gJmZlMl9jbGsuY29tbW9uLmh3LCAKPiArIFtDTEtfSUVQX0RFVTBdID0gJmllcF9k ZXUwX2Nsay5jb21tb24uaHcsIAo+ICsgW0NMS19JRVBfREVVMV0gPSAmaWVwX2RldTFfY2xrLmNv bW1vbi5odywgCj4gKyBbQ0xLX0JFMF0gPSAmYmUwX2Nsay5jb21tb24uaHcsIAo+ICsgW0NMS19C RTFdID0gJmJlMV9jbGsuY29tbW9uLmh3LCAKPiArIFtDTEtfQkUyXSA9ICZiZTJfY2xrLmNvbW1v bi5odywgCj4gKyBbQ0xLX0lFUF9EUkMwXSA9ICZpZXBfZHJjMF9jbGsuY29tbW9uLmh3LCAKPiAr IFtDTEtfSUVQX0RSQzFdID0gJmllcF9kcmMxX2Nsay5jb21tb24uaHcsIAo+ICsgW0NMS19NRVJH RV0gPSAmbWVyZ2VfY2xrLmNvbW1vbi5odywgCj4gKyAKPiArIFtDTEtfRFJBTV9GRTBdID0gJmRy YW1fZmUwX2Nsay5jb21tb24uaHcsIAo+ICsgW0NMS19EUkFNX0ZFMV0gPSAmZHJhbV9mZTFfY2xr LmNvbW1vbi5odywgCj4gKyBbQ0xLX0RSQU1fRkUyXSA9ICZkcmFtX2ZlMl9jbGsuY29tbW9uLmh3 LCAKPiArIFtDTEtfRFJBTV9ERVUwXSA9ICZkcmFtX2RldTBfY2xrLmNvbW1vbi5odywgCj4gKyBb Q0xLX0RSQU1fREVVMV0gPSAmZHJhbV9kZXUxX2Nsay5jb21tb24uaHcsIAo+ICsgW0NMS19EUkFN X0JFMF0gPSAmZHJhbV9iZTBfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xLX0RSQU1fQkUxXSA9ICZk cmFtX2JlMV9jbGsuY29tbW9uLmh3LCAKPiArIFtDTEtfRFJBTV9CRTJdID0gJmRyYW1fYmUyX2Ns ay5jb21tb24uaHcsIAo+ICsgW0NMS19EUkFNX0RSQzBdID0gJmRyYW1fZHJjMF9jbGsuY29tbW9u Lmh3LCAKPiArIFtDTEtfRFJBTV9EUkMxXSA9ICZkcmFtX2RyYzFfY2xrLmNvbW1vbi5odywgCj4g KyAKPiArIFtDTEtfQlVTX0ZFMF0gPSAmYnVzX2ZlMF9jbGsuY29tbW9uLmh3LCAKPiArIFtDTEtf QlVTX0ZFMV0gPSAmYnVzX2ZlMV9jbGsuY29tbW9uLmh3LCAKPiArIFtDTEtfQlVTX0ZFMl0gPSAm YnVzX2ZlMl9jbGsuY29tbW9uLmh3LCAKPiArIFtDTEtfQlVTX0RFVTBdID0gJmJ1c19kZXUwX2Ns ay5jb21tb24uaHcsIAo+ICsgW0NMS19CVVNfREVVMV0gPSAmYnVzX2RldTFfY2xrLmNvbW1vbi5o dywgCj4gKyBbQ0xLX0JVU19CRTBdID0gJmJ1c19iZTBfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xL X0JVU19CRTFdID0gJmJ1c19iZTFfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xLX0JVU19CRTJdID0g JmJ1c19iZTJfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xLX0JVU19EUkMwXSA9ICZidXNfZHJjMF9j bGsuY29tbW9uLmh3LCAKPiArIFtDTEtfQlVTX0RSQzFdID0gJmJ1c19kcmMxX2Nsay5jb21tb24u aHcsIAo+ICsgCj4gKyBbQ0xLX0ZFMF9ESVZdID0gJmZlMF9kaXZfY2xrLmNvbW1vbi5odywgCj4g KyBbQ0xLX0ZFMV9ESVZdID0gJmZlMV9kaXZfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xLX0ZFMl9E SVZdID0gJmZlMl9kaXZfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xLX0JFMF9ESVZdID0gJmJlMF9k aXZfY2xrLmNvbW1vbi5odywgCj4gKyBbQ0xLX0JFMV9ESVZdID0gJmJlMV9kaXZfY2xrLmNvbW1v bi5odywgCj4gKyBbQ0xLX0JFMl9ESVZdID0gJmJlMl9kaXZfY2xrLmNvbW1vbi5odywgCj4gKyB9 LCAKPiArIC5udW0gPSBDTEtfTlVNQkVSLCAKPiArfTsgCj4gKyAKPiArc3RhdGljIHN0cnVjdCBj Y3VfcmVzZXRfbWFwIHN1bjlpX2E4MF9kZV9yZXNldHNbXSA9IHsgCj4gKyBbUlNUX0ZFMF0gPSB7 IDB4MGMsIEJJVCgwKSB9LCAKPiArIFtSU1RfRkUxXSA9IHsgMHgwYywgQklUKDEpIH0sIAo+ICsg W1JTVF9GRTJdID0geyAweDBjLCBCSVQoMikgfSwgCj4gKyBbUlNUX0RFVTBdID0geyAweDBjLCBC SVQoNCkgfSwgCj4gKyBbUlNUX0RFVTFdID0geyAweDBjLCBCSVQoNSkgfSwgCj4gKyBbUlNUX0JF MF0gPSB7IDB4MGMsIEJJVCg4KSB9LCAKPiArIFtSU1RfQkUxXSA9IHsgMHgwYywgQklUKDkpIH0s IAo+ICsgW1JTVF9CRTJdID0geyAweDBjLCBCSVQoMTApIH0sIAo+ICsgW1JTVF9EUkMwXSA9IHsg MHgwYywgQklUKDEyKSB9LCAKPiArIFtSU1RfRFJDMV0gPSB7IDB4MGMsIEJJVCgxMykgfSwgCj4g KyBbUlNUX01FUkdFXSA9IHsgMHgwYywgQklUKDIwKSB9LCAKPiArfTsgCj4gKyAKPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBzdW54aV9jY3VfZGVzYyBzdW45aV9hODBfZGVfY2xrX2Rlc2MgPSB7IAo+ ICsgLmNjdV9jbGtzID0gc3VuOWlfYTgwX2RlX2Nsa3MsIAo+ICsgLm51bV9jY3VfY2xrcyA9IEFS UkFZX1NJWkUoc3VuOWlfYTgwX2RlX2Nsa3MpLCAKPiArIAo+ICsgLmh3X2Nsa3MgPSAmc3VuOWlf YTgwX2RlX2h3X2Nsa3MsIAo+ICsgCj4gKyAucmVzZXRzID0gc3VuOWlfYTgwX2RlX3Jlc2V0cywg Cj4gKyAubnVtX3Jlc2V0cyA9IEFSUkFZX1NJWkUoc3VuOWlfYTgwX2RlX3Jlc2V0cyksIAo+ICt9 OyAKPiArIAo+ICtzdGF0aWMgaW50IHN1bjlpX2E4MF9kZV9jbGtfcHJvYmUoc3RydWN0IHBsYXRm b3JtX2RldmljZSAqcGRldikgCj4gK3sgCj4gKyBzdHJ1Y3QgcmVzb3VyY2UgKnJlczsgCj4gKyBz dHJ1Y3QgY2xrICpidXNfY2xrOyAKPiArIHN0cnVjdCByZXNldF9jb250cm9sICpyc3RjOyAKPiAr IHZvaWQgX19pb21lbSAqcmVnOyAKPiArIGludCByZXQ7IAo+ICsgCj4gKyByZXMgPSBwbGF0Zm9y bV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOyAKPiArIHJlZyA9IGRldm1f aW9yZW1hcF9yZXNvdXJjZSgmcGRldi0+ZGV2LCByZXMpOyAKPiArIGlmIChJU19FUlIocmVnKSkg Cj4gKyByZXR1cm4gUFRSX0VSUihyZWcpOyAKPiArIAo+ICsgYnVzX2NsayA9IGRldm1fY2xrX2dl dCgmcGRldi0+ZGV2LCAiYnVzIik7IAo+ICsgaWYgKElTX0VSUihidXNfY2xrKSkgeyAKPiArIHJl dCA9IFBUUl9FUlIoYnVzX2Nsayk7IAo+ICsgaWYgKHJldCAhPSAtRVBST0JFX0RFRkVSKSAKPiAr IGRldl9lcnIoJnBkZXYtPmRldiwgIkNvdWxkbid0IGdldCBidXMgY2xrOiAlZFxuIiwgcmV0KTsg Cj4gKyByZXR1cm4gcmV0OyAKPiArIH0gCj4gKyAKPiArIHJzdGMgPSBkZXZtX3Jlc2V0X2NvbnRy b2xfZ2V0X2V4Y2x1c2l2ZSgmcGRldi0+ZGV2LCBOVUxMKTsgCj4gKyBpZiAoSVNfRVJSKHJzdGMp KSB7IAo+ICsgcmV0ID0gUFRSX0VSUihidXNfY2xrKTsgCj4gKyBpZiAocmV0ICE9IC1FUFJPQkVf REVGRVIpIAo+ICsgZGV2X2VycigmcGRldi0+ZGV2LCAKPiArICJDb3VsZG4ndCBnZXQgcmVzZXQg Y29udHJvbDogJWRcbiIsIHJldCk7IAo+ICsgcmV0dXJuIHJldDsgCj4gKyB9IAo+ICsgCj4gKyAv KiBUaGUgYnVzIGNsb2NrIG5lZWRzIHRvIGJlIGVuYWJsZWQgZm9yIHVzIHRvIGFjY2VzcyB0aGUg cmVnaXN0ZXJzICovIAo+ICsgcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGJ1c19jbGspOyAKPiAr IGlmIChyZXQpIHsgCj4gKyBkZXZfZXJyKCZwZGV2LT5kZXYsICJDb3VsZG4ndCBlbmFibGUgYnVz IGNsazogJWRcbiIsIHJldCk7IAo+ICsgcmV0dXJuIHJldDsgCj4gKyB9IAo+ICsgCj4gKyAvKiBU aGUgcmVzZXQgY29udHJvbCBuZWVkcyB0byBiZSBhc3NlcnRlZCBmb3IgdGhlIGNvbnRyb2xzIHRv IHdvcmsgKi8gCj4gKyByZXQgPSByZXNldF9jb250cm9sX2RlYXNzZXJ0KHJzdGMpOyAKPiArIGlm IChyZXQpIHsgCj4gKyBkZXZfZXJyKCZwZGV2LT5kZXYsIAo+ICsgIkNvdWxkbid0IGRlYXNzZXJ0 IHJlc2V0IGNvbnRyb2w6ICVkXG4iLCByZXQpOyAKPiArIGdvdG8gZXJyX2Rpc2FibGVfY2xrOyAK PiArIH0gCj4gKyAKPiArIHJldCA9IHN1bnhpX2NjdV9wcm9iZShwZGV2LT5kZXYub2Zfbm9kZSwg cmVnLCAKPiArIMKgwqDCoMKgwqAgJnN1bjlpX2E4MF9kZV9jbGtfZGVzYyk7IAo+ICsgaWYgKHJl dCkgCj4gKyBnb3RvIGVycl9hc3NlcnRfcmVzZXQ7IAo+ICsgCj4gKyByZXR1cm4gMDsgCj4gKyAK PiArZXJyX2Fzc2VydF9yZXNldDogCj4gKyByZXNldF9jb250cm9sX2Fzc2VydChyc3RjKTsgCj4g K2Vycl9kaXNhYmxlX2NsazogCj4gKyBjbGtfZGlzYWJsZV91bnByZXBhcmUoYnVzX2Nsayk7IAo+ ICsgcmV0dXJuIHJldDsgCj4gK30gCj4gKyAKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZp Y2VfaWQgc3VuOWlfYTgwX2RlX2Nsa19pZHNbXSA9IHsgCj4gKyB7IC5jb21wYXRpYmxlID0gImFs bHdpbm5lcixzdW45aS1hODAtZGUtY2xrcyIgfSwgCj4gKyB7IH0gCj4gK307IAo+ICsgCj4gK3N0 YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHN1bjlpX2E4MF9kZV9jbGtfZHJpdmVyID0geyAK PiArIC5wcm9iZSA9IHN1bjlpX2E4MF9kZV9jbGtfcHJvYmUsIAo+ICsgLmRyaXZlciA9IHsgCj4g KyAubmFtZSA9ICJzdW45aS1hODAtZGUtY2xrcyIsIAo+ICsgLm9mX21hdGNoX3RhYmxlID0gc3Vu OWlfYTgwX2RlX2Nsa19pZHMsIAo+ICsgfSwgCj4gK307IAo+ICtidWlsdGluX3BsYXRmb3JtX2Ry aXZlcihzdW45aV9hODBfZGVfY2xrX2RyaXZlcik7IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Ns ay9zdW54aS1uZy9jY3Utc3VuOWktYTgwLWRlLmggYi9kcml2ZXJzL2Nsay9zdW54aS1uZy9jY3Ut c3VuOWktYTgwLWRlLmggCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQgCj4gaW5kZXggMDAwMDAwMDAw MDAwLi5hNDc2OTA0MWU0MGYgCj4gLS0tIC9kZXYvbnVsbCAKPiArKysgYi9kcml2ZXJzL2Nsay9z dW54aS1uZy9jY3Utc3VuOWktYTgwLWRlLmggCj4gQEAgLTAsMCArMSwzMyBAQCAKPiArLyogCj4g KyAqIENvcHlyaWdodCAyMDE2IENoZW4tWXUgVHNhaSAKPiArICogCj4gKyAqIENoZW4tWXUgVHNh aSA8d2Vuc0Bjc2llLm9yZz4gCj4gKyAqIAo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSAKPiArICogaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkgCj4gKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIAo+ICsgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLiAKPiArICogCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCAKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgCj4gKyAqIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS7CoCBTZWUgdGhlIAo+ ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLiAKPiArICov IAo+ICsgCj4gKyNpZm5kZWYgX0NDVV9TVU45SV9BODBfREVfSF8gCj4gKyNkZWZpbmUgX0NDVV9T VU45SV9BODBfREVfSF8gCj4gKyAKPiArI2luY2x1ZGUgPGR0LWJpbmRpbmdzL2Nsb2NrL3N1bjlp LWE4MC1kZS5oPiAKPiArI2luY2x1ZGUgPGR0LWJpbmRpbmdzL3Jlc2V0L3N1bjlpLWE4MC1kZS5o PiAKPiArIAo+ICsvKiBJbnRlcm1lZGlhcnkgY2xvY2sgZGl2aWRlcnMgYXJlIG5vdCBleHBvcnRl ZCAqLyAKPiArI2RlZmluZSBDTEtfRkUwX0RJViAzMSAKPiArI2RlZmluZSBDTEtfRkUxX0RJViAz MiAKPiArI2RlZmluZSBDTEtfRkUyX0RJViAzMyAKPiArI2RlZmluZSBDTEtfQkUwX0RJViAzNCAK PiArI2RlZmluZSBDTEtfQkUxX0RJViAzNSAKPiArI2RlZmluZSBDTEtfQkUyX0RJViAzNiAKPiAr IAo+ICsjZGVmaW5lIENMS19OVU1CRVIgKENMS19CRTJfRElWICsgMSkgCj4gKyAKPiArI2VuZGlm IC8qIF9DQ1VfU1VOOUlfQTgwX0RFX0hfICovIAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2R0LWJp bmRpbmdzL2Nsb2NrL3N1bjlpLWE4MC1kZS5oIGIvaW5jbHVkZS9kdC1iaW5kaW5ncy9jbG9jay9z dW45aS1hODAtZGUuaCAKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NCAKPiBpbmRleCAwMDAwMDAwMDAw MDAuLjNkYWQ2YzNjZDEzMSAKPiAtLS0gL2Rldi9udWxsIAo+ICsrKyBiL2luY2x1ZGUvZHQtYmlu ZGluZ3MvY2xvY2svc3VuOWktYTgwLWRlLmggCj4gQEAgLTAsMCArMSw4MCBAQCAKPiArLyogCj4g KyAqIENvcHlyaWdodCAoQykgMjAxNiBDaGVuLVl1IFRzYWkgPHdlbnNAY3NpZS5vcmc+IAo+ICsg KiAKPiArICogVGhpcyBmaWxlIGlzIGR1YWwtbGljZW5zZWQ6IHlvdSBjYW4gdXNlIGl0IGVpdGhl ciB1bmRlciB0aGUgdGVybXMgCj4gKyAqIG9mIHRoZSBHUEwgb3IgdGhlIFgxMSBsaWNlbnNlLCBh dCB5b3VyIG9wdGlvbi4gTm90ZSB0aGF0IHRoaXMgZHVhbCAKPiArICogbGljZW5zaW5nIG9ubHkg YXBwbGllcyB0byB0aGlzIGZpbGUsIGFuZCBub3QgdGhpcyBwcm9qZWN0IGFzIGEgCj4gKyAqIHdo b2xlLiAKPiArICogCj4gKyAqwqAgYSkgVGhpcyBmaWxlIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciAKPiArICrCoMKgwqDCoCBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyAKPiArICrCoMKg wqDCoCBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl cnNpb24gMiBvZiB0aGUgCj4gKyAqwqDCoMKgwqAgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9u KSBhbnkgbGF0ZXIgdmVyc2lvbi4gCj4gKyAqIAo+ICsgKsKgwqDCoMKgIFRoaXMgZmlsZSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCAKPiArICrCoMKg wqDCoCBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZiAKPiArICrCoMKgwqDCoCBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuwqAgU2VlIHRoZSAKPiArICrCoMKgwqDCoCBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLiAKPiArICogCj4gKyAqIE9yLCBhbHRl cm5hdGl2ZWx5LCAKPiArICogCj4gKyAqwqAgYikgUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRl ZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gCj4gKyAqwqDCoMKgwqAgb2J0YWluaW5n IGEgY29weSBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gCj4g KyAqwqDCoMKgwqAgZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVhbCBpbiB0aGUgU29mdHdh cmUgd2l0aG91dCAKPiArICrCoMKgwqDCoCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQg bGltaXRhdGlvbiB0aGUgcmlnaHRzIHRvIHVzZSwgCj4gKyAqwqDCoMKgwqAgY29weSwgbW9kaWZ5 LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIAo+ICsgKsKg wqDCoMKgIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25z IHRvIHdob20gdGhlIAo+ICsgKsKgwqDCoMKgIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBz bywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIAo+ICsgKsKgwqDCoMKgIGNvbmRpdGlvbnM6IAo+ ICsgKiAKPiArICrCoMKgwqDCoCBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBw ZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSAKPiArICrCoMKgwqDCoCBpbmNsdWRlZCBpbiBhbGwg Y29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4gCj4gKyAqIAo+ ICsgKsKgwqDCoMKgIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdB UlJBTlRZIE9GIEFOWSBLSU5ELCAKPiArICrCoMKgwqDCoCBFWFBSRVNTIE9SIElNUExJRUQsIElO Q0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgCj4gKyAqwqDCoMKgwqAg T0YgTUVSQ0hBTlRBQklMSVRZLCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQg Cj4gKyAqwqDCoMKgwqAgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQVVU SE9SUyBPUiBDT1BZUklHSFQgCj4gKyAqwqDCoMKgwqAgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFO WSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUiBMSUFCSUxJVFksIAo+ICsgKsKgwqDCoMKgIFdIRVRI RVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyAK PiArICrCoMKgwqDCoCBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZU V0FSRSBPUiBUSEUgVVNFIE9SIAo+ICsgKsKgwqDCoMKgIE9USEVSIERFQUxJTkdTIElOIFRIRSBT T0ZUV0FSRS4gCj4gKyAqLyAKPiArIAo+ICsjaWZuZGVmIF9EVF9CSU5ESU5HU19DTE9DS19TVU45 SV9BODBfREVfSF8gCj4gKyNkZWZpbmUgX0RUX0JJTkRJTkdTX0NMT0NLX1NVTjlJX0E4MF9ERV9I XyAKPiArIAo+ICsjZGVmaW5lIENMS19GRTAgMCAKPiArI2RlZmluZSBDTEtfRkUxIDEgCj4gKyNk ZWZpbmUgQ0xLX0ZFMiAyIAo+ICsjZGVmaW5lIENMS19JRVBfREVVMCAzIAo+ICsjZGVmaW5lIENM S19JRVBfREVVMSA0IAo+ICsjZGVmaW5lIENMS19CRTAgNSAKPiArI2RlZmluZSBDTEtfQkUxIDYg Cj4gKyNkZWZpbmUgQ0xLX0JFMiA3IAo+ICsjZGVmaW5lIENMS19JRVBfRFJDMCA4IAo+ICsjZGVm aW5lIENMS19JRVBfRFJDMSA5IAo+ICsjZGVmaW5lIENMS19NRVJHRSAxMCAKPiArIAo+ICsjZGVm aW5lIENMS19EUkFNX0ZFMCAxMSAKPiArI2RlZmluZSBDTEtfRFJBTV9GRTEgMTIgCj4gKyNkZWZp bmUgQ0xLX0RSQU1fRkUyIDEzIAo+ICsjZGVmaW5lIENMS19EUkFNX0RFVTAgMTQgCj4gKyNkZWZp bmUgQ0xLX0RSQU1fREVVMSAxNSAKPiArI2RlZmluZSBDTEtfRFJBTV9CRTAgMTYgCj4gKyNkZWZp bmUgQ0xLX0RSQU1fQkUxIDE3IAo+ICsjZGVmaW5lIENMS19EUkFNX0JFMiAxOCAKPiArI2RlZmlu ZSBDTEtfRFJBTV9EUkMwIDE5IAo+ICsjZGVmaW5lIENMS19EUkFNX0RSQzEgMjAgCj4gKyAKPiAr I2RlZmluZSBDTEtfQlVTX0ZFMCAyMSAKPiArI2RlZmluZSBDTEtfQlVTX0ZFMSAyMiAKPiArI2Rl ZmluZSBDTEtfQlVTX0ZFMiAyMyAKPiArI2RlZmluZSBDTEtfQlVTX0RFVTAgMjQgCj4gKyNkZWZp bmUgQ0xLX0JVU19ERVUxIDI1IAo+ICsjZGVmaW5lIENMS19CVVNfQkUwIDI2IAo+ICsjZGVmaW5l IENMS19CVVNfQkUxIDI3IAo+ICsjZGVmaW5lIENMS19CVVNfQkUyIDI4IAo+ICsjZGVmaW5lIENM S19CVVNfRFJDMCAyOSAKPiArI2RlZmluZSBDTEtfQlVTX0RSQzEgMzAgCj4gKyAKPiArI2VuZGlm IC8qIF9EVF9CSU5ESU5HU19DTE9DS19TVU45SV9BODBfREVfSF8gKi8gCj4gZGlmZiAtLWdpdCBh L2luY2x1ZGUvZHQtYmluZGluZ3MvcmVzZXQvc3VuOWktYTgwLWRlLmggYi9pbmNsdWRlL2R0LWJp bmRpbmdzL3Jlc2V0L3N1bjlpLWE4MC1kZS5oIAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0IAo+IGlu ZGV4IDAwMDAwMDAwMDAwMC4uMjA1MDcyNzcwMTcxIAo+IC0tLSAvZGV2L251bGwgCj4gKysrIGIv aW5jbHVkZS9kdC1iaW5kaW5ncy9yZXNldC9zdW45aS1hODAtZGUuaCAKPiBAQCAtMCwwICsxLDU4 IEBAIAo+ICsvKiAKPiArICogQ29weXJpZ2h0IChDKSAyMDE2IENoZW4tWXUgVHNhaSA8d2Vuc0Bj c2llLm9yZz4gCj4gKyAqIAo+ICsgKiBUaGlzIGZpbGUgaXMgZHVhbC1saWNlbnNlZDogeW91IGNh biB1c2UgaXQgZWl0aGVyIHVuZGVyIHRoZSB0ZXJtcyAKPiArICogb2YgdGhlIEdQTCBvciB0aGUg WDExIGxpY2Vuc2UsIGF0IHlvdXIgb3B0aW9uLiBOb3RlIHRoYXQgdGhpcyBkdWFsIAo+ICsgKiBs aWNlbnNpbmcgb25seSBhcHBsaWVzIHRvIHRoaXMgZmlsZSwgYW5kIG5vdCB0aGlzIHByb2plY3Qg YXMgYSAKPiArICogd2hvbGUuIAo+ICsgKiAKPiArICrCoCBhKSBUaGlzIGZpbGUgaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIAo+ICsgKsKgwqDCoMKgIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IGFzIAo+ICsgKsKgwqDCoMKgIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSAKPiArICrCoMKgwqDCoCBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLiAKPiArICogCj4gKyAqwqDCoMKgwqAg VGhpcyBmaWxlIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsIAo+ICsgKsKgwqDCoMKgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVu IHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIAo+ICsgKsKgwqDCoMKgIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS7CoCBTZWUgdGhlIAo+ICsgKsKgwqDC oMKgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuIAo+ICsgKiAK PiArICogT3IsIGFsdGVybmF0aXZlbHksIAo+ICsgKiAKPiArICrCoCBiKSBQZXJtaXNzaW9uIGlz IGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiAKPiArICrCoMKg wqDCoCBvYnRhaW5pbmcgYSBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9j dW1lbnRhdGlvbiAKPiArICrCoMKgwqDCoCBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLCB0byBkZWFs IGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IAo+ICsgKsKgwqDCoMKgIHJlc3RyaWN0aW9uLCBpbmNs dWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHMgdG8gdXNlLCAKPiArICrCoMKgwqDC oCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBh bmQvb3IgCj4gKyAqwqDCoMKgwqAgc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8g cGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgCj4gKyAqwqDCoMKgwqAgU29mdHdhcmUgaXMgZnVy bmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgCj4gKyAqwqDCoMKgwqAg Y29uZGl0aW9uczogCj4gKyAqIAo+ICsgKsKgwqDCoMKgIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90 aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIAo+ICsgKsKgwqDCoMKgIGlu Y2x1ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3 YXJlLiAKPiArICogCj4gKyAqwqDCoMKgwqAgVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJ UyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIAo+ICsgKsKgwqDCoMKgIEVYUFJFU1Mg T1IgSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyAK PiArICrCoMKgwqDCoCBPRiBNRVJDSEFOVEFCSUxJVFksIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFIEFORCAKPiArICrCoMKgwqDCoCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5U IFNIQUxMIFRIRSBBVVRIT1JTIE9SIENPUFlSSUdIVCAKPiArICrCoMKgwqDCoCBIT0xERVJTIEJF IExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSIExJQUJJTElUWSwgCj4gKyAq wqDCoMKgwqAgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJX SVNFLCBBUklTSU5HIAo+ICsgKsKgwqDCoMKgIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9O IFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgCj4gKyAqwqDCoMKgwqAgT1RIRVIgREVB TElOR1MgSU4gVEhFIFNPRlRXQVJFLiAKPiArICovIAo+ICsgCj4gKyNpZm5kZWYgX0RUX0JJTkRJ TkdTX1JFU0VUX1NVTjlJX0E4MF9ERV9IXyAKPiArI2RlZmluZSBfRFRfQklORElOR1NfUkVTRVRf U1VOOUlfQTgwX0RFX0hfIAo+ICsgCj4gKyNkZWZpbmUgUlNUX0ZFMCAwIAo+ICsjZGVmaW5lIFJT VF9GRTEgMSAKPiArI2RlZmluZSBSU1RfRkUyIDIgCj4gKyNkZWZpbmUgUlNUX0RFVTAgMyAKPiAr I2RlZmluZSBSU1RfREVVMSA0IAo+ICsjZGVmaW5lIFJTVF9CRTAgNSAKPiArI2RlZmluZSBSU1Rf QkUxIDYgCj4gKyNkZWZpbmUgUlNUX0JFMiA3IAo+ICsjZGVmaW5lIFJTVF9EUkMwIDggCj4gKyNk ZWZpbmUgUlNUX0RSQzEgOSAKPiArI2RlZmluZSBSU1RfTUVSR0UgMTAgCj4gKyAKPiArI2VuZGlm IC8qIF9EVF9CSU5ESU5HU19SRVNFVF9TVU45SV9BODBfREVfSF8gKi8gCj4gLS0gCj4gMi4xMS4w IAo+Cj4KPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXyAK PiBsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdCAKPiBsaW51eC1hcm0ta2VybmVsQGxpc3Rz LmluZnJhZGVhZC5vcmcgCj4gaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0 aW5mby9saW51eC1hcm0ta2VybmVsIAo=
next reply other threads:[~2017-01-24 6:50 UTC|newest] Thread overview: 19+ messages / expand[flat|nested] mbox.gz Atom feed top 2017-01-24 6:50 Icenowy Zheng [this message] 2017-01-24 6:50 ` [PATCH 07/11] clk: sunxi-ng: Add A80 Display Engine CCU Icenowy Zheng -- strict thread matches above, loose matches on Subject: below -- 2017-01-24 2:32 [PATCH 00/11] clk: sunxi-ng: Add support for A80 CCUs Chen-Yu Tsai 2017-01-24 2:32 ` [PATCH 07/11] clk: sunxi-ng: Add A80 Display Engine CCU Chen-Yu Tsai 2017-01-24 2:32 ` Chen-Yu Tsai 2017-01-24 2:32 ` Chen-Yu Tsai 2017-01-26 10:39 ` Maxime Ripard 2017-01-26 10:39 ` Maxime Ripard 2017-01-26 11:20 ` Chen-Yu Tsai 2017-01-26 11:20 ` Chen-Yu Tsai 2017-01-26 11:20 ` Chen-Yu Tsai 2017-01-27 8:58 ` Maxime Ripard 2017-01-27 8:58 ` Maxime Ripard 2017-01-27 8:58 ` Maxime Ripard 2017-01-27 9:26 ` Chen-Yu Tsai 2017-01-27 9:26 ` Chen-Yu Tsai 2017-01-27 9:26 ` Chen-Yu Tsai 2017-01-27 9:42 ` Maxime Ripard 2017-01-27 9:42 ` Maxime Ripard 2017-01-27 9:42 ` Maxime Ripard
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20170124100509.53LGRxbi@smtp2m.mail.yandex.net \ --to=icenowy-ymacfijhrkm@public.gmane.org \ --cc=devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org \ --cc=linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org \ --cc=linux-clk-u79uwXL29TY76Z2rM5mHXA@public.gmane.org \ --cc=linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org \ --cc=linux-sunxi-/JYPxA39Uh5TLH3MbocFFw@public.gmane.org \ --cc=mark.rutland-5wv7dgnIgG8@public.gmane.org \ --cc=maxime.ripard-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org \ --cc=mturquette-rdvid1DuHRBWk0Htik3J/w@public.gmane.org \ --cc=robh+dt-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org \ --cc=sboyd-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org \ --cc=wens-jdAy2FN1RRM@public.gmane.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.