hw/xen/xen-host-pci-device.c

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