mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 18:51:56 -04:00
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
Merge the BIOS workarounds from 2.6.32, and the swiotlb fallback on failure.
This commit is contained in:
David Woodhouse
commit
ec20849193
3916 changed files with 177608 additions and 77063 deletions
|
|
@ -175,15 +175,6 @@ dmar_parse_one_drhd(struct acpi_dmar_header *header)
|
|||
int ret = 0;
|
||||
|
||||
drhd = (struct acpi_dmar_hardware_unit *)header;
|
||||
if (!drhd->address) {
|
||||
/* Promote an attitude of violence to a BIOS engineer today */
|
||||
WARN(1, "Your BIOS is broken; DMAR reported at address zero!\n"
|
||||
"BIOS vendor: %s; Ver: %s; Product Version: %s\n",
|
||||
dmi_get_system_info(DMI_BIOS_VENDOR),
|
||||
dmi_get_system_info(DMI_BIOS_VERSION),
|
||||
dmi_get_system_info(DMI_PRODUCT_VERSION));
|
||||
return -ENODEV;
|
||||
}
|
||||
dmaru = kzalloc(sizeof(*dmaru), GFP_KERNEL);
|
||||
if (!dmaru)
|
||||
return -ENOMEM;
|
||||
|
|
@ -622,12 +613,53 @@ int __init dmar_table_init(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int __init check_zero_address(void)
|
||||
{
|
||||
struct acpi_table_dmar *dmar;
|
||||
struct acpi_dmar_header *entry_header;
|
||||
struct acpi_dmar_hardware_unit *drhd;
|
||||
|
||||
dmar = (struct acpi_table_dmar *)dmar_tbl;
|
||||
entry_header = (struct acpi_dmar_header *)(dmar + 1);
|
||||
|
||||
while (((unsigned long)entry_header) <
|
||||
(((unsigned long)dmar) + dmar_tbl->length)) {
|
||||
/* Avoid looping forever on bad ACPI tables */
|
||||
if (entry_header->length == 0) {
|
||||
printk(KERN_WARNING PREFIX
|
||||
"Invalid 0-length structure\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (entry_header->type == ACPI_DMAR_TYPE_HARDWARE_UNIT) {
|
||||
drhd = (void *)entry_header;
|
||||
if (!drhd->address) {
|
||||
/* Promote an attitude of violence to a BIOS engineer today */
|
||||
WARN(1, "Your BIOS is broken; DMAR reported at address zero!\n"
|
||||
"BIOS vendor: %s; Ver: %s; Product Version: %s\n",
|
||||
dmi_get_system_info(DMI_BIOS_VENDOR),
|
||||
dmi_get_system_info(DMI_BIOS_VERSION),
|
||||
dmi_get_system_info(DMI_PRODUCT_VERSION));
|
||||
#ifdef CONFIG_DMAR
|
||||
dmar_disabled = 1;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
entry_header = ((void *)entry_header + entry_header->length);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
void __init detect_intel_iommu(void)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = dmar_table_detect();
|
||||
|
||||
if (ret)
|
||||
ret = check_zero_address();
|
||||
{
|
||||
#ifdef CONFIG_INTR_REMAP
|
||||
struct acpi_table_dmar *dmar;
|
||||
|
|
@ -644,9 +676,12 @@ void __init detect_intel_iommu(void)
|
|||
"x2apic and Intr-remapping.\n");
|
||||
#endif
|
||||
#ifdef CONFIG_DMAR
|
||||
if (ret && !no_iommu && !iommu_detected && !swiotlb &&
|
||||
!dmar_disabled)
|
||||
if (ret && !no_iommu && !iommu_detected && !dmar_disabled)
|
||||
iommu_detected = 1;
|
||||
#endif
|
||||
#ifdef CONFIG_X86
|
||||
if (ret)
|
||||
x86_init.iommu.iommu_init = intel_iommu_init;
|
||||
#endif
|
||||
}
|
||||
early_acpi_os_unmap_memory(dmar_tbl, dmar_tbl_size);
|
||||
|
|
|
|||
|
|
@ -406,7 +406,6 @@ static acpi_status __init ibm_find_acpi_device(acpi_handle handle,
|
|||
__func__, status);
|
||||
return retval;
|
||||
}
|
||||
info->hardware_id.string[sizeof(info->hardware_id.length) - 1] = '\0';
|
||||
|
||||
if (info->current_status && (info->valid & ACPI_VALID_HID) &&
|
||||
(!strcmp(info->hardware_id.string, IBM_HARDWARE_ID1) ||
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
#include <asm/io.h> /* for read? and write? functions */
|
||||
#include <linux/delay.h> /* for delays */
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/sched.h> /* for signal_pending() */
|
||||
|
||||
#define MY_NAME "cpqphp"
|
||||
|
||||
|
|
|
|||
|
|
@ -72,15 +72,9 @@ do { \
|
|||
|
||||
#define SLOT_NAME_SIZE 10
|
||||
struct slot {
|
||||
u8 bus;
|
||||
u8 device;
|
||||
u8 state;
|
||||
u8 hp_slot;
|
||||
u32 number;
|
||||
struct controller *ctrl;
|
||||
struct hpc_ops *hpc_ops;
|
||||
struct hotplug_slot *hotplug_slot;
|
||||
struct list_head slot_list;
|
||||
struct delayed_work work; /* work for button event */
|
||||
struct mutex lock;
|
||||
};
|
||||
|
|
@ -92,18 +86,10 @@ struct event_info {
|
|||
};
|
||||
|
||||
struct controller {
|
||||
struct mutex crit_sect; /* critical section mutex */
|
||||
struct mutex ctrl_lock; /* controller lock */
|
||||
int num_slots; /* Number of slots on ctlr */
|
||||
int slot_num_inc; /* 1 or -1 */
|
||||
struct pci_dev *pci_dev;
|
||||
struct pcie_device *pcie; /* PCI Express port service */
|
||||
struct list_head slot_list;
|
||||
struct hpc_ops *hpc_ops;
|
||||
struct slot *slot;
|
||||
wait_queue_head_t queue; /* sleep & wake process */
|
||||
u8 slot_device_offset;
|
||||
u32 first_slot; /* First physical slot number */ /* PCIE only has 1 slot */
|
||||
u8 slot_bus; /* Bus where the slots handled by this controller sit */
|
||||
u32 slot_cap;
|
||||
u8 cap_base;
|
||||
struct timer_list poll_timer;
|
||||
|
|
@ -131,40 +117,20 @@ struct controller {
|
|||
#define POWERON_STATE 3
|
||||
#define POWEROFF_STATE 4
|
||||
|
||||
/* Error messages */
|
||||
#define INTERLOCK_OPEN 0x00000002
|
||||
#define ADD_NOT_SUPPORTED 0x00000003
|
||||
#define CARD_FUNCTIONING 0x00000005
|
||||
#define ADAPTER_NOT_SAME 0x00000006
|
||||
#define NO_ADAPTER_PRESENT 0x00000009
|
||||
#define NOT_ENOUGH_RESOURCES 0x0000000B
|
||||
#define DEVICE_TYPE_NOT_SUPPORTED 0x0000000C
|
||||
#define WRONG_BUS_FREQUENCY 0x0000000D
|
||||
#define POWER_FAILURE 0x0000000E
|
||||
|
||||
/* Field definitions in Slot Capabilities Register */
|
||||
#define ATTN_BUTTN_PRSN 0x00000001
|
||||
#define PWR_CTRL_PRSN 0x00000002
|
||||
#define MRL_SENS_PRSN 0x00000004
|
||||
#define ATTN_LED_PRSN 0x00000008
|
||||
#define PWR_LED_PRSN 0x00000010
|
||||
#define HP_SUPR_RM_SUP 0x00000020
|
||||
#define EMI_PRSN 0x00020000
|
||||
#define NO_CMD_CMPL_SUP 0x00040000
|
||||
|
||||
#define ATTN_BUTTN(ctrl) ((ctrl)->slot_cap & ATTN_BUTTN_PRSN)
|
||||
#define POWER_CTRL(ctrl) ((ctrl)->slot_cap & PWR_CTRL_PRSN)
|
||||
#define MRL_SENS(ctrl) ((ctrl)->slot_cap & MRL_SENS_PRSN)
|
||||
#define ATTN_LED(ctrl) ((ctrl)->slot_cap & ATTN_LED_PRSN)
|
||||
#define PWR_LED(ctrl) ((ctrl)->slot_cap & PWR_LED_PRSN)
|
||||
#define HP_SUPR_RM(ctrl) ((ctrl)->slot_cap & HP_SUPR_RM_SUP)
|
||||
#define EMI(ctrl) ((ctrl)->slot_cap & EMI_PRSN)
|
||||
#define NO_CMD_CMPL(ctrl) ((ctrl)->slot_cap & NO_CMD_CMPL_SUP)
|
||||
#define ATTN_BUTTN(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_ABP)
|
||||
#define POWER_CTRL(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_PCP)
|
||||
#define MRL_SENS(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_MRLSP)
|
||||
#define ATTN_LED(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_AIP)
|
||||
#define PWR_LED(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_PIP)
|
||||
#define HP_SUPR_RM(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_HPS)
|
||||
#define EMI(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_EIP)
|
||||
#define NO_CMD_CMPL(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_NCCS)
|
||||
#define PSN(ctrl) ((ctrl)->slot_cap >> 19)
|
||||
|
||||
extern int pciehp_sysfs_enable_slot(struct slot *slot);
|
||||
extern int pciehp_sysfs_disable_slot(struct slot *slot);
|
||||
extern u8 pciehp_handle_attention_button(struct slot *p_slot);
|
||||
extern u8 pciehp_handle_switch_change(struct slot *p_slot);
|
||||
extern u8 pciehp_handle_switch_change(struct slot *p_slot);
|
||||
extern u8 pciehp_handle_presence_change(struct slot *p_slot);
|
||||
extern u8 pciehp_handle_power_fault(struct slot *p_slot);
|
||||
extern int pciehp_configure_device(struct slot *p_slot);
|
||||
|
|
@ -175,45 +141,30 @@ int pcie_init_notification(struct controller *ctrl);
|
|||
int pciehp_enable_slot(struct slot *p_slot);
|
||||
int pciehp_disable_slot(struct slot *p_slot);
|
||||
int pcie_enable_notification(struct controller *ctrl);
|
||||
int pciehp_power_on_slot(struct slot *slot);
|
||||
int pciehp_power_off_slot(struct slot *slot);
|
||||
int pciehp_get_power_status(struct slot *slot, u8 *status);
|
||||
int pciehp_get_attention_status(struct slot *slot, u8 *status);
|
||||
|
||||
int pciehp_set_attention_status(struct slot *slot, u8 status);
|
||||
int pciehp_get_latch_status(struct slot *slot, u8 *status);
|
||||
int pciehp_get_adapter_status(struct slot *slot, u8 *status);
|
||||
int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *speed);
|
||||
int pciehp_get_max_link_width(struct slot *slot, enum pcie_link_width *val);
|
||||
int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *speed);
|
||||
int pciehp_get_cur_link_width(struct slot *slot, enum pcie_link_width *val);
|
||||
int pciehp_query_power_fault(struct slot *slot);
|
||||
void pciehp_green_led_on(struct slot *slot);
|
||||
void pciehp_green_led_off(struct slot *slot);
|
||||
void pciehp_green_led_blink(struct slot *slot);
|
||||
int pciehp_check_link_status(struct controller *ctrl);
|
||||
void pciehp_release_ctrl(struct controller *ctrl);
|
||||
|
||||
static inline const char *slot_name(struct slot *slot)
|
||||
{
|
||||
return hotplug_slot_name(slot->hotplug_slot);
|
||||
}
|
||||
|
||||
static inline struct slot *pciehp_find_slot(struct controller *ctrl, u8 device)
|
||||
{
|
||||
struct slot *slot;
|
||||
|
||||
list_for_each_entry(slot, &ctrl->slot_list, slot_list) {
|
||||
if (slot->device == device)
|
||||
return slot;
|
||||
}
|
||||
|
||||
ctrl_err(ctrl, "Slot (device=0x%02x) not found\n", device);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct hpc_ops {
|
||||
int (*power_on_slot)(struct slot *slot);
|
||||
int (*power_off_slot)(struct slot *slot);
|
||||
int (*get_power_status)(struct slot *slot, u8 *status);
|
||||
int (*get_attention_status)(struct slot *slot, u8 *status);
|
||||
int (*set_attention_status)(struct slot *slot, u8 status);
|
||||
int (*get_latch_status)(struct slot *slot, u8 *status);
|
||||
int (*get_adapter_status)(struct slot *slot, u8 *status);
|
||||
int (*get_max_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
|
||||
int (*get_cur_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
|
||||
int (*get_max_lnk_width)(struct slot *slot, enum pcie_link_width *val);
|
||||
int (*get_cur_lnk_width)(struct slot *slot, enum pcie_link_width *val);
|
||||
int (*query_power_fault)(struct slot *slot);
|
||||
void (*green_led_on)(struct slot *slot);
|
||||
void (*green_led_off)(struct slot *slot);
|
||||
void (*green_led_blink)(struct slot *slot);
|
||||
void (*release_ctlr)(struct controller *ctrl);
|
||||
int (*check_lnk_status)(struct controller *ctrl);
|
||||
};
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
#include <acpi/acpi.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
|
|
|
|||
|
|
@ -33,6 +33,11 @@
|
|||
#define PCIEHP_DETECT_AUTO (2)
|
||||
#define PCIEHP_DETECT_DEFAULT PCIEHP_DETECT_AUTO
|
||||
|
||||
struct dummy_slot {
|
||||
u32 number;
|
||||
struct list_head list;
|
||||
};
|
||||
|
||||
static int slot_detection_mode;
|
||||
static char *pciehp_detect_mode;
|
||||
module_param(pciehp_detect_mode, charp, 0444);
|
||||
|
|
@ -77,7 +82,7 @@ static int __init dummy_probe(struct pcie_device *dev)
|
|||
int pos;
|
||||
u32 slot_cap;
|
||||
acpi_handle handle;
|
||||
struct slot *slot, *tmp;
|
||||
struct dummy_slot *slot, *tmp;
|
||||
struct pci_dev *pdev = dev->port;
|
||||
/* Note: pciehp_detect_mode != PCIEHP_DETECT_ACPI here */
|
||||
if (pciehp_get_hp_hw_control_from_firmware(pdev))
|
||||
|
|
@ -89,11 +94,11 @@ static int __init dummy_probe(struct pcie_device *dev)
|
|||
if (!slot)
|
||||
return -ENOMEM;
|
||||
slot->number = slot_cap >> 19;
|
||||
list_for_each_entry(tmp, &dummy_slots, slot_list) {
|
||||
list_for_each_entry(tmp, &dummy_slots, list) {
|
||||
if (tmp->number == slot->number)
|
||||
dup_slot_id++;
|
||||
}
|
||||
list_add_tail(&slot->slot_list, &dummy_slots);
|
||||
list_add_tail(&slot->list, &dummy_slots);
|
||||
handle = DEVICE_ACPI_HANDLE(&pdev->dev);
|
||||
if (!acpi_slot_detected && acpi_pci_detect_ejectable(handle))
|
||||
acpi_slot_detected = 1;
|
||||
|
|
@ -109,11 +114,11 @@ static struct pcie_port_service_driver __initdata dummy_driver = {
|
|||
|
||||
static int __init select_detection_mode(void)
|
||||
{
|
||||
struct slot *slot, *tmp;
|
||||
struct dummy_slot *slot, *tmp;
|
||||
pcie_port_service_register(&dummy_driver);
|
||||
pcie_port_service_unregister(&dummy_driver);
|
||||
list_for_each_entry_safe(slot, tmp, &dummy_slots, slot_list) {
|
||||
list_del(&slot->slot_list);
|
||||
list_for_each_entry_safe(slot, tmp, &dummy_slots, list) {
|
||||
list_del(&slot->list);
|
||||
kfree(slot);
|
||||
}
|
||||
if (acpi_slot_detected && dup_slot_id)
|
||||
|
|
|
|||
|
|
@ -99,65 +99,55 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
|
|||
kfree(hotplug_slot);
|
||||
}
|
||||
|
||||
static int init_slots(struct controller *ctrl)
|
||||
static int init_slot(struct controller *ctrl)
|
||||
{
|
||||
struct slot *slot;
|
||||
struct hotplug_slot *hotplug_slot;
|
||||
struct hotplug_slot_info *info;
|
||||
struct slot *slot = ctrl->slot;
|
||||
struct hotplug_slot *hotplug = NULL;
|
||||
struct hotplug_slot_info *info = NULL;
|
||||
char name[SLOT_NAME_SIZE];
|
||||
int retval = -ENOMEM;
|
||||
|
||||
list_for_each_entry(slot, &ctrl->slot_list, slot_list) {
|
||||
hotplug_slot = kzalloc(sizeof(*hotplug_slot), GFP_KERNEL);
|
||||
if (!hotplug_slot)
|
||||
goto error;
|
||||
hotplug = kzalloc(sizeof(*hotplug), GFP_KERNEL);
|
||||
if (!hotplug)
|
||||
goto out;
|
||||
|
||||
info = kzalloc(sizeof(*info), GFP_KERNEL);
|
||||
if (!info)
|
||||
goto error_hpslot;
|
||||
info = kzalloc(sizeof(*info), GFP_KERNEL);
|
||||
if (!info)
|
||||
goto out;
|
||||
|
||||
/* register this slot with the hotplug pci core */
|
||||
hotplug_slot->info = info;
|
||||
hotplug_slot->private = slot;
|
||||
hotplug_slot->release = &release_slot;
|
||||
hotplug_slot->ops = &pciehp_hotplug_slot_ops;
|
||||
slot->hotplug_slot = hotplug_slot;
|
||||
snprintf(name, SLOT_NAME_SIZE, "%u", slot->number);
|
||||
/* register this slot with the hotplug pci core */
|
||||
hotplug->info = info;
|
||||
hotplug->private = slot;
|
||||
hotplug->release = &release_slot;
|
||||
hotplug->ops = &pciehp_hotplug_slot_ops;
|
||||
slot->hotplug_slot = hotplug;
|
||||
snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));
|
||||
|
||||
ctrl_dbg(ctrl, "Registering domain:bus:dev=%04x:%02x:%02x "
|
||||
"hp_slot=%x sun=%x slot_device_offset=%x\n",
|
||||
pci_domain_nr(ctrl->pci_dev->subordinate),
|
||||
slot->bus, slot->device, slot->hp_slot, slot->number,
|
||||
ctrl->slot_device_offset);
|
||||
retval = pci_hp_register(hotplug_slot,
|
||||
ctrl->pci_dev->subordinate,
|
||||
slot->device,
|
||||
name);
|
||||
if (retval) {
|
||||
ctrl_err(ctrl, "pci_hp_register failed with error %d\n",
|
||||
retval);
|
||||
goto error_info;
|
||||
}
|
||||
get_power_status(hotplug_slot, &info->power_status);
|
||||
get_attention_status(hotplug_slot, &info->attention_status);
|
||||
get_latch_status(hotplug_slot, &info->latch_status);
|
||||
get_adapter_status(hotplug_slot, &info->adapter_status);
|
||||
ctrl_dbg(ctrl, "Registering domain:bus:dev=%04x:%02x:00 sun=%x\n",
|
||||
pci_domain_nr(ctrl->pcie->port->subordinate),
|
||||
ctrl->pcie->port->subordinate->number, PSN(ctrl));
|
||||
retval = pci_hp_register(hotplug,
|
||||
ctrl->pcie->port->subordinate, 0, name);
|
||||
if (retval) {
|
||||
ctrl_err(ctrl,
|
||||
"pci_hp_register failed with error %d\n", retval);
|
||||
goto out;
|
||||
}
|
||||
get_power_status(hotplug, &info->power_status);
|
||||
get_attention_status(hotplug, &info->attention_status);
|
||||
get_latch_status(hotplug, &info->latch_status);
|
||||
get_adapter_status(hotplug, &info->adapter_status);
|
||||
out:
|
||||
if (retval) {
|
||||
kfree(info);
|
||||
kfree(hotplug);
|
||||
}
|
||||
|
||||
return 0;
|
||||
error_info:
|
||||
kfree(info);
|
||||
error_hpslot:
|
||||
kfree(hotplug_slot);
|
||||
error:
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void cleanup_slots(struct controller *ctrl)
|
||||
static void cleanup_slot(struct controller *ctrl)
|
||||
{
|
||||
struct slot *slot;
|
||||
list_for_each_entry(slot, &ctrl->slot_list, slot_list)
|
||||
pci_hp_deregister(slot->hotplug_slot);
|
||||
pci_hp_deregister(ctrl->slot->hotplug_slot);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -173,7 +163,7 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
|
|||
hotplug_slot->info->attention_status = status;
|
||||
|
||||
if (ATTN_LED(slot->ctrl))
|
||||
slot->hpc_ops->set_attention_status(slot, status);
|
||||
pciehp_set_attention_status(slot, status);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -208,7 +198,7 @@ static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
|
|||
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
|
||||
__func__, slot_name(slot));
|
||||
|
||||
retval = slot->hpc_ops->get_power_status(slot, value);
|
||||
retval = pciehp_get_power_status(slot, value);
|
||||
if (retval < 0)
|
||||
*value = hotplug_slot->info->power_status;
|
||||
|
||||
|
|
@ -223,7 +213,7 @@ static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
|
|||
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
|
||||
__func__, slot_name(slot));
|
||||
|
||||
retval = slot->hpc_ops->get_attention_status(slot, value);
|
||||
retval = pciehp_get_attention_status(slot, value);
|
||||
if (retval < 0)
|
||||
*value = hotplug_slot->info->attention_status;
|
||||
|
||||
|
|
@ -238,7 +228,7 @@ static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
|
|||
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
|
||||
__func__, slot_name(slot));
|
||||
|
||||
retval = slot->hpc_ops->get_latch_status(slot, value);
|
||||
retval = pciehp_get_latch_status(slot, value);
|
||||
if (retval < 0)
|
||||
*value = hotplug_slot->info->latch_status;
|
||||
|
||||
|
|
@ -253,7 +243,7 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
|
|||
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
|
||||
__func__, slot_name(slot));
|
||||
|
||||
retval = slot->hpc_ops->get_adapter_status(slot, value);
|
||||
retval = pciehp_get_adapter_status(slot, value);
|
||||
if (retval < 0)
|
||||
*value = hotplug_slot->info->adapter_status;
|
||||
|
||||
|
|
@ -269,7 +259,7 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
|
|||
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
|
||||
__func__, slot_name(slot));
|
||||
|
||||
retval = slot->hpc_ops->get_max_bus_speed(slot, value);
|
||||
retval = pciehp_get_max_link_speed(slot, value);
|
||||
if (retval < 0)
|
||||
*value = PCI_SPEED_UNKNOWN;
|
||||
|
||||
|
|
@ -284,7 +274,7 @@ static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
|
|||
ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
|
||||
__func__, slot_name(slot));
|
||||
|
||||
retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
|
||||
retval = pciehp_get_cur_link_speed(slot, value);
|
||||
if (retval < 0)
|
||||
*value = PCI_SPEED_UNKNOWN;
|
||||
|
||||
|
|
@ -295,7 +285,7 @@ static int pciehp_probe(struct pcie_device *dev)
|
|||
{
|
||||
int rc;
|
||||
struct controller *ctrl;
|
||||
struct slot *t_slot;
|
||||
struct slot *slot;
|
||||
u8 value;
|
||||
struct pci_dev *pdev = dev->port;
|
||||
|
||||
|
|
@ -314,7 +304,7 @@ static int pciehp_probe(struct pcie_device *dev)
|
|||
set_service_data(dev, ctrl);
|
||||
|
||||
/* Setup the slot information structures */
|
||||
rc = init_slots(ctrl);
|
||||
rc = init_slot(ctrl);
|
||||
if (rc) {
|
||||
if (rc == -EBUSY)
|
||||
ctrl_warn(ctrl, "Slot already registered by another "
|
||||
|
|
@ -332,15 +322,15 @@ static int pciehp_probe(struct pcie_device *dev)
|
|||
}
|
||||
|
||||
/* Check if slot is occupied */
|
||||
t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
|
||||
t_slot->hpc_ops->get_adapter_status(t_slot, &value);
|
||||
slot = ctrl->slot;
|
||||
pciehp_get_adapter_status(slot, &value);
|
||||
if (value) {
|
||||
if (pciehp_force)
|
||||
pciehp_enable_slot(t_slot);
|
||||
pciehp_enable_slot(slot);
|
||||
} else {
|
||||
/* Power off slot if not occupied */
|
||||
if (POWER_CTRL(ctrl)) {
|
||||
rc = t_slot->hpc_ops->power_off_slot(t_slot);
|
||||
rc = pciehp_power_off_slot(slot);
|
||||
if (rc)
|
||||
goto err_out_free_ctrl_slot;
|
||||
}
|
||||
|
|
@ -349,19 +339,19 @@ static int pciehp_probe(struct pcie_device *dev)
|
|||
return 0;
|
||||
|
||||
err_out_free_ctrl_slot:
|
||||
cleanup_slots(ctrl);
|
||||
cleanup_slot(ctrl);
|
||||
err_out_release_ctlr:
|
||||
ctrl->hpc_ops->release_ctlr(ctrl);
|
||||
pciehp_release_ctrl(ctrl);
|
||||
err_out_none:
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static void pciehp_remove (struct pcie_device *dev)
|
||||
static void pciehp_remove(struct pcie_device *dev)
|
||||
{
|
||||
struct controller *ctrl = get_service_data(dev);
|
||||
|
||||
cleanup_slots(ctrl);
|
||||
ctrl->hpc_ops->release_ctlr(ctrl);
|
||||
cleanup_slot(ctrl);
|
||||
pciehp_release_ctrl(ctrl);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
|
|
@ -376,20 +366,20 @@ static int pciehp_resume (struct pcie_device *dev)
|
|||
dev_info(&dev->device, "%s ENTRY\n", __func__);
|
||||
if (pciehp_force) {
|
||||
struct controller *ctrl = get_service_data(dev);
|
||||
struct slot *t_slot;
|
||||
struct slot *slot;
|
||||
u8 status;
|
||||
|
||||
/* reinitialize the chipset's event detection logic */
|
||||
pcie_enable_notification(ctrl);
|
||||
|
||||
t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
|
||||
slot = ctrl->slot;
|
||||
|
||||
/* Check if slot is occupied */
|
||||
t_slot->hpc_ops->get_adapter_status(t_slot, &status);
|
||||
pciehp_get_adapter_status(slot, &status);
|
||||
if (status)
|
||||
pciehp_enable_slot(t_slot);
|
||||
pciehp_enable_slot(slot);
|
||||
else
|
||||
pciehp_disable_slot(t_slot);
|
||||
pciehp_disable_slot(slot);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ u8 pciehp_handle_switch_change(struct slot *p_slot)
|
|||
/* Switch Change */
|
||||
ctrl_dbg(ctrl, "Switch interrupt received\n");
|
||||
|
||||
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
|
||||
pciehp_get_latch_status(p_slot, &getstatus);
|
||||
if (getstatus) {
|
||||
/*
|
||||
* Switch opened
|
||||
|
|
@ -114,7 +114,7 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
|
|||
/* Switch is open, assume a presence change
|
||||
* Save the presence state
|
||||
*/
|
||||
p_slot->hpc_ops->get_adapter_status(p_slot, &presence_save);
|
||||
pciehp_get_adapter_status(p_slot, &presence_save);
|
||||
if (presence_save) {
|
||||
/*
|
||||
* Card Present
|
||||
|
|
@ -143,7 +143,7 @@ u8 pciehp_handle_power_fault(struct slot *p_slot)
|
|||
/* power fault */
|
||||
ctrl_dbg(ctrl, "Power fault interrupt received\n");
|
||||
|
||||
if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
|
||||
if (!pciehp_query_power_fault(p_slot)) {
|
||||
/*
|
||||
* power fault Cleared
|
||||
*/
|
||||
|
|
@ -172,7 +172,7 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
|
|||
{
|
||||
/* turn off slot, turn on Amber LED, turn off Green LED if supported*/
|
||||
if (POWER_CTRL(ctrl)) {
|
||||
if (pslot->hpc_ops->power_off_slot(pslot)) {
|
||||
if (pciehp_power_off_slot(pslot)) {
|
||||
ctrl_err(ctrl,
|
||||
"Issue of Slot Power Off command failed\n");
|
||||
return;
|
||||
|
|
@ -186,10 +186,10 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
|
|||
}
|
||||
|
||||
if (PWR_LED(ctrl))
|
||||
pslot->hpc_ops->green_led_off(pslot);
|
||||
pciehp_green_led_off(pslot);
|
||||
|
||||
if (ATTN_LED(ctrl)) {
|
||||
if (pslot->hpc_ops->set_attention_status(pslot, 1)) {
|
||||
if (pciehp_set_attention_status(pslot, 1)) {
|
||||
ctrl_err(ctrl,
|
||||
"Issue of Set Attention Led command failed\n");
|
||||
return;
|
||||
|
|
@ -208,24 +208,20 @@ static int board_added(struct slot *p_slot)
|
|||
{
|
||||
int retval = 0;
|
||||
struct controller *ctrl = p_slot->ctrl;
|
||||
struct pci_bus *parent = ctrl->pci_dev->subordinate;
|
||||
|
||||
ctrl_dbg(ctrl, "%s: slot device, slot offset, hp slot = %d, %d, %d\n",
|
||||
__func__, p_slot->device, ctrl->slot_device_offset,
|
||||
p_slot->hp_slot);
|
||||
struct pci_bus *parent = ctrl->pcie->port->subordinate;
|
||||
|
||||
if (POWER_CTRL(ctrl)) {
|
||||
/* Power on slot */
|
||||
retval = p_slot->hpc_ops->power_on_slot(p_slot);
|
||||
retval = pciehp_power_on_slot(p_slot);
|
||||
if (retval)
|
||||
return retval;
|
||||
}
|
||||
|
||||
if (PWR_LED(ctrl))
|
||||
p_slot->hpc_ops->green_led_blink(p_slot);
|
||||
pciehp_green_led_blink(p_slot);
|
||||
|
||||
/* Check link training status */
|
||||
retval = p_slot->hpc_ops->check_lnk_status(ctrl);
|
||||
retval = pciehp_check_link_status(ctrl);
|
||||
if (retval) {
|
||||
ctrl_err(ctrl, "Failed to check link status\n");
|
||||
set_slot_off(ctrl, p_slot);
|
||||
|
|
@ -233,21 +229,21 @@ static int board_added(struct slot *p_slot)
|
|||
}
|
||||
|
||||
/* Check for a power fault */
|
||||
if (p_slot->hpc_ops->query_power_fault(p_slot)) {
|
||||
if (pciehp_query_power_fault(p_slot)) {
|
||||
ctrl_dbg(ctrl, "Power fault detected\n");
|
||||
retval = POWER_FAILURE;
|
||||
retval = -EIO;
|
||||
goto err_exit;
|
||||
}
|
||||
|
||||
retval = pciehp_configure_device(p_slot);
|
||||
if (retval) {
|
||||
ctrl_err(ctrl, "Cannot add device at %04x:%02x:%02x\n",
|
||||
pci_domain_nr(parent), p_slot->bus, p_slot->device);
|
||||
ctrl_err(ctrl, "Cannot add device at %04x:%02x:00\n",
|
||||
pci_domain_nr(parent), parent->number);
|
||||
goto err_exit;
|
||||
}
|
||||
|
||||
if (PWR_LED(ctrl))
|
||||
p_slot->hpc_ops->green_led_on(p_slot);
|
||||
pciehp_green_led_on(p_slot);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
@ -269,11 +265,9 @@ static int remove_board(struct slot *p_slot)
|
|||
if (retval)
|
||||
return retval;
|
||||
|
||||
ctrl_dbg(ctrl, "%s: hp_slot = %d\n", __func__, p_slot->hp_slot);
|
||||
|
||||
if (POWER_CTRL(ctrl)) {
|
||||
/* power off slot */
|
||||
retval = p_slot->hpc_ops->power_off_slot(p_slot);
|
||||
retval = pciehp_power_off_slot(p_slot);
|
||||
if (retval) {
|
||||
ctrl_err(ctrl,
|
||||
"Issue of Slot Disable command failed\n");
|
||||
|
|
@ -287,9 +281,9 @@ static int remove_board(struct slot *p_slot)
|
|||
msleep(1000);
|
||||
}
|
||||
|
||||
/* turn off Green LED */
|
||||
if (PWR_LED(ctrl))
|
||||
/* turn off Green LED */
|
||||
p_slot->hpc_ops->green_led_off(p_slot);
|
||||
pciehp_green_led_off(p_slot);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -317,18 +311,17 @@ static void pciehp_power_thread(struct work_struct *work)
|
|||
case POWEROFF_STATE:
|
||||
mutex_unlock(&p_slot->lock);
|
||||
ctrl_dbg(p_slot->ctrl,
|
||||
"Disabling domain:bus:device=%04x:%02x:%02x\n",
|
||||
pci_domain_nr(p_slot->ctrl->pci_dev->subordinate),
|
||||
p_slot->bus, p_slot->device);
|
||||
"Disabling domain:bus:device=%04x:%02x:00\n",
|
||||
pci_domain_nr(p_slot->ctrl->pcie->port->subordinate),
|
||||
p_slot->ctrl->pcie->port->subordinate->number);
|
||||
pciehp_disable_slot(p_slot);
|
||||
mutex_lock(&p_slot->lock);
|
||||
p_slot->state = STATIC_STATE;
|
||||
break;
|
||||
case POWERON_STATE:
|
||||
mutex_unlock(&p_slot->lock);
|
||||
if (pciehp_enable_slot(p_slot) &&
|
||||
PWR_LED(p_slot->ctrl))
|
||||
p_slot->hpc_ops->green_led_off(p_slot);
|
||||
if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl))
|
||||
pciehp_green_led_off(p_slot);
|
||||
mutex_lock(&p_slot->lock);
|
||||
p_slot->state = STATIC_STATE;
|
||||
break;
|
||||
|
|
@ -379,10 +372,10 @@ static int update_slot_info(struct slot *slot)
|
|||
if (!info)
|
||||
return -ENOMEM;
|
||||
|
||||
slot->hpc_ops->get_power_status(slot, &(info->power_status));
|
||||
slot->hpc_ops->get_attention_status(slot, &(info->attention_status));
|
||||
slot->hpc_ops->get_latch_status(slot, &(info->latch_status));
|
||||
slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status));
|
||||
pciehp_get_power_status(slot, &info->power_status);
|
||||
pciehp_get_attention_status(slot, &info->attention_status);
|
||||
pciehp_get_latch_status(slot, &info->latch_status);
|
||||
pciehp_get_adapter_status(slot, &info->adapter_status);
|
||||
|
||||
result = pci_hp_change_slot_info(slot->hotplug_slot, info);
|
||||
kfree (info);
|
||||
|
|
@ -399,7 +392,7 @@ static void handle_button_press_event(struct slot *p_slot)
|
|||
|
||||
switch (p_slot->state) {
|
||||
case STATIC_STATE:
|
||||
p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
|
||||
pciehp_get_power_status(p_slot, &getstatus);
|
||||
if (getstatus) {
|
||||
p_slot->state = BLINKINGOFF_STATE;
|
||||
ctrl_info(ctrl,
|
||||
|
|
@ -413,9 +406,9 @@ static void handle_button_press_event(struct slot *p_slot)
|
|||
}
|
||||
/* blink green LED and turn off amber */
|
||||
if (PWR_LED(ctrl))
|
||||
p_slot->hpc_ops->green_led_blink(p_slot);
|
||||
pciehp_green_led_blink(p_slot);
|
||||
if (ATTN_LED(ctrl))
|
||||
p_slot->hpc_ops->set_attention_status(p_slot, 0);
|
||||
pciehp_set_attention_status(p_slot, 0);
|
||||
|
||||
schedule_delayed_work(&p_slot->work, 5*HZ);
|
||||
break;
|
||||
|
|
@ -430,13 +423,13 @@ static void handle_button_press_event(struct slot *p_slot)
|
|||
cancel_delayed_work(&p_slot->work);
|
||||
if (p_slot->state == BLINKINGOFF_STATE) {
|
||||
if (PWR_LED(ctrl))
|
||||
p_slot->hpc_ops->green_led_on(p_slot);
|
||||
pciehp_green_led_on(p_slot);
|
||||
} else {
|
||||
if (PWR_LED(ctrl))
|
||||
p_slot->hpc_ops->green_led_off(p_slot);
|
||||
pciehp_green_led_off(p_slot);
|
||||
}
|
||||
if (ATTN_LED(ctrl))
|
||||
p_slot->hpc_ops->set_attention_status(p_slot, 0);
|
||||
pciehp_set_attention_status(p_slot, 0);
|
||||
ctrl_info(ctrl, "PCI slot #%s - action canceled "
|
||||
"due to button press\n", slot_name(p_slot));
|
||||
p_slot->state = STATIC_STATE;
|
||||
|
|
@ -474,7 +467,7 @@ static void handle_surprise_event(struct slot *p_slot)
|
|||
info->p_slot = p_slot;
|
||||
INIT_WORK(&info->work, pciehp_power_thread);
|
||||
|
||||
p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
|
||||
pciehp_get_adapter_status(p_slot, &getstatus);
|
||||
if (!getstatus)
|
||||
p_slot->state = POWEROFF_STATE;
|
||||
else
|
||||
|
|
@ -498,9 +491,9 @@ static void interrupt_event_handler(struct work_struct *work)
|
|||
if (!POWER_CTRL(ctrl))
|
||||
break;
|
||||
if (ATTN_LED(ctrl))
|
||||
p_slot->hpc_ops->set_attention_status(p_slot, 1);
|
||||
pciehp_set_attention_status(p_slot, 1);
|
||||
if (PWR_LED(ctrl))
|
||||
p_slot->hpc_ops->green_led_off(p_slot);
|
||||
pciehp_green_led_off(p_slot);
|
||||
break;
|
||||
case INT_PRESENCE_ON:
|
||||
case INT_PRESENCE_OFF:
|
||||
|
|
@ -525,45 +518,38 @@ int pciehp_enable_slot(struct slot *p_slot)
|
|||
int rc;
|
||||
struct controller *ctrl = p_slot->ctrl;
|
||||
|
||||
/* Check to see if (latch closed, card present, power off) */
|
||||
mutex_lock(&p_slot->ctrl->crit_sect);
|
||||
|
||||
rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
|
||||
rc = pciehp_get_adapter_status(p_slot, &getstatus);
|
||||
if (rc || !getstatus) {
|
||||
ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return -ENODEV;
|
||||
}
|
||||
if (MRL_SENS(p_slot->ctrl)) {
|
||||
rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
|
||||
rc = pciehp_get_latch_status(p_slot, &getstatus);
|
||||
if (rc || getstatus) {
|
||||
ctrl_info(ctrl, "Latch open on slot(%s)\n",
|
||||
slot_name(p_slot));
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return -ENODEV;
|
||||
}
|
||||
}
|
||||
|
||||
if (POWER_CTRL(p_slot->ctrl)) {
|
||||
rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
|
||||
rc = pciehp_get_power_status(p_slot, &getstatus);
|
||||
if (rc || getstatus) {
|
||||
ctrl_info(ctrl, "Already enabled on slot(%s)\n",
|
||||
slot_name(p_slot));
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
|
||||
pciehp_get_latch_status(p_slot, &getstatus);
|
||||
|
||||
rc = board_added(p_slot);
|
||||
if (rc) {
|
||||
p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
|
||||
pciehp_get_latch_status(p_slot, &getstatus);
|
||||
}
|
||||
|
||||
update_slot_info(p_slot);
|
||||
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
@ -577,35 +563,29 @@ int pciehp_disable_slot(struct slot *p_slot)
|
|||
if (!p_slot->ctrl)
|
||||
return 1;
|
||||
|
||||
/* Check to see if (latch closed, card present, power on) */
|
||||
mutex_lock(&p_slot->ctrl->crit_sect);
|
||||
|
||||
if (!HP_SUPR_RM(p_slot->ctrl)) {
|
||||
ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
|
||||
ret = pciehp_get_adapter_status(p_slot, &getstatus);
|
||||
if (ret || !getstatus) {
|
||||
ctrl_info(ctrl, "No adapter on slot(%s)\n",
|
||||
slot_name(p_slot));
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return -ENODEV;
|
||||
}
|
||||
}
|
||||
|
||||
if (MRL_SENS(p_slot->ctrl)) {
|
||||
ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
|
||||
ret = pciehp_get_latch_status(p_slot, &getstatus);
|
||||
if (ret || getstatus) {
|
||||
ctrl_info(ctrl, "Latch open on slot(%s)\n",
|
||||
slot_name(p_slot));
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return -ENODEV;
|
||||
}
|
||||
}
|
||||
|
||||
if (POWER_CTRL(p_slot->ctrl)) {
|
||||
ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
|
||||
ret = pciehp_get_power_status(p_slot, &getstatus);
|
||||
if (ret || !getstatus) {
|
||||
ctrl_info(ctrl, "Already disabled on slot(%s)\n",
|
||||
slot_name(p_slot));
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
|
@ -613,7 +593,6 @@ int pciehp_disable_slot(struct slot *p_slot)
|
|||
ret = remove_board(p_slot);
|
||||
update_slot_info(p_slot);
|
||||
|
||||
mutex_unlock(&p_slot->ctrl->crit_sect);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,25 +44,25 @@ static atomic_t pciehp_num_controllers = ATOMIC_INIT(0);
|
|||
|
||||
static inline int pciehp_readw(struct controller *ctrl, int reg, u16 *value)
|
||||
{
|
||||
struct pci_dev *dev = ctrl->pci_dev;
|
||||
struct pci_dev *dev = ctrl->pcie->port;
|
||||
return pci_read_config_word(dev, ctrl->cap_base + reg, value);
|
||||
}
|
||||
|
||||
static inline int pciehp_readl(struct controller *ctrl, int reg, u32 *value)
|
||||
{
|
||||
struct pci_dev *dev = ctrl->pci_dev;
|
||||
struct pci_dev *dev = ctrl->pcie->port;
|
||||
return pci_read_config_dword(dev, ctrl->cap_base + reg, value);
|
||||
}
|
||||
|
||||
static inline int pciehp_writew(struct controller *ctrl, int reg, u16 value)
|
||||
{
|
||||
struct pci_dev *dev = ctrl->pci_dev;
|
||||
struct pci_dev *dev = ctrl->pcie->port;
|
||||
return pci_write_config_word(dev, ctrl->cap_base + reg, value);
|
||||
}
|
||||
|
||||
static inline int pciehp_writel(struct controller *ctrl, int reg, u32 value)
|
||||
{
|
||||
struct pci_dev *dev = ctrl->pci_dev;
|
||||
struct pci_dev *dev = ctrl->pcie->port;
|
||||
return pci_write_config_dword(dev, ctrl->cap_base + reg, value);
|
||||
}
|
||||
|
||||
|
|
@ -266,7 +266,7 @@ static void pcie_wait_link_active(struct controller *ctrl)
|
|||
ctrl_dbg(ctrl, "Data Link Layer Link Active not set in 1000 msec\n");
|
||||
}
|
||||
|
||||
static int hpc_check_lnk_status(struct controller *ctrl)
|
||||
int pciehp_check_link_status(struct controller *ctrl)
|
||||
{
|
||||
u16 lnk_status;
|
||||
int retval = 0;
|
||||
|
|
@ -305,7 +305,7 @@ static int hpc_check_lnk_status(struct controller *ctrl)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int hpc_get_attention_status(struct slot *slot, u8 *status)
|
||||
int pciehp_get_attention_status(struct slot *slot, u8 *status)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_ctrl;
|
||||
|
|
@ -344,7 +344,7 @@ static int hpc_get_attention_status(struct slot *slot, u8 *status)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int hpc_get_power_status(struct slot *slot, u8 *status)
|
||||
int pciehp_get_power_status(struct slot *slot, u8 *status)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_ctrl;
|
||||
|
|
@ -376,7 +376,7 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int hpc_get_latch_status(struct slot *slot, u8 *status)
|
||||
int pciehp_get_latch_status(struct slot *slot, u8 *status)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_status;
|
||||
|
|
@ -392,7 +392,7 @@ static int hpc_get_latch_status(struct slot *slot, u8 *status)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int hpc_get_adapter_status(struct slot *slot, u8 *status)
|
||||
int pciehp_get_adapter_status(struct slot *slot, u8 *status)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_status;
|
||||
|
|
@ -408,7 +408,7 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int hpc_query_power_fault(struct slot *slot)
|
||||
int pciehp_query_power_fault(struct slot *slot)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_status;
|
||||
|
|
@ -422,7 +422,7 @@ static int hpc_query_power_fault(struct slot *slot)
|
|||
return !!(slot_status & PCI_EXP_SLTSTA_PFD);
|
||||
}
|
||||
|
||||
static int hpc_set_attention_status(struct slot *slot, u8 value)
|
||||
int pciehp_set_attention_status(struct slot *slot, u8 value)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_cmd;
|
||||
|
|
@ -450,7 +450,7 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
|
|||
return rc;
|
||||
}
|
||||
|
||||
static void hpc_set_green_led_on(struct slot *slot)
|
||||
void pciehp_green_led_on(struct slot *slot)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_cmd;
|
||||
|
|
@ -463,7 +463,7 @@ static void hpc_set_green_led_on(struct slot *slot)
|
|||
__func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
|
||||
}
|
||||
|
||||
static void hpc_set_green_led_off(struct slot *slot)
|
||||
void pciehp_green_led_off(struct slot *slot)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_cmd;
|
||||
|
|
@ -476,7 +476,7 @@ static void hpc_set_green_led_off(struct slot *slot)
|
|||
__func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
|
||||
}
|
||||
|
||||
static void hpc_set_green_led_blink(struct slot *slot)
|
||||
void pciehp_green_led_blink(struct slot *slot)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_cmd;
|
||||
|
|
@ -489,7 +489,7 @@ static void hpc_set_green_led_blink(struct slot *slot)
|
|||
__func__, ctrl->cap_base + PCI_EXP_SLTCTL, slot_cmd);
|
||||
}
|
||||
|
||||
static int hpc_power_on_slot(struct slot * slot)
|
||||
int pciehp_power_on_slot(struct slot * slot)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_cmd;
|
||||
|
|
@ -497,8 +497,6 @@ static int hpc_power_on_slot(struct slot * slot)
|
|||
u16 slot_status;
|
||||
int retval = 0;
|
||||
|
||||
ctrl_dbg(ctrl, "%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
|
||||
|
||||
/* Clear sticky power-fault bit from previous power failures */
|
||||
retval = pciehp_readw(ctrl, PCI_EXP_SLTSTA, &slot_status);
|
||||
if (retval) {
|
||||
|
|
@ -539,7 +537,7 @@ static int hpc_power_on_slot(struct slot * slot)
|
|||
|
||||
static inline int pcie_mask_bad_dllp(struct controller *ctrl)
|
||||
{
|
||||
struct pci_dev *dev = ctrl->pci_dev;
|
||||
struct pci_dev *dev = ctrl->pcie->port;
|
||||
int pos;
|
||||
u32 reg;
|
||||
|
||||
|
|
@ -556,7 +554,7 @@ static inline int pcie_mask_bad_dllp(struct controller *ctrl)
|
|||
|
||||
static inline void pcie_unmask_bad_dllp(struct controller *ctrl)
|
||||
{
|
||||
struct pci_dev *dev = ctrl->pci_dev;
|
||||
struct pci_dev *dev = ctrl->pcie->port;
|
||||
u32 reg;
|
||||
int pos;
|
||||
|
||||
|
|
@ -570,7 +568,7 @@ static inline void pcie_unmask_bad_dllp(struct controller *ctrl)
|
|||
pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, reg);
|
||||
}
|
||||
|
||||
static int hpc_power_off_slot(struct slot * slot)
|
||||
int pciehp_power_off_slot(struct slot * slot)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
u16 slot_cmd;
|
||||
|
|
@ -578,8 +576,6 @@ static int hpc_power_off_slot(struct slot * slot)
|
|||
int retval = 0;
|
||||
int changed;
|
||||
|
||||
ctrl_dbg(ctrl, "%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
|
||||
|
||||
/*
|
||||
* Set Bad DLLP Mask bit in Correctable Error Mask
|
||||
* Register. This is the workaround against Bad DLLP error
|
||||
|
|
@ -614,8 +610,8 @@ static int hpc_power_off_slot(struct slot * slot)
|
|||
static irqreturn_t pcie_isr(int irq, void *dev_id)
|
||||
{
|
||||
struct controller *ctrl = (struct controller *)dev_id;
|
||||
struct slot *slot = ctrl->slot;
|
||||
u16 detected, intr_loc;
|
||||
struct slot *p_slot;
|
||||
|
||||
/*
|
||||
* In order to guarantee that all interrupt events are
|
||||
|
|
@ -656,29 +652,27 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
|
|||
if (!(intr_loc & ~PCI_EXP_SLTSTA_CC))
|
||||
return IRQ_HANDLED;
|
||||
|
||||
p_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
|
||||
|
||||
/* Check MRL Sensor Changed */
|
||||
if (intr_loc & PCI_EXP_SLTSTA_MRLSC)
|
||||
pciehp_handle_switch_change(p_slot);
|
||||
pciehp_handle_switch_change(slot);
|
||||
|
||||
/* Check Attention Button Pressed */
|
||||
if (intr_loc & PCI_EXP_SLTSTA_ABP)
|
||||
pciehp_handle_attention_button(p_slot);
|
||||
pciehp_handle_attention_button(slot);
|
||||
|
||||
/* Check Presence Detect Changed */
|
||||
if (intr_loc & PCI_EXP_SLTSTA_PDC)
|
||||
pciehp_handle_presence_change(p_slot);
|
||||
pciehp_handle_presence_change(slot);
|
||||
|
||||
/* Check Power Fault Detected */
|
||||
if ((intr_loc & PCI_EXP_SLTSTA_PFD) && !ctrl->power_fault_detected) {
|
||||
ctrl->power_fault_detected = 1;
|
||||
pciehp_handle_power_fault(p_slot);
|
||||
pciehp_handle_power_fault(slot);
|
||||
}
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
|
||||
int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *value)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
enum pcie_link_speed lnk_speed;
|
||||
|
|
@ -709,7 +703,7 @@ static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int hpc_get_max_lnk_width(struct slot *slot,
|
||||
int pciehp_get_max_lnk_width(struct slot *slot,
|
||||
enum pcie_link_width *value)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
|
|
@ -759,7 +753,7 @@ static int hpc_get_max_lnk_width(struct slot *slot,
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
|
||||
int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *value)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN;
|
||||
|
|
@ -791,7 +785,7 @@ static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int hpc_get_cur_lnk_width(struct slot *slot,
|
||||
int pciehp_get_cur_lnk_width(struct slot *slot,
|
||||
enum pcie_link_width *value)
|
||||
{
|
||||
struct controller *ctrl = slot->ctrl;
|
||||
|
|
@ -842,30 +836,6 @@ static int hpc_get_cur_lnk_width(struct slot *slot,
|
|||
return retval;
|
||||
}
|
||||
|
||||
static void pcie_release_ctrl(struct controller *ctrl);
|
||||
static struct hpc_ops pciehp_hpc_ops = {
|
||||
.power_on_slot = hpc_power_on_slot,
|
||||
.power_off_slot = hpc_power_off_slot,
|
||||
.set_attention_status = hpc_set_attention_status,
|
||||
.get_power_status = hpc_get_power_status,
|
||||
.get_attention_status = hpc_get_attention_status,
|
||||
.get_latch_status = hpc_get_latch_status,
|
||||
.get_adapter_status = hpc_get_adapter_status,
|
||||
|
||||
.get_max_bus_speed = hpc_get_max_lnk_speed,
|
||||
.get_cur_bus_speed = hpc_get_cur_lnk_speed,
|
||||
.get_max_lnk_width = hpc_get_max_lnk_width,
|
||||
.get_cur_lnk_width = hpc_get_cur_lnk_width,
|
||||
|
||||
.query_power_fault = hpc_query_power_fault,
|
||||
.green_led_on = hpc_set_green_led_on,
|
||||
.green_led_off = hpc_set_green_led_off,
|
||||
.green_led_blink = hpc_set_green_led_blink,
|
||||
|
||||
.release_ctlr = pcie_release_ctrl,
|
||||
.check_lnk_status = hpc_check_lnk_status,
|
||||
};
|
||||
|
||||
int pcie_enable_notification(struct controller *ctrl)
|
||||
{
|
||||
u16 cmd, mask;
|
||||
|
|
@ -930,23 +900,16 @@ static int pcie_init_slot(struct controller *ctrl)
|
|||
if (!slot)
|
||||
return -ENOMEM;
|
||||
|
||||
slot->hp_slot = 0;
|
||||
slot->ctrl = ctrl;
|
||||
slot->bus = ctrl->pci_dev->subordinate->number;
|
||||
slot->device = ctrl->slot_device_offset + slot->hp_slot;
|
||||
slot->hpc_ops = ctrl->hpc_ops;
|
||||
slot->number = ctrl->first_slot;
|
||||
mutex_init(&slot->lock);
|
||||
INIT_DELAYED_WORK(&slot->work, pciehp_queue_pushbutton_work);
|
||||
list_add(&slot->slot_list, &ctrl->slot_list);
|
||||
ctrl->slot = slot;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void pcie_cleanup_slot(struct controller *ctrl)
|
||||
{
|
||||
struct slot *slot;
|
||||
slot = list_first_entry(&ctrl->slot_list, struct slot, slot_list);
|
||||
list_del(&slot->slot_list);
|
||||
struct slot *slot = ctrl->slot;
|
||||
cancel_delayed_work(&slot->work);
|
||||
flush_scheduled_work();
|
||||
flush_workqueue(pciehp_wq);
|
||||
|
|
@ -957,7 +920,7 @@ static inline void dbg_ctrl(struct controller *ctrl)
|
|||
{
|
||||
int i;
|
||||
u16 reg16;
|
||||
struct pci_dev *pdev = ctrl->pci_dev;
|
||||
struct pci_dev *pdev = ctrl->pcie->port;
|
||||
|
||||
if (!pciehp_debug)
|
||||
return;
|
||||
|
|
@ -980,7 +943,7 @@ static inline void dbg_ctrl(struct controller *ctrl)
|
|||
(unsigned long long)pci_resource_start(pdev, i));
|
||||
}
|
||||
ctrl_info(ctrl, "Slot Capabilities : 0x%08x\n", ctrl->slot_cap);
|
||||
ctrl_info(ctrl, " Physical Slot Number : %d\n", ctrl->first_slot);
|
||||
ctrl_info(ctrl, " Physical Slot Number : %d\n", PSN(ctrl));
|
||||
ctrl_info(ctrl, " Attention Button : %3s\n",
|
||||
ATTN_BUTTN(ctrl) ? "yes" : "no");
|
||||
ctrl_info(ctrl, " Power Controller : %3s\n",
|
||||
|
|
@ -1014,10 +977,7 @@ struct controller *pcie_init(struct pcie_device *dev)
|
|||
dev_err(&dev->device, "%s: Out of memory\n", __func__);
|
||||
goto abort;
|
||||
}
|
||||
INIT_LIST_HEAD(&ctrl->slot_list);
|
||||
|
||||
ctrl->pcie = dev;
|
||||
ctrl->pci_dev = pdev;
|
||||
ctrl->cap_base = pci_find_capability(pdev, PCI_CAP_ID_EXP);
|
||||
if (!ctrl->cap_base) {
|
||||
ctrl_err(ctrl, "Cannot find PCI Express capability\n");
|
||||
|
|
@ -1029,11 +989,6 @@ struct controller *pcie_init(struct pcie_device *dev)
|
|||
}
|
||||
|
||||
ctrl->slot_cap = slot_cap;
|
||||
ctrl->first_slot = slot_cap >> 19;
|
||||
ctrl->slot_device_offset = 0;
|
||||
ctrl->num_slots = 1;
|
||||
ctrl->hpc_ops = &pciehp_hpc_ops;
|
||||
mutex_init(&ctrl->crit_sect);
|
||||
mutex_init(&ctrl->ctrl_lock);
|
||||
init_waitqueue_head(&ctrl->queue);
|
||||
dbg_ctrl(ctrl);
|
||||
|
|
@ -1089,7 +1044,7 @@ abort:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
void pcie_release_ctrl(struct controller *ctrl)
|
||||
void pciehp_release_ctrl(struct controller *ctrl)
|
||||
{
|
||||
pcie_shutdown_notification(ctrl);
|
||||
pcie_cleanup_slot(ctrl);
|
||||
|
|
|
|||
|
|
@ -63,27 +63,27 @@ static int __ref pciehp_add_bridge(struct pci_dev *dev)
|
|||
int pciehp_configure_device(struct slot *p_slot)
|
||||
{
|
||||
struct pci_dev *dev;
|
||||
struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
|
||||
struct pci_bus *parent = p_slot->ctrl->pcie->port->subordinate;
|
||||
int num, fn;
|
||||
struct controller *ctrl = p_slot->ctrl;
|
||||
|
||||
dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));
|
||||
dev = pci_get_slot(parent, PCI_DEVFN(0, 0));
|
||||
if (dev) {
|
||||
ctrl_err(ctrl, "Device %s already exists "
|
||||
"at %04x:%02x:%02x, cannot hot-add\n", pci_name(dev),
|
||||
pci_domain_nr(parent), p_slot->bus, p_slot->device);
|
||||
"at %04x:%02x:00, cannot hot-add\n", pci_name(dev),
|
||||
pci_domain_nr(parent), parent->number);
|
||||
pci_dev_put(dev);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
|
||||
num = pci_scan_slot(parent, PCI_DEVFN(0, 0));
|
||||
if (num == 0) {
|
||||
ctrl_err(ctrl, "No new device found\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
for (fn = 0; fn < 8; fn++) {
|
||||
dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, fn));
|
||||
dev = pci_get_slot(parent, PCI_DEVFN(0, fn));
|
||||
if (!dev)
|
||||
continue;
|
||||
if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
|
||||
|
|
@ -111,19 +111,18 @@ int pciehp_unconfigure_device(struct slot *p_slot)
|
|||
int j;
|
||||
u8 bctl = 0;
|
||||
u8 presence = 0;
|
||||
struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
|
||||
struct pci_bus *parent = p_slot->ctrl->pcie->port->subordinate;
|
||||
u16 command;
|
||||
struct controller *ctrl = p_slot->ctrl;
|
||||
|
||||
ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:%02x\n",
|
||||
__func__, pci_domain_nr(parent), p_slot->bus, p_slot->device);
|
||||
ret = p_slot->hpc_ops->get_adapter_status(p_slot, &presence);
|
||||
ctrl_dbg(ctrl, "%s: domain:bus:dev = %04x:%02x:00\n",
|
||||
__func__, pci_domain_nr(parent), parent->number);
|
||||
ret = pciehp_get_adapter_status(p_slot, &presence);
|
||||
if (ret)
|
||||
presence = 0;
|
||||
|
||||
for (j = 0; j < 8; j++) {
|
||||
struct pci_dev* temp = pci_get_slot(parent,
|
||||
(p_slot->device << 3) | j);
|
||||
struct pci_dev* temp = pci_get_slot(parent, PCI_DEVFN(0, j));
|
||||
if (!temp)
|
||||
continue;
|
||||
if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
|
||||
|
|
|
|||
|
|
@ -2776,7 +2776,15 @@ static void *intel_alloc_coherent(struct device *hwdev, size_t size,
|
|||
|
||||
size = PAGE_ALIGN(size);
|
||||
order = get_order(size);
|
||||
flags &= ~(GFP_DMA | GFP_DMA32);
|
||||
|
||||
if (!iommu_no_mapping(hwdev))
|
||||
flags &= ~(GFP_DMA | GFP_DMA32);
|
||||
else if (hwdev->coherent_dma_mask < dma_get_required_mask(hwdev)) {
|
||||
if (hwdev->coherent_dma_mask < DMA_BIT_MASK(32))
|
||||
flags |= GFP_DMA;
|
||||
else
|
||||
flags |= GFP_DMA32;
|
||||
}
|
||||
|
||||
vaddr = (void *)__get_free_pages(flags, order);
|
||||
if (!vaddr)
|
||||
|
|
@ -3216,6 +3224,33 @@ static int __init init_iommu_sysfs(void)
|
|||
}
|
||||
#endif /* CONFIG_PM */
|
||||
|
||||
/*
|
||||
* Here we only respond to action of unbound device from driver.
|
||||
*
|
||||
* Added device is not attached to its DMAR domain here yet. That will happen
|
||||
* when mapping the device to iova.
|
||||
*/
|
||||
static int device_notifier(struct notifier_block *nb,
|
||||
unsigned long action, void *data)
|
||||
{
|
||||
struct device *dev = data;
|
||||
struct pci_dev *pdev = to_pci_dev(dev);
|
||||
struct dmar_domain *domain;
|
||||
|
||||
domain = find_domain(pdev);
|
||||
if (!domain)
|
||||
return 0;
|
||||
|
||||
if (action == BUS_NOTIFY_UNBOUND_DRIVER && !iommu_pass_through)
|
||||
domain_remove_one_dev_info(domain, pdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct notifier_block device_nb = {
|
||||
.notifier_call = device_notifier,
|
||||
};
|
||||
|
||||
int __init intel_iommu_init(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
|
@ -3240,7 +3275,7 @@ int __init intel_iommu_init(void)
|
|||
* Check the need for DMA-remapping initialization now.
|
||||
* Above initialization will also be used by Interrupt-remapping.
|
||||
*/
|
||||
if (no_iommu || swiotlb || dmar_disabled)
|
||||
if (no_iommu || dmar_disabled)
|
||||
return -ENODEV;
|
||||
|
||||
iommu_init_mempool();
|
||||
|
|
@ -3261,13 +3296,17 @@ int __init intel_iommu_init(void)
|
|||
"PCI-DMA: Intel(R) Virtualization Technology for Directed I/O\n");
|
||||
|
||||
init_timer(&unmap_timer);
|
||||
force_iommu = 1;
|
||||
#ifdef CONFIG_SWIOTLB
|
||||
swiotlb = 0;
|
||||
#endif
|
||||
dma_ops = &intel_dma_ops;
|
||||
|
||||
init_iommu_sysfs();
|
||||
|
||||
register_iommu(&intel_iommu_ops);
|
||||
|
||||
bus_register_notifier(&pci_bus_type, &device_nb);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -513,7 +513,11 @@ static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
|
|||
else if (state == PCI_D2 || dev->current_state == PCI_D2)
|
||||
udelay(PCI_PM_D2_DELAY);
|
||||
|
||||
dev->current_state = state;
|
||||
pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
|
||||
dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);
|
||||
if (dev->current_state != state && printk_ratelimit())
|
||||
dev_info(&dev->dev, "Refused to change power state, "
|
||||
"currently in D%d\n", dev->current_state);
|
||||
|
||||
/* According to section 5.4.1 of the "PCI BUS POWER MANAGEMENT
|
||||
* INTERFACE SPECIFICATION, REV. 1.2", a device transitioning
|
||||
|
|
@ -2542,10 +2546,10 @@ int pci_resource_bar(struct pci_dev *dev, int resno, enum pci_bar_type *type)
|
|||
|
||||
/**
|
||||
* pci_set_vga_state - set VGA decode state on device and parents if requested
|
||||
* @dev the PCI device
|
||||
* @decode - true = enable decoding, false = disable decoding
|
||||
* @command_bits PCI_COMMAND_IO and/or PCI_COMMAND_MEMORY
|
||||
* @change_bridge - traverse ancestors and change bridges
|
||||
* @dev: the PCI device
|
||||
* @decode: true = enable decoding, false = disable decoding
|
||||
* @command_bits: PCI_COMMAND_IO and/or PCI_COMMAND_MEMORY
|
||||
* @change_bridge: traverse ancestors and change bridges
|
||||
*/
|
||||
int pci_set_vga_state(struct pci_dev *dev, bool decode,
|
||||
unsigned int command_bits, bool change_bridge)
|
||||
|
|
@ -2719,17 +2723,6 @@ int __attribute__ ((weak)) pci_ext_cfg_avail(struct pci_dev *dev)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int __devinit pci_init(void)
|
||||
{
|
||||
struct pci_dev *dev = NULL;
|
||||
|
||||
while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
|
||||
pci_fixup_device(pci_fixup_final, dev);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init pci_setup(char *str)
|
||||
{
|
||||
while (str) {
|
||||
|
|
@ -2767,8 +2760,6 @@ static int __init pci_setup(char *str)
|
|||
}
|
||||
early_param("pci", pci_setup);
|
||||
|
||||
device_initcall(pci_init);
|
||||
|
||||
EXPORT_SYMBOL(pci_reenable_device);
|
||||
EXPORT_SYMBOL(pci_enable_device_io);
|
||||
EXPORT_SYMBOL(pci_enable_device_mem);
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/pm.h>
|
||||
|
|
@ -52,7 +53,7 @@ static struct pci_error_handlers aer_error_handlers = {
|
|||
|
||||
static struct pcie_port_service_driver aerdriver = {
|
||||
.name = "aer",
|
||||
.port_type = PCIE_ANY_PORT,
|
||||
.port_type = PCIE_RC_PORT,
|
||||
.service = PCIE_PORT_SERVICE_AER,
|
||||
|
||||
.probe = aer_probe,
|
||||
|
|
@ -318,6 +319,8 @@ static int __init aer_service_init(void)
|
|||
{
|
||||
if (pcie_aer_disable)
|
||||
return -ENXIO;
|
||||
if (!pci_msi_enabled())
|
||||
return -ENXIO;
|
||||
return pcie_port_service_register(&aerdriver);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -303,9 +303,6 @@ static void pcie_get_aspm_reg(struct pci_dev *pdev,
|
|||
pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
|
||||
pci_read_config_dword(pdev, pos + PCI_EXP_LNKCAP, ®32);
|
||||
info->support = (reg32 & PCI_EXP_LNKCAP_ASPMS) >> 10;
|
||||
/* 00b and 10b are defined as "Reserved". */
|
||||
if (info->support == PCIE_LINK_STATE_L1)
|
||||
info->support = 0;
|
||||
info->latency_encoding_l0s = (reg32 & PCI_EXP_LNKCAP_L0SEL) >> 12;
|
||||
info->latency_encoding_l1 = (reg32 & PCI_EXP_LNKCAP_L1EL) >> 15;
|
||||
pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, ®16);
|
||||
|
|
@ -659,8 +656,10 @@ void pcie_aspm_exit_link_state(struct pci_dev *pdev)
|
|||
free_link_state(link);
|
||||
|
||||
/* Recheck latencies and configure upstream links */
|
||||
pcie_update_aspm_capable(root);
|
||||
pcie_config_aspm_path(parent_link);
|
||||
if (parent_link) {
|
||||
pcie_update_aspm_capable(root);
|
||||
pcie_config_aspm_path(parent_link);
|
||||
}
|
||||
out:
|
||||
mutex_unlock(&aspm_lock);
|
||||
up_read(&pci_bus_sem);
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@ MODULE_DESCRIPTION(DRIVER_DESC);
|
|||
MODULE_LICENSE("GPL");
|
||||
|
||||
/* global data */
|
||||
static const char device_name[] = "pcieport-driver";
|
||||
|
||||
static int pcie_portdrv_restore_config(struct pci_dev *dev)
|
||||
{
|
||||
|
|
@ -262,7 +261,7 @@ static struct pci_error_handlers pcie_portdrv_err_handler = {
|
|||
};
|
||||
|
||||
static struct pci_driver pcie_portdriver = {
|
||||
.name = (char *)device_name,
|
||||
.name = "pcieport",
|
||||
.id_table = &port_pci_ids[0],
|
||||
|
||||
.probe = pcie_portdrv_probe,
|
||||
|
|
|
|||
|
|
@ -670,6 +670,25 @@ static void __devinit quirk_vt8235_acpi(struct pci_dev *dev)
|
|||
}
|
||||
DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235, quirk_vt8235_acpi);
|
||||
|
||||
/*
|
||||
* TI XIO2000a PCIe-PCI Bridge erroneously reports it supports fast back-to-back:
|
||||
* Disable fast back-to-back on the secondary bus segment
|
||||
*/
|
||||
static void __devinit quirk_xio2000a(struct pci_dev *dev)
|
||||
{
|
||||
struct pci_dev *pdev;
|
||||
u16 command;
|
||||
|
||||
dev_warn(&dev->dev, "TI XIO2000a quirk detected; "
|
||||
"secondary bus fast back-to-back transfers disabled\n");
|
||||
list_for_each_entry(pdev, &dev->subordinate->devices, bus_list) {
|
||||
pci_read_config_word(pdev, PCI_COMMAND, &command);
|
||||
if (command & PCI_COMMAND_FAST_BACK)
|
||||
pci_write_config_word(pdev, PCI_COMMAND, command & ~PCI_COMMAND_FAST_BACK);
|
||||
}
|
||||
}
|
||||
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XIO2000A,
|
||||
quirk_xio2000a);
|
||||
|
||||
#ifdef CONFIG_X86_IO_APIC
|
||||
|
||||
|
|
@ -990,7 +1009,7 @@ DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454NX,
|
|||
|
||||
static void __devinit quirk_amd_ide_mode(struct pci_dev *pdev)
|
||||
{
|
||||
/* set SBX00 SATA in IDE mode to AHCI mode */
|
||||
/* set SBX00/Hudson-2 SATA in IDE mode to AHCI mode */
|
||||
u8 tmp;
|
||||
|
||||
pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &tmp);
|
||||
|
|
@ -1009,8 +1028,8 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_SATA, quirk
|
|||
DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_SATA, quirk_amd_ide_mode);
|
||||
DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP700_SATA, quirk_amd_ide_mode);
|
||||
DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP700_SATA, quirk_amd_ide_mode);
|
||||
DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SB900_SATA_IDE, quirk_amd_ide_mode);
|
||||
DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SB900_SATA_IDE, quirk_amd_ide_mode);
|
||||
DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_HUDSON2_SATA_IDE, quirk_amd_ide_mode);
|
||||
DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_HUDSON2_SATA_IDE, quirk_amd_ide_mode);
|
||||
|
||||
/*
|
||||
* Serverworks CSB5 IDE does not fully support native mode
|
||||
|
|
@ -2572,6 +2591,19 @@ void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev)
|
|||
}
|
||||
pci_do_fixups(dev, start, end);
|
||||
}
|
||||
|
||||
static int __init pci_apply_final_quirks(void)
|
||||
{
|
||||
struct pci_dev *dev = NULL;
|
||||
|
||||
while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
|
||||
pci_fixup_device(pci_fixup_final, dev);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
fs_initcall_sync(pci_apply_final_quirks);
|
||||
#else
|
||||
void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev) {}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -205,43 +205,6 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
|
|||
return ret;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int pci_assign_resource_fixed(struct pci_dev *dev, int resno)
|
||||
{
|
||||
struct pci_bus *bus = dev->bus;
|
||||
struct resource *res = dev->resource + resno;
|
||||
unsigned int type_mask;
|
||||
int i, ret = -EBUSY;
|
||||
|
||||
type_mask = IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH;
|
||||
|
||||
for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
|
||||
struct resource *r = bus->resource[i];
|
||||
if (!r)
|
||||
continue;
|
||||
|
||||
/* type_mask must match */
|
||||
if ((res->flags ^ r->flags) & type_mask)
|
||||
continue;
|
||||
|
||||
ret = request_resource(r, res);
|
||||
|
||||
if (ret == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret) {
|
||||
dev_err(&dev->dev, "BAR %d: can't allocate %s resource %pR\n",
|
||||
resno, res->flags & IORESOURCE_IO ? "I/O" : "mem", res);
|
||||
} else if (resno < PCI_BRIDGE_RESOURCES) {
|
||||
pci_update_resource(dev, resno);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pci_assign_resource_fixed);
|
||||
#endif
|
||||
|
||||
/* Sort resources by alignment */
|
||||
void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in a new issue