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