From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [RFC] usb: xhci: add Immediate Data Transfers support From: Felipe Balbi Message-Id: <877eejocsu.fsf@linux.intel.com> Date: Fri, 01 Feb 2019 15:31:29 +0200 To: Nicolas Saenz Julienne , oneukum@suse.com, Mathias Nyman , Greg Kroah-Hartman Cc: linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org List-ID: SGksCgpOaWNvbGFzIFNhZW56IEp1bGllbm5lIDxuc2FlbnpqdWxpZW5uZUBzdXNlLmRlPiB3cml0 ZXM6Cj4gSW1tZWRpYXRlIGRhdGEgdHJhbnNmZXJzIChJRFQpIGFsbG93IHRoZSBIQ0QgdG8gY29w eSBzbWFsbCBjaHVua3Mgb2YKPiBkYXRhICh1cCB0byA4Yml0cykgZGlyZWN0bHkgaW50byBpdHMg b3V0cHV0IHRyYW5zZmVyIFRSQnMuIFRoaXMgYXZvaWRzCiAgICAgICAgICAgICAgXl5eXl4KICAg ICAgICAgICAgICA4IGJ5dGVzCgo+IHRoZSBzb21ld2hhdCBleHBlbnNpdmUgRE1BIG1hcHBpbmdz IHRoYXQgYXJlIHBlcmZvcm1lZCBieSBkZWZhdWx0IG9uCj4gbW9zdCBVUkJzIHN1Ym1pc3Npb25z Lgo+Cj4gSW4gdGhlIGNhc2UgYW4gVVJCIHdhcyBzdWl0YWJsZSBmb3IgSURULiBUaGUgZGF0YSBp cyBkaXJlY3RseSBjb3BpZWQKPiBpbnRvIHRoZSAiRGF0YSBCdWZmZXIgUG9pbnRlciIgcmVnaW9u IG9mIHRoZSBUUkIgYW5kIHRoZSBJRFQgZmxhZyBpcwo+IHNldC4gSW5zdGVhZCBvZiB0cmlnZ2Vy aW5nIG1lbW9yeSBhY2Nlc3NlcyB0aGUgSEMgd2lsbCB1c2UgdGhlIGRhdGEKPiBkaXJlY3RseS4K Pgo+IEFuIGFkZGl0aW9uYWwgVVJCIGZsYWcgd2FzIGNyZWF0ZWQgdG8gbWFyayB3aGVuZXZlciB0 aGUgVVJCIGRvZXNuJ3QgbmVlZAo+IGFueSBETUEgbWFwcGluZy4gSWRlYWxseSBpdCB3b3VsZCBo YXZlIGJlZW4gbmljZSB0byB1c2UgYSBwcml2YXRlIGZsYWcKPiBhcyB0aGlzIGlzIHNwZWNpZmlj IHRvIFhIQ0kuIFlldCBpdCdzIG5vdCBwb3NzaWJsZSBhcyB0aGUgVVJCIHByaXZhdGUKPiBhcmVh IGlzIGFsbG9jYXRlZCBvbmx5IGFmdGVyIHRoZSBETUEgbWFwcGluZyBpcyBkb25lLgo+Cj4gSXNv Y2hyb25vdXMgdHJhbnNmZXJzIGFyZSBub3QgaW1wbGVtZW50ZWQgc28gZmFyIGFzIGl0J3MgaGFy ZCB0byBmaW5kIGEKPiBkZXZpY2UgdGhhdCB3aWxsIHNlbmQgc3VjaCBzbWFsbCBwYWNrZXRzLgo+ Cj4gVGhpcyB3YXMgdGVzdGVkIHVzaW5nIFVTQi9zZXJpYWwgYWRhcHRlciBhbmQgYnkgY29udHJv bGxpbmcgdGhlIGxlZHMgb24KPiBhbiBYQk9YIGNvbnRyb2xsZXIuIFRoZXJlIHdoZXJlIG5vIGRp c3J1cHRpb25zIG9uIHRoZSByZXN0IG9mIFVTQgo+IGRldmljZXMgYXR0YWNoZWQgb24gdGhlIHN5 c3RlbS4KPgo+IFNpZ25lZC1vZmYtYnk6IE5pY29sYXMgU2FlbnogSnVsaWVubmUgPG5zYWVuemp1 bGllbm5lQHN1c2UuZGU+Cj4gLS0tCj4gIGRyaXZlcnMvdXNiL2hvc3QveGhjaS1yaW5nLmMgfCAg NiArKysrKysKPiAgZHJpdmVycy91c2IvaG9zdC94aGNpLmMgICAgICB8IDM3ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBkcml2ZXJzL3VzYi9ob3N0L3hoY2kuaCAgICAg IHwgIDIgKysKPiAgaW5jbHVkZS9saW51eC91c2IuaCAgICAgICAgICB8ICAyICsrCj4gIDQgZmls ZXMgY2hhbmdlZCwgNDcgaW5zZXJ0aW9ucygrKQo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNi L2hvc3QveGhjaS1yaW5nLmMgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktcmluZy5jCj4gaW5kZXgg NDBmYTI1YzRkMDQxLi5kZDk4MDVmYjA1NjYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvaG9z dC94aGNpLXJpbmcuYwo+ICsrKyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS1yaW5nLmMKPiBAQCAt MzI3Miw2ICszMjcyLDEyIEBAIGludCB4aGNpX3F1ZXVlX2J1bGtfdHgoc3RydWN0IHhoY2lfaGNk ICp4aGNpLCBnZnBfdCBtZW1fZmxhZ3MsCj4gIAkJCWZpZWxkIHw9IFRSQl9JT0M7Cj4gIAkJCW1v cmVfdHJic19jb21pbmcgPSBmYWxzZTsKPiAgCQkJdGQtPmxhc3RfdHJiID0gcmluZy0+ZW5xdWV1 ZTsKPiArCj4gKwkJCWlmICh1cmItPnRyYW5zZmVyX2ZsYWdzICYgVVJCX05PX0RNQV9NQVApIHsK CmRvIHlvdSByZWFsbHkgbmVlZCB0aGUgZmxhZz8gV2h5IGRvbid0IHlvdSBkbyB0aGlzIHVuY29u ZGl0aW9uYWxseSBhcwpsb25nIGFzIHVyYi0+dHJhbnNmZXJfbGVuZ3RoIGlzIDw9IDg/Cgo+ICsJ CQkJbWVtY3B5KCZzZW5kX2FkZHIsIHVyYi0+dHJhbnNmZXJfYnVmZmVyLAo+ICsJCQkJICAgICAg IGZ1bGxfbGVuKTsKPiArCQkJCWZpZWxkIHw9IFRSQl9JRFQ7Cj4gKwkJCX0KPiAgCQl9Cj4gIAo+ ICAJCS8qIE9ubHkgc2V0IGludGVycnVwdCBvbiBzaG9ydCBwYWNrZXQgZm9yIElOIGVuZHBvaW50 cyAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuYyBiL2RyaXZlcnMvdXNi L2hvc3QveGhjaS5jCj4gaW5kZXggMDA1ZTY1OTIyNjA4Li5jZTNiNjY2M2Y5NDAgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy91c2IvaG9zdC94aGNpLmMKPiArKysgYi9kcml2ZXJzL3VzYi9ob3N0L3ho Y2kuYwo+IEBAIC0xMjM4LDYgKzEyMzgsNDEgQEAgRVhQT1JUX1NZTUJPTF9HUEwoeGhjaV9yZXN1 bWUpOwo+ICAKPiAgLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KPiAgCj4gK3N0YXRpYyB2b2lkIHhoY2lf dW5tYXBfdXJiX2Zvcl9kbWEoc3RydWN0IHVzYl9oY2QgKmhjZCwgc3RydWN0IHVyYiAqdXJiKQo+ ICt7Cj4gKwlpZiAodXJiLT50cmFuc2Zlcl9mbGFncyAmIFVSQl9OT19ETUFfTUFQKQo+ICsJCXVy Yi0+dHJhbnNmZXJfZmxhZ3MgJj0gflVSQl9OT19ETUFfTUFQOwo+ICsJZWxzZQo+ICsJCXVzYl9o Y2RfdW5tYXBfdXJiX2Zvcl9kbWEoaGNkLCB1cmIpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHho Y2lfbWFwX3VyYl9mb3JfZG1hKHN0cnVjdCB1c2JfaGNkICpoY2QsIHN0cnVjdCB1cmIgKnVyYiwK PiArCQkJCWdmcF90IG1lbV9mbGFncykKPiArewo+ICsJaW50IG1heHAgPSB1c2JfZW5kcG9pbnRf bWF4cCgmdXJiLT5lcC0+ZGVzYyk7Cj4gKwlpbnQgbGVuID0gdXJiLT50cmFuc2Zlcl9idWZmZXJf bGVuZ3RoOwo+ICsJaW50IHJldCA9IDA7Cj4gKwo+ICsJLyoKPiArCSAqIENoZWNrcyBpZiBVUkIg aXMgc3VpdGFibGUgZm9yIEltbWVkaWF0ZSBUcmFuc2ZlciAoSURUKTogaW5zdGVhZCBvZgo+ICsJ ICogbWFwcGluZyB0aGUgYnVmZmVyIGZvciBETUEgYW5kIHBhc3NpbmcgdGhlIGFkZHJlc3MgdG8g dGhlIGhvc3QKPiArCSAqIGNvbnRyb2xsZXIsIHdlIGNvcHkgdGhlIGFjdHVhbCBkYXRhIGludG8g dGhlIFRSQiBhZGRyZXNzIHJlZ2lzdGVyLgo+ICsJICogVGhpcyBpcyBsaW1pdGVkIHRvIHRyYW5z ZmVycyB1cCB0byA4IGJ5dGVzLgo+ICsJICoKPiArCSAqIElEVCBpcyBvbmx5IHN1cHBvcnRlZCBm b3IgQnVsayBhbmQgSW50ZXJydXB0IGVuZHBvaW50cy4gQXBhcnQgZnJvbQo+ICsJICogdGhlIHNp emUgY29uc3RyYWludHMgc3BlY2lhbCBjYXJlIGlzIHRha2VuIHRvIGF2b2lkIGNhc2VzIHdoZXJl Cj4gKwkgKiB3TWF4UGFja2V0U2l6ZSBpcyBzbWFsbGVyIHRoYW4gOCBieXRlcyBhcyBpdCdzIG5v dCBzdXBwb3J0ZWQuCj4gKwkgKi8KPiArCWlmICgodXNiX2VuZHBvaW50X2lzX2ludF9vdXQoJnVy Yi0+ZXAtPmRlc2MpIHx8Cj4gKwkgICAgdXNiX2VuZHBvaW50X2lzX2J1bGtfb3V0KCZ1cmItPmVw LT5kZXNjKSkgJiYKCkkgZG9uJ3QgdW5kZXJzdGFuZCB0aGUgY2hlY2sgZm9yIGVuZHBvaW50IHR5 cGUuIElEVCBpcywgYWN0dWFsbHksCmFscmVhZHkgdXNlZCBmb3IgY29udHJvbCBlbmRwb2ludHMg YmVjYXVzZSBzZXR1cCBwYWNrZXRzIGFyZSBjb21wb3NlZCBvZgo4IGJ5dGVzLiBZb3UncmUgYWxz byBzaG93aW5nIHRoYXQgdGhpcyB3b3JrcyBmb3IgSU5UIGFuZCBCVUxLIHR5cGVzLiBJdAp3b3Vs ZCBiZSBhIHN1cnByaXNlIGlmIGl0IGRvZXNuJ3Qgd29yayBmb3IgSVNPQy4KCj4gKwkgICAgbWF4 cCA+PSBUUkJfSURUX01BWF9TSVpFICYmIGxlbiA8PSBUUkJfSURUX01BWF9TSVpFKQoKd2h5IHRo ZSBtYXhwIGNoZWNrPyBXaGF0IGlmIEknbSBhbiBpbnRlcnJ1cHQgZW5kcG9pbnQgd2l0aCBtYXhw IG9mIDI/CklzIHRoZXJlIHJlYWxseSBhIGxpbWl0YXRpb24gdGhhdCB5b3UgY291bGRuJ3QgdXNl IElEVCBmb3IgdGhvc2U/Cgo+ICsJCXVyYi0+dHJhbnNmZXJfZmxhZ3MgfD0gVVJCX05PX0RNQV9N QVA7CgpkbyB3ZSByZWFsbHkgbmVlZCB0aGlzPyBJIHdvbmRlciBpZiByZXR1cm5pbmcgemVybyBo ZXJlIHdvdWxkIGJlIGVub3VnaCwKdGhlbiB5b3UgY291bGQ6CgouLi5tYXBfdXJiX2Zvcl9kbWEo Li4uKQp7CglyZXQgPSAwOwoKCWlmICh1cmItPnRyYW5zZmVyX2xlbmd0aCA+IDgpCiAgICAgICAg CXJldCA9IHVzYl9oY2RfbWFwX3VyYl9mb3JfZG1hKGhjZCwgdXJiLCBmbGFncyk7CgoJcmV0dXJu IHJldDsKfQoKLi4udW5tYXBfdXJiX2Zvcl9kbWEoLi4uKQp7CglpZiB1cmItPnRyYW5zZmVyX2xl bmd0aCA+IDgpCiAgICAgICAgCXVzYl9oY2RfdW5tYXBfdXJiX2Zvcl9kbWEoaGNkLCB1cmIpOwp9 CgouLi54aGNpX3F1ZXVlX2J1bGtfdHgoLi4uKQp7CglbLi4uXQoKCWlmICh1cmItPnRyYW5zZmVy X2xlbmd0aCA8PSA4KSB7CgkJbWVtY3B5KCZhZGRyLCB1cmItPnRyYW5zZmVyX2J1ZmZlciwgOCls CgkJZmllbGQgfD0gVFJCX0lEVDsKICAgICAgICB9CgoJWy4uLl0KfQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CAB21C282D8 for ; Fri, 1 Feb 2019 13:31:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A302421872 for ; Fri, 1 Feb 2019 13:31:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728921AbfBANbg (ORCPT ); Fri, 1 Feb 2019 08:31:36 -0500 Received: from mga04.intel.com ([192.55.52.120]:8242 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726586AbfBANbg (ORCPT ); Fri, 1 Feb 2019 08:31:36 -0500 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 01 Feb 2019 05:31:35 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,548,1539673200"; d="asc'?scan'208";a="315512397" Received: from pipin.fi.intel.com (HELO localhost) ([10.237.72.175]) by fmsmga006.fm.intel.com with ESMTP; 01 Feb 2019 05:31:33 -0800 From: Felipe Balbi To: Nicolas Saenz Julienne , oneukum@suse.com, Mathias Nyman , Greg Kroah-Hartman Cc: Nicolas Saenz Julienne , linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [RFC] usb: xhci: add Immediate Data Transfers support In-Reply-To: <20190201130602.9171-1-nsaenzjulienne@suse.de> References: <20190201130602.9171-1-nsaenzjulienne@suse.de> Date: Fri, 01 Feb 2019 15:31:29 +0200 Message-ID: <877eejocsu.fsf@linux.intel.com> MIME-Version: 1.0 Content-Type: multipart/signed; boundary="=-=-="; micalg=pgp-sha256; protocol="application/pgp-signature" Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --=-=-= Content-Type: text/plain Content-Transfer-Encoding: quoted-printable Hi, Nicolas Saenz Julienne writes: > Immediate data transfers (IDT) allow the HCD to copy small chunks of > data (up to 8bits) directly into its output transfer TRBs. This avoids ^^^^^ 8 bytes > the somewhat expensive DMA mappings that are performed by default on > most URBs submissions. > > In the case an URB was suitable for IDT. The data is directly copied > into the "Data Buffer Pointer" region of the TRB and the IDT flag is > set. Instead of triggering memory accesses the HC will use the data > directly. > > An additional URB flag was created to mark whenever the URB doesn't need > any DMA mapping. Ideally it would have been nice to use a private flag > as this is specific to XHCI. Yet it's not possible as the URB private > area is allocated only after the DMA mapping is done. > > Isochronous transfers are not implemented so far as it's hard to find a > device that will send such small packets. > > This was tested using USB/serial adapter and by controlling the leds on > an XBOX controller. There where no disruptions on the rest of USB > devices attached on the system. > > Signed-off-by: Nicolas Saenz Julienne > --- > drivers/usb/host/xhci-ring.c | 6 ++++++ > drivers/usb/host/xhci.c | 37 ++++++++++++++++++++++++++++++++++++ > drivers/usb/host/xhci.h | 2 ++ > include/linux/usb.h | 2 ++ > 4 files changed, 47 insertions(+) > > diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c > index 40fa25c4d041..dd9805fb0566 100644 > --- a/drivers/usb/host/xhci-ring.c > +++ b/drivers/usb/host/xhci-ring.c > @@ -3272,6 +3272,12 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_= t mem_flags, > field |=3D TRB_IOC; > more_trbs_coming =3D false; > td->last_trb =3D ring->enqueue; > + > + if (urb->transfer_flags & URB_NO_DMA_MAP) { do you really need the flag? Why don't you do this unconditionally as long as urb->transfer_length is <=3D 8? > + memcpy(&send_addr, urb->transfer_buffer, > + full_len); > + field |=3D TRB_IDT; > + } > } >=20=20 > /* Only set interrupt on short packet for IN endpoints */ > diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c > index 005e65922608..ce3b6663f940 100644 > --- a/drivers/usb/host/xhci.c > +++ b/drivers/usb/host/xhci.c > @@ -1238,6 +1238,41 @@ EXPORT_SYMBOL_GPL(xhci_resume); >=20=20 > /*----------------------------------------------------------------------= ---*/ >=20=20 > +static void xhci_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb) > +{ > + if (urb->transfer_flags & URB_NO_DMA_MAP) > + urb->transfer_flags &=3D ~URB_NO_DMA_MAP; > + else > + usb_hcd_unmap_urb_for_dma(hcd, urb); > +} > + > +static int xhci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, > + gfp_t mem_flags) > +{ > + int maxp =3D usb_endpoint_maxp(&urb->ep->desc); > + int len =3D urb->transfer_buffer_length; > + int ret =3D 0; > + > + /* > + * Checks if URB is suitable for Immediate Transfer (IDT): instead of > + * mapping the buffer for DMA and passing the address to the host > + * controller, we copy the actual data into the TRB address register. > + * This is limited to transfers up to 8 bytes. > + * > + * IDT is only supported for Bulk and Interrupt endpoints. Apart from > + * the size constraints special care is taken to avoid cases where > + * wMaxPacketSize is smaller than 8 bytes as it's not supported. > + */ > + if ((usb_endpoint_is_int_out(&urb->ep->desc) || > + usb_endpoint_is_bulk_out(&urb->ep->desc)) && I don't understand the check for endpoint type. IDT is, actually, already used for control endpoints because setup packets are composed of 8 bytes. You're also showing that this works for INT and BULK types. It would be a surprise if it doesn't work for ISOC. > + maxp >=3D TRB_IDT_MAX_SIZE && len <=3D TRB_IDT_MAX_SIZE) why the maxp check? What if I'm an interrupt endpoint with maxp of 2? Is there really a limitation that you couldn't use IDT for those? > + urb->transfer_flags |=3D URB_NO_DMA_MAP; do we really need this? I wonder if returning zero here would be enough, then you could: ...map_urb_for_dma(...) { ret =3D 0; if (urb->transfer_length > 8) ret =3D usb_hcd_map_urb_for_dma(hcd, urb, flags); return ret; } ...unmap_urb_for_dma(...) { if urb->transfer_length > 8) usb_hcd_unmap_urb_for_dma(hcd, urb); } ...xhci_queue_bulk_tx(...) { [...] if (urb->transfer_length <=3D 8) { memcpy(&addr, urb->transfer_buffer, 8)l field |=3D TRB_IDT; } [...] } =2D-=20 balbi --=-=-= Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iQIzBAEBCAAdFiEElLzh7wn96CXwjh2IzL64meEamQYFAlxUSjEACgkQzL64meEa mQahyRAArMrVSj00oL/k6LTGlMKnyGvSP9gVrBAITw6KWDp4+cojmmvpLdsm4lgt vIkg7tK6p+L+t1SD3vZL5/HYKr+UR+BjW8EpOAx0TEC99pfAVJd/mL1d8Z+73eOc qC1vQZ4Tj7LL3XyO1ovfnq5aIi+WqulaLsIAHDyIUY3puaQy3cldMnI7x+ZXG2+I zh9Wo1qK83VX152FSBrK9QDKfSQUEUgF4TnDr57bf7BCXMSYDK1XHo2fdTzPKPeG npQxt/yIuozOY0ajwAesnieCQbstFfop8SqGFuwZ/pQCtdKS79e4ZqTYh0GStfEQ 4Xj80lr6TeXl7IhW0DwKQvjC/x/19jn4JBwbg905eDC5gHmPZm0BsUMmXHGlhK3y BJdwEFZCjg6wyJOeoFvM3VojxSDVIn+vi2Z/FOqRDLEJtrogFt3g+QXCBWuN3cyK si0YvBQagJb4AHtdaNeiXqcCGziGvWwjO3mDtWNtpzYXd4c8tmd3eptgVVtXRqwu GmrjErCVL144SVR3Xu7JS/BsyDuvPhtII35KY8jZf+BfAIqGW50bk31vbGf9I2wW 9R42ii9xS7OFcFk6AgieRN7jcBPGuwhstwDfkVYdYnYuLZl7lylYGLvDVerizsNn 64kr05F7qmYPy0901JEVWSfgrmbFzuuTGEFlfacJ8g5mx97W1Yg= =LmAY -----END PGP SIGNATURE----- --=-=-=--