Merge commit 'v3.6-rc5' into next
Bjorn Helgaas [Thu, 13 Sep 2012 14:41:01 +0000 (08:41 -0600)]
* commit 'v3.6-rc5': (1098 commits)
  Linux 3.6-rc5
  HID: tpkbd: work even if the new Lenovo Keyboard driver is not configured
  Remove user-triggerable BUG from mpol_to_str
  xen/pciback: Fix proper FLR steps.
  uml: fix compile error in deliver_alarm()
  dj: memory scribble in logi_dj
  Fix order of arguments to compat_put_time[spec|val]
  xen: Use correct masking in xen_swiotlb_alloc_coherent.
  xen: fix logical error in tlb flushing
  xen/p2m: Fix one-off error in checking the P2M tree directory.
  powerpc: Don't use __put_user() in patch_instruction
  powerpc: Make sure IPI handlers see data written by IPI senders
  powerpc: Restore correct DSCR in context switch
  powerpc: Fix DSCR inheritance in copy_thread()
  powerpc: Keep thread.dscr and thread.dscr_inherit in sync
  powerpc: Update DSCR on all CPUs when writing sysfs dscr_default
  powerpc/powernv: Always go into nap mode when CPU is offline
  powerpc: Give hypervisor decrementer interrupts their own handler
  powerpc/vphn: Fix arch_update_cpu_topology() return value
  ARM: gemini: fix the gemini build
  ...

Conflicts:
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
drivers/rapidio/devices/tsi721.c

15 files changed:
1  2 
Documentation/feature-removal-schedule.txt
drivers/gpu/drm/radeon/evergreen.c
drivers/iommu/intel-iommu.c
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
drivers/net/ethernet/emulex/benet/be_main.c
drivers/net/ethernet/intel/e1000e/netdev.c
drivers/net/ethernet/intel/igb/igb_main.c
drivers/net/ethernet/mellanox/mlx4/main.c
drivers/net/wireless/ath/ath9k/pci.c
drivers/net/wireless/iwlwifi/pcie/trans.c
drivers/pci/pci.c
drivers/pci/pcie/portdrv_pci.c
drivers/pci/probe.c
drivers/rapidio/devices/tsi721.c
drivers/xen/xen-pciback/pci_stub.c

@@@ -253,6 -253,38 +253,6 @@@ Who:      Dave Jones <davej@redhat.com>, Mat
  
  -----------------------------
  
 -What: fakephp and associated sysfs files in /sys/bus/pci/slots/
 -When: 2011
 -Why:  In 2.6.27, the semantics of /sys/bus/pci/slots was redefined to
 -      represent a machine's physical PCI slots. The change in semantics
 -      had userspace implications, as the hotplug core no longer allowed
 -      drivers to create multiple sysfs files per physical slot (required
 -      for multi-function devices, e.g.). fakephp was seen as a developer's
 -      tool only, and its interface changed. Too late, we learned that
 -      there were some users of the fakephp interface.
 -
 -      In 2.6.30, the original fakephp interface was restored. At the same
 -      time, the PCI core gained the ability that fakephp provided, namely
 -      function-level hot-remove and hot-add.
 -
 -      Since the PCI core now provides the same functionality, exposed in:
 -
 -              /sys/bus/pci/rescan
 -              /sys/bus/pci/devices/.../remove
 -              /sys/bus/pci/devices/.../rescan
 -
 -      there is no functional reason to maintain fakephp as well.
 -
 -      We will keep the existing module so that 'modprobe fakephp' will
 -      present the old /sys/bus/pci/slots/... interface for compatibility,
 -      but users are urged to migrate their applications to the API above.
 -
 -      After a reasonable transition period, we will remove the legacy
 -      fakephp interface.
 -Who:  Alex Chiang <achiang@hp.com>
 -
 ----------------------------
 -
  What: CONFIG_RFKILL_INPUT
  When: 2.6.33
  Why:  Should be implemented in userspace, policy daemon.
@@@ -547,7 -579,7 +547,7 @@@ Why:       KVM tracepoints provide mostly equ
  ----------------------------
  
  What: at91-mci driver ("CONFIG_MMC_AT91")
- When: 3.7
+ When: 3.8
  Why:  There are two mci drivers: at91-mci and atmel-mci. The PDC support
        was added to atmel-mci as a first step to support more chips.
        Then at91-mci was kept only for old IP versions (on at91rm9200 and
@@@ -77,9 -77,13 +77,9 @@@ void evergreen_tiling_fields(unsigned t
  void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
  {
        u16 ctl, v;
 -      int cap, err;
 +      int err;
  
 -      cap = pci_pcie_cap(rdev->pdev);
 -      if (!cap)
 -              return;
 -
 -      err = pci_read_config_word(rdev->pdev, cap + PCI_EXP_DEVCTL, &ctl);
 +      err = pcie_capability_read_word(rdev->pdev, PCI_EXP_DEVCTL, &ctl);
        if (err)
                return;
  
@@@ -91,7 -95,7 +91,7 @@@
        if ((v == 0) || (v == 6) || (v == 7)) {
                ctl &= ~PCI_EXP_DEVCTL_READRQ;
                ctl |= (2 << 12);
 -              pci_write_config_word(rdev->pdev, cap + PCI_EXP_DEVCTL, ctl);
 +              pcie_capability_write_word(rdev->pdev, PCI_EXP_DEVCTL, ctl);
        }
  }
  
@@@ -1225,24 -1229,8 +1225,8 @@@ void evergreen_agp_enable(struct radeon
  
  void evergreen_mc_stop(struct radeon_device *rdev, struct evergreen_mc_save *save)
  {
-       save->vga_control[0] = RREG32(D1VGA_CONTROL);
-       save->vga_control[1] = RREG32(D2VGA_CONTROL);
        save->vga_render_control = RREG32(VGA_RENDER_CONTROL);
        save->vga_hdp_control = RREG32(VGA_HDP_CONTROL);
-       save->crtc_control[0] = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET);
-       save->crtc_control[1] = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET);
-       if (rdev->num_crtc >= 4) {
-               save->vga_control[2] = RREG32(EVERGREEN_D3VGA_CONTROL);
-               save->vga_control[3] = RREG32(EVERGREEN_D4VGA_CONTROL);
-               save->crtc_control[2] = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC2_REGISTER_OFFSET);
-               save->crtc_control[3] = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC3_REGISTER_OFFSET);
-       }
-       if (rdev->num_crtc >= 6) {
-               save->vga_control[4] = RREG32(EVERGREEN_D5VGA_CONTROL);
-               save->vga_control[5] = RREG32(EVERGREEN_D6VGA_CONTROL);
-               save->crtc_control[4] = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC4_REGISTER_OFFSET);
-               save->crtc_control[5] = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC5_REGISTER_OFFSET);
-       }
  
        /* Stop all video */
        WREG32(VGA_RENDER_CONTROL, 0);
@@@ -1353,47 -1341,6 +1337,6 @@@ void evergreen_mc_resume(struct radeon_
        /* Unlock host access */
        WREG32(VGA_HDP_CONTROL, save->vga_hdp_control);
        mdelay(1);
-       /* Restore video state */
-       WREG32(D1VGA_CONTROL, save->vga_control[0]);
-       WREG32(D2VGA_CONTROL, save->vga_control[1]);
-       if (rdev->num_crtc >= 4) {
-               WREG32(EVERGREEN_D3VGA_CONTROL, save->vga_control[2]);
-               WREG32(EVERGREEN_D4VGA_CONTROL, save->vga_control[3]);
-       }
-       if (rdev->num_crtc >= 6) {
-               WREG32(EVERGREEN_D5VGA_CONTROL, save->vga_control[4]);
-               WREG32(EVERGREEN_D6VGA_CONTROL, save->vga_control[5]);
-       }
-       WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC0_REGISTER_OFFSET, 1);
-       WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC1_REGISTER_OFFSET, 1);
-       if (rdev->num_crtc >= 4) {
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC2_REGISTER_OFFSET, 1);
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC3_REGISTER_OFFSET, 1);
-       }
-       if (rdev->num_crtc >= 6) {
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC4_REGISTER_OFFSET, 1);
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC5_REGISTER_OFFSET, 1);
-       }
-       WREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET, save->crtc_control[0]);
-       WREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET, save->crtc_control[1]);
-       if (rdev->num_crtc >= 4) {
-               WREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC2_REGISTER_OFFSET, save->crtc_control[2]);
-               WREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC3_REGISTER_OFFSET, save->crtc_control[3]);
-       }
-       if (rdev->num_crtc >= 6) {
-               WREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC4_REGISTER_OFFSET, save->crtc_control[4]);
-               WREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC5_REGISTER_OFFSET, save->crtc_control[5]);
-       }
-       WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0);
-       WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0);
-       if (rdev->num_crtc >= 4) {
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC2_REGISTER_OFFSET, 0);
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC3_REGISTER_OFFSET, 0);
-       }
-       if (rdev->num_crtc >= 6) {
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC4_REGISTER_OFFSET, 0);
-               WREG32(EVERGREEN_CRTC_UPDATE_LOCK + EVERGREEN_CRTC5_REGISTER_OFFSET, 0);
-       }
        WREG32(VGA_RENDER_CONTROL, save->vga_render_control);
  }
  
@@@ -1982,10 -1929,18 +1925,18 @@@ static void evergreen_gpu_init(struct r
        if (rdev->flags & RADEON_IS_IGP)
                rdev->config.evergreen.tile_config |= 1 << 4;
        else {
-               if ((mc_arb_ramcfg & NOOFBANK_MASK) >> NOOFBANK_SHIFT)
-                       rdev->config.evergreen.tile_config |= 1 << 4;
-               else
+               switch ((mc_arb_ramcfg & NOOFBANK_MASK) >> NOOFBANK_SHIFT) {
+               case 0: /* four banks */
                        rdev->config.evergreen.tile_config |= 0 << 4;
+                       break;
+               case 1: /* eight banks */
+                       rdev->config.evergreen.tile_config |= 1 << 4;
+                       break;
+               case 2: /* sixteen banks */
+               default:
+                       rdev->config.evergreen.tile_config |= 2 << 4;
+                       break;
+               }
        }
        rdev->config.evergreen.tile_config |= 0 << 8;
        rdev->config.evergreen.tile_config |=
@@@ -2008,6 -2008,7 +2008,7 @@@ static struct dmar_domain *get_domain_f
        if (!drhd) {
                printk(KERN_ERR "IOMMU: can't find DMAR for device %s\n",
                        pci_name(pdev));
+               free_domain_mem(domain);
                return NULL;
        }
        iommu = drhd->iommu;
@@@ -2350,7 -2351,7 +2351,7 @@@ static int iommu_should_identity_map(st
                        return 0;
                if (pdev->class >> 8 == PCI_CLASS_BRIDGE_PCI)
                        return 0;
 -      } else if (pdev->pcie_type == PCI_EXP_TYPE_PCI_BRIDGE)
 +      } else if (pci_pcie_type(pdev) == PCI_EXP_TYPE_PCI_BRIDGE)
                return 0;
  
        /* 
@@@ -3545,10 -3546,10 +3546,10 @@@ found
                struct pci_dev *bridge = bus->self;
  
                if (!bridge || !pci_is_pcie(bridge) ||
 -                  bridge->pcie_type == PCI_EXP_TYPE_PCI_BRIDGE)
 +                  pci_pcie_type(bridge) == PCI_EXP_TYPE_PCI_BRIDGE)
                        return 0;
  
 -              if (bridge->pcie_type == PCI_EXP_TYPE_ROOT_PORT) {
 +              if (pci_pcie_type(bridge) == PCI_EXP_TYPE_ROOT_PORT) {
                        for (i = 0; i < atsru->devices_cnt; i++)
                                if (atsru->devices[i] == bridge)
                                        return 1;
@@@ -4124,8 -4125,13 +4125,13 @@@ static int intel_iommu_add_device(struc
        } else
                dma_pdev = pci_dev_get(pdev);
  
+       /* Account for quirked devices */
        swap_pci_ref(&dma_pdev, pci_get_dma_source(dma_pdev));
  
+       /*
+        * If it's a multifunction device that does not support our
+        * required ACS flags, add to the same group as function 0.
+        */
        if (dma_pdev->multifunction &&
            !pci_acs_enabled(dma_pdev, REQ_ACS_FLAGS))
                swap_pci_ref(&dma_pdev,
                                          PCI_DEVFN(PCI_SLOT(dma_pdev->devfn),
                                          0)));
  
+       /*
+        * Devices on the root bus go through the iommu.  If that's not us,
+        * find the next upstream device and test ACS up to the root bus.
+        * Finding the next device may require skipping virtual buses.
+        */
        while (!pci_is_root_bus(dma_pdev->bus)) {
-               if (pci_acs_path_enabled(dma_pdev->bus->self,
-                                        NULL, REQ_ACS_FLAGS))
+               struct pci_bus *bus = dma_pdev->bus;
+               while (!bus->self) {
+                       if (!pci_is_root_bus(bus))
+                               bus = bus->parent;
+                       else
+                               goto root_bus;
+               }
+               if (pci_acs_path_enabled(bus->self, NULL, REQ_ACS_FLAGS))
                        break;
  
-               swap_pci_ref(&dma_pdev, pci_dev_get(dma_pdev->bus->self));
+               swap_pci_ref(&dma_pdev, pci_dev_get(bus->self));
        }
  
+ root_bus:
        group = iommu_group_get(&dma_pdev->dev);
        pci_dev_put(dma_pdev);
        if (!group) {
@@@ -1162,9 -1162,14 +1162,9 @@@ static int bnx2x_send_final_clnup(struc
  
  static u8 bnx2x_is_pcie_pending(struct pci_dev *dev)
  {
 -      int pos;
        u16 status;
  
 -      pos = pci_pcie_cap(dev);
 -      if (!pos)
 -              return false;
 -
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &status);
 +      pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
        return status & PCI_EXP_DEVSTA_TRPND;
  }
  
@@@ -4036,20 -4041,6 +4036,6 @@@ static bool bnx2x_get_load_status(struc
        return val != 0;
  }
  
- /*
-  * Reset the load status for the current engine.
-  */
- static void bnx2x_clear_load_status(struct bnx2x *bp)
- {
-       u32 val;
-       u32 mask = (BP_PATH(bp) ? BNX2X_PATH1_LOAD_CNT_MASK :
-                   BNX2X_PATH0_LOAD_CNT_MASK);
-       bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_RECOVERY_REG);
-       val = REG_RD(bp, BNX2X_RECOVERY_GLOB_REG);
-       REG_WR(bp, BNX2X_RECOVERY_GLOB_REG, val & (~mask));
-       bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RECOVERY_REG);
- }
  static void _print_next_block(int idx, const char *blk)
  {
        pr_cont("%s%s", idx ? ", " : "", blk);
@@@ -6144,7 -6135,8 +6130,7 @@@ static void bnx2x_init_pxp(struct bnx2
        u16 devctl;
        int r_order, w_order;
  
 -      pci_read_config_word(bp->pdev,
 -                           pci_pcie_cap(bp->pdev) + PCI_EXP_DEVCTL, &devctl);
 +      pcie_capability_read_word(bp->pdev, PCI_EXP_DEVCTL, &devctl);
        DP(NETIF_MSG_HW, "read 0x%x from devctl\n", devctl);
        w_order = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
        if (bp->mrrs == -1)
@@@ -8435,6 -8427,8 +8421,8 @@@ unload_error
  
        /* Disable HW interrupts, NAPI */
        bnx2x_netif_stop(bp, 1);
+       /* Delete all NAPI objects */
+       bnx2x_del_all_napi(bp);
  
        /* Release IRQs */
        bnx2x_free_irq(bp);
@@@ -9378,34 -9372,35 +9366,31 @@@ static int __devinit bnx2x_prev_mark_pa
        return rc;
  }
  
- static bool __devinit bnx2x_can_flr(struct bnx2x *bp)
- {
-       u32 cap;
-       struct pci_dev *dev = bp->pdev;
-       pcie_capability_read_dword(dev, PCI_EXP_DEVCAP, &cap);
-       if (!(cap & PCI_EXP_DEVCAP_FLR))
-               return false;
-       return true;
- }
  static int __devinit bnx2x_do_flr(struct bnx2x *bp)
  {
 -      int i, pos;
 +      int i;
        u16 status;
        struct pci_dev *dev = bp->pdev;
  
-       /* probe the capability first */
-       if (bnx2x_can_flr(bp))
-               return -ENOTTY;
+       if (CHIP_IS_E1x(bp)) {
+               BNX2X_DEV_INFO("FLR not supported in E1/E1H\n");
+               return -EINVAL;
+       }
+       /* only bootcode REQ_BC_VER_4_INITIATE_FLR and onwards support flr */
+       if (bp->common.bc_ver < REQ_BC_VER_4_INITIATE_FLR) {
+               BNX2X_ERR("FLR not supported by BC_VER: 0x%x\n",
+                         bp->common.bc_ver);
+               return -EINVAL;
+       }
  
 -      pos = pci_pcie_cap(dev);
 -      if (!pos)
 -              return -ENOTTY;
 -
        /* Wait for Transaction Pending bit clean */
        for (i = 0; i < 4; i++) {
                if (i)
                        msleep((1 << (i - 1)) * 100);
  
 -              pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &status);
 +              pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
                if (!(status & PCI_EXP_DEVSTA_TRPND))
                        goto clear;
        }
                "transaction is not cleared; proceeding with reset anyway\n");
  
  clear:
-       if (bp->common.bc_ver < REQ_BC_VER_4_INITIATE_FLR) {
-               BNX2X_ERR("FLR not supported by BC_VER: 0x%x\n",
-                         bp->common.bc_ver);
-               return -EINVAL;
-       }
  
+       BNX2X_DEV_INFO("Initiating FLR\n");
        bnx2x_fw_command(bp, DRV_MSG_CODE_INITIATE_FLR, 0);
  
        return 0;
@@@ -9439,8 -9430,21 +9420,21 @@@ static int __devinit bnx2x_prev_unload_
         * the one required, then FLR will be sufficient to clean any residue
         * left by previous driver
         */
-       if (bnx2x_test_firmware_version(bp, false) && bnx2x_can_flr(bp))
-               return bnx2x_do_flr(bp);
+       rc = bnx2x_test_firmware_version(bp, false);
+       if (!rc) {
+               /* fw version is good */
+               BNX2X_DEV_INFO("FW version matches our own. Attempting FLR\n");
+               rc = bnx2x_do_flr(bp);
+       }
+       if (!rc) {
+               /* FLR was performed */
+               BNX2X_DEV_INFO("FLR successful\n");
+               return 0;
+       }
+       BNX2X_DEV_INFO("Could not FLR\n");
  
        /* Close the MCP request, return failure*/
        rc = bnx2x_prev_mcp_done(bp);
@@@ -11227,10 -11231,12 +11221,12 @@@ static int bnx2x_ioctl(struct net_devic
  static void poll_bnx2x(struct net_device *dev)
  {
        struct bnx2x *bp = netdev_priv(dev);
+       int i;
  
-       disable_irq(bp->pdev->irq);
-       bnx2x_interrupt(bp->pdev->irq, dev);
-       enable_irq(bp->pdev->irq);
+       for_each_eth_queue(bp, i) {
+               struct bnx2x_fastpath *fp = &bp->fp[i];
+               napi_schedule(&bnx2x_fp(bp, fp->index, napi));
+       }
  }
  #endif
  
@@@ -11412,9 -11418,6 +11408,6 @@@ static int __devinit bnx2x_init_dev(str
        if (!chip_is_e1x)
                REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
  
-       /* Reset the load counter */
-       bnx2x_clear_load_status(bp);
        dev->watchdog_timeo = TX_TIMEOUT;
  
        dev->netdev_ops = &bnx2x_netdev_ops;
@@@ -11900,9 -11903,6 +11893,6 @@@ static int __devinit bnx2x_init_one(str
         */
        bnx2x_set_int_mode(bp);
  
-       /* Add all NAPI objects */
-       bnx2x_add_all_napi(bp);
        rc = register_netdev(dev);
        if (rc) {
                dev_err(&pdev->dev, "Cannot register net device\n");
@@@ -11977,9 -11977,6 +11967,6 @@@ static void __devexit bnx2x_remove_one(
  
        unregister_netdev(dev);
  
-       /* Delete all NAPI objects */
-       bnx2x_del_all_napi(bp);
        /* Power on: we can't let PCI layer write to us while we are in D3 */
        bnx2x_set_power_state(bp, PCI_D0);
  
@@@ -12026,6 -12023,8 +12013,8 @@@ static int bnx2x_eeh_nic_unload(struct 
        bnx2x_tx_disable(bp);
  
        bnx2x_netif_stop(bp, 0);
+       /* Delete all NAPI objects */
+       bnx2x_del_all_napi(bp);
  
        del_timer_sync(&bp->timer);
  
@@@ -12156,7 -12155,7 +12145,7 @@@ static void bnx2x_io_resume(struct pci_
        rtnl_unlock();
  }
  
 -static struct pci_error_handlers bnx2x_err_handler = {
 +static const struct pci_error_handlers bnx2x_err_handler = {
        .error_detected = bnx2x_io_error_detected,
        .slot_reset     = bnx2x_io_slot_reset,
        .resume         = bnx2x_io_resume,
@@@ -1948,7 -1948,7 +1948,7 @@@ static int be_rx_cqs_create(struct be_a
  
        if (adapter->num_rx_qs != MAX_RX_QS)
                dev_info(&adapter->pdev->dev,
-                       "Created only %d receive queues", adapter->num_rx_qs);
+                       "Created only %d receive queues\n", adapter->num_rx_qs);
  
        return 0;
  }
@@@ -3763,7 -3763,9 +3763,9 @@@ static void be_worker(struct work_struc
        /* when interrupts are not yet enabled, just reap any pending
        * mcc completions */
        if (!netif_running(adapter->netdev)) {
+               local_bh_disable();
                be_process_mcc(adapter);
+               local_bh_enable();
                goto reschedule;
        }
  
@@@ -4104,7 -4106,7 +4106,7 @@@ err
        dev_err(&adapter->pdev->dev, "EEH resume failed\n");
  }
  
 -static struct pci_error_handlers be_eeh_handlers = {
 +static const struct pci_error_handlers be_eeh_handlers = {
        .error_detected = be_eeh_err_detected,
        .slot_reset = be_eeh_reset,
        .resume = be_eeh_resume,
@@@ -178,6 -178,24 +178,24 @@@ static void e1000_regdump(struct e1000_
        pr_info("%-15s %08x %08x\n", rname, regs[0], regs[1]);
  }
  
+ static void e1000e_dump_ps_pages(struct e1000_adapter *adapter,
+                                struct e1000_buffer *bi)
+ {
+       int i;
+       struct e1000_ps_page *ps_page;
+       for (i = 0; i < adapter->rx_ps_pages; i++) {
+               ps_page = &bi->ps_pages[i];
+               if (ps_page->page) {
+                       pr_info("packet dump for ps_page %d:\n", i);
+                       print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,
+                                      16, 1, page_address(ps_page->page),
+                                      PAGE_SIZE, true);
+               }
+       }
+ }
  /*
   * e1000e_dump - Print registers, Tx-ring and Rx-ring
   */
@@@ -299,10 -317,10 +317,10 @@@ static void e1000e_dump(struct e1000_ad
                        (unsigned long long)buffer_info->time_stamp,
                        buffer_info->skb, next_desc);
  
-               if (netif_msg_pktdata(adapter) && buffer_info->dma != 0)
+               if (netif_msg_pktdata(adapter) && buffer_info->skb)
                        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS,
-                                      16, 1, phys_to_virt(buffer_info->dma),
-                                      buffer_info->length, true);
+                                      16, 1, buffer_info->skb->data,
+                                      buffer_info->skb->len, true);
        }
  
        /* Print Rx Ring Summary */
@@@ -381,10 -399,8 +399,8 @@@ rx_ring_summary
                                        buffer_info->skb, next_desc);
  
                                if (netif_msg_pktdata(adapter))
-                                       print_hex_dump(KERN_INFO, "",
-                                               DUMP_PREFIX_ADDRESS, 16, 1,
-                                               phys_to_virt(buffer_info->dma),
-                                               adapter->rx_ps_bsize0, true);
+                                       e1000e_dump_ps_pages(adapter,
+                                                            buffer_info);
                        }
                }
                break;
                                        (unsigned long long)buffer_info->dma,
                                        buffer_info->skb, next_desc);
  
-                               if (netif_msg_pktdata(adapter))
+                               if (netif_msg_pktdata(adapter) &&
+                                   buffer_info->skb)
                                        print_hex_dump(KERN_INFO, "",
                                                       DUMP_PREFIX_ADDRESS, 16,
                                                       1,
-                                                      phys_to_virt
-                                                      (buffer_info->dma),
+                                                      buffer_info->skb->data,
                                                       adapter->rx_buffer_len,
                                                       true);
                        }
@@@ -3501,6 -3517,15 +3517,15 @@@ void e1000e_reset(struct e1000_adapter 
        }
  
        /*
+        * Alignment of Tx data is on an arbitrary byte boundary with the
+        * maximum size per Tx descriptor limited only to the transmit
+        * allocation of the packet buffer minus 96 bytes with an upper
+        * limit of 24KB due to receive synchronization limitations.
+        */
+       adapter->tx_fifo_limit = min_t(u32, ((er32(PBA) >> 16) << 10) - 96,
+                                      24 << 10);
+       /*
         * Disable Adaptive Interrupt Moderation if 2 full packets cannot
         * fit in receive buffer.
         */
@@@ -4769,12 -4794,9 +4794,9 @@@ static bool e1000_tx_csum(struct e1000_
        return 1;
  }
  
- #define E1000_MAX_PER_TXD     8192
- #define E1000_MAX_TXD_PWR     12
  static int e1000_tx_map(struct e1000_ring *tx_ring, struct sk_buff *skb,
                        unsigned int first, unsigned int max_per_txd,
-                       unsigned int nr_frags, unsigned int mss)
+                       unsigned int nr_frags)
  {
        struct e1000_adapter *adapter = tx_ring->adapter;
        struct pci_dev *pdev = adapter->pdev;
@@@ -5007,20 -5029,19 +5029,19 @@@ static int __e1000_maybe_stop_tx(struc
  
  static int e1000_maybe_stop_tx(struct e1000_ring *tx_ring, int size)
  {
+       BUG_ON(size > tx_ring->count);
        if (e1000_desc_unused(tx_ring) >= size)
                return 0;
        return __e1000_maybe_stop_tx(tx_ring, size);
  }
  
- #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1)
  static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                                    struct net_device *netdev)
  {
        struct e1000_adapter *adapter = netdev_priv(netdev);
        struct e1000_ring *tx_ring = adapter->tx_ring;
        unsigned int first;
-       unsigned int max_per_txd = E1000_MAX_PER_TXD;
-       unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
        unsigned int tx_flags = 0;
        unsigned int len = skb_headlen(skb);
        unsigned int nr_frags;
        }
  
        mss = skb_shinfo(skb)->gso_size;
-       /*
-        * The controller does a simple calculation to
-        * make sure there is enough room in the FIFO before
-        * initiating the DMA for each buffer.  The calc is:
-        * 4 = ceil(buffer len/mss).  To make sure we don't
-        * overrun the FIFO, adjust the max buffer len if mss
-        * drops.
-        */
        if (mss) {
                u8 hdr_len;
-               max_per_txd = min(mss << 2, max_per_txd);
-               max_txd_pwr = fls(max_per_txd) - 1;
  
                /*
                 * TSO Workaround for 82571/2/3 Controllers -- if skb->data
                count++;
        count++;
  
-       count += TXD_USE_COUNT(len, max_txd_pwr);
+       count += DIV_ROUND_UP(len, adapter->tx_fifo_limit);
  
        nr_frags = skb_shinfo(skb)->nr_frags;
        for (f = 0; f < nr_frags; f++)
-               count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]),
-                                      max_txd_pwr);
+               count += DIV_ROUND_UP(skb_frag_size(&skb_shinfo(skb)->frags[f]),
+                                     adapter->tx_fifo_limit);
  
        if (adapter->hw.mac.tx_pkt_filtering)
                e1000_transfer_dhcp_info(adapter, skb);
                tx_flags |= E1000_TX_FLAGS_NO_FCS;
  
        /* if count is 0 then mapping error has occurred */
-       count = e1000_tx_map(tx_ring, skb, first, max_per_txd, nr_frags, mss);
+       count = e1000_tx_map(tx_ring, skb, first, adapter->tx_fifo_limit,
+                            nr_frags);
        if (count) {
                skb_tx_timestamp(skb);
  
                netdev_sent_queue(netdev, skb->len);
                e1000_tx_queue(tx_ring, tx_flags, count);
                /* Make sure there is space in the ring for the next send. */
-               e1000_maybe_stop_tx(tx_ring, MAX_SKB_FRAGS + 2);
+               e1000_maybe_stop_tx(tx_ring,
+                                   (MAX_SKB_FRAGS *
+                                    DIV_ROUND_UP(PAGE_SIZE,
+                                                 adapter->tx_fifo_limit) + 2));
        } else {
                dev_kfree_skb_any(skb);
                tx_ring->buffer_info[first].time_stamp = 0;
@@@ -5570,15 -5584,16 +5584,15 @@@ static void e1000_complete_shutdown(str
         */
        if (adapter->flags & FLAG_IS_QUAD_PORT) {
                struct pci_dev *us_dev = pdev->bus->self;
 -              int pos = pci_pcie_cap(us_dev);
                u16 devctl;
  
 -              pci_read_config_word(us_dev, pos + PCI_EXP_DEVCTL, &devctl);
 -              pci_write_config_word(us_dev, pos + PCI_EXP_DEVCTL,
 -                                    (devctl & ~PCI_EXP_DEVCTL_CERE));
 +              pcie_capability_read_word(us_dev, PCI_EXP_DEVCTL, &devctl);
 +              pcie_capability_write_word(us_dev, PCI_EXP_DEVCTL,
 +                                         (devctl & ~PCI_EXP_DEVCTL_CERE));
  
                e1000_power_off(pdev, sleep, wake);
  
 -              pci_write_config_word(us_dev, pos + PCI_EXP_DEVCTL, devctl);
 +              pcie_capability_write_word(us_dev, PCI_EXP_DEVCTL, devctl);
        } else {
                e1000_power_off(pdev, sleep, wake);
        }
@@@ -5592,15 -5607,25 +5606,15 @@@ static void __e1000e_disable_aspm(struc
  #else
  static void __e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
  {
 -      int pos;
 -      u16 reg16;
 -
        /*
         * Both device and parent should have the same ASPM setting.
         * Disable ASPM in downstream component first and then upstream.
         */
 -      pos = pci_pcie_cap(pdev);
 -      pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, &reg16);
 -      reg16 &= ~state;
 -      pci_write_config_word(pdev, pos + PCI_EXP_LNKCTL, reg16);
 -
 -      if (!pdev->bus->self)
 -              return;
 +      pcie_capability_clear_word(pdev, PCI_EXP_LNKCTL, state);
  
 -      pos = pci_pcie_cap(pdev->bus->self);
 -      pci_read_config_word(pdev->bus->self, pos + PCI_EXP_LNKCTL, &reg16);
 -      reg16 &= ~state;
 -      pci_write_config_word(pdev->bus->self, pos + PCI_EXP_LNKCTL, reg16);
 +      if (pdev->bus->self)
 +              pcie_capability_clear_word(pdev->bus->self, PCI_EXP_LNKCTL,
 +                                         state);
  }
  #endif
  static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
@@@ -6300,8 -6325,8 +6314,8 @@@ static int __devinit e1000_probe(struc
        adapter->hw.phy.autoneg_advertised = 0x2f;
  
        /* ring size defaults */
-       adapter->rx_ring->count = 256;
-       adapter->tx_ring->count = 256;
+       adapter->rx_ring->count = E1000_DEFAULT_RXD;
+       adapter->tx_ring->count = E1000_DEFAULT_TXD;
  
        /*
         * Initial Wake on LAN setting - If APM wake is enabled in
@@@ -6461,7 -6486,7 +6475,7 @@@ static void __devexit e1000_remove(stru
  }
  
  /* PCI Error Recovery (ERS) */
 -static struct pci_error_handlers e1000_err_handler = {
 +static const struct pci_error_handlers e1000_err_handler = {
        .error_detected = e1000_io_error_detected,
        .slot_reset = e1000_io_slot_reset,
        .resume = e1000_io_resume,
@@@ -217,7 -217,7 +217,7 @@@ static pci_ers_result_t igb_io_error_de
  static pci_ers_result_t igb_io_slot_reset(struct pci_dev *);
  static void igb_io_resume(struct pci_dev *);
  
 -static struct pci_error_handlers igb_err_handler = {
 +static const struct pci_error_handlers igb_err_handler = {
        .error_detected = igb_io_error_detected,
        .slot_reset = igb_io_slot_reset,
        .resume = igb_io_resume,
@@@ -462,10 -462,10 +462,10 @@@ static void igb_dump(struct igb_adapte
                                (u64)buffer_info->time_stamp,
                                buffer_info->skb, next_desc);
  
-                       if (netif_msg_pktdata(adapter) && buffer_info->dma != 0)
+                       if (netif_msg_pktdata(adapter) && buffer_info->skb)
                                print_hex_dump(KERN_INFO, "",
                                        DUMP_PREFIX_ADDRESS,
-                                       16, 1, phys_to_virt(buffer_info->dma),
+                                       16, 1, buffer_info->skb->data,
                                        buffer_info->length, true);
                }
        }
@@@ -547,18 -547,17 +547,17 @@@ rx_ring_summary
                                        (u64)buffer_info->dma,
                                        buffer_info->skb, next_desc);
  
-                               if (netif_msg_pktdata(adapter)) {
+                               if (netif_msg_pktdata(adapter) &&
+                                   buffer_info->dma && buffer_info->skb) {
                                        print_hex_dump(KERN_INFO, "",
-                                               DUMP_PREFIX_ADDRESS,
-                                               16, 1,
-                                               phys_to_virt(buffer_info->dma),
-                                               IGB_RX_HDR_LEN, true);
+                                                 DUMP_PREFIX_ADDRESS,
+                                                 16, 1, buffer_info->skb->data,
+                                                 IGB_RX_HDR_LEN, true);
                                        print_hex_dump(KERN_INFO, "",
                                          DUMP_PREFIX_ADDRESS,
                                          16, 1,
-                                         phys_to_virt(
-                                           buffer_info->page_dma +
-                                           buffer_info->page_offset),
+                                         page_address(buffer_info->page) +
+                                                     buffer_info->page_offset,
                                          PAGE_SIZE/2, true);
                                }
                        }
@@@ -6539,20 -6538,28 +6538,20 @@@ static int igb_ioctl(struct net_device 
  s32 igb_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
  {
        struct igb_adapter *adapter = hw->back;
 -      u16 cap_offset;
  
 -      cap_offset = adapter->pdev->pcie_cap;
 -      if (!cap_offset)
 +      if (pcie_capability_read_word(adapter->pdev, reg, value))
                return -E1000_ERR_CONFIG;
  
 -      pci_read_config_word(adapter->pdev, cap_offset + reg, value);
 -
        return 0;
  }
  
  s32 igb_write_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
  {
        struct igb_adapter *adapter = hw->back;
 -      u16 cap_offset;
  
 -      cap_offset = adapter->pdev->pcie_cap;
 -      if (!cap_offset)
 +      if (pcie_capability_write_word(adapter->pdev, reg, *value))
                return -E1000_ERR_CONFIG;
  
 -      pci_write_config_word(adapter->pdev, cap_offset + reg, *value);
 -
        return 0;
  }
  
@@@ -157,9 -157,6 +157,6 @@@ int mlx4_check_port_params(struct mlx4_
                                         "on this HCA, aborting.\n");
                                return -EINVAL;
                        }
-                       if (port_type[i] == MLX4_PORT_TYPE_ETH &&
-                           port_type[i + 1] == MLX4_PORT_TYPE_IB)
-                               return -EINVAL;
                }
        }
  
@@@ -2301,7 -2298,7 +2298,7 @@@ static pci_ers_result_t mlx4_pci_slot_r
        return ret ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
  }
  
 -static struct pci_error_handlers mlx4_err_handler = {
 +static const struct pci_error_handlers mlx4_err_handler = {
        .error_detected = mlx4_pci_err_detected,
        .slot_reset     = mlx4_pci_slot_reset,
  };
@@@ -37,6 -37,7 +37,7 @@@ static DEFINE_PCI_DEVICE_TABLE(ath_pci_
        { PCI_VDEVICE(ATHEROS, 0x0032) }, /* PCI-E  AR9485 */
        { PCI_VDEVICE(ATHEROS, 0x0033) }, /* PCI-E  AR9580 */
        { PCI_VDEVICE(ATHEROS, 0x0034) }, /* PCI-E  AR9462 */
+       { PCI_VDEVICE(ATHEROS, 0x0037) }, /* PCI-E  AR1111/AR9485 */
        { 0 }
  };
  
@@@ -112,32 -113,41 +113,32 @@@ static void ath_pci_aspm_init(struct at
        struct ath_hw *ah = sc->sc_ah;
        struct pci_dev *pdev = to_pci_dev(sc->dev);
        struct pci_dev *parent;
 -      int pos;
 -      u8 aspm;
 +      u16 aspm;
  
        if (!ah->is_pciexpress)
                return;
  
 -      pos = pci_pcie_cap(pdev);
 -      if (!pos)
 -              return;
 -
        parent = pdev->bus->self;
        if (!parent)
                return;
  
        if (ath9k_hw_get_btcoex_scheme(ah) != ATH_BTCOEX_CFG_NONE) {
                /* Bluetooth coexistance requires disabling ASPM. */
 -              pci_read_config_byte(pdev, pos + PCI_EXP_LNKCTL, &aspm);
 -              aspm &= ~(PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
 -              pci_write_config_byte(pdev, pos + PCI_EXP_LNKCTL, aspm);
 +              pcie_capability_clear_word(pdev, PCI_EXP_LNKCTL,
 +                      PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
  
                /*
                 * Both upstream and downstream PCIe components should
                 * have the same ASPM settings.
                 */
 -              pos = pci_pcie_cap(parent);
 -              pci_read_config_byte(parent, pos + PCI_EXP_LNKCTL, &aspm);
 -              aspm &= ~(PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
 -              pci_write_config_byte(parent, pos + PCI_EXP_LNKCTL, aspm);
 +              pcie_capability_clear_word(parent, PCI_EXP_LNKCTL,
 +                      PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
  
                ath_info(common, "Disabling ASPM since BTCOEX is enabled\n");
                return;
        }
  
 -      pos = pci_pcie_cap(parent);
 -      pci_read_config_byte(parent, pos +  PCI_EXP_LNKCTL, &aspm);
 +      pcie_capability_read_word(parent, PCI_EXP_LNKCTL, &aspm);
        if (aspm & (PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1)) {
                ah->aspm_enabled = true;
                /* Initialize PCIe PM and SERDES registers. */
@@@ -311,6 -321,7 +312,7 @@@ static int ath_pci_suspend(struct devic
         * Otherwise the chip never moved to full sleep,
         * when no interface is up.
         */
+       ath9k_stop_btcoex(sc);
        ath9k_hw_disable(sc->sc_ah);
        ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_FULL_SLEEP);
  
@@@ -675,10 -675,13 +675,10 @@@ static void iwl_set_pwr_vmain(struct iw
  static u16 iwl_pciexp_link_ctrl(struct iwl_trans *trans)
  {
        struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
 -      int pos;
        u16 pci_lnk_ctl;
  
 -      struct pci_dev *pci_dev = trans_pcie->pci_dev;
 -
 -      pos = pci_pcie_cap(pci_dev);
 -      pci_read_config_word(pci_dev, pos + PCI_EXP_LNKCTL, &pci_lnk_ctl);
 +      pcie_capability_read_word(trans_pcie->pci_dev, PCI_EXP_LNKCTL,
 +                                &pci_lnk_ctl);
        return pci_lnk_ctl;
  }
  
@@@ -1646,13 -1649,9 +1646,9 @@@ static const char *get_fh_string(int cm
  #undef IWL_CMD
  }
  
- int iwl_dump_fh(struct iwl_trans *trans, char **buf, bool display)
+ int iwl_dump_fh(struct iwl_trans *trans, char **buf)
  {
        int i;
- #ifdef CONFIG_IWLWIFI_DEBUG
-       int pos = 0;
-       size_t bufsz = 0;
- #endif
        static const u32 fh_tbl[] = {
                FH_RSCSR_CHNL0_STTS_WPTR_REG,
                FH_RSCSR_CHNL0_RBDCB_BASE_REG,
                FH_TSSR_TX_STATUS_REG,
                FH_TSSR_TX_ERROR_REG
        };
- #ifdef CONFIG_IWLWIFI_DEBUG
-       if (display) {
-               bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
+ #ifdef CONFIG_IWLWIFI_DEBUGFS
+       if (buf) {
+               int pos = 0;
+               size_t bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
                *buf = kmalloc(bufsz, GFP_KERNEL);
                if (!*buf)
                        return -ENOMEM;
                pos += scnprintf(*buf + pos, bufsz - pos,
                                "FH register values:\n");
-               for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
+               for (i = 0; i < ARRAY_SIZE(fh_tbl); i++)
                        pos += scnprintf(*buf + pos, bufsz - pos,
                                "  %34s: 0X%08x\n",
                                get_fh_string(fh_tbl[i]),
                                iwl_read_direct32(trans, fh_tbl[i]));
-               }
                return pos;
        }
  #endif
        IWL_ERR(trans, "FH register values:\n");
-       for (i = 0; i <  ARRAY_SIZE(fh_tbl); i++) {
+       for (i = 0; i <  ARRAY_SIZE(fh_tbl); i++)
                IWL_ERR(trans, "  %34s: 0X%08x\n",
                        get_fh_string(fh_tbl[i]),
                        iwl_read_direct32(trans, fh_tbl[i]));
-       }
        return 0;
  }
  
@@@ -1979,11 -1984,11 +1981,11 @@@ static ssize_t iwl_dbgfs_fh_reg_read(st
                                     size_t count, loff_t *ppos)
  {
        struct iwl_trans *trans = file->private_data;
-       char *buf;
+       char *buf = NULL;
        int pos = 0;
        ssize_t ret = -EFAULT;
  
-       ret = pos = iwl_dump_fh(trans, &buf, true);
+       ret = pos = iwl_dump_fh(trans, &buf);
        if (buf) {
                ret = simple_read_from_buffer(user_buf,
                                              count, ppos, buf, pos);
diff --combined drivers/pci/pci.c
@@@ -254,17 -254,52 +254,17 @@@ int pci_bus_find_capability(struct pci_
  }
  
  /**
 - * pci_pcie_cap2 - query for devices' PCI_CAP_ID_EXP v2 capability structure
 - * @dev: PCI device to check
 - *
 - * Like pci_pcie_cap() but also checks that the PCIe capability version is
 - * >= 2.  Note that v1 capability structures could be sparse in that not
 - * all register fields were required.  v2 requires the entire structure to
 - * be present size wise, while still allowing for non-implemented registers
 - * to exist but they must be hardwired to 0.
 - *
 - * Due to the differences in the versions of capability structures, one
 - * must be careful not to try and access non-existant registers that may
 - * exist in early versions - v1 - of Express devices.
 - *
 - * Returns the offset of the PCIe capability structure as long as the
 - * capability version is >= 2; otherwise 0 is returned.
 - */
 -static int pci_pcie_cap2(struct pci_dev *dev)
 -{
 -      u16 flags;
 -      int pos;
 -
 -      pos = pci_pcie_cap(dev);
 -      if (pos) {
 -              pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &flags);
 -              if ((flags & PCI_EXP_FLAGS_VERS) < 2)
 -                      pos = 0;
 -      }
 -
 -      return pos;
 -}
 -
 -/**
 - * pci_find_ext_capability - Find an extended capability
 + * pci_find_next_ext_capability - Find an extended capability
   * @dev: PCI device to query
 + * @start: address at which to start looking (0 to start at beginning of list)
   * @cap: capability code
   *
 - * Returns the address of the requested extended capability structure
 + * Returns the address of the next matching extended capability structure
   * within the device's PCI configuration space or 0 if the device does
 - * not support it.  Possible values for @cap:
 - *
 - *  %PCI_EXT_CAP_ID_ERR               Advanced Error Reporting
 - *  %PCI_EXT_CAP_ID_VC                Virtual Channel
 - *  %PCI_EXT_CAP_ID_DSN               Device Serial Number
 - *  %PCI_EXT_CAP_ID_PWR               Power Budgeting
 + * not support it.  Some capabilities can occur several times, e.g., the
 + * vendor-specific capability, and this provides a way to find them all.
   */
 -int pci_find_ext_capability(struct pci_dev *dev, int cap)
 +int pci_find_next_ext_capability(struct pci_dev *dev, int start, int cap)
  {
        u32 header;
        int ttl;
        if (dev->cfg_size <= PCI_CFG_SPACE_SIZE)
                return 0;
  
 +      if (start)
 +              pos = start;
 +
        if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
                return 0;
  
                return 0;
  
        while (ttl-- > 0) {
 -              if (PCI_EXT_CAP_ID(header) == cap)
 +              if (PCI_EXT_CAP_ID(header) == cap && pos != start)
                        return pos;
  
                pos = PCI_EXT_CAP_NEXT(header);
  
        return 0;
  }
 +EXPORT_SYMBOL_GPL(pci_find_next_ext_capability);
 +
 +/**
 + * pci_find_ext_capability - Find an extended capability
 + * @dev: PCI device to query
 + * @cap: capability code
 + *
 + * Returns the address of the requested extended capability structure
 + * within the device's PCI configuration space or 0 if the device does
 + * not support it.  Possible values for @cap:
 + *
 + *  %PCI_EXT_CAP_ID_ERR               Advanced Error Reporting
 + *  %PCI_EXT_CAP_ID_VC                Virtual Channel
 + *  %PCI_EXT_CAP_ID_DSN               Device Serial Number
 + *  %PCI_EXT_CAP_ID_PWR               Power Budgeting
 + */
 +int pci_find_ext_capability(struct pci_dev *dev, int cap)
 +{
 +      return pci_find_next_ext_capability(dev, 0, cap);
 +}
  EXPORT_SYMBOL_GPL(pci_find_ext_capability);
  
  static int __pci_find_next_ht_cap(struct pci_dev *dev, int pos, int ht_cap)
@@@ -842,6 -854,21 +842,6 @@@ EXPORT_SYMBOL(pci_choose_state)
  
  #define PCI_EXP_SAVE_REGS     7
  
 -#define pcie_cap_has_devctl(type, flags)      1
 -#define pcie_cap_has_lnkctl(type, flags)              \
 -              ((flags & PCI_EXP_FLAGS_VERS) > 1 ||    \
 -               (type == PCI_EXP_TYPE_ROOT_PORT ||     \
 -                type == PCI_EXP_TYPE_ENDPOINT ||      \
 -                type == PCI_EXP_TYPE_LEG_END))
 -#define pcie_cap_has_sltctl(type, flags)              \
 -              ((flags & PCI_EXP_FLAGS_VERS) > 1 ||    \
 -               ((type == PCI_EXP_TYPE_ROOT_PORT) ||   \
 -                (type == PCI_EXP_TYPE_DOWNSTREAM &&   \
 -                 (flags & PCI_EXP_FLAGS_SLOT))))
 -#define pcie_cap_has_rtctl(type, flags)                       \
 -              ((flags & PCI_EXP_FLAGS_VERS) > 1 ||    \
 -               (type == PCI_EXP_TYPE_ROOT_PORT ||     \
 -                type == PCI_EXP_TYPE_RC_EC))
  
  static struct pci_cap_saved_state *pci_find_saved_cap(
        struct pci_dev *pci_dev, char cap)
  
  static int pci_save_pcie_state(struct pci_dev *dev)
  {
 -      int pos, i = 0;
 +      int i = 0;
        struct pci_cap_saved_state *save_state;
        u16 *cap;
 -      u16 flags;
  
 -      pos = pci_pcie_cap(dev);
 -      if (!pos)
 +      if (!pci_is_pcie(dev))
                return 0;
  
        save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
                dev_err(&dev->dev, "buffer not found in %s\n", __func__);
                return -ENOMEM;
        }
 -      cap = (u16 *)&save_state->cap.data[0];
 -
 -      pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &flags);
  
 -      if (pcie_cap_has_devctl(dev->pcie_type, flags))
 -              pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &cap[i++]);
 -      if (pcie_cap_has_lnkctl(dev->pcie_type, flags))
 -              pci_read_config_word(dev, pos + PCI_EXP_LNKCTL, &cap[i++]);
 -      if (pcie_cap_has_sltctl(dev->pcie_type, flags))
 -              pci_read_config_word(dev, pos + PCI_EXP_SLTCTL, &cap[i++]);
 -      if (pcie_cap_has_rtctl(dev->pcie_type, flags))
 -              pci_read_config_word(dev, pos + PCI_EXP_RTCTL, &cap[i++]);
 -
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return 0;
 +      cap = (u16 *)&save_state->cap.data[0];
 +      pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &cap[i++]);
 +      pcie_capability_read_word(dev, PCI_EXP_LNKCTL, &cap[i++]);
 +      pcie_capability_read_word(dev, PCI_EXP_SLTCTL, &cap[i++]);
 +      pcie_capability_read_word(dev, PCI_EXP_RTCTL,  &cap[i++]);
 +      pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]);
 +      pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]);
 +      pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]);
  
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &cap[i++]);
 -      pci_read_config_word(dev, pos + PCI_EXP_LNKCTL2, &cap[i++]);
 -      pci_read_config_word(dev, pos + PCI_EXP_SLTCTL2, &cap[i++]);
        return 0;
  }
  
  static void pci_restore_pcie_state(struct pci_dev *dev)
  {
 -      int i = 0, pos;
 +      int i = 0;
        struct pci_cap_saved_state *save_state;
        u16 *cap;
 -      u16 flags;
  
        save_state = pci_find_saved_cap(dev, PCI_CAP_ID_EXP);
 -      pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 -      if (!save_state || pos <= 0)
 -              return;
 -      cap = (u16 *)&save_state->cap.data[0];
 -
 -      pci_read_config_word(dev, pos + PCI_EXP_FLAGS, &flags);
 -
 -      if (pcie_cap_has_devctl(dev->pcie_type, flags))
 -              pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, cap[i++]);
 -      if (pcie_cap_has_lnkctl(dev->pcie_type, flags))
 -              pci_write_config_word(dev, pos + PCI_EXP_LNKCTL, cap[i++]);
 -      if (pcie_cap_has_sltctl(dev->pcie_type, flags))
 -              pci_write_config_word(dev, pos + PCI_EXP_SLTCTL, cap[i++]);
 -      if (pcie_cap_has_rtctl(dev->pcie_type, flags))
 -              pci_write_config_word(dev, pos + PCI_EXP_RTCTL, cap[i++]);
 -
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 +      if (!save_state)
                return;
  
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, cap[i++]);
 -      pci_write_config_word(dev, pos + PCI_EXP_LNKCTL2, cap[i++]);
 -      pci_write_config_word(dev, pos + PCI_EXP_SLTCTL2, cap[i++]);
 +      cap = (u16 *)&save_state->cap.data[0];
 +      pcie_capability_write_word(dev, PCI_EXP_DEVCTL, cap[i++]);
 +      pcie_capability_write_word(dev, PCI_EXP_LNKCTL, cap[i++]);
 +      pcie_capability_write_word(dev, PCI_EXP_SLTCTL, cap[i++]);
 +      pcie_capability_write_word(dev, PCI_EXP_RTCTL, cap[i++]);
 +      pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]);
 +      pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]);
 +      pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]);
  }
  
  
@@@ -1889,6 -1941,7 +1889,7 @@@ void pci_pm_init(struct pci_dev *dev
        dev->pm_cap = pm;
        dev->d3_delay = PCI_PM_D3_WAIT;
        dev->d3cold_delay = PCI_PM_D3COLD_WAIT;
+       dev->d3cold_allowed = true;
  
        dev->d1_support = false;
        dev->d2_support = false;
@@@ -2014,24 -2067,35 +2015,24 @@@ void pci_free_cap_save_buffers(struct p
   */
  void pci_enable_ari(struct pci_dev *dev)
  {
 -      int pos;
        u32 cap;
 -      u16 ctrl;
        struct pci_dev *bridge;
  
        if (pcie_ari_disabled || !pci_is_pcie(dev) || dev->devfn)
                return;
  
 -      pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
 -      if (!pos)
 +      if (!pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI))
                return;
  
        bridge = dev->bus->self;
        if (!bridge)
                return;
  
 -      /* ARI is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(bridge);
 -      if (!pos)
 -              return;
 -
 -      pci_read_config_dword(bridge, pos + PCI_EXP_DEVCAP2, &cap);
 +      pcie_capability_read_dword(bridge, PCI_EXP_DEVCAP2, &cap);
        if (!(cap & PCI_EXP_DEVCAP2_ARI))
                return;
  
 -      pci_read_config_word(bridge, pos + PCI_EXP_DEVCTL2, &ctrl);
 -      ctrl |= PCI_EXP_DEVCTL2_ARI;
 -      pci_write_config_word(bridge, pos + PCI_EXP_DEVCTL2, ctrl);
 -
 +      pcie_capability_set_word(bridge, PCI_EXP_DEVCTL2, PCI_EXP_DEVCTL2_ARI);
        bridge->ari_enabled = 1;
  }
  
   */
  void pci_enable_ido(struct pci_dev *dev, unsigned long type)
  {
 -      int pos;
 -      u16 ctrl;
 +      u16 ctrl = 0;
  
 -      /* ID-based Ordering is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return;
 -
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
        if (type & PCI_EXP_IDO_REQUEST)
                ctrl |= PCI_EXP_IDO_REQ_EN;
        if (type & PCI_EXP_IDO_COMPLETION)
                ctrl |= PCI_EXP_IDO_CMP_EN;
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
 +      if (ctrl)
 +              pcie_capability_set_word(dev, PCI_EXP_DEVCTL2, ctrl);
  }
  EXPORT_SYMBOL(pci_enable_ido);
  
   */
  void pci_disable_ido(struct pci_dev *dev, unsigned long type)
  {
 -      int pos;
 -      u16 ctrl;
 +      u16 ctrl = 0;
  
 -      /* ID-based Ordering is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return;
 -
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
        if (type & PCI_EXP_IDO_REQUEST)
 -              ctrl &= ~PCI_EXP_IDO_REQ_EN;
 +              ctrl |= PCI_EXP_IDO_REQ_EN;
        if (type & PCI_EXP_IDO_COMPLETION)
 -              ctrl &= ~PCI_EXP_IDO_CMP_EN;
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
 +              ctrl |= PCI_EXP_IDO_CMP_EN;
 +      if (ctrl)
 +              pcie_capability_clear_word(dev, PCI_EXP_DEVCTL2, ctrl);
  }
  EXPORT_SYMBOL(pci_disable_ido);
  
   */
  int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type type)
  {
 -      int pos;
        u32 cap;
        u16 ctrl;
        int ret;
  
 -      /* OBFF is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return -ENOTSUPP;
 -
 -      pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP2, &cap);
 +      pcie_capability_read_dword(dev, PCI_EXP_DEVCAP2, &cap);
        if (!(cap & PCI_EXP_OBFF_MASK))
                return -ENOTSUPP; /* no OBFF support at all */
  
                        return ret;
        }
  
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
 +      pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &ctrl);
        if (cap & PCI_EXP_OBFF_WAKE)
                ctrl |= PCI_EXP_OBFF_WAKE_EN;
        else {
                        return -ENOTSUPP;
                }
        }
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
 +      pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, ctrl);
  
        return 0;
  }
@@@ -2143,7 -2225,17 +2144,7 @@@ EXPORT_SYMBOL(pci_enable_obff)
   */
  void pci_disable_obff(struct pci_dev *dev)
  {
 -      int pos;
 -      u16 ctrl;
 -
 -      /* OBFF is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return;
 -
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
 -      ctrl &= ~PCI_EXP_OBFF_WAKE_EN;
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
 +      pcie_capability_clear_word(dev, PCI_EXP_DEVCTL2, PCI_EXP_OBFF_WAKE_EN);
  }
  EXPORT_SYMBOL(pci_disable_obff);
  
   */
  static bool pci_ltr_supported(struct pci_dev *dev)
  {
 -      int pos;
        u32 cap;
  
 -      /* LTR is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return false;
 -
 -      pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP2, &cap);
 +      pcie_capability_read_dword(dev, PCI_EXP_DEVCAP2, &cap);
  
        return cap & PCI_EXP_DEVCAP2_LTR;
  }
   */
  int pci_enable_ltr(struct pci_dev *dev)
  {
 -      int pos;
 -      u16 ctrl;
        int ret;
  
 -      if (!pci_ltr_supported(dev))
 -              return -ENOTSUPP;
 -
 -      /* LTR is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return -ENOTSUPP;
 -
        /* Only primary function can enable/disable LTR */
        if (PCI_FUNC(dev->devfn) != 0)
                return -EINVAL;
  
 +      if (!pci_ltr_supported(dev))
 +              return -ENOTSUPP;
 +
        /* Enable upstream ports first */
        if (dev->bus->self) {
                ret = pci_enable_ltr(dev->bus->self);
                        return ret;
        }
  
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
 -      ctrl |= PCI_EXP_LTR_EN;
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
 -
 -      return 0;
 +      return pcie_capability_set_word(dev, PCI_EXP_DEVCTL2, PCI_EXP_LTR_EN);
  }
  EXPORT_SYMBOL(pci_enable_ltr);
  
   */
  void pci_disable_ltr(struct pci_dev *dev)
  {
 -      int pos;
 -      u16 ctrl;
 -
 -      if (!pci_ltr_supported(dev))
 -              return;
 -
 -      /* LTR is a PCIe cap v2 feature */
 -      pos = pci_pcie_cap2(dev);
 -      if (!pos)
 -              return;
 -
        /* Only primary function can enable/disable LTR */
        if (PCI_FUNC(dev->devfn) != 0)
                return;
  
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
 -      ctrl &= ~PCI_EXP_LTR_EN;
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
 +      if (!pci_ltr_supported(dev))
 +              return;
 +
 +      pcie_capability_clear_word(dev, PCI_EXP_DEVCTL2, PCI_EXP_LTR_EN);
  }
  EXPORT_SYMBOL(pci_disable_ltr);
  
@@@ -2291,6 -2410,9 +2292,6 @@@ void pci_enable_acs(struct pci_dev *dev
        if (!pci_acs_enable)
                return;
  
 -      if (!pci_is_pcie(dev))
 -              return;
 -
        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS);
        if (!pos)
                return;
@@@ -2338,8 -2460,8 +2339,8 @@@ bool pci_acs_enabled(struct pci_dev *pd
                acs_flags &= (PCI_ACS_RR | PCI_ACS_CR |
                              PCI_ACS_EC | PCI_ACS_DT);
  
 -      if (pdev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM ||
 -          pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
 +      if (pci_pcie_type(pdev) == PCI_EXP_TYPE_DOWNSTREAM ||
 +          pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT ||
            pdev->multifunction) {
                pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ACS);
                if (!pos)
@@@ -3055,10 -3177,15 +3056,10 @@@ EXPORT_SYMBOL(pci_set_dma_seg_boundary)
  static int pcie_flr(struct pci_dev *dev, int probe)
  {
        int i;
 -      int pos;
        u32 cap;
 -      u16 status, control;
 -
 -      pos = pci_pcie_cap(dev);
 -      if (!pos)
 -              return -ENOTTY;
 +      u16 status;
  
 -      pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP, &cap);
 +      pcie_capability_read_dword(dev, PCI_EXP_DEVCAP, &cap);
        if (!(cap & PCI_EXP_DEVCAP_FLR))
                return -ENOTTY;
  
                if (i)
                        msleep((1 << (i - 1)) * 100);
  
 -              pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &status);
 +              pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
                if (!(status & PCI_EXP_DEVSTA_TRPND))
                        goto clear;
        }
                        "proceeding with reset anyway\n");
  
  clear:
 -      pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &control);
 -      control |= PCI_EXP_DEVCTL_BCR_FLR;
 -      pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, control);
 +      pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_BCR_FLR);
  
        msleep(100);
  
@@@ -3447,11 -3576,18 +3448,11 @@@ EXPORT_SYMBOL(pcix_set_mmrbc)
   */
  int pcie_get_readrq(struct pci_dev *dev)
  {
 -      int ret, cap;
        u16 ctl;
  
 -      cap = pci_pcie_cap(dev);
 -      if (!cap)
 -              return -EINVAL;
 -
 -      ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
 -      if (!ret)
 -              ret = 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
 +      pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
  
 -      return ret;
 +      return 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
  }
  EXPORT_SYMBOL(pcie_get_readrq);
  
   */
  int pcie_set_readrq(struct pci_dev *dev, int rq)
  {
 -      int cap, err = -EINVAL;
 -      u16 ctl, v;
 +      u16 v;
  
        if (rq < 128 || rq > 4096 || !is_power_of_2(rq))
 -              goto out;
 -
 -      cap = pci_pcie_cap(dev);
 -      if (!cap)
 -              goto out;
 +              return -EINVAL;
  
 -      err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
 -      if (err)
 -              goto out;
        /*
         * If using the "performance" PCIe config, we clamp the
         * read rq size to the max packet size to prevent the
  
        v = (ffs(rq) - 8) << 12;
  
 -      if ((ctl & PCI_EXP_DEVCTL_READRQ) != v) {
 -              ctl &= ~PCI_EXP_DEVCTL_READRQ;
 -              ctl |= v;
 -              err = pci_write_config_word(dev, cap + PCI_EXP_DEVCTL, ctl);
 -      }
 -
 -out:
 -      return err;
 +      return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
 +                                                PCI_EXP_DEVCTL_READRQ, v);
  }
  EXPORT_SYMBOL(pcie_set_readrq);
  
   */
  int pcie_get_mps(struct pci_dev *dev)
  {
 -      int ret, cap;
        u16 ctl;
  
 -      cap = pci_pcie_cap(dev);
 -      if (!cap)
 -              return -EINVAL;
 -
 -      ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
 -      if (!ret)
 -              ret = 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
 +      pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
  
 -      return ret;
 +      return 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
  }
  
  /**
   */
  int pcie_set_mps(struct pci_dev *dev, int mps)
  {
 -      int cap, err = -EINVAL;
 -      u16 ctl, v;
 +      u16 v;
  
        if (mps < 128 || mps > 4096 || !is_power_of_2(mps))
 -              goto out;
 +              return -EINVAL;
  
        v = ffs(mps) - 8;
        if (v > dev->pcie_mpss) 
 -              goto out;
 +              return -EINVAL;
        v <<= 5;
  
 -      cap = pci_pcie_cap(dev);
 -      if (!cap)
 -              goto out;
 -
 -      err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
 -      if (err)
 -              goto out;
 -
 -      if ((ctl & PCI_EXP_DEVCTL_PAYLOAD) != v) {
 -              ctl &= ~PCI_EXP_DEVCTL_PAYLOAD;
 -              ctl |= v;
 -              err = pci_write_config_word(dev, cap + PCI_EXP_DEVCTL, ctl);
 -      }
 -out:
 -      return err;
 +      return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
 +                                                PCI_EXP_DEVCTL_PAYLOAD, v);
  }
  
  /**
@@@ -64,7 -64,14 +64,7 @@@ __setup("pcie_ports=", pcie_port_setup)
   */
  void pcie_clear_root_pme_status(struct pci_dev *dev)
  {
 -      int rtsta_pos;
 -      u32 rtsta;
 -
 -      rtsta_pos = pci_pcie_cap(dev) + PCI_EXP_RTSTA;
 -
 -      pci_read_config_dword(dev, rtsta_pos, &rtsta);
 -      rtsta |= PCI_EXP_RTSTA_PME;
 -      pci_write_config_dword(dev, rtsta_pos, rtsta);
 +      pcie_capability_set_dword(dev, PCI_EXP_RTSTA, PCI_EXP_RTSTA_PME);
  }
  
  static int pcie_portdrv_restore_config(struct pci_dev *dev)
@@@ -88,7 -95,7 +88,7 @@@ static int pcie_port_resume_noirq(struc
         * which breaks ACPI-based runtime wakeup on PCI Express, so clear those
         * bits now just in case (shouldn't hurt).
         */
 -      if(pdev->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
 +      if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT)
                pcie_clear_root_pme_status(pdev);
        return 0;
  }
@@@ -133,9 -140,17 +133,17 @@@ static int pcie_port_runtime_resume(str
  {
        return 0;
  }
+ static int pcie_port_runtime_idle(struct device *dev)
+ {
+       /* Delay for a short while to prevent too frequent suspend/resume */
+       pm_schedule_suspend(dev, 10);
+       return -EBUSY;
+ }
  #else
  #define pcie_port_runtime_suspend     NULL
  #define pcie_port_runtime_resume      NULL
+ #define pcie_port_runtime_idle                NULL
  #endif
  
  static const struct dev_pm_ops pcie_portdrv_pm_ops = {
        .resume_noirq   = pcie_port_resume_noirq,
        .runtime_suspend = pcie_port_runtime_suspend,
        .runtime_resume = pcie_port_runtime_resume,
+       .runtime_idle   = pcie_port_runtime_idle,
  };
  
  #define PCIE_PORTDRV_PM_OPS   (&pcie_portdrv_pm_ops)
@@@ -179,9 -195,9 +188,9 @@@ static int __devinit pcie_portdrv_probe
        int status;
  
        if (!pci_is_pcie(dev) ||
 -          ((dev->pcie_type != PCI_EXP_TYPE_ROOT_PORT) &&
 -           (dev->pcie_type != PCI_EXP_TYPE_UPSTREAM) &&
 -           (dev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM)))
 +          ((pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT) &&
 +           (pci_pcie_type(dev) != PCI_EXP_TYPE_UPSTREAM) &&
 +           (pci_pcie_type(dev) != PCI_EXP_TYPE_DOWNSTREAM)))
                return -ENODEV;
  
        if (!dev->irq && dev->pin) {
                return status;
  
        pci_save_state(dev);
+       /*
+        * D3cold may not work properly on some PCIe port, so disable
+        * it by default.
+        */
+       dev->d3cold_allowed = false;
        if (!pci_match_id(port_runtime_pm_black_list, dev))
                pm_runtime_put_noidle(&dev->dev);
  
@@@ -364,11 -385,11 +378,11 @@@ static const struct pci_device_id port_
  };
  MODULE_DEVICE_TABLE(pci, port_pci_ids);
  
 -static struct pci_error_handlers pcie_portdrv_err_handler = {
 -              .error_detected = pcie_portdrv_error_detected,
 -              .mmio_enabled = pcie_portdrv_mmio_enabled,
 -              .slot_reset = pcie_portdrv_slot_reset,
 -              .resume = pcie_portdrv_err_resume,
 +static const struct pci_error_handlers pcie_portdrv_err_handler = {
 +      .error_detected = pcie_portdrv_error_detected,
 +      .mmio_enabled = pcie_portdrv_mmio_enabled,
 +      .slot_reset = pcie_portdrv_slot_reset,
 +      .resume = pcie_portdrv_err_resume,
  };
  
  static struct pci_driver pcie_portdriver = {
diff --combined drivers/pci/probe.c
@@@ -144,15 -144,13 +144,13 @@@ static inline unsigned long decode_bar(
        case PCI_BASE_ADDRESS_MEM_TYPE_32:
                break;
        case PCI_BASE_ADDRESS_MEM_TYPE_1M:
-               dev_info(&dev->dev, "1M mem BAR treated as 32-bit BAR\n");
+               /* 1M mem BAR treated as 32-bit BAR */
                break;
        case PCI_BASE_ADDRESS_MEM_TYPE_64:
                flags |= IORESOURCE_MEM_64;
                break;
        default:
-               dev_warn(&dev->dev,
-                        "mem unknown type %x treated as 32-bit BAR\n",
-                        mem_type);
+               /* mem unknown type treated as 32-bit BAR */
                break;
        }
        return flags;
@@@ -173,9 -171,11 +171,11 @@@ int __pci_read_base(struct pci_dev *dev
        u32 l, sz, mask;
        u16 orig_cmd;
        struct pci_bus_region region;
+       bool bar_too_big = false, bar_disabled = false;
  
        mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
  
+       /* No printks while decoding is disabled! */
        if (!dev->mmio_always_on) {
                pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
                pci_write_config_word(dev, PCI_COMMAND,
                        goto fail;
  
                if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
-                       dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n",
-                               pos);
+                       bar_too_big = true;
                        goto fail;
                }
  
                        region.start = 0;
                        region.end = sz64;
                        pcibios_bus_to_resource(dev, res, &region);
+                       bar_disabled = true;
                } else {
                        region.start = l64;
                        region.end = l64 + sz64;
                        pcibios_bus_to_resource(dev, res, &region);
-                       dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n",
-                                  pos, res);
                }
        } else {
                sz = pci_size(l, sz, mask);
                region.start = l;
                region.end = l + sz;
                pcibios_bus_to_resource(dev, res, &region);
-               dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
        }
  
-  out:
+       goto out;
+ fail:
+       res->flags = 0;
+ out:
        if (!dev->mmio_always_on)
                pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
  
+       if (bar_too_big)
+               dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n", pos);
+       if (res->flags && !bar_disabled)
+               dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
        return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
-  fail:
-       res->flags = 0;
-       goto out;
  }
  
  static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
@@@ -603,10 -606,10 +606,10 @@@ static void pci_set_bus_speed(struct pc
                u32 linkcap;
                u16 linksta;
  
 -              pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
 +              pcie_capability_read_dword(bridge, PCI_EXP_LNKCAP, &linkcap);
                bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];
  
 -              pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
 +              pcie_capability_read_word(bridge, PCI_EXP_LNKSTA, &linksta);
                pcie_update_link_speed(bus, linksta);
        }
  }
@@@ -929,16 -932,24 +932,16 @@@ void set_pcie_port_type(struct pci_dev 
        pdev->is_pcie = 1;
        pdev->pcie_cap = pos;
        pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 -      pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
 +      pdev->pcie_flags_reg = reg16;
        pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
        pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
  }
  
  void set_pcie_hotplug_bridge(struct pci_dev *pdev)
  {
 -      int pos;
 -      u16 reg16;
        u32 reg32;
  
 -      pos = pci_pcie_cap(pdev);
 -      if (!pos)
 -              return;
 -      pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 -      if (!(reg16 & PCI_EXP_FLAGS_SLOT))
 -              return;
 -      pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, &reg32);
 +      pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32);
        if (reg32 & PCI_EXP_SLTCAP_HPC)
                pdev->is_hotplug_bridge = 1;
  }
@@@ -1152,7 -1163,8 +1155,7 @@@ int pci_cfg_space_size(struct pci_dev *
        if (class == PCI_CLASS_BRIDGE_HOST)
                return pci_cfg_space_size_ext(dev);
  
 -      pos = pci_pcie_cap(dev);
 -      if (!pos) {
 +      if (!pci_is_pcie(dev)) {
                pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
                if (!pos)
                        goto fail;
@@@ -1374,9 -1386,9 +1377,9 @@@ static int only_one_child(struct pci_bu
  
        if (!parent || !pci_is_pcie(parent))
                return 0;
 -      if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
 +      if (pci_pcie_type(parent) == PCI_EXP_TYPE_ROOT_PORT)
                return 1;
 -      if (parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM &&
 +      if (pci_pcie_type(parent) == PCI_EXP_TYPE_DOWNSTREAM &&
            !pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
                return 1;
        return 0;
@@@ -1453,7 -1465,7 +1456,7 @@@ static int pcie_find_smpss(struct pci_d
         */
        if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
             (dev->bus->self &&
 -            dev->bus->self->pcie_type != PCI_EXP_TYPE_ROOT_PORT)))
 +            pci_pcie_type(dev->bus->self) != PCI_EXP_TYPE_ROOT_PORT)))
                *smpss = 0;
  
        if (*smpss > dev->pcie_mpss)
@@@ -1469,8 -1481,7 +1472,8 @@@ static void pcie_write_mps(struct pci_d
        if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
                mps = 128 << dev->pcie_mpss;
  
 -              if (dev->pcie_type != PCI_EXP_TYPE_ROOT_PORT && dev->bus->self)
 +              if (pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT &&
 +                  dev->bus->self)
                        /* For "Performance", the assumption is made that
                         * downstream communication will never be larger than
                         * the MRRS.  So, the MPS only needs to be configured
@@@ -435,6 -435,9 +435,9 @@@ static void tsi721_db_dpc(struct work_s
                                " info %4.4x\n", DBELL_SID(idb.bytes),
                                DBELL_TID(idb.bytes), DBELL_INF(idb.bytes));
                }
+               wr_ptr = ioread32(priv->regs +
+                                 TSI721_IDQ_WP(IDB_QUEUE)) % IDB_QSIZE;
        }
  
        iowrite32(rd_ptr & (IDB_QSIZE - 1),
        regval |= TSI721_SR_CHINT_IDBQRCV;
        iowrite32(regval,
                priv->regs + TSI721_SR_CHINTE(IDB_QUEUE));
+       wr_ptr = ioread32(priv->regs + TSI721_IDQ_WP(IDB_QUEUE)) % IDB_QSIZE;
+       if (wr_ptr != rd_ptr)
+               schedule_work(&priv->idb_work);
  }
  
  /**
@@@ -2212,8 -2219,9 +2219,7 @@@ static int __devinit tsi721_probe(struc
                                  const struct pci_device_id *id)
  {
        struct tsi721_device *priv;
-       int i;
 -      int cap;
        int err;
 -      u32 regval;
  
        priv = kzalloc(sizeof(struct tsi721_device), GFP_KERNEL);
        if (priv == NULL) {
        priv->pdev = pdev;
  
  #ifdef DEBUG
+       {
+       int i;
        for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
                dev_dbg(&pdev->dev, "res[%d] @ 0x%llx (0x%lx, 0x%lx)\n",
                        i, (unsigned long long)pci_resource_start(pdev, i),
                        (unsigned long)pci_resource_len(pdev, i),
                        pci_resource_flags(pdev, i));
        }
+       }
  #endif
        /*
         * Verify BAR configuration
                        dev_info(&pdev->dev, "Unable to set consistent DMA mask\n");
        }
  
 -      cap = pci_pcie_cap(pdev);
 -      BUG_ON(cap == 0);
 +      BUG_ON(!pci_is_pcie(pdev));
  
        /* Clear "no snoop" and "relaxed ordering" bits, use default MRRS. */
 -      pci_read_config_dword(pdev, cap + PCI_EXP_DEVCTL, &regval);
 -      regval &= ~(PCI_EXP_DEVCTL_READRQ | PCI_EXP_DEVCTL_RELAX_EN |
 -                  PCI_EXP_DEVCTL_NOSNOOP_EN);
 -      regval |= 0x2 << MAX_READ_REQUEST_SZ_SHIFT;
 -      pci_write_config_dword(pdev, cap + PCI_EXP_DEVCTL, regval);
 +      pcie_capability_clear_and_set_word(pdev, PCI_EXP_DEVCTL,
 +              PCI_EXP_DEVCTL_READRQ | PCI_EXP_DEVCTL_RELAX_EN |
 +              PCI_EXP_DEVCTL_NOSNOOP_EN,
 +              0x2 << MAX_READ_REQUEST_SZ_SHIFT);
  
        /* Adjust PCIe completion timeout. */
 -      pci_read_config_dword(pdev, cap + PCI_EXP_DEVCTL2, &regval);
 -      regval &= ~(0x0f);
 -      pci_write_config_dword(pdev, cap + PCI_EXP_DEVCTL2, regval | 0x2);
 +      pcie_capability_clear_and_set_word(pdev, PCI_EXP_DEVCTL2, 0xf, 0x2);
  
        /*
         * FIXUP: correct offsets of MSI-X tables in the MSI-X Capability Block
@@@ -353,16 -353,16 +353,16 @@@ static int __devinit pcistub_init_devic
        if (err)
                goto config_release;
  
-       dev_dbg(&dev->dev, "reseting (FLR, D3, etc) the device\n");
-       __pci_reset_function_locked(dev);
        /* We need the device active to save the state. */
        dev_dbg(&dev->dev, "save state of device\n");
        pci_save_state(dev);
        dev_data->pci_saved_state = pci_store_saved_state(dev);
        if (!dev_data->pci_saved_state)
                dev_err(&dev->dev, "Could not store PCI conf saved state!\n");
+       else {
+               dev_dbg(&dev->dev, "reseting (FLR, D3, etc) the device\n");
+               __pci_reset_function_locked(dev);
+       }
        /* Now disable the device (this also ensures some private device
         * data is setup before we export)
         */
@@@ -871,7 -871,7 +871,7 @@@ end
  }
  
  /*add xen_pcibk AER handling*/
 -static struct pci_error_handlers xen_pcibk_error_handler = {
 +static const struct pci_error_handlers xen_pcibk_error_handler = {
        .error_detected = xen_pcibk_error_detected,
        .mmio_enabled = xen_pcibk_mmio_enabled,
        .slot_reset = xen_pcibk_slot_reset,