From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from e23smtp03.au.ibm.com (e23smtp03.au.ibm.com [202.81.31.145]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id C5AD21A01A9 for ; Tue, 14 Oct 2014 19:40:07 +1100 (EST) Received: from /spool/local by e23smtp03.au.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Tue, 14 Oct 2014 18:40:06 +1000 Received: from d23relay05.au.ibm.com (d23relay05.au.ibm.com [9.190.235.152]) by d23dlp03.au.ibm.com (Postfix) with ESMTP id 75E71357804E for ; Tue, 14 Oct 2014 19:40:03 +1100 (EST) Received: from d23av04.au.ibm.com (d23av04.au.ibm.com [9.190.235.139]) by d23relay05.au.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id s9E8FU7H63242284 for ; Tue, 14 Oct 2014 19:15:31 +1100 Received: from d23av04.au.ibm.com (localhost [127.0.0.1]) by d23av04.au.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id s9E8e1ZT018363 for ; Tue, 14 Oct 2014 19:40:02 +1100 Subject: [PATCH v3] rtc/tpo: Driver to support rtc and wakeup on PowerNV platform To: devicetree@vger.kernel.org, tglx@linutronix.de, linuxppc-dev@lists.ozlabs.org, rtc-linux@googlegroups.com, a.zummo@towertech.it From: Neelesh Gupta Date: Tue, 14 Oct 2014 14:08:36 +0530 Message-ID: <20141014083447.7505.89771.stgit@localhost.localdomain> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Cc: benh@au1.ibm.com List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , The patch implements the OPAL rtc driver that binds with the rtc driver subsystem. The driver uses the platform device infrastructure to probe the rtc device and register it to rtc class framework. The 'wakeup' is supported depending upon the property 'has-tpo' present in the OF node. It provides a way to load the generic rtc driver in in the absence of an OPAL driver. The patch also moves the existing OPAL rtc get/set time interfaces to the new driver and exposes the necessary OPAL calls using EXPORT_SYMBOL_GPL. Test results: ------------- Host: [root@tul169p1 ~]# ls -l /sys/class/rtc/ total 0 lrwxrwxrwx 1 root root 0 Oct 14 03:07 rtc0 -> ../../devices/opal-rtc/rtc/rtc0 [root@tul169p1 ~]# cat /sys/devices/opal-rtc/rtc/rtc0/time 08:10:07 [root@tul169p1 ~]# echo `date '+%s' -d '+ 2 minutes'` > /sys/class/rtc/rtc0/wakealarm [root@tul169p1 ~]# cat /sys/class/rtc/rtc0/wakealarm 1413274345 [root@tul169p1 ~]# FSP: $ smgr mfgState standby $ rtim timeofday System time is valid: 2014/10/14 08:12:04.225115 $ smgr mfgState ipling $ Signed-off-by: Neelesh Gupta --- Changes in v3 ============= - Rebased to the latest tree. Changes in v2 ============= - Added Documentation/devicetree/bindings/rtc/rtc-opal.txt - Explicitly turn off RTC_UIE mode by setting 'rtc->uie_unsupported' Documentation/devicetree/bindings/rtc/rtc-opal.txt | 16 + arch/powerpc/include/asm/opal.h | 7 - arch/powerpc/kernel/time.c | 1 arch/powerpc/platforms/powernv/opal-async.c | 3 arch/powerpc/platforms/powernv/opal-rtc.c | 65 +---- arch/powerpc/platforms/powernv/opal-wrappers.S | 2 arch/powerpc/platforms/powernv/opal.c | 6 arch/powerpc/platforms/powernv/setup.c | 2 drivers/rtc/Kconfig | 11 + drivers/rtc/Makefile | 1 drivers/rtc/rtc-opal.c | 261 ++++++++++++++++++++ 11 files changed, 325 insertions(+), 50 deletions(-) create mode 100644 Documentation/devicetree/bindings/rtc/rtc-opal.txt create mode 100644 drivers/rtc/rtc-opal.c diff --git a/Documentation/devicetree/bindings/rtc/rtc-opal.txt b/Documentation/devicetree/bindings/rtc/rtc-opal.txt new file mode 100644 index 0000000..af87e5e --- /dev/null +++ b/Documentation/devicetree/bindings/rtc/rtc-opal.txt @@ -0,0 +1,16 @@ +IBM OPAL real-time clock +------------------------ + +Required properties: +- comapatible: Should be "ibm,opal-rtc" + +Optional properties: +- has-tpo: Decides if the wakeup is supported or not. + +Example: + rtc { + compatible = "ibm,opal-rtc"; + has-tpo; + phandle = <0x10000029>; + linux,phandle = <0x10000029>; + }; diff --git a/arch/powerpc/include/asm/opal.h b/arch/powerpc/include/asm/opal.h index 9124b0e..2c20561 100644 --- a/arch/powerpc/include/asm/opal.h +++ b/arch/powerpc/include/asm/opal.h @@ -154,6 +154,8 @@ struct opal_sg_list { #define OPAL_HANDLE_HMI 98 #define OPAL_REGISTER_DUMP_REGION 101 #define OPAL_UNREGISTER_DUMP_REGION 102 +#define OPAL_WRITE_TPO 103 +#define OPAL_READ_TPO 104 #ifndef __ASSEMBLY__ @@ -819,6 +821,9 @@ int64_t opal_rtc_read(__be32 *year_month_day, __be64 *hour_minute_second_millisecond); int64_t opal_rtc_write(uint32_t year_month_day, uint64_t hour_minute_second_millisecond); +int64_t opal_tpo_read(uint64_t token, __be32 *year_mon_day, __be32 *hour_min); +int64_t opal_tpo_write(uint64_t token, uint32_t year_mon_day, + uint32_t hour_min); int64_t opal_cec_power_down(uint64_t request); int64_t opal_cec_reboot(void); int64_t opal_read_nvram(uint64_t buffer, uint64_t size, uint64_t offset); @@ -992,8 +997,6 @@ extern int opal_async_wait_response(uint64_t token, struct opal_msg *msg); extern int opal_get_sensor_data(u32 sensor_hndl, u32 *sensor_data); struct rtc_time; -extern int opal_set_rtc_time(struct rtc_time *tm); -extern void opal_get_rtc_time(struct rtc_time *tm); extern unsigned long opal_get_boot_time(void); extern void opal_nvram_init(void); extern void opal_flash_init(void); diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c index 7505599..54490c7 100644 --- a/arch/powerpc/kernel/time.c +++ b/arch/powerpc/kernel/time.c @@ -989,6 +989,7 @@ void GregorianDay(struct rtc_time * tm) tm->tm_wday = day % 7; } +EXPORT_SYMBOL_GPL(GregorianDay); void to_tm(int tim, struct rtc_time * tm) { diff --git a/arch/powerpc/platforms/powernv/opal-async.c b/arch/powerpc/platforms/powernv/opal-async.c index e462ab9..693b6cd 100644 --- a/arch/powerpc/platforms/powernv/opal-async.c +++ b/arch/powerpc/platforms/powernv/opal-async.c @@ -71,6 +71,7 @@ int opal_async_get_token_interruptible(void) return token; } +EXPORT_SYMBOL_GPL(opal_async_get_token_interruptible); int __opal_async_release_token(int token) { @@ -102,6 +103,7 @@ int opal_async_release_token(int token) return 0; } +EXPORT_SYMBOL_GPL(opal_async_release_token); int opal_async_wait_response(uint64_t token, struct opal_msg *msg) { @@ -120,6 +122,7 @@ int opal_async_wait_response(uint64_t token, struct opal_msg *msg) return 0; } +EXPORT_SYMBOL_GPL(opal_async_wait_response); static int opal_async_comp_event(struct notifier_block *nb, unsigned long msg_type, void *msg) diff --git a/arch/powerpc/platforms/powernv/opal-rtc.c b/arch/powerpc/platforms/powernv/opal-rtc.c index 499707d..37dbee1 100644 --- a/arch/powerpc/platforms/powernv/opal-rtc.c +++ b/arch/powerpc/platforms/powernv/opal-rtc.c @@ -15,6 +15,8 @@ #include #include #include +#include +#include #include #include @@ -43,7 +45,7 @@ unsigned long __init opal_get_boot_time(void) long rc = OPAL_BUSY; if (!opal_check_token(OPAL_RTC_READ)) - goto out; + return 0; while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) { rc = opal_rtc_read(&__y_m_d, &__h_m_s_ms); @@ -53,62 +55,33 @@ unsigned long __init opal_get_boot_time(void) mdelay(10); } if (rc != OPAL_SUCCESS) - goto out; + return 0; y_m_d = be32_to_cpu(__y_m_d); h_m_s_ms = be64_to_cpu(__h_m_s_ms); opal_to_tm(y_m_d, h_m_s_ms, &tm); return mktime(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); -out: - ppc_md.get_rtc_time = NULL; - ppc_md.set_rtc_time = NULL; - return 0; } -void opal_get_rtc_time(struct rtc_time *tm) +static __init int opal_time_init(void) { - long rc = OPAL_BUSY; - u32 y_m_d; - u64 h_m_s_ms; - __be32 __y_m_d; - __be64 __h_m_s_ms; + struct platform_device *pdev; + struct device_node *rtc; - while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) { - rc = opal_rtc_read(&__y_m_d, &__h_m_s_ms); - if (rc == OPAL_BUSY_EVENT) - opal_poll_events(NULL); + rtc = of_find_node_by_path("/ibm,opal/rtc"); + if (rtc) { + pdev = of_platform_device_create(rtc, "opal-rtc", NULL); + of_node_put(rtc); + } else { + if (opal_check_token(OPAL_RTC_READ) || + opal_check_token(OPAL_READ_TPO)) + pdev = platform_device_register_simple("opal-rtc", -1, + NULL, 0); else - mdelay(10); + return -ENODEV; } - if (rc != OPAL_SUCCESS) - return; - y_m_d = be32_to_cpu(__y_m_d); - h_m_s_ms = be64_to_cpu(__h_m_s_ms); - opal_to_tm(y_m_d, h_m_s_ms, tm); -} - -int opal_set_rtc_time(struct rtc_time *tm) -{ - long rc = OPAL_BUSY; - u32 y_m_d = 0; - u64 h_m_s_ms = 0; - - y_m_d |= ((u32)bin2bcd((tm->tm_year + 1900) / 100)) << 24; - y_m_d |= ((u32)bin2bcd((tm->tm_year + 1900) % 100)) << 16; - y_m_d |= ((u32)bin2bcd((tm->tm_mon + 1))) << 8; - y_m_d |= ((u32)bin2bcd(tm->tm_mday)); - - h_m_s_ms |= ((u64)bin2bcd(tm->tm_hour)) << 56; - h_m_s_ms |= ((u64)bin2bcd(tm->tm_min)) << 48; - h_m_s_ms |= ((u64)bin2bcd(tm->tm_sec)) << 40; - while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) { - rc = opal_rtc_write(y_m_d, h_m_s_ms); - if (rc == OPAL_BUSY_EVENT) - opal_poll_events(NULL); - else - mdelay(10); - } - return rc == OPAL_SUCCESS ? 0 : -EIO; + return PTR_ERR_OR_ZERO(pdev); } +machine_subsys_initcall(powernv, opal_time_init); diff --git a/arch/powerpc/platforms/powernv/opal-wrappers.S b/arch/powerpc/platforms/powernv/opal-wrappers.S index e9e2450..7d7e7a8 100644 --- a/arch/powerpc/platforms/powernv/opal-wrappers.S +++ b/arch/powerpc/platforms/powernv/opal-wrappers.S @@ -250,3 +250,5 @@ OPAL_CALL(opal_handle_hmi, OPAL_HANDLE_HMI); OPAL_CALL(opal_register_dump_region, OPAL_REGISTER_DUMP_REGION); OPAL_CALL(opal_unregister_dump_region, OPAL_UNREGISTER_DUMP_REGION); OPAL_CALL(opal_pci_set_phb_cxl_mode, OPAL_PCI_SET_PHB_CXL_MODE); +OPAL_CALL(opal_tpo_write, OPAL_WRITE_TPO); +OPAL_CALL(opal_tpo_read, OPAL_READ_TPO); diff --git a/arch/powerpc/platforms/powernv/opal.c b/arch/powerpc/platforms/powernv/opal.c index b642b05..7a7365a 100644 --- a/arch/powerpc/platforms/powernv/opal.c +++ b/arch/powerpc/platforms/powernv/opal.c @@ -784,3 +784,9 @@ void opal_free_sg_list(struct opal_sg_list *sg) sg = NULL; } } + +EXPORT_SYMBOL_GPL(opal_poll_events); +EXPORT_SYMBOL_GPL(opal_rtc_read); +EXPORT_SYMBOL_GPL(opal_rtc_write); +EXPORT_SYMBOL_GPL(opal_tpo_read); +EXPORT_SYMBOL_GPL(opal_tpo_write); diff --git a/arch/powerpc/platforms/powernv/setup.c b/arch/powerpc/platforms/powernv/setup.c index 3f9546d..9759338 100644 --- a/arch/powerpc/platforms/powernv/setup.c +++ b/arch/powerpc/platforms/powernv/setup.c @@ -265,8 +265,6 @@ static unsigned long pnv_memory_block_size(void) static void __init pnv_setup_machdep_opal(void) { ppc_md.get_boot_time = opal_get_boot_time; - ppc_md.get_rtc_time = opal_get_rtc_time; - ppc_md.set_rtc_time = opal_set_rtc_time; ppc_md.restart = pnv_restart; ppc_md.power_off = pnv_power_off; ppc_md.halt = pnv_halt; diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index 8cd0bee..0e38cec 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -979,6 +979,17 @@ config RTC_DRV_NUC900 If you say yes here you get support for the RTC subsystem of the NUC910/NUC920 used in embedded systems. +config RTC_DRV_OPAL + tristate "IBM OPAL RTC driver" + depends on PPC_POWERNV + default y + help + If you say yes here you get support for the PowerNV platform RTC + driver based on OPAL interfaces. + + This driver can also be built as a module. If so, the module + will be called rtc-opal. + comment "on-CPU RTC drivers" config RTC_DRV_DAVINCI diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile index b188323..c8ef3e1 100644 --- a/drivers/rtc/Makefile +++ b/drivers/rtc/Makefile @@ -92,6 +92,7 @@ obj-$(CONFIG_RTC_DRV_MSM6242) += rtc-msm6242.o obj-$(CONFIG_RTC_DRV_MPC5121) += rtc-mpc5121.o obj-$(CONFIG_RTC_DRV_MV) += rtc-mv.o obj-$(CONFIG_RTC_DRV_NUC900) += rtc-nuc900.o +obj-$(CONFIG_RTC_DRV_OPAL) += rtc-opal.o obj-$(CONFIG_RTC_DRV_OMAP) += rtc-omap.o obj-$(CONFIG_RTC_DRV_PALMAS) += rtc-palmas.o obj-$(CONFIG_RTC_DRV_PCAP) += rtc-pcap.o diff --git a/drivers/rtc/rtc-opal.c b/drivers/rtc/rtc-opal.c new file mode 100644 index 0000000..95f6521 --- /dev/null +++ b/drivers/rtc/rtc-opal.c @@ -0,0 +1,261 @@ +/* + * IBM OPAL RTC driver + * Copyright (C) 2014 IBM + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program. + */ + +#define DRVNAME "rtc-opal" +#define pr_fmt(fmt) DRVNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void opal_to_tm(u32 y_m_d, u64 h_m_s_ms, struct rtc_time *tm) +{ + tm->tm_year = ((bcd2bin(y_m_d >> 24) * 100) + + bcd2bin((y_m_d >> 16) & 0xff)) - 1900; + tm->tm_mon = bcd2bin((y_m_d >> 8) & 0xff) - 1; + tm->tm_mday = bcd2bin(y_m_d & 0xff); + tm->tm_hour = bcd2bin((h_m_s_ms >> 56) & 0xff); + tm->tm_min = bcd2bin((h_m_s_ms >> 48) & 0xff); + tm->tm_sec = bcd2bin((h_m_s_ms >> 40) & 0xff); + + GregorianDay(tm); +} + +static void tm_to_opal(struct rtc_time *tm, u32 *y_m_d, u64 *h_m_s_ms) +{ + *y_m_d |= ((u32)bin2bcd((tm->tm_year + 1900) / 100)) << 24; + *y_m_d |= ((u32)bin2bcd((tm->tm_year + 1900) % 100)) << 16; + *y_m_d |= ((u32)bin2bcd((tm->tm_mon + 1))) << 8; + *y_m_d |= ((u32)bin2bcd(tm->tm_mday)); + + *h_m_s_ms |= ((u64)bin2bcd(tm->tm_hour)) << 56; + *h_m_s_ms |= ((u64)bin2bcd(tm->tm_min)) << 48; + *h_m_s_ms |= ((u64)bin2bcd(tm->tm_sec)) << 40; +} + +static int opal_get_rtc_time(struct device *dev, struct rtc_time *tm) +{ + long rc = OPAL_BUSY; + u32 y_m_d; + u64 h_m_s_ms; + __be32 __y_m_d; + __be64 __h_m_s_ms; + + while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) { + rc = opal_rtc_read(&__y_m_d, &__h_m_s_ms); + if (rc == OPAL_BUSY_EVENT) + opal_poll_events(NULL); + else + msleep(10); + } + + if (rc != OPAL_SUCCESS) + return -EIO; + + y_m_d = be32_to_cpu(__y_m_d); + h_m_s_ms = be64_to_cpu(__h_m_s_ms); + opal_to_tm(y_m_d, h_m_s_ms, tm); + + return 0; +} + +static int opal_set_rtc_time(struct device *dev, struct rtc_time *tm) +{ + long rc = OPAL_BUSY; + u32 y_m_d = 0; + u64 h_m_s_ms = 0; + + tm_to_opal(tm, &y_m_d, &h_m_s_ms); + while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) { + rc = opal_rtc_write(y_m_d, h_m_s_ms); + if (rc == OPAL_BUSY_EVENT) + opal_poll_events(NULL); + else + msleep(10); + } + + return rc == OPAL_SUCCESS ? 0 : -EIO; +} + +/* + * TPO Timed Power-On + * + * TPO get/set OPAL calls care about the hour and min and to make it consistent + * with the rtc utility time conversion functions, we use the 'u64' to store + * its value and perform bit shift by 32 before use.. + */ +static int opal_get_tpo_time(struct device *dev, struct rtc_wkalrm *alarm) +{ + __be32 __y_m_d, __h_m; + struct opal_msg msg; + int rc, token; + u64 h_m_s_ms; + u32 y_m_d; + + token = opal_async_get_token_interruptible(); + if (token < 0) { + if (token != -ERESTARTSYS) + pr_err("Failed to get the async token\n"); + + return token; + } + + rc = opal_tpo_read(token, &__y_m_d, &__h_m); + if (rc != OPAL_ASYNC_COMPLETION) { + rc = -EIO; + goto exit; + } + + rc = opal_async_wait_response(token, &msg); + if (rc) { + rc = -EIO; + goto exit; + } + + rc = be64_to_cpu(msg.params[1]); + if (rc != OPAL_SUCCESS) { + rc = -EIO; + goto exit; + } + + y_m_d = be32_to_cpu(__y_m_d); + h_m_s_ms = ((u64)be32_to_cpu(__h_m) << 32); + opal_to_tm(y_m_d, h_m_s_ms, &alarm->time); + +exit: + opal_async_release_token(token); + return rc; +} + +/* Set Timed Power-On */ +static int opal_set_tpo_time(struct device *dev, struct rtc_wkalrm *alarm) +{ + u64 h_m_s_ms = 0, token; + struct opal_msg msg; + u32 y_m_d = 0; + int rc; + + tm_to_opal(&alarm->time, &y_m_d, &h_m_s_ms); + + token = opal_async_get_token_interruptible(); + if (token < 0) { + if (token != -ERESTARTSYS) + pr_err("Failed to get the async token\n"); + + return token; + } + + /* TPO, we care about hour and minute */ + rc = opal_tpo_write(token, y_m_d, + (u32)((h_m_s_ms >> 32) & 0xffff0000)); + if (rc != OPAL_ASYNC_COMPLETION) { + rc = -EIO; + goto exit; + } + + rc = opal_async_wait_response(token, &msg); + if (rc) { + rc = -EIO; + goto exit; + } + + rc = be64_to_cpu(msg.params[1]); + if (rc != OPAL_SUCCESS) + rc = -EIO; + +exit: + opal_async_release_token(token); + return rc; +} + +static const struct rtc_class_ops opal_rtc_ops = { + .read_time = opal_get_rtc_time, + .set_time = opal_set_rtc_time, + .read_alarm = opal_get_tpo_time, + .set_alarm = opal_set_tpo_time, +}; + +static int opal_rtc_probe(struct platform_device *pdev) +{ + struct rtc_device *rtc; + + if (pdev->dev.of_node && of_get_property(pdev->dev.of_node, "has-tpo", + NULL)) + device_set_wakeup_capable(&pdev->dev, true); + + rtc = devm_rtc_device_register(&pdev->dev, DRVNAME, &opal_rtc_ops, + THIS_MODULE); + if (IS_ERR(rtc)) + return PTR_ERR(rtc); + + rtc->uie_unsupported = 1; + + return 0; +} + +static const struct of_device_id opal_rtc_match[] = { + { + .compatible = "ibm,opal-rtc", + }, + { } +}; +MODULE_DEVICE_TABLE(of, opal_rtc_match); + +static const struct platform_device_id opal_rtc_driver_ids[] = { + { + .name = "opal-rtc", + }, + { } +}; +MODULE_DEVICE_TABLE(platform, opal_rtc_driver_ids); + +static struct platform_driver opal_rtc_driver = { + .probe = opal_rtc_probe, + .id_table = opal_rtc_driver_ids, + .driver = { + .name = DRVNAME, + .owner = THIS_MODULE, + .of_match_table = opal_rtc_match, + }, +}; + +static int __init opal_rtc_init(void) +{ + if (!firmware_has_feature(FW_FEATURE_OPAL)) + return -ENODEV; + + return platform_driver_register(&opal_rtc_driver); +} + +static void __exit opal_rtc_exit(void) +{ + platform_driver_unregister(&opal_rtc_driver); +} + +MODULE_AUTHOR("Neelesh Gupta "); +MODULE_DESCRIPTION("IBM OPAL RTC driver"); +MODULE_LICENSE("GPL"); + +module_init(opal_rtc_init); +module_exit(opal_rtc_exit); From mboxrd@z Thu Jan 1 00:00:00 1970 From: Neelesh Gupta Subject: [PATCH v3] rtc/tpo: Driver to support rtc and wakeup on PowerNV platform Date: Tue, 14 Oct 2014 14:08:36 +0530 Message-ID: <20141014083447.7505.89771.stgit@localhost.localdomain> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" To: devicetree@vger.kernel.org, tglx@linutronix.de, linuxppc-dev@lists.ozlabs.org, rtc-linux@googlegroups.com, a.zummo@towertech.it Cc: benh@au1.ibm.com List-Id: devicetree@vger.kernel.org VGhlIHBhdGNoIGltcGxlbWVudHMgdGhlIE9QQUwgcnRjIGRyaXZlciB0aGF0IGJpbmRzIHdpdGgg dGhlIHJ0Ywpkcml2ZXIgc3Vic3lzdGVtLiBUaGUgZHJpdmVyIHVzZXMgdGhlIHBsYXRmb3JtIGRl dmljZSBpbmZyYXN0cnVjdHVyZQp0byBwcm9iZSB0aGUgcnRjIGRldmljZSBhbmQgcmVnaXN0ZXIg aXQgdG8gcnRjIGNsYXNzIGZyYW1ld29yay4gVGhlCid3YWtldXAnIGlzIHN1cHBvcnRlZCBkZXBl bmRpbmcgdXBvbiB0aGUgcHJvcGVydHkgJ2hhcy10cG8nIHByZXNlbnQKaW4gdGhlIE9GIG5vZGUu IEl0IHByb3ZpZGVzIGEgd2F5IHRvIGxvYWQgdGhlIGdlbmVyaWMgcnRjIGRyaXZlciBpbgppbiB0 aGUgYWJzZW5jZSBvZiBhbiBPUEFMIGRyaXZlci4KClRoZSBwYXRjaCBhbHNvIG1vdmVzIHRoZSBl eGlzdGluZyBPUEFMIHJ0YyBnZXQvc2V0IHRpbWUgaW50ZXJmYWNlcyB0byB0aGUKbmV3IGRyaXZl ciBhbmQgZXhwb3NlcyB0aGUgbmVjZXNzYXJ5IE9QQUwgY2FsbHMgdXNpbmcgRVhQT1JUX1NZTUJP TF9HUEwuCgpUZXN0IHJlc3VsdHM6Ci0tLS0tLS0tLS0tLS0KSG9zdDoKW3Jvb3RAdHVsMTY5cDEg fl0jIGxzIC1sIC9zeXMvY2xhc3MvcnRjLwp0b3RhbCAwCmxyd3hyd3hyd3ggMSByb290IHJvb3Qg MCBPY3QgMTQgMDM6MDcgcnRjMCAtPiAuLi8uLi9kZXZpY2VzL29wYWwtcnRjL3J0Yy9ydGMwClty b290QHR1bDE2OXAxIH5dIyBjYXQgL3N5cy9kZXZpY2VzL29wYWwtcnRjL3J0Yy9ydGMwL3RpbWUK MDg6MTA6MDcKW3Jvb3RAdHVsMTY5cDEgfl0jIGVjaG8gYGRhdGUgJyslcycgLWQgJysgMiBtaW51 dGVzJ2AgPiAvc3lzL2NsYXNzL3J0Yy9ydGMwL3dha2VhbGFybQpbcm9vdEB0dWwxNjlwMSB+XSMg Y2F0IC9zeXMvY2xhc3MvcnRjL3J0YzAvd2FrZWFsYXJtCjE0MTMyNzQzNDUKW3Jvb3RAdHVsMTY5 cDEgfl0jCgpGU1A6CiQgc21nciBtZmdTdGF0ZQpzdGFuZGJ5CiQgcnRpbSB0aW1lb2ZkYXkKClN5 c3RlbSB0aW1lIGlzIHZhbGlkOiAyMDE0LzEwLzE0IDA4OjEyOjA0LjIyNTExNQoKJCBzbWdyIG1m Z1N0YXRlCmlwbGluZwokIAoKU2lnbmVkLW9mZi1ieTogTmVlbGVzaCBHdXB0YSA8bmVlbGVndXBA bGludXgudm5ldC5pYm0uY29tPgotLS0KCkNoYW5nZXMgaW4gdjMKPT09PT09PT09PT09PQotIFJl YmFzZWQgdG8gdGhlIGxhdGVzdCB0cmVlLgoKQ2hhbmdlcyBpbiB2Mgo9PT09PT09PT09PT09Ci0g QWRkZWQgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3J0Yy9ydGMtb3BhbC50eHQK LSBFeHBsaWNpdGx5IHR1cm4gb2ZmIFJUQ19VSUUgbW9kZSBieSBzZXR0aW5nICdydGMtPnVpZV91 bnN1cHBvcnRlZCcKCiBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcnRjL3J0Yy1v cGFsLnR4dCB8ICAgMTYgKwogYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL29wYWwuaCAgICAgICAg ICAgICAgICAgICAgfCAgICA3IC0KIGFyY2gvcG93ZXJwYy9rZXJuZWwvdGltZS5jICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAgMSAKIGFyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9v cGFsLWFzeW5jLmMgICAgICAgIHwgICAgMyAKIGFyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJu di9vcGFsLXJ0Yy5jICAgICAgICAgIHwgICA2NSArLS0tLQogYXJjaC9wb3dlcnBjL3BsYXRmb3Jt cy9wb3dlcm52L29wYWwtd3JhcHBlcnMuUyAgICAgfCAgICAyIAogYXJjaC9wb3dlcnBjL3BsYXRm b3Jtcy9wb3dlcm52L29wYWwuYyAgICAgICAgICAgICAgfCAgICA2IAogYXJjaC9wb3dlcnBjL3Bs YXRmb3Jtcy9wb3dlcm52L3NldHVwLmMgICAgICAgICAgICAgfCAgICAyIAogZHJpdmVycy9ydGMv S2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDExICsKIGRyaXZlcnMv cnRjL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMSAKIGRyaXZl cnMvcnRjL3J0Yy1vcGFsLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDI2MSArKysr KysrKysrKysrKysrKysrKwogMTEgZmlsZXMgY2hhbmdlZCwgMzI1IGluc2VydGlvbnMoKyksIDUw IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vZGV2aWNldHJl ZS9iaW5kaW5ncy9ydGMvcnRjLW9wYWwudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9y dGMvcnRjLW9wYWwuYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5k aW5ncy9ydGMvcnRjLW9wYWwudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdz L3J0Yy9ydGMtb3BhbC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWY4 N2U1ZQotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5n cy9ydGMvcnRjLW9wYWwudHh0CkBAIC0wLDAgKzEsMTYgQEAKK0lCTSBPUEFMIHJlYWwtdGltZSBj bG9jaworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK1JlcXVpcmVkIHByb3BlcnRpZXM6Cist IGNvbWFwYXRpYmxlOiBTaG91bGQgYmUgImlibSxvcGFsLXJ0YyIKKworT3B0aW9uYWwgcHJvcGVy dGllczoKKy0gaGFzLXRwbzogRGVjaWRlcyBpZiB0aGUgd2FrZXVwIGlzIHN1cHBvcnRlZCBvciBu b3QuCisKK0V4YW1wbGU6CisJcnRjIHsKKwkJY29tcGF0aWJsZSA9ICJpYm0sb3BhbC1ydGMiOwor CQloYXMtdHBvOworCQlwaGFuZGxlID0gPDB4MTAwMDAwMjk+OworCQlsaW51eCxwaGFuZGxlID0g PDB4MTAwMDAwMjk+OworCX07CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20v b3BhbC5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL29wYWwuaAppbmRleCA5MTI0YjBlLi4y YzIwNTYxIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vb3BhbC5oCisrKyBi L2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9vcGFsLmgKQEAgLTE1NCw2ICsxNTQsOCBAQCBzdHJ1 Y3Qgb3BhbF9zZ19saXN0IHsKICNkZWZpbmUgT1BBTF9IQU5ETEVfSE1JCQkJCTk4CiAjZGVmaW5l IE9QQUxfUkVHSVNURVJfRFVNUF9SRUdJT04JCTEwMQogI2RlZmluZSBPUEFMX1VOUkVHSVNURVJf RFVNUF9SRUdJT04JCTEwMgorI2RlZmluZSBPUEFMX1dSSVRFX1RQTwkJCQkxMDMKKyNkZWZpbmUg T1BBTF9SRUFEX1RQTwkJCQkxMDQKIAogI2lmbmRlZiBfX0FTU0VNQkxZX18KIApAQCAtODE5LDYg KzgyMSw5IEBAIGludDY0X3Qgb3BhbF9ydGNfcmVhZChfX2JlMzIgKnllYXJfbW9udGhfZGF5LAog CQkgICAgICBfX2JlNjQgKmhvdXJfbWludXRlX3NlY29uZF9taWxsaXNlY29uZCk7CiBpbnQ2NF90 IG9wYWxfcnRjX3dyaXRlKHVpbnQzMl90IHllYXJfbW9udGhfZGF5LAogCQkgICAgICAgdWludDY0 X3QgaG91cl9taW51dGVfc2Vjb25kX21pbGxpc2Vjb25kKTsKK2ludDY0X3Qgb3BhbF90cG9fcmVh ZCh1aW50NjRfdCB0b2tlbiwgX19iZTMyICp5ZWFyX21vbl9kYXksIF9fYmUzMiAqaG91cl9taW4p OworaW50NjRfdCBvcGFsX3Rwb193cml0ZSh1aW50NjRfdCB0b2tlbiwgdWludDMyX3QgeWVhcl9t b25fZGF5LAorCQkgICAgICAgdWludDMyX3QgaG91cl9taW4pOwogaW50NjRfdCBvcGFsX2NlY19w b3dlcl9kb3duKHVpbnQ2NF90IHJlcXVlc3QpOwogaW50NjRfdCBvcGFsX2NlY19yZWJvb3Qodm9p ZCk7CiBpbnQ2NF90IG9wYWxfcmVhZF9udnJhbSh1aW50NjRfdCBidWZmZXIsIHVpbnQ2NF90IHNp emUsIHVpbnQ2NF90IG9mZnNldCk7CkBAIC05OTIsOCArOTk3LDYgQEAgZXh0ZXJuIGludCBvcGFs X2FzeW5jX3dhaXRfcmVzcG9uc2UodWludDY0X3QgdG9rZW4sIHN0cnVjdCBvcGFsX21zZyAqbXNn KTsKIGV4dGVybiBpbnQgb3BhbF9nZXRfc2Vuc29yX2RhdGEodTMyIHNlbnNvcl9obmRsLCB1MzIg KnNlbnNvcl9kYXRhKTsKIAogc3RydWN0IHJ0Y190aW1lOwotZXh0ZXJuIGludCBvcGFsX3NldF9y dGNfdGltZShzdHJ1Y3QgcnRjX3RpbWUgKnRtKTsKLWV4dGVybiB2b2lkIG9wYWxfZ2V0X3J0Y190 aW1lKHN0cnVjdCBydGNfdGltZSAqdG0pOwogZXh0ZXJuIHVuc2lnbmVkIGxvbmcgb3BhbF9nZXRf Ym9vdF90aW1lKHZvaWQpOwogZXh0ZXJuIHZvaWQgb3BhbF9udnJhbV9pbml0KHZvaWQpOwogZXh0 ZXJuIHZvaWQgb3BhbF9mbGFzaF9pbml0KHZvaWQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBj L2tlcm5lbC90aW1lLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3RpbWUuYwppbmRleCA3NTA1NTk5 Li41NDQ5MGM3IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3RpbWUuYworKysgYi9h cmNoL3Bvd2VycGMva2VybmVsL3RpbWUuYwpAQCAtOTg5LDYgKzk4OSw3IEBAIHZvaWQgR3JlZ29y aWFuRGF5KHN0cnVjdCBydGNfdGltZSAqIHRtKQogCiAJdG0tPnRtX3dkYXkgPSBkYXkgJSA3Owog fQorRVhQT1JUX1NZTUJPTF9HUEwoR3JlZ29yaWFuRGF5KTsKIAogdm9pZCB0b190bShpbnQgdGlt LCBzdHJ1Y3QgcnRjX3RpbWUgKiB0bSkKIHsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0 Zm9ybXMvcG93ZXJudi9vcGFsLWFzeW5jLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2Vy bnYvb3BhbC1hc3luYy5jCmluZGV4IGU0NjJhYjkuLjY5M2I2Y2QgMTAwNjQ0Ci0tLSBhL2FyY2gv cG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9vcGFsLWFzeW5jLmMKKysrIGIvYXJjaC9wb3dlcnBj L3BsYXRmb3Jtcy9wb3dlcm52L29wYWwtYXN5bmMuYwpAQCAtNzEsNiArNzEsNyBAQCBpbnQgb3Bh bF9hc3luY19nZXRfdG9rZW5faW50ZXJydXB0aWJsZSh2b2lkKQogCiAJcmV0dXJuIHRva2VuOwog fQorRVhQT1JUX1NZTUJPTF9HUEwob3BhbF9hc3luY19nZXRfdG9rZW5faW50ZXJydXB0aWJsZSk7 CiAKIGludCBfX29wYWxfYXN5bmNfcmVsZWFzZV90b2tlbihpbnQgdG9rZW4pCiB7CkBAIC0xMDIs NiArMTAzLDcgQEAgaW50IG9wYWxfYXN5bmNfcmVsZWFzZV90b2tlbihpbnQgdG9rZW4pCiAKIAly ZXR1cm4gMDsKIH0KK0VYUE9SVF9TWU1CT0xfR1BMKG9wYWxfYXN5bmNfcmVsZWFzZV90b2tlbik7 CiAKIGludCBvcGFsX2FzeW5jX3dhaXRfcmVzcG9uc2UodWludDY0X3QgdG9rZW4sIHN0cnVjdCBv cGFsX21zZyAqbXNnKQogewpAQCAtMTIwLDYgKzEyMiw3IEBAIGludCBvcGFsX2FzeW5jX3dhaXRf cmVzcG9uc2UodWludDY0X3QgdG9rZW4sIHN0cnVjdCBvcGFsX21zZyAqbXNnKQogCiAJcmV0dXJu IDA7CiB9CitFWFBPUlRfU1lNQk9MX0dQTChvcGFsX2FzeW5jX3dhaXRfcmVzcG9uc2UpOwogCiBz dGF0aWMgaW50IG9wYWxfYXN5bmNfY29tcF9ldmVudChzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5i LAogCQl1bnNpZ25lZCBsb25nIG1zZ190eXBlLCB2b2lkICptc2cpCmRpZmYgLS1naXQgYS9hcmNo L3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvb3BhbC1ydGMuYyBiL2FyY2gvcG93ZXJwYy9wbGF0 Zm9ybXMvcG93ZXJudi9vcGFsLXJ0Yy5jCmluZGV4IDQ5OTcwN2QuLjM3ZGJlZTEgMTAwNjQ0Ci0t LSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9vcGFsLXJ0Yy5jCisrKyBiL2FyY2gv cG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9vcGFsLXJ0Yy5jCkBAIC0xNSw2ICsxNSw4IEBACiAj aW5jbHVkZSA8bGludXgvYmNkLmg+CiAjaW5jbHVkZSA8bGludXgvcnRjLmg+CiAjaW5jbHVkZSA8 bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNs dWRlIDxsaW51eC9vZl9wbGF0Zm9ybS5oPgogCiAjaW5jbHVkZSA8YXNtL29wYWwuaD4KICNpbmNs dWRlIDxhc20vZmlybXdhcmUuaD4KQEAgLTQzLDcgKzQ1LDcgQEAgdW5zaWduZWQgbG9uZyBfX2lu aXQgb3BhbF9nZXRfYm9vdF90aW1lKHZvaWQpCiAJbG9uZyByYyA9IE9QQUxfQlVTWTsKIAogCWlm ICghb3BhbF9jaGVja190b2tlbihPUEFMX1JUQ19SRUFEKSkKLQkJZ290byBvdXQ7CisJCXJldHVy biAwOwogCiAJd2hpbGUgKHJjID09IE9QQUxfQlVTWSB8fCByYyA9PSBPUEFMX0JVU1lfRVZFTlQp IHsKIAkJcmMgPSBvcGFsX3J0Y19yZWFkKCZfX3lfbV9kLCAmX19oX21fc19tcyk7CkBAIC01Myw2 MiArNTUsMzMgQEAgdW5zaWduZWQgbG9uZyBfX2luaXQgb3BhbF9nZXRfYm9vdF90aW1lKHZvaWQp CiAJCQltZGVsYXkoMTApOwogCX0KIAlpZiAocmMgIT0gT1BBTF9TVUNDRVNTKQotCQlnb3RvIG91 dDsKKwkJcmV0dXJuIDA7CiAKIAl5X21fZCA9IGJlMzJfdG9fY3B1KF9feV9tX2QpOwogCWhfbV9z X21zID0gYmU2NF90b19jcHUoX19oX21fc19tcyk7CiAJb3BhbF90b190bSh5X21fZCwgaF9tX3Nf bXMsICZ0bSk7CiAJcmV0dXJuIG1rdGltZSh0bS50bV95ZWFyICsgMTkwMCwgdG0udG1fbW9uICsg MSwgdG0udG1fbWRheSwKIAkJICAgICAgdG0udG1faG91ciwgdG0udG1fbWluLCB0bS50bV9zZWMp Owotb3V0OgotCXBwY19tZC5nZXRfcnRjX3RpbWUgPSBOVUxMOwotCXBwY19tZC5zZXRfcnRjX3Rp bWUgPSBOVUxMOwotCXJldHVybiAwOwogfQogCi12b2lkIG9wYWxfZ2V0X3J0Y190aW1lKHN0cnVj dCBydGNfdGltZSAqdG0pCitzdGF0aWMgX19pbml0IGludCBvcGFsX3RpbWVfaW5pdCh2b2lkKQog ewotCWxvbmcgcmMgPSBPUEFMX0JVU1k7Ci0JdTMyIHlfbV9kOwotCXU2NCBoX21fc19tczsKLQlf X2JlMzIgX195X21fZDsKLQlfX2JlNjQgX19oX21fc19tczsKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2 aWNlICpwZGV2OworCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcnRjOwogCi0Jd2hpbGUgKHJjID09IE9Q QUxfQlVTWSB8fCByYyA9PSBPUEFMX0JVU1lfRVZFTlQpIHsKLQkJcmMgPSBvcGFsX3J0Y19yZWFk KCZfX3lfbV9kLCAmX19oX21fc19tcyk7Ci0JCWlmIChyYyA9PSBPUEFMX0JVU1lfRVZFTlQpCi0J CQlvcGFsX3BvbGxfZXZlbnRzKE5VTEwpOworCXJ0YyA9IG9mX2ZpbmRfbm9kZV9ieV9wYXRoKCIv aWJtLG9wYWwvcnRjIik7CisJaWYgKHJ0YykgeworCQlwZGV2ID0gb2ZfcGxhdGZvcm1fZGV2aWNl X2NyZWF0ZShydGMsICJvcGFsLXJ0YyIsIE5VTEwpOworCQlvZl9ub2RlX3B1dChydGMpOworCX0g ZWxzZSB7CisJCWlmIChvcGFsX2NoZWNrX3Rva2VuKE9QQUxfUlRDX1JFQUQpIHx8CisJCSAgICBv cGFsX2NoZWNrX3Rva2VuKE9QQUxfUkVBRF9UUE8pKQorCQkJcGRldiA9IHBsYXRmb3JtX2Rldmlj ZV9yZWdpc3Rlcl9zaW1wbGUoIm9wYWwtcnRjIiwgLTEsCisJCQkJCQkJICAgICAgIE5VTEwsIDAp OwogCQllbHNlCi0JCQltZGVsYXkoMTApOworCQkJcmV0dXJuIC1FTk9ERVY7CiAJfQotCWlmIChy YyAhPSBPUEFMX1NVQ0NFU1MpCi0JCXJldHVybjsKLQl5X21fZCA9IGJlMzJfdG9fY3B1KF9feV9t X2QpOwotCWhfbV9zX21zID0gYmU2NF90b19jcHUoX19oX21fc19tcyk7Ci0Jb3BhbF90b190bSh5 X21fZCwgaF9tX3NfbXMsIHRtKTsKLX0KLQotaW50IG9wYWxfc2V0X3J0Y190aW1lKHN0cnVjdCBy dGNfdGltZSAqdG0pCi17Ci0JbG9uZyByYyA9IE9QQUxfQlVTWTsKLQl1MzIgeV9tX2QgPSAwOwot CXU2NCBoX21fc19tcyA9IDA7Ci0KLQl5X21fZCB8PSAoKHUzMiliaW4yYmNkKCh0bS0+dG1feWVh ciArIDE5MDApIC8gMTAwKSkgPDwgMjQ7Ci0JeV9tX2QgfD0gKCh1MzIpYmluMmJjZCgodG0tPnRt X3llYXIgKyAxOTAwKSAlIDEwMCkpIDw8IDE2OwotCXlfbV9kIHw9ICgodTMyKWJpbjJiY2QoKHRt LT50bV9tb24gKyAxKSkpIDw8IDg7Ci0JeV9tX2QgfD0gKCh1MzIpYmluMmJjZCh0bS0+dG1fbWRh eSkpOwotCi0JaF9tX3NfbXMgfD0gKCh1NjQpYmluMmJjZCh0bS0+dG1faG91cikpIDw8IDU2Owot CWhfbV9zX21zIHw9ICgodTY0KWJpbjJiY2QodG0tPnRtX21pbikpIDw8IDQ4OwotCWhfbV9zX21z IHw9ICgodTY0KWJpbjJiY2QodG0tPnRtX3NlYykpIDw8IDQwOwogCi0Jd2hpbGUgKHJjID09IE9Q QUxfQlVTWSB8fCByYyA9PSBPUEFMX0JVU1lfRVZFTlQpIHsKLQkJcmMgPSBvcGFsX3J0Y193cml0 ZSh5X21fZCwgaF9tX3NfbXMpOwotCQlpZiAocmMgPT0gT1BBTF9CVVNZX0VWRU5UKQotCQkJb3Bh bF9wb2xsX2V2ZW50cyhOVUxMKTsKLQkJZWxzZQotCQkJbWRlbGF5KDEwKTsKLQl9Ci0JcmV0dXJu IHJjID09IE9QQUxfU1VDQ0VTUyA/IDAgOiAtRUlPOworCXJldHVybiBQVFJfRVJSX09SX1pFUk8o cGRldik7CiB9CittYWNoaW5lX3N1YnN5c19pbml0Y2FsbChwb3dlcm52LCBvcGFsX3RpbWVfaW5p dCk7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybnYvb3BhbC13cmFw cGVycy5TIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L29wYWwtd3JhcHBlcnMuUwpp bmRleCBlOWUyNDUwLi43ZDdlN2E4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1z L3Bvd2VybnYvb3BhbC13cmFwcGVycy5TCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93 ZXJudi9vcGFsLXdyYXBwZXJzLlMKQEAgLTI1MCwzICsyNTAsNSBAQCBPUEFMX0NBTEwob3BhbF9o YW5kbGVfaG1pLAkJCU9QQUxfSEFORExFX0hNSSk7CiBPUEFMX0NBTEwob3BhbF9yZWdpc3Rlcl9k dW1wX3JlZ2lvbiwJCU9QQUxfUkVHSVNURVJfRFVNUF9SRUdJT04pOwogT1BBTF9DQUxMKG9wYWxf dW5yZWdpc3Rlcl9kdW1wX3JlZ2lvbiwJCU9QQUxfVU5SRUdJU1RFUl9EVU1QX1JFR0lPTik7CiBP UEFMX0NBTEwob3BhbF9wY2lfc2V0X3BoYl9jeGxfbW9kZSwJCU9QQUxfUENJX1NFVF9QSEJfQ1hM X01PREUpOworT1BBTF9DQUxMKG9wYWxfdHBvX3dyaXRlLAkJCU9QQUxfV1JJVEVfVFBPKTsKK09Q QUxfQ0FMTChvcGFsX3Rwb19yZWFkLAkJCU9QQUxfUkVBRF9UUE8pOwpkaWZmIC0tZ2l0IGEvYXJj aC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L29wYWwuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9y bXMvcG93ZXJudi9vcGFsLmMKaW5kZXggYjY0MmIwNS4uN2E3MzY1YSAxMDA2NDQKLS0tIGEvYXJj aC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L29wYWwuYworKysgYi9hcmNoL3Bvd2VycGMvcGxh dGZvcm1zL3Bvd2VybnYvb3BhbC5jCkBAIC03ODQsMyArNzg0LDkgQEAgdm9pZCBvcGFsX2ZyZWVf c2dfbGlzdChzdHJ1Y3Qgb3BhbF9zZ19saXN0ICpzZykKIAkJCXNnID0gTlVMTDsKIAl9CiB9CisK K0VYUE9SVF9TWU1CT0xfR1BMKG9wYWxfcG9sbF9ldmVudHMpOworRVhQT1JUX1NZTUJPTF9HUEwo b3BhbF9ydGNfcmVhZCk7CitFWFBPUlRfU1lNQk9MX0dQTChvcGFsX3J0Y193cml0ZSk7CitFWFBP UlRfU1lNQk9MX0dQTChvcGFsX3Rwb19yZWFkKTsKK0VYUE9SVF9TWU1CT0xfR1BMKG9wYWxfdHBv X3dyaXRlKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcG93ZXJudi9zZXR1 cC5jIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L3NldHVwLmMKaW5kZXggM2Y5NTQ2 ZC4uOTc1OTMzOCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L3Nl dHVwLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm52L3NldHVwLmMKQEAgLTI2 NSw4ICsyNjUsNiBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBwbnZfbWVtb3J5X2Jsb2NrX3NpemUo dm9pZCkKIHN0YXRpYyB2b2lkIF9faW5pdCBwbnZfc2V0dXBfbWFjaGRlcF9vcGFsKHZvaWQpCiB7 CiAJcHBjX21kLmdldF9ib290X3RpbWUgPSBvcGFsX2dldF9ib290X3RpbWU7Ci0JcHBjX21kLmdl dF9ydGNfdGltZSA9IG9wYWxfZ2V0X3J0Y190aW1lOwotCXBwY19tZC5zZXRfcnRjX3RpbWUgPSBv cGFsX3NldF9ydGNfdGltZTsKIAlwcGNfbWQucmVzdGFydCA9IHBudl9yZXN0YXJ0OwogCXBwY19t ZC5wb3dlcl9vZmYgPSBwbnZfcG93ZXJfb2ZmOwogCXBwY19tZC5oYWx0ID0gcG52X2hhbHQ7CmRp ZmYgLS1naXQgYS9kcml2ZXJzL3J0Yy9LY29uZmlnIGIvZHJpdmVycy9ydGMvS2NvbmZpZwppbmRl eCA4Y2QwYmVlLi4wZTM4Y2VjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3J0Yy9LY29uZmlnCisrKyBi L2RyaXZlcnMvcnRjL0tjb25maWcKQEAgLTk3OSw2ICs5NzksMTcgQEAgY29uZmlnIFJUQ19EUlZf TlVDOTAwCiAJICBJZiB5b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgdGhlIFJU QyBzdWJzeXN0ZW0gb2YgdGhlCiAJICBOVUM5MTAvTlVDOTIwIHVzZWQgaW4gZW1iZWRkZWQgc3lz dGVtcy4KIAorY29uZmlnIFJUQ19EUlZfT1BBTAorCXRyaXN0YXRlICJJQk0gT1BBTCBSVEMgZHJp dmVyIgorCWRlcGVuZHMgb24gUFBDX1BPV0VSTlYKKwlkZWZhdWx0IHkKKwloZWxwCisJICBJZiB5 b3Ugc2F5IHllcyBoZXJlIHlvdSBnZXQgc3VwcG9ydCBmb3IgdGhlIFBvd2VyTlYgcGxhdGZvcm0g UlRDCisJICBkcml2ZXIgYmFzZWQgb24gT1BBTCBpbnRlcmZhY2VzLgorCisJICBUaGlzIGRyaXZl ciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28sIHRoZSBtb2R1bGUKKwkgIHdp bGwgYmUgY2FsbGVkIHJ0Yy1vcGFsLgorCiBjb21tZW50ICJvbi1DUFUgUlRDIGRyaXZlcnMiCiAK IGNvbmZpZyBSVENfRFJWX0RBVklOQ0kKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL01ha2VmaWxl IGIvZHJpdmVycy9ydGMvTWFrZWZpbGUKaW5kZXggYjE4ODMyMy4uYzhlZjNlMSAxMDA2NDQKLS0t IGEvZHJpdmVycy9ydGMvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ydGMvTWFrZWZpbGUKQEAgLTky LDYgKzkyLDcgQEAgb2JqLSQoQ09ORklHX1JUQ19EUlZfTVNNNjI0MikJKz0gcnRjLW1zbTYyNDIu bwogb2JqLSQoQ09ORklHX1JUQ19EUlZfTVBDNTEyMSkJKz0gcnRjLW1wYzUxMjEubwogb2JqLSQo Q09ORklHX1JUQ19EUlZfTVYpCSs9IHJ0Yy1tdi5vCiBvYmotJChDT05GSUdfUlRDX0RSVl9OVUM5 MDApCSs9IHJ0Yy1udWM5MDAubworb2JqLSQoQ09ORklHX1JUQ19EUlZfT1BBTCkJKz0gcnRjLW9w YWwubwogb2JqLSQoQ09ORklHX1JUQ19EUlZfT01BUCkJKz0gcnRjLW9tYXAubwogb2JqLSQoQ09O RklHX1JUQ19EUlZfUEFMTUFTKQkrPSBydGMtcGFsbWFzLm8KIG9iai0kKENPTkZJR19SVENfRFJW X1BDQVApCSs9IHJ0Yy1wY2FwLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL3J0Yy1vcGFsLmMg Yi9kcml2ZXJzL3J0Yy9ydGMtb3BhbC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjk1ZjY1MjEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3J0Yy9ydGMtb3BhbC5jCkBA IC0wLDAgKzEsMjYxIEBACisvKgorICogSUJNIE9QQUwgUlRDIGRyaXZlcgorICogQ29weXJpZ2h0 IChDKSAyMDE0IElCTQorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5z ZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3Jh bS4KKyAqLworCisjZGVmaW5lIERSVk5BTUUJCSJydGMtb3BhbCIKKyNkZWZpbmUgcHJfZm10KGZt dCkJRFJWTkFNRSAiOiAiIGZtdAorCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVk ZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvcnRjLmg+CisjaW5jbHVkZSA8bGludXgv ZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9iY2QuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9y bV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGFzbS9vcGFsLmg+ CisjaW5jbHVkZSA8YXNtL2Zpcm13YXJlLmg+CisKK3N0YXRpYyB2b2lkIG9wYWxfdG9fdG0odTMy IHlfbV9kLCB1NjQgaF9tX3NfbXMsIHN0cnVjdCBydGNfdGltZSAqdG0pCit7CisJdG0tPnRtX3ll YXIgPSAoKGJjZDJiaW4oeV9tX2QgPj4gMjQpICogMTAwKSArCisJCSAgICAgICBiY2QyYmluKCh5 X21fZCA+PiAxNikgJiAweGZmKSkgLSAxOTAwOworCXRtLT50bV9tb24gID0gYmNkMmJpbigoeV9t X2QgPj4gOCkgJiAweGZmKSAtIDE7CisJdG0tPnRtX21kYXkgPSBiY2QyYmluKHlfbV9kICYgMHhm Zik7CisJdG0tPnRtX2hvdXIgPSBiY2QyYmluKChoX21fc19tcyA+PiA1NikgJiAweGZmKTsKKwl0 bS0+dG1fbWluICA9IGJjZDJiaW4oKGhfbV9zX21zID4+IDQ4KSAmIDB4ZmYpOworCXRtLT50bV9z ZWMgID0gYmNkMmJpbigoaF9tX3NfbXMgPj4gNDApICYgMHhmZik7CisKKwlHcmVnb3JpYW5EYXko dG0pOworfQorCitzdGF0aWMgdm9pZCB0bV90b19vcGFsKHN0cnVjdCBydGNfdGltZSAqdG0sIHUz MiAqeV9tX2QsIHU2NCAqaF9tX3NfbXMpCit7CisJKnlfbV9kIHw9ICgodTMyKWJpbjJiY2QoKHRt LT50bV95ZWFyICsgMTkwMCkgLyAxMDApKSA8PCAyNDsKKwkqeV9tX2QgfD0gKCh1MzIpYmluMmJj ZCgodG0tPnRtX3llYXIgKyAxOTAwKSAlIDEwMCkpIDw8IDE2OworCSp5X21fZCB8PSAoKHUzMili aW4yYmNkKCh0bS0+dG1fbW9uICsgMSkpKSA8PCA4OworCSp5X21fZCB8PSAoKHUzMiliaW4yYmNk KHRtLT50bV9tZGF5KSk7CisKKwkqaF9tX3NfbXMgfD0gKCh1NjQpYmluMmJjZCh0bS0+dG1faG91 cikpIDw8IDU2OworCSpoX21fc19tcyB8PSAoKHU2NCliaW4yYmNkKHRtLT50bV9taW4pKSA8PCA0 ODsKKwkqaF9tX3NfbXMgfD0gKCh1NjQpYmluMmJjZCh0bS0+dG1fc2VjKSkgPDwgNDA7Cit9CisK K3N0YXRpYyBpbnQgb3BhbF9nZXRfcnRjX3RpbWUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qg cnRjX3RpbWUgKnRtKQoreworCWxvbmcgcmMgPSBPUEFMX0JVU1k7CisJdTMyIHlfbV9kOworCXU2 NCBoX21fc19tczsKKwlfX2JlMzIgX195X21fZDsKKwlfX2JlNjQgX19oX21fc19tczsKKworCXdo aWxlIChyYyA9PSBPUEFMX0JVU1kgfHwgcmMgPT0gT1BBTF9CVVNZX0VWRU5UKSB7CisJCXJjID0g b3BhbF9ydGNfcmVhZCgmX195X21fZCwgJl9faF9tX3NfbXMpOworCQlpZiAocmMgPT0gT1BBTF9C VVNZX0VWRU5UKQorCQkJb3BhbF9wb2xsX2V2ZW50cyhOVUxMKTsKKwkJZWxzZQorCQkJbXNsZWVw KDEwKTsKKwl9CisKKwlpZiAocmMgIT0gT1BBTF9TVUNDRVNTKQorCQlyZXR1cm4gLUVJTzsKKwor CXlfbV9kID0gYmUzMl90b19jcHUoX195X21fZCk7CisJaF9tX3NfbXMgPSBiZTY0X3RvX2NwdShf X2hfbV9zX21zKTsKKwlvcGFsX3RvX3RtKHlfbV9kLCBoX21fc19tcywgdG0pOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgb3BhbF9zZXRfcnRjX3RpbWUoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3QgcnRjX3RpbWUgKnRtKQoreworCWxvbmcgcmMgPSBPUEFMX0JVU1k7CisJdTMyIHlf bV9kID0gMDsKKwl1NjQgaF9tX3NfbXMgPSAwOworCisJdG1fdG9fb3BhbCh0bSwgJnlfbV9kLCAm aF9tX3NfbXMpOworCXdoaWxlIChyYyA9PSBPUEFMX0JVU1kgfHwgcmMgPT0gT1BBTF9CVVNZX0VW RU5UKSB7CisJCXJjID0gb3BhbF9ydGNfd3JpdGUoeV9tX2QsIGhfbV9zX21zKTsKKwkJaWYgKHJj ID09IE9QQUxfQlVTWV9FVkVOVCkKKwkJCW9wYWxfcG9sbF9ldmVudHMoTlVMTCk7CisJCWVsc2UK KwkJCW1zbGVlcCgxMCk7CisJfQorCisJcmV0dXJuIHJjID09IE9QQUxfU1VDQ0VTUyA/IDAgOiAt RUlPOworfQorCisvKgorICogVFBPCVRpbWVkIFBvd2VyLU9uCisgKgorICogVFBPIGdldC9zZXQg T1BBTCBjYWxscyBjYXJlIGFib3V0IHRoZSBob3VyIGFuZCBtaW4gYW5kIHRvIG1ha2UgaXQgY29u c2lzdGVudAorICogd2l0aCB0aGUgcnRjIHV0aWxpdHkgdGltZSBjb252ZXJzaW9uIGZ1bmN0aW9u cywgd2UgdXNlIHRoZSAndTY0JyB0byBzdG9yZQorICogaXRzIHZhbHVlIGFuZCBwZXJmb3JtIGJp dCBzaGlmdCBieSAzMiBiZWZvcmUgdXNlLi4KKyAqLworc3RhdGljIGludCBvcGFsX2dldF90cG9f dGltZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBydGNfd2thbHJtICphbGFybSkKK3sKKwlf X2JlMzIgX195X21fZCwgX19oX207CisJc3RydWN0IG9wYWxfbXNnIG1zZzsKKwlpbnQgcmMsIHRv a2VuOworCXU2NCBoX21fc19tczsKKwl1MzIgeV9tX2Q7CisKKwl0b2tlbiA9IG9wYWxfYXN5bmNf Z2V0X3Rva2VuX2ludGVycnVwdGlibGUoKTsKKwlpZiAodG9rZW4gPCAwKSB7CisJCWlmICh0b2tl biAhPSAtRVJFU1RBUlRTWVMpCisJCQlwcl9lcnIoIkZhaWxlZCB0byBnZXQgdGhlIGFzeW5jIHRv a2VuXG4iKTsKKworCQlyZXR1cm4gdG9rZW47CisJfQorCisJcmMgPSBvcGFsX3Rwb19yZWFkKHRv a2VuLCAmX195X21fZCwgJl9faF9tKTsKKwlpZiAocmMgIT0gT1BBTF9BU1lOQ19DT01QTEVUSU9O KSB7CisJCXJjID0gLUVJTzsKKwkJZ290byBleGl0OworCX0KKworCXJjID0gb3BhbF9hc3luY193 YWl0X3Jlc3BvbnNlKHRva2VuLCAmbXNnKTsKKwlpZiAocmMpIHsKKwkJcmMgPSAtRUlPOworCQln b3RvIGV4aXQ7CisJfQorCisJcmMgPSBiZTY0X3RvX2NwdShtc2cucGFyYW1zWzFdKTsKKwlpZiAo cmMgIT0gT1BBTF9TVUNDRVNTKSB7CisJCXJjID0gLUVJTzsKKwkJZ290byBleGl0OworCX0KKwor CXlfbV9kID0gYmUzMl90b19jcHUoX195X21fZCk7CisJaF9tX3NfbXMgPSAoKHU2NCliZTMyX3Rv X2NwdShfX2hfbSkgPDwgMzIpOworCW9wYWxfdG9fdG0oeV9tX2QsIGhfbV9zX21zLCAmYWxhcm0t PnRpbWUpOworCitleGl0OgorCW9wYWxfYXN5bmNfcmVsZWFzZV90b2tlbih0b2tlbik7CisJcmV0 dXJuIHJjOworfQorCisvKiBTZXQgVGltZWQgUG93ZXItT24gKi8KK3N0YXRpYyBpbnQgb3BhbF9z ZXRfdHBvX3RpbWUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcnRjX3drYWxybSAqYWxhcm0p Cit7CisJdTY0IGhfbV9zX21zID0gMCwgdG9rZW47CisJc3RydWN0IG9wYWxfbXNnIG1zZzsKKwl1 MzIgeV9tX2QgPSAwOworCWludCByYzsKKworCXRtX3RvX29wYWwoJmFsYXJtLT50aW1lLCAmeV9t X2QsICZoX21fc19tcyk7CisKKwl0b2tlbiA9IG9wYWxfYXN5bmNfZ2V0X3Rva2VuX2ludGVycnVw dGlibGUoKTsKKwlpZiAodG9rZW4gPCAwKSB7CisJCWlmICh0b2tlbiAhPSAtRVJFU1RBUlRTWVMp CisJCQlwcl9lcnIoIkZhaWxlZCB0byBnZXQgdGhlIGFzeW5jIHRva2VuXG4iKTsKKworCQlyZXR1 cm4gdG9rZW47CisJfQorCisJLyogVFBPLCB3ZSBjYXJlIGFib3V0IGhvdXIgYW5kIG1pbnV0ZSAq LworCXJjID0gb3BhbF90cG9fd3JpdGUodG9rZW4sIHlfbV9kLAorCQkJICAgICh1MzIpKChoX21f c19tcyA+PiAzMikgJiAweGZmZmYwMDAwKSk7CisJaWYgKHJjICE9IE9QQUxfQVNZTkNfQ09NUExF VElPTikgeworCQlyYyA9IC1FSU87CisJCWdvdG8gZXhpdDsKKwl9CisKKwlyYyA9IG9wYWxfYXN5 bmNfd2FpdF9yZXNwb25zZSh0b2tlbiwgJm1zZyk7CisJaWYgKHJjKSB7CisJCXJjID0gLUVJTzsK KwkJZ290byBleGl0OworCX0KKworCXJjID0gYmU2NF90b19jcHUobXNnLnBhcmFtc1sxXSk7CisJ aWYgKHJjICE9IE9QQUxfU1VDQ0VTUykKKwkJcmMgPSAtRUlPOworCitleGl0OgorCW9wYWxfYXN5 bmNfcmVsZWFzZV90b2tlbih0b2tlbik7CisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgY29uc3Qg c3RydWN0IHJ0Y19jbGFzc19vcHMgb3BhbF9ydGNfb3BzID0geworCS5yZWFkX3RpbWUJPSBvcGFs X2dldF9ydGNfdGltZSwKKwkuc2V0X3RpbWUJPSBvcGFsX3NldF9ydGNfdGltZSwKKwkucmVhZF9h bGFybQk9IG9wYWxfZ2V0X3Rwb190aW1lLAorCS5zZXRfYWxhcm0JPSBvcGFsX3NldF90cG9fdGlt ZSwKK307CisKK3N0YXRpYyBpbnQgb3BhbF9ydGNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKK3sKKwlzdHJ1Y3QgcnRjX2RldmljZSAqcnRjOworCisJaWYgKHBkZXYtPmRldi5v Zl9ub2RlICYmIG9mX2dldF9wcm9wZXJ0eShwZGV2LT5kZXYub2Zfbm9kZSwgImhhcy10cG8iLAor CQkJCQkJIE5VTEwpKQorCQlkZXZpY2Vfc2V0X3dha2V1cF9jYXBhYmxlKCZwZGV2LT5kZXYsIHRy dWUpOworCisJcnRjID0gZGV2bV9ydGNfZGV2aWNlX3JlZ2lzdGVyKCZwZGV2LT5kZXYsIERSVk5B TUUsICZvcGFsX3J0Y19vcHMsCisJCQkJICAgICAgIFRISVNfTU9EVUxFKTsKKwlpZiAoSVNfRVJS KHJ0YykpCisJCXJldHVybiBQVFJfRVJSKHJ0Yyk7CisKKwlydGMtPnVpZV91bnN1cHBvcnRlZCA9 IDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQg b3BhbF9ydGNfbWF0Y2hbXSA9IHsKKwl7CisJCS5jb21wYXRpYmxlCT0gImlibSxvcGFsLXJ0YyIs CisJfSwKKwl7IH0KK307CitNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBvcGFsX3J0Y19tYXRjaCk7 CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlX2lkIG9wYWxfcnRjX2RyaXZl cl9pZHNbXSA9IHsKKwl7CisJCS5uYW1lCQk9ICJvcGFsLXJ0YyIsCisJfSwKKwl7IH0KK307CitN T0RVTEVfREVWSUNFX1RBQkxFKHBsYXRmb3JtLCBvcGFsX3J0Y19kcml2ZXJfaWRzKTsKKworc3Rh dGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgb3BhbF9ydGNfZHJpdmVyID0geworCS5wcm9iZQkJ PSBvcGFsX3J0Y19wcm9iZSwKKwkuaWRfdGFibGUJPSBvcGFsX3J0Y19kcml2ZXJfaWRzLAorCS5k cml2ZXIJCT0geworCQkubmFtZQkJPSBEUlZOQU1FLAorCQkub3duZXIJCT0gVEhJU19NT0RVTEUs CisJCS5vZl9tYXRjaF90YWJsZQk9IG9wYWxfcnRjX21hdGNoLAorCX0sCit9OworCitzdGF0aWMg aW50IF9faW5pdCBvcGFsX3J0Y19pbml0KHZvaWQpCit7CisJaWYgKCFmaXJtd2FyZV9oYXNfZmVh dHVyZShGV19GRUFUVVJFX09QQUwpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXJldHVybiBwbGF0 Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJm9wYWxfcnRjX2RyaXZlcik7Cit9CisKK3N0YXRpYyB2b2lk IF9fZXhpdCBvcGFsX3J0Y19leGl0KHZvaWQpCit7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0 ZXIoJm9wYWxfcnRjX2RyaXZlcik7Cit9CisKK01PRFVMRV9BVVRIT1IoIk5lZWxlc2ggR3VwdGEg PG5lZWxlZ3VwQGxpbnV4LnZuZXQuaWJtLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiSUJN IE9QQUwgUlRDIGRyaXZlciIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworCittb2R1bGVfaW5p dChvcGFsX3J0Y19pbml0KTsKK21vZHVsZV9leGl0KG9wYWxfcnRjX2V4aXQpOwoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXhwcGMtZGV2IG1haWxp bmcgbGlzdApMaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwpodHRwczovL2xpc3RzLm96bGFi cy5vcmcvbGlzdGluZm8vbGludXhwcGMtZGV2