From nobody Sat Aug 20 11:38:11 2022 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4M8xTF3K7wz4Z5SZ; Sat, 20 Aug 2022 11:38:25 +0000 (UTC) (envelope-from ganbold@gmail.com) Received: from mail-il1-x12c.google.com (mail-il1-x12c.google.com [IPv6:2607:f8b0:4864:20::12c]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (2048 bits) client-digest SHA256) (Client CN "smtp.gmail.com", Issuer "GTS CA 1D4" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4M8xTD3Rt6z45pR; Sat, 20 Aug 2022 11:38:24 +0000 (UTC) (envelope-from ganbold@gmail.com) Received: by mail-il1-x12c.google.com with SMTP id p9so3461404ilq.13; Sat, 20 Aug 2022 04:38:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc; bh=RdIwkWKAkBD6hh7axLesmy2WsYEDk4IC4bxJ01ewzj4=; b=E5lRzlGaZlwjp3qdSF0/iCurPPRVWxwCh3yMYKcT0/f7AR20qtib57ijH7EsG2wLvu PqBMCYDPut3Ta8Mhli3s26/SMKhvVBExAEW3+2ymCjaFpQoJ4yjOilnICXCZNduFSHvR gsLLearPdnzb3xr+oWRjT0xu5tYN2AjAreirJ+kVZqCXJIQVN5HwUUtrDd5M1k/yYtXO fBz5GD8ilxSA9sQRFrNhsNd1yHpHIl2K5u2lYyzb0Q2eoeBVNmpR+i7jz2My9A2uL+e/ P8kEB2ReDV6yFWLXvzkK8JNmV5/2YvWEmPbphfOGEgenU1qXOCJyTxUd0TNYRdLI9Fqf gCGw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc; bh=RdIwkWKAkBD6hh7axLesmy2WsYEDk4IC4bxJ01ewzj4=; b=sNZoQMYQ2UXZt7mcwhQFP4WV5tafxj/Bv4+OKxMnP6z9a/9pYlRhxBv2Ilv7rImFTN 1zAystdj297wt/qp2V8kKF1NV+EuS7FrEbDw4MSfE5cd40acjvUEzH7CCPT0KaNT7IoK w+1PUhkdvNSVe28N8I+nKqnQL5pIwQeBDxsZEo/ssSnGZxtnfIMdvPWPdFh9o34UmGsh tY1EvgVEwTYf3AktUgnx7wSx+73ofPQog0UB1Paq8CXqFM2Wxn0gvkJYQFM6ti0QYTEa NXdWxglSqYOfC1+elJmZWoF8p5mDllQR5y/LPbT0vgxxwk0JIgB9TCfn+l70+QQk1Kv/ enUQ== X-Gm-Message-State: ACgBeo2M3xF/e87AfJ2oKCS9yCFJvFU3CP1Z/+f7ajyHXZWhMBac1+/0 MxeZ+19d68rSpv/fHXl5FP++ddosqtp4ratqPzNdPmWUFlA= X-Google-Smtp-Source: AA6agR5Fo1A3cP0Nu3qBkCDdf+H6cLbTPgyRHhQpUTuu+8SwL4lem/GkVsXpMNrQg8R1IER650cnjUh+RVT/iAvA97M= X-Received: by 2002:a92:cc44:0:b0:2e8:a467:da0f with SMTP id t4-20020a92cc44000000b002e8a467da0fmr5838964ilq.11.1660995503224; Sat, 20 Aug 2022 04:38:23 -0700 (PDT) List-Id: Commit messages for all branches of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: Sender: owner-dev-commits-src-all@freebsd.org X-BeenThere: dev-commits-src-all@freebsd.org MIME-Version: 1.0 References: <202208201132.27KBWQPq086007@gitrepo.freebsd.org> In-Reply-To: <202208201132.27KBWQPq086007@gitrepo.freebsd.org> From: Ganbold Tsagaankhuu Date: Sat, 20 Aug 2022 19:38:11 +0800 Message-ID: Subject: Re: git: ec556724d7ad - main - Add interrupt handling to rk_gpio driver. To: Ganbold Tsagaankhuu Cc: src-committers@freebsd.org, dev-commits-src-all@freebsd.org, dev-commits-src-main@freebsd.org Content-Type: multipart/alternative; boundary="000000000000f17ad705e6aaa602" X-Rspamd-Queue-Id: 4M8xTD3Rt6z45pR X-Spamd-Bar: --- Authentication-Results: mx1.freebsd.org; dkim=pass header.d=gmail.com header.s=20210112 header.b=E5lRzlGa; dmarc=pass (policy=none) header.from=gmail.com; spf=pass (mx1.freebsd.org: domain of ganbold@gmail.com designates 2607:f8b0:4864:20::12c as permitted sender) smtp.mailfrom=ganbold@gmail.com X-Spamd-Result: default: False [-3.67 / 15.00]; NEURAL_HAM_LONG(-1.00)[-0.999]; NEURAL_HAM_SHORT(-0.98)[-0.976]; NEURAL_HAM_MEDIUM(-0.80)[-0.799]; DMARC_POLICY_ALLOW(-0.50)[gmail.com,none]; R_DKIM_ALLOW(-0.20)[gmail.com:s=20210112]; R_SPF_ALLOW(-0.20)[+ip6:2607:f8b0:4000::/36:c]; MIME_BASE64_TEXT(0.10)[]; MIME_GOOD(-0.10)[multipart/alternative,text/plain]; FREEFALL_USER(0.00)[ganbold]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; RCPT_COUNT_THREE(0.00)[4]; RCVD_IN_DNSWL_NONE(0.00)[2607:f8b0:4864:20::12c:from]; ARC_NA(0.00)[]; ASN(0.00)[asn:15169, ipnet:2607:f8b0::/32, country:US]; MLMMJ_DEST(0.00)[dev-commits-src-all@freebsd.org,dev-commits-src-main@freebsd.org]; DKIM_TRACE(0.00)[gmail.com:+]; MID_RHS_MATCH_FROMTLD(0.00)[]; FREEMAIL_FROM(0.00)[gmail.com]; DWL_DNSWL_NONE(0.00)[gmail.com:dkim]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+,1:+,2:~]; RCVD_TLS_LAST(0.00)[]; FREEMAIL_ENVFROM(0.00)[gmail.com]; RCVD_COUNT_TWO(0.00)[2] X-ThisMailContainsUnwantedMimeParts: N --000000000000f17ad705e6aaa602 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Sat, Aug 20, 2022 at 7:32 PM Ganbold Tsagaankhuu wrote: > The branch main has been updated by ganbold: > > URL: > https://cgit.FreeBSD.org/src/commit/?id=3Dec556724d7ad1ee117fe595728e73dc= 9ddf78048 > > commit ec556724d7ad1ee117fe595728e73dc9ddf78048 > Author: S=C3=B8ren Schmidt > AuthorDate: 2022-08-20 06:09:49 +0000 > Commit: Ganbold Tsagaankhuu > CommitDate: 2022-08-20 11:30:54 +0000 > > Add interrupt handling to rk_gpio driver. > Sorry, it was reviewed by manu and differential revision is https://reviews.freebsd.org/D36273 Probably I missed git arc ... command before pushing. Ganbold > --- > sys/arm64/rockchip/rk_gpio.c | 227 > ++++++++++++++++++++++++++++++++++++++++++- > 1 file changed, 226 insertions(+), 1 deletion(-) > > diff --git a/sys/arm64/rockchip/rk_gpio.c b/sys/arm64/rockchip/rk_gpio.c > index c9ad1c9ea1df..c3b1044df2f7 100644 > --- a/sys/arm64/rockchip/rk_gpio.c > +++ b/sys/arm64/rockchip/rk_gpio.c > @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); > > #include > #include > +#include > #include > #include > #include > @@ -51,6 +52,7 @@ __FBSDID("$FreeBSD$"); > #include > > #include "gpio_if.h" > +#include "pic_if.h" > > #include "fdt_pinctrl_if.h" > > @@ -73,7 +75,9 @@ enum gpio_regs { > #define RK_GPIO_LS_SYNC 0x60 /* Level sensitive > syncronization enable register */ > > #define RK_GPIO_DEFAULT_CAPS (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT > | \ > - GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN) > + GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN | GPIO_INTR_EDGE_BOTH | \ > + GPIO_INTR_EDGE_RISING | GPIO_INTR_EDGE_FALLING | \ > + GPIO_INTR_LEVEL_HIGH | GPIO_INTR_LEVEL_LOW) > > #define GPIO_FLAGS_PINCTRL GPIO_PIN_PULLUP | GPIO_PIN_PULLDO= WN > #define RK_GPIO_MAX_PINS 32 > @@ -83,6 +87,12 @@ struct pin_cached { > uint32_t flags; > }; > > +struct rk_pin_irqsrc { > + struct intr_irqsrc isrc; > + uint32_t irq; > + uint32_t mode; > +}; > + > struct rk_gpio_softc { > device_t sc_dev; > device_t sc_busdev; > @@ -97,6 +107,8 @@ struct rk_gpio_softc { > uint32_t version; > struct pin_cached pin_cached[RK_GPIO_MAX_PINS]; > uint8_t regs[RK_GPIO_REGNUM]; > + void *ihandle; > + struct rk_pin_irqsrc isrcs[RK_GPIO_MAX_PINS]; > }; > > static struct ofw_compat_data compat_data[] =3D { > @@ -113,6 +125,7 @@ static struct resource_spec rk_gpio_spec[] =3D { > #define RK_GPIO_VERSION 0x78 > #define RK_GPIO_TYPE_V1 0x00000000 > #define RK_GPIO_TYPE_V2 0x01000c2b > +#define RK_GPIO_ISRC(sc, irq) (&(sc->isrcs[irq].isrc)) > > static int rk_gpio_detach(device_t dev); > > @@ -141,6 +154,29 @@ rk_gpio_read_bit(struct rk_gpio_softc *sc, int reg, > int bit) > return (value & 1); > } > > +static void > +rk_gpio_write_bit(struct rk_gpio_softc *sc, int reg, int bit, int data) > +{ > + int offset =3D sc->regs[reg]; > + uint32_t value; > + > + if (sc->version =3D=3D RK_GPIO_TYPE_V1) { > + value =3D RK_GPIO_READ(sc, offset); > + if (data) > + value |=3D (1 << bit); > + else > + value &=3D ~(1 << bit); > + RK_GPIO_WRITE(sc, offset, value); > + } else { > + if (data) > + value =3D (1 << (bit % 16)); > + else > + value =3D 0; > + value |=3D (1 << ((bit % 16) + 16)); > + RK_GPIO_WRITE(sc, bit > 15 ? offset + 4 : offset, value); > + } > +} > + > static uint32_t > rk_gpio_read_4(struct rk_gpio_softc *sc, int reg) > { > @@ -168,6 +204,43 @@ rk_gpio_write_4(struct rk_gpio_softc *sc, int reg, > uint32_t value) > } > } > > +static int > +rk_gpio_intr(void *arg) > +{ > + struct rk_gpio_softc *sc =3D (struct rk_gpio_softc *)arg;; > + struct trapframe *tf =3D curthread->td_intr_frame; > + uint32_t status; > + > + RK_GPIO_LOCK(sc); > + status =3D rk_gpio_read_4(sc, RK_GPIO_INT_STATUS); > + rk_gpio_write_4(sc, RK_GPIO_PORTA_EOI, status); > + RK_GPIO_UNLOCK(sc); > + > + while (status) { > + int pin =3D ffs(status) - 1; > + > + status &=3D ~(1 << pin); > + if (intr_isrc_dispatch(RK_GPIO_ISRC(sc, pin), tf)) { > + device_printf(sc->sc_dev, "Interrupt pin=3D%d > unhandled\n", > + pin); > + continue; > + } > + > + if ((sc->version =3D=3D RK_GPIO_TYPE_V1) && > + (sc->isrcs[pin].mode & GPIO_INTR_EDGE_BOTH)) { > + RK_GPIO_LOCK(sc); > + if (rk_gpio_read_bit(sc, RK_GPIO_EXT_PORTA, pin)) > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARIT= Y, > + (1 << pin), 0); > + else > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARIT= Y, > + (1 << pin), 1); > + RK_GPIO_UNLOCK(sc); > + } > + } > + return (FILTER_HANDLED); > +} > + > static int > rk_gpio_probe(device_t dev) > { > @@ -221,6 +294,15 @@ rk_gpio_attach(device_t dev) > rk_gpio_detach(dev); > return (ENXIO); > } > + > + if ((err =3D bus_setup_intr(dev, sc->sc_res[1], > + INTR_TYPE_MISC | INTR_MPSAFE, rk_gpio_intr, NULL, > + sc, &sc->ihandle))) { > + device_printf(dev, "Can not setup IRQ\n"); > + rk_gpio_detach(dev); > + return (ENXIO); > + } > + > RK_GPIO_LOCK(sc); > sc->version =3D rk_gpio_read_4(sc, RK_GPIO_VERSION); > RK_GPIO_UNLOCK(sc); > @@ -259,6 +341,23 @@ rk_gpio_attach(device_t dev) > return (ENXIO); > } > > + for (i =3D 0; i < RK_GPIO_MAX_PINS; i++) { > + sc->isrcs[i].irq =3D i; > + sc->isrcs[i].mode =3D GPIO_INTR_CONFORM; > + if ((err =3D intr_isrc_register(RK_GPIO_ISRC(sc, i), > + dev, 0, "%s", device_get_nameunit(dev)))) { > + device_printf(dev, "Can not register isrc %d\n", > err); > + rk_gpio_detach(dev); > + return (ENXIO); > + } > + } > + > + if (intr_pic_register(dev, OF_xref_from_node(node)) =3D=3D NULL) = { > + device_printf(dev, "Can not register pic\n"); > + rk_gpio_detach(dev); > + return (ENXIO); > + } > + > sc->sc_busdev =3D gpiobus_attach_bus(dev); > if (sc->sc_busdev =3D=3D NULL) { > rk_gpio_detach(dev); > @@ -549,6 +648,127 @@ rk_gpio_get_node(device_t bus, device_t dev) > return (ofw_bus_get_node(bus)); > } > > +static int > +rk_pic_map_intr(device_t dev, struct intr_map_data *data, > + struct intr_irqsrc **isrcp) > +{ > + struct rk_gpio_softc *sc =3D device_get_softc(dev); > + struct intr_map_data_gpio *gdata; > + uint32_t irq; > + > + if (data->type !=3D INTR_MAP_DATA_GPIO) { > + device_printf(dev, "Wrong type\n"); > + return (ENOTSUP); > + } > + gdata =3D (struct intr_map_data_gpio *)data; > + irq =3D gdata->gpio_pin_num; > + if (irq >=3D RK_GPIO_MAX_PINS) { > + device_printf(dev, "Invalid interrupt %u\n", irq); > + return (EINVAL); > + } > + *isrcp =3D RK_GPIO_ISRC(sc, irq); > + return (0); > +} > + > +static int > +rk_pic_setup_intr(device_t dev, struct intr_irqsrc *isrc, > + struct resource *res, struct intr_map_data *data) > +{ > + struct rk_gpio_softc *sc =3D device_get_softc(dev); > + struct rk_pin_irqsrc *rkisrc =3D (struct rk_pin_irqsrc *)isrc; > + struct intr_map_data_gpio *gdata; > + uint32_t mode; > + uint8_t pin; > + > + if (!data) { > + device_printf(dev, "No map data\n"); > + return (ENOTSUP); > + } > + gdata =3D (struct intr_map_data_gpio *)data; > + mode =3D gdata->gpio_intr_mode; > + pin =3D gdata->gpio_pin_num; > + > + if (rkisrc->irq !=3D gdata->gpio_pin_num) { > + device_printf(dev, "Interrupts don't match\n"); > + return (EINVAL); > + } > + > + if (isrc->isrc_handlers !=3D 0) { > + device_printf(dev, "Handler already attached\n"); > + return (rkisrc->mode =3D=3D mode ? 0 : EINVAL); > + } > + rkisrc->mode =3D mode; > + > + RK_GPIO_LOCK(sc); > + > + switch (mode & GPIO_INTR_MASK) { > + case GPIO_INTR_EDGE_RISING: > + rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 1); > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 1); > + break; > + case GPIO_INTR_EDGE_FALLING: > + rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 1); > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 0); > + break; > + case GPIO_INTR_EDGE_BOTH: > + rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 1); > + if (sc->version =3D=3D RK_GPIO_TYPE_V1) { > + if (rk_gpio_read_bit(sc, RK_GPIO_EXT_PORTA, pin)) > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARIT= Y, > + pin, 0); > + else > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARIT= Y, > + pin, 1); > + } else > + rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_BOTH, pin, > 1); > + break; > + case GPIO_INTR_LEVEL_HIGH: > + rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 1); > + break; > + case GPIO_INTR_LEVEL_LOW: > + rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 0); > + break; > + default: > + rk_gpio_write_bit(sc, RK_GPIO_INTMASK, pin, 1); > + rk_gpio_write_bit(sc, RK_GPIO_INTEN, pin, 0); > + RK_GPIO_UNLOCK(sc); > + return (EINVAL); > + } > + rk_gpio_write_bit(sc, RK_GPIO_DEBOUNCE, pin, 1); > + rk_gpio_write_bit(sc, RK_GPIO_INTMASK, pin, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTEN, pin, 1); > + RK_GPIO_UNLOCK(sc); > + > + return (0); > +} > + > +static int > +rk_pic_teardown_intr(device_t dev, struct intr_irqsrc *isrc, > + struct resource *res, struct intr_map_data *data) > +{ > + struct rk_gpio_softc *sc =3D device_get_softc(dev); > + struct rk_pin_irqsrc *irqsrc; > + > + irqsrc =3D (struct rk_pin_irqsrc *)isrc; > + > + if (isrc->isrc_handlers =3D=3D 0) { > + irqsrc->mode =3D GPIO_INTR_CONFORM; > + RK_GPIO_LOCK(sc); > + rk_gpio_write_bit(sc, RK_GPIO_INTEN, irqsrc->irq, 0); > + rk_gpio_write_bit(sc, RK_GPIO_INTMASK, irqsrc->irq, 0); > + rk_gpio_write_bit(sc, RK_GPIO_DEBOUNCE, irqsrc->irq, 0); > + RK_GPIO_UNLOCK(sc); > + } > + return (0); > +} > + > static device_method_t rk_gpio_methods[] =3D { > /* Device interface */ > DEVMETHOD(device_probe, rk_gpio_probe), > @@ -569,6 +789,11 @@ static device_method_t rk_gpio_methods[] =3D { > DEVMETHOD(gpio_pin_config_32, rk_gpio_pin_config_32), > DEVMETHOD(gpio_map_gpios, rk_gpio_map_gpios), > > + /* Interrupt controller interface */ > + DEVMETHOD(pic_map_intr, rk_pic_map_intr), > + DEVMETHOD(pic_setup_intr, rk_pic_setup_intr), > + DEVMETHOD(pic_teardown_intr, rk_pic_teardown_intr), > + > /* ofw_bus interface */ > DEVMETHOD(ofw_bus_get_node, rk_gpio_get_node), > > > --000000000000f17ad705e6aaa602 Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: base64 PGRpdiBkaXI9Imx0ciI+PGRpdiBjbGFzcz0iZ21haWxfcXVvdGUiPjxkaXYgZGlyPSJsdHIiIGNs YXNzPSJnbWFpbF9hdHRyIj5PbiBTYXQsIEF1ZyAyMCwgMjAyMiBhdCA3OjMyIFBNIEdhbmJvbGQg VHNhZ2FhbmtodXUgJmx0OzxhIGhyZWY9Im1haWx0bzpnYW5ib2xkQGZyZWVic2Qub3JnIj5nYW5i b2xkQGZyZWVic2Qub3JnPC9hPiZndDsgd3JvdGU6PGJyPjwvZGl2PjxibG9ja3F1b3RlIGNsYXNz PSJnbWFpbF9xdW90ZSIgc3R5bGU9Im1hcmdpbjowcHggMHB4IDBweCAwLjhleDtib3JkZXItbGVm dDoxcHggc29saWQgcmdiKDIwNCwyMDQsMjA0KTtwYWRkaW5nLWxlZnQ6MWV4Ij5UaGUgYnJhbmNo IG1haW4gaGFzIGJlZW4gdXBkYXRlZCBieSBnYW5ib2xkOjxicj4NCjxicj4NClVSTDogPGEgaHJl Zj0iaHR0cHM6Ly9jZ2l0LkZyZWVCU0Qub3JnL3NyYy9jb21taXQvP2lkPWVjNTU2NzI0ZDdhZDFl ZTExN2ZlNTk1NzI4ZTczZGM5ZGRmNzgwNDgiIHJlbD0ibm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxh bmsiPmh0dHBzOi8vY2dpdC5GcmVlQlNELm9yZy9zcmMvY29tbWl0Lz9pZD1lYzU1NjcyNGQ3YWQx ZWUxMTdmZTU5NTcyOGU3M2RjOWRkZjc4MDQ4PC9hPjxicj4NCjxicj4NCmNvbW1pdCBlYzU1Njcy NGQ3YWQxZWUxMTdmZTU5NTcyOGU3M2RjOWRkZjc4MDQ4PGJyPg0KQXV0aG9yOsKgIMKgIMKgU8O4 cmVuIFNjaG1pZHQgJmx0O3Nvc0BGcmVlQlNELm9yZyZndDs8YnI+DQpBdXRob3JEYXRlOiAyMDIy LTA4LTIwIDA2OjA5OjQ5ICswMDAwPGJyPg0KQ29tbWl0OsKgIMKgIMKgR2FuYm9sZCBUc2FnYWFu a2h1dSAmbHQ7Z2FuYm9sZEBGcmVlQlNELm9yZyZndDs8YnI+DQpDb21taXREYXRlOiAyMDIyLTA4 LTIwIDExOjMwOjU0ICswMDAwPGJyPg0KPGJyPg0KwqAgwqAgQWRkIGludGVycnVwdCBoYW5kbGlu ZyB0byBya19ncGlvIGRyaXZlci48YnI+PC9ibG9ja3F1b3RlPjxkaXY+PGJyPjwvZGl2PjxkaXY+ U29ycnksIGl0IHdhcyByZXZpZXdlZCBieSBtYW51IGFuZCBkaWZmZXJlbnRpYWwgcmV2aXNpb24g aXPCoDxhIGhyZWY9Imh0dHBzOi8vcmV2aWV3cy5mcmVlYnNkLm9yZy9EMzYyNzMiPmh0dHBzOi8v cmV2aWV3cy5mcmVlYnNkLm9yZy9EMzYyNzM8L2E+PC9kaXY+PGRpdj5Qcm9iYWJseSBJIG1pc3Nl ZCBnaXQgYXJjIC4uLiBjb21tYW5kIGJlZm9yZSBwdXNoaW5nLjwvZGl2PjxkaXY+PGJyPjwvZGl2 PjxkaXY+R2FuYm9sZDwvZGl2PjxkaXY+wqA8L2Rpdj48YmxvY2txdW90ZSBjbGFzcz0iZ21haWxf cXVvdGUiIHN0eWxlPSJtYXJnaW46MHB4IDBweCAwcHggMC44ZXg7Ym9yZGVyLWxlZnQ6MXB4IHNv bGlkIHJnYigyMDQsMjA0LDIwNCk7cGFkZGluZy1sZWZ0OjFleCI+DQotLS08YnI+DQrCoHN5cy9h cm02NC9yb2NrY2hpcC9ya19ncGlvLmMgfCAyMjcgKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrLTxicj4NCsKgMSBmaWxlIGNoYW5nZWQsIDIyNiBpbnNlcnRpb25zKCsp LCAxIGRlbGV0aW9uKC0pPGJyPg0KPGJyPg0KZGlmZiAtLWdpdCBhL3N5cy9hcm02NC9yb2NrY2hp cC9ya19ncGlvLmMgYi9zeXMvYXJtNjQvcm9ja2NoaXAvcmtfZ3Bpby5jPGJyPg0KaW5kZXggYzlh ZDFjOWVhMWRmLi5jM2IxMDQ0ZGYyZjcgMTAwNjQ0PGJyPg0KLS0tIGEvc3lzL2FybTY0L3JvY2tj aGlwL3JrX2dwaW8uYzxicj4NCisrKyBiL3N5cy9hcm02NC9yb2NrY2hpcC9ya19ncGlvLmM8YnI+ DQpAQCAtMzYsNiArMzYsNyBAQCBfX0ZCU0RJRCgmcXVvdDskRnJlZUJTRCQmcXVvdDspOzxicj4N Cjxicj4NCsKgI2luY2x1ZGUgJmx0O3N5cy9rZXJuZWwuaCZndDs8YnI+DQrCoCNpbmNsdWRlICZs dDtzeXMvbW9kdWxlLmgmZ3Q7PGJyPg0KKyNpbmNsdWRlICZsdDtzeXMvcHJvYy5oJmd0Ozxicj4N CsKgI2luY2x1ZGUgJmx0O3N5cy9ybWFuLmgmZ3Q7PGJyPg0KwqAjaW5jbHVkZSAmbHQ7c3lzL2xv Y2suaCZndDs8YnI+DQrCoCNpbmNsdWRlICZsdDtzeXMvbXV0ZXguaCZndDs8YnI+DQpAQCAtNTEs NiArNTIsNyBAQCBfX0ZCU0RJRCgmcXVvdDskRnJlZUJTRCQmcXVvdDspOzxicj4NCsKgI2luY2x1 ZGUgJmx0O2Rldi9leHRyZXMvY2xrL2Nsay5oJmd0Ozxicj4NCjxicj4NCsKgI2luY2x1ZGUgJnF1 b3Q7Z3Bpb19pZi5oJnF1b3Q7PGJyPg0KKyNpbmNsdWRlICZxdW90O3BpY19pZi5oJnF1b3Q7PGJy Pg0KPGJyPg0KwqAjaW5jbHVkZSAmcXVvdDtmZHRfcGluY3RybF9pZi5oJnF1b3Q7PGJyPg0KPGJy Pg0KQEAgLTczLDcgKzc1LDkgQEAgZW51bSBncGlvX3JlZ3Mgezxicj4NCsKgI2RlZmluZcKgIMKg IMKgIMKgIFJLX0dQSU9fTFNfU1lOQ8KgIMKgIMKgIMKgIMKgMHg2MMKgIMKgIC8qIExldmVsIHNl bnNpdGl2ZSBzeW5jcm9uaXphdGlvbiBlbmFibGUgcmVnaXN0ZXIgKi88YnI+DQo8YnI+DQrCoCNk ZWZpbmXCoCDCoCDCoCDCoCBSS19HUElPX0RFRkFVTFRfQ0FQU8KgIMKgIChHUElPX1BJTl9JTlBV VCB8IEdQSU9fUElOX09VVFBVVCB8wqAgwqAgwqBcPGJyPg0KLcKgIMKgIEdQSU9fUElOX1BVTExV UCB8IEdQSU9fUElOX1BVTExET1dOKTxicj4NCivCoCDCoCBHUElPX1BJTl9QVUxMVVAgfCBHUElP X1BJTl9QVUxMRE9XTiB8IEdQSU9fSU5UUl9FREdFX0JPVEggfCBcPGJyPg0KK8KgIMKgIEdQSU9f SU5UUl9FREdFX1JJU0lORyB8IEdQSU9fSU5UUl9FREdFX0ZBTExJTkcgfCBcPGJyPg0KK8KgIMKg IEdQSU9fSU5UUl9MRVZFTF9ISUdIIHwgR1BJT19JTlRSX0xFVkVMX0xPVyk8YnI+DQo8YnI+DQrC oCNkZWZpbmXCoCDCoCDCoCDCoCBHUElPX0ZMQUdTX1BJTkNUUkzCoCDCoCDCoCBHUElPX1BJTl9Q VUxMVVAgfCBHUElPX1BJTl9QVUxMRE9XTjxicj4NCsKgI2RlZmluZcKgIMKgIMKgIMKgIFJLX0dQ SU9fTUFYX1BJTlPCoCDCoCDCoCDCoCAzMjxicj4NCkBAIC04Myw2ICs4NywxMiBAQCBzdHJ1Y3Qg cGluX2NhY2hlZCB7PGJyPg0KwqAgwqAgwqAgwqAgdWludDMyX3TCoCDCoCDCoCDCoCBmbGFnczs8 YnI+DQrCoH07PGJyPg0KPGJyPg0KK3N0cnVjdCBya19waW5faXJxc3JjIHs8YnI+DQorwqAgwqAg wqAgwqBzdHJ1Y3QgaW50cl9pcnFzcmPCoCDCoCDCoCBpc3JjOzxicj4NCivCoCDCoCDCoCDCoHVp bnQzMl90wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgaXJxOzxicj4NCivCoCDCoCDCoCDCoHVpbnQz Ml90wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgbW9kZTs8YnI+DQorfTs8YnI+DQorPGJyPg0KwqBz dHJ1Y3QgcmtfZ3Bpb19zb2Z0YyB7PGJyPg0KwqAgwqAgwqAgwqAgZGV2aWNlX3TCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCBzY19kZXY7PGJyPg0KwqAgwqAgwqAgwqAgZGV2aWNlX3TCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCBzY19idXNkZXY7PGJyPg0KQEAgLTk3LDYgKzEwNyw4IEBAIHN0cnVjdCBy a19ncGlvX3NvZnRjIHs8YnI+DQrCoCDCoCDCoCDCoCB1aW50MzJfdMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIHZlcnNpb247PGJyPg0KwqAgwqAgwqAgwqAgc3RydWN0IHBpbl9jYWNoZWTCoCDCoCDC oCDCoHBpbl9jYWNoZWRbUktfR1BJT19NQVhfUElOU107PGJyPg0KwqAgwqAgwqAgwqAgdWludDhf dMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmVnc1tSS19HUElPX1JFR05VTV07PGJyPg0KK8Kg IMKgIMKgIMKgdm9pZMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgICppaGFuZGxlOzxicj4N CivCoCDCoCDCoCDCoHN0cnVjdCBya19waW5faXJxc3JjwqAgwqAgaXNyY3NbUktfR1BJT19NQVhf UElOU107PGJyPg0KwqB9Ozxicj4NCjxicj4NCsKgc3RhdGljIHN0cnVjdCBvZndfY29tcGF0X2Rh dGEgY29tcGF0X2RhdGFbXSA9IHs8YnI+DQpAQCAtMTEzLDYgKzEyNSw3IEBAIHN0YXRpYyBzdHJ1 Y3QgcmVzb3VyY2Vfc3BlYyBya19ncGlvX3NwZWNbXSA9IHs8YnI+DQrCoCNkZWZpbmXCoCDCoCDC oCDCoCBSS19HUElPX1ZFUlNJT07CoCDCoCDCoCDCoCDCoDB4Nzg8YnI+DQrCoCNkZWZpbmXCoCDC oCDCoCDCoCBSS19HUElPX1RZUEVfVjHCoCDCoCDCoCDCoCDCoDB4MDAwMDAwMDA8YnI+DQrCoCNk ZWZpbmXCoCDCoCDCoCDCoCBSS19HUElPX1RZUEVfVjLCoCDCoCDCoCDCoCDCoDB4MDEwMDBjMmI8 YnI+DQorI2RlZmluZcKgIMKgIMKgIMKgIFJLX0dQSU9fSVNSQyhzYywgaXJxKcKgIMKgKCZhbXA7 KHNjLSZndDtpc3Jjc1tpcnFdLmlzcmMpKTxicj4NCjxicj4NCsKgc3RhdGljIGludCBya19ncGlv X2RldGFjaChkZXZpY2VfdCBkZXYpOzxicj4NCjxicj4NCkBAIC0xNDEsNiArMTU0LDI5IEBAIHJr X2dwaW9fcmVhZF9iaXQoc3RydWN0IHJrX2dwaW9fc29mdGMgKnNjLCBpbnQgcmVnLCBpbnQgYml0 KTxicj4NCsKgIMKgIMKgIMKgIHJldHVybiAodmFsdWUgJmFtcDsgMSk7PGJyPg0KwqB9PGJyPg0K PGJyPg0KK3N0YXRpYyB2b2lkPGJyPg0KK3JrX2dwaW9fd3JpdGVfYml0KHN0cnVjdCBya19ncGlv X3NvZnRjICpzYywgaW50IHJlZywgaW50IGJpdCwgaW50IGRhdGEpPGJyPg0KK3s8YnI+DQorwqAg wqAgwqAgwqBpbnQgb2Zmc2V0ID0gc2MtJmd0O3JlZ3NbcmVnXTs8YnI+DQorwqAgwqAgwqAgwqB1 aW50MzJfdCB2YWx1ZTs8YnI+DQorPGJyPg0KK8KgIMKgIMKgIMKgaWYgKHNjLSZndDt2ZXJzaW9u ID09IFJLX0dQSU9fVFlQRV9WMSkgezxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHZhbHVl ID0gUktfR1BJT19SRUFEKHNjLCBvZmZzZXQpOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oGlmIChkYXRhKTxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHZhbHVl IHw9ICgxICZsdDsmbHQ7IGJpdCk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgZWxzZTxi cj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHZhbHVlICZhbXA7PSB+KDEg Jmx0OyZsdDsgYml0KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBSS19HUElPX1dSSVRF KHNjLCBvZmZzZXQsIHZhbHVlKTs8YnI+DQorwqAgwqAgwqAgwqB9IGVsc2Ugezxicj4NCivCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoGlmIChkYXRhKTxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoHZhbHVlID0gKDEgJmx0OyZsdDsgKGJpdCAlIDE2KSk7PGJyPg0KK8KgIMKg IMKgIMKgIMKgIMKgIMKgIMKgZWxzZTxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoHZhbHVlID0gMDs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqB2YWx1ZSB8PSAo MSAmbHQ7Jmx0OyAoKGJpdCAlIDE2KSArIDE2KSk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKg IMKgUktfR1BJT19XUklURShzYywgYml0ICZndDsgMTUgPyBvZmZzZXQgKyA0IDogb2Zmc2V0LCB2 YWx1ZSk7PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4NCit9PGJyPg0KKzxicj4NCsKgc3RhdGljIHVp bnQzMl90PGJyPg0KwqBya19ncGlvX3JlYWRfNChzdHJ1Y3QgcmtfZ3Bpb19zb2Z0YyAqc2MsIGlu dCByZWcpPGJyPg0KwqB7PGJyPg0KQEAgLTE2OCw2ICsyMDQsNDMgQEAgcmtfZ3Bpb193cml0ZV80 KHN0cnVjdCBya19ncGlvX3NvZnRjICpzYywgaW50IHJlZywgdWludDMyX3QgdmFsdWUpPGJyPg0K wqAgwqAgwqAgwqAgfTxicj4NCsKgfTxicj4NCjxicj4NCitzdGF0aWMgaW50PGJyPg0KK3JrX2dw aW9faW50cih2b2lkICphcmcpPGJyPg0KK3s8YnI+DQorwqAgwqAgwqAgwqBzdHJ1Y3QgcmtfZ3Bp b19zb2Z0YyAqc2MgPSAoc3RydWN0IHJrX2dwaW9fc29mdGMgKilhcmc7Ozxicj4NCivCoCDCoCDC oCDCoHN0cnVjdCB0cmFwZnJhbWUgKnRmID0gY3VydGhyZWFkLSZndDt0ZF9pbnRyX2ZyYW1lOzxi cj4NCivCoCDCoCDCoCDCoHVpbnQzMl90IHN0YXR1czs8YnI+DQorPGJyPg0KK8KgIMKgIMKgIMKg UktfR1BJT19MT0NLKHNjKTs8YnI+DQorwqAgwqAgwqAgwqBzdGF0dXMgPSBya19ncGlvX3JlYWRf NChzYywgUktfR1BJT19JTlRfU1RBVFVTKTs8YnI+DQorwqAgwqAgwqAgwqBya19ncGlvX3dyaXRl XzQoc2MsIFJLX0dQSU9fUE9SVEFfRU9JLCBzdGF0dXMpOzxicj4NCivCoCDCoCDCoCDCoFJLX0dQ SU9fVU5MT0NLKHNjKTs8YnI+DQorPGJyPg0KK8KgIMKgIMKgIMKgd2hpbGUgKHN0YXR1cykgezxi cj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGludCBwaW4gPSBmZnMoc3RhdHVzKSAtIDE7PGJy Pg0KKzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHN0YXR1cyAmYW1wOz0gfigxICZsdDsm bHQ7IHBpbik7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaWYgKGludHJfaXNyY19kaXNw YXRjaChSS19HUElPX0lTUkMoc2MsIHBpbiksIHRmKSkgezxicj4NCivCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoGRldmljZV9wcmludGYoc2MtJmd0O3NjX2RldiwgJnF1b3Q7SW50 ZXJydXB0IHBpbj0lZCB1bmhhbmRsZWRcbiZxdW90Oyw8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBwaW4pOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoGNvbnRpbnVlOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoH08YnI+ DQorPGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaWYgKChzYy0mZ3Q7dmVyc2lvbiA9PSBS S19HUElPX1RZUEVfVjEpICZhbXA7JmFtcDs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAoc2MtJmd0O2lzcmNzW3Bpbl0ubW9kZSAmYW1wOyBHUElPX0lOVFJfRURHRV9CT1RIKSkg ezxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFJLX0dQSU9fTE9DSyhz Yyk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaWYgKHJrX2dwaW9f cmVhZF9iaXQoc2MsIFJLX0dQSU9fRVhUX1BPUlRBLCBwaW4pKTxicj4NCivCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJrX2dwaW9fd3JpdGVfYml0KHNjLCBS S19HUElPX0lOVF9QT0xBUklUWSw8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAoMSAmbHQ7Jmx0OyBwaW4pLCAwKTs8YnI+DQorwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBlbHNlPGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQoc2MsIFJLX0dQ SU9fSU5UX1BPTEFSSVRZLDxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCgxICZsdDsmbHQ7IHBpbiksIDEpOzxicj4NCivCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFJLX0dQSU9fVU5MT0NLKHNjKTs8YnI+DQorwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqB9PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4NCivCoCDCoCDCoCDCoHJl dHVybiAoRklMVEVSX0hBTkRMRUQpOzxicj4NCit9PGJyPg0KKzxicj4NCsKgc3RhdGljIGludDxi cj4NCsKgcmtfZ3Bpb19wcm9iZShkZXZpY2VfdCBkZXYpPGJyPg0KwqB7PGJyPg0KQEAgLTIyMSw2 ICsyOTQsMTUgQEAgcmtfZ3Bpb19hdHRhY2goZGV2aWNlX3QgZGV2KTxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIHJrX2dwaW9fZGV0YWNoKGRldik7PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgcmV0dXJuIChFTlhJTyk7PGJyPg0KwqAgwqAgwqAgwqAgfTxicj4NCis8YnI+DQorwqAg wqAgwqAgwqBpZiAoKGVyciA9IGJ1c19zZXR1cF9pbnRyKGRldiwgc2MtJmd0O3NjX3Jlc1sxXSw8 YnI+DQorwqAgwqAgwqAgwqAgwqAgwqBJTlRSX1RZUEVfTUlTQyB8IElOVFJfTVBTQUZFLCBya19n cGlvX2ludHIsIE5VTEwsPGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgc2MsICZhbXA7c2MtJmd0O2lo YW5kbGUpKSkgezxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGRldmljZV9wcmludGYoZGV2 LCAmcXVvdDtDYW4gbm90IHNldHVwIElSUVxuJnF1b3Q7KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqBya19ncGlvX2RldGFjaChkZXYpOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oHJldHVybiAoRU5YSU8pOzxicj4NCivCoCDCoCDCoCDCoH08YnI+DQorPGJyPg0KwqAgwqAgwqAg wqAgUktfR1BJT19MT0NLKHNjKTs8YnI+DQrCoCDCoCDCoCDCoCBzYy0mZ3Q7dmVyc2lvbiA9IHJr X2dwaW9fcmVhZF80KHNjLCBSS19HUElPX1ZFUlNJT04pOzxicj4NCsKgIMKgIMKgIMKgIFJLX0dQ SU9fVU5MT0NLKHNjKTs8YnI+DQpAQCAtMjU5LDYgKzM0MSwyMyBAQCBya19ncGlvX2F0dGFjaChk ZXZpY2VfdCBkZXYpPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgcmV0dXJuIChFTlhJTyk7 PGJyPg0KwqAgwqAgwqAgwqAgfTxicj4NCjxicj4NCivCoCDCoCDCoCDCoGZvciAoaSA9IDA7IGkg Jmx0OyBSS19HUElPX01BWF9QSU5TOyBpKyspIHs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqBzYy0mZ3Q7aXNyY3NbaV0uaXJxID0gaTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBz Yy0mZ3Q7aXNyY3NbaV0ubW9kZSA9IEdQSU9fSU5UUl9DT05GT1JNOzxicj4NCivCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoGlmICgoZXJyID0gaW50cl9pc3JjX3JlZ2lzdGVyKFJLX0dQSU9fSVNSQyhz YywgaSksPGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgZGV2LCAwLCAmcXVvdDsl cyZxdW90OywgZGV2aWNlX2dldF9uYW1ldW5pdChkZXYpKSkpIHs8YnI+DQorwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBkZXZpY2VfcHJpbnRmKGRldiwgJnF1b3Q7Q2FuIG5vdCBy ZWdpc3RlciBpc3JjICVkXG4mcXVvdDssIGVycik7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb19kZXRhY2goZGV2KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gKEVOWElPKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqB9PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4NCis8YnI+DQorwqAgwqAgwqAgwqBpZiAo aW50cl9waWNfcmVnaXN0ZXIoZGV2LCBPRl94cmVmX2Zyb21fbm9kZShub2RlKSkgPT0gTlVMTCkg ezxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGRldmljZV9wcmludGYoZGV2LCAmcXVvdDtD YW4gbm90IHJlZ2lzdGVyIHBpY1xuJnF1b3Q7KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqBya19ncGlvX2RldGFjaChkZXYpOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJldHVy biAoRU5YSU8pOzxicj4NCivCoCDCoCDCoCDCoH08YnI+DQorPGJyPg0KwqAgwqAgwqAgwqAgc2Mt Jmd0O3NjX2J1c2RldiA9IGdwaW9idXNfYXR0YWNoX2J1cyhkZXYpOzxicj4NCsKgIMKgIMKgIMKg IGlmIChzYy0mZ3Q7c2NfYnVzZGV2ID09IE5VTEwpIHs8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCBya19ncGlvX2RldGFjaChkZXYpOzxicj4NCkBAIC01NDksNiArNjQ4LDEyNyBAQCBya19n cGlvX2dldF9ub2RlKGRldmljZV90IGJ1cywgZGV2aWNlX3QgZGV2KTxicj4NCsKgIMKgIMKgIMKg IHJldHVybiAob2Z3X2J1c19nZXRfbm9kZShidXMpKTs8YnI+DQrCoH08YnI+DQo8YnI+DQorc3Rh dGljIGludDxicj4NCitya19waWNfbWFwX2ludHIoZGV2aWNlX3QgZGV2LCBzdHJ1Y3QgaW50cl9t YXBfZGF0YSAqZGF0YSw8YnI+DQorwqAgwqAgc3RydWN0IGludHJfaXJxc3JjICoqaXNyY3ApPGJy Pg0KK3s8YnI+DQorwqAgwqAgwqAgwqBzdHJ1Y3QgcmtfZ3Bpb19zb2Z0YyAqc2MgPSBkZXZpY2Vf Z2V0X3NvZnRjKGRldik7PGJyPg0KK8KgIMKgIMKgIMKgc3RydWN0IGludHJfbWFwX2RhdGFfZ3Bp byAqZ2RhdGE7PGJyPg0KK8KgIMKgIMKgIMKgdWludDMyX3QgaXJxOzxicj4NCis8YnI+DQorwqAg wqAgwqAgwqBpZiAoZGF0YS0mZ3Q7dHlwZSAhPSBJTlRSX01BUF9EQVRBX0dQSU8pIHs8YnI+DQor wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBkZXZpY2VfcHJpbnRmKGRldiwgJnF1b3Q7V3JvbmcgdHlw ZVxuJnF1b3Q7KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gKEVOT1RTVVAp Ozxicj4NCivCoCDCoCDCoCDCoH08YnI+DQorwqAgwqAgwqAgwqBnZGF0YSA9IChzdHJ1Y3QgaW50 cl9tYXBfZGF0YV9ncGlvICopZGF0YTs8YnI+DQorwqAgwqAgwqAgwqBpcnEgPSBnZGF0YS0mZ3Q7 Z3Bpb19waW5fbnVtOzxicj4NCivCoCDCoCDCoCDCoGlmIChpcnEgJmd0Oz0gUktfR1BJT19NQVhf UElOUykgezxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGRldmljZV9wcmludGYoZGV2LCAm cXVvdDtJbnZhbGlkIGludGVycnVwdCAldVxuJnF1b3Q7LCBpcnEpOzxicj4NCivCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoHJldHVybiAoRUlOVkFMKTs8YnI+DQorwqAgwqAgwqAgwqB9PGJyPg0KK8Kg IMKgIMKgIMKgKmlzcmNwID0gUktfR1BJT19JU1JDKHNjLCBpcnEpOzxicj4NCivCoCDCoCDCoCDC oHJldHVybiAoMCk7PGJyPg0KK308YnI+DQorPGJyPg0KK3N0YXRpYyBpbnQ8YnI+DQorcmtfcGlj X3NldHVwX2ludHIoZGV2aWNlX3QgZGV2LCBzdHJ1Y3QgaW50cl9pcnFzcmMgKmlzcmMsPGJyPg0K K8KgIMKgIHN0cnVjdCByZXNvdXJjZSAqcmVzLCBzdHJ1Y3QgaW50cl9tYXBfZGF0YSAqZGF0YSk8 YnI+DQorezxicj4NCivCoCDCoCDCoCDCoHN0cnVjdCBya19ncGlvX3NvZnRjICpzYyA9IGRldmlj ZV9nZXRfc29mdGMoZGV2KTs8YnI+DQorwqAgwqAgwqAgwqBzdHJ1Y3QgcmtfcGluX2lycXNyYyAq cmtpc3JjID0gKHN0cnVjdCBya19waW5faXJxc3JjICopaXNyYzs8YnI+DQorwqAgwqAgwqAgwqBz dHJ1Y3QgaW50cl9tYXBfZGF0YV9ncGlvICpnZGF0YTs8YnI+DQorwqAgwqAgwqAgwqB1aW50MzJf dCBtb2RlOzxicj4NCivCoCDCoCDCoCDCoHVpbnQ4X3QgcGluOzxicj4NCis8YnI+DQorwqAgwqAg wqAgwqBpZiAoIWRhdGEpIHs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBkZXZpY2VfcHJp bnRmKGRldiwgJnF1b3Q7Tm8gbWFwIGRhdGFcbiZxdW90Oyk7PGJyPg0KK8KgIMKgIMKgIMKgIMKg IMKgIMKgIMKgcmV0dXJuIChFTk9UU1VQKTs8YnI+DQorwqAgwqAgwqAgwqB9PGJyPg0KK8KgIMKg IMKgIMKgZ2RhdGEgPSAoc3RydWN0IGludHJfbWFwX2RhdGFfZ3BpbyAqKWRhdGE7PGJyPg0KK8Kg IMKgIMKgIMKgbW9kZSA9IGdkYXRhLSZndDtncGlvX2ludHJfbW9kZTs8YnI+DQorwqAgwqAgwqAg wqBwaW4gPSBnZGF0YS0mZ3Q7Z3Bpb19waW5fbnVtOzxicj4NCis8YnI+DQorwqAgwqAgwqAgwqBp ZiAocmtpc3JjLSZndDtpcnEgIT0gZ2RhdGEtJmd0O2dwaW9fcGluX251bSkgezxicj4NCivCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoGRldmljZV9wcmludGYoZGV2LCAmcXVvdDtJbnRlcnJ1cHRzIGRv biYjMzk7dCBtYXRjaFxuJnF1b3Q7KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1 cm4gKEVJTlZBTCk7PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4NCis8YnI+DQorwqAgwqAgwqAgwqBp ZiAoaXNyYy0mZ3Q7aXNyY19oYW5kbGVycyAhPSAwKSB7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKg IMKgIMKgZGV2aWNlX3ByaW50ZihkZXYsICZxdW90O0hhbmRsZXIgYWxyZWFkeSBhdHRhY2hlZFxu JnF1b3Q7KTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gKHJraXNyYy0mZ3Q7 bW9kZSA9PSBtb2RlID8gMCA6IEVJTlZBTCk7PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4NCivCoCDC oCDCoCDCoHJraXNyYy0mZ3Q7bW9kZSA9IG1vZGU7PGJyPg0KKzxicj4NCivCoCDCoCDCoCDCoFJL X0dQSU9fTE9DSyhzYyk7PGJyPg0KKzxicj4NCivCoCDCoCDCoCDCoHN3aXRjaCAobW9kZSAmYW1w OyBHUElPX0lOVFJfTUFTSykgezxicj4NCivCoCDCoCDCoCDCoGNhc2UgR1BJT19JTlRSX0VER0Vf UklTSU5HOjxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJrX2dwaW9fd3JpdGVfYml0KHNj LCBSS19HUElPX1NXUE9SVEFfRERSLCBwaW4sIDApOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoHJrX2dwaW9fd3JpdGVfYml0KHNjLCBSS19HUElPX0lOVFRZUEVfTEVWRUwsIHBpbiwgMSk7 PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQoc2MsIFJLX0dQ SU9fSU5UX1BPTEFSSVRZLCBwaW4sIDEpOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGJy ZWFrOzxicj4NCivCoCDCoCDCoCDCoGNhc2UgR1BJT19JTlRSX0VER0VfRkFMTElORzo8YnI+DQor wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBya19ncGlvX3dyaXRlX2JpdChzYywgUktfR1BJT19TV1BP UlRBX0REUiwgcGluLCAwKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBya19ncGlvX3dy aXRlX2JpdChzYywgUktfR1BJT19JTlRUWVBFX0xFVkVMLCBwaW4sIDEpOzxicj4NCivCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoHJrX2dwaW9fd3JpdGVfYml0KHNjLCBSS19HUElPX0lOVF9QT0xBUklU WSwgcGluLCAwKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBicmVhazs8YnI+DQorwqAg wqAgwqAgwqBjYXNlIEdQSU9fSU5UUl9FREdFX0JPVEg6PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKg IMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQoc2MsIFJLX0dQSU9fU1dQT1JUQV9ERFIsIHBpbiwgMCk7 PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQoc2MsIFJLX0dQ SU9fSU5UVFlQRV9MRVZFTCwgcGluLCAxKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBp ZiAoc2MtJmd0O3ZlcnNpb24gPT0gUktfR1BJT19UWVBFX1YxKSB7PGJyPg0KK8KgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaWYgKHJrX2dwaW9fcmVhZF9iaXQoc2MsIFJLX0dQSU9f RVhUX1BPUlRBLCBwaW4pKTxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoHJrX2dwaW9fd3JpdGVfYml0KHNjLCBSS19HUElPX0lOVF9QT0xBUklUWSw8 YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqBwaW4sIDApOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGVsc2U8 YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBya19n cGlvX3dyaXRlX2JpdChzYywgUktfR1BJT19JTlRfUE9MQVJJVFksPGJyPg0KK8KgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcGluLCAxKTs8YnI+DQor wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqB9IGVsc2U8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBya19ncGlvX3dyaXRlX2JpdChzYywgUktfR1BJT19JTlRUWVBFX0JPVEgs IHBpbiwgMSk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgYnJlYWs7PGJyPg0KK8KgIMKg IMKgIMKgY2FzZSBHUElPX0lOVFJfTEVWRUxfSElHSDo8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqBya19ncGlvX3dyaXRlX2JpdChzYywgUktfR1BJT19TV1BPUlRBX0REUiwgcGluLCAwKTs8 YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBya19ncGlvX3dyaXRlX2JpdChzYywgUktfR1BJ T19JTlRUWVBFX0xFVkVMLCBwaW4sIDApOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJr X2dwaW9fd3JpdGVfYml0KHNjLCBSS19HUElPX0lOVF9QT0xBUklUWSwgcGluLCAxKTs8YnI+DQor wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBicmVhazs8YnI+DQorwqAgwqAgwqAgwqBjYXNlIEdQSU9f SU5UUl9MRVZFTF9MT1c6PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0 ZV9iaXQoc2MsIFJLX0dQSU9fU1dQT1JUQV9ERFIsIHBpbiwgMCk7PGJyPg0KK8KgIMKgIMKgIMKg IMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQoc2MsIFJLX0dQSU9fSU5UVFlQRV9MRVZFTCwg cGluLCAwKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBya19ncGlvX3dyaXRlX2JpdChz YywgUktfR1BJT19JTlRfUE9MQVJJVFksIHBpbiwgMCk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKg IMKgIMKgYnJlYWs7PGJyPg0KK8KgIMKgIMKgIMKgZGVmYXVsdDo8YnI+DQorwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqBya19ncGlvX3dyaXRlX2JpdChzYywgUktfR1BJT19JTlRNQVNLLCBwaW4sIDEp Ozxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJrX2dwaW9fd3JpdGVfYml0KHNjLCBSS19H UElPX0lOVEVOLCBwaW4sIDApOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFJLX0dQSU9f VU5MT0NLKHNjKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gKEVJTlZBTCk7 PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4NCivCoCDCoCDCoCDCoHJrX2dwaW9fd3JpdGVfYml0KHNj LCBSS19HUElPX0RFQk9VTkNFLCBwaW4sIDEpOzxicj4NCivCoCDCoCDCoCDCoHJrX2dwaW9fd3Jp dGVfYml0KHNjLCBSS19HUElPX0lOVE1BU0ssIHBpbiwgMCk7PGJyPg0KK8KgIMKgIMKgIMKgcmtf Z3Bpb193cml0ZV9iaXQoc2MsIFJLX0dQSU9fSU5URU4sIHBpbiwgMSk7PGJyPg0KK8KgIMKgIMKg IMKgUktfR1BJT19VTkxPQ0soc2MpOzxicj4NCis8YnI+DQorwqAgwqAgwqAgwqByZXR1cm4gKDAp Ozxicj4NCit9PGJyPg0KKzxicj4NCitzdGF0aWMgaW50PGJyPg0KK3JrX3BpY190ZWFyZG93bl9p bnRyKGRldmljZV90IGRldiwgc3RydWN0IGludHJfaXJxc3JjICppc3JjLDxicj4NCivCoCDCoCBz dHJ1Y3QgcmVzb3VyY2UgKnJlcywgc3RydWN0IGludHJfbWFwX2RhdGEgKmRhdGEpPGJyPg0KK3s8 YnI+DQorwqAgwqAgwqAgwqBzdHJ1Y3QgcmtfZ3Bpb19zb2Z0YyAqc2MgPSBkZXZpY2VfZ2V0X3Nv ZnRjKGRldik7PGJyPg0KK8KgIMKgIMKgIMKgc3RydWN0IHJrX3Bpbl9pcnFzcmMgKmlycXNyYzs8 YnI+DQorPGJyPg0KK8KgIMKgIMKgIMKgaXJxc3JjID0gKHN0cnVjdCBya19waW5faXJxc3JjICop aXNyYzs8YnI+DQorPGJyPg0KK8KgIMKgIMKgIMKgaWYgKGlzcmMtJmd0O2lzcmNfaGFuZGxlcnMg PT0gMCkgezxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGlycXNyYy0mZ3Q7bW9kZSA9IEdQ SU9fSU5UUl9DT05GT1JNOzxicj4NCivCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFJLX0dQSU9fTE9D SyhzYyk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQoc2Ms IFJLX0dQSU9fSU5URU4sIGlycXNyYy0mZ3Q7aXJxLCAwKTs8YnI+DQorwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqBya19ncGlvX3dyaXRlX2JpdChzYywgUktfR1BJT19JTlRNQVNLLCBpcnFzcmMtJmd0 O2lycSwgMCk7PGJyPg0KK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb193cml0ZV9iaXQo c2MsIFJLX0dQSU9fREVCT1VOQ0UsIGlycXNyYy0mZ3Q7aXJxLCAwKTs8YnI+DQorwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBSS19HUElPX1VOTE9DSyhzYyk7PGJyPg0KK8KgIMKgIMKgIMKgfTxicj4N CivCoCDCoCDCoCDCoHJldHVybiAoMCk7PGJyPg0KK308YnI+DQorPGJyPg0KwqBzdGF0aWMgZGV2 aWNlX21ldGhvZF90IHJrX2dwaW9fbWV0aG9kc1tdID0gezxicj4NCsKgIMKgIMKgIMKgIC8qIERl dmljZSBpbnRlcmZhY2UgKi88YnI+DQrCoCDCoCDCoCDCoCBERVZNRVRIT0QoZGV2aWNlX3Byb2Jl LMKgIMKgIMKgIMKgIMKgcmtfZ3Bpb19wcm9iZSksPGJyPg0KQEAgLTU2OSw2ICs3ODksMTEgQEAg c3RhdGljIGRldmljZV9tZXRob2RfdCBya19ncGlvX21ldGhvZHNbXSA9IHs8YnI+DQrCoCDCoCDC oCDCoCBERVZNRVRIT0QoZ3Bpb19waW5fY29uZmlnXzMyLMKgIMKgcmtfZ3Bpb19waW5fY29uZmln XzMyKSw8YnI+DQrCoCDCoCDCoCDCoCBERVZNRVRIT0QoZ3Bpb19tYXBfZ3Bpb3MswqAgwqAgwqAg wqBya19ncGlvX21hcF9ncGlvcyksPGJyPg0KPGJyPg0KK8KgIMKgIMKgIMKgLyogSW50ZXJydXB0 IGNvbnRyb2xsZXIgaW50ZXJmYWNlICovPGJyPg0KK8KgIMKgIMKgIMKgREVWTUVUSE9EKHBpY19t YXBfaW50cizCoCDCoCDCoCDCoCDCoHJrX3BpY19tYXBfaW50ciksPGJyPg0KK8KgIMKgIMKgIMKg REVWTUVUSE9EKHBpY19zZXR1cF9pbnRyLMKgIMKgIMKgIMKgcmtfcGljX3NldHVwX2ludHIpLDxi cj4NCivCoCDCoCDCoCDCoERFVk1FVEhPRChwaWNfdGVhcmRvd25faW50cizCoCDCoCBya19waWNf dGVhcmRvd25faW50ciksPGJyPg0KKzxicj4NCsKgIMKgIMKgIMKgIC8qIG9md19idXMgaW50ZXJm YWNlICovPGJyPg0KwqAgwqAgwqAgwqAgREVWTUVUSE9EKG9md19idXNfZ2V0X25vZGUswqAgwqAg wqBya19ncGlvX2dldF9ub2RlKSw8YnI+DQo8YnI+DQo8YnI+DQo8L2Jsb2NrcXVvdGU+PC9kaXY+ PC9kaXY+DQo= --000000000000f17ad705e6aaa602--