1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Purpose: Export the firmware instance and label associated with 4 * a pci device to sysfs 5 * Copyright (C) 2010 Dell Inc. 6 * by Narendra K <Narendra_K@dell.com>, 7 * Jordan Hargrave <Jordan_Hargrave@dell.com> 8 * 9 * PCI Firmware Specification Revision 3.1 section 4.6.7 (DSM for Naming a 10 * PCI or PCI Express Device Under Operating Systems) defines an instance 11 * number and string name. This code retrieves them and exports them to sysfs. 12 * If the system firmware does not provide the ACPI _DSM (Device Specific 13 * Method), then the SMBIOS type 41 instance number and string is exported to 14 * sysfs. 15 * 16 * SMBIOS defines type 41 for onboard pci devices. This code retrieves 17 * the instance number and string from the type 41 record and exports 18 * it to sysfs. 19 * 20 * Please see http://linux.dell.com/files/biosdevname/ for more 21 * information. 22 */ 23 24 #include <linux/dmi.h> 25 #include <linux/sysfs.h> 26 #include <linux/pci.h> 27 #include <linux/pci_ids.h> 28 #include <linux/module.h> 29 #include <linux/device.h> 30 #include <linux/nls.h> 31 #include <linux/acpi.h> 32 #include <linux/pci-acpi.h> 33 #include "pci.h" 34 35 #ifdef CONFIG_DMI 36 enum smbios_attr_enum { 37 SMBIOS_ATTR_NONE = 0, 38 SMBIOS_ATTR_LABEL_SHOW, 39 SMBIOS_ATTR_INSTANCE_SHOW, 40 }; 41 42 static size_t find_smbios_instance_string(struct pci_dev *pdev, char *buf, 43 enum smbios_attr_enum attribute) 44 { 45 const struct dmi_device *dmi; 46 struct dmi_dev_onboard *donboard; 47 int domain_nr; 48 int bus; 49 int devfn; 50 51 domain_nr = pci_domain_nr(pdev->bus); 52 bus = pdev->bus->number; 53 devfn = pdev->devfn; 54 55 dmi = NULL; 56 while ((dmi = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, 57 NULL, dmi)) != NULL) { 58 donboard = dmi->device_data; 59 if (donboard && donboard->segment == domain_nr && 60 donboard->bus == bus && 61 donboard->devfn == devfn) { 62 if (buf) { 63 if (attribute == SMBIOS_ATTR_INSTANCE_SHOW) 64 return scnprintf(buf, PAGE_SIZE, 65 "%d\n", 66 donboard->instance); 67 else if (attribute == SMBIOS_ATTR_LABEL_SHOW) 68 return scnprintf(buf, PAGE_SIZE, 69 "%s\n", 70 dmi->name); 71 } 72 return strlen(dmi->name); 73 } 74 } 75 return 0; 76 } 77 78 static umode_t smbios_instance_string_exist(struct kobject *kobj, 79 struct attribute *attr, int n) 80 { 81 struct device *dev; 82 struct pci_dev *pdev; 83 84 dev = kobj_to_dev(kobj); 85 pdev = to_pci_dev(dev); 86 87 return find_smbios_instance_string(pdev, NULL, SMBIOS_ATTR_NONE) ? 88 S_IRUGO : 0; 89 } 90 91 static ssize_t smbioslabel_show(struct device *dev, 92 struct device_attribute *attr, char *buf) 93 { 94 struct pci_dev *pdev; 95 pdev = to_pci_dev(dev); 96 97 return find_smbios_instance_string(pdev, buf, 98 SMBIOS_ATTR_LABEL_SHOW); 99 } 100 101 static ssize_t smbiosinstance_show(struct device *dev, 102 struct device_attribute *attr, char *buf) 103 { 104 struct pci_dev *pdev; 105 pdev = to_pci_dev(dev); 106 107 return find_smbios_instance_string(pdev, buf, 108 SMBIOS_ATTR_INSTANCE_SHOW); 109 } 110 111 static struct device_attribute smbios_attr_label = { 112 .attr = {.name = "label", .mode = 0444}, 113 .show = smbioslabel_show, 114 }; 115 116 static struct device_attribute smbios_attr_instance = { 117 .attr = {.name = "index", .mode = 0444}, 118 .show = smbiosinstance_show, 119 }; 120 121 static struct attribute *smbios_attributes[] = { 122 &smbios_attr_label.attr, 123 &smbios_attr_instance.attr, 124 NULL, 125 }; 126 127 static const struct attribute_group smbios_attr_group = { 128 .attrs = smbios_attributes, 129 .is_visible = smbios_instance_string_exist, 130 }; 131 132 static int pci_create_smbiosname_file(struct pci_dev *pdev) 133 { 134 return sysfs_create_group(&pdev->dev.kobj, &smbios_attr_group); 135 } 136 137 static void pci_remove_smbiosname_file(struct pci_dev *pdev) 138 { 139 sysfs_remove_group(&pdev->dev.kobj, &smbios_attr_group); 140 } 141 #else 142 static inline int pci_create_smbiosname_file(struct pci_dev *pdev) 143 { 144 return -1; 145 } 146 147 static inline void pci_remove_smbiosname_file(struct pci_dev *pdev) 148 { 149 } 150 #endif 151 152 #ifdef CONFIG_ACPI 153 enum acpi_attr_enum { 154 ACPI_ATTR_LABEL_SHOW, 155 ACPI_ATTR_INDEX_SHOW, 156 }; 157 158 static void dsm_label_utf16s_to_utf8s(union acpi_object *obj, char *buf) 159 { 160 int len; 161 len = utf16s_to_utf8s((const wchar_t *)obj->buffer.pointer, 162 obj->buffer.length, 163 UTF16_LITTLE_ENDIAN, 164 buf, PAGE_SIZE); 165 buf[len] = '\n'; 166 } 167 168 static int dsm_get_label(struct device *dev, char *buf, 169 enum acpi_attr_enum attr) 170 { 171 acpi_handle handle; 172 union acpi_object *obj, *tmp; 173 int len = -1; 174 175 handle = ACPI_HANDLE(dev); 176 if (!handle) 177 return -1; 178 179 obj = acpi_evaluate_dsm(handle, &pci_acpi_dsm_guid, 0x2, 180 DEVICE_LABEL_DSM, NULL); 181 if (!obj) 182 return -1; 183 184 tmp = obj->package.elements; 185 if (obj->type == ACPI_TYPE_PACKAGE && obj->package.count == 2 && 186 tmp[0].type == ACPI_TYPE_INTEGER && 187 (tmp[1].type == ACPI_TYPE_STRING || 188 tmp[1].type == ACPI_TYPE_BUFFER)) { 189 /* 190 * The second string element is optional even when 191 * this _DSM is implemented; when not implemented, 192 * this entry must return a null string. 193 */ 194 if (attr == ACPI_ATTR_INDEX_SHOW) { 195 scnprintf(buf, PAGE_SIZE, "%llu\n", tmp->integer.value); 196 } else if (attr == ACPI_ATTR_LABEL_SHOW) { 197 if (tmp[1].type == ACPI_TYPE_STRING) 198 scnprintf(buf, PAGE_SIZE, "%s\n", 199 tmp[1].string.pointer); 200 else if (tmp[1].type == ACPI_TYPE_BUFFER) 201 dsm_label_utf16s_to_utf8s(tmp + 1, buf); 202 } 203 len = strlen(buf) > 0 ? strlen(buf) : -1; 204 } 205 206 ACPI_FREE(obj); 207 208 return len; 209 } 210 211 static bool device_has_dsm(struct device *dev) 212 { 213 acpi_handle handle; 214 215 handle = ACPI_HANDLE(dev); 216 if (!handle) 217 return false; 218 219 return !!acpi_check_dsm(handle, &pci_acpi_dsm_guid, 0x2, 220 1 << DEVICE_LABEL_DSM); 221 } 222 223 static umode_t acpi_index_string_exist(struct kobject *kobj, 224 struct attribute *attr, int n) 225 { 226 struct device *dev; 227 228 dev = kobj_to_dev(kobj); 229 230 if (device_has_dsm(dev)) 231 return S_IRUGO; 232 233 return 0; 234 } 235 236 static ssize_t acpilabel_show(struct device *dev, 237 struct device_attribute *attr, char *buf) 238 { 239 return dsm_get_label(dev, buf, ACPI_ATTR_LABEL_SHOW); 240 } 241 242 static ssize_t acpiindex_show(struct device *dev, 243 struct device_attribute *attr, char *buf) 244 { 245 return dsm_get_label(dev, buf, ACPI_ATTR_INDEX_SHOW); 246 } 247 248 static struct device_attribute acpi_attr_label = { 249 .attr = {.name = "label", .mode = 0444}, 250 .show = acpilabel_show, 251 }; 252 253 static struct device_attribute acpi_attr_index = { 254 .attr = {.name = "acpi_index", .mode = 0444}, 255 .show = acpiindex_show, 256 }; 257 258 static struct attribute *acpi_attributes[] = { 259 &acpi_attr_label.attr, 260 &acpi_attr_index.attr, 261 NULL, 262 }; 263 264 static const struct attribute_group acpi_attr_group = { 265 .attrs = acpi_attributes, 266 .is_visible = acpi_index_string_exist, 267 }; 268 269 static int pci_create_acpi_index_label_files(struct pci_dev *pdev) 270 { 271 return sysfs_create_group(&pdev->dev.kobj, &acpi_attr_group); 272 } 273 274 static int pci_remove_acpi_index_label_files(struct pci_dev *pdev) 275 { 276 sysfs_remove_group(&pdev->dev.kobj, &acpi_attr_group); 277 return 0; 278 } 279 #else 280 static inline int pci_create_acpi_index_label_files(struct pci_dev *pdev) 281 { 282 return -1; 283 } 284 285 static inline int pci_remove_acpi_index_label_files(struct pci_dev *pdev) 286 { 287 return -1; 288 } 289 290 static inline bool device_has_dsm(struct device *dev) 291 { 292 return false; 293 } 294 #endif 295 296 void pci_create_firmware_label_files(struct pci_dev *pdev) 297 { 298 if (device_has_dsm(&pdev->dev)) 299 pci_create_acpi_index_label_files(pdev); 300 else 301 pci_create_smbiosname_file(pdev); 302 } 303 304 void pci_remove_firmware_label_files(struct pci_dev *pdev) 305 { 306 if (device_has_dsm(&pdev->dev)) 307 pci_remove_acpi_index_label_files(pdev); 308 else 309 pci_remove_smbiosname_file(pdev); 310 } 311