xref: /openbmc/linux/drivers/pci/pci-sysfs.c (revision 4f205687)
1 /*
2  * drivers/pci/pci-sysfs.c
3  *
4  * (C) Copyright 2002-2004 Greg Kroah-Hartman <greg@kroah.com>
5  * (C) Copyright 2002-2004 IBM Corp.
6  * (C) Copyright 2003 Matthew Wilcox
7  * (C) Copyright 2003 Hewlett-Packard
8  * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com>
9  * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com>
10  *
11  * File attributes for PCI devices
12  *
13  * Modeled after usb's driverfs.c
14  *
15  */
16 
17 
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/pci.h>
21 #include <linux/stat.h>
22 #include <linux/export.h>
23 #include <linux/topology.h>
24 #include <linux/mm.h>
25 #include <linux/fs.h>
26 #include <linux/capability.h>
27 #include <linux/security.h>
28 #include <linux/pci-aspm.h>
29 #include <linux/slab.h>
30 #include <linux/vgaarb.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/of.h>
33 #include "pci.h"
34 
35 static int sysfs_initialized;	/* = 0 */
36 
37 /* show configuration fields */
38 #define pci_config_attr(field, format_string)				\
39 static ssize_t								\
40 field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
41 {									\
42 	struct pci_dev *pdev;						\
43 									\
44 	pdev = to_pci_dev(dev);						\
45 	return sprintf(buf, format_string, pdev->field);		\
46 }									\
47 static DEVICE_ATTR_RO(field)
48 
49 pci_config_attr(vendor, "0x%04x\n");
50 pci_config_attr(device, "0x%04x\n");
51 pci_config_attr(subsystem_vendor, "0x%04x\n");
52 pci_config_attr(subsystem_device, "0x%04x\n");
53 pci_config_attr(class, "0x%06x\n");
54 pci_config_attr(irq, "%u\n");
55 
56 static ssize_t broken_parity_status_show(struct device *dev,
57 					 struct device_attribute *attr,
58 					 char *buf)
59 {
60 	struct pci_dev *pdev = to_pci_dev(dev);
61 	return sprintf(buf, "%u\n", pdev->broken_parity_status);
62 }
63 
64 static ssize_t broken_parity_status_store(struct device *dev,
65 					  struct device_attribute *attr,
66 					  const char *buf, size_t count)
67 {
68 	struct pci_dev *pdev = to_pci_dev(dev);
69 	unsigned long val;
70 
71 	if (kstrtoul(buf, 0, &val) < 0)
72 		return -EINVAL;
73 
74 	pdev->broken_parity_status = !!val;
75 
76 	return count;
77 }
78 static DEVICE_ATTR_RW(broken_parity_status);
79 
80 static ssize_t pci_dev_show_local_cpu(struct device *dev, bool list,
81 				      struct device_attribute *attr, char *buf)
82 {
83 	const struct cpumask *mask;
84 
85 #ifdef CONFIG_NUMA
86 	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
87 					  cpumask_of_node(dev_to_node(dev));
88 #else
89 	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
90 #endif
91 	return cpumap_print_to_pagebuf(list, buf, mask);
92 }
93 
94 static ssize_t local_cpus_show(struct device *dev,
95 			       struct device_attribute *attr, char *buf)
96 {
97 	return pci_dev_show_local_cpu(dev, false, attr, buf);
98 }
99 static DEVICE_ATTR_RO(local_cpus);
100 
101 static ssize_t local_cpulist_show(struct device *dev,
102 				  struct device_attribute *attr, char *buf)
103 {
104 	return pci_dev_show_local_cpu(dev, true, attr, buf);
105 }
106 static DEVICE_ATTR_RO(local_cpulist);
107 
108 /*
109  * PCI Bus Class Devices
110  */
111 static ssize_t cpuaffinity_show(struct device *dev,
112 				struct device_attribute *attr, char *buf)
113 {
114 	const struct cpumask *cpumask = cpumask_of_pcibus(to_pci_bus(dev));
115 
116 	return cpumap_print_to_pagebuf(false, buf, cpumask);
117 }
118 static DEVICE_ATTR_RO(cpuaffinity);
119 
120 static ssize_t cpulistaffinity_show(struct device *dev,
121 				    struct device_attribute *attr, char *buf)
122 {
123 	const struct cpumask *cpumask = cpumask_of_pcibus(to_pci_bus(dev));
124 
125 	return cpumap_print_to_pagebuf(true, buf, cpumask);
126 }
127 static DEVICE_ATTR_RO(cpulistaffinity);
128 
129 /* show resources */
130 static ssize_t resource_show(struct device *dev, struct device_attribute *attr,
131 			     char *buf)
132 {
133 	struct pci_dev *pci_dev = to_pci_dev(dev);
134 	char *str = buf;
135 	int i;
136 	int max;
137 	resource_size_t start, end;
138 
139 	if (pci_dev->subordinate)
140 		max = DEVICE_COUNT_RESOURCE;
141 	else
142 		max = PCI_BRIDGE_RESOURCES;
143 
144 	for (i = 0; i < max; i++) {
145 		struct resource *res =  &pci_dev->resource[i];
146 		pci_resource_to_user(pci_dev, i, res, &start, &end);
147 		str += sprintf(str, "0x%016llx 0x%016llx 0x%016llx\n",
148 			       (unsigned long long)start,
149 			       (unsigned long long)end,
150 			       (unsigned long long)res->flags);
151 	}
152 	return (str - buf);
153 }
154 static DEVICE_ATTR_RO(resource);
155 
156 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
157 			     char *buf)
158 {
159 	struct pci_dev *pci_dev = to_pci_dev(dev);
160 
161 	return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X\n",
162 		       pci_dev->vendor, pci_dev->device,
163 		       pci_dev->subsystem_vendor, pci_dev->subsystem_device,
164 		       (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
165 		       (u8)(pci_dev->class));
166 }
167 static DEVICE_ATTR_RO(modalias);
168 
169 static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
170 			     const char *buf, size_t count)
171 {
172 	struct pci_dev *pdev = to_pci_dev(dev);
173 	unsigned long val;
174 	ssize_t result = kstrtoul(buf, 0, &val);
175 
176 	if (result < 0)
177 		return result;
178 
179 	/* this can crash the machine when done on the "wrong" device */
180 	if (!capable(CAP_SYS_ADMIN))
181 		return -EPERM;
182 
183 	if (!val) {
184 		if (pci_is_enabled(pdev))
185 			pci_disable_device(pdev);
186 		else
187 			result = -EIO;
188 	} else
189 		result = pci_enable_device(pdev);
190 
191 	return result < 0 ? result : count;
192 }
193 
194 static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
195 			    char *buf)
196 {
197 	struct pci_dev *pdev;
198 
199 	pdev = to_pci_dev(dev);
200 	return sprintf(buf, "%u\n", atomic_read(&pdev->enable_cnt));
201 }
202 static DEVICE_ATTR_RW(enable);
203 
204 #ifdef CONFIG_NUMA
205 static ssize_t numa_node_store(struct device *dev,
206 			       struct device_attribute *attr, const char *buf,
207 			       size_t count)
208 {
209 	struct pci_dev *pdev = to_pci_dev(dev);
210 	int node, ret;
211 
212 	if (!capable(CAP_SYS_ADMIN))
213 		return -EPERM;
214 
215 	ret = kstrtoint(buf, 0, &node);
216 	if (ret)
217 		return ret;
218 
219 	if ((node < 0 && node != NUMA_NO_NODE) || node >= MAX_NUMNODES)
220 		return -EINVAL;
221 
222 	if (node != NUMA_NO_NODE && !node_online(node))
223 		return -EINVAL;
224 
225 	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
226 	dev_alert(&pdev->dev, FW_BUG "Overriding NUMA node to %d.  Contact your vendor for updates.",
227 		  node);
228 
229 	dev->numa_node = node;
230 	return count;
231 }
232 
233 static ssize_t numa_node_show(struct device *dev, struct device_attribute *attr,
234 			      char *buf)
235 {
236 	return sprintf(buf, "%d\n", dev->numa_node);
237 }
238 static DEVICE_ATTR_RW(numa_node);
239 #endif
240 
241 static ssize_t dma_mask_bits_show(struct device *dev,
242 				  struct device_attribute *attr, char *buf)
243 {
244 	struct pci_dev *pdev = to_pci_dev(dev);
245 
246 	return sprintf(buf, "%d\n", fls64(pdev->dma_mask));
247 }
248 static DEVICE_ATTR_RO(dma_mask_bits);
249 
250 static ssize_t consistent_dma_mask_bits_show(struct device *dev,
251 					     struct device_attribute *attr,
252 					     char *buf)
253 {
254 	return sprintf(buf, "%d\n", fls64(dev->coherent_dma_mask));
255 }
256 static DEVICE_ATTR_RO(consistent_dma_mask_bits);
257 
258 static ssize_t msi_bus_show(struct device *dev, struct device_attribute *attr,
259 			    char *buf)
260 {
261 	struct pci_dev *pdev = to_pci_dev(dev);
262 	struct pci_bus *subordinate = pdev->subordinate;
263 
264 	return sprintf(buf, "%u\n", subordinate ?
265 		       !(subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI)
266 			   : !pdev->no_msi);
267 }
268 
269 static ssize_t msi_bus_store(struct device *dev, struct device_attribute *attr,
270 			     const char *buf, size_t count)
271 {
272 	struct pci_dev *pdev = to_pci_dev(dev);
273 	struct pci_bus *subordinate = pdev->subordinate;
274 	unsigned long val;
275 
276 	if (kstrtoul(buf, 0, &val) < 0)
277 		return -EINVAL;
278 
279 	if (!capable(CAP_SYS_ADMIN))
280 		return -EPERM;
281 
282 	/*
283 	 * "no_msi" and "bus_flags" only affect what happens when a driver
284 	 * requests MSI or MSI-X.  They don't affect any drivers that have
285 	 * already requested MSI or MSI-X.
286 	 */
287 	if (!subordinate) {
288 		pdev->no_msi = !val;
289 		dev_info(&pdev->dev, "MSI/MSI-X %s for future drivers\n",
290 			 val ? "allowed" : "disallowed");
291 		return count;
292 	}
293 
294 	if (val)
295 		subordinate->bus_flags &= ~PCI_BUS_FLAGS_NO_MSI;
296 	else
297 		subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MSI;
298 
299 	dev_info(&subordinate->dev, "MSI/MSI-X %s for future drivers of devices on this bus\n",
300 		 val ? "allowed" : "disallowed");
301 	return count;
302 }
303 static DEVICE_ATTR_RW(msi_bus);
304 
305 static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
306 				size_t count)
307 {
308 	unsigned long val;
309 	struct pci_bus *b = NULL;
310 
311 	if (kstrtoul(buf, 0, &val) < 0)
312 		return -EINVAL;
313 
314 	if (val) {
315 		pci_lock_rescan_remove();
316 		while ((b = pci_find_next_bus(b)) != NULL)
317 			pci_rescan_bus(b);
318 		pci_unlock_rescan_remove();
319 	}
320 	return count;
321 }
322 static BUS_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store);
323 
324 static struct attribute *pci_bus_attrs[] = {
325 	&bus_attr_rescan.attr,
326 	NULL,
327 };
328 
329 static const struct attribute_group pci_bus_group = {
330 	.attrs = pci_bus_attrs,
331 };
332 
333 const struct attribute_group *pci_bus_groups[] = {
334 	&pci_bus_group,
335 	NULL,
336 };
337 
338 static ssize_t dev_rescan_store(struct device *dev,
339 				struct device_attribute *attr, const char *buf,
340 				size_t count)
341 {
342 	unsigned long val;
343 	struct pci_dev *pdev = to_pci_dev(dev);
344 
345 	if (kstrtoul(buf, 0, &val) < 0)
346 		return -EINVAL;
347 
348 	if (val) {
349 		pci_lock_rescan_remove();
350 		pci_rescan_bus(pdev->bus);
351 		pci_unlock_rescan_remove();
352 	}
353 	return count;
354 }
355 static struct device_attribute dev_rescan_attr = __ATTR(rescan,
356 							(S_IWUSR|S_IWGRP),
357 							NULL, dev_rescan_store);
358 
359 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
360 			    const char *buf, size_t count)
361 {
362 	unsigned long val;
363 
364 	if (kstrtoul(buf, 0, &val) < 0)
365 		return -EINVAL;
366 
367 	if (val && device_remove_file_self(dev, attr))
368 		pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));
369 	return count;
370 }
371 static struct device_attribute dev_remove_attr = __ATTR(remove,
372 							(S_IWUSR|S_IWGRP),
373 							NULL, remove_store);
374 
375 static ssize_t dev_bus_rescan_store(struct device *dev,
376 				    struct device_attribute *attr,
377 				    const char *buf, size_t count)
378 {
379 	unsigned long val;
380 	struct pci_bus *bus = to_pci_bus(dev);
381 
382 	if (kstrtoul(buf, 0, &val) < 0)
383 		return -EINVAL;
384 
385 	if (val) {
386 		pci_lock_rescan_remove();
387 		if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
388 			pci_rescan_bus_bridge_resize(bus->self);
389 		else
390 			pci_rescan_bus(bus);
391 		pci_unlock_rescan_remove();
392 	}
393 	return count;
394 }
395 static DEVICE_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store);
396 
397 #if defined(CONFIG_PM) && defined(CONFIG_ACPI)
398 static ssize_t d3cold_allowed_store(struct device *dev,
399 				    struct device_attribute *attr,
400 				    const char *buf, size_t count)
401 {
402 	struct pci_dev *pdev = to_pci_dev(dev);
403 	unsigned long val;
404 
405 	if (kstrtoul(buf, 0, &val) < 0)
406 		return -EINVAL;
407 
408 	pdev->d3cold_allowed = !!val;
409 	pm_runtime_resume(dev);
410 
411 	return count;
412 }
413 
414 static ssize_t d3cold_allowed_show(struct device *dev,
415 				   struct device_attribute *attr, char *buf)
416 {
417 	struct pci_dev *pdev = to_pci_dev(dev);
418 	return sprintf(buf, "%u\n", pdev->d3cold_allowed);
419 }
420 static DEVICE_ATTR_RW(d3cold_allowed);
421 #endif
422 
423 #ifdef CONFIG_OF
424 static ssize_t devspec_show(struct device *dev,
425 			    struct device_attribute *attr, char *buf)
426 {
427 	struct pci_dev *pdev = to_pci_dev(dev);
428 	struct device_node *np = pci_device_to_OF_node(pdev);
429 
430 	if (np == NULL || np->full_name == NULL)
431 		return 0;
432 	return sprintf(buf, "%s", np->full_name);
433 }
434 static DEVICE_ATTR_RO(devspec);
435 #endif
436 
437 #ifdef CONFIG_PCI_IOV
438 static ssize_t sriov_totalvfs_show(struct device *dev,
439 				   struct device_attribute *attr,
440 				   char *buf)
441 {
442 	struct pci_dev *pdev = to_pci_dev(dev);
443 
444 	return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));
445 }
446 
447 
448 static ssize_t sriov_numvfs_show(struct device *dev,
449 				 struct device_attribute *attr,
450 				 char *buf)
451 {
452 	struct pci_dev *pdev = to_pci_dev(dev);
453 
454 	return sprintf(buf, "%u\n", pdev->sriov->num_VFs);
455 }
456 
457 /*
458  * num_vfs > 0; number of VFs to enable
459  * num_vfs = 0; disable all VFs
460  *
461  * Note: SRIOV spec doesn't allow partial VF
462  *       disable, so it's all or none.
463  */
464 static ssize_t sriov_numvfs_store(struct device *dev,
465 				  struct device_attribute *attr,
466 				  const char *buf, size_t count)
467 {
468 	struct pci_dev *pdev = to_pci_dev(dev);
469 	int ret;
470 	u16 num_vfs;
471 
472 	ret = kstrtou16(buf, 0, &num_vfs);
473 	if (ret < 0)
474 		return ret;
475 
476 	if (num_vfs > pci_sriov_get_totalvfs(pdev))
477 		return -ERANGE;
478 
479 	if (num_vfs == pdev->sriov->num_VFs)
480 		return count;		/* no change */
481 
482 	/* is PF driver loaded w/callback */
483 	if (!pdev->driver || !pdev->driver->sriov_configure) {
484 		dev_info(&pdev->dev, "Driver doesn't support SRIOV configuration via sysfs\n");
485 		return -ENOSYS;
486 	}
487 
488 	if (num_vfs == 0) {
489 		/* disable VFs */
490 		ret = pdev->driver->sriov_configure(pdev, 0);
491 		if (ret < 0)
492 			return ret;
493 		return count;
494 	}
495 
496 	/* enable VFs */
497 	if (pdev->sriov->num_VFs) {
498 		dev_warn(&pdev->dev, "%d VFs already enabled. Disable before enabling %d VFs\n",
499 			 pdev->sriov->num_VFs, num_vfs);
500 		return -EBUSY;
501 	}
502 
503 	ret = pdev->driver->sriov_configure(pdev, num_vfs);
504 	if (ret < 0)
505 		return ret;
506 
507 	if (ret != num_vfs)
508 		dev_warn(&pdev->dev, "%d VFs requested; only %d enabled\n",
509 			 num_vfs, ret);
510 
511 	return count;
512 }
513 
514 static struct device_attribute sriov_totalvfs_attr = __ATTR_RO(sriov_totalvfs);
515 static struct device_attribute sriov_numvfs_attr =
516 		__ATTR(sriov_numvfs, (S_IRUGO|S_IWUSR|S_IWGRP),
517 		       sriov_numvfs_show, sriov_numvfs_store);
518 #endif /* CONFIG_PCI_IOV */
519 
520 static ssize_t driver_override_store(struct device *dev,
521 				     struct device_attribute *attr,
522 				     const char *buf, size_t count)
523 {
524 	struct pci_dev *pdev = to_pci_dev(dev);
525 	char *driver_override, *old = pdev->driver_override, *cp;
526 
527 	/* We need to keep extra room for a newline */
528 	if (count >= (PAGE_SIZE - 1))
529 		return -EINVAL;
530 
531 	driver_override = kstrndup(buf, count, GFP_KERNEL);
532 	if (!driver_override)
533 		return -ENOMEM;
534 
535 	cp = strchr(driver_override, '\n');
536 	if (cp)
537 		*cp = '\0';
538 
539 	if (strlen(driver_override)) {
540 		pdev->driver_override = driver_override;
541 	} else {
542 		kfree(driver_override);
543 		pdev->driver_override = NULL;
544 	}
545 
546 	kfree(old);
547 
548 	return count;
549 }
550 
551 static ssize_t driver_override_show(struct device *dev,
552 				    struct device_attribute *attr, char *buf)
553 {
554 	struct pci_dev *pdev = to_pci_dev(dev);
555 
556 	return snprintf(buf, PAGE_SIZE, "%s\n", pdev->driver_override);
557 }
558 static DEVICE_ATTR_RW(driver_override);
559 
560 static struct attribute *pci_dev_attrs[] = {
561 	&dev_attr_resource.attr,
562 	&dev_attr_vendor.attr,
563 	&dev_attr_device.attr,
564 	&dev_attr_subsystem_vendor.attr,
565 	&dev_attr_subsystem_device.attr,
566 	&dev_attr_class.attr,
567 	&dev_attr_irq.attr,
568 	&dev_attr_local_cpus.attr,
569 	&dev_attr_local_cpulist.attr,
570 	&dev_attr_modalias.attr,
571 #ifdef CONFIG_NUMA
572 	&dev_attr_numa_node.attr,
573 #endif
574 	&dev_attr_dma_mask_bits.attr,
575 	&dev_attr_consistent_dma_mask_bits.attr,
576 	&dev_attr_enable.attr,
577 	&dev_attr_broken_parity_status.attr,
578 	&dev_attr_msi_bus.attr,
579 #if defined(CONFIG_PM) && defined(CONFIG_ACPI)
580 	&dev_attr_d3cold_allowed.attr,
581 #endif
582 #ifdef CONFIG_OF
583 	&dev_attr_devspec.attr,
584 #endif
585 	&dev_attr_driver_override.attr,
586 	NULL,
587 };
588 
589 static const struct attribute_group pci_dev_group = {
590 	.attrs = pci_dev_attrs,
591 };
592 
593 const struct attribute_group *pci_dev_groups[] = {
594 	&pci_dev_group,
595 	NULL,
596 };
597 
598 static struct attribute *pcibus_attrs[] = {
599 	&dev_attr_rescan.attr,
600 	&dev_attr_cpuaffinity.attr,
601 	&dev_attr_cpulistaffinity.attr,
602 	NULL,
603 };
604 
605 static const struct attribute_group pcibus_group = {
606 	.attrs = pcibus_attrs,
607 };
608 
609 const struct attribute_group *pcibus_groups[] = {
610 	&pcibus_group,
611 	NULL,
612 };
613 
614 static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr,
615 			     char *buf)
616 {
617 	struct pci_dev *pdev = to_pci_dev(dev);
618 	struct pci_dev *vga_dev = vga_default_device();
619 
620 	if (vga_dev)
621 		return sprintf(buf, "%u\n", (pdev == vga_dev));
622 
623 	return sprintf(buf, "%u\n",
624 		!!(pdev->resource[PCI_ROM_RESOURCE].flags &
625 		   IORESOURCE_ROM_SHADOW));
626 }
627 static struct device_attribute vga_attr = __ATTR_RO(boot_vga);
628 
629 static ssize_t pci_read_config(struct file *filp, struct kobject *kobj,
630 			       struct bin_attribute *bin_attr, char *buf,
631 			       loff_t off, size_t count)
632 {
633 	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
634 	unsigned int size = 64;
635 	loff_t init_off = off;
636 	u8 *data = (u8 *) buf;
637 
638 	/* Several chips lock up trying to read undefined config space */
639 	if (file_ns_capable(filp, &init_user_ns, CAP_SYS_ADMIN))
640 		size = dev->cfg_size;
641 	else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
642 		size = 128;
643 
644 	if (off > size)
645 		return 0;
646 	if (off + count > size) {
647 		size -= off;
648 		count = size;
649 	} else {
650 		size = count;
651 	}
652 
653 	pci_config_pm_runtime_get(dev);
654 
655 	if ((off & 1) && size) {
656 		u8 val;
657 		pci_user_read_config_byte(dev, off, &val);
658 		data[off - init_off] = val;
659 		off++;
660 		size--;
661 	}
662 
663 	if ((off & 3) && size > 2) {
664 		u16 val;
665 		pci_user_read_config_word(dev, off, &val);
666 		data[off - init_off] = val & 0xff;
667 		data[off - init_off + 1] = (val >> 8) & 0xff;
668 		off += 2;
669 		size -= 2;
670 	}
671 
672 	while (size > 3) {
673 		u32 val;
674 		pci_user_read_config_dword(dev, off, &val);
675 		data[off - init_off] = val & 0xff;
676 		data[off - init_off + 1] = (val >> 8) & 0xff;
677 		data[off - init_off + 2] = (val >> 16) & 0xff;
678 		data[off - init_off + 3] = (val >> 24) & 0xff;
679 		off += 4;
680 		size -= 4;
681 	}
682 
683 	if (size >= 2) {
684 		u16 val;
685 		pci_user_read_config_word(dev, off, &val);
686 		data[off - init_off] = val & 0xff;
687 		data[off - init_off + 1] = (val >> 8) & 0xff;
688 		off += 2;
689 		size -= 2;
690 	}
691 
692 	if (size > 0) {
693 		u8 val;
694 		pci_user_read_config_byte(dev, off, &val);
695 		data[off - init_off] = val;
696 		off++;
697 		--size;
698 	}
699 
700 	pci_config_pm_runtime_put(dev);
701 
702 	return count;
703 }
704 
705 static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,
706 				struct bin_attribute *bin_attr, char *buf,
707 				loff_t off, size_t count)
708 {
709 	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
710 	unsigned int size = count;
711 	loff_t init_off = off;
712 	u8 *data = (u8 *) buf;
713 
714 	if (off > dev->cfg_size)
715 		return 0;
716 	if (off + count > dev->cfg_size) {
717 		size = dev->cfg_size - off;
718 		count = size;
719 	}
720 
721 	pci_config_pm_runtime_get(dev);
722 
723 	if ((off & 1) && size) {
724 		pci_user_write_config_byte(dev, off, data[off - init_off]);
725 		off++;
726 		size--;
727 	}
728 
729 	if ((off & 3) && size > 2) {
730 		u16 val = data[off - init_off];
731 		val |= (u16) data[off - init_off + 1] << 8;
732 		pci_user_write_config_word(dev, off, val);
733 		off += 2;
734 		size -= 2;
735 	}
736 
737 	while (size > 3) {
738 		u32 val = data[off - init_off];
739 		val |= (u32) data[off - init_off + 1] << 8;
740 		val |= (u32) data[off - init_off + 2] << 16;
741 		val |= (u32) data[off - init_off + 3] << 24;
742 		pci_user_write_config_dword(dev, off, val);
743 		off += 4;
744 		size -= 4;
745 	}
746 
747 	if (size >= 2) {
748 		u16 val = data[off - init_off];
749 		val |= (u16) data[off - init_off + 1] << 8;
750 		pci_user_write_config_word(dev, off, val);
751 		off += 2;
752 		size -= 2;
753 	}
754 
755 	if (size) {
756 		pci_user_write_config_byte(dev, off, data[off - init_off]);
757 		off++;
758 		--size;
759 	}
760 
761 	pci_config_pm_runtime_put(dev);
762 
763 	return count;
764 }
765 
766 static ssize_t read_vpd_attr(struct file *filp, struct kobject *kobj,
767 			     struct bin_attribute *bin_attr, char *buf,
768 			     loff_t off, size_t count)
769 {
770 	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
771 
772 	if (bin_attr->size > 0) {
773 		if (off > bin_attr->size)
774 			count = 0;
775 		else if (count > bin_attr->size - off)
776 			count = bin_attr->size - off;
777 	}
778 
779 	return pci_read_vpd(dev, off, count, buf);
780 }
781 
782 static ssize_t write_vpd_attr(struct file *filp, struct kobject *kobj,
783 			      struct bin_attribute *bin_attr, char *buf,
784 			      loff_t off, size_t count)
785 {
786 	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
787 
788 	if (bin_attr->size > 0) {
789 		if (off > bin_attr->size)
790 			count = 0;
791 		else if (count > bin_attr->size - off)
792 			count = bin_attr->size - off;
793 	}
794 
795 	return pci_write_vpd(dev, off, count, buf);
796 }
797 
798 #ifdef HAVE_PCI_LEGACY
799 /**
800  * pci_read_legacy_io - read byte(s) from legacy I/O port space
801  * @filp: open sysfs file
802  * @kobj: kobject corresponding to file to read from
803  * @bin_attr: struct bin_attribute for this file
804  * @buf: buffer to store results
805  * @off: offset into legacy I/O port space
806  * @count: number of bytes to read
807  *
808  * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
809  * callback routine (pci_legacy_read).
810  */
811 static ssize_t pci_read_legacy_io(struct file *filp, struct kobject *kobj,
812 				  struct bin_attribute *bin_attr, char *buf,
813 				  loff_t off, size_t count)
814 {
815 	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
816 
817 	/* Only support 1, 2 or 4 byte accesses */
818 	if (count != 1 && count != 2 && count != 4)
819 		return -EINVAL;
820 
821 	return pci_legacy_read(bus, off, (u32 *)buf, count);
822 }
823 
824 /**
825  * pci_write_legacy_io - write byte(s) to legacy I/O port space
826  * @filp: open sysfs file
827  * @kobj: kobject corresponding to file to read from
828  * @bin_attr: struct bin_attribute for this file
829  * @buf: buffer containing value to be written
830  * @off: offset into legacy I/O port space
831  * @count: number of bytes to write
832  *
833  * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
834  * callback routine (pci_legacy_write).
835  */
836 static ssize_t pci_write_legacy_io(struct file *filp, struct kobject *kobj,
837 				   struct bin_attribute *bin_attr, char *buf,
838 				   loff_t off, size_t count)
839 {
840 	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
841 
842 	/* Only support 1, 2 or 4 byte accesses */
843 	if (count != 1 && count != 2 && count != 4)
844 		return -EINVAL;
845 
846 	return pci_legacy_write(bus, off, *(u32 *)buf, count);
847 }
848 
849 /**
850  * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
851  * @filp: open sysfs file
852  * @kobj: kobject corresponding to device to be mapped
853  * @attr: struct bin_attribute for this file
854  * @vma: struct vm_area_struct passed to mmap
855  *
856  * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
857  * legacy memory space (first meg of bus space) into application virtual
858  * memory space.
859  */
860 static int pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
861 			       struct bin_attribute *attr,
862 			       struct vm_area_struct *vma)
863 {
864 	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
865 
866 	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
867 }
868 
869 /**
870  * pci_mmap_legacy_io - map legacy PCI IO into user memory space
871  * @filp: open sysfs file
872  * @kobj: kobject corresponding to device to be mapped
873  * @attr: struct bin_attribute for this file
874  * @vma: struct vm_area_struct passed to mmap
875  *
876  * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
877  * legacy IO space (first meg of bus space) into application virtual
878  * memory space. Returns -ENOSYS if the operation isn't supported
879  */
880 static int pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
881 			      struct bin_attribute *attr,
882 			      struct vm_area_struct *vma)
883 {
884 	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
885 
886 	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
887 }
888 
889 /**
890  * pci_adjust_legacy_attr - adjustment of legacy file attributes
891  * @b: bus to create files under
892  * @mmap_type: I/O port or memory
893  *
894  * Stub implementation. Can be overridden by arch if necessary.
895  */
896 void __weak pci_adjust_legacy_attr(struct pci_bus *b,
897 				   enum pci_mmap_state mmap_type)
898 {
899 }
900 
901 /**
902  * pci_create_legacy_files - create legacy I/O port and memory files
903  * @b: bus to create files under
904  *
905  * Some platforms allow access to legacy I/O port and ISA memory space on
906  * a per-bus basis.  This routine creates the files and ties them into
907  * their associated read, write and mmap files from pci-sysfs.c
908  *
909  * On error unwind, but don't propagate the error to the caller
910  * as it is ok to set up the PCI bus without these files.
911  */
912 void pci_create_legacy_files(struct pci_bus *b)
913 {
914 	int error;
915 
916 	b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
917 			       GFP_ATOMIC);
918 	if (!b->legacy_io)
919 		goto kzalloc_err;
920 
921 	sysfs_bin_attr_init(b->legacy_io);
922 	b->legacy_io->attr.name = "legacy_io";
923 	b->legacy_io->size = 0xffff;
924 	b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
925 	b->legacy_io->read = pci_read_legacy_io;
926 	b->legacy_io->write = pci_write_legacy_io;
927 	b->legacy_io->mmap = pci_mmap_legacy_io;
928 	pci_adjust_legacy_attr(b, pci_mmap_io);
929 	error = device_create_bin_file(&b->dev, b->legacy_io);
930 	if (error)
931 		goto legacy_io_err;
932 
933 	/* Allocated above after the legacy_io struct */
934 	b->legacy_mem = b->legacy_io + 1;
935 	sysfs_bin_attr_init(b->legacy_mem);
936 	b->legacy_mem->attr.name = "legacy_mem";
937 	b->legacy_mem->size = 1024*1024;
938 	b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
939 	b->legacy_mem->mmap = pci_mmap_legacy_mem;
940 	pci_adjust_legacy_attr(b, pci_mmap_mem);
941 	error = device_create_bin_file(&b->dev, b->legacy_mem);
942 	if (error)
943 		goto legacy_mem_err;
944 
945 	return;
946 
947 legacy_mem_err:
948 	device_remove_bin_file(&b->dev, b->legacy_io);
949 legacy_io_err:
950 	kfree(b->legacy_io);
951 	b->legacy_io = NULL;
952 kzalloc_err:
953 	printk(KERN_WARNING "pci: warning: could not create legacy I/O port and ISA memory resources to sysfs\n");
954 	return;
955 }
956 
957 void pci_remove_legacy_files(struct pci_bus *b)
958 {
959 	if (b->legacy_io) {
960 		device_remove_bin_file(&b->dev, b->legacy_io);
961 		device_remove_bin_file(&b->dev, b->legacy_mem);
962 		kfree(b->legacy_io); /* both are allocated here */
963 	}
964 }
965 #endif /* HAVE_PCI_LEGACY */
966 
967 #ifdef HAVE_PCI_MMAP
968 
969 int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma,
970 		  enum pci_mmap_api mmap_api)
971 {
972 	unsigned long nr, start, size, pci_start;
973 
974 	if (pci_resource_len(pdev, resno) == 0)
975 		return 0;
976 	nr = vma_pages(vma);
977 	start = vma->vm_pgoff;
978 	size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
979 	pci_start = (mmap_api == PCI_MMAP_PROCFS) ?
980 			pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0;
981 	if (start >= pci_start && start < pci_start + size &&
982 			start + nr <= pci_start + size)
983 		return 1;
984 	return 0;
985 }
986 
987 /**
988  * pci_mmap_resource - map a PCI resource into user memory space
989  * @kobj: kobject for mapping
990  * @attr: struct bin_attribute for the file being mapped
991  * @vma: struct vm_area_struct passed into the mmap
992  * @write_combine: 1 for write_combine mapping
993  *
994  * Use the regular PCI mapping routines to map a PCI resource into userspace.
995  */
996 static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
997 			     struct vm_area_struct *vma, int write_combine)
998 {
999 	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
1000 	struct resource *res = attr->private;
1001 	enum pci_mmap_state mmap_type;
1002 	resource_size_t start, end;
1003 	int i;
1004 
1005 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
1006 		if (res == &pdev->resource[i])
1007 			break;
1008 	if (i >= PCI_ROM_RESOURCE)
1009 		return -ENODEV;
1010 
1011 	if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(res->start))
1012 		return -EINVAL;
1013 
1014 	if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) {
1015 		WARN(1, "process \"%s\" tried to map 0x%08lx bytes at page 0x%08lx on %s BAR %d (start 0x%16Lx, size 0x%16Lx)\n",
1016 			current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff,
1017 			pci_name(pdev), i,
1018 			(u64)pci_resource_start(pdev, i),
1019 			(u64)pci_resource_len(pdev, i));
1020 		return -EINVAL;
1021 	}
1022 
1023 	/* pci_mmap_page_range() expects the same kind of entry as coming
1024 	 * from /proc/bus/pci/ which is a "user visible" value. If this is
1025 	 * different from the resource itself, arch will do necessary fixup.
1026 	 */
1027 	pci_resource_to_user(pdev, i, res, &start, &end);
1028 	vma->vm_pgoff += start >> PAGE_SHIFT;
1029 	mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;
1030 	return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
1031 }
1032 
1033 static int pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
1034 				struct bin_attribute *attr,
1035 				struct vm_area_struct *vma)
1036 {
1037 	return pci_mmap_resource(kobj, attr, vma, 0);
1038 }
1039 
1040 static int pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
1041 				struct bin_attribute *attr,
1042 				struct vm_area_struct *vma)
1043 {
1044 	return pci_mmap_resource(kobj, attr, vma, 1);
1045 }
1046 
1047 static ssize_t pci_resource_io(struct file *filp, struct kobject *kobj,
1048 			       struct bin_attribute *attr, char *buf,
1049 			       loff_t off, size_t count, bool write)
1050 {
1051 	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
1052 	struct resource *res = attr->private;
1053 	unsigned long port = off;
1054 	int i;
1055 
1056 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
1057 		if (res == &pdev->resource[i])
1058 			break;
1059 	if (i >= PCI_ROM_RESOURCE)
1060 		return -ENODEV;
1061 
1062 	port += pci_resource_start(pdev, i);
1063 
1064 	if (port > pci_resource_end(pdev, i))
1065 		return 0;
1066 
1067 	if (port + count - 1 > pci_resource_end(pdev, i))
1068 		return -EINVAL;
1069 
1070 	switch (count) {
1071 	case 1:
1072 		if (write)
1073 			outb(*(u8 *)buf, port);
1074 		else
1075 			*(u8 *)buf = inb(port);
1076 		return 1;
1077 	case 2:
1078 		if (write)
1079 			outw(*(u16 *)buf, port);
1080 		else
1081 			*(u16 *)buf = inw(port);
1082 		return 2;
1083 	case 4:
1084 		if (write)
1085 			outl(*(u32 *)buf, port);
1086 		else
1087 			*(u32 *)buf = inl(port);
1088 		return 4;
1089 	}
1090 	return -EINVAL;
1091 }
1092 
1093 static ssize_t pci_read_resource_io(struct file *filp, struct kobject *kobj,
1094 				    struct bin_attribute *attr, char *buf,
1095 				    loff_t off, size_t count)
1096 {
1097 	return pci_resource_io(filp, kobj, attr, buf, off, count, false);
1098 }
1099 
1100 static ssize_t pci_write_resource_io(struct file *filp, struct kobject *kobj,
1101 				     struct bin_attribute *attr, char *buf,
1102 				     loff_t off, size_t count)
1103 {
1104 	return pci_resource_io(filp, kobj, attr, buf, off, count, true);
1105 }
1106 
1107 /**
1108  * pci_remove_resource_files - cleanup resource files
1109  * @pdev: dev to cleanup
1110  *
1111  * If we created resource files for @pdev, remove them from sysfs and
1112  * free their resources.
1113  */
1114 static void pci_remove_resource_files(struct pci_dev *pdev)
1115 {
1116 	int i;
1117 
1118 	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
1119 		struct bin_attribute *res_attr;
1120 
1121 		res_attr = pdev->res_attr[i];
1122 		if (res_attr) {
1123 			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
1124 			kfree(res_attr);
1125 		}
1126 
1127 		res_attr = pdev->res_attr_wc[i];
1128 		if (res_attr) {
1129 			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
1130 			kfree(res_attr);
1131 		}
1132 	}
1133 }
1134 
1135 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
1136 {
1137 	/* allocate attribute structure, piggyback attribute name */
1138 	int name_len = write_combine ? 13 : 10;
1139 	struct bin_attribute *res_attr;
1140 	char *res_attr_name;
1141 	int retval;
1142 
1143 	res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
1144 	if (!res_attr)
1145 		return -ENOMEM;
1146 
1147 	res_attr_name = (char *)(res_attr + 1);
1148 
1149 	sysfs_bin_attr_init(res_attr);
1150 	if (write_combine) {
1151 		pdev->res_attr_wc[num] = res_attr;
1152 		sprintf(res_attr_name, "resource%d_wc", num);
1153 		res_attr->mmap = pci_mmap_resource_wc;
1154 	} else {
1155 		pdev->res_attr[num] = res_attr;
1156 		sprintf(res_attr_name, "resource%d", num);
1157 		res_attr->mmap = pci_mmap_resource_uc;
1158 	}
1159 	if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
1160 		res_attr->read = pci_read_resource_io;
1161 		res_attr->write = pci_write_resource_io;
1162 	}
1163 	res_attr->attr.name = res_attr_name;
1164 	res_attr->attr.mode = S_IRUSR | S_IWUSR;
1165 	res_attr->size = pci_resource_len(pdev, num);
1166 	res_attr->private = &pdev->resource[num];
1167 	retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
1168 	if (retval)
1169 		kfree(res_attr);
1170 
1171 	return retval;
1172 }
1173 
1174 /**
1175  * pci_create_resource_files - create resource files in sysfs for @dev
1176  * @pdev: dev in question
1177  *
1178  * Walk the resources in @pdev creating files for each resource available.
1179  */
1180 static int pci_create_resource_files(struct pci_dev *pdev)
1181 {
1182 	int i;
1183 	int retval;
1184 
1185 	/* Expose the PCI resources from this device as files */
1186 	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
1187 
1188 		/* skip empty resources */
1189 		if (!pci_resource_len(pdev, i))
1190 			continue;
1191 
1192 		retval = pci_create_attr(pdev, i, 0);
1193 		/* for prefetchable resources, create a WC mappable file */
1194 		if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
1195 			retval = pci_create_attr(pdev, i, 1);
1196 
1197 		if (retval) {
1198 			pci_remove_resource_files(pdev);
1199 			return retval;
1200 		}
1201 	}
1202 	return 0;
1203 }
1204 #else /* !HAVE_PCI_MMAP */
1205 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
1206 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
1207 #endif /* HAVE_PCI_MMAP */
1208 
1209 /**
1210  * pci_write_rom - used to enable access to the PCI ROM display
1211  * @filp: sysfs file
1212  * @kobj: kernel object handle
1213  * @bin_attr: struct bin_attribute for this file
1214  * @buf: user input
1215  * @off: file offset
1216  * @count: number of byte in input
1217  *
1218  * writing anything except 0 enables it
1219  */
1220 static ssize_t pci_write_rom(struct file *filp, struct kobject *kobj,
1221 			     struct bin_attribute *bin_attr, char *buf,
1222 			     loff_t off, size_t count)
1223 {
1224 	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
1225 
1226 	if ((off ==  0) && (*buf == '0') && (count == 2))
1227 		pdev->rom_attr_enabled = 0;
1228 	else
1229 		pdev->rom_attr_enabled = 1;
1230 
1231 	return count;
1232 }
1233 
1234 /**
1235  * pci_read_rom - read a PCI ROM
1236  * @filp: sysfs file
1237  * @kobj: kernel object handle
1238  * @bin_attr: struct bin_attribute for this file
1239  * @buf: where to put the data we read from the ROM
1240  * @off: file offset
1241  * @count: number of bytes to read
1242  *
1243  * Put @count bytes starting at @off into @buf from the ROM in the PCI
1244  * device corresponding to @kobj.
1245  */
1246 static ssize_t pci_read_rom(struct file *filp, struct kobject *kobj,
1247 			    struct bin_attribute *bin_attr, char *buf,
1248 			    loff_t off, size_t count)
1249 {
1250 	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
1251 	void __iomem *rom;
1252 	size_t size;
1253 
1254 	if (!pdev->rom_attr_enabled)
1255 		return -EINVAL;
1256 
1257 	rom = pci_map_rom(pdev, &size);	/* size starts out as PCI window size */
1258 	if (!rom || !size)
1259 		return -EIO;
1260 
1261 	if (off >= size)
1262 		count = 0;
1263 	else {
1264 		if (off + count > size)
1265 			count = size - off;
1266 
1267 		memcpy_fromio(buf, rom + off, count);
1268 	}
1269 	pci_unmap_rom(pdev, rom);
1270 
1271 	return count;
1272 }
1273 
1274 static struct bin_attribute pci_config_attr = {
1275 	.attr =	{
1276 		.name = "config",
1277 		.mode = S_IRUGO | S_IWUSR,
1278 	},
1279 	.size = PCI_CFG_SPACE_SIZE,
1280 	.read = pci_read_config,
1281 	.write = pci_write_config,
1282 };
1283 
1284 static struct bin_attribute pcie_config_attr = {
1285 	.attr =	{
1286 		.name = "config",
1287 		.mode = S_IRUGO | S_IWUSR,
1288 	},
1289 	.size = PCI_CFG_SPACE_EXP_SIZE,
1290 	.read = pci_read_config,
1291 	.write = pci_write_config,
1292 };
1293 
1294 static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
1295 			   const char *buf, size_t count)
1296 {
1297 	struct pci_dev *pdev = to_pci_dev(dev);
1298 	unsigned long val;
1299 	ssize_t result = kstrtoul(buf, 0, &val);
1300 
1301 	if (result < 0)
1302 		return result;
1303 
1304 	if (val != 1)
1305 		return -EINVAL;
1306 
1307 	result = pci_reset_function(pdev);
1308 	if (result < 0)
1309 		return result;
1310 
1311 	return count;
1312 }
1313 
1314 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);
1315 
1316 static int pci_create_capabilities_sysfs(struct pci_dev *dev)
1317 {
1318 	int retval;
1319 	struct bin_attribute *attr;
1320 
1321 	/* If the device has VPD, try to expose it in sysfs. */
1322 	if (dev->vpd) {
1323 		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1324 		if (!attr)
1325 			return -ENOMEM;
1326 
1327 		sysfs_bin_attr_init(attr);
1328 		attr->size = 0;
1329 		attr->attr.name = "vpd";
1330 		attr->attr.mode = S_IRUSR | S_IWUSR;
1331 		attr->read = read_vpd_attr;
1332 		attr->write = write_vpd_attr;
1333 		retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
1334 		if (retval) {
1335 			kfree(attr);
1336 			return retval;
1337 		}
1338 		dev->vpd->attr = attr;
1339 	}
1340 
1341 	/* Active State Power Management */
1342 	pcie_aspm_create_sysfs_dev_files(dev);
1343 
1344 	if (!pci_probe_reset_function(dev)) {
1345 		retval = device_create_file(&dev->dev, &reset_attr);
1346 		if (retval)
1347 			goto error;
1348 		dev->reset_fn = 1;
1349 	}
1350 	return 0;
1351 
1352 error:
1353 	pcie_aspm_remove_sysfs_dev_files(dev);
1354 	if (dev->vpd && dev->vpd->attr) {
1355 		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1356 		kfree(dev->vpd->attr);
1357 	}
1358 
1359 	return retval;
1360 }
1361 
1362 int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev)
1363 {
1364 	int retval;
1365 	int rom_size;
1366 	struct bin_attribute *attr;
1367 
1368 	if (!sysfs_initialized)
1369 		return -EACCES;
1370 
1371 	if (pdev->cfg_size > PCI_CFG_SPACE_SIZE)
1372 		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1373 	else
1374 		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
1375 	if (retval)
1376 		goto err;
1377 
1378 	retval = pci_create_resource_files(pdev);
1379 	if (retval)
1380 		goto err_config_file;
1381 
1382 	/* If the device has a ROM, try to expose it in sysfs. */
1383 	rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1384 	if (rom_size) {
1385 		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1386 		if (!attr) {
1387 			retval = -ENOMEM;
1388 			goto err_resource_files;
1389 		}
1390 		sysfs_bin_attr_init(attr);
1391 		attr->size = rom_size;
1392 		attr->attr.name = "rom";
1393 		attr->attr.mode = S_IRUSR | S_IWUSR;
1394 		attr->read = pci_read_rom;
1395 		attr->write = pci_write_rom;
1396 		retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
1397 		if (retval) {
1398 			kfree(attr);
1399 			goto err_resource_files;
1400 		}
1401 		pdev->rom_attr = attr;
1402 	}
1403 
1404 	/* add sysfs entries for various capabilities */
1405 	retval = pci_create_capabilities_sysfs(pdev);
1406 	if (retval)
1407 		goto err_rom_file;
1408 
1409 	pci_create_firmware_label_files(pdev);
1410 
1411 	return 0;
1412 
1413 err_rom_file:
1414 	if (pdev->rom_attr) {
1415 		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1416 		kfree(pdev->rom_attr);
1417 		pdev->rom_attr = NULL;
1418 	}
1419 err_resource_files:
1420 	pci_remove_resource_files(pdev);
1421 err_config_file:
1422 	if (pdev->cfg_size > PCI_CFG_SPACE_SIZE)
1423 		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1424 	else
1425 		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1426 err:
1427 	return retval;
1428 }
1429 
1430 static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
1431 {
1432 	if (dev->vpd && dev->vpd->attr) {
1433 		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1434 		kfree(dev->vpd->attr);
1435 	}
1436 
1437 	pcie_aspm_remove_sysfs_dev_files(dev);
1438 	if (dev->reset_fn) {
1439 		device_remove_file(&dev->dev, &reset_attr);
1440 		dev->reset_fn = 0;
1441 	}
1442 }
1443 
1444 /**
1445  * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
1446  * @pdev: device whose entries we should free
1447  *
1448  * Cleanup when @pdev is removed from sysfs.
1449  */
1450 void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
1451 {
1452 	if (!sysfs_initialized)
1453 		return;
1454 
1455 	pci_remove_capabilities_sysfs(pdev);
1456 
1457 	if (pdev->cfg_size > PCI_CFG_SPACE_SIZE)
1458 		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1459 	else
1460 		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1461 
1462 	pci_remove_resource_files(pdev);
1463 
1464 	if (pdev->rom_attr) {
1465 		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1466 		kfree(pdev->rom_attr);
1467 		pdev->rom_attr = NULL;
1468 	}
1469 
1470 	pci_remove_firmware_label_files(pdev);
1471 }
1472 
1473 static int __init pci_sysfs_init(void)
1474 {
1475 	struct pci_dev *pdev = NULL;
1476 	int retval;
1477 
1478 	sysfs_initialized = 1;
1479 	for_each_pci_dev(pdev) {
1480 		retval = pci_create_sysfs_dev_files(pdev);
1481 		if (retval) {
1482 			pci_dev_put(pdev);
1483 			return retval;
1484 		}
1485 	}
1486 
1487 	return 0;
1488 }
1489 late_initcall(pci_sysfs_init);
1490 
1491 static struct attribute *pci_dev_dev_attrs[] = {
1492 	&vga_attr.attr,
1493 	NULL,
1494 };
1495 
1496 static umode_t pci_dev_attrs_are_visible(struct kobject *kobj,
1497 					 struct attribute *a, int n)
1498 {
1499 	struct device *dev = kobj_to_dev(kobj);
1500 	struct pci_dev *pdev = to_pci_dev(dev);
1501 
1502 	if (a == &vga_attr.attr)
1503 		if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
1504 			return 0;
1505 
1506 	return a->mode;
1507 }
1508 
1509 static struct attribute *pci_dev_hp_attrs[] = {
1510 	&dev_remove_attr.attr,
1511 	&dev_rescan_attr.attr,
1512 	NULL,
1513 };
1514 
1515 static umode_t pci_dev_hp_attrs_are_visible(struct kobject *kobj,
1516 					    struct attribute *a, int n)
1517 {
1518 	struct device *dev = kobj_to_dev(kobj);
1519 	struct pci_dev *pdev = to_pci_dev(dev);
1520 
1521 	if (pdev->is_virtfn)
1522 		return 0;
1523 
1524 	return a->mode;
1525 }
1526 
1527 static struct attribute_group pci_dev_hp_attr_group = {
1528 	.attrs = pci_dev_hp_attrs,
1529 	.is_visible = pci_dev_hp_attrs_are_visible,
1530 };
1531 
1532 #ifdef CONFIG_PCI_IOV
1533 static struct attribute *sriov_dev_attrs[] = {
1534 	&sriov_totalvfs_attr.attr,
1535 	&sriov_numvfs_attr.attr,
1536 	NULL,
1537 };
1538 
1539 static umode_t sriov_attrs_are_visible(struct kobject *kobj,
1540 				       struct attribute *a, int n)
1541 {
1542 	struct device *dev = kobj_to_dev(kobj);
1543 
1544 	if (!dev_is_pf(dev))
1545 		return 0;
1546 
1547 	return a->mode;
1548 }
1549 
1550 static struct attribute_group sriov_dev_attr_group = {
1551 	.attrs = sriov_dev_attrs,
1552 	.is_visible = sriov_attrs_are_visible,
1553 };
1554 #endif /* CONFIG_PCI_IOV */
1555 
1556 static struct attribute_group pci_dev_attr_group = {
1557 	.attrs = pci_dev_dev_attrs,
1558 	.is_visible = pci_dev_attrs_are_visible,
1559 };
1560 
1561 static const struct attribute_group *pci_dev_attr_groups[] = {
1562 	&pci_dev_attr_group,
1563 	&pci_dev_hp_attr_group,
1564 #ifdef CONFIG_PCI_IOV
1565 	&sriov_dev_attr_group,
1566 #endif
1567 	NULL,
1568 };
1569 
1570 struct device_type pci_dev_type = {
1571 	.groups = pci_dev_attr_groups,
1572 };
1573