/* * Do PCIe cleanup, after chip-specific cleanup, etc. Just prior * to releasing the dd memory. * void because none of the core pcie cleanup returns are void */ void qib_pcie_ddcleanup(struct qib_devdata *dd) { u64 __iomem *base = (void __iomem *) dd->kregbase; qib_cdbg(VERBOSE, "Unmapping kregbase %p\n", dd->kregbase); dd->kregbase = NULL; iounmap(base); if (dd->piobase) { qib_cdbg(VERBOSE, "Unmapping piobase %p\n", dd->piobase); iounmap(dd->piobase); } if (dd->userbase) { qib_cdbg(VERBOSE, "Unmapping userbase %p\n", dd->userbase); iounmap(dd->userbase); } if (dd->piovl15base) { qib_cdbg(VERBOSE, "Unmapping vl15base %p\n", dd->piovl15base); iounmap(dd->piovl15base); } qib_cdbg(VERBOSE, "calling pci_disable_device\n"); pci_disable_device(dd->pcidev); pci_release_regions(dd->pcidev); pci_set_drvdata(dd->pcidev, NULL); }
/* * Setup pcie interrupt stuff again after a reset. I'd like to just call * pci_enable_msi() again for msi, but when I do that, * the MSI enable bit doesn't get set in the command word, and * we switch to to a different interrupt vector, which is confusing, * so I instead just do it all inline. Perhaps somehow can tie this * into the PCIe hotplug support at some point */ int qib_reinit_intr(struct qib_devdata *dd) { int pos; u16 control; int ret = 0; if (!dd->msi_lo) /* we weren't using MSI, so don't restore it */ goto bail; #ifdef CONFIG_PCI_MSI pos = pci_find_capability(dd->pcidev, PCI_CAP_ID_MSI); if (!pos) { qib_dev_err(dd, "Can't find MSI capability, " "can't restore MSI settings\n"); ret = 0; /* nothing special for MSIx, just MSI */ goto bail; } qib_cdbg(VERBOSE, "Writing msi_lo 0x%x to config offset 0x%x\n", dd->msi_lo, pos + PCI_MSI_ADDRESS_LO); pci_write_config_dword(dd->pcidev, pos + PCI_MSI_ADDRESS_LO, dd->msi_lo); qib_cdbg(VERBOSE, "Writing msi_lo 0x%x to config offset 0x%x\n", dd->msi_hi, pos + PCI_MSI_ADDRESS_HI); pci_write_config_dword(dd->pcidev, pos + PCI_MSI_ADDRESS_HI, dd->msi_hi); pci_read_config_word(dd->pcidev, pos + PCI_MSI_FLAGS, &control); if (!(control & PCI_MSI_FLAGS_ENABLE)) { qib_cdbg(INIT, "MSI control at off %x was %x, " "setting MSI enable (%x)\n", pos + PCI_MSI_FLAGS, control, control | PCI_MSI_FLAGS_ENABLE); control |= PCI_MSI_FLAGS_ENABLE; pci_write_config_word(dd->pcidev, pos + PCI_MSI_FLAGS, control); } /* now rewrite the data (vector) info */ pci_write_config_word(dd->pcidev, pos + ((control & PCI_MSI_FLAGS_64BIT) ? 12 : 8), dd->msi_data); ret = 1; #endif /* CONFIG_PCI_MSI */ bail: if (!ret && (dd->flags & QIB_HAS_INTX)) { qib_cdbg(INIT, "Using INTx, MSI disabled or not configured\n"); qib_enable_intx(dd->pcidev); ret = 1; } /* and now set the pci master bit again */ pci_set_master(dd->pcidev); return ret; }
/* * Same as qib_nosmi, but for MSIx. */ void qib_nomsix(struct qib_devdata *dd) { #ifdef CONFIG_PCI_MSI qib_cdbg(INIT, "disable device MSIx interrupts\n"); pci_disable_msix(dd->pcidev); #endif }
/** * We save the msi lo and hi values, so we can restore them after * chip reset (the kernel PCI infrastructure doesn't yet handle that * correctly. */ static int qib_msi_setup(struct qib_devdata *dd, int pos) { struct pci_dev *pdev = dd->pcidev; u16 control; int ret; ret = pci_enable_msi(pdev); if (ret) qib_dev_err(dd, "pci_enable_msi failed: %d, " "interrupts may not work\n", ret); /* continue even if it fails, we may still be OK... */ pci_read_config_dword(pdev, pos + PCI_MSI_ADDRESS_LO, &dd->msi_lo); pci_read_config_dword(pdev, pos + PCI_MSI_ADDRESS_HI, &dd->msi_hi); pci_read_config_word(pdev, pos + PCI_MSI_FLAGS, &control); /* now save the data (vector) info */ pci_read_config_word(pdev, pos + ((control & PCI_MSI_FLAGS_64BIT) ? 12 : 8), &dd->msi_data); qib_cdbg(VERBOSE, "Read msi data 0x%x from config offset " "0x%x, control=0x%x\n", dd->msi_data, pos + ((control & PCI_MSI_FLAGS_64BIT) ? 12 : 8), control); return ret; }
/* * Do remaining PCIe setup, once dd is allocated, and save away * fields required to re-initialize after a chip reset, or for * various other purposes */ int qib_pcie_ddinit(struct qib_devdata *dd, struct pci_dev *pdev, const struct pci_device_id *ent) { unsigned long len; resource_size_t addr; dd->pcidev = pdev; pci_set_drvdata(pdev, dd); addr = pci_resource_start(pdev, 0); len = pci_resource_len(pdev, 0); qib_cdbg(VERBOSE, "regbase (0) %llx len %ld vend %x/%x " "driver_data %p\n", (unsigned long long)addr, len, ent->vendor, ent->device, pci_get_drvdata(pdev)); #if defined(__powerpc__) /* There isn't a generic way to specify writethrough mappings */ dd->kregbase = __ioremap(addr, len, _PAGE_NO_CACHE | _PAGE_WRITETHRU); #else dd->kregbase = ioremap_nocache(addr, len); #endif if (!dd->kregbase) { qib_dbg("Unable to map io addr %llx to kvirt, failing\n", (unsigned long long)addr); return -ENOMEM; } dd->kregend = (u64 __iomem *)((void __iomem *) dd->kregbase + len); dd->physaddr = addr; /* used for io_remap, etc. */ /* for user mmap */ qib_cdbg(VERBOSE, "mapped io addr %llx to kregbase %p through %p\n", (unsigned long long)addr, dd->kregbase, dd->kregend); /* * Save BARs to rewrite after device reset. Save all 64 bits of * BAR, just in case. */ dd->pcibar0 = addr; dd->pcibar1 = addr >> 32; dd->deviceid = ent->device; /* save for later use */ dd->vendorid = ent->vendor; return 0; }
static void __qib_release_user_pages(struct page **p, size_t num_pages, int dirty) { size_t i; for (i = 0; i < num_pages; i++) { qib_cdbg(MM, "%lu/%lu put_page %p\n", (unsigned long) i, (unsigned long) num_pages, p[i]); if (dirty) set_page_dirty_lock(p[i]); put_page(p[i]); } }
/* * Call with current->mm->mmap_sem held. */ static int __get_user_pages(unsigned long start_page, size_t num_pages, struct page **p, struct vm_area_struct **vma) { unsigned long lock_limit; size_t got; int ret; #ifdef __LWK__ lock_limit = ULONG_MAX; #else lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur >> PAGE_SHIFT; #endif if (num_pages > lock_limit) { ret = -ENOMEM; goto bail; } qib_cdbg(VERBOSE, "pin %lx pages from vaddr %lx\n", (unsigned long) num_pages, start_page); for (got = 0; got < num_pages; got += ret) { ret = get_user_pages(current, current->mm, start_page + got * PAGE_SIZE, num_pages - got, 1, 1, p + got, vma); if (ret < 0) goto bail_release; } current->mm->locked_vm += num_pages; ret = 0; goto bail; bail_release: __qib_release_user_pages(p, got, 0); bail: return ret; }
static int qsfp_read(struct qib_pportdata *ppd, int addr, void *bp, int len) { struct qib_devdata *dd = ppd->dd; u32 out, mask; int ret, cnt, pass = 0; int stuck = 0; u8 *buff = bp; qib_cdbg(VERBOSE, "Grabbing Mutex for QSFP in %d:%d\n", dd->unit, ppd->port); ret = mutex_lock_interruptible(&dd->eep_lock); if (ret) goto no_unlock; if (dd->twsi_eeprom_dev == QIB_TWSI_NO_DEV) { qib_dbg("QSFP read on board without QSFP\n"); ret = -ENXIO; goto bail; } /* * We presume, if we are called at all, that this board has * QSFP. This is on the same i2c chain as the legacy parts, * but only responds if the module is selected via GPIO pins. * Further, there are very long setup and hold requirements * on MODSEL. */ mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE; out = QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE; if (ppd->hw_pidx) { mask <<= QSFP_GPIO_PORT2_SHIFT; out <<= QSFP_GPIO_PORT2_SHIFT; } dd->f_gpio_mod(dd, out, mask, mask); /* * Module could take up to 2 Msec to respond to MOD_SEL, and there * is no way to tell if it is ready, so we must wait. */ msleep(2); /* Make sure TWSI bus is in sane state. */ ret = qib_twsi_reset(dd); if (ret) { qib_dev_porterr(dd, ppd->port, "QSFP interface Reset for read failed\n"); ret = -EIO; stuck = 1; goto deselect; } /* All QSFP modules are at A0 */ cnt = 0; while (cnt < len) { unsigned in_page; int wlen = len - cnt; in_page = addr % QSFP_PAGESIZE; if ((in_page + wlen) > QSFP_PAGESIZE) wlen = QSFP_PAGESIZE - in_page; ret = qib_twsi_blk_rd(dd, QSFP_DEV, addr, buff + cnt, wlen); /* Some QSFP's fail first try. Retry as experiment */ if (ret && cnt == 0 && ++pass < QSFP_MAX_RETRY) continue; if (ret) { /* qib_twsi_blk_rd() 1 for error, else 0 */ ret = -EIO; goto deselect; } addr += wlen; cnt += wlen; } ret = cnt; deselect: /* * Module could take up to 10 uSec after transfer before * ready to respond to MOD_SEL negation, and there is no way * to tell if it is ready, so we must wait. */ udelay(10); /* set QSFP MODSEL, RST. LP all high */ dd->f_gpio_mod(dd, mask, mask, mask); /* * Module could take up to 2 Msec to respond to MOD_SEL * going away, and there is no way to tell if it is ready. * so we must wait. */ if (stuck) qib_dev_err(dd, "QSFP interface bus stuck non-idle\n"); if (pass >= QSFP_MAX_RETRY && ret) qib_dev_porterr(dd, ppd->port, "QSFP failed even retrying\n"); else if (pass) qib_dev_porterr(dd, ppd->port, "QSFP retries: %d\n", pass); msleep(2); bail: mutex_unlock(&dd->eep_lock); qib_cdbg(VERBOSE, "Released Mutex for QSFP %d:%d, ret %d\n", dd->unit, ppd->port, ret); no_unlock: return ret; }
int qib_pcie_params(struct qib_devdata *dd, u32 minw, u32 *nent, struct msix_entry *entry) { u16 linkstat, speed; int pos = 0, pose, ret = 1; pose = pci_find_capability(dd->pcidev, PCI_CAP_ID_EXP); if (!pose) { qib_dev_err(dd, "Can't find PCI Express capability!\n"); /* set up something... */ dd->lbus_width = 1; dd->lbus_speed = 2500; /* Gen1, 2.5GHz */ goto bail; } #ifdef CONFIG_PCI_MSI pos = pci_find_capability(dd->pcidev, PCI_CAP_ID_MSIX); if (nent && *nent && pos) { qib_msix_setup(dd, pos, nent, entry); ret = 0; /* did it, either MSIx or INTx */ } else { pos = pci_find_capability(dd->pcidev, PCI_CAP_ID_MSI); if (pos) ret = qib_msi_setup(dd, pos); else qib_dev_err(dd, "No PCI MSI or MSIx capability!\n"); } #else ret = 0; /* no MSI or MSIx support; OK */ #endif /* CONFIG_PCI_MSI */ if (!pos) qib_enable_intx(dd->pcidev); pci_read_config_word(dd->pcidev, pose + PCI_EXP_LNKSTA, &linkstat); /* * speed is bits 0-3, linkwidth is bits 4-8 * no defines for them in headers */ speed = linkstat & 0xf; linkstat >>= 4; linkstat &= 0x1f; dd->lbus_width = linkstat; switch (speed) { case 1: dd->lbus_speed = 2500; /* Gen1, 2.5GHz */ break; case 2: dd->lbus_speed = 5000; /* Gen1, 5GHz */ break; default: /* not defined, assume gen1 */ qib_dbg("PCIe unexpected link speed %u\n", speed); dd->lbus_speed = 2500; break; } /* * check against expected pcie width and complain if "wrong" * on first initialization, not afterwards (i.e., reset). */ if (minw && linkstat < minw) qib_dev_err(dd, "PCIe width %u (x%u HCA), performance reduced\n", linkstat, minw); else qib_cdbg(VERBOSE, "PCIe speed %u width %u (x8 HCA)\n", dd->lbus_speed, linkstat); qib_tune_pcie_caps(dd); qib_tune_pcie_coalesce(dd); bail: /* fill in string, even on errors */ snprintf(dd->lbus_info, sizeof(dd->lbus_info), "PCIe,%uMHz,x%u\n", dd->lbus_speed, dd->lbus_width); return ret; }