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; 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; dbg("Could not find %s in acpi namespace, trying parent\n", pci_name(pdev)); if (!pdev->bus->parent->self) /* Parent must be a host bridge */ handle = acpi_get_pci_rootbridge_handle( pci_domain_nr(pdev->bus->parent), pdev->bus->parent->number); else handle = DEVICE_ACPI_HANDLE( &(pdev->bus->parent->self->dev)); pdev = pdev->bus->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; }
static void acpi_run_oshp ( struct acpi_bridge *ab) { acpi_status status; u8 *path_name = acpi_path_name(ab->handle); /* run OSHP */ status = acpi_evaluate_object(ab->handle, METHOD_NAME_OSHP, NULL, NULL); if (ACPI_FAILURE(status)) { err("acpi_pciehprm:%s OSHP fails=0x%x\n", path_name, status); } else dbg("acpi_pciehprm:%s OSHP passes =0x%x\n", path_name, status); return; }
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); } }
static acpi_status acpi_evaluate_crs( acpi_handle handle, struct acpi_resource **retbuf ) { acpi_status status; struct acpi_buffer crsbuf; u8 *path_name = acpi_path_name(handle); crsbuf.length = 0; crsbuf.pointer = NULL; status = acpi_get_current_resources (handle, &crsbuf); switch (status) { case AE_BUFFER_OVERFLOW: break; /* Found */ case AE_NOT_FOUND: dbg("acpi_pciehprm:%s _CRS not found\n", path_name); return status; default: err ("acpi_pciehprm:%s _CRS fail=0x%x\n", path_name, status); return status; } crsbuf.pointer = kmalloc (crsbuf.length, GFP_KERNEL); if (!crsbuf.pointer) { err ("acpi_pciehprm: alloc %ld bytes for %s _CRS fail\n", (ulong)crsbuf.length, path_name); return AE_NO_MEMORY; } status = acpi_get_current_resources (handle, &crsbuf); if (ACPI_FAILURE(status)) { err("acpi_pciehprm: %s _CRS fail=0x%x.\n", path_name, status); kfree(crsbuf.pointer); return status; } *retbuf = crsbuf.pointer; return status; }
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_get__hpp ( struct acpi_bridge *ab) { 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(ab->handle); int i, len = 0; /* Get _hpp */ status = acpi_evaluate_object(ab->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 ("acpi_pciehprm:%s alloc for _HPP fail\n", path_name); return; } status = acpi_evaluate_object(ab->handle, METHOD_NAME__HPP, NULL, &ret_buf); if (ACPI_SUCCESS(status)) break; default: if (ACPI_FAILURE(status)) { err("acpi_pciehprm:%s _HPP fail=0x%x\n", path_name, status); return; } } ext_obj = (union acpi_object *) ret_buf.pointer; if (ext_obj->type != ACPI_TYPE_PACKAGE) { err ("acpi_pciehprm:%s _HPP obj not a package\n", path_name); 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 ("acpi_pciehprm:%s _HPP obj type incorrect\n", path_name); goto free_and_return; } } ab->_hpp = kmalloc (sizeof (struct acpi__hpp), GFP_KERNEL); if (!ab->_hpp) { err ("acpi_pciehprm:%s alloc for _HPP failed\n", path_name); goto free_and_return; } memset(ab->_hpp, 0, sizeof(struct acpi__hpp)); ab->_hpp->cache_line_size = nui[0]; ab->_hpp->latency_timer = nui[1]; ab->_hpp->enable_serr = nui[2]; ab->_hpp->enable_perr = nui[3]; dbg(" _HPP: cache_line_size=0x%x\n", ab->_hpp->cache_line_size); dbg(" _HPP: latency timer =0x%x\n", ab->_hpp->latency_timer); dbg(" _HPP: enable SERR =0x%x\n", ab->_hpp->enable_serr); dbg(" _HPP: enable PERR =0x%x\n", ab->_hpp->enable_perr); free_and_return: kfree(ret_buf.pointer); }