[qemu.git] / hw / xen / xen-host-pci-device.c

/*
 * Copyright (C) 2011       Citrix Ltd.
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 */

#include "qemu-common.h"
#include "xen-host-pci-device.h"

#define XEN_HOST_PCI_MAX_EXT_CAP \
    ((PCIE_CONFIG_SPACE_SIZE - PCI_CONFIG_SPACE_SIZE) / (PCI_CAP_SIZEOF + 4))

#ifdef XEN_HOST_PCI_DEVICE_DEBUG
#  define XEN_HOST_PCI_LOG(f, a...) fprintf(stderr, "%s: " f, __func__, ##a)
#else
#  define XEN_HOST_PCI_LOG(f, a...) (void)0
#endif

/*
 * from linux/ioport.h
 * IO resources have these defined flags.
 */
#define IORESOURCE_BITS         0x000000ff      /* Bus-specific bits */

#define IORESOURCE_TYPE_BITS    0x00000f00      /* Resource type */
#define IORESOURCE_IO           0x00000100
#define IORESOURCE_MEM          0x00000200

#define IORESOURCE_PREFETCH     0x00001000      /* No side effects */
#define IORESOURCE_MEM_64       0x00100000

static int xen_host_pci_sysfs_path(const XenHostPCIDevice *d,
                                   const char *name, char *buf, ssize_t size)
{
    int rc;

    rc = snprintf(buf, size, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/%s",
                  d->domain, d->bus, d->dev, d->func, name);

    if (rc >= size || rc < 0) {
        /* The ouput is truncated or an other error is encountered */
        return -ENODEV;
    }
    return 0;
}


/* This size should be enough to read the first 7 lines of a resource file */
#define XEN_HOST_PCI_RESOURCE_BUFFER_SIZE 400
static int xen_host_pci_get_resource(XenHostPCIDevice *d)
{
    int i, rc, fd;
    char path[PATH_MAX];
    char buf[XEN_HOST_PCI_RESOURCE_BUFFER_SIZE];
    unsigned long long start, end, flags, size;
    char *endptr, *s;
    uint8_t type;

    rc = xen_host_pci_sysfs_path(d, "resource", path, sizeof (path));
    if (rc) {
        return rc;
    }
    fd = open(path, O_RDONLY);
    if (fd == -1) {
        XEN_HOST_PCI_LOG("Error: Can't open %s: %s\n", path, strerror(errno));
        return -errno;
    }

    do {
        rc = read(fd, &buf, sizeof (buf) - 1);
        if (rc < 0 && errno != EINTR) {
            rc = -errno;
            goto out;
        }
    } while (rc < 0);
    buf[rc] = 0;
    rc = 0;

    s = buf;
    for (i = 0; i < PCI_NUM_REGIONS; i++) {
        type = 0;

        start = strtoll(s, &endptr, 16);
        if (*endptr != ' ' || s == endptr) {
            break;
        }
        s = endptr + 1;
        end = strtoll(s, &endptr, 16);
        if (*endptr != ' ' || s == endptr) {
            break;
        }
        s = endptr + 1;
        flags = strtoll(s, &endptr, 16);
        if (*endptr != '\n' || s == endptr) {
            break;
        }
        s = endptr + 1;

        if (start) {
            size = end - start + 1;
        } else {
            size = 0;
        }

        if (flags & IORESOURCE_IO) {
            type |= XEN_HOST_PCI_REGION_TYPE_IO;
        }
        if (flags & IORESOURCE_MEM) {
            type |= XEN_HOST_PCI_REGION_TYPE_MEM;
        }
        if (flags & IORESOURCE_PREFETCH) {
            type |= XEN_HOST_PCI_REGION_TYPE_PREFETCH;
        }
        if (flags & IORESOURCE_MEM_64) {
            type |= XEN_HOST_PCI_REGION_TYPE_MEM_64;
        }

        if (i < PCI_ROM_SLOT) {
            d->io_regions[i].base_addr = start;
            d->io_regions[i].size = size;
            d->io_regions[i].type = type;
            d->io_regions[i].bus_flags = flags & IORESOURCE_BITS;
        } else {
            d->rom.base_addr = start;
            d->rom.size = size;
            d->rom.type = type;
            d->rom.bus_flags = flags & IORESOURCE_BITS;
        }
    }
    if (i != PCI_NUM_REGIONS) {
        /* Invalid format or input to short */
        rc = -ENODEV;
    }

out:
    close(fd);
    return rc;
}

/* This size should be enough to read a long from a file */
#define XEN_HOST_PCI_GET_VALUE_BUFFER_SIZE 22
static int xen_host_pci_get_value(XenHostPCIDevice *d, const char *name,
                                  unsigned int *pvalue, int base)
{
    char path[PATH_MAX];
    char buf[XEN_HOST_PCI_GET_VALUE_BUFFER_SIZE];
    int fd, rc;
    unsigned long value;
    char *endptr;

    rc = xen_host_pci_sysfs_path(d, name, path, sizeof (path));
    if (rc) {
        return rc;
    }
    fd = open(path, O_RDONLY);
    if (fd == -1) {
        XEN_HOST_PCI_LOG("Error: Can't open %s: %s\n", path, strerror(errno));
        return -errno;
    }
    do {
        rc = read(fd, &buf, sizeof (buf) - 1);
        if (rc < 0 && errno != EINTR) {
            rc = -errno;
            goto out;
        }
    } while (rc < 0);
    buf[rc] = 0;
    value = strtol(buf, &endptr, base);
    if (endptr == buf || *endptr != '\n') {
        rc = -1;
    } else if ((value == LONG_MIN || value == LONG_MAX) && errno == ERANGE) {
        rc = -errno;
    } else {
        rc = 0;
        *pvalue = value;
    }
out:
    close(fd);
    return rc;
}

static inline int xen_host_pci_get_hex_value(XenHostPCIDevice *d,
                                             const char *name,
                                             unsigned int *pvalue)
{
    return xen_host_pci_get_value(d, name, pvalue, 16);
}

static inline int xen_host_pci_get_dec_value(XenHostPCIDevice *d,
                                             const char *name,
                                             unsigned int *pvalue)
{
    return xen_host_pci_get_value(d, name, pvalue, 10);
}

static bool xen_host_pci_dev_is_virtfn(XenHostPCIDevice *d)
{
    char path[PATH_MAX];
    struct stat buf;

    if (xen_host_pci_sysfs_path(d, "physfn", path, sizeof (path))) {
        return false;
    }
    return !stat(path, &buf);
}

static int xen_host_pci_config_open(XenHostPCIDevice *d)
{
    char path[PATH_MAX];
    int rc;

    rc = xen_host_pci_sysfs_path(d, "config", path, sizeof (path));
    if (rc) {
        return rc;
    }
    d->config_fd = open(path, O_RDWR);
    if (d->config_fd < 0) {
        return -errno;
    }
    return 0;
}

static int xen_host_pci_config_read(XenHostPCIDevice *d,
                                    int pos, void *buf, int len)
{
    int rc;

    do {
        rc = pread(d->config_fd, buf, len, pos);
    } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
    if (rc != len) {
        return -errno;
    }
    return 0;
}

static int xen_host_pci_config_write(XenHostPCIDevice *d,
                                     int pos, const void *buf, int len)
{
    int rc;

    do {
        rc = pwrite(d->config_fd, buf, len, pos);
    } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
    if (rc != len) {
        return -errno;
    }
    return 0;
}


int xen_host_pci_get_byte(XenHostPCIDevice *d, int pos, uint8_t *p)
{
    uint8_t buf;
    int rc = xen_host_pci_config_read(d, pos, &buf, 1);
    if (!rc) {
        *p = buf;
    }
    return rc;
}

int xen_host_pci_get_word(XenHostPCIDevice *d, int pos, uint16_t *p)
{
    uint16_t buf;
    int rc = xen_host_pci_config_read(d, pos, &buf, 2);
    if (!rc) {
        *p = le16_to_cpu(buf);
    }
    return rc;
}

int xen_host_pci_get_long(XenHostPCIDevice *d, int pos, uint32_t *p)
{
    uint32_t buf;
    int rc = xen_host_pci_config_read(d, pos, &buf, 4);
    if (!rc) {
        *p = le32_to_cpu(buf);
    }
    return rc;
}

int xen_host_pci_get_block(XenHostPCIDevice *d, int pos, uint8_t *buf, int len)
{
    return xen_host_pci_config_read(d, pos, buf, len);
}

int xen_host_pci_set_byte(XenHostPCIDevice *d, int pos, uint8_t data)
{
    return xen_host_pci_config_write(d, pos, &data, 1);
}

int xen_host_pci_set_word(XenHostPCIDevice *d, int pos, uint16_t data)
{
    data = cpu_to_le16(data);
    return xen_host_pci_config_write(d, pos, &data, 2);
}

int xen_host_pci_set_long(XenHostPCIDevice *d, int pos, uint32_t data)
{
    data = cpu_to_le32(data);
    return xen_host_pci_config_write(d, pos, &data, 4);
}

int xen_host_pci_set_block(XenHostPCIDevice *d, int pos, uint8_t *buf, int len)
{
    return xen_host_pci_config_write(d, pos, buf, len);
}

int xen_host_pci_find_ext_cap_offset(XenHostPCIDevice *d, uint32_t cap)
{
    uint32_t header = 0;
    int max_cap = XEN_HOST_PCI_MAX_EXT_CAP;
    int pos = PCI_CONFIG_SPACE_SIZE;

    do {
        if (xen_host_pci_get_long(d, pos, &header)) {
            break;
        }
        /*
         * If we have no capabilities, this is indicated by cap ID,
         * cap version and next pointer all being 0.
         */
        if (header == 0) {
            break;
        }

        if (PCI_EXT_CAP_ID(header) == cap) {
            return pos;
        }

        pos = PCI_EXT_CAP_NEXT(header);
        if (pos < PCI_CONFIG_SPACE_SIZE) {
            break;
        }

        max_cap--;
    } while (max_cap > 0);

    return -1;
}

int xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain,
                            uint8_t bus, uint8_t dev, uint8_t func)
{
    unsigned int v;
    int rc = 0;

    d->config_fd = -1;
    d->domain = domain;
    d->bus = bus;
    d->dev = dev;
    d->func = func;

    rc = xen_host_pci_config_open(d);
    if (rc) {
        goto error;
    }
    rc = xen_host_pci_get_resource(d);
    if (rc) {
        goto error;
    }
    rc = xen_host_pci_get_hex_value(d, "vendor", &v);
    if (rc) {
        goto error;
    }
    d->vendor_id = v;
    rc = xen_host_pci_get_hex_value(d, "device", &v);
    if (rc) {
        goto error;
    }
    d->device_id = v;
    rc = xen_host_pci_get_dec_value(d, "irq", &v);
    if (rc) {
        goto error;
    }
    d->irq = v;
    d->is_virtfn = xen_host_pci_dev_is_virtfn(d);

    return 0;
error:
    if (d->config_fd >= 0) {
        close(d->config_fd);
        d->config_fd = -1;
    }
    return rc;
}

void xen_host_pci_device_put(XenHostPCIDevice *d)
{
    if (d->config_fd >= 0) {
        close(d->config_fd);
        d->config_fd = -1;
    }
}
Commit	Line	Data
396af688 AP	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"
47b43a1f	10	#include "xen-host-pci-device.h"
396af688 AP	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
52a8e968 SW	50	/* This size should be enough to read the first 7 lines of a resource file */
52a8e968 SW	51	#define XEN_HOST_PCI_RESOURCE_BUFFER_SIZE 400
396af688 AP	52	static int xen_host_pci_get_resource(XenHostPCIDevice *d)
	53	{
	54	int i, rc, fd;
	55	char path[PATH_MAX];
52a8e968	56	char buf[XEN_HOST_PCI_RESOURCE_BUFFER_SIZE];
396af688 AP	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	}