sys/bus/pci/pci_user.c

   1 /*-
   2  * Copyright (c) 1997, Stefan Esser <se@kfreebsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/pci/pci_user.c,v 1.22.2.4.2.1 2009/04/15 03:14:26 kensmith Exp $
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/malloc.h>
  32 #include <sys/module.h>
  33 #include <sys/linker.h>
  34 #include <sys/fcntl.h>
  35 #include <sys/conf.h>
  36 #include <sys/kernel.h>
  37 #include <sys/proc.h>
  38 #include <sys/queue.h>
  39 #include <sys/types.h>
  40
  41 #include <vm/vm.h>
  42 #include <vm/pmap.h>
  43 #include <vm/vm_extern.h>
  44
  45 #include <sys/bus.h>
  46 #include <sys/rman.h>
  47 #include <sys/device.h>
  48 #include <sys/pciio.h>
  49 #include <bus/pci/pcireg.h>
  50 #include <bus/pci/pcivar.h>
  51
  52 #include "pcib_if.h"
  53 #include "pci_if.h"
  54
  55 /*
  56  * This is the user interface to PCI configuration space.
  57  */
  58 static struct lwkt_token pci_token = LWKT_TOKEN_INITIALIZER(pci_token);
  59
  60 static d_open_t         pci_open;
  61 static d_close_t        pci_close;
  62 static int      pci_conf_match(struct pci_match_conf *matches, int num_matches,
  63                                struct pci_conf *match_buf);
  64 static d_ioctl_t        pci_ioctl;
  65
  66 struct dev_ops pci_ops = {
  67         { "pci", 0, D_MPSAFE },
  68         .d_open =       pci_open,
  69         .d_close =      pci_close,
  70         .d_ioctl =      pci_ioctl,
  71 };
  72
  73 static int
  74 pci_open(struct dev_open_args *ap)
  75 {
  76         int oflags = ap->a_oflags;
  77
  78         if (oflags & FWRITE) {
  79                 if (securelevel > 0)
  80                         return (EPERM);
  81         }
  82
  83         return (0);
  84 }
  85
  86 static int
  87 pci_close(struct dev_close_args *ap)
  88 {
  89         return 0;
  90 }
  91
  92 /*
  93  * Match a single pci_conf structure against an array of pci_match_conf
  94  * structures.  The first argument, 'matches', is an array of num_matches
  95  * pci_match_conf structures.  match_buf is a pointer to the pci_conf
  96  * structure that will be compared to every entry in the matches array.
  97  * This function returns 1 on failure, 0 on success.
  98  */
  99 static int
 100 pci_conf_match(struct pci_match_conf *matches, int num_matches,
 101                struct pci_conf *match_buf)
 102 {
 103         int i;
 104
 105         if ((matches == NULL) || (match_buf == NULL) || (num_matches <= 0))
 106                 return(1);
 107
 108         for (i = 0; i < num_matches; i++) {
 109                 /*
 110                  * I'm not sure why someone would do this...but...
 111                  */
 112                 if (matches[i].flags == PCI_GETCONF_NO_MATCH)
 113                         continue;
 114
 115                 /*
 116                  * Look at each of the match flags.  If it's set, do the
 117                  * comparison.  If the comparison fails, we don't have a
 118                  * match, go on to the next item if there is one.
 119                  */
 120                 if (((matches[i].flags & PCI_GETCONF_MATCH_DOMAIN) != 0)
 121                  && (match_buf->pc_sel.pc_domain !=
 122                  matches[i].pc_sel.pc_domain))
 123                         continue;
 124
 125                 if (((matches[i].flags & PCI_GETCONF_MATCH_BUS) != 0)
 126                  && (match_buf->pc_sel.pc_bus != matches[i].pc_sel.pc_bus))
 127                         continue;
 128
 129                 if (((matches[i].flags & PCI_GETCONF_MATCH_DEV) != 0)
 130                  && (match_buf->pc_sel.pc_dev != matches[i].pc_sel.pc_dev))
 131                         continue;
 132
 133                 if (((matches[i].flags & PCI_GETCONF_MATCH_FUNC) != 0)
 134                  && (match_buf->pc_sel.pc_func != matches[i].pc_sel.pc_func))
 135                         continue;
 136
 137                 if (((matches[i].flags & PCI_GETCONF_MATCH_VENDOR) != 0)
 138                  && (match_buf->pc_vendor != matches[i].pc_vendor))
 139                         continue;
 140
 141                 if (((matches[i].flags & PCI_GETCONF_MATCH_DEVICE) != 0)
 142                  && (match_buf->pc_device != matches[i].pc_device))
 143                         continue;
 144
 145                 if (((matches[i].flags & PCI_GETCONF_MATCH_CLASS) != 0)
 146                  && (match_buf->pc_class != matches[i].pc_class))
 147                         continue;
 148
 149                 if (((matches[i].flags & PCI_GETCONF_MATCH_UNIT) != 0)
 150                  && (match_buf->pd_unit != matches[i].pd_unit))
 151                         continue;
 152
 153                 if (((matches[i].flags & PCI_GETCONF_MATCH_NAME) != 0)
 154                  && (strncmp(matches[i].pd_name, match_buf->pd_name,
 155                              sizeof(match_buf->pd_name)) != 0))
 156                         continue;
 157
 158                 return(0);
 159         }
 160
 161         return(1);
 162 }
 163
 164 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
 165     defined(COMPAT_FREEBSD6) || defined(__DragonFly__)
 166 #define PRE7_COMPAT
 167
 168 typedef enum {
 169         PCI_GETCONF_NO_MATCH_OLD        = 0x00,
 170         PCI_GETCONF_MATCH_BUS_OLD       = 0x01,
 171         PCI_GETCONF_MATCH_DEV_OLD       = 0x02,
 172         PCI_GETCONF_MATCH_FUNC_OLD      = 0x04,
 173         PCI_GETCONF_MATCH_NAME_OLD      = 0x08,
 174         PCI_GETCONF_MATCH_UNIT_OLD      = 0x10,
 175         PCI_GETCONF_MATCH_VENDOR_OLD    = 0x20,
 176         PCI_GETCONF_MATCH_DEVICE_OLD    = 0x40,
 177         PCI_GETCONF_MATCH_CLASS_OLD     = 0x80
 178 } pci_getconf_flags_old;
 179
 180 struct pcisel_old {
 181         u_int8_t        pc_bus;         /* bus number */
 182         u_int8_t        pc_dev;         /* device on this bus */
 183         u_int8_t        pc_func;        /* function on this device */
 184 };
 185
 186 struct pci_conf_old {
 187         struct pcisel_old pc_sel;       /* bus+slot+function */
 188         u_int8_t        pc_hdr;         /* PCI header type */
 189         u_int16_t       pc_subvendor;   /* card vendor ID */
 190         u_int16_t       pc_subdevice;   /* card device ID, assigned by
 191                                            card vendor */
 192         u_int16_t       pc_vendor;      /* chip vendor ID */
 193         u_int16_t       pc_device;      /* chip device ID, assigned by
 194                                            chip vendor */
 195         u_int8_t        pc_class;       /* chip PCI class */
 196         u_int8_t        pc_subclass;    /* chip PCI subclass */
 197         u_int8_t        pc_progif;      /* chip PCI programming interface */
 198         u_int8_t        pc_revid;       /* chip revision ID */
 199         char            pd_name[PCI_MAXNAMELEN + 1];  /* device name */
 200         u_long          pd_unit;        /* device unit number */
 201 };
 202
 203 struct pci_match_conf_old {
 204         struct pcisel_old       pc_sel;         /* bus+slot+function */
 205         char                    pd_name[PCI_MAXNAMELEN + 1];  /* device name */
 206         u_long                  pd_unit;        /* Unit number */
 207         u_int16_t               pc_vendor;      /* PCI Vendor ID */
 208         u_int16_t               pc_device;      /* PCI Device ID */
 209         u_int8_t                pc_class;       /* PCI class */
 210         pci_getconf_flags_old   flags;          /* Matching expression */
 211 };
 212
 213 struct pci_io_old {
 214         struct pcisel_old pi_sel;       /* device to operate on */
 215         int             pi_reg;         /* configuration register to examine */
 216         int             pi_width;       /* width (in bytes) of read or write */
 217         u_int32_t       pi_data;        /* data to write or result of read */
 218 };
 219
 220 #define PCIOCGETCONF_OLD        _IOWR('p', 1, struct pci_conf_io)
 221 #define PCIOCREAD_OLD           _IOWR('p', 2, struct pci_io_old)
 222 #define PCIOCWRITE_OLD          _IOWR('p', 3, struct pci_io_old)
 223
 224 static int      pci_conf_match_old(struct pci_match_conf_old *matches,
 225                     int num_matches, struct pci_conf *match_buf);
 226
 227 static int
 228 pci_conf_match_old(struct pci_match_conf_old *matches, int num_matches,
 229     struct pci_conf *match_buf)
 230 {
 231         int i;
 232
 233         if ((matches == NULL) || (match_buf == NULL) || (num_matches <= 0))
 234                 return(1);
 235
 236         for (i = 0; i < num_matches; i++) {
 237                 if (match_buf->pc_sel.pc_domain != 0)
 238                         continue;
 239
 240                 /*
 241                  * I'm not sure why someone would do this...but...
 242                  */
 243                 if (matches[i].flags == PCI_GETCONF_NO_MATCH_OLD)
 244                         continue;
 245
 246                 /*
 247                  * Look at each of the match flags.  If it's set, do the
 248                  * comparison.  If the comparison fails, we don't have a
 249                  * match, go on to the next item if there is one.
 250                  */
 251                 if (((matches[i].flags & PCI_GETCONF_MATCH_BUS_OLD) != 0)
 252                  && (match_buf->pc_sel.pc_bus != matches[i].pc_sel.pc_bus))
 253                         continue;
 254
 255                 if (((matches[i].flags & PCI_GETCONF_MATCH_DEV_OLD) != 0)
 256                  && (match_buf->pc_sel.pc_dev != matches[i].pc_sel.pc_dev))
 257                         continue;
 258
 259                 if (((matches[i].flags & PCI_GETCONF_MATCH_FUNC_OLD) != 0)
 260                  && (match_buf->pc_sel.pc_func != matches[i].pc_sel.pc_func))
 261                         continue;
 262
 263                 if (((matches[i].flags & PCI_GETCONF_MATCH_VENDOR_OLD) != 0)
 264                  && (match_buf->pc_vendor != matches[i].pc_vendor))
 265                         continue;
 266
 267                 if (((matches[i].flags & PCI_GETCONF_MATCH_DEVICE_OLD) != 0)
 268                  && (match_buf->pc_device != matches[i].pc_device))
 269                         continue;
 270
 271                 if (((matches[i].flags & PCI_GETCONF_MATCH_CLASS_OLD) != 0)
 272                  && (match_buf->pc_class != matches[i].pc_class))
 273                         continue;
 274
 275                 if (((matches[i].flags & PCI_GETCONF_MATCH_UNIT_OLD) != 0)
 276                  && (match_buf->pd_unit != matches[i].pd_unit))
 277                         continue;
 278
 279                 if (((matches[i].flags & PCI_GETCONF_MATCH_NAME_OLD) != 0)
 280                  && (strncmp(matches[i].pd_name, match_buf->pd_name,
 281                              sizeof(match_buf->pd_name)) != 0))
 282                         continue;
 283
 284                 return(0);
 285         }
 286
 287         return(1);
 288 }
 289
 290 #endif
 291
 292 static int
 293 pci_ioctl(struct dev_ioctl_args *ap)
 294 {
 295         device_t pcidev, brdev;
 296         void *confdata;
 297         const char *name;
 298         struct devlist *devlist_head;
 299         struct pci_conf_io *cio;
 300         struct pci_devinfo *dinfo;
 301         struct pci_io *io;
 302         struct pci_bar_io *bio;
 303         struct pci_match_conf *pattern_buf;
 304         struct resource_list_entry *rle;
 305         uint32_t value;
 306         size_t confsz, iolen, pbufsz;
 307         int error, ionum, i, num_patterns;
 308 #ifdef PRE7_COMPAT
 309         struct pci_conf_old conf_old;
 310         struct pci_io iodata;
 311         struct pci_io_old *io_old;
 312         struct pci_match_conf_old *pattern_buf_old;
 313
 314         io_old = NULL;
 315         pattern_buf_old = NULL;
 316
 317         if (!(ap->a_fflag & FWRITE) && ap->a_cmd != PCIOCGETBAR &&
 318             ap->a_cmd != PCIOCGETCONF && ap->a_cmd != PCIOCGETCONF_OLD)
 319                 return EPERM;
 320 #else
 321         if (!(ap->a_fflag & FWRITE) && ap->a_cmd != PCIOCGETBAR && ap->a_cmd != PCIOCGETCONF)
 322                 return EPERM;
 323 #endif
 324
 325         lwkt_gettoken(&pci_token);
 326
 327         switch(ap->a_cmd) {
 328 #ifdef PRE7_COMPAT
 329         case PCIOCGETCONF_OLD:
 330                 /* FALLTHROUGH */
 331 #endif
 332         case PCIOCGETCONF:
 333                 cio = (struct pci_conf_io *)ap->a_data;
 334
 335                 pattern_buf = NULL;
 336                 num_patterns = 0;
 337                 dinfo = NULL;
 338
 339                 cio->num_matches = 0;
 340
 341                 /*
 342                  * If the user specified an offset into the device list,
 343                  * but the list has changed since they last called this
 344                  * ioctl, tell them that the list has changed.  They will
 345                  * have to get the list from the beginning.
 346                  */
 347                 if ((cio->offset != 0)
 348                  && (cio->generation != pci_generation)){
 349                         cio->status = PCI_GETCONF_LIST_CHANGED;
 350                         error = 0;
 351                         break;
 352                 }
 353
 354                 /*
 355                  * Check to see whether the user has asked for an offset
 356                  * past the end of our list.
 357                  */
 358                 if (cio->offset >= pci_numdevs) {
 359                         cio->status = PCI_GETCONF_LAST_DEVICE;
 360                         error = 0;
 361                         break;
 362                 }
 363
 364                 /* get the head of the device queue */
 365                 devlist_head = &pci_devq;
 366
 367                 /*
 368                  * Determine how much room we have for pci_conf structures.
 369                  * Round the user's buffer size down to the nearest
 370                  * multiple of sizeof(struct pci_conf) in case the user
 371                  * didn't specify a multiple of that size.
 372                  */
 373 #ifdef PRE7_COMPAT
 374                 if (ap->a_cmd == PCIOCGETCONF_OLD)
 375                         confsz = sizeof(struct pci_conf_old);
 376                 else
 377 #endif
 378                         confsz = sizeof(struct pci_conf);
 379                 iolen = min(cio->match_buf_len - (cio->match_buf_len % confsz),
 380                     pci_numdevs * confsz);
 381
 382                 /*
 383                  * Since we know that iolen is a multiple of the size of
 384                  * the pciconf union, it's okay to do this.
 385                  */
 386                 ionum = iolen / confsz;
 387
 388                 /*
 389                  * If this test is true, the user wants the pci_conf
 390                  * structures returned to match the supplied entries.
 391                  */
 392                 if ((cio->num_patterns > 0) && (cio->num_patterns < pci_numdevs)
 393                  && (cio->pat_buf_len > 0)) {
 394                         /*
 395                          * pat_buf_len needs to be:
 396                          * num_patterns * sizeof(struct pci_match_conf)
 397                          * While it is certainly possible the user just
 398                          * allocated a large buffer, but set the number of
 399                          * matches correctly, it is far more likely that
 400                          * their kernel doesn't match the userland utility
 401                          * they're using.  It's also possible that the user
 402                          * forgot to initialize some variables.  Yes, this
 403                          * may be overly picky, but I hazard to guess that
 404                          * it's far more likely to just catch folks that
 405                          * updated their kernel but not their userland.
 406                          */
 407 #ifdef PRE7_COMPAT
 408                         if (ap->a_cmd == PCIOCGETCONF_OLD)
 409                                 pbufsz = sizeof(struct pci_match_conf_old);
 410                         else
 411 #endif
 412                                 pbufsz = sizeof(struct pci_match_conf);
 413                         if (cio->num_patterns * pbufsz != cio->pat_buf_len) {
 414                                 /* The user made a mistake, return an error. */
 415                                 cio->status = PCI_GETCONF_ERROR;
 416                                 error = EINVAL;
 417                                 break;
 418                         }
 419
 420                         /*
 421                          * Allocate a buffer to hold the patterns.
 422                          */
 423 #ifdef PRE7_COMPAT
 424                         if (ap->a_cmd == PCIOCGETCONF_OLD) {
 425                                 pattern_buf_old = kmalloc(cio->pat_buf_len,
 426                                     M_TEMP, M_WAITOK);
 427                                 error = copyin(cio->patterns,
 428                                     pattern_buf_old, cio->pat_buf_len);
 429                         } else
 430 #endif
 431                         {
 432                                 pattern_buf = kmalloc(cio->pat_buf_len, M_TEMP,
 433                                     M_WAITOK);
 434                                 error = copyin(cio->patterns, pattern_buf,
 435                                     cio->pat_buf_len);
 436                         }
 437                         if (error != 0) {
 438                                 error = EINVAL;
 439                                 goto getconfexit;
 440                         }
 441                         num_patterns = cio->num_patterns;
 442                 } else if ((cio->num_patterns > 0)
 443                         || (cio->pat_buf_len > 0)) {
 444                         /*
 445                          * The user made a mistake, spit out an error.
 446                          */
 447                         cio->status = PCI_GETCONF_ERROR;
 448                         error = EINVAL;
 449                         break;
 450                 }
 451
 452                 /*
 453                  * Go through the list of devices and copy out the devices
 454                  * that match the user's criteria.
 455                  */
 456                 for (cio->num_matches = 0, error = 0, i = 0,
 457                      dinfo = STAILQ_FIRST(devlist_head);
 458                      (dinfo != NULL) && (cio->num_matches < ionum)
 459                      && (error == 0) && (i < pci_numdevs) && (dinfo != NULL);
 460                      dinfo = STAILQ_NEXT(dinfo, pci_links), i++) {
 461
 462                         if (i < cio->offset)
 463                                 continue;
 464
 465                         /* Populate pd_name and pd_unit */
 466                         name = NULL;
 467                         if (dinfo->cfg.dev)
 468                                 name = device_get_name(dinfo->cfg.dev);
 469                         if (name) {
 470                                 strncpy(dinfo->conf.pd_name, name,
 471                                         sizeof(dinfo->conf.pd_name));
 472                                 dinfo->conf.pd_name[PCI_MAXNAMELEN] = 0;
 473                                 dinfo->conf.pd_unit =
 474                                         device_get_unit(dinfo->cfg.dev);
 475                         } else {
 476                                 dinfo->conf.pd_name[0] = '\0';
 477                                 dinfo->conf.pd_unit = 0;
 478                         }
 479
 480 #ifdef PRE7_COMPAT
 481                         if ((ap->a_cmd == PCIOCGETCONF_OLD &&
 482                             (pattern_buf_old == NULL ||
 483                             pci_conf_match_old(pattern_buf_old, num_patterns,
 484                             &dinfo->conf) == 0)) ||
 485                             (ap->a_cmd == PCIOCGETCONF &&
 486                             (pattern_buf == NULL ||
 487                             pci_conf_match(pattern_buf, num_patterns,
 488                             &dinfo->conf) == 0))) {
 489 #else
 490                         if (pattern_buf == NULL ||
 491                             pci_conf_match(pattern_buf, num_patterns,
 492                             &dinfo->conf) == 0) {
 493 #endif
 494                                 /*
 495                                  * If we've filled up the user's buffer,
 496                                  * break out at this point.  Since we've
 497                                  * got a match here, we'll pick right back
 498                                  * up at the matching entry.  We can also
 499                                  * tell the user that there are more matches
 500                                  * left.
 501                                  */
 502                                 if (cio->num_matches >= ionum)
 503                                         break;
 504
 505 #ifdef PRE7_COMPAT
 506                                 if (ap->a_cmd == PCIOCGETCONF_OLD) {
 507                                         conf_old.pc_sel.pc_bus =
 508                                             dinfo->conf.pc_sel.pc_bus;
 509                                         conf_old.pc_sel.pc_dev =
 510                                             dinfo->conf.pc_sel.pc_dev;
 511                                         conf_old.pc_sel.pc_func =
 512                                             dinfo->conf.pc_sel.pc_func;
 513                                         conf_old.pc_hdr = dinfo->conf.pc_hdr;
 514                                         conf_old.pc_subvendor =
 515                                             dinfo->conf.pc_subvendor;
 516                                         conf_old.pc_subdevice =
 517                                             dinfo->conf.pc_subdevice;
 518                                         conf_old.pc_vendor =
 519                                             dinfo->conf.pc_vendor;
 520                                         conf_old.pc_device =
 521                                             dinfo->conf.pc_device;
 522                                         conf_old.pc_class =
 523                                             dinfo->conf.pc_class;
 524                                         conf_old.pc_subclass =
 525                                             dinfo->conf.pc_subclass;
 526                                         conf_old.pc_progif =
 527                                             dinfo->conf.pc_progif;
 528                                         conf_old.pc_revid =
 529                                             dinfo->conf.pc_revid;
 530                                         strncpy(conf_old.pd_name,
 531                                             dinfo->conf.pd_name,
 532                                             sizeof(conf_old.pd_name));
 533                                         conf_old.pd_name[PCI_MAXNAMELEN] = 0;
 534                                         conf_old.pd_unit =
 535                                             dinfo->conf.pd_unit;
 536                                         confdata = &conf_old;
 537                                 } else
 538 #endif
 539                                         confdata = &dinfo->conf;
 540                                 /* Only if we can copy it out do we count it. */
 541                                 if (!(error = copyout(confdata,
 542                                     (caddr_t)cio->matches +
 543                                     confsz * cio->num_matches, confsz)))
 544                                         cio->num_matches++;
 545                         }
 546                 }
 547
 548                 /*
 549                  * Set the pointer into the list, so if the user is getting
 550                  * n records at a time, where n < pci_numdevs,
 551                  */
 552                 cio->offset = i;
 553
 554                 /*
 555                  * Set the generation, the user will need this if they make
 556                  * another ioctl call with offset != 0.
 557                  */
 558                 cio->generation = pci_generation;
 559
 560                 /*
 561                  * If this is the last device, inform the user so he won't
 562                  * bother asking for more devices.  If dinfo isn't NULL, we
 563                  * know that there are more matches in the list because of
 564                  * the way the traversal is done.
 565                  */
 566                 if (dinfo == NULL)
 567                         cio->status = PCI_GETCONF_LAST_DEVICE;
 568                 else
 569                         cio->status = PCI_GETCONF_MORE_DEVS;
 570
 571 getconfexit:
 572                 if (pattern_buf != NULL)
 573                         kfree(pattern_buf, M_TEMP);
 574 #ifdef PRE7_COMPAT
 575                 if (pattern_buf_old != NULL)
 576                         kfree(pattern_buf_old, M_TEMP);
 577 #endif
 578
 579                 break;
 580
 581 #ifdef PRE7_COMPAT
 582         case PCIOCREAD_OLD:
 583         case PCIOCWRITE_OLD:
 584                 io_old = (struct pci_io_old *)ap->a_data;
 585                 iodata.pi_sel.pc_domain = 0;
 586                 iodata.pi_sel.pc_bus = io_old->pi_sel.pc_bus;
 587                 iodata.pi_sel.pc_dev = io_old->pi_sel.pc_dev;
 588                 iodata.pi_sel.pc_func = io_old->pi_sel.pc_func;
 589                 iodata.pi_reg = io_old->pi_reg;
 590                 iodata.pi_width = io_old->pi_width;
 591                 iodata.pi_data = io_old->pi_data;
 592                 ap->a_data = (caddr_t)&iodata;
 593                 /* FALLTHROUGH */
 594 #endif
 595         case PCIOCREAD:
 596         case PCIOCWRITE:
 597                 io = (struct pci_io *)ap->a_data;
 598                 switch(io->pi_width) {
 599                 case 4:
 600                 case 2:
 601                 case 1:
 602                         /* Make sure register is not negative and aligned. */
 603                         if (io->pi_reg < 0 ||
 604                             io->pi_reg & (io->pi_width - 1)) {
 605                                 error = EINVAL;
 606                                 break;
 607                         }
 608                         /*
 609                          * Assume that the user-level bus number is
 610                          * in fact the physical PCI bus number.
 611                          * Look up the grandparent, i.e. the bridge device,
 612                          * so that we can issue configuration space cycles.
 613                          */
 614                         pcidev = pci_find_dbsf(io->pi_sel.pc_domain,
 615                             io->pi_sel.pc_bus, io->pi_sel.pc_dev,
 616                             io->pi_sel.pc_func);
 617                         if (pcidev) {
 618                                 brdev = device_get_parent(
 619                                     device_get_parent(pcidev));
 620
 621 #ifdef PRE7_COMPAT
 622                                 if (ap->a_cmd == PCIOCWRITE || ap->a_cmd == PCIOCWRITE_OLD)
 623 #else
 624                                 if (ap->a_cmd == PCIOCWRITE)
 625 #endif
 626                                         PCIB_WRITE_CONFIG(brdev,
 627                                                           io->pi_sel.pc_bus,
 628                                                           io->pi_sel.pc_dev,
 629                                                           io->pi_sel.pc_func,
 630                                                           io->pi_reg,
 631                                                           io->pi_data,
 632                                                           io->pi_width);
 633 #ifdef PRE7_COMPAT
 634                                 else if (ap->a_cmd == PCIOCREAD_OLD)
 635                                         io_old->pi_data =
 636                                                 PCIB_READ_CONFIG(brdev,
 637                                                           io->pi_sel.pc_bus,
 638                                                           io->pi_sel.pc_dev,
 639                                                           io->pi_sel.pc_func,
 640                                                           io->pi_reg,
 641                                                           io->pi_width);
 642 #endif
 643                                 else
 644                                         io->pi_data =
 645                                                 PCIB_READ_CONFIG(brdev,
 646                                                           io->pi_sel.pc_bus,
 647                                                           io->pi_sel.pc_dev,
 648                                                           io->pi_sel.pc_func,
 649                                                           io->pi_reg,
 650                                                           io->pi_width);
 651                                 error = 0;
 652                         } else {
 653 #ifdef COMPAT_FREEBSD4
 654                                 if (cmd == PCIOCREAD_OLD) {
 655                                         io_old->pi_data = -1;
 656                                         error = 0;
 657                                 } else
 658 #endif
 659                                         error = ENODEV;
 660                         }
 661                         break;
 662                 default:
 663                         error = EINVAL;
 664                         break;
 665                 }
 666                 break;
 667
 668         case PCIOCGETBAR:
 669                 bio = (struct pci_bar_io *)ap->a_data;
 670
 671                 /*
 672                  * Assume that the user-level bus number is
 673                  * in fact the physical PCI bus number.
 674                  */
 675                 pcidev = pci_find_dbsf(bio->pbi_sel.pc_domain,
 676                     bio->pbi_sel.pc_bus, bio->pbi_sel.pc_dev,
 677                     bio->pbi_sel.pc_func);
 678                 if (pcidev == NULL) {
 679                         error = ENODEV;
 680                         break;
 681                 }
 682                 dinfo = device_get_ivars(pcidev);
 683
 684                 /*
 685                  * Look for a resource list entry matching the requested BAR.
 686                  *
 687                  * XXX: This will not find BARs that are not initialized, but
 688                  * maybe that is ok?
 689                  */
 690                 rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY,
 691                     bio->pbi_reg);
 692                 if (rle == NULL)
 693                         rle = resource_list_find(&dinfo->resources,
 694                             SYS_RES_IOPORT, bio->pbi_reg);
 695                 if (rle == NULL || rle->res == NULL) {
 696                         error = EINVAL;
 697                         break;
 698                 }
 699
 700                 /*
 701                  * Ok, we have a resource for this BAR.  Read the lower
 702                  * 32 bits to get any flags.
 703                  */
 704                 value = pci_read_config(pcidev, bio->pbi_reg, 4);
 705                 if (PCI_BAR_MEM(value)) {
 706                         if (rle->type != SYS_RES_MEMORY) {
 707                                 error = EINVAL;
 708                                 break;
 709                         }
 710                         value &= ~PCIM_BAR_MEM_BASE;
 711                 } else {
 712                         if (rle->type != SYS_RES_IOPORT) {
 713                                 error = EINVAL;
 714                                 break;
 715                         }
 716                         value &= ~PCIM_BAR_IO_BASE;
 717                 }
 718                 bio->pbi_base = rman_get_start(rle->res) | value;
 719                 bio->pbi_length = rman_get_size(rle->res);
 720
 721                 /*
 722                  * Check the command register to determine if this BAR
 723                  * is enabled.
 724                  */
 725                 value = pci_read_config(pcidev, PCIR_COMMAND, 2);
 726                 if (rle->type == SYS_RES_MEMORY)
 727                         bio->pbi_enabled = (value & PCIM_CMD_MEMEN) != 0;
 728                 else
 729                         bio->pbi_enabled = (value & PCIM_CMD_PORTEN) != 0;
 730                 error = 0;
 731                 break;
 732         case PCIOCATTACHED:
 733                 error = 0;
 734                 io = (struct pci_io *)ap->a_data;
 735                 pcidev = pci_find_dbsf(io->pi_sel.pc_domain, io->pi_sel.pc_bus,
 736                                        io->pi_sel.pc_dev, io->pi_sel.pc_func);
 737                 if (pcidev != NULL)
 738                         io->pi_data = device_is_attached(pcidev);
 739                 else
 740                         error = ENODEV;
 741                 break;
 742         default:
 743                 error = ENOTTY;
 744                 break;
 745         }
 746         lwkt_reltoken(&pci_token);
 747
 748         return (error);
 749 }