From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755226AbbBLHRA (ORCPT ); Thu, 12 Feb 2015 02:17:00 -0500 Received: from m01.linkvast.com.tw ([203.67.208.22]:33795 "EHLO sism01.sis.com" rhost-flags-OK-FAIL-OK-OK) by vger.kernel.org with ESMTP id S1755126AbbBLHQ7 (ORCPT ); Thu, 12 Feb 2015 02:16:59 -0500 X-MimeOLE: Produced By Microsoft Exchange V6.5 Content-class: urn:content-classes:message MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Subject: Re: [PATCH 2/2] INPUT/HID: add touch support for SiS touch driver Date: Thu, 12 Feb 2015 15:16:43 +0800 Message-ID: <8322374EB97AA24A95D0DDBFC8F1CA1DCB0821@SISMBEV01.sis.com.tw> In-Reply-To: <20150212070342.GB38837@dtor-ws> X-MS-Has-Attach: X-MS-TNEF-Correlator: Thread-Topic: [PATCH 2/2] INPUT/HID: add touch support for SiS touch driver Thread-Index: AdBGkhXdNVnqDklbT/KhR3Sld2WlCgAAOp9g References: <8322374EB97AA24A95D0DDBFC8F1CA1DCB07FA@SISMBEV01.sis.com.tw> <20150212070342.GB38837@dtor-ws> From: =?UTF-8?B?5pu+5am36JGzICh0YW1teV90c2VuZyk=?= To: "Dmitry Torokhov" Cc: "Oliver Neukum" , "lkml" , , X-OriginalArrivalTime: 12 Feb 2015 07:16:44.0551 (UTC) FILETIME=[DB342970:01D04693] X-TM-AS-Product-Ver: SMEX-10.2.0.3176-7.500.1018-21324.002 X-TM-AS-Result: No--14.963900-0.000000-31 X-TM-AS-User-Approved-Sender: Yes X-TM-AS-User-Blocked-Sender: No X-Received-IP: 192.168.50.86 X-Envelope-From: X-Sherlock-Send: MailFilter (sism01.sis.com) X-License: 1 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by nfs id t1C7H8pw028044 Hi, Dmitry > -----Original Message----- > From: Dmitry Torokhov [mailto:dmitry.torokhov@gmail.com] > Sent: Thursday, February 12, 2015 3:04 PM > To: 曾婷葳 (tammy_tseng) > Cc: Oliver Neukum; lkml; linux-input@vger.kernel.org; tammy0524@gmail.com > Subject: Re: [PATCH 2/2] INPUT/HID: add touch support for SiS touch > driver > > Hi Tammy, > > On Thu, Feb 12, 2015 at 02:07:26PM +0800, 曾婷葳 (tammy_tseng) wrote: > > Hi, > > > > > > > > I've checked the coding style and modified the i2c and hid touch driver for sis > touch controller. > > > > Please help review them. > > > > Thanks a lot. > > This was sent as HTML so mailing lists dropped it. > > Thanks. > > -- > Dmitry Sorry. Re-send the code diff again. Here is the hid touch driver for sis touch controller. Thanks. Tammy ----- linux-3.18.5/drivers/hid/Kconfig | 14 ++ linux-3.18.5/drivers/hid/hid-ids.h | 1 + linux-3.18.5/drivers/hid/hid-multitouch.c | 16 ++ linux-3.18.5/drivers/hid/hid-sis_ctrl.c | 360 +++++++++++++++++++++++++++ linux-3.18.5/drivers/hid/usbhid/hid-quirks.c | 1 + 5 files changed, 392 insertions(+) ----- diff --git a/linux-3.18.5/drivers/hid/Kconfig b/linux-3.18.5/drivers/hid/Kconfig index f42df4d..2235cfe 100644 --- a/linux-3.18.5/drivers/hid/Kconfig +++ b/linux-3.18.5/drivers/hid/Kconfig @@ -496,6 +496,20 @@ config HID_MULTITOUCH To compile this driver as a module, choose M here: the module will be called hid-multitouch. +config HID_SIS_CTRL + bool "SiS Touch Device Controller" + depends on HID_MULTITOUCH + ---help--- + Support for SiS Touch devices update FW. + +config DEBUG_HID_SIS_UPDATE_FW + bool "SiS Touch device debug message(update firmware)" + depends on HID_SIS_CTRL + default n + ---help--- + Say Y here if you want to enable debug message(update firmware) for SiS Touch + devices. Must enable config HID_SIS_UPDATE_FW first. + config HID_NTRIG tristate "N-Trig touch screen" depends on USB_HID diff --git a/linux-3.18.5/drivers/hid/hid-ids.h b/linux-3.18.5/drivers/hid/hid-ids.h index 0e28190..b9ca441 100644 --- a/linux-3.18.5/drivers/hid/hid-ids.h +++ b/linux-3.18.5/drivers/hid/hid-ids.h @@ -809,6 +809,7 @@ #define USB_VENDOR_ID_SIS_TOUCH 0x0457 #define USB_DEVICE_ID_SIS9200_TOUCH 0x9200 #define USB_DEVICE_ID_SIS817_TOUCH 0x0817 +#define USB_DEVICE_ID_SISF817_TOUCH 0xF817 #define USB_DEVICE_ID_SIS_TS 0x1013 #define USB_DEVICE_ID_SIS1030_TOUCH 0x1030 diff --git a/linux-3.18.5/drivers/hid/hid-multitouch.c b/linux-3.18.5/drivers/hid/hid-multitouch.c index 51e25b9..11d67bc 100644 --- a/linux-3.18.5/drivers/hid/hid-multitouch.c +++ b/linux-3.18.5/drivers/hid/hid-multitouch.c @@ -54,6 +54,10 @@ MODULE_LICENSE("GPL"); #include "hid-ids.h" +#ifdef CONFIG_HID_SIS_CTRL +#include "hid-sis_ctrl.c" +#endif + /* quirks to control the device */ #define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0) #define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1) @@ -951,6 +955,14 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) } } +#ifdef CONFIG_HID_SIS_CTRL + if (hdev->vendor == USB_VENDOR_ID_SIS_TOUCH) { + ret = sis_setup_chardev(hdev); + if (ret) + dev_err(&hdev->dev, "sis_setup_chardev fail\n"); + } +#endif + /* This allows the driver to correctly support devices * that emit events over several HID messages. */ @@ -1043,6 +1055,10 @@ static void mt_remove(struct hid_device *hdev) { sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group); hid_hw_stop(hdev); +#ifdef CONFIG_HID_SIS_CTRL + if (hdev->vendor == USB_VENDOR_ID_SIS_TOUCH) + sis_deinit_chardev(); +#endif } /* diff --git a/linux-3.18.5/drivers/hid/hid-sis_ctrl.c b/linux-3.18.5/drivers/hid/hid-sis_ctrl.c new file mode 100644 index 0000000..3a7b3df --- /dev/null +++ b/linux-3.18.5/drivers/hid/hid-sis_ctrl.c @@ -0,0 +1,360 @@ +/* + * Character device driver for SIS multitouch panels control + * + * Copyright (c) 2009 SIS, Ltd. + * + */ + +/* + * 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. + */ + +#include +#include +#include +#include "usbhid/usbhid.h" +#include + +/*update FW*/ +#include +#include +/*#include */ /*copy_from_user() & copy_to_user()*/ +#include + +#include "hid-ids.h" + +#define SIS817_DEVICE_NAME "sis_aegis_hid_touch_device" +#define SISF817_DEVICE_NAME "sis_aegis_hid_bridge_touch_device" + +#define CTRL 0 +#define ENDP_01 1 +#define ENDP_02 2 +#define DIR_IN 0x1 + +#define SIS_ERR_ALLOCATE_KERNEL_MEM -12 /* Allocate memory fail */ +#define SIS_ERR_COPY_FROM_USER -14 /* Copy data from user fail */ +#define SIS_ERR_COPY_FROM_KERNEL -19 /* Copy data from kernel fail */ + +static const int sis_char_devs_count = 1; /* device count */ +static int sis_char_major; +static struct cdev sis_char_cdev; +static struct class *sis_char_class; + +static struct hid_device *hid_dev_backup; /*backup address*/ +static struct urb *backup_urb; + +#ifdef CONFIG_DEBUG_HID_SIS_UPDATE_FW + #define DBG_FW(fmt, arg...) printk(fmt, ##arg) + static void sis_dbg_dump_array(u8 *ptr, u32 size) + { + u32 i; + + for (i = 0; i < size; i++) { + DBG_FW("%02X ", ptr[i]); + if (((i+1)&0xF) == 0) + DBG_FW("\n"); + } + if (size & 0xF) + DBG_FW("\n"); + } +#else + #define DBG_FW(...) + #define sis_dbg_dump_array(...) +#endif /*CONFIG_DEBUG_HID_SIS_UPDATE_FW*/ + +/*20120306 Yuger ioctl for tool*/ +static int sis_cdev_open(struct inode *inode, struct file *filp) +{ + struct usbhid_device *usbhid; + + DBG_FW("%s\n" , __func__); + /*20110511, Yuger, kill current urb by method of usbhid_stop*/ + if (!hid_dev_backup) { + pr_info("(stop)hid_dev_backup is not initialized yet"); + return -1; + } + + usbhid = hid_dev_backup->driver_data; + + pr_info("sys_sis_HID_stop\n"); + + /* printk( KERN_INFO "hid_dev_backup->vendor, + * hid_dev_backup->product = %x %x\n", hid_dev_backup->vendor, + * hid_dev_backup->product );*/ + + /*20110602, Yuger, fix bug: not contact usb cause kernel panic*/ + if (!usbhid) { + pr_info("(stop)usbhid is not initialized yet"); + return -1; + } else if (!usbhid->urbin) { + pr_info("(stop)usbhid->urbin is not initialized yet"); + return -1; + } else if (hid_dev_backup->vendor == USB_VENDOR_ID_SIS_TOUCH) { + usb_fill_int_urb(backup_urb, + usbhid->urbin->dev, + usbhid->urbin->pipe, + usbhid->urbin->transfer_buffer, + usbhid->urbin->transfer_buffer_length, + usbhid->urbin->complete, + usbhid->urbin->context, + usbhid->urbin->interval); + clear_bit(HID_STARTED, &usbhid->iofl); + set_bit(HID_DISCONNECTED, &usbhid->iofl); + + usb_kill_urb(usbhid->urbin); + usb_free_urb(usbhid->urbin); + usbhid->urbin = NULL; + return 0; + } + + pr_info("This is not a SiS device"); + return -801; +} + +static int sis_cdev_release(struct inode *inode, struct file *filp) +{ + /*20110505, Yuger, rebuild the urb which is at the same urb address, + * then re-submit it*/ + + int ret; + struct usbhid_device *usbhid; + unsigned long flags; + + DBG_FW("%s: ", __func__); + + if (!hid_dev_backup) { + pr_info("(stop)hid_dev_backup is not initialized yet"); + return -1; + } + + usbhid = hid_dev_backup->driver_data; + + pr_info("sys_sis_HID_start"); + + if (!usbhid) { + pr_info("(start)usbhid is not initialized yet"); + return -1; + } + + if (!backup_urb) { + pr_info("(start)backup_urb is not initialized yet"); + return -1; + } + + clear_bit(HID_DISCONNECTED, &usbhid->iofl); + usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL); + + if (!backup_urb->interval) { + pr_info("(start)backup_urb->interval does not exist"); + return -1; + } + + usb_fill_int_urb(usbhid->urbin, backup_urb->dev, backup_urb->pipe, + backup_urb->transfer_buffer, backup_urb->transfer_buffer_length, + backup_urb->complete, backup_urb->context, backup_urb->interval); + usbhid->urbin->transfer_dma = usbhid->inbuf_dma; + usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + + set_bit(HID_STARTED, &usbhid->iofl); + + /*method at hid_start_in*/ + spin_lock_irqsave(&usbhid->lock, flags); + ret = usb_submit_urb(usbhid->urbin, GFP_ATOMIC); + spin_unlock_irqrestore(&usbhid->lock, flags); + /*yy*/ + + DBG_FW("ret = %d", ret); + + return ret; +} + +/*SiS 817 only*/ +static ssize_t sis_cdev_read(struct file *file, char __user *buf, + size_t count, loff_t *ppos) +{ + int actual_length = 0; + u8 *rep_data = NULL; + u32 size, timeout; + long rep_ret = 0; + struct usb_interface *intf = + to_usb_interface(hid_dev_backup->dev.parent); + struct usb_device *dev = interface_to_usbdev(intf); + + DBG_FW("%s\n", __func__); + + rep_data = kzalloc(count, GFP_KERNEL); + if (!rep_data) + return SIS_ERR_ALLOCATE_KERNEL_MEM; + + if (copy_from_user(rep_data, (void *)buf, count)) { + pr_err("copy_to_user fail\n"); + rep_ret = SIS_ERR_COPY_FROM_USER; + goto end; + } + size = be32_to_cpup((u32 *)&rep_data[64]); + timeout = be32_to_cpup((u32 *)&rep_data[68]); + + rep_ret = usb_interrupt_msg(dev, backup_urb->pipe, + rep_data, size, &actual_length, timeout); + + DBG_FW("%s: rep_data = ", __func__); + sis_dbg_dump_array(rep_data, 8); + + if (rep_ret == 0) { + rep_ret = actual_length; + if (copy_to_user((void *)buf, rep_data, rep_ret)) { + pr_err("copy_to_user fail\n"); + rep_ret = SIS_ERR_COPY_FROM_KERNEL; + goto end; + } + } + DBG_FW("%s: rep_ret = %ld\n", __func__, rep_ret); +end: + /*free allocated data*/ + kfree(rep_data); + return rep_ret; +} + +static ssize_t sis_cdev_write(struct file *file, const char __user *buf, + size_t count, loff_t *f_pos) +{ + int actual_length = 0; + u8 *rep_data = NULL; + long rep_ret = 0; + struct usb_interface *intf = + to_usb_interface(hid_dev_backup->dev.parent); + struct usb_device *dev = interface_to_usbdev(intf); + struct usbhid_device *usbhid = hid_dev_backup->driver_data; + u32 size, timeout; + + rep_data = kzalloc(count, GFP_KERNEL); + if (!rep_data) + return SIS_ERR_ALLOCATE_KERNEL_MEM; + + if (copy_from_user(rep_data, (void *)buf, count)) { + pr_err("copy_to_user fail\n"); + rep_ret = SIS_ERR_COPY_FROM_USER; + goto end; + } + + size = be32_to_cpup((u32 *)&rep_data[64]); + timeout = be32_to_cpup((u32 *)&rep_data[68]); + + rep_ret = usb_interrupt_msg(dev, usbhid->urbout->pipe, + rep_data, size, &actual_length, timeout); + + DBG_FW("%s: rep_data = ", __func__); + sis_dbg_dump_array(rep_data, size); + + if (rep_ret == 0) { + rep_ret = actual_length; + if (copy_to_user((void *)buf, rep_data, rep_ret)) { + pr_err("copy_to_user fail\n"); + rep_ret = SIS_ERR_COPY_FROM_KERNEL; + goto end; + } + } + DBG_FW("%s: rep_ret = %ld\n", __func__, rep_ret); + DBG_FW("End of sys_sis_HID_IO\n"); +end: + /*free allocated data*/ + kfree(rep_data); + return rep_ret; +} + + +/*for ioctl*/ +static const struct file_operations sis_cdev_fops = { + .owner = THIS_MODULE, + .read = sis_cdev_read, + .write = sis_cdev_write, + .open = sis_cdev_open, + .release = sis_cdev_release, +}; + +/*for ioctl*/ +static int sis_setup_chardev(struct hid_device *hdev) +{ + dev_t dev = MKDEV(sis_char_major, 0); + int ret = 0; + struct device *class_dev = NULL; + u8 *name = (hdev->product == USB_DEVICE_ID_SISF817_TOUCH) ? + SISF817_DEVICE_NAME : SIS817_DEVICE_NAME; + + dev_info(&hdev->dev, "sis_setup_chardev.\n"); + + backup_urb = usb_alloc_urb(0, GFP_KERNEL); /*0721test*/ + if (!backup_urb) { + dev_err(&hdev->dev, "cannot allocate backup_urb\n"); + return -ENOMEM; + } + hid_dev_backup = hdev; + /*dynamic allocate driver handle*/ + ret = alloc_chrdev_region(&dev, 0, sis_char_devs_count, name); + if (ret) + goto err1; + + sis_char_major = MAJOR(dev); + cdev_init(&sis_char_cdev, &sis_cdev_fops); + sis_char_cdev.owner = THIS_MODULE; + ret = cdev_add(&sis_char_cdev, dev, sis_char_devs_count); + if (ret) + goto err2; + + dev_info(&hdev->dev, "%s driver(major %d) installed.\n", + name, sis_char_major); + + /*register class*/ + sis_char_class = class_create(THIS_MODULE, name); + if (IS_ERR(sis_char_class)) { + ret = PTR_ERR(sis_char_class); + goto err3; + } + + class_dev = device_create(sis_char_class, NULL, dev, NULL, name); + if (IS_ERR(class_dev)) { + ret = PTR_ERR(class_dev); + goto err4; + } + + return 0; +err4: + class_destroy(sis_char_class); + sis_char_class = NULL; +err3: + cdev_del(&sis_char_cdev); + memset(&sis_char_cdev, 0, sizeof(struct cdev)); +err2: + sis_char_major = 0; + unregister_chrdev_region(dev, sis_char_devs_count); +err1: + usb_kill_urb(backup_urb); + usb_free_urb(backup_urb); + backup_urb = NULL; + hid_dev_backup = NULL; + return ret; +} + +/*for ioctl*/ +static void sis_deinit_chardev(void) +{ + dev_t dev = MKDEV(sis_char_major, 0); + + if (hid_dev_backup) { + dev_info(&hid_dev_backup->dev, "sis_remove\n"); + device_destroy(sis_char_class, dev); + class_destroy(sis_char_class); + sis_char_class = NULL; + cdev_del(&sis_char_cdev); + memset(&sis_char_cdev, 0, sizeof(struct cdev)); + sis_char_major = 0; + unregister_chrdev_region(dev, sis_char_devs_count); + usb_kill_urb(backup_urb); + usb_free_urb(backup_urb); + backup_urb = NULL; + hid_dev_backup = NULL; + } +} diff --git a/linux-3.18.5/drivers/hid/usbhid/hid-quirks.c b/linux-3.18.5/drivers/hid/usbhid/hid-quirks.c index 4477eb7..b534321 100644 --- a/linux-3.18.5/drivers/hid/usbhid/hid-quirks.c +++ b/linux-3.18.5/drivers/hid/usbhid/hid-quirks.c @@ -97,6 +97,7 @@ static const struct hid_blacklist { { USB_VENDOR_ID_SIGMATEL, USB_DEVICE_ID_SIGMATEL_STMP3780, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS9200_TOUCH, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS817_TOUCH, HID_QUIRK_NOGET }, + { USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SISF817_TOUCH, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS_TS, HID_QUIRK_NO_INIT_REPORTS }, { USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS1030_TOUCH, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET }, {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?B?5pu+5am36JGzICh0YW1teV90c2VuZyk=?= Subject: Re: [PATCH 2/2] INPUT/HID: add touch support for SiS touch driver Date: Thu, 12 Feb 2015 15:16:43 +0800 Message-ID: <8322374EB97AA24A95D0DDBFC8F1CA1DCB0821@SISMBEV01.sis.com.tw> References: <8322374EB97AA24A95D0DDBFC8F1CA1DCB07FA@SISMBEV01.sis.com.tw> <20150212070342.GB38837@dtor-ws> Mime-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: base64 Return-path: Received: from m01.linkvast.com.tw ([203.67.208.22]:33795 "EHLO sism01.sis.com" rhost-flags-OK-FAIL-OK-OK) by vger.kernel.org with ESMTP id S1755126AbbBLHQ7 (ORCPT ); Thu, 12 Feb 2015 02:16:59 -0500 Content-class: urn:content-classes:message In-Reply-To: <20150212070342.GB38837@dtor-ws> Sender: linux-input-owner@vger.kernel.org List-Id: linux-input@vger.kernel.org To: Dmitry Torokhov Cc: Oliver Neukum , lkml , linux-input@vger.kernel.org, tammy0524@gmail.com SGksIERtaXRyeQ0KDQo+IC0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+IEZyb206IERtaXRy eSBUb3Jva2hvdiBbbWFpbHRvOmRtaXRyeS50b3Jva2hvdkBnbWFpbC5jb21dDQo+IFNlbnQ6IFRo dXJzZGF5LCBGZWJydWFyeSAxMiwgMjAxNSAzOjA0IFBNDQo+IFRvOiDmm77lqbfokbMgKHRhbW15 X3RzZW5nKQ0KPiBDYzogT2xpdmVyIE5ldWt1bTsgbGttbDsgbGludXgtaW5wdXRAdmdlci5rZXJu ZWwub3JnOyB0YW1teTA1MjRAZ21haWwuY29tDQo+IFN1YmplY3Q6IFJlOiBbUEFUQ0ggMi8yXSBJ TlBVVC9ISUQ6IGFkZCB0b3VjaCBzdXBwb3J0IGZvciBTaVMgdG91Y2gNCj4gZHJpdmVyDQo+IA0K PiBIaSBUYW1teSwNCj4gDQo+IE9uIFRodSwgRmViIDEyLCAyMDE1IGF0IDAyOjA3OjI2UE0gKzA4 MDAsIOabvuWpt+iRsyAodGFtbXlfdHNlbmcpIHdyb3RlOg0KPiA+IEhpLA0KPiA+DQo+ID4NCj4g Pg0KPiA+IEkndmUgY2hlY2tlZCB0aGUgY29kaW5nIHN0eWxlIGFuZCBtb2RpZmllZCB0aGUgaTJj IGFuZCBoaWQgdG91Y2ggZHJpdmVyIGZvciBzaXMNCj4gdG91Y2ggY29udHJvbGxlci4NCj4gPg0K PiA+IFBsZWFzZSBoZWxwIHJldmlldyB0aGVtLg0KPiA+DQo+ID4gVGhhbmtzIGEgbG90Lg0KPiAN Cj4gVGhpcyB3YXMgc2VudCBhcyBIVE1MIHNvIG1haWxpbmcgbGlzdHMgZHJvcHBlZCBpdC4NCj4g DQo+IFRoYW5rcy4NCj4gDQo+IC0tDQo+IERtaXRyeQ0KDQoNClNvcnJ5LiBSZS1zZW5kIHRoZSBj b2RlIGRpZmYgYWdhaW4uDQpIZXJlIGlzIHRoZSBoaWQgdG91Y2ggZHJpdmVyIGZvciBzaXMgdG91 Y2ggY29udHJvbGxlci4NClRoYW5rcy4NCg0KVGFtbXkNCi0tLS0tDQoNCmxpbnV4LTMuMTguNS9k cml2ZXJzL2hpZC9LY29uZmlnICAgICAgICAgICAgIHwgIDE0ICsrDQpsaW51eC0zLjE4LjUvZHJp dmVycy9oaWQvaGlkLWlkcy5oICAgICAgICAgICB8ICAgMSArDQpsaW51eC0zLjE4LjUvZHJpdmVy cy9oaWQvaGlkLW11bHRpdG91Y2guYyAgICB8ICAxNiArKw0KbGludXgtMy4xOC41L2RyaXZlcnMv aGlkL2hpZC1zaXNfY3RybC5jICAgICAgfCAzNjAgKysrKysrKysrKysrKysrKysrKysrKysrKysr DQpsaW51eC0zLjE4LjUvZHJpdmVycy9oaWQvdXNiaGlkL2hpZC1xdWlya3MuYyB8ICAgMSArDQo1 IGZpbGVzIGNoYW5nZWQsIDM5MiBpbnNlcnRpb25zKCspDQoNCg0KLS0tLS0NCmRpZmYgLS1naXQg YS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvS2NvbmZpZyBiL2xpbnV4LTMuMTguNS9kcml2ZXJz L2hpZC9LY29uZmlnDQppbmRleCBmNDJkZjRkLi4yMjM1Y2ZlIDEwMDY0NA0KLS0tIGEvbGludXgt My4xOC41L2RyaXZlcnMvaGlkL0tjb25maWcNCisrKyBiL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hp ZC9LY29uZmlnDQpAQCAtNDk2LDYgKzQ5NiwyMCBAQCBjb25maWcgSElEX01VTFRJVE9VQ0gNCiAg ICAgICAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTog dGhlDQogICAgICAgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBoaWQtbXVsdGl0b3VjaC4NCg0KK2Nv bmZpZyBISURfU0lTX0NUUkwNCisgICAgICBib29sICJTaVMgVG91Y2ggRGV2aWNlIENvbnRyb2xs ZXIiDQorICAgICAgZGVwZW5kcyBvbiBISURfTVVMVElUT1VDSA0KKyAgICAgIC0tLWhlbHAtLS0N CisgICAgICBTdXBwb3J0IGZvciBTaVMgVG91Y2ggZGV2aWNlcyB1cGRhdGUgRlcuDQorDQorY29u ZmlnIERFQlVHX0hJRF9TSVNfVVBEQVRFX0ZXDQorICAgICAgYm9vbCAiU2lTIFRvdWNoIGRldmlj ZSBkZWJ1ZyBtZXNzYWdlKHVwZGF0ZSBmaXJtd2FyZSkiDQorICAgICAgZGVwZW5kcyBvbiBISURf U0lTX0NUUkwNCisgICAgICBkZWZhdWx0IG4NCisgICAgICAtLS1oZWxwLS0tDQorICAgICAgICBT YXkgWSBoZXJlIGlmIHlvdSB3YW50IHRvIGVuYWJsZSBkZWJ1ZyBtZXNzYWdlKHVwZGF0ZSBmaXJt d2FyZSkgZm9yIFNpUyBUb3VjaCANCisgICAgICAgICAgZGV2aWNlcy4gTXVzdCBlbmFibGUgY29u ZmlnIEhJRF9TSVNfVVBEQVRFX0ZXIGZpcnN0Lg0KKw0KY29uZmlnIEhJRF9OVFJJRw0KICAgICAg dHJpc3RhdGUgIk4tVHJpZyB0b3VjaCBzY3JlZW4iDQogICAgICBkZXBlbmRzIG9uIFVTQl9ISUQN CmRpZmYgLS1naXQgYS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlkLWlkcy5oIGIvbGludXgt My4xOC41L2RyaXZlcnMvaGlkL2hpZC1pZHMuaA0KaW5kZXggMGUyODE5MC4uYjljYTQ0MSAxMDA2 NDQNCi0tLSBhL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtaWRzLmgNCisrKyBiL2xpbnV4 LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtaWRzLmgNCkBAIC04MDksNiArODA5LDcgQEANCiNkZWZp bmUgVVNCX1ZFTkRPUl9JRF9TSVNfVE9VQ0ggICAgICAgICAgICAgICAgMHgwNDU3DQojZGVmaW5l IFVTQl9ERVZJQ0VfSURfU0lTOTIwMF9UT1VDSCAgMHg5MjAwDQojZGVmaW5lIFVTQl9ERVZJQ0Vf SURfU0lTODE3X1RPVUNIICAgIDB4MDgxNw0KKyNkZWZpbmUgVVNCX0RFVklDRV9JRF9TSVNGODE3 X1RPVUNIICAweEY4MTcNCiNkZWZpbmUgVVNCX0RFVklDRV9JRF9TSVNfVFMgICAgICAgICAgMHgx MDEzDQojZGVmaW5lIFVTQl9ERVZJQ0VfSURfU0lTMTAzMF9UT1VDSCAgMHgxMDMwDQoNCmRpZmYg LS1naXQgYS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlkLW11bHRpdG91Y2guYyBiL2xpbnV4 LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtbXVsdGl0b3VjaC5jDQppbmRleCA1MWUyNWI5Li4xMWQ2 N2JjIDEwMDY0NA0KLS0tIGEvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL2hpZC1tdWx0aXRvdWNo LmMNCisrKyBiL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtbXVsdGl0b3VjaC5jDQpAQCAt NTQsNiArNTQsMTAgQEAgTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOw0KDQogI2luY2x1ZGUgImhpZC1p ZHMuaCINCg0KKyNpZmRlZiBDT05GSUdfSElEX1NJU19DVFJMDQorI2luY2x1ZGUgImhpZC1zaXNf Y3RybC5jIg0KKyNlbmRpZg0KKw0KLyogcXVpcmtzIHRvIGNvbnRyb2wgdGhlIGRldmljZSAqLw0K I2RlZmluZSBNVF9RVUlSS19OT1RfU0VFTl9NRUFOU19VUCAgICAgICgxIDw8IDApDQojZGVmaW5l IE1UX1FVSVJLX1NMT1RfSVNfQ09OVEFDVElEICAgKDEgPDwgMSkNCkBAIC05NTEsNiArOTU1LDE0 IEBAIHN0YXRpYyBpbnQgbXRfcHJvYmUoc3RydWN0IGhpZF9kZXZpY2UgKmhkZXYsIGNvbnN0IHN0 cnVjdCBoaWRfZGV2aWNlX2lkICppZCkNCiAgICAgICAgICAgICAgfQ0KICAgICAgfQ0KDQorI2lm ZGVmIENPTkZJR19ISURfU0lTX0NUUkwNCisgICAgICBpZiAoaGRldi0+dmVuZG9yID09IFVTQl9W RU5ET1JfSURfU0lTX1RPVUNIKSB7DQorICAgICAgICAgICAgICByZXQgPSBzaXNfc2V0dXBfY2hh cmRldihoZGV2KTsNCisgICAgICAgICAgICAgIGlmIChyZXQpDQorICAgICAgICAgICAgICAgICAg ICAgIGRldl9lcnIoJmhkZXYtPmRldiwgInNpc19zZXR1cF9jaGFyZGV2IGZhaWxcbiIpOw0KKyAg ICAgIH0NCisjZW5kaWYNCisNCiAgICAgIC8qIFRoaXMgYWxsb3dzIHRoZSBkcml2ZXIgdG8gY29y cmVjdGx5IHN1cHBvcnQgZGV2aWNlcw0KICAgICAgICogdGhhdCBlbWl0IGV2ZW50cyBvdmVyIHNl dmVyYWwgSElEIG1lc3NhZ2VzLg0KICAgICAgICovDQpAQCAtMTA0Myw2ICsxMDU1LDEwIEBAIHN0 YXRpYyB2b2lkIG10X3JlbW92ZShzdHJ1Y3QgaGlkX2RldmljZSAqaGRldikNCnsNCiAgICAgIHN5 c2ZzX3JlbW92ZV9ncm91cCgmaGRldi0+ZGV2LmtvYmosICZtdF9hdHRyaWJ1dGVfZ3JvdXApOw0K ICAgICAgaGlkX2h3X3N0b3AoaGRldik7DQorI2lmZGVmIENPTkZJR19ISURfU0lTX0NUUkwNCisg ICAgICBpZiAoaGRldi0+dmVuZG9yID09IFVTQl9WRU5ET1JfSURfU0lTX1RPVUNIKQ0KKyAgICAg ICAgICAgICAgc2lzX2RlaW5pdF9jaGFyZGV2KCk7DQorI2VuZGlmDQp9DQoNCiAvKg0KZGlmZiAt LWdpdCBhL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtc2lzX2N0cmwuYyBiL2xpbnV4LTMu MTguNS9kcml2ZXJzL2hpZC9oaWQtc2lzX2N0cmwuYw0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmlu ZGV4IDAwMDAwMDAuLjNhN2IzZGYNCi0tLSAvZGV2L251bGwNCisrKyBiL2xpbnV4LTMuMTguNS9k cml2ZXJzL2hpZC9oaWQtc2lzX2N0cmwuYw0KQEAgLTAsMCArMSwzNjAgQEANCisvKg0KKyAqICBD aGFyYWN0ZXIgZGV2aWNlIGRyaXZlciBmb3IgU0lTIG11bHRpdG91Y2ggcGFuZWxzIGNvbnRyb2wN CisgKg0KKyAqICBDb3B5cmlnaHQgKGMpIDIwMDkgU0lTLCBMdGQuDQorICoNCisgKi8NCisNCisv Kg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0DQorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUNCisgKiBTb2Z0d2Fy ZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91 ciBvcHRpb24pDQorICogYW55IGxhdGVyIHZlcnNpb24uDQorICovDQorDQorI2luY2x1ZGUgPGxp bnV4L2hpZC5oPg0KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4NCisjaW5jbHVkZSA8bGludXgv dXNiLmg+DQorI2luY2x1ZGUgInVzYmhpZC91c2JoaWQuaCINCisjaW5jbHVkZSA8bGludXgvaW5p dC5oPg0KKw0KKy8qdXBkYXRlIEZXKi8NCisjaW5jbHVkZSA8bGludXgvZnMuaD4NCisjaW5jbHVk ZSA8bGludXgvY2Rldi5oPg0KKy8qI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+Ki8gICAvKmNvcHlf ZnJvbV91c2VyKCkgJiBjb3B5X3RvX3VzZXIoKSovDQorI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3Mu aD4NCisNCisjaW5jbHVkZSAiaGlkLWlkcy5oIg0KKw0KKyNkZWZpbmUgU0lTODE3X0RFVklDRV9O QU1FICJzaXNfYWVnaXNfaGlkX3RvdWNoX2RldmljZSINCisjZGVmaW5lIFNJU0Y4MTdfREVWSUNF X05BTUUgInNpc19hZWdpc19oaWRfYnJpZGdlX3RvdWNoX2RldmljZSINCisNCisjZGVmaW5lIENU UkwgMA0KKyNkZWZpbmUgRU5EUF8wMSAxDQorI2RlZmluZSBFTkRQXzAyIDINCisjZGVmaW5lIERJ Ul9JTiAweDENCisNCisjZGVmaW5lIFNJU19FUlJfQUxMT0NBVEVfS0VSTkVMX01FTSAgICAgICAg LTEyIC8qIEFsbG9jYXRlIG1lbW9yeSBmYWlsICovDQorI2RlZmluZSBTSVNfRVJSX0NPUFlfRlJP TV9VU0VSICAgICAgICAgIC0xNCAvKiBDb3B5IGRhdGEgZnJvbSB1c2VyIGZhaWwgKi8NCisjZGVm aW5lIFNJU19FUlJfQ09QWV9GUk9NX0tFUk5FTCAgICAgIC0xOSAvKiBDb3B5IGRhdGEgZnJvbSBr ZXJuZWwgZmFpbCAqLw0KKw0KK3N0YXRpYyBjb25zdCBpbnQgc2lzX2NoYXJfZGV2c19jb3VudCA9 IDE7ICAgICAgICAgICAvKiBkZXZpY2UgY291bnQgKi8NCitzdGF0aWMgaW50IHNpc19jaGFyX21h am9yOw0KK3N0YXRpYyBzdHJ1Y3QgY2RldiBzaXNfY2hhcl9jZGV2Ow0KK3N0YXRpYyBzdHJ1Y3Qg Y2xhc3MgKnNpc19jaGFyX2NsYXNzOw0KKw0KK3N0YXRpYyBzdHJ1Y3QgaGlkX2RldmljZSAqaGlk X2Rldl9iYWNrdXA7ICAgICAgICAvKmJhY2t1cCBhZGRyZXNzKi8NCitzdGF0aWMgc3RydWN0IHVy YiAqYmFja3VwX3VyYjsNCisNCisjaWZkZWYgQ09ORklHX0RFQlVHX0hJRF9TSVNfVVBEQVRFX0ZX DQorICAgICAgI2RlZmluZSBEQkdfRlcoZm10LCBhcmcuLi4pIHByaW50ayhmbXQsICMjYXJnKQ0K KyAgICAgIHN0YXRpYyB2b2lkIHNpc19kYmdfZHVtcF9hcnJheSh1OCAqcHRyLCB1MzIgc2l6ZSkN CisgICAgICB7DQorICAgICAgICAgICAgICB1MzIgaTsNCisNCisgICAgICAgICAgICAgIGZvciAo aSA9IDA7IGkgPCBzaXplOyBpKyspIHsNCisgICAgICAgICAgICAgICAgICAgICAgREJHX0ZXKCIl MDJYICIsIHB0cltpXSk7DQorICAgICAgICAgICAgICAgICAgICAgIGlmICgoKGkrMSkmMHhGKSA9 PSAwKQ0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIERCR19GVygiXG4iKTsNCisgICAg ICAgICAgICAgIH0NCisgICAgICAgICAgICAgIGlmIChzaXplICYgMHhGKQ0KKyAgICAgICAgICAg ICAgICAgICAgICBEQkdfRlcoIlxuIik7DQorICAgICAgfQ0KKyNlbHNlDQorICAgICAgI2RlZmlu ZSBEQkdfRlcoLi4uKQ0KKyAgICAgICNkZWZpbmUgc2lzX2RiZ19kdW1wX2FycmF5KC4uLikNCisj ZW5kaWYgICAvKkNPTkZJR19ERUJVR19ISURfU0lTX1VQREFURV9GVyovDQorDQorLyoyMDEyMDMw NiBZdWdlciBpb2N0bCBmb3IgdG9vbCovDQorc3RhdGljIGludCBzaXNfY2Rldl9vcGVuKHN0cnVj dCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQ0KK3sNCisgICAgICBzdHJ1Y3QgdXNi aGlkX2RldmljZSAqdXNiaGlkOw0KKw0KKyAgICAgIERCR19GVygiJXNcbiIgLCBfX2Z1bmNfXyk7 DQorICAgICAgLyoyMDExMDUxMSwgWXVnZXIsIGtpbGwgY3VycmVudCB1cmIgYnkgbWV0aG9kIG9m IHVzYmhpZF9zdG9wKi8NCisgICAgICBpZiAoIWhpZF9kZXZfYmFja3VwKSB7DQorICAgICAgICAg ICAgICBwcl9pbmZvKCIoc3RvcCloaWRfZGV2X2JhY2t1cCBpcyBub3QgaW5pdGlhbGl6ZWQgeWV0 Iik7DQorICAgICAgICAgICAgICByZXR1cm4gLTE7DQorICAgICAgfQ0KKw0KKyAgICAgIHVzYmhp ZCA9IGhpZF9kZXZfYmFja3VwLT5kcml2ZXJfZGF0YTsNCisNCisgICAgICBwcl9pbmZvKCJzeXNf c2lzX0hJRF9zdG9wXG4iKTsNCisNCisgICAgICAvKiBwcmludGsoIEtFUk5fSU5GTyAiaGlkX2Rl dl9iYWNrdXAtPnZlbmRvciwNCisgICAgICAqIGhpZF9kZXZfYmFja3VwLT5wcm9kdWN0ID0gJXgg JXhcbiIsIGhpZF9kZXZfYmFja3VwLT52ZW5kb3IsDQorICAgICAgKiBoaWRfZGV2X2JhY2t1cC0+ cHJvZHVjdCApOyovDQorDQorICAgICAgLyoyMDExMDYwMiwgWXVnZXIsIGZpeCBidWc6IG5vdCBj b250YWN0IHVzYiBjYXVzZSBrZXJuZWwgcGFuaWMqLw0KKyAgICAgIGlmICghdXNiaGlkKSB7DQor ICAgICAgICAgICAgICBwcl9pbmZvKCIoc3RvcCl1c2JoaWQgaXMgbm90IGluaXRpYWxpemVkIHll dCIpOw0KKyAgICAgICAgICAgICAgcmV0dXJuIC0xOw0KKyAgICAgIH0gZWxzZSBpZiAoIXVzYmhp ZC0+dXJiaW4pIHsNCisgICAgICAgICAgICAgIHByX2luZm8oIihzdG9wKXVzYmhpZC0+dXJiaW4g aXMgbm90IGluaXRpYWxpemVkIHlldCIpOw0KKyAgICAgICAgICAgICAgcmV0dXJuIC0xOw0KKyAg ICAgIH0gZWxzZSBpZiAoaGlkX2Rldl9iYWNrdXAtPnZlbmRvciA9PSBVU0JfVkVORE9SX0lEX1NJ U19UT1VDSCkgew0KKyAgICAgICAgICAgICAgdXNiX2ZpbGxfaW50X3VyYihiYWNrdXBfdXJiLA0K KyAgICAgICAgICAgICAgICAgICAgICB1c2JoaWQtPnVyYmluLT5kZXYsDQorICAgICAgICAgICAg ICAgICAgICAgIHVzYmhpZC0+dXJiaW4tPnBpcGUsDQorICAgICAgICAgICAgICAgICAgICAgIHVz YmhpZC0+dXJiaW4tPnRyYW5zZmVyX2J1ZmZlciwNCisgICAgICAgICAgICAgICAgICAgICAgdXNi aGlkLT51cmJpbi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwNCisgICAgICAgICAgICAgICAgICAg ICAgdXNiaGlkLT51cmJpbi0+Y29tcGxldGUsDQorICAgICAgICAgICAgICAgICAgICAgIHVzYmhp ZC0+dXJiaW4tPmNvbnRleHQsDQorICAgICAgICAgICAgICAgICAgICAgIHVzYmhpZC0+dXJiaW4t PmludGVydmFsKTsNCisgICAgICAgICAgICAgIGNsZWFyX2JpdChISURfU1RBUlRFRCwgJnVzYmhp ZC0+aW9mbCk7DQorICAgICAgICAgICAgICBzZXRfYml0KEhJRF9ESVNDT05ORUNURUQsICZ1c2Jo aWQtPmlvZmwpOw0KKw0KKyAgICAgICAgICAgICAgdXNiX2tpbGxfdXJiKHVzYmhpZC0+dXJiaW4p Ow0KKyAgICAgICAgICAgICAgdXNiX2ZyZWVfdXJiKHVzYmhpZC0+dXJiaW4pOw0KKyAgICAgICAg ICAgICAgdXNiaGlkLT51cmJpbiA9IE5VTEw7DQorICAgICAgICAgICAgICByZXR1cm4gMDsNCisg ICAgICB9DQorDQorICAgICAgcHJfaW5mbygiVGhpcyBpcyBub3QgYSBTaVMgZGV2aWNlIik7DQor ICAgICAgcmV0dXJuIC04MDE7DQorfQ0KKw0KK3N0YXRpYyBpbnQgc2lzX2NkZXZfcmVsZWFzZShz dHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkNCit7DQorICAgICAgLyoyMDEx MDUwNSwgWXVnZXIsIHJlYnVpbGQgdGhlIHVyYiB3aGljaCBpcyBhdCB0aGUgc2FtZSB1cmIgYWRk cmVzcywNCisgICAgICAqIHRoZW4gcmUtc3VibWl0IGl0Ki8NCisNCisgICAgICBpbnQgcmV0Ow0K KyAgICAgIHN0cnVjdCB1c2JoaWRfZGV2aWNlICp1c2JoaWQ7DQorICAgICAgdW5zaWduZWQgbG9u ZyBmbGFnczsNCisNCisgICAgICBEQkdfRlcoIiVzOiAiLCBfX2Z1bmNfXyk7DQorDQorICAgICAg aWYgKCFoaWRfZGV2X2JhY2t1cCkgew0KKyAgICAgICAgICAgICAgcHJfaW5mbygiKHN0b3ApaGlk X2Rldl9iYWNrdXAgaXMgbm90IGluaXRpYWxpemVkIHlldCIpOw0KKyAgICAgICAgICAgICAgcmV0 dXJuIC0xOw0KKyAgICAgIH0NCisNCisgICAgICB1c2JoaWQgPSBoaWRfZGV2X2JhY2t1cC0+ZHJp dmVyX2RhdGE7DQorDQorICAgICAgcHJfaW5mbygic3lzX3Npc19ISURfc3RhcnQiKTsNCisNCisg ICAgICBpZiAoIXVzYmhpZCkgew0KKyAgICAgICAgICAgICAgcHJfaW5mbygiKHN0YXJ0KXVzYmhp ZCBpcyBub3QgaW5pdGlhbGl6ZWQgeWV0Iik7DQorICAgICAgICAgICAgICByZXR1cm4gLTE7DQor ICAgICAgfQ0KKw0KKyAgICAgIGlmICghYmFja3VwX3VyYikgew0KKyAgICAgICAgICAgICAgcHJf aW5mbygiKHN0YXJ0KWJhY2t1cF91cmIgaXMgbm90IGluaXRpYWxpemVkIHlldCIpOw0KKyAgICAg ICAgICAgICAgcmV0dXJuIC0xOw0KKyAgICAgIH0NCisNCisgICAgICBjbGVhcl9iaXQoSElEX0RJ U0NPTk5FQ1RFRCwgJnVzYmhpZC0+aW9mbCk7DQorICAgICAgdXNiaGlkLT51cmJpbiA9IHVzYl9h bGxvY191cmIoMCwgR0ZQX0tFUk5FTCk7DQorDQorICAgICAgaWYgKCFiYWNrdXBfdXJiLT5pbnRl cnZhbCkgew0KKyAgICAgICAgICAgICAgcHJfaW5mbygiKHN0YXJ0KWJhY2t1cF91cmItPmludGVy dmFsIGRvZXMgbm90IGV4aXN0Iik7DQorICAgICAgICAgICAgICByZXR1cm4gLTE7DQorICAgICAg fQ0KKw0KKyAgICAgIHVzYl9maWxsX2ludF91cmIodXNiaGlkLT51cmJpbiwgYmFja3VwX3VyYi0+ ZGV2LCBiYWNrdXBfdXJiLT5waXBlLA0KKyAgICAgIGJhY2t1cF91cmItPnRyYW5zZmVyX2J1ZmZl ciwgYmFja3VwX3VyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwNCisgICAgICBiYWNrdXBfdXJi LT5jb21wbGV0ZSwgYmFja3VwX3VyYi0+Y29udGV4dCwgYmFja3VwX3VyYi0+aW50ZXJ2YWwpOw0K KyAgICAgIHVzYmhpZC0+dXJiaW4tPnRyYW5zZmVyX2RtYSA9IHVzYmhpZC0+aW5idWZfZG1hOw0K KyAgICAgIHVzYmhpZC0+dXJiaW4tPnRyYW5zZmVyX2ZsYWdzIHw9IFVSQl9OT19UUkFOU0ZFUl9E TUFfTUFQOw0KKw0KKyAgICAgIHNldF9iaXQoSElEX1NUQVJURUQsICZ1c2JoaWQtPmlvZmwpOw0K Kw0KKyAgICAgIC8qbWV0aG9kIGF0IGhpZF9zdGFydF9pbiovDQorICAgICAgc3Bpbl9sb2NrX2ly cXNhdmUoJnVzYmhpZC0+bG9jaywgZmxhZ3MpOw0KKyAgICAgIHJldCA9IHVzYl9zdWJtaXRfdXJi KHVzYmhpZC0+dXJiaW4sIEdGUF9BVE9NSUMpOw0KKyAgICAgIHNwaW5fdW5sb2NrX2lycXJlc3Rv cmUoJnVzYmhpZC0+bG9jaywgZmxhZ3MpOw0KKyAgICAgIC8qeXkqLw0KKw0KKyAgICAgIERCR19G VygicmV0ID0gJWQiLCByZXQpOw0KKw0KKyAgICAgIHJldHVybiByZXQ7DQorfQ0KKw0KKy8qU2lT IDgxNyBvbmx5Ki8NCitzdGF0aWMgc3NpemVfdCBzaXNfY2Rldl9yZWFkKHN0cnVjdCBmaWxlICpm aWxlLCBjaGFyIF9fdXNlciAqYnVmLA0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNp emVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQ0KK3sNCisgICAgICBpbnQgYWN0dWFsX2xlbmd0aCA9 IDA7DQorICAgICAgdTggKnJlcF9kYXRhID0gTlVMTDsNCisgICAgICB1MzIgc2l6ZSwgdGltZW91 dDsNCisgICAgICBsb25nIHJlcF9yZXQgPSAwOw0KKyAgICAgIHN0cnVjdCB1c2JfaW50ZXJmYWNl ICppbnRmID0NCisgICAgICAgICAgICAgICAgICAgICAgdG9fdXNiX2ludGVyZmFjZShoaWRfZGV2 X2JhY2t1cC0+ZGV2LnBhcmVudCk7DQorICAgICAgc3RydWN0IHVzYl9kZXZpY2UgKmRldiA9IGlu dGVyZmFjZV90b191c2JkZXYoaW50Zik7DQorDQorICAgICAgREJHX0ZXKCIlc1xuIiwgX19mdW5j X18pOw0KKw0KKyAgICAgIHJlcF9kYXRhID0ga3phbGxvYyhjb3VudCwgR0ZQX0tFUk5FTCk7DQor ICAgICAgaWYgKCFyZXBfZGF0YSkNCisgICAgICAgICAgICAgIHJldHVybiBTSVNfRVJSX0FMTE9D QVRFX0tFUk5FTF9NRU07DQorDQorICAgICAgaWYgKGNvcHlfZnJvbV91c2VyKHJlcF9kYXRhLCAo dm9pZCAqKWJ1ZiwgY291bnQpKSB7DQorICAgICAgICAgICAgICBwcl9lcnIoImNvcHlfdG9fdXNl ciBmYWlsXG4iKTsNCisgICAgICAgICAgICAgIHJlcF9yZXQgPSBTSVNfRVJSX0NPUFlfRlJPTV9V U0VSOw0KKyAgICAgICAgICAgICAgZ290byBlbmQ7DQorICAgICAgfQ0KKyAgICAgIHNpemUgPSBi ZTMyX3RvX2NwdXAoKHUzMiAqKSZyZXBfZGF0YVs2NF0pOw0KKyAgICAgIHRpbWVvdXQgPSBiZTMy X3RvX2NwdXAoKHUzMiAqKSZyZXBfZGF0YVs2OF0pOw0KKw0KKyAgICAgIHJlcF9yZXQgPSB1c2Jf aW50ZXJydXB0X21zZyhkZXYsIGJhY2t1cF91cmItPnBpcGUsDQorICAgICAgICAgICAgICByZXBf ZGF0YSwgc2l6ZSwgJmFjdHVhbF9sZW5ndGgsIHRpbWVvdXQpOw0KKw0KKyAgICAgIERCR19GVygi JXM6IHJlcF9kYXRhID0gIiwgX19mdW5jX18pOw0KKyAgICAgIHNpc19kYmdfZHVtcF9hcnJheShy ZXBfZGF0YSwgOCk7DQorDQorICAgICAgaWYgKHJlcF9yZXQgPT0gMCkgew0KKyAgICAgICAgICAg ICAgcmVwX3JldCA9IGFjdHVhbF9sZW5ndGg7DQorICAgICAgICAgICAgICBpZiAoY29weV90b191 c2VyKCh2b2lkICopYnVmLCByZXBfZGF0YSwgcmVwX3JldCkpIHsNCisgICAgICAgICAgICAgICAg ICAgICAgcHJfZXJyKCJjb3B5X3RvX3VzZXIgZmFpbFxuIik7DQorICAgICAgICAgICAgICAgICAg ICAgIHJlcF9yZXQgPSBTSVNfRVJSX0NPUFlfRlJPTV9LRVJORUw7DQorICAgICAgICAgICAgICAg ICAgICAgIGdvdG8gZW5kOw0KKyAgICAgICAgICAgICAgfQ0KKyAgICAgIH0NCisgICAgICBEQkdf RlcoIiVzOiByZXBfcmV0ID0gJWxkXG4iLCBfX2Z1bmNfXywgcmVwX3JldCk7DQorZW5kOg0KKyAg ICAgIC8qZnJlZSBhbGxvY2F0ZWQgZGF0YSovDQorICAgICAga2ZyZWUocmVwX2RhdGEpOw0KKyAg ICAgIHJldHVybiByZXBfcmV0Ow0KK30NCisNCitzdGF0aWMgc3NpemVfdCBzaXNfY2Rldl93cml0 ZShzdHJ1Y3QgZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZiwNCisgICAgICAgICAg ICAgICAgICAgICAgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKmZfcG9zKQ0KK3sNCisgICAgICBpbnQg YWN0dWFsX2xlbmd0aCA9IDA7DQorICAgICAgdTggKnJlcF9kYXRhID0gTlVMTDsNCisgICAgICBs b25nIHJlcF9yZXQgPSAwOw0KKyAgICAgIHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmID0NCisg ICAgICAgICAgICAgICAgICAgICAgdG9fdXNiX2ludGVyZmFjZShoaWRfZGV2X2JhY2t1cC0+ZGV2 LnBhcmVudCk7DQorICAgICAgc3RydWN0IHVzYl9kZXZpY2UgKmRldiA9IGludGVyZmFjZV90b191 c2JkZXYoaW50Zik7DQorICAgICAgc3RydWN0IHVzYmhpZF9kZXZpY2UgKnVzYmhpZCA9IGhpZF9k ZXZfYmFja3VwLT5kcml2ZXJfZGF0YTsNCisgICAgICB1MzIgc2l6ZSwgdGltZW91dDsNCisNCisg ICAgICByZXBfZGF0YSA9IGt6YWxsb2MoY291bnQsIEdGUF9LRVJORUwpOw0KKyAgICAgIGlmICgh cmVwX2RhdGEpDQorICAgICAgICAgICAgICByZXR1cm4gU0lTX0VSUl9BTExPQ0FURV9LRVJORUxf TUVNOw0KKw0KKyAgICAgIGlmIChjb3B5X2Zyb21fdXNlcihyZXBfZGF0YSwgKHZvaWQgKilidWYs IGNvdW50KSkgew0KKyAgICAgICAgICAgICAgcHJfZXJyKCJjb3B5X3RvX3VzZXIgZmFpbFxuIik7 DQorICAgICAgICAgICAgICByZXBfcmV0ID0gU0lTX0VSUl9DT1BZX0ZST01fVVNFUjsNCisgICAg ICAgICAgICAgIGdvdG8gZW5kOw0KKyAgICAgIH0NCisNCisgICAgICBzaXplID0gYmUzMl90b19j cHVwKCh1MzIgKikmcmVwX2RhdGFbNjRdKTsNCisgICAgICB0aW1lb3V0ID0gYmUzMl90b19jcHVw KCh1MzIgKikmcmVwX2RhdGFbNjhdKTsNCisNCisgICAgICByZXBfcmV0ID0gdXNiX2ludGVycnVw dF9tc2coZGV2LCB1c2JoaWQtPnVyYm91dC0+cGlwZSwNCisgICAgICAgICAgICAgIHJlcF9kYXRh LCBzaXplLCAmYWN0dWFsX2xlbmd0aCwgdGltZW91dCk7DQorDQorICAgICAgREJHX0ZXKCIlczog cmVwX2RhdGEgPSAiLCBfX2Z1bmNfXyk7DQorICAgICAgc2lzX2RiZ19kdW1wX2FycmF5KHJlcF9k YXRhLCBzaXplKTsNCisNCisgICAgICBpZiAocmVwX3JldCA9PSAwKSB7DQorICAgICAgICAgICAg ICByZXBfcmV0ID0gYWN0dWFsX2xlbmd0aDsNCisgICAgICAgICAgICAgIGlmIChjb3B5X3RvX3Vz ZXIoKHZvaWQgKilidWYsIHJlcF9kYXRhLCByZXBfcmV0KSkgew0KKyAgICAgICAgICAgICAgICAg ICAgICBwcl9lcnIoImNvcHlfdG9fdXNlciBmYWlsXG4iKTsNCisgICAgICAgICAgICAgICAgICAg ICAgcmVwX3JldCA9IFNJU19FUlJfQ09QWV9GUk9NX0tFUk5FTDsNCisgICAgICAgICAgICAgICAg ICAgICAgZ290byBlbmQ7DQorICAgICAgICAgICAgICB9DQorICAgICAgfQ0KKyAgICAgIERCR19G VygiJXM6IHJlcF9yZXQgPSAlbGRcbiIsIF9fZnVuY19fLCByZXBfcmV0KTsNCisgICAgICBEQkdf RlcoIkVuZCBvZiBzeXNfc2lzX0hJRF9JT1xuIik7DQorZW5kOg0KKyAgICAgIC8qZnJlZSBhbGxv Y2F0ZWQgZGF0YSovDQorICAgICAga2ZyZWUocmVwX2RhdGEpOw0KKyAgICAgIHJldHVybiByZXBf cmV0Ow0KK30NCisNCisNCisvKmZvciBpb2N0bCovDQorc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxl X29wZXJhdGlvbnMgc2lzX2NkZXZfZm9wcyA9IHsNCisgICAgICAub3duZXIgICAgPSBUSElTX01P RFVMRSwNCisgICAgICAucmVhZCAgICAgICA9IHNpc19jZGV2X3JlYWQsDQorICAgICAgLndyaXRl ICAgICAgID0gc2lzX2NkZXZfd3JpdGUsDQorICAgICAgLm9wZW4gICAgICA9IHNpc19jZGV2X29w ZW4sDQorICAgICAgLnJlbGVhc2UgPSBzaXNfY2Rldl9yZWxlYXNlLA0KK307DQorDQorLypmb3Ig aW9jdGwqLw0KK3N0YXRpYyBpbnQgc2lzX3NldHVwX2NoYXJkZXYoc3RydWN0IGhpZF9kZXZpY2Ug KmhkZXYpDQorew0KKyAgICAgIGRldl90IGRldiA9IE1LREVWKHNpc19jaGFyX21ham9yLCAwKTsN CisgICAgICBpbnQgcmV0ID0gMDsNCisgICAgICBzdHJ1Y3QgZGV2aWNlICpjbGFzc19kZXYgPSBO VUxMOw0KKyAgICAgIHU4ICpuYW1lID0gKGhkZXYtPnByb2R1Y3QgPT0gVVNCX0RFVklDRV9JRF9T SVNGODE3X1RPVUNIKSA/DQorICAgICAgICAgICAgICAgICAgICAgIFNJU0Y4MTdfREVWSUNFX05B TUUgOiBTSVM4MTdfREVWSUNFX05BTUU7DQorDQorICAgICAgZGV2X2luZm8oJmhkZXYtPmRldiwg InNpc19zZXR1cF9jaGFyZGV2LlxuIik7DQorDQorICAgICAgYmFja3VwX3VyYiA9IHVzYl9hbGxv Y191cmIoMCwgR0ZQX0tFUk5FTCk7ICAgIC8qMDcyMXRlc3QqLw0KKyAgICAgIGlmICghYmFja3Vw X3VyYikgew0KKyAgICAgICAgICAgICAgZGV2X2VycigmaGRldi0+ZGV2LCAiY2Fubm90IGFsbG9j YXRlIGJhY2t1cF91cmJcbiIpOw0KKyAgICAgICAgICAgICAgcmV0dXJuIC1FTk9NRU07DQorICAg ICAgfQ0KKyAgICAgIGhpZF9kZXZfYmFja3VwID0gaGRldjsNCisgICAgICAvKmR5bmFtaWMgYWxs b2NhdGUgZHJpdmVyIGhhbmRsZSovDQorICAgICAgcmV0ID0gYWxsb2NfY2hyZGV2X3JlZ2lvbigm ZGV2LCAwLCBzaXNfY2hhcl9kZXZzX2NvdW50LCBuYW1lKTsNCisgICAgICBpZiAocmV0KQ0KKyAg ICAgICAgICAgICAgZ290byBlcnIxOw0KKw0KKyAgICAgIHNpc19jaGFyX21ham9yID0gTUFKT1Io ZGV2KTsNCisgICAgICBjZGV2X2luaXQoJnNpc19jaGFyX2NkZXYsICZzaXNfY2Rldl9mb3BzKTsN CisgICAgICBzaXNfY2hhcl9jZGV2Lm93bmVyID0gVEhJU19NT0RVTEU7DQorICAgICAgcmV0ID0g Y2Rldl9hZGQoJnNpc19jaGFyX2NkZXYsIGRldiwgc2lzX2NoYXJfZGV2c19jb3VudCk7DQorICAg ICAgaWYgKHJldCkNCisgICAgICAgICAgICAgIGdvdG8gZXJyMjsNCisNCisgICAgICBkZXZfaW5m bygmaGRldi0+ZGV2LCAiJXMgZHJpdmVyKG1ham9yICVkKSBpbnN0YWxsZWQuXG4iLA0KKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmFtZSwgc2lzX2NoYXJfbWFqb3IpOw0K Kw0KKyAgICAgIC8qcmVnaXN0ZXIgY2xhc3MqLw0KKyAgICAgIHNpc19jaGFyX2NsYXNzID0gY2xh c3NfY3JlYXRlKFRISVNfTU9EVUxFLCBuYW1lKTsNCisgICAgICBpZiAoSVNfRVJSKHNpc19jaGFy X2NsYXNzKSkgew0KKyAgICAgICAgICAgICAgcmV0ID0gUFRSX0VSUihzaXNfY2hhcl9jbGFzcyk7 DQorICAgICAgICAgICAgICBnb3RvIGVycjM7DQorICAgICAgfQ0KKw0KKyAgICAgIGNsYXNzX2Rl diA9IGRldmljZV9jcmVhdGUoc2lzX2NoYXJfY2xhc3MsIE5VTEwsIGRldiwgTlVMTCwgbmFtZSk7 DQorICAgICAgaWYgKElTX0VSUihjbGFzc19kZXYpKSB7DQorICAgICAgICAgICAgICByZXQgPSBQ VFJfRVJSKGNsYXNzX2Rldik7DQorICAgICAgICAgICAgICBnb3RvIGVycjQ7DQorICAgICAgfQ0K Kw0KKyAgICAgIHJldHVybiAwOw0KK2VycjQ6DQorICAgICAgY2xhc3NfZGVzdHJveShzaXNfY2hh cl9jbGFzcyk7DQorICAgICAgc2lzX2NoYXJfY2xhc3MgPSBOVUxMOw0KK2VycjM6DQorICAgICAg Y2Rldl9kZWwoJnNpc19jaGFyX2NkZXYpOw0KKyAgICAgIG1lbXNldCgmc2lzX2NoYXJfY2Rldiwg MCwgc2l6ZW9mKHN0cnVjdCBjZGV2KSk7DQorZXJyMjoNCisgICAgICBzaXNfY2hhcl9tYWpvciA9 IDA7DQorICAgICAgdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKGRldiwgc2lzX2NoYXJfZGV2c19j b3VudCk7DQorZXJyMToNCisgICAgICB1c2Jfa2lsbF91cmIoYmFja3VwX3VyYik7DQorICAgICAg dXNiX2ZyZWVfdXJiKGJhY2t1cF91cmIpOw0KKyAgICAgIGJhY2t1cF91cmIgPSBOVUxMOw0KKyAg ICAgIGhpZF9kZXZfYmFja3VwID0gTlVMTDsNCisgICAgICByZXR1cm4gcmV0Ow0KK30NCisNCisv KmZvciBpb2N0bCovDQorc3RhdGljIHZvaWQgc2lzX2RlaW5pdF9jaGFyZGV2KHZvaWQpDQorew0K KyAgICAgIGRldl90IGRldiA9IE1LREVWKHNpc19jaGFyX21ham9yLCAwKTsNCisNCisgICAgICBp ZiAoaGlkX2Rldl9iYWNrdXApIHsNCisgICAgICAgICAgICAgIGRldl9pbmZvKCZoaWRfZGV2X2Jh Y2t1cC0+ZGV2LCAic2lzX3JlbW92ZVxuIik7DQorICAgICAgICAgICAgICBkZXZpY2VfZGVzdHJv eShzaXNfY2hhcl9jbGFzcywgZGV2KTsNCisgICAgICAgICAgICAgIGNsYXNzX2Rlc3Ryb3koc2lz X2NoYXJfY2xhc3MpOw0KKyAgICAgICAgICAgICAgc2lzX2NoYXJfY2xhc3MgPSBOVUxMOw0KKyAg ICAgICAgICAgICAgY2Rldl9kZWwoJnNpc19jaGFyX2NkZXYpOw0KKyAgICAgICAgICAgICAgbWVt c2V0KCZzaXNfY2hhcl9jZGV2LCAwLCBzaXplb2Yoc3RydWN0IGNkZXYpKTsNCisgICAgICAgICAg ICAgIHNpc19jaGFyX21ham9yID0gMDsNCisgICAgICAgICAgICAgIHVucmVnaXN0ZXJfY2hyZGV2 X3JlZ2lvbihkZXYsIHNpc19jaGFyX2RldnNfY291bnQpOw0KKyAgICAgICAgICAgICAgdXNiX2tp bGxfdXJiKGJhY2t1cF91cmIpOw0KKyAgICAgICAgICAgICAgdXNiX2ZyZWVfdXJiKGJhY2t1cF91 cmIpOw0KKyAgICAgICAgICAgICAgYmFja3VwX3VyYiA9IE5VTEw7DQorICAgICAgICAgICAgICBo aWRfZGV2X2JhY2t1cCA9IE5VTEw7DQorICAgICAgfQ0KK30NCmRpZmYgLS1naXQgYS9saW51eC0z LjE4LjUvZHJpdmVycy9oaWQvdXNiaGlkL2hpZC1xdWlya3MuYyBiL2xpbnV4LTMuMTguNS9kcml2 ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5jDQppbmRleCA0NDc3ZWI3Li5iNTM0MzIxIDEwMDY0 NA0KLS0tIGEvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL3VzYmhpZC9oaWQtcXVpcmtzLmMNCisr KyBiL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5jDQpAQCAtOTcs NiArOTcsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGhpZF9ibGFja2xpc3Qgew0KICAgICAgeyBV U0JfVkVORE9SX0lEX1NJR01BVEVMLCBVU0JfREVWSUNFX0lEX1NJR01BVEVMX1NUTVAzNzgwLCBI SURfUVVJUktfTk9HRVQgfSwNCiAgICAgIHsgVVNCX1ZFTkRPUl9JRF9TSVNfVE9VQ0gsIFVTQl9E RVZJQ0VfSURfU0lTOTIwMF9UT1VDSCwgSElEX1FVSVJLX05PR0VUIH0sDQogICAgICB7IFVTQl9W RU5ET1JfSURfU0lTX1RPVUNILCBVU0JfREVWSUNFX0lEX1NJUzgxN19UT1VDSCwgSElEX1FVSVJL X05PR0VUIH0sDQorICAgICAgeyBVU0JfVkVORE9SX0lEX1NJU19UT1VDSCwgVVNCX0RFVklDRV9J RF9TSVNGODE3X1RPVUNILCBISURfUVVJUktfTk9HRVQgfSwNCiAgICAgIHsgVVNCX1ZFTkRPUl9J RF9TSVNfVE9VQ0gsIFVTQl9ERVZJQ0VfSURfU0lTX1RTLCBISURfUVVJUktfTk9fSU5JVF9SRVBP UlRTIH0sDQogICAgICB7IFVTQl9WRU5ET1JfSURfU0lTX1RPVUNILCBVU0JfREVWSUNFX0lEX1NJ UzEwMzBfVE9VQ0gsIEhJRF9RVUlSS19OT0dFVCB9LA0KICAgICAgeyBVU0JfVkVORE9SX0lEX1NV TiwgVVNCX0RFVklDRV9JRF9SQVJJVEFOX0tWTV9ET05HTEUsIEhJRF9RVUlSS19OT0dFVCB9LA0K