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 1fQwQa-0001NW-F9 for linux-mtd@lists.infradead.org; Thu, 07 Jun 2018 15:02:19 +0000 Date: Thu, 7 Jun 2018 17:01:53 +0200 From: Miquel Raynal To: Boris Brezillon Cc: David Woodhouse , Brian Norris , Marek Vasut , Richard Weinberger , linux-mtd@lists.infradead.org, Mark Brown , linux-spi@vger.kernel.org, Cyrille Pitchen , Vignesh R , Thomas Petazzoni Subject: Re: [RFC PATCH 1/2] spi: spi-mem: Add a new API to support direct mapping Message-ID: <20180607170153.757ca102@xps13> In-Reply-To: <20180601143603.4047-2-boris.brezillon@bootlin.com> References: <20180601143603.4047-1-boris.brezillon@bootlin.com> <20180601143603.4047-2-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, On Fri, 1 Jun 2018 16:36:02 +0200, Boris Brezillon wrote: > Most modern QSPI controllers support can directly map a SPI memory (or s/support// ? > a portion of the SPI memory) in the CPU address space. Most of the time > this brings significant performance improvements as it automates the > whole process of sending SPI memory operations every time a new region > is accessed. >=20 > This new API allow SPI memory driver to create direct mappings and then s/allow/allows/ s/driver/drivers/ ? > use them to access the memory instead of using spi_mem_exec_op(). >=20 > Signed-off-by: Boris Brezillon > --- > drivers/spi/spi-mem.c | 267 ++++++++++++++++++++++++++++++++++++++= ++---- > include/linux/spi/spi-mem.h | 72 ++++++++++++ > 2 files changed, 318 insertions(+), 21 deletions(-) >=20 > diff --git a/drivers/spi/spi-mem.c b/drivers/spi/spi-mem.c > index 990770dfa5cf..90ea0c5263a7 100644 > --- a/drivers/spi/spi-mem.c > +++ b/drivers/spi/spi-mem.c > @@ -175,6 +175,44 @@ bool spi_mem_supports_op(struct spi_mem *mem, const = struct spi_mem_op *op) > } > EXPORT_SYMBOL_GPL(spi_mem_supports_op); > =20 > +static int spi_mem_access_start(struct spi_mem *mem) > +{ > + struct spi_controller *ctlr =3D mem->spi->controller; > + > + /* > + * Flush the message queue before executing our SPI memory > + * operation to prevent preemption of regular SPI transfers. > + */ > + spi_flush_queue(ctlr); > + > + if (ctlr->auto_runtime_pm) { > + int ret; > + > + ret =3D pm_runtime_get_sync(ctlr->dev.parent); > + if (ret < 0) { > + dev_err(&ctlr->dev, "Failed to power device: %d\n", > + ret); > + return ret; > + } > + } > + > + mutex_lock(&ctlr->bus_lock_mutex); > + mutex_lock(&ctlr->io_mutex); > + > + return 0; > +} > + > +static void spi_mem_access_end(struct spi_mem *mem) > +{ > + struct spi_controller *ctlr =3D mem->spi->controller; > + > + mutex_unlock(&ctlr->io_mutex); > + mutex_unlock(&ctlr->bus_lock_mutex); > + > + if (ctlr->auto_runtime_pm) > + pm_runtime_put(ctlr->dev.parent); > +} > + > /** > * spi_mem_exec_op() - Execute a memory operation > * @mem: the SPI memory > @@ -200,30 +238,13 @@ int spi_mem_exec_op(struct spi_mem *mem, const stru= ct spi_mem_op *op) > return -ENOTSUPP; > =20 > if (ctlr->mem_ops) { > - /* > - * Flush the message queue before executing our SPI memory > - * operation to prevent preemption of regular SPI transfers. > - */ > - spi_flush_queue(ctlr); > - > - if (ctlr->auto_runtime_pm) { > - ret =3D pm_runtime_get_sync(ctlr->dev.parent); > - if (ret < 0) { > - dev_err(&ctlr->dev, > - "Failed to power device: %d\n", > - ret); > - return ret; > - } > - } > + ret =3D spi_mem_access_start(mem); > + if (ret) > + return ret; > =20 > - mutex_lock(&ctlr->bus_lock_mutex); > - mutex_lock(&ctlr->io_mutex); > ret =3D ctlr->mem_ops->exec_op(mem, op); > - mutex_unlock(&ctlr->io_mutex); > - mutex_unlock(&ctlr->bus_lock_mutex); > =20 > - if (ctlr->auto_runtime_pm) > - pm_runtime_put(ctlr->dev.parent); > + spi_mem_access_end(mem); As this is something you tell me on a weekly basis: would you mind to separate the direct mapping support and the spi_mem_access_start/end() helpers introduction in different patches? :) > =20 > /* > * Some controllers only optimize specific paths (typically the > @@ -336,6 +357,210 @@ int spi_mem_adjust_op_size(struct spi_mem *mem, str= uct spi_mem_op *op) > } > EXPORT_SYMBOL_GPL(spi_mem_adjust_op_size); > =20 [...] > + > +/** > + * struct spi_mem_dirmap_desc - Direct mapping descriptor > + * @mem: the SPI memory device this direct mapping is attached to > + * @info: information passed at direct mapping creation time > + * @nodirmap: set to true if the SPI controller does not implement > + * ->mem_ops->dirmap_create() or when this function returned an s/returned/returns/ > + * error. If dirmap is true, all spi_mem_dirmap_{read,write}() > + * calls will use spi_mem_exec_op() to access the memory. This is a > + * degraded mode that allows higher spi_mem drivers to use the same > + * code no matter if the controller supports direct mapping or not > + * @priv: field pointing to controller specific data > + * > + * Common part of a direct mapping descriptor. This object is created by > + * spi_mem_dirmap_create() and controller implementation of ->create_dir= map() > + * can create/attach direct mapping resources to the descriptor in the -= >priv > + * field. > + */ > +struct spi_mem_dirmap_desc { > + struct spi_mem *mem; > + struct spi_mem_dirmap_info info; > + bool nodirmap; > + void *priv; > +}; > + > /** > * struct spi_mem - describes a SPI memory device > * @spi: the underlying SPI device > @@ -167,10 +210,24 @@ static inline void *spi_mem_get_drvdata(struct spi_= mem *mem) > * limitations) > * @supports_op: check if an operation is supported by the controller > * @exec_op: execute a SPI memory operation > + * @dirmap_create: create a direct mapping descriptor that can later be = used to > + * access the memory device. This method is optional Only *dirmap_create() is marked as optional while all are. > + * @dirmap_destroy: destroy a memory descriptor previous created by > + * ->dirmap_create() s/previous/previously/ > + * @dirmap_read: read data from the memory device using the direct mappi= ng > + * created by ->dirmap_create(). > + * @dirmap_write: write data to the memory device using the direct mappi= ng > + * created by ->dirmap_create(). I think there is a better kernel-doc way to reference dirmap_create(), maybe with '@' (I don't remember exactly). > * > * This interface should be implemented by SPI controllers providing an > * high-level interface to execute SPI memory operation, which is usuall= y the > * case for QSPI controllers. > + * > + * Note on ->dirmap_{read,write}(): drivers should avoid accessing the d= irect > + * mapping from the CPU because doing that can stall the CPU waiting for= the > + * SPI mem transaction to finish, and this will make real-time maintaine= rs > + * unhappy and might make your system less reactive. Instead, drivers sh= ould > + * use DMA to access this direct mapping. > */ > struct spi_controller_mem_ops { > int (*adjust_op_size)(struct spi_mem *mem, struct spi_mem_op *op); > @@ -178,6 +235,12 @@ struct spi_controller_mem_ops { > const struct spi_mem_op *op); > int (*exec_op)(struct spi_mem *mem, > const struct spi_mem_op *op); > + int (*dirmap_create)(struct spi_mem_dirmap_desc *desc); > + void (*dirmap_destroy)(struct spi_mem_dirmap_desc *desc); > + ssize_t (*dirmap_read)(struct spi_mem_dirmap_desc *desc, > + u64 offs, size_t len, void *buf); > + ssize_t (*dirmap_write)(struct spi_mem_dirmap_desc *desc, > + u64 offs, size_t len, const void *buf); > }; > =20 > /** > @@ -236,6 +299,15 @@ bool spi_mem_supports_op(struct spi_mem *mem, > int spi_mem_exec_op(struct spi_mem *mem, > const struct spi_mem_op *op); > =20 > +struct spi_mem_dirmap_desc * > +spi_mem_dirmap_create(struct spi_mem *mem, > + const struct spi_mem_dirmap_info *info); > +void spi_mem_dirmap_destroy(struct spi_mem_dirmap_desc *desc); > +ssize_t spi_mem_dirmap_read(struct spi_mem_dirmap_desc *desc, > + u64 offs, size_t len, void *buf); > +ssize_t spi_mem_dirmap_write(struct spi_mem_dirmap_desc *desc, > + u64 offs, size_t len, const void *buf); > + > int spi_mem_driver_register_with_owner(struct spi_mem_driver *drv, > struct module *owner); > =20 The rest is clear for me. Thanks, Miqu=C3=A8l From mboxrd@z Thu Jan 1 00:00:00 1970 From: Miquel Raynal Subject: Re: [RFC PATCH 1/2] spi: spi-mem: Add a new API to support direct mapping Date: Thu, 7 Jun 2018 17:01:53 +0200 Message-ID: <20180607170153.757ca102@xps13> References: <20180601143603.4047-1-boris.brezillon@bootlin.com> <20180601143603.4047-2-boris.brezillon@bootlin.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: Vignesh R , Richard Weinberger , Cyrille Pitchen , linux-spi@vger.kernel.org, Marek Vasut , Mark Brown , linux-mtd@lists.infradead.org, Thomas Petazzoni , Brian Norris , David Woodhouse To: Boris Brezillon Return-path: In-Reply-To: <20180601143603.4047-2-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 SGkgQm9yaXMsCgpPbiBGcmksICAxIEp1biAyMDE4IDE2OjM2OjAyICswMjAwLCBCb3JpcyBCcmV6 aWxsb24KPGJvcmlzLmJyZXppbGxvbkBib290bGluLmNvbT4gd3JvdGU6Cgo+IE1vc3QgbW9kZXJu IFFTUEkgY29udHJvbGxlcnMgc3VwcG9ydCBjYW4gZGlyZWN0bHkgbWFwIGEgU1BJIG1lbW9yeSAo b3IKCnMvc3VwcG9ydC8vID8KCj4gYSBwb3J0aW9uIG9mIHRoZSBTUEkgbWVtb3J5KSBpbiB0aGUg Q1BVIGFkZHJlc3Mgc3BhY2UuIE1vc3Qgb2YgdGhlIHRpbWUKPiB0aGlzIGJyaW5ncyBzaWduaWZp Y2FudCBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudHMgYXMgaXQgYXV0b21hdGVzIHRoZQo+IHdob2xl IHByb2Nlc3Mgb2Ygc2VuZGluZyBTUEkgbWVtb3J5IG9wZXJhdGlvbnMgZXZlcnkgdGltZSBhIG5l dyByZWdpb24KPiBpcyBhY2Nlc3NlZC4KPiAKPiBUaGlzIG5ldyBBUEkgYWxsb3cgU1BJIG1lbW9y eSBkcml2ZXIgdG8gY3JlYXRlIGRpcmVjdCBtYXBwaW5ncyBhbmQgdGhlbgoKcy9hbGxvdy9hbGxv d3MvCnMvZHJpdmVyL2RyaXZlcnMvID8KCj4gdXNlIHRoZW0gdG8gYWNjZXNzIHRoZSBtZW1vcnkg aW5zdGVhZCBvZiB1c2luZyBzcGlfbWVtX2V4ZWNfb3AoKS4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBC b3JpcyBCcmV6aWxsb24gPGJvcmlzLmJyZXppbGxvbkBib290bGluLmNvbT4KPiAtLS0KPiAgZHJp dmVycy9zcGkvc3BpLW1lbS5jICAgICAgIHwgMjY3ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKystLS0tCj4gIGluY2x1ZGUvbGludXgvc3BpL3NwaS1tZW0uaCB8ICA3MiAr KysrKysrKysrKysKPiAgMiBmaWxlcyBjaGFuZ2VkLCAzMTggaW5zZXJ0aW9ucygrKSwgMjEgZGVs ZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaS1tZW0uYyBiL2RyaXZl cnMvc3BpL3NwaS1tZW0uYwo+IGluZGV4IDk5MDc3MGRmYTVjZi4uOTBlYTBjNTI2M2E3IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvc3BpL3NwaS1tZW0uYwo+ICsrKyBiL2RyaXZlcnMvc3BpL3NwaS1t ZW0uYwo+IEBAIC0xNzUsNiArMTc1LDQ0IEBAIGJvb2wgc3BpX21lbV9zdXBwb3J0c19vcChzdHJ1 Y3Qgc3BpX21lbSAqbWVtLCBjb25zdCBzdHJ1Y3Qgc3BpX21lbV9vcCAqb3ApCj4gIH0KPiAgRVhQ T1JUX1NZTUJPTF9HUEwoc3BpX21lbV9zdXBwb3J0c19vcCk7Cj4gIAo+ICtzdGF0aWMgaW50IHNw aV9tZW1fYWNjZXNzX3N0YXJ0KHN0cnVjdCBzcGlfbWVtICptZW0pCj4gK3sKPiArCXN0cnVjdCBz cGlfY29udHJvbGxlciAqY3RsciA9IG1lbS0+c3BpLT5jb250cm9sbGVyOwo+ICsKPiArCS8qCj4g KwkgKiBGbHVzaCB0aGUgbWVzc2FnZSBxdWV1ZSBiZWZvcmUgZXhlY3V0aW5nIG91ciBTUEkgbWVt b3J5Cj4gKwkgKiBvcGVyYXRpb24gdG8gcHJldmVudCBwcmVlbXB0aW9uIG9mIHJlZ3VsYXIgU1BJ IHRyYW5zZmVycy4KPiArCSAqLwo+ICsJc3BpX2ZsdXNoX3F1ZXVlKGN0bHIpOwo+ICsKPiArCWlm IChjdGxyLT5hdXRvX3J1bnRpbWVfcG0pIHsKPiArCQlpbnQgcmV0Owo+ICsKPiArCQlyZXQgPSBw bV9ydW50aW1lX2dldF9zeW5jKGN0bHItPmRldi5wYXJlbnQpOwo+ICsJCWlmIChyZXQgPCAwKSB7 Cj4gKwkJCWRldl9lcnIoJmN0bHItPmRldiwgIkZhaWxlZCB0byBwb3dlciBkZXZpY2U6ICVkXG4i LAo+ICsJCQkJcmV0KTsKPiArCQkJcmV0dXJuIHJldDsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJbXV0 ZXhfbG9jaygmY3Rsci0+YnVzX2xvY2tfbXV0ZXgpOwo+ICsJbXV0ZXhfbG9jaygmY3Rsci0+aW9f bXV0ZXgpOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBzcGlfbWVt X2FjY2Vzc19lbmQoc3RydWN0IHNwaV9tZW0gKm1lbSkKPiArewo+ICsJc3RydWN0IHNwaV9jb250 cm9sbGVyICpjdGxyID0gbWVtLT5zcGktPmNvbnRyb2xsZXI7Cj4gKwo+ICsJbXV0ZXhfdW5sb2Nr KCZjdGxyLT5pb19tdXRleCk7Cj4gKwltdXRleF91bmxvY2soJmN0bHItPmJ1c19sb2NrX211dGV4 KTsKPiArCj4gKwlpZiAoY3Rsci0+YXV0b19ydW50aW1lX3BtKQo+ICsJCXBtX3J1bnRpbWVfcHV0 KGN0bHItPmRldi5wYXJlbnQpOwo+ICt9Cj4gKwo+ICAvKioKPiAgICogc3BpX21lbV9leGVjX29w KCkgLSBFeGVjdXRlIGEgbWVtb3J5IG9wZXJhdGlvbgo+ICAgKiBAbWVtOiB0aGUgU1BJIG1lbW9y eQo+IEBAIC0yMDAsMzAgKzIzOCwxMyBAQCBpbnQgc3BpX21lbV9leGVjX29wKHN0cnVjdCBzcGlf bWVtICptZW0sIGNvbnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCkKPiAgCQlyZXR1cm4gLUVOT1RT VVBQOwo+ICAKPiAgCWlmIChjdGxyLT5tZW1fb3BzKSB7Cj4gLQkJLyoKPiAtCQkgKiBGbHVzaCB0 aGUgbWVzc2FnZSBxdWV1ZSBiZWZvcmUgZXhlY3V0aW5nIG91ciBTUEkgbWVtb3J5Cj4gLQkJICog b3BlcmF0aW9uIHRvIHByZXZlbnQgcHJlZW1wdGlvbiBvZiByZWd1bGFyIFNQSSB0cmFuc2ZlcnMu Cj4gLQkJICovCj4gLQkJc3BpX2ZsdXNoX3F1ZXVlKGN0bHIpOwo+IC0KPiAtCQlpZiAoY3Rsci0+ YXV0b19ydW50aW1lX3BtKSB7Cj4gLQkJCXJldCA9IHBtX3J1bnRpbWVfZ2V0X3N5bmMoY3Rsci0+ ZGV2LnBhcmVudCk7Cj4gLQkJCWlmIChyZXQgPCAwKSB7Cj4gLQkJCQlkZXZfZXJyKCZjdGxyLT5k ZXYsCj4gLQkJCQkJIkZhaWxlZCB0byBwb3dlciBkZXZpY2U6ICVkXG4iLAo+IC0JCQkJCXJldCk7 Cj4gLQkJCQlyZXR1cm4gcmV0Owo+IC0JCQl9Cj4gLQkJfQo+ICsJCXJldCA9IHNwaV9tZW1fYWNj ZXNzX3N0YXJ0KG1lbSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJcmV0dXJuIHJldDsKPiAgCj4gLQkJ bXV0ZXhfbG9jaygmY3Rsci0+YnVzX2xvY2tfbXV0ZXgpOwo+IC0JCW11dGV4X2xvY2soJmN0bHIt PmlvX211dGV4KTsKPiAgCQlyZXQgPSBjdGxyLT5tZW1fb3BzLT5leGVjX29wKG1lbSwgb3ApOwo+ IC0JCW11dGV4X3VubG9jaygmY3Rsci0+aW9fbXV0ZXgpOwo+IC0JCW11dGV4X3VubG9jaygmY3Rs ci0+YnVzX2xvY2tfbXV0ZXgpOwo+ICAKPiAtCQlpZiAoY3Rsci0+YXV0b19ydW50aW1lX3BtKQo+ IC0JCQlwbV9ydW50aW1lX3B1dChjdGxyLT5kZXYucGFyZW50KTsKPiArCQlzcGlfbWVtX2FjY2Vz c19lbmQobWVtKTsKCkFzIHRoaXMgaXMgc29tZXRoaW5nIHlvdSB0ZWxsIG1lIG9uIGEgd2Vla2x5 IGJhc2lzOiB3b3VsZCB5b3UgbWluZCB0bwpzZXBhcmF0ZSB0aGUgZGlyZWN0IG1hcHBpbmcgc3Vw cG9ydCBhbmQgdGhlCnNwaV9tZW1fYWNjZXNzX3N0YXJ0L2VuZCgpIGhlbHBlcnMgaW50cm9kdWN0 aW9uIGluIGRpZmZlcmVudApwYXRjaGVzPyA6KQoKPiAgCj4gIAkJLyoKPiAgCQkgKiBTb21lIGNv bnRyb2xsZXJzIG9ubHkgb3B0aW1pemUgc3BlY2lmaWMgcGF0aHMgKHR5cGljYWxseSB0aGUKPiBA QCAtMzM2LDYgKzM1NywyMTAgQEAgaW50IHNwaV9tZW1fYWRqdXN0X29wX3NpemUoc3RydWN0IHNw aV9tZW0gKm1lbSwgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQo+ICB9Cj4gIEVYUE9SVF9TWU1CT0xf R1BMKHNwaV9tZW1fYWRqdXN0X29wX3NpemUpOwo+ICAKClsuLi5dCgo+ICsKPiArLyoqCj4gKyAq IHN0cnVjdCBzcGlfbWVtX2Rpcm1hcF9kZXNjIC0gRGlyZWN0IG1hcHBpbmcgZGVzY3JpcHRvcgo+ ICsgKiBAbWVtOiB0aGUgU1BJIG1lbW9yeSBkZXZpY2UgdGhpcyBkaXJlY3QgbWFwcGluZyBpcyBh dHRhY2hlZCB0bwo+ICsgKiBAaW5mbzogaW5mb3JtYXRpb24gcGFzc2VkIGF0IGRpcmVjdCBtYXBw aW5nIGNyZWF0aW9uIHRpbWUKPiArICogQG5vZGlybWFwOiBzZXQgdG8gdHJ1ZSBpZiB0aGUgU1BJ IGNvbnRyb2xsZXIgZG9lcyBub3QgaW1wbGVtZW50Cj4gKyAqCSAgICAgIC0+bWVtX29wcy0+ZGly bWFwX2NyZWF0ZSgpIG9yIHdoZW4gdGhpcyBmdW5jdGlvbiByZXR1cm5lZCBhbgoKcy9yZXR1cm5l ZC9yZXR1cm5zLwoKPiArICoJICAgICAgZXJyb3IuIElmIGRpcm1hcCBpcyB0cnVlLCBhbGwgc3Bp X21lbV9kaXJtYXBfe3JlYWQsd3JpdGV9KCkKPiArICoJICAgICAgY2FsbHMgd2lsbCB1c2Ugc3Bp X21lbV9leGVjX29wKCkgdG8gYWNjZXNzIHRoZSBtZW1vcnkuIFRoaXMgaXMgYQo+ICsgKgkgICAg ICBkZWdyYWRlZCBtb2RlIHRoYXQgYWxsb3dzIGhpZ2hlciBzcGlfbWVtIGRyaXZlcnMgdG8gdXNl IHRoZSBzYW1lCj4gKyAqCSAgICAgIGNvZGUgbm8gbWF0dGVyIGlmIHRoZSBjb250cm9sbGVyIHN1 cHBvcnRzIGRpcmVjdCBtYXBwaW5nIG9yIG5vdAo+ICsgKiBAcHJpdjogZmllbGQgcG9pbnRpbmcg dG8gY29udHJvbGxlciBzcGVjaWZpYyBkYXRhCj4gKyAqCj4gKyAqIENvbW1vbiBwYXJ0IG9mIGEg ZGlyZWN0IG1hcHBpbmcgZGVzY3JpcHRvci4gVGhpcyBvYmplY3QgaXMgY3JlYXRlZCBieQo+ICsg KiBzcGlfbWVtX2Rpcm1hcF9jcmVhdGUoKSBhbmQgY29udHJvbGxlciBpbXBsZW1lbnRhdGlvbiBv ZiAtPmNyZWF0ZV9kaXJtYXAoKQo+ICsgKiBjYW4gY3JlYXRlL2F0dGFjaCBkaXJlY3QgbWFwcGlu ZyByZXNvdXJjZXMgdG8gdGhlIGRlc2NyaXB0b3IgaW4gdGhlIC0+cHJpdgo+ICsgKiBmaWVsZC4K PiArICovCj4gK3N0cnVjdCBzcGlfbWVtX2Rpcm1hcF9kZXNjIHsKPiArCXN0cnVjdCBzcGlfbWVt ICptZW07Cj4gKwlzdHJ1Y3Qgc3BpX21lbV9kaXJtYXBfaW5mbyBpbmZvOwo+ICsJYm9vbCBub2Rp cm1hcDsKPiArCXZvaWQgKnByaXY7Cj4gK307Cj4gKwo+ICAvKioKPiAgICogc3RydWN0IHNwaV9t ZW0gLSBkZXNjcmliZXMgYSBTUEkgbWVtb3J5IGRldmljZQo+ICAgKiBAc3BpOiB0aGUgdW5kZXJs eWluZyBTUEkgZGV2aWNlCj4gQEAgLTE2NywxMCArMjEwLDI0IEBAIHN0YXRpYyBpbmxpbmUgdm9p ZCAqc3BpX21lbV9nZXRfZHJ2ZGF0YShzdHJ1Y3Qgc3BpX21lbSAqbWVtKQo+ICAgKgkJICAgIGxp bWl0YXRpb25zKQo+ICAgKiBAc3VwcG9ydHNfb3A6IGNoZWNrIGlmIGFuIG9wZXJhdGlvbiBpcyBz dXBwb3J0ZWQgYnkgdGhlIGNvbnRyb2xsZXIKPiAgICogQGV4ZWNfb3A6IGV4ZWN1dGUgYSBTUEkg bWVtb3J5IG9wZXJhdGlvbgo+ICsgKiBAZGlybWFwX2NyZWF0ZTogY3JlYXRlIGEgZGlyZWN0IG1h cHBpbmcgZGVzY3JpcHRvciB0aGF0IGNhbiBsYXRlciBiZSB1c2VkIHRvCj4gKyAqCQkgICBhY2Nl c3MgdGhlIG1lbW9yeSBkZXZpY2UuIFRoaXMgbWV0aG9kIGlzIG9wdGlvbmFsCgpPbmx5ICpkaXJt YXBfY3JlYXRlKCkgaXMgbWFya2VkIGFzIG9wdGlvbmFsIHdoaWxlIGFsbCBhcmUuCgo+ICsgKiBA ZGlybWFwX2Rlc3Ryb3k6IGRlc3Ryb3kgYSBtZW1vcnkgZGVzY3JpcHRvciBwcmV2aW91cyBjcmVh dGVkIGJ5Cj4gKyAqCQkgICAgLT5kaXJtYXBfY3JlYXRlKCkKCnMvcHJldmlvdXMvcHJldmlvdXNs eS8KCj4gKyAqIEBkaXJtYXBfcmVhZDogcmVhZCBkYXRhIGZyb20gdGhlIG1lbW9yeSBkZXZpY2Ug dXNpbmcgdGhlIGRpcmVjdCBtYXBwaW5nCj4gKyAqCQkgY3JlYXRlZCBieSAtPmRpcm1hcF9jcmVh dGUoKS4KPiArICogQGRpcm1hcF93cml0ZTogd3JpdGUgZGF0YSB0byB0aGUgbWVtb3J5IGRldmlj ZSB1c2luZyB0aGUgZGlyZWN0IG1hcHBpbmcKPiArICoJCSAgY3JlYXRlZCBieSAtPmRpcm1hcF9j cmVhdGUoKS4KCkkgdGhpbmsgdGhlcmUgaXMgYSBiZXR0ZXIga2VybmVsLWRvYyB3YXkgdG8gcmVm ZXJlbmNlIGRpcm1hcF9jcmVhdGUoKSwKbWF5YmUgd2l0aCAnQCcgKEkgZG9uJ3QgcmVtZW1iZXIg ZXhhY3RseSkuCgo+ICAgKgo+ICAgKiBUaGlzIGludGVyZmFjZSBzaG91bGQgYmUgaW1wbGVtZW50 ZWQgYnkgU1BJIGNvbnRyb2xsZXJzIHByb3ZpZGluZyBhbgo+ICAgKiBoaWdoLWxldmVsIGludGVy ZmFjZSB0byBleGVjdXRlIFNQSSBtZW1vcnkgb3BlcmF0aW9uLCB3aGljaCBpcyB1c3VhbGx5IHRo ZQo+ICAgKiBjYXNlIGZvciBRU1BJIGNvbnRyb2xsZXJzLgo+ICsgKgo+ICsgKiBOb3RlIG9uIC0+ ZGlybWFwX3tyZWFkLHdyaXRlfSgpOiBkcml2ZXJzIHNob3VsZCBhdm9pZCBhY2Nlc3NpbmcgdGhl IGRpcmVjdAo+ICsgKiBtYXBwaW5nIGZyb20gdGhlIENQVSBiZWNhdXNlIGRvaW5nIHRoYXQgY2Fu IHN0YWxsIHRoZSBDUFUgd2FpdGluZyBmb3IgdGhlCj4gKyAqIFNQSSBtZW0gdHJhbnNhY3Rpb24g dG8gZmluaXNoLCBhbmQgdGhpcyB3aWxsIG1ha2UgcmVhbC10aW1lIG1haW50YWluZXJzCj4gKyAq IHVuaGFwcHkgYW5kIG1pZ2h0IG1ha2UgeW91ciBzeXN0ZW0gbGVzcyByZWFjdGl2ZS4gSW5zdGVh ZCwgZHJpdmVycyBzaG91bGQKPiArICogdXNlIERNQSB0byBhY2Nlc3MgdGhpcyBkaXJlY3QgbWFw cGluZy4KPiAgICovCj4gIHN0cnVjdCBzcGlfY29udHJvbGxlcl9tZW1fb3BzIHsKPiAgCWludCAo KmFkanVzdF9vcF9zaXplKShzdHJ1Y3Qgc3BpX21lbSAqbWVtLCBzdHJ1Y3Qgc3BpX21lbV9vcCAq b3ApOwo+IEBAIC0xNzgsNiArMjM1LDEyIEBAIHN0cnVjdCBzcGlfY29udHJvbGxlcl9tZW1fb3Bz IHsKPiAgCQkJICAgIGNvbnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCk7Cj4gIAlpbnQgKCpleGVj X29wKShzdHJ1Y3Qgc3BpX21lbSAqbWVtLAo+ICAJCSAgICAgICBjb25zdCBzdHJ1Y3Qgc3BpX21l bV9vcCAqb3ApOwo+ICsJaW50ICgqZGlybWFwX2NyZWF0ZSkoc3RydWN0IHNwaV9tZW1fZGlybWFw X2Rlc2MgKmRlc2MpOwo+ICsJdm9pZCAoKmRpcm1hcF9kZXN0cm95KShzdHJ1Y3Qgc3BpX21lbV9k aXJtYXBfZGVzYyAqZGVzYyk7Cj4gKwlzc2l6ZV90ICgqZGlybWFwX3JlYWQpKHN0cnVjdCBzcGlf bWVtX2Rpcm1hcF9kZXNjICpkZXNjLAo+ICsJCQkgICAgICAgdTY0IG9mZnMsIHNpemVfdCBsZW4s IHZvaWQgKmJ1Zik7Cj4gKwlzc2l6ZV90ICgqZGlybWFwX3dyaXRlKShzdHJ1Y3Qgc3BpX21lbV9k aXJtYXBfZGVzYyAqZGVzYywKPiArCQkJCXU2NCBvZmZzLCBzaXplX3QgbGVuLCBjb25zdCB2b2lk ICpidWYpOwo+ICB9Owo+ICAKPiAgLyoqCj4gQEAgLTIzNiw2ICsyOTksMTUgQEAgYm9vbCBzcGlf bWVtX3N1cHBvcnRzX29wKHN0cnVjdCBzcGlfbWVtICptZW0sCj4gIGludCBzcGlfbWVtX2V4ZWNf b3Aoc3RydWN0IHNwaV9tZW0gKm1lbSwKPiAgCQkgICAgY29uc3Qgc3RydWN0IHNwaV9tZW1fb3Ag Km9wKTsKPiAgCj4gK3N0cnVjdCBzcGlfbWVtX2Rpcm1hcF9kZXNjICoKPiArc3BpX21lbV9kaXJt YXBfY3JlYXRlKHN0cnVjdCBzcGlfbWVtICptZW0sCj4gKwkJICAgICAgY29uc3Qgc3RydWN0IHNw aV9tZW1fZGlybWFwX2luZm8gKmluZm8pOwo+ICt2b2lkIHNwaV9tZW1fZGlybWFwX2Rlc3Ryb3ko c3RydWN0IHNwaV9tZW1fZGlybWFwX2Rlc2MgKmRlc2MpOwo+ICtzc2l6ZV90IHNwaV9tZW1fZGly bWFwX3JlYWQoc3RydWN0IHNwaV9tZW1fZGlybWFwX2Rlc2MgKmRlc2MsCj4gKwkJCSAgICB1NjQg b2Zmcywgc2l6ZV90IGxlbiwgdm9pZCAqYnVmKTsKPiArc3NpemVfdCBzcGlfbWVtX2Rpcm1hcF93 cml0ZShzdHJ1Y3Qgc3BpX21lbV9kaXJtYXBfZGVzYyAqZGVzYywKPiArCQkJICAgICB1NjQgb2Zm cywgc2l6ZV90IGxlbiwgY29uc3Qgdm9pZCAqYnVmKTsKPiArCj4gIGludCBzcGlfbWVtX2RyaXZl cl9yZWdpc3Rlcl93aXRoX293bmVyKHN0cnVjdCBzcGlfbWVtX2RyaXZlciAqZHJ2LAo+ICAJCQkJ ICAgICAgIHN0cnVjdCBtb2R1bGUgKm93bmVyKTsKPiAgCgpUaGUgcmVzdCBpcyBjbGVhciBmb3Ig bWUuCgpUaGFua3MsCk1pcXXDqGwKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpMaW51eCBNVEQgZGlzY3Vzc2lvbiBtYWlsaW5nIGxpc3QKaHR0 cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1tdGQvCg==