fbsd-device.c

   1 /*
   2  *      The PCI Library -- FreeBSD /dev/pci access
   3  *
   4  *      Copyright (c) 1999 Jari Kirma <kirma@cs.hut.fi>
   5  *      Updated in 2003 by Samy Al Bahra <samy@kerneled.com>
   6  *      Updated in 2017 by Imre Vadász <imrevdsz@gmail.com>
   7  *
   8  *      Can be freely distributed and used under the terms of the GNU GPL v2+.
   9  *
  10  *      SPDX-License-Identifier: GPL-2.0-or-later
  11  */
  12
  13 #include <errno.h>
  14 #include <fcntl.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19 #include <osreldate.h>
  20 #include <stdint.h>
  21
  22 #ifdef __FreeBSD_kernel_version
  23 #  ifndef __FreeBSD_version
  24 #    define __FreeBSD_version __FreeBSD_kernel_version
  25 #  endif
  26 #endif
  27
  28 #if __FreeBSD_version < 430000 && !defined(__DragonFly__)
  29 #  include <pci/pcivar.h>
  30 #  include <pci/pci_ioctl.h>
  31 #else
  32 #  include <sys/pciio.h>
  33 #endif
  34
  35 #include "internal.h"
  36
  37 static void
  38 fbsd_config(struct pci_access *a)
  39 {
  40   pci_define_param(a, "fbsd.path", PCI_PATH_FBSD_DEVICE, "Path to the FreeBSD PCI device");
  41 }
  42
  43 static int
  44 fbsd_detect(struct pci_access *a)
  45 {
  46   char *name = pci_get_param(a, "fbsd.path");
  47
  48   if (access(name, R_OK))
  49     {
  50       a->warning("Cannot open %s", name);
  51       return 0;
  52     }
  53   a->debug("...using %s", name);
  54   return 1;
  55 }
  56
  57 static void
  58 fbsd_init(struct pci_access *a)
  59 {
  60   char *name = pci_get_param(a, "fbsd.path");
  61   int fd;
  62
  63   a->fd = -1;
  64   a->fd_rw = -1;
  65   /*
  66    * When opening /dev/pci as read-write fails, retry with readonly which
  67    * will still allow us to gain some information via the PCIOCGETCONF and
  68    * PCIOCGETBAR IOCTLs, even without generic read access to the PCI config
  69    * space.
  70    */
  71   fd = open(name, O_RDWR, 0);
  72   if (fd < 0)
  73     {
  74       fd = open(name, O_RDONLY, 0);
  75       if (fd < 0)
  76         a->error("fbsd_init: %s open failed", name);
  77       else
  78         {
  79           a->debug("fbsd_init: Fallback to read-only opened %s", name);
  80           a->fd = fd;
  81         }
  82     }
  83   else
  84     a->fd_rw = fd;
  85 }
  86
  87 static void
  88 fbsd_cleanup(struct pci_access *a)
  89 {
  90   if (a->fd >= 0)
  91     {
  92       close(a->fd);
  93       a->fd = -1;
  94     }
  95   if (a->fd_rw >= 0)
  96     {
  97       close(a->fd_rw);
  98       a->fd_rw = -1;
  99     }
 100 }
 101
 102 static void
 103 fbsd_scan(struct pci_access *a)
 104 {
 105   struct pci_conf_io conf;
 106   struct pci_conf *matches;
 107   struct pci_dev *t;
 108   uint32_t offset = 0;
 109   unsigned int i;
 110
 111   matches = calloc(32, sizeof(struct pci_conf));
 112   if (matches == NULL)
 113     {
 114       a->error("calloc: %s", strerror(errno));
 115       return;
 116     }
 117
 118   conf.generation = 0;
 119   do
 120     {
 121       conf.pat_buf_len = 0;
 122       conf.num_patterns = 0;
 123       conf.patterns = NULL;
 124       conf.match_buf_len = 32 * sizeof(struct pci_conf);
 125       conf.num_matches = 32;
 126       conf.matches = matches;
 127       conf.offset = offset;
 128       conf.status = 0;
 129       if (ioctl(a->fd_rw >= 0 ? a->fd_rw : a->fd, PCIOCGETCONF, &conf) < 0)
 130         {
 131           if (errno == ENODEV)
 132             break;
 133           a->error("fbsd_scan: ioctl(PCIOCGETCONF) failed: %s",
 134               strerror(errno));
 135         }
 136       /* PCI_GETCONF_LIST_CHANGED would require us to start over. */
 137       if (conf.status == PCI_GETCONF_ERROR ||
 138           conf.status == PCI_GETCONF_LIST_CHANGED)
 139         {
 140           a->error("fbsd_scan: ioctl(PCIOCGETCONF) failed");
 141           break;
 142         }
 143       for (i = 0; i < conf.num_matches; i++)
 144         {
 145           t = pci_alloc_dev(a);
 146           t->bus = matches[i].pc_sel.pc_bus;
 147           t->dev = matches[i].pc_sel.pc_dev;
 148           t->func = matches[i].pc_sel.pc_func;
 149           t->domain = matches[i].pc_sel.pc_domain;
 150           t->domain_16 = matches[i].pc_sel.pc_domain;
 151           t->vendor_id = matches[i].pc_vendor;
 152           t->device_id = matches[i].pc_device;
 153           t->known_fields = PCI_FILL_IDENT;
 154           t->hdrtype = matches[i].pc_hdr;
 155           pci_link_dev(a, t);
 156         }
 157       offset += conf.num_matches;
 158     }
 159   while (conf.status == PCI_GETCONF_MORE_DEVS);
 160
 161   free(matches);
 162 }
 163
 164 static void
 165 fbsd_fill_info(struct pci_dev *d, unsigned int flags)
 166 {
 167   struct pci_conf_io conf;
 168   struct pci_bar_io bar;
 169   struct pci_match_conf pattern;
 170   struct pci_conf match;
 171   int i;
 172
 173   if (d->access->fd_rw >= 0)
 174     return pci_generic_fill_info(d, flags);
 175
 176   /*
 177    * Can only handle PCI_FILL_IDENT, PCI_FILL_CLASS, PCI_FILL_BASES and
 178    * PCI_FILL_SIZES requests with the PCIOCGETCONF and PCIOCGETBAR IOCTLs.
 179    */
 180
 181   conf.pat_buf_len = sizeof(struct pci_match_conf);
 182   conf.num_patterns = 1;
 183   conf.patterns = &pattern;
 184   conf.match_buf_len = sizeof(struct pci_conf);
 185   conf.num_matches = 1;
 186   conf.matches = &match;
 187   conf.offset = 0;
 188   conf.generation = 0;
 189   conf.status = 0;
 190
 191   pattern.pc_sel.pc_domain = d->domain;
 192   pattern.pc_sel.pc_bus = d->bus;
 193   pattern.pc_sel.pc_dev = d->dev;
 194   pattern.pc_sel.pc_func = d->func;
 195   pattern.flags = PCI_GETCONF_MATCH_DOMAIN | PCI_GETCONF_MATCH_BUS |
 196           PCI_GETCONF_MATCH_DEV | PCI_GETCONF_MATCH_FUNC;
 197
 198   if (ioctl(d->access->fd, PCIOCGETCONF, &conf) < 0)
 199     {
 200       if (errno != ENODEV)
 201         d->access->error("fbsd_fill_info: ioctl(PCIOCGETCONF) failed: %s", strerror(errno));
 202       return;
 203     }
 204
 205   if (want_fill(d, flags, PCI_FILL_IDENT))
 206     {
 207       d->vendor_id = match.pc_vendor;
 208       d->device_id = match.pc_device;
 209     }
 210   if (want_fill(d, flags, PCI_FILL_CLASS))
 211     d->device_class = (match.pc_class << 8) | match.pc_subclass;
 212   if (want_fill(d, flags, PCI_FILL_BASES | PCI_FILL_SIZES))
 213     {
 214       d->rom_base_addr = 0;
 215       d->rom_size = 0;
 216       for (i = 0; i < 6; i++)
 217         {
 218           bar.pbi_sel.pc_domain = d->domain;
 219           bar.pbi_sel.pc_bus = d->bus;
 220           bar.pbi_sel.pc_dev = d->dev;
 221           bar.pbi_sel.pc_func = d->func;
 222           bar.pbi_reg = 0x10 + 4*i;
 223           bar.pbi_enabled = 0;
 224           bar.pbi_base = 0;
 225           bar.pbi_length = 0;
 226           if (ioctl(d->access->fd, PCIOCGETBAR, &bar) < 0)
 227             {
 228               if (errno == ENODEV)
 229                 return;
 230               if (errno == EINVAL)
 231                 {
 232                   d->base_addr[i] = 0;
 233                   d->size[i] = 0;
 234                 }
 235               else
 236                 d->access->error("fbsd_fill_info: ioctl(PCIOCGETBAR) failed: %s", strerror(errno));
 237             }
 238           else
 239             {
 240               d->base_addr[i] = bar.pbi_base;
 241               d->size[i] = bar.pbi_length;
 242             }
 243         }
 244     }
 245 }
 246
 247 static int
 248 fbsd_read(struct pci_dev *d, int pos, byte *buf, int len)
 249 {
 250   struct pci_io pi;
 251
 252   if (d->access->fd_rw < 0)
 253     {
 254       d->access->warning("fbsd_read: missing permissions");
 255       return 0;
 256     }
 257
 258   if (!(len == 1 || len == 2 || len == 4))
 259     return pci_generic_block_read(d, pos, buf, len);
 260
 261   if (pos >= 4096)
 262     return 0;
 263
 264 #if __FreeBSD_version >= 700053 || defined(__DragonFly__)
 265   pi.pi_sel.pc_domain = d->domain;
 266 #else
 267   if (d->domain)
 268     return 0;
 269 #endif
 270   pi.pi_sel.pc_bus = d->bus;
 271   pi.pi_sel.pc_dev = d->dev;
 272   pi.pi_sel.pc_func = d->func;
 273
 274   pi.pi_reg = pos;
 275   pi.pi_width = len;
 276
 277   if (ioctl(d->access->fd_rw, PCIOCREAD, &pi) < 0)
 278     {
 279       if (errno == ENODEV)
 280         return 0;
 281       d->access->error("fbsd_read: ioctl(PCIOCREAD) failed: %s", strerror(errno));
 282     }
 283
 284   switch (len)
 285     {
 286     case 1:
 287       buf[0] = (u8) pi.pi_data;
 288       break;
 289     case 2:
 290       ((u16 *) buf)[0] = cpu_to_le16((u16) pi.pi_data);
 291       break;
 292     case 4:
 293       ((u32 *) buf)[0] = cpu_to_le32((u32) pi.pi_data);
 294       break;
 295     }
 296   return 1;
 297 }
 298
 299 static int
 300 fbsd_write(struct pci_dev *d, int pos, byte *buf, int len)
 301 {
 302   struct pci_io pi;
 303
 304   if (d->access->fd_rw < 0)
 305     {
 306       d->access->warning("fbsd_write: missing permissions");
 307       return 0;
 308     }
 309
 310   if (!(len == 1 || len == 2 || len == 4))
 311     return pci_generic_block_write(d, pos, buf, len);
 312
 313   if (pos >= 4096)
 314     return 0;
 315
 316 #if __FreeBSD_version >= 700053 || defined(__DragonFly__)
 317   pi.pi_sel.pc_domain = d->domain;
 318 #else
 319   if (d->domain)
 320     return 0;
 321 #endif
 322   pi.pi_sel.pc_bus = d->bus;
 323   pi.pi_sel.pc_dev = d->dev;
 324   pi.pi_sel.pc_func = d->func;
 325
 326   pi.pi_reg = pos;
 327   pi.pi_width = len;
 328
 329   switch (len)
 330     {
 331     case 1:
 332       pi.pi_data = buf[0];
 333       break;
 334     case 2:
 335       pi.pi_data = le16_to_cpu(((u16 *) buf)[0]);
 336       break;
 337     case 4:
 338       pi.pi_data = le32_to_cpu(((u32 *) buf)[0]);
 339       break;
 340     }
 341
 342   if (ioctl(d->access->fd_rw, PCIOCWRITE, &pi) < 0)
 343     {
 344       if (errno == ENODEV)
 345         return 0;
 346       d->access->error("fbsd_write: ioctl(PCIOCWRITE) failed: %s", strerror(errno));
 347     }
 348
 349   return 1;
 350 }
 351
 352 struct pci_methods pm_fbsd_device = {
 353   "fbsd-device",
 354   "FreeBSD /dev/pci device",
 355   fbsd_config,
 356   fbsd_detect,
 357   fbsd_init,
 358   fbsd_cleanup,
 359   fbsd_scan,
 360   fbsd_fill_info,
 361   fbsd_read,
 362   fbsd_write,
 363   NULL,                                 /* read_vpd */
 364   NULL,                                 /* dev_init */
 365   NULL                                  /* dev_cleanup */
 366 };