From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D25B2C43381 for ; Fri, 29 Mar 2019 04:15:10 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 96F3A2173C for ; Fri, 29 Mar 2019 04:15:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728777AbfC2EPD (ORCPT ); Fri, 29 Mar 2019 00:15:03 -0400 Received: from szxga07-in.huawei.com ([45.249.212.35]:48906 "EHLO huawei.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1728652AbfC2EOh (ORCPT ); Fri, 29 Mar 2019 00:14:37 -0400 Received: from DGGEMS411-HUB.china.huawei.com (unknown [172.30.72.59]) by Forcepoint Email with ESMTP id 7D3EC3C459B921E721BE; Fri, 29 Mar 2019 12:14:35 +0800 (CST) Received: from vm100-107-113-134.huawei.com (100.107.113.134) by DGGEMS411-HUB.china.huawei.com (10.3.19.211) with Microsoft SMTP Server id 14.3.408.0; Fri, 29 Mar 2019 12:14:26 +0800 From: Yu Chen To: , , CC: , , , , , , , , , , , , , , Yu Chen , Chunfeng Yun , Andy Shevchenko , Arnd Bergmann , Greg Kroah-Hartman , Binghui Wang , Heikki Krogerus Subject: [PATCH v5 11/13] hikey960: Support usb functionality of Hikey960 Date: Fri, 29 Mar 2019 12:14:07 +0800 Message-ID: <20190329041409.70138-12-chenyu56@huawei.com> X-Mailer: git-send-email 2.15.0-rc2 In-Reply-To: <20190329041409.70138-1-chenyu56@huawei.com> References: <20190329041409.70138-1-chenyu56@huawei.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [100.107.113.134] X-CFilter-Loop: Reflected Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This driver handles usb hub power on and typeC port event of HiKey960 board: 1)DP&DM switching between usb hub and typeC port base on typeC port state 2)Control power of usb hub on Hikey960 3)Control vbus of typeC port Cc: Chunfeng Yun Cc: Andy Shevchenko Cc: Arnd Bergmann Cc: Greg Kroah-Hartman Cc: John Stultz Cc: Binghui Wang Cc: Heikki Krogerus Signed-off-by: Yu Chen --- v1: * Using gpiod API with the gpios. * Removing registering usb role switch. * Registering usb role switch notifier. v2: * Fix license declaration. * Add configuration of gpio direction. * Remove some log print. v3: * Remove property of "typec_vbus_enable_val". * Remove gpiod_direction_output and set initial value of gpio by * devm_gpiod_get. v4: * Remove 'linux/of.h' and add 'linux/mod_devicetable.h'. * Remove unused 'root' of_node. * Remove unuseful NULL check return by 'devm_gpiod_get'. * Use 'devm_gpiod_get_optional' to get optional gpio. --- --- drivers/misc/Kconfig | 6 ++ drivers/misc/Makefile | 1 + drivers/misc/hisi_hikey_usb.c | 162 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 169 insertions(+) create mode 100644 drivers/misc/hisi_hikey_usb.c diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig index 42ab8ec92a04..3b3f610b80c2 100644 --- a/drivers/misc/Kconfig +++ b/drivers/misc/Kconfig @@ -532,6 +532,12 @@ config PVPANIC a paravirtualized device provided by QEMU; it lets a virtual machine (guest) communicate panic events to the host. +config HISI_HIKEY_USB + tristate "USB functionality of HiSilicon Hikey Platform" + depends on OF && GPIOLIB + help + If you say yes here you get support for usb functionality of HiSilicon Hikey Platform. + source "drivers/misc/c2port/Kconfig" source "drivers/misc/eeprom/Kconfig" source "drivers/misc/cb710/Kconfig" diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index d5b7d3404dc7..1c6c108d3a0c 100644 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -61,3 +61,4 @@ obj-$(CONFIG_OCXL) += ocxl/ obj-y += cardreader/ obj-$(CONFIG_PVPANIC) += pvpanic.o obj-$(CONFIG_HABANA_AI) += habanalabs/ +obj-$(CONFIG_HISI_HIKEY_USB) += hisi_hikey_usb.o diff --git a/drivers/misc/hisi_hikey_usb.c b/drivers/misc/hisi_hikey_usb.c new file mode 100644 index 000000000000..a3bb46266f04 --- /dev/null +++ b/drivers/misc/hisi_hikey_usb.c @@ -0,0 +1,162 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Support for usb functionality of Hikey series boards + * based on Hisilicon Kirin Soc. + * + * Copyright (C) 2017-2018 Hilisicon Electronics Co., Ltd. + * http://www.huawei.com + * + * Authors: Yu Chen + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEVICE_DRIVER_NAME "hisi_hikey_usb" + +#define HUB_VBUS_POWER_ON 1 +#define HUB_VBUS_POWER_OFF 0 +#define USB_SWITCH_TO_HUB 1 +#define USB_SWITCH_TO_TYPEC 0 +#define TYPEC_VBUS_POWER_ON 1 +#define TYPEC_VBUS_POWER_OFF 0 + +struct hisi_hikey_usb { + struct gpio_desc *otg_switch; + struct gpio_desc *typec_vbus; + struct gpio_desc *hub_vbus; + + struct usb_role_switch *role_sw; + struct notifier_block nb; +}; + +static void hub_power_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, int value) +{ + gpiod_set_value_cansleep(hisi_hikey_usb->hub_vbus, value); +} + +static void usb_switch_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, + int switch_to) +{ + gpiod_set_value_cansleep(hisi_hikey_usb->otg_switch, switch_to); +} + +static void usb_typec_power_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, + int value) +{ + gpiod_set_value_cansleep(hisi_hikey_usb->typec_vbus, value); +} + +static int hisi_hikey_role_switch(struct notifier_block *nb, + unsigned long state, void *data) +{ + struct hisi_hikey_usb *hisi_hikey_usb; + + hisi_hikey_usb = container_of(nb, struct hisi_hikey_usb, nb); + + switch (state) { + case USB_ROLE_NONE: + usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_OFF); + usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_HUB); + hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_ON); + break; + case USB_ROLE_HOST: + usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_TYPEC); + usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_ON); + break; + case USB_ROLE_DEVICE: + hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_OFF); + usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_OFF); + usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_TYPEC); + break; + default: + break; + } + + return 0; +} + +static int hisi_hikey_usb_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct hisi_hikey_usb *hisi_hikey_usb; + int ret; + + hisi_hikey_usb = devm_kzalloc(dev, sizeof(*hisi_hikey_usb), GFP_KERNEL); + if (!hisi_hikey_usb) + return -ENOMEM; + + hisi_hikey_usb->nb.notifier_call = hisi_hikey_role_switch; + + hisi_hikey_usb->typec_vbus = devm_gpiod_get(dev, "typec-vbus", + GPIOD_OUT_LOW); + if (IS_ERR(hisi_hikey_usb->typec_vbus)) + return PTR_ERR(hisi_hikey_usb->typec_vbus); + + hisi_hikey_usb->otg_switch = devm_gpiod_get(dev, "otg-switch", + GPIOD_OUT_HIGH); + if (IS_ERR(hisi_hikey_usb->otg_switch)) + return PTR_ERR(hisi_hikey_usb->otg_switch); + + /* hub-vdd33-en is optional */ + hisi_hikey_usb->hub_vbus = devm_gpiod_get_optional(dev, "hub-vdd33-en", + GPIOD_OUT_HIGH); + if (IS_ERR(hisi_hikey_usb->hub_vbus)) + return PTR_ERR(hisi_hikey_usb->hub_vbus); + + hisi_hikey_usb->role_sw = usb_role_switch_get(dev); + if (!hisi_hikey_usb->role_sw) + return -EPROBE_DEFER; + if (IS_ERR(hisi_hikey_usb->role_sw)) + return PTR_ERR(hisi_hikey_usb->role_sw); + + ret = usb_role_switch_register_notifier(hisi_hikey_usb->role_sw, + &hisi_hikey_usb->nb); + if (ret) { + usb_role_switch_put(hisi_hikey_usb->role_sw); + return ret; + } + + platform_set_drvdata(pdev, hisi_hikey_usb); + + return 0; +} + +static int hisi_hikey_usb_remove(struct platform_device *pdev) +{ + struct hisi_hikey_usb *hisi_hikey_usb = platform_get_drvdata(pdev); + + usb_role_switch_unregister_notifier(hisi_hikey_usb->role_sw, + &hisi_hikey_usb->nb); + + usb_role_switch_put(hisi_hikey_usb->role_sw); + + return 0; +} + +static const struct of_device_id id_table_hisi_hikey_usb[] = { + {.compatible = "hisilicon,gpio_hubv1"}, + {.compatible = "hisilicon,hikey960_usb"}, + {} +}; + +static struct platform_driver hisi_hikey_usb_driver = { + .probe = hisi_hikey_usb_probe, + .remove = hisi_hikey_usb_remove, + .driver = { + .name = DEVICE_DRIVER_NAME, + .of_match_table = id_table_hisi_hikey_usb, + }, +}; + +module_platform_driver(hisi_hikey_usb_driver); + +MODULE_AUTHOR("Yu Chen "); +MODULE_DESCRIPTION("Driver Support for USB functionality of Hikey"); +MODULE_LICENSE("GPL v2"); -- 2.15.0-rc2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Yu Chen Subject: [PATCH v5 11/13] hikey960: Support usb functionality of Hikey960 Date: Fri, 29 Mar 2019 12:14:07 +0800 Message-ID: <20190329041409.70138-12-chenyu56@huawei.com> References: <20190329041409.70138-1-chenyu56@huawei.com> Mime-Version: 1.0 Content-Type: text/plain Return-path: In-Reply-To: <20190329041409.70138-1-chenyu56@huawei.com> Sender: linux-kernel-owner@vger.kernel.org To: linux-usb@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: john.stultz@linaro.org, suzhuangluan@hisilicon.com, kongfei@hisilicon.com, liuyu712@hisilicon.com, wanghu17@hisilicon.com, butao@hisilicon.com, chenyao11@huawei.com, fangshengzhou@hisilicon.com, lipengcheng8@huawei.com, songxiaowei@hisilicon.com, xuyiping@hisilicon.com, xuyoujun4@huawei.com, yudongbin@hisilicon.com, zangleigang@hisilicon.com, Yu Chen , Chunfeng Yun , Andy Shevchenko , Arnd Bergmann , Greg Kroah-Hartman , Binghui Wang , Heikki Krogerus List-Id: devicetree@vger.kernel.org This driver handles usb hub power on and typeC port event of HiKey960 board: 1)DP&DM switching between usb hub and typeC port base on typeC port state 2)Control power of usb hub on Hikey960 3)Control vbus of typeC port Cc: Chunfeng Yun Cc: Andy Shevchenko Cc: Arnd Bergmann Cc: Greg Kroah-Hartman Cc: John Stultz Cc: Binghui Wang Cc: Heikki Krogerus Signed-off-by: Yu Chen --- v1: * Using gpiod API with the gpios. * Removing registering usb role switch. * Registering usb role switch notifier. v2: * Fix license declaration. * Add configuration of gpio direction. * Remove some log print. v3: * Remove property of "typec_vbus_enable_val". * Remove gpiod_direction_output and set initial value of gpio by * devm_gpiod_get. v4: * Remove 'linux/of.h' and add 'linux/mod_devicetable.h'. * Remove unused 'root' of_node. * Remove unuseful NULL check return by 'devm_gpiod_get'. * Use 'devm_gpiod_get_optional' to get optional gpio. --- --- drivers/misc/Kconfig | 6 ++ drivers/misc/Makefile | 1 + drivers/misc/hisi_hikey_usb.c | 162 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 169 insertions(+) create mode 100644 drivers/misc/hisi_hikey_usb.c diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig index 42ab8ec92a04..3b3f610b80c2 100644 --- a/drivers/misc/Kconfig +++ b/drivers/misc/Kconfig @@ -532,6 +532,12 @@ config PVPANIC a paravirtualized device provided by QEMU; it lets a virtual machine (guest) communicate panic events to the host. +config HISI_HIKEY_USB + tristate "USB functionality of HiSilicon Hikey Platform" + depends on OF && GPIOLIB + help + If you say yes here you get support for usb functionality of HiSilicon Hikey Platform. + source "drivers/misc/c2port/Kconfig" source "drivers/misc/eeprom/Kconfig" source "drivers/misc/cb710/Kconfig" diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index d5b7d3404dc7..1c6c108d3a0c 100644 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -61,3 +61,4 @@ obj-$(CONFIG_OCXL) += ocxl/ obj-y += cardreader/ obj-$(CONFIG_PVPANIC) += pvpanic.o obj-$(CONFIG_HABANA_AI) += habanalabs/ +obj-$(CONFIG_HISI_HIKEY_USB) += hisi_hikey_usb.o diff --git a/drivers/misc/hisi_hikey_usb.c b/drivers/misc/hisi_hikey_usb.c new file mode 100644 index 000000000000..a3bb46266f04 --- /dev/null +++ b/drivers/misc/hisi_hikey_usb.c @@ -0,0 +1,162 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Support for usb functionality of Hikey series boards + * based on Hisilicon Kirin Soc. + * + * Copyright (C) 2017-2018 Hilisicon Electronics Co., Ltd. + * http://www.huawei.com + * + * Authors: Yu Chen + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEVICE_DRIVER_NAME "hisi_hikey_usb" + +#define HUB_VBUS_POWER_ON 1 +#define HUB_VBUS_POWER_OFF 0 +#define USB_SWITCH_TO_HUB 1 +#define USB_SWITCH_TO_TYPEC 0 +#define TYPEC_VBUS_POWER_ON 1 +#define TYPEC_VBUS_POWER_OFF 0 + +struct hisi_hikey_usb { + struct gpio_desc *otg_switch; + struct gpio_desc *typec_vbus; + struct gpio_desc *hub_vbus; + + struct usb_role_switch *role_sw; + struct notifier_block nb; +}; + +static void hub_power_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, int value) +{ + gpiod_set_value_cansleep(hisi_hikey_usb->hub_vbus, value); +} + +static void usb_switch_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, + int switch_to) +{ + gpiod_set_value_cansleep(hisi_hikey_usb->otg_switch, switch_to); +} + +static void usb_typec_power_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, + int value) +{ + gpiod_set_value_cansleep(hisi_hikey_usb->typec_vbus, value); +} + +static int hisi_hikey_role_switch(struct notifier_block *nb, + unsigned long state, void *data) +{ + struct hisi_hikey_usb *hisi_hikey_usb; + + hisi_hikey_usb = container_of(nb, struct hisi_hikey_usb, nb); + + switch (state) { + case USB_ROLE_NONE: + usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_OFF); + usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_HUB); + hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_ON); + break; + case USB_ROLE_HOST: + usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_TYPEC); + usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_ON); + break; + case USB_ROLE_DEVICE: + hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_OFF); + usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_OFF); + usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_TYPEC); + break; + default: + break; + } + + return 0; +} + +static int hisi_hikey_usb_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct hisi_hikey_usb *hisi_hikey_usb; + int ret; + + hisi_hikey_usb = devm_kzalloc(dev, sizeof(*hisi_hikey_usb), GFP_KERNEL); + if (!hisi_hikey_usb) + return -ENOMEM; + + hisi_hikey_usb->nb.notifier_call = hisi_hikey_role_switch; + + hisi_hikey_usb->typec_vbus = devm_gpiod_get(dev, "typec-vbus", + GPIOD_OUT_LOW); + if (IS_ERR(hisi_hikey_usb->typec_vbus)) + return PTR_ERR(hisi_hikey_usb->typec_vbus); + + hisi_hikey_usb->otg_switch = devm_gpiod_get(dev, "otg-switch", + GPIOD_OUT_HIGH); + if (IS_ERR(hisi_hikey_usb->otg_switch)) + return PTR_ERR(hisi_hikey_usb->otg_switch); + + /* hub-vdd33-en is optional */ + hisi_hikey_usb->hub_vbus = devm_gpiod_get_optional(dev, "hub-vdd33-en", + GPIOD_OUT_HIGH); + if (IS_ERR(hisi_hikey_usb->hub_vbus)) + return PTR_ERR(hisi_hikey_usb->hub_vbus); + + hisi_hikey_usb->role_sw = usb_role_switch_get(dev); + if (!hisi_hikey_usb->role_sw) + return -EPROBE_DEFER; + if (IS_ERR(hisi_hikey_usb->role_sw)) + return PTR_ERR(hisi_hikey_usb->role_sw); + + ret = usb_role_switch_register_notifier(hisi_hikey_usb->role_sw, + &hisi_hikey_usb->nb); + if (ret) { + usb_role_switch_put(hisi_hikey_usb->role_sw); + return ret; + } + + platform_set_drvdata(pdev, hisi_hikey_usb); + + return 0; +} + +static int hisi_hikey_usb_remove(struct platform_device *pdev) +{ + struct hisi_hikey_usb *hisi_hikey_usb = platform_get_drvdata(pdev); + + usb_role_switch_unregister_notifier(hisi_hikey_usb->role_sw, + &hisi_hikey_usb->nb); + + usb_role_switch_put(hisi_hikey_usb->role_sw); + + return 0; +} + +static const struct of_device_id id_table_hisi_hikey_usb[] = { + {.compatible = "hisilicon,gpio_hubv1"}, + {.compatible = "hisilicon,hikey960_usb"}, + {} +}; + +static struct platform_driver hisi_hikey_usb_driver = { + .probe = hisi_hikey_usb_probe, + .remove = hisi_hikey_usb_remove, + .driver = { + .name = DEVICE_DRIVER_NAME, + .of_match_table = id_table_hisi_hikey_usb, + }, +}; + +module_platform_driver(hisi_hikey_usb_driver); + +MODULE_AUTHOR("Yu Chen "); +MODULE_DESCRIPTION("Driver Support for USB functionality of Hikey"); +MODULE_LICENSE("GPL v2"); -- 2.15.0-rc2 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v5,11/13] hikey960: Support usb functionality of Hikey960 From: Yu Chen Message-Id: <20190329041409.70138-12-chenyu56@huawei.com> Date: Fri, 29 Mar 2019 12:14:07 +0800 To: linux-usb@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: john.stultz@linaro.org, suzhuangluan@hisilicon.com, kongfei@hisilicon.com, liuyu712@hisilicon.com, wanghu17@hisilicon.com, butao@hisilicon.com, chenyao11@huawei.com, fangshengzhou@hisilicon.com, lipengcheng8@huawei.com, songxiaowei@hisilicon.com, xuyiping@hisilicon.com, xuyoujun4@huawei.com, yudongbin@hisilicon.com, zangleigang@hisilicon.com, Yu Chen , Chunfeng Yun , Andy Shevchenko , Arnd Bergmann , Greg Kroah-Hartman , Binghui Wang , Heikki Krogerus List-ID: VGhpcyBkcml2ZXIgaGFuZGxlcyB1c2IgaHViIHBvd2VyIG9uIGFuZCB0eXBlQyBwb3J0IGV2ZW50 IG9mIEhpS2V5OTYwIGJvYXJkOgoxKURQJkRNIHN3aXRjaGluZyBiZXR3ZWVuIHVzYiBodWIgYW5k IHR5cGVDIHBvcnQgYmFzZSBvbiB0eXBlQyBwb3J0CnN0YXRlCjIpQ29udHJvbCBwb3dlciBvZiB1 c2IgaHViIG9uIEhpa2V5OTYwCjMpQ29udHJvbCB2YnVzIG9mIHR5cGVDIHBvcnQKCkNjOiBDaHVu ZmVuZyBZdW4gPGNodW5mZW5nLnl1bkBtZWRpYXRlay5jb20+CkNjOiBBbmR5IFNoZXZjaGVua28g PGFuZHkuc2hldmNoZW5rb0BnbWFpbC5jb20+CkNjOiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFybmRi LmRlPgpDYzogR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9yZz4K Q2M6IEpvaG4gU3R1bHR6IDxqb2huLnN0dWx0ekBsaW5hcm8ub3JnPgpDYzogQmluZ2h1aSBXYW5n IDx3YW5nYmluZ2h1aUBoaXNpbGljb24uY29tPgpDYzogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2ku a3JvZ2VydXNAbGludXguaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBZdSBDaGVuIDxjaGVueXU1 NkBodWF3ZWkuY29tPgotLS0KdjE6CiogVXNpbmcgZ3Bpb2QgQVBJIHdpdGggdGhlIGdwaW9zLgoq IFJlbW92aW5nIHJlZ2lzdGVyaW5nIHVzYiByb2xlIHN3aXRjaC4KKiBSZWdpc3RlcmluZyB1c2Ig cm9sZSBzd2l0Y2ggbm90aWZpZXIuCnYyOgoqIEZpeCBsaWNlbnNlIGRlY2xhcmF0aW9uLgoqIEFk ZCBjb25maWd1cmF0aW9uIG9mICBncGlvIGRpcmVjdGlvbi4KKiBSZW1vdmUgc29tZSBsb2cgcHJp bnQuCnYzOgoqIFJlbW92ZSBwcm9wZXJ0eSBvZiAidHlwZWNfdmJ1c19lbmFibGVfdmFsIi4KKiBS ZW1vdmUgZ3Bpb2RfZGlyZWN0aW9uX291dHB1dCBhbmQgc2V0IGluaXRpYWwgdmFsdWUgb2YgZ3Bp byBieQoqIGRldm1fZ3Bpb2RfZ2V0Lgp2NDoKKiBSZW1vdmUgJ2xpbnV4L29mLmgnIGFuZCBhZGQg J2xpbnV4L21vZF9kZXZpY2V0YWJsZS5oJy4KKiBSZW1vdmUgdW51c2VkICdyb290JyBvZl9ub2Rl LgoqIFJlbW92ZSB1bnVzZWZ1bCBOVUxMIGNoZWNrIHJldHVybiBieSAnZGV2bV9ncGlvZF9nZXQn LgoqIFVzZSAnZGV2bV9ncGlvZF9nZXRfb3B0aW9uYWwnIHRvIGdldCBvcHRpb25hbCBncGlvLgot LS0KLS0tCiBkcml2ZXJzL21pc2MvS2NvbmZpZyAgICAgICAgICB8ICAgNiArKwogZHJpdmVycy9t aXNjL01ha2VmaWxlICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9taXNjL2hpc2lfaGlrZXlfdXNi LmMgfCAxNjIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZp bGVzIGNoYW5nZWQsIDE2OSBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9taXNjL2hpc2lfaGlrZXlfdXNiLmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvS2NvbmZp ZyBiL2RyaXZlcnMvbWlzYy9LY29uZmlnCmluZGV4IDQyYWI4ZWM5MmEwNC4uM2IzZjYxMGI4MGMy IDEwMDY0NAotLS0gYS9kcml2ZXJzL21pc2MvS2NvbmZpZworKysgYi9kcml2ZXJzL21pc2MvS2Nv bmZpZwpAQCAtNTMyLDYgKzUzMiwxMiBAQCBjb25maWcgUFZQQU5JQwogCSAgYSBwYXJhdmlydHVh bGl6ZWQgZGV2aWNlIHByb3ZpZGVkIGJ5IFFFTVU7IGl0IGxldHMgYSB2aXJ0dWFsIG1hY2hpbmUK IAkgIChndWVzdCkgY29tbXVuaWNhdGUgcGFuaWMgZXZlbnRzIHRvIHRoZSBob3N0LgogCitjb25m aWcgSElTSV9ISUtFWV9VU0IKKwl0cmlzdGF0ZSAiVVNCIGZ1bmN0aW9uYWxpdHkgb2YgSGlTaWxp Y29uIEhpa2V5IFBsYXRmb3JtIgorCWRlcGVuZHMgb24gT0YgJiYgR1BJT0xJQgorCWhlbHAKKwkg IElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciB1c2IgZnVuY3Rpb25hbGl0 eSBvZiBIaVNpbGljb24gSGlrZXkgUGxhdGZvcm0uCisKIHNvdXJjZSAiZHJpdmVycy9taXNjL2My cG9ydC9LY29uZmlnIgogc291cmNlICJkcml2ZXJzL21pc2MvZWVwcm9tL0tjb25maWciCiBzb3Vy Y2UgImRyaXZlcnMvbWlzYy9jYjcxMC9LY29uZmlnIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNj L01ha2VmaWxlIGIvZHJpdmVycy9taXNjL01ha2VmaWxlCmluZGV4IGQ1YjdkMzQwNGRjNy4uMWM2 YzEwOGQzYTBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21pc2MvTWFrZWZpbGUKKysrIGIvZHJpdmVy cy9taXNjL01ha2VmaWxlCkBAIC02MSwzICs2MSw0IEBAIG9iai0kKENPTkZJR19PQ1hMKQkJKz0g b2N4bC8KIG9iai15CQkJCSs9IGNhcmRyZWFkZXIvCiBvYmotJChDT05GSUdfUFZQQU5JQykgICAJ Kz0gcHZwYW5pYy5vCiBvYmotJChDT05GSUdfSEFCQU5BX0FJKQkJKz0gaGFiYW5hbGFicy8KK29i ai0kKENPTkZJR19ISVNJX0hJS0VZX1VTQikJKz0gaGlzaV9oaWtleV91c2IubwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9taXNjL2hpc2lfaGlrZXlfdXNiLmMgYi9kcml2ZXJzL21pc2MvaGlzaV9oaWtl eV91c2IuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmEzYmI0NjI2 NmYwNAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbWlzYy9oaXNpX2hpa2V5X3VzYi5jCkBA IC0wLDAgKzEsMTYyIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoK KyAqIFN1cHBvcnQgZm9yIHVzYiBmdW5jdGlvbmFsaXR5IG9mIEhpa2V5IHNlcmllcyBib2FyZHMK KyAqIGJhc2VkIG9uIEhpc2lsaWNvbiBLaXJpbiBTb2MuCisgKgorICogQ29weXJpZ2h0IChDKSAy MDE3LTIwMTggSGlsaXNpY29uIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICoJCWh0dHA6Ly93d3cu aHVhd2VpLmNvbQorICoKKyAqIEF1dGhvcnM6IFl1IENoZW4gPGNoZW55dTU2QGh1YXdlaS5jb20+ CisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2dwaW8vY29uc3VtZXIuaD4KKyNpbmNsdWRlIDxsaW51 eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2RfZGV2aWNldGFibGUuaD4KKyNpbmNsdWRl IDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgorI2luY2x1ZGUg PGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNs dWRlIDxsaW51eC91c2Ivcm9sZS5oPgorCisjZGVmaW5lIERFVklDRV9EUklWRVJfTkFNRSAiaGlz aV9oaWtleV91c2IiCisKKyNkZWZpbmUgSFVCX1ZCVVNfUE9XRVJfT04gMQorI2RlZmluZSBIVUJf VkJVU19QT1dFUl9PRkYgMAorI2RlZmluZSBVU0JfU1dJVENIX1RPX0hVQiAxCisjZGVmaW5lIFVT Ql9TV0lUQ0hfVE9fVFlQRUMgMAorI2RlZmluZSBUWVBFQ19WQlVTX1BPV0VSX09OIDEKKyNkZWZp bmUgVFlQRUNfVkJVU19QT1dFUl9PRkYgMAorCitzdHJ1Y3QgaGlzaV9oaWtleV91c2IgeworCXN0 cnVjdCBncGlvX2Rlc2MgKm90Z19zd2l0Y2g7CisJc3RydWN0IGdwaW9fZGVzYyAqdHlwZWNfdmJ1 czsKKwlzdHJ1Y3QgZ3Bpb19kZXNjICpodWJfdmJ1czsKKworCXN0cnVjdCB1c2Jfcm9sZV9zd2l0 Y2ggKnJvbGVfc3c7CisJc3RydWN0IG5vdGlmaWVyX2Jsb2NrIG5iOworfTsKKworc3RhdGljIHZv aWQgaHViX3Bvd2VyX2N0cmwoc3RydWN0IGhpc2lfaGlrZXlfdXNiICpoaXNpX2hpa2V5X3VzYiwg aW50IHZhbHVlKQoreworCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChoaXNpX2hpa2V5X3VzYi0+ aHViX3ZidXMsIHZhbHVlKTsKK30KKworc3RhdGljIHZvaWQgdXNiX3N3aXRjaF9jdHJsKHN0cnVj dCBoaXNpX2hpa2V5X3VzYiAqaGlzaV9oaWtleV91c2IsCisJCWludCBzd2l0Y2hfdG8pCit7CisJ Z3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKGhpc2lfaGlrZXlfdXNiLT5vdGdfc3dpdGNoLCBzd2l0 Y2hfdG8pOworfQorCitzdGF0aWMgdm9pZCB1c2JfdHlwZWNfcG93ZXJfY3RybChzdHJ1Y3QgaGlz aV9oaWtleV91c2IgKmhpc2lfaGlrZXlfdXNiLAorCQlpbnQgdmFsdWUpCit7CisJZ3Bpb2Rfc2V0 X3ZhbHVlX2NhbnNsZWVwKGhpc2lfaGlrZXlfdXNiLT50eXBlY192YnVzLCB2YWx1ZSk7Cit9CisK K3N0YXRpYyBpbnQgaGlzaV9oaWtleV9yb2xlX3N3aXRjaChzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sg Km5iLAorCQkJdW5zaWduZWQgbG9uZyBzdGF0ZSwgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgaGlz aV9oaWtleV91c2IgKmhpc2lfaGlrZXlfdXNiOworCisJaGlzaV9oaWtleV91c2IgPSBjb250YWlu ZXJfb2YobmIsIHN0cnVjdCBoaXNpX2hpa2V5X3VzYiwgbmIpOworCisJc3dpdGNoIChzdGF0ZSkg eworCWNhc2UgVVNCX1JPTEVfTk9ORToKKwkJdXNiX3R5cGVjX3Bvd2VyX2N0cmwoaGlzaV9oaWtl eV91c2IsIFRZUEVDX1ZCVVNfUE9XRVJfT0ZGKTsKKwkJdXNiX3N3aXRjaF9jdHJsKGhpc2lfaGlr ZXlfdXNiLCBVU0JfU1dJVENIX1RPX0hVQik7CisJCWh1Yl9wb3dlcl9jdHJsKGhpc2lfaGlrZXlf dXNiLCBIVUJfVkJVU19QT1dFUl9PTik7CisJCWJyZWFrOworCWNhc2UgVVNCX1JPTEVfSE9TVDoK KwkJdXNiX3N3aXRjaF9jdHJsKGhpc2lfaGlrZXlfdXNiLCBVU0JfU1dJVENIX1RPX1RZUEVDKTsK KwkJdXNiX3R5cGVjX3Bvd2VyX2N0cmwoaGlzaV9oaWtleV91c2IsIFRZUEVDX1ZCVVNfUE9XRVJf T04pOworCQlicmVhazsKKwljYXNlIFVTQl9ST0xFX0RFVklDRToKKwkJaHViX3Bvd2VyX2N0cmwo aGlzaV9oaWtleV91c2IsIEhVQl9WQlVTX1BPV0VSX09GRik7CisJCXVzYl90eXBlY19wb3dlcl9j dHJsKGhpc2lfaGlrZXlfdXNiLCBUWVBFQ19WQlVTX1BPV0VSX09GRik7CisJCXVzYl9zd2l0Y2hf Y3RybChoaXNpX2hpa2V5X3VzYiwgVVNCX1NXSVRDSF9UT19UWVBFQyk7CisJCWJyZWFrOworCWRl ZmF1bHQ6CisJCWJyZWFrOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGhpc2lf aGlrZXlfdXNiX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0 IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3QgaGlzaV9oaWtleV91c2IgKmhpc2lf aGlrZXlfdXNiOworCWludCByZXQ7CisKKwloaXNpX2hpa2V5X3VzYiA9IGRldm1fa3phbGxvYyhk ZXYsIHNpemVvZigqaGlzaV9oaWtleV91c2IpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWhpc2lfaGlr ZXlfdXNiKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWhpc2lfaGlrZXlfdXNiLT5uYi5ub3RpZmll cl9jYWxsID0gaGlzaV9oaWtleV9yb2xlX3N3aXRjaDsKKworCWhpc2lfaGlrZXlfdXNiLT50eXBl Y192YnVzID0gZGV2bV9ncGlvZF9nZXQoZGV2LCAidHlwZWMtdmJ1cyIsCisJCQlHUElPRF9PVVRf TE9XKTsKKwlpZiAoSVNfRVJSKGhpc2lfaGlrZXlfdXNiLT50eXBlY192YnVzKSkKKwkJcmV0dXJu IFBUUl9FUlIoaGlzaV9oaWtleV91c2ItPnR5cGVjX3ZidXMpOworCisJaGlzaV9oaWtleV91c2It Pm90Z19zd2l0Y2ggPSBkZXZtX2dwaW9kX2dldChkZXYsICJvdGctc3dpdGNoIiwKKwkJCUdQSU9E X09VVF9ISUdIKTsKKwlpZiAoSVNfRVJSKGhpc2lfaGlrZXlfdXNiLT5vdGdfc3dpdGNoKSkKKwkJ cmV0dXJuIFBUUl9FUlIoaGlzaV9oaWtleV91c2ItPm90Z19zd2l0Y2gpOworCisJLyogaHViLXZk ZDMzLWVuIGlzIG9wdGlvbmFsICovCisJaGlzaV9oaWtleV91c2ItPmh1Yl92YnVzID0gZGV2bV9n cGlvZF9nZXRfb3B0aW9uYWwoZGV2LCAiaHViLXZkZDMzLWVuIiwKKwkJCUdQSU9EX09VVF9ISUdI KTsKKwlpZiAoSVNfRVJSKGhpc2lfaGlrZXlfdXNiLT5odWJfdmJ1cykpCisJCXJldHVybiBQVFJf RVJSKGhpc2lfaGlrZXlfdXNiLT5odWJfdmJ1cyk7CisKKwloaXNpX2hpa2V5X3VzYi0+cm9sZV9z dyA9IHVzYl9yb2xlX3N3aXRjaF9nZXQoZGV2KTsKKwlpZiAoIWhpc2lfaGlrZXlfdXNiLT5yb2xl X3N3KQorCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKKwlpZiAoSVNfRVJSKGhpc2lfaGlrZXlfdXNi LT5yb2xlX3N3KSkKKwkJcmV0dXJuIFBUUl9FUlIoaGlzaV9oaWtleV91c2ItPnJvbGVfc3cpOwor CisJcmV0ID0gdXNiX3JvbGVfc3dpdGNoX3JlZ2lzdGVyX25vdGlmaWVyKGhpc2lfaGlrZXlfdXNi LT5yb2xlX3N3LAorCQkJJmhpc2lfaGlrZXlfdXNiLT5uYik7CisJaWYgKHJldCkgeworCQl1c2Jf cm9sZV9zd2l0Y2hfcHV0KGhpc2lfaGlrZXlfdXNiLT5yb2xlX3N3KTsKKwkJcmV0dXJuIHJldDsK Kwl9CisKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBoaXNpX2hpa2V5X3VzYik7CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGludCAgaGlzaV9oaWtleV91c2JfcmVtb3ZlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGhpc2lfaGlrZXlfdXNiICpoaXNpX2hp a2V5X3VzYiA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJdXNiX3JvbGVfc3dpdGNo X3VucmVnaXN0ZXJfbm90aWZpZXIoaGlzaV9oaWtleV91c2ItPnJvbGVfc3csCisJCQkmaGlzaV9o aWtleV91c2ItPm5iKTsKKworCXVzYl9yb2xlX3N3aXRjaF9wdXQoaGlzaV9oaWtleV91c2ItPnJv bGVfc3cpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNl X2lkIGlkX3RhYmxlX2hpc2lfaGlrZXlfdXNiW10gPSB7CisJey5jb21wYXRpYmxlID0gImhpc2ls aWNvbixncGlvX2h1YnYxIn0sCisJey5jb21wYXRpYmxlID0gImhpc2lsaWNvbixoaWtleTk2MF91 c2IifSwKKwl7fQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgaGlzaV9oaWtl eV91c2JfZHJpdmVyID0geworCS5wcm9iZSA9IGhpc2lfaGlrZXlfdXNiX3Byb2JlLAorCS5yZW1v dmUgPSBoaXNpX2hpa2V5X3VzYl9yZW1vdmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSBERVZJ Q0VfRFJJVkVSX05BTUUsCisJCS5vZl9tYXRjaF90YWJsZSA9IGlkX3RhYmxlX2hpc2lfaGlrZXlf dXNiLAorCX0sCit9OworCittb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGhpc2lfaGlrZXlfdXNiX2Ry aXZlcik7CisKK01PRFVMRV9BVVRIT1IoIll1IENoZW4gPGNoZW55dTU2QGh1YXdlaS5jb20+Iik7 CitNT0RVTEVfREVTQ1JJUFRJT04oIkRyaXZlciBTdXBwb3J0IGZvciBVU0IgZnVuY3Rpb25hbGl0 eSBvZiBIaWtleSIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo=