usr/src/uts/i86pc/io/pci/pci.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright 2012 Garrett D'Amore <garrett@damore.org>.  All rights reserved.
  27  */
  28
  29 /*
  30  *      Host to PCI local bus driver
  31  */
  32
  33 #include <sys/conf.h>
  34 #include <sys/modctl.h>
  35 #include <sys/pci.h>
  36 #include <sys/pci_impl.h>
  37 #include <sys/sysmacros.h>
  38 #include <sys/sunndi.h>
  39 #include <sys/ddifm.h>
  40 #include <sys/ndifm.h>
  41 #include <sys/fm/protocol.h>
  42 #include <sys/hotplug/pci/pcihp.h>
  43 #include <io/pci/pci_common.h>
  44 #include <io/pci/pci_tools_ext.h>
  45
  46 /* Save minimal state. */
  47 void *pci_statep;
  48
  49 /*
  50  * Bus Operation functions
  51  */
  52 static int      pci_bus_map(dev_info_t *, dev_info_t *, ddi_map_req_t *,
  53                     off_t, off_t, caddr_t *);
  54 static int      pci_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t,
  55                     void *, void *);
  56 static int      pci_intr_ops(dev_info_t *, dev_info_t *, ddi_intr_op_t,
  57                     ddi_intr_handle_impl_t *, void *);
  58 static int      pci_fm_init(dev_info_t *, dev_info_t *, int,
  59                     ddi_iblock_cookie_t *);
  60 static int      pci_fm_callback(dev_info_t *, ddi_fm_error_t *, const void *);
  61
  62 struct bus_ops pci_bus_ops = {
  63         BUSO_REV,
  64         pci_bus_map,
  65         NULL,
  66         NULL,
  67         NULL,
  68         i_ddi_map_fault,
  69         NULL,
  70         ddi_dma_allochdl,
  71         ddi_dma_freehdl,
  72         ddi_dma_bindhdl,
  73         ddi_dma_unbindhdl,
  74         ddi_dma_flush,
  75         ddi_dma_win,
  76         ddi_dma_mctl,
  77         pci_ctlops,
  78         ddi_bus_prop_op,
  79         0,              /* (*bus_get_eventcookie)();    */
  80         0,              /* (*bus_add_eventcall)();      */
  81         0,              /* (*bus_remove_eventcall)();   */
  82         0,              /* (*bus_post_event)();         */
  83         0,              /* (*bus_intr_ctl)(); */
  84         0,              /* (*bus_config)(); */
  85         0,              /* (*bus_unconfig)(); */
  86         pci_fm_init,    /* (*bus_fm_init)(); */
  87         NULL,           /* (*bus_fm_fini)(); */
  88         NULL,           /* (*bus_fm_access_enter)(); */
  89         NULL,           /* (*bus_fm_access_exit)(); */
  90         NULL,           /* (*bus_power)(); */
  91         pci_intr_ops    /* (*bus_intr_op)(); */
  92 };
  93
  94 /*
  95  * One goal here is to leverage off of the pcihp.c source without making
  96  * changes to it.  Call into it's cb_ops directly if needed, piggybacking
  97  * anything else needed by the pci_tools.c module.  Only pci_tools and pcihp
  98  * will be opening PCI nexus driver file descriptors.
  99  */
 100 static int      pci_open(dev_t *, int, int, cred_t *);
 101 static int      pci_close(dev_t, int, int, cred_t *);
 102 static int      pci_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 103 static int      pci_prop_op(dev_t, dev_info_t *, ddi_prop_op_t, int, char *,
 104                     caddr_t, int *);
 105 static int      pci_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
 106 static void     pci_peekpoke_cb(dev_info_t *, ddi_fm_error_t *);
 107
 108 struct cb_ops pci_cb_ops = {
 109         pci_open,                       /* open */
 110         pci_close,                      /* close */
 111         nodev,                          /* strategy */
 112         nodev,                          /* print */
 113         nodev,                          /* dump */
 114         nodev,                          /* read */
 115         nodev,                          /* write */
 116         pci_ioctl,                      /* ioctl */
 117         nodev,                          /* devmap */
 118         nodev,                          /* mmap */
 119         nodev,                          /* segmap */
 120         nochpoll,                       /* poll */
 121         pci_prop_op,                    /* cb_prop_op */
 122         NULL,                           /* streamtab */
 123         D_NEW | D_MP | D_HOTPLUG,       /* Driver compatibility flag */
 124         CB_REV,                         /* rev */
 125         nodev,                          /* int (*cb_aread)() */
 126         nodev                           /* int (*cb_awrite)() */
 127 };
 128
 129 /*
 130  * Device Node Operation functions
 131  */
 132 static int pci_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
 133 static int pci_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
 134
 135 struct dev_ops pci_ops = {
 136         DEVO_REV,               /* devo_rev */
 137         0,                      /* refcnt  */
 138         pci_info,               /* info */
 139         nulldev,                /* identify */
 140         nulldev,                /* probe */
 141         pci_attach,             /* attach */
 142         pci_detach,             /* detach */
 143         nulldev,                /* reset */
 144         &pci_cb_ops,            /* driver operations */
 145         &pci_bus_ops,           /* bus operations */
 146         NULL,                   /* power */
 147         ddi_quiesce_not_needed          /* quiesce */
 148 };
 149
 150 /*
 151  * This variable controls the default setting of the command register
 152  * for pci devices.  See pci_initchild() for details.
 153  */
 154 static ushort_t pci_command_default = PCI_COMM_ME |
 155                                         PCI_COMM_MAE |
 156                                         PCI_COMM_IO;
 157
 158 /*
 159  * Internal routines in support of particular pci_ctlops.
 160  */
 161 static int pci_removechild(dev_info_t *child);
 162 static int pci_initchild(dev_info_t *child);
 163
 164 /*
 165  * Module linkage information for the kernel.
 166  */
 167
 168 static struct modldrv modldrv = {
 169         &mod_driverops,                         /* Type of module */
 170         "x86 Host to PCI nexus driver",         /* Name of module */
 171         &pci_ops,                               /* driver ops */
 172 };
 173
 174 static struct modlinkage modlinkage = {
 175         MODREV_1,
 176         (void *)&modldrv,
 177         NULL
 178 };
 179
 180 int
 181 _init(void)
 182 {
 183         int e;
 184
 185         /*
 186          * Initialize per-pci bus soft state pointer.
 187          */
 188         e = ddi_soft_state_init(&pci_statep, sizeof (pci_state_t), 1);
 189         if (e != 0)
 190                 return (e);
 191
 192         if ((e = mod_install(&modlinkage)) != 0)
 193                 ddi_soft_state_fini(&pci_statep);
 194
 195         return (e);
 196 }
 197
 198 int
 199 _fini(void)
 200 {
 201         int rc;
 202
 203         rc = mod_remove(&modlinkage);
 204         if (rc != 0)
 205                 return (rc);
 206
 207         ddi_soft_state_fini(&pci_statep);
 208
 209         return (rc);
 210 }
 211
 212 int
 213 _info(struct modinfo *modinfop)
 214 {
 215         return (mod_info(&modlinkage, modinfop));
 216 }
 217
 218 /*ARGSUSED*/
 219 static int
 220 pci_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
 221 {
 222         /*
 223          * Use the minor number as constructed by pcihp, as the index value to
 224          * ddi_soft_state_zalloc.
 225          */
 226         int instance = ddi_get_instance(devi);
 227         pci_state_t *pcip = NULL;
 228         switch (cmd) {
 229         case DDI_ATTACH:
 230                 break;
 231
 232         case DDI_RESUME:
 233                 return (DDI_SUCCESS);
 234
 235         default:
 236                 return (DDI_FAILURE);
 237         }
 238
 239         if (ddi_prop_update_string(DDI_DEV_T_NONE, devi, "device_type", "pci")
 240             != DDI_PROP_SUCCESS) {
 241                 cmn_err(CE_WARN, "pci:  'device_type' prop create failed");
 242         }
 243
 244         if (ddi_soft_state_zalloc(pci_statep, instance) == DDI_SUCCESS) {
 245                 pcip = ddi_get_soft_state(pci_statep, instance);
 246         }
 247
 248         if (pcip == NULL) {
 249                 goto bad_soft_state;
 250         }
 251
 252         pcip->pci_dip = devi;
 253         pcip->pci_soft_state = PCI_SOFT_STATE_CLOSED;
 254
 255         /*
 256          * Initialize hotplug support on this bus. At minimum
 257          * (for non hotplug bus) this would create ":devctl" minor
 258          * node to support DEVCTL_DEVICE_* and DEVCTL_BUS_* ioctls
 259          * to this bus.
 260          */
 261         if (pcihp_init(devi) != DDI_SUCCESS) {
 262                 cmn_err(CE_WARN, "pci: Failed to setup hotplug framework");
 263                 goto bad_pcihp_init;
 264         }
 265
 266         /* Second arg: initialize for pci, not pci_express */
 267         if (pcitool_init(devi, B_FALSE) != DDI_SUCCESS) {
 268                 goto bad_pcitool_init;
 269         }
 270
 271         pcip->pci_fmcap = DDI_FM_ERRCB_CAPABLE |
 272             DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;
 273         ddi_fm_init(devi, &pcip->pci_fmcap, &pcip->pci_fm_ibc);
 274         mutex_init(&pcip->pci_mutex, NULL, MUTEX_DRIVER, NULL);
 275         mutex_init(&pcip->pci_err_mutex, NULL, MUTEX_DRIVER,
 276             (void *)pcip->pci_fm_ibc);
 277         mutex_init(&pcip->pci_peek_poke_mutex, NULL, MUTEX_DRIVER,
 278             (void *)pcip->pci_fm_ibc);
 279         if (pcip->pci_fmcap & DDI_FM_ERRCB_CAPABLE) {
 280                 pci_ereport_setup(devi);
 281                 ddi_fm_handler_register(devi, pci_fm_callback, NULL);
 282         }
 283
 284         ddi_report_dev(devi);
 285
 286         return (DDI_SUCCESS);
 287
 288 bad_pcitool_init:
 289         (void) pcihp_uninit(devi);
 290 bad_pcihp_init:
 291         ddi_soft_state_free(pci_statep, instance);
 292 bad_soft_state:
 293         return (DDI_FAILURE);
 294 }
 295
 296 /*ARGSUSED*/
 297 static int
 298 pci_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
 299 {
 300         int instance = ddi_get_instance(devi);
 301         pci_state_t *pcip;
 302
 303         pcip = ddi_get_soft_state(pci_statep, ddi_get_instance(devi));
 304
 305
 306         switch (cmd) {
 307         case DDI_DETACH:
 308                 if (pcip->pci_fmcap & DDI_FM_ERRCB_CAPABLE) {
 309                         ddi_fm_handler_unregister(devi);
 310                         pci_ereport_teardown(devi);
 311                 }
 312                 mutex_destroy(&pcip->pci_peek_poke_mutex);
 313                 mutex_destroy(&pcip->pci_err_mutex);
 314                 mutex_destroy(&pcip->pci_mutex);
 315                 ddi_fm_fini(devi);      /* Uninitialize pcitool support. */
 316                 pcitool_uninit(devi);
 317
 318                 /* Uninitialize hotplug support on this bus. */
 319                 (void) pcihp_uninit(devi);
 320
 321                 ddi_soft_state_free(pci_statep, instance);
 322
 323                 return (DDI_SUCCESS);
 324         case DDI_SUSPEND:
 325                 return (DDI_SUCCESS);
 326         default:
 327                 return (DDI_FAILURE);
 328         }
 329 }
 330
 331 static int
 332 pci_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
 333         off_t offset, off_t len, caddr_t *vaddrp)
 334 {
 335         struct regspec reg;
 336         ddi_map_req_t mr;
 337         ddi_acc_hdl_t *hp;
 338         ddi_acc_impl_t *hdlp;
 339         pci_regspec_t pci_reg;
 340         pci_regspec_t *pci_rp;
 341         int     rnumber;
 342         int     length;
 343         pci_acc_cfblk_t *cfp;
 344         int     space;
 345         pci_state_t *pcip;
 346
 347         mr = *mp; /* Get private copy of request */
 348         mp = &mr;
 349
 350         if (mp->map_handlep != NULL) {
 351                 pcip = ddi_get_soft_state(pci_statep, ddi_get_instance(dip));
 352                 hdlp = (ddi_acc_impl_t *)(mp->map_handlep)->ah_platform_private;
 353                 hdlp->ahi_err_mutexp = &pcip->pci_err_mutex;
 354                 hdlp->ahi_peekpoke_mutexp = &pcip->pci_peek_poke_mutex;
 355                 hdlp->ahi_scan_dip = dip;
 356                 hdlp->ahi_scan = pci_peekpoke_cb;
 357         }
 358
 359         /*
 360          * check for register number
 361          */
 362         switch (mp->map_type) {
 363         case DDI_MT_REGSPEC:
 364                 pci_reg = *(pci_regspec_t *)(mp->map_obj.rp);
 365                 pci_rp = &pci_reg;
 366                 if (pci_common_get_reg_prop(rdip, pci_rp) != DDI_SUCCESS)
 367                         return (DDI_FAILURE);
 368                 break;
 369         case DDI_MT_RNUMBER:
 370                 rnumber = mp->map_obj.rnumber;
 371                 /*
 372                  * get ALL "reg" properties for dip, select the one of
 373                  * of interest. In x86, "assigned-addresses" property
 374                  * is identical to the "reg" property, so there is no
 375                  * need to cross check the two to determine the physical
 376                  * address of the registers.
 377                  * This routine still performs some validity checks to
 378                  * make sure that everything is okay.
 379                  */
 380                 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, rdip,
 381                     DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
 382                     (uint_t *)&length) != DDI_PROP_SUCCESS)
 383                         return (DDI_FAILURE);
 384
 385                 /*
 386                  * validate the register number.
 387                  */
 388                 length /= (sizeof (pci_regspec_t) / sizeof (int));
 389                 if (rnumber >= length) {
 390                         ddi_prop_free(pci_rp);
 391                         return (DDI_FAILURE);
 392                 }
 393
 394                 /*
 395                  * copy the required entry.
 396                  */
 397                 pci_reg = pci_rp[rnumber];
 398
 399                 /*
 400                  * free the memory allocated by ddi_prop_lookup_int_array
 401                  */
 402                 ddi_prop_free(pci_rp);
 403
 404                 pci_rp = &pci_reg;
 405                 if (pci_common_get_reg_prop(rdip, pci_rp) != DDI_SUCCESS)
 406                         return (DDI_FAILURE);
 407                 mp->map_type = DDI_MT_REGSPEC;
 408                 break;
 409         default:
 410                 return (DDI_ME_INVAL);
 411         }
 412
 413         space = pci_rp->pci_phys_hi & PCI_REG_ADDR_M;
 414
 415         /*
 416          * check for unmap and unlock of address space
 417          */
 418         if ((mp->map_op == DDI_MO_UNMAP) || (mp->map_op == DDI_MO_UNLOCK)) {
 419                 /*
 420                  * Adjust offset and length
 421                  * A non-zero length means override the one in the regspec.
 422                  */
 423                 pci_rp->pci_phys_low += (uint_t)offset;
 424                 if (len != 0)
 425                         pci_rp->pci_size_low = len;
 426
 427                 switch (space) {
 428                 case PCI_ADDR_CONFIG:
 429                         /* No work required on unmap of Config space */
 430                         return (DDI_SUCCESS);
 431
 432                 case PCI_ADDR_IO:
 433                         reg.regspec_bustype = 1;
 434                         break;
 435
 436                 case PCI_ADDR_MEM64:
 437                         /*
 438                          * MEM64 requires special treatment on map, to check
 439                          * that the device is below 4G.  On unmap, however,
 440                          * we can assume that everything is OK... the map
 441                          * must have succeeded.
 442                          */
 443                         /* FALLTHROUGH */
 444                 case PCI_ADDR_MEM32:
 445                         reg.regspec_bustype = 0;
 446                         break;
 447
 448                 default:
 449                         return (DDI_FAILURE);
 450                 }
 451                 reg.regspec_addr = pci_rp->pci_phys_low;
 452                 reg.regspec_size = pci_rp->pci_size_low;
 453
 454                 mp->map_obj.rp = &reg;
 455                 return (ddi_map(dip, mp, (off_t)0, (off_t)0, vaddrp));
 456
 457         }
 458
 459         /* check for user mapping request - not legal for Config */
 460         if (mp->map_op == DDI_MO_MAP_HANDLE && space == PCI_ADDR_CONFIG) {
 461                 return (DDI_FAILURE);
 462         }
 463
 464         /*
 465          * check for config space
 466          * On x86, CONFIG is not mapped via MMU and there is
 467          * no endian-ness issues. Set the attr field in the handle to
 468          * indicate that the common routines to call the nexus driver.
 469          */
 470         if (space == PCI_ADDR_CONFIG) {
 471                 /* Can't map config space without a handle */
 472                 hp = (ddi_acc_hdl_t *)mp->map_handlep;
 473                 if (hp == NULL)
 474                         return (DDI_FAILURE);
 475
 476                 /* record the device address for future reference */
 477                 cfp = (pci_acc_cfblk_t *)&hp->ah_bus_private;
 478                 cfp->c_busnum = PCI_REG_BUS_G(pci_rp->pci_phys_hi);
 479                 cfp->c_devnum = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
 480                 cfp->c_funcnum = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);
 481
 482                 *vaddrp = (caddr_t)offset;
 483                 return (pci_fm_acc_setup(hp, offset, len));
 484         }
 485
 486         /*
 487          * range check
 488          */
 489         if ((offset >= pci_rp->pci_size_low) ||
 490             (len > pci_rp->pci_size_low) ||
 491             (offset + len > pci_rp->pci_size_low)) {
 492                 return (DDI_FAILURE);
 493         }
 494
 495         /*
 496          * Adjust offset and length
 497          * A non-zero length means override the one in the regspec.
 498          */
 499         pci_rp->pci_phys_low += (uint_t)offset;
 500         if (len != 0)
 501                 pci_rp->pci_size_low = len;
 502
 503         /*
 504          * convert the pci regsec into the generic regspec used by the
 505          * parent root nexus driver.
 506          */
 507         switch (space) {
 508         case PCI_ADDR_IO:
 509                 reg.regspec_bustype = 1;
 510                 break;
 511         case PCI_ADDR_MEM64:
 512                 /*
 513                  * We can't handle 64-bit devices that are mapped above
 514                  * 4G or that are larger than 4G.
 515                  */
 516                 if (pci_rp->pci_phys_mid != 0 ||
 517                     pci_rp->pci_size_hi != 0)
 518                         return (DDI_FAILURE);
 519                 /*
 520                  * Other than that, we can treat them as 32-bit mappings
 521                  */
 522                 /* FALLTHROUGH */
 523         case PCI_ADDR_MEM32:
 524                 reg.regspec_bustype = 0;
 525                 break;
 526         default:
 527                 return (DDI_FAILURE);
 528         }
 529         reg.regspec_addr = pci_rp->pci_phys_low;
 530         reg.regspec_size = pci_rp->pci_size_low;
 531
 532         mp->map_obj.rp = &reg;
 533         return (ddi_map(dip, mp, (off_t)0, (off_t)0, vaddrp));
 534 }
 535
 536
 537 /*ARGSUSED*/
 538 static int
 539 pci_ctlops(dev_info_t *dip, dev_info_t *rdip,
 540         ddi_ctl_enum_t ctlop, void *arg, void *result)
 541 {
 542         pci_regspec_t *drv_regp;
 543         uint_t  reglen;
 544         int     rn;
 545         int     totreg;
 546         pci_state_t *pcip;
 547         struct  attachspec *asp;
 548
 549         switch (ctlop) {
 550         case DDI_CTLOPS_REPORTDEV:
 551                 if (rdip == (dev_info_t *)0)
 552                         return (DDI_FAILURE);
 553                 cmn_err(CE_CONT, "?PCI-device: %s@%s, %s%d\n",
 554                     ddi_node_name(rdip), ddi_get_name_addr(rdip),
 555                     ddi_driver_name(rdip),
 556                     ddi_get_instance(rdip));
 557                 return (DDI_SUCCESS);
 558
 559         case DDI_CTLOPS_INITCHILD:
 560                 return (pci_initchild((dev_info_t *)arg));
 561
 562         case DDI_CTLOPS_UNINITCHILD:
 563                 return (pci_removechild((dev_info_t *)arg));
 564
 565         case DDI_CTLOPS_SIDDEV:
 566                 return (DDI_SUCCESS);
 567
 568         case DDI_CTLOPS_REGSIZE:
 569         case DDI_CTLOPS_NREGS:
 570                 if (rdip == (dev_info_t *)0)
 571                         return (DDI_FAILURE);
 572
 573                 *(int *)result = 0;
 574                 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, rdip,
 575                     DDI_PROP_DONTPASS, "reg", (int **)&drv_regp,
 576                     &reglen) != DDI_PROP_SUCCESS) {
 577                         return (DDI_FAILURE);
 578                 }
 579
 580                 totreg = (reglen * sizeof (int)) / sizeof (pci_regspec_t);
 581                 if (ctlop == DDI_CTLOPS_NREGS)
 582                         *(int *)result = totreg;
 583                 else if (ctlop == DDI_CTLOPS_REGSIZE) {
 584                         rn = *(int *)arg;
 585                         if (rn >= totreg) {
 586                                 ddi_prop_free(drv_regp);
 587                                 return (DDI_FAILURE);
 588                         }
 589                         *(off_t *)result = drv_regp[rn].pci_size_low;
 590                 }
 591                 ddi_prop_free(drv_regp);
 592
 593                 return (DDI_SUCCESS);
 594
 595         case DDI_CTLOPS_POWER: {
 596                 power_req_t     *reqp = (power_req_t *)arg;
 597                 /*
 598                  * We currently understand reporting of PCI_PM_IDLESPEED
 599                  * capability. Everything else is passed up.
 600                  */
 601                 if ((reqp->request_type == PMR_REPORT_PMCAP) &&
 602                     (reqp->req.report_pmcap_req.cap ==  PCI_PM_IDLESPEED)) {
 603
 604                         return (DDI_SUCCESS);
 605                 }
 606                 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
 607         }
 608
 609         case DDI_CTLOPS_PEEK:
 610         case DDI_CTLOPS_POKE:
 611                 pcip = ddi_get_soft_state(pci_statep, ddi_get_instance(dip));
 612                 return (pci_peekpoke_check(dip, rdip, ctlop, arg, result,
 613                     pci_common_peekpoke, &pcip->pci_err_mutex,
 614                     &pcip->pci_peek_poke_mutex, pci_peekpoke_cb));
 615
 616         /* for now only X86 systems support PME wakeup from suspended state */
 617         case DDI_CTLOPS_ATTACH:
 618                 asp = (struct attachspec *)arg;
 619                 if (asp->cmd == DDI_RESUME && asp->when == DDI_PRE)
 620                         if (pci_pre_resume(rdip) != DDI_SUCCESS)
 621                                 return (DDI_FAILURE);
 622                 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
 623
 624         case DDI_CTLOPS_DETACH:
 625                 asp = (struct attachspec *)arg;
 626                 if (asp->cmd == DDI_SUSPEND && asp->when == DDI_POST)
 627                         if (pci_post_suspend(rdip) != DDI_SUCCESS)
 628                                 return (DDI_FAILURE);
 629                 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
 630
 631         default:
 632                 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
 633         }
 634
 635         /* NOTREACHED */
 636
 637 }
 638
 639 /*
 640  * pci_intr_ops
 641  */
 642 static int
 643 pci_intr_ops(dev_info_t *pdip, dev_info_t *rdip, ddi_intr_op_t intr_op,
 644     ddi_intr_handle_impl_t *hdlp, void *result)
 645 {
 646         return (pci_common_intr_ops(pdip, rdip, intr_op, hdlp, result));
 647 }
 648
 649
 650 static int
 651 pci_initchild(dev_info_t *child)
 652 {
 653         char name[80];
 654         ddi_acc_handle_t config_handle;
 655         ushort_t command_preserve, command;
 656
 657         if (pci_common_name_child(child, name, 80) != DDI_SUCCESS) {
 658                 return (DDI_FAILURE);
 659         }
 660         ddi_set_name_addr(child, name);
 661
 662         /*
 663          * Pseudo nodes indicate a prototype node with per-instance
 664          * properties to be merged into the real h/w device node.
 665          * The interpretation of the unit-address is DD[,F]
 666          * where DD is the device id and F is the function.
 667          */
 668         if (ndi_dev_is_persistent_node(child) == 0) {
 669                 extern int pci_allow_pseudo_children;
 670
 671                 ddi_set_parent_data(child, NULL);
 672
 673                 /*
 674                  * Try to merge the properties from this prototype
 675                  * node into real h/w nodes.
 676                  */
 677                 if (ndi_merge_node(child, pci_common_name_child) ==
 678                     DDI_SUCCESS) {
 679                         /*
 680                          * Merged ok - return failure to remove the node.
 681                          */
 682                         ddi_set_name_addr(child, NULL);
 683                         return (DDI_FAILURE);
 684                 }
 685
 686                 /* workaround for ddivs to run under PCI */
 687                 if (pci_allow_pseudo_children) {
 688                         /*
 689                          * If the "interrupts" property doesn't exist,
 690                          * this must be the ddivs no-intr case, and it returns
 691                          * DDI_SUCCESS instead of DDI_FAILURE.
 692                          */
 693                         if (ddi_prop_get_int(DDI_DEV_T_ANY, child,
 694                             DDI_PROP_DONTPASS, "interrupts", -1) == -1)
 695                                 return (DDI_SUCCESS);
 696                         /*
 697                          * Create the ddi_parent_private_data for a pseudo
 698                          * child.
 699                          */
 700                         pci_common_set_parent_private_data(child);
 701                         return (DDI_SUCCESS);
 702                 }
 703
 704                 /*
 705                  * The child was not merged into a h/w node,
 706                  * but there's not much we can do with it other
 707                  * than return failure to cause the node to be removed.
 708                  */
 709                 cmn_err(CE_WARN, "!%s@%s: %s.conf properties not merged",
 710                     ddi_get_name(child), ddi_get_name_addr(child),
 711                     ddi_get_name(child));
 712                 ddi_set_name_addr(child, NULL);
 713                 return (DDI_NOT_WELL_FORMED);
 714         }
 715
 716         if (ddi_prop_get_int(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
 717             "interrupts", -1) != -1)
 718                 pci_common_set_parent_private_data(child);
 719         else
 720                 ddi_set_parent_data(child, NULL);
 721
 722         /*
 723          * initialize command register
 724          */
 725         if (pci_config_setup(child, &config_handle) != DDI_SUCCESS)
 726                 return (DDI_FAILURE);
 727
 728         /*
 729          * Support for the "command-preserve" property.
 730          */
 731         command_preserve = ddi_prop_get_int(DDI_DEV_T_ANY, child,
 732             DDI_PROP_DONTPASS, "command-preserve", 0);
 733         command = pci_config_get16(config_handle, PCI_CONF_COMM);
 734         command &= (command_preserve | PCI_COMM_BACK2BACK_ENAB);
 735         command |= (pci_command_default & ~command_preserve);
 736         pci_config_put16(config_handle, PCI_CONF_COMM, command);
 737
 738         pci_config_teardown(&config_handle);
 739         return (DDI_SUCCESS);
 740 }
 741
 742 static int
 743 pci_removechild(dev_info_t *dip)
 744 {
 745         struct ddi_parent_private_data *pdptr;
 746
 747         if ((pdptr = ddi_get_parent_data(dip)) != NULL) {
 748                 kmem_free(pdptr, (sizeof (*pdptr) + sizeof (struct intrspec)));
 749                 ddi_set_parent_data(dip, NULL);
 750         }
 751         ddi_set_name_addr(dip, NULL);
 752
 753         /*
 754          * Strip the node to properly convert it back to prototype form
 755          */
 756         ddi_remove_minor_node(dip, NULL);
 757
 758         impl_rem_dev_props(dip);
 759
 760         return (DDI_SUCCESS);
 761 }
 762
 763
 764 /*
 765  * When retrofitting this module for pci_tools, functions such as open, close,
 766  * and ioctl are now pulled into this module.  Before this, the functions in
 767  * the pcihp module were referenced directly.  Now they are called or
 768  * referenced through the pcihp cb_ops structure from functions in this module.
 769  */
 770
 771 static int
 772 pci_open(dev_t *devp, int flags, int otyp, cred_t *credp)
 773 {
 774         return ((pcihp_get_cb_ops())->cb_open(devp, flags, otyp, credp));
 775 }
 776
 777 static int
 778 pci_close(dev_t dev, int flags, int otyp, cred_t *credp)
 779 {
 780         return ((pcihp_get_cb_ops())->cb_close(dev, flags, otyp, credp));
 781 }
 782
 783 static int
 784 pci_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
 785 {
 786         minor_t         minor = getminor(dev);
 787         int             instance = PCI_MINOR_NUM_TO_INSTANCE(minor);
 788         pci_state_t     *pci_p = ddi_get_soft_state(pci_statep, instance);
 789         int             ret = ENOTTY;
 790
 791         if (pci_p == NULL)
 792                 return (ENXIO);
 793
 794         switch (PCI_MINOR_NUM_TO_PCI_DEVNUM(minor)) {
 795         case PCI_TOOL_REG_MINOR_NUM:
 796         case PCI_TOOL_INTR_MINOR_NUM:
 797                 /* To handle pcitool related ioctls */
 798                 ret =  pci_common_ioctl(pci_p->pci_dip, dev, cmd, arg, mode,
 799                     credp, rvalp);
 800                 break;
 801         default:
 802                 /* To handle devctl and hotplug related ioctls */
 803                 ret = (pcihp_get_cb_ops())->cb_ioctl(dev, cmd, arg, mode,
 804                     credp, rvalp);
 805                 break;
 806         }
 807
 808         return (ret);
 809 }
 810
 811
 812 static int
 813 pci_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
 814         int flags, char *name, caddr_t valuep, int *lengthp)
 815 {
 816         return ((pcihp_get_cb_ops())->cb_prop_op(dev, dip, prop_op, flags,
 817             name, valuep, lengthp));
 818 }
 819
 820 static int
 821 pci_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
 822 {
 823         return (pcihp_info(dip, cmd, arg, result));
 824 }
 825
 826 void pci_peekpoke_cb(dev_info_t *dip, ddi_fm_error_t *derr) {
 827         (void) pci_ereport_post(dip, derr, NULL);
 828 }
 829
 830 /*ARGSUSED*/
 831 static int
 832 pci_fm_init(dev_info_t *dip, dev_info_t *tdip, int cap,
 833     ddi_iblock_cookie_t *ibc)
 834 {
 835         pci_state_t  *pcip = ddi_get_soft_state(pci_statep,
 836             ddi_get_instance(dip));
 837
 838         ASSERT(ibc != NULL);
 839         *ibc = pcip->pci_fm_ibc;
 840
 841         return (pcip->pci_fmcap);
 842 }
 843
 844 /*ARGSUSED*/
 845 static int
 846 pci_fm_callback(dev_info_t *dip, ddi_fm_error_t *derr, const void *no_used)
 847 {
 848         pci_state_t  *pcip = ddi_get_soft_state(pci_statep,
 849             ddi_get_instance(dip));
 850
 851         mutex_enter(&pcip->pci_err_mutex);
 852         pci_ereport_post(dip, derr, NULL);
 853         mutex_exit(&pcip->pci_err_mutex);
 854         return (derr->fme_status);
 855 }