Merge tag 'for-3.7' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci
Linus Torvalds [Mon, 1 Oct 2012 19:05:36 +0000 (12:05 -0700)]
Pull PCI changes from Bjorn Helgaas:
 "Host bridge hotplug
    - Protect acpi_pci_drivers and acpi_pci_roots (Taku Izumi)
    - Clear host bridge resource info to avoid issue when releasing
      (Yinghai Lu)
    - Notify acpi_pci_drivers when hot-plugging host bridges (Jiang Liu)
    - Use standard list ops for acpi_pci_drivers (Jiang Liu)

  Device hotplug
    - Use pci_get_domain_bus_and_slot() to close hotplug races (Jiang
      Liu)
    - Remove fakephp driver (Bjorn Helgaas)
    - Fix VGA ref count in hotplug remove path (Yinghai Lu)
    - Allow acpiphp to handle PCIe ports without native hotplug (Jiang
      Liu)
    - Implement resume regardless of pciehp_force param (Oliver Neukum)
    - Make pci_fixup_irqs() work after init (Thierry Reding)

  Miscellaneous
    - Add pci_pcie_type(dev) and remove pci_dev.pcie_type (Yijing Wang)
    - Factor out PCI Express Capability accessors (Jiang Liu)
    - Add pcibios_window_alignment() so powerpc EEH can use generic
      resource assignment (Gavin Shan)
    - Make pci_error_handlers const (Stephen Hemminger)
    - Cleanup drivers/pci/remove.c (Bjorn Helgaas)
    - Improve Vendor-Specific Extended Capability support (Bjorn
      Helgaas)
    - Use standard list ops for bus->devices (Bjorn Helgaas)
    - Avoid kmalloc in pci_get_subsys() and pci_get_class() (Feng Tang)
    - Reassign invalid bus number ranges (Intel DP43BF workaround)
      (Yinghai Lu)"

* tag 'for-3.7' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci: (102 commits)
  PCI: acpiphp: Handle PCIe ports without native hotplug capability
  PCI/ACPI: Use acpi_driver_data() rather than searching acpi_pci_roots
  PCI/ACPI: Protect acpi_pci_roots list with mutex
  PCI/ACPI: Use acpi_pci_root info rather than looking it up again
  PCI/ACPI: Pass acpi_pci_root to acpi_pci_drivers' add/remove interface
  PCI/ACPI: Protect acpi_pci_drivers list with mutex
  PCI/ACPI: Notify acpi_pci_drivers when hot-plugging PCI root bridges
  PCI/ACPI: Use normal list for struct acpi_pci_driver
  PCI/ACPI: Use DEVICE_ACPI_HANDLE rather than searching acpi_pci_roots
  PCI: Fix default vga ref_count
  ia64/PCI: Clear host bridge aperture struct resource
  x86/PCI: Clear host bridge aperture struct resource
  PCI: Stop all children first, before removing all children
  Revert "PCI: Use hotplug-safe pci_get_domain_bus_and_slot()"
  PCI: Provide a default pcibios_update_irq()
  PCI: Discard __init annotations for pci_fixup_irqs() and related functions
  PCI: Use correct type when freeing bus resource list
  PCI: Check P2P bridge for invalid secondary/subordinate range
  PCI: Convert "new_id"/"remove_id" into generic pci_bus driver attributes
  xen-pcifront: Use hotplug-safe pci_get_domain_bus_and_slot()
  ...

1  2 
drivers/block/nvme.c
drivers/net/ethernet/broadcom/bnx2.c
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
drivers/net/ethernet/intel/e1000/e1000_main.c
drivers/net/ethernet/mellanox/mlx4/main.c
drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
drivers/net/wireless/iwlwifi/pcie/trans.c
drivers/scsi/ipr.c
drivers/scsi/lpfc/lpfc_init.c
drivers/scsi/qla4xxx/ql4_os.c

diff --combined drivers/block/nvme.c
@@@ -79,7 -79,6 +79,7 @@@ struct nvme_dev 
        char serial[20];
        char model[40];
        char firmware_rev[8];
 +      u32 max_hw_sectors;
  };
  
  /*
@@@ -836,15 -835,15 +836,15 @@@ static int nvme_identify(struct nvme_de
  }
  
  static int nvme_get_features(struct nvme_dev *dev, unsigned fid,
 -                              unsigned dword11, dma_addr_t dma_addr)
 +                              unsigned nsid, dma_addr_t dma_addr)
  {
        struct nvme_command c;
  
        memset(&c, 0, sizeof(c));
        c.features.opcode = nvme_admin_get_features;
 +      c.features.nsid = cpu_to_le32(nsid);
        c.features.prp1 = cpu_to_le64(dma_addr);
        c.features.fid = cpu_to_le32(fid);
 -      c.features.dword11 = cpu_to_le32(dword11);
  
        return nvme_submit_admin_cmd(dev, &c, NULL);
  }
@@@ -863,51 -862,11 +863,51 @@@ static int nvme_set_features(struct nvm
        return nvme_submit_admin_cmd(dev, &c, result);
  }
  
 +/**
 + * nvme_cancel_ios - Cancel outstanding I/Os
 + * @queue: The queue to cancel I/Os on
 + * @timeout: True to only cancel I/Os which have timed out
 + */
 +static void nvme_cancel_ios(struct nvme_queue *nvmeq, bool timeout)
 +{
 +      int depth = nvmeq->q_depth - 1;
 +      struct nvme_cmd_info *info = nvme_cmd_info(nvmeq);
 +      unsigned long now = jiffies;
 +      int cmdid;
 +
 +      for_each_set_bit(cmdid, nvmeq->cmdid_data, depth) {
 +              void *ctx;
 +              nvme_completion_fn fn;
 +              static struct nvme_completion cqe = {
 +                      .status = cpu_to_le16(NVME_SC_ABORT_REQ) << 1,
 +              };
 +
 +              if (timeout && !time_after(now, info[cmdid].timeout))
 +                      continue;
 +              dev_warn(nvmeq->q_dmadev, "Cancelling I/O %d\n", cmdid);
 +              ctx = cancel_cmdid(nvmeq, cmdid, &fn);
 +              fn(nvmeq->dev, ctx, &cqe);
 +      }
 +}
 +
 +static void nvme_free_queue_mem(struct nvme_queue *nvmeq)
 +{
 +      dma_free_coherent(nvmeq->q_dmadev, CQ_SIZE(nvmeq->q_depth),
 +                              (void *)nvmeq->cqes, nvmeq->cq_dma_addr);
 +      dma_free_coherent(nvmeq->q_dmadev, SQ_SIZE(nvmeq->q_depth),
 +                                      nvmeq->sq_cmds, nvmeq->sq_dma_addr);
 +      kfree(nvmeq);
 +}
 +
  static void nvme_free_queue(struct nvme_dev *dev, int qid)
  {
        struct nvme_queue *nvmeq = dev->queues[qid];
        int vector = dev->entry[nvmeq->cq_vector].vector;
  
 +      spin_lock_irq(&nvmeq->q_lock);
 +      nvme_cancel_ios(nvmeq, false);
 +      spin_unlock_irq(&nvmeq->q_lock);
 +
        irq_set_affinity_hint(vector, NULL);
        free_irq(vector, nvmeq);
  
                adapter_delete_cq(dev, qid);
        }
  
 -      dma_free_coherent(nvmeq->q_dmadev, CQ_SIZE(nvmeq->q_depth),
 -                              (void *)nvmeq->cqes, nvmeq->cq_dma_addr);
 -      dma_free_coherent(nvmeq->q_dmadev, SQ_SIZE(nvmeq->q_depth),
 -                                      nvmeq->sq_cmds, nvmeq->sq_dma_addr);
 -      kfree(nvmeq);
 +      nvme_free_queue_mem(nvmeq);
  }
  
  static struct nvme_queue *nvme_alloc_queue(struct nvme_dev *dev, int qid,
                                                        int depth, int vector)
  {
        struct device *dmadev = &dev->pci_dev->dev;
 -      unsigned extra = (depth / 8) + (depth * sizeof(struct nvme_cmd_info));
 +      unsigned extra = DIV_ROUND_UP(depth, 8) + (depth *
 +                                              sizeof(struct nvme_cmd_info));
        struct nvme_queue *nvmeq = kzalloc(sizeof(*nvmeq) + extra, GFP_KERNEL);
        if (!nvmeq)
                return NULL;
@@@ -1013,7 -975,7 +1013,7 @@@ static __devinit struct nvme_queue *nvm
  
  static int __devinit nvme_configure_admin_queue(struct nvme_dev *dev)
  {
 -      int result;
 +      int result = 0;
        u32 aqa;
        u64 cap;
        unsigned long timeout;
        timeout = ((NVME_CAP_TIMEOUT(cap) + 1) * HZ / 2) + jiffies;
        dev->db_stride = NVME_CAP_STRIDE(cap);
  
 -      while (!(readl(&dev->bar->csts) & NVME_CSTS_RDY)) {
 +      while (!result && !(readl(&dev->bar->csts) & NVME_CSTS_RDY)) {
                msleep(100);
                if (fatal_signal_pending(current))
 -                      return -EINTR;
 +                      result = -EINTR;
                if (time_after(jiffies, timeout)) {
                        dev_err(&dev->pci_dev->dev,
                                "Device not ready; aborting initialisation\n");
 -                      return -ENODEV;
 +                      result = -ENODEV;
                }
        }
  
 +      if (result) {
 +              nvme_free_queue_mem(nvmeq);
 +              return result;
 +      }
 +
        result = queue_request_irq(dev, nvmeq, "nvme admin");
        dev->queues[0] = nvmeq;
        return result;
@@@ -1080,8 -1037,6 +1080,8 @@@ static struct nvme_iod *nvme_map_user_p
        offset = offset_in_page(addr);
        count = DIV_ROUND_UP(offset + length, PAGE_SIZE);
        pages = kcalloc(count, sizeof(*pages), GFP_KERNEL);
 +      if (!pages)
 +              return ERR_PTR(-ENOMEM);
  
        err = get_user_pages_fast(addr, count, 1, pages);
        if (err < count) {
@@@ -1191,13 -1146,14 +1191,13 @@@ static int nvme_submit_io(struct nvme_n
        return status;
  }
  
 -static int nvme_user_admin_cmd(struct nvme_ns *ns,
 +static int nvme_user_admin_cmd(struct nvme_dev *dev,
                                        struct nvme_admin_cmd __user *ucmd)
  {
        struct nvme_admin_cmd cmd;
        struct nvme_command c;
        int status, length;
 -      struct nvme_iod *iod;
 +      struct nvme_iod *uninitialized_var(iod);
  
        if (!capable(CAP_SYS_ADMIN))
                return -EACCES;
@@@ -1248,7 -1204,7 +1248,7 @@@ static int nvme_ioctl(struct block_devi
        case NVME_IOCTL_ID:
                return ns->ns_id;
        case NVME_IOCTL_ADMIN_CMD:
 -              return nvme_user_admin_cmd(ns, (void __user *)arg);
 +              return nvme_user_admin_cmd(ns->dev, (void __user *)arg);
        case NVME_IOCTL_SUBMIT_IO:
                return nvme_submit_io(ns, (void __user *)arg);
        default:
@@@ -1262,6 -1218,26 +1262,6 @@@ static const struct block_device_operat
        .compat_ioctl   = nvme_ioctl,
  };
  
 -static void nvme_timeout_ios(struct nvme_queue *nvmeq)
 -{
 -      int depth = nvmeq->q_depth - 1;
 -      struct nvme_cmd_info *info = nvme_cmd_info(nvmeq);
 -      unsigned long now = jiffies;
 -      int cmdid;
 -
 -      for_each_set_bit(cmdid, nvmeq->cmdid_data, depth) {
 -              void *ctx;
 -              nvme_completion_fn fn;
 -              static struct nvme_completion cqe = { .status = cpu_to_le16(NVME_SC_ABORT_REQ) << 1, };
 -
 -              if (!time_after(now, info[cmdid].timeout))
 -                      continue;
 -              dev_warn(nvmeq->q_dmadev, "Timing out I/O %d\n", cmdid);
 -              ctx = cancel_cmdid(nvmeq, cmdid, &fn);
 -              fn(nvmeq->dev, ctx, &cqe);
 -      }
 -}
 -
  static void nvme_resubmit_bios(struct nvme_queue *nvmeq)
  {
        while (bio_list_peek(&nvmeq->sq_cong)) {
@@@ -1293,7 -1269,7 +1293,7 @@@ static int nvme_kthread(void *data
                                spin_lock_irq(&nvmeq->q_lock);
                                if (nvme_process_cq(nvmeq))
                                        printk("process_cq did something\n");
 -                              nvme_timeout_ios(nvmeq);
 +                              nvme_cancel_ios(nvmeq, true);
                                nvme_resubmit_bios(nvmeq);
                                spin_unlock_irq(&nvmeq->q_lock);
                        }
@@@ -1363,9 -1339,6 +1363,9 @@@ static struct nvme_ns *nvme_alloc_ns(st
        ns->disk = disk;
        lbaf = id->flbas & 0xf;
        ns->lba_shift = id->lbaf[lbaf].ds;
 +      blk_queue_logical_block_size(ns->queue, 1 << ns->lba_shift);
 +      if (dev->max_hw_sectors)
 +              blk_queue_max_hw_sectors(ns->queue, dev->max_hw_sectors);
  
        disk->major = nvme_major;
        disk->minors = NVME_MINORS;
@@@ -1410,7 -1383,7 +1410,7 @@@ static int set_queue_count(struct nvme_
  
  static int __devinit nvme_setup_io_queues(struct nvme_dev *dev)
  {
 -      int result, cpu, i, nr_io_queues, db_bar_size;
 +      int result, cpu, i, nr_io_queues, db_bar_size, q_depth;
  
        nr_io_queues = num_online_cpus();
        result = set_queue_count(dev, nr_io_queues);
                cpu = cpumask_next(cpu, cpu_online_mask);
        }
  
 +      q_depth = min_t(int, NVME_CAP_MQES(readq(&dev->bar->cap)) + 1,
 +                                                              NVME_Q_DEPTH);
        for (i = 0; i < nr_io_queues; i++) {
 -              dev->queues[i + 1] = nvme_create_queue(dev, i + 1,
 -                                                      NVME_Q_DEPTH, i);
 +              dev->queues[i + 1] = nvme_create_queue(dev, i + 1, q_depth, i);
                if (IS_ERR(dev->queues[i + 1]))
                        return PTR_ERR(dev->queues[i + 1]);
                dev->queue_count++;
@@@ -1508,10 -1480,6 +1508,10 @@@ static int __devinit nvme_dev_add(struc
        memcpy(dev->serial, ctrl->sn, sizeof(ctrl->sn));
        memcpy(dev->model, ctrl->mn, sizeof(ctrl->mn));
        memcpy(dev->firmware_rev, ctrl->fr, sizeof(ctrl->fr));
 +      if (ctrl->mdts) {
 +              int shift = NVME_CAP_MPSMIN(readq(&dev->bar->cap)) + 12;
 +              dev->max_hw_sectors = 1 << (ctrl->mdts + shift - 9);
 +      }
  
        id_ns = mem;
        for (i = 1; i <= nn; i++) {
@@@ -1555,6 -1523,8 +1555,6 @@@ static int nvme_dev_remove(struct nvme_
        list_del(&dev->node);
        spin_unlock(&dev_list_lock);
  
 -      /* TODO: wait all I/O finished or cancel them */
 -
        list_for_each_entry_safe(ns, next, &dev->namespaces, list) {
                list_del(&ns->list);
                del_gendisk(ns->disk);
@@@ -1590,33 -1560,15 +1590,33 @@@ static void nvme_release_prp_pools(stru
        dma_pool_destroy(dev->prp_small_pool);
  }
  
 -/* XXX: Use an ida or something to let remove / add work correctly */
 -static void nvme_set_instance(struct nvme_dev *dev)
 +static DEFINE_IDA(nvme_instance_ida);
 +
 +static int nvme_set_instance(struct nvme_dev *dev)
  {
 -      static int instance;
 -      dev->instance = instance++;
 +      int instance, error;
 +
 +      do {
 +              if (!ida_pre_get(&nvme_instance_ida, GFP_KERNEL))
 +                      return -ENODEV;
 +
 +              spin_lock(&dev_list_lock);
 +              error = ida_get_new(&nvme_instance_ida, &instance);
 +              spin_unlock(&dev_list_lock);
 +      } while (error == -EAGAIN);
 +
 +      if (error)
 +              return -ENODEV;
 +
 +      dev->instance = instance;
 +      return 0;
  }
  
  static void nvme_release_instance(struct nvme_dev *dev)
  {
 +      spin_lock(&dev_list_lock);
 +      ida_remove(&nvme_instance_ida, dev->instance);
 +      spin_unlock(&dev_list_lock);
  }
  
  static int __devinit nvme_probe(struct pci_dev *pdev,
        pci_set_drvdata(pdev, dev);
        dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
        dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
 -      nvme_set_instance(dev);
 +      result = nvme_set_instance(dev);
 +      if (result)
 +              goto disable;
 +
        dev->entry[0].vector = pdev->irq;
  
        result = nvme_setup_prp_pools(dev);
@@@ -1726,7 -1675,7 +1726,7 @@@ static void __devexit nvme_remove(struc
  #define nvme_suspend NULL
  #define nvme_resume NULL
  
- static struct pci_error_handlers nvme_err_handler = {
+ static const struct pci_error_handlers nvme_err_handler = {
        .error_detected = nvme_error_detected,
        .mmio_enabled   = nvme_dump_registers,
        .link_reset     = nvme_link_reset,
@@@ -1755,17 -1704,15 +1755,17 @@@ static struct pci_driver nvme_driver = 
  
  static int __init nvme_init(void)
  {
 -      int result = -EBUSY;
 +      int result;
  
        nvme_thread = kthread_run(nvme_kthread, NULL, "nvme");
        if (IS_ERR(nvme_thread))
                return PTR_ERR(nvme_thread);
  
 -      nvme_major = register_blkdev(nvme_major, "nvme");
 -      if (nvme_major <= 0)
 +      result = register_blkdev(nvme_major, "nvme");
 +      if (result < 0)
                goto kill_kthread;
 +      else if (result > 0)
 +              nvme_major = result;
  
        result = pci_register_driver(&nvme_driver);
        if (result)
@@@ -8564,7 -8564,7 +8564,7 @@@ bnx2_init_one(struct pci_dev *pdev, con
        return 0;
  
  error:
 -      iounmap(bp->regview);
 +      pci_iounmap(pdev, bp->regview);
        pci_release_regions(pdev);
        pci_disable_device(pdev);
        pci_set_drvdata(pdev, NULL);
@@@ -8742,7 -8742,7 +8742,7 @@@ static void bnx2_io_resume(struct pci_d
        rtnl_unlock();
  }
  
- static struct pci_error_handlers bnx2_err_handler = {
+ static const struct pci_error_handlers bnx2_err_handler = {
        .error_detected = bnx2_io_error_detected,
        .slot_reset     = bnx2_io_slot_reset,
        .resume         = bnx2_io_resume,
@@@ -1162,14 -1162,9 +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;
  }
  
@@@ -6135,8 -6130,7 +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)
@@@ -7561,14 -7555,8 +7555,14 @@@ int bnx2x_set_mac_one(struct bnx2x *bp
        }
  
        rc = bnx2x_config_vlan_mac(bp, &ramrod_param);
 -      if (rc < 0)
 +
 +      if (rc == -EEXIST) {
 +              DP(BNX2X_MSG_SP, "Failed to schedule ADD operations: %d\n", rc);
 +              /* do not treat adding same MAC as error */
 +              rc = 0;
 +      } else if (rc < 0)
                BNX2X_ERR("%s MAC failed\n", (set ? "Set" : "Del"));
 +
        return rc;
  }
  
@@@ -9380,7 -9368,7 +9374,7 @@@ static int __devinit bnx2x_prev_mark_pa
  
  static int __devinit bnx2x_do_flr(struct bnx2x *bp)
  {
-       int i, pos;
+       int i;
        u16 status;
        struct pci_dev *dev = bp->pdev;
  
                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;
        }
@@@ -9831,13 -9815,12 +9821,13 @@@ static void __devinit bnx2x_get_igu_cam
        }
  
  #ifdef CONFIG_PCI_MSI
 -      /*
 -       * It's expected that number of CAM entries for this functions is equal
 -       * to the number evaluated based on the MSI-X table size. We want a
 -       * harsh warning if these values are different!
 +      /* Due to new PF resource allocation by MFW T7.4 and above, it's
 +       * optional that number of CAM entries will not be equal to the value
 +       * advertised in PCI.
 +       * Driver should use the minimal value of both as the actual status
 +       * block count
         */
 -      WARN_ON(bp->igu_sb_cnt != igu_sb_cnt);
 +      bp->igu_sb_cnt = min_t(int, bp->igu_sb_cnt, igu_sb_cnt);
  #endif
  
        if (igu_sb_cnt == 0)
@@@ -10301,11 -10284,13 +10291,11 @@@ static void __devinit bnx2x_get_fcoe_in
                                dev_info.port_hw_config[port].
                                 fcoe_wwn_node_name_lower);
        } else if (!IS_MF_SD(bp)) {
 -              u32 cfg = MF_CFG_RD(bp, func_ext_config[func].func_cfg);
 -
                /*
                 * Read the WWN info only if the FCoE feature is enabled for
                 * this function.
                 */
 -              if (cfg & MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD)
 +              if (BNX2X_MF_EXT_PROTOCOL_FCOE(bp) && !CHIP_IS_E1x(bp))
                        bnx2x_get_ext_wwn_info(bp, func);
  
        } else if (IS_MF_FCOE_SD(bp))
@@@ -11078,14 -11063,7 +11068,14 @@@ static int bnx2x_set_uc_list(struct bnx
        netdev_for_each_uc_addr(ha, dev) {
                rc = bnx2x_set_mac_one(bp, bnx2x_uc_addr(ha), mac_obj, true,
                                       BNX2X_UC_LIST_MAC, &ramrod_flags);
 -              if (rc < 0) {
 +              if (rc == -EEXIST) {
 +                      DP(BNX2X_MSG_SP,
 +                         "Failed to schedule ADD operations: %d\n", rc);
 +                      /* do not treat adding same MAC as error */
 +                      rc = 0;
 +
 +              } else if (rc < 0) {
 +
                        BNX2X_ERR("Failed to schedule ADD operations: %d\n",
                                  rc);
                        return rc;
@@@ -12167,7 -12145,7 +12157,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,
@@@ -192,7 -192,7 +192,7 @@@ static pci_ers_result_t e1000_io_error_
  static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
  static void e1000_io_resume(struct pci_dev *pdev);
  
- 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,
@@@ -3149,17 -3149,6 +3149,17 @@@ static netdev_tx_t e1000_xmit_frame(str
                return NETDEV_TX_OK;
        }
  
 +      /* On PCI/PCI-X HW, if packet size is less than ETH_ZLEN,
 +       * packets may get corrupted during padding by HW.
 +       * To WA this issue, pad all small packets manually.
 +       */
 +      if (skb->len < ETH_ZLEN) {
 +              if (skb_pad(skb, ETH_ZLEN - skb->len))
 +                      return NETDEV_TX_OK;
 +              skb->len = ETH_ZLEN;
 +              skb_set_tail_pointer(skb, ETH_ZLEN);
 +      }
 +
        mss = skb_shinfo(skb)->gso_size;
        /* The controller does a simple calculation to
         * make sure there is enough room in the FIFO before
@@@ -1234,13 -1234,13 +1234,13 @@@ static int mlx4_init_hca(struct mlx4_de
                                mlx4_info(dev, "non-primary physical function, skipping.\n");
                        else
                                mlx4_err(dev, "QUERY_FW command failed, aborting.\n");
 -                      goto unmap_bf;
 +                      return err;
                }
  
                err = mlx4_load_fw(dev);
                if (err) {
                        mlx4_err(dev, "Failed to start FW, aborting.\n");
 -                      goto unmap_bf;
 +                      return err;
                }
  
                mlx4_cfg.log_pg_sz_m = 1;
                err = mlx4_init_slave(dev);
                if (err) {
                        mlx4_err(dev, "Failed to initialize slave\n");
 -                      goto unmap_bf;
 +                      return err;
                }
  
                err = mlx4_slave_cap(dev);
        err = mlx4_QUERY_ADAPTER(dev, &adapter);
        if (err) {
                mlx4_err(dev, "QUERY_ADAPTER command failed, aborting.\n");
 -              goto err_close;
 +              goto unmap_bf;
        }
  
        priv->eq_table.inta_pin = adapter.inta_pin;
  
        return 0;
  
 +unmap_bf:
 +      unmap_bf_area(dev);
 +
  err_close:
        mlx4_close_hca(dev);
  
@@@ -1347,6 -1344,8 +1347,6 @@@ err_stop_fw
                mlx4_UNMAP_FA(dev);
                mlx4_free_icm(dev, priv->fw.fw_icm, 0);
        }
 -unmap_bf:
 -      unmap_bf_area(dev);
        return err;
  }
  
@@@ -1997,8 -1996,7 +1997,8 @@@ static int __mlx4_init_one(struct pci_d
        }
  
  slave_start:
 -      if (mlx4_cmd_init(dev)) {
 +      err = mlx4_cmd_init(dev);
 +      if (err) {
                mlx4_err(dev, "Failed to init command interface, aborting.\n");
                goto err_sriov;
        }
@@@ -2300,7 -2298,7 +2300,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,
  };
@@@ -1378,15 -1378,11 +1378,15 @@@ static void netxen_mask_aer_correctable
        struct pci_dev *root = pdev->bus->self;
        u32 aer_pos;
  
 +      /* root bus? */
 +      if (!root)
 +              return;
 +
        if (adapter->ahw.board_type != NETXEN_BRDTYPE_P3_4_GB_MM &&
                adapter->ahw.board_type != NETXEN_BRDTYPE_P3_10G_TP)
                return;
  
-       if (root->pcie_type != PCI_EXP_TYPE_ROOT_PORT)
+       if (pci_pcie_type(root) != PCI_EXP_TYPE_ROOT_PORT)
                return;
  
        aer_pos = pci_find_ext_capability(root, PCI_EXT_CAP_ID_ERR);
@@@ -3340,7 -3336,7 +3340,7 @@@ netxen_free_vlan_ip_list(struct netxen_
  { }
  #endif
  
- static struct pci_error_handlers netxen_err_handler = {
+ static const struct pci_error_handlers netxen_err_handler = {
        .error_detected = netxen_io_error_detected,
        .slot_reset = netxen_io_slot_reset,
        .resume = netxen_io_resume,
@@@ -675,13 -675,10 +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;
  }
  
@@@ -1442,7 -1439,6 +1439,7 @@@ static int iwl_trans_pcie_start_hw(stru
        return err;
  
  err_free_irq:
 +      trans_pcie->irq_requested = false;
        free_irq(trans_pcie->irq, trans);
  error:
        iwl_free_isr_ict(trans);
diff --combined drivers/scsi/ipr.c
@@@ -192,7 -192,7 +192,7 @@@ static const struct ipr_chip_t ipr_chip
        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
  };
  
 -static int ipr_max_bus_speeds [] = {
 +static int ipr_max_bus_speeds[] = {
        IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
  };
  
@@@ -562,7 -562,7 +562,7 @@@ static void ipr_trc_hook(struct ipr_cmn
        trace_entry->u.add_data = add_data;
  }
  #else
 -#define ipr_trc_hook(ipr_cmd, type, add_data) do { } while(0)
 +#define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
  #endif
  
  /**
@@@ -1002,7 -1002,7 +1002,7 @@@ static void ipr_send_hcam(struct ipr_io
   **/
  static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
  {
 -      switch(proto) {
 +      switch (proto) {
        case IPR_PROTO_SATA:
        case IPR_PROTO_SAS_STP:
                res->ata_class = ATA_DEV_ATA;
@@@ -3043,7 -3043,7 +3043,7 @@@ static void ipr_get_ioa_dump(struct ipr
  }
  
  #else
 -#define ipr_get_ioa_dump(ioa_cfg, dump) do { } while(0)
 +#define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
  #endif
  
  /**
   **/
  static void ipr_release_dump(struct kref *kref)
  {
 -      struct ipr_dump *dump = container_of(kref,struct ipr_dump,kref);
 +      struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
        struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
        unsigned long lock_flags = 0;
        int i;
@@@ -3142,7 -3142,7 +3142,7 @@@ restart
                                break;
                        }
                }
 -      } while(did_work);
 +      } while (did_work);
  
        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
                if (res->add_to_ml) {
@@@ -3268,7 -3268,7 +3268,7 @@@ static ssize_t ipr_show_log_level(struc
   *    number of bytes printed to buffer
   **/
  static ssize_t ipr_store_log_level(struct device *dev,
 -                                 struct device_attribute *attr,
 +                                 struct device_attribute *attr,
                                   const char *buf, size_t count)
  {
        struct Scsi_Host *shost = class_to_shost(dev);
@@@ -3315,7 -3315,7 +3315,7 @@@ static ssize_t ipr_store_diagnostics(st
                return -EACCES;
  
        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
@@@ -3682,7 -3682,7 +3682,7 @@@ static int ipr_update_ioa_ucode(struct 
        unsigned long lock_flags;
  
        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
@@@ -3746,7 -3746,7 +3746,7 @@@ static ssize_t ipr_store_update_fw(stru
        len = snprintf(fname, 99, "%s", buf);
        fname[len-1] = '\0';
  
 -      if(request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
 +      if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
                dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
                return -EIO;
        }
@@@ -4612,7 -4612,7 +4612,7 @@@ static int ipr_slave_alloc(struct scsi_
   * Return value:
   *    SUCCESS / FAILED
   **/
 -static int __ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
 +static int __ipr_eh_host_reset(struct scsi_cmnd *scsi_cmd)
  {
        struct ipr_ioa_cfg *ioa_cfg;
        int rc;
        return rc;
  }
  
 -static int ipr_eh_host_reset(struct scsi_cmnd * cmd)
 +static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
  {
        int rc;
  
@@@ -4701,7 -4701,7 +4701,7 @@@ static int ipr_device_reset(struct ipr_
        }
  
        LEAVE;
 -      return (IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0);
 +      return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
  }
  
  /**
@@@ -4725,7 -4725,7 +4725,7 @@@ static int ipr_sata_reset(struct ata_li
  
        ENTER;
        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
   * Return value:
   *    SUCCESS / FAILED
   **/
 -static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
 +static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
  {
        struct ipr_cmnd *ipr_cmd;
        struct ipr_ioa_cfg *ioa_cfg;
        res->resetting_device = 0;
  
        LEAVE;
 -      return (rc ? FAILED : SUCCESS);
 +      return rc ? FAILED : SUCCESS;
  }
  
 -static int ipr_eh_dev_reset(struct scsi_cmnd * cmd)
 +static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
  {
        int rc;
  
@@@ -4910,7 -4910,7 +4910,7 @@@ static void ipr_abort_timeout(struct ip
   * Return value:
   *    SUCCESS / FAILED
   **/
 -static int ipr_cancel_op(struct scsi_cmnd * scsi_cmd)
 +static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
  {
        struct ipr_cmnd *ipr_cmd;
        struct ipr_ioa_cfg *ioa_cfg;
                res->needs_sync_complete = 1;
  
        LEAVE;
 -      return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
 +      return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
  }
  
  /**
   * Return value:
   *    SUCCESS / FAILED
   **/
 -static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
 +static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
  {
        unsigned long flags;
        int rc;
@@@ -5907,7 -5907,7 +5907,7 @@@ static int ipr_ioctl(struct scsi_devic
   * Return value:
   *    pointer to buffer with description string
   **/
 -static const char * ipr_ioa_info(struct Scsi_Host *host)
 +static const char *ipr_ioa_info(struct Scsi_Host *host)
  {
        static char buffer[512];
        struct ipr_ioa_cfg *ioa_cfg;
@@@ -5965,7 -5965,7 +5965,7 @@@ static void ipr_ata_phy_reset(struct at
  
        ENTER;
        spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
@@@ -6005,7 -6005,7 +6005,7 @@@ static void ipr_ata_post_internal(struc
        unsigned long flags;
  
        spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
@@@ -6330,7 -6330,7 +6330,7 @@@ static int ipr_invalid_adapter(struct i
        int i;
  
        if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) {
 -              for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++){
 +              for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) {
                        if (__is_processor(ipr_blocked_processors[i]))
                                return 1;
                }
@@@ -6608,7 -6608,7 +6608,7 @@@ static void ipr_scsi_bus_speed_limit(st
   *    none
   **/
  static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
 -                                              struct ipr_mode_pages *mode_pages)
 +                                        struct ipr_mode_pages *mode_pages)
  {
        int i, entry_length;
        struct ipr_dev_bus_entry *bus;
@@@ -8022,7 -8022,7 +8022,7 @@@ static void ipr_reset_ioa_job(struct ip
                ipr_reinit_ipr_cmnd(ipr_cmd);
                ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
                rc = ipr_cmd->job_step(ipr_cmd);
 -      } while(rc == IPR_RC_JOB_CONTINUE);
 +      } while (rc == IPR_RC_JOB_CONTINUE);
  }
  
  /**
@@@ -8283,7 -8283,7 +8283,7 @@@ static void ipr_free_cmd_blks(struct ip
        }
  
        if (ioa_cfg->ipr_cmd_pool)
 -              pci_pool_destroy (ioa_cfg->ipr_cmd_pool);
 +              pci_pool_destroy(ioa_cfg->ipr_cmd_pool);
  
        kfree(ioa_cfg->ipr_cmnd_list);
        kfree(ioa_cfg->ipr_cmnd_list_dma);
@@@ -8363,8 -8363,8 +8363,8 @@@ static int __devinit ipr_alloc_cmd_blks
        dma_addr_t dma_addr;
        int i;
  
 -      ioa_cfg->ipr_cmd_pool = pci_pool_create (IPR_NAME, ioa_cfg->pdev,
 -                                               sizeof(struct ipr_cmnd), 512, 0);
 +      ioa_cfg->ipr_cmd_pool = pci_pool_create(IPR_NAME, ioa_cfg->pdev,
 +                                              sizeof(struct ipr_cmnd), 512, 0);
  
        if (!ioa_cfg->ipr_cmd_pool)
                return -ENOMEM;
        }
  
        for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
 -              ipr_cmd = pci_pool_alloc (ioa_cfg->ipr_cmd_pool, GFP_KERNEL, &dma_addr);
 +              ipr_cmd = pci_pool_alloc(ioa_cfg->ipr_cmd_pool, GFP_KERNEL, &dma_addr);
  
                if (!ipr_cmd) {
                        ipr_free_cmd_blks(ioa_cfg);
@@@ -8964,7 -8964,7 +8964,7 @@@ static void ipr_scan_vsets(struct ipr_i
        int target, lun;
  
        for (target = 0; target < IPR_MAX_NUM_TARGETS_PER_BUS; target++)
 -              for (lun = 0; lun < IPR_MAX_NUM_VSET_LUNS_PER_TARGET; lun++ )
 +              for (lun = 0; lun < IPR_MAX_NUM_VSET_LUNS_PER_TARGET; lun++)
                        scsi_add_device(ioa_cfg->host, IPR_VSET_BUS, target, lun);
  }
  
@@@ -9010,7 -9010,7 +9010,7 @@@ static void __ipr_remove(struct pci_de
        ENTER;
  
        spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
@@@ -9139,7 -9139,7 +9139,7 @@@ static void ipr_shutdown(struct pci_de
        unsigned long lock_flags = 0;
  
        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 -      while(ioa_cfg->in_reset_reload) {
 +      while (ioa_cfg->in_reset_reload) {
                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
@@@ -9228,7 -9228,7 +9228,7 @@@ static struct pci_device_id ipr_pci_tab
  };
  MODULE_DEVICE_TABLE(pci, ipr_pci_table);
  
- static struct pci_error_handlers ipr_err_handler = {
+ static const struct pci_error_handlers ipr_err_handler = {
        .error_detected = ipr_pci_error_detected,
        .slot_reset = ipr_pci_slot_reset,
  };
@@@ -6607,7 -6607,7 +6607,7 @@@ out_error
   * we just use some constant number as place holder.
   *
   * Return codes
 - *      0 - sucessful
 + *      0 - successful
   *      -ENOMEM - No availble memory
   *      -EIO - The mailbox failed to complete successfully.
   **/
@@@ -10425,7 -10425,7 +10425,7 @@@ static struct pci_device_id lpfc_id_tab
  
  MODULE_DEVICE_TABLE(pci, lpfc_id_table);
  
- static struct pci_error_handlers lpfc_err_handler = {
+ static const struct pci_error_handlers lpfc_err_handler = {
        .error_detected = lpfc_io_error_detected,
        .slot_reset = lpfc_io_slot_reset,
        .resume = lpfc_io_resume,
@@@ -803,7 -803,7 +803,7 @@@ static void qla4xxx_conn_get_stats(stru
                                     iscsi_stats_dma);
        if (ret != QLA_SUCCESS) {
                ql4_printk(KERN_ERR, ha,
 -                         "Unable to retreive iscsi stats\n");
 +                         "Unable to retrieve iscsi stats\n");
                goto free_stats;
        }
  
@@@ -4338,7 -4338,7 +4338,7 @@@ static int qla4xxx_compare_tuple_ddb(st
                return QLA_ERROR;
  
        /* For multi sessions, driver generates the ISID, so do not compare
 -       * ISID in reset path since it would be a comparision between the
 +       * ISID in reset path since it would be a comparison between the
         * driver generated ISID and firmware generated ISID. This could
         * lead to adding duplicated DDBs in the list as driver generated
         * ISID would not match firmware generated ISID.
@@@ -5326,7 -5326,7 +5326,7 @@@ static void qla4xxx_destroy_fw_ddb_sess
        }
  }
  /**
 - * qla4xxx_remove_adapter - calback function to remove adapter.
 + * qla4xxx_remove_adapter - callback function to remove adapter.
   * @pci_dev: PCI device pointer
   **/
  static void __devexit qla4xxx_remove_adapter(struct pci_dev *pdev)
@@@ -6148,7 -6148,7 +6148,7 @@@ qla4xxx_pci_resume(struct pci_dev *pdev
        clear_bit(AF_EEH_BUSY, &ha->flags);
  }
  
- static struct pci_error_handlers qla4xxx_err_handler = {
+ static const struct pci_error_handlers qla4xxx_err_handler = {
        .error_detected = qla4xxx_pci_error_detected,
        .mmio_enabled = qla4xxx_pci_mmio_enabled,
        .slot_reset = qla4xxx_pci_slot_reset,