From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755262AbbBLHYc (ORCPT ); Thu, 12 Feb 2015 02:24:32 -0500 Received: from sism000.sis.com ([210.242.182.187]:30700 "EHLO sism02.sis.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1750792AbbBLHYa (ORCPT ); Thu, 12 Feb 2015 02:24:30 -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:24:20 +0800 Message-ID: <8322374EB97AA24A95D0DDBFC8F1CA1DCB0825@SISMBEV01.sis.com.tw> X-MS-Has-Attach: X-MS-TNEF-Correlator: Thread-Topic: Re: [PATCH 2/2] INPUT/HID: add touch support for SiS touch driver Thread-Index: AdBGkhXdNVnqDklbT/KhR3Sld2WlCgAAOp9gAABSnMA= From: =?UTF-8?B?5pu+5am36JGzICh0YW1teV90c2VuZyk=?= To: "Dmitry Torokhov" , "Oliver Neukum" Cc: "lkml" , , X-OriginalArrivalTime: 12 Feb 2015 07:24:20.0900 (UTC) FILETIME=[EB357E40:01D04694] 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.87 X-Envelope-From: X-Sherlock-Send: MailFilter (sism02.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 t1C7OeN5028064 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:24:20 +0800 Message-ID: <8322374EB97AA24A95D0DDBFC8F1CA1DCB0825@SISMBEV01.sis.com.tw> Mime-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: base64 Return-path: Received: from sism000.sis.com ([210.242.182.187]:30700 "EHLO sism02.sis.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1750792AbbBLHYa (ORCPT ); Thu, 12 Feb 2015 02:24:30 -0500 Content-class: urn:content-classes:message Sender: linux-input-owner@vger.kernel.org List-Id: linux-input@vger.kernel.org To: Dmitry Torokhov , Oliver Neukum Cc: lkml , linux-input@vger.kernel.org, tammy0524@gmail.com SGksIERtaXRyeQ0KDQo+IC0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+IEZyb206IERtaXRy eSBUb3Jva2hvdiBbbWFpbHRvOmRtaXRyeS50b3Jva2hvdkBnbWFpbC5jb21dDQo+IFNlbnQ6IFRo dXJzZGF5LCBGZWJydWFyeSAxMiwgMjAxNSAzOjA0IFBNDQo+IFRvOiDmm77lqbfokbMgKHRhbW15 X3RzZW5nKQ0KPiBDYzogT2xpdmVyIE5ldWt1bTsgbGttbDsgbGludXgtaW5wdXRAdmdlci5rZXJu ZWwub3JnOyANCj4gdGFtbXkwNTI0QGdtYWlsLmNvbQ0KPiBTdWJqZWN0OiBSZTogW1BBVENIIDIv Ml0gSU5QVVQvSElEOiBhZGQgdG91Y2ggc3VwcG9ydCBmb3IgU2lTIHRvdWNoIA0KPiBkcml2ZXIN Cj4gDQo+IEhpIFRhbW15LA0KPiANCj4gT24gVGh1LCBGZWIgMTIsIDIwMTUgYXQgMDI6MDc6MjZQ TSArMDgwMCwg5pu+5am36JGzICh0YW1teV90c2VuZykgd3JvdGU6DQo+ID4gSGksDQo+ID4NCj4g Pg0KPiA+DQo+ID4gSSd2ZSBjaGVja2VkIHRoZSBjb2Rpbmcgc3R5bGUgYW5kIG1vZGlmaWVkIHRo ZSBpMmMgYW5kIGhpZCB0b3VjaCANCj4gPiBkcml2ZXIgZm9yIHNpcw0KPiB0b3VjaCBjb250cm9s bGVyLg0KPiA+DQo+ID4gUGxlYXNlIGhlbHAgcmV2aWV3IHRoZW0uDQo+ID4NCj4gPiBUaGFua3Mg YSBsb3QuDQo+IA0KPiBUaGlzIHdhcyBzZW50IGFzIEhUTUwgc28gbWFpbGluZyBsaXN0cyBkcm9w cGVkIGl0Lg0KPiANCj4gVGhhbmtzLg0KPiANCj4gLS0NCj4gRG1pdHJ5DQoNCg0KU29ycnkuIFJl LXNlbmQgdGhlIGNvZGUgZGlmZiBhZ2Fpbi4NCkhlcmUgaXMgdGhlIGhpZCB0b3VjaCBkcml2ZXIg Zm9yIHNpcyB0b3VjaCBjb250cm9sbGVyLg0KVGhhbmtzLg0KDQpUYW1teQ0KLS0tLS0NCg0KbGlu dXgtMy4xOC41L2RyaXZlcnMvaGlkL0tjb25maWcgICAgICAgICAgICAgfCAgMTQgKysNCmxpbnV4 LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtaWRzLmggICAgICAgICAgIHwgICAxICsNCmxpbnV4LTMu MTguNS9kcml2ZXJzL2hpZC9oaWQtbXVsdGl0b3VjaC5jICAgIHwgIDE2ICsrDQpsaW51eC0zLjE4 LjUvZHJpdmVycy9oaWQvaGlkLXNpc19jdHJsLmMgICAgICB8IDM2MCArKysrKysrKysrKysrKysr KysrKysrKysrKysNCmxpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5j IHwgICAxICsNCjUgZmlsZXMgY2hhbmdlZCwgMzkyIGluc2VydGlvbnMoKykNCg0KDQotLS0tLQ0K ZGlmZiAtLWdpdCBhL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC9LY29uZmlnIGIvbGludXgtMy4x OC41L2RyaXZlcnMvaGlkL0tjb25maWcNCmluZGV4IGY0MmRmNGQuLjIyMzVjZmUgMTAwNjQ0DQot LS0gYS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvS2NvbmZpZw0KKysrIGIvbGludXgtMy4xOC41 L2RyaXZlcnMvaGlkL0tjb25maWcNCkBAIC00OTYsNiArNDk2LDIwIEBAIGNvbmZpZyBISURfTVVM VElUT1VDSA0KICAgICAgICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9v c2UgTSBoZXJlOiB0aGUNCiAgICAgICAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGhpZC1tdWx0aXRv dWNoLg0KDQorY29uZmlnIEhJRF9TSVNfQ1RSTA0KKyAgICAgIGJvb2wgIlNpUyBUb3VjaCBEZXZp Y2UgQ29udHJvbGxlciINCisgICAgICBkZXBlbmRzIG9uIEhJRF9NVUxUSVRPVUNIDQorICAgICAg LS0taGVscC0tLQ0KKyAgICAgIFN1cHBvcnQgZm9yIFNpUyBUb3VjaCBkZXZpY2VzIHVwZGF0ZSBG Vy4NCisNCitjb25maWcgREVCVUdfSElEX1NJU19VUERBVEVfRlcNCisgICAgICBib29sICJTaVMg VG91Y2ggZGV2aWNlIGRlYnVnIG1lc3NhZ2UodXBkYXRlIGZpcm13YXJlKSINCisgICAgICBkZXBl bmRzIG9uIEhJRF9TSVNfQ1RSTA0KKyAgICAgIGRlZmF1bHQgbg0KKyAgICAgIC0tLWhlbHAtLS0N CisgICAgICAgIFNheSBZIGhlcmUgaWYgeW91IHdhbnQgdG8gZW5hYmxlIGRlYnVnIG1lc3NhZ2Uo dXBkYXRlIGZpcm13YXJlKSBmb3IgU2lTIFRvdWNoIA0KKyAgICAgICAgICBkZXZpY2VzLiBNdXN0 IGVuYWJsZSBjb25maWcgSElEX1NJU19VUERBVEVfRlcgZmlyc3QuDQorDQpjb25maWcgSElEX05U UklHDQogICAgICB0cmlzdGF0ZSAiTi1UcmlnIHRvdWNoIHNjcmVlbiINCiAgICAgIGRlcGVuZHMg b24gVVNCX0hJRA0KZGlmZiAtLWdpdCBhL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtaWRz LmggYi9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlkLWlkcy5oDQppbmRleCAwZTI4MTkwLi5i OWNhNDQxIDEwMDY0NA0KLS0tIGEvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL2hpZC1pZHMuaA0K KysrIGIvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL2hpZC1pZHMuaA0KQEAgLTgwOSw2ICs4MDks NyBAQA0KI2RlZmluZSBVU0JfVkVORE9SX0lEX1NJU19UT1VDSCAgICAgICAgICAgICAgICAweDA0 NTcNCiNkZWZpbmUgVVNCX0RFVklDRV9JRF9TSVM5MjAwX1RPVUNIICAweDkyMDANCiNkZWZpbmUg VVNCX0RFVklDRV9JRF9TSVM4MTdfVE9VQ0ggICAgMHgwODE3DQorI2RlZmluZSBVU0JfREVWSUNF X0lEX1NJU0Y4MTdfVE9VQ0ggIDB4RjgxNw0KI2RlZmluZSBVU0JfREVWSUNFX0lEX1NJU19UUyAg ICAgICAgICAweDEwMTMNCiNkZWZpbmUgVVNCX0RFVklDRV9JRF9TSVMxMDMwX1RPVUNIICAweDEw MzANCg0KZGlmZiAtLWdpdCBhL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC9oaWQtbXVsdGl0b3Vj aC5jIGIvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL2hpZC1tdWx0aXRvdWNoLmMNCmluZGV4IDUx ZTI1YjkuLjExZDY3YmMgMTAwNjQ0DQotLS0gYS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlk LW11bHRpdG91Y2guYw0KKysrIGIvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL2hpZC1tdWx0aXRv dWNoLmMNCkBAIC01NCw2ICs1NCwxMCBAQCBNT0RVTEVfTElDRU5TRSgiR1BMIik7DQoNCiAjaW5j bHVkZSAiaGlkLWlkcy5oIg0KDQorI2lmZGVmIENPTkZJR19ISURfU0lTX0NUUkwNCisjaW5jbHVk ZSAiaGlkLXNpc19jdHJsLmMiDQorI2VuZGlmDQorDQovKiBxdWlya3MgdG8gY29udHJvbCB0aGUg ZGV2aWNlICovDQojZGVmaW5lIE1UX1FVSVJLX05PVF9TRUVOX01FQU5TX1VQICAgICAgKDEgPDwg MCkNCiNkZWZpbmUgTVRfUVVJUktfU0xPVF9JU19DT05UQUNUSUQgICAoMSA8PCAxKQ0KQEAgLTk1 MSw2ICs5NTUsMTQgQEAgc3RhdGljIGludCBtdF9wcm9iZShzdHJ1Y3QgaGlkX2RldmljZSAqaGRl diwgY29uc3Qgc3RydWN0IGhpZF9kZXZpY2VfaWQgKmlkKQ0KICAgICAgICAgICAgICB9DQogICAg ICB9DQoNCisjaWZkZWYgQ09ORklHX0hJRF9TSVNfQ1RSTA0KKyAgICAgIGlmIChoZGV2LT52ZW5k b3IgPT0gVVNCX1ZFTkRPUl9JRF9TSVNfVE9VQ0gpIHsNCisgICAgICAgICAgICAgIHJldCA9IHNp c19zZXR1cF9jaGFyZGV2KGhkZXYpOw0KKyAgICAgICAgICAgICAgaWYgKHJldCkNCisgICAgICAg ICAgICAgICAgICAgICAgZGV2X2VycigmaGRldi0+ZGV2LCAic2lzX3NldHVwX2NoYXJkZXYgZmFp bFxuIik7DQorICAgICAgfQ0KKyNlbmRpZg0KKw0KICAgICAgLyogVGhpcyBhbGxvd3MgdGhlIGRy aXZlciB0byBjb3JyZWN0bHkgc3VwcG9ydCBkZXZpY2VzDQogICAgICAgKiB0aGF0IGVtaXQgZXZl bnRzIG92ZXIgc2V2ZXJhbCBISUQgbWVzc2FnZXMuDQogICAgICAgKi8NCkBAIC0xMDQzLDYgKzEw NTUsMTAgQEAgc3RhdGljIHZvaWQgbXRfcmVtb3ZlKHN0cnVjdCBoaWRfZGV2aWNlICpoZGV2KSB7 DQogICAgICBzeXNmc19yZW1vdmVfZ3JvdXAoJmhkZXYtPmRldi5rb2JqLCAmbXRfYXR0cmlidXRl X2dyb3VwKTsNCiAgICAgIGhpZF9od19zdG9wKGhkZXYpOw0KKyNpZmRlZiBDT05GSUdfSElEX1NJ U19DVFJMDQorICAgICAgaWYgKGhkZXYtPnZlbmRvciA9PSBVU0JfVkVORE9SX0lEX1NJU19UT1VD SCkNCisgICAgICAgICAgICAgIHNpc19kZWluaXRfY2hhcmRldigpOw0KKyNlbmRpZg0KfQ0KDQog LyoNCmRpZmYgLS1naXQgYS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlkLXNpc19jdHJsLmMg Yi9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlkLXNpc19jdHJsLmMNCm5ldyBmaWxlIG1vZGUg MTAwNjQ0DQppbmRleCAwMDAwMDAwLi4zYTdiM2RmDQotLS0gL2Rldi9udWxsDQorKysgYi9saW51 eC0zLjE4LjUvZHJpdmVycy9oaWQvaGlkLXNpc19jdHJsLmMNCkBAIC0wLDAgKzEsMzYwIEBADQor LyoNCisgKiAgQ2hhcmFjdGVyIGRldmljZSBkcml2ZXIgZm9yIFNJUyBtdWx0aXRvdWNoIHBhbmVs cyBjb250cm9sDQorICoNCisgKiAgQ29weXJpZ2h0IChjKSAyMDA5IFNJUywgTHRkLg0KKyAqDQor ICovDQorDQorLyoNCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSANCitpdA0KKyAqIHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IA0KK3RoZSBG cmVlDQorICogU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgDQorb3B0aW9uKQ0KKyAqIGFueSBsYXRlciB2ZXJzaW9uLg0KKyAq Lw0KKw0KKyNpbmNsdWRlIDxsaW51eC9oaWQuaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ DQorI2luY2x1ZGUgPGxpbnV4L3VzYi5oPg0KKyNpbmNsdWRlICJ1c2JoaWQvdXNiaGlkLmgiDQor I2luY2x1ZGUgPGxpbnV4L2luaXQuaD4NCisNCisvKnVwZGF0ZSBGVyovDQorI2luY2x1ZGUgPGxp bnV4L2ZzLmg+DQorI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4NCisvKiNpbmNsdWRlIDxhc20vdWFj Y2Vzcy5oPiovICAgLypjb3B5X2Zyb21fdXNlcigpICYgY29weV90b191c2VyKCkqLw0KKyNpbmNs dWRlIDxsaW51eC91YWNjZXNzLmg+DQorDQorI2luY2x1ZGUgImhpZC1pZHMuaCINCisNCisjZGVm aW5lIFNJUzgxN19ERVZJQ0VfTkFNRSAic2lzX2FlZ2lzX2hpZF90b3VjaF9kZXZpY2UiDQorI2Rl ZmluZSBTSVNGODE3X0RFVklDRV9OQU1FICJzaXNfYWVnaXNfaGlkX2JyaWRnZV90b3VjaF9kZXZp Y2UiDQorDQorI2RlZmluZSBDVFJMIDANCisjZGVmaW5lIEVORFBfMDEgMQ0KKyNkZWZpbmUgRU5E UF8wMiAyDQorI2RlZmluZSBESVJfSU4gMHgxDQorDQorI2RlZmluZSBTSVNfRVJSX0FMTE9DQVRF X0tFUk5FTF9NRU0gICAgICAgIC0xMiAvKiBBbGxvY2F0ZSBtZW1vcnkgZmFpbCAqLw0KKyNkZWZp bmUgU0lTX0VSUl9DT1BZX0ZST01fVVNFUiAgICAgICAgICAtMTQgLyogQ29weSBkYXRhIGZyb20g dXNlciBmYWlsICovDQorI2RlZmluZSBTSVNfRVJSX0NPUFlfRlJPTV9LRVJORUwgICAgICAtMTkg LyogQ29weSBkYXRhIGZyb20ga2VybmVsIGZhaWwgKi8NCisNCitzdGF0aWMgY29uc3QgaW50IHNp c19jaGFyX2RldnNfY291bnQgPSAxOyAgICAgICAgICAgLyogZGV2aWNlIGNvdW50ICovDQorc3Rh dGljIGludCBzaXNfY2hhcl9tYWpvcjsNCitzdGF0aWMgc3RydWN0IGNkZXYgc2lzX2NoYXJfY2Rl djsNCitzdGF0aWMgc3RydWN0IGNsYXNzICpzaXNfY2hhcl9jbGFzczsNCisNCitzdGF0aWMgc3Ry dWN0IGhpZF9kZXZpY2UgKmhpZF9kZXZfYmFja3VwOyAgICAgICAgLypiYWNrdXAgYWRkcmVzcyov DQorc3RhdGljIHN0cnVjdCB1cmIgKmJhY2t1cF91cmI7DQorDQorI2lmZGVmIENPTkZJR19ERUJV R19ISURfU0lTX1VQREFURV9GVw0KKyAgICAgICNkZWZpbmUgREJHX0ZXKGZtdCwgYXJnLi4uKSBw cmludGsoZm10LCAjI2FyZykNCisgICAgICBzdGF0aWMgdm9pZCBzaXNfZGJnX2R1bXBfYXJyYXko dTggKnB0ciwgdTMyIHNpemUpDQorICAgICAgew0KKyAgICAgICAgICAgICAgdTMyIGk7DQorDQor ICAgICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7DQorICAgICAgICAgICAg ICAgICAgICAgIERCR19GVygiJTAyWCAiLCBwdHJbaV0pOw0KKyAgICAgICAgICAgICAgICAgICAg ICBpZiAoKChpKzEpJjB4RikgPT0gMCkNCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBE QkdfRlcoIlxuIik7DQorICAgICAgICAgICAgICB9DQorICAgICAgICAgICAgICBpZiAoc2l6ZSAm IDB4RikNCisgICAgICAgICAgICAgICAgICAgICAgREJHX0ZXKCJcbiIpOw0KKyAgICAgIH0NCisj ZWxzZQ0KKyAgICAgICNkZWZpbmUgREJHX0ZXKC4uLikNCisgICAgICAjZGVmaW5lIHNpc19kYmdf ZHVtcF9hcnJheSguLi4pDQorI2VuZGlmICAgLypDT05GSUdfREVCVUdfSElEX1NJU19VUERBVEVf RlcqLw0KKw0KKy8qMjAxMjAzMDYgWXVnZXIgaW9jdGwgZm9yIHRvb2wqLw0KK3N0YXRpYyBpbnQg c2lzX2NkZXZfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkgew0K KyAgICAgIHN0cnVjdCB1c2JoaWRfZGV2aWNlICp1c2JoaWQ7DQorDQorICAgICAgREJHX0ZXKCIl c1xuIiAsIF9fZnVuY19fKTsNCisgICAgICAvKjIwMTEwNTExLCBZdWdlciwga2lsbCBjdXJyZW50 IHVyYiBieSBtZXRob2Qgb2YgdXNiaGlkX3N0b3AqLw0KKyAgICAgIGlmICghaGlkX2Rldl9iYWNr dXApIHsNCisgICAgICAgICAgICAgIHByX2luZm8oIihzdG9wKWhpZF9kZXZfYmFja3VwIGlzIG5v dCBpbml0aWFsaXplZCB5ZXQiKTsNCisgICAgICAgICAgICAgIHJldHVybiAtMTsNCisgICAgICB9 DQorDQorICAgICAgdXNiaGlkID0gaGlkX2Rldl9iYWNrdXAtPmRyaXZlcl9kYXRhOw0KKw0KKyAg ICAgIHByX2luZm8oInN5c19zaXNfSElEX3N0b3BcbiIpOw0KKw0KKyAgICAgIC8qIHByaW50aygg S0VSTl9JTkZPICJoaWRfZGV2X2JhY2t1cC0+dmVuZG9yLA0KKyAgICAgICogaGlkX2Rldl9iYWNr dXAtPnByb2R1Y3QgPSAleCAleFxuIiwgaGlkX2Rldl9iYWNrdXAtPnZlbmRvciwNCisgICAgICAq IGhpZF9kZXZfYmFja3VwLT5wcm9kdWN0ICk7Ki8NCisNCisgICAgICAvKjIwMTEwNjAyLCBZdWdl ciwgZml4IGJ1Zzogbm90IGNvbnRhY3QgdXNiIGNhdXNlIGtlcm5lbCBwYW5pYyovDQorICAgICAg aWYgKCF1c2JoaWQpIHsNCisgICAgICAgICAgICAgIHByX2luZm8oIihzdG9wKXVzYmhpZCBpcyBu b3QgaW5pdGlhbGl6ZWQgeWV0Iik7DQorICAgICAgICAgICAgICByZXR1cm4gLTE7DQorICAgICAg fSBlbHNlIGlmICghdXNiaGlkLT51cmJpbikgew0KKyAgICAgICAgICAgICAgcHJfaW5mbygiKHN0 b3ApdXNiaGlkLT51cmJpbiBpcyBub3QgaW5pdGlhbGl6ZWQgeWV0Iik7DQorICAgICAgICAgICAg ICByZXR1cm4gLTE7DQorICAgICAgfSBlbHNlIGlmIChoaWRfZGV2X2JhY2t1cC0+dmVuZG9yID09 IFVTQl9WRU5ET1JfSURfU0lTX1RPVUNIKSB7DQorICAgICAgICAgICAgICB1c2JfZmlsbF9pbnRf dXJiKGJhY2t1cF91cmIsDQorICAgICAgICAgICAgICAgICAgICAgIHVzYmhpZC0+dXJiaW4tPmRl diwNCisgICAgICAgICAgICAgICAgICAgICAgdXNiaGlkLT51cmJpbi0+cGlwZSwNCisgICAgICAg ICAgICAgICAgICAgICAgdXNiaGlkLT51cmJpbi0+dHJhbnNmZXJfYnVmZmVyLA0KKyAgICAgICAg ICAgICAgICAgICAgICB1c2JoaWQtPnVyYmluLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLA0KKyAg ICAgICAgICAgICAgICAgICAgICB1c2JoaWQtPnVyYmluLT5jb21wbGV0ZSwNCisgICAgICAgICAg ICAgICAgICAgICAgdXNiaGlkLT51cmJpbi0+Y29udGV4dCwNCisgICAgICAgICAgICAgICAgICAg ICAgdXNiaGlkLT51cmJpbi0+aW50ZXJ2YWwpOw0KKyAgICAgICAgICAgICAgY2xlYXJfYml0KEhJ RF9TVEFSVEVELCAmdXNiaGlkLT5pb2ZsKTsNCisgICAgICAgICAgICAgIHNldF9iaXQoSElEX0RJ U0NPTk5FQ1RFRCwgJnVzYmhpZC0+aW9mbCk7DQorDQorICAgICAgICAgICAgICB1c2Jfa2lsbF91 cmIodXNiaGlkLT51cmJpbik7DQorICAgICAgICAgICAgICB1c2JfZnJlZV91cmIodXNiaGlkLT51 cmJpbik7DQorICAgICAgICAgICAgICB1c2JoaWQtPnVyYmluID0gTlVMTDsNCisgICAgICAgICAg ICAgIHJldHVybiAwOw0KKyAgICAgIH0NCisNCisgICAgICBwcl9pbmZvKCJUaGlzIGlzIG5vdCBh IFNpUyBkZXZpY2UiKTsNCisgICAgICByZXR1cm4gLTgwMTsNCit9DQorDQorc3RhdGljIGludCBz aXNfY2Rldl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKSB7 DQorICAgICAgLyoyMDExMDUwNSwgWXVnZXIsIHJlYnVpbGQgdGhlIHVyYiB3aGljaCBpcyBhdCB0 aGUgc2FtZSB1cmIgYWRkcmVzcywNCisgICAgICAqIHRoZW4gcmUtc3VibWl0IGl0Ki8NCisNCisg ICAgICBpbnQgcmV0Ow0KKyAgICAgIHN0cnVjdCB1c2JoaWRfZGV2aWNlICp1c2JoaWQ7DQorICAg ICAgdW5zaWduZWQgbG9uZyBmbGFnczsNCisNCisgICAgICBEQkdfRlcoIiVzOiAiLCBfX2Z1bmNf Xyk7DQorDQorICAgICAgaWYgKCFoaWRfZGV2X2JhY2t1cCkgew0KKyAgICAgICAgICAgICAgcHJf aW5mbygiKHN0b3ApaGlkX2Rldl9iYWNrdXAgaXMgbm90IGluaXRpYWxpemVkIHlldCIpOw0KKyAg ICAgICAgICAgICAgcmV0dXJuIC0xOw0KKyAgICAgIH0NCisNCisgICAgICB1c2JoaWQgPSBoaWRf ZGV2X2JhY2t1cC0+ZHJpdmVyX2RhdGE7DQorDQorICAgICAgcHJfaW5mbygic3lzX3Npc19ISURf c3RhcnQiKTsNCisNCisgICAgICBpZiAoIXVzYmhpZCkgew0KKyAgICAgICAgICAgICAgcHJfaW5m bygiKHN0YXJ0KXVzYmhpZCBpcyBub3QgaW5pdGlhbGl6ZWQgeWV0Iik7DQorICAgICAgICAgICAg ICByZXR1cm4gLTE7DQorICAgICAgfQ0KKw0KKyAgICAgIGlmICghYmFja3VwX3VyYikgew0KKyAg ICAgICAgICAgICAgcHJfaW5mbygiKHN0YXJ0KWJhY2t1cF91cmIgaXMgbm90IGluaXRpYWxpemVk IHlldCIpOw0KKyAgICAgICAgICAgICAgcmV0dXJuIC0xOw0KKyAgICAgIH0NCisNCisgICAgICBj bGVhcl9iaXQoSElEX0RJU0NPTk5FQ1RFRCwgJnVzYmhpZC0+aW9mbCk7DQorICAgICAgdXNiaGlk LT51cmJpbiA9IHVzYl9hbGxvY191cmIoMCwgR0ZQX0tFUk5FTCk7DQorDQorICAgICAgaWYgKCFi YWNrdXBfdXJiLT5pbnRlcnZhbCkgew0KKyAgICAgICAgICAgICAgcHJfaW5mbygiKHN0YXJ0KWJh Y2t1cF91cmItPmludGVydmFsIGRvZXMgbm90IGV4aXN0Iik7DQorICAgICAgICAgICAgICByZXR1 cm4gLTE7DQorICAgICAgfQ0KKw0KKyAgICAgIHVzYl9maWxsX2ludF91cmIodXNiaGlkLT51cmJp biwgYmFja3VwX3VyYi0+ZGV2LCBiYWNrdXBfdXJiLT5waXBlLA0KKyAgICAgIGJhY2t1cF91cmIt PnRyYW5zZmVyX2J1ZmZlciwgYmFja3VwX3VyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwNCisg ICAgICBiYWNrdXBfdXJiLT5jb21wbGV0ZSwgYmFja3VwX3VyYi0+Y29udGV4dCwgYmFja3VwX3Vy Yi0+aW50ZXJ2YWwpOw0KKyAgICAgIHVzYmhpZC0+dXJiaW4tPnRyYW5zZmVyX2RtYSA9IHVzYmhp ZC0+aW5idWZfZG1hOw0KKyAgICAgIHVzYmhpZC0+dXJiaW4tPnRyYW5zZmVyX2ZsYWdzIHw9IFVS Ql9OT19UUkFOU0ZFUl9ETUFfTUFQOw0KKw0KKyAgICAgIHNldF9iaXQoSElEX1NUQVJURUQsICZ1 c2JoaWQtPmlvZmwpOw0KKw0KKyAgICAgIC8qbWV0aG9kIGF0IGhpZF9zdGFydF9pbiovDQorICAg ICAgc3Bpbl9sb2NrX2lycXNhdmUoJnVzYmhpZC0+bG9jaywgZmxhZ3MpOw0KKyAgICAgIHJldCA9 IHVzYl9zdWJtaXRfdXJiKHVzYmhpZC0+dXJiaW4sIEdGUF9BVE9NSUMpOw0KKyAgICAgIHNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJnVzYmhpZC0+bG9jaywgZmxhZ3MpOw0KKyAgICAgIC8qeXkqLw0K Kw0KKyAgICAgIERCR19GVygicmV0ID0gJWQiLCByZXQpOw0KKw0KKyAgICAgIHJldHVybiByZXQ7 DQorfQ0KKw0KKy8qU2lTIDgxNyBvbmx5Ki8NCitzdGF0aWMgc3NpemVfdCBzaXNfY2Rldl9yZWFk KHN0cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqYnVmLA0KKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKSB7DQorICAgICAgaW50IGFj dHVhbF9sZW5ndGggPSAwOw0KKyAgICAgIHU4ICpyZXBfZGF0YSA9IE5VTEw7DQorICAgICAgdTMy IHNpemUsIHRpbWVvdXQ7DQorICAgICAgbG9uZyByZXBfcmV0ID0gMDsNCisgICAgICBzdHJ1Y3Qg dXNiX2ludGVyZmFjZSAqaW50ZiA9DQorICAgICAgICAgICAgICAgICAgICAgIHRvX3VzYl9pbnRl cmZhY2UoaGlkX2Rldl9iYWNrdXAtPmRldi5wYXJlbnQpOw0KKyAgICAgIHN0cnVjdCB1c2JfZGV2 aWNlICpkZXYgPSBpbnRlcmZhY2VfdG9fdXNiZGV2KGludGYpOw0KKw0KKyAgICAgIERCR19GVygi JXNcbiIsIF9fZnVuY19fKTsNCisNCisgICAgICByZXBfZGF0YSA9IGt6YWxsb2MoY291bnQsIEdG UF9LRVJORUwpOw0KKyAgICAgIGlmICghcmVwX2RhdGEpDQorICAgICAgICAgICAgICByZXR1cm4g U0lTX0VSUl9BTExPQ0FURV9LRVJORUxfTUVNOw0KKw0KKyAgICAgIGlmIChjb3B5X2Zyb21fdXNl cihyZXBfZGF0YSwgKHZvaWQgKilidWYsIGNvdW50KSkgew0KKyAgICAgICAgICAgICAgcHJfZXJy KCJjb3B5X3RvX3VzZXIgZmFpbFxuIik7DQorICAgICAgICAgICAgICByZXBfcmV0ID0gU0lTX0VS Ul9DT1BZX0ZST01fVVNFUjsNCisgICAgICAgICAgICAgIGdvdG8gZW5kOw0KKyAgICAgIH0NCisg ICAgICBzaXplID0gYmUzMl90b19jcHVwKCh1MzIgKikmcmVwX2RhdGFbNjRdKTsNCisgICAgICB0 aW1lb3V0ID0gYmUzMl90b19jcHVwKCh1MzIgKikmcmVwX2RhdGFbNjhdKTsNCisNCisgICAgICBy ZXBfcmV0ID0gdXNiX2ludGVycnVwdF9tc2coZGV2LCBiYWNrdXBfdXJiLT5waXBlLA0KKyAgICAg ICAgICAgICAgcmVwX2RhdGEsIHNpemUsICZhY3R1YWxfbGVuZ3RoLCB0aW1lb3V0KTsNCisNCisg ICAgICBEQkdfRlcoIiVzOiByZXBfZGF0YSA9ICIsIF9fZnVuY19fKTsNCisgICAgICBzaXNfZGJn X2R1bXBfYXJyYXkocmVwX2RhdGEsIDgpOw0KKw0KKyAgICAgIGlmIChyZXBfcmV0ID09IDApIHsN CisgICAgICAgICAgICAgIHJlcF9yZXQgPSBhY3R1YWxfbGVuZ3RoOw0KKyAgICAgICAgICAgICAg aWYgKGNvcHlfdG9fdXNlcigodm9pZCAqKWJ1ZiwgcmVwX2RhdGEsIHJlcF9yZXQpKSB7DQorICAg ICAgICAgICAgICAgICAgICAgIHByX2VycigiY29weV90b191c2VyIGZhaWxcbiIpOw0KKyAgICAg ICAgICAgICAgICAgICAgICByZXBfcmV0ID0gU0lTX0VSUl9DT1BZX0ZST01fS0VSTkVMOw0KKyAg ICAgICAgICAgICAgICAgICAgICBnb3RvIGVuZDsNCisgICAgICAgICAgICAgIH0NCisgICAgICB9 DQorICAgICAgREJHX0ZXKCIlczogcmVwX3JldCA9ICVsZFxuIiwgX19mdW5jX18sIHJlcF9yZXQp Ow0KK2VuZDoNCisgICAgICAvKmZyZWUgYWxsb2NhdGVkIGRhdGEqLw0KKyAgICAgIGtmcmVlKHJl cF9kYXRhKTsNCisgICAgICByZXR1cm4gcmVwX3JldDsNCit9DQorDQorc3RhdGljIHNzaXplX3Qg c2lzX2NkZXZfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWYs DQorICAgICAgICAgICAgICAgICAgICAgIHNpemVfdCBjb3VudCwgbG9mZl90ICpmX3Bvcykgew0K KyAgICAgIGludCBhY3R1YWxfbGVuZ3RoID0gMDsNCisgICAgICB1OCAqcmVwX2RhdGEgPSBOVUxM Ow0KKyAgICAgIGxvbmcgcmVwX3JldCA9IDA7DQorICAgICAgc3RydWN0IHVzYl9pbnRlcmZhY2Ug KmludGYgPQ0KKyAgICAgICAgICAgICAgICAgICAgICB0b191c2JfaW50ZXJmYWNlKGhpZF9kZXZf YmFja3VwLT5kZXYucGFyZW50KTsNCisgICAgICBzdHJ1Y3QgdXNiX2RldmljZSAqZGV2ID0gaW50 ZXJmYWNlX3RvX3VzYmRldihpbnRmKTsNCisgICAgICBzdHJ1Y3QgdXNiaGlkX2RldmljZSAqdXNi aGlkID0gaGlkX2Rldl9iYWNrdXAtPmRyaXZlcl9kYXRhOw0KKyAgICAgIHUzMiBzaXplLCB0aW1l b3V0Ow0KKw0KKyAgICAgIHJlcF9kYXRhID0ga3phbGxvYyhjb3VudCwgR0ZQX0tFUk5FTCk7DQor ICAgICAgaWYgKCFyZXBfZGF0YSkNCisgICAgICAgICAgICAgIHJldHVybiBTSVNfRVJSX0FMTE9D QVRFX0tFUk5FTF9NRU07DQorDQorICAgICAgaWYgKGNvcHlfZnJvbV91c2VyKHJlcF9kYXRhLCAo dm9pZCAqKWJ1ZiwgY291bnQpKSB7DQorICAgICAgICAgICAgICBwcl9lcnIoImNvcHlfdG9fdXNl ciBmYWlsXG4iKTsNCisgICAgICAgICAgICAgIHJlcF9yZXQgPSBTSVNfRVJSX0NPUFlfRlJPTV9V U0VSOw0KKyAgICAgICAgICAgICAgZ290byBlbmQ7DQorICAgICAgfQ0KKw0KKyAgICAgIHNpemUg PSBiZTMyX3RvX2NwdXAoKHUzMiAqKSZyZXBfZGF0YVs2NF0pOw0KKyAgICAgIHRpbWVvdXQgPSBi ZTMyX3RvX2NwdXAoKHUzMiAqKSZyZXBfZGF0YVs2OF0pOw0KKw0KKyAgICAgIHJlcF9yZXQgPSB1 c2JfaW50ZXJydXB0X21zZyhkZXYsIHVzYmhpZC0+dXJib3V0LT5waXBlLA0KKyAgICAgICAgICAg ICAgcmVwX2RhdGEsIHNpemUsICZhY3R1YWxfbGVuZ3RoLCB0aW1lb3V0KTsNCisNCisgICAgICBE QkdfRlcoIiVzOiByZXBfZGF0YSA9ICIsIF9fZnVuY19fKTsNCisgICAgICBzaXNfZGJnX2R1bXBf YXJyYXkocmVwX2RhdGEsIHNpemUpOw0KKw0KKyAgICAgIGlmIChyZXBfcmV0ID09IDApIHsNCisg ICAgICAgICAgICAgIHJlcF9yZXQgPSBhY3R1YWxfbGVuZ3RoOw0KKyAgICAgICAgICAgICAgaWYg KGNvcHlfdG9fdXNlcigodm9pZCAqKWJ1ZiwgcmVwX2RhdGEsIHJlcF9yZXQpKSB7DQorICAgICAg ICAgICAgICAgICAgICAgIHByX2VycigiY29weV90b191c2VyIGZhaWxcbiIpOw0KKyAgICAgICAg ICAgICAgICAgICAgICByZXBfcmV0ID0gU0lTX0VSUl9DT1BZX0ZST01fS0VSTkVMOw0KKyAgICAg ICAgICAgICAgICAgICAgICBnb3RvIGVuZDsNCisgICAgICAgICAgICAgIH0NCisgICAgICB9DQor ICAgICAgREJHX0ZXKCIlczogcmVwX3JldCA9ICVsZFxuIiwgX19mdW5jX18sIHJlcF9yZXQpOw0K KyAgICAgIERCR19GVygiRW5kIG9mIHN5c19zaXNfSElEX0lPXG4iKTsNCitlbmQ6DQorICAgICAg LypmcmVlIGFsbG9jYXRlZCBkYXRhKi8NCisgICAgICBrZnJlZShyZXBfZGF0YSk7DQorICAgICAg cmV0dXJuIHJlcF9yZXQ7DQorfQ0KKw0KKw0KKy8qZm9yIGlvY3RsKi8NCitzdGF0aWMgY29uc3Qg c3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzaXNfY2Rldl9mb3BzID0gew0KKyAgICAgIC5vd25lciAg ICA9IFRISVNfTU9EVUxFLA0KKyAgICAgIC5yZWFkICAgICAgID0gc2lzX2NkZXZfcmVhZCwNCisg ICAgICAud3JpdGUgICAgICAgPSBzaXNfY2Rldl93cml0ZSwNCisgICAgICAub3BlbiAgICAgID0g c2lzX2NkZXZfb3BlbiwNCisgICAgICAucmVsZWFzZSA9IHNpc19jZGV2X3JlbGVhc2UsDQorfTsN CisNCisvKmZvciBpb2N0bCovDQorc3RhdGljIGludCBzaXNfc2V0dXBfY2hhcmRldihzdHJ1Y3Qg aGlkX2RldmljZSAqaGRldikgew0KKyAgICAgIGRldl90IGRldiA9IE1LREVWKHNpc19jaGFyX21h am9yLCAwKTsNCisgICAgICBpbnQgcmV0ID0gMDsNCisgICAgICBzdHJ1Y3QgZGV2aWNlICpjbGFz c19kZXYgPSBOVUxMOw0KKyAgICAgIHU4ICpuYW1lID0gKGhkZXYtPnByb2R1Y3QgPT0gVVNCX0RF VklDRV9JRF9TSVNGODE3X1RPVUNIKSA/DQorICAgICAgICAgICAgICAgICAgICAgIFNJU0Y4MTdf REVWSUNFX05BTUUgOiBTSVM4MTdfREVWSUNFX05BTUU7DQorDQorICAgICAgZGV2X2luZm8oJmhk ZXYtPmRldiwgInNpc19zZXR1cF9jaGFyZGV2LlxuIik7DQorDQorICAgICAgYmFja3VwX3VyYiA9 IHVzYl9hbGxvY191cmIoMCwgR0ZQX0tFUk5FTCk7ICAgIC8qMDcyMXRlc3QqLw0KKyAgICAgIGlm ICghYmFja3VwX3VyYikgew0KKyAgICAgICAgICAgICAgZGV2X2VycigmaGRldi0+ZGV2LCAiY2Fu bm90IGFsbG9jYXRlIGJhY2t1cF91cmJcbiIpOw0KKyAgICAgICAgICAgICAgcmV0dXJuIC1FTk9N RU07DQorICAgICAgfQ0KKyAgICAgIGhpZF9kZXZfYmFja3VwID0gaGRldjsNCisgICAgICAvKmR5 bmFtaWMgYWxsb2NhdGUgZHJpdmVyIGhhbmRsZSovDQorICAgICAgcmV0ID0gYWxsb2NfY2hyZGV2 X3JlZ2lvbigmZGV2LCAwLCBzaXNfY2hhcl9kZXZzX2NvdW50LCBuYW1lKTsNCisgICAgICBpZiAo cmV0KQ0KKyAgICAgICAgICAgICAgZ290byBlcnIxOw0KKw0KKyAgICAgIHNpc19jaGFyX21ham9y ID0gTUFKT1IoZGV2KTsNCisgICAgICBjZGV2X2luaXQoJnNpc19jaGFyX2NkZXYsICZzaXNfY2Rl dl9mb3BzKTsNCisgICAgICBzaXNfY2hhcl9jZGV2Lm93bmVyID0gVEhJU19NT0RVTEU7DQorICAg ICAgcmV0ID0gY2Rldl9hZGQoJnNpc19jaGFyX2NkZXYsIGRldiwgc2lzX2NoYXJfZGV2c19jb3Vu dCk7DQorICAgICAgaWYgKHJldCkNCisgICAgICAgICAgICAgIGdvdG8gZXJyMjsNCisNCisgICAg ICBkZXZfaW5mbygmaGRldi0+ZGV2LCAiJXMgZHJpdmVyKG1ham9yICVkKSBpbnN0YWxsZWQuXG4i LA0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmFtZSwgc2lzX2NoYXJf bWFqb3IpOw0KKw0KKyAgICAgIC8qcmVnaXN0ZXIgY2xhc3MqLw0KKyAgICAgIHNpc19jaGFyX2Ns YXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCBuYW1lKTsNCisgICAgICBpZiAoSVNfRVJS KHNpc19jaGFyX2NsYXNzKSkgew0KKyAgICAgICAgICAgICAgcmV0ID0gUFRSX0VSUihzaXNfY2hh cl9jbGFzcyk7DQorICAgICAgICAgICAgICBnb3RvIGVycjM7DQorICAgICAgfQ0KKw0KKyAgICAg IGNsYXNzX2RldiA9IGRldmljZV9jcmVhdGUoc2lzX2NoYXJfY2xhc3MsIE5VTEwsIGRldiwgTlVM TCwgbmFtZSk7DQorICAgICAgaWYgKElTX0VSUihjbGFzc19kZXYpKSB7DQorICAgICAgICAgICAg ICByZXQgPSBQVFJfRVJSKGNsYXNzX2Rldik7DQorICAgICAgICAgICAgICBnb3RvIGVycjQ7DQor ICAgICAgfQ0KKw0KKyAgICAgIHJldHVybiAwOw0KK2VycjQ6DQorICAgICAgY2xhc3NfZGVzdHJv eShzaXNfY2hhcl9jbGFzcyk7DQorICAgICAgc2lzX2NoYXJfY2xhc3MgPSBOVUxMOw0KK2VycjM6 DQorICAgICAgY2Rldl9kZWwoJnNpc19jaGFyX2NkZXYpOw0KKyAgICAgIG1lbXNldCgmc2lzX2No YXJfY2RldiwgMCwgc2l6ZW9mKHN0cnVjdCBjZGV2KSk7DQorZXJyMjoNCisgICAgICBzaXNfY2hh cl9tYWpvciA9IDA7DQorICAgICAgdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKGRldiwgc2lzX2No YXJfZGV2c19jb3VudCk7DQorZXJyMToNCisgICAgICB1c2Jfa2lsbF91cmIoYmFja3VwX3VyYik7 DQorICAgICAgdXNiX2ZyZWVfdXJiKGJhY2t1cF91cmIpOw0KKyAgICAgIGJhY2t1cF91cmIgPSBO VUxMOw0KKyAgICAgIGhpZF9kZXZfYmFja3VwID0gTlVMTDsNCisgICAgICByZXR1cm4gcmV0Ow0K K30NCisNCisvKmZvciBpb2N0bCovDQorc3RhdGljIHZvaWQgc2lzX2RlaW5pdF9jaGFyZGV2KHZv aWQpDQorew0KKyAgICAgIGRldl90IGRldiA9IE1LREVWKHNpc19jaGFyX21ham9yLCAwKTsNCisN CisgICAgICBpZiAoaGlkX2Rldl9iYWNrdXApIHsNCisgICAgICAgICAgICAgIGRldl9pbmZvKCZo aWRfZGV2X2JhY2t1cC0+ZGV2LCAic2lzX3JlbW92ZVxuIik7DQorICAgICAgICAgICAgICBkZXZp Y2VfZGVzdHJveShzaXNfY2hhcl9jbGFzcywgZGV2KTsNCisgICAgICAgICAgICAgIGNsYXNzX2Rl c3Ryb3koc2lzX2NoYXJfY2xhc3MpOw0KKyAgICAgICAgICAgICAgc2lzX2NoYXJfY2xhc3MgPSBO VUxMOw0KKyAgICAgICAgICAgICAgY2Rldl9kZWwoJnNpc19jaGFyX2NkZXYpOw0KKyAgICAgICAg ICAgICAgbWVtc2V0KCZzaXNfY2hhcl9jZGV2LCAwLCBzaXplb2Yoc3RydWN0IGNkZXYpKTsNCisg ICAgICAgICAgICAgIHNpc19jaGFyX21ham9yID0gMDsNCisgICAgICAgICAgICAgIHVucmVnaXN0 ZXJfY2hyZGV2X3JlZ2lvbihkZXYsIHNpc19jaGFyX2RldnNfY291bnQpOw0KKyAgICAgICAgICAg ICAgdXNiX2tpbGxfdXJiKGJhY2t1cF91cmIpOw0KKyAgICAgICAgICAgICAgdXNiX2ZyZWVfdXJi KGJhY2t1cF91cmIpOw0KKyAgICAgICAgICAgICAgYmFja3VwX3VyYiA9IE5VTEw7DQorICAgICAg ICAgICAgICBoaWRfZGV2X2JhY2t1cCA9IE5VTEw7DQorICAgICAgfQ0KK30NCmRpZmYgLS1naXQg YS9saW51eC0zLjE4LjUvZHJpdmVycy9oaWQvdXNiaGlkL2hpZC1xdWlya3MuYyBiL2xpbnV4LTMu MTguNS9kcml2ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5jDQppbmRleCA0NDc3ZWI3Li5iNTM0 MzIxIDEwMDY0NA0KLS0tIGEvbGludXgtMy4xOC41L2RyaXZlcnMvaGlkL3VzYmhpZC9oaWQtcXVp cmtzLmMNCisrKyBiL2xpbnV4LTMuMTguNS9kcml2ZXJzL2hpZC91c2JoaWQvaGlkLXF1aXJrcy5j DQpAQCAtOTcsNiArOTcsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGhpZF9ibGFja2xpc3Qgew0K ICAgICAgeyBVU0JfVkVORE9SX0lEX1NJR01BVEVMLCBVU0JfREVWSUNFX0lEX1NJR01BVEVMX1NU TVAzNzgwLCBISURfUVVJUktfTk9HRVQgfSwNCiAgICAgIHsgVVNCX1ZFTkRPUl9JRF9TSVNfVE9V Q0gsIFVTQl9ERVZJQ0VfSURfU0lTOTIwMF9UT1VDSCwgSElEX1FVSVJLX05PR0VUIH0sDQogICAg ICB7IFVTQl9WRU5ET1JfSURfU0lTX1RPVUNILCBVU0JfREVWSUNFX0lEX1NJUzgxN19UT1VDSCwg SElEX1FVSVJLX05PR0VUIH0sDQorICAgICAgeyBVU0JfVkVORE9SX0lEX1NJU19UT1VDSCwgVVNC X0RFVklDRV9JRF9TSVNGODE3X1RPVUNILCANCisgSElEX1FVSVJLX05PR0VUIH0sDQogICAgICB7 IFVTQl9WRU5ET1JfSURfU0lTX1RPVUNILCBVU0JfREVWSUNFX0lEX1NJU19UUywgSElEX1FVSVJL X05PX0lOSVRfUkVQT1JUUyB9LA0KICAgICAgeyBVU0JfVkVORE9SX0lEX1NJU19UT1VDSCwgVVNC X0RFVklDRV9JRF9TSVMxMDMwX1RPVUNILCBISURfUVVJUktfTk9HRVQgfSwNCiAgICAgIHsgVVNC X1ZFTkRPUl9JRF9TVU4sIFVTQl9ERVZJQ0VfSURfUkFSSVRBTl9LVk1fRE9OR0xFLCBISURfUVVJ UktfTk9HRVQgfSwNCg==