blob: b5a7d9bfcb24a70523a33793e60d217475fc9a91 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
Linus Torvaldsb5ff7df2008-10-02 18:52:51 -070019#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/pci.h>
21#include <linux/stat.h>
22#include <linux/topology.h>
23#include <linux/mm.h>
Chris Wrightde139a32010-05-13 10:43:07 -070024#include <linux/fs.h>
Alexey Dobriyanaa0ac362007-07-15 23:40:39 -070025#include <linux/capability.h>
Shaohua Li7d715a62008-02-25 09:46:41 +080026#include <linux/pci-aspm.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "pci.h"
29
30static int sysfs_initialized; /* = 0 */
31
32/* show configuration fields */
33#define pci_config_attr(field, format_string) \
34static ssize_t \
Yani Ioannoue404e272005-05-17 06:42:58 -040035field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070036{ \
37 struct pci_dev *pdev; \
38 \
39 pdev = to_pci_dev (dev); \
40 return sprintf (buf, format_string, pdev->field); \
41}
42
43pci_config_attr(vendor, "0x%04x\n");
44pci_config_attr(device, "0x%04x\n");
45pci_config_attr(subsystem_vendor, "0x%04x\n");
46pci_config_attr(subsystem_device, "0x%04x\n");
47pci_config_attr(class, "0x%06x\n");
48pci_config_attr(irq, "%u\n");
49
Doug Thompsonbdee9d92006-06-14 16:59:48 -070050static ssize_t broken_parity_status_show(struct device *dev,
51 struct device_attribute *attr,
52 char *buf)
53{
54 struct pci_dev *pdev = to_pci_dev(dev);
55 return sprintf (buf, "%u\n", pdev->broken_parity_status);
56}
57
58static ssize_t broken_parity_status_store(struct device *dev,
59 struct device_attribute *attr,
60 const char *buf, size_t count)
61{
62 struct pci_dev *pdev = to_pci_dev(dev);
Trent Piepho92425a42008-11-30 17:10:12 -080063 unsigned long val;
Doug Thompsonbdee9d92006-06-14 16:59:48 -070064
Trent Piepho92425a42008-11-30 17:10:12 -080065 if (strict_strtoul(buf, 0, &val) < 0)
66 return -EINVAL;
67
68 pdev->broken_parity_status = !!val;
69
70 return count;
Doug Thompsonbdee9d92006-06-14 16:59:48 -070071}
72
Alan Cox4327edf2005-09-10 00:25:49 -070073static ssize_t local_cpus_show(struct device *dev,
74 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
Mike Travis3be83052009-01-04 05:18:01 -080076 const struct cpumask *mask;
Alan Cox4327edf2005-09-10 00:25:49 -070077 int len;
78
Andreas Herrmanne0cd5162009-04-17 12:01:55 +020079#ifdef CONFIG_NUMA
David John6be954d2010-01-04 20:28:57 +053080 mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
81 cpumask_of_node(dev_to_node(dev));
Andreas Herrmanne0cd5162009-04-17 12:01:55 +020082#else
Mike Travis3be83052009-01-04 05:18:01 -080083 mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
Andreas Herrmanne0cd5162009-04-17 12:01:55 +020084#endif
Mike Travis3be83052009-01-04 05:18:01 -080085 len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
Mike Travis39106dc2008-04-08 11:43:03 -070086 buf[len++] = '\n';
87 buf[len] = '\0';
88 return len;
89}
90
91
92static ssize_t local_cpulist_show(struct device *dev,
93 struct device_attribute *attr, char *buf)
94{
Mike Travis3be83052009-01-04 05:18:01 -080095 const struct cpumask *mask;
Mike Travis39106dc2008-04-08 11:43:03 -070096 int len;
97
Andreas Herrmanne0cd5162009-04-17 12:01:55 +020098#ifdef CONFIG_NUMA
David John6be954d2010-01-04 20:28:57 +053099 mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
100 cpumask_of_node(dev_to_node(dev));
Andreas Herrmanne0cd5162009-04-17 12:01:55 +0200101#else
Mike Travis3be83052009-01-04 05:18:01 -0800102 mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
Andreas Herrmanne0cd5162009-04-17 12:01:55 +0200103#endif
Mike Travis3be83052009-01-04 05:18:01 -0800104 len = cpulist_scnprintf(buf, PAGE_SIZE-2, mask);
Mike Travis39106dc2008-04-08 11:43:03 -0700105 buf[len++] = '\n';
106 buf[len] = '\0';
107 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
110/* show resources */
111static ssize_t
Yani Ioannoue404e272005-05-17 06:42:58 -0400112resource_show(struct device * dev, struct device_attribute *attr, char * buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
114 struct pci_dev * pci_dev = to_pci_dev(dev);
115 char * str = buf;
116 int i;
Yu Zhaofde09c62008-11-22 02:39:32 +0800117 int max;
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700118 resource_size_t start, end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120 if (pci_dev->subordinate)
121 max = DEVICE_COUNT_RESOURCE;
Yu Zhaofde09c62008-11-22 02:39:32 +0800122 else
123 max = PCI_BRIDGE_RESOURCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125 for (i = 0; i < max; i++) {
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000126 struct resource *res = &pci_dev->resource[i];
127 pci_resource_to_user(pci_dev, i, res, &start, &end);
128 str += sprintf(str,"0x%016llx 0x%016llx 0x%016llx\n",
129 (unsigned long long)start,
130 (unsigned long long)end,
131 (unsigned long long)res->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 }
133 return (str - buf);
134}
135
Greg Kroah-Hartman87c8a442005-06-19 12:21:43 +0200136static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
Greg KH98885492005-05-05 11:57:25 -0700137{
138 struct pci_dev *pci_dev = to_pci_dev(dev);
139
140 return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x\n",
141 pci_dev->vendor, pci_dev->device,
142 pci_dev->subsystem_vendor, pci_dev->subsystem_device,
143 (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
144 (u8)(pci_dev->class));
145}
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800146
147static ssize_t is_enabled_store(struct device *dev,
148 struct device_attribute *attr, const char *buf,
149 size_t count)
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200150{
151 struct pci_dev *pdev = to_pci_dev(dev);
Trent Piepho92425a42008-11-30 17:10:12 -0800152 unsigned long val;
153 ssize_t result = strict_strtoul(buf, 0, &val);
154
155 if (result < 0)
156 return result;
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200157
158 /* this can crash the machine when done on the "wrong" device */
159 if (!capable(CAP_SYS_ADMIN))
Trent Piepho92425a42008-11-30 17:10:12 -0800160 return -EPERM;
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200161
Trent Piepho92425a42008-11-30 17:10:12 -0800162 if (!val) {
Yuji Shimada296ccb02009-04-03 16:41:46 +0900163 if (pci_is_enabled(pdev))
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800164 pci_disable_device(pdev);
165 else
166 result = -EIO;
Trent Piepho92425a42008-11-30 17:10:12 -0800167 } else
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800168 result = pci_enable_device(pdev);
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200169
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800170 return result < 0 ? result : count;
171}
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200172
Inaky Perez-Gonzalezbae94d02006-11-22 12:40:31 -0800173static ssize_t is_enabled_show(struct device *dev,
174 struct device_attribute *attr, char *buf)
175{
176 struct pci_dev *pdev;
177
178 pdev = to_pci_dev (dev);
179 return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt));
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200180}
181
Brice Goglin81bb0e12007-01-28 10:53:40 +0100182#ifdef CONFIG_NUMA
183static ssize_t
184numa_node_show(struct device *dev, struct device_attribute *attr, char *buf)
185{
186 return sprintf (buf, "%d\n", dev->numa_node);
187}
188#endif
189
Brice Goglinfe970642006-08-31 01:55:15 -0400190static ssize_t
Yinghai Lubb965402009-11-24 18:21:21 -0800191dma_mask_bits_show(struct device *dev, struct device_attribute *attr, char *buf)
192{
193 struct pci_dev *pdev = to_pci_dev(dev);
194
195 return sprintf (buf, "%d\n", fls64(pdev->dma_mask));
196}
197
198static ssize_t
199consistent_dma_mask_bits_show(struct device *dev, struct device_attribute *attr,
200 char *buf)
201{
202 return sprintf (buf, "%d\n", fls64(dev->coherent_dma_mask));
203}
204
205static ssize_t
Brice Goglinfe970642006-08-31 01:55:15 -0400206msi_bus_show(struct device *dev, struct device_attribute *attr, char *buf)
207{
208 struct pci_dev *pdev = to_pci_dev(dev);
209
210 if (!pdev->subordinate)
211 return 0;
212
213 return sprintf (buf, "%u\n",
214 !(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI));
215}
216
217static ssize_t
218msi_bus_store(struct device *dev, struct device_attribute *attr,
219 const char *buf, size_t count)
220{
221 struct pci_dev *pdev = to_pci_dev(dev);
Trent Piepho92425a42008-11-30 17:10:12 -0800222 unsigned long val;
223
224 if (strict_strtoul(buf, 0, &val) < 0)
225 return -EINVAL;
Brice Goglinfe970642006-08-31 01:55:15 -0400226
227 /* bad things may happen if the no_msi flag is changed
228 * while some drivers are loaded */
229 if (!capable(CAP_SYS_ADMIN))
Trent Piepho92425a42008-11-30 17:10:12 -0800230 return -EPERM;
Brice Goglinfe970642006-08-31 01:55:15 -0400231
Trent Piepho92425a42008-11-30 17:10:12 -0800232 /* Maybe pci devices without subordinate busses shouldn't even have this
233 * attribute in the first place? */
Brice Goglinfe970642006-08-31 01:55:15 -0400234 if (!pdev->subordinate)
235 return count;
236
Trent Piepho92425a42008-11-30 17:10:12 -0800237 /* Is the flag going to change, or keep the value it already had? */
238 if (!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI) ^
239 !!val) {
240 pdev->subordinate->bus_flags ^= PCI_BUS_FLAGS_NO_MSI;
Brice Goglinfe970642006-08-31 01:55:15 -0400241
Trent Piepho92425a42008-11-30 17:10:12 -0800242 dev_warn(&pdev->dev, "forced subordinate bus to%s support MSI,"
243 " bad things could happen\n", val ? "" : " not");
Brice Goglinfe970642006-08-31 01:55:15 -0400244 }
245
246 return count;
247}
Greg KH98885492005-05-05 11:57:25 -0700248
Alex Chiang705b1aa2009-03-20 14:56:31 -0600249#ifdef CONFIG_HOTPLUG
250static DEFINE_MUTEX(pci_remove_rescan_mutex);
251static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
252 size_t count)
253{
254 unsigned long val;
255 struct pci_bus *b = NULL;
256
257 if (strict_strtoul(buf, 0, &val) < 0)
258 return -EINVAL;
259
260 if (val) {
261 mutex_lock(&pci_remove_rescan_mutex);
262 while ((b = pci_find_next_bus(b)) != NULL)
263 pci_rescan_bus(b);
264 mutex_unlock(&pci_remove_rescan_mutex);
265 }
266 return count;
267}
268
269struct bus_attribute pci_bus_attrs[] = {
270 __ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store),
271 __ATTR_NULL
272};
Alex Chiang77c27c72009-03-20 14:56:36 -0600273
Alex Chiang738a6392009-03-20 14:56:41 -0600274static ssize_t
275dev_rescan_store(struct device *dev, struct device_attribute *attr,
276 const char *buf, size_t count)
277{
278 unsigned long val;
279 struct pci_dev *pdev = to_pci_dev(dev);
280
281 if (strict_strtoul(buf, 0, &val) < 0)
282 return -EINVAL;
283
284 if (val) {
285 mutex_lock(&pci_remove_rescan_mutex);
286 pci_rescan_bus(pdev->bus);
287 mutex_unlock(&pci_remove_rescan_mutex);
288 }
289 return count;
290}
291
Alex Chiang77c27c72009-03-20 14:56:36 -0600292static void remove_callback(struct device *dev)
293{
294 struct pci_dev *pdev = to_pci_dev(dev);
295
296 mutex_lock(&pci_remove_rescan_mutex);
297 pci_remove_bus_device(pdev);
298 mutex_unlock(&pci_remove_rescan_mutex);
299}
300
301static ssize_t
302remove_store(struct device *dev, struct device_attribute *dummy,
303 const char *buf, size_t count)
304{
305 int ret = 0;
306 unsigned long val;
Alex Chiang77c27c72009-03-20 14:56:36 -0600307
308 if (strict_strtoul(buf, 0, &val) < 0)
309 return -EINVAL;
310
Alex Chiang77c27c72009-03-20 14:56:36 -0600311 /* An attribute cannot be unregistered by one of its own methods,
312 * so we have to use this roundabout approach.
313 */
314 if (val)
315 ret = device_schedule_callback(dev, remove_callback);
316 if (ret)
317 count = ret;
318 return count;
319}
Alex Chiang705b1aa2009-03-20 14:56:31 -0600320#endif
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322struct device_attribute pci_dev_attrs[] = {
323 __ATTR_RO(resource),
324 __ATTR_RO(vendor),
325 __ATTR_RO(device),
326 __ATTR_RO(subsystem_vendor),
327 __ATTR_RO(subsystem_device),
328 __ATTR_RO(class),
329 __ATTR_RO(irq),
330 __ATTR_RO(local_cpus),
Mike Travis39106dc2008-04-08 11:43:03 -0700331 __ATTR_RO(local_cpulist),
Greg KH98885492005-05-05 11:57:25 -0700332 __ATTR_RO(modalias),
Brice Goglin81bb0e12007-01-28 10:53:40 +0100333#ifdef CONFIG_NUMA
334 __ATTR_RO(numa_node),
335#endif
Yinghai Lubb965402009-11-24 18:21:21 -0800336 __ATTR_RO(dma_mask_bits),
337 __ATTR_RO(consistent_dma_mask_bits),
Arjan van de Ven9f125d32006-04-29 10:59:08 +0200338 __ATTR(enable, 0600, is_enabled_show, is_enabled_store),
Doug Thompsonbdee9d92006-06-14 16:59:48 -0700339 __ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
340 broken_parity_status_show,broken_parity_status_store),
Brice Goglinfe970642006-08-31 01:55:15 -0400341 __ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store),
Alex Chiang77c27c72009-03-20 14:56:36 -0600342#ifdef CONFIG_HOTPLUG
343 __ATTR(remove, (S_IWUSR|S_IWGRP), NULL, remove_store),
Alex Chiang738a6392009-03-20 14:56:41 -0600344 __ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_rescan_store),
Alex Chiang77c27c72009-03-20 14:56:36 -0600345#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 __ATTR_NULL,
347};
348
349static ssize_t
Dave Airlie217f45d2009-03-04 05:57:05 +0000350boot_vga_show(struct device *dev, struct device_attribute *attr, char *buf)
351{
352 struct pci_dev *pdev = to_pci_dev(dev);
353
354 return sprintf(buf, "%u\n",
355 !!(pdev->resource[PCI_ROM_RESOURCE].flags &
356 IORESOURCE_ROM_SHADOW));
357}
358struct device_attribute vga_attr = __ATTR_RO(boot_vga);
359
360static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700361pci_read_config(struct file *filp, struct kobject *kobj,
362 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800363 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364{
365 struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
366 unsigned int size = 64;
367 loff_t init_off = off;
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900368 u8 *data = (u8*) buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 /* Several chips lock up trying to read undefined config space */
Chris Wrightde139a32010-05-13 10:43:07 -0700371 if (cap_raised(filp->f_cred->cap_effective, CAP_SYS_ADMIN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 size = dev->cfg_size;
373 } else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
374 size = 128;
375 }
376
377 if (off > size)
378 return 0;
379 if (off + count > size) {
380 size -= off;
381 count = size;
382 } else {
383 size = count;
384 }
385
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900386 if ((off & 1) && size) {
387 u8 val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700388 pci_user_read_config_byte(dev, off, &val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900389 data[off - init_off] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 off++;
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900391 size--;
392 }
393
394 if ((off & 3) && size > 2) {
395 u16 val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700396 pci_user_read_config_word(dev, off, &val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900397 data[off - init_off] = val & 0xff;
398 data[off - init_off + 1] = (val >> 8) & 0xff;
399 off += 2;
400 size -= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 }
402
403 while (size > 3) {
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900404 u32 val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700405 pci_user_read_config_dword(dev, off, &val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900406 data[off - init_off] = val & 0xff;
407 data[off - init_off + 1] = (val >> 8) & 0xff;
408 data[off - init_off + 2] = (val >> 16) & 0xff;
409 data[off - init_off + 3] = (val >> 24) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 off += 4;
411 size -= 4;
412 }
413
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900414 if (size >= 2) {
415 u16 val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700416 pci_user_read_config_word(dev, off, &val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900417 data[off - init_off] = val & 0xff;
418 data[off - init_off + 1] = (val >> 8) & 0xff;
419 off += 2;
420 size -= 2;
421 }
422
423 if (size > 0) {
424 u8 val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700425 pci_user_read_config_byte(dev, off, &val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900426 data[off - init_off] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 off++;
428 --size;
429 }
430
431 return count;
432}
433
434static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700435pci_write_config(struct file* filp, struct kobject *kobj,
436 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800437 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
440 unsigned int size = count;
441 loff_t init_off = off;
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900442 u8 *data = (u8*) buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 if (off > dev->cfg_size)
445 return 0;
446 if (off + count > dev->cfg_size) {
447 size = dev->cfg_size - off;
448 count = size;
449 }
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900450
451 if ((off & 1) && size) {
Brian Kinge04b0ea2005-09-27 01:21:55 -0700452 pci_user_write_config_byte(dev, off, data[off - init_off]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 off++;
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900454 size--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 }
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900456
457 if ((off & 3) && size > 2) {
458 u16 val = data[off - init_off];
459 val |= (u16) data[off - init_off + 1] << 8;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700460 pci_user_write_config_word(dev, off, val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900461 off += 2;
462 size -= 2;
463 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465 while (size > 3) {
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900466 u32 val = data[off - init_off];
467 val |= (u32) data[off - init_off + 1] << 8;
468 val |= (u32) data[off - init_off + 2] << 16;
469 val |= (u32) data[off - init_off + 3] << 24;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700470 pci_user_write_config_dword(dev, off, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 off += 4;
472 size -= 4;
473 }
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900474
475 if (size >= 2) {
476 u16 val = data[off - init_off];
477 val |= (u16) data[off - init_off + 1] << 8;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700478 pci_user_write_config_word(dev, off, val);
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900479 off += 2;
480 size -= 2;
481 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
ssant@in.ibm.com4c0619a2005-04-08 14:53:31 +0900483 if (size) {
Brian Kinge04b0ea2005-09-27 01:21:55 -0700484 pci_user_write_config_byte(dev, off, data[off - init_off]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 off++;
486 --size;
487 }
488
489 return count;
490}
491
Ben Hutchings94e61082008-03-05 16:52:39 +0000492static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700493read_vpd_attr(struct file *filp, struct kobject *kobj,
494 struct bin_attribute *bin_attr,
Ben Hutchings94e61082008-03-05 16:52:39 +0000495 char *buf, loff_t off, size_t count)
496{
497 struct pci_dev *dev =
498 to_pci_dev(container_of(kobj, struct device, kobj));
Ben Hutchings94e61082008-03-05 16:52:39 +0000499
500 if (off > bin_attr->size)
501 count = 0;
502 else if (count > bin_attr->size - off)
503 count = bin_attr->size - off;
Ben Hutchings94e61082008-03-05 16:52:39 +0000504
Stephen Hemminger287d19c2008-12-18 09:17:16 -0800505 return pci_read_vpd(dev, off, count, buf);
506}
Ben Hutchings94e61082008-03-05 16:52:39 +0000507
Stephen Hemminger287d19c2008-12-18 09:17:16 -0800508static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700509write_vpd_attr(struct file *filp, struct kobject *kobj,
510 struct bin_attribute *bin_attr,
Stephen Hemminger287d19c2008-12-18 09:17:16 -0800511 char *buf, loff_t off, size_t count)
512{
513 struct pci_dev *dev =
514 to_pci_dev(container_of(kobj, struct device, kobj));
515
516 if (off > bin_attr->size)
517 count = 0;
518 else if (count > bin_attr->size - off)
519 count = bin_attr->size - off;
520
521 return pci_write_vpd(dev, off, count, buf);
Ben Hutchings94e61082008-03-05 16:52:39 +0000522}
523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524#ifdef HAVE_PCI_LEGACY
525/**
526 * pci_read_legacy_io - read byte(s) from legacy I/O port space
Chris Wright2c3c8be2010-05-12 18:28:57 -0700527 * @filp: open sysfs file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 * @kobj: kobject corresponding to file to read from
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700529 * @bin_attr: struct bin_attribute for this file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 * @buf: buffer to store results
531 * @off: offset into legacy I/O port space
532 * @count: number of bytes to read
533 *
534 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
535 * callback routine (pci_legacy_read).
536 */
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000537static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700538pci_read_legacy_io(struct file *filp, struct kobject *kobj,
539 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800540 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
542 struct pci_bus *bus = to_pci_bus(container_of(kobj,
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400543 struct device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 kobj));
545
546 /* Only support 1, 2 or 4 byte accesses */
547 if (count != 1 && count != 2 && count != 4)
548 return -EINVAL;
549
550 return pci_legacy_read(bus, off, (u32 *)buf, count);
551}
552
553/**
554 * pci_write_legacy_io - write byte(s) to legacy I/O port space
Chris Wright2c3c8be2010-05-12 18:28:57 -0700555 * @filp: open sysfs file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 * @kobj: kobject corresponding to file to read from
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700557 * @bin_attr: struct bin_attribute for this file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 * @buf: buffer containing value to be written
559 * @off: offset into legacy I/O port space
560 * @count: number of bytes to write
561 *
562 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
563 * callback routine (pci_legacy_write).
564 */
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000565static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700566pci_write_legacy_io(struct file *filp, struct kobject *kobj,
567 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800568 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
570 struct pci_bus *bus = to_pci_bus(container_of(kobj,
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400571 struct device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 kobj));
573 /* Only support 1, 2 or 4 byte accesses */
574 if (count != 1 && count != 2 && count != 4)
575 return -EINVAL;
576
577 return pci_legacy_write(bus, off, *(u32 *)buf, count);
578}
579
580/**
581 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
Chris Wright2c3c8be2010-05-12 18:28:57 -0700582 * @filp: open sysfs file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 * @kobj: kobject corresponding to device to be mapped
584 * @attr: struct bin_attribute for this file
585 * @vma: struct vm_area_struct passed to mmap
586 *
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000587 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 * legacy memory space (first meg of bus space) into application virtual
589 * memory space.
590 */
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000591static int
Chris Wright2c3c8be2010-05-12 18:28:57 -0700592pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
593 struct bin_attribute *attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 struct vm_area_struct *vma)
595{
596 struct pci_bus *bus = to_pci_bus(container_of(kobj,
Greg Kroah-Hartmanfd7d1ce2007-05-22 22:47:54 -0400597 struct device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 kobj));
599
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000600 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
601}
602
603/**
604 * pci_mmap_legacy_io - map legacy PCI IO into user memory space
Chris Wright2c3c8be2010-05-12 18:28:57 -0700605 * @filp: open sysfs file
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000606 * @kobj: kobject corresponding to device to be mapped
607 * @attr: struct bin_attribute for this file
608 * @vma: struct vm_area_struct passed to mmap
609 *
610 * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
611 * legacy IO space (first meg of bus space) into application virtual
612 * memory space. Returns -ENOSYS if the operation isn't supported
613 */
614static int
Chris Wright2c3c8be2010-05-12 18:28:57 -0700615pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
616 struct bin_attribute *attr,
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000617 struct vm_area_struct *vma)
618{
619 struct pci_bus *bus = to_pci_bus(container_of(kobj,
620 struct device,
621 kobj));
622
623 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
624}
625
626/**
Ivan Kokshaysky10a0ef32009-02-17 13:46:53 +0300627 * pci_adjust_legacy_attr - adjustment of legacy file attributes
628 * @b: bus to create files under
629 * @mmap_type: I/O port or memory
630 *
631 * Stub implementation. Can be overridden by arch if necessary.
632 */
633void __weak
634pci_adjust_legacy_attr(struct pci_bus *b, enum pci_mmap_state mmap_type)
635{
636 return;
637}
638
639/**
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000640 * pci_create_legacy_files - create legacy I/O port and memory files
641 * @b: bus to create files under
642 *
643 * Some platforms allow access to legacy I/O port and ISA memory space on
644 * a per-bus basis. This routine creates the files and ties them into
645 * their associated read, write and mmap files from pci-sysfs.c
646 *
647 * On error unwind, but don't propogate the error to the caller
648 * as it is ok to set up the PCI bus without these files.
649 */
650void pci_create_legacy_files(struct pci_bus *b)
651{
652 int error;
653
654 b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
655 GFP_ATOMIC);
656 if (!b->legacy_io)
657 goto kzalloc_err;
658
Stephen Rothwell62e877b82010-03-01 20:38:36 +1100659 sysfs_bin_attr_init(b->legacy_io);
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000660 b->legacy_io->attr.name = "legacy_io";
661 b->legacy_io->size = 0xffff;
662 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
663 b->legacy_io->read = pci_read_legacy_io;
664 b->legacy_io->write = pci_write_legacy_io;
665 b->legacy_io->mmap = pci_mmap_legacy_io;
Ivan Kokshaysky10a0ef32009-02-17 13:46:53 +0300666 pci_adjust_legacy_attr(b, pci_mmap_io);
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000667 error = device_create_bin_file(&b->dev, b->legacy_io);
668 if (error)
669 goto legacy_io_err;
670
671 /* Allocated above after the legacy_io struct */
672 b->legacy_mem = b->legacy_io + 1;
Mel Gorman6757eca32010-03-10 22:48:34 +0000673 sysfs_bin_attr_init(b->legacy_mem);
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000674 b->legacy_mem->attr.name = "legacy_mem";
675 b->legacy_mem->size = 1024*1024;
676 b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
677 b->legacy_mem->mmap = pci_mmap_legacy_mem;
Ivan Kokshaysky10a0ef32009-02-17 13:46:53 +0300678 pci_adjust_legacy_attr(b, pci_mmap_mem);
Benjamin Herrenschmidtf19aeb12008-10-03 19:49:32 +1000679 error = device_create_bin_file(&b->dev, b->legacy_mem);
680 if (error)
681 goto legacy_mem_err;
682
683 return;
684
685legacy_mem_err:
686 device_remove_bin_file(&b->dev, b->legacy_io);
687legacy_io_err:
688 kfree(b->legacy_io);
689 b->legacy_io = NULL;
690kzalloc_err:
691 printk(KERN_WARNING "pci: warning: could not create legacy I/O port "
692 "and ISA memory resources to sysfs\n");
693 return;
694}
695
696void pci_remove_legacy_files(struct pci_bus *b)
697{
698 if (b->legacy_io) {
699 device_remove_bin_file(&b->dev, b->legacy_io);
700 device_remove_bin_file(&b->dev, b->legacy_mem);
701 kfree(b->legacy_io); /* both are allocated here */
702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
704#endif /* HAVE_PCI_LEGACY */
705
706#ifdef HAVE_PCI_MMAP
Linus Torvaldsb5ff7df2008-10-02 18:52:51 -0700707
Jesse Barnes9eff02e2008-10-24 10:32:33 -0700708int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma)
Linus Torvaldsb5ff7df2008-10-02 18:52:51 -0700709{
710 unsigned long nr, start, size;
711
712 nr = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
713 start = vma->vm_pgoff;
Ed Swierk88e7df02008-11-03 14:41:16 -0800714 size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
Linus Torvaldsb5ff7df2008-10-02 18:52:51 -0700715 if (start < size && size - start >= nr)
716 return 1;
717 WARN(1, "process \"%s\" tried to map 0x%08lx-0x%08lx on %s BAR %d (size 0x%08lx)\n",
718 current->comm, start, start+nr, pci_name(pdev), resno, size);
719 return 0;
720}
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722/**
723 * pci_mmap_resource - map a PCI resource into user memory space
724 * @kobj: kobject for mapping
725 * @attr: struct bin_attribute for the file being mapped
726 * @vma: struct vm_area_struct passed into the mmap
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700727 * @write_combine: 1 for write_combine mapping
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 *
729 * Use the regular PCI mapping routines to map a PCI resource into userspace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 */
731static int
732pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700733 struct vm_area_struct *vma, int write_combine)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
735 struct pci_dev *pdev = to_pci_dev(container_of(kobj,
736 struct device, kobj));
Kulikov Vasiliya3f58352010-06-29 14:15:28 +0400737 struct resource *res = attr->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 enum pci_mmap_state mmap_type;
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700739 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000740 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000742 for (i = 0; i < PCI_ROM_RESOURCE; i++)
743 if (res == &pdev->resource[i])
744 break;
745 if (i >= PCI_ROM_RESOURCE)
746 return -ENODEV;
747
Linus Torvaldsb5ff7df2008-10-02 18:52:51 -0700748 if (!pci_mmap_fits(pdev, i, vma))
749 return -EINVAL;
750
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000751 /* pci_mmap_page_range() expects the same kind of entry as coming
752 * from /proc/bus/pci/ which is a "user visible" value. If this is
753 * different from the resource itself, arch will do necessary fixup.
754 */
755 pci_resource_to_user(pdev, i, res, &start, &end);
756 vma->vm_pgoff += start >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;
758
Arjan van de Vene8de1482008-10-22 19:55:31 -0700759 if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
760 return -EINVAL;
761
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700762 return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
763}
764
765static int
Chris Wright2c3c8be2010-05-12 18:28:57 -0700766pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
767 struct bin_attribute *attr,
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700768 struct vm_area_struct *vma)
769{
770 return pci_mmap_resource(kobj, attr, vma, 0);
771}
772
773static int
Chris Wright2c3c8be2010-05-12 18:28:57 -0700774pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
775 struct bin_attribute *attr,
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700776 struct vm_area_struct *vma)
777{
778 return pci_mmap_resource(kobj, attr, vma, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779}
780
Alex Williamson86333282010-07-19 09:45:34 -0600781static ssize_t
782pci_resource_io(struct file *filp, struct kobject *kobj,
783 struct bin_attribute *attr, char *buf,
784 loff_t off, size_t count, bool write)
785{
786 struct pci_dev *pdev = to_pci_dev(container_of(kobj,
787 struct device, kobj));
788 struct resource *res = attr->private;
789 unsigned long port = off;
790 int i;
791
792 for (i = 0; i < PCI_ROM_RESOURCE; i++)
793 if (res == &pdev->resource[i])
794 break;
795 if (i >= PCI_ROM_RESOURCE)
796 return -ENODEV;
797
798 port += pci_resource_start(pdev, i);
799
800 if (port > pci_resource_end(pdev, i))
801 return 0;
802
803 if (port + count - 1 > pci_resource_end(pdev, i))
804 return -EINVAL;
805
806 switch (count) {
807 case 1:
808 if (write)
809 outb(*(u8 *)buf, port);
810 else
811 *(u8 *)buf = inb(port);
812 return 1;
813 case 2:
814 if (write)
815 outw(*(u16 *)buf, port);
816 else
817 *(u16 *)buf = inw(port);
818 return 2;
819 case 4:
820 if (write)
821 outl(*(u32 *)buf, port);
822 else
823 *(u32 *)buf = inl(port);
824 return 4;
825 }
826 return -EINVAL;
827}
828
829static ssize_t
830pci_read_resource_io(struct file *filp, struct kobject *kobj,
831 struct bin_attribute *attr, char *buf,
832 loff_t off, size_t count)
833{
834 return pci_resource_io(filp, kobj, attr, buf, off, count, false);
835}
836
837static ssize_t
838pci_write_resource_io(struct file *filp, struct kobject *kobj,
839 struct bin_attribute *attr, char *buf,
840 loff_t off, size_t count)
841{
842 return pci_resource_io(filp, kobj, attr, buf, off, count, true);
843}
844
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845/**
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700846 * pci_remove_resource_files - cleanup resource files
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700847 * @pdev: dev to cleanup
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700848 *
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700849 * If we created resource files for @pdev, remove them from sysfs and
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700850 * free their resources.
851 */
852static void
853pci_remove_resource_files(struct pci_dev *pdev)
854{
855 int i;
856
857 for (i = 0; i < PCI_ROM_RESOURCE; i++) {
858 struct bin_attribute *res_attr;
859
860 res_attr = pdev->res_attr[i];
861 if (res_attr) {
862 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
863 kfree(res_attr);
864 }
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700865
866 res_attr = pdev->res_attr_wc[i];
867 if (res_attr) {
868 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
869 kfree(res_attr);
870 }
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700871 }
872}
873
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700874static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
875{
876 /* allocate attribute structure, piggyback attribute name */
877 int name_len = write_combine ? 13 : 10;
878 struct bin_attribute *res_attr;
879 int retval;
880
881 res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
882 if (res_attr) {
883 char *res_attr_name = (char *)(res_attr + 1);
884
Eric W. Biedermana07e4152010-02-11 15:23:05 -0800885 sysfs_bin_attr_init(res_attr);
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700886 if (write_combine) {
887 pdev->res_attr_wc[num] = res_attr;
888 sprintf(res_attr_name, "resource%d_wc", num);
889 res_attr->mmap = pci_mmap_resource_wc;
890 } else {
891 pdev->res_attr[num] = res_attr;
892 sprintf(res_attr_name, "resource%d", num);
893 res_attr->mmap = pci_mmap_resource_uc;
894 }
Alex Williamson86333282010-07-19 09:45:34 -0600895 if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
896 res_attr->read = pci_read_resource_io;
897 res_attr->write = pci_write_resource_io;
898 }
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700899 res_attr->attr.name = res_attr_name;
900 res_attr->attr.mode = S_IRUSR | S_IWUSR;
901 res_attr->size = pci_resource_len(pdev, num);
902 res_attr->private = &pdev->resource[num];
903 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
904 } else
905 retval = -ENOMEM;
906
907 return retval;
908}
909
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700910/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 * pci_create_resource_files - create resource files in sysfs for @dev
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700912 * @pdev: dev in question
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 *
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700914 * Walk the resources in @pdev creating files for each resource available.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 */
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700916static int pci_create_resource_files(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
918 int i;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700919 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 /* Expose the PCI resources from this device as files */
922 for (i = 0; i < PCI_ROM_RESOURCE; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
924 /* skip empty resources */
925 if (!pci_resource_len(pdev, i))
926 continue;
927
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700928 retval = pci_create_attr(pdev, i, 0);
929 /* for prefetchable resources, create a WC mappable file */
930 if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
931 retval = pci_create_attr(pdev, i, 1);
Dmitry Torokhovd48593b2005-04-29 00:58:46 -0500932
venkatesh.pallipadi@intel.com45aec1ae2008-03-18 17:00:22 -0700933 if (retval) {
934 pci_remove_resource_files(pdev);
935 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 }
937 }
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700938 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939}
940#else /* !HAVE_PCI_MMAP */
Ivan Kokshaysky10a0ef32009-02-17 13:46:53 +0300941int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
942void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943#endif /* HAVE_PCI_MMAP */
944
945/**
946 * pci_write_rom - used to enable access to the PCI ROM display
Chris Wright2c3c8be2010-05-12 18:28:57 -0700947 * @filp: sysfs file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 * @kobj: kernel object handle
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700949 * @bin_attr: struct bin_attribute for this file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 * @buf: user input
951 * @off: file offset
952 * @count: number of byte in input
953 *
954 * writing anything except 0 enables it
955 */
956static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700957pci_write_rom(struct file *filp, struct kobject *kobj,
958 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800959 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
961 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
962
963 if ((off == 0) && (*buf == '0') && (count == 2))
964 pdev->rom_attr_enabled = 0;
965 else
966 pdev->rom_attr_enabled = 1;
967
968 return count;
969}
970
971/**
972 * pci_read_rom - read a PCI ROM
Chris Wright2c3c8be2010-05-12 18:28:57 -0700973 * @filp: sysfs file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 * @kobj: kernel object handle
Randy Dunlapcffb2fa2009-04-10 15:17:50 -0700975 * @bin_attr: struct bin_attribute for this file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 * @buf: where to put the data we read from the ROM
977 * @off: file offset
978 * @count: number of bytes to read
979 *
980 * Put @count bytes starting at @off into @buf from the ROM in the PCI
981 * device corresponding to @kobj.
982 */
983static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700984pci_read_rom(struct file *filp, struct kobject *kobj,
985 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800986 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987{
988 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
989 void __iomem *rom;
990 size_t size;
991
992 if (!pdev->rom_attr_enabled)
993 return -EINVAL;
994
995 rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */
Timothy S. Nelson97c44832009-01-30 06:12:47 +1100996 if (!rom || !size)
997 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
999 if (off >= size)
1000 count = 0;
1001 else {
1002 if (off + count > size)
1003 count = size - off;
1004
1005 memcpy_fromio(buf, rom + off, count);
1006 }
1007 pci_unmap_rom(pdev, rom);
1008
1009 return count;
1010}
1011
1012static struct bin_attribute pci_config_attr = {
1013 .attr = {
1014 .name = "config",
1015 .mode = S_IRUGO | S_IWUSR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 },
Zhao, Yu557848c2008-10-13 19:18:07 +08001017 .size = PCI_CFG_SPACE_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 .read = pci_read_config,
1019 .write = pci_write_config,
1020};
1021
1022static struct bin_attribute pcie_config_attr = {
1023 .attr = {
1024 .name = "config",
1025 .mode = S_IRUGO | S_IWUSR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 },
Zhao, Yu557848c2008-10-13 19:18:07 +08001027 .size = PCI_CFG_SPACE_EXP_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 .read = pci_read_config,
1029 .write = pci_write_config,
1030};
1031
Michael Ellermana2cd52c2007-05-08 12:03:08 +10001032int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
Michael Ellerman575e3342007-05-08 12:03:07 +10001033{
Michael Ellermana2cd52c2007-05-08 12:03:08 +10001034 return 0;
Michael Ellerman575e3342007-05-08 12:03:07 +10001035}
1036
Michael S. Tsirkin711d5772009-07-27 23:37:48 +03001037static ssize_t reset_store(struct device *dev,
1038 struct device_attribute *attr, const char *buf,
1039 size_t count)
1040{
1041 struct pci_dev *pdev = to_pci_dev(dev);
1042 unsigned long val;
1043 ssize_t result = strict_strtoul(buf, 0, &val);
1044
1045 if (result < 0)
1046 return result;
1047
1048 if (val != 1)
1049 return -EINVAL;
Michal Schmidt447c5dd2010-05-11 11:44:54 +02001050
1051 result = pci_reset_function(pdev);
1052 if (result < 0)
1053 return result;
1054
1055 return count;
Michael S. Tsirkin711d5772009-07-27 23:37:48 +03001056}
1057
1058static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);
1059
Zhao, Yu280c73d2008-10-13 20:01:00 +08001060static int pci_create_capabilities_sysfs(struct pci_dev *dev)
1061{
1062 int retval;
1063 struct bin_attribute *attr;
1064
1065 /* If the device has VPD, try to expose it in sysfs. */
1066 if (dev->vpd) {
1067 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1068 if (!attr)
1069 return -ENOMEM;
1070
Eric W. Biedermana07e4152010-02-11 15:23:05 -08001071 sysfs_bin_attr_init(attr);
Zhao, Yu280c73d2008-10-13 20:01:00 +08001072 attr->size = dev->vpd->len;
1073 attr->attr.name = "vpd";
1074 attr->attr.mode = S_IRUSR | S_IWUSR;
Stephen Hemminger287d19c2008-12-18 09:17:16 -08001075 attr->read = read_vpd_attr;
1076 attr->write = write_vpd_attr;
Zhao, Yu280c73d2008-10-13 20:01:00 +08001077 retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
1078 if (retval) {
1079 kfree(dev->vpd->attr);
1080 return retval;
1081 }
1082 dev->vpd->attr = attr;
1083 }
1084
1085 /* Active State Power Management */
1086 pcie_aspm_create_sysfs_dev_files(dev);
1087
Michael S. Tsirkin711d5772009-07-27 23:37:48 +03001088 if (!pci_probe_reset_function(dev)) {
1089 retval = device_create_file(&dev->dev, &reset_attr);
1090 if (retval)
1091 goto error;
1092 dev->reset_fn = 1;
1093 }
Zhao, Yu280c73d2008-10-13 20:01:00 +08001094 return 0;
Michael S. Tsirkin711d5772009-07-27 23:37:48 +03001095
1096error:
1097 pcie_aspm_remove_sysfs_dev_files(dev);
1098 if (dev->vpd && dev->vpd->attr) {
1099 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1100 kfree(dev->vpd->attr);
1101 }
1102
1103 return retval;
Zhao, Yu280c73d2008-10-13 20:01:00 +08001104}
1105
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001106int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107{
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001108 int retval;
Zhao, Yu280c73d2008-10-13 20:01:00 +08001109 int rom_size = 0;
1110 struct bin_attribute *attr;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001111
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 if (!sysfs_initialized)
1113 return -EACCES;
1114
Zhao, Yu557848c2008-10-13 19:18:07 +08001115 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001116 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 else
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001118 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1119 if (retval)
1120 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001122 retval = pci_create_resource_files(pdev);
1123 if (retval)
Zhao, Yu280c73d2008-10-13 20:01:00 +08001124 goto err_config_file;
1125
1126 if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
1127 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1128 else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
1129 rom_size = 0x20000;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131 /* If the device has a ROM, try to expose it in sysfs. */
Zhao, Yu280c73d2008-10-13 20:01:00 +08001132 if (rom_size) {
Ben Hutchings94e61082008-03-05 16:52:39 +00001133 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
Zhao, Yu280c73d2008-10-13 20:01:00 +08001134 if (!attr) {
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001135 retval = -ENOMEM;
Michael Ellerman9890b122007-04-18 13:34:12 +10001136 goto err_resource_files;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 }
Eric W. Biedermana07e4152010-02-11 15:23:05 -08001138 sysfs_bin_attr_init(attr);
Zhao, Yu280c73d2008-10-13 20:01:00 +08001139 attr->size = rom_size;
1140 attr->attr.name = "rom";
1141 attr->attr.mode = S_IRUSR;
1142 attr->read = pci_read_rom;
1143 attr->write = pci_write_rom;
1144 retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
1145 if (retval) {
1146 kfree(attr);
1147 goto err_resource_files;
1148 }
1149 pdev->rom_attr = attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 }
Zhao, Yu280c73d2008-10-13 20:01:00 +08001151
Dave Airlie217f45d2009-03-04 05:57:05 +00001152 if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) {
1153 retval = device_create_file(&pdev->dev, &vga_attr);
1154 if (retval)
1155 goto err_rom_file;
1156 }
1157
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 /* add platform-specific attributes */
Zhao, Yu280c73d2008-10-13 20:01:00 +08001159 retval = pcibios_add_platform_entries(pdev);
1160 if (retval)
Dave Airlie217f45d2009-03-04 05:57:05 +00001161 goto err_vga_file;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001162
Zhao, Yu280c73d2008-10-13 20:01:00 +08001163 /* add sysfs entries for various capabilities */
1164 retval = pci_create_capabilities_sysfs(pdev);
1165 if (retval)
Dave Airlie217f45d2009-03-04 05:57:05 +00001166 goto err_vga_file;
Shaohua Li7d715a62008-02-25 09:46:41 +08001167
Narendra K911e1c92010-07-26 05:56:50 -05001168 pci_create_firmware_label_files(pdev);
1169
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 return 0;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001171
Dave Airlie217f45d2009-03-04 05:57:05 +00001172err_vga_file:
1173 if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
1174 device_remove_file(&pdev->dev, &vga_attr);
Michael Ellermana2cd52c2007-05-08 12:03:08 +10001175err_rom_file:
Zhao, Yu280c73d2008-10-13 20:01:00 +08001176 if (rom_size) {
Ben Hutchings94e61082008-03-05 16:52:39 +00001177 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
Zhao, Yu280c73d2008-10-13 20:01:00 +08001178 kfree(pdev->rom_attr);
1179 pdev->rom_attr = NULL;
1180 }
Michael Ellerman9890b122007-04-18 13:34:12 +10001181err_resource_files:
1182 pci_remove_resource_files(pdev);
Ben Hutchings94e61082008-03-05 16:52:39 +00001183err_config_file:
Zhao, Yu557848c2008-10-13 19:18:07 +08001184 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001185 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1186 else
1187 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1188err:
1189 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190}
1191
Zhao, Yu280c73d2008-10-13 20:01:00 +08001192static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
1193{
1194 if (dev->vpd && dev->vpd->attr) {
1195 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1196 kfree(dev->vpd->attr);
1197 }
1198
1199 pcie_aspm_remove_sysfs_dev_files(dev);
Michael S. Tsirkin711d5772009-07-27 23:37:48 +03001200 if (dev->reset_fn) {
1201 device_remove_file(&dev->dev, &reset_attr);
1202 dev->reset_fn = 0;
1203 }
Zhao, Yu280c73d2008-10-13 20:01:00 +08001204}
1205
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206/**
1207 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
1208 * @pdev: device whose entries we should free
1209 *
1210 * Cleanup when @pdev is removed from sysfs.
1211 */
1212void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
1213{
Zhao, Yu280c73d2008-10-13 20:01:00 +08001214 int rom_size = 0;
1215
David Millerd67afe52006-11-10 12:27:48 -08001216 if (!sysfs_initialized)
1217 return;
1218
Zhao, Yu280c73d2008-10-13 20:01:00 +08001219 pci_remove_capabilities_sysfs(pdev);
Shaohua Li7d715a62008-02-25 09:46:41 +08001220
Zhao, Yu557848c2008-10-13 19:18:07 +08001221 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1223 else
1224 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1225
1226 pci_remove_resource_files(pdev);
1227
Zhao, Yu280c73d2008-10-13 20:01:00 +08001228 if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
1229 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1230 else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
1231 rom_size = 0x20000;
1232
1233 if (rom_size && pdev->rom_attr) {
1234 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1235 kfree(pdev->rom_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 }
Narendra K911e1c92010-07-26 05:56:50 -05001237
1238 pci_remove_firmware_label_files(pdev);
1239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240}
1241
1242static int __init pci_sysfs_init(void)
1243{
1244 struct pci_dev *pdev = NULL;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001245 int retval;
1246
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 sysfs_initialized = 1;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001248 for_each_pci_dev(pdev) {
1249 retval = pci_create_sysfs_dev_files(pdev);
Julia Lawall151fc5d2007-11-20 08:41:16 +01001250 if (retval) {
1251 pci_dev_put(pdev);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001252 return retval;
Julia Lawall151fc5d2007-11-20 08:41:16 +01001253 }
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -07001254 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
1256 return 0;
1257}
1258
Jesse Barnes40ee9e92007-03-24 11:03:32 -07001259late_initcall(pci_sysfs_init);