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