hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[PATCH] PCI Hotplug: add common acpi functions to core 

shpchprm_acpi.c and pciehprm_acpi.c are nearly identical.  In addition,
there are functions in both these files that are also in acpiphp_glue.c.
This patch will remove duplicate functions from shpchp, pciehp, and
acpiphp and move this functionality to pci_hotplug, as it is not
hardware specific.  Get rid of shpchprm* and pciehprm* files since they
are no longer needed.  shpchprm_nonacpi.c and pciehprm_nonacpi.c are
identical, as well as shpchprm_legacy.c and can be replaced with a
macro.

This patch also changes acpiphp to use the common hpp code.

Signed-off-by:  Kristen Carlson Accardi <kristen.c.accardi@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Kristen Accardi 2006-03-03 10:16:05 -08:00 committed by Greg Kroah-Hartman
parent f5afe8064f
commit 783c49fc50
14 changed files with 254 additions and 591 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
drivers/pci/hotplug/Makefile
View File

@ -22,6 +22,9 @@ ifdef CONFIG_HOTPLUG_PCI_CPCI
pci_hotplug-objs += cpci_hotplug_core.o \ pci_hotplug-objs += cpci_hotplug_core.o \
cpci_hotplug_pci.o cpci_hotplug_pci.o
endif endif
ifdef CONFIG_ACPI
pci_hotplug-objs += acpi_pcihp.o
endif
cpqphp-objs := cpqphp_core.o \ cpqphp-objs := cpqphp_core.o \
cpqphp_ctrl.o \ cpqphp_ctrl.o \
@ -51,23 +54,9 @@ pciehp-objs := pciehp_core.o \
pciehp_ctrl.o \ pciehp_ctrl.o \
pciehp_pci.o \ pciehp_pci.o \
pciehp_hpc.o pciehp_hpc.o
ifdef CONFIG_ACPI
pciehp-objs += pciehprm_acpi.o
else
pciehp-objs += pciehprm_nonacpi.o
endif
shpchp-objs := shpchp_core.o \ shpchp-objs := shpchp_core.o \
shpchp_ctrl.o \ shpchp_ctrl.o \
shpchp_pci.o \ shpchp_pci.o \
shpchp_sysfs.o \ shpchp_sysfs.o \
shpchp_hpc.o shpchp_hpc.o
ifdef CONFIG_ACPI
shpchp-objs += shpchprm_acpi.o
else
ifdef CONFIG_HOTPLUG_PCI_SHPC_PHPRM_LEGACY
shpchp-objs += shpchprm_legacy.o
else
shpchp-objs += shpchprm_nonacpi.o
endif
endif

206
drivers/pci/hotplug/pciehprm_acpi.c → drivers/pci/hotplug/acpi_pcihp.c
View File

@ -1,7 +1,7 @@
/* /*
* PCIEHPRM ACPI: PHP Resource Manager for ACPI platform * Common ACPI functions for hot plug platforms
* *
* Copyright (C) 2003-2004 Intel Corporation * Copyright (C) 2006 Intel Corporation
* *
* All rights reserved. * All rights reserved.
* *
@ -28,30 +28,37 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/acpi.h> #include <acpi/acpi.h>
#include <linux/pci-acpi.h>
#include <acpi/acpi_bus.h> #include <acpi/acpi_bus.h>
#include <acpi/actypes.h> #include <acpi/actypes.h>
#include "pciehp.h" #include "pci_hotplug.h"
#define METHOD_NAME__SUN "_SUN" #define METHOD_NAME__SUN "_SUN"
#define METHOD_NAME__HPP "_HPP" #define METHOD_NAME__HPP "_HPP"
#define METHOD_NAME_OSHP "OSHP" #define METHOD_NAME_OSHP "OSHP"
static u8 * acpi_path_name( acpi_handle handle) /* acpi_path_name
*
* @handle - the acpi_handle of the object who's name you want.
*
* Caller must free buffer.
*/
u8 * acpi_path_name(acpi_handle handle)
{ {
acpi_status status; acpi_status status;
static u8 path_name[ACPI_PATHNAME_MAX]; struct acpi_buffer ret_buf = {ACPI_ALLOCATE_BUFFER, NULL};
struct acpi_buffer ret_buf = { ACPI_PATHNAME_MAX, path_name }; union acpi_object *obj;
memset(path_name, 0, sizeof (path_name));
status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf); status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf);
if (ACPI_FAILURE(status)) {
if (ACPI_FAILURE(status))
return NULL; return NULL;
else }
return path_name; obj = ret_buf.pointer;
return obj->string.pointer;
} }
EXPORT_SYMBOL_GPL(acpi_path_name);
static acpi_status static acpi_status
acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp) acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
@ -69,8 +76,9 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
case AE_BUFFER_OVERFLOW: case AE_BUFFER_OVERFLOW:
ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL); ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL);
if (!ret_buf.pointer) { if (!ret_buf.pointer) {
err ("%s:%s alloc for _HPP fail\n", __FUNCTION__, printk(KERN_ERR "%s:%s alloc for _HPP fail\n",
path_name); __FUNCTION__, path_name);
acpi_os_free(path_name);
return AE_NO_MEMORY; return AE_NO_MEMORY;
} }
status = acpi_evaluate_object(handle, METHOD_NAME__HPP, status = acpi_evaluate_object(handle, METHOD_NAME__HPP,
@ -79,15 +87,16 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
break; break;
default: default:
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status)) {
dbg("%s:%s _HPP fail=0x%x\n", __FUNCTION__, pr_debug("%s:%s _HPP fail=0x%x\n", __FUNCTION__,
path_name, status); path_name, status);
acpi_os_free(path_name);
return status; return status;
} }
} }
ext_obj = (union acpi_object *) ret_buf.pointer; ext_obj = (union acpi_object *) ret_buf.pointer;
if (ext_obj->type != ACPI_TYPE_PACKAGE) { if (ext_obj->type != ACPI_TYPE_PACKAGE) {
err ("%s:%s _HPP obj not a package\n", __FUNCTION__, printk(KERN_ERR "%s:%s _HPP obj not a package\n", __FUNCTION__,
path_name); path_name);
status = AE_ERROR; status = AE_ERROR;
goto free_and_return; goto free_and_return;
@ -102,8 +111,8 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
nui[i] = (u8)ext_obj->integer.value; nui[i] = (u8)ext_obj->integer.value;
break; break;
default: default:
err ("%s:%s _HPP obj type incorrect\n", __FUNCTION__, printk(KERN_ERR "%s:%s _HPP obj type incorrect\n",
path_name); __FUNCTION__, path_name);
status = AE_ERROR; status = AE_ERROR;
goto free_and_return; goto free_and_return;
} }
@ -114,33 +123,79 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
hpp->enable_serr = nui[2]; hpp->enable_serr = nui[2];
hpp->enable_perr = nui[3]; hpp->enable_perr = nui[3];
dbg(" _HPP: cache_line_size=0x%x\n", hpp->cache_line_size); pr_debug(" _HPP: cache_line_size=0x%x\n", hpp->cache_line_size);
dbg(" _HPP: latency timer =0x%x\n", hpp->latency_timer); pr_debug(" _HPP: latency timer =0x%x\n", hpp->latency_timer);
dbg(" _HPP: enable SERR =0x%x\n", hpp->enable_serr); pr_debug(" _HPP: enable SERR =0x%x\n", hpp->enable_serr);
dbg(" _HPP: enable PERR =0x%x\n", hpp->enable_perr); pr_debug(" _HPP: enable PERR =0x%x\n", hpp->enable_perr);
free_and_return: free_and_return:
acpi_os_free(path_name);
kfree(ret_buf.pointer); kfree(ret_buf.pointer);
return status; return status;
} }
static acpi_status acpi_run_oshp(acpi_handle handle)
/* acpi_run_oshp - get control of hotplug from the firmware
*
* @handle - the handle of the hotplug controller.
*/
acpi_status acpi_run_oshp(acpi_handle handle)
{ {
acpi_status status; acpi_status status;
u8 *path_name = acpi_path_name(handle); u8 *path_name = acpi_path_name(handle);
/* run OSHP */ /* run OSHP */
status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL); status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL);
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status))
dbg("%s:%s OSHP fails=0x%x\n", __FUNCTION__, path_name, printk(KERN_ERR "%s:%s OSHP fails=0x%x\n", __FUNCTION__,
status); path_name, status);
} else { else
dbg("%s:%s OSHP passes\n", __FUNCTION__, path_name); pr_debug("%s:%s OSHP passes\n", __FUNCTION__, path_name);
acpi_os_free(path_name);
return status;
}
EXPORT_SYMBOL_GPL(acpi_run_oshp);
/* acpi_get_hp_params_from_firmware
*
* @dev - the pci_dev of the newly added device
* @hpp - allocated by the caller
*/
acpi_status acpi_get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
acpi_status status = AE_NOT_FOUND;
struct pci_dev *pdev = dev;
/*
* _HPP settings apply to all child buses, until another _HPP is
* encountered. If we don't find an _HPP for the input pci dev,
* look for it in the parent device scope since that would apply to
* this pci dev. If we don't find any _HPP, use hardcoded defaults
*/
while (pdev && (ACPI_FAILURE(status))) {
acpi_handle handle = DEVICE_ACPI_HANDLE(&(pdev->dev));
if (!handle)
break;
status = acpi_run_hpp(handle, hpp);
if (!(pdev->bus->parent))
break;
/* Check if a parent object supports _HPP */
pdev = pdev->bus->parent->self;
} }
return status; return status;
} }
EXPORT_SYMBOL_GPL(acpi_get_hp_params_from_firmware);
static int is_root_bridge(acpi_handle handle)
/* acpi_root_bridge - check to see if this acpi object is a root bridge
*
* @handle - the acpi object in question.
*/
int acpi_root_bridge(acpi_handle handle)
{ {
acpi_status status; acpi_status status;
struct acpi_device_info *info; struct acpi_device_info *info;
@ -165,93 +220,8 @@ static int is_root_bridge(acpi_handle handle)
} }
} }
} }
acpi_os_free(buffer.pointer);
} }
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(acpi_root_bridge);
int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev)
{
acpi_status status;
acpi_handle chandle, handle = DEVICE_ACPI_HANDLE(&(dev->dev));
struct pci_dev *pdev = dev;
struct pci_bus *parent;
u8 *path_name;
/*
* Per PCI firmware specification, we should run the ACPI _OSC
* method to get control of hotplug hardware before using it.
* If an _OSC is missing, we look for an OSHP to do the same thing.
* To handle different BIOS behavior, we look for _OSC and OSHP
* within the scope of the hotplug controller and its parents, upto
* the host bridge under which this controller exists.
*/
while (!handle) {
/*
* This hotplug controller was not listed in the ACPI name
* space at all. Try to get acpi handle of parent pci bus.
*/
if (!pdev || !pdev->bus->parent)
break;
parent = pdev->bus->parent;
dbg("Could not find %s in acpi namespace, trying parent\n",
pci_name(pdev));
if (!parent->self)
/* Parent must be a host bridge */
handle = acpi_get_pci_rootbridge_handle(
pci_domain_nr(parent),
parent->number);
else
handle = DEVICE_ACPI_HANDLE(
&(parent->self->dev));
pdev = parent->self;
}
while (handle) {
path_name = acpi_path_name(handle);
dbg("Trying to get hotplug control for %s \n", path_name);
status = pci_osc_control_set(handle,
OSC_PCI_EXPRESS_NATIVE_HP_CONTROL);
if (status == AE_NOT_FOUND)
status = acpi_run_oshp(handle);
if (ACPI_SUCCESS(status)) {
dbg("Gained control for hotplug HW for pci %s (%s)\n",
pci_name(dev), path_name);
return 0;
}
if (is_root_bridge(handle))
break;
chandle = handle;
status = acpi_get_parent(chandle, &handle);
if (ACPI_FAILURE(status))
break;
}
err("Cannot get control of hotplug hardware for pci %s\n",
pci_name(dev));
return -1;
}
void pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
acpi_status status = AE_NOT_FOUND;
struct pci_dev *pdev = dev;
/*
* _HPP settings apply to all child buses, until another _HPP is
* encountered. If we don't find an _HPP for the input pci dev,
* look for it in the parent device scope since that would apply to
* this pci dev. If we don't find any _HPP, use hardcoded defaults
*/
while (pdev && (ACPI_FAILURE(status))) {
acpi_handle handle = DEVICE_ACPI_HANDLE(&(pdev->dev));
if (!handle)
break;
status = acpi_run_hpp(handle, hpp);
if (!(pdev->bus->parent))
break;
/* Check if a parent object supports _HPP */
pdev = pdev->bus->parent->self;
}
}

15
drivers/pci/hotplug/acpiphp.h
View File

@ -64,19 +64,6 @@ struct slot {
struct acpiphp_slot *acpi_slot; struct acpiphp_slot *acpi_slot;
}; };
/**
* struct hpp_param - ACPI 2.0 _HPP Hot Plug Parameters
* @cache_line_size in DWORD
* @latency_timer in PCI clock
* @enable_SERR 0 or 1
* @enable_PERR 0 or 1
*/
struct hpp_param {
u8 cache_line_size;
u8 latency_timer;
u8 enable_SERR;
u8 enable_PERR;
};
/** /**
@ -100,7 +87,7 @@ struct acpiphp_bridge {
struct pci_dev *pci_dev; struct pci_dev *pci_dev;
/* ACPI 2.0 _HPP parameters */ /* ACPI 2.0 _HPP parameters */
struct hpp_param hpp; struct hotplug_params hpp;
spinlock_t res_lock; spinlock_t res_lock;
}; };

91
drivers/pci/hotplug/acpiphp_glue.c
View File

@ -285,57 +285,19 @@ static int detect_ejectable_slots(acpi_handle *bridge_handle)
static void decode_hpp(struct acpiphp_bridge *bridge) static void decode_hpp(struct acpiphp_bridge *bridge)
{ {
acpi_status status; acpi_status status;
struct acpi_buffer buffer = { .length = ACPI_ALLOCATE_BUFFER,
.pointer = NULL};
union acpi_object *package;
int i;
/* default numbers */
bridge->hpp.cache_line_size = 0x10;
bridge->hpp.latency_timer = 0x40;
bridge->hpp.enable_SERR = 0;
bridge->hpp.enable_PERR = 0;
status = acpi_evaluate_object(bridge->handle, "_HPP", NULL, &buffer);
status = acpi_get_hp_params_from_firmware(bridge->pci_dev, &bridge->hpp);
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status)) {
dbg("_HPP evaluation failed\n"); /* use default numbers */
return; bridge->hpp.cache_line_size = 0x10;
bridge->hpp.latency_timer = 0x40;
bridge->hpp.enable_serr = 0;
bridge->hpp.enable_perr = 0;
} }
package = (union acpi_object *) buffer.pointer;
if (!package || package->type != ACPI_TYPE_PACKAGE ||
package->package.count != 4 || !package->package.elements) {
err("invalid _HPP object; ignoring\n");
goto err_exit;
}
for (i = 0; i < 4; i++) {
if (package->package.elements[i].type != ACPI_TYPE_INTEGER) {
err("invalid _HPP parameter type; ignoring\n");
goto err_exit;
}
}
bridge->hpp.cache_line_size = package->package.elements[0].integer.value;
bridge->hpp.latency_timer = package->package.elements[1].integer.value;
bridge->hpp.enable_SERR = package->package.elements[2].integer.value;
bridge->hpp.enable_PERR = package->package.elements[3].integer.value;
dbg("_HPP parameter = (%02x, %02x, %02x, %02x)\n",
bridge->hpp.cache_line_size,
bridge->hpp.latency_timer,
bridge->hpp.enable_SERR,
bridge->hpp.enable_PERR);
bridge->flags |= BRIDGE_HAS_HPP;
err_exit:
kfree(buffer.pointer);
} }
/* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */ /* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */
static void init_bridge_misc(struct acpiphp_bridge *bridge) static void init_bridge_misc(struct acpiphp_bridge *bridge)
{ {
@ -1154,11 +1116,11 @@ static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge)
pci_write_config_byte(dev, PCI_LATENCY_TIMER, pci_write_config_byte(dev, PCI_LATENCY_TIMER,
bridge->hpp.latency_timer); bridge->hpp.latency_timer);
pci_read_config_word(dev, PCI_COMMAND, &pci_cmd); pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
if (bridge->hpp.enable_SERR) if (bridge->hpp.enable_serr)
pci_cmd |= PCI_COMMAND_SERR; pci_cmd |= PCI_COMMAND_SERR;
else else
pci_cmd &= ~PCI_COMMAND_SERR; pci_cmd &= ~PCI_COMMAND_SERR;
if (bridge->hpp.enable_PERR) if (bridge->hpp.enable_perr)
pci_cmd |= PCI_COMMAND_PARITY; pci_cmd |= PCI_COMMAND_PARITY;
else else
pci_cmd &= ~PCI_COMMAND_PARITY; pci_cmd &= ~PCI_COMMAND_PARITY;
@ -1169,11 +1131,11 @@ static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge)
pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
bridge->hpp.latency_timer); bridge->hpp.latency_timer);
pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl); pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
if (bridge->hpp.enable_SERR) if (bridge->hpp.enable_serr)
pci_bctl |= PCI_BRIDGE_CTL_SERR; pci_bctl |= PCI_BRIDGE_CTL_SERR;
else else
pci_bctl &= ~PCI_BRIDGE_CTL_SERR; pci_bctl &= ~PCI_BRIDGE_CTL_SERR;
if (bridge->hpp.enable_PERR) if (bridge->hpp.enable_perr)
pci_bctl |= PCI_BRIDGE_CTL_PARITY; pci_bctl |= PCI_BRIDGE_CTL_PARITY;
else else
pci_bctl &= ~PCI_BRIDGE_CTL_PARITY; pci_bctl &= ~PCI_BRIDGE_CTL_PARITY;
@ -1193,6 +1155,7 @@ static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus)
memset(&bridge, 0, sizeof(bridge)); memset(&bridge, 0, sizeof(bridge));
bridge.handle = handle; bridge.handle = handle;
bridge.pci_dev = bus->self;
decode_hpp(&bridge); decode_hpp(&bridge);
list_for_each_entry(dev, &bus->devices, bus_list) list_for_each_entry(dev, &bus->devices, bus_list)
program_hpp(dev, &bridge); program_hpp(dev, &bridge);
@ -1409,41 +1372,13 @@ void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context)
} }
} }
static int is_root_bridge(acpi_handle handle)
{
acpi_status status;
struct acpi_device_info *info;
struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
int i;
status = acpi_get_object_info(handle, &buffer);
if (ACPI_SUCCESS(status)) {
info = buffer.pointer;
if ((info->valid & ACPI_VALID_HID) &&
!strcmp(PCI_ROOT_HID_STRING,
info->hardware_id.value)) {
acpi_os_free(buffer.pointer);
return 1;
}
if (info->valid & ACPI_VALID_CID) {
for (i=0; i < info->compatibility_id.count; i++) {
if (!strcmp(PCI_ROOT_HID_STRING,
info->compatibility_id.id[i].value)) {
acpi_os_free(buffer.pointer);
return 1;
}
}
}
}
return 0;
}
static acpi_status static acpi_status
find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
{ {
int *count = (int *)context; int *count = (int *)context;
if (is_root_bridge(handle)) { if (acpi_root_bridge(handle)) {
acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
handle_hotplug_event_bridge, NULL); handle_hotplug_event_bridge, NULL);
(*count)++; (*count)++;

17
drivers/pci/hotplug/pci_hotplug.h
View File

@ -176,5 +176,22 @@ extern int pci_hp_change_slot_info (struct hotplug_slot *slot,
struct hotplug_slot_info *info); struct hotplug_slot_info *info);
extern struct subsystem pci_hotplug_slots_subsys; extern struct subsystem pci_hotplug_slots_subsys;
struct hotplug_params {
u8 cache_line_size;
u8 latency_timer;
u8 enable_serr;
u8 enable_perr;
};
#ifdef CONFIG_ACPI
#include <acpi/acpi.h>
#include <acpi/acpi_bus.h>
#include <acpi/actypes.h>
extern acpi_status acpi_run_oshp(acpi_handle handle);
extern acpi_status acpi_get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp);
extern u8 * acpi_path_name(acpi_handle handle);
int acpi_root_bridge(acpi_handle handle);
#endif
#endif #endif

24
drivers/pci/hotplug/pciehp.h
View File

@ -50,12 +50,6 @@ extern int pciehp_force;
#define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg) #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
#define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg) #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
struct hotplug_params {
u8 cache_line_size;
u8 latency_timer;
u8 enable_serr;
u8 enable_perr;
};
struct slot { struct slot {
struct slot *next; struct slot *next;
@ -192,9 +186,6 @@ extern u8 pciehp_handle_power_fault (u8 hp_slot, void *inst_id);
/* pci functions */ /* pci functions */
extern int pciehp_configure_device (struct slot *p_slot); extern int pciehp_configure_device (struct slot *p_slot);
extern int pciehp_unconfigure_device (struct slot *p_slot); extern int pciehp_unconfigure_device (struct slot *p_slot);
extern int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev);
extern void pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp);
@ -286,4 +277,19 @@ struct hpc_ops {
int (*check_lnk_status) (struct controller *ctrl); int (*check_lnk_status) (struct controller *ctrl);
}; };
#ifdef CONFIG_ACPI
#define pciehp_get_hp_hw_control_from_firmware(dev) \
pciehp_acpi_get_hp_hw_control_from_firmware(dev)
static inline int pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
if (ACPI_FAILURE(acpi_get_hp_params_from_firmware(dev, hpp)))
return -ENODEV;
return 0;
}
#else
#define pciehp_get_hp_hw_control_from_firmware(dev) 0
#define pciehp_get_hp_params_from_firmware(dev, hpp) (-ENODEV)
#endif /* CONFIG_ACPI */
#endif /* _PCIEHP_H */ #endif /* _PCIEHP_H */

74
drivers/pci/hotplug/pciehp_hpc.c
View File

@ -38,7 +38,10 @@
#include "../pci.h" #include "../pci.h"
#include "pciehp.h" #include "pciehp.h"
#include <acpi/acpi.h>
#include <acpi/acpi_bus.h>
#include <acpi/actypes.h>
#include <linux/pci-acpi.h>
#ifdef DEBUG #ifdef DEBUG
#define DBG_K_TRACE_ENTRY ((unsigned int)0x00000001) /* On function entry */ #define DBG_K_TRACE_ENTRY ((unsigned int)0x00000001) /* On function entry */
#define DBG_K_TRACE_EXIT ((unsigned int)0x00000002) /* On function exit */ #define DBG_K_TRACE_EXIT ((unsigned int)0x00000002) /* On function exit */
@ -1236,6 +1239,75 @@ static struct hpc_ops pciehp_hpc_ops = {
.check_lnk_status = hpc_check_lnk_status, .check_lnk_status = hpc_check_lnk_status,
}; };
#ifdef CONFIG_ACPI
int pciehp_acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev)
{
acpi_status status;
acpi_handle chandle, handle = DEVICE_ACPI_HANDLE(&(dev->dev));
struct pci_dev *pdev = dev;
struct pci_bus *parent;
u8 *path_name = NULL;
/*
* Per PCI firmware specification, we should run the ACPI _OSC
* method to get control of hotplug hardware before using it.
* If an _OSC is missing, we look for an OSHP to do the same thing.
* To handle different BIOS behavior, we look for _OSC and OSHP
* within the scope of the hotplug controller and its parents, upto
* the host bridge under which this controller exists.
*/
while (!handle) {
/*
* This hotplug controller was not listed in the ACPI name
* space at all. Try to get acpi handle of parent pci bus.
*/
if (!pdev || !pdev->bus->parent)
break;
parent = pdev->bus->parent;
dbg("Could not find %s in acpi namespace, trying parent\n",
pci_name(pdev));
if (!parent->self)
/* Parent must be a host bridge */
handle = acpi_get_pci_rootbridge_handle(
pci_domain_nr(parent),
parent->number);
else
handle = DEVICE_ACPI_HANDLE(
&(parent->self->dev));
pdev = parent->self;
}
while (handle) {
path_name = acpi_path_name(handle);
dbg("Trying to get hotplug control for %s \n", path_name);
status = pci_osc_control_set(handle,
OSC_PCI_EXPRESS_NATIVE_HP_CONTROL);
if (status == AE_NOT_FOUND)
status = acpi_run_oshp(handle);
if (ACPI_SUCCESS(status)) {
dbg("Gained control for hotplug HW for pci %s (%s)\n",
pci_name(dev), path_name);
acpi_os_free(path_name);
return 0;
}
if (acpi_root_bridge(handle))
break;
chandle = handle;
status = acpi_get_parent(chandle, &handle);
if (ACPI_FAILURE(status))
break;
}
err("Cannot get control of hotplug hardware for pci %s\n",
pci_name(dev));
if (path_name)
acpi_os_free(path_name);
return -1;
}
#endif
int pcie_init(struct controller * ctrl, struct pcie_device *dev) int pcie_init(struct controller * ctrl, struct pcie_device *dev)
{ {
struct php_ctlr_state_s *php_ctlr, *p; struct php_ctlr_state_s *php_ctlr, *p;

47
drivers/pci/hotplug/pciehprm_nonacpi.c
View File

@ -1,47 +0,0 @@
/*
* PCIEHPRM NONACPI: PHP Resource Manager for Non-ACPI/Legacy platform
*
* Copyright (C) 1995,2001 Compaq Computer Corporation
* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
* Copyright (C) 2001 IBM Corp.
* Copyright (C) 2003-2004 Intel Corporation
*
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
* NON INFRINGEMENT. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
*
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include "pciehp.h"
void pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
return;
}
int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev)
{
return 0;
}

30
drivers/pci/hotplug/shpchp.h
View File

@ -106,12 +106,6 @@ struct controller {
volatile int cmd_busy; volatile int cmd_busy;
}; };
struct hotplug_params {
u8 cache_line_size;
u8 latency_timer;
u8 enable_serr;
u8 enable_perr;
};
/* Define AMD SHPC ID */ /* Define AMD SHPC ID */
#define PCI_DEVICE_ID_AMD_GOLAM_7450 0x7450 #define PCI_DEVICE_ID_AMD_GOLAM_7450 0x7450
@ -193,15 +187,29 @@ extern u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id);
extern int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num); extern int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num);
extern int shpchp_configure_device(struct slot *p_slot); extern int shpchp_configure_device(struct slot *p_slot);
extern int shpchp_unconfigure_device(struct slot *p_slot); extern int shpchp_unconfigure_device(struct slot *p_slot);
extern void get_hp_hw_control_from_firmware(struct pci_dev *dev);
extern void get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp);
extern int shpchprm_get_physical_slot_number(struct controller *ctrl,
u32 *sun, u8 busnum, u8 devnum);
extern void shpchp_remove_ctrl_files(struct controller *ctrl); extern void shpchp_remove_ctrl_files(struct controller *ctrl);
extern void cleanup_slots(struct controller *ctrl); extern void cleanup_slots(struct controller *ctrl);
extern void queue_pushbutton_work(void *data); extern void queue_pushbutton_work(void *data);
#ifdef CONFIG_ACPI
static inline int get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
if (ACPI_FAILURE(acpi_get_hp_params_from_firmware(dev, hpp)))
return -ENODEV;
return 0;
}
#define get_hp_hw_control_from_firmware(pdev) \
do { \
if (DEVICE_ACPI_HANDLE(&(pdev->dev))) \
acpi_run_oshp(DEVICE_ACPI_HANDLE(&(pdev->dev))); \
} while (0)
#else
#define get_hp_params_from_firmware(dev, hpp) (-ENODEV)
#define get_hp_hw_control_from_firmware(dev) do { } while (0)
#endif
struct ctrl_reg { struct ctrl_reg {
volatile u32 base_offset; volatile u32 base_offset;
volatile u32 slot_avail1; volatile u32 slot_avail1;

17
drivers/pci/hotplug/shpchp_core.c
View File

@ -104,6 +104,23 @@ static void make_slot_name(struct slot *slot)
slot->bus, slot->number); slot->bus, slot->number);
} }
static int
shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun,
u8 busnum, u8 devnum)
{
int offset = devnum - ctrl->slot_device_offset;
dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__,
ctrl->slot_num_inc, offset);
*sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc *offset);
return 0;
}
static int init_slots(struct controller *ctrl) static int init_slots(struct controller *ctrl)
{ {
struct slot *slot; struct slot *slot;

10
drivers/pci/hotplug/shpchp_pci.c
View File

@ -38,7 +38,7 @@ static void program_fw_provided_values(struct pci_dev *dev)
{ {
u16 pci_cmd, pci_bctl; u16 pci_cmd, pci_bctl;
struct pci_dev *cdev; struct pci_dev *cdev;
struct hotplug_params hpp = {0x8, 0x40, 0, 0}; /* defaults */ struct hotplug_params hpp;
/* Program hpp values for this device */ /* Program hpp values for this device */
if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL || if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL ||
@ -46,7 +46,13 @@ static void program_fw_provided_values(struct pci_dev *dev)
(dev->class >> 8) == PCI_CLASS_BRIDGE_PCI))) (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
return; return;
get_hp_params_from_firmware(dev, &hpp); /* use default values if we can't get them from firmware */
if (get_hp_params_from_firmware(dev, &hpp)) {
hpp.cache_line_size = 8;
hpp.latency_timer = 0x40;
hpp.enable_serr = 0;
hpp.enable_perr = 0;
}
pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, hpp.cache_line_size); pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, hpp.cache_line_size);
pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp.latency_timer); pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp.latency_timer);

186
drivers/pci/hotplug/shpchprm_acpi.c
View File

@ -1,186 +0,0 @@
/*
* SHPCHPRM ACPI: PHP Resource Manager for ACPI platform
*
* Copyright (C) 2003-2004 Intel Corporation
*
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
* NON INFRINGEMENT. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Send feedback to <kristen.c.accardi@intel.com>
*
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <acpi/acpi.h>
#include <acpi/acpi_bus.h>
#include <acpi/actypes.h>
#include "shpchp.h"
#define METHOD_NAME__SUN "_SUN"
#define METHOD_NAME__HPP "_HPP"
#define METHOD_NAME_OSHP "OSHP"
static u8 * acpi_path_name( acpi_handle handle)
{
acpi_status status;
static u8 path_name[ACPI_PATHNAME_MAX];
struct acpi_buffer ret_buf = { ACPI_PATHNAME_MAX, path_name };
memset(path_name, 0, sizeof (path_name));
status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf);
if (ACPI_FAILURE(status))
return NULL;
else
return path_name;
}
static acpi_status
acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
{
acpi_status status;
u8 nui[4];
struct acpi_buffer ret_buf = { 0, NULL};
union acpi_object *ext_obj, *package;
u8 *path_name = acpi_path_name(handle);
int i, len = 0;
/* get _hpp */
status = acpi_evaluate_object(handle, METHOD_NAME__HPP, NULL, &ret_buf);
switch (status) {
case AE_BUFFER_OVERFLOW:
ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL);
if (!ret_buf.pointer) {
err ("%s:%s alloc for _HPP fail\n", __FUNCTION__,
path_name);
return AE_NO_MEMORY;
}
status = acpi_evaluate_object(handle, METHOD_NAME__HPP,
NULL, &ret_buf);
if (ACPI_SUCCESS(status))
break;
default:
if (ACPI_FAILURE(status)) {
dbg("%s:%s _HPP fail=0x%x\n", __FUNCTION__,
path_name, status);
return status;
}
}
ext_obj = (union acpi_object *) ret_buf.pointer;
if (ext_obj->type != ACPI_TYPE_PACKAGE) {
err ("%s:%s _HPP obj not a package\n", __FUNCTION__,
path_name);
status = AE_ERROR;
goto free_and_return;
}
len = ext_obj->package.count;
package = (union acpi_object *) ret_buf.pointer;
for ( i = 0; (i < len) || (i < 4); i++) {
ext_obj = (union acpi_object *) &package->package.elements[i];
switch (ext_obj->type) {
case ACPI_TYPE_INTEGER:
nui[i] = (u8)ext_obj->integer.value;
break;
default:
err ("%s:%s _HPP obj type incorrect\n", __FUNCTION__,
path_name);
status = AE_ERROR;
goto free_and_return;
}
}
hpp->cache_line_size = nui[0];
hpp->latency_timer = nui[1];
hpp->enable_serr = nui[2];
hpp->enable_perr = nui[3];
dbg(" _HPP: cache_line_size=0x%x\n", hpp->cache_line_size);
dbg(" _HPP: latency timer =0x%x\n", hpp->latency_timer);
dbg(" _HPP: enable SERR =0x%x\n", hpp->enable_serr);
dbg(" _HPP: enable PERR =0x%x\n", hpp->enable_perr);
free_and_return:
kfree(ret_buf.pointer);
return status;
}
static void acpi_run_oshp(acpi_handle handle)
{
acpi_status status;
u8 *path_name = acpi_path_name(handle);
/* run OSHP */
status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL);
if (ACPI_FAILURE(status)) {
err("%s:%s OSHP fails=0x%x\n", __FUNCTION__, path_name,
status);
} else {
dbg("%s:%s OSHP passes\n", __FUNCTION__, path_name);
}
}
int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
{
int offset = devnum - ctrl->slot_device_offset;
dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__, ctrl->slot_num_inc, offset);
*sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc *offset);
return 0;
}
void get_hp_hw_control_from_firmware(struct pci_dev *dev)
{
/*
* OSHP is an optional ACPI firmware control method. If present,
* we need to run it to inform BIOS that we will control SHPC
* hardware from now on.
*/
acpi_handle handle = DEVICE_ACPI_HANDLE(&(dev->dev));
if (!handle)
return;
acpi_run_oshp(handle);
}
void get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
acpi_status status = AE_NOT_FOUND;
struct pci_dev *pdev = dev;
/*
* _HPP settings apply to all child buses, until another _HPP is
* encountered. If we don't find an _HPP for the input pci dev,
* look for it in the parent device scope since that would apply to
* this pci dev. If we don't find any _HPP, use hardcoded defaults
*/
while (pdev && (ACPI_FAILURE(status))) {
acpi_handle handle = DEVICE_ACPI_HANDLE(&(pdev->dev));
if (!handle)
break;
status = acpi_run_hpp(handle, hpp);
if (!(pdev->bus->parent))
break;
/* Check if a parent object supports _HPP */
pdev = pdev->bus->parent->self;
}
}

54
drivers/pci/hotplug/shpchprm_legacy.c
View File

@ -1,54 +0,0 @@
/*
* SHPCHPRM Legacy: PHP Resource Manager for Non-ACPI/Legacy platform
*
* Copyright (C) 1995,2001 Compaq Computer Corporation
* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
* Copyright (C) 2001 IBM Corp.
* Copyright (C) 2003-2004 Intel Corporation
*
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
* NON INFRINGEMENT. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Send feedback to <greg@kroah.com>,<kristen.c.accardi@intel.com>
*
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/pci.h>
#include "shpchp.h"
int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
{
int offset = devnum - ctrl->slot_device_offset;
*sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc * offset);
return 0;
}
void get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
return;
}
void get_hp_hw_control_from_firmware(struct pci_dev *dev)
{
return;
}

57
drivers/pci/hotplug/shpchprm_nonacpi.c
View File

@ -1,57 +0,0 @@
/*
* SHPCHPRM NONACPI: PHP Resource Manager for Non-ACPI/Legacy platform
*
* Copyright (C) 1995,2001 Compaq Computer Corporation
* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
* Copyright (C) 2001 IBM Corp.
* Copyright (C) 2003-2004 Intel Corporation
*
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
* NON INFRINGEMENT. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
*
*/
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include "shpchp.h"
int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
{
int offset = devnum - ctrl->slot_device_offset;
dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__, ctrl->slot_num_inc, offset);
*sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc * offset);
return 0;
}
void get_hp_params_from_firmware(struct pci_dev *dev,
struct hotplug_params *hpp)
{
return;
}
void get_hp_hw_control_from_firmware(struct pci_dev *dev)
{
return;
}