From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NgsVi-0000TY-3Z for qemu-devel@nongnu.org; Sun, 14 Feb 2010 23:24:38 -0500 Received: from [199.232.76.173] (port=59807 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NgsVh-0000TJ-Mz for qemu-devel@nongnu.org; Sun, 14 Feb 2010 23:24:37 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NgsVg-000770-Tu for qemu-devel@nongnu.org; Sun, 14 Feb 2010 23:24:37 -0500 Received: from col0-omc2-s4.col0.hotmail.com ([65.55.34.78]:31880) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NgsVg-00076w-KP for qemu-devel@nongnu.org; Sun, 14 Feb 2010 23:24:36 -0500 Message-ID: Content-Type: multipart/alternative; boundary="_20a44711-26fc-4292-a8aa-220c174e9c4e_" From: Taimoor Mirza Date: Mon, 15 Feb 2010 09:24:34 +0500 MIME-Version: 1.0 Subject: [Qemu-devel] EHCI support in QEMU List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org --_20a44711-26fc-4292-a8aa-220c174e9c4e_ Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable Hi all=2C =20 I downloaded version 0.12.2 of QEMU and I am unable to find EHCI support in= it. Does QEMU support EHCI emulation? Do I need to download some other pat= ch for it? QEMU documentation also does not tell anything about EHCI. =20 -Taimoor =20 _________________________________________________________________ Hotmail: Trusted email with powerful SPAM protection. https://signup.live.com/signup.aspx?id=3D60969= --_20a44711-26fc-4292-a8aa-220c174e9c4e_ Content-Type: text/html; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable Hi all=2C
=3B
I downloaded version 0.12.2 of QEMU and I am unable to find EHCI support in= it. Does QEMU support EHCI emulation? Do I need to download some other pat= ch for it? QEMU documentation also does not tell anything about EHCI.
=3B
-Taimoor

Hotmail: Trusted email with powerful SP= AM protection. Sign up now. = --_20a44711-26fc-4292-a8aa-220c174e9c4e_-- From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NgxO1-0008P0-QO for qemu-devel@nongnu.org; Mon, 15 Feb 2010 04:37:01 -0500 Received: from [199.232.76.173] (port=55746 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NgxO0-0008Os-BB for qemu-devel@nongnu.org; Mon, 15 Feb 2010 04:37:00 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NgxNz-0007Kd-74 for qemu-devel@nongnu.org; Mon, 15 Feb 2010 04:37:00 -0500 Received: from thoth.sbs.de ([192.35.17.2]:20621) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1NgxNy-0007Js-Mf for qemu-devel@nongnu.org; Mon, 15 Feb 2010 04:36:59 -0500 Message-ID: <4B7915B4.6040305@siemens.com> Date: Mon, 15 Feb 2010 10:36:52 +0100 From: Jan Kiszka MIME-Version: 1.0 References: In-Reply-To: Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Subject: [Qemu-devel] Re: EHCI support in QEMU List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Taimoor Mirza Cc: qemu-devel@nongnu.org Taimoor Mirza wrote: > Hi all, > > > > I downloaded version 0.12.2 of QEMU and I am unable to find EHCI support in it. Does QEMU support EHCI emulation? Do I need to download some other patch for it? QEMU documentation also does not tell anything about EHCI. > QEMU does not support USB 2.0 / EHCI yet. There were patches flying around here, but so far no one stepped up and seriously pushed that towards mainline. Jan -- Siemens AG, Corporate Technology, CT T DE IT 1 Corporate Competence Center Embedded Linux From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NmCGW-0002Oy-0N for qemu-devel@nongnu.org; Mon, 01 Mar 2010 15:30:56 -0500 Received: from [199.232.76.173] (port=40897 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NmCGV-0002Om-2p for qemu-devel@nongnu.org; Mon, 01 Mar 2010 15:30:55 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NmCGS-0001c9-Ep for qemu-devel@nongnu.org; Mon, 01 Mar 2010 15:30:54 -0500 Received: from mail-wy0-f173.google.com ([74.125.82.173]:34234) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NmCGS-0001bv-2h for qemu-devel@nongnu.org; Mon, 01 Mar 2010 15:30:52 -0500 Received: by wyb36 with SMTP id 36so1441785wyb.4 for ; Mon, 01 Mar 2010 12:30:49 -0800 (PST) MIME-Version: 1.0 Sender: niels@nixpanic.net In-Reply-To: <4B7915B4.6040305@siemens.com> References: <4B7915B4.6040305@siemens.com> Date: Mon, 1 Mar 2010 20:30:49 +0000 Message-ID: <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> Subject: Re: [Qemu-devel] Re: EHCI support in QEMU From: Niels de Vos Content-Type: text/plain; charset=UTF-8 List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Taimoor Mirza , Jan Kiszka Cc: qemu-devel@nongnu.org Hello Jan and Taimoor, On Mon, Feb 15, 2010 at 9:36 AM, Jan Kiszka wrote: >> I downloaded version 0.12.2 of QEMU and I am unable to find EHCI >> support in it. Does QEMU support EHCI emulation? Do I need to >> download some other patch for it? QEMU documentation also does not >> tell anything about EHCI. >> > > QEMU does not support USB 2.0 / EHCI yet. There were patches flying > around here, but so far no one stepped up and seriously pushed that > towards mainline. By coincidence I was looking into the same. I found http://lists.gnu.org/archive/html/qemu-devel/2008-10/msg01326.html and started to port it to the current git-tree. My google foo did not reveal any other/newer/more-complete patches. The status of this patch is unknown to me, but seems to be a good start. If someone is interested in this partially ported patch, I'm happy to share, but it will at least need some attention to make it compile. After that, lots of tests need to be done and probably quite some bugfixes are required. I'm happy to assist, but do not have a lot of time to spare on this hobby project. On the occasion that it is something more solid and starting to do something, I will of course inform this list again. Cheers, Niels From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NmD08-0000Hv-8A for qemu-devel@nongnu.org; Mon, 01 Mar 2010 16:18:04 -0500 Received: from [199.232.76.173] (port=51672 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NmD07-0000Gk-Lp for qemu-devel@nongnu.org; Mon, 01 Mar 2010 16:18:03 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NmD05-00043v-BC for qemu-devel@nongnu.org; Mon, 01 Mar 2010 16:18:02 -0500 Received: from fmmailgate01.web.de ([217.72.192.221]:43449) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NmD04-00043X-SQ for qemu-devel@nongnu.org; Mon, 01 Mar 2010 16:18:01 -0500 Message-ID: <4B8C2EFF.3030106@web.de> Date: Mon, 01 Mar 2010 22:17:51 +0100 From: Jan Kiszka MIME-Version: 1.0 References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> In-Reply-To: <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="------------enigCCCA8283CF6DE5B4429362B6" Sender: jan.kiszka@web.de Subject: [Qemu-devel] Re: EHCI support in QEMU List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Niels de Vos Cc: Taimoor Mirza , qemu-devel@nongnu.org This is an OpenPGP/MIME signed message (RFC 2440 and 3156) --------------enigCCCA8283CF6DE5B4429362B6 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Niels de Vos wrote: > Hello Jan and Taimoor, >=20 > On Mon, Feb 15, 2010 at 9:36 AM, Jan Kiszka wr= ote: >>> I downloaded version 0.12.2 of QEMU and I am unable to find EHCI >>> support in it. Does QEMU support EHCI emulation? Do I need to >>> download some other patch for it? QEMU documentation also does not >>> tell anything about EHCI. >>> >> QEMU does not support USB 2.0 / EHCI yet. There were patches flying >> around here, but so far no one stepped up and seriously pushed that >> towards mainline. >=20 > By coincidence I was looking into the same. I found > http://lists.gnu.org/archive/html/qemu-devel/2008-10/msg01326.html and > started to port it to the current git-tree. My google foo did not revea= l > any other/newer/more-complete patches. The status of this patch is > unknown to me, but seems to be a good start. This should indeed be the version I had in mind as well - hell, already 1.5 years since then, and still no EHCI upstream... >=20 > If someone is interested in this partially ported patch, I'm happy to > share, but it will at least need some attention to make it compile. > After that, lots of tests need to be done and probably quite some > bugfixes are required. I'm happy to assist, but do not have a lot of > time to spare on this hobby project. On the occasion that it is somethi= ng > more solid and starting to do something, I will of course inform this l= ist > again. OK, to keep this heavy ball rolling, I would suggest posting your patch. Either it's already in a good shape to get it merged as experimental feature. Or I will pick it up in git tree, collect patches as they fly in, and will keep on pushing it upstream. I can't promise spending much time on hacking, but integration work, basic testing, and some more or less helpful comments should be feasible. Thanks, Jan --------------enigCCCA8283CF6DE5B4429362B6 Content-Type: application/pgp-signature; name="signature.asc" Content-Description: OpenPGP digital signature Content-Disposition: attachment; filename="signature.asc" -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.9 (GNU/Linux) Comment: Using GnuPG with SUSE - http://enigmail.mozdev.org iEYEARECAAYFAkuMLwIACgkQitSsb3rl5xQ2GQCfccxNM3r6agBGdtM/OXjyJMzo 4wAAn0U0Qyqh1bOjWSjfxKxUjS8MSX32 =1Jbv -----END PGP SIGNATURE----- --------------enigCCCA8283CF6DE5B4429362B6-- From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NmPfO-00015Y-Hd for qemu-devel@nongnu.org; Tue, 02 Mar 2010 05:49:30 -0500 Received: from [199.232.76.173] (port=37622 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NmPfN-00013e-3e for qemu-devel@nongnu.org; Tue, 02 Mar 2010 05:49:29 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NmPfM-0001aP-Dr for qemu-devel@nongnu.org; Tue, 02 Mar 2010 05:49:28 -0500 Received: from mx1.redhat.com ([209.132.183.28]:10949) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NmPfM-0001aH-2F for qemu-devel@nongnu.org; Tue, 02 Mar 2010 05:49:28 -0500 Message-ID: <4B8CED08.2030705@redhat.com> Date: Tue, 02 Mar 2010 11:48:40 +0100 From: Kevin Wolf MIME-Version: 1.0 Subject: Re: [Qemu-devel] Re: EHCI support in QEMU References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> <4B8C2EFF.3030106@web.de> In-Reply-To: <4B8C2EFF.3030106@web.de> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Jan Kiszka Cc: Taimoor Mirza , Niels de Vos , qemu-devel@nongnu.org Am 01.03.2010 22:17, schrieb Jan Kiszka: > Niels de Vos wrote: >> If someone is interested in this partially ported patch, I'm happy to >> share, but it will at least need some attention to make it compile. >> After that, lots of tests need to be done and probably quite some >> bugfixes are required. I'm happy to assist, but do not have a lot of >> time to spare on this hobby project. On the occasion that it is something >> more solid and starting to do something, I will of course inform this list >> again. > > OK, to keep this heavy ball rolling, I would suggest posting your patch. > Either it's already in a good shape to get it merged as experimental > feature. Or I will pick it up in git tree, collect patches as they fly > in, and will keep on pushing it upstream. I can't promise spending much > time on hacking, but integration work, basic testing, and some more or > less helpful comments should be feasible. Yes, please post it. I won't promise anything either, but maybe I can find some time to help a bit. Anyway, I'd love to see EHCI in qemu. Kevin From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1Nmme4-0003Ef-Dk for qemu-devel@nongnu.org; Wed, 03 Mar 2010 06:21:40 -0500 Received: from [199.232.76.173] (port=38886 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Nmme3-0003EN-Ut for qemu-devel@nongnu.org; Wed, 03 Mar 2010 06:21:39 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1Nmmdy-0003Og-9Q for qemu-devel@nongnu.org; Wed, 03 Mar 2010 06:21:39 -0500 Received: from mail-ww0-f45.google.com ([74.125.82.45]:54834) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1Nmmdx-0003Oc-6I for qemu-devel@nongnu.org; Wed, 03 Mar 2010 06:21:34 -0500 Received: by wwb34 with SMTP id 34so645614wwb.4 for ; Wed, 03 Mar 2010 03:21:29 -0800 (PST) MIME-Version: 1.0 Sender: niels@nixpanic.net In-Reply-To: <4B8CED08.2030705@redhat.com> References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> <4B8C2EFF.3030106@web.de> <4B8CED08.2030705@redhat.com> Date: Wed, 3 Mar 2010 11:21:28 +0000 Message-ID: <1b51b6f81003030321g6a3eb47ak6a59267cae50b7f2@mail.gmail.com> Subject: Re: [Qemu-devel] Re: EHCI support in QEMU From: Niels de Vos Content-Type: text/plain; charset=UTF-8 List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Jan Kiszka Cc: Taimoor Mirza , Kevin Wolf , qemu-devel@nongnu.org On Tue, Mar 2, 2010 at 10:48 AM, Kevin Wolf wrote: > Am 01.03.2010 22:17, schrieb Jan Kiszka: >> Niels de Vos wrote: >>> If someone is interested in this partially ported patch, I'm happy to >>> share, but it will at least need some attention to make it compile. >>> After that, lots of tests need to be done and probably quite some >>> bugfixes are required. I'm happy to assist, but do not have a lot of >>> time to spare on this hobby project. On the occasion that it is something >>> more solid and starting to do something, I will of course inform this list >>> again. >> >> OK, to keep this heavy ball rolling, I would suggest posting your patch. >> Either it's already in a good shape to get it merged as experimental >> feature. Or I will pick it up in git tree, collect patches as they fly >> in, and will keep on pushing it upstream. I can't promise spending much >> time on hacking, but integration work, basic testing, and some more or >> less helpful comments should be feasible. > > Yes, please post it. I won't promise anything either, but maybe I can > find some time to help a bit. Anyway, I'd love to see EHCI in qemu. Okay, here it is. Please note that the patch is very raw, does not compile and even basic things like indention is broken at the moment. Please refer to http://lists.gnu.org/archive/html/qemu-devel/2008-10/msg01326.html for the original author, nothing seriously of this patch is done by me. Kind regards and thanks for your help, Niels diff --git a/Makefile.target b/Makefile.target index 320f807..b797842 100644 --- a/Makefile.target +++ b/Makefile.target @@ -208,7 +208,7 @@ obj-i386-y += pckbd.o $(sound-obj-y) dma.o obj-i386-y += vga.o vga-pci.o vga-isa.o obj-i386-y += fdc.o mc146818rtc.o serial.o i8259.o i8254.o pcspk.o pc.o obj-i386-y += cirrus_vga.o apic.o ioapic.o parallel.o acpi.o piix_pci.o -obj-i386-y += usb-uhci.o vmmouse.o vmport.o vmware_vga.o hpet.o +obj-i386-y += usb-uhci.o usb-ehci.o vmmouse.o vmport.o vmware_vga.o hpet.o obj-i386-y += device-hotplug.o pci-hotplug.o smbios.o wdt_ib700.o obj-i386-y += ne2000-isa.o debugcon.o multiboot.o diff --git a/hw/pc.c b/hw/pc.c index 4f6a522..0b29e1d 100644 --- a/hw/pc.c +++ b/hw/pc.c @@ -28,6 +28,7 @@ #include "vmware_vga.h" #include "usb-uhci.h" #include "usb-ohci.h" +#include "usb-ehci.h" #include "prep_pci.h" #include "apb_pci.h" #include "block.h" @@ -1016,8 +1017,11 @@ static void pc_init1(ram_addr_t ram_size, cmos_init(below_4g_mem_size, above_4g_mem_size, boot_device, hd); + // TODO the piix3 does not have EHCI - looks like ICH4 + // was first southbridge to support it. if (pci_enabled && usb_enabled) { - usb_uhci_piix3_init(pci_bus, piix3_devfn + 2); + usb_uhci_piix3_init(pci_bus, piix3_devfn + 3); + usb_ehci_init(pci_bus, piix3_devfn + 2); } if (pci_enabled && acpi_enabled) { @@ -1025,7 +1029,7 @@ static void pc_init1(ram_addr_t ram_size, i2c_bus *smbus; /* TODO: Populate SPD eeprom data. */ - smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100, + smbus = piix4_pm_init(pci_bus, piix3_devfn + 4, 0xb100, isa_reserve_irq(9)); for (i = 0; i < 8; i++) { DeviceState *eeprom; diff --git a/hw/usb-ehci.c b/hw/usb-ehci.c new file mode 100644 index 0000000..93121e8 --- /dev/null +++ b/hw/usb-ehci.c @@ -0,0 +1,2044 @@ +/* + * QEMU USB EHCI Emulation + * + * Copyright(c) 2008 Emutex Ltd. (address@hidden) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or(at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * TODO: + * o Downstream port handoff + */ + +#include "hw.h" +#include "qemu-timer.h" +#include "usb.h" +#include "pci.h" + +// #define DEBUG(x) timed_printf x +// #define DEBUG(x) printf x +#define DEBUG(x) +// #define TDEBUG +// #define DEBUG_PACKET + +#define ASSERT(x) { if (!(x)) { printf("Assertion failed in usb-echi.c line %d\n", __LINE__); exit(1); } } + +#define MMIO_SIZE 0x1000 + +#define CAPREGBASE 0x0000 // Capability Registers Base Address + +#define CAPLENGTH CAPREGBASE + 0x0000 +#define HCIVERSION CAPREGBASE + 0x0002 +#define HCSPARAMS CAPREGBASE + 0x0004 +#define HCCPARAMS CAPREGBASE + 0x0008 +#define EECP HCCPARAMS + 1 +#define HCSPPORTROUTE1 CAPREGBASE + 0x000c +#define HCSPPORTROUTE2 CAPREGBASE + 0x0010 + +#define OPREGBASE 0x0020 // Operational Registers Base Address + +#define USBCMD OPREGBASE + 0x0000 +#define USBCMD_RUNSTOP (1 << 0) // run / Stop +#define USBCMD_HCRESET (1 << 1) // HC Reset +#define USBCMD_FLS (3 << 2) // Frame List Size +#define USBCMD_FLS_SH 2 // Frame List Size Shift +#define USBCMD_PSE (1 << 4) // Periodic Schedule Enable +#define USBCMD_ASE (1 << 5) // Asynch Schedule Enable +#define USBCMD_IAAD (1 << 6) // Int Asynch Advance Doorbell +#define USBCMD_LHCR (1 << 7) // Light Host Controller Reset +#define USBCMD_ASPMC (3 << 8) // Async Sched Park Mode Count +#define USBCMD_ASPME (1 << 11) // Async Sched Park Mode Enable +#define USBCMD_ITC (0x7f << 16) // Int Threshold Control +#define USBCMD_ITC_SH 16 // Int Threshold Control Shift + +#define USBSTS OPREGBASE + 0x0004 +#define USBSTS_RO_MASK 0x0000003f +#define USBSTS_INT (1 << 0) // USB Interrupt +#define USBSTS_ERRINT (1 << 1) // Error Interrupt +#define USBSTS_PCD (1 << 2) // Port Change Detect +#define USBSTS_FLR (1 << 3) // Frame List Rollover +#define USBSTS_HSE (1 << 4) // Host System Error +#define USBSTS_IAA (1 << 5) // Interrupt Async Advance +#define USBSTS_HALT (1 << 12) // HC Halted +#define USBSTS_REC (1 << 13) // Reclamation +#define USBSTS_PSS (1 << 14) // Periodic Schedule Status +#define USBSTS_ASS (1 << 15) // Asynchronous Schedule Status + +/* + * Interrupt enable bits correspond to the interrupt active bits in USBSTS + * so no need to redefine here. + */ +#define USBINTR OPREGBASE + 0x0008 +#define USBINTR_MASK 0x0000003f + +#define FRINDEX OPREGBASE + 0x000c +#define CTRLDSSEGMENT OPREGBASE + 0x0010 +#define PERIODICLISTBASE OPREGBASE + 0x0014 +#define ASYNCLISTADDR OPREGBASE + 0x0018 +#define ASYNCLISTADDR_MASK 0xffffffe0 + +#define CONFIGFLAG OPREGBASE + 0x0040 + +#define PORTSC (OPREGBASE + 0x0044) +#define PORTSC_BEGIN PORTSC +#define PORTSC_END (PORTSC + 4 * NB_PORTS) +/* + * Bits that are reserverd or are read-only are masked out of values + * written to us by software + */ +#define PORTSC_RO_MASK 0x007021c5 +#define PORTSC_RWC_MASK 0x0000002a +#define PORTSC_WKOC_E (1 << 22) // Wake on Over Current Enable +#define PORTSC_WKDS_E (1 << 21) // Wake on Disconnect Enable +#define PORTSC_WKCN_E (1 << 20) // Wake on Connect Enable +#define PORTSC_PTC (15 << 16) // Port Test Control +#define PORTSC_PTC_SH 16 // Port Test Control shift +#define PORTSC_PIC (3 << 14) // Port Indicator Control +#define PORTSC_PIC_SH 14 // Port Indicator Control Shift +#define PORTSC_POWNER (1 << 13) // Port Owner +#define PORTSC_PPOWER (1 << 12) // Port Power +#define PORTSC_LINESTAT (3 << 10) // Port Line Status +#define PORTSC_LINESTAT_SH 10 // Port Line Status Shift +#define PORTSC_PRESET (1 << 8) // Port Reset +#define PORTSC_SUSPEND (1 << 7) // Port Suspend +#define PORTSC_FPRES (1 << 6) // Force Port Resume +#define PORTSC_OCC (1 << 5) // Over Current Change +#define PORTSC_OCA (1 << 4) // Over Current Active +#define PORTSC_PEDC (1 << 3) // Port Enable/Disable Change +#define PORTSC_PED (1 << 2) // Port Enable/Disable +#define PORTSC_CSC (1 << 1) // Connect Status Change +#define PORTSC_CONNECT (1 << 0) // Current Connect Status + +#define EHCI_NOMICROFRAMES + +#ifdef EHCI_NOMICROFRAMES +#define FRAME_TIMER_FREQ 2000 +#else +#define FRAME_TIMER_FREQ 8000 +#endif + +#define NB_MAXINTRATE 8 // Max rate at which controller issues ints +#define NB_PORTS 4 // Number of downstream ports +#define BUFF_SIZE 20480 // Max bytes to transfer per transaction +#define MAX_ITERATIONS 1000 // Max number of states before we abort +#define MAX_QH 1000 // Max allowable queue heads in a chain + +/* Internal periodic / asynchronous schedule state machine states + */ +typedef enum { + EST_INACTIVE = 1000, + EST_ACTIVE, + EST_EXECUTING, + EST_SLEEPING, + /* The following states are internal to the state machine function + */ + EST_WAITLISTHEAD, + EST_DORELOAD, + EST_WAITSTARTEVENT, + EST_FETCHENTRY, + EST_FETCHQH, + EST_FETCHITD, + EST_ADVANCEQUEUE, + EST_FETCHQTD, + EST_EXECUTE, + EST_WRITEBACK, + EST_HORIZONTALQH +} EHCI_STATES; + +/* EHCI spec version 1.0 Section 3.3 + */ +typedef struct EHCIitd { + uint32_t next; +#define NLPTR_GET(x) ((x) & 0xffffffe0) +#define NLPTR_TYPE_GET(x) (((x) >> 1) & 3) +#define NLPTR_TYPE_ITD 0 +#define NLPTR_TYPE_QH 1 +#define NLPTR_TYPE_STITD 2 +#define NLPTR_TYPE_FSTN 3 +#define NLPTR_TBIT(x) ((x) & 1) + + uint32_t transact[8]; +#define ITD_XACT_ACTIVE (1 << 31) +#define ITD_XACT_DBERROR (1 << 30) +#define ITD_XACT_BABBLE (1 << 29) +#define ITD_XACT_XACTERR (1 << 28) +#define ITD_XACT_LENGTH_MASK 0x0fff0000 +#define ITD_XACT_LENGTH_SH 16 +#define ITD_XACT_IOC (1 << 15) +#define ITD_XACT_PGSEL_MASK 0x00007000 +#define ITD_XACT_PGSEL_SH 12 +#define ITD_XACT_OFFSET_MASK 0x00000fff + + uint32_t bufptr[7]; +#define ITD_BUFPTR_MASK 0xfffff000 +#define ITD_BUFPTR_SH 12 +#define ITD_BUFPTR_EP_MASK 0x00000f00 +#define ITD_BUFPTR_EP_SH 8 +#define ITD_BUFPTR_DEVADDR_MASK 0x0000007f +#define ITD_BUFPTR_DIRECTION (1 << 11) +#define ITD_BUFPTR_MAXPKT_MASK 0x000007ff +#define ITD_BUFPTR_MULT_MASK 0x00000003 +} EHCIitd; + +/* EHCI spec version 1.0 Section 3.4 + */ +typedef struct EHCIsitd { + uint32_t next; // Standard next link pointer + uint32_t epchar; +#define SITD_EPCHAR_IO (1 << 31) +#define SITD_EPCHAR_PORTNUM_MASK 0x7f000000 +#define SITD_EPCHAR_PORTNUM_SH 24 +#define SITD_EPCHAR_HUBADD_MASK 0x007f0000 +#define SITD_EPCHAR_HUBADDR_SH 16 +#define SITD_EPCHAR_EPNUM_MASK 0x00000f00 +#define SITD_EPCHAR_EPNUM_SH 8 +#define SITD_EPCHAR_DEVADDR_MASK 0x0000007f + + uint32_t uframe; +#define SITD_UFRAME_CMASK_MASK 0x0000ff00 +#define SITD_UFRAME_CMASK_SH 8 +#define SITD_UFRAME_SMASK_MASK 0x000000ff + + uint32_t results; +#define SITD_RESULTS_IOC (1 << 31) +#define SITD_RESULTS_PGSEL (1 << 30) +#define SITD_RESULTS_TBYTES_MASK 0x03ff0000 +#define SITD_RESULTS_TYBYTES_SH 16 +#define SITD_RESULTS_CPROGMASK_MASK 0x0000ff00 +#define SITD_RESULTS_CPROGMASK_SH 8 +#define SITD_RESULTS_ACTIVE (1 << 7) +#define SITD_RESULTS_ERR (1 << 6) +#define SITD_RESULTS_DBERR (1 << 5) +#define SITD_RESULTS_BABBLE (1 << 4) +#define SITD_RESULTS_XACTERR (1 << 3) +#define SITD_RESULTS_MISSEDUF (1 << 2) +#define SITD_RESULTS_SPLITXSTATE (1 << 1) + + uint32_t bufptr[2]; +#define BUFPTR_MASK 0xfffff000 +#define BUFPTR_CURROFF_MASK 0x00000fff +#define BUFPTR_TPOS_MASK 0x00000018 +#define BUFPTR_TPOS_SH 3 +#define BUFPTR_TCNT_MASK 0x00000007 + + uint32_t backptr; // Standard next link pointer +} EHCIsitd; + +/* EHCI spec version 1.0 Section 3.5 + */ +typedef struct EHCIqtd { + uint32_t next; // Standard next link pointer + uint32_t altnext; // Standard next link pointer + uint32_t token; +#define QTD_TOKEN_DTOGGLE (1 << 31) +#define QTD_TOKEN_TBYTES_MASK 0x7fff0000 +#define QTD_TOKEN_TBYTES_SH 16 +#define QTD_TOKEN_IOC (1 << 15) +#define QTD_TOKEN_CPAGE_MASK 0x00007000 +#define QTD_TOKEN_CPAGE_SH 12 +#define QTD_TOKEN_CERR_MASK 0x00000c00 +#define QTD_TOKEN_CERR_SH 10 +#define QTD_TOKEN_PID_MASK 0x00000300 +#define QTD_TOKEN_PID_SH 8 +#define QTD_TOKEN_ACTIVE (1 << 7) +#define QTD_TOKEN_HALT (1 << 6) +#define QTD_TOKEN_DBERR (1 << 5) +#define QTD_TOKEN_BABBLE (1 << 4) +#define QTD_TOKEN_XACTERR (1 << 3) +#define QTD_TOKEN_MISSEDUF (1 << 2) +#define QTD_TOKEN_SPLITXSTATE (1 << 1) +#define QTD_TOKEN_PING (1 << 0) + + uint32_t bufptr[5]; // Standard buffer pointer +} EHCIqtd; + +/* EHCI spec version 1.0 Section 3.6 + */ +typedef struct EHCIqh { + uint32_t next; // Standard next link pointer + + uint32_t epchar; +#define QH_EPCHAR_RL_MASK 0xf0000000 +#define QH_EPCHAR_RL_SH 28 +#define QH_EPCHAR_C (1 << 27) +#define QH_EPCHAR_MPLEN_MASK 0x07FF0000 +#define QH_EPCHAR_MPLEN_SH 16 +#define QH_EPCHAR_H (1 << 15) +#define QH_EPCHAR_DTC (1 << 14) +#define QH_EPCHAR_EPS_MASK 0x00003000 +#define QH_EPCHAR_EPS_SH 12 +#define QH_EPCHAR_EP_MASK 0x00000f00 +#define QH_EPCHAR_EP_SH 8 +#define QH_EPCHAR_I (1 << 7) +#define QH_EPCHAR_DEVADDR_MASK 0x0000007f + + uint32_t epcap; +#define QH_EPCAP_MULT_MASK 0xc0000000 +#define QH_EPCAP_MULT_SH 30 +#define QH_EPCAP_PORTNUM_MASK 0x3f800000 +#define QH_EPCAP_PORTNUM_SH 23 +#define QH_EPCAP_HUBADDR_MASK 0x007f0000 +#define QH_EPCAP_HUBADDR_SH 16 +#define QH_EPCAP_CMASK_MASK 0x0000ff00 +#define QH_EPCAP_CMASK_SH 8 +#define QH_EPCAP_SMASK_MASK 0x000000ff + + uint32_t current; // Standard next link pointer + uint32_t qtdnext; // Standard next link pointer + uint32_t altnext; +#define QH_ALTNEXT_NAKCNT_MASK 0x0000001e +#define QH_ALTNEXT_NAKCNT_SH 1 + + uint32_t token; // Same as QTD token + uint32_t bufptr[5]; // Standard buffer pointer +#define BUFPTR_CPROGMASK_MASK 0x000000ff +#define BUFPTR_FRAMETAG_MASK 0x0000001f +#define BUFPTR_SBYTES_MASK 0x00000fe0 +#define BUFPTR_SBYTES_SH 5 +} EHCIqh; + +/* EHCI spec version 1.0 Section 3.7 + */ +typedef struct EHCIfstn { + uint32_t next; // Standard next link pointer + uint32_t backptr; // Standard next link pointer +} EHCIfstn; + +typedef struct { + PCIDevice dev; + qemu_irq irq; + target_phys_addr_t mem_base; + int mem; + int num_ports; + /* + * EHCI spec version 1.0 Section 2.3 + * Host Controller Operational Registers + */ + union { + uint8_t mmio[MMIO_SIZE]; + struct { + uint8_t cap[OPREGBASE]; + uint32_t usbcmd; + uint32_t usbsts; + uint32_t usbintr; + uint32_t frindex; + uint32_t ctrldssegment; + uint32_t periodiclistbase; + uint32_t asynclistaddr; + uint32_t notused[9]; + uint32_t configflag; + uint32_t portsc[NB_PORTS]; + }; + }; + /* + * Internal states, shadow registers, etc + */ + uint32_t sofv; + QEMUTimer *frame_timer; + int attach_poll_counter; + int astate; // Current state in asynchronous schedule + int pstate; // Current state in periodic schedule + USBPort ports[NB_PORTS]; + unsigned char buffer[BUFF_SIZE]; + EHCIqh qh; + EHCIqtd qtd; + USBBus bus; + USBPacket usb_packet; + int async_port_in_progress; + int async_complete; + uint32_t qhaddr; + uint32_t itdaddr; + uint32_t qtdaddr; + uint32_t tbytes; + int pid; + int exec_status; + int isoch_pause; + uint32_t last_run_usec; + uint32_t frame_end_usec; +} EHCIState; + +static inline uint32_t get_field(uint32_t data, uint32_t mask, int shift) +{ + return((data & mask) >> shift); +} + +static inline void set_field(uint32_t *data, uint32_t val, + uint32_t mask, int shift) +{ + *data &= ~mask; + *data |=(val << shift); +} + +static void dump_ptr(char *s, uint32_t ptr, int has_type) +{ + int t = NLPTR_TYPE_GET(ptr); + + printf("%s%08X", s, NLPTR_GET(ptr)); + + if (has_type) { + printf("(PTR type is %s)", + t == NLPTR_TYPE_ITD ? "ITD" : + (t == NLPTR_TYPE_QH ? "QH" : + (t == NLPTR_TYPE_STITD ? "STITD" : + (t == NLPTR_TYPE_FSTN ? "FSTN" : "****")))); + } + + printf("%s\n", NLPTR_TBIT(ptr) ? " TBIT set" : ""); +} + +static void dump_qtd(EHCIqtd *qtd, uint32_t qtdaddr) +{ + int pid; + + pid =(qtd->token & QTD_TOKEN_PID_MASK) >> QTD_TOKEN_PID_SH; + + printf(" QTD analysis %08X\n" + " === ======== ========\n", qtdaddr); + + printf(" NakCnt: %d\n", + (qtd->altnext & QH_ALTNEXT_NAKCNT_MASK) >> QH_ALTNEXT_NAKCNT_SH); + dump_ptr(" Next: ", qtd->next, 0); + dump_ptr(" Alternate: ", qtd->altnext, 0); + printf(" Data Toggle: %s ", + qtd->token & QTD_TOKEN_DTOGGLE ? "Yes " : "No "); + printf(" Total Bytes: %d\n", + (qtd->token & QTD_TOKEN_TBYTES_MASK) >> QTD_TOKEN_TBYTES_SH); + printf(" IOC: %s ", + qtd->token & QTD_TOKEN_IOC ? "Yes " : "No "); + printf(" C_Page: %d\n", + (qtd->token & QTD_TOKEN_CPAGE_MASK) >> QTD_TOKEN_CPAGE_SH); + printf(" CErr: %-4d ", + (qtd->token & QTD_TOKEN_CERR_MASK) >> QTD_TOKEN_CERR_SH); + printf(" PID code: %s\n", + pid == 0 ? "OUT" : + (pid == 1 ? "IN" : + (pid == 2 ? "SETUP" : "****"))); + printf(" Flags: %s%s%s%s%s%s%s%s\n", + qtd->token & QTD_TOKEN_ACTIVE ? "ACTIVE " : "", + qtd->token & QTD_TOKEN_HALT ? "HALT " : "", + qtd->token & QTD_TOKEN_DBERR ? "DBERR " : "", + qtd->token & QTD_TOKEN_BABBLE ? "BABBLE " : "", + qtd->token & QTD_TOKEN_XACTERR ? "XACTERR " : "", + qtd->token & QTD_TOKEN_MISSEDUF ? "MISSEDUF " : "", + qtd->token & QTD_TOKEN_SPLITXSTATE ? "SPLITXSTATE " : "", + qtd->token & QTD_TOKEN_PING ? "PING " : ""); + printf(" Current Offset %d\n", + qtd->bufptr[0] & BUFPTR_CURROFF_MASK); + printf(" === ======== ========\n"); +} + +static void dump_qh(EHCIqh *qh, uint32_t qhaddr) +{ + int speed =(qh->epchar & QH_EPCHAR_EPS_MASK) >> QH_EPCHAR_EPS_SH; + + printf("QH analysis %08X\n" + "== ======== ========\n", qhaddr); + + dump_ptr("Horizontal: ", qh->next, 1); + printf("Nak Count Reload: %d\n", + (qh->epchar & QH_EPCHAR_RL_MASK) >> QH_EPCHAR_RL_SH); + printf("Max Pkt Len: %d\n", + (qh->epchar & QH_EPCHAR_MPLEN_MASK) >> QH_EPCHAR_MPLEN_SH); + printf("Control Endpoint: %s ", + (qh->epchar & QH_EPCHAR_C) ? "Yes " : "No "); + printf("H-bit: %s\n", + (qh->epchar & QH_EPCHAR_H) ? "Yes " : "No "); + printf("DTC: %s ", + (qh->epchar & QH_EPCHAR_DTC) ? "Yes " : "No "); + printf("EndPoint Speed: %s\n", + speed == 0 ? "Full" : + (speed == 1 ? "Low " : + (speed == 2 ? "High" : "****"))); + printf("EndPoint: %-4d ", + (qh->epchar & QH_EPCHAR_EP_MASK) >> QH_EPCHAR_EP_SH); + printf("Inactive on next: %s\n", + (qh->epchar & QH_EPCHAR_I) ? "Yes" : "No"); + printf("DevAddr: %-4d ", + qh->epchar & QH_EPCHAR_DEVADDR_MASK); + printf("Mult: %-4d\n", + (qh->epcap & QH_EPCAP_MULT_MASK) >> QH_EPCAP_MULT_SH); + printf("PortNum: %-4d ", + (qh->epcap & QH_EPCAP_PORTNUM_MASK) >> QH_EPCAP_PORTNUM_SH); + printf("HubAddr: %d\n", + (qh->epcap & QH_EPCAP_HUBADDR_MASK) >> QH_EPCAP_HUBADDR_SH); + printf("C-mask: %-4d ", + (qh->epcap & QH_EPCAP_CMASK_MASK) >> QH_EPCAP_CMASK_SH); + printf("S-mask: %d\n", + qh->epcap & QH_EPCAP_SMASK_MASK); + dump_ptr("Current: ", qh->current, 0); + + dump_qtd((EHCIqtd *)&qh->qtdnext, qhaddr + 16); + + printf("C-prog mask: %d\n", + qh->bufptr[1] & BUFPTR_CPROGMASK_MASK); + printf("S-bytes: %d\n", + qh->bufptr[2] & BUFPTR_FRAMETAG_MASK); + printf("FrameTag: %d\n", + (qh->bufptr[2] & BUFPTR_SBYTES_MASK) >> BUFPTR_SBYTES_SH); + printf("== ======== ========\n"); +} + +#ifdef DEBUG_PACKET + +static void dump_itd(EHCIitd *itd, uint32_t addr) +{ + int i; + + printf("ITD analysis %08X\n" + "=== ======== ========\n", addr); + + dump_ptr("Horizontal: ", itd->next, 1); + + for(i = 0; i < 8; i++) { + printf("Trans Desc %d, len %5d, off %03X, page sel %d, ioc:%s ", + i, + get_field(itd->transact[i], ITD_XACT_LENGTH_MASK, + ITD_XACT_LENGTH_SH), + get_field(itd->transact[i], ITD_XACT_OFFSET_MASK, 0), + get_field(itd->transact[i], ITD_XACT_PGSEL_MASK, + ITD_XACT_PGSEL_SH), + itd->transact[i] & ITD_XACT_IOC ? "Yes" : "No "); + + if (itd->transact[i] & ITD_XACT_ACTIVE) + printf("ACTIVE "); + + if (itd->transact[i] & ITD_XACT_DBERROR) + printf("DATAERR "); + + if (itd->transact[i] & ITD_XACT_BABBLE) + printf("BABBLE "); + + if (itd->transact[i] & ITD_XACT_XACTERR) + printf("XACTERR "); + + printf("\n"); + } + + printf("Device: %d\n", + get_field(itd->bufptr[0], ITD_BUFPTR_DEVADDR_MASK, 0)); + + printf("Endpoint: %d\n", + get_field(itd->bufptr[0], ITD_BUFPTR_EP_MASK, ITD_BUFPTR_EP_SH)); + + printf("Direction: %s\n", + itd->bufptr[1] & ITD_BUFPTR_DIRECTION ? "IN" : "OUT"); + + printf("Max Packet: %d\n", + get_field(itd->bufptr[1], ITD_BUFPTR_MAXPKT_MASK, 0)); + + printf("Mult: %d\n", + get_field(itd->bufptr[2], ITD_BUFPTR_MULT_MASK, 0)); + + for(i = 0; i < 7; i++) + printf("Buf Ptr %d: %05X\n", i, itd->bufptr[i] >> 12); +} + +#endif + +int timed_printf(char *fmt, ...) +{ + int msec, usec; + static int usec_last; + va_list ap; + + usec = qemu_get_clock(vm_clock) / 1000; + + msec = usec - usec_last; + usec_last = usec; + usec = msec; + + msec /= 1000; + msec %= 1000; + + usec %= 1000; + + va_start(ap, fmt); + printf("%03d.%03d ", msec, usec); + vprintf(fmt, ap); + va_end(ap); + + return 0; +} + +static void inline ehci_set_interrupt(EHCIState *ehci, int intr) +{ + int level = 0; + + // TODO honour interrupt threshold requests + + ehci->usbsts |= intr; + + if ((ehci->usbsts & USBINTR_MASK) & ehci->usbintr) + level = 1; + +#ifdef TDEBUG + DEBUG(("ehci: setting interrupt level %d(st/en)=(%02X/%02X)\n", level, + ehci->usbsts & USBINTR_MASK, ehci->usbintr)); +#endif + qemu_set_irq(ehci->irq, level); +} + +/* Attach or detach a device on root hub */ + +static void ehci_attach(USBPort *port, USBDevice *dev) +{ + EHCIState *s = port->opaque; + uint32_t *portsc = &s->portsc[port->index]; + + if (dev) { + if (port->dev) { + usb_attach(port, NULL); + } + + *portsc |= PORTSC_CONNECT; + + usb_send_msg(dev, USB_MSG_ATTACH); + port->dev = dev; + } else { + *portsc &= ~PORTSC_CONNECT; + + if (port->dev) { + dev = port->dev; + usb_send_msg(dev, USB_MSG_DETACH); + } + + port->dev = NULL; + } + + *portsc |= PORTSC_CSC; + + /* + * If a high speed device is attached then we own this port(indicated + * by zero in the PORTSC_POWNER bit field) so set the status bit + * and set an interrupt if enabled. + */ + if ( !(*portsc & PORTSC_POWNER)) { + ehci_set_interrupt(s, USBSTS_PCD); + } +} + +static void ehci_reset(EHCIState *s) +{ + uint8_t *pci_conf; + int i; + + pci_conf = s->dev.config; + + memset(&s->mmio[OPREGBASE], 0x00, MMIO_SIZE - OPREGBASE); + + s->usbcmd = NB_MAXINTRATE << USBCMD_ITC_SH; + s->usbsts = USBSTS_HALT; + + s->astate = EST_INACTIVE; + s->pstate = EST_INACTIVE; + s->async_port_in_progress = -1; + s->async_complete = 0; + s->isoch_pause = -1; + s->attach_poll_counter = 0; + + for(i = 0; i < NB_PORTS; i++) { + s->portsc[i] = PORTSC_POWNER | PORTSC_PPOWER; + + if (s->ports[i].dev) + ehci_attach(&s->ports[i], s->ports[i].dev); + } +} + +static uint32_t ehci_mem_readb(void *ptr, target_phys_addr_t addr) +{ + EHCIState *s = ptr; + uint32_t val; + + addr -= s->mem_base; + val = s->mmio[addr]; + + DEBUG(("mem_readb : addr=0x%08X, val=%02X\n",(int)addr,(int)val)); + + return val; +} + +static uint32_t ehci_mem_readw(void *ptr, target_phys_addr_t addr) +{ + EHCIState *s = ptr; + uint32_t val; + + addr -= s->mem_base; + val = s->mmio[addr] |(s->mmio[addr+1] << 8); + + DEBUG(("mem_readw : addr=0x%08X, val=0x%04X\n",(int)addr,(int)val)); + + return val; +} + +static uint32_t ehci_mem_readl(void *ptr, target_phys_addr_t addr) +{ + EHCIState *s = ptr; + uint32_t val; + + addr -= s->mem_base; + + val = s->mmio[addr] |(s->mmio[addr+1] << 8) | + (s->mmio[addr+2] << 16) |(s->mmio[addr+3] << 24); + + DEBUG(("mem_readl : addr=0x%08X, val=0x%08X\n",(unsigned) addr, val)); + + return val; +} + +static void ehci_mem_writeb(void *ptr, target_phys_addr_t addr, uint32_t val) +{ + printf("EHCI doesn't handle byte writes to MMIO\n"); + exit(1); +} + +static void ehci_mem_writew(void *ptr, target_phys_addr_t addr, uint32_t val) +{ + printf("EHCI doesn't handle 16-bit writes to MMIO\n"); + exit(1); +} + +static void handle_port_status_write(EHCIState *s, int port, uint32_t val) +{ + uint32_t *portsc = &s->portsc[port]; + int rwc; + USBDevice *dev = s->ports[port].dev; + + DEBUG(("PORTSC %08X->%08X rwc=%08X rw=%08X\n", *portsc, val, + (val & PORTSC_RWC_MASK), + val & PORTSC_RO_MASK)); + + rwc = val & PORTSC_RWC_MASK; + val &= PORTSC_RO_MASK; + + // handle_read_write_clear(&val, portsc, PORTSC_PEDC | PORTSC_CSC); + + *portsc &= ~rwc; + + DEBUG(("PORTSC -> %08X\n", *portsc)); + + if ((val & PORTSC_PRESET) && !(*portsc & PORTSC_PRESET)) { + DEBUG(("USBTRAN Port %d reset begin\n", port)); + } + + if (!(val & PORTSC_PRESET) &&(*portsc & PORTSC_PRESET)) { + DEBUG(("USBTRAN Port %d reset done\n", port)); + ehci_attach(&s->ports[port], dev); + + // TODO how to handle reset of ports with no device + if (dev) + usb_send_msg(dev, USB_MSG_RESET); + + if (s->ports[port].dev) { + DEBUG(("Device was connected before reset, clearing CSC bit\n")); + *portsc &= ~PORTSC_CSC; + } + + /* Table 2.16 Set the enable bit(and enable bit change) to indicate + * to SW that this port has a high speed device attached + * + * TODO - when to disable? + */ + val |= PORTSC_PED; + val |= PORTSC_PEDC; + } + + *portsc &= ~PORTSC_RO_MASK; + *portsc |= val; + DEBUG(("Port status set to 0x%08x\n", *portsc)); +} + +static void ehci_mem_writel(void *ptr, target_phys_addr_t addr, uint32_t val) +{ + EHCIState *s = ptr; + int i; + + addr -= s->mem_base; + + /* Only aligned reads are allowed on OHCI */ + if (addr & 3) { + printf("usb-ehci: Mis-aligned write\n"); + return; + } + + if (addr >= PORTSC && addr < PORTSC + 4 * NB_PORTS) { + DEBUG(("mem_writel : PORTSC%d->0x%08X \n",(int)(addr-PORTSC)/4, val)); + handle_port_status_write(s,(addr-PORTSC)/4, val); + return; + } + + /* Do any register specific pre-write processing here. */ + + switch(addr) + { + case USBCMD: + if ((val & USBCMD_RUNSTOP) && !(s->usbcmd & USBCMD_RUNSTOP)) { + DEBUG(("mem_writel : USBCMD run, clear halt\n")); + // printf("Call mod_timer for %p\n", s->frame_timer); + qemu_mod_timer(s->frame_timer, qemu_get_clock(vm_clock)); + s->last_run_usec = qemu_get_clock(vm_clock) / 1000; + s->usbsts &= ~USBSTS_HALT; + } + + if (!(val & USBCMD_RUNSTOP) &&(s->usbcmd & USBCMD_RUNSTOP)) { + DEBUG(("mem_writel : USBCMD ** STOP **\n")); + // printf("Call del_timer for %p\n", s->frame_timer); +#if 0 + qemu_del_timer(s->frame_timer); +#endif + // TODO - should finish out some stuff before setting halt + s->usbsts |= USBSTS_HALT; + } + + if (val & USBCMD_HCRESET) { + DEBUG(("mem_writel : USBCMD resetting ...\n")); + ehci_reset(s); + DEBUG(("mem_writel : USBCMD reset done, clear reset request bit\n")); + val &= ~USBCMD_HCRESET; + } + + break; + + case USBSTS: + val &= USBSTS_RO_MASK; // bits 6 thru 31 are RO + DEBUG(("mem_writel : USBSTS RWC set to 0x%08X\n", val)); + + val =(s->usbsts &= ~val); // bits 0 thru 5 are R/WC + DEBUG(("mem_writel : USBSTS updating interrupt condition\n")); + ehci_set_interrupt(s, 0); + + break; + + case USBINTR: + val &= USBINTR_MASK; + // DEBUG(("mem_writel : USBINTR set to 0x%08X\n", val)); + break; + + case FRINDEX: + s->sofv = val >> 3; + break; + + case CONFIGFLAG: + val &= 0x1; + + if (val) { + for(i = 0; i < NB_PORTS; i++) + s->portsc[i] &= ~PORTSC_POWNER; + } + + break; + } + + if (addr != 0x28) { + DEBUG(("mem_writel : addr=0x%08X, val=0x%08X\n",(unsigned) addr, val)); + } + + *(uint32_t *)(&s->mmio[addr]) = val; +} + + +// TODO : Put in common header file, duplication from usb-ohci.c + +/* Get an array of dwords from main memory */ +static inline int get_dwords(uint32_t addr, uint32_t *buf, int num) +{ + int i; + + for(i = 0; i < num; i++, buf++, addr += sizeof(*buf)) { + cpu_physical_memory_rw(addr,(uint8_t *)buf, sizeof(*buf), 0); + *buf = le32_to_cpu(*buf); + } + + return 1; +} + +/* Put an array of dwords in to main memory */ +static inline int put_dwords(uint32_t addr, uint32_t *buf, int num) +{ + int i; + + for(i = 0; i < num; i++, buf++, addr += sizeof(*buf)) { + uint32_t tmp = cpu_to_le32(*buf); + cpu_physical_memory_rw(addr,(uint8_t *)&tmp, sizeof(tmp), 1); + } + + return 1; +} + +// 4.10.2 + +static void ehci_qh_do_overlay(EHCIState *ehci, EHCIqh *qh, EHCIqtd *qtd) +{ + int i; + int dtoggle; + int ping; + + // remember values in fields to preserve in qh after overlay + + dtoggle = qh->token & QTD_TOKEN_DTOGGLE; + ping = qh->token & QTD_TOKEN_PING; + + DEBUG(("setting qh.current from %08X to 0x%08X\n", qh->current, + ehci->qtdaddr)); + qh->current = ehci->qtdaddr; + qh->qtdnext = qtd->next; + qh->altnext = qtd->altnext; + qh->token = qtd->token; + + if (qh->current < 0x1000) { +#ifdef DEBUG_PACKET + dump_qh(qh, qh->current); +#endif + ASSERT(1==2); + } + + if (((qh->epchar & QH_EPCHAR_EPS_MASK) >> QH_EPCHAR_EPS_SH) == 2) { + qh->token &= ~QTD_TOKEN_PING; + qh->token |= ping; + } + + for(i = 0; i < 6; i++) + qh->bufptr[i] = qtd->bufptr[i]; + + if (!(qh->epchar & QH_EPCHAR_DTC)) { + // preserve QH DT bit + qh->token &= ~QTD_TOKEN_DTOGGLE; + qh->token |= dtoggle; + } + + qh->bufptr[1] &= ~BUFPTR_CPROGMASK_MASK; + qh->bufptr[2] &= ~BUFPTR_FRAMETAG_MASK; + + // TODO NakCnt +} + +static void ehci_buffer_rw(EHCIState *ehci, EHCIqh *qh, int bytes, int rw) +{ + int bufpos = 0; + int cpage; + uint32_t head; + uint32_t tail; + + cpage = get_field(qh->token, QTD_TOKEN_CPAGE_MASK, QTD_TOKEN_CPAGE_SH); + ASSERT(cpage == 0); + + DEBUG(("exec: %sing %d bytes to/from %08x\n", + rw ? "writ" : "read", bytes, qh->bufptr[0])); + + if (!bytes) + return; + + do { + head = qh->bufptr[cpage]; + tail =(qh->bufptr[cpage] & 0xfffff000) + 0x1000; + + if (bytes <=(tail - head)) + tail = head + bytes; + + DEBUG(("DATA %s cpage:%d head:%08X tail:%08X target:%08X\n", + rw ? "WRITE" : "READ ", cpage, head, tail, bufpos)); + + ASSERT(bufpos + tail - head <= BUFF_SIZE); + ASSERT(tail - head > 0); + + cpu_physical_memory_rw(qh->bufptr[cpage], &ehci->buffer[bufpos], + tail - head, rw); + + bufpos +=(tail - head); + bytes -=(tail - head); + + qh->bufptr[cpage] +=(tail - head); + + if (bytes > 0) + cpage++; + } while (bytes > 0); + + set_field(&qh->token, cpage, QTD_TOKEN_CPAGE_MASK, QTD_TOKEN_CPAGE_SH); +} + +static int transactid; + +static void ehci_async_complete_packet(USBPacket *packet, void *opaque) +{ + EHCIState *ehci = opaque; +#ifdef DEBUG_PACKET + dprintf("Async packet complete\n"); +#endif + ehci->async_complete = 1; + ehci->exec_status = packet->len; +} + +static int ehci_execute_complete(EHCIState *ehci, + EHCIqh *qh, + int ret) +{ + if (ret == USB_RET_ASYNC && !ehci->async_complete) { + DEBUG(("not done yet\n")); + return ret; + } + + ehci->async_complete = 0; + ehci->async_port_in_progress = -1; + + if (ret < 0) { + switch(ret) { + case USB_RET_NODEV: + printf("USB no device\n"); + break; + case USB_RET_STALL: + printf("USB stall\n"); + qh->token |= QTD_TOKEN_HALT; + break; + case USB_RET_NAK: + DEBUG(("USBTRAN RSP NAK, returning without clear active\n")); + return USB_RET_NAK; + break; + case USB_RET_BABBLE: + printf("USB babble TODO\n"); + ASSERT(ret >= 0); + break; + default: + printf("USB invalid response %d to handle\n", + ret); + ASSERT(ret >= 0); + break; + } + } else { + // if (ret < maxpkt) + // { + // DEBUG(("Short packet condition\n")); + // // TODO check 4.12 for splits + // } + + if (ehci->tbytes && ehci->pid == USB_TOKEN_IN) { + ASSERT(ret > 0); + ehci_buffer_rw(ehci, qh, ret, 1); +#ifdef TDEBUG + printf("Data after execution:\n"); + // dump_data(ehci->buffer, ehci->tbytes < 64 ? ehci->tbytes : 64); + // decode_data(ehci->pid, ehci->buffer, ret); +#endif + ehci->tbytes -= ret; + } else + ehci->tbytes = 0; + + ASSERT(ehci->tbytes >= 0); + + set_field(&qh->token, ehci->tbytes, + QTD_TOKEN_TBYTES_MASK, QTD_TOKEN_TBYTES_SH); + } + + qh->token ^= QTD_TOKEN_DTOGGLE; + qh->token &= ~QTD_TOKEN_ACTIVE; + + if (qh->token & QTD_TOKEN_IOC) { + // TODO should do this after writeback to memory + ehci_set_interrupt(ehci, USBSTS_INT); + } +#ifdef DEBUG_PACKET + DEBUG(("QH after execute:-\n")); + dump_qh(qh, NLPTR_GET(ehci->qhaddr)); +#endif + +#ifdef TDEBUG + printf("USBTRAN RSP %3d return:(%5d) ", + transactid, + ret); + + if (ehci->pid == USB_TOKEN_IN) { + printf("[%02X %02X %02X %02X ...]\n", + *ehci->buffer, *(ehci->buffer+1), + *(ehci->buffer+2), *(ehci->buffer+3)); + } + else + printf("\n"); +#endif + return ret; +} + +// 4.10.3 + +static int ehci_execute(EHCIState *ehci, + uint32_t qhaddr, + EHCIqh *qh) +{ + USBPort *port; + USBDevice *dev; + int smask; + int maxpkt; + int ret; + int i; + int endp; + int devadr; + + smask = QH_EPCAP_SMASK_MASK & qh->epcap; + ehci->tbytes =(qh->token & QTD_TOKEN_TBYTES_MASK) >> QTD_TOKEN_TBYTES_SH; + ehci->pid =(qh->token & QTD_TOKEN_PID_MASK) >> QTD_TOKEN_PID_SH; + maxpkt = get_field(qh->epchar, QH_EPCHAR_MPLEN_MASK, QH_EPCHAR_MPLEN_SH); + endp = get_field(qh->epchar, QH_EPCHAR_EP_MASK, QH_EPCHAR_EP_SH); + devadr = get_field(qh->epchar, QH_EPCHAR_DEVADDR_MASK, 0); + + if ( !(qh->token & QTD_TOKEN_ACTIVE)) { + printf("Attempting to execute inactive QH\n"); + exit(1);; + } + + if (smask) { + DEBUG(("active interrupt transfer frindex %d for dev %d EP %d\n", + ehci->frindex, devadr, endp)); + // TODO are interrupt always IN ? + ehci->pid = USB_TOKEN_IN; + } else { + DEBUG(("Active non-interrupt QH, executing\n")); + + DEBUG(("pid is %2X\n", ehci->pid)); + + switch(ehci->pid) { + case 0: ehci->pid = USB_TOKEN_OUT; break; + case 1: ehci->pid = USB_TOKEN_IN; break; + case 2: ehci->pid = USB_TOKEN_SETUP; break; + default: printf("bad token\n"); break; + } + } + + // TODO set reclam + +#ifdef DEBUG_PACKET + DEBUG(("QH before execute:-\n")); + dump_qh(qh, NLPTR_GET(qhaddr)); +#endif + + if (ehci->tbytes && ehci->pid != USB_TOKEN_IN) { + ehci_buffer_rw(ehci, qh, ehci->tbytes, 0); +#ifdef TDEBUG + printf("Data before execution:\n"); + // dump_data(ehci->buffer, ehci->tbytes < 64 ? ehci->tbytes : 64); + // decode_data(ehci->pid, ehci->buffer, ehci->tbytes); +#endif + } + +#ifdef TDEBUG + printf("\nUSBTRAN REQ %3d dev:%d ep:%d pid:%02X %s bytes:(%5d) ", + ++transactid, + devadr, + endp, + ehci->pid, + (ehci->pid == USB_TOKEN_SETUP ? "(SETUP)" : + (ehci->pid == USB_TOKEN_IN ? "(IN) " : + (ehci->pid == USB_TOKEN_OUT ? "(OUT) " : "(*****)"))), + ehci->tbytes); + + if (ehci->pid != USB_TOKEN_IN) { + printf("[%02X %02X %02X %02X ...]\n", + *ehci->buffer, *(ehci->buffer+1), + *(ehci->buffer+2), *(ehci->buffer+3)); + } + else + printf("\n"); +#endif + + ret = USB_RET_NODEV; + + for(i = 0; i < NB_PORTS; i++) { + port = &ehci->ports[i]; + dev = port->dev; + + // TODO sometime we will also need to check if we are the port owner + + if (!(ehci->portsc[i] &(PORTSC_CONNECT))) { + DEBUG(("Port %d, no exec, not connected(%08X)\n", + i, ehci->portsc[i])); + continue; + } + + ehci->usb_packet.pid = ehci->pid; + ehci->usb_packet.devaddr = devadr; + ehci->usb_packet.devep = endp; + ehci->usb_packet.data = ehci->buffer; + ehci->usb_packet.len = ehci->tbytes; + ehci->usb_packet.complete_cb = ehci_async_complete_packet; + ehci->usb_packet.complete_opaque = ehci; + + DEBUG(("calling dev->info->handle_packet\n")); + ret = dev->info->handle_packet(dev, &ehci->usb_packet); + + if (ret != USB_RET_NODEV) + break; + } + + DEBUG(("exit loop dev->info->handle_packet\n")); + + if (ret > BUFF_SIZE || ehci->tbytes > BUFF_SIZE) { + printf("bogus QH byte count\n"); + dump_qh(qh, NLPTR_GET(qhaddr)); + ASSERT(ret <= BUFF_SIZE && ehci->tbytes <= BUFF_SIZE); + } + + if (ret == USB_RET_ASYNC) { + ehci->async_port_in_progress = i; + ehci->async_complete = 0; + } + + return ret; +} + +/* 4.7.2 + */ + +static void ehci_process_itd(EHCIState *ehci, + EHCIitd *itd) +{ + USBPort *port; + USBDevice *dev; + int ret; + int i, j; + int ptr; + int pid; + int pg; + int len; + int dir; + int devadr; + int endp; + int maxpkt; + + dir =(itd->bufptr[1] & ITD_BUFPTR_DIRECTION); + devadr = get_field(itd->bufptr[0], + ITD_BUFPTR_DEVADDR_MASK, 0); + endp = get_field(itd->bufptr[0], + ITD_BUFPTR_EP_MASK, ITD_BUFPTR_EP_SH); + maxpkt = get_field(itd->bufptr[1], ITD_BUFPTR_MAXPKT_MASK, 0); + +#ifdef EHCI_NOMICROFRAMES + for(i = 0; i < 8; i++) { +#else + i =(ehci->frindex & 7); +#endif + + if (itd->transact[i] & ITD_XACT_ACTIVE) { + DEBUG(("ISOCHRONOUS active for frame %d, interval %d\n", + ehci->frindex >> 3, i)); + + pg = get_field(itd->transact[i], ITD_XACT_PGSEL_MASK, + ITD_XACT_PGSEL_SH); + ptr =(itd->bufptr[pg] & ITD_BUFPTR_MASK) | + (itd->transact[i] & ITD_XACT_OFFSET_MASK); + len = get_field(itd->transact[i], ITD_XACT_LENGTH_MASK, + ITD_XACT_LENGTH_SH); + + ASSERT(len <= BUFF_SIZE); + + DEBUG(("ISOCH: buffer %08X len %d\n", ptr, len)); + + if (!dir) { + cpu_physical_memory_rw(ptr, &ehci->buffer[0], len, 0); + pid = USB_TOKEN_OUT; + } else + pid = USB_TOKEN_IN; + + ret = USB_RET_NODEV; + + for(j = 0; j < NB_PORTS; j++) { + port = &ehci->ports[j]; + dev = port->dev; + + // TODO sometime we will also need to check if we are the port owner + + if (!(ehci->portsc[j] &(PORTSC_CONNECT))) { + DEBUG(("Port %d, no exec, not connected(%08X)\n", + j, ehci->portsc[j])); + continue; + } + + ehci->usb_packet.pid = ehci->pid; + ehci->usb_packet.devaddr = devadr; + ehci->usb_packet.devep = endp; + ehci->usb_packet.data = ehci->buffer; + ehci->usb_packet.len = len; + ehci->usb_packet.complete_cb = ehci_async_complete_packet; + ehci->usb_packet.complete_opaque = ehci; + + DEBUG(("calling dev->info->handle_packet\n")); + ret = dev->info->handle_packet(dev, &ehci->usb_packet); + + if (ret != USB_RET_NODEV) + break; + } + + /* In isoch, there is no facility to indicate a NAK so let's + * instead just complete a zero-byte transaction. Setting + * DBERR seems too draconian. + */ + + if (ret == USB_RET_NAK) { + if (ehci->isoch_pause > 0) { + DEBUG(("ISOCH: received a NAK but paused so returning\n")); + ehci->isoch_pause--; + return; + } else if (ehci->isoch_pause == -1) { + DEBUG(("ISOCH: recv NAK & isoch pause inactive, setting\n")); + // Pause frindex for up to 50 msec waiting for data from + // remote + ehci->isoch_pause = 50; + return; + } else { + DEBUG(("ISOCH: isoch pause timeout! return 0\n")); + ret = 0; + } + } else { + DEBUG(("ISOCH: received ACK, clearing pause\n")); + ehci->isoch_pause = -1; + } + + if (ret >= 0) { + itd->transact[i] &= ~ITD_XACT_ACTIVE; + + if (itd->transact[i] & ITD_XACT_IOC) { + // TODO should do this after writeback to memory + ehci_set_interrupt(ehci, USBSTS_INT); + } + } + + if (ret >= 0 && dir) { + cpu_physical_memory_rw(ptr, &ehci->buffer[0], len, 1); + + if (ret != len) { + DEBUG(("ISOCH IN expected %d, got %d\n", + len, ret)); + set_field(&itd->transact[i], + ret, + ITD_XACT_LENGTH_MASK, + ITD_XACT_LENGTH_SH); + } + } + } + +#ifdef EHCI_NOMICROFRAMES + } +#endif +} + +/* This is the state machine that is common to both async and periodic */ + +static int ehci_advance_state(EHCIState *ehci, + int async, + int state, + uint32_t entry) +{ + EHCIqh *qh = &ehci->qh; + EHCIqtd *qtd = &ehci->qtd; + EHCIitd itd; + int again = 0; + int loopcount = 0; + int transactCtr; + int smask; + int reload; + int nakcnt; + + do { + DEBUG(("advance_state: again=%d\n", again)); + again = 0; + // ASSERT(loopcount++ < MAX_ITERATIONS); + + switch(state) { + /* This state is the entry point for asynchronous schedule + * processing. Entry here consitutes a EHCI start event state(4.8.5) + */ + case EST_WAITLISTHEAD: + DEBUG(("WAITLISTHEAD\n")); + + if (async) + ehci->usbsts |= USBSTS_REC; + + /* Find the head of the list + */ + + for(loopcount = 0; loopcount < MAX_QH; loopcount++) { + get_dwords(NLPTR_GET(entry),(uint32_t *) qh, + sizeof(EHCIqh) >> 2); + + if (qh->epchar & QH_EPCHAR_H) { + DEBUG(("QH %08X is the HEAD of the list\n", entry)); + break; + } + + DEBUG(("QH %08X is NOT the HEAD of the list\n", entry)); + entry = qh->next; + } + + entry |=(NLPTR_TYPE_QH << 1); + ASSERT(loopcount < MAX_QH); + loopcount = 0; + + state = EST_FETCHENTRY; + again = 1; + break; + + /* This state is the entry point for periodic schedule + * processing as well as being a continuation state for async + * processing. + */ + case EST_FETCHENTRY: + DEBUG(("FETCHENTRY\n")); + + if (qemu_get_clock(vm_clock) / 1000 > ehci->frame_end_usec) { + if (async) { + DEBUG(("FRAME timer elapsed, exit state machine\n")); + state = EST_ACTIVE; + break; + } else + DEBUG(("WARNING - frame timer elapsed during periodic\n")); + } + + if (NLPTR_TBIT(entry)) { + state = EST_ACTIVE; + break; + } + + if (NLPTR_TYPE_GET(entry) == NLPTR_TYPE_QH) { + state = EST_FETCHQH; + ehci->qhaddr = entry; + again = 1; + break; + } + + if (NLPTR_TYPE_GET(entry) == NLPTR_TYPE_ITD) { + state = EST_FETCHITD; + ehci->itdaddr = entry; + again = 1; + break; + } + + // TODO handle types other than QH + ASSERT(NLPTR_TYPE_GET(entry) == NLPTR_TYPE_QH); + break; + + case EST_FETCHQH: + get_dwords(NLPTR_GET(ehci->qhaddr),(uint32_t *) qh, sizeof(EHCIqh) >> 2); + DEBUG(("FETCHQH: Fetched QH at address %08X " + "(next is %08X, h-bit is %d)\n", + ehci->qhaddr, qh->next, qh->epchar & QH_EPCHAR_H)); + +#ifdef DEBUG_PACKET + dump_qh(qh, NLPTR_GET(ehci->qhaddr)); +#endif + + if (async) { + /* EHCI spec version 1.0 Section 4.8.3 + */ + if (qh->epchar & QH_EPCHAR_H) { + DEBUG(("h-bit set\n")); + + if (!(ehci->usbsts & USBSTS_REC)) { + DEBUG(("h-bit and !reclam, done\n")); + state = EST_ACTIVE; + break; + } + } + /* EHCI spec version 1.0 Section 4.10.1 + */ + if ( !(qh->epcap & QH_EPCAP_SMASK_MASK)) { + DEBUG(("not intr, clear reclam\n")); + ehci->usbsts &= ~USBSTS_REC; + } + } else { + DEBUG(("exec: qh check, frindex is %d,%d\n", + (ehci->frindex >> 3),(ehci->frindex & 7))); + } + + reload = get_field(qh->epchar, QH_EPCHAR_RL_MASK, QH_EPCHAR_RL_SH); + + if (reload) { + DEBUG(("reloading nakcnt to %d\n", + reload)); + set_field(&qh->altnext, reload, QH_ALTNEXT_NAKCNT_MASK, + QH_ALTNEXT_NAKCNT_SH); + } + + if (qh->token & QTD_TOKEN_ACTIVE) { + if ((qh->token & QTD_TOKEN_HALT)) { + printf("Active, Halt, ** ILLEGAL **\n"); + state = EST_ACTIVE; + } else { + DEBUG(("Active, !Halt, execute - fetchqtd\n")); + ehci->qtdaddr = qh->current; + state = EST_FETCHQTD; + again = 1; + } + } else { + if (qh->token & QTD_TOKEN_HALT) { + DEBUG(("!Active, Halt, go horiz\n")); + state = EST_HORIZONTALQH; + again = 1; + } else { + /* EHCI spec version 1.0 Section 4.10.2 + */ + DEBUG(("!Active, !Halt, adv q\n")); + state = EST_ADVANCEQUEUE; + again = 1; + } + } + + break; + + case EST_FETCHITD: + get_dwords(NLPTR_GET(ehci->itdaddr),(uint32_t *) &itd, + sizeof(EHCIitd) >> 2); + DEBUG(("FETCHITD: Fetched ITD at address %08X " + "(next is %08X)\n", + ehci->itdaddr, itd.next)); + +#ifdef DEBUG_PACKET + dump_itd(&itd, NLPTR_GET(ehci->itdaddr)); +#endif + + ehci_process_itd(ehci, &itd); +#ifdef DEBUG_PACKET + dump_itd(&itd, NLPTR_GET(ehci->itdaddr)); +#endif + put_dwords(NLPTR_GET(ehci->itdaddr),(uint32_t *) &itd, + sizeof(EHCIitd) >> 2); + entry = itd.next; + state = EST_FETCHENTRY; + again = 1; + break; + + case EST_ADVANCEQUEUE: + DEBUG(("ADVANCEQUEUE\n")); + if ((qh->token & QTD_TOKEN_TBYTES_MASK) != 0 && + NLPTR_TBIT(qh->altnext) == 0) { + ehci->qtdaddr = qh->altnext; + DEBUG(("tbytes!=0 and tbit = 0, go with altnext\n")); + } else { + if (NLPTR_TBIT(qh->qtdnext)) { + state = EST_HORIZONTALQH; + again = 1; + break; + } + + ehci->qtdaddr = qh->qtdnext; + } + state = EST_FETCHQTD; + again = 1; + break; + + case EST_FETCHQTD: + DEBUG(("FETCHQTD: Fetching QTD at address %08X\n", ehci->qtdaddr)); + get_dwords(NLPTR_GET(ehci->qtdaddr),(uint32_t *) qtd, + sizeof(EHCIqtd) >> 2); + + if (qtd->token & QTD_TOKEN_ACTIVE) { + state = EST_EXECUTE; + again = 1; + break; + } else { + DEBUG(("abort advance, not active\n")); + state = EST_HORIZONTALQH; + again = 1; + break; + } + + break; + + case EST_HORIZONTALQH: + entry = qh->next; + state = EST_FETCHENTRY; + again = 1; + break; + + case EST_EXECUTE: + if (async) { + DEBUG(("\n\n>>>>> ASYNC STATE MACHINE execute\n")); + } else { + DEBUG(("\n\n>>>>> PERIODIC STATE MACHINE execute\n")); + } + +#ifdef DEBUG_PACKET + dump_qh(qh, NLPTR_GET(ehci->qhaddr)); + dump_qtd(qtd, NLPTR_GET(ehci->qtdaddr)); +#endif + + smask = QH_EPCAP_SMASK_MASK & qh->epcap; + +#ifndef EHCI_NOMICROFRAMES + if (smask &&(smask &(1 <<(ehci->frindex & 7))) == 0) { + DEBUG(("PERIODIC active not interval: " + "mask is %d, " + "frindex is %d,%d\n", + smask, + (ehci->frindex >> 3),(ehci->frindex & 7))); + + state = EST_HORIZONTALQH; + again = 1; + break; + } +#endif + + if (smask) { + DEBUG(("PERIODIC active !!! " + "mask is %d, " + "frindex is %d,%d\n", + smask, + (ehci->frindex >> 3),(ehci->frindex & 7))); + } + + reload = get_field(qh->epchar, QH_EPCHAR_RL_MASK, QH_EPCHAR_RL_SH); + nakcnt = get_field(qh->altnext, QH_ALTNEXT_NAKCNT_MASK, QH_ALTNEXT_NAKCNT_SH); + if (reload && !nakcnt) { + DEBUG(("RL != 0 but NakCnt == 0, no execute\n")); + state = EST_HORIZONTALQH; + again = 1; + break; + } + + transactCtr = get_field(qh->epcap, + QH_EPCAP_MULT_MASK, QH_EPCAP_MULT_SH); + + // TODO verify enough time remains in the uframe as in 4.4.1.1 + + // TODO write back ptr to async list when done or out of time + + // TODO Windows does not seem to ever set the MULT field + +#if 0 + if (!transactCtr &&(qh->epcap & QH_EPCAP_SMASK_MASK) > 0) + { + DEBUG(("ZERO transactctr for int qh, go HORIZ\n")); + *state = EST_HORIZONTALQH; + again = 1; + break; + } +#endif + + if (!transactCtr) { + transactCtr = 1; // TODO - check at what level do we repeat + + if (qh->epcap & QH_EPCAP_SMASK_MASK) + DEBUG(("WARN - ZERO transactctr force to 1 for intr\n")); + } + + DEBUG(("exec: ctr is %d\n", transactCtr)); + DEBUG(("exec: frindex is %d,%d\n", + (ehci->frindex >> 3),(ehci->frindex & 7))); + + ehci_qh_do_overlay(ehci, qh, qtd); + ehci->exec_status = ehci_execute(ehci, ehci->qhaddr, qh); + state = EST_EXECUTING; + + if (ehci->exec_status != USB_RET_ASYNC) + again = 1; + + break; + + case EST_EXECUTING: + DEBUG(("Enter EXECUTING\n")); + ehci->exec_status = ehci_execute_complete(ehci, qh, + ehci->exec_status); + + if (ehci->exec_status == USB_RET_ASYNC) + break; + + DEBUG(("finishing exec\n")); + transactCtr = get_field(qh->epcap, + QH_EPCAP_MULT_MASK, QH_EPCAP_MULT_SH); + + if (transactCtr) + transactCtr--; + + set_field(&qh->epcap, transactCtr, + QH_EPCAP_MULT_MASK, QH_EPCAP_MULT_SH); + + reload = get_field(qh->epchar, QH_EPCHAR_RL_MASK, QH_EPCHAR_RL_SH); + nakcnt = get_field(qh->altnext, QH_ALTNEXT_NAKCNT_MASK, QH_ALTNEXT_NAKCNT_SH); + + if (reload != 0) { + if (ehci->exec_status == USB_RET_NAK) { + nakcnt--; + + DEBUG(("Nak occured and RL != 0, dec NakCnt to %d\n", + nakcnt)); + } else { + nakcnt = reload; + + DEBUG(("Nak didn't occur, reloading to %d\n", + nakcnt)); + } + + set_field(&qh->altnext, nakcnt, QH_ALTNEXT_NAKCNT_MASK, + QH_ALTNEXT_NAKCNT_SH); + } + + /* + * Write the qh back to guest physical memory. This step isn't + * in the EHCI spec but we need to do it since we don't share + * physical memory with our guest VM. + */ + + DEBUG(("write QH to VM memory\n")); +#ifdef DEBUG_PACKET + dump_qh(qh, NLPTR_GET(ehci->qhaddr)); +#endif + put_dwords(NLPTR_GET(ehci->qhaddr),(uint32_t *) qh, + sizeof(EHCIqh) >> 2); + + // 4.10.5 + + if (qh->token & QTD_TOKEN_ACTIVE) + state = EST_HORIZONTALQH; + else + state = EST_WRITEBACK; + + again = 1; + break; + + case EST_WRITEBACK: + /* Write back the QTD from the QH area */ + DEBUG(("write QTD to VM memory\n")); + put_dwords(NLPTR_GET(ehci->qtdaddr),(uint32_t *) &qh->qtdnext, + sizeof(EHCIqtd) >> 2); + /* TODO confirm next state. For now, keep going if async + * but stop after one qtd if periodic + */ + // if (async) + // { + state = EST_FETCHQH; + again = 1; + // } + // else + // state = EST_ACTIVE; + break; + + default: + printf("Bad state!\n"); + break; + } + } + while (again); + + return state; +} + +static void ehci_advance_async_state(EHCIState *ehci) +{ + switch(ehci->astate) { + case EST_INACTIVE: + if (ehci->usbcmd & USBCMD_ASE) { + DEBUG(("ASYNC going active\n")); + ehci->usbsts |= USBSTS_ASS; + ehci->astate = EST_ACTIVE; + // No break, fall through to ACTIVE + } else + break; + + case EST_ACTIVE: + if ( !(ehci->usbcmd & USBCMD_ASE)) { + DEBUG(("ASYNC going inactive\n")); + ehci->usbsts &= ~USBSTS_ASS; + ehci->astate = EST_INACTIVE; + break; + } + + DEBUG(("\n\n\n\n === === === === === ===\n\n\n\n")); + if (ehci->usbcmd & USBCMD_IAAD) { + /* Async advance doorbell interrupted requested + */ + ehci->usbcmd &= ~USBCMD_IAAD; + ehci_set_interrupt(ehci, USBSTS_IAA); + } + + ehci->astate = ehci_advance_state(ehci, 1, + EST_WAITLISTHEAD, + ehci->asynclistaddr); + break; + + case EST_EXECUTING: + DEBUG(("async state adv for executing\n")); + ehci->astate = ehci_advance_state(ehci, 1, + EST_EXECUTING, ehci->qhaddr); + break; + + default: + printf("Bad asynchronous state %d\n", + ehci->astate); + ASSERT(1==2); + } +} + +static void ehci_advance_periodic_state(EHCIState *ehci) +{ + uint32_t entry; + uint32_t list; + + // 4.6 + + switch(ehci->pstate) { + case EST_INACTIVE: + if ( !(ehci->frindex & 7) &&(ehci->usbcmd & USBCMD_PSE)) { + DEBUG(("PERIODIC going active\n")); + ehci->usbsts |= USBSTS_PSS; + ehci->pstate = EST_ACTIVE; + // No break, fall through to ACTIVE + } else + break; + + case EST_ACTIVE: + if ( !(ehci->frindex & 7) && !(ehci->usbcmd & USBCMD_PSE)) { + DEBUG(("PERIODIC going inactive\n")); + ehci->usbsts &= ~USBSTS_PSS; + ehci->pstate = EST_INACTIVE; + break; + } + + list = ehci->periodiclistbase & 0xfffff000; + list |=((ehci->frindex & 0x1ff8) >> 1); + + cpu_physical_memory_rw(list,(uint8_t *) &entry, sizeof entry, 0); + entry = le32_to_cpu(entry); + + DEBUG(("periodic state adv fr=%d. [%08X] -> %08X\n", + ehci->frindex / 8, list, entry)); + ehci->pstate = ehci_advance_state(ehci, 0, + EST_FETCHENTRY, entry); + break; + + case EST_EXECUTING: + DEBUG(("periodic state adv for executing\n")); + ehci->pstate = ehci_advance_state(ehci, 0, + EST_EXECUTING, ehci->qhaddr); + break; + + default: + printf("Bad periodic state %d\n", + ehci->pstate); + ASSERT(1==2); + } +} + +static void ehci_frame_timer(void *opaque) +{ + EHCIState *ehci = opaque; + int64_t expire_time; + int usec_elapsed; + int frames; + int usec_now; + int i; + int skipped_frames = 0; + + usec_now = qemu_get_clock(vm_clock) / 1000; + usec_elapsed = usec_now - ehci->last_run_usec; + ehci->frame_end_usec = usec_now + 1000; + +#ifdef EHCI_NOMICROFRAMES + frames = usec_elapsed / 1000; + ehci->frame_end_usec = usec_now + 1000; +#else + frames = usec_elapsed / 125; + ehci->frame_end_usec = usec_now + 125; +#endif + +#ifdef TDEBUG + DEBUG(("Frame timer, usec elapsed since last %d, frames %d\n", + usec_elapsed, frames)); +#endif + + for(i = 0; i < frames; i++) { + if ( !(ehci->usbsts & USBSTS_HALT)) { + if (ehci->isoch_pause <= 0) { +#ifdef EHCI_NOMICROFRAMES + ehci->frindex += 8; +#else + ehci->frindex++; +#endif + } + + if (ehci->frindex > 0x00001fff) { + ehci->frindex = 0; +#ifdef TDEBUG + DEBUG(("PERIODIC frindex rollover\n")); +#endif + ehci_set_interrupt(ehci, USBSTS_FLR); + } + + ehci->sofv =(ehci->frindex - 1) >> 3; + ehci->sofv &= 0x000003ff; + } + + if (frames - i > 10) + skipped_frames++; + else { + // TODO could this cause periodic frames to get skipped if async + // active? + if (ehci->astate != EST_EXECUTING) + ehci_advance_periodic_state(ehci); + } + +#ifdef EHCI_NOMICROFRAMES + ehci->last_run_usec += 1000; +#else + ehci->last_run_usec += 125; +#endif + } + + if (skipped_frames) + DEBUG(("WARNING - EHCI skipped %d frames\n", skipped_frames)); + + /* Async is not inside loop since it executes everything it can once + * called + */ + if (ehci->pstate != EST_EXECUTING) + ehci_advance_async_state(ehci); + + expire_time = qemu_get_clock(vm_clock) + + (get_ticks_per_sec() / FRAME_TIMER_FREQ); + + qemu_mod_timer(ehci->frame_timer, expire_time); + + usec_elapsed = qemu_get_clock(vm_clock) / 1000 - usec_now; + +#ifdef TDEBUG + DEBUG(("TIMING: frame_timer used %d usec\n", usec_elapsed)); +#endif +} + +static CPUReadMemoryFunc *ehci_readfn[3]={ + ehci_mem_readb, + ehci_mem_readw, + ehci_mem_readl +}; + +static CPUWriteMemoryFunc *ehci_writefn[3]={ + ehci_mem_writeb, + ehci_mem_writew, + ehci_mem_writel +}; + +static void ehci_map(PCIDevice *pci_dev, int region_num, + pcibus_t addr, pcibus_t size, int type) +{ + EHCIState *s =(EHCIState *)pci_dev; + + DEBUG(("ehci_map: region %d, addr %08X, size %d, s->mem %08X\n", + region_num, addr, size, s->mem)); + s->mem_base = addr; + cpu_register_physical_memory(addr, size, s->mem); +} + +static EHCIState *ehci_info; + +void usb_ehci_info(void) +{ + int i; + uint32_t val; + static uint32_t last[0x64 + NB_PORTS * 4]; + + for(i = 0; i <= 0x64 + NB_PORTS * 4; i+=4) { + val = *(uint32_t *) &(ehci_info->mmio[i]); + + printf("MMIO %08X : %08X [+/- %08X]\n", i, val, val ^ last[i/4]); + last[i/4] = val; + } +} + + +void usb_ehci_init(PCIBus *bus, int devfn) +{ + EHCIState *ehci; + uint8_t *pci_conf; + int i; + + ehci =(EHCIState *)pci_register_device(bus, + "USB-EHCI", sizeof(EHCIState), + devfn, NULL, NULL); + + pci_conf = ehci->dev.config; + pci_conf[0x00] = 0x86; + pci_conf[0x01] = 0x80; // Intel + pci_conf[0x02] = 0xCD; + pci_conf[0x03] = 0x24; // ICH4 / 82801D + pci_conf[0x08] = 0x10; // revision number + pci_conf[0x09] = 0x20; + pci_conf[0x0a] = 0x03; + pci_conf[0x0b] = 0x0c; + pci_conf[0x0e] = 0x00; // header_type 0 + pci_conf[0x34] = 0x00; // capabilities pointer + + // pci_conf[0x34] = 0x50; // capabilities pointer + + pci_conf[0x3d] = 4; // interrupt pin 3 + pci_conf[0x3e] = 0; // MaxLat + pci_conf[0x3f] = 0; // MinGnt + + // pci_conf[0x50] = 0x01; // power management caps + + pci_conf[0x60] = 0x20; // SBRN + pci_conf[0x61] = 0x20; // FLADJ + pci_conf[0x62] = 0x7f; + pci_conf[0x63] = 0x00; // PORTWAKECAP + pci_conf[0x64] = 0x00; + pci_conf[0x65] = 0x00; + pci_conf[0x66] = 0x00; + pci_conf[0x67] = 0x00; + pci_conf[0x68] = 0x01; + pci_conf[0x69] = 0x00; + pci_conf[0x6a] = 0x00; + pci_conf[0x6b] = 0x00; // USBLEGSUP + pci_conf[0x6c] = 0x00; + pci_conf[0x6d] = 0x00; + pci_conf[0x6e] = 0x00; + pci_conf[0x6f] = 0xc0; // USBLEFCTLSTS + + ehci->mmio[0x00] = OPREGBASE; + ehci->mmio[0x01] = 0x00; + ehci->mmio[0x02] = 0x00; + ehci->mmio[0x03] = 0x01; // HC version + ehci->mmio[0x04] = NB_PORTS; // Number of downstream ports + ehci->mmio[0x05] = 0x00; // No companion ports at present + ehci->mmio[0x06] = 0x00; + ehci->mmio[0x07] = 0x00; + ehci->mmio[0x08] = 0x80; // We can cache whole frame, not 64-bit capable + ehci->mmio[0x09] = 0x68; // EECP + ehci->mmio[0x0a] = 0x00; + ehci->mmio[0x0b] = 0x00; + + ehci->irq = ehci->dev.irq[0]; + + // TODO - port registration is going to need an overhaul since ports + // can be low, full or high speed and are not tied to UHCI or EHCI. + // This works for now since we register last so are top of the free + // list but really all ports need to be owned by EHCI and it should + // hand off to companion controllers if device is full or low speed. + + DEBUG(("ehci init : registering USB ports with no device attached\n")); + + // TODO come up with a better port allocation scheme + // added ehci->bus, need to find ehci->DeviceState + usb_bus_new(&ehci->bus, &s->dev.qdev); + for(i = NB_PORTS-1; i > 0; i--) { + usb_register_port(&ehci->bus, &ehci->ports[i], ehci, i, ehci_attach); + ehci->ports[i].dev = 0; + } + + ehci->frame_timer = qemu_new_timer(vm_clock, ehci_frame_timer, ehci); + DEBUG(("Alloc new timer for %p\n", ehci->frame_timer)); + + ehci->mem = cpu_register_io_memory(ehci_readfn, ehci_writefn, ehci); + + DEBUG(("ehci init : registering MMIO size %d\n", MMIO_SIZE)); + pci_register_bar(&ehci->dev, 0, MMIO_SIZE, PCI_BASE_ADDRESS_SPACE_MEMORY, + ehci_map); + + ehci_reset(ehci); + ehci_info = ehci; + + DEBUG(("*** ehci init : under development 16-OCT-08 *** \n\n")); +} + diff --git a/hw/usb-ehci.h b/hw/usb-ehci.h new file mode 100644 index 0000000..15d74d2 --- /dev/null +++ b/hw/usb-ehci.h @@ -0,0 +1,9 @@ +#ifndef QEMU_USB_EHCI_H +#define QEMU_USB_EHCI_H + +#include "qemu-common.h" + +void usb_ehci_info(Monitor *mon); +void usb_ehci_init(PCIBus *bus, int devfn); + +#endif diff --git a/monitor.c b/monitor.c index 19470d1..65b933f 100644 --- a/monitor.c +++ b/monitor.c @@ -25,6 +25,7 @@ #include "hw/hw.h" #include "hw/qdev.h" #include "hw/usb.h" +#include "hw/usb-ehci.h" #include "hw/pcmcia.h" #include "hw/pc.h" #include "hw/pci.h" @@ -2719,6 +2720,13 @@ static const mon_cmd_t info_cmds[] = { .mhandler.info = usb_host_info, }, { + .name = "usbehci", + .args_type = "", + .params = "", + .help = "show ehci status", + .mhandler.info = usb_ehci_info, + }, + { .name = "profile", .args_type = "", .params = "", From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NmxJo-0000fv-P3 for qemu-devel@nongnu.org; Wed, 03 Mar 2010 17:45:28 -0500 Received: from [199.232.76.173] (port=57364 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NmxJn-0000fn-CP for qemu-devel@nongnu.org; Wed, 03 Mar 2010 17:45:27 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NmxJf-000069-02 for qemu-devel@nongnu.org; Wed, 03 Mar 2010 17:45:27 -0500 Received: from sj-iport-4.cisco.com ([171.68.10.86]:61964) by monty-python.gnu.org with esmtps (TLS-1.0:RSA_ARCFOUR_SHA1:16) (Exim 4.60) (envelope-from ) id 1NmxJH-0008UD-3C for qemu-devel@nongnu.org; Wed, 03 Mar 2010 17:45:18 -0500 Message-ID: <4B8EE632.7090303@cisco.com> Date: Wed, 03 Mar 2010 15:44:02 -0700 From: "David S. Ahern" MIME-Version: 1.0 Subject: Re: [Qemu-devel] Re: EHCI support in QEMU References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> <4B8C2EFF.3030106@web.de> <4B8CED08.2030705@redhat.com> <1b51b6f81003030321g6a3eb47ak6a59267cae50b7f2@mail.gmail.com> In-Reply-To: <1b51b6f81003030321g6a3eb47ak6a59267cae50b7f2@mail.gmail.com> Content-Type: multipart/mixed; boundary="------------090505010901090803000005" List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Niels de Vos Cc: Taimoor Mirza , Kevin Wolf , Jan Kiszka , qemu-devel@nongnu.org This is a multi-part message in MIME format. --------------090505010901090803000005 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 03/03/2010 04:21 AM, Niels de Vos wrote: > On Tue, Mar 2, 2010 at 10:48 AM, Kevin Wolf wrote: >> Am 01.03.2010 22:17, schrieb Jan Kiszka: >>> Niels de Vos wrote: >>>> If someone is interested in this partially ported patch, I'm happy to >>>> share, but it will at least need some attention to make it compile. >>>> After that, lots of tests need to be done and probably quite some >>>> bugfixes are required. I'm happy to assist, but do not have a lot of >>>> time to spare on this hobby project. On the occasion that it is something >>>> more solid and starting to do something, I will of course inform this list >>>> again. >>> >>> OK, to keep this heavy ball rolling, I would suggest posting your patch. >>> Either it's already in a good shape to get it merged as experimental >>> feature. Or I will pick it up in git tree, collect patches as they fly >>> in, and will keep on pushing it upstream. I can't promise spending much >>> time on hacking, but integration work, basic testing, and some more or >>> less helpful comments should be feasible. >> >> Yes, please post it. I won't promise anything either, but maybe I can >> find some time to help a bit. Anyway, I'd love to see EHCI in qemu. > > Okay, here it is. Please note that the patch is very raw, does not > compile and even basic things like indention is broken at the moment. > Please refer to > http://lists.gnu.org/archive/html/qemu-devel/2008-10/msg01326.html for > the original author, nothing seriously of this patch is done by me. > > Kind regards and thanks for your help, > Niels FWIW: the attached compiles and qemu does not die (patch created against qemu-kvm.git but applies to qemu.git as well). For now I disabled uhci so that the device is attached to the ehci bus. I can attach a usb key, but lsusb in the guest (fedora core 12) does not show it. David --------------090505010901090803000005 Content-Type: text/plain; name="qemu-ehci-03032010.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="qemu-ehci-03032010.patch" ZGlmZiAtLWdpdCBhL01ha2VmaWxlLnRhcmdldCBiL01ha2VmaWxlLnRhcmdldAppbmRleCA4 MmNhZjIwLi42OTMyNTE1IDEwMDY0NAotLS0gYS9NYWtlZmlsZS50YXJnZXQKKysrIGIvTWFr ZWZpbGUudGFyZ2V0CkBAIC0yMjMsNyArMjIzLDcgQEAgb2JqLWkzODYteSArPSBwY2tiZC5v ICQoc291bmQtb2JqLXkpIGRtYS5vCiBvYmotaTM4Ni15ICs9IHZnYS5vIHZnYS1wY2kubyB2 Z2EtaXNhLm8KIG9iai1pMzg2LXkgKz0gZmRjLm8gbWMxNDY4MThydGMubyBzZXJpYWwubyBp ODI1OS5vIGk4MjU0Lm8gcGNzcGsubyBwYy5vCiBvYmotaTM4Ni15ICs9IGNpcnJ1c192Z2Eu byBhcGljLm8gaW9hcGljLm8gcGFyYWxsZWwubyBhY3BpLm8gcGlpeF9wY2kubwotb2JqLWkz ODYteSArPSB1c2ItdWhjaS5vIHZtbW91c2UubyB2bXBvcnQubyB2bXdhcmVfdmdhLm8gaHBl dC5vCitvYmotaTM4Ni15ICs9IHVzYi11aGNpLm8gdXNiLWVoY2kubyB2bW1vdXNlLm8gdm1w b3J0Lm8gdm13YXJlX3ZnYS5vIGhwZXQubwogb2JqLWkzODYteSArPSBkZXZpY2UtaG90cGx1 Zy5vIHBjaS1ob3RwbHVnLm8gc21iaW9zLm8gd2R0X2liNzAwLm8KIG9iai1pMzg2LXkgKz0g ZXh0Ym9vdC5vCiBvYmotaTM4Ni15ICs9IG5lMjAwMC1pc2EubyBkZWJ1Z2Nvbi5vIG11bHRp Ym9vdC5vCmRpZmYgLS1naXQgYS9ody9wYy5jIGIvaHcvcGMuYwppbmRleCAwYWViYWU5Li44 ZjVjMGRjIDEwMDY0NAotLS0gYS9ody9wYy5jCisrKyBiL2h3L3BjLmMKQEAgLTI4LDYgKzI4 LDcgQEAKICNpbmNsdWRlICJ2bXdhcmVfdmdhLmgiCiAjaW5jbHVkZSAidXNiLXVoY2kuaCIK ICNpbmNsdWRlICJ1c2Itb2hjaS5oIgorI2luY2x1ZGUgInVzYi1laGNpLmgiCiAjaW5jbHVk ZSAicHJlcF9wY2kuaCIKICNpbmNsdWRlICJhcGJfcGNpLmgiCiAjaW5jbHVkZSAiYmxvY2su aCIKQEAgLTEwMzksOCArMTA0NCwxNCBAQCBzdGF0aWMgdm9pZCBwY19pbml0MShyYW1fYWRk cl90IHJhbV9zaXplLAogCiAgICAgY21vc19pbml0KGJlbG93XzRnX21lbV9zaXplLCBhYm92 ZV80Z19tZW1fc2l6ZSwgYm9vdF9kZXZpY2UsIGhkKTsKIAorICAgIC8vICBUT0RPIHRoZSBw aWl4MyBkb2VzIG5vdCBoYXZlIEVIQ0kgLSBsb29rcyBsaWtlIElDSDQKKwkvLyAgd2FzIGZp cnN0IHNvdXRoYnJpZGdlIHRvIHN1cHBvcnQgaXQuCiAgICAgaWYgKHBjaV9lbmFibGVkICYm IHVzYl9lbmFibGVkKSB7Ci0gICAgICAgIHVzYl91aGNpX3BpaXgzX2luaXQocGNpX2J1cywg cGlpeDNfZGV2Zm4gKyAyKTsKKyNpZiAwCisgICAgICAgIHVzYl91aGNpX3BpaXgzX2luaXQo cGNpX2J1cywgcGlpeDNfZGV2Zm4gKyAzKTsKKyNlbHNlCisgICAgICAgIHVzYl9laGNpX2lu aXQocGNpX2J1cywgcGlpeDNfZGV2Zm4gKyAyKTsKKyNlbmRpZgogICAgIH0KIAogICAgIGlm IChwY2lfZW5hYmxlZCAmJiBhY3BpX2VuYWJsZWQpIHsKZGlmZiAtLWdpdCBhL2h3L3BjaV9p ZHMuaCBiL2h3L3BjaV9pZHMuaAppbmRleCBmZTdhMTIxLi5hMWJkZjUwIDEwMDY0NAotLS0g YS9ody9wY2lfaWRzLmgKKysrIGIvaHcvcGNpX2lkcy5oCkBAIC04OSw2ICs4OSw3IEBACiAj ZGVmaW5lIFBDSV9WRU5ET1JfSURfSU5URUwgICAgICAgICAgICAgIDB4ODA4NgogI2RlZmlu ZSBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyNDQxICAgICAgICAweDEyMzcKICNkZWZpbmUgUENJ X0RFVklDRV9JRF9JTlRFTF84MjgwMUFBXzUgICAgMHgyNDE1CisjZGVmaW5lIFBDSV9ERVZJ Q0VfSURfSU5URUxfODI4MDFEICAgICAgIDB4MjRDRAogI2RlZmluZSBQQ0lfREVWSUNFX0lE X0lOVEVMX0VTQl85ICAgICAgICAweDI1YWIKICNkZWZpbmUgUENJX0RFVklDRV9JRF9JTlRF TF84MjM3MVNCXzAgICAgMHg3MDAwCiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfSU5URUxfODIz NzFTQl8xICAgIDB4NzAxMApkaWZmIC0tZ2l0IGEvaHcvdXNiLWVoY2kuYyBiL2h3L3VzYi1l aGNpLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWE4ZWQ5ZQotLS0g L2Rldi9udWxsCisrKyBiL2h3L3VzYi1laGNpLmMKQEAgLTAsMCArMSwyMDgxIEBACisvKgor ICogUUVNVSBVU0IgRUhDSSBFbXVsYXRpb24KKyAqCisgKiBDb3B5cmlnaHQoYykgMjAwOCAg RW11dGV4IEx0ZC4gKGFkZHJlc3NAaGlkZGVuKQorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcihhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQor ICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3Rv biwgTUEgIDAyMTExLTEzMDcgIFVTQQorICoKKyAqIFRPRE86CisgKiAgbyBEb3duc3RyZWFt IHBvcnQgaGFuZG9mZgorICovCisKKyNpbmNsdWRlICJody5oIgorI2luY2x1ZGUgInFlbXUt dGltZXIuaCIKKyNpbmNsdWRlICJ1c2IuaCIKKyNpbmNsdWRlICJwY2kuaCIKKyNpbmNsdWRl ICJ1c2ItZWhjaS5oIgorI2luY2x1ZGUgIm1vbml0b3IuaCIKKworI2RlZmluZSBFSENJX0RF QlVHIDEKKyNpZiBFSENJX0RFQlVHCisvLyNkZWZpbmUgREVCVUcoeCkgdGltZWRfcHJpbnRm IHggCisjZGVmaW5lIERFQlVHKHgpIHByaW50ZiB4CisjZWxzZQorI2RlZmluZSBERUJVRyh4 KQorI2VuZGlmCisvL3N0YXRpYyBpbnQgdGltZWRfcHJpbnRmKGNvbnN0IGNoYXIgKmZtdCwg Li4uKTsKKworLy8gI2RlZmluZSBUREVCVUcKKy8vICNkZWZpbmUgREVCVUdfUEFDS0VUCisK KyNkZWZpbmUgQVNTRVJUKHgpIHsgaWYgKCEoeCkpIHsgcHJpbnRmKCJBc3NlcnRpb24gZmFp bGVkIGluIHVzYi1lY2hpLmMgbGluZSAlZFxuIiwgX19MSU5FX18pOyBleGl0KDEpOyB9IH0K KworI2RlZmluZSBNTUlPX1NJWkUgICAgICAgIDB4MTAwMAorCisjZGVmaW5lIENBUFJFR0JB U0UgICAgICAgMHgwMDAwICAgICAgICAvLyBDYXBhYmlsaXR5IFJlZ2lzdGVycyBCYXNlIEFk ZHJlc3MKKworI2RlZmluZSBDQVBMRU5HVEggICAgICAgIENBUFJFR0JBU0UgKyAweDAwMDAK KyNkZWZpbmUgSENJVkVSU0lPTiAgICAgICBDQVBSRUdCQVNFICsgMHgwMDAyCisjZGVmaW5l IEhDU1BBUkFNUyAgICAgICAgQ0FQUkVHQkFTRSArIDB4MDAwNAorI2RlZmluZSBIQ0NQQVJB TVMgICAgICAgIENBUFJFR0JBU0UgKyAweDAwMDgKKyNkZWZpbmUgRUVDUCAgICAgICAgICAg ICBIQ0NQQVJBTVMgKyAxCisjZGVmaW5lIEhDU1BQT1JUUk9VVEUxICAgQ0FQUkVHQkFTRSAr IDB4MDAwYworI2RlZmluZSBIQ1NQUE9SVFJPVVRFMiAgIENBUFJFR0JBU0UgKyAweDAwMTAK KworI2RlZmluZSBPUFJFR0JBU0UgICAgICAgIDB4MDAyMCAgICAgICAgLy8gT3BlcmF0aW9u YWwgUmVnaXN0ZXJzIEJhc2UgQWRkcmVzcworCisjZGVmaW5lIFVTQkNNRCAgICAgICAgICAg T1BSRUdCQVNFICsgMHgwMDAwCisjZGVmaW5lIFVTQkNNRF9SVU5TVE9QICAgKDEgPDwgMCkg ICAgICAvLyBydW4gLyBTdG9wCisjZGVmaW5lIFVTQkNNRF9IQ1JFU0VUICAgKDEgPDwgMSkg ICAgICAvLyBIQyBSZXNldAorI2RlZmluZSBVU0JDTURfRkxTICAgICAgICgzIDw8IDIpICAg ICAgLy8gRnJhbWUgTGlzdCBTaXplCisjZGVmaW5lIFVTQkNNRF9GTFNfU0ggICAgMiAgICAg ICAgICAgICAvLyBGcmFtZSBMaXN0IFNpemUgU2hpZnQKKyNkZWZpbmUgVVNCQ01EX1BTRSAg ICAgICAoMSA8PCA0KSAgICAgIC8vIFBlcmlvZGljIFNjaGVkdWxlIEVuYWJsZQorI2RlZmlu ZSBVU0JDTURfQVNFICAgICAgICgxIDw8IDUpICAgICAgLy8gQXN5bmNoIFNjaGVkdWxlIEVu YWJsZQorI2RlZmluZSBVU0JDTURfSUFBRCAgICAgICgxIDw8IDYpICAgICAgLy8gSW50IEFz eW5jaCBBZHZhbmNlIERvb3JiZWxsCisjZGVmaW5lIFVTQkNNRF9MSENSICAgICAgKDEgPDwg NykgICAgICAvLyBMaWdodCBIb3N0IENvbnRyb2xsZXIgUmVzZXQKKyNkZWZpbmUgVVNCQ01E X0FTUE1DICAgICAoMyA8PCA4KSAgICAgIC8vIEFzeW5jIFNjaGVkIFBhcmsgTW9kZSBDb3Vu dAorI2RlZmluZSBVU0JDTURfQVNQTUUgICAgICgxIDw8IDExKSAgICAgLy8gQXN5bmMgU2No ZWQgUGFyayBNb2RlIEVuYWJsZQorI2RlZmluZSBVU0JDTURfSVRDICAgICAgICgweDdmIDw8 IDE2KSAgLy8gSW50IFRocmVzaG9sZCBDb250cm9sCisjZGVmaW5lIFVTQkNNRF9JVENfU0gg ICAgMTYgICAgICAgICAgICAvLyBJbnQgVGhyZXNob2xkIENvbnRyb2wgU2hpZnQKKworI2Rl ZmluZSBVU0JTVFMgICAgICAgICAgIE9QUkVHQkFTRSArIDB4MDAwNAorI2RlZmluZSBVU0JT VFNfUk9fTUFTSyAgIDB4MDAwMDAwM2YKKyNkZWZpbmUgVVNCU1RTX0lOVCAgICAgICAoMSA8 PCAwKSAgICAgIC8vIFVTQiBJbnRlcnJ1cHQKKyNkZWZpbmUgVVNCU1RTX0VSUklOVCAgICAo MSA8PCAxKSAgICAgIC8vIEVycm9yIEludGVycnVwdAorI2RlZmluZSBVU0JTVFNfUENEICAg ICAgICgxIDw8IDIpICAgICAgLy8gUG9ydCBDaGFuZ2UgRGV0ZWN0CisjZGVmaW5lIFVTQlNU U19GTFIgICAgICAgKDEgPDwgMykgICAgICAvLyBGcmFtZSBMaXN0IFJvbGxvdmVyCisjZGVm aW5lIFVTQlNUU19IU0UgICAgICAgKDEgPDwgNCkgICAgICAvLyBIb3N0IFN5c3RlbSBFcnJv cgorI2RlZmluZSBVU0JTVFNfSUFBICAgICAgICgxIDw8IDUpICAgICAgLy8gSW50ZXJydXB0 IEFzeW5jIEFkdmFuY2UKKyNkZWZpbmUgVVNCU1RTX0hBTFQgICAgICAoMSA8PCAxMikgICAg IC8vIEhDIEhhbHRlZAorI2RlZmluZSBVU0JTVFNfUkVDICAgICAgICgxIDw8IDEzKSAgICAg Ly8gUmVjbGFtYXRpb24KKyNkZWZpbmUgVVNCU1RTX1BTUyAgICAgICAoMSA8PCAxNCkgICAg IC8vIFBlcmlvZGljIFNjaGVkdWxlIFN0YXR1cworI2RlZmluZSBVU0JTVFNfQVNTICAgICAg ICgxIDw8IDE1KSAgICAgLy8gQXN5bmNocm9ub3VzIFNjaGVkdWxlIFN0YXR1cworCisvKgor ICogIEludGVycnVwdCBlbmFibGUgYml0cyBjb3JyZXNwb25kIHRvIHRoZSBpbnRlcnJ1cHQg YWN0aXZlIGJpdHMgaW4gVVNCU1RTCisgKiAgc28gbm8gbmVlZCB0byByZWRlZmluZSBoZXJl LgorICovCisjZGVmaW5lIFVTQklOVFIgICAgICAgICAgICAgIE9QUkVHQkFTRSArIDB4MDAw OAorI2RlZmluZSBVU0JJTlRSX01BU0sgICAgICAgICAweDAwMDAwMDNmCisKKyNkZWZpbmUg RlJJTkRFWCAgICAgICAgICAgICAgT1BSRUdCQVNFICsgMHgwMDBjCisjZGVmaW5lIENUUkxE U1NFR01FTlQgICAgICAgIE9QUkVHQkFTRSArIDB4MDAxMAorI2RlZmluZSBQRVJJT0RJQ0xJ U1RCQVNFICAgICBPUFJFR0JBU0UgKyAweDAwMTQKKyNkZWZpbmUgQVNZTkNMSVNUQUREUiAg ICAgICAgT1BSRUdCQVNFICsgMHgwMDE4CisjZGVmaW5lIEFTWU5DTElTVEFERFJfTUFTSyAg IDB4ZmZmZmZmZTAKKworI2RlZmluZSBDT05GSUdGTEFHICAgICAgICAgICBPUFJFR0JBU0Ug KyAweDAwNDAKKworI2RlZmluZSBQT1JUU0MgICAgICAgICAgICAgICAoT1BSRUdCQVNFICsg MHgwMDQ0KQorI2RlZmluZSBQT1JUU0NfQkVHSU4gICAgICAgICBQT1JUU0MKKyNkZWZpbmUg UE9SVFNDX0VORCAgICAgICAgICAgKFBPUlRTQyArIDQgKiBOQl9QT1JUUykKKy8qCisgKiBC aXRzIHRoYXQgYXJlIHJlc2VydmVyZCBvciBhcmUgcmVhZC1vbmx5IGFyZSBtYXNrZWQgb3V0 IG9mIHZhbHVlcworICogd3JpdHRlbiB0byB1cyBieSBzb2Z0d2FyZQorICovCisjZGVmaW5l IFBPUlRTQ19ST19NQVNLICAgICAgIDB4MDA3MDIxYzUKKyNkZWZpbmUgUE9SVFNDX1JXQ19N QVNLICAgICAgMHgwMDAwMDAyYQorI2RlZmluZSBQT1JUU0NfV0tPQ19FICAgICAgICAoMSA8 PCAyMikgICAgLy8gV2FrZSBvbiBPdmVyIEN1cnJlbnQgRW5hYmxlCisjZGVmaW5lIFBPUlRT Q19XS0RTX0UgICAgICAgICgxIDw8IDIxKSAgICAvLyBXYWtlIG9uIERpc2Nvbm5lY3QgRW5h YmxlCisjZGVmaW5lIFBPUlRTQ19XS0NOX0UgICAgICAgICgxIDw8IDIwKSAgICAvLyBXYWtl IG9uIENvbm5lY3QgRW5hYmxlCisjZGVmaW5lIFBPUlRTQ19QVEMgICAgICAgICAgICgxNSA8 PCAxNikgICAvLyBQb3J0IFRlc3QgQ29udHJvbAorI2RlZmluZSBQT1JUU0NfUFRDX1NIICAg ICAgICAxNiAgICAgICAgICAgLy8gUG9ydCBUZXN0IENvbnRyb2wgc2hpZnQKKyNkZWZpbmUg UE9SVFNDX1BJQyAgICAgICAgICAgKDMgPDwgMTQpICAgIC8vIFBvcnQgSW5kaWNhdG9yIENv bnRyb2wKKyNkZWZpbmUgUE9SVFNDX1BJQ19TSCAgICAgICAgMTQgICAgICAgICAgIC8vIFBv cnQgSW5kaWNhdG9yIENvbnRyb2wgU2hpZnQKKyNkZWZpbmUgUE9SVFNDX1BPV05FUiAgICAg ICAgKDEgPDwgMTMpICAgIC8vIFBvcnQgT3duZXIKKyNkZWZpbmUgUE9SVFNDX1BQT1dFUiAg ICAgICAgKDEgPDwgMTIpICAgIC8vIFBvcnQgUG93ZXIKKyNkZWZpbmUgUE9SVFNDX0xJTkVT VEFUICAgICAgKDMgPDwgMTApICAgIC8vIFBvcnQgTGluZSBTdGF0dXMKKyNkZWZpbmUgUE9S VFNDX0xJTkVTVEFUX1NIICAgMTAgICAgICAgICAgIC8vIFBvcnQgTGluZSBTdGF0dXMgU2hp ZnQKKyNkZWZpbmUgUE9SVFNDX1BSRVNFVCAgICAgICAgKDEgPDwgOCkgICAgIC8vIFBvcnQg UmVzZXQKKyNkZWZpbmUgUE9SVFNDX1NVU1BFTkQgICAgICAgKDEgPDwgNykgICAgIC8vIFBv cnQgU3VzcGVuZAorI2RlZmluZSBQT1JUU0NfRlBSRVMgICAgICAgICAoMSA8PCA2KSAgICAg Ly8gRm9yY2UgUG9ydCBSZXN1bWUKKyNkZWZpbmUgUE9SVFNDX09DQyAgICAgICAgICAgKDEg PDwgNSkgICAgIC8vIE92ZXIgQ3VycmVudCBDaGFuZ2UKKyNkZWZpbmUgUE9SVFNDX09DQSAg ICAgICAgICAgKDEgPDwgNCkgICAgIC8vIE92ZXIgQ3VycmVudCBBY3RpdmUKKyNkZWZpbmUg UE9SVFNDX1BFREMgICAgICAgICAgKDEgPDwgMykgICAgIC8vIFBvcnQgRW5hYmxlL0Rpc2Fi bGUgQ2hhbmdlCisjZGVmaW5lIFBPUlRTQ19QRUQgICAgICAgICAgICgxIDw8IDIpICAgICAv LyBQb3J0IEVuYWJsZS9EaXNhYmxlCisjZGVmaW5lIFBPUlRTQ19DU0MgICAgICAgICAgICgx IDw8IDEpICAgICAvLyBDb25uZWN0IFN0YXR1cyBDaGFuZ2UKKyNkZWZpbmUgUE9SVFNDX0NP Tk5FQ1QgICAgICAgKDEgPDwgMCkgICAgIC8vIEN1cnJlbnQgQ29ubmVjdCBTdGF0dXMKKwor Ly8jZGVmaW5lIEVIQ0lfTk9NSUNST0ZSQU1FUworCisjaWZkZWYgRUhDSV9OT01JQ1JPRlJB TUVTCisjZGVmaW5lIEZSQU1FX1RJTUVSX0ZSRVEgMjAwMAorI2Vsc2UKKyNkZWZpbmUgRlJB TUVfVElNRVJfRlJFUSA4MDAwCisjZW5kaWYKKworI2RlZmluZSBOQl9NQVhJTlRSQVRFICAg IDggICAgICAgIC8vIE1heCByYXRlIGF0IHdoaWNoIGNvbnRyb2xsZXIgaXNzdWVzIGludHMK KyNkZWZpbmUgTkJfUE9SVFMgICAgICAgICA0ICAgICAgICAvLyBOdW1iZXIgb2YgZG93bnN0 cmVhbSBwb3J0cworI2RlZmluZSBCVUZGX1NJWkUgICAgICAgIDIwNDgwICAgIC8vIE1heCBi eXRlcyB0byB0cmFuc2ZlciBwZXIgdHJhbnNhY3Rpb24KKyNkZWZpbmUgTUFYX0lURVJBVElP TlMgICAxMDAwICAgICAvLyBNYXggbnVtYmVyIG9mIHN0YXRlcyBiZWZvcmUgd2UgYWJvcnQK KyNkZWZpbmUgTUFYX1FIICAgICAgICAgICAxMDAwICAgICAvLyBNYXggYWxsb3dhYmxlIHF1 ZXVlIGhlYWRzIGluIGEgY2hhaW4KKworLyogIEludGVybmFsIHBlcmlvZGljIC8gYXN5bmNo cm9ub3VzIHNjaGVkdWxlIHN0YXRlIG1hY2hpbmUgc3RhdGVzCisgKi8KK3R5cGVkZWYgZW51 bSB7CisgICAgRVNUX0lOQUNUSVZFID0gMTAwMCwKKyAgICBFU1RfQUNUSVZFLAorICAgIEVT VF9FWEVDVVRJTkcsCisgICAgRVNUX1NMRUVQSU5HLAorICAgIC8qICBUaGUgZm9sbG93aW5n IHN0YXRlcyBhcmUgaW50ZXJuYWwgdG8gdGhlIHN0YXRlIG1hY2hpbmUgZnVuY3Rpb24KKyAg ICAqLworICAgIEVTVF9XQUlUTElTVEhFQUQsCisgICAgRVNUX0RPUkVMT0FELAorICAgIEVT VF9XQUlUU1RBUlRFVkVOVCwKKyAgICBFU1RfRkVUQ0hFTlRSWSwKKyAgICBFU1RfRkVUQ0hR SCwKKyAgICBFU1RfRkVUQ0hJVEQsCisgICAgRVNUX0FEVkFOQ0VRVUVVRSwKKyAgICBFU1Rf RkVUQ0hRVEQsCisgICAgRVNUX0VYRUNVVEUsCisgICAgRVNUX1dSSVRFQkFDSywKKyAgICBF U1RfSE9SSVpPTlRBTFFICit9IEVIQ0lfU1RBVEVTOworCisvKiAgRUhDSSBzcGVjIHZlcnNp b24gMS4wIFNlY3Rpb24gMy4zCisgKi8KK3R5cGVkZWYgc3RydWN0IEVIQ0lpdGQgeworICAg IHVpbnQzMl90IG5leHQ7CisjZGVmaW5lIE5MUFRSX0dFVCh4KSAgICAgICAgICAgICAoKHgp ICYgMHhmZmZmZmZlMCkKKyNkZWZpbmUgTkxQVFJfVFlQRV9HRVQoeCkgICAgICAgICgoKHgp ID4+IDEpICYgMykKKyNkZWZpbmUgTkxQVFJfVFlQRV9JVEQgICAgICAgICAgIDAKKyNkZWZp bmUgTkxQVFJfVFlQRV9RSCAgICAgICAgICAgIDEKKyNkZWZpbmUgTkxQVFJfVFlQRV9TVElU RCAgICAgICAgIDIKKyNkZWZpbmUgTkxQVFJfVFlQRV9GU1ROICAgICAgICAgIDMKKyNkZWZp bmUgTkxQVFJfVEJJVCh4KSAgICAgICAgICAgICgoeCkgJiAxKQorCisgICAgdWludDMyX3Qg dHJhbnNhY3RbOF07CisjZGVmaW5lIElURF9YQUNUX0FDVElWRSAgICAgICAgICAoMSA8PCAz MSkKKyNkZWZpbmUgSVREX1hBQ1RfREJFUlJPUiAgICAgICAgICgxIDw8IDMwKQorI2RlZmlu ZSBJVERfWEFDVF9CQUJCTEUgICAgICAgICAgKDEgPDwgMjkpCisjZGVmaW5lIElURF9YQUNU X1hBQ1RFUlIgICAgICAgICAoMSA8PCAyOCkKKyNkZWZpbmUgSVREX1hBQ1RfTEVOR1RIX01B U0sgICAgIDB4MGZmZjAwMDAKKyNkZWZpbmUgSVREX1hBQ1RfTEVOR1RIX1NIICAgICAgIDE2 CisjZGVmaW5lIElURF9YQUNUX0lPQyAgICAgICAgICAgICAoMSA8PCAxNSkKKyNkZWZpbmUg SVREX1hBQ1RfUEdTRUxfTUFTSyAgICAgIDB4MDAwMDcwMDAKKyNkZWZpbmUgSVREX1hBQ1Rf UEdTRUxfU0ggICAgICAgIDEyCisjZGVmaW5lIElURF9YQUNUX09GRlNFVF9NQVNLICAgICAw eDAwMDAwZmZmCisKKyAgICB1aW50MzJfdCBidWZwdHJbN107CisjZGVmaW5lIElURF9CVUZQ VFJfTUFTSyAgICAgICAgICAweGZmZmZmMDAwCisjZGVmaW5lIElURF9CVUZQVFJfU0ggICAg ICAgICAgICAxMgorI2RlZmluZSBJVERfQlVGUFRSX0VQX01BU0sgICAgICAgMHgwMDAwMGYw MAorI2RlZmluZSBJVERfQlVGUFRSX0VQX1NIICAgICAgICAgOAorI2RlZmluZSBJVERfQlVG UFRSX0RFVkFERFJfTUFTSyAgMHgwMDAwMDA3ZgorI2RlZmluZSBJVERfQlVGUFRSX0RJUkVD VElPTiAgICAgKDEgPDwgMTEpCisjZGVmaW5lIElURF9CVUZQVFJfTUFYUEtUX01BU0sgICAw eDAwMDAwN2ZmCisjZGVmaW5lIElURF9CVUZQVFJfTVVMVF9NQVNLICAgICAweDAwMDAwMDAz Cit9IEVIQ0lpdGQ7CisKKy8qICBFSENJIHNwZWMgdmVyc2lvbiAxLjAgU2VjdGlvbiAzLjQK KyAqLwordHlwZWRlZiBzdHJ1Y3QgRUhDSXNpdGQgeworICAgIHVpbnQzMl90IG5leHQ7ICAg ICAgICAgICAgICAgICAgLy8gU3RhbmRhcmQgbmV4dCBsaW5rIHBvaW50ZXIKKyAgICB1aW50 MzJfdCBlcGNoYXI7CisjZGVmaW5lIFNJVERfRVBDSEFSX0lPICAgICAgICAgICAgICAoMSA8 PCAzMSkKKyNkZWZpbmUgU0lURF9FUENIQVJfUE9SVE5VTV9NQVNLICAgIDB4N2YwMDAwMDAK KyNkZWZpbmUgU0lURF9FUENIQVJfUE9SVE5VTV9TSCAgICAgIDI0CisjZGVmaW5lIFNJVERf RVBDSEFSX0hVQkFERF9NQVNLICAgICAweDAwN2YwMDAwCisjZGVmaW5lIFNJVERfRVBDSEFS X0hVQkFERFJfU0ggICAgICAxNgorI2RlZmluZSBTSVREX0VQQ0hBUl9FUE5VTV9NQVNLICAg ICAgMHgwMDAwMGYwMAorI2RlZmluZSBTSVREX0VQQ0hBUl9FUE5VTV9TSCAgICAgICAgOAor I2RlZmluZSBTSVREX0VQQ0hBUl9ERVZBRERSX01BU0sgICAgMHgwMDAwMDA3ZgorCisgICAg dWludDMyX3QgdWZyYW1lOworI2RlZmluZSBTSVREX1VGUkFNRV9DTUFTS19NQVNLICAgICAg MHgwMDAwZmYwMAorI2RlZmluZSBTSVREX1VGUkFNRV9DTUFTS19TSCAgICAgICAgOAorI2Rl ZmluZSBTSVREX1VGUkFNRV9TTUFTS19NQVNLICAgICAgMHgwMDAwMDBmZgorCisgICAgdWlu dDMyX3QgcmVzdWx0czsKKyNkZWZpbmUgU0lURF9SRVNVTFRTX0lPQyAgICAgICAgICAgICAg KDEgPDwgMzEpCisjZGVmaW5lIFNJVERfUkVTVUxUU19QR1NFTCAgICAgICAgICAgICgxIDw8 IDMwKQorI2RlZmluZSBTSVREX1JFU1VMVFNfVEJZVEVTX01BU0sgICAgICAweDAzZmYwMDAw CisjZGVmaW5lIFNJVERfUkVTVUxUU19UWUJZVEVTX1NIICAgICAgIDE2CisjZGVmaW5lIFNJ VERfUkVTVUxUU19DUFJPR01BU0tfTUFTSyAgIDB4MDAwMGZmMDAKKyNkZWZpbmUgU0lURF9S RVNVTFRTX0NQUk9HTUFTS19TSCAgICAgOAorI2RlZmluZSBTSVREX1JFU1VMVFNfQUNUSVZF ICAgICAgICAgICAoMSA8PCA3KQorI2RlZmluZSBTSVREX1JFU1VMVFNfRVJSICAgICAgICAg ICAgICAoMSA8PCA2KQorI2RlZmluZSBTSVREX1JFU1VMVFNfREJFUlIgICAgICAgICAgICAo MSA8PCA1KQorI2RlZmluZSBTSVREX1JFU1VMVFNfQkFCQkxFICAgICAgICAgICAoMSA8PCA0 KQorI2RlZmluZSBTSVREX1JFU1VMVFNfWEFDVEVSUiAgICAgICAgICAoMSA8PCAzKQorI2Rl ZmluZSBTSVREX1JFU1VMVFNfTUlTU0VEVUYgICAgICAgICAoMSA8PCAyKQorI2RlZmluZSBT SVREX1JFU1VMVFNfU1BMSVRYU1RBVEUgICAgICAoMSA8PCAxKQorCisgICAgdWludDMyX3Qg YnVmcHRyWzJdOworI2RlZmluZSBCVUZQVFJfTUFTSyAgICAgICAgICAgICAgICAgICAweGZm ZmZmMDAwCisjZGVmaW5lIEJVRlBUUl9DVVJST0ZGX01BU0sgICAgICAgICAgIDB4MDAwMDBm ZmYKKyNkZWZpbmUgQlVGUFRSX1RQT1NfTUFTSyAgICAgICAgICAgICAgMHgwMDAwMDAxOAor I2RlZmluZSBCVUZQVFJfVFBPU19TSCAgICAgICAgICAgICAgICAzCisjZGVmaW5lIEJVRlBU Ul9UQ05UX01BU0sgICAgICAgICAgICAgIDB4MDAwMDAwMDcKKworICAgIHVpbnQzMl90IGJh Y2twdHI7ICAgICAgICAgICAgICAgICAvLyBTdGFuZGFyZCBuZXh0IGxpbmsgcG9pbnRlcgor fSBFSENJc2l0ZDsKKworLyogIEVIQ0kgc3BlYyB2ZXJzaW9uIDEuMCBTZWN0aW9uIDMuNQor ICovCit0eXBlZGVmIHN0cnVjdCBFSENJcXRkIHsKKyAgICB1aW50MzJfdCBuZXh0OyAgICAg ICAgICAgICAgICAgICAgLy8gU3RhbmRhcmQgbmV4dCBsaW5rIHBvaW50ZXIKKyAgICB1aW50 MzJfdCBhbHRuZXh0OyAgICAgICAgICAgICAgICAgLy8gU3RhbmRhcmQgbmV4dCBsaW5rIHBv aW50ZXIKKyAgICB1aW50MzJfdCB0b2tlbjsKKyNkZWZpbmUgUVREX1RPS0VOX0RUT0dHTEUg ICAgICAgICAgICAgKDEgPDwgMzEpCisjZGVmaW5lIFFURF9UT0tFTl9UQllURVNfTUFTSyAg ICAgICAgIDB4N2ZmZjAwMDAKKyNkZWZpbmUgUVREX1RPS0VOX1RCWVRFU19TSCAgICAgICAg ICAgMTYKKyNkZWZpbmUgUVREX1RPS0VOX0lPQyAgICAgICAgICAgICAgICAgKDEgPDwgMTUp CisjZGVmaW5lIFFURF9UT0tFTl9DUEFHRV9NQVNLICAgICAgICAgIDB4MDAwMDcwMDAKKyNk ZWZpbmUgUVREX1RPS0VOX0NQQUdFX1NIICAgICAgICAgICAgMTIKKyNkZWZpbmUgUVREX1RP S0VOX0NFUlJfTUFTSyAgICAgICAgICAgMHgwMDAwMGMwMAorI2RlZmluZSBRVERfVE9LRU5f Q0VSUl9TSCAgICAgICAgICAgICAxMAorI2RlZmluZSBRVERfVE9LRU5fUElEX01BU0sgICAg ICAgICAgICAweDAwMDAwMzAwCisjZGVmaW5lIFFURF9UT0tFTl9QSURfU0ggICAgICAgICAg ICAgIDgKKyNkZWZpbmUgUVREX1RPS0VOX0FDVElWRSAgICAgICAgICAgICAgKDEgPDwgNykK KyNkZWZpbmUgUVREX1RPS0VOX0hBTFQgICAgICAgICAgICAgICAgKDEgPDwgNikKKyNkZWZp bmUgUVREX1RPS0VOX0RCRVJSICAgICAgICAgICAgICAgKDEgPDwgNSkKKyNkZWZpbmUgUVRE X1RPS0VOX0JBQkJMRSAgICAgICAgICAgICAgKDEgPDwgNCkKKyNkZWZpbmUgUVREX1RPS0VO X1hBQ1RFUlIgICAgICAgICAgICAgKDEgPDwgMykKKyNkZWZpbmUgUVREX1RPS0VOX01JU1NF RFVGICAgICAgICAgICAgKDEgPDwgMikKKyNkZWZpbmUgUVREX1RPS0VOX1NQTElUWFNUQVRF ICAgICAgICAgKDEgPDwgMSkKKyNkZWZpbmUgUVREX1RPS0VOX1BJTkcgICAgICAgICAgICAg ICAgKDEgPDwgMCkKKworICAgIHVpbnQzMl90IGJ1ZnB0cls1XTsgICAgICAgICAgICAgICAv LyBTdGFuZGFyZCBidWZmZXIgcG9pbnRlcgorfSBFSENJcXRkOworCisvKiAgRUhDSSBzcGVj IHZlcnNpb24gMS4wIFNlY3Rpb24gMy42CisgKi8KK3R5cGVkZWYgc3RydWN0IEVIQ0lxaCB7 CisgICAgdWludDMyX3QgbmV4dDsgICAgICAgICAgICAgICAgICAgIC8vIFN0YW5kYXJkIG5l eHQgbGluayBwb2ludGVyCisKKyAgICB1aW50MzJfdCBlcGNoYXI7CisjZGVmaW5lIFFIX0VQ Q0hBUl9STF9NQVNLICAgICAgICAgICAgIDB4ZjAwMDAwMDAKKyNkZWZpbmUgUUhfRVBDSEFS X1JMX1NIICAgICAgICAgICAgICAgMjgKKyNkZWZpbmUgUUhfRVBDSEFSX0MgICAgICAgICAg ICAgICAgICAgKDEgPDwgMjcpCisjZGVmaW5lIFFIX0VQQ0hBUl9NUExFTl9NQVNLICAgICAg ICAgIDB4MDdGRjAwMDAKKyNkZWZpbmUgUUhfRVBDSEFSX01QTEVOX1NIICAgICAgICAgICAg MTYKKyNkZWZpbmUgUUhfRVBDSEFSX0ggICAgICAgICAgICAgICAgICAgKDEgPDwgMTUpCisj ZGVmaW5lIFFIX0VQQ0hBUl9EVEMgICAgICAgICAgICAgICAgICgxIDw8IDE0KQorI2RlZmlu ZSBRSF9FUENIQVJfRVBTX01BU0sgICAgICAgICAgICAweDAwMDAzMDAwCisjZGVmaW5lIFFI X0VQQ0hBUl9FUFNfU0ggICAgICAgICAgICAgIDEyCisjZGVmaW5lIFFIX0VQQ0hBUl9FUF9N QVNLICAgICAgICAgICAgIDB4MDAwMDBmMDAKKyNkZWZpbmUgUUhfRVBDSEFSX0VQX1NIICAg ICAgICAgICAgICAgOAorI2RlZmluZSBRSF9FUENIQVJfSSAgICAgICAgICAgICAgICAgICAo MSA8PCA3KQorI2RlZmluZSBRSF9FUENIQVJfREVWQUREUl9NQVNLICAgICAgICAweDAwMDAw MDdmCisKKyAgICB1aW50MzJfdCBlcGNhcDsKKyNkZWZpbmUgUUhfRVBDQVBfTVVMVF9NQVNL ICAgICAgICAgICAgMHhjMDAwMDAwMAorI2RlZmluZSBRSF9FUENBUF9NVUxUX1NIICAgICAg ICAgICAgICAzMAorI2RlZmluZSBRSF9FUENBUF9QT1JUTlVNX01BU0sgICAgICAgICAweDNm ODAwMDAwCisjZGVmaW5lIFFIX0VQQ0FQX1BPUlROVU1fU0ggICAgICAgICAgIDIzCisjZGVm aW5lIFFIX0VQQ0FQX0hVQkFERFJfTUFTSyAgICAgICAgIDB4MDA3ZjAwMDAKKyNkZWZpbmUg UUhfRVBDQVBfSFVCQUREUl9TSCAgICAgICAgICAgMTYKKyNkZWZpbmUgUUhfRVBDQVBfQ01B U0tfTUFTSyAgICAgICAgICAgMHgwMDAwZmYwMAorI2RlZmluZSBRSF9FUENBUF9DTUFTS19T SCAgICAgICAgICAgICA4CisjZGVmaW5lIFFIX0VQQ0FQX1NNQVNLX01BU0sgICAgICAgICAg IDB4MDAwMDAwZmYKKworICAgIHVpbnQzMl90IGN1cnJlbnQ7ICAgICAgICAgICAgICAgICAv LyBTdGFuZGFyZCBuZXh0IGxpbmsgcG9pbnRlcgorICAgIHVpbnQzMl90IHF0ZG5leHQ7ICAg ICAgICAgICAgICAgICAvLyBTdGFuZGFyZCBuZXh0IGxpbmsgcG9pbnRlcgorICAgIHVpbnQz Ml90IGFsdG5leHQ7CisjZGVmaW5lIFFIX0FMVE5FWFRfTkFLQ05UX01BU0sgICAgICAgIDB4 MDAwMDAwMWUKKyNkZWZpbmUgUUhfQUxUTkVYVF9OQUtDTlRfU0ggICAgICAgICAgMQorCisg ICAgdWludDMyX3QgdG9rZW47ICAgICAgICAgICAgICAgICAgIC8vIFNhbWUgYXMgUVREIHRv a2VuCisgICAgdWludDMyX3QgYnVmcHRyWzVdOyAgICAgICAgICAgICAgIC8vIFN0YW5kYXJk IGJ1ZmZlciBwb2ludGVyCisjZGVmaW5lIEJVRlBUUl9DUFJPR01BU0tfTUFTSyAgICAgICAg IDB4MDAwMDAwZmYKKyNkZWZpbmUgQlVGUFRSX0ZSQU1FVEFHX01BU0sgICAgICAgICAgMHgw MDAwMDAxZgorI2RlZmluZSBCVUZQVFJfU0JZVEVTX01BU0sgICAgICAgICAgICAweDAwMDAw ZmUwCisjZGVmaW5lIEJVRlBUUl9TQllURVNfU0ggICAgICAgICAgICAgIDUKK30gRUhDSXFo OworCisvKiAgRUhDSSBzcGVjIHZlcnNpb24gMS4wIFNlY3Rpb24gMy43CisgKi8KK3R5cGVk ZWYgc3RydWN0IEVIQ0lmc3RuIHsKKyAgICB1aW50MzJfdCBuZXh0OyAgICAgICAgICAgICAg ICAgICAgLy8gU3RhbmRhcmQgbmV4dCBsaW5rIHBvaW50ZXIKKyAgICB1aW50MzJfdCBiYWNr cHRyOyAgICAgICAgICAgICAgICAgLy8gU3RhbmRhcmQgbmV4dCBsaW5rIHBvaW50ZXIKK30g RUhDSWZzdG47CisKK3R5cGVkZWYgc3RydWN0IHsKKyAgICBQQ0lEZXZpY2UgZGV2OworICAg IHFlbXVfaXJxIGlycTsKKyAgICB0YXJnZXRfcGh5c19hZGRyX3QgbWVtX2Jhc2U7CisgICAg aW50IG1lbTsKKyAgICBpbnQgbnVtX3BvcnRzOworICAgIC8qCisgICAgICogIEVIQ0kgc3Bl YyB2ZXJzaW9uIDEuMCBTZWN0aW9uIDIuMworICAgICAqICBIb3N0IENvbnRyb2xsZXIgT3Bl cmF0aW9uYWwgUmVnaXN0ZXJzCisgICAgICovCisgICAgdW5pb24geworICAgICAgICB1aW50 OF90IG1taW9bTU1JT19TSVpFXTsKKyAgICAgICAgc3RydWN0IHsKKyAgICAgICAgICAgIHVp bnQ4X3QgY2FwW09QUkVHQkFTRV07CisgICAgICAgICAgICB1aW50MzJfdCB1c2JjbWQ7Cisg ICAgICAgICAgICB1aW50MzJfdCB1c2JzdHM7CisgICAgICAgICAgICB1aW50MzJfdCB1c2Jp bnRyOworICAgICAgICAgICAgdWludDMyX3QgZnJpbmRleDsKKyAgICAgICAgICAgIHVpbnQz Ml90IGN0cmxkc3NlZ21lbnQ7CisgICAgICAgICAgICB1aW50MzJfdCBwZXJpb2RpY2xpc3Ri YXNlOworICAgICAgICAgICAgdWludDMyX3QgYXN5bmNsaXN0YWRkcjsKKyAgICAgICAgICAg IHVpbnQzMl90IG5vdHVzZWRbOV07CisgICAgICAgICAgICB1aW50MzJfdCBjb25maWdmbGFn OworICAgICAgICAgICAgdWludDMyX3QgcG9ydHNjW05CX1BPUlRTXTsKKyAgICAgICAgfTsK KyAgICB9OworICAgIC8qCisgICAgICogIEludGVybmFsIHN0YXRlcywgc2hhZG93IHJlZ2lz dGVycywgZXRjCisgICAgICovCisgICAgdWludDMyX3Qgc29mdjsKKyAgICBRRU1VVGltZXIg KmZyYW1lX3RpbWVyOworICAgIGludCBhdHRhY2hfcG9sbF9jb3VudGVyOworICAgIGludCBh c3RhdGU7ICAgICAgICAgICAgICAgICAgICAgICAgLy8gQ3VycmVudCBzdGF0ZSBpbiBhc3lu Y2hyb25vdXMgc2NoZWR1bGUKKyAgICBpbnQgcHN0YXRlOyAgICAgICAgICAgICAgICAgICAg ICAgIC8vIEN1cnJlbnQgc3RhdGUgaW4gcGVyaW9kaWMgc2NoZWR1bGUKKyAgICBVU0JQb3J0 IHBvcnRzW05CX1BPUlRTXTsKKyAgICB1bnNpZ25lZCBjaGFyIGJ1ZmZlcltCVUZGX1NJWkVd OworICAgIEVIQ0lxaCBxaDsKKyAgICBFSENJcXRkIHF0ZDsKKyAgICBVU0JCdXMgYnVzOwor ICAgIFVTQlBhY2tldCB1c2JfcGFja2V0OworICAgIGludCBhc3luY19wb3J0X2luX3Byb2dy ZXNzOworICAgIGludCBhc3luY19jb21wbGV0ZTsKKyAgICB1aW50MzJfdCBxaGFkZHI7Cisg ICAgdWludDMyX3QgaXRkYWRkcjsKKyAgICB1aW50MzJfdCBxdGRhZGRyOworICAgIHVpbnQz Ml90IHRieXRlczsKKyAgICBpbnQgcGlkOworICAgIGludCBleGVjX3N0YXR1czsKKyAgICBp bnQgaXNvY2hfcGF1c2U7CisgICAgdWludDMyX3QgbGFzdF9ydW5fdXNlYzsKKyAgICB1aW50 MzJfdCBmcmFtZV9lbmRfdXNlYzsKK30gRUhDSVN0YXRlOworCitzdGF0aWMgaW5saW5lIHVp bnQzMl90IGdldF9maWVsZCh1aW50MzJfdCBkYXRhLCB1aW50MzJfdCBtYXNrLCBpbnQgc2hp ZnQpCit7CisgICAgcmV0dXJuKChkYXRhICYgbWFzaykgPj4gc2hpZnQpOworfQorCitzdGF0 aWMgaW5saW5lIHZvaWQgc2V0X2ZpZWxkKHVpbnQzMl90ICpkYXRhLCB1aW50MzJfdCB2YWws CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50MzJfdCBtYXNrLCBpbnQgc2hp ZnQpCit7CisgICAgKmRhdGEgJj0gfm1hc2s7CisgICAgKmRhdGEgfD0odmFsIDw8IHNoaWZ0 KTsKK30KKworc3RhdGljIHZvaWQgZHVtcF9wdHIoY29uc3QgY2hhciAqcywgdWludDMyX3Qg cHRyLCBpbnQgaGFzX3R5cGUpCit7CisgICAgaW50IHQgPSBOTFBUUl9UWVBFX0dFVChwdHIp OworCisgICAgcHJpbnRmKCIlcyUwOFgiLCBzLCBOTFBUUl9HRVQocHRyKSk7CisKKyAgICBp ZiAoaGFzX3R5cGUpIHsKKyAgICAgICAgcHJpbnRmKCIoUFRSIHR5cGUgaXMgJXMpIiwKKyAg ICAgICAgICAgIHQgPT0gTkxQVFJfVFlQRV9JVEQgPyAiSVREIiA6CisgICAgICAgICAgICh0 ID09IE5MUFRSX1RZUEVfUUggPyAiUUgiIDoKKyAgICAgICAgICAgKHQgPT0gTkxQVFJfVFlQ RV9TVElURCA/ICJTVElURCIgOgorICAgICAgICAgICAodCA9PSBOTFBUUl9UWVBFX0ZTVE4g PyAiRlNUTiIgOiAiKioqKiIpKSkpOworICAgIH0KKworICAgIHByaW50ZigiJXNcbiIsIE5M UFRSX1RCSVQocHRyKSA/ICIgVEJJVCBzZXQiIDogIiIpOworfQorCitzdGF0aWMgdm9pZCBk dW1wX3F0ZChFSENJcXRkICpxdGQsIHVpbnQzMl90IHF0ZGFkZHIpCit7CisgICAgaW50IHBp ZDsKKworICAgIHBpZCA9KHF0ZC0+dG9rZW4gJiBRVERfVE9LRU5fUElEX01BU0spID4+IFFU RF9UT0tFTl9QSURfU0g7CisKKyAgICBwcmludGYoIiAgICBRVEQgYW5hbHlzaXMgICAgICAl MDhYXG4iCisgICAgICAgICAgICAiICAgID09PSA9PT09PT09PSAgICAgID09PT09PT09XG4i LCBxdGRhZGRyKTsKKworICAgIHByaW50ZigiICAgIE5ha0NudDogICAgICAgICAgICVkXG4i LAorICAgICAgICAgICAgIChxdGQtPmFsdG5leHQgJiBRSF9BTFRORVhUX05BS0NOVF9NQVNL KSA+PiBRSF9BTFRORVhUX05BS0NOVF9TSCk7CisgICAgZHVtcF9wdHIoIiAgICBOZXh0OiAg ICAgICAgICAgICAiLCBxdGQtPm5leHQsIDApOworICAgIGR1bXBfcHRyKCIgICAgQWx0ZXJu YXRlOiAgICAgICAgIiwgcXRkLT5hbHRuZXh0LCAwKTsKKyAgICBwcmludGYoIiAgICBEYXRh IFRvZ2dsZTogICAgICAlcyAgICAgICAgIiwKKyAgICAgICAgICAgICAgcXRkLT50b2tlbiAm IFFURF9UT0tFTl9EVE9HR0xFID8gIlllcyAiIDogIk5vICAiKTsKKyAgICBwcmludGYoIiAg ICBUb3RhbCBCeXRlczogICAgICAlZFxuIiwKKyAgICAgICAgICAgICAocXRkLT50b2tlbiAm IFFURF9UT0tFTl9UQllURVNfTUFTSykgPj4gUVREX1RPS0VOX1RCWVRFU19TSCk7CisgICAg cHJpbnRmKCIgICAgSU9DOiAgICAgICAgICAgICAgJXMgICAgICAgICIsCisgICAgICAgICAg ICAgIHF0ZC0+dG9rZW4gJiBRVERfVE9LRU5fSU9DID8gIlllcyAiIDogIk5vICAiKTsKKyAg ICBwcmludGYoIiAgICBDX1BhZ2U6ICAgICAgICAgICAlZFxuIiwKKyAgICAgICAgICAgICAo cXRkLT50b2tlbiAmIFFURF9UT0tFTl9DUEFHRV9NQVNLKSA+PiBRVERfVE9LRU5fQ1BBR0Vf U0gpOworICAgIHByaW50ZigiICAgIENFcnI6ICAgICAgICAgICAgICUtNGQgICAgICAgICIs CisgICAgICAgICAgICAgKHF0ZC0+dG9rZW4gJiBRVERfVE9LRU5fQ0VSUl9NQVNLKSA+PiBR VERfVE9LRU5fQ0VSUl9TSCk7CisgICAgcHJpbnRmKCIgICAgUElEIGNvZGU6ICAgICAgICAg JXNcbiIsCisgICAgICAgICAgICAgIHBpZCA9PSAwID8gIk9VVCIgOgorICAgICAgICAgICAg IChwaWQgPT0gMSA/ICJJTiIgOgorICAgICAgICAgICAgIChwaWQgPT0gMiA/ICJTRVRVUCIg OiAiKioqKiIpKSk7CisgICAgcHJpbnRmKCIgICAgRmxhZ3M6ICAgICAgICAgICAgJXMlcyVz JXMlcyVzJXMlc1xuIiwKKyAgICAgICAgICAgICAgcXRkLT50b2tlbiAmIFFURF9UT0tFTl9B Q1RJVkUgPyAiQUNUSVZFICIgOiAiIiwKKyAgICAgICAgICAgICAgcXRkLT50b2tlbiAmIFFU RF9UT0tFTl9IQUxUID8gIkhBTFQgIiA6ICIiLAorICAgICAgICAgICAgICBxdGQtPnRva2Vu ICYgUVREX1RPS0VOX0RCRVJSID8gIkRCRVJSICIgOiAiIiwKKyAgICAgICAgICAgICAgcXRk LT50b2tlbiAmIFFURF9UT0tFTl9CQUJCTEUgPyAiQkFCQkxFICIgOiAiIiwKKyAgICAgICAg ICAgICAgcXRkLT50b2tlbiAmIFFURF9UT0tFTl9YQUNURVJSID8gIlhBQ1RFUlIgIiA6ICIi LAorICAgICAgICAgICAgICBxdGQtPnRva2VuICYgUVREX1RPS0VOX01JU1NFRFVGID8gIk1J U1NFRFVGICIgOiAiIiwKKyAgICAgICAgICAgICAgcXRkLT50b2tlbiAmIFFURF9UT0tFTl9T UExJVFhTVEFURSA/ICJTUExJVFhTVEFURSAiIDogIiIsCisgICAgICAgICAgICAgIHF0ZC0+ dG9rZW4gJiBRVERfVE9LRU5fUElORyA/ICJQSU5HICIgOiAiIik7CisgICAgcHJpbnRmKCIg ICAgQ3VycmVudCBPZmZzZXQgICAgJWRcbiIsCisgICAgICAgICAgICAgIHF0ZC0+YnVmcHRy WzBdICYgQlVGUFRSX0NVUlJPRkZfTUFTSyk7CisgICAgcHJpbnRmKCIgICAgPT09ID09PT09 PT09ICAgICAgPT09PT09PT1cbiIpOworfQorCitzdGF0aWMgdm9pZCBkdW1wX3FoKEVIQ0lx aCAqcWgsIHVpbnQzMl90IHFoYWRkcikKK3sKKyAgICBpbnQgc3BlZWQgPShxaC0+ZXBjaGFy ICYgUUhfRVBDSEFSX0VQU19NQVNLKSA+PiBRSF9FUENIQVJfRVBTX1NIOworCisgICAgcHJp bnRmKCJRSCBhbmFseXNpcyAgICAgICAlMDhYXG4iCisgICAgICAgICAgICAiPT0gPT09PT09 PT0gICAgICAgPT09PT09PT1cbiIsIHFoYWRkcik7CisKKyAgICBkdW1wX3B0cigiSG9yaXpv bnRhbDogICAgICAgIiwgcWgtPm5leHQsIDEpOworICAgIHByaW50ZigiTmFrIENvdW50IFJl bG9hZDogJWRcbiIsCisgICAgICAgICAgIChxaC0+ZXBjaGFyICYgUUhfRVBDSEFSX1JMX01B U0spID4+IFFIX0VQQ0hBUl9STF9TSCk7CisgICAgcHJpbnRmKCJNYXggUGt0IExlbjogICAg ICAlZFxuIiwKKyAgICAgICAgICAgKHFoLT5lcGNoYXIgJiBRSF9FUENIQVJfTVBMRU5fTUFT SykgPj4gUUhfRVBDSEFSX01QTEVOX1NIKTsKKyAgICBwcmludGYoIkNvbnRyb2wgRW5kcG9p bnQ6ICVzICAgICAgICAiLAorICAgICAgICAgICAocWgtPmVwY2hhciAmIFFIX0VQQ0hBUl9D KSA/ICJZZXMgIiA6ICJObyAgIik7CisgICAgcHJpbnRmKCJILWJpdDogICAgICAgICAgICAl c1xuIiwKKyAgICAgICAgICAgKHFoLT5lcGNoYXIgJiBRSF9FUENIQVJfSCkgPyAiWWVzICIg OiAiTm8gICIpOworICAgIHByaW50ZigiRFRDOiAgICAgICAgICAgICAgJXMgICAgICAgICIs CisgICAgICAgICAgIChxaC0+ZXBjaGFyICYgUUhfRVBDSEFSX0RUQykgPyAiWWVzICIgOiAi Tm8gICIpOworICAgIHByaW50ZigiRW5kUG9pbnQgU3BlZWQ6ICAgJXNcbiIsCisgICAgICAg ICAgICBzcGVlZCA9PSAwID8gIkZ1bGwiIDoKKyAgICAgICAgICAgKHNwZWVkID09IDEgPyAi TG93ICIgOgorICAgICAgICAgICAoc3BlZWQgPT0gMiA/ICJIaWdoIiA6ICIqKioqIikpKTsK KyAgICBwcmludGYoIkVuZFBvaW50OiAgICAgICAgICUtNGQgICAgICAgICIsCisgICAgICAg ICAgIChxaC0+ZXBjaGFyICYgUUhfRVBDSEFSX0VQX01BU0spID4+IFFIX0VQQ0hBUl9FUF9T SCk7CisgICAgcHJpbnRmKCJJbmFjdGl2ZSBvbiBuZXh0OiAlc1xuIiwKKyAgICAgICAgICAg KHFoLT5lcGNoYXIgJiBRSF9FUENIQVJfSSkgPyAiWWVzIiA6ICJObyIpOworICAgIHByaW50 ZigiRGV2QWRkcjogICAgICAgICAgJS00ZCAgICAgICAgIiwKKyAgICAgICAgICAgICBxaC0+ ZXBjaGFyICYgUUhfRVBDSEFSX0RFVkFERFJfTUFTSyk7CisgICAgcHJpbnRmKCJNdWx0OiAg ICAgICAgICAgICAlLTRkXG4iLAorICAgICAgICAgICAocWgtPmVwY2FwICYgUUhfRVBDQVBf TVVMVF9NQVNLKSA+PiBRSF9FUENBUF9NVUxUX1NIKTsKKyAgICBwcmludGYoIlBvcnROdW06 ICAgICAgICAgICUtNGQgICAgICAgICIsCisgICAgICAgICAgIChxaC0+ZXBjYXAgJiBRSF9F UENBUF9QT1JUTlVNX01BU0spID4+IFFIX0VQQ0FQX1BPUlROVU1fU0gpOworICAgIHByaW50 ZigiSHViQWRkcjogICAgICAgICAgJWRcbiIsCisgICAgICAgICAgIChxaC0+ZXBjYXAgJiBR SF9FUENBUF9IVUJBRERSX01BU0spID4+IFFIX0VQQ0FQX0hVQkFERFJfU0gpOworICAgIHBy aW50ZigiQy1tYXNrOiAgICAgICAgICAgJS00ZCAgICAgICAgIiwKKyAgICAgICAgICAgKHFo LT5lcGNhcCAmIFFIX0VQQ0FQX0NNQVNLX01BU0spID4+IFFIX0VQQ0FQX0NNQVNLX1NIKTsK KyAgICBwcmludGYoIlMtbWFzazogICAgICAgICAgICVkXG4iLAorICAgICAgICAgICAgICBx aC0+ZXBjYXAgJiBRSF9FUENBUF9TTUFTS19NQVNLKTsKKyAgICBkdW1wX3B0cigiQ3VycmVu dDogICAgICAgICAgIiwgcWgtPmN1cnJlbnQsIDApOworCisgICAgZHVtcF9xdGQoKEVIQ0lx dGQgKikmcWgtPnF0ZG5leHQsIHFoYWRkciArIDE2KTsKKworICAgIHByaW50ZigiQy1wcm9n IG1hc2s6ICAgICAgJWRcbiIsCisgICAgICAgICAgICAgIHFoLT5idWZwdHJbMV0gJiBCVUZQ VFJfQ1BST0dNQVNLX01BU0spOworICAgIHByaW50ZigiUy1ieXRlczogICAgICAgICAgJWRc biIsCisgICAgICAgICAgICAgIHFoLT5idWZwdHJbMl0gJiBCVUZQVFJfRlJBTUVUQUdfTUFT Syk7CisgICAgcHJpbnRmKCJGcmFtZVRhZzogICAgICAgICAlZFxuIiwKKyAgICAgICAgICAg ICAocWgtPmJ1ZnB0clsyXSAmIEJVRlBUUl9TQllURVNfTUFTSykgPj4gQlVGUFRSX1NCWVRF U19TSCk7CisgICAgcHJpbnRmKCI9PSA9PT09PT09PSAgICAgICA9PT09PT09PVxuIik7Cit9 CisKKyNpZmRlZiBERUJVR19QQUNLRVQKKworc3RhdGljIHZvaWQgZHVtcF9pdGQoRUhDSWl0 ZCAqaXRkLCB1aW50MzJfdCBhZGRyKQoreworICAgIGludCBpOworCisgICAgcHJpbnRmKCJJ VEQgYW5hbHlzaXMgICAgICAgJTA4WFxuIgorICAgICAgICAgICAgIj09PSA9PT09PT09PSAg ICAgICA9PT09PT09PVxuIiwgYWRkcik7CisKKyAgICBkdW1wX3B0cigiSG9yaXpvbnRhbDog ICAgICAgIiwgaXRkLT5uZXh0LCAxKTsKKworICAgIGZvcihpID0gMDsgaSA8IDg7IGkrKykg eworICAgICAgICBwcmludGYoIlRyYW5zIERlc2MgJWQsIGxlbiAlNWQsIG9mZiAlMDNYLCBw YWdlIHNlbCAlZCwgaW9jOiVzICIsCisgICAgICAgICAgICAgICAgICBpLAorICAgICAgICAg ICAgICAgICAgZ2V0X2ZpZWxkKGl0ZC0+dHJhbnNhY3RbaV0sIElURF9YQUNUX0xFTkdUSF9N QVNLLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJVERfWEFDVF9MRU5HVEhfU0gp LAorICAgICAgICAgICAgICAgICAgZ2V0X2ZpZWxkKGl0ZC0+dHJhbnNhY3RbaV0sIElURF9Y QUNUX09GRlNFVF9NQVNLLCAwKSwKKyAgICAgICAgICAgICAgICAgIGdldF9maWVsZChpdGQt PnRyYW5zYWN0W2ldLCBJVERfWEFDVF9QR1NFTF9NQVNLLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBJVERfWEFDVF9QR1NFTF9TSCksCisgICAgICAgICAgICAgICAgICBpdGQt PnRyYW5zYWN0W2ldICYgSVREX1hBQ1RfSU9DID8gIlllcyIgOiAiTm8gIik7CisKKyAgICAg ICAgaWYgKGl0ZC0+dHJhbnNhY3RbaV0gJiBJVERfWEFDVF9BQ1RJVkUpCisgICAgICAgICAg ICBwcmludGYoIkFDVElWRSAiKTsKKworICAgICAgICBpZiAoaXRkLT50cmFuc2FjdFtpXSAm IElURF9YQUNUX0RCRVJST1IpCisgICAgICAgICAgICBwcmludGYoIkRBVEFFUlIgIik7CisK KyAgICAgICAgaWYgKGl0ZC0+dHJhbnNhY3RbaV0gJiBJVERfWEFDVF9CQUJCTEUpCisgICAg ICAgICAgICBwcmludGYoIkJBQkJMRSAiKTsKKworICAgICAgICBpZiAoaXRkLT50cmFuc2Fj dFtpXSAmIElURF9YQUNUX1hBQ1RFUlIpCisgICAgICAgICAgICBwcmludGYoIlhBQ1RFUlIg Iik7CisKKyAgICAgICAgcHJpbnRmKCJcbiIpOworICAgIH0KKworICAgIHByaW50ZigiRGV2 aWNlOiAgICAgJWRcbiIsCisgICAgICAgICAgICBnZXRfZmllbGQoaXRkLT5idWZwdHJbMF0s IElURF9CVUZQVFJfREVWQUREUl9NQVNLLCAwKSk7CisKKyAgICBwcmludGYoIkVuZHBvaW50 OiAgICVkXG4iLAorICAgICAgICAgICAgZ2V0X2ZpZWxkKGl0ZC0+YnVmcHRyWzBdLCBJVERf QlVGUFRSX0VQX01BU0ssIElURF9CVUZQVFJfRVBfU0gpKTsKKworICAgIHByaW50ZigiRGly ZWN0aW9uOiAgJXNcbiIsCisgICAgICAgICAgICBpdGQtPmJ1ZnB0clsxXSAmIElURF9CVUZQ VFJfRElSRUNUSU9OID8gIklOIiA6ICJPVVQiKTsKKworICAgIHByaW50ZigiTWF4IFBhY2tl dDogJWRcbiIsCisgICAgICAgICAgICBnZXRfZmllbGQoaXRkLT5idWZwdHJbMV0sIElURF9C VUZQVFJfTUFYUEtUX01BU0ssIDApKTsKKworICAgIHByaW50ZigiTXVsdDogICAgICAgJWRc biIsCisgICAgICAgICAgICBnZXRfZmllbGQoaXRkLT5idWZwdHJbMl0sIElURF9CVUZQVFJf TVVMVF9NQVNLLCAwKSk7CisKKyAgICBmb3IoaSA9IDA7IGkgPCA3OyBpKyspCisgICAgICAg IHByaW50ZigiQnVmIFB0ciAlZDogJTA1WFxuIiwgaSwgaXRkLT5idWZwdHJbaV0gPj4gMTIp OworfQorCisjZW5kaWYKKworI2lmIDAKK3N0YXRpYyBpbnQgdGltZWRfcHJpbnRmKGNvbnN0 IGNoYXIgKmZtdCwgLi4uKQoreworICAgIGludCBtc2VjLCB1c2VjOworICAgIHN0YXRpYyBp bnQgdXNlY19sYXN0OworICAgIHZhX2xpc3QgYXA7CisKKyAgICB1c2VjID0gcWVtdV9nZXRf Y2xvY2sodm1fY2xvY2spIC8gMTAwMDsKKworICAgIG1zZWMgPSB1c2VjIC0gdXNlY19sYXN0 OworICAgIHVzZWNfbGFzdCA9IHVzZWM7CisgICAgdXNlYyA9IG1zZWM7CisKKyAgICBtc2Vj IC89IDEwMDA7CisgICAgbXNlYyAlPSAxMDAwOworCisgICAgdXNlYyAlPSAxMDAwOworCisg ICAgdmFfc3RhcnQoYXAsIGZtdCk7CisgICAgcHJpbnRmKCIlMDNkLiUwM2QgIiwgbXNlYywg dXNlYyk7CisgICAgdnByaW50ZihmbXQsIGFwKTsKKyAgICB2YV9lbmQoYXApOworCisgICAg cmV0dXJuIDA7Cit9CisjZW5kaWYKKworc3RhdGljIGlubGluZSB2b2lkIGVoY2lfc2V0X2lu dGVycnVwdChFSENJU3RhdGUgKmVoY2ksIGludCBpbnRyKQoreworICAgIGludCBsZXZlbCA9 IDA7CisKKyAgICAvLyBUT0RPIGhvbm91ciBpbnRlcnJ1cHQgdGhyZXNob2xkIHJlcXVlc3Rz CisKKyAgICBlaGNpLT51c2JzdHMgfD0gaW50cjsKKworICAgIGlmICgoZWhjaS0+dXNic3Rz ICYgVVNCSU5UUl9NQVNLKSAmIGVoY2ktPnVzYmludHIpCisgICAgICAgIGxldmVsID0gMTsK KworI2lmZGVmIFRERUJVRworICAgIERFQlVHKCgiZWhjaTogc2V0dGluZyBpbnRlcnJ1cHQg bGV2ZWwgJWQoc3QvZW4pPSglMDJYLyUwMlgpXG4iLCBsZXZlbCwKKyAgICAgICAgICAgIGVo Y2ktPnVzYnN0cyAmIFVTQklOVFJfTUFTSywgZWhjaS0+dXNiaW50cikpOworI2VuZGlmCisg ICAgcWVtdV9zZXRfaXJxKGVoY2ktPmlycSwgbGV2ZWwpOworfQorCisvKiBBdHRhY2ggb3Ig ZGV0YWNoIGEgZGV2aWNlIG9uIHJvb3QgaHViICovCisKK3N0YXRpYyB2b2lkIGVoY2lfYXR0 YWNoKFVTQlBvcnQgKnBvcnQsIFVTQkRldmljZSAqZGV2KQoreworICAgIEVIQ0lTdGF0ZSAq cyA9IHBvcnQtPm9wYXF1ZTsKKyAgICB1aW50MzJfdCAqcG9ydHNjID0gJnMtPnBvcnRzY1tw b3J0LT5pbmRleF07CisKKyAgICBERUJVRygoImVoY2lfYXR0YWNoIGludm9rZWQgZm9yIGlu ZGV4ICVkLCBkZXNjICVzXG4iLAorICAgICAgICAgICBwb3J0LT5pbmRleCwgZGV2ID8gZGV2 LT5wcm9kdWN0X2Rlc2MgOiAidW5kZWZpbmVkIikpOworCisgICAgaWYgKGRldikgeworICAg ICAgICBpZiAocG9ydC0+ZGV2KSB7CisgICAgICAgICAgICB1c2JfYXR0YWNoKHBvcnQsIE5V TEwpOworICAgICAgICB9CisKKyAgICAgICAgKnBvcnRzYyB8PSBQT1JUU0NfQ09OTkVDVDsK KworICAgICAgICB1c2Jfc2VuZF9tc2coZGV2LCBVU0JfTVNHX0FUVEFDSCk7CisgICAgICAg IHBvcnQtPmRldiA9IGRldjsKKyAgICB9IGVsc2UgeworICAgICAgICAqcG9ydHNjICY9IH5Q T1JUU0NfQ09OTkVDVDsKKworICAgICAgICBpZiAocG9ydC0+ZGV2KSB7CisgICAgICAgICAg ICBkZXYgPSBwb3J0LT5kZXY7CisgICAgICAgICAgICB1c2Jfc2VuZF9tc2coZGV2LCBVU0Jf TVNHX0RFVEFDSCk7CisgICAgICAgIH0KKworICAgICAgICBwb3J0LT5kZXYgPSBOVUxMOwor ICAgIH0KKworICAgICpwb3J0c2MgfD0gUE9SVFNDX0NTQzsKKworICAgIC8qCisgICAgICog IElmIGEgaGlnaCBzcGVlZCBkZXZpY2UgaXMgYXR0YWNoZWQgdGhlbiB3ZSBvd24gdGhpcyBw b3J0KGluZGljYXRlZAorICAgICAqICBieSB6ZXJvIGluIHRoZSBQT1JUU0NfUE9XTkVSIGJp dCBmaWVsZCkgc28gc2V0IHRoZSBzdGF0dXMgYml0CisgICAgICogIGFuZCBzZXQgYW4gaW50 ZXJydXB0IGlmIGVuYWJsZWQuCisgICAgICovCisgICAgaWYgKCAhKCpwb3J0c2MgJiBQT1JU U0NfUE9XTkVSKSkgeworICAgICAgICBlaGNpX3NldF9pbnRlcnJ1cHQocywgVVNCU1RTX1BD RCk7CisgICAgfQorfQorCitzdGF0aWMgdm9pZCBlaGNpX3Jlc2V0KHZvaWQgKm9wYXF1ZSkK K3sKKyAgICBFSENJU3RhdGUgKnMgPSBvcGFxdWU7CisgICAgdWludDhfdCAqcGNpX2NvbmY7 CisgICAgaW50IGk7CisKKyAgICBERUJVRygoImVoY2lfcmVzZXRcbiIpKTsKKyAgICBwY2lf Y29uZiA9IHMtPmRldi5jb25maWc7CisKKyAgICBtZW1zZXQoJnMtPm1taW9bT1BSRUdCQVNF XSwgMHgwMCwgTU1JT19TSVpFIC0gT1BSRUdCQVNFKTsKKworICAgIHMtPnVzYmNtZCA9IE5C X01BWElOVFJBVEUgPDwgVVNCQ01EX0lUQ19TSDsKKyAgICBzLT51c2JzdHMgPSBVU0JTVFNf SEFMVDsKKworICAgIHMtPmFzdGF0ZSA9IEVTVF9JTkFDVElWRTsKKyAgICBzLT5wc3RhdGUg PSBFU1RfSU5BQ1RJVkU7CisgICAgcy0+YXN5bmNfcG9ydF9pbl9wcm9ncmVzcyA9IC0xOwor ICAgIHMtPmFzeW5jX2NvbXBsZXRlID0gMDsKKyAgICBzLT5pc29jaF9wYXVzZSA9IC0xOwor ICAgIHMtPmF0dGFjaF9wb2xsX2NvdW50ZXIgPSAwOworCisgICAgZm9yKGkgPSAwOyBpIDwg TkJfUE9SVFM7IGkrKykgeworICAgICAgICBzLT5wb3J0c2NbaV0gPSBQT1JUU0NfUE9XTkVS IHwgUE9SVFNDX1BQT1dFUjsKKworICAgICAgICBpZiAocy0+cG9ydHNbaV0uZGV2KQorICAg ICAgICAgICAgZWhjaV9hdHRhY2goJnMtPnBvcnRzW2ldLCBzLT5wb3J0c1tpXS5kZXYpOwor ICAgIH0KK30KKworc3RhdGljIHVpbnQzMl90IGVoY2lfbWVtX3JlYWRiKHZvaWQgKnB0ciwg dGFyZ2V0X3BoeXNfYWRkcl90IGFkZHIpCit7CisgICAgRUhDSVN0YXRlICpzID0gcHRyOwor ICAgIHVpbnQzMl90IHZhbDsKKworICAgIHZhbCA9IHMtPm1taW9bYWRkcl07CisgICAgREVC VUcoKCJtZW1fcmVhZGIgOiBhZGRyPTB4JTA4WCwgdmFsPSUwMlhcbiIsKGludClhZGRyLChp bnQpdmFsKSk7CisKKyAgICByZXR1cm4gdmFsOworfQorCitzdGF0aWMgdWludDMyX3QgZWhj aV9tZW1fcmVhZHcodm9pZCAqcHRyLCB0YXJnZXRfcGh5c19hZGRyX3QgYWRkcikKK3sKKyAg ICBFSENJU3RhdGUgKnMgPSBwdHI7CisgICAgdWludDMyX3QgdmFsOworCisgICAgdmFsID0g cy0+bW1pb1thZGRyXSB8KHMtPm1taW9bYWRkcisxXSA8PCA4KTsKKyAgICBERUJVRygoIm1l bV9yZWFkdyA6IGFkZHI9MHglMDhYLCB2YWw9MHglMDRYXG4iLChpbnQpYWRkciwoaW50KXZh bCkpOworCisgICAgcmV0dXJuIHZhbDsKK30KKworc3RhdGljIHVpbnQzMl90IGVoY2lfbWVt X3JlYWRsKHZvaWQgKnB0ciwgdGFyZ2V0X3BoeXNfYWRkcl90IGFkZHIpCit7CisgICAgRUhD SVN0YXRlICpzID0gcHRyOworICAgIHVpbnQzMl90IHZhbDsKKworICAgIHZhbCA9IHMtPm1t aW9bYWRkcl0gfChzLT5tbWlvW2FkZHIrMV0gPDwgOCkgfAorICAgICAgICAgIChzLT5tbWlv W2FkZHIrMl0gPDwgMTYpIHwocy0+bW1pb1thZGRyKzNdIDw8IDI0KTsKKworICAgIERFQlVH KCgiZWhjaV9tZW1fcmVhZGwgOiBhZGRyPTB4JTA4WCwgdmFsPTB4JTA4WFxuIiwodW5zaWdu ZWQpIGFkZHIsIHZhbCkpOworCisgICAgcmV0dXJuIHZhbDsKK30KKworc3RhdGljIHZvaWQg ZWhjaV9tZW1fd3JpdGViKHZvaWQgKnB0ciwgdGFyZ2V0X3BoeXNfYWRkcl90IGFkZHIsIHVp bnQzMl90IHZhbCkKK3sKKyAgICBwcmludGYoIkVIQ0kgZG9lc24ndCBoYW5kbGUgYnl0ZSB3 cml0ZXMgdG8gTU1JT1xuIik7CisgICAgZXhpdCgxKTsKK30KKworc3RhdGljIHZvaWQgZWhj aV9tZW1fd3JpdGV3KHZvaWQgKnB0ciwgdGFyZ2V0X3BoeXNfYWRkcl90IGFkZHIsIHVpbnQz Ml90IHZhbCkKK3sKKyAgICBwcmludGYoIkVIQ0kgZG9lc24ndCBoYW5kbGUgMTYtYml0IHdy aXRlcyB0byBNTUlPXG4iKTsKKyAgICBleGl0KDEpOworfQorCitzdGF0aWMgdm9pZCBoYW5k bGVfcG9ydF9zdGF0dXNfd3JpdGUoRUhDSVN0YXRlICpzLCBpbnQgcG9ydCwgdWludDMyX3Qg dmFsKQoreworICAgIHVpbnQzMl90ICpwb3J0c2MgPSAmcy0+cG9ydHNjW3BvcnRdOworICAg IGludCByd2M7CisgICAgVVNCRGV2aWNlICpkZXYgPSBzLT5wb3J0c1twb3J0XS5kZXY7CisK KyAgICBERUJVRygoIlBPUlRTQyAgJTA4WC0+JTA4WCAgcndjPSUwOFggIHJ3PSUwOFhcbiIs ICpwb3J0c2MsIHZhbCwKKyAgICAgICAgICAodmFsICYgUE9SVFNDX1JXQ19NQVNLKSwKKyAg ICAgICAgICAgdmFsICYgUE9SVFNDX1JPX01BU0spKTsKKworICAgIHJ3YyA9IHZhbCAmIFBP UlRTQ19SV0NfTUFTSzsKKyAgICB2YWwgJj0gUE9SVFNDX1JPX01BU0s7CisKKyAgICAvLyBo YW5kbGVfcmVhZF93cml0ZV9jbGVhcigmdmFsLCBwb3J0c2MsIFBPUlRTQ19QRURDIHwgUE9S VFNDX0NTQyk7CisKKyAgICAqcG9ydHNjICY9IH5yd2M7CisKKyAgICBERUJVRygoIlBPUlRT QyAgLT4gICUwOFhcbiIsICpwb3J0c2MpKTsKKworICAgIGlmICgodmFsICYgUE9SVFNDX1BS RVNFVCkgJiYgISgqcG9ydHNjICYgUE9SVFNDX1BSRVNFVCkpIHsKKyAgICAgICAgREVCVUco KCJVU0JUUkFOIFBvcnQgJWQgcmVzZXQgYmVnaW5cbiIsIHBvcnQpKTsKKyAgICB9CisKKyAg ICBpZiAoISh2YWwgJiBQT1JUU0NfUFJFU0VUKSAmJigqcG9ydHNjICYgUE9SVFNDX1BSRVNF VCkpIHsKKyAgICAgICAgREVCVUcoKCJVU0JUUkFOIFBvcnQgJWQgcmVzZXQgZG9uZVxuIiwg cG9ydCkpOworICAgICAgICBlaGNpX2F0dGFjaCgmcy0+cG9ydHNbcG9ydF0sIGRldik7CisK KyAgICAgICAgLy8gVE9ETyBob3cgdG8gaGFuZGxlIHJlc2V0IG9mIHBvcnRzIHdpdGggbm8g ZGV2aWNlCisgICAgICAgIGlmIChkZXYpCisgICAgICAgICAgICB1c2Jfc2VuZF9tc2coZGV2 LCBVU0JfTVNHX1JFU0VUKTsKKworICAgICAgICBpZiAocy0+cG9ydHNbcG9ydF0uZGV2KSB7 CisgICAgICAgICAgICBERUJVRygoIkRldmljZSB3YXMgY29ubmVjdGVkIGJlZm9yZSByZXNl dCwgY2xlYXJpbmcgQ1NDIGJpdFxuIikpOworICAgICAgICAgICAgKnBvcnRzYyAmPSB+UE9S VFNDX0NTQzsKKyAgICAgICAgfQorCisgICAgICAgIC8qICBUYWJsZSAyLjE2IFNldCB0aGUg ZW5hYmxlIGJpdChhbmQgZW5hYmxlIGJpdCBjaGFuZ2UpIHRvIGluZGljYXRlCisgICAgICAg ICAqICB0byBTVyB0aGF0IHRoaXMgcG9ydCBoYXMgYSBoaWdoIHNwZWVkIGRldmljZSBhdHRh Y2hlZAorICAgICAgICAgKgorICAgICAgICAgKiAgVE9ETyAtIHdoZW4gdG8gZGlzYWJsZT8K KyAgICAgICAgICovCisgICAgICAgIHZhbCB8PSBQT1JUU0NfUEVEOworICAgICAgICB2YWwg fD0gUE9SVFNDX1BFREM7CisgICAgfQorCisgICAgKnBvcnRzYyAmPSB+UE9SVFNDX1JPX01B U0s7CisgICAgKnBvcnRzYyB8PSB2YWw7CisgICAgREVCVUcoKCJQb3J0IHN0YXR1cyBzZXQg dG8gMHglMDh4XG4iLCAqcG9ydHNjKSk7Cit9CisKK3N0YXRpYyB2b2lkIGVoY2lfbWVtX3dy aXRlbCh2b2lkICpwdHIsIHRhcmdldF9waHlzX2FkZHJfdCBhZGRyLCB1aW50MzJfdCB2YWwp Cit7CisgICAgRUhDSVN0YXRlICpzID0gcHRyOworICAgIGludCBpOworCisgICAgLyogT25s eSBhbGlnbmVkIHJlYWRzIGFyZSBhbGxvd2VkIG9uIE9IQ0kgKi8KKyAgICBpZiAoYWRkciAm IDMpIHsKKyAgICAgICAgcHJpbnRmKCJ1c2ItZWhjaTogTWlzLWFsaWduZWQgd3JpdGVcbiIp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKGFkZHIgPj0gUE9SVFNDICYm IGFkZHIgPCBQT1JUU0MgKyA0ICogTkJfUE9SVFMpIHsKKyAgICAgICAgREVCVUcoKCJlaGNp X21lbV93cml0ZWwgOiBQT1JUU0MlZC0+MHglMDhYIFxuIiwKKyAgICAgICAgICAgICAgIChp bnQpKGFkZHItUE9SVFNDKS80LCB2YWwpKTsKKyAgICAgICAgaGFuZGxlX3BvcnRfc3RhdHVz X3dyaXRlKHMsIChhZGRyLVBPUlRTQykvNCwgdmFsKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKworICAgIC8qIERvIGFueSByZWdpc3RlciBzcGVjaWZpYyBwcmUtd3JpdGUgcHJvY2Vz c2luZyBoZXJlLiAgKi8KKworICAgIHN3aXRjaChhZGRyKQorICAgIHsKKyAgICBjYXNlIFVT QkNNRDoKKyAgICAgICAgaWYgKCh2YWwgJiBVU0JDTURfUlVOU1RPUCkgJiYgIShzLT51c2Jj bWQgJiBVU0JDTURfUlVOU1RPUCkpIHsKKyAgICAgICAgICAgIERFQlVHKCgiZWhjaV9tZW1f d3JpdGVsIDogVVNCQ01EIHJ1biwgY2xlYXIgaGFsdFxuIikpOworICAgICAgICAgICAgLy8g cHJpbnRmKCJDYWxsIG1vZF90aW1lciBmb3IgJXBcbiIsIHMtPmZyYW1lX3RpbWVyKTsKKyAg ICAgICAgICAgIHFlbXVfbW9kX3RpbWVyKHMtPmZyYW1lX3RpbWVyLCBxZW11X2dldF9jbG9j ayh2bV9jbG9jaykpOworICAgICAgICAgICAgcy0+bGFzdF9ydW5fdXNlYyA9IHFlbXVfZ2V0 X2Nsb2NrKHZtX2Nsb2NrKSAvIDEwMDA7CisgICAgICAgICAgICBzLT51c2JzdHMgJj0gflVT QlNUU19IQUxUOworICAgICAgICB9CisKKyAgICAgICAgaWYgKCEodmFsICYgVVNCQ01EX1JV TlNUT1ApICYmKHMtPnVzYmNtZCAmIFVTQkNNRF9SVU5TVE9QKSkgeworICAgICAgICAgICAg REVCVUcoKCJlaGNpX21lbV93cml0ZWwgOiBVU0JDTUQgICoqIFNUT1AgKipcbiIpKTsKKyAg ICAgICAgICAgIC8vIHByaW50ZigiQ2FsbCBkZWxfdGltZXIgZm9yICVwXG4iLCBzLT5mcmFt ZV90aW1lcik7CisjaWYgMAorICAgICAgICAgICAgcWVtdV9kZWxfdGltZXIocy0+ZnJhbWVf dGltZXIpOworI2VuZGlmCisgICAgICAgICAgICAvLyBUT0RPIC0gc2hvdWxkIGZpbmlzaCBv dXQgc29tZSBzdHVmZiBiZWZvcmUgc2V0dGluZyBoYWx0CisgICAgICAgICAgICBzLT51c2Jz dHMgfD0gVVNCU1RTX0hBTFQ7CisgICAgICAgIH0KKworICAgICAgICBpZiAodmFsICYgVVNC Q01EX0hDUkVTRVQpIHsKKyAgICAgICAgICAgIERFQlVHKCgiZWhjaV9tZW1fd3JpdGVsIDog VVNCQ01EIHJlc2V0dGluZyAuLi5cbiIpKTsKKyAgICAgICAgICAgIGVoY2lfcmVzZXQocyk7 CisgICAgICAgICAgICBERUJVRygoImVoY2lfbWVtX3dyaXRlbDogVVNCQ01EIHJlc2V0IGRv bmUsIGNsZWFyIHJlc2V0IHJlcXVlc3QgYml0XG4iKSk7CisgICAgICAgICAgICB2YWwgJj0g flVTQkNNRF9IQ1JFU0VUOworICAgICAgICB9CisKKyAgICAgICAgYnJlYWs7CisKKyAgICBj YXNlIFVTQlNUUzoKKyAgICAgICAgdmFsICY9IFVTQlNUU19ST19NQVNLOyAgICAgICAgICAg ICAgLy8gYml0cyA2IHRocnUgMzEgYXJlIFJPCisgICAgICAgIERFQlVHKCgiZWhjaV9tZW1f d3JpdGVsIDogVVNCU1RTIFJXQyBzZXQgdG8gMHglMDhYXG4iLCB2YWwpKTsKKworICAgICAg ICB2YWwgPShzLT51c2JzdHMgJj0gfnZhbCk7ICAgICAgICAgLy8gYml0cyAwIHRocnUgNSBh cmUgUi9XQworICAgICAgICBERUJVRygoImVoY2lfbWVtX3dyaXRlbCA6IFVTQlNUUyB1cGRh dGluZyBpbnRlcnJ1cHQgY29uZGl0aW9uXG4iKSk7CisgICAgICAgIGVoY2lfc2V0X2ludGVy cnVwdChzLCAwKTsKKworICAgICAgICBicmVhazsKKworICAgIGNhc2UgVVNCSU5UUjoKKyAg ICAgICAgdmFsICY9IFVTQklOVFJfTUFTSzsKKyAgICAgICAgLy8gREVCVUcoKCJlaGNpX21l bV93cml0ZWwgOiBVU0JJTlRSIHNldCB0byAweCUwOFhcbiIsIHZhbCkpOworICAgICAgICBi cmVhazsKKworICAgIGNhc2UgRlJJTkRFWDoKKyAgICAgICAgcy0+c29mdiA9IHZhbCA+PiAz OworICAgICAgICBicmVhazsKKworICAgIGNhc2UgQ09ORklHRkxBRzoKKyAgICAgICAgdmFs ICY9IDB4MTsKKworICAgICAgICBpZiAodmFsKSB7CisgICAgICAgICAgICBmb3IoaSA9IDA7 IGkgPCBOQl9QT1JUUzsgaSsrKQorICAgICAgICAgICAgICAgIHMtPnBvcnRzY1tpXSAmPSB+ UE9SVFNDX1BPV05FUjsKKyAgICAgICAgfQorCisgICAgICAgIGJyZWFrOworICAgIH0KKwor ICAgIGlmIChhZGRyICE9IDB4MjgpIHsKKyAgICAgICAgREVCVUcoKCJlaGNpX21lbV93cml0 ZWwgOiBhZGRyPTB4JTA4WCwgdmFsPTB4JTA4WFxuIiwodW5zaWduZWQpIGFkZHIsIHZhbCkp OworICAgIH0KKworICAgICoodWludDMyX3QgKikoJnMtPm1taW9bYWRkcl0pID0gdmFsOwor fQorCisKKy8vIFRPRE8gOiBQdXQgaW4gY29tbW9uIGhlYWRlciBmaWxlLCBkdXBsaWNhdGlv biBmcm9tIHVzYi1vaGNpLmMKKworLyogR2V0IGFuIGFycmF5IG9mIGR3b3JkcyBmcm9tIG1h aW4gbWVtb3J5ICovCitzdGF0aWMgaW5saW5lIGludCBnZXRfZHdvcmRzKHVpbnQzMl90IGFk ZHIsIHVpbnQzMl90ICpidWYsIGludCBudW0pCit7CisgICAgaW50IGk7CisKKyAgICBmb3Io aSA9IDA7IGkgPCBudW07IGkrKywgYnVmKyssIGFkZHIgKz0gc2l6ZW9mKCpidWYpKSB7Cisg ICAgICAgIGNwdV9waHlzaWNhbF9tZW1vcnlfcncoYWRkciwodWludDhfdCAqKWJ1Ziwgc2l6 ZW9mKCpidWYpLCAwKTsKKyAgICAgICAgKmJ1ZiA9IGxlMzJfdG9fY3B1KCpidWYpOworICAg IH0KKworICAgIHJldHVybiAxOworfQorCisvKiBQdXQgYW4gYXJyYXkgb2YgZHdvcmRzIGlu IHRvIG1haW4gbWVtb3J5ICovCitzdGF0aWMgaW5saW5lIGludCBwdXRfZHdvcmRzKHVpbnQz Ml90IGFkZHIsIHVpbnQzMl90ICpidWYsIGludCBudW0pCit7CisgICAgaW50IGk7CisKKyAg ICBmb3IoaSA9IDA7IGkgPCBudW07IGkrKywgYnVmKyssIGFkZHIgKz0gc2l6ZW9mKCpidWYp KSB7CisgICAgICAgIHVpbnQzMl90IHRtcCA9IGNwdV90b19sZTMyKCpidWYpOworICAgICAg ICBjcHVfcGh5c2ljYWxfbWVtb3J5X3J3KGFkZHIsKHVpbnQ4X3QgKikmdG1wLCBzaXplb2Yo dG1wKSwgMSk7CisgICAgfQorCisgICAgcmV0dXJuIDE7Cit9CisKKy8vIDQuMTAuMgorCitz dGF0aWMgdm9pZCBlaGNpX3FoX2RvX292ZXJsYXkoRUhDSVN0YXRlICplaGNpLCBFSENJcWgg KnFoLCBFSENJcXRkICpxdGQpCit7CisgICAgaW50IGk7CisgICAgaW50IGR0b2dnbGU7Cisg ICAgaW50IHBpbmc7CisKKyAgICAvLyByZW1lbWJlciB2YWx1ZXMgaW4gZmllbGRzIHRvIHBy ZXNlcnZlIGluIHFoIGFmdGVyIG92ZXJsYXkKKworICAgIGR0b2dnbGUgPSBxaC0+dG9rZW4g JiBRVERfVE9LRU5fRFRPR0dMRTsKKyAgICBwaW5nID0gcWgtPnRva2VuICYgUVREX1RPS0VO X1BJTkc7CisKKyAgICBERUJVRygoInNldHRpbmcgcWguY3VycmVudCBmcm9tICUwOFggdG8g MHglMDhYXG4iLCBxaC0+Y3VycmVudCwKKyAgICAgICAgICAgIGVoY2ktPnF0ZGFkZHIpKTsK KyAgICBxaC0+Y3VycmVudCAgPSBlaGNpLT5xdGRhZGRyOworICAgIHFoLT5xdGRuZXh0ICA9 IHF0ZC0+bmV4dDsKKyAgICBxaC0+YWx0bmV4dCAgPSBxdGQtPmFsdG5leHQ7CisgICAgcWgt PnRva2VuICAgID0gcXRkLT50b2tlbjsKKworICAgIGlmIChxaC0+Y3VycmVudCA8IDB4MTAw MCkgeworI2lmZGVmIERFQlVHX1BBQ0tFVAorICAgICAgICBkdW1wX3FoKHFoLCBxaC0+Y3Vy cmVudCk7CisjZW5kaWYKKyAgICAgICAgQVNTRVJUKDE9PTIpOworICAgIH0KKworICAgIGlm ICgoKHFoLT5lcGNoYXIgJiBRSF9FUENIQVJfRVBTX01BU0spID4+IFFIX0VQQ0hBUl9FUFNf U0gpID09IDIpIHsKKyAgICAgICAgcWgtPnRva2VuICY9IH5RVERfVE9LRU5fUElORzsKKyAg ICAgICAgcWgtPnRva2VuIHw9IHBpbmc7CisgICAgfQorCisgICAgZm9yIChpID0gMDsgaSA8 IDU7IGkrKykKKyAgICAgICAgcWgtPmJ1ZnB0cltpXSA9IHF0ZC0+YnVmcHRyW2ldOworCisg ICAgaWYgKCEocWgtPmVwY2hhciAmIFFIX0VQQ0hBUl9EVEMpKSB7CisgICAgICAgIC8vIHBy ZXNlcnZlIFFIIERUIGJpdAorICAgICAgICBxaC0+dG9rZW4gJj0gflFURF9UT0tFTl9EVE9H R0xFOworICAgICAgICBxaC0+dG9rZW4gfD0gZHRvZ2dsZTsKKyAgICB9CisKKyAgICBxaC0+ YnVmcHRyWzFdICY9IH5CVUZQVFJfQ1BST0dNQVNLX01BU0s7CisgICAgcWgtPmJ1ZnB0clsy XSAmPSB+QlVGUFRSX0ZSQU1FVEFHX01BU0s7CisKKyAgICAvLyBUT0RPIE5ha0NudAorfQor CitzdGF0aWMgdm9pZCBlaGNpX2J1ZmZlcl9ydyhFSENJU3RhdGUgKmVoY2ksIEVIQ0lxaCAq cWgsIGludCBieXRlcywgaW50IHJ3KQoreworICAgIGludCBidWZwb3MgPSAwOworICAgIGlu dCBjcGFnZTsKKyAgICB1aW50MzJfdCBoZWFkOworICAgIHVpbnQzMl90IHRhaWw7CisKKyAg ICBjcGFnZSA9IGdldF9maWVsZChxaC0+dG9rZW4sIFFURF9UT0tFTl9DUEFHRV9NQVNLLCBR VERfVE9LRU5fQ1BBR0VfU0gpOworICAgIEFTU0VSVChjcGFnZSA9PSAwKTsKKworICAgIERF QlVHKCgiZXhlYzogJXNpbmcgJWQgYnl0ZXMgdG8vZnJvbSAlMDh4XG4iLAorICAgICAgICAg ICBydyA/ICJ3cml0IiA6ICJyZWFkIiwgYnl0ZXMsIHFoLT5idWZwdHJbMF0pKTsKKworICAg IGlmICghYnl0ZXMpCisgICAgICAgIHJldHVybjsKKworICAgIGRvIHsKKyAgICAgICAgaGVh ZCA9IHFoLT5idWZwdHJbY3BhZ2VdOworICAgICAgICB0YWlsID0ocWgtPmJ1ZnB0cltjcGFn ZV0gJiAweGZmZmZmMDAwKSArIDB4MTAwMDsKKworICAgICAgICBpZiAoYnl0ZXMgPD0odGFp bCAtIGhlYWQpKQorICAgICAgICAgICAgdGFpbCA9IGhlYWQgKyBieXRlczsKKworICAgICAg ICBERUJVRygoIkRBVEEgJXMgY3BhZ2U6JWQgaGVhZDolMDhYIHRhaWw6JTA4WCB0YXJnZXQ6 JTA4WFxuIiwKKyAgICAgICAgICAgICAgICBydyA/ICJXUklURSIgOiAiUkVBRCAiLCBjcGFn ZSwgaGVhZCwgdGFpbCwgYnVmcG9zKSk7CisKKyAgICAgICAgQVNTRVJUKGJ1ZnBvcyArIHRh aWwgLSBoZWFkIDw9IEJVRkZfU0laRSk7CisgICAgICAgIEFTU0VSVCh0YWlsIC0gaGVhZCA+ IDApOworCisgICAgICAgIGNwdV9waHlzaWNhbF9tZW1vcnlfcncocWgtPmJ1ZnB0cltjcGFn ZV0sICZlaGNpLT5idWZmZXJbYnVmcG9zXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdGFpbCAtIGhlYWQsIHJ3KTsKKworICAgICAgICBidWZwb3MgKz0odGFpbCAtIGhl YWQpOworICAgICAgICBieXRlcyAtPSh0YWlsIC0gaGVhZCk7CisKKyAgICAgICAgcWgtPmJ1 ZnB0cltjcGFnZV0gKz0odGFpbCAtIGhlYWQpOworCisgICAgICAgIGlmIChieXRlcyA+IDAp CisgICAgICAgICAgICBjcGFnZSsrOworICAgIH0gd2hpbGUgKGJ5dGVzID4gMCk7CisKKyAg ICBzZXRfZmllbGQoJnFoLT50b2tlbiwgY3BhZ2UsIFFURF9UT0tFTl9DUEFHRV9NQVNLLCBR VERfVE9LRU5fQ1BBR0VfU0gpOworfQorCitzdGF0aWMgdm9pZCBlaGNpX2FzeW5jX2NvbXBs ZXRlX3BhY2tldChVU0JQYWNrZXQgKnBhY2tldCwgdm9pZCAqb3BhcXVlKQoreworICAgIEVI Q0lTdGF0ZSAqZWhjaSA9IG9wYXF1ZTsKKyNpZmRlZiBERUJVR19QQUNLRVQKKyAgICBkcHJp bnRmKCJBc3luYyBwYWNrZXQgY29tcGxldGVcbiIpOworI2VuZGlmCisgICAgZWhjaS0+YXN5 bmNfY29tcGxldGUgPSAxOworICAgIGVoY2ktPmV4ZWNfc3RhdHVzID0gcGFja2V0LT5sZW47 Cit9CisKK3N0YXRpYyBpbnQgZWhjaV9leGVjdXRlX2NvbXBsZXRlKEVIQ0lTdGF0ZSAqZWhj aSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFSENJcWggKnFoLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludCByZXQpCit7CisgICAgaWYgKHJl dCA9PSBVU0JfUkVUX0FTWU5DICYmICFlaGNpLT5hc3luY19jb21wbGV0ZSkgeworICAgICAg ICBERUJVRygoIm5vdCBkb25lIHlldFxuIikpOworICAgICAgICByZXR1cm4gcmV0OworICAg IH0KKworICAgIGVoY2ktPmFzeW5jX2NvbXBsZXRlID0gMDsKKyAgICBlaGNpLT5hc3luY19w b3J0X2luX3Byb2dyZXNzID0gLTE7CisKKyAgICBpZiAocmV0IDwgMCkgeworICAgICAgICBz d2l0Y2gocmV0KSB7CisgICAgICAgIGNhc2UgVVNCX1JFVF9OT0RFVjoKKyAgICAgICAgICAg IHByaW50ZigiVVNCIG5vIGRldmljZVxuIik7CisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgY2FzZSBVU0JfUkVUX1NUQUxMOgorICAgICAgICAgICAgcHJpbnRmKCJVU0Igc3RhbGxc biIpOworICAgICAgICAgICAgcWgtPnRva2VuIHw9IFFURF9UT0tFTl9IQUxUOworICAgICAg ICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVNCX1JFVF9OQUs6CisgICAgICAgICAgICBE RUJVRygoIlVTQlRSQU4gUlNQIE5BSywgcmV0dXJuaW5nIHdpdGhvdXQgY2xlYXIgYWN0aXZl XG4iKSk7CisgICAgICAgICAgICByZXR1cm4gVVNCX1JFVF9OQUs7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgY2FzZSBVU0JfUkVUX0JBQkJMRToKKyAgICAgICAgICAgIHByaW50 ZigiVVNCIGJhYmJsZSBUT0RPXG4iKTsKKyAgICAgICAgICAgIEFTU0VSVChyZXQgPj0gMCk7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIHBy aW50ZigiVVNCIGludmFsaWQgcmVzcG9uc2UgJWQgdG8gaGFuZGxlXG4iLAorICAgICAgICAg ICAgICAgICAgICByZXQpOworICAgICAgICAgICAgQVNTRVJUKHJldCA+PSAwKTsKKyAgICAg ICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfSBlbHNlIHsKKyAgICAgICAgLy8gaWYg KHJldCA8IG1heHBrdCkKKyAgICAgICAgLy8geworICAgICAgICAvLyAgICAgREVCVUcoKCJT aG9ydCBwYWNrZXQgY29uZGl0aW9uXG4iKSk7CisgICAgICAgIC8vICAgICAvLyBUT0RPIGNo ZWNrIDQuMTIgZm9yIHNwbGl0cworICAgICAgICAgLy8gfQorCisgICAgICAgIGlmIChlaGNp LT50Ynl0ZXMgJiYgZWhjaS0+cGlkID09IFVTQl9UT0tFTl9JTikgeworICAgICAgICAgICAg QVNTRVJUKHJldCA+IDApOworICAgICAgICAgICAgZWhjaV9idWZmZXJfcncoZWhjaSwgcWgs IHJldCwgMSk7CisjaWZkZWYgVERFQlVHCisgICAgICAgICAgICBwcmludGYoIkRhdGEgYWZ0 ZXIgZXhlY3V0aW9uOlxuIik7CisgICAgICAgICAgICAvLyBkdW1wX2RhdGEoZWhjaS0+YnVm ZmVyLCBlaGNpLT50Ynl0ZXMgPCA2NCA/IGVoY2ktPnRieXRlcyA6IDY0KTsKKyAgICAgICAg ICAgIC8vIGRlY29kZV9kYXRhKGVoY2ktPnBpZCwgZWhjaS0+YnVmZmVyLCByZXQpOworI2Vu ZGlmCisgICAgICAgICAgICBlaGNpLT50Ynl0ZXMgLT0gcmV0OworICAgICAgICB9IGVsc2UK KyAgICAgICAgICAgIGVoY2ktPnRieXRlcyA9IDA7CisKKyAgICAgICAgQVNTRVJUKGVoY2kt PnRieXRlcyA+PSAwKTsKKworICAgICAgICBzZXRfZmllbGQoJnFoLT50b2tlbiwgZWhjaS0+ dGJ5dGVzLAorICAgICAgICAgICAgICAgICAgIFFURF9UT0tFTl9UQllURVNfTUFTSywgUVRE X1RPS0VOX1RCWVRFU19TSCk7CisgICAgfQorCisgICAgcWgtPnRva2VuIF49IFFURF9UT0tF Tl9EVE9HR0xFOworICAgIHFoLT50b2tlbiAmPSB+UVREX1RPS0VOX0FDVElWRTsKKworICAg IGlmIChxaC0+dG9rZW4gJiBRVERfVE9LRU5fSU9DKSB7CisgICAgICAgIC8vIFRPRE8gc2hv dWxkIGRvIHRoaXMgYWZ0ZXIgd3JpdGViYWNrIHRvIG1lbW9yeQorICAgICAgICBlaGNpX3Nl dF9pbnRlcnJ1cHQoZWhjaSwgVVNCU1RTX0lOVCk7CisgICAgfQorI2lmZGVmIERFQlVHX1BB Q0tFVAorICAgIERFQlVHKCgiUUggYWZ0ZXIgZXhlY3V0ZTotXG4iKSk7CisgICAgZHVtcF9x aChxaCwgTkxQVFJfR0VUKGVoY2ktPnFoYWRkcikpOworI2VuZGlmCisKKyNpZmRlZiBUREVC VUcKKyAgICBwcmludGYoIlVTQlRSQU4gUlNQICUzZCAgICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuOiglNWQpICIsCisgICAgICAgICAgICB0cmFuc2FjdGlkLAorICAgICAgICAg ICAgcmV0KTsKKworICAgIGlmIChlaGNpLT5waWQgPT0gVVNCX1RPS0VOX0lOKSB7CisgICAg ICAgIHByaW50ZigiWyUwMlggJTAyWCAlMDJYICUwMlggLi4uXVxuIiwKKyAgICAgICAgICAg ICplaGNpLT5idWZmZXIsICooZWhjaS0+YnVmZmVyKzEpLAorICAgICAgICAgICAgKihlaGNp LT5idWZmZXIrMiksICooZWhjaS0+YnVmZmVyKzMpKTsKKyAgICB9CisgICAgZWxzZQorICAg ICAgICBwcmludGYoIlxuIik7CisjZW5kaWYKKyAgICByZXR1cm4gcmV0OworfQorCisvLyA0 LjEwLjMKKworc3RhdGljIGludCBlaGNpX2V4ZWN1dGUoRUhDSVN0YXRlICplaGNpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICB1aW50MzJfdCBxaGFkZHIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgIEVIQ0lxaCAqcWgpCit7CisgICAgVVNCUG9ydCAqcG9ydDsKKyAgICBV U0JEZXZpY2UgKmRldjsKKyAgICBpbnQgc21hc2s7CisgICAgaW50IG1heHBrdDsKKyAgICBp bnQgcmV0OworICAgIGludCBpOworICAgIGludCBlbmRwOworICAgIGludCBkZXZhZHI7CisK KyAgICBzbWFzayA9IFFIX0VQQ0FQX1NNQVNLX01BU0sgJiBxaC0+ZXBjYXA7CisgICAgZWhj aS0+dGJ5dGVzID0ocWgtPnRva2VuICYgUVREX1RPS0VOX1RCWVRFU19NQVNLKSA+PiBRVERf VE9LRU5fVEJZVEVTX1NIOworICAgIGVoY2ktPnBpZCA9KHFoLT50b2tlbiAmIFFURF9UT0tF Tl9QSURfTUFTSykgPj4gUVREX1RPS0VOX1BJRF9TSDsKKyAgICBtYXhwa3QgPSBnZXRfZmll bGQocWgtPmVwY2hhciwgUUhfRVBDSEFSX01QTEVOX01BU0ssIFFIX0VQQ0hBUl9NUExFTl9T SCk7CisgICAgZW5kcCA9IGdldF9maWVsZChxaC0+ZXBjaGFyLCBRSF9FUENIQVJfRVBfTUFT SywgUUhfRVBDSEFSX0VQX1NIKTsKKyAgICBkZXZhZHIgPSBnZXRfZmllbGQocWgtPmVwY2hh ciwgUUhfRVBDSEFSX0RFVkFERFJfTUFTSywgMCk7CisKKyAgICBpZiAoICEocWgtPnRva2Vu ICYgUVREX1RPS0VOX0FDVElWRSkpIHsKKyAgICAgICAgcHJpbnRmKCJBdHRlbXB0aW5nIHRv IGV4ZWN1dGUgaW5hY3RpdmUgUUhcbiIpOworICAgICAgICBleGl0KDEpOzsKKyAgICB9CisK KyAgICBpZiAoc21hc2spIHsKKyAgICAgICAgREVCVUcoKCJhY3RpdmUgaW50ZXJydXB0IHRy YW5zZmVyIGZyaW5kZXggJWQgZm9yIGRldiAlZCBFUCAlZFxuIiwKKyAgICAgICAgICAgICAg ICBlaGNpLT5mcmluZGV4LCBkZXZhZHIsIGVuZHApKTsKKyAgICAgICAgLy8gVE9ETyBhcmUg aW50ZXJydXB0IGFsd2F5cyBJTiA/CisgICAgICAgIGVoY2ktPnBpZCA9IFVTQl9UT0tFTl9J TjsKKyAgICB9IGVsc2UgeworICAgICAgICBERUJVRygoIkFjdGl2ZSBub24taW50ZXJydXB0 IFFILCBleGVjdXRpbmdcbiIpKTsKKworICAgICAgICBERUJVRygoInBpZCBpcyAlMlhcbiIs IGVoY2ktPnBpZCkpOworCisgICAgICAgIHN3aXRjaChlaGNpLT5waWQpIHsKKyAgICAgICAg Y2FzZSAwOiBlaGNpLT5waWQgPSBVU0JfVE9LRU5fT1VUOyBicmVhazsKKyAgICAgICAgY2Fz ZSAxOiBlaGNpLT5waWQgPSBVU0JfVE9LRU5fSU47IGJyZWFrOworICAgICAgICBjYXNlIDI6 IGVoY2ktPnBpZCA9IFVTQl9UT0tFTl9TRVRVUDsgYnJlYWs7CisgICAgICAgIGRlZmF1bHQ6 IHByaW50ZigiYmFkIHRva2VuXG4iKTsgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAg ICAvLyBUT0RPIHNldCByZWNsYW0KKworI2lmZGVmIERFQlVHX1BBQ0tFVAorICAgIERFQlVH KCgiUUggYmVmb3JlIGV4ZWN1dGU6LVxuIikpOworICAgIGR1bXBfcWgocWgsIE5MUFRSX0dF VChxaGFkZHIpKTsKKyNlbmRpZgorCisgICAgaWYgKGVoY2ktPnRieXRlcyAmJiBlaGNpLT5w aWQgIT0gVVNCX1RPS0VOX0lOKSB7CisgICAgICAgIGVoY2lfYnVmZmVyX3J3KGVoY2ksIHFo LCBlaGNpLT50Ynl0ZXMsIDApOworI2lmZGVmIFRERUJVRworICAgICAgICBwcmludGYoIkRh dGEgYmVmb3JlIGV4ZWN1dGlvbjpcbiIpOworICAgICAgICAvLyBkdW1wX2RhdGEoZWhjaS0+ YnVmZmVyLCBlaGNpLT50Ynl0ZXMgPCA2NCA/IGVoY2ktPnRieXRlcyA6IDY0KTsKKyAgICAg ICAgLy8gZGVjb2RlX2RhdGEoZWhjaS0+cGlkLCBlaGNpLT5idWZmZXIsIGVoY2ktPnRieXRl cyk7CisjZW5kaWYKKyAgICB9CisKKyNpZmRlZiBUREVCVUcKKyAgICBwcmludGYoIlxuVVNC VFJBTiBSRVEgJTNkIGRldjolZCBlcDolZCBwaWQ6JTAyWCAlcyBieXRlczooJTVkKSAiLAor ICAgICAgICAgICAgKyt0cmFuc2FjdGlkLAorICAgICAgICAgICAgZGV2YWRyLAorICAgICAg ICAgICAgZW5kcCwKKyAgICAgICAgICAgIGVoY2ktPnBpZCwKKyAgICAgICAgICAgKGVoY2kt PnBpZCA9PSBVU0JfVE9LRU5fU0VUVVAgPyAiKFNFVFVQKSIgOgorICAgICAgICAgICAoZWhj aS0+cGlkID09IFVTQl9UT0tFTl9JTiA/ICIoSU4pICAgIiA6CisgICAgICAgICAgIChlaGNp LT5waWQgPT0gVVNCX1RPS0VOX09VVCA/ICIoT1VUKSAgIiA6ICIoKioqKiopIikpKSwKKyAg ICAgICAgICAgIGVoY2ktPnRieXRlcyk7CisKKyAgICBpZiAoZWhjaS0+cGlkICE9IFVTQl9U T0tFTl9JTikgeworICAgICAgICBwcmludGYoIlslMDJYICUwMlggJTAyWCAlMDJYIC4uLl1c biIsCisgICAgICAgICAgICAqZWhjaS0+YnVmZmVyLCAqKGVoY2ktPmJ1ZmZlcisxKSwKKyAg ICAgICAgICAgICooZWhjaS0+YnVmZmVyKzIpLCAqKGVoY2ktPmJ1ZmZlciszKSk7CisgICAg fQorICAgIGVsc2UKKyAgICAgICAgcHJpbnRmKCJcbiIpOworI2VuZGlmCisKKyAgICByZXQg PSBVU0JfUkVUX05PREVWOworCisgICAgZm9yKGkgPSAwOyBpIDwgTkJfUE9SVFM7IGkrKykg eworICAgICAgICBwb3J0ID0gJmVoY2ktPnBvcnRzW2ldOworICAgICAgICBkZXYgPSBwb3J0 LT5kZXY7CisKKyAgICAgICAgLy8gVE9ETyBzb21ldGltZSB3ZSB3aWxsIGFsc28gbmVlZCB0 byBjaGVjayBpZiB3ZSBhcmUgdGhlIHBvcnQgb3duZXIKKworICAgICAgICBpZiAoIShlaGNp LT5wb3J0c2NbaV0gJihQT1JUU0NfQ09OTkVDVCkpKSB7CisgICAgICAgICAgICBERUJVRygo IlBvcnQgJWQsIG5vIGV4ZWMsIG5vdCBjb25uZWN0ZWQoJTA4WClcbiIsCisgICAgICAgICAg ICAgICAgICAgIGksIGVoY2ktPnBvcnRzY1tpXSkpOworICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgIH0KKworICAgICAgICBlaGNpLT51c2JfcGFja2V0LnBpZCA9IGVoY2ktPnBp ZDsKKyAgICAgICAgZWhjaS0+dXNiX3BhY2tldC5kZXZhZGRyID0gZGV2YWRyOworICAgICAg ICBlaGNpLT51c2JfcGFja2V0LmRldmVwID0gZW5kcDsKKyAgICAgICAgZWhjaS0+dXNiX3Bh Y2tldC5kYXRhID0gZWhjaS0+YnVmZmVyOworICAgICAgICBlaGNpLT51c2JfcGFja2V0Lmxl biA9IGVoY2ktPnRieXRlczsKKyAgICAgICAgZWhjaS0+dXNiX3BhY2tldC5jb21wbGV0ZV9j YiA9IGVoY2lfYXN5bmNfY29tcGxldGVfcGFja2V0OworICAgICAgICBlaGNpLT51c2JfcGFj a2V0LmNvbXBsZXRlX29wYXF1ZSA9IGVoY2k7CisKKyAgICAgICAgREVCVUcoKCJjYWxsaW5n IGRldi0+aW5mby0+aGFuZGxlX3BhY2tldFxuIikpOworICAgICAgICByZXQgPSBkZXYtPmlu Zm8tPmhhbmRsZV9wYWNrZXQoZGV2LCAmZWhjaS0+dXNiX3BhY2tldCk7CisKKyAgICAgICAg aWYgKHJldCAhPSBVU0JfUkVUX05PREVWKQorICAgICAgICAgICAgYnJlYWs7CisgICAgfQor CisgICAgREVCVUcoKCJleGl0IGxvb3AgZGV2LT5pbmZvLT5oYW5kbGVfcGFja2V0XG4iKSk7 CisKKyAgICBpZiAocmV0ID4gQlVGRl9TSVpFIHx8IGVoY2ktPnRieXRlcyA+IEJVRkZfU0la RSkgeworICAgICAgICBwcmludGYoImJvZ3VzIFFIIGJ5dGUgY291bnRcbiIpOworICAgICAg ICBkdW1wX3FoKHFoLCBOTFBUUl9HRVQocWhhZGRyKSk7CisgICAgICAgIEFTU0VSVChyZXQg PD0gQlVGRl9TSVpFICYmIGVoY2ktPnRieXRlcyA8PSBCVUZGX1NJWkUpOworICAgIH0KKwor ICAgIGlmIChyZXQgPT0gVVNCX1JFVF9BU1lOQykgeworICAgICAgICBlaGNpLT5hc3luY19w b3J0X2luX3Byb2dyZXNzID0gaTsKKyAgICAgICAgZWhjaS0+YXN5bmNfY29tcGxldGUgPSAw OworICAgIH0KKworICAgIHJldHVybiByZXQ7Cit9CisKKy8qICA0LjcuMgorICovCisKK3N0 YXRpYyB2b2lkIGVoY2lfcHJvY2Vzc19pdGQoRUhDSVN0YXRlICplaGNpLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBFSENJaXRkICppdGQpCit7CisgICAgVVNCUG9ydCAqcG9y dDsKKyAgICBVU0JEZXZpY2UgKmRldjsKKyAgICBpbnQgcmV0OworICAgIGludCBpLCBqOwor ICAgIGludCBwdHI7CisgICAgaW50IHBpZDsKKyAgICBpbnQgcGc7CisgICAgaW50IGxlbjsK KyAgICBpbnQgZGlyOworICAgIGludCBkZXZhZHI7CisgICAgaW50IGVuZHA7CisgICAgaW50 IG1heHBrdDsKKworICAgIGRpciA9KGl0ZC0+YnVmcHRyWzFdICYgSVREX0JVRlBUUl9ESVJF Q1RJT04pOworICAgIGRldmFkciA9IGdldF9maWVsZChpdGQtPmJ1ZnB0clswXSwKKyAgICAg ICAgICAgICAgICAgICAgICAgIElURF9CVUZQVFJfREVWQUREUl9NQVNLLCAwKTsKKyAgICBl bmRwID0gZ2V0X2ZpZWxkKGl0ZC0+YnVmcHRyWzBdLAorICAgICAgICAgICAgICAgICAgICAg IElURF9CVUZQVFJfRVBfTUFTSywgSVREX0JVRlBUUl9FUF9TSCk7CisgICAgbWF4cGt0ID0g Z2V0X2ZpZWxkKGl0ZC0+YnVmcHRyWzFdLCBJVERfQlVGUFRSX01BWFBLVF9NQVNLLCAwKTsK KworI2lmZGVmIEVIQ0lfTk9NSUNST0ZSQU1FUworICAgIGZvcihpID0gMDsgaSA8IDg7IGkr KykgeworI2Vsc2UKKyAgICBpID0oZWhjaS0+ZnJpbmRleCAmIDcpOworI2VuZGlmCisKKyAg ICBpZiAoaXRkLT50cmFuc2FjdFtpXSAmIElURF9YQUNUX0FDVElWRSkgeworICAgICAgICBE RUJVRygoIklTT0NIUk9OT1VTIGFjdGl2ZSBmb3IgZnJhbWUgJWQsIGludGVydmFsICVkXG4i LAorICAgICAgICAgICAgICAgIGVoY2ktPmZyaW5kZXggPj4gMywgaSkpOworCisgICAgICAg IHBnID0gZ2V0X2ZpZWxkKGl0ZC0+dHJhbnNhY3RbaV0sIElURF9YQUNUX1BHU0VMX01BU0ss CisgICAgICAgICAgICAgICAgICAgICAgICBJVERfWEFDVF9QR1NFTF9TSCk7CisgICAgICAg IHB0ciA9KGl0ZC0+YnVmcHRyW3BnXSAmIElURF9CVUZQVFJfTUFTSykgfAorICAgICAgICAg ICAgIChpdGQtPnRyYW5zYWN0W2ldICYgSVREX1hBQ1RfT0ZGU0VUX01BU0spOworICAgICAg ICBsZW4gPSBnZXRfZmllbGQoaXRkLT50cmFuc2FjdFtpXSwgSVREX1hBQ1RfTEVOR1RIX01B U0ssCisgICAgICAgICAgICAgICAgICAgICAgICAgSVREX1hBQ1RfTEVOR1RIX1NIKTsKKwor ICAgICAgICBBU1NFUlQobGVuIDw9IEJVRkZfU0laRSk7CisKKyAgICAgICAgREVCVUcoKCJJ U09DSDogYnVmZmVyICUwOFggbGVuICVkXG4iLCBwdHIsIGxlbikpOworCisgICAgICAgIGlm ICghZGlyKSB7CisgICAgICAgICAgICBjcHVfcGh5c2ljYWxfbWVtb3J5X3J3KHB0ciwgJmVo Y2ktPmJ1ZmZlclswXSwgbGVuLCAwKTsKKyAgICAgICAgICAgIHBpZCA9IFVTQl9UT0tFTl9P VVQ7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgcGlkID0gVVNCX1RPS0VOX0lOOwor CisgICAgICAgIHJldCA9IFVTQl9SRVRfTk9ERVY7CisKKyAgICAgICAgZm9yKGogPSAwOyBq IDwgTkJfUE9SVFM7IGorKykgeworICAgICAgICAgICAgcG9ydCA9ICZlaGNpLT5wb3J0c1tq XTsKKyAgICAgICAgICAgIGRldiA9IHBvcnQtPmRldjsKKworICAgICAgICAgICAgLy8gVE9E TyBzb21ldGltZSB3ZSB3aWxsIGFsc28gbmVlZCB0byBjaGVjayBpZiB3ZSBhcmUgdGhlIHBv cnQgb3duZXIKKworICAgICAgICAgICAgaWYgKCEoZWhjaS0+cG9ydHNjW2pdICYoUE9SVFND X0NPTk5FQ1QpKSkgeworICAgICAgICAgICAgICAgIERFQlVHKCgiUG9ydCAlZCwgbm8gZXhl Yywgbm90IGNvbm5lY3RlZCglMDhYKVxuIiwKKyAgICAgICAgICAgICAgICAgICAgICAgIGos IGVoY2ktPnBvcnRzY1tqXSkpOworICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICAgICAgfQorCisgICAgICAgICAgICBlaGNpLT51c2JfcGFja2V0LnBpZCA9IGVoY2ktPnBp ZDsKKyAgICAgICAgICAgIGVoY2ktPnVzYl9wYWNrZXQuZGV2YWRkciA9IGRldmFkcjsKKyAg ICAgICAgICAgIGVoY2ktPnVzYl9wYWNrZXQuZGV2ZXAgPSBlbmRwOworICAgICAgICAgICAg ZWhjaS0+dXNiX3BhY2tldC5kYXRhID0gZWhjaS0+YnVmZmVyOworICAgICAgICAgICAgZWhj aS0+dXNiX3BhY2tldC5sZW4gPSBsZW47CisgICAgICAgICAgICBlaGNpLT51c2JfcGFja2V0 LmNvbXBsZXRlX2NiID0gZWhjaV9hc3luY19jb21wbGV0ZV9wYWNrZXQ7CisgICAgICAgICAg ICBlaGNpLT51c2JfcGFja2V0LmNvbXBsZXRlX29wYXF1ZSA9IGVoY2k7CisKKyAgICAgICAg ICAgIERFQlVHKCgiY2FsbGluZyBkZXYtPmluZm8tPmhhbmRsZV9wYWNrZXRcbiIpKTsKKyAg ICAgICAgICAgIHJldCA9IGRldi0+aW5mby0+aGFuZGxlX3BhY2tldChkZXYsICZlaGNpLT51 c2JfcGFja2V0KTsKKworICAgICAgICAgICAgaWYgKHJldCAhPSBVU0JfUkVUX05PREVWKQor ICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisKKyAgICAgICAgLyogIEluIGlz b2NoLCB0aGVyZSBpcyBubyBmYWNpbGl0eSB0byBpbmRpY2F0ZSBhIE5BSyBzbyBsZXQncwor ICAgICAgICAgKiAgaW5zdGVhZCBqdXN0IGNvbXBsZXRlIGEgemVyby1ieXRlIHRyYW5zYWN0 aW9uLiAgU2V0dGluZworICAgICAgICAgKiAgREJFUlIgc2VlbXMgdG9vIGRyYWNvbmlhbi4K KyAgICAgICAgICovCisKKyAgICAgICAgaWYgKHJldCA9PSBVU0JfUkVUX05BSykgeworICAg ICAgICAgICAgaWYgKGVoY2ktPmlzb2NoX3BhdXNlID4gMCkgeworICAgICAgICAgICAgICAg IERFQlVHKCgiSVNPQ0g6IHJlY2VpdmVkIGEgTkFLIGJ1dCBwYXVzZWQgc28gcmV0dXJuaW5n XG4iKSk7CisgICAgICAgICAgICAgICAgZWhjaS0+aXNvY2hfcGF1c2UtLTsKKyAgICAgICAg ICAgICAgICByZXR1cm47CisgICAgICAgICAgICB9IGVsc2UgaWYgKGVoY2ktPmlzb2NoX3Bh dXNlID09IC0xKSB7CisgICAgICAgICAgICAgICAgREVCVUcoKCJJU09DSDogcmVjdiBOQUsg JiBpc29jaCBwYXVzZSBpbmFjdGl2ZSwgc2V0dGluZ1xuIikpOworICAgICAgICAgICAgICAg IC8vIFBhdXNlIGZyaW5kZXggZm9yIHVwIHRvIDUwIG1zZWMgd2FpdGluZyBmb3IgZGF0YSBm cm9tCisgICAgICAgICAgICAgICAgLy8gcmVtb3RlCisgICAgICAgICAgICAgICAgZWhjaS0+ aXNvY2hfcGF1c2UgPSA1MDsKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgICAgIERFQlVHKCgiSVNPQ0g6IGlzb2NoIHBhdXNl IHRpbWVvdXQhIHJldHVybiAwXG4iKSk7CisgICAgICAgICAgICAgICAgcmV0ID0gMDsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIERFQlVHKCgiSVNP Q0g6IHJlY2VpdmVkIEFDSywgY2xlYXJpbmcgcGF1c2VcbiIpKTsKKyAgICAgICAgICAgIGVo Y2ktPmlzb2NoX3BhdXNlID0gLTE7CisgICAgICAgIH0KKworICAgICAgICBpZiAocmV0ID49 IDApIHsKKyAgICAgICAgICAgIGl0ZC0+dHJhbnNhY3RbaV0gJj0gfklURF9YQUNUX0FDVElW RTsKKworICAgICAgICAgICAgaWYgKGl0ZC0+dHJhbnNhY3RbaV0gJiBJVERfWEFDVF9JT0Mp IHsKKyAgICAgICAgICAgICAgICAvLyBUT0RPIHNob3VsZCBkbyB0aGlzIGFmdGVyIHdyaXRl YmFjayB0byBtZW1vcnkKKyAgICAgICAgICAgICAgICBlaGNpX3NldF9pbnRlcnJ1cHQoZWhj aSwgVVNCU1RTX0lOVCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAgICBp ZiAocmV0ID49IDAgJiYgZGlyKSB7CisgICAgICAgICAgICBjcHVfcGh5c2ljYWxfbWVtb3J5 X3J3KHB0ciwgJmVoY2ktPmJ1ZmZlclswXSwgbGVuLCAxKTsKKworICAgICAgICAgICAgaWYg KHJldCAhPSBsZW4pIHsKKyAgICAgICAgICAgICAgICBERUJVRygoIklTT0NIIElOIGV4cGVj dGVkICVkLCBnb3QgJWRcbiIsCisgICAgICAgICAgICAgICAgICAgICAgICBsZW4sIHJldCkp OworICAgICAgICAgICAgICAgIHNldF9maWVsZCgmaXRkLT50cmFuc2FjdFtpXSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg IElURF9YQUNUX0xFTkdUSF9NQVNLLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgSVRE X1hBQ1RfTEVOR1RIX1NIKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKwor I2lmZGVmIEVIQ0lfTk9NSUNST0ZSQU1FUworICAgIH0KKyNlbmRpZgorfQorCisvKiBUaGlz IGlzIHRoZSBzdGF0ZSBtYWNoaW5lIHRoYXQgaXMgY29tbW9uIHRvIGJvdGggYXN5bmMgYW5k IHBlcmlvZGljICovCisKK3N0YXRpYyBpbnQgZWhjaV9hZHZhbmNlX3N0YXRlKEVIQ0lTdGF0 ZSAqZWhjaSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IGFzeW5jLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgc3RhdGUsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHVpbnQzMl90IGVudHJ5KQoreworICAgIEVIQ0lxaCAq cWggPSAmZWhjaS0+cWg7CisgICAgRUhDSXF0ZCAqcXRkID0gJmVoY2ktPnF0ZDsKKyAgICBF SENJaXRkIGl0ZDsKKyAgICBpbnQgYWdhaW4gPSAwOworICAgIGludCBsb29wY291bnQgPSAw OworICAgIGludCB0cmFuc2FjdEN0cjsKKyAgICBpbnQgc21hc2s7CisgICAgaW50IHJlbG9h ZDsKKyAgICBpbnQgbmFrY250OworCisgICAgZG8geworICAgICAgICBERUJVRygoImFkdmFu Y2Vfc3RhdGU6IGFnYWluPSVkXG4iLCBhZ2FpbikpOworICAgICAgICBhZ2FpbiA9IDA7Cisg ICAgICAgIC8vIEFTU0VSVChsb29wY291bnQrKyA8IE1BWF9JVEVSQVRJT05TKTsKKworICAg ICAgICBzd2l0Y2goc3RhdGUpIHsKKyAgICAgICAgLyogIFRoaXMgc3RhdGUgaXMgdGhlIGVu dHJ5IHBvaW50IGZvciBhc3luY2hyb25vdXMgc2NoZWR1bGUKKyAgICAgICAgICogIHByb2Nl c3NpbmcuICBFbnRyeSBoZXJlIGNvbnNpdHV0ZXMgYSBFSENJIHN0YXJ0IGV2ZW50IHN0YXRl KDQuOC41KQorICAgICAgICAgKi8KKyAgICAgICAgY2FzZSBFU1RfV0FJVExJU1RIRUFEOgor ICAgICAgICAgICAgREVCVUcoKCJXQUlUTElTVEhFQURcbiIpKTsKKworICAgICAgICAgICAg aWYgKGFzeW5jKQorICAgICAgICAgICAgICAgIGVoY2ktPnVzYnN0cyB8PSBVU0JTVFNfUkVD OworCisgICAgICAgICAgICAvKiAgRmluZCB0aGUgaGVhZCBvZiB0aGUgbGlzdAorICAgICAg ICAgICAgICovCisKKyAgICAgICAgICAgIGZvcihsb29wY291bnQgPSAwOyBsb29wY291bnQg PCBNQVhfUUg7IGxvb3Bjb3VudCsrKSB7CisgICAgICAgICAgICAgICAgZ2V0X2R3b3JkcyhO TFBUUl9HRVQoZW50cnkpLCh1aW50MzJfdCAqKSBxaCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzaXplb2YoRUhDSXFoKSA+PiAyKTsKKworICAgICAgICAgICAgICAgIGlmIChx aC0+ZXBjaGFyICYgUUhfRVBDSEFSX0gpIHsKKyAgICAgICAgICAgICAgICAgICAgREVCVUco KCJRSCAlMDhYIGlzIHRoZSBIRUFEIG9mIHRoZSBsaXN0XG4iLCBlbnRyeSkpOworICAgICAg ICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAg ICAgICBERUJVRygoIlFIICUwOFggaXMgTk9UIHRoZSBIRUFEIG9mIHRoZSBsaXN0XG4iLCBl bnRyeSkpOworICAgICAgICAgICAgICAgIGVudHJ5ID0gcWgtPm5leHQ7CisgICAgICAgICAg ICB9CisKKyAgICAgICAgICAgIGVudHJ5IHw9KE5MUFRSX1RZUEVfUUggPDwgMSk7CisgICAg ICAgICAgICBBU1NFUlQobG9vcGNvdW50IDwgTUFYX1FIKTsKKyAgICAgICAgICAgIGxvb3Bj b3VudCA9IDA7CisKKyAgICAgICAgICAgIHN0YXRlID0gRVNUX0ZFVENIRU5UUlk7CisgICAg ICAgICAgICBhZ2FpbiA9IDE7CisgICAgICAgICAgICBicmVhazsKKworICAgICAgICAvKiAg VGhpcyBzdGF0ZSBpcyB0aGUgZW50cnkgcG9pbnQgZm9yIHBlcmlvZGljIHNjaGVkdWxlCisg ICAgICAgICAqICBwcm9jZXNzaW5nIGFzIHdlbGwgYXMgYmVpbmcgYSBjb250aW51YXRpb24g c3RhdGUgZm9yIGFzeW5jCisgICAgICAgICAqICBwcm9jZXNzaW5nLgorICAgICAgICAgKi8K KyAgICAgICAgY2FzZSBFU1RfRkVUQ0hFTlRSWToKKyAgICAgICAgICAgIERFQlVHKCgiRkVU Q0hFTlRSWVxuIikpOworCisgICAgICAgICAgICBpZiAocWVtdV9nZXRfY2xvY2sodm1fY2xv Y2spIC8gMTAwMCA+IGVoY2ktPmZyYW1lX2VuZF91c2VjKSB7CisgICAgICAgICAgICAgICAg aWYgKGFzeW5jKSB7CisgICAgICAgICAgICAgICAgICAgIERFQlVHKCgiRlJBTUUgdGltZXIg ZWxhcHNlZCwgZXhpdCBzdGF0ZSBtYWNoaW5lXG4iKSk7CisgICAgICAgICAgICAgICAgICAg IHN0YXRlID0gRVNUX0FDVElWRTsKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgICAgIERFQlVHKCgiV0FSTklO RyAtIGZyYW1lIHRpbWVyIGVsYXBzZWQgZHVyaW5nIHBlcmlvZGljXG4iKSk7CisgICAgICAg ICAgICB9CisKKyAgICAgICAgICAgIGlmIChOTFBUUl9UQklUKGVudHJ5KSkgeworICAgICAg ICAgICAgICAgIHN0YXRlID0gRVNUX0FDVElWRTsKKyAgICAgICAgICAgICAgICBicmVhazsK KyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaWYgKE5MUFRSX1RZUEVfR0VUKGVudHJ5 KSA9PSBOTFBUUl9UWVBFX1FIKSB7CisgICAgICAgICAgICAgICAgc3RhdGUgPSBFU1RfRkVU Q0hRSDsKKyAgICAgICAgICAgICAgICBlaGNpLT5xaGFkZHIgPSBlbnRyeTsKKyAgICAgICAg ICAgICAgICBhZ2FpbiA9IDE7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAg ICB9CisKKyAgICAgICAgICAgIGlmIChOTFBUUl9UWVBFX0dFVChlbnRyeSkgPT0gTkxQVFJf VFlQRV9JVEQpIHsKKyAgICAgICAgICAgICAgICBzdGF0ZSA9IEVTVF9GRVRDSElURDsKKyAg ICAgICAgICAgICAgICBlaGNpLT5pdGRhZGRyID0gZW50cnk7CisgICAgICAgICAgICAgICAg YWdhaW4gPSAxOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorCisg ICAgICAgICAgICAvLyBUT0RPIGhhbmRsZSB0eXBlcyBvdGhlciB0aGFuIFFICisgICAgICAg ICAgICBBU1NFUlQoTkxQVFJfVFlQRV9HRVQoZW50cnkpID09IE5MUFRSX1RZUEVfUUgpOwor ICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2FzZSBFU1RfRkVUQ0hRSDoKKyAgICAg ICAgICAgIGdldF9kd29yZHMoTkxQVFJfR0VUKGVoY2ktPnFoYWRkciksKHVpbnQzMl90ICop IHFoLCAKKyAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKEVIQ0lxaCkgPj4gMik7Cisg ICAgICAgICAgICBERUJVRygoIkZFVENIUUg6IEZldGNoZWQgUUggYXQgYWRkcmVzcyAlMDhY ICIKKyAgICAgICAgICAgICAgICAgICAgIihuZXh0IGlzICUwOFgsIGgtYml0IGlzICVkKVxu IiwKKyAgICAgICAgICAgICAgICAgICAgZWhjaS0+cWhhZGRyLCBxaC0+bmV4dCwgcWgtPmVw Y2hhciAmIFFIX0VQQ0hBUl9IKSk7CisKKyNpZmRlZiBERUJVR19QQUNLRVQKKyAgICAgICAg ICAgIGR1bXBfcWgocWgsIE5MUFRSX0dFVChlaGNpLT5xaGFkZHIpKTsKKyNlbmRpZgorCisg ICAgICAgICAgICBpZiAoYXN5bmMpIHsKKyAgICAgICAgICAgICAgICAvKiAgRUhDSSBzcGVj IHZlcnNpb24gMS4wIFNlY3Rpb24gNC44LjMKKyAgICAgICAgICAgICAgICAgKi8KKyAgICAg ICAgICAgICAgICBpZiAocWgtPmVwY2hhciAmIFFIX0VQQ0hBUl9IKSB7CisgICAgICAgICAg ICAgICAgICAgIERFQlVHKCgiaC1iaXQgc2V0XG4iKSk7CisKKyAgICAgICAgICAgICAgICAg ICAgaWYgKCEoZWhjaS0+dXNic3RzICYgVVNCU1RTX1JFQykpIHsKKyAgICAgICAgICAgICAg ICAgICAgICAgIERFQlVHKCgiaC1iaXQgYW5kICFyZWNsYW0sIGRvbmVcbiIpKTsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHN0YXRlID0gRVNUX0FDVElWRTsKKyAgICAgICAgICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgfQorICAgICAgICAgICAgICAgIC8qICBFSENJIHNwZWMgdmVyc2lvbiAxLjAgU2VjdGlv biA0LjEwLjEKKyAgICAgICAgICAgICAgICAgKi8KKyAgICAgICAgICAgICAgICBpZiAoICEo cWgtPmVwY2FwICYgUUhfRVBDQVBfU01BU0tfTUFTSykpIHsKKyAgICAgICAgICAgICAgICAg ICAgREVCVUcoKCJub3QgaW50ciwgY2xlYXIgcmVjbGFtXG4iKSk7CisgICAgICAgICAgICAg ICAgICAgIGVoY2ktPnVzYnN0cyAmPSB+VVNCU1RTX1JFQzsKKyAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIERFQlVHKCgiZXhlYzog cWggY2hlY2ssIGZyaW5kZXggaXMgJWQsJWRcbiIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgKGVoY2ktPmZyaW5kZXggPj4gMyksKGVoY2ktPmZyaW5kZXggJiA3KSkpOworICAgICAg ICAgICAgfQorCisgICAgICAgICAgICByZWxvYWQgPSBnZXRfZmllbGQocWgtPmVwY2hhciwg UUhfRVBDSEFSX1JMX01BU0ssIFFIX0VQQ0hBUl9STF9TSCk7CisKKyAgICAgICAgICAgIGlm IChyZWxvYWQpIHsKKyAgICAgICAgICAgICAgICBERUJVRygoInJlbG9hZGluZyBuYWtjbnQg dG8gJWRcbiIsCisgICAgICAgICAgICAgICAgICAgICAgICByZWxvYWQpKTsKKyAgICAgICAg ICAgICAgICBzZXRfZmllbGQoJnFoLT5hbHRuZXh0LCByZWxvYWQsIFFIX0FMVE5FWFRfTkFL Q05UX01BU0ssCisgICAgICAgICAgICAgICAgICAgICAgICAgICBRSF9BTFRORVhUX05BS0NO VF9TSCk7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGlmIChxaC0+dG9rZW4gJiBR VERfVE9LRU5fQUNUSVZFKSB7CisgICAgICAgICAgICAgICAgaWYgKChxaC0+dG9rZW4gJiBR VERfVE9LRU5fSEFMVCkpIHsKKyAgICAgICAgICAgICAgICAgICAgcHJpbnRmKCJBY3RpdmUs IEhhbHQsICoqIElMTEVHQUwgKipcbiIpOworICAgICAgICAgICAgICAgICAgICBzdGF0ZSA9 IEVTVF9BQ1RJVkU7CisgICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAg ICAgICAgREVCVUcoKCJBY3RpdmUsICFIYWx0LCBleGVjdXRlIC0gZmV0Y2hxdGRcbiIpKTsK KyAgICAgICAgICAgICAgICAgICAgZWhjaS0+cXRkYWRkciA9IHFoLT5jdXJyZW50OworICAg ICAgICAgICAgICAgICAgICBzdGF0ZSA9IEVTVF9GRVRDSFFURDsKKyAgICAgICAgICAgICAg ICAgICAgYWdhaW4gPSAxOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICAgICAgaWYgKHFoLT50b2tlbiAmIFFURF9UT0tFTl9IQUxUKSB7 CisgICAgICAgICAgICAgICAgICAgIERFQlVHKCgiIUFjdGl2ZSwgSGFsdCwgZ28gaG9yaXpc biIpKTsKKyAgICAgICAgICAgICAgICAgICAgc3RhdGUgPSBFU1RfSE9SSVpPTlRBTFFIOwor ICAgICAgICAgICAgICAgICAgICBhZ2FpbiA9IDE7CisgICAgICAgICAgICAgICAgfSBlbHNl IHsKKyAgICAgICAgICAgICAgICAgICAgLyogIEVIQ0kgc3BlYyB2ZXJzaW9uIDEuMCBTZWN0 aW9uIDQuMTAuMgorICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICAgICAgICAgICAgICAg ICAgREVCVUcoKCIhQWN0aXZlLCAhSGFsdCwgYWR2IHFcbiIpKTsKKyAgICAgICAgICAgICAg ICAgICAgc3RhdGUgPSBFU1RfQURWQU5DRVFVRVVFOworICAgICAgICAgICAgICAgICAgICBh Z2FpbiA9IDE7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorCisgICAgICAg ICAgICBicmVhazsKKworICAgICAgICBjYXNlIEVTVF9GRVRDSElURDoKKyAgICAgICAgICAg IGdldF9kd29yZHMoTkxQVFJfR0VUKGVoY2ktPml0ZGFkZHIpLCh1aW50MzJfdCAqKSAmaXRk LAorICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKEVIQ0lpdGQpID4+IDIpOworICAg ICAgICAgICAgREVCVUcoKCJGRVRDSElURDogRmV0Y2hlZCBJVEQgYXQgYWRkcmVzcyAlMDhY ICIKKyAgICAgICAgICAgICAgICAgICAgIihuZXh0IGlzICUwOFgpXG4iLAorICAgICAgICAg ICAgICAgICAgICBlaGNpLT5pdGRhZGRyLCBpdGQubmV4dCkpOworCisjaWZkZWYgREVCVUdf UEFDS0VUCisgICAgICAgICAgICBkdW1wX2l0ZCgmaXRkLCBOTFBUUl9HRVQoZWhjaS0+aXRk YWRkcikpOworI2VuZGlmCisKKyAgICAgICAgICAgIGVoY2lfcHJvY2Vzc19pdGQoZWhjaSwg Jml0ZCk7CisjaWZkZWYgREVCVUdfUEFDS0VUCisgICAgICAgICAgICBkdW1wX2l0ZCgmaXRk LCBOTFBUUl9HRVQoZWhjaS0+aXRkYWRkcikpOworI2VuZGlmCisgICAgICAgICAgICBwdXRf ZHdvcmRzKE5MUFRSX0dFVChlaGNpLT5pdGRhZGRyKSwodWludDMyX3QgKikgJml0ZCwKKyAg ICAgICAgICAgICAgICAgICAgICAgIHNpemVvZihFSENJaXRkKSA+PiAyKTsKKyAgICAgICAg ICAgIGVudHJ5ID0gaXRkLm5leHQ7CisgICAgICAgICAgICBzdGF0ZSA9IEVTVF9GRVRDSEVO VFJZOworICAgICAgICAgICAgYWdhaW4gPSAxOworICAgICAgICAgICAgYnJlYWs7CisKKyAg ICAgICAgY2FzZSBFU1RfQURWQU5DRVFVRVVFOgorICAgICAgICAgICAgREVCVUcoKCJBRFZB TkNFUVVFVUVcbiIpKTsKKyAgICAgICAgICAgIGlmICgocWgtPnRva2VuICYgUVREX1RPS0VO X1RCWVRFU19NQVNLKSAhPSAwICYmCisgICAgICAgICAgICAgICAgTkxQVFJfVEJJVChxaC0+ YWx0bmV4dCkgPT0gMCkgeworICAgICAgICAgICAgICAgIGVoY2ktPnF0ZGFkZHIgPSBxaC0+ YWx0bmV4dDsKKyAgICAgICAgICAgICAgICBERUJVRygoInRieXRlcyE9MCBhbmQgdGJpdCA9 IDAsIGdvIHdpdGggYWx0bmV4dFxuIikpOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgICAgICBpZiAoTkxQVFJfVEJJVChxaC0+cXRkbmV4dCkpIHsKKyAgICAgICAgICAg ICAgICAgICAgc3RhdGUgPSBFU1RfSE9SSVpPTlRBTFFIOworICAgICAgICAgICAgICAgICAg ICBhZ2FpbiA9IDE7CisgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAg ICAgIH0KKworICAgICAgICAgICAgICAgIGVoY2ktPnF0ZGFkZHIgPSBxaC0+cXRkbmV4dDsK KyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHN0YXRlID0gRVNUX0ZFVENIUVREOworICAg ICAgICAgICAgYWdhaW4gPSAxOworICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2Fz ZSBFU1RfRkVUQ0hRVEQ6CisgICAgICAgICAgICBERUJVRygoIkZFVENIUVREOiBGZXRjaGlu ZyBRVEQgYXQgYWRkcmVzcyAlMDhYXG4iLCBlaGNpLT5xdGRhZGRyKSk7CisgICAgICAgICAg ICBnZXRfZHdvcmRzKE5MUFRSX0dFVChlaGNpLT5xdGRhZGRyKSwodWludDMyX3QgKikgcXRk LAorICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKEVIQ0lxdGQpID4+IDIpOworCisg ICAgICAgICAgICBpZiAocXRkLT50b2tlbiAmIFFURF9UT0tFTl9BQ1RJVkUpIHsKKyAgICAg ICAgICAgICAgICBzdGF0ZSA9IEVTVF9FWEVDVVRFOworICAgICAgICAgICAgICAgIGFnYWlu ID0gMTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0gZWxzZSB7Cisg ICAgICAgICAgICAgICAgREVCVUcoKCJhYm9ydCBhZHZhbmNlLCBub3QgYWN0aXZlXG4iKSk7 CisgICAgICAgICAgICAgICAgc3RhdGUgPSBFU1RfSE9SSVpPTlRBTFFIOworICAgICAgICAg ICAgICAgIGFnYWluID0gMTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAg IH0KKworICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2FzZSBFU1RfSE9SSVpPTlRB TFFIOgorICAgICAgICAgICAgZW50cnkgPSBxaC0+bmV4dDsKKyAgICAgICAgICAgIHN0YXRl ID0gRVNUX0ZFVENIRU5UUlk7CisgICAgICAgICAgICBhZ2FpbiA9IDE7CisgICAgICAgICAg ICBicmVhazsKKworICAgICAgICBjYXNlIEVTVF9FWEVDVVRFOgorICAgICAgICAgICAgaWYg KGFzeW5jKSB7CisgICAgICAgICAgICAgICAgREVCVUcoKCJcblxuPj4+Pj4gQVNZTkMgU1RB VEUgTUFDSElORSBleGVjdXRlXG4iKSk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgICAgIERFQlVHKCgiXG5cbj4+Pj4+IFBFUklPRElDIFNUQVRFIE1BQ0hJTkUgZXhl Y3V0ZVxuIikpOworICAgICAgICAgICAgfQorCisjaWZkZWYgREVCVUdfUEFDS0VUCisgICAg ICAgICAgICBkdW1wX3FoKHFoLCBOTFBUUl9HRVQoZWhjaS0+cWhhZGRyKSk7CisgICAgICAg ICAgICBkdW1wX3F0ZChxdGQsIE5MUFRSX0dFVChlaGNpLT5xdGRhZGRyKSk7CisjZW5kaWYK KworICAgICAgICAgICAgc21hc2sgPSBRSF9FUENBUF9TTUFTS19NQVNLICYgcWgtPmVwY2Fw OworCisjaWZuZGVmIEVIQ0lfTk9NSUNST0ZSQU1FUworICAgICAgICAgICAgaWYgKHNtYXNr ICYmKHNtYXNrICYoMSA8PChlaGNpLT5mcmluZGV4ICYgNykpKSA9PSAwKSB7CisgICAgICAg ICAgICAgICAgREVCVUcoKCJQRVJJT0RJQyBhY3RpdmUgbm90IGludGVydmFsOiAiCisgICAg ICAgICAgICAgICAgICAgICAgICAibWFzayBpcyAlZCwgIgorICAgICAgICAgICAgICAgICAg ICAgICAgImZyaW5kZXggaXMgJWQsJWRcbiIsCisgICAgICAgICAgICAgICAgICAgICAgICBz bWFzaywKKyAgICAgICAgICAgICAgICAgICAgICAgIChlaGNpLT5mcmluZGV4ID4+IDMpLChl aGNpLT5mcmluZGV4ICYgNykpKTsKKworICAgICAgICAgICAgICAgIHN0YXRlID0gRVNUX0hP UklaT05UQUxRSDsKKyAgICAgICAgICAgICAgICBhZ2FpbiA9IDE7CisgICAgICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgICAgICB9CisjZW5kaWYKKworICAgICAgICAgICAgaWYgKHNt YXNrKSB7CisgICAgICAgICAgICAgICAgREVCVUcoKCJQRVJJT0RJQyBhY3RpdmUgISEhICIK KyAgICAgICAgICAgICAgICAgICAgICAgICJtYXNrIGlzICVkLCAiCisgICAgICAgICAgICAg ICAgICAgICAgICAiZnJpbmRleCBpcyAlZCwlZFxuIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgIHNtYXNrLAorICAgICAgICAgICAgICAgICAgICAgICAgKGVoY2ktPmZyaW5kZXggPj4g MyksKGVoY2ktPmZyaW5kZXggJiA3KSkpOworICAgICAgICAgICAgfQorCisgICAgICAgICAg ICByZWxvYWQgPSBnZXRfZmllbGQocWgtPmVwY2hhciwgUUhfRVBDSEFSX1JMX01BU0ssIFFI X0VQQ0hBUl9STF9TSCk7CisgICAgICAgICAgICBuYWtjbnQgPSBnZXRfZmllbGQocWgtPmFs dG5leHQsIFFIX0FMVE5FWFRfTkFLQ05UX01BU0ssIAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFFIX0FMVE5FWFRfTkFLQ05UX1NIKTsKKyAgICAgICAgICAgIGlmIChyZWxv YWQgJiYgIW5ha2NudCkgeworICAgICAgICAgICAgICAgIERFQlVHKCgiUkwgIT0gMCBidXQg TmFrQ250ID09IDAsIG5vIGV4ZWN1dGVcbiIpKTsKKyAgICAgICAgICAgICAgICBzdGF0ZSA9 IEVTVF9IT1JJWk9OVEFMUUg7CisgICAgICAgICAgICAgICAgYWdhaW4gPSAxOworICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorCisgICAgICAgICAgICB0cmFuc2Fj dEN0ciA9IGdldF9maWVsZChxaC0+ZXBjYXAsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgUUhfRVBDQVBfTVVMVF9NQVNLLCBRSF9FUENBUF9NVUxUX1NIKTsKKwor ICAgICAgICAgICAgLy8gVE9ETyB2ZXJpZnkgZW5vdWdoIHRpbWUgcmVtYWlucyBpbiB0aGUg dWZyYW1lIGFzIGluIDQuNC4xLjEKKworICAgICAgICAgICAgLy8gVE9ETyB3cml0ZSBiYWNr IHB0ciB0byBhc3luYyBsaXN0IHdoZW4gZG9uZSBvciBvdXQgb2YgdGltZQorCisgICAgICAg ICAgICAvLyBUT0RPIFdpbmRvd3MgZG9lcyBub3Qgc2VlbSB0byBldmVyIHNldCB0aGUgTVVM VCBmaWVsZAorCisjaWYgMAorICAgICAgICAgICAgaWYgKCF0cmFuc2FjdEN0ciAmJihxaC0+ ZXBjYXAgJiBRSF9FUENBUF9TTUFTS19NQVNLKSA+IDApCisgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgREVCVUcoKCJaRVJPIHRyYW5zYWN0Y3RyIGZvciBpbnQgcWgsIGdvIEhP UklaXG4iKSk7CisgICAgICAgICAgICAgICAgKnN0YXRlID0gRVNUX0hPUklaT05UQUxRSDsK KyAgICAgICAgICAgICAgICBhZ2FpbiA9IDE7CisgICAgICAgICAgICAgICAgYnJlYWs7Cisg ICAgICAgICAgICB9CisjZW5kaWYKKworICAgICAgICAgICAgaWYgKCF0cmFuc2FjdEN0cikg eworICAgICAgICAgICAgICAgIHRyYW5zYWN0Q3RyID0gMTsgLy8gVE9ETyAtIGNoZWNrIGF0 IHdoYXQgbGV2ZWwgZG8gd2UgcmVwZWF0CisKKyAgICAgICAgICAgICAgICBpZiAocWgtPmVw Y2FwICYgUUhfRVBDQVBfU01BU0tfTUFTSykKKyAgICAgICAgICAgICAgICAgICAgREVCVUco KCJXQVJOIC0gWkVSTyB0cmFuc2FjdGN0ciBmb3JjZSB0byAxIGZvciBpbnRyXG4iKSk7Cisg ICAgICAgICAgICB9CisKKyAgICAgICAgICAgIERFQlVHKCgiZXhlYzogY3RyIGlzICVkXG4i LCB0cmFuc2FjdEN0cikpOworICAgICAgICAgICAgREVCVUcoKCJleGVjOiBmcmluZGV4IGlz ICVkLCVkXG4iLAorICAgICAgICAgICAgICAgICAgIChlaGNpLT5mcmluZGV4ID4+IDMpLChl aGNpLT5mcmluZGV4ICYgNykpKTsKKworICAgICAgICAgICAgZWhjaV9xaF9kb19vdmVybGF5 KGVoY2ksIHFoLCBxdGQpOworICAgICAgICAgICAgZWhjaS0+ZXhlY19zdGF0dXMgPSBlaGNp X2V4ZWN1dGUoZWhjaSwgZWhjaS0+cWhhZGRyLCBxaCk7CisgICAgICAgICAgICBzdGF0ZSA9 IEVTVF9FWEVDVVRJTkc7CisKKyAgICAgICAgICAgIGlmIChlaGNpLT5leGVjX3N0YXR1cyAh PSBVU0JfUkVUX0FTWU5DKQorICAgICAgICAgICAgICAgIGFnYWluID0gMTsKKworICAgICAg ICAgICAgYnJlYWs7CisKKyAgICAgICAgY2FzZSBFU1RfRVhFQ1VUSU5HOgorICAgICAgICAg ICAgREVCVUcoKCJFbnRlciBFWEVDVVRJTkdcbiIpKTsKKyAgICAgICAgICAgIGVoY2ktPmV4 ZWNfc3RhdHVzID0gZWhjaV9leGVjdXRlX2NvbXBsZXRlKGVoY2ksIHFoLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVoY2ktPmV4 ZWNfc3RhdHVzKTsKKworICAgICAgICAgICAgaWYgKGVoY2ktPmV4ZWNfc3RhdHVzID09IFVT Ql9SRVRfQVNZTkMpCisgICAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgIERF QlVHKCgiZmluaXNoaW5nIGV4ZWNcbiIpKTsKKyAgICAgICAgICAgIHRyYW5zYWN0Q3RyID0g Z2V0X2ZpZWxkKHFoLT5lcGNhcCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBRSF9FUENBUF9NVUxUX01BU0ssIFFIX0VQQ0FQX01VTFRfU0gpOworCisgICAgICAg ICAgICBpZiAodHJhbnNhY3RDdHIpCisgICAgICAgICAgICAgICAgdHJhbnNhY3RDdHItLTsK KworICAgICAgICAgICAgc2V0X2ZpZWxkKCZxaC0+ZXBjYXAsIHRyYW5zYWN0Q3RyLAorICAg ICAgICAgICAgICAgICAgICAgICBRSF9FUENBUF9NVUxUX01BU0ssIFFIX0VQQ0FQX01VTFRf U0gpOworCisgICAgICAgICAgICByZWxvYWQgPSBnZXRfZmllbGQocWgtPmVwY2hhciwgUUhf RVBDSEFSX1JMX01BU0ssIFFIX0VQQ0hBUl9STF9TSCk7CisgICAgICAgICAgICBuYWtjbnQg PSBnZXRfZmllbGQocWgtPmFsdG5leHQsIFFIX0FMVE5FWFRfTkFLQ05UX01BU0ssCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgUUhfQUxUTkVYVF9OQUtDTlRfU0gpOworCisg ICAgICAgICAgICBpZiAocmVsb2FkICE9IDApIHsKKyAgICAgICAgICAgICAgICBpZiAoZWhj aS0+ZXhlY19zdGF0dXMgPT0gVVNCX1JFVF9OQUspIHsKKyAgICAgICAgICAgICAgICAgICAg bmFrY250LS07CisKKyAgICAgICAgICAgICAgICAgICAgREVCVUcoKCJOYWsgb2NjdXJlZCBh bmQgUkwgIT0gMCwgZGVjIE5ha0NudCB0byAlZFxuIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICBuYWtjbnQpKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAg ICAgICAgICAgICBuYWtjbnQgPSByZWxvYWQ7CisKKyAgICAgICAgICAgICAgICAgICAgREVC VUcoKCJOYWsgZGlkbid0IG9jY3VyLCByZWxvYWRpbmcgdG8gJWRcbiIsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgbmFrY250KSk7CisgICAgICAgICAgICAgICAgfQorCisgICAg ICAgICAgICAgICAgc2V0X2ZpZWxkKCZxaC0+YWx0bmV4dCwgbmFrY250LCBRSF9BTFRORVhU X05BS0NOVF9NQVNLLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgUUhfQUxUTkVYVF9O QUtDTlRfU0gpOworICAgICAgICAgICAgfQorCisgICAgICAgICAgICAvKgorICAgICAgICAg ICAgICogIFdyaXRlIHRoZSBxaCBiYWNrIHRvIGd1ZXN0IHBoeXNpY2FsIG1lbW9yeS4gIFRo aXMgc3RlcCBpc24ndAorICAgICAgICAgICAgICogIGluIHRoZSBFSENJIHNwZWMgYnV0IHdl IG5lZWQgdG8gZG8gaXQgc2luY2Ugd2UgZG9uJ3Qgc2hhcmUKKyAgICAgICAgICAgICAqICBw aHlzaWNhbCBtZW1vcnkgd2l0aCBvdXIgZ3Vlc3QgVk0uCisgICAgICAgICAgICAgKi8KKwor ICAgICAgICAgICAgREVCVUcoKCJ3cml0ZSBRSCB0byBWTSBtZW1vcnlcbiIpKTsKKyNpZmRl ZiBERUJVR19QQUNLRVQKKyAgICAgICAgICAgIGR1bXBfcWgocWgsIE5MUFRSX0dFVChlaGNp LT5xaGFkZHIpKTsKKyNlbmRpZgorICAgICAgICAgICAgcHV0X2R3b3JkcyhOTFBUUl9HRVQo ZWhjaS0+cWhhZGRyKSwodWludDMyX3QgKikgcWgsCisgICAgICAgICAgICAgICAgICAgICAg ICBzaXplb2YoRUhDSXFoKSA+PiAyKTsKKworICAgICAgICAgICAgLy8gNC4xMC41CisKKyAg ICAgICAgICAgIGlmIChxaC0+dG9rZW4gJiBRVERfVE9LRU5fQUNUSVZFKQorICAgICAgICAg ICAgICAgIHN0YXRlID0gRVNUX0hPUklaT05UQUxRSDsKKyAgICAgICAgICAgIGVsc2UKKyAg ICAgICAgICAgICAgICBzdGF0ZSA9IEVTVF9XUklURUJBQ0s7CisKKyAgICAgICAgICAgIGFn YWluID0gMTsKKyAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgIGNhc2UgRVNUX1dSSVRF QkFDSzoKKyAgICAgICAgICAgIC8qICBXcml0ZSBiYWNrIHRoZSBRVEQgZnJvbSB0aGUgUUgg YXJlYSAqLworICAgICAgICAgICAgREVCVUcoKCJ3cml0ZSBRVEQgdG8gVk0gbWVtb3J5XG4i KSk7CisgICAgICAgICAgICBwdXRfZHdvcmRzKE5MUFRSX0dFVChlaGNpLT5xdGRhZGRyKSwo dWludDMyX3QgKikgJnFoLT5xdGRuZXh0LAorICAgICAgICAgICAgICAgICAgICAgICAgc2l6 ZW9mKEVIQ0lxdGQpID4+IDIpOworICAgICAgICAgICAgLyogVE9ETyBjb25maXJtIG5leHQg c3RhdGUuICBGb3Igbm93LCBrZWVwIGdvaW5nIGlmIGFzeW5jCisgICAgICAgICAgICAgKiBi dXQgc3RvcCBhZnRlciBvbmUgcXRkIGlmIHBlcmlvZGljCisgICAgICAgICAgICAgKi8KKyAg ICAgICAgICAgIC8vIGlmIChhc3luYykKKyAgICAgICAgICAgIC8vIHsKKyAgICAgICAgICAg ICAgICBzdGF0ZSA9IEVTVF9GRVRDSFFIOworICAgICAgICAgICAgICAgIGFnYWluID0gMTsK KyAgICAgICAgICAgIC8vIH0KKyAgICAgICAgICAgIC8vIGVsc2UKKyAgICAgICAgICAgLy8g ICAgICAgICAgc3RhdGUgPSBFU1RfQUNUSVZFOworICAgICAgICAgICAgYnJlYWs7CisKKyAg ICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIHByaW50ZigiQmFkIHN0YXRlIVxuIik7Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICB9CisgICAgd2hpbGUgKGFn YWluKTsKKworICAgIHJldHVybiBzdGF0ZTsKK30KKworc3RhdGljIHZvaWQgZWhjaV9hZHZh bmNlX2FzeW5jX3N0YXRlKEVIQ0lTdGF0ZSAqZWhjaSkKK3sKKyAgICBzd2l0Y2goZWhjaS0+ YXN0YXRlKSB7CisgICAgY2FzZSBFU1RfSU5BQ1RJVkU6CisgICAgICAgIGlmIChlaGNpLT51 c2JjbWQgJiBVU0JDTURfQVNFKSB7CisgICAgICAgICAgICBERUJVRygoIkFTWU5DIGdvaW5n IGFjdGl2ZVxuIikpOworICAgICAgICAgICAgZWhjaS0+dXNic3RzIHw9IFVTQlNUU19BU1M7 CisgICAgICAgICAgICBlaGNpLT5hc3RhdGUgPSBFU1RfQUNUSVZFOworICAgICAgICAgICAg Ly8gTm8gYnJlYWssIGZhbGwgdGhyb3VnaCB0byBBQ1RJVkUKKyAgICAgICAgfSBlbHNlCisg ICAgICAgICAgICBicmVhazsKKworICAgIGNhc2UgRVNUX0FDVElWRToKKyAgICAgICAgaWYg KCAhKGVoY2ktPnVzYmNtZCAmIFVTQkNNRF9BU0UpKSB7CisgICAgICAgICAgICBERUJVRygo IkFTWU5DIGdvaW5nIGluYWN0aXZlXG4iKSk7CisgICAgICAgICAgICBlaGNpLT51c2JzdHMg Jj0gflVTQlNUU19BU1M7CisgICAgICAgICAgICBlaGNpLT5hc3RhdGUgPSBFU1RfSU5BQ1RJ VkU7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorCisgICAgICAgIERFQlVHKCgi XG4gICAgPT09ICAgPT09ICAgPT09ICAgPT09ICAgPT09ICAgPT09XG5cbiIpKTsKKyAgICAg ICAgaWYgKGVoY2ktPnVzYmNtZCAmIFVTQkNNRF9JQUFEKSB7CisgICAgICAgICAgICAvKiAg QXN5bmMgYWR2YW5jZSBkb29yYmVsbCBpbnRlcnJ1cHRlZCByZXF1ZXN0ZWQKKyAgICAgICAg ICAgICAqLworICAgICAgICAgICAgZWhjaS0+dXNiY21kICY9IH5VU0JDTURfSUFBRDsKKyAg ICAgICAgICAgIGVoY2lfc2V0X2ludGVycnVwdChlaGNpLCBVU0JTVFNfSUFBKTsKKyAgICAg ICAgfQorCisgICAgICAgIGVoY2ktPmFzdGF0ZSA9IGVoY2lfYWR2YW5jZV9zdGF0ZShlaGNp LCAxLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVTVF9X QUlUTElTVEhFQUQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgZWhjaS0+YXN5bmNsaXN0YWRkcik7CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBF U1RfRVhFQ1VUSU5HOgorICAgICAgICBERUJVRygoImFzeW5jIHN0YXRlIGFkdiBmb3IgZXhl Y3V0aW5nXG4iKSk7CisgICAgICAgIGVoY2ktPmFzdGF0ZSA9IGVoY2lfYWR2YW5jZV9zdGF0 ZShlaGNpLCAxLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEVTVF9FWEVDVVRJTkcsIGVoY2ktPnFoYWRkcik7CisgICAgICAgIGJyZWFrOworCisgICAg ZGVmYXVsdDoKKyAgICAgICAgcHJpbnRmKCJCYWQgYXN5bmNocm9ub3VzIHN0YXRlICVkXG4i LAorICAgICAgICAgICAgICAgIGVoY2ktPmFzdGF0ZSk7CisgICAgICAgIEFTU0VSVCgxPT0y KTsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIGVoY2lfYWR2YW5jZV9wZXJpb2RpY19zdGF0 ZShFSENJU3RhdGUgKmVoY2kpCit7CisgICAgdWludDMyX3QgZW50cnk7CisgICAgdWludDMy X3QgbGlzdDsKKworICAgIC8vIDQuNgorCisgICAgc3dpdGNoKGVoY2ktPnBzdGF0ZSkgewor ICAgIGNhc2UgRVNUX0lOQUNUSVZFOgorICAgICAgICBpZiAoICEoZWhjaS0+ZnJpbmRleCAm IDcpICYmKGVoY2ktPnVzYmNtZCAmIFVTQkNNRF9QU0UpKSB7CisgICAgICAgICAgICBERUJV RygoIlBFUklPRElDIGdvaW5nIGFjdGl2ZVxuIikpOworICAgICAgICAgICAgZWhjaS0+dXNi c3RzIHw9IFVTQlNUU19QU1M7CisgICAgICAgICAgICBlaGNpLT5wc3RhdGUgPSBFU1RfQUNU SVZFOworICAgICAgICAgICAgLy8gTm8gYnJlYWssIGZhbGwgdGhyb3VnaCB0byBBQ1RJVkUK KyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBicmVhazsKKworICAgIGNhc2UgRVNUX0FD VElWRToKKyAgICAgICAgaWYgKCAhKGVoY2ktPmZyaW5kZXggJiA3KSAmJiAhKGVoY2ktPnVz YmNtZCAmIFVTQkNNRF9QU0UpKSB7CisgICAgICAgICAgICBERUJVRygoIlBFUklPRElDIGdv aW5nIGluYWN0aXZlXG4iKSk7CisgICAgICAgICAgICBlaGNpLT51c2JzdHMgJj0gflVTQlNU U19QU1M7CisgICAgICAgICAgICBlaGNpLT5wc3RhdGUgPSBFU1RfSU5BQ1RJVkU7CisgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgfQorCisgICAgICAgIGxpc3QgPSBlaGNpLT5wZXJp b2RpY2xpc3RiYXNlICYgMHhmZmZmZjAwMDsKKyAgICAgICAgbGlzdCB8PSgoZWhjaS0+ZnJp bmRleCAmIDB4MWZmOCkgPj4gMSk7CisKKyAgICAgICAgY3B1X3BoeXNpY2FsX21lbW9yeV9y dyhsaXN0LCh1aW50OF90ICopICZlbnRyeSwgc2l6ZW9mIGVudHJ5LCAwKTsKKyAgICAgICAg ZW50cnkgPSBsZTMyX3RvX2NwdShlbnRyeSk7CisKKyAgICAgICAgREVCVUcoKCJwZXJpb2Rp YyBzdGF0ZSBhZHYgZnI9JWQuICBbJTA4WF0gLT4gJTA4WFxuIiwKKyAgICAgICAgICAgICAg ICBlaGNpLT5mcmluZGV4IC8gOCwgbGlzdCwgZW50cnkpKTsKKyAgICAgICAgZWhjaS0+cHN0 YXRlID0gZWhjaV9hZHZhbmNlX3N0YXRlKGVoY2ksIDAsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgRVNUX0ZFVENIRU5UUlksIGVudHJ5KTsKKyAgICAg ICAgYnJlYWs7CisKKyAgICBjYXNlIEVTVF9FWEVDVVRJTkc6CisgICAgICAgIERFQlVHKCgi cGVyaW9kaWMgc3RhdGUgYWR2IGZvciBleGVjdXRpbmdcbiIpKTsKKyAgICAgICAgZWhjaS0+ cHN0YXRlID0gZWhjaV9hZHZhbmNlX3N0YXRlKGVoY2ksIDAsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgRVNUX0VYRUNVVElORywgZWhjaS0+cWhhZGRy KTsKKyAgICAgICAgYnJlYWs7CisKKyAgICBkZWZhdWx0OgorICAgICAgICBwcmludGYoIkJh ZCBwZXJpb2RpYyBzdGF0ZSAlZFxuIiwKKyAgICAgICAgICAgICAgICBlaGNpLT5wc3RhdGUp OworICAgICAgICBBU1NFUlQoMT09Mik7CisgICAgfQorfQorCitzdGF0aWMgdm9pZCBlaGNp X2ZyYW1lX3RpbWVyKHZvaWQgKm9wYXF1ZSkKK3sKKyAgICBFSENJU3RhdGUgKmVoY2kgPSBv cGFxdWU7CisgICAgaW50NjRfdCBleHBpcmVfdGltZSwgdF9ub3c7CisgICAgaW50IHVzZWNf ZWxhcHNlZDsKKyAgICBpbnQgZnJhbWVzOworICAgIGludCB1c2VjX25vdzsKKyAgICBpbnQg aTsKKyAgICBpbnQgc2tpcHBlZF9mcmFtZXMgPSAwOworCisKKyAgICB0X25vdyA9IHFlbXVf Z2V0X2Nsb2NrKHZtX2Nsb2NrKTsKKyAgICBleHBpcmVfdGltZSA9IHRfbm93ICsgKGdldF90 aWNrc19wZXJfc2VjKCkgLyBGUkFNRV9USU1FUl9GUkVRKTsKKyAgICBpZiAoZXhwaXJlX3Rp bWUgPT0gdF9ub3cpCisgICAgICAgIGV4cGlyZV90aW1lKys7CisKKyAgICB1c2VjX25vdyA9 IHRfbm93IC8gMTAwMDsKKyAgICB1c2VjX2VsYXBzZWQgPSB1c2VjX25vdyAtIGVoY2ktPmxh c3RfcnVuX3VzZWM7CisgICAgZWhjaS0+ZnJhbWVfZW5kX3VzZWMgPSB1c2VjX25vdyArIDEw MDA7CisKKyNpZmRlZiBFSENJX05PTUlDUk9GUkFNRVMKKyAgICBmcmFtZXMgPSB1c2VjX2Vs YXBzZWQgLyAxMDAwOworICAgIGVoY2ktPmZyYW1lX2VuZF91c2VjID0gdXNlY19ub3cgKyAx MDAwOworI2Vsc2UKKyAgICBmcmFtZXMgPSB1c2VjX2VsYXBzZWQgLyAxMjU7CisgICAgZWhj aS0+ZnJhbWVfZW5kX3VzZWMgPSB1c2VjX25vdyArIDEyNTsKKyNlbmRpZgorCisjaWZkZWYg VERFQlVHCisgICAgREVCVUcoKCJGcmFtZSB0aW1lciwgdXNlYyBlbGFwc2VkIHNpbmNlIGxh c3QgJWQsIGZyYW1lcyAlZFxuIiwKKyAgICAgICAgICAgIHVzZWNfZWxhcHNlZCwgZnJhbWVz KSk7CisjZW5kaWYKKworICAgIGZvcihpID0gMDsgaSA8IGZyYW1lczsgaSsrKSB7CisgICAg ICAgIGlmICggIShlaGNpLT51c2JzdHMgJiBVU0JTVFNfSEFMVCkpIHsKKyAgICAgICAgICAg IGlmIChlaGNpLT5pc29jaF9wYXVzZSA8PSAwKSB7CisjaWZkZWYgRUhDSV9OT01JQ1JPRlJB TUVTCisgICAgICAgICAgICAgICAgZWhjaS0+ZnJpbmRleCArPSA4OworI2Vsc2UKKyAgICAg ICAgICAgICAgICBlaGNpLT5mcmluZGV4Kys7CisjZW5kaWYKKyAgICAgICAgICAgIH0KKwor ICAgICAgICAgICAgaWYgKGVoY2ktPmZyaW5kZXggPiAweDAwMDAxZmZmKSB7CisgICAgICAg ICAgICAgICAgZWhjaS0+ZnJpbmRleCA9IDA7CisjaWZkZWYgVERFQlVHCisgICAgICAgICAg ICAgICAgREVCVUcoKCJQRVJJT0RJQyBmcmluZGV4IHJvbGxvdmVyXG4iKSk7CisjZW5kaWYK KyAgICAgICAgICAgICAgICBlaGNpX3NldF9pbnRlcnJ1cHQoZWhjaSwgVVNCU1RTX0ZMUik7 CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGVoY2ktPnNvZnYgPShlaGNpLT5mcmlu ZGV4IC0gMSkgPj4gMzsKKyAgICAgICAgICAgIGVoY2ktPnNvZnYgJj0gMHgwMDAwMDNmZjsK KyAgICAgICAgfQorCisgICAgICAgIGlmIChmcmFtZXMgLSBpID4gMTApCisgICAgICAgICAg ICBza2lwcGVkX2ZyYW1lcysrOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIC8vIFRP RE8gY291bGQgdGhpcyBjYXVzZSBwZXJpb2RpYyBmcmFtZXMgdG8gZ2V0IHNraXBwZWQgaWYg YXN5bmMKKyAgICAgICAgICAgIC8vIGFjdGl2ZT8KKyAgICAgICAgICAgIGlmIChlaGNpLT5h c3RhdGUgIT0gRVNUX0VYRUNVVElORykKKyAgICAgICAgICAgICAgICBlaGNpX2FkdmFuY2Vf cGVyaW9kaWNfc3RhdGUoZWhjaSk7CisgICAgICAgIH0KKworI2lmZGVmIEVIQ0lfTk9NSUNS T0ZSQU1FUworICAgICAgICBlaGNpLT5sYXN0X3J1bl91c2VjICs9IDEwMDA7CisjZWxzZQor ICAgICAgICBlaGNpLT5sYXN0X3J1bl91c2VjICs9IDEyNTsKKyNlbmRpZgorICAgIH0KKwor I2lmIDAKKyAgICBpZiAoc2tpcHBlZF9mcmFtZXMpCisgICAgICAgIERFQlVHKCgiV0FSTklO RyAtIEVIQ0kgc2tpcHBlZCAlZCBmcmFtZXNcbiIsIHNraXBwZWRfZnJhbWVzKSk7CisjZW5k aWYKKworICAgIC8qICBBc3luYyBpcyBub3QgaW5zaWRlIGxvb3Agc2luY2UgaXQgZXhlY3V0 ZXMgZXZlcnl0aGluZyBpdCBjYW4gb25jZQorICAgICAqICBjYWxsZWQKKyAgICAgKi8KKyAg ICBpZiAoZWhjaS0+cHN0YXRlICE9IEVTVF9FWEVDVVRJTkcpCisgICAgICAgIGVoY2lfYWR2 YW5jZV9hc3luY19zdGF0ZShlaGNpKTsKKworICAgIHFlbXVfbW9kX3RpbWVyKGVoY2ktPmZy YW1lX3RpbWVyLCBleHBpcmVfdGltZSk7CisKKyAgICB1c2VjX2VsYXBzZWQgPSBxZW11X2dl dF9jbG9jayh2bV9jbG9jaykgLyAxMDAwIC0gdXNlY19ub3c7CisKKyNpZmRlZiBUREVCVUcK KyAgICBERUJVRygoIlRJTUlORzogZnJhbWVfdGltZXIgdXNlZCAlZCB1c2VjXG4iLCB1c2Vj X2VsYXBzZWQpKTsKKyNlbmRpZgorfQorCitzdGF0aWMgQ1BVUmVhZE1lbW9yeUZ1bmMgKmVo Y2lfcmVhZGZuWzNdPXsKKyAgICBlaGNpX21lbV9yZWFkYiwKKyAgICBlaGNpX21lbV9yZWFk dywKKyAgICBlaGNpX21lbV9yZWFkbAorfTsKKworc3RhdGljIENQVVdyaXRlTWVtb3J5RnVu YyAqZWhjaV93cml0ZWZuWzNdPXsKKyAgICBlaGNpX21lbV93cml0ZWIsCisgICAgZWhjaV9t ZW1fd3JpdGV3LAorICAgIGVoY2lfbWVtX3dyaXRlbAorfTsKKworc3RhdGljIHZvaWQgZWhj aV9tYXAoUENJRGV2aWNlICpwY2lfZGV2LCBpbnQgcmVnaW9uX251bSwKKyAgICAgICAgICAg ICAgICAgICAgcGNpYnVzX3QgYWRkciwgcGNpYnVzX3Qgc2l6ZSwgaW50IHR5cGUpCit7Cisg ICAgRUhDSVN0YXRlICpzID0oRUhDSVN0YXRlICopcGNpX2RldjsKKworICAgIERFQlVHKCgi ZWhjaV9tYXA6IHJlZ2lvbiAlZCwgYWRkciAlMDhsWCwgc2l6ZSAlbGQsIHMtPm1lbSAlMDhY XG4iLAorICAgICAgICAgICAgcmVnaW9uX251bSwgYWRkciwgc2l6ZSwgcy0+bWVtKSk7Cisg ICAgcy0+bWVtX2Jhc2UgPSBhZGRyOworICAgIGNwdV9yZWdpc3Rlcl9waHlzaWNhbF9tZW1v cnkoYWRkciwgc2l6ZSwgcy0+bWVtKTsKK30KKworc3RhdGljIGludCB1c2JfZWhjaV9pbml0 Zm4oUENJRGV2aWNlICpkZXYpOworCitzdGF0aWMgUENJRGV2aWNlSW5mbyBlaGNpX2luZm9b XSA9IHsKKyAgICB7CisgICAgICAgIC5xZGV2Lm5hbWUgICAgPSAidXNiLWVoY2kiLAorICAg ICAgICAucWRldi5zaXplICAgID0gc2l6ZW9mKEVIQ0lTdGF0ZSksCisgICAgICAgIC5pbml0 ICAgICAgICAgPSB1c2JfZWhjaV9pbml0Zm4sCisgICAgfSx7CisgICAgICAgIC8qIGVuZCBv ZiBsaXN0ICovCisgICAgfQorfTsKKworI2lmIDAKK3ZvaWQgdXNiX2VoY2lfaW5mbyhNb25p dG9yICptb24pCit7CisgICAgaW50IGk7CisgICAgdWludDMyX3QgdmFsOworICAgIHN0YXRp YyB1aW50MzJfdCBsYXN0WzB4NjQgKyBOQl9QT1JUUyAqIDRdOworCisgICAgZm9yKGkgPSAw OyBpIDw9IDB4NjQgKyBOQl9QT1JUUyAqIDQ7IGkrPTQpIHsKKyAgICAgICAgdmFsID0gKih1 aW50MzJfdCAqKSAmKGVoY2lfaW5mby0+bW1pb1tpXSk7CisKKyAgICAgICAgbW9uaXRvcl9w cmludGYobW9uLCAiTU1JTyAlMDhYIDogJTA4WCAgIFsrLy0gJTA4WF1cbiIsIGksIHZhbCwg dmFsIF4gbGFzdFtpLzRdKTsKKyAgICAgICAgbGFzdFtpLzRdID0gdmFsOworICAgIH0KK30K KyNlbHNlCit2b2lkIHVzYl9laGNpX2luZm8oTW9uaXRvciAqbW9uKQoreworICAgIG1vbml0 b3JfcHJpbnRmKG1vbiwgIlVTQiBFSENJIGluZm8gbm90IGltcGxlbWVudGVkIHlldFxuIik7 Cit9CisjZW5kaWYKKworc3RhdGljIGludCB1c2JfZWhjaV9pbml0Zm4oUENJRGV2aWNlICpk ZXYpCit7CisgICAgRUhDSVN0YXRlICpzID0gRE9fVVBDQVNUKEVIQ0lTdGF0ZSwgZGV2LCBk ZXYpOworICAgIHVpbnQ4X3QgKnBjaV9jb25mID0gcy0+ZGV2LmNvbmZpZzsKKyAgICBpbnQg aTsKKworICAgIHBjaV9jb25maWdfc2V0X3ZlbmRvcl9pZChwY2lfY29uZiwgUENJX1ZFTkRP Ul9JRF9JTlRFTCk7CisgICAgcGNpX2NvbmZpZ19zZXRfZGV2aWNlX2lkKHBjaV9jb25mLCBQ Q0lfREVWSUNFX0lEX0lOVEVMXzgyODAxRCk7CisgICAgcGNpX2NvbmZbUENJX1JFVklTSU9O X0lEXSA9IDB4MTA7CisgICAgcGNpX2NvbmZbUENJX0NMQVNTX1BST0ddID0gMHgyMDsKKyAg ICBwY2lfY29uZmlnX3NldF9jbGFzcyhwY2lfY29uZiwgUENJX0NMQVNTX1NFUklBTF9VU0Ip OworCisgICAgcGNpX2NvbmZbUENJX0hFQURFUl9UWVBFXSA9IFBDSV9IRUFERVJfVFlQRV9O T1JNQUw7CisgICAgcGNpX2NvbmZbUENJX0NBUEFCSUxJVFlfTElTVF0gPSAweDAwOyAvLyBj YXBhYmlsaXRpZXMgcG9pbnRlcgorCisgICAgLy8gcGNpX2NvbmZbMHgzNF0gPSAweDUwOyAv LyBjYXBhYmlsaXRpZXMgcG9pbnRlcgorCisgICAgcGNpX2NvbmZbMHgzZF0gPSA0OyAvLyBp bnRlcnJ1cHQgcGluIDMKKyAgICBwY2lfY29uZlsweDNlXSA9IDA7IC8vIE1heExhdAorICAg IHBjaV9jb25mWzB4M2ZdID0gMDsgLy8gTWluR250CisKKyAgICAvLyBwY2lfY29uZlsweDUw XSA9IDB4MDE7IC8vIHBvd2VyIG1hbmFnZW1lbnQgY2FwcworCisgICAgcGNpX2NvbmZbMHg2 MF0gPSAweDIwOyAgLy8gU0JSTgorICAgIHBjaV9jb25mWzB4NjFdID0gMHgyMDsgIC8vIEZM QURKCisgICAgcGNpX2NvbmZbMHg2Ml0gPSAweDdmOworICAgIHBjaV9jb25mWzB4NjNdID0g MHgwMDsgIC8vIFBPUlRXQUtFQ0FQCisgICAgcGNpX2NvbmZbMHg2NF0gPSAweDAwOworICAg IHBjaV9jb25mWzB4NjVdID0gMHgwMDsKKyAgICBwY2lfY29uZlsweDY2XSA9IDB4MDA7Cisg ICAgcGNpX2NvbmZbMHg2N10gPSAweDAwOworICAgIHBjaV9jb25mWzB4NjhdID0gMHgwMTsK KyAgICBwY2lfY29uZlsweDY5XSA9IDB4MDA7CisgICAgcGNpX2NvbmZbMHg2YV0gPSAweDAw OworICAgIHBjaV9jb25mWzB4NmJdID0gMHgwMDsgIC8vIFVTQkxFR1NVUAorICAgIHBjaV9j b25mWzB4NmNdID0gMHgwMDsKKyAgICBwY2lfY29uZlsweDZkXSA9IDB4MDA7CisgICAgcGNp X2NvbmZbMHg2ZV0gPSAweDAwOworICAgIHBjaV9jb25mWzB4NmZdID0gMHhjMDsgIC8vIFVT QkxFRkNUTFNUUworCisgICAgcy0+bW1pb1sweDAwXSA9IE9QUkVHQkFTRTsKKyAgICBzLT5t bWlvWzB4MDFdID0gMHgwMDsKKyAgICBzLT5tbWlvWzB4MDJdID0gMHgwMDsKKyAgICBzLT5t bWlvWzB4MDNdID0gMHgwMTsgICAgLy8gSEMgdmVyc2lvbgorICAgIHMtPm1taW9bMHgwNF0g PSBOQl9QT1JUUzsgIC8vIE51bWJlciBvZiBkb3duc3RyZWFtIHBvcnRzCisgICAgcy0+bW1p b1sweDA1XSA9IDB4MDA7ICAgIC8vIE5vIGNvbXBhbmlvbiBwb3J0cyBhdCBwcmVzZW50Cisg ICAgcy0+bW1pb1sweDA2XSA9IDB4MDA7CisgICAgcy0+bW1pb1sweDA3XSA9IDB4MDA7Cisg ICAgcy0+bW1pb1sweDA4XSA9IDB4ODA7ICAgIC8vIFdlIGNhbiBjYWNoZSB3aG9sZSBmcmFt ZSwgbm90IDY0LWJpdCBjYXBhYmxlCisgICAgcy0+bW1pb1sweDA5XSA9IDB4Njg7ICAgIC8v IEVFQ1AKKyAgICBzLT5tbWlvWzB4MGFdID0gMHgwMDsKKyAgICBzLT5tbWlvWzB4MGJdID0g MHgwMDsKKworICAgIHMtPmlycSA9IHMtPmRldi5pcnFbMF07CisKKyAgICAvLyBUT0RPIC0g cG9ydCByZWdpc3RyYXRpb24gaXMgZ29pbmcgdG8gbmVlZCBhbiBvdmVyaGF1bCBzaW5jZSBw b3J0cworICAgIC8vIGNhbiBiZSBsb3csIGZ1bGwgb3IgaGlnaCBzcGVlZCBhbmQgYXJlIG5v dCB0aWVkIHRvIFVIQ0kgb3IgRUhDSS4KKyAgICAvLyBUaGlzIHdvcmtzIGZvciBub3cgc2lu Y2Ugd2UgcmVnaXN0ZXIgbGFzdCBzbyBhcmUgdG9wIG9mIHRoZSBmcmVlCisgICAgLy8gbGlz dCBidXQgcmVhbGx5IGFsbCBwb3J0cyBuZWVkIHRvIGJlIG93bmVkIGJ5IEVIQ0kgYW5kIGl0 IHNob3VsZAorICAgIC8vIGhhbmQgb2ZmIHRvIGNvbXBhbmlvbiBjb250cm9sbGVycyBpZiBk ZXZpY2UgaXMgZnVsbCBvciBsb3cgc3BlZWQuCisKKyAgICBERUJVRygoImVoY2kgaW5pdCA6 IHJlZ2lzdGVyaW5nIFVTQiBwb3J0cyB3aXRoIG5vIGRldmljZSBhdHRhY2hlZFxuIikpOwor CisgICAgLy8gVE9ETyBjb21lIHVwIHdpdGggYSBiZXR0ZXIgcG9ydCBhbGxvY2F0aW9uIHNj aGVtZQorICAgIC8vIGFkZGVkIGVoY2ktPmJ1cywgbmVlZCB0byBmaW5kIGVoY2ktPkRldmlj ZVN0YXRlCisgICAgdXNiX2J1c19uZXcoJnMtPmJ1cywgJnMtPmRldi5xZGV2KTsKKyAgICBm b3IoaSA9IDA7IGkgPCBOQl9QT1JUUzsgaSsrKSB7CisgICAgICAgIHVzYl9yZWdpc3Rlcl9w b3J0KCZzLT5idXMsICZzLT5wb3J0c1tpXSwgcywgaSwgZWhjaV9hdHRhY2gpOworICAgICAg ICBzLT5wb3J0c1tpXS5kZXYgPSAwOworICAgIH0KKworICAgIHMtPmZyYW1lX3RpbWVyID0g cWVtdV9uZXdfdGltZXIodm1fY2xvY2ssIGVoY2lfZnJhbWVfdGltZXIsIHMpOworCisgICAg cWVtdV9yZWdpc3Rlcl9yZXNldChlaGNpX3Jlc2V0LCBzKTsKKworICAgIHMtPm1lbSA9IGNw dV9yZWdpc3Rlcl9pb19tZW1vcnkoZWhjaV9yZWFkZm4sIGVoY2lfd3JpdGVmbiwgcyk7CisK KyAgICBERUJVRygoImVoY2kgaW5pdCA6IHJlZ2lzdGVyaW5nIE1NSU8gc2l6ZSAlZFxuIiwg TU1JT19TSVpFKSk7CisgICAgcGNpX3JlZ2lzdGVyX2Jhcigmcy0+ZGV2LCAwLCBNTUlPX1NJ WkUsIFBDSV9CQVNFX0FERFJFU1NfU1BBQ0VfTUVNT1JZLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWhjaV9tYXApOwor CisgICAgREVCVUcoKCIqKiogZWhjaSBpbml0IDogdW5kZXIgZGV2ZWxvcG1lbnQgMTYtT0NU LTA4ICoqKiBcbiIpKTsKKworICAgIHJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBlaGNp X3JlZ2lzdGVyKHZvaWQpCit7CisgICAgcGNpX3FkZXZfcmVnaXN0ZXJfbWFueShlaGNpX2lu Zm8pOworfQorZGV2aWNlX2luaXQoZWhjaV9yZWdpc3Rlcik7CisKK3ZvaWQgdXNiX2VoY2lf aW5pdChQQ0lCdXMgKmJ1cywgaW50IGRldmZuKQoreworICAgIHBjaV9jcmVhdGVfc2ltcGxl KGJ1cywgZGV2Zm4sICJ1c2ItZWhjaSIpOworfQorCisvKgorICogdmltOiBleHBhbmR0YWIg dHM9NAorICovCmRpZmYgLS1naXQgYS9ody91c2ItZWhjaS5oIGIvaHcvdXNiLWVoY2kuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xNWQ3NGQyCi0tLSAvZGV2L251 bGwKKysrIGIvaHcvdXNiLWVoY2kuaApAQCAtMCwwICsxLDkgQEAKKyNpZm5kZWYgUUVNVV9V U0JfRUhDSV9ICisjZGVmaW5lIFFFTVVfVVNCX0VIQ0lfSAorCisjaW5jbHVkZSAicWVtdS1j b21tb24uaCIKKwordm9pZCB1c2JfZWhjaV9pbmZvKE1vbml0b3IgKm1vbik7Cit2b2lkIHVz Yl9laGNpX2luaXQoUENJQnVzICpidXMsIGludCBkZXZmbik7CisKKyNlbmRpZgpkaWZmIC0t Z2l0IGEvbW9uaXRvci5jIGIvbW9uaXRvci5jCmluZGV4IGE0OWUzZjAuLmFlNGZmMWYgMTAw NjQ0Ci0tLSBhL21vbml0b3IuYworKysgYi9tb25pdG9yLmMKQEAgLTI1LDYgKzI1LDcgQEAK ICNpbmNsdWRlICJody9ody5oIgogI2luY2x1ZGUgImh3L3FkZXYuaCIKICNpbmNsdWRlICJo dy91c2IuaCIKKyNpbmNsdWRlICJody91c2ItZWhjaS5oIgogI2luY2x1ZGUgImh3L3BjbWNp YS5oIgogI2luY2x1ZGUgImh3L3BjLmgiCiAjaW5jbHVkZSAiaHcvcGNpLmgiCkBAIC0yNzUy LDYgKzI3NTMsMTMgQEAgc3RhdGljIGNvbnN0IG1vbl9jbWRfdCBpbmZvX2NtZHNbXSA9IHsK ICAgICAgICAgLm1oYW5kbGVyLmluZm8gPSB1c2JfaG9zdF9pbmZvLAogICAgIH0sCiAgICAg eworICAgICAgICAubmFtZSAgICAgICA9ICJ1c2JlaGNpIiwKKyAgICAgICAgLmFyZ3NfdHlw ZSAgPSAiIiwKKyAgICAgICAgLnBhcmFtcyAgICAgPSAiIiwKKyAgICAgICAgLmhlbHAgICAg ICAgPSAic2hvdyBlaGNpIHN0YXR1cyIsCisgICAgICAgIC5taGFuZGxlci5pbmZvID0gdXNi X2VoY2lfaW5mbywKKyAgICB9LAorICAgIHsKICAgICAgICAgLm5hbWUgICAgICAgPSAicHJv ZmlsZSIsCiAgICAgICAgIC5hcmdzX3R5cGUgID0gIiIsCiAgICAgICAgIC5wYXJhbXMgICAg ID0gIiIsCg== --------------090505010901090803000005-- From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NmyIL-0001R0-HU for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:48:01 -0500 Received: from [199.232.76.173] (port=34226 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NmyIL-0001QJ-58 for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:48:01 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NmyIJ-00006P-5R for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:48:00 -0500 Received: from fmmailgate03.web.de ([217.72.192.234]:55137) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NmyII-00006H-Ik for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:47:58 -0500 Message-ID: <4B8EF509.4030409@web.de> Date: Thu, 04 Mar 2010 00:47:21 +0100 From: Jan Kiszka MIME-Version: 1.0 Subject: Re: [Qemu-devel] Re: EHCI support in QEMU References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> <4B8C2EFF.3030106@web.de> <4B8CED08.2030705@redhat.com> <1b51b6f81003030321g6a3eb47ak6a59267cae50b7f2@mail.gmail.com> <4B8EE632.7090303@cisco.com> In-Reply-To: <4B8EE632.7090303@cisco.com> Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="------------enigF87CFA07237F6DB107A17482" Sender: jan.kiszka@web.de List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: "David S. Ahern" Cc: Taimoor Mirza , Kevin Wolf , Niels de Vos , qemu-devel@nongnu.org This is an OpenPGP/MIME signed message (RFC 2440 and 3156) --------------enigF87CFA07237F6DB107A17482 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable David S. Ahern wrote: > On 03/03/2010 04:21 AM, Niels de Vos wrote: >> On Tue, Mar 2, 2010 at 10:48 AM, Kevin Wolf wrote: >>> Am 01.03.2010 22:17, schrieb Jan Kiszka: >>>> Niels de Vos wrote: >>>>> If someone is interested in this partially ported patch, I'm happy = to >>>>> share, but it will at least need some attention to make it compile.= >>>>> After that, lots of tests need to be done and probably quite some >>>>> bugfixes are required. I'm happy to assist, but do not have a lot o= f >>>>> time to spare on this hobby project. On the occasion that it is som= ething >>>>> more solid and starting to do something, I will of course inform th= is list >>>>> again. >>>> OK, to keep this heavy ball rolling, I would suggest posting your pa= tch. >>>> Either it's already in a good shape to get it merged as experimental= >>>> feature. Or I will pick it up in git tree, collect patches as they f= ly >>>> in, and will keep on pushing it upstream. I can't promise spending m= uch >>>> time on hacking, but integration work, basic testing, and some more = or >>>> less helpful comments should be feasible. >>> Yes, please post it. I won't promise anything either, but maybe I can= >>> find some time to help a bit. Anyway, I'd love to see EHCI in qemu. >> Okay, here it is. Please note that the patch is very raw, does not >> compile and even basic things like indention is broken at the moment. >> Please refer to >> http://lists.gnu.org/archive/html/qemu-devel/2008-10/msg01326.html for= >> the original author, nothing seriously of this patch is done by me. >> >> Kind regards and thanks for your help, >> Niels >=20 > FWIW: the attached compiles and qemu does not die (patch created agains= t > qemu-kvm.git but applies to qemu.git as well). For now I disabled uhci > so that the device is attached to the ehci bus. I can attach a usb key,= > but lsusb in the guest (fedora core 12) does not show it. >=20 Thanks for your work, David and Niels! I assume that David based this on Niels' patch, so there is nothing to be merged? David's version built for me, so I pushed git://git.kiszka.org/qemu.git ehci So far it's supposed to be a reference for anyone interested in this topic, willing to test or even to hack on it. I will collect and merge improvements as they are sent to the list. Jan --------------enigF87CFA07237F6DB107A17482 Content-Type: application/pgp-signature; name="signature.asc" Content-Description: OpenPGP digital signature Content-Disposition: attachment; filename="signature.asc" -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.9 (GNU/Linux) Comment: Using GnuPG with SUSE - http://enigmail.mozdev.org iEYEARECAAYFAkuO9QkACgkQitSsb3rl5xTbOwCgln0UkLJ4rQWe6mJ5u+RPJGcK GSoAoOvVCYv3jdXqG052WdZWgWYzqSin =5mng -----END PGP SIGNATURE----- --------------enigF87CFA07237F6DB107A17482-- From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NmySQ-0006vM-SD for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:58:26 -0500 Received: from [199.232.76.173] (port=49838 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NmySQ-0006vE-Ec for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:58:26 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NmySP-0001CC-Fw for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:58:26 -0500 Received: from sj-iport-1.cisco.com ([171.71.176.70]:46746) by monty-python.gnu.org with esmtps (TLS-1.0:RSA_ARCFOUR_SHA1:16) (Exim 4.60) (envelope-from ) id 1NmySP-0001C4-1x for qemu-devel@nongnu.org; Wed, 03 Mar 2010 18:58:25 -0500 Message-ID: <4B8EF79E.1000201@cisco.com> Date: Wed, 03 Mar 2010 16:58:22 -0700 From: "David S. Ahern" MIME-Version: 1.0 Subject: Re: [Qemu-devel] Re: EHCI support in QEMU References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> <4B8C2EFF.3030106@web.de> <4B8CED08.2030705@redhat.com> <1b51b6f81003030321g6a3eb47ak6a59267cae50b7f2@mail.gmail.com> <4B8EE632.7090303@cisco.com> <4B8EF509.4030409@web.de> In-Reply-To: <4B8EF509.4030409@web.de> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Jan Kiszka Cc: Taimoor Mirza , Kevin Wolf , Niels de Vos , qemu-devel@nongnu.org On 03/03/2010 04:47 PM, Jan Kiszka wrote: > > Thanks for your work, David and Niels! I assume that David based this on > Niels' patch, so there is nothing to be merged? David's version built > for me, so I pushed > > git://git.kiszka.org/qemu.git ehci > > So far it's supposed to be a reference for anyone interested in this > topic, willing to test or even to hack on it. I will collect and merge > improvements as they are sent to the list. > > Jan > Yes, I took Niels post as a start. Addressed a few white space issues, made some of the initializations parallel the uhci code and removed the mem_base from the read/write functions (causing segfaults due to outbounds referencing -- addr > MMIO_SIZE -- and do not appear to be needed). David From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NnCux-0000kK-Ml for qemu-devel@nongnu.org; Thu, 04 Mar 2010 10:24:51 -0500 Received: from [199.232.76.173] (port=52540 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NnCux-0000jz-8a for qemu-devel@nongnu.org; Thu, 04 Mar 2010 10:24:51 -0500 Received: from Debian-exim by monty-python.gnu.org with spam-scanned (Exim 4.60) (envelope-from ) id 1NnCuv-0003U8-21 for qemu-devel@nongnu.org; Thu, 04 Mar 2010 10:24:50 -0500 Received: from mail-ew0-f219.google.com ([209.85.219.219]:62518) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NnCuu-0003TB-3r for qemu-devel@nongnu.org; Thu, 04 Mar 2010 10:24:48 -0500 Received: by ewy19 with SMTP id 19so2938785ewy.2 for ; Thu, 04 Mar 2010 07:24:44 -0800 (PST) MIME-Version: 1.0 Sender: niels@nixpanic.net In-Reply-To: <4B8EF79E.1000201@cisco.com> References: <4B7915B4.6040305@siemens.com> <1b51b6f81003011230pc6e5238odc48948a617e261f@mail.gmail.com> <4B8C2EFF.3030106@web.de> <4B8CED08.2030705@redhat.com> <1b51b6f81003030321g6a3eb47ak6a59267cae50b7f2@mail.gmail.com> <4B8EE632.7090303@cisco.com> <4B8EF509.4030409@web.de> <4B8EF79E.1000201@cisco.com> Date: Thu, 4 Mar 2010 15:24:44 +0000 Message-ID: <1b51b6f81003040724r33dafe5dqa89fb213a495f877@mail.gmail.com> Subject: Re: [Qemu-devel] Re: EHCI support in QEMU From: Niels de Vos Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Jan Kiszka , "David S. Ahern" Cc: Taimoor Mirza , Kevin Wolf , qemu-devel@nongnu.org On Wed, Mar 3, 2010 at 11:58 PM, David S. Ahern wrote: > On 03/03/2010 04:47 PM, Jan Kiszka wrote: >> >> Thanks for your work, David and Niels! I assume that David based this on >> Niels' patch, so there is nothing to be merged? David's version built >> for me, so I pushed >> >> =C2=A0 =C2=A0 =C2=A0 git://git.kiszka.org/qemu.git ehci >> >> So far it's supposed to be a reference for anyone interested in this >> topic, willing to test or even to hack on it. I will collect and merge >> improvements as they are sent to the list. >> >> Jan >> > > Yes, I took Niels post as a start. Addressed a few white space issues, > made some of the initializations parallel the uhci code and removed the > mem_base from the read/write functions (causing segfaults due to > outbounds referencing -- addr > MMIO_SIZE -- and do not appear to be > needed). Hi David and Jan, thanks, sounds really cool! I don't have any knowledge about the qemu internals, therefore the details would be too difficult for me anyway :) I'll keep an eye on the progress, and maybe I'll be able to test and contribute a it more later on. Cheers, Niels