* [PATCH] pci-sysfs: Make PCI bridge attribute visible in sysfs @ 2017-04-17 5:50 Wong Vee Khee 2017-04-17 15:41 ` Bjorn Helgaas 0 siblings, 1 reply; 4+ messages in thread From: Wong Vee Khee @ 2017-04-17 5:50 UTC (permalink / raw) To: bhelgaas, keith.busch, rajatja, shhuiw Cc: hui.chun.ong, jonathan.yong, vee.khee.wong, Ram.Amrani, linux-pci, linux-kernel From: vwong <vee.khee.wong@ni.com> Export the PCIe link attributes of PCI bridges to sysfs. Signed-off-by: Wong Vee Khee <vee.khee.wong@ni.com> Signed-off-by: Hui Chun Ong <hui.chun.ong@ni.com> --- drivers/pci/pci-sysfs.c | 197 +++++++++++++++++++++++++++++++++++++++++- include/uapi/linux/pci_regs.h | 4 + 2 files changed, 197 insertions(+), 4 deletions(-) diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c index 25d010d..a218c43 100644 --- a/drivers/pci/pci-sysfs.c +++ b/drivers/pci/pci-sysfs.c @@ -154,6 +154,127 @@ static ssize_t resource_show(struct device *dev, struct device_attribute *attr, } static DEVICE_ATTR_RO(resource); +static ssize_t max_link_speed_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + u32 linkcap; + int err; + const char *speed; + + err = pcie_capability_read_dword(pci_dev, PCI_EXP_LNKCAP, &linkcap); + + if (!err && linkcap) { + switch (linkcap & PCI_EXP_LNKCAP_MLS) { + case PCI_EXP_LNKCAP_MLS_8_0GB: + speed = "8 GT/s"; + break; + case PCI_EXP_LNKCAP_MLS_5_0GB: + speed = "5 GT/s"; + break; + case PCI_EXP_LNKCAP_MLS_2_5GB: + speed = "2.5 GT/s"; + break; + default: + speed = "Unknown speed"; + } + + return sprintf(buf, "%s\n", speed); + } + + return -EINVAL; +} +static DEVICE_ATTR_RO(max_link_speed); + +static ssize_t max_link_width_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + u32 linkcap; + int err; + + err = pcie_capability_read_dword(pci_dev, PCI_EXP_LNKCAP, &linkcap); + + return err ? -EINVAL : sprintf( + buf, "%u\n", (linkcap & PCI_EXP_LNKCAP_MLW) >> 4); +} +static DEVICE_ATTR_RO(max_link_width); + +static ssize_t current_link_speed_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + u16 linkstat; + int err; + const char *speed; + + err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat); + + if (!err && linkstat) { + switch (linkstat & PCI_EXP_LNKSTA_CLS) { + case PCI_EXP_LNKSTA_CLS_8_0GB: + speed = "8 GT/s"; + break; + case PCI_EXP_LNKSTA_CLS_5_0GB: + speed = "5 GT/s"; + break; + case PCI_EXP_LNKSTA_CLS_2_5GB: + speed = "2.5 GT/s"; + break; + default: + speed = "Unknown speed"; + } + + return sprintf(buf, "%s\n", speed); + } + + return -EINVAL; +} +static DEVICE_ATTR_RO(current_link_speed); + +static ssize_t current_link_width_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + u16 linkstat; + int err; + + err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat); + + return err ? -EINVAL : sprintf( + buf, "%u\n", + (linkstat & PCI_EXP_LNKSTA_NLW) >> PCI_EXP_LNKSTA_NLW_SHIFT); +} +static DEVICE_ATTR_RO(current_link_width); + +static ssize_t secondary_bus_number_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + u8 sec_bus; + int err; + + err = pci_read_config_byte(pci_dev, PCI_SECONDARY_BUS, &sec_bus); + + return err ? -EINVAL : sprintf(buf, "%u\n", sec_bus); +} +static DEVICE_ATTR_RO(secondary_bus_number); + +static ssize_t subordinate_bus_number_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + u8 sub_bus; + int err; + + err = pci_read_config_byte(pci_dev, PCI_SUBORDINATE_BUS, &sub_bus); + + return err ? -EINVAL : sprintf(buf, "%u\n", sub_bus); +} +static DEVICE_ATTR_RO(subordinate_bus_number); + static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) { @@ -602,12 +723,17 @@ static struct attribute *pci_dev_attrs[] = { NULL, }; -static const struct attribute_group pci_dev_group = { - .attrs = pci_dev_attrs, +static struct attribute *pci_bridge_attrs[] = { + &dev_attr_subordinate_bus_number.attr, + &dev_attr_secondary_bus_number.attr, + NULL, }; -const struct attribute_group *pci_dev_groups[] = { - &pci_dev_group, +static struct attribute *pcie_dev_attrs[] = { + &dev_attr_current_link_speed.attr, + &dev_attr_current_link_width.attr, + &dev_attr_max_link_width.attr, + &dev_attr_max_link_speed.attr, NULL, }; @@ -1540,6 +1666,57 @@ static umode_t pci_dev_hp_attrs_are_visible(struct kobject *kobj, return a->mode; } +static umode_t pci_bridge_attrs_are_visible(struct kobject *kobj, + struct attribute *a, int n) +{ + struct device *dev = kobj_to_dev(kobj); + struct pci_dev *pdev = to_pci_dev(dev); + + if (!pci_is_bridge(pdev)) + return 0; + + return a->mode; +} + +static umode_t pcie_dev_attrs_are_visible(struct kobject *kobj, + struct attribute *a, int n) +{ + struct device *dev = kobj_to_dev(kobj); + struct pci_dev *pdev = to_pci_dev(dev); + + if (pci_find_capability(pdev, PCI_CAP_ID_EXP) == 0) + return 0; + + return a->mode; +} + +static const struct attribute_group pci_dev_group = { + .attrs = pci_dev_attrs, +}; + +const struct attribute_group *pci_dev_groups[] = { + &pci_dev_group, + NULL, +}; + +static const struct attribute_group pci_bridge_group = { + .attrs = pci_bridge_attrs, +}; + +const struct attribute_group *pci_bridge_groups[] = { + &pci_bridge_group, + NULL, +}; + +static const struct attribute_group pcie_dev_group = { + .attrs = pcie_dev_attrs, +}; + +const struct attribute_group *pcie_dev_groups[] = { + &pcie_dev_group, + NULL, +}; + static struct attribute_group pci_dev_hp_attr_group = { .attrs = pci_dev_hp_attrs, .is_visible = pci_dev_hp_attrs_are_visible, @@ -1574,12 +1751,24 @@ static struct attribute_group pci_dev_attr_group = { .is_visible = pci_dev_attrs_are_visible, }; +static struct attribute_group pci_bridge_attr_group = { + .attrs = pci_bridge_attrs, + .is_visible = pci_bridge_attrs_are_visible, +}; + +static struct attribute_group pcie_dev_attr_group = { + .attrs = pcie_dev_attrs, + .is_visible = pcie_dev_attrs_are_visible, +}; + static const struct attribute_group *pci_dev_attr_groups[] = { &pci_dev_attr_group, &pci_dev_hp_attr_group, #ifdef CONFIG_PCI_IOV &sriov_dev_attr_group, #endif + &pci_bridge_attr_group, + &pcie_dev_attr_group, NULL, }; diff --git a/include/uapi/linux/pci_regs.h b/include/uapi/linux/pci_regs.h index 634c9c4..b1770dc 100644 --- a/include/uapi/linux/pci_regs.h +++ b/include/uapi/linux/pci_regs.h @@ -517,6 +517,10 @@ #define PCI_EXP_LNKCAP_SLS 0x0000000f /* Supported Link Speeds */ #define PCI_EXP_LNKCAP_SLS_2_5GB 0x00000001 /* LNKCAP2 SLS Vector bit 0 */ #define PCI_EXP_LNKCAP_SLS_5_0GB 0x00000002 /* LNKCAP2 SLS Vector bit 1 */ +#define PCI_EXP_LNKCAP_MLS 0x0000000f /* Maximum Link Speeds */ +#define PCI_EXP_LNKCAP_MLS_2_5GB 0x00000001 /* LNKCAP2 SLS Vector bit 0 */ +#define PCI_EXP_LNKCAP_MLS_5_0GB 0x00000002 /* LNKCAP2 SLS Vector bit 1 */ +#define PCI_EXP_LNKCAP_MLS_8_0GB 0x00000003 /* LNKCAP2 SLS Vector bit 2 */ #define PCI_EXP_LNKCAP_MLW 0x000003f0 /* Maximum Link Width */ #define PCI_EXP_LNKCAP_ASPMS 0x00000c00 /* ASPM Support */ #define PCI_EXP_LNKCAP_L0SEL 0x00007000 /* L0s Exit Latency */ -- 2.7.4 ^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PATCH] pci-sysfs: Make PCI bridge attribute visible in sysfs 2017-04-17 5:50 [PATCH] pci-sysfs: Make PCI bridge attribute visible in sysfs Wong Vee Khee @ 2017-04-17 15:41 ` Bjorn Helgaas 2017-05-04 7:32 ` Vee Khee Wong 0 siblings, 1 reply; 4+ messages in thread From: Bjorn Helgaas @ 2017-04-17 15:41 UTC (permalink / raw) To: Wong Vee Khee Cc: Keith Busch, Rajat Jain, shhuiw, hui.chun.ong, jonathan.yong, Ram.Amrani, linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org On Mon, Apr 17, 2017 at 12:50 AM, Wong Vee Khee <vee.khee.wong@ni.com> wrote: > From: vwong <vee.khee.wong@ni.com> > > Export the PCIe link attributes of PCI bridges to sysfs. This needs justification for *why* we should export these via sysfs. Some of these things, e.g., secondary/subordinate bus numbers, are already visible to non-privileged users via "lspci -v". > Signed-off-by: Wong Vee Khee <vee.khee.wong@ni.com> > Signed-off-by: Hui Chun Ong <hui.chun.ong@ni.com> > --- > drivers/pci/pci-sysfs.c | 197 +++++++++++++++++++++++++++++++++++++++++- > include/uapi/linux/pci_regs.h | 4 + > 2 files changed, 197 insertions(+), 4 deletions(-) > > diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c > index 25d010d..a218c43 100644 > --- a/drivers/pci/pci-sysfs.c > +++ b/drivers/pci/pci-sysfs.c > @@ -154,6 +154,127 @@ static ssize_t resource_show(struct device *dev, struct device_attribute *attr, > } > static DEVICE_ATTR_RO(resource); > > +static ssize_t max_link_speed_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + struct pci_dev *pci_dev = to_pci_dev(dev); > + u32 linkcap; > + int err; > + const char *speed; > + > + err = pcie_capability_read_dword(pci_dev, PCI_EXP_LNKCAP, &linkcap); > + > + if (!err && linkcap) { if (err) return -EINVAL; I don't think there's a reason to test "linkcap" here. Per spec, zero is not a valid value of LNKCAP, so if we got a zero, I think showing "Unknown speed" would be fine. > + switch (linkcap & PCI_EXP_LNKCAP_MLS) { > + case PCI_EXP_LNKCAP_MLS_8_0GB: > + speed = "8 GT/s"; > + break; > + case PCI_EXP_LNKCAP_MLS_5_0GB: > + speed = "5 GT/s"; > + break; > + case PCI_EXP_LNKCAP_MLS_2_5GB: > + speed = "2.5 GT/s"; > + break; > + default: > + speed = "Unknown speed"; > + } > + > + return sprintf(buf, "%s\n", speed); > + } > + > + return -EINVAL; > +} > +static DEVICE_ATTR_RO(max_link_speed); > + > +static ssize_t max_link_width_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + struct pci_dev *pci_dev = to_pci_dev(dev); > + u32 linkcap; > + int err; > + > + err = pcie_capability_read_dword(pci_dev, PCI_EXP_LNKCAP, &linkcap); > + > + return err ? -EINVAL : sprintf( > + buf, "%u\n", (linkcap & PCI_EXP_LNKCAP_MLW) >> 4); if (err) return -EINVAL; return sprintf(...); > +} > +static DEVICE_ATTR_RO(max_link_width); > + > +static ssize_t current_link_speed_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + struct pci_dev *pci_dev = to_pci_dev(dev); > + u16 linkstat; > + int err; > + const char *speed; > + > + err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat); > + > + if (!err && linkstat) { See max_link_speed above. > + switch (linkstat & PCI_EXP_LNKSTA_CLS) { > + case PCI_EXP_LNKSTA_CLS_8_0GB: > + speed = "8 GT/s"; > + break; > + case PCI_EXP_LNKSTA_CLS_5_0GB: > + speed = "5 GT/s"; > + break; > + case PCI_EXP_LNKSTA_CLS_2_5GB: > + speed = "2.5 GT/s"; > + break; > + default: > + speed = "Unknown speed"; > + } > + > + return sprintf(buf, "%s\n", speed); > + } > + > + return -EINVAL; > +} > +static DEVICE_ATTR_RO(current_link_speed); > + > +static ssize_t current_link_width_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + struct pci_dev *pci_dev = to_pci_dev(dev); > + u16 linkstat; > + int err; > + > + err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat); > + > + return err ? -EINVAL : sprintf( > + buf, "%u\n", > + (linkstat & PCI_EXP_LNKSTA_NLW) >> PCI_EXP_LNKSTA_NLW_SHIFT); > +} > +static DEVICE_ATTR_RO(current_link_width); > + > +static ssize_t secondary_bus_number_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct pci_dev *pci_dev = to_pci_dev(dev); > + u8 sec_bus; > + int err; > + > + err = pci_read_config_byte(pci_dev, PCI_SECONDARY_BUS, &sec_bus); There is already a /sys/devices/pciDDDD:BB/DDDD:BB:dd.f/<secondary>/ directory and a .../pci_bus/ directory that looks like it is the secondary bus. Is that enough? If we also need this file, I would like it to do something sensible when there is no secondary bus. Maybe that is exposing the bus numbers directly, or maybe it is something else. I tend to think that if you just want the register contents, lspci is enough, and if you need something in sysfs, it should be a little more digested, e.g., the existing subdirectory. It'd be helpful to know something about how you want to use this. > + return err ? -EINVAL : sprintf(buf, "%u\n", sec_bus); > +} > +static DEVICE_ATTR_RO(secondary_bus_number); > + > +static ssize_t subordinate_bus_number_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct pci_dev *pci_dev = to_pci_dev(dev); > + u8 sub_bus; > + int err; > + > + err = pci_read_config_byte(pci_dev, PCI_SUBORDINATE_BUS, &sub_bus); > + > + return err ? -EINVAL : sprintf(buf, "%u\n", sub_bus); > +} > +static DEVICE_ATTR_RO(subordinate_bus_number); > + > static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, > char *buf) > { > @@ -602,12 +723,17 @@ static struct attribute *pci_dev_attrs[] = { > NULL, > }; > > -static const struct attribute_group pci_dev_group = { > - .attrs = pci_dev_attrs, > +static struct attribute *pci_bridge_attrs[] = { > + &dev_attr_subordinate_bus_number.attr, > + &dev_attr_secondary_bus_number.attr, > + NULL, > }; > > -const struct attribute_group *pci_dev_groups[] = { > - &pci_dev_group, > +static struct attribute *pcie_dev_attrs[] = { > + &dev_attr_current_link_speed.attr, > + &dev_attr_current_link_width.attr, > + &dev_attr_max_link_width.attr, > + &dev_attr_max_link_speed.attr, > NULL, > }; > > @@ -1540,6 +1666,57 @@ static umode_t pci_dev_hp_attrs_are_visible(struct kobject *kobj, > return a->mode; > } > > +static umode_t pci_bridge_attrs_are_visible(struct kobject *kobj, > + struct attribute *a, int n) > +{ > + struct device *dev = kobj_to_dev(kobj); > + struct pci_dev *pdev = to_pci_dev(dev); > + > + if (!pci_is_bridge(pdev)) > + return 0; if (pci_is_bridge(pdev)) return a->mode; return 0; I think it's easier to read without the negation. Possibly that's just my personal preference :) > + > + return a->mode; > +} > + > +static umode_t pcie_dev_attrs_are_visible(struct kobject *kobj, > + struct attribute *a, int n) > +{ > + struct device *dev = kobj_to_dev(kobj); > + struct pci_dev *pdev = to_pci_dev(dev); > + > + if (pci_find_capability(pdev, PCI_CAP_ID_EXP) == 0) Use pci_is_pcie(). > + return 0; > + > + return a->mode; > +} > + > +static const struct attribute_group pci_dev_group = { > + .attrs = pci_dev_attrs, > +}; > + > +const struct attribute_group *pci_dev_groups[] = { > + &pci_dev_group, > + NULL, > +}; > + > +static const struct attribute_group pci_bridge_group = { > + .attrs = pci_bridge_attrs, > +}; > + > +const struct attribute_group *pci_bridge_groups[] = { > + &pci_bridge_group, > + NULL, > +}; > + > +static const struct attribute_group pcie_dev_group = { > + .attrs = pcie_dev_attrs, > +}; > + > +const struct attribute_group *pcie_dev_groups[] = { > + &pcie_dev_group, > + NULL, > +}; > + > static struct attribute_group pci_dev_hp_attr_group = { > .attrs = pci_dev_hp_attrs, > .is_visible = pci_dev_hp_attrs_are_visible, > @@ -1574,12 +1751,24 @@ static struct attribute_group pci_dev_attr_group = { > .is_visible = pci_dev_attrs_are_visible, > }; > > +static struct attribute_group pci_bridge_attr_group = { > + .attrs = pci_bridge_attrs, > + .is_visible = pci_bridge_attrs_are_visible, > +}; > + > +static struct attribute_group pcie_dev_attr_group = { > + .attrs = pcie_dev_attrs, > + .is_visible = pcie_dev_attrs_are_visible, > +}; > + > static const struct attribute_group *pci_dev_attr_groups[] = { > &pci_dev_attr_group, > &pci_dev_hp_attr_group, > #ifdef CONFIG_PCI_IOV > &sriov_dev_attr_group, > #endif > + &pci_bridge_attr_group, > + &pcie_dev_attr_group, > NULL, > }; > > diff --git a/include/uapi/linux/pci_regs.h b/include/uapi/linux/pci_regs.h > index 634c9c4..b1770dc 100644 > --- a/include/uapi/linux/pci_regs.h > +++ b/include/uapi/linux/pci_regs.h > @@ -517,6 +517,10 @@ > #define PCI_EXP_LNKCAP_SLS 0x0000000f /* Supported Link Speeds */ > #define PCI_EXP_LNKCAP_SLS_2_5GB 0x00000001 /* LNKCAP2 SLS Vector bit 0 */ > #define PCI_EXP_LNKCAP_SLS_5_0GB 0x00000002 /* LNKCAP2 SLS Vector bit 1 */ > +#define PCI_EXP_LNKCAP_MLS 0x0000000f /* Maximum Link Speeds */ > +#define PCI_EXP_LNKCAP_MLS_2_5GB 0x00000001 /* LNKCAP2 SLS Vector bit 0 */ > +#define PCI_EXP_LNKCAP_MLS_5_0GB 0x00000002 /* LNKCAP2 SLS Vector bit 1 */ > +#define PCI_EXP_LNKCAP_MLS_8_0GB 0x00000003 /* LNKCAP2 SLS Vector bit 2 */ Rather than adding these _MLS_ symbols as duplicates of _SLS_, please just add one SLS_8_0GB symbol. The _SLS_ names are an artifact of the fact that prior to PCIe r3.0, this field was the "Supported Link Speeds" field. PCIe 3.0 renamed it to "Max Link Speed" and added the "Supported Link Speeds Vector" in the new Link Capabilities 2 register. > #define PCI_EXP_LNKCAP_MLW 0x000003f0 /* Maximum Link Width */ > #define PCI_EXP_LNKCAP_ASPMS 0x00000c00 /* ASPM Support */ > #define PCI_EXP_LNKCAP_L0SEL 0x00007000 /* L0s Exit Latency */ > -- > 2.7.4 > ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] pci-sysfs: Make PCI bridge attribute visible in sysfs 2017-04-17 15:41 ` Bjorn Helgaas @ 2017-05-04 7:32 ` Vee Khee Wong 2017-05-04 12:58 ` Bjorn Helgaas 0 siblings, 1 reply; 4+ messages in thread From: Vee Khee Wong @ 2017-05-04 7:32 UTC (permalink / raw) To: bhelgaas@google.com Cc: linux-kernel@vger.kernel.org, Jonathan Hearn, Ram.Amrani@cavium.com, Hui Chun Ong, shhuiw@foxmail.com, rajatja@google.com, linux-pci@vger.kernel.org, keith.busch@intel.com, jonathan.yong@intel.com DQoNCk9uIE1vbiwgMjAxNy0wNC0xNyBhdCAxMDo0MSAtMDUwMCwgQmpvcm4gSGVsZ2FhcyB3cm90 ZToNCj4gT24gTW9uLCBBcHIgMTcsIDIwMTcgYXQgMTI6NTAgQU0sIFdvbmcgVmVlIEtoZWUgPHZl ZS5raGVlLndvbmdAbmkuY29tDQo+ID4gd3JvdGU6DQo+ID4gDQo+ID4gRnJvbTogdndvbmcgPHZl ZS5raGVlLndvbmdAbmkuY29tPg0KPiA+IA0KPiA+IEV4cG9ydCB0aGUgUENJZSBsaW5rIGF0dHJp YnV0ZXMgb2YgUENJIGJyaWRnZXMgdG8gc3lzZnMuDQo+IFRoaXMgbmVlZHMganVzdGlmaWNhdGlv biBmb3IgKndoeSogd2Ugc2hvdWxkIGV4cG9ydCB0aGVzZSB2aWEgc3lzZnMuDQo+IA0KPiBTb21l IG9mIHRoZXNlIHRoaW5ncywgZS5nLiwgc2Vjb25kYXJ5L3N1Ym9yZGluYXRlIGJ1cyBudW1iZXJz LCBhcmUNCj4gYWxyZWFkeSB2aXNpYmxlIHRvIG5vbi1wcml2aWxlZ2VkIHVzZXJzIHZpYSAibHNw Y2kgLXYiLg0KPiANCldlIG5lZWQgdG8gZXhwb3NlIHRoZXNlIGF0dHJpYnV0ZXMgdmlhIHN5c2Zz IGR1ZSB0byBzZXZlcmFsIHJlYXNvbnMNCmxpc3RlZCBiZWxvdzoNCg0KMSkgUENJZSBjYXBhYmls aXRpZXMgaW5mbyBzdWNoIGFzIE1heGltdW0vQWN0dWFsIGxpbmsgd2lkdGggYW5kIGxpbmsgc3Bl ZWQgb25seSB2aXNpYmxlIHRvIHByaXZpbGVnZWQgdXNlcnMgdmlhICJsc3BjaSAtdnZ2Ii4gVGhl IHNvZnR3YXJlIHRoYXQgbXkgdGVhbSBpcyB3b3JraW5nIG9uIG5lZWQgdG8gZ2V0IFBDSWUgbGlu ayBpbmZvcm1hdGlvbiBhcyBub24tcm9vdCB1c2VyLg0KDQoyKSBGcm9tIGEgY2xpZW50IHBlcnNw ZWN0aXZlLCBpdCByZXF1aXJlIGEgbG90IG9mIG92ZXJoZWFkIHBhcnNpbmcgb3V0cHV0IG9mIGxz cGNpIHRvIGdldCBQQ0llIGNhcGFiaWxpdGllcy4gT3VyIGFwcGxpY2F0aW9uIGlzIG9ubHkgaW50 ZXJlc3RlZCBpbiBnZXR0aW5nIFBDSWUgYnJpZGdlcyBidXQgbHNwY2kgcHJpbnQgaW5mbyBmb3Ig YWxsIFBDSWUgZGV2aWNlcy4NCg0KPiA+IA0KPiA+IFNpZ25lZC1vZmYtYnk6IFdvbmcgVmVlIEto ZWUgPHZlZS5raGVlLndvbmdAbmkuY29tPg0KPiA+IFNpZ25lZC1vZmYtYnk6IEh1aSBDaHVuIE9u ZyA8aHVpLmNodW4ub25nQG5pLmNvbT4NCj4gPiAtLS0NCj4gPiDCoGRyaXZlcnMvcGNpL3BjaS1z eXNmcy5jwqDCoMKgwqDCoMKgwqB8IDE5Nw0KPiA+ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrLQ0KPiA+IMKgaW5jbHVkZS91YXBpL2xpbnV4L3BjaV9yZWdzLmggfMKg wqDCoDQgKw0KPiA+IMKgMiBmaWxlcyBjaGFuZ2VkLCAxOTcgaW5zZXJ0aW9ucygrKSwgNCBkZWxl dGlvbnMoLSkNCj4gPiANCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpLXN5c2ZzLmMg Yi9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYw0KPiA+IGluZGV4IDI1ZDAxMGQuLmEyMThjNDMgMTAw NjQ0DQo+ID4gLS0tIGEvZHJpdmVycy9wY2kvcGNpLXN5c2ZzLmMNCj4gPiArKysgYi9kcml2ZXJz L3BjaS9wY2ktc3lzZnMuYw0KPiA+IEBAIC0xNTQsNiArMTU0LDEyNyBAQCBzdGF0aWMgc3NpemVf dCByZXNvdXJjZV9zaG93KHN0cnVjdCBkZXZpY2UNCj4gPiAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0 dHJpYnV0ZSAqYXR0ciwNCj4gPiDCoH0NCj4gPiDCoHN0YXRpYyBERVZJQ0VfQVRUUl9STyhyZXNv dXJjZSk7DQo+ID4gDQo+ID4gK3N0YXRpYyBzc2l6ZV90IG1heF9saW5rX3NwZWVkX3Nob3coc3Ry dWN0IGRldmljZSAqZGV2LA0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHN0cnVjdCBkZXZpY2VfYXR0cmlidXRl ICphdHRyLA0KPiA+IGNoYXIgKmJ1ZikNCj4gPiArew0KPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVj dCBwY2lfZGV2ICpwY2lfZGV2ID0gdG9fcGNpX2RldihkZXYpOw0KPiA+ICvCoMKgwqDCoMKgwqDC oHUzMiBsaW5rY2FwOw0KPiA+ICvCoMKgwqDCoMKgwqDCoGludCBlcnI7DQo+ID4gK8KgwqDCoMKg wqDCoMKgY29uc3QgY2hhciAqc3BlZWQ7DQo+ID4gKw0KPiA+ICvCoMKgwqDCoMKgwqDCoGVyciA9 IHBjaWVfY2FwYWJpbGl0eV9yZWFkX2R3b3JkKHBjaV9kZXYsIFBDSV9FWFBfTE5LQ0FQLA0KPiA+ ICZsaW5rY2FwKTsNCj4gPiArDQo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKCFlcnIgJiYgbGlua2Nh cCkgew0KPiDCoCBpZiAoZXJyKQ0KPiDCoMKgwqDCoHJldHVybiAtRUlOVkFMOw0KPiANCj4gSSBk b24ndCB0aGluayB0aGVyZSdzIGEgcmVhc29uIHRvIHRlc3QgImxpbmtjYXAiIGhlcmUuwqDCoFBl ciBzcGVjLA0KPiB6ZXJvDQo+IGlzIG5vdCBhIHZhbGlkIHZhbHVlIG9mIExOS0NBUCwgc28gaWYg d2UgZ290IGEgemVybywgSSB0aGluayBzaG93aW5nDQo+ICJVbmtub3duIHNwZWVkIiB3b3VsZCBi ZSBmaW5lLg0KPiANCj4gPiANCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3dp dGNoIChsaW5rY2FwICYgUENJX0VYUF9MTktDQVBfTUxTKSB7DQo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoGNhc2UgUENJX0VYUF9MTktDQVBfTUxTXzhfMEdCOg0KPiA+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3BlZWQgPSAiOCBHVC9z IjsNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGJy ZWFrOw0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBjYXNlIFBDSV9FWFBfTE5L Q0FQX01MU181XzBHQjoNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoHNwZWVkID0gIjUgR1QvcyI7DQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBicmVhazsNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgY2FzZSBQQ0lfRVhQX0xOS0NBUF9NTFNfMl81R0I6DQo+ID4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzcGVlZCA9ICIyLjUgR1QvcyI7DQo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBicmVhazsN Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgZGVmYXVsdDoNCj4gPiArwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHNwZWVkID0gIlVua25vd24g c3BlZWQiOw0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB9DQo+ID4gKw0KPiA+ ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXR1cm4gc3ByaW50ZihidWYsICIlc1xu Iiwgc3BlZWQpOw0KPiA+ICvCoMKgwqDCoMKgwqDCoH0NCj4gPiArDQo+ID4gK8KgwqDCoMKgwqDC oMKgcmV0dXJuIC1FSU5WQUw7DQo+ID4gK30NCj4gPiArc3RhdGljIERFVklDRV9BVFRSX1JPKG1h eF9saW5rX3NwZWVkKTsNCj4gPiArDQo+ID4gK3N0YXRpYyBzc2l6ZV90IG1heF9saW5rX3dpZHRo X3Nob3coc3RydWN0IGRldmljZSAqZGV2LA0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLA0KPiA+IGNoYXIgKmJ1ZikNCj4gPiArew0KPiA+ICvCoMKgwqDCoMKg wqDCoHN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2ID0gdG9fcGNpX2RldihkZXYpOw0KPiA+ICvCoMKg wqDCoMKgwqDCoHUzMiBsaW5rY2FwOw0KPiA+ICvCoMKgwqDCoMKgwqDCoGludCBlcnI7DQo+ID4g Kw0KPiA+ICvCoMKgwqDCoMKgwqDCoGVyciA9IHBjaWVfY2FwYWJpbGl0eV9yZWFkX2R3b3JkKHBj aV9kZXYsIFBDSV9FWFBfTE5LQ0FQLA0KPiA+ICZsaW5rY2FwKTsNCj4gPiArDQo+ID4gK8KgwqDC oMKgwqDCoMKgcmV0dXJuIGVyciA/IC1FSU5WQUwgOiBzcHJpbnRmKA0KPiA+ICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqBidWYsICIldVxuIiwgKGxpbmtjYXAgJiBQQ0lfRVhQX0xOS0NB UF9NTFcpID4+IDQpOw0KPiDCoCBpZiAoZXJyKQ0KPiDCoMKgwqDCoHJldHVybiAtRUlOVkFMOw0K PiANCj4gwqAgcmV0dXJuIHNwcmludGYoLi4uKTsNCj4gDQo+ID4gDQo+ID4gK30NCj4gPiArc3Rh dGljIERFVklDRV9BVFRSX1JPKG1heF9saW5rX3dpZHRoKTsNCj4gPiArDQo+ID4gK3N0YXRpYyBz c2l6ZV90IGN1cnJlbnRfbGlua19zcGVlZF9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwNCj4gPiAr wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlDQo+ID4gKmF0dHIsIGNo YXIgKmJ1ZikNCj4gPiArew0KPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBwY2lfZGV2ICpwY2lf ZGV2ID0gdG9fcGNpX2RldihkZXYpOw0KPiA+ICvCoMKgwqDCoMKgwqDCoHUxNiBsaW5rc3RhdDsN Cj4gPiArwqDCoMKgwqDCoMKgwqBpbnQgZXJyOw0KPiA+ICvCoMKgwqDCoMKgwqDCoGNvbnN0IGNo YXIgKnNwZWVkOw0KPiA+ICsNCj4gPiArwqDCoMKgwqDCoMKgwqBlcnIgPSBwY2llX2NhcGFiaWxp dHlfcmVhZF93b3JkKHBjaV9kZXYsIFBDSV9FWFBfTE5LU1RBLA0KPiA+ICZsaW5rc3RhdCk7DQo+ ID4gKw0KPiA+ICvCoMKgwqDCoMKgwqDCoGlmICghZXJyICYmIGxpbmtzdGF0KSB7DQo+IFNlZSBt YXhfbGlua19zcGVlZCBhYm92ZS4NCj4gDQo+ID4gDQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoHN3aXRjaCAobGlua3N0YXQgJiBQQ0lfRVhQX0xOS1NUQV9DTFMpIHsNCj4gPiAr wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgY2FzZSBQQ0lfRVhQX0xOS1NUQV9DTFNfOF8w R0I6DQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBz cGVlZCA9ICI4IEdUL3MiOw0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgYnJlYWs7DQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGNh c2UgUENJX0VYUF9MTktTVEFfQ0xTXzVfMEdCOg0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3BlZWQgPSAiNSBHVC9zIjsNCj4gPiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGJyZWFrOw0KPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBjYXNlIFBDSV9FWFBfTE5LU1RBX0NMU18yXzVHQjoNCj4g PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHNwZWVkID0g IjIuNSBHVC9zIjsNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoGJyZWFrOw0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBkZWZhdWx0 Og0KPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3Bl ZWQgPSAiVW5rbm93biBzcGVlZCI7DQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oH0NCj4gPiArDQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldHVybiBzcHJp bnRmKGJ1ZiwgIiVzXG4iLCBzcGVlZCk7DQo+ID4gK8KgwqDCoMKgwqDCoMKgfQ0KPiA+ICsNCj4g PiArwqDCoMKgwqDCoMKgwqByZXR1cm4gLUVJTlZBTDsNCj4gPiArfQ0KPiA+ICtzdGF0aWMgREVW SUNFX0FUVFJfUk8oY3VycmVudF9saW5rX3NwZWVkKTsNCj4gPiArDQo+ID4gK3N0YXRpYyBzc2l6 ZV90IGN1cnJlbnRfbGlua193aWR0aF9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwNCj4gPiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlDQo+ID4gKmF0dHIsIGNoYXIg KmJ1ZikNCj4gPiArew0KPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2 ID0gdG9fcGNpX2RldihkZXYpOw0KPiA+ICvCoMKgwqDCoMKgwqDCoHUxNiBsaW5rc3RhdDsNCj4g PiArwqDCoMKgwqDCoMKgwqBpbnQgZXJyOw0KPiA+ICsNCj4gPiArwqDCoMKgwqDCoMKgwqBlcnIg PSBwY2llX2NhcGFiaWxpdHlfcmVhZF93b3JkKHBjaV9kZXYsIFBDSV9FWFBfTE5LU1RBLA0KPiA+ ICZsaW5rc3RhdCk7DQo+ID4gKw0KPiA+ICvCoMKgwqDCoMKgwqDCoHJldHVybiBlcnIgPyAtRUlO VkFMIDogc3ByaW50ZigNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgYnVmLCAi JXVcbiIsDQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoChsaW5rc3RhdCAmIFBD SV9FWFBfTE5LU1RBX05MVykgPj4NCj4gPiBQQ0lfRVhQX0xOS1NUQV9OTFdfU0hJRlQpOw0KPiA+ ICt9DQo+ID4gK3N0YXRpYyBERVZJQ0VfQVRUUl9STyhjdXJyZW50X2xpbmtfd2lkdGgpOw0KPiA+ ICsNCj4gPiArc3RhdGljIHNzaXplX3Qgc2Vjb25kYXJ5X2J1c19udW1iZXJfc2hvdyhzdHJ1Y3Qg ZGV2aWNlICpkZXYsDQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3RydWN0IGRldmljZV9h dHRyaWJ1dGUNCj4gPiAqYXR0ciwNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBjaGFyICpi dWYpDQo+ID4gK3sNCj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldiA9 IHRvX3BjaV9kZXYoZGV2KTsNCj4gPiArwqDCoMKgwqDCoMKgwqB1OCBzZWNfYnVzOw0KPiA+ICvC oMKgwqDCoMKgwqDCoGludCBlcnI7DQo+ID4gKw0KPiA+ICvCoMKgwqDCoMKgwqDCoGVyciA9IHBj aV9yZWFkX2NvbmZpZ19ieXRlKHBjaV9kZXYsIFBDSV9TRUNPTkRBUllfQlVTLA0KPiA+ICZzZWNf YnVzKTsNCj4gVGhlcmUgaXMgYWxyZWFkeSBhIC9zeXMvZGV2aWNlcy9wY2lEREREOkJCL0REREQ6 QkI6ZGQuZi88c2Vjb25kYXJ5Pi8NCj4gZGlyZWN0b3J5IGFuZCBhIC4uLi9wY2lfYnVzLyBkaXJl Y3RvcnkgdGhhdCBsb29rcyBsaWtlIGl0IGlzIHRoZQ0KPiBzZWNvbmRhcnkgYnVzLsKgwqBJcyB0 aGF0IGVub3VnaD8NCj4gDQo+IElmIHdlIGFsc28gbmVlZCB0aGlzIGZpbGUsIEkgd291bGQgbGlr ZSBpdCB0byBkbyBzb21ldGhpbmcgc2Vuc2libGUNCj4gd2hlbiB0aGVyZSBpcyBubyBzZWNvbmRh cnkgYnVzLsKgwqBNYXliZSB0aGF0IGlzIGV4cG9zaW5nIHRoZSBidXMNCj4gbnVtYmVycyBkaXJl Y3RseSwgb3IgbWF5YmUgaXQgaXMgc29tZXRoaW5nIGVsc2UuwqDCoEkgdGVuZCB0byB0aGluaw0K PiB0aGF0DQo+IGlmIHlvdSBqdXN0IHdhbnQgdGhlIHJlZ2lzdGVyIGNvbnRlbnRzLCBsc3BjaSBp cyBlbm91Z2gsIGFuZCBpZiB5b3UNCj4gbmVlZCBzb21ldGhpbmcgaW4gc3lzZnMsIGl0IHNob3Vs ZCBiZSBhIGxpdHRsZSBtb3JlIGRpZ2VzdGVkLCBlLmcuLA0KPiB0aGUgZXhpc3Rpbmcgc3ViZGly ZWN0b3J5Lg0KPiANCj4gSXQnZCBiZSBoZWxwZnVsIHRvIGtub3cgc29tZXRoaW5nIGFib3V0IGhv dyB5b3Ugd2FudCB0byB1c2UgdGhpcy4NCj4gDQo+ID4gDQo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0 dXJuIGVyciA/IC1FSU5WQUwgOiBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCBzZWNfYnVzKTsNCj4gPiAr fQ0KPiA+ICtzdGF0aWMgREVWSUNFX0FUVFJfUk8oc2Vjb25kYXJ5X2J1c19udW1iZXIpOw0KPiA+ ICsNCj4gPiArc3RhdGljIHNzaXplX3Qgc3Vib3JkaW5hdGVfYnVzX251bWJlcl9zaG93KHN0cnVj dCBkZXZpY2UgKmRldiwNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3RydWN0IGRl dmljZV9hdHRyaWJ1dGUNCj4gPiAqYXR0ciwNCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgY2hhciAqYnVmKQ0KPiA+ICt7DQo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IHBjaV9kZXYg KnBjaV9kZXYgPSB0b19wY2lfZGV2KGRldik7DQo+ID4gK8KgwqDCoMKgwqDCoMKgdTggc3ViX2J1 czsNCj4gPiArwqDCoMKgwqDCoMKgwqBpbnQgZXJyOw0KPiA+ICsNCj4gPiArwqDCoMKgwqDCoMKg wqBlcnIgPSBwY2lfcmVhZF9jb25maWdfYnl0ZShwY2lfZGV2LCBQQ0lfU1VCT1JESU5BVEVfQlVT LA0KPiA+ICZzdWJfYnVzKTsNCj4gPiArDQo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0dXJuIGVyciA/ IC1FSU5WQUwgOiBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCBzdWJfYnVzKTsNCj4gPiArfQ0KPiA+ICtz dGF0aWMgREVWSUNFX0FUVFJfUk8oc3Vib3JkaW5hdGVfYnVzX251bWJlcik7DQo+ID4gKw0KPiA+ IMKgc3RhdGljIHNzaXplX3QgbW9kYWxpYXNfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dA0KPiA+IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsDQo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGNoYXIgKmJ1ZikNCj4gPiDCoHsN Cj4gPiBAQCAtNjAyLDEyICs3MjMsMTcgQEAgc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnBjaV9k ZXZfYXR0cnNbXSA9IHsNCj4gPiDCoMKgwqDCoMKgwqDCoMKgTlVMTCwNCj4gPiDCoH07DQo+ID4g DQo+ID4gLXN0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIHBjaV9kZXZfZ3JvdXAg PSB7DQo+ID4gLcKgwqDCoMKgwqDCoMKgLmF0dHJzID0gcGNpX2Rldl9hdHRycywNCj4gPiArc3Rh dGljIHN0cnVjdCBhdHRyaWJ1dGUgKnBjaV9icmlkZ2VfYXR0cnNbXSA9IHsNCj4gPiArwqDCoMKg wqDCoMKgwqAmZGV2X2F0dHJfc3Vib3JkaW5hdGVfYnVzX251bWJlci5hdHRyLA0KPiA+ICvCoMKg wqDCoMKgwqDCoCZkZXZfYXR0cl9zZWNvbmRhcnlfYnVzX251bWJlci5hdHRyLA0KPiA+ICvCoMKg wqDCoMKgwqDCoE5VTEwsDQo+ID4gwqB9Ow0KPiA+IA0KPiA+IC1jb25zdCBzdHJ1Y3QgYXR0cmli dXRlX2dyb3VwICpwY2lfZGV2X2dyb3Vwc1tdID0gew0KPiA+IC3CoMKgwqDCoMKgwqDCoCZwY2lf ZGV2X2dyb3VwLA0KPiA+ICtzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqcGNpZV9kZXZfYXR0cnNb XSA9IHsNCj4gPiArwqDCoMKgwqDCoMKgwqAmZGV2X2F0dHJfY3VycmVudF9saW5rX3NwZWVkLmF0 dHIsDQo+ID4gK8KgwqDCoMKgwqDCoMKgJmRldl9hdHRyX2N1cnJlbnRfbGlua193aWR0aC5hdHRy LA0KPiA+ICvCoMKgwqDCoMKgwqDCoCZkZXZfYXR0cl9tYXhfbGlua193aWR0aC5hdHRyLA0KPiA+ ICvCoMKgwqDCoMKgwqDCoCZkZXZfYXR0cl9tYXhfbGlua19zcGVlZC5hdHRyLA0KPiA+IMKgwqDC oMKgwqDCoMKgwqBOVUxMLA0KPiA+IMKgfTsNCj4gPiANCj4gPiBAQCAtMTU0MCw2ICsxNjY2LDU3 IEBAIHN0YXRpYyB1bW9kZV90DQo+ID4gcGNpX2Rldl9ocF9hdHRyc19hcmVfdmlzaWJsZShzdHJ1 Y3Qga29iamVjdCAqa29iaiwNCj4gPiDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuIGEtPm1vZGU7DQo+ ID4gwqB9DQo+ID4gDQo+ID4gK3N0YXRpYyB1bW9kZV90IHBjaV9icmlkZ2VfYXR0cnNfYXJlX3Zp c2libGUoc3RydWN0IGtvYmplY3QgKmtvYmosDQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgc3RydWN0IGF0dHJpYnV0ZSAqYSwNCj4gPiBpbnQgbikNCj4gPiArew0KPiA+ICvCoMKg wqDCoMKgwqDCoHN0cnVjdCBkZXZpY2UgKmRldiA9IGtvYmpfdG9fZGV2KGtvYmopOw0KPiA+ICvC oMKgwqDCoMKgwqDCoHN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gdG9fcGNpX2RldihkZXYpOw0KPiA+ ICsNCj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoIXBjaV9pc19icmlkZ2UocGRldikpDQo+ID4gK8Kg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldHVybiAwOw0KPiDCoCBpZiAocGNpX2lzX2Jy aWRnZShwZGV2KSkNCj4gwqDCoMKgwqByZXR1cm4gYS0+bW9kZTsNCj4gDQo+IMKgIHJldHVybiAw Ow0KPiANCj4gSSB0aGluayBpdCdzIGVhc2llciB0byByZWFkIHdpdGhvdXQgdGhlIG5lZ2F0aW9u LsKgwqBQb3NzaWJseSB0aGF0J3MNCj4ganVzdCBteSBwZXJzb25hbCBwcmVmZXJlbmNlIDopDQo+ IA0KPiA+IA0KPiA+ICsNCj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gYS0+bW9kZTsNCj4gPiAr fQ0KPiA+ICsNCj4gPiArc3RhdGljIHVtb2RlX3QgcGNpZV9kZXZfYXR0cnNfYXJlX3Zpc2libGUo c3RydWN0IGtvYmplY3QgKmtvYmosDQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzdHJ1 Y3QgYXR0cmlidXRlICphLCBpbnQNCj4gPiBuKQ0KPiA+ICt7DQo+ID4gK8KgwqDCoMKgwqDCoMKg c3RydWN0IGRldmljZSAqZGV2ID0ga29ial90b19kZXYoa29iaik7DQo+ID4gK8KgwqDCoMKgwqDC oMKgc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KGRldik7DQo+ID4gKw0KPiA+ICvC oMKgwqDCoMKgwqDCoGlmIChwY2lfZmluZF9jYXBhYmlsaXR5KHBkZXYsIFBDSV9DQVBfSURfRVhQ KSA9PSAwKQ0KPiBVc2UgcGNpX2lzX3BjaWUoKS4NCj4gDQo+ID4gDQo+ID4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoHJldHVybiAwOw0KPiA+ICsNCj4gPiArwqDCoMKgwqDCoMKgwqBy ZXR1cm4gYS0+bW9kZTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCBh dHRyaWJ1dGVfZ3JvdXAgcGNpX2Rldl9ncm91cCA9IHsNCj4gPiArwqDCoMKgwqDCoMKgwqAuYXR0 cnMgPSBwY2lfZGV2X2F0dHJzLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArY29uc3Qgc3RydWN0IGF0 dHJpYnV0ZV9ncm91cCAqcGNpX2Rldl9ncm91cHNbXSA9IHsNCj4gPiArwqDCoMKgwqDCoMKgwqAm cGNpX2Rldl9ncm91cCwNCj4gPiArwqDCoMKgwqDCoMKgwqBOVUxMLA0KPiA+ICt9Ow0KPiA+ICsN Cj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgcGNpX2JyaWRnZV9ncm91 cCA9IHsNCj4gPiArwqDCoMKgwqDCoMKgwqAuYXR0cnMgPSBwY2lfYnJpZGdlX2F0dHJzLA0KPiA+ ICt9Ow0KPiA+ICsNCj4gPiArY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqcGNpX2JyaWRn ZV9ncm91cHNbXSA9IHsNCj4gPiArwqDCoMKgwqDCoMKgwqAmcGNpX2JyaWRnZV9ncm91cCwNCj4g PiArwqDCoMKgwqDCoMKgwqBOVUxMLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArc3RhdGljIGNvbnN0 IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgcGNpZV9kZXZfZ3JvdXAgPSB7DQo+ID4gK8KgwqDCoMKg wqDCoMKgLmF0dHJzID0gcGNpZV9kZXZfYXR0cnMsDQo+ID4gK307DQo+ID4gKw0KPiA+ICtjb25z dCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICpwY2llX2Rldl9ncm91cHNbXSA9IHsNCj4gPiArwqDC oMKgwqDCoMKgwqAmcGNpZV9kZXZfZ3JvdXAsDQo+ID4gK8KgwqDCoMKgwqDCoMKgTlVMTCwNCj4g PiArfTsNCj4gPiArDQo+ID4gwqBzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBwY2lfZGV2 X2hwX2F0dHJfZ3JvdXAgPSB7DQo+ID4gwqDCoMKgwqDCoMKgwqDCoC5hdHRycyA9IHBjaV9kZXZf aHBfYXR0cnMsDQo+ID4gwqDCoMKgwqDCoMKgwqDCoC5pc192aXNpYmxlID0gcGNpX2Rldl9ocF9h dHRyc19hcmVfdmlzaWJsZSwNCj4gPiBAQCAtMTU3NCwxMiArMTc1MSwyNCBAQCBzdGF0aWMgc3Ry dWN0IGF0dHJpYnV0ZV9ncm91cA0KPiA+IHBjaV9kZXZfYXR0cl9ncm91cCA9IHsNCj4gPiDCoMKg wqDCoMKgwqDCoMKgLmlzX3Zpc2libGUgPSBwY2lfZGV2X2F0dHJzX2FyZV92aXNpYmxlLA0KPiA+ IMKgfTsNCj4gPiANCj4gPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgcGNpX2JyaWRn ZV9hdHRyX2dyb3VwID0gew0KPiA+ICvCoMKgwqDCoMKgwqDCoC5hdHRycyA9IHBjaV9icmlkZ2Vf YXR0cnMsDQo+ID4gK8KgwqDCoMKgwqDCoMKgLmlzX3Zpc2libGUgPSBwY2lfYnJpZGdlX2F0dHJz X2FyZV92aXNpYmxlLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1 dGVfZ3JvdXAgcGNpZV9kZXZfYXR0cl9ncm91cCA9IHsNCj4gPiArwqDCoMKgwqDCoMKgwqAuYXR0 cnMgPSBwY2llX2Rldl9hdHRycywNCj4gPiArwqDCoMKgwqDCoMKgwqAuaXNfdmlzaWJsZSA9IHBj aWVfZGV2X2F0dHJzX2FyZV92aXNpYmxlLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiDCoHN0YXRpYyBj b25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICpwY2lfZGV2X2F0dHJfZ3JvdXBzW10gPSB7DQo+ ID4gwqDCoMKgwqDCoMKgwqDCoCZwY2lfZGV2X2F0dHJfZ3JvdXAsDQo+ID4gwqDCoMKgwqDCoMKg wqDCoCZwY2lfZGV2X2hwX2F0dHJfZ3JvdXAsDQo+ID4gwqAjaWZkZWYgQ09ORklHX1BDSV9JT1YN Cj4gPiDCoMKgwqDCoMKgwqDCoMKgJnNyaW92X2Rldl9hdHRyX2dyb3VwLA0KPiA+IMKgI2VuZGlm DQo+ID4gK8KgwqDCoMKgwqDCoMKgJnBjaV9icmlkZ2VfYXR0cl9ncm91cCwNCj4gPiArwqDCoMKg wqDCoMKgwqAmcGNpZV9kZXZfYXR0cl9ncm91cCwNCj4gPiDCoMKgwqDCoMKgwqDCoMKgTlVMTCwN Cj4gPiDCoH07DQo+ID4gDQo+ID4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC9wY2lf cmVncy5oDQo+ID4gYi9pbmNsdWRlL3VhcGkvbGludXgvcGNpX3JlZ3MuaA0KPiA+IGluZGV4IDYz NGM5YzQuLmIxNzcwZGMgMTAwNjQ0DQo+ID4gLS0tIGEvaW5jbHVkZS91YXBpL2xpbnV4L3BjaV9y ZWdzLmgNCj4gPiArKysgYi9pbmNsdWRlL3VhcGkvbGludXgvcGNpX3JlZ3MuaA0KPiA+IEBAIC01 MTcsNiArNTE3LDEwIEBADQo+ID4gwqAjZGVmaW5lwqDCoFBDSV9FWFBfTE5LQ0FQX1NMU8KgwqDC oMKgMHgwMDAwMDAwZiAvKiBTdXBwb3J0ZWQgTGluayBTcGVlZHMNCj4gPiAqLw0KPiA+IMKgI2Rl ZmluZcKgwqBQQ0lfRVhQX0xOS0NBUF9TTFNfMl81R0IgMHgwMDAwMDAwMSAvKiBMTktDQVAyIFNM UyBWZWN0b3INCj4gPiBiaXQgMCAqLw0KPiA+IMKgI2RlZmluZcKgwqBQQ0lfRVhQX0xOS0NBUF9T TFNfNV8wR0IgMHgwMDAwMDAwMiAvKiBMTktDQVAyIFNMUyBWZWN0b3INCj4gPiBiaXQgMSAqLw0K PiA+ICsjZGVmaW5lwqDCoFBDSV9FWFBfTE5LQ0FQX01MU8KgwqDCoMKgMHgwMDAwMDAwZiAvKiBN YXhpbXVtIExpbmsgU3BlZWRzDQo+ID4gKi8NCj4gPiArI2RlZmluZcKgwqBQQ0lfRVhQX0xOS0NB UF9NTFNfMl81R0IgMHgwMDAwMDAwMSAvKiBMTktDQVAyIFNMUyBWZWN0b3INCj4gPiBiaXQgMCAq Lw0KPiA+ICsjZGVmaW5lwqDCoFBDSV9FWFBfTE5LQ0FQX01MU181XzBHQiAweDAwMDAwMDAyIC8q IExOS0NBUDIgU0xTIFZlY3Rvcg0KPiA+IGJpdCAxICovDQo+ID4gKyNkZWZpbmXCoMKgUENJX0VY UF9MTktDQVBfTUxTXzhfMEdCIDB4MDAwMDAwMDMgLyogTE5LQ0FQMiBTTFMgVmVjdG9yDQo+ID4g Yml0IDIgKi8NCj4gUmF0aGVyIHRoYW4gYWRkaW5nIHRoZXNlIF9NTFNfIHN5bWJvbHMgYXMgZHVw bGljYXRlcyBvZiBfU0xTXywgcGxlYXNlDQo+IGp1c3QgYWRkIG9uZSBTTFNfOF8wR0Igc3ltYm9s Lg0KPiANCj4gVGhlIF9TTFNfIG5hbWVzIGFyZSBhbiBhcnRpZmFjdCBvZiB0aGUgZmFjdCB0aGF0 IHByaW9yIHRvIFBDSWUgcjMuMCwNCj4gdGhpcyBmaWVsZCB3YXMgdGhlICJTdXBwb3J0ZWQgTGlu ayBTcGVlZHMiIGZpZWxkLsKgwqBQQ0llIDMuMCByZW5hbWVkDQo+IGl0DQo+IHRvICJNYXggTGlu ayBTcGVlZCIgYW5kIGFkZGVkIHRoZSAiU3VwcG9ydGVkIExpbmsgU3BlZWRzIFZlY3RvciIgaW4N Cj4gdGhlIG5ldyBMaW5rIENhcGFiaWxpdGllcyAyIHJlZ2lzdGVyLg0KPiANCj4gPiANCj4gPiDC oCNkZWZpbmXCoMKgUENJX0VYUF9MTktDQVBfTUxXwqDCoMKgwqAweDAwMDAwM2YwIC8qIE1heGlt dW0gTGluayBXaWR0aCAqLw0KPiA+IMKgI2RlZmluZcKgwqBQQ0lfRVhQX0xOS0NBUF9BU1BNU8Kg wqAweDAwMDAwYzAwIC8qIEFTUE0gU3VwcG9ydCAqLw0KPiA+IMKgI2RlZmluZcKgwqBQQ0lfRVhQ X0xOS0NBUF9MMFNFTMKgwqAweDAwMDA3MDAwIC8qIEwwcyBFeGl0IExhdGVuY3kgKi8NCj4gPiAt LQ0KPiA+IDIuNy40DQo+ID4g ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] pci-sysfs: Make PCI bridge attribute visible in sysfs 2017-05-04 7:32 ` Vee Khee Wong @ 2017-05-04 12:58 ` Bjorn Helgaas 0 siblings, 0 replies; 4+ messages in thread From: Bjorn Helgaas @ 2017-05-04 12:58 UTC (permalink / raw) To: Vee Khee Wong Cc: linux-kernel@vger.kernel.org, Jonathan Hearn, Ram.Amrani@cavium.com, Hui Chun Ong, shhuiw@foxmail.com, rajatja@google.com, linux-pci@vger.kernel.org, keith.busch@intel.com, jonathan.yong@intel.com On Thu, May 4, 2017 at 2:32 AM, Vee Khee Wong <vee.khee.wong@ni.com> wrote: > > > On Mon, 2017-04-17 at 10:41 -0500, Bjorn Helgaas wrote: >> On Mon, Apr 17, 2017 at 12:50 AM, Wong Vee Khee <vee.khee.wong@ni.com >> > wrote: >> > >> > From: vwong <vee.khee.wong@ni.com> >> > >> > Export the PCIe link attributes of PCI bridges to sysfs. >> This needs justification for *why* we should export these via sysfs. >> >> Some of these things, e.g., secondary/subordinate bus numbers, are >> already visible to non-privileged users via "lspci -v". >> > We need to expose these attributes via sysfs due to several reasons > listed below: > > 1) PCIe capabilities info such as Maximum/Actual link width and link speed only visible to privileged users via "lspci -vvv". The software that my team is working on need to get PCIe link information as non-root user. > > 2) From a client perspective, it require a lot of overhead parsing output of lspci to get PCIe capabilities. Our application is only interested in getting PCIe bridges but lspci print info for all PCIe devices. I'm looking for a revised patch that incorporates the justification in the changelog and addresses the code comments I made. Bjorn ^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2017-05-04 12:59 UTC | newest] Thread overview: 4+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2017-04-17 5:50 [PATCH] pci-sysfs: Make PCI bridge attribute visible in sysfs Wong Vee Khee 2017-04-17 15:41 ` Bjorn Helgaas 2017-05-04 7:32 ` Vee Khee Wong 2017-05-04 12:58 ` Bjorn Helgaas
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).