void nautilus_kill_arch(int mode) { struct pci_bus *bus = pci_isa_hose->bus; u32 pmuport; int off; switch (mode) { case LINUX_REBOOT_CMD_RESTART: if (! alpha_using_srm) { u8 t8; pci_bus_read_config_byte(bus, 0x38, 0x43, &t8); pci_bus_write_config_byte(bus, 0x38, 0x43, t8 | 0x80); outb(1, 0x92); outb(0, 0x92); /* NOTREACHED */ } break; case LINUX_REBOOT_CMD_POWER_OFF: /* Assume M1543C */ off = 0x2000; /* SLP_TYPE = 0, SLP_EN = 1 */ pci_bus_read_config_dword(bus, 0x88, 0x10, &pmuport); if (!pmuport) { /* M1535D/D+ */ off = 0x3400; /* SLP_TYPE = 5, SLP_EN = 1 */ pci_bus_read_config_dword(bus, 0x88, 0xe0, &pmuport); } pmuport &= 0xfffe; outw(0xffff, pmuport); /* Clear pending events. */ outw(off, pmuport + 4); /* NOTREACHED */ break; } }
void nautilus_kill_arch(int mode) { struct pci_bus *bus = pci_isa_hose->bus; u32 pmuport; int off; switch (mode) { case LINUX_REBOOT_CMD_RESTART: if (! alpha_using_srm) { u8 t8; pci_bus_read_config_byte(bus, 0x38, 0x43, &t8); pci_bus_write_config_byte(bus, 0x38, 0x43, t8 | 0x80); outb(1, 0x92); outb(0, 0x92); /* */ } break; case LINUX_REBOOT_CMD_POWER_OFF: /* */ off = 0x2000; /* */ pci_bus_read_config_dword(bus, 0x88, 0x10, &pmuport); if (!pmuport) { /* */ off = 0x3400; /* */ pci_bus_read_config_dword(bus, 0x88, 0xe0, &pmuport); } pmuport &= 0xfffe; outw(0xffff, pmuport); /* */ outw(off, pmuport + 4); /* */ break; } }
/** * i915_stolen_to_phys - take an offset into stolen memory and turn it into * a physical one * @dev: drm device * @offset: address to translate * * Some chip functions require allocations from stolen space and need the * physical address of the memory in question. */ static unsigned long i915_stolen_to_phys(struct drm_device *dev, u32 offset) { struct drm_i915_private *dev_priv = dev->dev_private; struct pci_dev *pdev = dev_priv->bridge_dev; u32 base; #if 0 /* On the machines I have tested the Graphics Base of Stolen Memory * is unreliable, so compute the base by subtracting the stolen memory * from the Top of Low Usable DRAM which is where the BIOS places * the graphics stolen memory. */ if (INTEL_INFO(dev)->gen > 3 || IS_G33(dev)) { /* top 32bits are reserved = 0 */ pci_read_config_dword(pdev, 0xA4, &base); } else { /* XXX presume 8xx is the same as i915 */ pci_bus_read_config_dword(pdev->bus, 2, 0x5C, &base); } #else if (INTEL_INFO(dev)->gen > 3 || IS_G33(dev)) { u16 val; pci_read_config_word(pdev, 0xb0, &val); base = val >> 4 << 20; } else {
/** * imx_pcie_ep_probe - Device Initialization Routine * @pdev: PCI device information struct * @id: entry in id_tbl * * Returns 0 on success, negative on failure **/ static int imx_pcie_ep_probe(struct pci_dev *pdev, const struct pci_device_id *id) { int ret = 0; struct device *dev = &pdev->dev; struct imx_pcie_ep_priv *priv; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) { dev_err(dev, "can't alloc imx pcie priv\n"); return -ENOMEM; } priv->pci_dev = pdev; if (pci_enable_device(pdev)) { ret = -ENODEV; goto out; } pci_set_master(pdev); pci_set_drvdata(pdev, priv); priv->hw_base = pci_iomap(pdev, 0, 0); if (!priv->hw_base) { ret = -ENODEV; goto out; } pr_info("pci_resource_len = 0x%08llx\n", (unsigned long long) pci_resource_len(pdev, 0)); pr_info("pci_resource_base = %p\n", priv->hw_base); ret = pci_enable_msi(priv->pci_dev); if (ret < 0) { dev_err(dev, "can't enable msi\n"); return ret; } /* * Force to use 0x01FF8000 as the MSI address, * to do the MSI demo */ pci_bus_write_config_dword(pdev->bus, 0, 0x54, 0x01FF8000); pci_bus_write_config_dword(pdev->bus->parent, 0, 0x820, 0x01FF8000); /* configure rc's msi cap */ pci_bus_read_config_dword(pdev->bus->parent, 0, 0x50, &ret); ret |= (PCI_MSI_FLAGS_ENABLE << 16); pci_bus_write_config_dword(pdev->bus->parent, 0, 0x50, ret); pci_bus_write_config_dword(pdev->bus->parent, 0, 0x828, 0x1); pci_bus_write_config_dword(pdev->bus->parent, 0, 0x82C, 0xFFFFFFFE); return 0; out: return ret; }
int pci_read_config_dword(const struct pci_dev *dev, int where, u32 *val) { if (pci_dev_is_disconnected(dev)) { *val = ~0; return PCIBIOS_DEVICE_NOT_FOUND; } return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val); }
static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus) { u8 hdr_type; u32 link_ctrl; u16 pos, link_status; int link_is_active = 0; /* make sure we are not in EP mode */ pci_bus_read_config_byte(bus, 0, PCI_HEADER_TYPE, &hdr_type); if ((hdr_type & 0x7f) != PCI_HEADER_TYPE_BRIDGE) { dev_err(pcie->dev, "in EP mode, hdr=%#02x\n", hdr_type); return -EFAULT; } /* force class to PCI_CLASS_BRIDGE_PCI (0x0604) */ pci_bus_write_config_word(bus, 0, PCI_CLASS_DEVICE, PCI_CLASS_BRIDGE_PCI); /* check link status to see if link is active */ pos = pci_bus_find_capability(bus, 0, PCI_CAP_ID_EXP); pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status); if (link_status & PCI_EXP_LNKSTA_NLW) link_is_active = 1; if (!link_is_active) { /* try GEN 1 link speed */ #define PCI_LINK_STATUS_CTRL_2_OFFSET 0x0dc #define PCI_TARGET_LINK_SPEED_MASK 0xf #define PCI_TARGET_LINK_SPEED_GEN2 0x2 #define PCI_TARGET_LINK_SPEED_GEN1 0x1 pci_bus_read_config_dword(bus, 0, PCI_LINK_STATUS_CTRL_2_OFFSET, &link_ctrl); if ((link_ctrl & PCI_TARGET_LINK_SPEED_MASK) == PCI_TARGET_LINK_SPEED_GEN2) { link_ctrl &= ~PCI_TARGET_LINK_SPEED_MASK; link_ctrl |= PCI_TARGET_LINK_SPEED_GEN1; pci_bus_write_config_dword(bus, 0, PCI_LINK_STATUS_CTRL_2_OFFSET, link_ctrl); msleep(100); pos = pci_bus_find_capability(bus, 0, PCI_CAP_ID_EXP); pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status); if (link_status & PCI_EXP_LNKSTA_NLW) link_is_active = 1; } } dev_info(pcie->dev, "link: %s\n", link_is_active ? "UP" : "DOWN"); return link_is_active ? 0 : -ENODEV; }
static ssize_t show_power(struct device *dev, struct device_attribute *attr, char *buf) { u32 val, tdp_limit, running_avg_range; s32 running_avg_capture; u64 curr_pwr_watts; struct fam15h_power_data *data = dev_get_drvdata(dev); struct pci_dev *f4 = data->pdev; pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), REG_TDP_RUNNING_AVERAGE, &val); /* * On Carrizo and later platforms, TdpRunAvgAccCap bit field * is extended to 4:31 from 4:25. */ if (is_carrizo_or_later()) { running_avg_capture = val >> 4; running_avg_capture = sign_extend32(running_avg_capture, 27); } else {
/* allocate mem/pmem/io resource to a new function */ static int init_config_space (struct acpiphp_func *func) { u32 bar, len; u32 address[] = { PCI_BASE_ADDRESS_0, PCI_BASE_ADDRESS_1, PCI_BASE_ADDRESS_2, PCI_BASE_ADDRESS_3, PCI_BASE_ADDRESS_4, PCI_BASE_ADDRESS_5, 0 }; int count; struct acpiphp_bridge *bridge; struct pci_resource *res; struct pci_bus *pbus; int bus, device, function; unsigned int devfn; u16 tmp; bridge = func->slot->bridge; pbus = bridge->pci_bus; bus = bridge->bus; device = func->slot->device; function = func->function; devfn = PCI_DEVFN(device, function); for (count = 0; address[count]; count++) { /* for 6 BARs */ pci_bus_write_config_dword(pbus, devfn, address[count], 0xFFFFFFFF); pci_bus_read_config_dword(pbus, devfn, address[count], &bar); if (!bar) /* This BAR is not implemented */ continue; dbg("Device %02x.%02x BAR %d wants %x\n", device, function, count, bar); if (bar & PCI_BASE_ADDRESS_SPACE_IO) { /* This is IO */ len = bar & 0xFFFFFFFC; len = ~len + 1; dbg("len in IO %x, BAR %d\n", len, count); spin_lock(&bridge->res_lock); res = acpiphp_get_io_resource(&bridge->io_head, len); spin_unlock(&bridge->res_lock); if (!res) { err("cannot allocate requested io for %02x:%02x.%d len %x\n", bus, device, function, len); return -1; } pci_bus_write_config_dword(pbus, devfn, address[count], (u32)res->base); res->next = func->io_head; func->io_head = res; } else { /* This is Memory */ if (bar & PCI_BASE_ADDRESS_MEM_PREFETCH) { /* pfmem */ len = bar & 0xFFFFFFF0; len = ~len + 1; dbg("len in PFMEM %x, BAR %d\n", len, count); spin_lock(&bridge->res_lock); res = acpiphp_get_resource(&bridge->p_mem_head, len); spin_unlock(&bridge->res_lock); if (!res) { err("cannot allocate requested pfmem for %02x:%02x.%d len %x\n", bus, device, function, len); return -1; } pci_bus_write_config_dword(pbus, devfn, address[count], (u32)res->base); if (bar & PCI_BASE_ADDRESS_MEM_TYPE_64) { /* takes up another dword */ dbg("inside the pfmem 64 case, count %d\n", count); count += 1; pci_bus_write_config_dword(pbus, devfn, address[count], (u32)(res->base >> 32)); } res->next = func->p_mem_head; func->p_mem_head = res; } else {
static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus) { struct device *dev = pcie->dev; u8 hdr_type; u32 link_ctrl, class, val; u16 pos = PCI_EXP_CAP, link_status; bool link_is_active = false; /* * PAXC connects to emulated endpoint devices directly and does not * have a Serdes. Therefore skip the link detection logic here. */ if (pcie->type == IPROC_PCIE_PAXC) return 0; val = iproc_pcie_read_reg(pcie, IPROC_PCIE_LINK_STATUS); if (!(val & PCIE_PHYLINKUP) || !(val & PCIE_DL_ACTIVE)) { dev_err(dev, "PHY or data link is INACTIVE!\n"); return -ENODEV; } /* make sure we are not in EP mode */ pci_bus_read_config_byte(bus, 0, PCI_HEADER_TYPE, &hdr_type); if ((hdr_type & 0x7f) != PCI_HEADER_TYPE_BRIDGE) { dev_err(dev, "in EP mode, hdr=%#02x\n", hdr_type); return -EFAULT; } /* force class to PCI_CLASS_BRIDGE_PCI (0x0604) */ #define PCI_BRIDGE_CTRL_REG_OFFSET 0x43c #define PCI_CLASS_BRIDGE_MASK 0xffff00 #define PCI_CLASS_BRIDGE_SHIFT 8 pci_bus_read_config_dword(bus, 0, PCI_BRIDGE_CTRL_REG_OFFSET, &class); class &= ~PCI_CLASS_BRIDGE_MASK; class |= (PCI_CLASS_BRIDGE_PCI << PCI_CLASS_BRIDGE_SHIFT); pci_bus_write_config_dword(bus, 0, PCI_BRIDGE_CTRL_REG_OFFSET, class); /* check link status to see if link is active */ pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status); if (link_status & PCI_EXP_LNKSTA_NLW) link_is_active = true; if (!link_is_active) { /* try GEN 1 link speed */ #define PCI_TARGET_LINK_SPEED_MASK 0xf #define PCI_TARGET_LINK_SPEED_GEN2 0x2 #define PCI_TARGET_LINK_SPEED_GEN1 0x1 pci_bus_read_config_dword(bus, 0, pos + PCI_EXP_LNKCTL2, &link_ctrl); if ((link_ctrl & PCI_TARGET_LINK_SPEED_MASK) == PCI_TARGET_LINK_SPEED_GEN2) { link_ctrl &= ~PCI_TARGET_LINK_SPEED_MASK; link_ctrl |= PCI_TARGET_LINK_SPEED_GEN1; pci_bus_write_config_dword(bus, 0, pos + PCI_EXP_LNKCTL2, link_ctrl); msleep(100); pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status); if (link_status & PCI_EXP_LNKSTA_NLW) link_is_active = true; } } dev_info(dev, "link: %s\n", link_is_active ? "UP" : "DOWN"); return link_is_active ? 0 : -ENODEV; }
static int iproc_pcie_check_link(struct iproc_pcie *pcie, struct pci_bus *bus) { u8 hdr_type; u32 link_ctrl, class, val; u16 pos, link_status; bool link_is_active = false; val = readl(pcie->base + PCIE_LINK_STATUS_OFFSET); if (!(val & PCIE_PHYLINKUP) || !(val & PCIE_DL_ACTIVE)) { dev_err(pcie->dev, "PHY or data link is INACTIVE!\n"); return -ENODEV; } /* make sure we are not in EP mode */ pci_bus_read_config_byte(bus, 0, PCI_HEADER_TYPE, &hdr_type); if ((hdr_type & 0x7f) != PCI_HEADER_TYPE_BRIDGE) { dev_err(pcie->dev, "in EP mode, hdr=%#02x\n", hdr_type); return -EFAULT; } /* force class to PCI_CLASS_BRIDGE_PCI (0x0604) */ #define PCI_BRIDGE_CTRL_REG_OFFSET 0x43c #define PCI_CLASS_BRIDGE_MASK 0xffff00 #define PCI_CLASS_BRIDGE_SHIFT 8 pci_bus_read_config_dword(bus, 0, PCI_BRIDGE_CTRL_REG_OFFSET, &class); class &= ~PCI_CLASS_BRIDGE_MASK; class |= (PCI_CLASS_BRIDGE_PCI << PCI_CLASS_BRIDGE_SHIFT); pci_bus_write_config_dword(bus, 0, PCI_BRIDGE_CTRL_REG_OFFSET, class); /* check link status to see if link is active */ pos = pci_bus_find_capability(bus, 0, PCI_CAP_ID_EXP); pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status); if (link_status & PCI_EXP_LNKSTA_NLW) link_is_active = true; if (!link_is_active) { /* try GEN 1 link speed */ #define PCI_LINK_STATUS_CTRL_2_OFFSET 0x0dc #define PCI_TARGET_LINK_SPEED_MASK 0xf #define PCI_TARGET_LINK_SPEED_GEN2 0x2 #define PCI_TARGET_LINK_SPEED_GEN1 0x1 pci_bus_read_config_dword(bus, 0, PCI_LINK_STATUS_CTRL_2_OFFSET, &link_ctrl); if ((link_ctrl & PCI_TARGET_LINK_SPEED_MASK) == PCI_TARGET_LINK_SPEED_GEN2) { link_ctrl &= ~PCI_TARGET_LINK_SPEED_MASK; link_ctrl |= PCI_TARGET_LINK_SPEED_GEN1; pci_bus_write_config_dword(bus, 0, PCI_LINK_STATUS_CTRL_2_OFFSET, link_ctrl); msleep(100); pos = pci_bus_find_capability(bus, 0, PCI_CAP_ID_EXP); pci_bus_read_config_word(bus, 0, pos + PCI_EXP_LNKSTA, &link_status); if (link_status & PCI_EXP_LNKSTA_NLW) link_is_active = true; } } dev_info(pcie->dev, "link: %s\n", link_is_active ? "UP" : "DOWN"); return link_is_active ? 0 : -ENODEV; }