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