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