xref: /linux/drivers/pci/pci-sysfs.c (revision 26b0d14106954ae46d2f4f7eec3481828a210f7d)
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 "pci.h"
32 
33 static int sysfs_initialized;	/* = 0 */
34 
35 /* show configuration fields */
36 #define pci_config_attr(field, format_string)				\
37 static ssize_t								\
38 field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
39 {									\
40 	struct pci_dev *pdev;						\
41 									\
42 	pdev = to_pci_dev (dev);					\
43 	return sprintf (buf, format_string, pdev->field);		\
44 }
45 
46 pci_config_attr(vendor, "0x%04x\n");
47 pci_config_attr(device, "0x%04x\n");
48 pci_config_attr(subsystem_vendor, "0x%04x\n");
49 pci_config_attr(subsystem_device, "0x%04x\n");
50 pci_config_attr(class, "0x%06x\n");
51 pci_config_attr(irq, "%u\n");
52 
53 static ssize_t broken_parity_status_show(struct device *dev,
54 					 struct device_attribute *attr,
55 					 char *buf)
56 {
57 	struct pci_dev *pdev = to_pci_dev(dev);
58 	return sprintf (buf, "%u\n", pdev->broken_parity_status);
59 }
60 
61 static ssize_t broken_parity_status_store(struct device *dev,
62 					  struct device_attribute *attr,
63 					  const char *buf, size_t count)
64 {
65 	struct pci_dev *pdev = to_pci_dev(dev);
66 	unsigned long val;
67 
68 	if (strict_strtoul(buf, 0, &val) < 0)
69 		return -EINVAL;
70 
71 	pdev->broken_parity_status = !!val;
72 
73 	return count;
74 }
75 
76 static ssize_t local_cpus_show(struct device *dev,
77 			struct device_attribute *attr, char *buf)
78 {
79 	const struct cpumask *mask;
80 	int len;
81 
82 #ifdef CONFIG_NUMA
83 	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
84 					  cpumask_of_node(dev_to_node(dev));
85 #else
86 	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
87 #endif
88 	len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
89 	buf[len++] = '\n';
90 	buf[len] = '\0';
91 	return len;
92 }
93 
94 
95 static ssize_t local_cpulist_show(struct device *dev,
96 			struct device_attribute *attr, char *buf)
97 {
98 	const struct cpumask *mask;
99 	int len;
100 
101 #ifdef CONFIG_NUMA
102 	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
103 					  cpumask_of_node(dev_to_node(dev));
104 #else
105 	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
106 #endif
107 	len = cpulist_scnprintf(buf, PAGE_SIZE-2, mask);
108 	buf[len++] = '\n';
109 	buf[len] = '\0';
110 	return len;
111 }
112 
113 /*
114  * PCI Bus Class Devices
115  */
116 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
117 					int type,
118 					struct device_attribute *attr,
119 					char *buf)
120 {
121 	int ret;
122 	const struct cpumask *cpumask;
123 
124 	cpumask = cpumask_of_pcibus(to_pci_bus(dev));
125 	ret = type ?
126 		cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask) :
127 		cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
128 	buf[ret++] = '\n';
129 	buf[ret] = '\0';
130 	return ret;
131 }
132 
133 static inline ssize_t pci_bus_show_cpumaskaffinity(struct device *dev,
134 					struct device_attribute *attr,
135 					char *buf)
136 {
137 	return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
138 }
139 
140 static inline ssize_t pci_bus_show_cpulistaffinity(struct device *dev,
141 					struct device_attribute *attr,
142 					char *buf)
143 {
144 	return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
145 }
146 
147 /* show resources */
148 static ssize_t
149 resource_show(struct device * dev, struct device_attribute *attr, char * buf)
150 {
151 	struct pci_dev * pci_dev = to_pci_dev(dev);
152 	char * str = buf;
153 	int i;
154 	int max;
155 	resource_size_t start, end;
156 
157 	if (pci_dev->subordinate)
158 		max = DEVICE_COUNT_RESOURCE;
159 	else
160 		max = PCI_BRIDGE_RESOURCES;
161 
162 	for (i = 0; i < max; i++) {
163 		struct resource *res =  &pci_dev->resource[i];
164 		pci_resource_to_user(pci_dev, i, res, &start, &end);
165 		str += sprintf(str,"0x%016llx 0x%016llx 0x%016llx\n",
166 			       (unsigned long long)start,
167 			       (unsigned long long)end,
168 			       (unsigned long long)res->flags);
169 	}
170 	return (str - buf);
171 }
172 
173 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
174 {
175 	struct pci_dev *pci_dev = to_pci_dev(dev);
176 
177 	return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x\n",
178 		       pci_dev->vendor, pci_dev->device,
179 		       pci_dev->subsystem_vendor, pci_dev->subsystem_device,
180 		       (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
181 		       (u8)(pci_dev->class));
182 }
183 
184 static ssize_t is_enabled_store(struct device *dev,
185 				struct device_attribute *attr, const char *buf,
186 				size_t count)
187 {
188 	struct pci_dev *pdev = to_pci_dev(dev);
189 	unsigned long val;
190 	ssize_t result = strict_strtoul(buf, 0, &val);
191 
192 	if (result < 0)
193 		return result;
194 
195 	/* this can crash the machine when done on the "wrong" device */
196 	if (!capable(CAP_SYS_ADMIN))
197 		return -EPERM;
198 
199 	if (!val) {
200 		if (pci_is_enabled(pdev))
201 			pci_disable_device(pdev);
202 		else
203 			result = -EIO;
204 	} else
205 		result = pci_enable_device(pdev);
206 
207 	return result < 0 ? result : count;
208 }
209 
210 static ssize_t is_enabled_show(struct device *dev,
211 			       struct device_attribute *attr, char *buf)
212 {
213 	struct pci_dev *pdev;
214 
215 	pdev = to_pci_dev (dev);
216 	return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt));
217 }
218 
219 #ifdef CONFIG_NUMA
220 static ssize_t
221 numa_node_show(struct device *dev, struct device_attribute *attr, char *buf)
222 {
223 	return sprintf (buf, "%d\n", dev->numa_node);
224 }
225 #endif
226 
227 static ssize_t
228 dma_mask_bits_show(struct device *dev, struct device_attribute *attr, char *buf)
229 {
230 	struct pci_dev *pdev = to_pci_dev(dev);
231 
232 	return sprintf (buf, "%d\n", fls64(pdev->dma_mask));
233 }
234 
235 static ssize_t
236 consistent_dma_mask_bits_show(struct device *dev, struct device_attribute *attr,
237 				 char *buf)
238 {
239 	return sprintf (buf, "%d\n", fls64(dev->coherent_dma_mask));
240 }
241 
242 static ssize_t
243 msi_bus_show(struct device *dev, struct device_attribute *attr, char *buf)
244 {
245 	struct pci_dev *pdev = to_pci_dev(dev);
246 
247 	if (!pdev->subordinate)
248 		return 0;
249 
250 	return sprintf (buf, "%u\n",
251 			!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI));
252 }
253 
254 static ssize_t
255 msi_bus_store(struct device *dev, struct device_attribute *attr,
256 	      const char *buf, size_t count)
257 {
258 	struct pci_dev *pdev = to_pci_dev(dev);
259 	unsigned long val;
260 
261 	if (strict_strtoul(buf, 0, &val) < 0)
262 		return -EINVAL;
263 
264 	/* bad things may happen if the no_msi flag is changed
265 	 * while some drivers are loaded */
266 	if (!capable(CAP_SYS_ADMIN))
267 		return -EPERM;
268 
269 	/* Maybe pci devices without subordinate busses shouldn't even have this
270 	 * attribute in the first place?  */
271 	if (!pdev->subordinate)
272 		return count;
273 
274 	/* Is the flag going to change, or keep the value it already had? */
275 	if (!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI) ^
276 	    !!val) {
277 		pdev->subordinate->bus_flags ^= PCI_BUS_FLAGS_NO_MSI;
278 
279 		dev_warn(&pdev->dev, "forced subordinate bus to%s support MSI,"
280 			 " bad things could happen\n", val ? "" : " not");
281 	}
282 
283 	return count;
284 }
285 
286 #ifdef CONFIG_HOTPLUG
287 static DEFINE_MUTEX(pci_remove_rescan_mutex);
288 static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
289 				size_t count)
290 {
291 	unsigned long val;
292 	struct pci_bus *b = NULL;
293 
294 	if (strict_strtoul(buf, 0, &val) < 0)
295 		return -EINVAL;
296 
297 	if (val) {
298 		mutex_lock(&pci_remove_rescan_mutex);
299 		while ((b = pci_find_next_bus(b)) != NULL)
300 			pci_rescan_bus(b);
301 		mutex_unlock(&pci_remove_rescan_mutex);
302 	}
303 	return count;
304 }
305 
306 struct bus_attribute pci_bus_attrs[] = {
307 	__ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store),
308 	__ATTR_NULL
309 };
310 
311 static ssize_t
312 dev_rescan_store(struct device *dev, struct device_attribute *attr,
313 		 const char *buf, size_t count)
314 {
315 	unsigned long val;
316 	struct pci_dev *pdev = to_pci_dev(dev);
317 
318 	if (strict_strtoul(buf, 0, &val) < 0)
319 		return -EINVAL;
320 
321 	if (val) {
322 		mutex_lock(&pci_remove_rescan_mutex);
323 		pci_rescan_bus(pdev->bus);
324 		mutex_unlock(&pci_remove_rescan_mutex);
325 	}
326 	return count;
327 }
328 
329 static void remove_callback(struct device *dev)
330 {
331 	struct pci_dev *pdev = to_pci_dev(dev);
332 
333 	mutex_lock(&pci_remove_rescan_mutex);
334 	pci_stop_and_remove_bus_device(pdev);
335 	mutex_unlock(&pci_remove_rescan_mutex);
336 }
337 
338 static ssize_t
339 remove_store(struct device *dev, struct device_attribute *dummy,
340 	     const char *buf, size_t count)
341 {
342 	int ret = 0;
343 	unsigned long val;
344 
345 	if (strict_strtoul(buf, 0, &val) < 0)
346 		return -EINVAL;
347 
348 	/* An attribute cannot be unregistered by one of its own methods,
349 	 * so we have to use this roundabout approach.
350 	 */
351 	if (val)
352 		ret = device_schedule_callback(dev, remove_callback);
353 	if (ret)
354 		count = ret;
355 	return count;
356 }
357 
358 static ssize_t
359 dev_bus_rescan_store(struct device *dev, struct device_attribute *attr,
360 		 const char *buf, size_t count)
361 {
362 	unsigned long val;
363 	struct pci_bus *bus = to_pci_bus(dev);
364 
365 	if (strict_strtoul(buf, 0, &val) < 0)
366 		return -EINVAL;
367 
368 	if (val) {
369 		mutex_lock(&pci_remove_rescan_mutex);
370 		if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
371 			pci_rescan_bus_bridge_resize(bus->self);
372 		else
373 			pci_rescan_bus(bus);
374 		mutex_unlock(&pci_remove_rescan_mutex);
375 	}
376 	return count;
377 }
378 
379 #endif
380 
381 struct device_attribute pci_dev_attrs[] = {
382 	__ATTR_RO(resource),
383 	__ATTR_RO(vendor),
384 	__ATTR_RO(device),
385 	__ATTR_RO(subsystem_vendor),
386 	__ATTR_RO(subsystem_device),
387 	__ATTR_RO(class),
388 	__ATTR_RO(irq),
389 	__ATTR_RO(local_cpus),
390 	__ATTR_RO(local_cpulist),
391 	__ATTR_RO(modalias),
392 #ifdef CONFIG_NUMA
393 	__ATTR_RO(numa_node),
394 #endif
395 	__ATTR_RO(dma_mask_bits),
396 	__ATTR_RO(consistent_dma_mask_bits),
397 	__ATTR(enable, 0600, is_enabled_show, is_enabled_store),
398 	__ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
399 		broken_parity_status_show,broken_parity_status_store),
400 	__ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store),
401 #ifdef CONFIG_HOTPLUG
402 	__ATTR(remove, (S_IWUSR|S_IWGRP), NULL, remove_store),
403 	__ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_rescan_store),
404 #endif
405 	__ATTR_NULL,
406 };
407 
408 struct device_attribute pcibus_dev_attrs[] = {
409 #ifdef CONFIG_HOTPLUG
410 	__ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store),
411 #endif
412 	__ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpumaskaffinity, NULL),
413 	__ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL),
414 	__ATTR_NULL,
415 };
416 
417 static ssize_t
418 boot_vga_show(struct device *dev, struct device_attribute *attr, char *buf)
419 {
420 	struct pci_dev *pdev = to_pci_dev(dev);
421 	struct pci_dev *vga_dev = vga_default_device();
422 
423 	if (vga_dev)
424 		return sprintf(buf, "%u\n", (pdev == vga_dev));
425 
426 	return sprintf(buf, "%u\n",
427 		!!(pdev->resource[PCI_ROM_RESOURCE].flags &
428 		   IORESOURCE_ROM_SHADOW));
429 }
430 struct device_attribute vga_attr = __ATTR_RO(boot_vga);
431 
432 static ssize_t
433 pci_read_config(struct file *filp, struct kobject *kobj,
434 		struct bin_attribute *bin_attr,
435 		char *buf, loff_t off, size_t count)
436 {
437 	struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
438 	unsigned int size = 64;
439 	loff_t init_off = off;
440 	u8 *data = (u8*) buf;
441 
442 	/* Several chips lock up trying to read undefined config space */
443 	if (security_capable(filp->f_cred, &init_user_ns, CAP_SYS_ADMIN) == 0) {
444 		size = dev->cfg_size;
445 	} else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
446 		size = 128;
447 	}
448 
449 	if (off > size)
450 		return 0;
451 	if (off + count > size) {
452 		size -= off;
453 		count = size;
454 	} else {
455 		size = count;
456 	}
457 
458 	if ((off & 1) && size) {
459 		u8 val;
460 		pci_user_read_config_byte(dev, off, &val);
461 		data[off - init_off] = val;
462 		off++;
463 		size--;
464 	}
465 
466 	if ((off & 3) && size > 2) {
467 		u16 val;
468 		pci_user_read_config_word(dev, off, &val);
469 		data[off - init_off] = val & 0xff;
470 		data[off - init_off + 1] = (val >> 8) & 0xff;
471 		off += 2;
472 		size -= 2;
473 	}
474 
475 	while (size > 3) {
476 		u32 val;
477 		pci_user_read_config_dword(dev, off, &val);
478 		data[off - init_off] = val & 0xff;
479 		data[off - init_off + 1] = (val >> 8) & 0xff;
480 		data[off - init_off + 2] = (val >> 16) & 0xff;
481 		data[off - init_off + 3] = (val >> 24) & 0xff;
482 		off += 4;
483 		size -= 4;
484 	}
485 
486 	if (size >= 2) {
487 		u16 val;
488 		pci_user_read_config_word(dev, off, &val);
489 		data[off - init_off] = val & 0xff;
490 		data[off - init_off + 1] = (val >> 8) & 0xff;
491 		off += 2;
492 		size -= 2;
493 	}
494 
495 	if (size > 0) {
496 		u8 val;
497 		pci_user_read_config_byte(dev, off, &val);
498 		data[off - init_off] = val;
499 		off++;
500 		--size;
501 	}
502 
503 	return count;
504 }
505 
506 static ssize_t
507 pci_write_config(struct file* filp, struct kobject *kobj,
508 		 struct bin_attribute *bin_attr,
509 		 char *buf, loff_t off, size_t count)
510 {
511 	struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
512 	unsigned int size = count;
513 	loff_t init_off = off;
514 	u8 *data = (u8*) buf;
515 
516 	if (off > dev->cfg_size)
517 		return 0;
518 	if (off + count > dev->cfg_size) {
519 		size = dev->cfg_size - off;
520 		count = size;
521 	}
522 
523 	if ((off & 1) && size) {
524 		pci_user_write_config_byte(dev, off, data[off - init_off]);
525 		off++;
526 		size--;
527 	}
528 
529 	if ((off & 3) && size > 2) {
530 		u16 val = data[off - init_off];
531 		val |= (u16) data[off - init_off + 1] << 8;
532                 pci_user_write_config_word(dev, off, val);
533                 off += 2;
534                 size -= 2;
535         }
536 
537 	while (size > 3) {
538 		u32 val = data[off - init_off];
539 		val |= (u32) data[off - init_off + 1] << 8;
540 		val |= (u32) data[off - init_off + 2] << 16;
541 		val |= (u32) data[off - init_off + 3] << 24;
542 		pci_user_write_config_dword(dev, off, val);
543 		off += 4;
544 		size -= 4;
545 	}
546 
547 	if (size >= 2) {
548 		u16 val = data[off - init_off];
549 		val |= (u16) data[off - init_off + 1] << 8;
550 		pci_user_write_config_word(dev, off, val);
551 		off += 2;
552 		size -= 2;
553 	}
554 
555 	if (size) {
556 		pci_user_write_config_byte(dev, off, data[off - init_off]);
557 		off++;
558 		--size;
559 	}
560 
561 	return count;
562 }
563 
564 static ssize_t
565 read_vpd_attr(struct file *filp, struct kobject *kobj,
566 	      struct bin_attribute *bin_attr,
567 	      char *buf, loff_t off, size_t count)
568 {
569 	struct pci_dev *dev =
570 		to_pci_dev(container_of(kobj, struct device, kobj));
571 
572 	if (off > bin_attr->size)
573 		count = 0;
574 	else if (count > bin_attr->size - off)
575 		count = bin_attr->size - off;
576 
577 	return pci_read_vpd(dev, off, count, buf);
578 }
579 
580 static ssize_t
581 write_vpd_attr(struct file *filp, struct kobject *kobj,
582 	       struct bin_attribute *bin_attr,
583 	       char *buf, loff_t off, size_t count)
584 {
585 	struct pci_dev *dev =
586 		to_pci_dev(container_of(kobj, struct device, kobj));
587 
588 	if (off > bin_attr->size)
589 		count = 0;
590 	else if (count > bin_attr->size - off)
591 		count = bin_attr->size - off;
592 
593 	return pci_write_vpd(dev, off, count, buf);
594 }
595 
596 #ifdef HAVE_PCI_LEGACY
597 /**
598  * pci_read_legacy_io - read byte(s) from legacy I/O port space
599  * @filp: open sysfs file
600  * @kobj: kobject corresponding to file to read from
601  * @bin_attr: struct bin_attribute for this file
602  * @buf: buffer to store results
603  * @off: offset into legacy I/O port space
604  * @count: number of bytes to read
605  *
606  * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
607  * callback routine (pci_legacy_read).
608  */
609 static ssize_t
610 pci_read_legacy_io(struct file *filp, struct kobject *kobj,
611 		   struct bin_attribute *bin_attr,
612 		   char *buf, loff_t off, size_t count)
613 {
614         struct pci_bus *bus = to_pci_bus(container_of(kobj,
615                                                       struct device,
616 						      kobj));
617 
618         /* Only support 1, 2 or 4 byte accesses */
619         if (count != 1 && count != 2 && count != 4)
620                 return -EINVAL;
621 
622         return pci_legacy_read(bus, off, (u32 *)buf, count);
623 }
624 
625 /**
626  * pci_write_legacy_io - write byte(s) to legacy I/O port space
627  * @filp: open sysfs file
628  * @kobj: kobject corresponding to file to read from
629  * @bin_attr: struct bin_attribute for this file
630  * @buf: buffer containing value to be written
631  * @off: offset into legacy I/O port space
632  * @count: number of bytes to write
633  *
634  * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
635  * callback routine (pci_legacy_write).
636  */
637 static ssize_t
638 pci_write_legacy_io(struct file *filp, struct kobject *kobj,
639 		    struct bin_attribute *bin_attr,
640 		    char *buf, loff_t off, size_t count)
641 {
642         struct pci_bus *bus = to_pci_bus(container_of(kobj,
643 						      struct device,
644 						      kobj));
645         /* Only support 1, 2 or 4 byte accesses */
646         if (count != 1 && count != 2 && count != 4)
647                 return -EINVAL;
648 
649         return pci_legacy_write(bus, off, *(u32 *)buf, count);
650 }
651 
652 /**
653  * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
654  * @filp: open sysfs file
655  * @kobj: kobject corresponding to device to be mapped
656  * @attr: struct bin_attribute for this file
657  * @vma: struct vm_area_struct passed to mmap
658  *
659  * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
660  * legacy memory space (first meg of bus space) into application virtual
661  * memory space.
662  */
663 static int
664 pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
665 		    struct bin_attribute *attr,
666                     struct vm_area_struct *vma)
667 {
668         struct pci_bus *bus = to_pci_bus(container_of(kobj,
669                                                       struct device,
670 						      kobj));
671 
672         return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
673 }
674 
675 /**
676  * pci_mmap_legacy_io - map legacy PCI IO into user memory space
677  * @filp: open sysfs file
678  * @kobj: kobject corresponding to device to be mapped
679  * @attr: struct bin_attribute for this file
680  * @vma: struct vm_area_struct passed to mmap
681  *
682  * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
683  * legacy IO space (first meg of bus space) into application virtual
684  * memory space. Returns -ENOSYS if the operation isn't supported
685  */
686 static int
687 pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
688 		   struct bin_attribute *attr,
689 		   struct vm_area_struct *vma)
690 {
691         struct pci_bus *bus = to_pci_bus(container_of(kobj,
692                                                       struct device,
693 						      kobj));
694 
695         return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
696 }
697 
698 /**
699  * pci_adjust_legacy_attr - adjustment of legacy file attributes
700  * @b: bus to create files under
701  * @mmap_type: I/O port or memory
702  *
703  * Stub implementation. Can be overridden by arch if necessary.
704  */
705 void __weak
706 pci_adjust_legacy_attr(struct pci_bus *b, enum pci_mmap_state mmap_type)
707 {
708 	return;
709 }
710 
711 /**
712  * pci_create_legacy_files - create legacy I/O port and memory files
713  * @b: bus to create files under
714  *
715  * Some platforms allow access to legacy I/O port and ISA memory space on
716  * a per-bus basis.  This routine creates the files and ties them into
717  * their associated read, write and mmap files from pci-sysfs.c
718  *
719  * On error unwind, but don't propagate the error to the caller
720  * as it is ok to set up the PCI bus without these files.
721  */
722 void pci_create_legacy_files(struct pci_bus *b)
723 {
724 	int error;
725 
726 	b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
727 			       GFP_ATOMIC);
728 	if (!b->legacy_io)
729 		goto kzalloc_err;
730 
731 	sysfs_bin_attr_init(b->legacy_io);
732 	b->legacy_io->attr.name = "legacy_io";
733 	b->legacy_io->size = 0xffff;
734 	b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
735 	b->legacy_io->read = pci_read_legacy_io;
736 	b->legacy_io->write = pci_write_legacy_io;
737 	b->legacy_io->mmap = pci_mmap_legacy_io;
738 	pci_adjust_legacy_attr(b, pci_mmap_io);
739 	error = device_create_bin_file(&b->dev, b->legacy_io);
740 	if (error)
741 		goto legacy_io_err;
742 
743 	/* Allocated above after the legacy_io struct */
744 	b->legacy_mem = b->legacy_io + 1;
745 	sysfs_bin_attr_init(b->legacy_mem);
746 	b->legacy_mem->attr.name = "legacy_mem";
747 	b->legacy_mem->size = 1024*1024;
748 	b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
749 	b->legacy_mem->mmap = pci_mmap_legacy_mem;
750 	pci_adjust_legacy_attr(b, pci_mmap_mem);
751 	error = device_create_bin_file(&b->dev, b->legacy_mem);
752 	if (error)
753 		goto legacy_mem_err;
754 
755 	return;
756 
757 legacy_mem_err:
758 	device_remove_bin_file(&b->dev, b->legacy_io);
759 legacy_io_err:
760 	kfree(b->legacy_io);
761 	b->legacy_io = NULL;
762 kzalloc_err:
763 	printk(KERN_WARNING "pci: warning: could not create legacy I/O port "
764 	       "and ISA memory resources to sysfs\n");
765 	return;
766 }
767 
768 void pci_remove_legacy_files(struct pci_bus *b)
769 {
770 	if (b->legacy_io) {
771 		device_remove_bin_file(&b->dev, b->legacy_io);
772 		device_remove_bin_file(&b->dev, b->legacy_mem);
773 		kfree(b->legacy_io); /* both are allocated here */
774 	}
775 }
776 #endif /* HAVE_PCI_LEGACY */
777 
778 #ifdef HAVE_PCI_MMAP
779 
780 int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma,
781 		  enum pci_mmap_api mmap_api)
782 {
783 	unsigned long nr, start, size, pci_start;
784 
785 	if (pci_resource_len(pdev, resno) == 0)
786 		return 0;
787 	nr = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
788 	start = vma->vm_pgoff;
789 	size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
790 	pci_start = (mmap_api == PCI_MMAP_PROCFS) ?
791 			pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0;
792 	if (start >= pci_start && start < pci_start + size &&
793 			start + nr <= pci_start + size)
794 		return 1;
795 	return 0;
796 }
797 
798 /**
799  * pci_mmap_resource - map a PCI resource into user memory space
800  * @kobj: kobject for mapping
801  * @attr: struct bin_attribute for the file being mapped
802  * @vma: struct vm_area_struct passed into the mmap
803  * @write_combine: 1 for write_combine mapping
804  *
805  * Use the regular PCI mapping routines to map a PCI resource into userspace.
806  */
807 static int
808 pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
809 		  struct vm_area_struct *vma, int write_combine)
810 {
811 	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
812 						       struct device, kobj));
813 	struct resource *res = attr->private;
814 	enum pci_mmap_state mmap_type;
815 	resource_size_t start, end;
816 	int i;
817 
818 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
819 		if (res == &pdev->resource[i])
820 			break;
821 	if (i >= PCI_ROM_RESOURCE)
822 		return -ENODEV;
823 
824 	if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) {
825 		WARN(1, "process \"%s\" tried to map 0x%08lx bytes "
826 			"at page 0x%08lx on %s BAR %d (start 0x%16Lx, size 0x%16Lx)\n",
827 			current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff,
828 			pci_name(pdev), i,
829 			(u64)pci_resource_start(pdev, i),
830 			(u64)pci_resource_len(pdev, i));
831 		return -EINVAL;
832 	}
833 
834 	/* pci_mmap_page_range() expects the same kind of entry as coming
835 	 * from /proc/bus/pci/ which is a "user visible" value. If this is
836 	 * different from the resource itself, arch will do necessary fixup.
837 	 */
838 	pci_resource_to_user(pdev, i, res, &start, &end);
839 	vma->vm_pgoff += start >> PAGE_SHIFT;
840 	mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;
841 
842 	if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
843 		return -EINVAL;
844 
845 	return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
846 }
847 
848 static int
849 pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
850 		     struct bin_attribute *attr,
851 		     struct vm_area_struct *vma)
852 {
853 	return pci_mmap_resource(kobj, attr, vma, 0);
854 }
855 
856 static int
857 pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
858 		     struct bin_attribute *attr,
859 		     struct vm_area_struct *vma)
860 {
861 	return pci_mmap_resource(kobj, attr, vma, 1);
862 }
863 
864 static ssize_t
865 pci_resource_io(struct file *filp, struct kobject *kobj,
866 		struct bin_attribute *attr, char *buf,
867 		loff_t off, size_t count, bool write)
868 {
869 	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
870 						       struct device, kobj));
871 	struct resource *res = attr->private;
872 	unsigned long port = off;
873 	int i;
874 
875 	for (i = 0; i < PCI_ROM_RESOURCE; i++)
876 		if (res == &pdev->resource[i])
877 			break;
878 	if (i >= PCI_ROM_RESOURCE)
879 		return -ENODEV;
880 
881 	port += pci_resource_start(pdev, i);
882 
883 	if (port > pci_resource_end(pdev, i))
884 		return 0;
885 
886 	if (port + count - 1 > pci_resource_end(pdev, i))
887 		return -EINVAL;
888 
889 	switch (count) {
890 	case 1:
891 		if (write)
892 			outb(*(u8 *)buf, port);
893 		else
894 			*(u8 *)buf = inb(port);
895 		return 1;
896 	case 2:
897 		if (write)
898 			outw(*(u16 *)buf, port);
899 		else
900 			*(u16 *)buf = inw(port);
901 		return 2;
902 	case 4:
903 		if (write)
904 			outl(*(u32 *)buf, port);
905 		else
906 			*(u32 *)buf = inl(port);
907 		return 4;
908 	}
909 	return -EINVAL;
910 }
911 
912 static ssize_t
913 pci_read_resource_io(struct file *filp, struct kobject *kobj,
914 		     struct bin_attribute *attr, char *buf,
915 		     loff_t off, size_t count)
916 {
917 	return pci_resource_io(filp, kobj, attr, buf, off, count, false);
918 }
919 
920 static ssize_t
921 pci_write_resource_io(struct file *filp, struct kobject *kobj,
922 		      struct bin_attribute *attr, char *buf,
923 		      loff_t off, size_t count)
924 {
925 	return pci_resource_io(filp, kobj, attr, buf, off, count, true);
926 }
927 
928 /**
929  * pci_remove_resource_files - cleanup resource files
930  * @pdev: dev to cleanup
931  *
932  * If we created resource files for @pdev, remove them from sysfs and
933  * free their resources.
934  */
935 static void
936 pci_remove_resource_files(struct pci_dev *pdev)
937 {
938 	int i;
939 
940 	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
941 		struct bin_attribute *res_attr;
942 
943 		res_attr = pdev->res_attr[i];
944 		if (res_attr) {
945 			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
946 			kfree(res_attr);
947 		}
948 
949 		res_attr = pdev->res_attr_wc[i];
950 		if (res_attr) {
951 			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
952 			kfree(res_attr);
953 		}
954 	}
955 }
956 
957 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
958 {
959 	/* allocate attribute structure, piggyback attribute name */
960 	int name_len = write_combine ? 13 : 10;
961 	struct bin_attribute *res_attr;
962 	int retval;
963 
964 	res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
965 	if (res_attr) {
966 		char *res_attr_name = (char *)(res_attr + 1);
967 
968 		sysfs_bin_attr_init(res_attr);
969 		if (write_combine) {
970 			pdev->res_attr_wc[num] = res_attr;
971 			sprintf(res_attr_name, "resource%d_wc", num);
972 			res_attr->mmap = pci_mmap_resource_wc;
973 		} else {
974 			pdev->res_attr[num] = res_attr;
975 			sprintf(res_attr_name, "resource%d", num);
976 			res_attr->mmap = pci_mmap_resource_uc;
977 		}
978 		if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
979 			res_attr->read = pci_read_resource_io;
980 			res_attr->write = pci_write_resource_io;
981 		}
982 		res_attr->attr.name = res_attr_name;
983 		res_attr->attr.mode = S_IRUSR | S_IWUSR;
984 		res_attr->size = pci_resource_len(pdev, num);
985 		res_attr->private = &pdev->resource[num];
986 		retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
987 	} else
988 		retval = -ENOMEM;
989 
990 	return retval;
991 }
992 
993 /**
994  * pci_create_resource_files - create resource files in sysfs for @dev
995  * @pdev: dev in question
996  *
997  * Walk the resources in @pdev creating files for each resource available.
998  */
999 static int pci_create_resource_files(struct pci_dev *pdev)
1000 {
1001 	int i;
1002 	int retval;
1003 
1004 	/* Expose the PCI resources from this device as files */
1005 	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
1006 
1007 		/* skip empty resources */
1008 		if (!pci_resource_len(pdev, i))
1009 			continue;
1010 
1011 		retval = pci_create_attr(pdev, i, 0);
1012 		/* for prefetchable resources, create a WC mappable file */
1013 		if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
1014 			retval = pci_create_attr(pdev, i, 1);
1015 
1016 		if (retval) {
1017 			pci_remove_resource_files(pdev);
1018 			return retval;
1019 		}
1020 	}
1021 	return 0;
1022 }
1023 #else /* !HAVE_PCI_MMAP */
1024 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
1025 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
1026 #endif /* HAVE_PCI_MMAP */
1027 
1028 /**
1029  * pci_write_rom - used to enable access to the PCI ROM display
1030  * @filp: sysfs file
1031  * @kobj: kernel object handle
1032  * @bin_attr: struct bin_attribute for this file
1033  * @buf: user input
1034  * @off: file offset
1035  * @count: number of byte in input
1036  *
1037  * writing anything except 0 enables it
1038  */
1039 static ssize_t
1040 pci_write_rom(struct file *filp, struct kobject *kobj,
1041 	      struct bin_attribute *bin_attr,
1042 	      char *buf, loff_t off, size_t count)
1043 {
1044 	struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
1045 
1046 	if ((off ==  0) && (*buf == '0') && (count == 2))
1047 		pdev->rom_attr_enabled = 0;
1048 	else
1049 		pdev->rom_attr_enabled = 1;
1050 
1051 	return count;
1052 }
1053 
1054 /**
1055  * pci_read_rom - read a PCI ROM
1056  * @filp: sysfs file
1057  * @kobj: kernel object handle
1058  * @bin_attr: struct bin_attribute for this file
1059  * @buf: where to put the data we read from the ROM
1060  * @off: file offset
1061  * @count: number of bytes to read
1062  *
1063  * Put @count bytes starting at @off into @buf from the ROM in the PCI
1064  * device corresponding to @kobj.
1065  */
1066 static ssize_t
1067 pci_read_rom(struct file *filp, struct kobject *kobj,
1068 	     struct bin_attribute *bin_attr,
1069 	     char *buf, loff_t off, size_t count)
1070 {
1071 	struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
1072 	void __iomem *rom;
1073 	size_t size;
1074 
1075 	if (!pdev->rom_attr_enabled)
1076 		return -EINVAL;
1077 
1078 	rom = pci_map_rom(pdev, &size);	/* size starts out as PCI window size */
1079 	if (!rom || !size)
1080 		return -EIO;
1081 
1082 	if (off >= size)
1083 		count = 0;
1084 	else {
1085 		if (off + count > size)
1086 			count = size - off;
1087 
1088 		memcpy_fromio(buf, rom + off, count);
1089 	}
1090 	pci_unmap_rom(pdev, rom);
1091 
1092 	return count;
1093 }
1094 
1095 static struct bin_attribute pci_config_attr = {
1096 	.attr =	{
1097 		.name = "config",
1098 		.mode = S_IRUGO | S_IWUSR,
1099 	},
1100 	.size = PCI_CFG_SPACE_SIZE,
1101 	.read = pci_read_config,
1102 	.write = pci_write_config,
1103 };
1104 
1105 static struct bin_attribute pcie_config_attr = {
1106 	.attr =	{
1107 		.name = "config",
1108 		.mode = S_IRUGO | S_IWUSR,
1109 	},
1110 	.size = PCI_CFG_SPACE_EXP_SIZE,
1111 	.read = pci_read_config,
1112 	.write = pci_write_config,
1113 };
1114 
1115 int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
1116 {
1117 	return 0;
1118 }
1119 
1120 static ssize_t reset_store(struct device *dev,
1121 			   struct device_attribute *attr, const char *buf,
1122 			   size_t count)
1123 {
1124 	struct pci_dev *pdev = to_pci_dev(dev);
1125 	unsigned long val;
1126 	ssize_t result = strict_strtoul(buf, 0, &val);
1127 
1128 	if (result < 0)
1129 		return result;
1130 
1131 	if (val != 1)
1132 		return -EINVAL;
1133 
1134 	result = pci_reset_function(pdev);
1135 	if (result < 0)
1136 		return result;
1137 
1138 	return count;
1139 }
1140 
1141 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);
1142 
1143 static int pci_create_capabilities_sysfs(struct pci_dev *dev)
1144 {
1145 	int retval;
1146 	struct bin_attribute *attr;
1147 
1148 	/* If the device has VPD, try to expose it in sysfs. */
1149 	if (dev->vpd) {
1150 		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1151 		if (!attr)
1152 			return -ENOMEM;
1153 
1154 		sysfs_bin_attr_init(attr);
1155 		attr->size = dev->vpd->len;
1156 		attr->attr.name = "vpd";
1157 		attr->attr.mode = S_IRUSR | S_IWUSR;
1158 		attr->read = read_vpd_attr;
1159 		attr->write = write_vpd_attr;
1160 		retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
1161 		if (retval) {
1162 			kfree(attr);
1163 			return retval;
1164 		}
1165 		dev->vpd->attr = attr;
1166 	}
1167 
1168 	/* Active State Power Management */
1169 	pcie_aspm_create_sysfs_dev_files(dev);
1170 
1171 	if (!pci_probe_reset_function(dev)) {
1172 		retval = device_create_file(&dev->dev, &reset_attr);
1173 		if (retval)
1174 			goto error;
1175 		dev->reset_fn = 1;
1176 	}
1177 	return 0;
1178 
1179 error:
1180 	pcie_aspm_remove_sysfs_dev_files(dev);
1181 	if (dev->vpd && dev->vpd->attr) {
1182 		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1183 		kfree(dev->vpd->attr);
1184 	}
1185 
1186 	return retval;
1187 }
1188 
1189 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
1190 {
1191 	int retval;
1192 	int rom_size = 0;
1193 	struct bin_attribute *attr;
1194 
1195 	if (!sysfs_initialized)
1196 		return -EACCES;
1197 
1198 	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1199 		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
1200 	else
1201 		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1202 	if (retval)
1203 		goto err;
1204 
1205 	retval = pci_create_resource_files(pdev);
1206 	if (retval)
1207 		goto err_config_file;
1208 
1209 	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
1210 		rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1211 	else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
1212 		rom_size = 0x20000;
1213 
1214 	/* If the device has a ROM, try to expose it in sysfs. */
1215 	if (rom_size) {
1216 		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1217 		if (!attr) {
1218 			retval = -ENOMEM;
1219 			goto err_resource_files;
1220 		}
1221 		sysfs_bin_attr_init(attr);
1222 		attr->size = rom_size;
1223 		attr->attr.name = "rom";
1224 		attr->attr.mode = S_IRUSR | S_IWUSR;
1225 		attr->read = pci_read_rom;
1226 		attr->write = pci_write_rom;
1227 		retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
1228 		if (retval) {
1229 			kfree(attr);
1230 			goto err_resource_files;
1231 		}
1232 		pdev->rom_attr = attr;
1233 	}
1234 
1235 	if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) {
1236 		retval = device_create_file(&pdev->dev, &vga_attr);
1237 		if (retval)
1238 			goto err_rom_file;
1239 	}
1240 
1241 	/* add platform-specific attributes */
1242 	retval = pcibios_add_platform_entries(pdev);
1243 	if (retval)
1244 		goto err_vga_file;
1245 
1246 	/* add sysfs entries for various capabilities */
1247 	retval = pci_create_capabilities_sysfs(pdev);
1248 	if (retval)
1249 		goto err_vga_file;
1250 
1251 	pci_create_firmware_label_files(pdev);
1252 
1253 	return 0;
1254 
1255 err_vga_file:
1256 	if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
1257 		device_remove_file(&pdev->dev, &vga_attr);
1258 err_rom_file:
1259 	if (rom_size) {
1260 		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1261 		kfree(pdev->rom_attr);
1262 		pdev->rom_attr = NULL;
1263 	}
1264 err_resource_files:
1265 	pci_remove_resource_files(pdev);
1266 err_config_file:
1267 	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1268 		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1269 	else
1270 		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1271 err:
1272 	return retval;
1273 }
1274 
1275 static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
1276 {
1277 	if (dev->vpd && dev->vpd->attr) {
1278 		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1279 		kfree(dev->vpd->attr);
1280 	}
1281 
1282 	pcie_aspm_remove_sysfs_dev_files(dev);
1283 	if (dev->reset_fn) {
1284 		device_remove_file(&dev->dev, &reset_attr);
1285 		dev->reset_fn = 0;
1286 	}
1287 }
1288 
1289 /**
1290  * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
1291  * @pdev: device whose entries we should free
1292  *
1293  * Cleanup when @pdev is removed from sysfs.
1294  */
1295 void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
1296 {
1297 	int rom_size = 0;
1298 
1299 	if (!sysfs_initialized)
1300 		return;
1301 
1302 	pci_remove_capabilities_sysfs(pdev);
1303 
1304 	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1305 		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1306 	else
1307 		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1308 
1309 	pci_remove_resource_files(pdev);
1310 
1311 	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
1312 		rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1313 	else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
1314 		rom_size = 0x20000;
1315 
1316 	if (rom_size && pdev->rom_attr) {
1317 		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1318 		kfree(pdev->rom_attr);
1319 	}
1320 
1321 	pci_remove_firmware_label_files(pdev);
1322 
1323 }
1324 
1325 static int __init pci_sysfs_init(void)
1326 {
1327 	struct pci_dev *pdev = NULL;
1328 	int retval;
1329 
1330 	sysfs_initialized = 1;
1331 	for_each_pci_dev(pdev) {
1332 		retval = pci_create_sysfs_dev_files(pdev);
1333 		if (retval) {
1334 			pci_dev_put(pdev);
1335 			return retval;
1336 		}
1337 	}
1338 
1339 	return 0;
1340 }
1341 
1342 late_initcall(pci_sysfs_init);
1343