pci: support Thunderbolt requirements for I/O resources.
PATCH 1/1 pci: support Thunderbolt requirements for I/O resources.
Every Thunderbolt-based devices or Thunderbolt-connected devices should not allocate PCI I/O resources per Thunderbolt specs.
On a Thunderbolt PC, BIOS is responsible to allocate IO resources. Kernel shouldn't allocate the PCI I/O resources as it interferes with BIOS operation.
Doing this may cause the devices in the Thunderbolt chain not being detected or added, or worse to stuck the Thunderbolt Host controller.
To prevent this, we detect a chain contains a Thunderbolt device by checking the Thunderbolt PCI device id.
The validation is carried out at the pci_enable_device_flags() function that checks the PCI device or bridge is Thunderbolt chained and avoid IO resources allocation.
In addition, decode_bar() and pci_bridge_check_ranges() function has been internally checked for Thunderbolt as well to ensure no IO resources are allocated.
--- drivers/pci/pci.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++ drivers/pci/pci.h | 2 ++ drivers/pci/probe.c | 3 ++- drivers/pci/setup-bus.c | 4 ++-- include/linux/pci.h | 2 ++ 5 files changed, 72 insertions(+), 3 deletions(-)
drivers/pci/pci.c +64 -0
@@ -198,6 +198,62 @@ static int __pci_bus_find_cap_start(struct pci_bus *bus, }/** +* pci_is_thunderbolt_device - checks PCI device is Thunderbolt-based. +* The only existing way is to check the device id is allocated to Thunderbolt. +* @dev: the PCI device structure to check against +* +* Returns true if the PCI device is of the Thunderbolt type. +*/ +bool pci_is_thunderbolt_device (struct pci_dev *dev) +{ +if ((dev->vendor ==PCI_VENDOR_ID_INTEL ) && + ((dev->device ==0xcaca ) + || (dev->device ==0x1513 ) + || (dev->device ==0xcbca ) + || (dev->device ==0x151A ) + || (dev->device ==0x151B ) + || (dev->device ==0x1549 ) + || (dev->device ==0x1547 ) + || (dev->device ==0x1548 ) + || (dev->device ==0x1566 ) + || (dev->device ==0x1567 ) + || (dev->device ==0x1569 ) + || (dev->device ==0x1568 ) + || (dev->device ==0x156A ) + || (dev->device ==0x156B ) + || (dev->device ==0x156C ) + || (dev->device ==0x156D ) + || (dev->device ==0x1579 ) + || (dev->device ==0x157A ) + || (dev->device ==0x157D ) + || (dev->device ==0x157E ))) +return true; + +return false; +} +EXPORT_SYMBOL (pci_is_thunderbolt_device); + +/** +* pci_is_connected_to_thunderbolt - check if connected to a Thunderbolt chain. +* @dev: the PCI device structure to check against +* +* Returns true if the PCI device s connected is connected to a +* Thunderbolt-based in the chain. +*/ +bool pci_is_connected_to_thunderbolt (struct pci_dev *dev) +{ +struct pci_dev *bridge; + +if (pci_is_thunderbolt_device (dev)) +return true; + bridge =pci_upstream_bridge (dev); +if (bridge) +return pci_is_connected_to_thunderbolt (bridge); +return false; +} +EXPORT_SYMBOL (pci_is_connected_to_thunderbolt); + +/** * pci_find_capability - query for devices' capabilities * @dev: PCI device to query * @cap: capability code
@@ -1285,6 +1341,14 @@ static int pci_enable_device_flags(struct pci_dev *dev, unsigned long flags)if (atomic_inc_return (&dev->enable_cnt) >1 )return 0 ;/* already enabled */ +/* +* if IO resource have been requested, but the device is connected +* to Thunderbolt chain, don't allocate IO resource +*/ +if ((flags &IORESOURCE_IO ) + &&pci_is_connected_to_thunderbolt (dev)) + flags &= ~IORESOURCE_IO ; + bridge =pci_upstream_bridge (dev);if (bridge)pci_enable_bridge (bridge);
drivers/pci/pci.h +2 -0
@@ -4,6 +4,8 @@#define PCI_CFG_SPACE_SIZE 256#define PCI_CFG_SPACE_EXP_SIZE 4096 +bool pci_is_thunderbolt_device (struct pci_dev *dev); +extern const unsigned char pcie_link_speed[];/* Functions internal to the PCI core code */
drivers/pci/probe.c +2 -1
@@ -131,7 +131,8 @@ static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)if ((bar &PCI_BASE_ADDRESS_SPACE ) ==PCI_BASE_ADDRESS_SPACE_IO ) { flags = bar & ~PCI_BASE_ADDRESS_IO_MASK ; - flags |=IORESOURCE_IO ; +if (!pci_is_connected_to_thunderbolt (dev)) + flags |=IORESOURCE_IO ;return flags; }
drivers/pci/setup-bus.c +2 -2
@@ -663,12 +663,12 @@ static void pci_bridge_check_ranges(struct pci_bus *bus) b_res[1 ].flags |=IORESOURCE_MEM ;pci_read_config_word (bridge,PCI_IO_BASE , &io); -if (!io) { +if (!io ||pci_is_thunderbolt_device (bridge)) {pci_write_config_word (bridge,PCI_IO_BASE ,0xe0f0 );pci_read_config_word (bridge,PCI_IO_BASE , &io);pci_write_config_word (bridge,PCI_IO_BASE ,0x0 ); } -if (io) +if (io && !pci_is_thunderbolt_device (bridge)) b_res[0 ].flags |=IORESOURCE_IO ;/* DECchip 21050 pass 2 errata: the bridge may miss an address
include/linux/pci.h +2 -0
@@ -931,6 +931,8 @@ int __must_check pci_enable_device_io(struct pci_dev *dev);int __must_check pci_enable_device_mem (struct pci_dev *dev);int __must_check pci_reenable_device (struct pci_dev *);int __must_check pcim_enable_device (struct pci_dev *pdev); + +bool pci_is_connected_to_thunderbolt (struct pci_dev *dev);void pcim_pin_device (struct pci_dev *pdev);static inline int pci_is_enabled (struct pci_dev *pdev)
Signature · 9 lines
1.9.1 --------------------------------------------------------------------- Intel Israel (74) Limited This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
Bjorn Helgaas
maintainer[+cc Rafael, Andreas]
Quoted 3 lines · Michael Jamet
Every Thunderbolt-based devices or Thunderbolt-connected devices should not allocate PCI I/O resources per Thunderbolt specs.
Please include a pointer to those specs in the changelog.
Quoted 6 lines
On a Thunderbolt PC, BIOS is responsible to allocate IO resources. Kernel shouldn't allocate the PCI I/O resources as it interferes with BIOS operation.
Doing this may cause the devices in the Thunderbolt chain not being detected or added, or worse to stuck the Thunderbolt Host controller.
These new kernel/firmware coordination requirements need to be documented. If they're already part of a PCIe ECN or PCI firmware spec, just provide a pointer.
Quoted 2 lines
To prevent this, we detect a chain contains a Thunderbolt device by checking the Thunderbolt PCI device id.
I'm really not happy about checking a list of device IDs to identify Thunderbolt devices. Surely there's a better way, because a list like this has to be updated regularly.
Bjorn
Quoted 169 lines
The validation is carried out at the
pci_enable_device_flags()function that checks the PCI device or bridge is Thunderbolt chained and avoid IO resources allocation.In addition,
decode_bar()andpci_bridge_check_ranges()function has been internally checked for Thunderbolt as well to ensure no IO resources are allocated.Signed-off-by Michael Jamet <[email protected]>--- drivers/pci/pci.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++ drivers/pci/pci.h | 2 ++ drivers/pci/probe.c | 3 ++- drivers/pci/setup-bus.c | 4 ++-- include/linux/pci.h | 2 ++ 5 files changed, 72 insertions(+), 3 deletions(-)drivers/pci/pci.c +64
-0@@ -198,6 +198,62 @@ static int __pci_bus_find_cap_start(struct pci_bus *bus, }/** +* pci_is_thunderbolt_device - checks PCI device is Thunderbolt-based. +* The only existing way is to check the device id is allocated to Thunderbolt. +* @dev: the PCI device structure to check against +* +* Returns true if the PCI device is of the Thunderbolt type. +*/ +bool pci_is_thunderbolt_device (struct pci_dev *dev) +{ +if ((dev->vendor ==PCI_VENDOR_ID_INTEL ) && + ((dev->device ==0xcaca ) + || (dev->device ==0x1513 ) + || (dev->device ==0xcbca ) + || (dev->device ==0x151A ) + || (dev->device ==0x151B ) + || (dev->device ==0x1549 ) + || (dev->device ==0x1547 ) + || (dev->device ==0x1548 ) + || (dev->device ==0x1566 ) + || (dev->device ==0x1567 ) + || (dev->device ==0x1569 ) + || (dev->device ==0x1568 ) + || (dev->device ==0x156A ) + || (dev->device ==0x156B ) + || (dev->device ==0x156C ) + || (dev->device ==0x156D ) + || (dev->device ==0x1579 ) + || (dev->device ==0x157A ) + || (dev->device ==0x157D ) + || (dev->device ==0x157E ))) +return true; + +return false; +} +EXPORT_SYMBOL (pci_is_thunderbolt_device); + +/** +* pci_is_connected_to_thunderbolt - check if connected to a Thunderbolt chain. +* @dev: the PCI device structure to check against +* +* Returns true if the PCI device s connected is connected to a +* Thunderbolt-based in the chain. +*/ +bool pci_is_connected_to_thunderbolt (struct pci_dev *dev) +{ +struct pci_dev *bridge; + +if (pci_is_thunderbolt_device (dev)) +return true; + bridge =pci_upstream_bridge (dev); +if (bridge) +return pci_is_connected_to_thunderbolt (bridge); +return false; +} +EXPORT_SYMBOL (pci_is_connected_to_thunderbolt); + +/** * pci_find_capability - query for devices' capabilities * @dev: PCI device to query * @cap: capability code @@ -1285,6 +1341,14 @@ static int pci_enable_device_flags(struct pci_dev *dev, unsigned long flags)if (atomic_inc_return (&dev->enable_cnt) >1 )return 0 ;/* already enabled */ +/* +* if IO resource have been requested, but the device is connected +* to Thunderbolt chain, don't allocate IO resource +*/ +if ((flags &IORESOURCE_IO ) + &&pci_is_connected_to_thunderbolt (dev)) + flags &= ~IORESOURCE_IO ; + bridge =pci_upstream_bridge (dev);if (bridge)pci_enable_bridge (bridge);drivers/pci/pci.h +2
-0@@ -4,6 +4,8 @@#define PCI_CFG_SPACE_SIZE 256#define PCI_CFG_SPACE_EXP_SIZE 4096 +bool pci_is_thunderbolt_device (struct pci_dev *dev); +extern const unsigned char pcie_link_speed[];/* Functions internal to the PCI core code */ drivers/pci/probe.c +2
-1@@ -131,7 +131,8 @@ static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)if ((bar &PCI_BASE_ADDRESS_SPACE ) ==PCI_BASE_ADDRESS_SPACE_IO ) { flags = bar & ~PCI_BASE_ADDRESS_IO_MASK ; - flags |=IORESOURCE_IO ; +if (!pci_is_connected_to_thunderbolt (dev)) + flags |=IORESOURCE_IO ;return flags; }drivers/pci/setup-bus.c +2
-2@@ -663,12 +663,12 @@ static void pci_bridge_check_ranges(struct pci_bus *bus) b_res[1 ].flags |=IORESOURCE_MEM ;pci_read_config_word (bridge,PCI_IO_BASE , &io); -if (!io) { +if (!io ||pci_is_thunderbolt_device (bridge)) {pci_write_config_word (bridge,PCI_IO_BASE ,0xe0f0 );pci_read_config_word (bridge,PCI_IO_BASE , &io);pci_write_config_word (bridge,PCI_IO_BASE ,0x0 ); } -if (io) +if (io && !pci_is_thunderbolt_device (bridge)) b_res[0 ].flags |=IORESOURCE_IO ;/* DECchip 21050 pass 2 errata: the bridge may miss an address include/linux/pci.h +2
-1@@ -931,6 +931,8 @@ int __must_check pci_enable_device_io(struct pci_dev *dev);int __must_check pci_enable_device_mem (struct pci_dev *dev);int __must_check pci_reenable_device (struct pci_dev *);int __must_check pcim_enable_device (struct pci_dev *pdev); + +bool pci_is_connected_to_thunderbolt (struct pci_dev *dev);void pcim_pin_device (struct pci_dev *pdev);static inline int pci_is_enabled (struct pci_dev *pdev) --1.9.1
---------------------------------------------------------------------
Intel Israel (74) LimitedThis e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
On Wed, Nov 12, 2014 at 7:29 PM, Bjorn Helgaas <[email protected]> wrote:
[]
Quoted 6 lines
Quoted 2 lines
To prevent this, we detect a chain contains a Thunderbolt device by checking the Thunderbolt PCI device id.
I'm really not happy about checking a list of device IDs to identify Thunderbolt devices. Surely there's a better way, because a list like this has to be updated regularly.
I recently proposed internally to use quirks (pci_fixup_early) for that, but apparently Michael didn't have time to answer. It might be he can just comment here since the patch already public.
Signature · 2 lines
With Best Regards, Andy Shevchenko
Quoted 7 lines · Andy Shevchenko
On Wed, Nov 12, 2014 at 7:29 PM, Bjorn Helgaas <[email protected]> wrote:
[]
Quoted 3 lines
Quoted 2 lines
To prevent this, we detect a chain contains a Thunderbolt device by checking the Thunderbolt PCI device id.
Quoted 7 lines
Quoted 3 lines
I'm really not happy about checking a list of device IDs to identify Thunderbolt devices. Surely there's a better way, because a list like this has to be updated regularly.
I recently proposed internally to use quirks (
pci_fixup_early) for that, but apparently Michael didn't have time to answer. It might be he can just comment here since the patch already public.
In any case: this will interfere with thunderbolt hotplug on Apple systems, where we do not have BIOS support and have to handle hotplug events and assign resources ourselves. So please add a DMI check for Apple (the reverse of what we do in
http://lxr.free-electrons.com/source/drivers/thunderbolt/nhi.c?v=3.17#L664
).
Thanks,
Andreas
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBBbmRyZWFzIE5vZXZlciBbbWFp bHRvOmFuZHJlYXMubm9ldmVyQGdtYWlsLmNvbV0NCj4gU2VudDogV2VkbmVzZGF5LCBOb3ZlbWJl ciAxMiwgMjAxNCAyMjoxOQ0KPiBUbzogQW5keSBTaGV2Y2hlbmtvDQo+IENjOiBCam9ybiBIZWxn YWFzOyBKYW1ldCwgTWljaGFlbDsgbGludXgtcGNpQHZnZXIua2VybmVsLm9yZzsgbGludXgtDQo+ IGtlcm5lbEB2Z2VyLmtlcm5lbC5vcmc7IExldnksIEFtaXIgKEplcik7IEFsbG91biwgRGFuOyBS YWZhZWwgV3lzb2NraQ0KPiBTdWJqZWN0OiBSZTogW1BBVENIXSBwY2k6IHN1cHBvcnQgVGh1bmRl cmJvbHQgcmVxdWlyZW1lbnRzIGZvciBJL08NCj4gcmVzb3VyY2VzLg0KPiANCj4gT24gV2VkLCBO b3YgMTIsIDIwMTQgYXQgNzozMCBQTSwgQW5keSBTaGV2Y2hlbmtvDQo+IDxhbmR5LnNoZXZjaGVu a29AZ21haWwuY29tPiB3cm90ZToNCj4gPiBPbiBXZWQsIE5vdiAxMiwgMjAxNCBhdCA3OjI5IFBN LCBCam9ybiBIZWxnYWFzIDxiaGVsZ2Fhc0Bnb29nbGUuY29tPg0KPiB3cm90ZToNCj4gPg0KPiA+ IFtdDQo+ID4NCj4gPj4+IFRvIHByZXZlbnQgdGhpcywgd2UgZGV0ZWN0IGEgY2hhaW4gY29udGFp bnMgYSBUaHVuZGVyYm9sdCBkZXZpY2UgYnkNCj4gPj4+IGNoZWNraW5nIHRoZSBUaHVuZGVyYm9s dCBQQ0kgZGV2aWNlIGlkLg0KPiA+Pg0KPiA+PiBJJ20gcmVhbGx5IG5vdCBoYXBweSBhYm91dCBj aGVja2luZyBhIGxpc3Qgb2YgZGV2aWNlIElEcyB0byBpZGVudGlmeQ0KPiA+PiBUaHVuZGVyYm9s dCBkZXZpY2VzLiAgU3VyZWx5IHRoZXJlJ3MgYSBiZXR0ZXIgd2F5LCBiZWNhdXNlIGEgbGlzdA0K PiA+PiBsaWtlIHRoaXMgaGFzIHRvIGJlIHVwZGF0ZWQgcmVndWxhcmx5Lg0KPiA+DQo+ID4gSSBy ZWNlbnRseSBwcm9wb3NlZCBpbnRlcm5hbGx5IHRvIHVzZSBxdWlya3MgKHBjaV9maXh1cF9lYXJs eSkgZm9yDQo+ID4gdGhhdCwgYnV0IGFwcGFyZW50bHkgTWljaGFlbCBkaWRuJ3QgaGF2ZSB0aW1l IHRvIGFuc3dlci4gSXQgbWlnaHQgYmUNCj4gPiBoZSBjYW4ganVzdCBjb21tZW50IGhlcmUgc2lu Y2UgdGhlIHBhdGNoIGFscmVhZHkgcHVibGljLg0KPiANCj4gSW4gYW55IGNhc2U6IHRoaXMgd2ls bCBpbnRlcmZlcmUgd2l0aCB0aHVuZGVyYm9sdCBob3RwbHVnIG9uIEFwcGxlIHN5c3RlbXMsDQo+ IHdoZXJlIHdlIGRvIG5vdCBoYXZlIEJJT1Mgc3VwcG9ydCBhbmQgaGF2ZSB0byBoYW5kbGUgaG90 cGx1ZyBldmVudHMgYW5kDQo+IGFzc2lnbiByZXNvdXJjZXMgb3Vyc2VsdmVzLiBTbyBwbGVhc2Ug YWRkIGEgRE1JIGNoZWNrIGZvciBBcHBsZSAodGhlIHJldmVyc2UNCj4gb2Ygd2hhdCB3ZSBkbyBp bg0KPiBodHRwOi8vbHhyLmZyZWUtDQo+IGVsZWN0cm9ucy5jb20vc291cmNlL2RyaXZlcnMvdGh1 bmRlcmJvbHQvbmhpLmM/dj0zLjE3I0w2NjQNCj4gKS4NCj4gDQo+IFRoYW5rcywNCj4gQW5kcmVh cw0KDQpUaGlzIGlzIGNvcnJlY3QgdGhhdCB0aGUgaG90cGx1ZyBoYW5kbGluZyBtZWNoYW5pc20g YW5kIGludGVyYWN0aW9uIHdpdGggQklPUyBpcyBkaWZmZXJlbnQuIA0KSG93ZXZlciwgdGhpcyBw YXRjaCBhbHNvIGFwcGxpZXMgZm9yIGFueSBjYXNlLCBzaW5jZSB0aGUgSS9PIHNwYWNlIGlzIGxp bWl0ZWQgDQphbmQgbmVlZCB0byBiZSBwcmVzZXJ2ZWQsIHNvIHdlIG11c3QgcHJldmVudCBhbGxv Y2F0aW9uIG9mIEkvTyByZXNvdXJjZXMgDQpmcm9tIHRoZSBkZXZpY2VzIGFuZCBhdm9pZGluZyBl eGhhdXN0aW9uIHdoaWxlIGNoYWluaW5nIHRoZW0uDQoNCk1pY2hhZWwgDQoNCg0KLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCkludGVsIElzcmFlbCAoNzQpIExpbWl0ZWQKClRoaXMgZS1tYWlsIGFuZCBhbnkgYXR0YWNo bWVudHMgbWF5IGNvbnRhaW4gY29uZmlkZW50aWFsIG1hdGVyaWFsIGZvcgp0aGUgc29sZSB1c2Ug b2YgdGhlIGludGVuZGVkIHJlY2lwaWVudChzKS4gQW55IHJldmlldyBvciBkaXN0cmlidXRpb24K Ynkgb3RoZXJzIGlzIHN0cmljdGx5IHByb2hpYml0ZWQuIElmIHlvdSBhcmUgbm90IHRoZSBpbnRl bmRlZApyZWNpcGllbnQsIHBsZWFzZSBjb250YWN0IHRoZSBzZW5kZXIgYW5kIGRlbGV0ZSBhbGwg Y29waWVzLgo=
Quoted 35 lines · Michael
Quoted 35 lines
-----Original Message-----
From: Andreas Noever [mailto:[email protected]]
Sent: Wednesday, November 12, 2014 22:19
To: Andy Shevchenko
Cc: Bjorn Helgaas; Jamet, Michael; [email protected]; linux- [email protected]; Levy, Amir (Jer); Alloun, Dan; Rafael Wysocki
Subject: Re: [PATCH] pci: support Thunderbolt requirements for I/O resources.Quoted 1 line · Andy Shevchenko
On Wed, Nov 12, 2014 at 7:29 PM, Bjorn Helgaas <[email protected]>
Quoted 6 lines · wrote:
[]
Quoted 3 lines
Quoted 2 lines
To prevent this, we detect a chain contains a Thunderbolt device by checking the Thunderbolt PCI device id.
Quoted 7 lines
Quoted 3 lines
I'm really not happy about checking a list of device IDs to identify Thunderbolt devices. Surely there's a better way, because a list like this has to be updated regularly.
I recently proposed internally to use quirks (
pci_fixup_early) for that, but apparently Michael didn't have time to answer. It might be he can just comment here since the patch already public.In any case: this will interfere with thunderbolt hotplug on Apple systems, where we do not have BIOS support and have to handle hotplug events and assign resources ourselves. So please add a DMI check for Apple (the reverse of what we do in
http://lxr.free-
electrons.com/source/drivers/thunderbolt/nhi.c?v=3.17#L664
).
Quoted 7 lines
Quoted 2 lines
Thanks,
AndreasThis is correct that the hotplug handling mechanism and interaction with BIOS is different. However, this patch also applies for any case, since the I/O space is limited and need to be preserved, so we must prevent allocation of I/O resources from the devices and avoiding exhaustion while chaining them.
Now I am slightly confused. Does the BIOS (on non Apple hardware) leave I/O resources always unassigned? Your first post seemed to imply that it does assign some and that we should not interfere. In that case we would have to assign them on Apple systems ourselves. On the other hand if no TB device uses I/O resources and the BIOS never assigns them, then why do devices fail if we exhaust them?
Andreas
Quoted 10 lines
Michael
---------------------------------------------------------------------
Intel Israel (74) LimitedThis e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBBbmRyZWFzIE5vZXZlciBbbWFp bHRvOmFuZHJlYXMubm9ldmVyQGdtYWlsLmNvbV0NCj4gU2VudDogVHVlc2RheSwgTm92ZW1iZXIg MTgsIDIwMTQgMTc6NDgNCj4gVG86IEphbWV0LCBNaWNoYWVsDQo+IENjOiBBbmR5IFNoZXZjaGVu a287IEJqb3JuIEhlbGdhYXM7IGxpbnV4LXBjaUB2Z2VyLmtlcm5lbC5vcmc7IGxpbnV4LQ0KPiBr ZXJuZWxAdmdlci5rZXJuZWwub3JnOyBMZXZ5LCBBbWlyIChKZXIpOyBBbGxvdW4sIERhbjsgUmFm YWVsIFd5c29ja2kNCj4gU3ViamVjdDogUmU6IFtQQVRDSF0gcGNpOiBzdXBwb3J0IFRodW5kZXJi b2x0IHJlcXVpcmVtZW50cyBmb3IgSS9PIHJlc291cmNlcy4NCj4gDQo+IE9uIFR1ZSwgTm92IDE4 LCAyMDE0IGF0IDk6MjAgQU0sIEphbWV0LCBNaWNoYWVsIDxtaWNoYWVsLmphbWV0QGludGVsLmNv bT4NCj4gd3JvdGU6DQo+ID4+IC0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+ID4+IEZyb206 IEFuZHJlYXMgTm9ldmVyIFttYWlsdG86YW5kcmVhcy5ub2V2ZXJAZ21haWwuY29tXQ0KPiA+PiBT ZW50OiBXZWRuZXNkYXksIE5vdmVtYmVyIDEyLCAyMDE0IDIyOjE5DQo+ID4+IFRvOiBBbmR5IFNo ZXZjaGVua28NCj4gPj4gQ2M6IEJqb3JuIEhlbGdhYXM7IEphbWV0LCBNaWNoYWVsOyBsaW51eC1w Y2lAdmdlci5rZXJuZWwub3JnOyBsaW51eC0NCj4gPj4ga2VybmVsQHZnZXIua2VybmVsLm9yZzsg TGV2eSwgQW1pciAoSmVyKTsgQWxsb3VuLCBEYW47IFJhZmFlbCBXeXNvY2tpDQo+ID4+IFN1Ympl Y3Q6IFJlOiBbUEFUQ0hdIHBjaTogc3VwcG9ydCBUaHVuZGVyYm9sdCByZXF1aXJlbWVudHMgZm9y IEkvTw0KPiA+PiByZXNvdXJjZXMuDQo+ID4+DQo+ID4+IE9uIFdlZCwgTm92IDEyLCAyMDE0IGF0 IDc6MzAgUE0sIEFuZHkgU2hldmNoZW5rbw0KPiA+PiA8YW5keS5zaGV2Y2hlbmtvQGdtYWlsLmNv bT4gd3JvdGU6DQo+ID4+ID4gT24gV2VkLCBOb3YgMTIsIDIwMTQgYXQgNzoyOSBQTSwgQmpvcm4g SGVsZ2Fhcw0KPiA+PiA+IDxiaGVsZ2Fhc0Bnb29nbGUuY29tPg0KPiA+PiB3cm90ZToNCj4gPj4g Pg0KPiA+PiA+IFtdDQo+ID4+ID4NCj4gPj4gPj4+IFRvIHByZXZlbnQgdGhpcywgd2UgZGV0ZWN0 IGEgY2hhaW4gY29udGFpbnMgYSBUaHVuZGVyYm9sdCBkZXZpY2UNCj4gPj4gPj4+IGJ5IGNoZWNr aW5nIHRoZSBUaHVuZGVyYm9sdCBQQ0kgZGV2aWNlIGlkLg0KPiA+PiA+Pg0KPiA+PiA+PiBJJ20g cmVhbGx5IG5vdCBoYXBweSBhYm91dCBjaGVja2luZyBhIGxpc3Qgb2YgZGV2aWNlIElEcyB0bw0K PiA+PiA+PiBpZGVudGlmeSBUaHVuZGVyYm9sdCBkZXZpY2VzLiAgU3VyZWx5IHRoZXJlJ3MgYSBi ZXR0ZXIgd2F5LA0KPiA+PiA+PiBiZWNhdXNlIGEgbGlzdCBsaWtlIHRoaXMgaGFzIHRvIGJlIHVw ZGF0ZWQgcmVndWxhcmx5Lg0KPiA+PiA+DQo+ID4+ID4gSSByZWNlbnRseSBwcm9wb3NlZCBpbnRl cm5hbGx5IHRvIHVzZSBxdWlya3MgKHBjaV9maXh1cF9lYXJseSkgZm9yDQo+ID4+ID4gdGhhdCwg YnV0IGFwcGFyZW50bHkgTWljaGFlbCBkaWRuJ3QgaGF2ZSB0aW1lIHRvIGFuc3dlci4gSXQgbWln aHQNCj4gPj4gPiBiZSBoZSBjYW4ganVzdCBjb21tZW50IGhlcmUgc2luY2UgdGhlIHBhdGNoIGFs cmVhZHkgcHVibGljLg0KPiA+Pg0KPiA+PiBJbiBhbnkgY2FzZTogdGhpcyB3aWxsIGludGVyZmVy ZSB3aXRoIHRodW5kZXJib2x0IGhvdHBsdWcgb24gQXBwbGUNCj4gPj4gc3lzdGVtcywgd2hlcmUg d2UgZG8gbm90IGhhdmUgQklPUyBzdXBwb3J0IGFuZCBoYXZlIHRvIGhhbmRsZSBob3RwbHVnDQo+ ID4+IGV2ZW50cyBhbmQgYXNzaWduIHJlc291cmNlcyBvdXJzZWx2ZXMuIFNvIHBsZWFzZSBhZGQg YSBETUkgY2hlY2sgZm9yDQo+ID4+IEFwcGxlICh0aGUgcmV2ZXJzZSBvZiB3aGF0IHdlIGRvIGlu DQo+ID4+IGh0dHA6Ly9seHIuZnJlZS0NCj4gPj4gZWxlY3Ryb25zLmNvbS9zb3VyY2UvZHJpdmVy cy90aHVuZGVyYm9sdC9uaGkuYz92PTMuMTcjTDY2NA0KPiA+PiApLg0KPiA+Pg0KPiA+PiBUaGFu a3MsDQo+ID4+IEFuZHJlYXMNCj4gPg0KPiA+IFRoaXMgaXMgY29ycmVjdCB0aGF0IHRoZSBob3Rw bHVnIGhhbmRsaW5nIG1lY2hhbmlzbSBhbmQgaW50ZXJhY3Rpb24gd2l0aA0KPiBCSU9TIGlzIGRp ZmZlcmVudC4NCj4gPiBIb3dldmVyLCB0aGlzIHBhdGNoIGFsc28gYXBwbGllcyBmb3IgYW55IGNh c2UsIHNpbmNlIHRoZSBJL08gc3BhY2UgaXMNCj4gPiBsaW1pdGVkIGFuZCBuZWVkIHRvIGJlIHBy ZXNlcnZlZCwgc28gd2UgbXVzdCBwcmV2ZW50IGFsbG9jYXRpb24gb2YgSS9PDQo+ID4gcmVzb3Vy Y2VzIGZyb20gdGhlIGRldmljZXMgYW5kIGF2b2lkaW5nIGV4aGF1c3Rpb24gd2hpbGUgY2hhaW5p bmcgdGhlbS4NCj4gDQo+IE5vdyBJIGFtIHNsaWdodGx5IGNvbmZ1c2VkLiBEb2VzIHRoZSBCSU9T IChvbiBub24gQXBwbGUgaGFyZHdhcmUpIGxlYXZlIEkvTw0KPiByZXNvdXJjZXMgYWx3YXlzIHVu YXNzaWduZWQ/IFlvdXIgZmlyc3QgcG9zdCBzZWVtZWQgdG8gaW1wbHkgdGhhdCBpdCBkb2VzDQo+ IGFzc2lnbiBzb21lIGFuZCB0aGF0IHdlIHNob3VsZCBub3QgaW50ZXJmZXJlLiBJbiB0aGF0IGNh c2Ugd2Ugd291bGQgaGF2ZSB0bw0KPiBhc3NpZ24gdGhlbSBvbiBBcHBsZSBzeXN0ZW1zIG91cnNl bHZlcy4gT24gdGhlIG90aGVyIGhhbmQgaWYgbm8gVEIgZGV2aWNlIHVzZXMNCj4gSS9PIHJlc291 cmNlcyBhbmQgdGhlIEJJT1MgbmV2ZXIgYXNzaWducyB0aGVtLCB0aGVuIHdoeSBkbyBkZXZpY2Vz IGZhaWwgaWYgd2UNCj4gZXhoYXVzdCB0aGVtPw0KPiANCj4gQW5kcmVhcw0KDQpDb3JyZWN0LiBU aGUgQklPUyBtYXkgcGxheSBhIHJvbGUgaW4gYWxsb2NhdGlvbiBvZiBtZW1vcnkgYW5kIEkvTyAN CnJlc291cmNlcyBidXQgbW9zdCBvZiB0aGUgY2FzZSB3aWxsIGxlYXZlIHRoZSBJL08gIHJlc291 cmNlcyB1bmFzc2lnbmVkLg0KU29tZSBsZWdhY3kgVGh1bmRlcmJvbHQgZGV2aWNlcyBhcmUgZGVz aWduZWQgd2l0aCBJL08gQkFScywgc28gdGhleSANCm5lZWQgdG8gYmUgaGFuZGxlZCB3aXRoIGNh cmUgYXMgd3JpdHRlbiBpbiB0aGUgb3RoZXIgZW1haWwgdGhyZWFkIHRvIEJqb3JuLg0KDQovTWlj aGFlbA0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCkludGVsIElzcmFlbCAoNzQpIExpbWl0ZWQKClRoaXMgZS1tYWls IGFuZCBhbnkgYXR0YWNobWVudHMgbWF5IGNvbnRhaW4gY29uZmlkZW50aWFsIG1hdGVyaWFsIGZv cgp0aGUgc29sZSB1c2Ugb2YgdGhlIGludGVuZGVkIHJlY2lwaWVudChzKS4gQW55IHJldmlldyBv ciBkaXN0cmlidXRpb24KYnkgb3RoZXJzIGlzIHN0cmljdGx5IHByb2hpYml0ZWQuIElmIHlvdSBh cmUgbm90IHRoZSBpbnRlbmRlZApyZWNpcGllbnQsIHBsZWFzZSBjb250YWN0IHRoZSBzZW5kZXIg YW5kIGRlbGV0ZSBhbGwgY29waWVzLgo=
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBBbmR5IFNoZXZjaGVua28gW21h aWx0bzphbmR5LnNoZXZjaGVua29AZ21haWwuY29tXQ0KPiBTZW50OiBXZWRuZXNkYXksIE5vdmVt YmVyIDEyLCAyMDE0IDIwOjMxDQo+IFRvOiBCam9ybiBIZWxnYWFzDQo+IENjOiBKYW1ldCwgTWlj aGFlbDsgbGludXgtcGNpQHZnZXIua2VybmVsLm9yZzsgbGludXgta2VybmVsQHZnZXIua2VybmVs Lm9yZzsNCj4gTGV2eSwgQW1pciAoSmVyKTsgQWxsb3VuLCBEYW47IFJhZmFlbCBXeXNvY2tpOyBB bmRyZWFzIE5vZXZlcg0KPiBTdWJqZWN0OiBSZTogW1BBVENIXSBwY2k6IHN1cHBvcnQgVGh1bmRl cmJvbHQgcmVxdWlyZW1lbnRzIGZvciBJL08NCj4gcmVzb3VyY2VzLg0KPiANCj4gT24gV2VkLCBO b3YgMTIsIDIwMTQgYXQgNzoyOSBQTSwgQmpvcm4gSGVsZ2FhcyA8YmhlbGdhYXNAZ29vZ2xlLmNv bT4NCj4gd3JvdGU6DQo+IA0KPiBbXQ0KPiANCj4gPj4gVG8gcHJldmVudCB0aGlzLCB3ZSBkZXRl Y3QgYSBjaGFpbiBjb250YWlucyBhIFRodW5kZXJib2x0IGRldmljZSBieQ0KPiA+PiBjaGVja2lu ZyB0aGUgVGh1bmRlcmJvbHQgUENJIGRldmljZSBpZC4NCj4gPg0KPiA+IEknbSByZWFsbHkgbm90 IGhhcHB5IGFib3V0IGNoZWNraW5nIGEgbGlzdCBvZiBkZXZpY2UgSURzIHRvIGlkZW50aWZ5DQo+ ID4gVGh1bmRlcmJvbHQgZGV2aWNlcy4gIFN1cmVseSB0aGVyZSdzIGEgYmV0dGVyIHdheSwgYmVj YXVzZSBhIGxpc3QgbGlrZQ0KPiA+IHRoaXMgaGFzIHRvIGJlIHVwZGF0ZWQgcmVndWxhcmx5Lg0K PiANCj4gSSByZWNlbnRseSBwcm9wb3NlZCBpbnRlcm5hbGx5IHRvIHVzZSBxdWlya3MgKHBjaV9m aXh1cF9lYXJseSkgZm9yIHRoYXQsIGJ1dA0KPiBhcHBhcmVudGx5IE1pY2hhZWwgZGlkbid0IGhh dmUgdGltZSB0byBhbnN3ZXIuIEl0IG1pZ2h0IGJlIGhlIGNhbiBqdXN0DQo+IGNvbW1lbnQgaGVy ZSBzaW5jZSB0aGUgcGF0Y2ggYWxyZWFkeSBwdWJsaWMuDQo+IA0KPiAtLQ0KPiBXaXRoIEJlc3Qg UmVnYXJkcywNCj4gQW5keSBTaGV2Y2hlbmtvDQoNCkluZGVlZCwgSSd2ZSBleHBsb3JlZCB0aGUg cXVpcmtzIG9wdGlvbi4NClVuZm9ydHVuYXRlbHkgdGhlIGZpeHVwIGhvb2sgc2VlbXMgdG8gYmUg Y2FsbGVkIHRvbyBsYXRlIGluIHRoZSBjb2RlIA0Kc2luY2UgcGNpX2VuYWJsZV9kZXZpY2UoKWNh bGxzIHBjaWJpb3NfZW5hYmxlX2RldmljZSgpIHdoaWNoIGFjdHVhbGx5IA0Kc2VuZCBhIFBDSSBj b21tYW5kIHdpdGggIENNRCB8PVBDSV9DT01NQU5EX0lPIGFuZCBjb25maWd1cmUgdGhlIFBDSSBI Vy4gDQpUaGUgSU9SRVNPVVJDRV9NRU0gYW5kIElPUkVTT1VSQ0VfSU8gZmxhZ3MgYXJlIHNldCBh dCB0aGUgdGltZSB0aGUNCnBjaV9lbmFibGVfZGV2aWNlKCksIHBjaV9lbmFibGVfZGV2aWNlX21l bSgpIG9yIHBjaV9lbmFibGVfZGV2aWNlX2lvKCkgDQppcyBjYWxsZWQgZHVyaW5nIGRldmljZSBp bml0aWFsaXphdGlvbnMsIHNvIGFuIGVhcmx5IGZpeHVwIGNhbGwgd29uJ3QgaGVscCBlaXRoZXIu DQpBdCB0aGlzIHN0YWdlLCB0aGUgUENJIEhXIGlzIGNvbmZpZ3VyZWQgYW5kIGEgZml4dXAgY2Fs bCB3b24ndCAgcmVzb2x2ZSB0aGUgaXNzdWUNCnVubGVzcyBhbm90aGVyIFBDSSBjb21tYW5kIGlz IHNlbnQgdG8gcmV2ZXJ0IGl0IA0KKGdlbmVyYWxseSBub3QgYWR2aXNlZCB0byBleGVjdXRlIGFn YWluIG9uIGhhcmR3YXJlKS4NCg0KTWljaGFlbCANCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpJbnRlbCBJc3JhZWwg KDc0KSBMaW1pdGVkCgpUaGlzIGUtbWFpbCBhbmQgYW55IGF0dGFjaG1lbnRzIG1heSBjb250YWlu IGNvbmZpZGVudGlhbCBtYXRlcmlhbCBmb3IKdGhlIHNvbGUgdXNlIG9mIHRoZSBpbnRlbmRlZCBy ZWNpcGllbnQocykuIEFueSByZXZpZXcgb3IgZGlzdHJpYnV0aW9uCmJ5IG90aGVycyBpcyBzdHJp Y3RseSBwcm9oaWJpdGVkLiBJZiB5b3UgYXJlIG5vdCB0aGUgaW50ZW5kZWQKcmVjaXBpZW50LCBw bGVhc2UgY29udGFjdCB0aGUgc2VuZGVyIGFuZCBkZWxldGUgYWxsIGNvcGllcy4K
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBCam9ybiBIZWxnYWFzIFttYWls dG86YmhlbGdhYXNAZ29vZ2xlLmNvbV0NCj4gU2VudDogV2VkbmVzZGF5LCBOb3ZlbWJlciAxMiwg MjAxNCAxOToyOQ0KPiBUbzogSmFtZXQsIE1pY2hhZWwNCj4gQ2M6IGxpbnV4LXBjaUB2Z2VyLmtl cm5lbC5vcmc7IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmc7IExldnksIEFtaXINCj4gKEpl cik7IEFsbG91biwgRGFuOyBSYWZhZWwgV3lzb2NraTsgQW5kcmVhcyBOb2V2ZXINCj4gU3ViamVj dDogUmU6IFtQQVRDSF0gcGNpOiBzdXBwb3J0IFRodW5kZXJib2x0IHJlcXVpcmVtZW50cyBmb3Ig SS9PDQo+IHJlc291cmNlcy4NCj4gDQo+IFsrY2MgUmFmYWVsLCBBbmRyZWFzXQ0KPiANCj4gT24g V2VkLCBOb3YgMTIsIDIwMTQgYXQgNzo1MiBQTSwgTWljaGFlbCBKYW1ldA0KPiA8bWljaGFlbC5q YW1ldEBpbnRlbC5jb20+IHdyb3RlOg0KPiA+IEV2ZXJ5IFRodW5kZXJib2x0LWJhc2VkIGRldmlj ZXMgb3IgVGh1bmRlcmJvbHQtY29ubmVjdGVkIGRldmljZXMNCj4gPiBzaG91bGQgbm90IGFsbG9j YXRlIFBDSSBJL08gcmVzb3VyY2VzIHBlciBUaHVuZGVyYm9sdCBzcGVjcy4NCj4gDQo+IFBsZWFz ZSBpbmNsdWRlIGEgcG9pbnRlciB0byB0aG9zZSBzcGVjcyBpbiB0aGUgY2hhbmdlbG9nLg0KPiAN Cg0KVW5mb3J0dW5hdGVseSB0aGVzZSBzcGVjcyBhcmUgbm90IHB1YmxpY2FsbHkgYXZhaWxhYmxl Lg0KDQo+ID4gT24gYSBUaHVuZGVyYm9sdCBQQywgQklPUyBpcyByZXNwb25zaWJsZSB0byBhbGxv Y2F0ZSBJTyByZXNvdXJjZXMuDQo+ID4gS2VybmVsIHNob3VsZG4ndCBhbGxvY2F0ZSB0aGUgUENJ IEkvTyByZXNvdXJjZXMgYXMgaXQgaW50ZXJmZXJlcyB3aXRoDQo+ID4gQklPUyBvcGVyYXRpb24u DQo+ID4gRG9pbmcgdGhpcyBtYXkgY2F1c2UgdGhlIGRldmljZXMgaW4gdGhlIFRodW5kZXJib2x0 IGNoYWluIG5vdCBiZWluZw0KPiA+IGRldGVjdGVkIG9yIGFkZGVkLCBvciB3b3JzZSB0byBzdHVj ayB0aGUgVGh1bmRlcmJvbHQgSG9zdCBjb250cm9sbGVyLg0KPiANCj4gVGhlc2UgbmV3IGtlcm5l bC9maXJtd2FyZSBjb29yZGluYXRpb24gcmVxdWlyZW1lbnRzIG5lZWQgdG8gYmUNCj4gZG9jdW1l bnRlZC4gIElmIHRoZXkncmUgYWxyZWFkeSBwYXJ0IG9mIGEgUENJZSBFQ04gb3IgUENJIGZpcm13 YXJlIHNwZWMsIGp1c3QNCj4gcHJvdmlkZSBhIHBvaW50ZXIuDQo+IA0KDQpTYW1lLCB0aGlzIHJl ZmVycyB0byBzYW1lIHNwZWNzLg0KDQo+ID4gVG8gcHJldmVudCB0aGlzLCB3ZSBkZXRlY3QgYSBj aGFpbiBjb250YWlucyBhIFRodW5kZXJib2x0IGRldmljZSBieQ0KPiA+IGNoZWNraW5nIHRoZSBU aHVuZGVyYm9sdCBQQ0kgZGV2aWNlIGlkLg0KPiANCj4gSSdtIHJlYWxseSBub3QgaGFwcHkgYWJv dXQgY2hlY2tpbmcgYSBsaXN0IG9mIGRldmljZSBJRHMgdG8gaWRlbnRpZnkNCj4gVGh1bmRlcmJv bHQgZGV2aWNlcy4gIFN1cmVseSB0aGVyZSdzIGEgYmV0dGVyIHdheSwgYmVjYXVzZSBhIGxpc3Qg bGlrZSB0aGlzIGhhcw0KPiB0byBiZSB1cGRhdGVkIHJlZ3VsYXJseS4NCj4gDQo+IEJqb3JuDQo+ IA0KDQpUaGlzIHdhcyBhbHNvIGRpc2N1c3NlZCBpbnRlcm5hbGx5IGFuZCB0aGUgb25seSB3YXkg dG8gaWRlbnRpZnkgVGh1bmRlcmJvbHQgZGV2aWNlcyBpcyB0byBjaGVjayB0aGUgZGV2aWNlIElE cy4NCkFzIHlvdSBzYWlkLCB0aGlzIHdpbGwgcmVxdWlyZSB1cyB0byBtYWludGFpbiBhbmQga2Vl cCB0aGUgbGlzdCB1cC10by1kYXRlIGFzIHdlIGRlbGl2ZXIgbmV3IGRldmljZXMuDQoNCk1pY2hh ZWwNCg0KPiA+IFRoZSB2YWxpZGF0aW9uIGlzIGNhcnJpZWQgb3V0IGF0IHRoZSBwY2lfZW5hYmxl X2RldmljZV9mbGFncygpDQo+ID4gZnVuY3Rpb24gdGhhdCBjaGVja3MgdGhlIFBDSSBkZXZpY2Ug b3IgYnJpZGdlIGlzIFRodW5kZXJib2x0IGNoYWluZWQNCj4gPiBhbmQgYXZvaWQgSU8gcmVzb3Vy Y2VzIGFsbG9jYXRpb24uDQo+ID4NCj4gPiBJbiBhZGRpdGlvbiwgZGVjb2RlX2JhcigpIGFuZCBw Y2lfYnJpZGdlX2NoZWNrX3JhbmdlcygpIGZ1bmN0aW9uIGhhcw0KPiA+IGJlZW4gaW50ZXJuYWxs eSBjaGVja2VkIGZvciBUaHVuZGVyYm9sdCBhcyB3ZWxsIHRvIGVuc3VyZSBubyBJTw0KPiA+IHJl c291cmNlcyBhcmUgYWxsb2NhdGVkLg0KPiA+DQo+ID4gU2lnbmVkLW9mZi1ieTogTWljaGFlbCBK YW1ldCA8bWljaGFlbC5qYW1ldEBpbnRlbC5jb20+DQo+ID4gLS0tDQo+ID4gIGRyaXZlcnMvcGNp L3BjaS5jICAgICAgIHwgNjQNCj4gKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKw0KPiA+ICBkcml2ZXJzL3BjaS9wY2kuaCAgICAgICB8ICAyICsrDQo+ID4g IGRyaXZlcnMvcGNpL3Byb2JlLmMgICAgIHwgIDMgKystDQo+ID4gIGRyaXZlcnMvcGNpL3NldHVw LWJ1cy5jIHwgIDQgKystLQ0KPiA+ICBpbmNsdWRlL2xpbnV4L3BjaS5oICAgICB8ICAyICsrDQo+ ID4gIDUgZmlsZXMgY2hhbmdlZCwgNzIgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkNCj4g Pg0KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuYyBiL2RyaXZlcnMvcGNpL3BjaS5j IGluZGV4DQo+ID4gNjI1YTRhYy4uNDFjMjYxOSAxMDA2NDQNCj4gPiAtLS0gYS9kcml2ZXJzL3Bj aS9wY2kuYw0KPiA+ICsrKyBiL2RyaXZlcnMvcGNpL3BjaS5jDQo+ID4gQEAgLTE5OCw2ICsxOTgs NjIgQEAgc3RhdGljIGludCBfX3BjaV9idXNfZmluZF9jYXBfc3RhcnQoc3RydWN0DQo+ID4gcGNp X2J1cyAqYnVzLCAgfQ0KPiA+DQo+ID4gIC8qKg0KPiA+ICsgKiBwY2lfaXNfdGh1bmRlcmJvbHRf ZGV2aWNlIC0gY2hlY2tzIFBDSSBkZXZpY2UgaXMgVGh1bmRlcmJvbHQtYmFzZWQuDQo+ID4gKyAq IFRoZSBvbmx5IGV4aXN0aW5nIHdheSBpcyB0byBjaGVjayB0aGUgZGV2aWNlIGlkIGlzIGFsbG9j YXRlZCB0bw0KPiBUaHVuZGVyYm9sdC4NCj4gPiArICogQGRldjogdGhlIFBDSSBkZXZpY2Ugc3Ry dWN0dXJlIHRvIGNoZWNrIGFnYWluc3QNCj4gPiArICoNCj4gPiArICogUmV0dXJucyB0cnVlIGlm IHRoZSBQQ0kgZGV2aWNlIGlzIG9mIHRoZSBUaHVuZGVyYm9sdCB0eXBlLg0KPiA+ICsgKi8NCj4g PiArYm9vbCBwY2lfaXNfdGh1bmRlcmJvbHRfZGV2aWNlKHN0cnVjdCBwY2lfZGV2ICpkZXYpIHsN Cj4gPiArICAgICAgIGlmICgoZGV2LT52ZW5kb3IgPT0gUENJX1ZFTkRPUl9JRF9JTlRFTCkgJiYN Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAoKGRldi0+ZGV2aWNlID09IDB4Y2FjYSkNCj4g PiArICAgICAgICAgICAgICAgICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTEzKQ0KPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgIHx8IChkZXYtPmRldmljZSA9PSAweGNiY2EpDQo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgfHwgKGRldi0+ZGV2aWNlID09IDB4MTUxQSkNCj4gPiAr ICAgICAgICAgICAgICAgICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTFCKQ0KPiA+ICsg ICAgICAgICAgICAgICAgICAgICAgIHx8IChkZXYtPmRldmljZSA9PSAweDE1NDkpDQo+ID4gKyAg ICAgICAgICAgICAgICAgICAgICAgfHwgKGRldi0+ZGV2aWNlID09IDB4MTU0NykNCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTQ4KQ0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgIHx8IChkZXYtPmRldmljZSA9PSAweDE1NjYpDQo+ID4gKyAgICAg ICAgICAgICAgICAgICAgICAgfHwgKGRldi0+ZGV2aWNlID09IDB4MTU2NykNCj4gPiArICAgICAg ICAgICAgICAgICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTY5KQ0KPiA+ICsgICAgICAg ICAgICAgICAgICAgICAgIHx8IChkZXYtPmRldmljZSA9PSAweDE1NjgpDQo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgfHwgKGRldi0+ZGV2aWNlID09IDB4MTU2QSkNCj4gPiArICAgICAgICAg ICAgICAgICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTZCKQ0KPiA+ICsgICAgICAgICAg ICAgICAgICAgICAgIHx8IChkZXYtPmRldmljZSA9PSAweDE1NkMpDQo+ID4gKyAgICAgICAgICAg ICAgICAgICAgICAgfHwgKGRldi0+ZGV2aWNlID09IDB4MTU2RCkNCj4gPiArICAgICAgICAgICAg ICAgICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTc5KQ0KPiA+ICsgICAgICAgICAgICAg ICAgICAgICAgIHx8IChkZXYtPmRldmljZSA9PSAweDE1N0EpDQo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgfHwgKGRldi0+ZGV2aWNlID09IDB4MTU3RCkNCj4gPiArICAgICAgICAgICAgICAg ICAgICAgICB8fCAoZGV2LT5kZXZpY2UgPT0gMHgxNTdFKSkpDQo+ID4gKyAgICAgICAgICAgICAg IHJldHVybiB0cnVlOw0KPiA+ICsNCj4gPiArICAgICAgIHJldHVybiBmYWxzZTsNCj4gPiArfQ0K PiA+ICtFWFBPUlRfU1lNQk9MKHBjaV9pc190aHVuZGVyYm9sdF9kZXZpY2UpOw0KPiA+ICsNCj4g PiArLyoqDQo+ID4gKyAqIHBjaV9pc19jb25uZWN0ZWRfdG9fdGh1bmRlcmJvbHQgLSBjaGVjayBp ZiBjb25uZWN0ZWQgdG8gYQ0KPiBUaHVuZGVyYm9sdCBjaGFpbi4NCj4gPiArICogQGRldjogdGhl IFBDSSBkZXZpY2Ugc3RydWN0dXJlIHRvIGNoZWNrIGFnYWluc3QNCj4gPiArICoNCj4gPiArICog UmV0dXJucyB0cnVlIGlmIHRoZSBQQ0kgZGV2aWNlIHMgY29ubmVjdGVkIGlzIGNvbm5lY3RlZCB0 byBhDQo+ID4gKyAqIFRodW5kZXJib2x0LWJhc2VkIGluIHRoZSBjaGFpbi4NCj4gPiArICovDQo+ ID4gK2Jvb2wgcGNpX2lzX2Nvbm5lY3RlZF90b190aHVuZGVyYm9sdChzdHJ1Y3QgcGNpX2RldiAq ZGV2KSB7DQo+ID4gKyAgICAgICBzdHJ1Y3QgcGNpX2RldiAqYnJpZGdlOw0KPiA+ICsNCj4gPiAr ICAgICAgIGlmIChwY2lfaXNfdGh1bmRlcmJvbHRfZGV2aWNlKGRldikpDQo+ID4gKyAgICAgICAg ICAgICAgIHJldHVybiB0cnVlOw0KPiA+ICsgICAgICAgYnJpZGdlID0gIHBjaV91cHN0cmVhbV9i cmlkZ2UoZGV2KTsNCj4gPiArICAgICAgIGlmIChicmlkZ2UpDQo+ID4gKyAgICAgICAgICAgICAg IHJldHVybiBwY2lfaXNfY29ubmVjdGVkX3RvX3RodW5kZXJib2x0KGJyaWRnZSk7DQo+ID4gKyAg ICAgICByZXR1cm4gZmFsc2U7DQo+ID4gK30NCj4gPiArRVhQT1JUX1NZTUJPTChwY2lfaXNfY29u bmVjdGVkX3RvX3RodW5kZXJib2x0KTsNCj4gPiArDQo+ID4gKy8qKg0KPiA+ICAgKiBwY2lfZmlu ZF9jYXBhYmlsaXR5IC0gcXVlcnkgZm9yIGRldmljZXMnIGNhcGFiaWxpdGllcw0KPiA+ICAgKiBA ZGV2OiBQQ0kgZGV2aWNlIHRvIHF1ZXJ5DQo+ID4gICAqIEBjYXA6IGNhcGFiaWxpdHkgY29kZQ0K PiA+IEBAIC0xMjg1LDYgKzEzNDEsMTQgQEAgc3RhdGljIGludCBwY2lfZW5hYmxlX2RldmljZV9m bGFncyhzdHJ1Y3QgcGNpX2Rldg0KPiAqZGV2LCB1bnNpZ25lZCBsb25nIGZsYWdzKQ0KPiA+ICAg ICAgICAgaWYgKGF0b21pY19pbmNfcmV0dXJuKCZkZXYtPmVuYWJsZV9jbnQpID4gMSkNCj4gPiAg ICAgICAgICAgICAgICAgcmV0dXJuIDA7ICAgICAgICAgICAgICAgLyogYWxyZWFkeSBlbmFibGVk ICovDQo+ID4NCj4gPiArICAgICAgIC8qDQo+ID4gKyAgICAgICAgKiBpZiBJTyByZXNvdXJjZSBo YXZlIGJlZW4gcmVxdWVzdGVkLCBidXQgdGhlIGRldmljZSBpcyBjb25uZWN0ZWQNCj4gPiArICAg ICAgICAqIHRvIFRodW5kZXJib2x0IGNoYWluLCBkb24ndCBhbGxvY2F0ZSBJTyByZXNvdXJjZQ0K PiA+ICsgICAgICAgICovDQo+ID4gKyAgICAgICBpZiAoKGZsYWdzICYgSU9SRVNPVVJDRV9JTykN Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAmJiBwY2lfaXNfY29ubmVjdGVkX3RvX3RodW5k ZXJib2x0KGRldikpDQo+ID4gKyAgICAgICAgICAgICAgIGZsYWdzICY9IH5JT1JFU09VUkNFX0lP Ow0KPiA+ICsNCj4gPiAgICAgICAgIGJyaWRnZSA9IHBjaV91cHN0cmVhbV9icmlkZ2UoZGV2KTsN Cj4gPiAgICAgICAgIGlmIChicmlkZ2UpDQo+ID4gICAgICAgICAgICAgICAgIHBjaV9lbmFibGVf YnJpZGdlKGJyaWRnZSk7IGRpZmYgLS1naXQNCj4gPiBhL2RyaXZlcnMvcGNpL3BjaS5oIGIvZHJp dmVycy9wY2kvcGNpLmggaW5kZXggMDYwMTg5MC4uZmI5YTNiMSAxMDA2NDQNCj4gPiAtLS0gYS9k cml2ZXJzL3BjaS9wY2kuaA0KPiA+ICsrKyBiL2RyaXZlcnMvcGNpL3BjaS5oDQo+ID4gQEAgLTQs NiArNCw4IEBADQo+ID4gICNkZWZpbmUgUENJX0NGR19TUEFDRV9TSVpFICAgICAyNTYNCj4gPiAg I2RlZmluZSBQQ0lfQ0ZHX1NQQUNFX0VYUF9TSVpFIDQwOTYNCj4gPg0KPiA+ICtib29sIHBjaV9p c190aHVuZGVyYm9sdF9kZXZpY2Uoc3RydWN0IHBjaV9kZXYgKmRldik7DQo+ID4gKw0KPiA+ICBl eHRlcm4gY29uc3QgdW5zaWduZWQgY2hhciBwY2llX2xpbmtfc3BlZWRbXTsNCj4gPg0KPiA+ICAv KiBGdW5jdGlvbnMgaW50ZXJuYWwgdG8gdGhlIFBDSSBjb3JlIGNvZGUgKi8gZGlmZiAtLWdpdA0K PiA+IGEvZHJpdmVycy9wY2kvcHJvYmUuYyBiL2RyaXZlcnMvcGNpL3Byb2JlLmMgaW5kZXggNWVk OTkzMC4uZDgxNzFhZg0KPiA+IDEwMDY0NA0KPiA+IC0tLSBhL2RyaXZlcnMvcGNpL3Byb2JlLmMN Cj4gPiArKysgYi9kcml2ZXJzL3BjaS9wcm9iZS5jDQo+ID4gQEAgLTEzMSw3ICsxMzEsOCBAQCBz dGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgZGVjb2RlX2JhcihzdHJ1Y3QNCj4gPiBwY2lfZGV2 ICpkZXYsIHUzMiBiYXIpDQo+ID4NCj4gPiAgICAgICAgIGlmICgoYmFyICYgUENJX0JBU0VfQURE UkVTU19TUEFDRSkgPT0NCj4gUENJX0JBU0VfQUREUkVTU19TUEFDRV9JTykgew0KPiA+ICAgICAg ICAgICAgICAgICBmbGFncyA9IGJhciAmIH5QQ0lfQkFTRV9BRERSRVNTX0lPX01BU0s7DQo+ID4g LSAgICAgICAgICAgICAgIGZsYWdzIHw9IElPUkVTT1VSQ0VfSU87DQo+ID4gKyAgICAgICAgICAg ICAgIGlmICghcGNpX2lzX2Nvbm5lY3RlZF90b190aHVuZGVyYm9sdChkZXYpKQ0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgIGZsYWdzIHw9IElPUkVTT1VSQ0VfSU87DQo+ID4gICAgICAgICAg ICAgICAgIHJldHVybiBmbGFnczsNCj4gPiAgICAgICAgIH0NCj4gPg0KPiA+IGRpZmYgLS1naXQg YS9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYyBiL2RyaXZlcnMvcGNpL3NldHVwLWJ1cy5jIGluZGV4 DQo+ID4gMDQ4MjIzNS4uNzlhYzM4ZiAxMDA2NDQNCj4gPiAtLS0gYS9kcml2ZXJzL3BjaS9zZXR1 cC1idXMuYw0KPiA+ICsrKyBiL2RyaXZlcnMvcGNpL3NldHVwLWJ1cy5jDQo+ID4gQEAgLTY2Mywx MiArNjYzLDEyIEBAIHN0YXRpYyB2b2lkIHBjaV9icmlkZ2VfY2hlY2tfcmFuZ2VzKHN0cnVjdA0K PiBwY2lfYnVzICpidXMpDQo+ID4gICAgICAgICBiX3Jlc1sxXS5mbGFncyB8PSBJT1JFU09VUkNF X01FTTsNCj4gPg0KPiA+ICAgICAgICAgcGNpX3JlYWRfY29uZmlnX3dvcmQoYnJpZGdlLCBQQ0lf SU9fQkFTRSwgJmlvKTsNCj4gPiAtICAgICAgIGlmICghaW8pIHsNCj4gPiArICAgICAgIGlmICgh aW8gfHwgcGNpX2lzX3RodW5kZXJib2x0X2RldmljZShicmlkZ2UpKSB7DQo+ID4gICAgICAgICAg ICAgICAgIHBjaV93cml0ZV9jb25maWdfd29yZChicmlkZ2UsIFBDSV9JT19CQVNFLCAweGUwZjAp Ow0KPiA+ICAgICAgICAgICAgICAgICBwY2lfcmVhZF9jb25maWdfd29yZChicmlkZ2UsIFBDSV9J T19CQVNFLCAmaW8pOw0KPiA+ICAgICAgICAgICAgICAgICBwY2lfd3JpdGVfY29uZmlnX3dvcmQo YnJpZGdlLCBQQ0lfSU9fQkFTRSwgMHgwKTsNCj4gPiAgICAgICAgIH0NCj4gPiAtICAgICAgIGlm IChpbykNCj4gPiArICAgICAgIGlmIChpbyAmJiAhcGNpX2lzX3RodW5kZXJib2x0X2RldmljZShi cmlkZ2UpKQ0KPiA+ICAgICAgICAgICAgICAgICBiX3Jlc1swXS5mbGFncyB8PSBJT1JFU09VUkNF X0lPOw0KPiA+DQo+ID4gICAgICAgICAvKiAgREVDY2hpcCAyMTA1MCBwYXNzIDIgZXJyYXRhOiB0 aGUgYnJpZGdlIG1heSBtaXNzIGFuDQo+ID4gYWRkcmVzcyBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9wY2kuaCBiL2luY2x1ZGUvbGludXgvcGNpLmggaW5kZXgNCj4gPiAyYThjNDA1Li4wOWRk YzJjIDEwMDY0NA0KPiA+IC0tLSBhL2luY2x1ZGUvbGludXgvcGNpLmgNCj4gPiArKysgYi9pbmNs dWRlL2xpbnV4L3BjaS5oDQo+ID4gQEAgLTkzMSw2ICs5MzEsOCBAQCBpbnQgX19tdXN0X2NoZWNr IHBjaV9lbmFibGVfZGV2aWNlX2lvKHN0cnVjdA0KPiA+IHBjaV9kZXYgKmRldik7ICBpbnQgX19t dXN0X2NoZWNrIHBjaV9lbmFibGVfZGV2aWNlX21lbShzdHJ1Y3QgcGNpX2Rldg0KPiA+ICpkZXYp OyAgaW50IF9fbXVzdF9jaGVjayBwY2lfcmVlbmFibGVfZGV2aWNlKHN0cnVjdCBwY2lfZGV2ICop OyAgaW50DQo+ID4gX19tdXN0X2NoZWNrIHBjaW1fZW5hYmxlX2RldmljZShzdHJ1Y3QgcGNpX2Rl diAqcGRldik7DQo+ID4gKw0KPiA+ICtib29sIHBjaV9pc19jb25uZWN0ZWRfdG9fdGh1bmRlcmJv bHQoc3RydWN0IHBjaV9kZXYgKmRldik7DQo+ID4gIHZvaWQgcGNpbV9waW5fZGV2aWNlKHN0cnVj dCBwY2lfZGV2ICpwZGV2KTsNCj4gPg0KPiA+ICBzdGF0aWMgaW5saW5lIGludCBwY2lfaXNfZW5h YmxlZChzdHJ1Y3QgcGNpX2RldiAqcGRldikNCj4gPiAtLQ0KPiA+IDEuOS4xDQo+ID4NCj4gPiAt LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0NCj4gPiBJbnRlbCBJc3JhZWwgKDc0KSBMaW1pdGVkDQo+ID4NCj4gPiBUaGlz IGUtbWFpbCBhbmQgYW55IGF0dGFjaG1lbnRzIG1heSBjb250YWluIGNvbmZpZGVudGlhbCBtYXRl cmlhbCBmb3INCj4gPiB0aGUgc29sZSB1c2Ugb2YgdGhlIGludGVuZGVkIHJlY2lwaWVudChzKS4g QW55IHJldmlldyBvciBkaXN0cmlidXRpb24NCj4gPiBieSBvdGhlcnMgaXMgc3RyaWN0bHkgcHJv aGliaXRlZC4gSWYgeW91IGFyZSBub3QgdGhlIGludGVuZGVkDQo+ID4gcmVjaXBpZW50LCBwbGVh c2UgY29udGFjdCB0aGUgc2VuZGVyIGFuZCBkZWxldGUgYWxsIGNvcGllcy4NCj4gPg0KLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCkludGVsIElzcmFlbCAoNzQpIExpbWl0ZWQKClRoaXMgZS1tYWlsIGFuZCBhbnkgYXR0 YWNobWVudHMgbWF5IGNvbnRhaW4gY29uZmlkZW50aWFsIG1hdGVyaWFsIGZvcgp0aGUgc29sZSB1 c2Ugb2YgdGhlIGludGVuZGVkIHJlY2lwaWVudChzKS4gQW55IHJldmlldyBvciBkaXN0cmlidXRp b24KYnkgb3RoZXJzIGlzIHN0cmljdGx5IHByb2hpYml0ZWQuIElmIHlvdSBhcmUgbm90IHRoZSBp bnRlbmRlZApyZWNpcGllbnQsIHBsZWFzZSBjb250YWN0IHRoZSBzZW5kZXIgYW5kIGRlbGV0ZSBh bGwgY29waWVzLgo=
Bjorn Helgaas
maintainerQuoted 41 lines · Michael
Quoted 9 lines
-----Original Message-----
From: Bjorn Helgaas [mailto:[email protected]]
Sent: Wednesday, November 12, 2014 19:29
To: Jamet, Michael
Cc: [email protected]; [email protected]; Levy, Amir (Jer); Alloun, Dan; Rafael Wysocki; Andreas Noever
Subject: Re: [PATCH] pci: support Thunderbolt requirements for I/O resources.Quoted 9 lines
[+cc Rafael, Andreas]
Quoted 2 lines · Michael Jamet
Every Thunderbolt-based devices or Thunderbolt-connected devices should not allocate PCI I/O resources per Thunderbolt specs.
Please include a pointer to those specs in the changelog.
Unfortunately these specs are not publically available.
Quoted 10 lines
Quoted 5 lines
On a Thunderbolt PC, BIOS is responsible to allocate IO resources. Kernel shouldn't allocate the PCI I/O resources as it interferes with BIOS operation.
Doing this may cause the devices in the Thunderbolt chain not being detected or added, or worse to stuck the Thunderbolt Host controller.These new kernel/firmware coordination requirements need to be documented. If they're already part of a PCIe ECN or PCI firmware spec, just provide a pointer.
Same, this refers to same specs.
Quoted 7 lines
Quoted 2 lines
To prevent this, we detect a chain contains a Thunderbolt device by checking the Thunderbolt PCI device id.
I'm really not happy about checking a list of device IDs to identify Thunderbolt devices. Surely there's a better way, because a list like this has to be updated regularly.
Quoted 5 lines
Quoted 2 lines
Bjorn
This was also discussed internally and the only way to identify Thunderbolt devices is to check the device IDs. As you said, this will require us to maintain and keep the list up-to-date as we deliver new devices.
I don't really see how this can work. You're asking me to put changes based on a secret spec into generic code that is used on every machine with PCI. I have no way to maintain something like that.
This seems like a major screw up in the design and documentation of Thunderbolt.
Bjorn
Quoted 9 lines
Quoted 2 lines
This was also discussed internally and the only way to identify Thunderbolt devices is to check the device IDs. As you said, this will require us to maintain and keep the list up-to-date as we deliver new devices.
I don't really see how this can work. You're asking me to put changes based on a secret spec into generic code that is used on every machine with PCI. I have no way to maintain something like that.
This seems like a major screw up in the design and documentation of Thunderbolt.
page 10 for one of the brief public notes on the not relying on I/O space.
Bjorn Helgaas
maintainerQuoted 8 lines · One Thousand Gnomes
Quoted 8 lines
Quoted 2 lines
This was also discussed internally and the only way to identify Thunderbolt devices is to check the device IDs. As you said, this will require us to maintain and keep the list up-to-date as we deliver new devices.
I don't really see how this can work. You're asking me to put changes based on a secret spec into generic code that is used on every machine with PCI. I have no way to maintain something like that.
Quoted 6 lines
Quoted 1 line
This seems like a major screw up in the design and documentation of Thunderbolt.
page 10 for one of the brief public notes on the not relying on I/O space.
I agree with that recommendation not to rely on I/O space. It applies equally to *all* PCI devices, not just to Thunderbolt.
Presumably this patch fixes a problem. The changelog says:
Kernel shouldn't allocate the PCI I/O resources as it interferes with BIOS operation.
Doing this may cause the devices in the Thunderbolt chain not being detected or added, or worse to stuck the Thunderbolt Host controller.
The problem of devices not being detected sounds like a general problem (I assume the problem is actually that we do enumerate the device, but we may not be able to assign I/O port space to it, which means we may not be able to operate it). This could happen with any device. If you can come up with a generic way to deal with it, that might work. Note that we do already have pci_enable_device_mem() for drivers that don't need I/O space to operate their device.
If assigning I/O port space to a device can hang the Thunderbolt controller, that sounds like a controller defect, and maybe you could write a quirk to work around it. I'm not opposed to adding device-specific workarounds for things like that. I just have trouble with putting undocumented workarounds in the common path that everybody uses.
Bjorn
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBCam9ybiBIZWxnYWFzIFttYWls dG86YmhlbGdhYXNAZ29vZ2xlLmNvbV0NCj4gU2VudDogV2VkbmVzZGF5LCBEZWNlbWJlciAwMywg MjAxNCAwMjoxOQ0KPiBUbzogT25lIFRob3VzYW5kIEdub21lcw0KPiBDYzogSmFtZXQsIE1pY2hh ZWw7IGxpbnV4LXBjaUB2Z2VyLmtlcm5lbC5vcmc7IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5v cmc7DQo+IExldnksIEFtaXIgKEplcik7IEFsbG91biwgRGFuOyBSYWZhZWwgV3lzb2NraTsgQW5k cmVhcyBOb2V2ZXINCj4gU3ViamVjdDogUmU6IFtQQVRDSF0gcGNpOiBzdXBwb3J0IFRodW5kZXJi b2x0IHJlcXVpcmVtZW50cyBmb3IgSS9PIHJlc291cmNlcy4NCj4gDQo+IE9uIE1vbiwgTm92IDI0 LCAyMDE0IGF0IDI6MTcgQU0sIE9uZSBUaG91c2FuZCBHbm9tZXMNCj4gPGdub21lc0BseG9yZ3Vr LnVrdXUub3JnLnVrPiB3cm90ZToNCj4gPj4gPiBUaGlzIHdhcyBhbHNvIGRpc2N1c3NlZCBpbnRl cm5hbGx5IGFuZCB0aGUgb25seSB3YXkgdG8gaWRlbnRpZnkgVGh1bmRlcmJvbHQNCj4gZGV2aWNl cyBpcyB0byBjaGVjayB0aGUgZGV2aWNlIElEcy4NCj4gPj4gPiBBcyB5b3Ugc2FpZCwgdGhpcyB3 aWxsIHJlcXVpcmUgdXMgdG8gbWFpbnRhaW4gYW5kIGtlZXAgdGhlIGxpc3QgdXAtdG8tZGF0ZSBh cw0KPiB3ZSBkZWxpdmVyIG5ldyBkZXZpY2VzLg0KPiA+Pg0KPiA+PiBJIGRvbid0IHJlYWxseSBz ZWUgaG93IHRoaXMgY2FuIHdvcmsuICBZb3UncmUgYXNraW5nIG1lIHRvIHB1dA0KPiA+PiBjaGFu Z2VzIGJhc2VkIG9uIGEgc2VjcmV0IHNwZWMgaW50byBnZW5lcmljIGNvZGUgdGhhdCBpcyB1c2Vk IG9uDQo+ID4+IGV2ZXJ5IG1hY2hpbmUgd2l0aCBQQ0kuICBJIGhhdmUgbm8gd2F5IHRvIG1haW50 YWluIHNvbWV0aGluZyBsaWtlIHRoYXQuDQo+ID4NCj4gPj4NCj4gPj4gVGhpcyBzZWVtcyBsaWtl IGEgbWFqb3Igc2NyZXcgdXAgaW4gdGhlIGRlc2lnbiBhbmQgZG9jdW1lbnRhdGlvbiBvZg0KPiBU aHVuZGVyYm9sdC4NCj4gPg0KPiA+IFNlZQ0KPiA+IGh0dHBzOi8vZGV2ZWxvcGVyLmFwcGxlLmNv bS9saWJyYXJ5L21hYy9kb2N1bWVudGF0aW9uL0hhcmR3YXJlRHJpdmVycy8NCj4gPiBDb25jZXB0 dWFsL1RodW5kZXJib2x0RGV2R3VpZGUvVGh1bmRlcmJvbHREZXZHdWlkZS5wZGYNCj4gPg0KPiA+ IHBhZ2UgMTAgZm9yIG9uZSBvZiB0aGUgYnJpZWYgcHVibGljIG5vdGVzIG9uIHRoZSBub3QgcmVs eWluZyBvbiBJL08gc3BhY2UuDQo+IA0KPiBJIGFncmVlIHdpdGggdGhhdCByZWNvbW1lbmRhdGlv biBub3QgdG8gcmVseSBvbiBJL08gc3BhY2UuICBJdCBhcHBsaWVzIGVxdWFsbHkNCj4gdG8gKmFs bCogUENJIGRldmljZXMsIG5vdCBqdXN0IHRvIFRodW5kZXJib2x0Lg0KPiANCj4gUHJlc3VtYWJs eSB0aGlzIHBhdGNoIGZpeGVzIGEgcHJvYmxlbS4gIFRoZSBjaGFuZ2Vsb2cgc2F5czoNCj4gDQo+ ICAgICBLZXJuZWwgc2hvdWxkbid0IGFsbG9jYXRlIHRoZSBQQ0kgSS9PIHJlc291cmNlcw0KPiAg ICAgYXMgaXQgaW50ZXJmZXJlcyB3aXRoIEJJT1Mgb3BlcmF0aW9uLg0KPiAgICAgRG9pbmcgdGhp cyBtYXkgY2F1c2UgdGhlIGRldmljZXMgaW4gdGhlIFRodW5kZXJib2x0IGNoYWluDQo+ICAgICBu b3QgYmVpbmcgZGV0ZWN0ZWQgb3IgYWRkZWQsIG9yIHdvcnNlIHRvIHN0dWNrIHRoZQ0KPiAgICAg VGh1bmRlcmJvbHQgSG9zdCBjb250cm9sbGVyLg0KPiANCj4gVGhlIHByb2JsZW0gb2YgZGV2aWNl cyBub3QgYmVpbmcgZGV0ZWN0ZWQgc291bmRzIGxpa2UgYSBnZW5lcmFsIHByb2JsZW0gKEkNCj4g YXNzdW1lIHRoZSBwcm9ibGVtIGlzIGFjdHVhbGx5IHRoYXQgd2UgZG8gZW51bWVyYXRlIHRoZSBk ZXZpY2UsIGJ1dCB3ZSBtYXkNCj4gbm90IGJlIGFibGUgdG8gYXNzaWduIEkvTyBwb3J0IHNwYWNl IHRvIGl0LCB3aGljaCBtZWFucyB3ZSBtYXkgbm90IGJlIGFibGUgdG8NCj4gb3BlcmF0ZSBpdCku ICBUaGlzIGNvdWxkIGhhcHBlbiB3aXRoIGFueSBkZXZpY2UuICBJZiB5b3UgY2FuIGNvbWUgdXAg d2l0aCBhDQo+IGdlbmVyaWMgd2F5IHRvIGRlYWwgd2l0aCBpdCwgdGhhdCBtaWdodCB3b3JrLiAg Tm90ZSB0aGF0IHdlIGRvIGFscmVhZHkgaGF2ZQ0KPiBwY2lfZW5hYmxlX2RldmljZV9tZW0oKSBm b3IgZHJpdmVycyB0aGF0IGRvbid0IG5lZWQgSS9PIHNwYWNlIHRvIG9wZXJhdGUNCj4gdGhlaXIg ZGV2aWNlLg0KPiANCj4gSWYgYXNzaWduaW5nIEkvTyBwb3J0IHNwYWNlIHRvIGEgZGV2aWNlIGNh biBoYW5nIHRoZSBUaHVuZGVyYm9sdCBjb250cm9sbGVyLCB0aGF0DQo+IHNvdW5kcyBsaWtlIGEg Y29udHJvbGxlciBkZWZlY3QsIGFuZCBtYXliZSB5b3UgY291bGQgd3JpdGUgYSBxdWlyayB0byB3 b3JrDQo+IGFyb3VuZCBpdC4gIEknbSBub3Qgb3Bwb3NlZCB0byBhZGRpbmcgZGV2aWNlLXNwZWNp ZmljIHdvcmthcm91bmRzIGZvciB0aGluZ3MNCj4gbGlrZSB0aGF0LiAgSSBqdXN0IGhhdmUgdHJv dWJsZSB3aXRoIHB1dHRpbmcgdW5kb2N1bWVudGVkIHdvcmthcm91bmRzIGluIHRoZQ0KPiBjb21t b24gcGF0aCB0aGF0IGV2ZXJ5Ym9keSB1c2VzLg0KPiANCj4gQmpvcm4NCg0KVGhlIGFjdHVhbCBw cm9ibGVtIHRoZSBwYXRjaCBpcyBtZWFudCB0byBhZGRyZXNzIGlzIHJlbGF0ZWQgdG8gdGhlIFBD SSANCmxpbWl0YXRpb24gb2YgNjRLQiBJL08gc3BhY2UgYW5kIHRoZSBmYWN0IHRoYXQgYWxsb2Nh dGlvbnMgYXJlIA0KcGVyZm9ybWVkIGluIGNodW5rcyBvZiA0S0IgYmVoaW5kIFBDSS10by1QQ0kg YnJpZGdlcy4NCkFmdGVyIGEgY2VydGFpbiBhbW91bnQgb2YgZGV2aWNlcyB0aGUgSS9PIHJlc291 cmNlcyBtYXkgYmUgZXhoYXVzdGVkLiANClRoaXMgaXMgaW5kZWVkIGEgZ2VuZXJhbCBpc3N1ZSwg bm90IG9ubHkgcmVsYXRlZCB0byBUaHVuZGVyYm9sdCwgYW5kIA0KYXMgQmpvcm4gc3VnZ2VzdGVk IGEgZ2VuZXJhbCBmaXggaXMgYWR2aXNlZC4NCiANCkZvbGxvd2luZyBmdXJ0aGVyIGludmVzdGln YXRpb25zIGl0IHNlZW1zIHRoYXQgd2UgbWF5IG5vdCByZWFsbHkgbmVlZCANCnRoaXMgcGF0Y2gg Zm9yIHRoZSBmb2xsb3dpbmcgcmVhc29uczoNCg0KMS4gSXQgc2VlbXMgdGhhdCB0aGUgY29udHJv bGxlciBpc3N1ZXMgKHdyaXR0ZW4gb24gdGhlIGNoYW5nZWxvZykgd2VyZSANCnJlbGF0ZWQgdG8g dGhlIGxhY2sgb2Ygc3VwcG9ydCBvZiBob3RwbHVnIHRvcG9sb2d5IGNoYW5nZXMgaW4gdGhlIG9s ZCANCnRlc3RlZCBrZXJuZWwgKDMuMTUpIHJhdGhlciB0aGFuIHRoZSBJL08gc3BhY2UgaXNzdWUu DQoNCjIuIEtlcm5lbCBQQ0kgZHJpdmVyIGhhbmRsZXMgcHJvcGVybHkgYWxsb2NhdGlvbnMgb2Yg SS9PIHJlc291cmNlcyBhbmQgDQpwcmV2ZW50cyBJL08gcmVzb3VyY2VzIGV4aGF1c3Rpb24gd2hp Y2ggbWF5IGhhdmUgY2F1c2VkIGlzc3VlcyAoaWYgbm90IA0KaGFuZGxlZCBwcm9wZXJseSkgdG8g YW55IFBDSSBvciBUaHVuZGVyYm9sdCBjb250cm9sbGVyLiBMb29rcyBsaWtlIA0KZmlyc3QgZGV2 aWNlIGFza2luZyBJL08gaXMgdGhlIGZpcnN0IHNlcnZlZCBhbmQgdGhpcyBtZWNoYW5pc20gd29y a3MgZmluZS4NCg0KMy4gRm9yIG1vc3QgZGV2aWNlcyBzdXBwb3J0ZWQgdG9kYXkgb24gVGh1bmRl cmJvbHQgc3VjaCBhcyBBSENJIG9yICANCmlHQiAoRTEwMDBFKSwgaWYgbm8gSS9PIHJlc291cmNl cyBpcyBhbGxvY2F0ZWQsIHRoZSBkZXZpY2Ugc2VlbXMgdG8gDQpjb250aW51ZSB0byBvcGVyYXRl IHRocm91Z2ggdGhlIG1lbW9yeSBCQVJzLg0KIA0KL01pY2hhZWwNCi0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpJbnRl bCBJc3JhZWwgKDc0KSBMaW1pdGVkCgpUaGlzIGUtbWFpbCBhbmQgYW55IGF0dGFjaG1lbnRzIG1h eSBjb250YWluIGNvbmZpZGVudGlhbCBtYXRlcmlhbCBmb3IKdGhlIHNvbGUgdXNlIG9mIHRoZSBp bnRlbmRlZCByZWNpcGllbnQocykuIEFueSByZXZpZXcgb3IgZGlzdHJpYnV0aW9uCmJ5IG90aGVy cyBpcyBzdHJpY3RseSBwcm9oaWJpdGVkLiBJZiB5b3UgYXJlIG5vdCB0aGUgaW50ZW5kZWQKcmVj aXBpZW50LCBwbGVhc2UgY29udGFjdCB0aGUgc2VuZGVyIGFuZCBkZWxldGUgYWxsIGNvcGllcy4K