xref: /openbmc/qemu/hw/xen/xen-host-pci-device.c (revision a719a27c) 
1 /*
2  * Copyright (C) 2011       Citrix Ltd.
3  *
4  * This work is licensed under the terms of the GNU GPL, version 2.  See
5  * the COPYING file in the top-level directory.
6  *
7  */
8 
9 #include "qemu-common.h"
10 #include "xen-host-pci-device.h"
11 
12 #define XEN_HOST_PCI_MAX_EXT_CAP \
13     ((PCIE_CONFIG_SPACE_SIZE - PCI_CONFIG_SPACE_SIZE) / (PCI_CAP_SIZEOF + 4))
14 
15 #ifdef XEN_HOST_PCI_DEVICE_DEBUG
16 #  define XEN_HOST_PCI_LOG(f, a...) fprintf(stderr, "%s: " f, __func__, ##a)
17 #else
18 #  define XEN_HOST_PCI_LOG(f, a...) (void)0
19 #endif
20 
21 /*
22  * from linux/ioport.h
23  * IO resources have these defined flags.
24  */
25 #define IORESOURCE_BITS         0x000000ff      /* Bus-specific bits */
26 
27 #define IORESOURCE_TYPE_BITS    0x00000f00      /* Resource type */
28 #define IORESOURCE_IO           0x00000100
29 #define IORESOURCE_MEM          0x00000200
30 
31 #define IORESOURCE_PREFETCH     0x00001000      /* No side effects */
32 #define IORESOURCE_MEM_64       0x00100000
33 
34 static int xen_host_pci_sysfs_path(const XenHostPCIDevice *d,
35                                    const char *name, char *buf, ssize_t size)
36 {
37     int rc;
38 
39     rc = snprintf(buf, size, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/%s",
40                   d->domain, d->bus, d->dev, d->func, name);
41 
42     if (rc >= size || rc < 0) {
43         /* The ouput is truncated or an other error is encountered */
44         return -ENODEV;
45     }
46     return 0;
47 }
48 
49 
50 /* This size should be enough to read the first 7 lines of a resource file */
51 #define XEN_HOST_PCI_RESOURCE_BUFFER_SIZE 400
52 static int xen_host_pci_get_resource(XenHostPCIDevice *d)
53 {
54     int i, rc, fd;
55     char path[PATH_MAX];
56     char buf[XEN_HOST_PCI_RESOURCE_BUFFER_SIZE];
57     unsigned long long start, end, flags, size;
58     char *endptr, *s;
59     uint8_t type;
60 
61     rc = xen_host_pci_sysfs_path(d, "resource", path, sizeof (path));
62     if (rc) {
63         return rc;
64     }
65     fd = open(path, O_RDONLY);
66     if (fd == -1) {
67         XEN_HOST_PCI_LOG("Error: Can't open %s: %s\n", path, strerror(errno));
68         return -errno;
69     }
70 
71     do {
72         rc = read(fd, &buf, sizeof (buf) - 1);
73         if (rc < 0 && errno != EINTR) {
74             rc = -errno;
75             goto out;
76         }
77     } while (rc < 0);
78     buf[rc] = 0;
79     rc = 0;
80 
81     s = buf;
82     for (i = 0; i < PCI_NUM_REGIONS; i++) {
83         type = 0;
84 
85         start = strtoll(s, &endptr, 16);
86         if (*endptr != ' ' || s == endptr) {
87             break;
88         }
89         s = endptr + 1;
90         end = strtoll(s, &endptr, 16);
91         if (*endptr != ' ' || s == endptr) {
92             break;
93         }
94         s = endptr + 1;
95         flags = strtoll(s, &endptr, 16);
96         if (*endptr != '\n' || s == endptr) {
97             break;
98         }
99         s = endptr + 1;
100 
101         if (start) {
102             size = end - start + 1;
103         } else {
104             size = 0;
105         }
106 
107         if (flags & IORESOURCE_IO) {
108             type |= XEN_HOST_PCI_REGION_TYPE_IO;
109         }
110         if (flags & IORESOURCE_MEM) {
111             type |= XEN_HOST_PCI_REGION_TYPE_MEM;
112         }
113         if (flags & IORESOURCE_PREFETCH) {
114             type |= XEN_HOST_PCI_REGION_TYPE_PREFETCH;
115         }
116         if (flags & IORESOURCE_MEM_64) {
117             type |= XEN_HOST_PCI_REGION_TYPE_MEM_64;
118         }
119 
120         if (i < PCI_ROM_SLOT) {
121             d->io_regions[i].base_addr = start;
122             d->io_regions[i].size = size;
123             d->io_regions[i].type = type;
124             d->io_regions[i].bus_flags = flags & IORESOURCE_BITS;
125         } else {
126             d->rom.base_addr = start;
127             d->rom.size = size;
128             d->rom.type = type;
129             d->rom.bus_flags = flags & IORESOURCE_BITS;
130         }
131     }
132     if (i != PCI_NUM_REGIONS) {
133         /* Invalid format or input to short */
134         rc = -ENODEV;
135     }
136 
137 out:
138     close(fd);
139     return rc;
140 }
141 
142 /* This size should be enough to read a long from a file */
143 #define XEN_HOST_PCI_GET_VALUE_BUFFER_SIZE 22
144 static int xen_host_pci_get_value(XenHostPCIDevice *d, const char *name,
145                                   unsigned int *pvalue, int base)
146 {
147     char path[PATH_MAX];
148     char buf[XEN_HOST_PCI_GET_VALUE_BUFFER_SIZE];
149     int fd, rc;
150     unsigned long value;
151     char *endptr;
152 
153     rc = xen_host_pci_sysfs_path(d, name, path, sizeof (path));
154     if (rc) {
155         return rc;
156     }
157     fd = open(path, O_RDONLY);
158     if (fd == -1) {
159         XEN_HOST_PCI_LOG("Error: Can't open %s: %s\n", path, strerror(errno));
160         return -errno;
161     }
162     do {
163         rc = read(fd, &buf, sizeof (buf) - 1);
164         if (rc < 0 && errno != EINTR) {
165             rc = -errno;
166             goto out;
167         }
168     } while (rc < 0);
169     buf[rc] = 0;
170     value = strtol(buf, &endptr, base);
171     if (endptr == buf || *endptr != '\n') {
172         rc = -1;
173     } else if ((value == LONG_MIN || value == LONG_MAX) && errno == ERANGE) {
174         rc = -errno;
175     } else {
176         rc = 0;
177         *pvalue = value;
178     }
179 out:
180     close(fd);
181     return rc;
182 }
183 
184 static inline int xen_host_pci_get_hex_value(XenHostPCIDevice *d,
185                                              const char *name,
186                                              unsigned int *pvalue)
187 {
188     return xen_host_pci_get_value(d, name, pvalue, 16);
189 }
190 
191 static inline int xen_host_pci_get_dec_value(XenHostPCIDevice *d,
192                                              const char *name,
193                                              unsigned int *pvalue)
194 {
195     return xen_host_pci_get_value(d, name, pvalue, 10);
196 }
197 
198 static bool xen_host_pci_dev_is_virtfn(XenHostPCIDevice *d)
199 {
200     char path[PATH_MAX];
201     struct stat buf;
202 
203     if (xen_host_pci_sysfs_path(d, "physfn", path, sizeof (path))) {
204         return false;
205     }
206     return !stat(path, &buf);
207 }
208 
209 static int xen_host_pci_config_open(XenHostPCIDevice *d)
210 {
211     char path[PATH_MAX];
212     int rc;
213 
214     rc = xen_host_pci_sysfs_path(d, "config", path, sizeof (path));
215     if (rc) {
216         return rc;
217     }
218     d->config_fd = open(path, O_RDWR);
219     if (d->config_fd < 0) {
220         return -errno;
221     }
222     return 0;
223 }
224 
225 static int xen_host_pci_config_read(XenHostPCIDevice *d,
226                                     int pos, void *buf, int len)
227 {
228     int rc;
229 
230     do {
231         rc = pread(d->config_fd, buf, len, pos);
232     } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
233     if (rc != len) {
234         return -errno;
235     }
236     return 0;
237 }
238 
239 static int xen_host_pci_config_write(XenHostPCIDevice *d,
240                                      int pos, const void *buf, int len)
241 {
242     int rc;
243 
244     do {
245         rc = pwrite(d->config_fd, buf, len, pos);
246     } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
247     if (rc != len) {
248         return -errno;
249     }
250     return 0;
251 }
252 
253 
254 int xen_host_pci_get_byte(XenHostPCIDevice *d, int pos, uint8_t *p)
255 {
256     uint8_t buf;
257     int rc = xen_host_pci_config_read(d, pos, &buf, 1);
258     if (!rc) {
259         *p = buf;
260     }
261     return rc;
262 }
263 
264 int xen_host_pci_get_word(XenHostPCIDevice *d, int pos, uint16_t *p)
265 {
266     uint16_t buf;
267     int rc = xen_host_pci_config_read(d, pos, &buf, 2);
268     if (!rc) {
269         *p = le16_to_cpu(buf);
270     }
271     return rc;
272 }
273 
274 int xen_host_pci_get_long(XenHostPCIDevice *d, int pos, uint32_t *p)
275 {
276     uint32_t buf;
277     int rc = xen_host_pci_config_read(d, pos, &buf, 4);
278     if (!rc) {
279         *p = le32_to_cpu(buf);
280     }
281     return rc;
282 }
283 
284 int xen_host_pci_get_block(XenHostPCIDevice *d, int pos, uint8_t *buf, int len)
285 {
286     return xen_host_pci_config_read(d, pos, buf, len);
287 }
288 
289 int xen_host_pci_set_byte(XenHostPCIDevice *d, int pos, uint8_t data)
290 {
291     return xen_host_pci_config_write(d, pos, &data, 1);
292 }
293 
294 int xen_host_pci_set_word(XenHostPCIDevice *d, int pos, uint16_t data)
295 {
296     data = cpu_to_le16(data);
297     return xen_host_pci_config_write(d, pos, &data, 2);
298 }
299 
300 int xen_host_pci_set_long(XenHostPCIDevice *d, int pos, uint32_t data)
301 {
302     data = cpu_to_le32(data);
303     return xen_host_pci_config_write(d, pos, &data, 4);
304 }
305 
306 int xen_host_pci_set_block(XenHostPCIDevice *d, int pos, uint8_t *buf, int len)
307 {
308     return xen_host_pci_config_write(d, pos, buf, len);
309 }
310 
311 int xen_host_pci_find_ext_cap_offset(XenHostPCIDevice *d, uint32_t cap)
312 {
313     uint32_t header = 0;
314     int max_cap = XEN_HOST_PCI_MAX_EXT_CAP;
315     int pos = PCI_CONFIG_SPACE_SIZE;
316 
317     do {
318         if (xen_host_pci_get_long(d, pos, &header)) {
319             break;
320         }
321         /*
322          * If we have no capabilities, this is indicated by cap ID,
323          * cap version and next pointer all being 0.
324          */
325         if (header == 0) {
326             break;
327         }
328 
329         if (PCI_EXT_CAP_ID(header) == cap) {
330             return pos;
331         }
332 
333         pos = PCI_EXT_CAP_NEXT(header);
334         if (pos < PCI_CONFIG_SPACE_SIZE) {
335             break;
336         }
337 
338         max_cap--;
339     } while (max_cap > 0);
340 
341     return -1;
342 }
343 
344 int xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain,
345                             uint8_t bus, uint8_t dev, uint8_t func)
346 {
347     unsigned int v;
348     int rc = 0;
349 
350     d->config_fd = -1;
351     d->domain = domain;
352     d->bus = bus;
353     d->dev = dev;
354     d->func = func;
355 
356     rc = xen_host_pci_config_open(d);
357     if (rc) {
358         goto error;
359     }
360     rc = xen_host_pci_get_resource(d);
361     if (rc) {
362         goto error;
363     }
364     rc = xen_host_pci_get_hex_value(d, "vendor", &v);
365     if (rc) {
366         goto error;
367     }
368     d->vendor_id = v;
369     rc = xen_host_pci_get_hex_value(d, "device", &v);
370     if (rc) {
371         goto error;
372     }
373     d->device_id = v;
374     rc = xen_host_pci_get_dec_value(d, "irq", &v);
375     if (rc) {
376         goto error;
377     }
378     d->irq = v;
379     d->is_virtfn = xen_host_pci_dev_is_virtfn(d);
380 
381     return 0;
382 error:
383     if (d->config_fd >= 0) {
384         close(d->config_fd);
385         d->config_fd = -1;
386     }
387     return rc;
388 }
389 
390 void xen_host_pci_device_put(XenHostPCIDevice *d)
391 {
392     if (d->config_fd >= 0) {
393         close(d->config_fd);
394         d->config_fd = -1;
395     }
396 }
397