From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail.bootlin.com ([62.4.15.54]) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1fZgp2-0003xF-Uf for linux-mtd@lists.infradead.org; Sun, 01 Jul 2018 18:11:43 +0000 Date: Sun, 1 Jul 2018 20:11:27 +0200 From: Miquel Raynal To: Boris Brezillon Cc: Richard Weinberger , linux-mtd@lists.infradead.org, David Woodhouse , Brian Norris , Marek Vasut , Mark Brown , linux-spi@vger.kernel.org, Rob Herring , Pawel Moll , Mark Rutland , Ian Campbell , Kumar Gala , devicetree@vger.kernel.org, Geert Uytterhoeven , Piotr Bugalski , Peter Pan , Frieder Schrempf , Julien Su , Mason Yang , Subject: Re: [PATCH v9 0/6] mtd: Add a SPI NAND driver Message-ID: <20180701201127.551d969c@xps13> In-Reply-To: <20180622122828.12939-1-boris.brezillon@bootlin.com> References: <20180622122828.12939-1-boris.brezillon@bootlin.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Hi Boris, Boris Brezillon wrote on Fri, 22 Jun 2018 14:28:22 +0200: > Hello, >=20 > Not much has changed in this v9 except for the addition of the macronix > driver. I mainly fixed bugs/issues reported by Miquel. >=20 > Mark, Rob, Geert, I dropped the controversial changes in the DT > bindings patch, since it's not something specific to SPI NAND, this > applies to SPI memory devices in general. >=20 > Thanks, >=20 > Boris >=20 > v9 changes: > - add support for 2 SPI NANDs from Macronix > - a few fixes and improvements (see the changelog in each patch) > - drop the doc describing generic SPI device props in the DT binding >=20 > v8 changes: > - dropped patch 1 which has been applied > - fix various bugs in the core (see changelog in patch 1) > - add a commit message to patch 4 >=20 > v7 changes: > - Use the spi-mem interface > - Add support for on-die ECC > - Add support for Winbond W25M02GV chip >=20 > v6 changes: > - includes generic NAND framework patches in series > - rebase on nand/next (commit 6076fd1e9d879521f7082a5e22185b71e480b777) > - remove on-die ECC support > - remove devm_free() since everything allocated by devm_kmalloc() will be > automatically freed when device is released > - add comment header for structs in spinand.h > - remove spinand_register()/unregister(), call spinand_detect() in > spinand_init() and only expose spinand_init()/cleanup() > - add nand_release_bbt() in bbt.c and use it in nand_cleanup() and > spinand_cleanup() > - use BIT(n) instead (1 << n) in macro of spinand.h > - rename spinand_alloc() to devm_spinand_alloc() > - name lables in better way > - fix some typos > - add empty lines between code blocks >=20 > v5 changes: > - rebase patch on nand/next with Boris's generic NAND framework patches[3] > - replace pr_xxx() with dev_xxx() > - replace kzalloc()i/kfree() with devm_kzalloc()/devm_kfree() > - rename spinand_op_init() to spinand_init_op() for consistency > - remove command opcode in function comments > - use BIT(n) instead (1 << n) in macro > - remove manufactures.c and put spinand_manufacturers table in core.c > - change spinand_write_reg() u8 *buf argument to u8 value, > since the length is always 1 > - remove spinand_manufacture->detect() check, since it is always !=3D NULL > - alloc spinand_ecc_engine struct in vendor.c when using on-die ECC > (for hardware ECC, it should be in controllers/*.c) > - add comment header for struct spinand_op > - fix timeout bug in spinand_wait(), thanks for Arnaud's debug > - make spinand_manufacturers const > - add ecc_engine_ops pointer in struct micron_spinand_info > - make controller->cap assignment right with SPI_TX/RX_QUAD/DUAL flag >=20 > v4 changes: > - initialize struct mtd_oob_ops to 0 in bbt.c > - rename new added helper in nand.h to nand_check_xxxx() > - add struct mtd_oob_ops consistency check in nand_check_oob_ops() > - add dataleft in struct nand_page_iter instead of offs > - remove spinand_manufacturers->ops->detect() check since it is mandatory > - remove spinand_set_manufacturer_ops() and do the job in > spinand_manufacturer_detect() > - move .priv out of struct spinand_controller > - add spinand_alloc/free/register/unregister() and make > spinand_detect/init() static > - make BBT be configured by device tree > - chip->id.data stores raw ID directly > - refine device info print message after detect success > - add struct mtd_layout_ops pointer in struct micron_spinand_info > - remove micron_spinand_init() and do its job in micron_spinand_detect() > - fix BBT block cannot be erased bug >=20 > v3 changes: > - rebase patch on 4.11-rc1[2] > - change read ID method. read 4 bytes ID out then let ->detect() of each > manufacutre driver to decode ID and detect the device. > - make SPI NAND id table private to each manufacutre driver > - fix coding style to make checkpatch.pl happy > - update the MAINTAINERS file for spi nand code > - add nand_size() helper in nand.h > - use nand_for_each_page() helper in spinand_do_read/write_ops() > - create helper to check boundaries in generic NAND code and use it > in SPI NAND core > - rename spinand_base.c to core.c > - manufactures' drivers expose spinand_manufacturer struct instead of > spinand_manufacturer_ops struct to keep Manufacture ID macro in > manufactures' drivers and rename spinand_ids.c to manufacture.c > - rename spinand_micron.c to micron.c > - rename chips/ directory to controllers/ > - rename generic_spi.c to generic-spi.c > - replace ->build_column_addr() and ->get_dummy() hooks with ->prepare_op= () in > spinand_manufacturer_ops struct > - rename __spinand_erase() to spinand_erase() > - rename spinand_erase() to spinand_erase_skip_bbt() > - rename spinand_scan_ident() to spinand_detect() > - rename spinand_scan_tail() to spinand_init() > - move non detect related code from spinand_detect() to spinand_init() > - remove spinand_fill_nandd, assign nand->ops in spinand_detect() > - merge v2 patch 3(bad block support) and patch 4(BBT support) > - drop getchip parameter, remove spinand_get/remove_device(), take the lo= ck > by caller directly > - fix function comment headers > - use nand_bbt_is_initialized() helper > - replace spinand_ecc_engine and spinand_controller object in spinand_dev= ice > struct with pointer > - replace struct spinand_manufacturer_ops pointer in spinand_device struct > with spinand_manufacturer struct >=20 > v2 changes: > - replace "spi_nand" with "spinand". > - rename spi nand related structs for better understanding. > - introduce spi nand controller, manufacturer and ecc_engine struct. > - add spi nand manufacturer initialization function refer to Boris's > manuf-init branch. > - remove NAND_SKIP_BBTSCAN from series. Add it later when enabling HW ECC. > - reorganize series according to Boris's suggestion. >=20 > Boris Brezillon (2): > dt-bindings: Add bindings for SPI NAND devices > mtd: spinand: Add initial support for the MX35LF1GE4AB chip >=20 > Frieder Schrempf (1): > mtd: spinand: Add initial support for Winbond W25M02GV >=20 > Miquel Raynal (1): > mtd: spinand: macronix: Add support for MX35LF2GE4AB >=20 > Peter Pan (2): > mtd: nand: Add core infrastructure to support SPI NANDs > mtd: spinand: Add initial support for Micron MT29F2G01ABAGD >=20 > Documentation/devicetree/bindings/mtd/spi-nand.txt | 5 + > drivers/mtd/nand/Kconfig | 1 + > drivers/mtd/nand/Makefile | 1 + > drivers/mtd/nand/spi/Kconfig | 7 + > drivers/mtd/nand/spi/Makefile | 3 + > drivers/mtd/nand/spi/core.c | 1168 ++++++++++++++= ++++++ > drivers/mtd/nand/spi/macronix.c | 144 +++ > drivers/mtd/nand/spi/micron.c | 133 +++ > drivers/mtd/nand/spi/winbond.c | 141 +++ > include/linux/mtd/spinand.h | 421 +++++++ > include/linux/spi/spi-mem.h | 4 +- > 11 files changed, 2027 insertions(+), 1 deletion(-) > create mode 100644 Documentation/devicetree/bindings/mtd/spi-nand.txt > create mode 100644 drivers/mtd/nand/spi/Kconfig > create mode 100644 drivers/mtd/nand/spi/Makefile > create mode 100644 drivers/mtd/nand/spi/core.c > create mode 100644 drivers/mtd/nand/spi/macronix.c > create mode 100644 drivers/mtd/nand/spi/micron.c > create mode 100644 drivers/mtd/nand/spi/winbond.c > create mode 100644 include/linux/mtd/spinand.h >=20 Series applied. Thank you very much! Miqu=C3=A8l From mboxrd@z Thu Jan 1 00:00:00 1970 From: Miquel Raynal Subject: Re: [PATCH v9 0/6] mtd: Add a SPI NAND driver Date: Sun, 1 Jul 2018 20:11:27 +0200 Message-ID: <20180701201127.551d969c@xps13> References: <20180622122828.12939-1-boris.brezillon@bootlin.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: Mark Rutland , devicetree@vger.kernel.org, Mason Yang , Julien Su , Pawel Moll , Ian Campbell , Piotr Bugalski , Richard Weinberger , Rob Herring , linux-spi@vger.kernel.org, Peter Pan , Marek Vasut , Frieder Schrempf , Mark Brown , linux-mtd@lists.infradead.org, Kumar Gala , Geert Uytterhoeven , Brian Norris , David Woodhouse , zhengxunli@mxic.com.tw To: Boris Brezillon Return-path: In-Reply-To: <20180622122828.12939-1-boris.brezillon@bootlin.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-mtd" Errors-To: linux-mtd-bounces+gldm-linux-mtd-36=gmane.org@lists.infradead.org List-Id: linux-spi.vger.kernel.org SGkgQm9yaXMsCgpCb3JpcyBCcmV6aWxsb24gPGJvcmlzLmJyZXppbGxvbkBib290bGluLmNvbT4g d3JvdGUgb24gRnJpLCAyMiBKdW4gMjAxOAoxNDoyODoyMiArMDIwMDoKCj4gSGVsbG8sCj4gCj4g Tm90IG11Y2ggaGFzIGNoYW5nZWQgaW4gdGhpcyB2OSBleGNlcHQgZm9yIHRoZSBhZGRpdGlvbiBv ZiB0aGUgbWFjcm9uaXgKPiBkcml2ZXIuIEkgbWFpbmx5IGZpeGVkIGJ1Z3MvaXNzdWVzIHJlcG9y dGVkIGJ5IE1pcXVlbC4KPiAKPiBNYXJrLCBSb2IsIEdlZXJ0LCBJIGRyb3BwZWQgdGhlIGNvbnRy b3ZlcnNpYWwgY2hhbmdlcyBpbiB0aGUgRFQKPiBiaW5kaW5ncyBwYXRjaCwgc2luY2UgaXQncyBu b3Qgc29tZXRoaW5nIHNwZWNpZmljIHRvIFNQSSBOQU5ELCB0aGlzCj4gYXBwbGllcyB0byBTUEkg bWVtb3J5IGRldmljZXMgaW4gZ2VuZXJhbC4KPiAKPiBUaGFua3MsCj4gCj4gQm9yaXMKPiAKPiB2 OSBjaGFuZ2VzOgo+IC0gYWRkIHN1cHBvcnQgZm9yIDIgU1BJIE5BTkRzIGZyb20gTWFjcm9uaXgK PiAtIGEgZmV3IGZpeGVzIGFuZCBpbXByb3ZlbWVudHMgKHNlZSB0aGUgY2hhbmdlbG9nIGluIGVh Y2ggcGF0Y2gpCj4gLSBkcm9wIHRoZSBkb2MgZGVzY3JpYmluZyBnZW5lcmljIFNQSSBkZXZpY2Ug cHJvcHMgaW4gdGhlIERUIGJpbmRpbmcKPiAKPiB2OCBjaGFuZ2VzOgo+IC0gZHJvcHBlZCBwYXRj aCAxIHdoaWNoIGhhcyBiZWVuIGFwcGxpZWQKPiAtIGZpeCB2YXJpb3VzIGJ1Z3MgaW4gdGhlIGNv cmUgKHNlZSBjaGFuZ2Vsb2cgaW4gcGF0Y2ggMSkKPiAtIGFkZCBhIGNvbW1pdCBtZXNzYWdlIHRv IHBhdGNoIDQKPiAKPiB2NyBjaGFuZ2VzOgo+IC0gVXNlIHRoZSBzcGktbWVtIGludGVyZmFjZQo+ IC0gQWRkIHN1cHBvcnQgZm9yIG9uLWRpZSBFQ0MKPiAtIEFkZCBzdXBwb3J0IGZvciBXaW5ib25k IFcyNU0wMkdWIGNoaXAKPiAKPiB2NiBjaGFuZ2VzOgo+IC0gaW5jbHVkZXMgZ2VuZXJpYyBOQU5E IGZyYW1ld29yayBwYXRjaGVzIGluIHNlcmllcwo+IC0gcmViYXNlIG9uIG5hbmQvbmV4dCAoY29t bWl0IDYwNzZmZDFlOWQ4Nzk1MjFmNzA4MmE1ZTIyMTg1YjcxZTQ4MGI3NzcpCj4gLSByZW1vdmUg b24tZGllIEVDQyBzdXBwb3J0Cj4gLSByZW1vdmUgZGV2bV9mcmVlKCkgc2luY2UgZXZlcnl0aGlu ZyBhbGxvY2F0ZWQgYnkgZGV2bV9rbWFsbG9jKCkgd2lsbCBiZQo+ICAgYXV0b21hdGljYWxseSBm cmVlZCB3aGVuIGRldmljZSBpcyByZWxlYXNlZAo+IC0gYWRkIGNvbW1lbnQgaGVhZGVyIGZvciBz dHJ1Y3RzIGluIHNwaW5hbmQuaAo+IC0gcmVtb3ZlIHNwaW5hbmRfcmVnaXN0ZXIoKS91bnJlZ2lz dGVyKCksIGNhbGwgc3BpbmFuZF9kZXRlY3QoKSBpbgo+ICAgc3BpbmFuZF9pbml0KCkgYW5kIG9u bHkgZXhwb3NlIHNwaW5hbmRfaW5pdCgpL2NsZWFudXAoKQo+IC0gYWRkIG5hbmRfcmVsZWFzZV9i YnQoKSBpbiBiYnQuYyBhbmQgdXNlIGl0IGluIG5hbmRfY2xlYW51cCgpIGFuZAo+ICAgc3BpbmFu ZF9jbGVhbnVwKCkKPiAtIHVzZSBCSVQobikgaW5zdGVhZCAoMSA8PCBuKSBpbiBtYWNybyBvZiBz cGluYW5kLmgKPiAtIHJlbmFtZSBzcGluYW5kX2FsbG9jKCkgdG8gZGV2bV9zcGluYW5kX2FsbG9j KCkKPiAtIG5hbWUgbGFibGVzIGluIGJldHRlciB3YXkKPiAtIGZpeCBzb21lIHR5cG9zCj4gLSBh ZGQgZW1wdHkgbGluZXMgYmV0d2VlbiBjb2RlIGJsb2Nrcwo+IAo+IHY1IGNoYW5nZXM6Cj4gLSBy ZWJhc2UgcGF0Y2ggb24gbmFuZC9uZXh0IHdpdGggQm9yaXMncyBnZW5lcmljIE5BTkQgZnJhbWV3 b3JrIHBhdGNoZXNbM10KPiAtIHJlcGxhY2UgcHJfeHh4KCkgd2l0aCBkZXZfeHh4KCkKPiAtIHJl cGxhY2Uga3phbGxvYygpaS9rZnJlZSgpIHdpdGggZGV2bV9remFsbG9jKCkvZGV2bV9rZnJlZSgp Cj4gLSByZW5hbWUgc3BpbmFuZF9vcF9pbml0KCkgdG8gc3BpbmFuZF9pbml0X29wKCkgZm9yIGNv bnNpc3RlbmN5Cj4gLSByZW1vdmUgY29tbWFuZCBvcGNvZGUgaW4gZnVuY3Rpb24gY29tbWVudHMK PiAtIHVzZSBCSVQobikgaW5zdGVhZCAoMSA8PCBuKSBpbiBtYWNybwo+IC0gcmVtb3ZlIG1hbnVm YWN0dXJlcy5jIGFuZCBwdXQgc3BpbmFuZF9tYW51ZmFjdHVyZXJzIHRhYmxlIGluIGNvcmUuYwo+ IC0gY2hhbmdlIHNwaW5hbmRfd3JpdGVfcmVnKCkgdTggKmJ1ZiBhcmd1bWVudCB0byB1OCB2YWx1 ZSwKPiAgIHNpbmNlIHRoZSBsZW5ndGggaXMgYWx3YXlzIDEKPiAtIHJlbW92ZSBzcGluYW5kX21h bnVmYWN0dXJlLT5kZXRlY3QoKSBjaGVjaywgc2luY2UgaXQgaXMgYWx3YXlzICE9IE5VTEwKPiAt IGFsbG9jIHNwaW5hbmRfZWNjX2VuZ2luZSBzdHJ1Y3QgaW4gdmVuZG9yLmMgd2hlbiB1c2luZyBv bi1kaWUgRUNDCj4gICAoZm9yIGhhcmR3YXJlIEVDQywgaXQgc2hvdWxkIGJlIGluIGNvbnRyb2xs ZXJzLyouYykKPiAtIGFkZCBjb21tZW50IGhlYWRlciBmb3Igc3RydWN0IHNwaW5hbmRfb3AKPiAt IGZpeCB0aW1lb3V0IGJ1ZyBpbiBzcGluYW5kX3dhaXQoKSwgdGhhbmtzIGZvciBBcm5hdWQncyBk ZWJ1Zwo+IC0gbWFrZSBzcGluYW5kX21hbnVmYWN0dXJlcnMgY29uc3QKPiAtIGFkZCBlY2NfZW5n aW5lX29wcyBwb2ludGVyIGluIHN0cnVjdCBtaWNyb25fc3BpbmFuZF9pbmZvCj4gLSBtYWtlIGNv bnRyb2xsZXItPmNhcCBhc3NpZ25tZW50IHJpZ2h0IHdpdGggU1BJX1RYL1JYX1FVQUQvRFVBTCBm bGFnCj4gCj4gdjQgY2hhbmdlczoKPiAtIGluaXRpYWxpemUgc3RydWN0IG10ZF9vb2Jfb3BzIHRv IDAgaW4gYmJ0LmMKPiAtIHJlbmFtZSBuZXcgYWRkZWQgaGVscGVyIGluIG5hbmQuaCB0byBuYW5k X2NoZWNrX3h4eHgoKQo+IC0gYWRkIHN0cnVjdCBtdGRfb29iX29wcyBjb25zaXN0ZW5jeSBjaGVj ayBpbiBuYW5kX2NoZWNrX29vYl9vcHMoKQo+IC0gYWRkIGRhdGFsZWZ0IGluIHN0cnVjdCBuYW5k X3BhZ2VfaXRlciBpbnN0ZWFkIG9mIG9mZnMKPiAtIHJlbW92ZSBzcGluYW5kX21hbnVmYWN0dXJl cnMtPm9wcy0+ZGV0ZWN0KCkgY2hlY2sgc2luY2UgaXQgaXMgbWFuZGF0b3J5Cj4gLSByZW1vdmUg c3BpbmFuZF9zZXRfbWFudWZhY3R1cmVyX29wcygpIGFuZCBkbyB0aGUgam9iIGluCj4gICBzcGlu YW5kX21hbnVmYWN0dXJlcl9kZXRlY3QoKQo+IC0gbW92ZSAucHJpdiBvdXQgb2Ygc3RydWN0IHNw aW5hbmRfY29udHJvbGxlcgo+IC0gYWRkIHNwaW5hbmRfYWxsb2MvZnJlZS9yZWdpc3Rlci91bnJl Z2lzdGVyKCkgYW5kIG1ha2UKPiAgIHNwaW5hbmRfZGV0ZWN0L2luaXQoKSBzdGF0aWMKPiAtIG1h a2UgQkJUIGJlIGNvbmZpZ3VyZWQgYnkgZGV2aWNlIHRyZWUKPiAtIGNoaXAtPmlkLmRhdGEgc3Rv cmVzIHJhdyBJRCBkaXJlY3RseQo+IC0gcmVmaW5lIGRldmljZSBpbmZvIHByaW50IG1lc3NhZ2Ug YWZ0ZXIgZGV0ZWN0IHN1Y2Nlc3MKPiAtIGFkZCBzdHJ1Y3QgbXRkX2xheW91dF9vcHMgcG9pbnRl ciBpbiBzdHJ1Y3QgbWljcm9uX3NwaW5hbmRfaW5mbwo+IC0gcmVtb3ZlIG1pY3Jvbl9zcGluYW5k X2luaXQoKSBhbmQgZG8gaXRzIGpvYiBpbiBtaWNyb25fc3BpbmFuZF9kZXRlY3QoKQo+IC0gZml4 IEJCVCBibG9jayBjYW5ub3QgYmUgZXJhc2VkIGJ1Zwo+IAo+IHYzIGNoYW5nZXM6Cj4gLSByZWJh c2UgcGF0Y2ggb24gNC4xMS1yYzFbMl0KPiAtIGNoYW5nZSByZWFkIElEIG1ldGhvZC4gcmVhZCA0 IGJ5dGVzIElEIG91dCB0aGVuIGxldCAtPmRldGVjdCgpIG9mIGVhY2gKPiAgIG1hbnVmYWN1dHJl IGRyaXZlciB0byBkZWNvZGUgSUQgYW5kIGRldGVjdCB0aGUgZGV2aWNlLgo+IC0gbWFrZSBTUEkg TkFORCBpZCB0YWJsZSBwcml2YXRlIHRvIGVhY2ggbWFudWZhY3V0cmUgZHJpdmVyCj4gLSBmaXgg Y29kaW5nIHN0eWxlIHRvIG1ha2UgY2hlY2twYXRjaC5wbCBoYXBweQo+IC0gdXBkYXRlIHRoZSBN QUlOVEFJTkVSUyBmaWxlIGZvciBzcGkgbmFuZCBjb2RlCj4gLSBhZGQgbmFuZF9zaXplKCkgaGVs cGVyIGluIG5hbmQuaAo+IC0gdXNlIG5hbmRfZm9yX2VhY2hfcGFnZSgpIGhlbHBlciBpbiBzcGlu YW5kX2RvX3JlYWQvd3JpdGVfb3BzKCkKPiAtIGNyZWF0ZSBoZWxwZXIgdG8gY2hlY2sgYm91bmRh cmllcyBpbiBnZW5lcmljIE5BTkQgY29kZSBhbmQgdXNlIGl0Cj4gICBpbiBTUEkgTkFORCBjb3Jl Cj4gLSByZW5hbWUgc3BpbmFuZF9iYXNlLmMgdG8gY29yZS5jCj4gLSBtYW51ZmFjdHVyZXMnIGRy aXZlcnMgZXhwb3NlIHNwaW5hbmRfbWFudWZhY3R1cmVyIHN0cnVjdCBpbnN0ZWFkIG9mCj4gICBz cGluYW5kX21hbnVmYWN0dXJlcl9vcHMgc3RydWN0IHRvIGtlZXAgTWFudWZhY3R1cmUgSUQgbWFj cm8gaW4KPiAgIG1hbnVmYWN0dXJlcycgZHJpdmVycyBhbmQgcmVuYW1lIHNwaW5hbmRfaWRzLmMg dG8gbWFudWZhY3R1cmUuYwo+IC0gcmVuYW1lIHNwaW5hbmRfbWljcm9uLmMgdG8gbWljcm9uLmMK PiAtIHJlbmFtZSBjaGlwcy8gZGlyZWN0b3J5IHRvIGNvbnRyb2xsZXJzLwo+IC0gcmVuYW1lIGdl bmVyaWNfc3BpLmMgdG8gZ2VuZXJpYy1zcGkuYwo+IC0gcmVwbGFjZSAtPmJ1aWxkX2NvbHVtbl9h ZGRyKCkgYW5kIC0+Z2V0X2R1bW15KCkgaG9va3Mgd2l0aCAtPnByZXBhcmVfb3AoKSBpbgo+ICAg c3BpbmFuZF9tYW51ZmFjdHVyZXJfb3BzIHN0cnVjdAo+IC0gcmVuYW1lIF9fc3BpbmFuZF9lcmFz ZSgpIHRvIHNwaW5hbmRfZXJhc2UoKQo+IC0gcmVuYW1lIHNwaW5hbmRfZXJhc2UoKSB0byBzcGlu YW5kX2VyYXNlX3NraXBfYmJ0KCkKPiAtIHJlbmFtZSBzcGluYW5kX3NjYW5faWRlbnQoKSB0byBz cGluYW5kX2RldGVjdCgpCj4gLSByZW5hbWUgc3BpbmFuZF9zY2FuX3RhaWwoKSB0byBzcGluYW5k X2luaXQoKQo+IC0gbW92ZSBub24gZGV0ZWN0IHJlbGF0ZWQgY29kZSBmcm9tIHNwaW5hbmRfZGV0 ZWN0KCkgdG8gc3BpbmFuZF9pbml0KCkKPiAtIHJlbW92ZSBzcGluYW5kX2ZpbGxfbmFuZGQsIGFz c2lnbiBuYW5kLT5vcHMgaW4gc3BpbmFuZF9kZXRlY3QoKQo+IC0gbWVyZ2UgdjIgcGF0Y2ggMyhi YWQgYmxvY2sgc3VwcG9ydCkgYW5kIHBhdGNoIDQoQkJUIHN1cHBvcnQpCj4gLSBkcm9wIGdldGNo aXAgcGFyYW1ldGVyLCByZW1vdmUgc3BpbmFuZF9nZXQvcmVtb3ZlX2RldmljZSgpLCB0YWtlIHRo ZSBsb2NrCj4gICBieSBjYWxsZXIgZGlyZWN0bHkKPiAtIGZpeCBmdW5jdGlvbiBjb21tZW50IGhl YWRlcnMKPiAtIHVzZSBuYW5kX2JidF9pc19pbml0aWFsaXplZCgpIGhlbHBlcgo+IC0gcmVwbGFj ZSBzcGluYW5kX2VjY19lbmdpbmUgYW5kIHNwaW5hbmRfY29udHJvbGxlciBvYmplY3QgaW4gc3Bp bmFuZF9kZXZpY2UKPiAgIHN0cnVjdCB3aXRoIHBvaW50ZXIKPiAtIHJlcGxhY2Ugc3RydWN0IHNw aW5hbmRfbWFudWZhY3R1cmVyX29wcyBwb2ludGVyIGluIHNwaW5hbmRfZGV2aWNlIHN0cnVjdAo+ ICAgd2l0aCBzcGluYW5kX21hbnVmYWN0dXJlciBzdHJ1Y3QKPiAKPiB2MiBjaGFuZ2VzOgo+IC0g cmVwbGFjZSAic3BpX25hbmQiIHdpdGggInNwaW5hbmQiLgo+IC0gcmVuYW1lIHNwaSBuYW5kIHJl bGF0ZWQgc3RydWN0cyBmb3IgYmV0dGVyIHVuZGVyc3RhbmRpbmcuCj4gLSBpbnRyb2R1Y2Ugc3Bp IG5hbmQgY29udHJvbGxlciwgbWFudWZhY3R1cmVyIGFuZCBlY2NfZW5naW5lIHN0cnVjdC4KPiAt IGFkZCBzcGkgbmFuZCBtYW51ZmFjdHVyZXIgaW5pdGlhbGl6YXRpb24gZnVuY3Rpb24gcmVmZXIg dG8gQm9yaXMncwo+ICAgbWFudWYtaW5pdCBicmFuY2guCj4gLSByZW1vdmUgTkFORF9TS0lQX0JC VFNDQU4gZnJvbSBzZXJpZXMuIEFkZCBpdCBsYXRlciB3aGVuIGVuYWJsaW5nIEhXIEVDQy4KPiAt IHJlb3JnYW5pemUgc2VyaWVzIGFjY29yZGluZyB0byBCb3JpcydzIHN1Z2dlc3Rpb24uCj4gCj4g Qm9yaXMgQnJlemlsbG9uICgyKToKPiAgIGR0LWJpbmRpbmdzOiBBZGQgYmluZGluZ3MgZm9yIFNQ SSBOQU5EIGRldmljZXMKPiAgIG10ZDogc3BpbmFuZDogQWRkIGluaXRpYWwgc3VwcG9ydCBmb3Ig dGhlIE1YMzVMRjFHRTRBQiBjaGlwCj4gCj4gRnJpZWRlciBTY2hyZW1wZiAoMSk6Cj4gICBtdGQ6 IHNwaW5hbmQ6IEFkZCBpbml0aWFsIHN1cHBvcnQgZm9yIFdpbmJvbmQgVzI1TTAyR1YKPiAKPiBN aXF1ZWwgUmF5bmFsICgxKToKPiAgIG10ZDogc3BpbmFuZDogbWFjcm9uaXg6IEFkZCBzdXBwb3J0 IGZvciBNWDM1TEYyR0U0QUIKPiAKPiBQZXRlciBQYW4gKDIpOgo+ICAgbXRkOiBuYW5kOiBBZGQg Y29yZSBpbmZyYXN0cnVjdHVyZSB0byBzdXBwb3J0IFNQSSBOQU5Ecwo+ICAgbXRkOiBzcGluYW5k OiBBZGQgaW5pdGlhbCBzdXBwb3J0IGZvciBNaWNyb24gTVQyOUYyRzAxQUJBR0QKPiAKPiAgRG9j dW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL210ZC9zcGktbmFuZC50eHQgfCAgICA1ICsK PiAgZHJpdmVycy9tdGQvbmFuZC9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg ICAxICsKPiAgZHJpdmVycy9tdGQvbmFuZC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgICAxICsKPiAgZHJpdmVycy9tdGQvbmFuZC9zcGkvS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgICAgfCAgICA3ICsKPiAgZHJpdmVycy9tdGQvbmFuZC9zcGkvTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgfCAgICAzICsKPiAgZHJpdmVycy9tdGQvbmFuZC9zcGkvY29yZS5jICAg ICAgICAgICAgICAgICAgICAgICAgfCAxMTY4ICsrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZl cnMvbXRkL25hbmQvc3BpL21hY3Jvbml4LmMgICAgICAgICAgICAgICAgICAgIHwgIDE0NCArKysK PiAgZHJpdmVycy9tdGQvbmFuZC9zcGkvbWljcm9uLmMgICAgICAgICAgICAgICAgICAgICAgfCAg MTMzICsrKwo+ICBkcml2ZXJzL210ZC9uYW5kL3NwaS93aW5ib25kLmMgICAgICAgICAgICAgICAg ICAgICB8ICAxNDEgKysrCj4gIGluY2x1ZGUvbGludXgvbXRkL3NwaW5hbmQuaCAgICAgICAgICAg ICAgICAgICAgICAgIHwgIDQyMSArKysrKysrCj4gIGluY2x1ZGUvbGludXgvc3BpL3NwaS1tZW0u aCAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNCArLQo+ICAxMSBmaWxlcyBjaGFuZ2VkLCAy MDI3IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IERv Y3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvc3BpLW5hbmQudHh0Cj4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL210ZC9uYW5kL3NwaS9LY29uZmlnCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL210ZC9uYW5kL3NwaS9NYWtlZmlsZQo+ICBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9tdGQvbmFuZC9zcGkvY29yZS5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL210ZC9uYW5kL3NwaS9tYWNyb25peC5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L210ZC9uYW5kL3NwaS9taWNyb24uYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9tdGQv bmFuZC9zcGkvd2luYm9uZC5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L210 ZC9zcGluYW5kLmgKPiAKClNlcmllcyBhcHBsaWVkLgoKVGhhbmsgeW91IHZlcnkgbXVjaCEKTWlx dcOobAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCkxpbnV4IE1URCBkaXNjdXNzaW9uIG1haWxpbmcgbGlzdApodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LW10ZC8K