From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-il1-f176.google.com (mail-il1-f176.google.com [209.85.166.176]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 781256FA8 for ; Mon, 12 Aug 2024 00:59:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.166.176 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723424390; cv=none; b=TnJCUxpdllZvlIRhxYFvC0f/fD6cgS/TNZH7Qk3wqIWvRvbL9qa5QFCtWbRv3d6wYSIJk8Dp4s9o3s3/DBlTYSY0snQcyWGteBg4eLdeU/wdi1wThZu3PRsD/hUxXfb+XDjt8cM10tqEQrysQrOdUvtVWCE8pZKM0Mi/UC+oqJs= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723424390; c=relaxed/simple; bh=C+i0U6VGde+1v9kIi2tE1b1sf1jRuHcxIrWnNcHIpqg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=YDMqT6y9qovDrWdMTX18WhOJIo56CTgmO7yZU4IQ3rtfRhnlf9o0H9fgX7DOkrzEi2kycU/R9Km0f34zqPCXGTXPWbULLFXBR+d7VOHiZqAeHuxvqkrpMUugarSXELoLLAFzLROiOaJGj88jxay+IS+1zEKDgroDiyGsMl9g5gE= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com; spf=pass smtp.mailfrom=ventanamicro.com; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b=DC1z8xs9; arc=none smtp.client-ip=209.85.166.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ventanamicro.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ventanamicro.com header.i=@ventanamicro.com header.b="DC1z8xs9" Received: by mail-il1-f176.google.com with SMTP id e9e14a558f8ab-39728bbf949so14888235ab.3 for ; Sun, 11 Aug 2024 17:59:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1723424387; x=1724029187; darn=lists.linux.dev; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=8jeK3ESAUl7YxTE1Iy3jfhVYgTpS15SSq0iPGR06s9c=; b=DC1z8xs9hOFarISXDrq0j4TMx5Va8YISqwtpvUh/S3eNood0lv43L6kWwxocuJguM/ IWH7Pq7OCxbg8ZVxGDoLnx4RyOL8CW1WKspg59b9MZCgPIdM+2aUkueCXLkdCYIyFKvp Ft4I0gzqJZpxnhGn1XeHWfFYSMyr4kFkQXzpYs/o/6yWwDDB1ACp+EcXtuocNFzbJPcA xKU1RDdYnmbvJXY5XXFkIlLzuL+n7fXveECwwOMd+2giEgyBWGcXkhPPqGaPSxNKlv6i oRZqUzrPNnnsEqlOCfvnR5LBkem1iu6x3JXjLAQZZYfqodJnWC21SL8/A7swIclEwFHQ cb/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723424387; x=1724029187; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8jeK3ESAUl7YxTE1Iy3jfhVYgTpS15SSq0iPGR06s9c=; b=TbY2eRJW6h+qwkwHp0kaP+D4C6fAx5IrNaGK9sB6xqaV5o5plqJwepOZSZnX5zbQlM FpPMLzW+wLTRy/AM18fVc7JxpbTDS4BGtGhB401COr4o8ynhkSW5rscbJvMM+yrkiJVJ Dep5OW0Yv62yvZZNeTBJeCV4Hhu4R8nO3T3hGjBz9URnq1n5pq1gW3CSHgh+XKVMwbex zjhIY8NdhDQ+7QB4y0GcJPCjY59SAx4YtFHz74ue81oUy+OG6TWRYj5Cj23P0GscbTzp ZZ1QsNQEq1KtSkwTDFGJ64SpW2Z/Mc5WXpx0P+K8FnI9s8HotIAaTu2d+z9HrMyaK/Rh /toA== X-Forwarded-Encrypted: i=1; AJvYcCWfKcbPrSic8wu+NBqpRVRBIwgjvENvSG1cPjgOR9CUpCMM9NoQqtJ8TFDkdWLTC5CPfNb+24IJ7Mejd5/jhcgQ1olxEDGBFG3UA2vW X-Gm-Message-State: AOJu0YxIY9bgE2xxXwHV0+tSAPS03wjf36pftS+fZhcICPHMJDuyE7OI K4APs2LR/AbXsA/kHM4l5qGsb9W/o6kbBgef/XTPjh8u2oagdaNPV2/HKCvnjZc= X-Google-Smtp-Source: AGHT+IFIiqNGjgTEsTyA01AhWlCd5/qrU642pe+8j8qsMImF8/xohIsj9BzQ1yvF+gyWEF8FJGTC6A== X-Received: by 2002:a05:6e02:1a29:b0:398:81e9:3f9e with SMTP id e9e14a558f8ab-39b813345abmr101145885ab.12.1723424387549; Sun, 11 Aug 2024 17:59:47 -0700 (PDT) Received: from sunil-pc.tail07344b.ts.net ([106.51.198.16]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-7c3dbe8cbdcsm3074062a12.61.2024.08.11.17.59.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Aug 2024 17:59:47 -0700 (PDT) From: Sunil V L To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-riscv@lists.infradead.org, linux-acpi@vger.kernel.org, acpica-devel@lists.linux.dev Cc: Will Deacon , Paul Walmsley , Palmer Dabbelt , Albert Ou , "Rafael J . Wysocki" , Len Brown , Bjorn Helgaas , Anup Patel , Thomas Gleixner , Samuel Holland , Robert Moore , Conor Dooley , Haibo Xu , Andrew Jones , Atish Kumar Patra , Drew Fustini , Sunil V L , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= Subject: [PATCH v8 01/17] arm64: PCI: Migrate ACPI related functions to pci-acpi.c Date: Mon, 12 Aug 2024 06:29:13 +0530 Message-ID: <20240812005929.113499-2-sunilvl@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240812005929.113499-1-sunilvl@ventanamicro.com> References: <20240812005929.113499-1-sunilvl@ventanamicro.com> Precedence: bulk X-Mailing-List: acpica-devel@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=cp1252 Content-Transfer-Encoding: 8bit The functions defined in arm64 for ACPI support are required for RISC-V also. To avoid duplication, move these functions to common location. Signed-off-by: Sunil V L Acked-by: Bjorn Helgaas Acked-by: Will Deacon Tested-by: Björn Töpel --- arch/arm64/kernel/pci.c | 191 ---------------------------------------- drivers/pci/pci-acpi.c | 182 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 182 insertions(+), 191 deletions(-) diff --git a/arch/arm64/kernel/pci.c b/arch/arm64/kernel/pci.c index f872c57e9909..fd9a7bed83ce 100644 --- a/arch/arm64/kernel/pci.c +++ b/arch/arm64/kernel/pci.c @@ -6,28 +6,7 @@ * Copyright (C) 2014 ARM Ltd. */ -#include -#include -#include -#include -#include #include -#include -#include -#include - -#ifdef CONFIG_ACPI -/* - * Try to assign the IRQ number when probing a new device - */ -int pcibios_alloc_irq(struct pci_dev *dev) -{ - if (!acpi_disabled) - acpi_pci_irq_enable(dev); - - return 0; -} -#endif /* * raw_pci_read/write - Platform-specific PCI config space access. @@ -61,173 +40,3 @@ int pcibus_to_node(struct pci_bus *bus) EXPORT_SYMBOL(pcibus_to_node); #endif - -#ifdef CONFIG_ACPI - -struct acpi_pci_generic_root_info { - struct acpi_pci_root_info common; - struct pci_config_window *cfg; /* config space mapping */ -}; - -int acpi_pci_bus_find_domain_nr(struct pci_bus *bus) -{ - struct pci_config_window *cfg = bus->sysdata; - struct acpi_device *adev = to_acpi_device(cfg->parent); - struct acpi_pci_root *root = acpi_driver_data(adev); - - return root->segment; -} - -int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge) -{ - struct pci_config_window *cfg; - struct acpi_device *adev; - struct device *bus_dev; - - if (acpi_disabled) - return 0; - - cfg = bridge->bus->sysdata; - - /* - * On Hyper-V there is no corresponding ACPI device for a root bridge, - * therefore ->parent is set as NULL by the driver. And set 'adev' as - * NULL in this case because there is no proper ACPI device. - */ - if (!cfg->parent) - adev = NULL; - else - adev = to_acpi_device(cfg->parent); - - bus_dev = &bridge->bus->dev; - - ACPI_COMPANION_SET(&bridge->dev, adev); - set_dev_node(bus_dev, acpi_get_node(acpi_device_handle(adev))); - - return 0; -} - -static int pci_acpi_root_prepare_resources(struct acpi_pci_root_info *ci) -{ - struct resource_entry *entry, *tmp; - int status; - - status = acpi_pci_probe_root_resources(ci); - resource_list_for_each_entry_safe(entry, tmp, &ci->resources) { - if (!(entry->res->flags & IORESOURCE_WINDOW)) - resource_list_destroy_entry(entry); - } - return status; -} - -/* - * Lookup the bus range for the domain in MCFG, and set up config space - * mapping. - */ -static struct pci_config_window * -pci_acpi_setup_ecam_mapping(struct acpi_pci_root *root) -{ - struct device *dev = &root->device->dev; - struct resource *bus_res = &root->secondary; - u16 seg = root->segment; - const struct pci_ecam_ops *ecam_ops; - struct resource cfgres; - struct acpi_device *adev; - struct pci_config_window *cfg; - int ret; - - ret = pci_mcfg_lookup(root, &cfgres, &ecam_ops); - if (ret) { - dev_err(dev, "%04x:%pR ECAM region not found\n", seg, bus_res); - return NULL; - } - - adev = acpi_resource_consumer(&cfgres); - if (adev) - dev_info(dev, "ECAM area %pR reserved by %s\n", &cfgres, - dev_name(&adev->dev)); - else - dev_warn(dev, FW_BUG "ECAM area %pR not reserved in ACPI namespace\n", - &cfgres); - - cfg = pci_ecam_create(dev, &cfgres, bus_res, ecam_ops); - if (IS_ERR(cfg)) { - dev_err(dev, "%04x:%pR error %ld mapping ECAM\n", seg, bus_res, - PTR_ERR(cfg)); - return NULL; - } - - return cfg; -} - -/* release_info: free resources allocated by init_info */ -static void pci_acpi_generic_release_info(struct acpi_pci_root_info *ci) -{ - struct acpi_pci_generic_root_info *ri; - - ri = container_of(ci, struct acpi_pci_generic_root_info, common); - pci_ecam_free(ri->cfg); - kfree(ci->ops); - kfree(ri); -} - -/* Interface called from ACPI code to setup PCI host controller */ -struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root) -{ - struct acpi_pci_generic_root_info *ri; - struct pci_bus *bus, *child; - struct acpi_pci_root_ops *root_ops; - struct pci_host_bridge *host; - - ri = kzalloc(sizeof(*ri), GFP_KERNEL); - if (!ri) - return NULL; - - root_ops = kzalloc(sizeof(*root_ops), GFP_KERNEL); - if (!root_ops) { - kfree(ri); - return NULL; - } - - ri->cfg = pci_acpi_setup_ecam_mapping(root); - if (!ri->cfg) { - kfree(ri); - kfree(root_ops); - return NULL; - } - - root_ops->release_info = pci_acpi_generic_release_info; - root_ops->prepare_resources = pci_acpi_root_prepare_resources; - root_ops->pci_ops = (struct pci_ops *)&ri->cfg->ops->pci_ops; - bus = acpi_pci_root_create(root, root_ops, &ri->common, ri->cfg); - if (!bus) - return NULL; - - /* If we must preserve the resource configuration, claim now */ - host = pci_find_host_bridge(bus); - if (host->preserve_config) - pci_bus_claim_resources(bus); - - /* - * Assign whatever was left unassigned. If we didn't claim above, - * this will reassign everything. - */ - pci_assign_unassigned_root_bus_resources(bus); - - list_for_each_entry(child, &bus->children, node) - pcie_bus_configure_settings(child); - - return bus; -} - -void pcibios_add_bus(struct pci_bus *bus) -{ - acpi_pci_add_bus(bus); -} - -void pcibios_remove_bus(struct pci_bus *bus) -{ - acpi_pci_remove_bus(bus); -} - -#endif diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c index 9cc447da9475..8ed81a373bd7 100644 --- a/drivers/pci/pci-acpi.c +++ b/drivers/pci/pci-acpi.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -1541,3 +1542,184 @@ static int __init acpi_pci_init(void) return 0; } arch_initcall(acpi_pci_init); + +#if defined(CONFIG_ARM64) + +/* + * Try to assign the IRQ number when probing a new device + */ +int pcibios_alloc_irq(struct pci_dev *dev) +{ + if (!acpi_disabled) + acpi_pci_irq_enable(dev); + + return 0; +} + +struct acpi_pci_generic_root_info { + struct acpi_pci_root_info common; + struct pci_config_window *cfg; /* config space mapping */ +}; + +int acpi_pci_bus_find_domain_nr(struct pci_bus *bus) +{ + struct pci_config_window *cfg = bus->sysdata; + struct acpi_device *adev = to_acpi_device(cfg->parent); + struct acpi_pci_root *root = acpi_driver_data(adev); + + return root->segment; +} + +int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge) +{ + struct pci_config_window *cfg; + struct acpi_device *adev; + struct device *bus_dev; + + if (acpi_disabled) + return 0; + + cfg = bridge->bus->sysdata; + + /* + * On Hyper-V there is no corresponding ACPI device for a root bridge, + * therefore ->parent is set as NULL by the driver. And set 'adev' as + * NULL in this case because there is no proper ACPI device. + */ + if (!cfg->parent) + adev = NULL; + else + adev = to_acpi_device(cfg->parent); + + bus_dev = &bridge->bus->dev; + + ACPI_COMPANION_SET(&bridge->dev, adev); + set_dev_node(bus_dev, acpi_get_node(acpi_device_handle(adev))); + + return 0; +} + +static int pci_acpi_root_prepare_resources(struct acpi_pci_root_info *ci) +{ + struct resource_entry *entry, *tmp; + int status; + + status = acpi_pci_probe_root_resources(ci); + resource_list_for_each_entry_safe(entry, tmp, &ci->resources) { + if (!(entry->res->flags & IORESOURCE_WINDOW)) + resource_list_destroy_entry(entry); + } + return status; +} + +/* + * Lookup the bus range for the domain in MCFG, and set up config space + * mapping. + */ +static struct pci_config_window * +pci_acpi_setup_ecam_mapping(struct acpi_pci_root *root) +{ + struct device *dev = &root->device->dev; + struct resource *bus_res = &root->secondary; + u16 seg = root->segment; + const struct pci_ecam_ops *ecam_ops; + struct resource cfgres; + struct acpi_device *adev; + struct pci_config_window *cfg; + int ret; + + ret = pci_mcfg_lookup(root, &cfgres, &ecam_ops); + if (ret) { + dev_err(dev, "%04x:%pR ECAM region not found\n", seg, bus_res); + return NULL; + } + + adev = acpi_resource_consumer(&cfgres); + if (adev) + dev_info(dev, "ECAM area %pR reserved by %s\n", &cfgres, + dev_name(&adev->dev)); + else + dev_warn(dev, FW_BUG "ECAM area %pR not reserved in ACPI namespace\n", + &cfgres); + + cfg = pci_ecam_create(dev, &cfgres, bus_res, ecam_ops); + if (IS_ERR(cfg)) { + dev_err(dev, "%04x:%pR error %ld mapping ECAM\n", seg, bus_res, + PTR_ERR(cfg)); + return NULL; + } + + return cfg; +} + +/* release_info: free resources allocated by init_info */ +static void pci_acpi_generic_release_info(struct acpi_pci_root_info *ci) +{ + struct acpi_pci_generic_root_info *ri; + + ri = container_of(ci, struct acpi_pci_generic_root_info, common); + pci_ecam_free(ri->cfg); + kfree(ci->ops); + kfree(ri); +} + +/* Interface called from ACPI code to setup PCI host controller */ +struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root) +{ + struct acpi_pci_generic_root_info *ri; + struct pci_bus *bus, *child; + struct acpi_pci_root_ops *root_ops; + struct pci_host_bridge *host; + + ri = kzalloc(sizeof(*ri), GFP_KERNEL); + if (!ri) + return NULL; + + root_ops = kzalloc(sizeof(*root_ops), GFP_KERNEL); + if (!root_ops) { + kfree(ri); + return NULL; + } + + ri->cfg = pci_acpi_setup_ecam_mapping(root); + if (!ri->cfg) { + kfree(ri); + kfree(root_ops); + return NULL; + } + + root_ops->release_info = pci_acpi_generic_release_info; + root_ops->prepare_resources = pci_acpi_root_prepare_resources; + root_ops->pci_ops = (struct pci_ops *)&ri->cfg->ops->pci_ops; + bus = acpi_pci_root_create(root, root_ops, &ri->common, ri->cfg); + if (!bus) + return NULL; + + /* If we must preserve the resource configuration, claim now */ + host = pci_find_host_bridge(bus); + if (host->preserve_config) + pci_bus_claim_resources(bus); + + /* + * Assign whatever was left unassigned. If we didn't claim above, + * this will reassign everything. + */ + pci_assign_unassigned_root_bus_resources(bus); + + list_for_each_entry(child, &bus->children, node) + pcie_bus_configure_settings(child); + + return bus; +} + +void pcibios_add_bus(struct pci_bus *bus) +{ + acpi_pci_add_bus(bus); +} + +void pcibios_remove_bus(struct pci_bus *bus) +{ + acpi_pci_remove_bus(bus); +} + +#endif -- 2.43.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 23AB3C52D7F for ; Mon, 12 Aug 2024 01:00:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=OzPT2a1H1D7e3PegtZxINWKyv1yWcG/t2RbzDAqcAvo=; b=g3VoVA8s9mU37g 8icsA1sblQOJxb38etBU7LvP0qRYq2WQ+BUFL0s9kyrOmuN01HzJ8Z/yFZOFUuBOROB6Rt+7G9XGO 8ea3fG07gwCt/M3Y1pqgJKBl7/yQJCIz2M9u38VuvW/ZlfwqsZUu7YMwLqw09c4+zVMO3jC4Q17QT atmBZXHcdW1wgz3R4uyzgoRY4izChGFGpypzL/mktghge7ayodofVHuINGwAxp9u7tR20f99E7MME mjczvc3lNqVjTDsQWOjvMb9qCW9BDbyF9W5e/Oc6r7/DSZwR2zvPwuqS+lkqD1N4BPMSAx8fHrZmM HU/EHCRWepgRDCXpDWmg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1sdJQ7-0000000Ga3d-46IT; Mon, 12 Aug 2024 01:00:23 +0000 Received: from mail-il1-x135.google.com ([2607:f8b0:4864:20::135]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1sdJPY-0000000GZrZ-2pnE for linux-riscv@lists.infradead.org; Mon, 12 Aug 2024 00:59:50 +0000 Received: by mail-il1-x135.google.com with SMTP id e9e14a558f8ab-39728bbf949so14888225ab.3 for ; Sun, 11 Aug 2024 17:59:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1723424387; x=1724029187; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=8jeK3ESAUl7YxTE1Iy3jfhVYgTpS15SSq0iPGR06s9c=; b=bsbQ8GD+fyFMsB3eZ3IvUjzcT2+UWHUy/SyKGHOBkr3aRO8XxQgdoBYgBwnLio2zR2 zTp5GfFFUUkNjGs48RLS2wjr4zv0VN6sguZrlIu98d/KBcYADMIgMN50kCosB4I0prAw X+UuiF77akVepDsD3tR592PdGp/wCTJlerHzeGQ/g5EA3ajEbl1SUoInmmTppTzZXZXf bG4oLq68DXSPDpL1fyFLOTcEuJ8mfIkavAOJcr6QiHF5LQnTwC5c68WJt7OYogHN/TJu CIJnZCgV2FvXLVL8Tw1Ral7nqdkpCxg/Du24VG+tBkCYKpTsOLXcEvL/1ULs/4kMFsNJ C3wA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723424387; x=1724029187; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8jeK3ESAUl7YxTE1Iy3jfhVYgTpS15SSq0iPGR06s9c=; b=fQnFUGi9y61Ee5R7OOlPSk1DRRx+uQFPGie2ubWNKW0O+CrrTTjWvBKJL99ZD8HiEq jOw7dd6Zt+C4CXGRxrr4seKaEfMhu6Q611BmgsXuHoJmvm1VrZAp6oXfuTpCkdYmxkqt Xnn7u6V0cMi5q/Pni3C/cgkgEEge9GZmwA/6pmJiOBdrkNRtlyOs64FmPpUdfNQYIZaf qyvH4pZrgSkhEhoCgnKhfKnB4+FZyC3XDAE3GaYF5tN8Y255HZJl/zu8eFNd9HQbwayB Vnrb+e9OOXKGeT7Wwwj8yRxwUS+rqnULufMYt4kMTzeg96S6NFbNaeUZ1RTkXe21gTlR Awfg== X-Forwarded-Encrypted: i=1; AJvYcCXJ4/B+Ilpf/bjxH1xwBLw1f+/vsZGtMk2BQeoex13XW8Fk62WMTk1saqZjYckCJNk2RnW5yDbZTWb/zooob9VJpPBdTmOory3xKdxsyf0h X-Gm-Message-State: AOJu0YxzPY9ICnrlFsMOdBFgeyqulQrtf5cOz48kSHQalmLd/AGC6wbN zelYpshTLdbghbdPqT/VjMeasOxDJ+fMAKxNOH4FM0YocRgD+3+F7D1lsWcVN9g= X-Google-Smtp-Source: AGHT+IFIiqNGjgTEsTyA01AhWlCd5/qrU642pe+8j8qsMImF8/xohIsj9BzQ1yvF+gyWEF8FJGTC6A== X-Received: by 2002:a05:6e02:1a29:b0:398:81e9:3f9e with SMTP id e9e14a558f8ab-39b813345abmr101145885ab.12.1723424387549; Sun, 11 Aug 2024 17:59:47 -0700 (PDT) Received: from sunil-pc.tail07344b.ts.net ([106.51.198.16]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-7c3dbe8cbdcsm3074062a12.61.2024.08.11.17.59.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Aug 2024 17:59:47 -0700 (PDT) From: Sunil V L To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-riscv@lists.infradead.org, linux-acpi@vger.kernel.org, acpica-devel@lists.linux.dev Subject: [PATCH v8 01/17] arm64: PCI: Migrate ACPI related functions to pci-acpi.c Date: Mon, 12 Aug 2024 06:29:13 +0530 Message-ID: <20240812005929.113499-2-sunilvl@ventanamicro.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240812005929.113499-1-sunilvl@ventanamicro.com> References: <20240812005929.113499-1-sunilvl@ventanamicro.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240811_175948_754476_40CF8971 X-CRM114-Status: GOOD ( 21.23 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Albert Ou , Haibo Xu , "Rafael J . Wysocki" , Anup Patel , Atish Kumar Patra , Robert Moore , Samuel Holland , Conor Dooley , Palmer Dabbelt , Drew Fustini , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Paul Walmsley , Bjorn Helgaas , Thomas Gleixner , Andrew Jones , Will Deacon , Len Brown Content-Type: text/plain; charset="cp1252" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org VGhlIGZ1bmN0aW9ucyBkZWZpbmVkIGluIGFybTY0IGZvciBBQ1BJIHN1cHBvcnQgYXJlIHJlcXVp cmVkCmZvciBSSVNDLVYgYWxzby4gVG8gYXZvaWQgZHVwbGljYXRpb24sIG1vdmUgdGhlc2UgZnVu Y3Rpb25zCnRvIGNvbW1vbiBsb2NhdGlvbi4KClNpZ25lZC1vZmYtYnk6IFN1bmlsIFYgTCA8c3Vu aWx2bEB2ZW50YW5hbWljcm8uY29tPgpBY2tlZC1ieTogQmpvcm4gSGVsZ2FhcyA8YmhlbGdhYXNA Z29vZ2xlLmNvbT4KQWNrZWQtYnk6IFdpbGwgRGVhY29uIDx3aWxsQGtlcm5lbC5vcmc+ClRlc3Rl ZC1ieTogQmrDtnJuIFTDtnBlbCA8Ympvcm5Acml2b3NpbmMuY29tPgotLS0KIGFyY2gvYXJtNjQv a2VybmVsL3BjaS5jIHwgMTkxIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KIGRyaXZlcnMvcGNpL3BjaS1hY3BpLmMgIHwgMTgyICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDE4MiBpbnNlcnRpb25zKCspLCAxOTEg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvcGNpLmMgYi9hcmNo L2FybTY0L2tlcm5lbC9wY2kuYwppbmRleCBmODcyYzU3ZTk5MDkuLmZkOWE3YmVkODNjZSAxMDA2 NDQKLS0tIGEvYXJjaC9hcm02NC9rZXJuZWwvcGNpLmMKKysrIGIvYXJjaC9hcm02NC9rZXJuZWwv cGNpLmMKQEAgLTYsMjggKzYsNyBAQAogICogQ29weXJpZ2h0IChDKSAyMDE0IEFSTSBMdGQuCiAg Ki8KIAotI2luY2x1ZGUgPGxpbnV4L2FjcGkuaD4KLSNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Ci0j aW5jbHVkZSA8bGludXgvaW8uaD4KLSNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KLSNpbmNsdWRl IDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgotI2luY2x1ZGUgPGxpbnV4L3Bj aS1hY3BpLmg+Ci0jaW5jbHVkZSA8bGludXgvcGNpLWVjYW0uaD4KLSNpbmNsdWRlIDxsaW51eC9z bGFiLmg+Ci0KLSNpZmRlZiBDT05GSUdfQUNQSQotLyoKLSAqIFRyeSB0byBhc3NpZ24gdGhlIElS USBudW1iZXIgd2hlbiBwcm9iaW5nIGEgbmV3IGRldmljZQotICovCi1pbnQgcGNpYmlvc19hbGxv Y19pcnEoc3RydWN0IHBjaV9kZXYgKmRldikKLXsKLQlpZiAoIWFjcGlfZGlzYWJsZWQpCi0JCWFj cGlfcGNpX2lycV9lbmFibGUoZGV2KTsKLQotCXJldHVybiAwOwotfQotI2VuZGlmCiAKIC8qCiAg KiByYXdfcGNpX3JlYWQvd3JpdGUgLSBQbGF0Zm9ybS1zcGVjaWZpYyBQQ0kgY29uZmlnIHNwYWNl IGFjY2Vzcy4KQEAgLTYxLDE3MyArNDAsMyBAQCBpbnQgcGNpYnVzX3RvX25vZGUoc3RydWN0IHBj aV9idXMgKmJ1cykKIEVYUE9SVF9TWU1CT0wocGNpYnVzX3RvX25vZGUpOwogCiAjZW5kaWYKLQot I2lmZGVmIENPTkZJR19BQ1BJCi0KLXN0cnVjdCBhY3BpX3BjaV9nZW5lcmljX3Jvb3RfaW5mbyB7 Ci0Jc3RydWN0IGFjcGlfcGNpX3Jvb3RfaW5mbwljb21tb247Ci0Jc3RydWN0IHBjaV9jb25maWdf d2luZG93CSpjZmc7CS8qIGNvbmZpZyBzcGFjZSBtYXBwaW5nICovCi19OwotCi1pbnQgYWNwaV9w Y2lfYnVzX2ZpbmRfZG9tYWluX25yKHN0cnVjdCBwY2lfYnVzICpidXMpCi17Ci0Jc3RydWN0IHBj aV9jb25maWdfd2luZG93ICpjZmcgPSBidXMtPnN5c2RhdGE7Ci0Jc3RydWN0IGFjcGlfZGV2aWNl ICphZGV2ID0gdG9fYWNwaV9kZXZpY2UoY2ZnLT5wYXJlbnQpOwotCXN0cnVjdCBhY3BpX3BjaV9y b290ICpyb290ID0gYWNwaV9kcml2ZXJfZGF0YShhZGV2KTsKLQotCXJldHVybiByb290LT5zZWdt ZW50OwotfQotCi1pbnQgcGNpYmlvc19yb290X2JyaWRnZV9wcmVwYXJlKHN0cnVjdCBwY2lfaG9z dF9icmlkZ2UgKmJyaWRnZSkKLXsKLQlzdHJ1Y3QgcGNpX2NvbmZpZ193aW5kb3cgKmNmZzsKLQlz dHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXY7Ci0Jc3RydWN0IGRldmljZSAqYnVzX2RldjsKLQotCWlm IChhY3BpX2Rpc2FibGVkKQotCQlyZXR1cm4gMDsKLQotCWNmZyA9IGJyaWRnZS0+YnVzLT5zeXNk YXRhOwotCi0JLyoKLQkgKiBPbiBIeXBlci1WIHRoZXJlIGlzIG5vIGNvcnJlc3BvbmRpbmcgQUNQ SSBkZXZpY2UgZm9yIGEgcm9vdCBicmlkZ2UsCi0JICogdGhlcmVmb3JlIC0+cGFyZW50IGlzIHNl dCBhcyBOVUxMIGJ5IHRoZSBkcml2ZXIuIEFuZCBzZXQgJ2FkZXYnIGFzCi0JICogTlVMTCBpbiB0 aGlzIGNhc2UgYmVjYXVzZSB0aGVyZSBpcyBubyBwcm9wZXIgQUNQSSBkZXZpY2UuCi0JICovCi0J aWYgKCFjZmctPnBhcmVudCkKLQkJYWRldiA9IE5VTEw7Ci0JZWxzZQotCQlhZGV2ID0gdG9fYWNw aV9kZXZpY2UoY2ZnLT5wYXJlbnQpOwotCi0JYnVzX2RldiA9ICZicmlkZ2UtPmJ1cy0+ZGV2Owot Ci0JQUNQSV9DT01QQU5JT05fU0VUKCZicmlkZ2UtPmRldiwgYWRldik7Ci0Jc2V0X2Rldl9ub2Rl KGJ1c19kZXYsIGFjcGlfZ2V0X25vZGUoYWNwaV9kZXZpY2VfaGFuZGxlKGFkZXYpKSk7Ci0KLQly ZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCBwY2lfYWNwaV9yb290X3ByZXBhcmVfcmVzb3VyY2Vz KHN0cnVjdCBhY3BpX3BjaV9yb290X2luZm8gKmNpKQotewotCXN0cnVjdCByZXNvdXJjZV9lbnRy eSAqZW50cnksICp0bXA7Ci0JaW50IHN0YXR1czsKLQotCXN0YXR1cyA9IGFjcGlfcGNpX3Byb2Jl X3Jvb3RfcmVzb3VyY2VzKGNpKTsKLQlyZXNvdXJjZV9saXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUo ZW50cnksIHRtcCwgJmNpLT5yZXNvdXJjZXMpIHsKLQkJaWYgKCEoZW50cnktPnJlcy0+ZmxhZ3Mg JiBJT1JFU09VUkNFX1dJTkRPVykpCi0JCQlyZXNvdXJjZV9saXN0X2Rlc3Ryb3lfZW50cnkoZW50 cnkpOwotCX0KLQlyZXR1cm4gc3RhdHVzOwotfQotCi0vKgotICogTG9va3VwIHRoZSBidXMgcmFu Z2UgZm9yIHRoZSBkb21haW4gaW4gTUNGRywgYW5kIHNldCB1cCBjb25maWcgc3BhY2UKLSAqIG1h cHBpbmcuCi0gKi8KLXN0YXRpYyBzdHJ1Y3QgcGNpX2NvbmZpZ193aW5kb3cgKgotcGNpX2FjcGlf c2V0dXBfZWNhbV9tYXBwaW5nKHN0cnVjdCBhY3BpX3BjaV9yb290ICpyb290KQotewotCXN0cnVj dCBkZXZpY2UgKmRldiA9ICZyb290LT5kZXZpY2UtPmRldjsKLQlzdHJ1Y3QgcmVzb3VyY2UgKmJ1 c19yZXMgPSAmcm9vdC0+c2Vjb25kYXJ5OwotCXUxNiBzZWcgPSByb290LT5zZWdtZW50OwotCWNv bnN0IHN0cnVjdCBwY2lfZWNhbV9vcHMgKmVjYW1fb3BzOwotCXN0cnVjdCByZXNvdXJjZSBjZmdy ZXM7Ci0Jc3RydWN0IGFjcGlfZGV2aWNlICphZGV2OwotCXN0cnVjdCBwY2lfY29uZmlnX3dpbmRv dyAqY2ZnOwotCWludCByZXQ7Ci0KLQlyZXQgPSBwY2lfbWNmZ19sb29rdXAocm9vdCwgJmNmZ3Jl cywgJmVjYW1fb3BzKTsKLQlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LCAiJTA0eDolcFIgRUNB TSByZWdpb24gbm90IGZvdW5kXG4iLCBzZWcsIGJ1c19yZXMpOwotCQlyZXR1cm4gTlVMTDsKLQl9 Ci0KLQlhZGV2ID0gYWNwaV9yZXNvdXJjZV9jb25zdW1lcigmY2ZncmVzKTsKLQlpZiAoYWRldikK LQkJZGV2X2luZm8oZGV2LCAiRUNBTSBhcmVhICVwUiByZXNlcnZlZCBieSAlc1xuIiwgJmNmZ3Jl cywKLQkJCSBkZXZfbmFtZSgmYWRldi0+ZGV2KSk7Ci0JZWxzZQotCQlkZXZfd2FybihkZXYsIEZX X0JVRyAiRUNBTSBhcmVhICVwUiBub3QgcmVzZXJ2ZWQgaW4gQUNQSSBuYW1lc3BhY2VcbiIsCi0J CQkgJmNmZ3Jlcyk7Ci0KLQljZmcgPSBwY2lfZWNhbV9jcmVhdGUoZGV2LCAmY2ZncmVzLCBidXNf cmVzLCBlY2FtX29wcyk7Ci0JaWYgKElTX0VSUihjZmcpKSB7Ci0JCWRldl9lcnIoZGV2LCAiJTA0 eDolcFIgZXJyb3IgJWxkIG1hcHBpbmcgRUNBTVxuIiwgc2VnLCBidXNfcmVzLAotCQkJUFRSX0VS UihjZmcpKTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCi0JcmV0dXJuIGNmZzsKLX0KLQotLyogcmVs ZWFzZV9pbmZvOiBmcmVlIHJlc291cmNlcyBhbGxvY2F0ZWQgYnkgaW5pdF9pbmZvICovCi1zdGF0 aWMgdm9pZCBwY2lfYWNwaV9nZW5lcmljX3JlbGVhc2VfaW5mbyhzdHJ1Y3QgYWNwaV9wY2lfcm9v dF9pbmZvICpjaSkKLXsKLQlzdHJ1Y3QgYWNwaV9wY2lfZ2VuZXJpY19yb290X2luZm8gKnJpOwot Ci0JcmkgPSBjb250YWluZXJfb2YoY2ksIHN0cnVjdCBhY3BpX3BjaV9nZW5lcmljX3Jvb3RfaW5m bywgY29tbW9uKTsKLQlwY2lfZWNhbV9mcmVlKHJpLT5jZmcpOwotCWtmcmVlKGNpLT5vcHMpOwot CWtmcmVlKHJpKTsKLX0KLQotLyogSW50ZXJmYWNlIGNhbGxlZCBmcm9tIEFDUEkgY29kZSB0byBz ZXR1cCBQQ0kgaG9zdCBjb250cm9sbGVyICovCi1zdHJ1Y3QgcGNpX2J1cyAqcGNpX2FjcGlfc2Nh bl9yb290KHN0cnVjdCBhY3BpX3BjaV9yb290ICpyb290KQotewotCXN0cnVjdCBhY3BpX3BjaV9n ZW5lcmljX3Jvb3RfaW5mbyAqcmk7Ci0Jc3RydWN0IHBjaV9idXMgKmJ1cywgKmNoaWxkOwotCXN0 cnVjdCBhY3BpX3BjaV9yb290X29wcyAqcm9vdF9vcHM7Ci0Jc3RydWN0IHBjaV9ob3N0X2JyaWRn ZSAqaG9zdDsKLQotCXJpID0ga3phbGxvYyhzaXplb2YoKnJpKSwgR0ZQX0tFUk5FTCk7Ci0JaWYg KCFyaSkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlyb290X29wcyA9IGt6YWxsb2Moc2l6ZW9mKCpyb290 X29wcyksIEdGUF9LRVJORUwpOwotCWlmICghcm9vdF9vcHMpIHsKLQkJa2ZyZWUocmkpOwotCQly ZXR1cm4gTlVMTDsKLQl9Ci0KLQlyaS0+Y2ZnID0gcGNpX2FjcGlfc2V0dXBfZWNhbV9tYXBwaW5n KHJvb3QpOwotCWlmICghcmktPmNmZykgewotCQlrZnJlZShyaSk7Ci0JCWtmcmVlKHJvb3Rfb3Bz KTsKLQkJcmV0dXJuIE5VTEw7Ci0JfQotCi0Jcm9vdF9vcHMtPnJlbGVhc2VfaW5mbyA9IHBjaV9h Y3BpX2dlbmVyaWNfcmVsZWFzZV9pbmZvOwotCXJvb3Rfb3BzLT5wcmVwYXJlX3Jlc291cmNlcyA9 IHBjaV9hY3BpX3Jvb3RfcHJlcGFyZV9yZXNvdXJjZXM7Ci0Jcm9vdF9vcHMtPnBjaV9vcHMgPSAo c3RydWN0IHBjaV9vcHMgKikmcmktPmNmZy0+b3BzLT5wY2lfb3BzOwotCWJ1cyA9IGFjcGlfcGNp X3Jvb3RfY3JlYXRlKHJvb3QsIHJvb3Rfb3BzLCAmcmktPmNvbW1vbiwgcmktPmNmZyk7Ci0JaWYg KCFidXMpCi0JCXJldHVybiBOVUxMOwotCi0JLyogSWYgd2UgbXVzdCBwcmVzZXJ2ZSB0aGUgcmVz b3VyY2UgY29uZmlndXJhdGlvbiwgY2xhaW0gbm93ICovCi0JaG9zdCA9IHBjaV9maW5kX2hvc3Rf YnJpZGdlKGJ1cyk7Ci0JaWYgKGhvc3QtPnByZXNlcnZlX2NvbmZpZykKLQkJcGNpX2J1c19jbGFp bV9yZXNvdXJjZXMoYnVzKTsKLQotCS8qCi0JICogQXNzaWduIHdoYXRldmVyIHdhcyBsZWZ0IHVu YXNzaWduZWQuIElmIHdlIGRpZG4ndCBjbGFpbSBhYm92ZSwKLQkgKiB0aGlzIHdpbGwgcmVhc3Np Z24gZXZlcnl0aGluZy4KLQkgKi8KLQlwY2lfYXNzaWduX3VuYXNzaWduZWRfcm9vdF9idXNfcmVz b3VyY2VzKGJ1cyk7Ci0KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNoaWxkLCAmYnVzLT5jaGlsZHJl biwgbm9kZSkKLQkJcGNpZV9idXNfY29uZmlndXJlX3NldHRpbmdzKGNoaWxkKTsKLQotCXJldHVy biBidXM7Ci19Ci0KLXZvaWQgcGNpYmlvc19hZGRfYnVzKHN0cnVjdCBwY2lfYnVzICpidXMpCi17 Ci0JYWNwaV9wY2lfYWRkX2J1cyhidXMpOwotfQotCi12b2lkIHBjaWJpb3NfcmVtb3ZlX2J1cyhz dHJ1Y3QgcGNpX2J1cyAqYnVzKQotewotCWFjcGlfcGNpX3JlbW92ZV9idXMoYnVzKTsKLX0KLQot I2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2ktYWNwaS5jIGIvZHJpdmVycy9wY2kv cGNpLWFjcGkuYwppbmRleCA5Y2M0NDdkYTk0NzUuLjhlZDgxYTM3M2JkNyAxMDA2NDQKLS0tIGEv ZHJpdmVycy9wY2kvcGNpLWFjcGkuYworKysgYi9kcml2ZXJzL3BjaS9wY2ktYWNwaS5jCkBAIC0x NSw2ICsxNSw3IEBACiAjaW5jbHVkZSA8bGludXgvcGNpX2hvdHBsdWcuaD4KICNpbmNsdWRlIDxs aW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9wY2ktYWNwaS5oPgorI2luY2x1ZGUgPGxp bnV4L3BjaS1lY2FtLmg+CiAjaW5jbHVkZSA8bGludXgvcG1fcnVudGltZS5oPgogI2luY2x1ZGUg PGxpbnV4L3BtX3Fvcy5oPgogI2luY2x1ZGUgPGxpbnV4L3J3c2VtLmg+CkBAIC0xNTQxLDMgKzE1 NDIsMTg0IEBAIHN0YXRpYyBpbnQgX19pbml0IGFjcGlfcGNpX2luaXQodm9pZCkKIAlyZXR1cm4g MDsKIH0KIGFyY2hfaW5pdGNhbGwoYWNwaV9wY2lfaW5pdCk7CisKKyNpZiBkZWZpbmVkKENPTkZJ R19BUk02NCkKKworLyoKKyAqIFRyeSB0byBhc3NpZ24gdGhlIElSUSBudW1iZXIgd2hlbiBwcm9i aW5nIGEgbmV3IGRldmljZQorICovCitpbnQgcGNpYmlvc19hbGxvY19pcnEoc3RydWN0IHBjaV9k ZXYgKmRldikKK3sKKwlpZiAoIWFjcGlfZGlzYWJsZWQpCisJCWFjcGlfcGNpX2lycV9lbmFibGUo ZGV2KTsKKworCXJldHVybiAwOworfQorCitzdHJ1Y3QgYWNwaV9wY2lfZ2VuZXJpY19yb290X2lu Zm8geworCXN0cnVjdCBhY3BpX3BjaV9yb290X2luZm8JY29tbW9uOworCXN0cnVjdCBwY2lfY29u ZmlnX3dpbmRvdwkqY2ZnOwkvKiBjb25maWcgc3BhY2UgbWFwcGluZyAqLworfTsKKworaW50IGFj cGlfcGNpX2J1c19maW5kX2RvbWFpbl9ucihzdHJ1Y3QgcGNpX2J1cyAqYnVzKQoreworCXN0cnVj dCBwY2lfY29uZmlnX3dpbmRvdyAqY2ZnID0gYnVzLT5zeXNkYXRhOworCXN0cnVjdCBhY3BpX2Rl dmljZSAqYWRldiA9IHRvX2FjcGlfZGV2aWNlKGNmZy0+cGFyZW50KTsKKwlzdHJ1Y3QgYWNwaV9w Y2lfcm9vdCAqcm9vdCA9IGFjcGlfZHJpdmVyX2RhdGEoYWRldik7CisKKwlyZXR1cm4gcm9vdC0+ c2VnbWVudDsKK30KKworaW50IHBjaWJpb3Nfcm9vdF9icmlkZ2VfcHJlcGFyZShzdHJ1Y3QgcGNp X2hvc3RfYnJpZGdlICpicmlkZ2UpCit7CisJc3RydWN0IHBjaV9jb25maWdfd2luZG93ICpjZmc7 CisJc3RydWN0IGFjcGlfZGV2aWNlICphZGV2OworCXN0cnVjdCBkZXZpY2UgKmJ1c19kZXY7CisK KwlpZiAoYWNwaV9kaXNhYmxlZCkKKwkJcmV0dXJuIDA7CisKKwljZmcgPSBicmlkZ2UtPmJ1cy0+ c3lzZGF0YTsKKworCS8qCisJICogT24gSHlwZXItViB0aGVyZSBpcyBubyBjb3JyZXNwb25kaW5n IEFDUEkgZGV2aWNlIGZvciBhIHJvb3QgYnJpZGdlLAorCSAqIHRoZXJlZm9yZSAtPnBhcmVudCBp cyBzZXQgYXMgTlVMTCBieSB0aGUgZHJpdmVyLiBBbmQgc2V0ICdhZGV2JyBhcworCSAqIE5VTEwg aW4gdGhpcyBjYXNlIGJlY2F1c2UgdGhlcmUgaXMgbm8gcHJvcGVyIEFDUEkgZGV2aWNlLgorCSAq LworCWlmICghY2ZnLT5wYXJlbnQpCisJCWFkZXYgPSBOVUxMOworCWVsc2UKKwkJYWRldiA9IHRv X2FjcGlfZGV2aWNlKGNmZy0+cGFyZW50KTsKKworCWJ1c19kZXYgPSAmYnJpZGdlLT5idXMtPmRl djsKKworCUFDUElfQ09NUEFOSU9OX1NFVCgmYnJpZGdlLT5kZXYsIGFkZXYpOworCXNldF9kZXZf bm9kZShidXNfZGV2LCBhY3BpX2dldF9ub2RlKGFjcGlfZGV2aWNlX2hhbmRsZShhZGV2KSkpOwor CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcGNpX2FjcGlfcm9vdF9wcmVwYXJlX3Jlc291 cmNlcyhzdHJ1Y3QgYWNwaV9wY2lfcm9vdF9pbmZvICpjaSkKK3sKKwlzdHJ1Y3QgcmVzb3VyY2Vf ZW50cnkgKmVudHJ5LCAqdG1wOworCWludCBzdGF0dXM7CisKKwlzdGF0dXMgPSBhY3BpX3BjaV9w cm9iZV9yb290X3Jlc291cmNlcyhjaSk7CisJcmVzb3VyY2VfbGlzdF9mb3JfZWFjaF9lbnRyeV9z YWZlKGVudHJ5LCB0bXAsICZjaS0+cmVzb3VyY2VzKSB7CisJCWlmICghKGVudHJ5LT5yZXMtPmZs YWdzICYgSU9SRVNPVVJDRV9XSU5ET1cpKQorCQkJcmVzb3VyY2VfbGlzdF9kZXN0cm95X2VudHJ5 KGVudHJ5KTsKKwl9CisJcmV0dXJuIHN0YXR1czsKK30KKworLyoKKyAqIExvb2t1cCB0aGUgYnVz IHJhbmdlIGZvciB0aGUgZG9tYWluIGluIE1DRkcsIGFuZCBzZXQgdXAgY29uZmlnIHNwYWNlCisg KiBtYXBwaW5nLgorICovCitzdGF0aWMgc3RydWN0IHBjaV9jb25maWdfd2luZG93ICoKK3BjaV9h Y3BpX3NldHVwX2VjYW1fbWFwcGluZyhzdHJ1Y3QgYWNwaV9wY2lfcm9vdCAqcm9vdCkKK3sKKwlz dHJ1Y3QgZGV2aWNlICpkZXYgPSAmcm9vdC0+ZGV2aWNlLT5kZXY7CisJc3RydWN0IHJlc291cmNl ICpidXNfcmVzID0gJnJvb3QtPnNlY29uZGFyeTsKKwl1MTYgc2VnID0gcm9vdC0+c2VnbWVudDsK Kwljb25zdCBzdHJ1Y3QgcGNpX2VjYW1fb3BzICplY2FtX29wczsKKwlzdHJ1Y3QgcmVzb3VyY2Ug Y2ZncmVzOworCXN0cnVjdCBhY3BpX2RldmljZSAqYWRldjsKKwlzdHJ1Y3QgcGNpX2NvbmZpZ193 aW5kb3cgKmNmZzsKKwlpbnQgcmV0OworCisJcmV0ID0gcGNpX21jZmdfbG9va3VwKHJvb3QsICZj ZmdyZXMsICZlY2FtX29wcyk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgIiUwNHg6JXBS IEVDQU0gcmVnaW9uIG5vdCBmb3VuZFxuIiwgc2VnLCBidXNfcmVzKTsKKwkJcmV0dXJuIE5VTEw7 CisJfQorCisJYWRldiA9IGFjcGlfcmVzb3VyY2VfY29uc3VtZXIoJmNmZ3Jlcyk7CisJaWYgKGFk ZXYpCisJCWRldl9pbmZvKGRldiwgIkVDQU0gYXJlYSAlcFIgcmVzZXJ2ZWQgYnkgJXNcbiIsICZj ZmdyZXMsCisJCQkgZGV2X25hbWUoJmFkZXYtPmRldikpOworCWVsc2UKKwkJZGV2X3dhcm4oZGV2 LCBGV19CVUcgIkVDQU0gYXJlYSAlcFIgbm90IHJlc2VydmVkIGluIEFDUEkgbmFtZXNwYWNlXG4i LAorCQkJICZjZmdyZXMpOworCisJY2ZnID0gcGNpX2VjYW1fY3JlYXRlKGRldiwgJmNmZ3Jlcywg YnVzX3JlcywgZWNhbV9vcHMpOworCWlmIChJU19FUlIoY2ZnKSkgeworCQlkZXZfZXJyKGRldiwg IiUwNHg6JXBSIGVycm9yICVsZCBtYXBwaW5nIEVDQU1cbiIsIHNlZywgYnVzX3JlcywKKwkJCVBU Ul9FUlIoY2ZnKSk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBjZmc7Cit9CisKKy8q IHJlbGVhc2VfaW5mbzogZnJlZSByZXNvdXJjZXMgYWxsb2NhdGVkIGJ5IGluaXRfaW5mbyAqLwor c3RhdGljIHZvaWQgcGNpX2FjcGlfZ2VuZXJpY19yZWxlYXNlX2luZm8oc3RydWN0IGFjcGlfcGNp X3Jvb3RfaW5mbyAqY2kpCit7CisJc3RydWN0IGFjcGlfcGNpX2dlbmVyaWNfcm9vdF9pbmZvICpy aTsKKworCXJpID0gY29udGFpbmVyX29mKGNpLCBzdHJ1Y3QgYWNwaV9wY2lfZ2VuZXJpY19yb290 X2luZm8sIGNvbW1vbik7CisJcGNpX2VjYW1fZnJlZShyaS0+Y2ZnKTsKKwlrZnJlZShjaS0+b3Bz KTsKKwlrZnJlZShyaSk7Cit9CisKKy8qIEludGVyZmFjZSBjYWxsZWQgZnJvbSBBQ1BJIGNvZGUg dG8gc2V0dXAgUENJIGhvc3QgY29udHJvbGxlciAqLworc3RydWN0IHBjaV9idXMgKnBjaV9hY3Bp X3NjYW5fcm9vdChzdHJ1Y3QgYWNwaV9wY2lfcm9vdCAqcm9vdCkKK3sKKwlzdHJ1Y3QgYWNwaV9w Y2lfZ2VuZXJpY19yb290X2luZm8gKnJpOworCXN0cnVjdCBwY2lfYnVzICpidXMsICpjaGlsZDsK KwlzdHJ1Y3QgYWNwaV9wY2lfcm9vdF9vcHMgKnJvb3Rfb3BzOworCXN0cnVjdCBwY2lfaG9zdF9i cmlkZ2UgKmhvc3Q7CisKKwlyaSA9IGt6YWxsb2Moc2l6ZW9mKCpyaSksIEdGUF9LRVJORUwpOwor CWlmICghcmkpCisJCXJldHVybiBOVUxMOworCisJcm9vdF9vcHMgPSBremFsbG9jKHNpemVvZigq cm9vdF9vcHMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXJvb3Rfb3BzKSB7CisJCWtmcmVlKHJpKTsK KwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmktPmNmZyA9IHBjaV9hY3BpX3NldHVwX2VjYW1fbWFw cGluZyhyb290KTsKKwlpZiAoIXJpLT5jZmcpIHsKKwkJa2ZyZWUocmkpOworCQlrZnJlZShyb290 X29wcyk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJvb3Rfb3BzLT5yZWxlYXNlX2luZm8gPSBw Y2lfYWNwaV9nZW5lcmljX3JlbGVhc2VfaW5mbzsKKwlyb290X29wcy0+cHJlcGFyZV9yZXNvdXJj ZXMgPSBwY2lfYWNwaV9yb290X3ByZXBhcmVfcmVzb3VyY2VzOworCXJvb3Rfb3BzLT5wY2lfb3Bz ID0gKHN0cnVjdCBwY2lfb3BzICopJnJpLT5jZmctPm9wcy0+cGNpX29wczsKKwlidXMgPSBhY3Bp X3BjaV9yb290X2NyZWF0ZShyb290LCByb290X29wcywgJnJpLT5jb21tb24sIHJpLT5jZmcpOwor CWlmICghYnVzKQorCQlyZXR1cm4gTlVMTDsKKworCS8qIElmIHdlIG11c3QgcHJlc2VydmUgdGhl IHJlc291cmNlIGNvbmZpZ3VyYXRpb24sIGNsYWltIG5vdyAqLworCWhvc3QgPSBwY2lfZmluZF9o b3N0X2JyaWRnZShidXMpOworCWlmIChob3N0LT5wcmVzZXJ2ZV9jb25maWcpCisJCXBjaV9idXNf Y2xhaW1fcmVzb3VyY2VzKGJ1cyk7CisKKwkvKgorCSAqIEFzc2lnbiB3aGF0ZXZlciB3YXMgbGVm dCB1bmFzc2lnbmVkLiBJZiB3ZSBkaWRuJ3QgY2xhaW0gYWJvdmUsCisJICogdGhpcyB3aWxsIHJl YXNzaWduIGV2ZXJ5dGhpbmcuCisJICovCisJcGNpX2Fzc2lnbl91bmFzc2lnbmVkX3Jvb3RfYnVz X3Jlc291cmNlcyhidXMpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjaGlsZCwgJmJ1cy0+Y2hp bGRyZW4sIG5vZGUpCisJCXBjaWVfYnVzX2NvbmZpZ3VyZV9zZXR0aW5ncyhjaGlsZCk7CisKKwly ZXR1cm4gYnVzOworfQorCit2b2lkIHBjaWJpb3NfYWRkX2J1cyhzdHJ1Y3QgcGNpX2J1cyAqYnVz KQoreworCWFjcGlfcGNpX2FkZF9idXMoYnVzKTsKK30KKwordm9pZCBwY2liaW9zX3JlbW92ZV9i dXMoc3RydWN0IHBjaV9idXMgKmJ1cykKK3sKKwlhY3BpX3BjaV9yZW1vdmVfYnVzKGJ1cyk7Cit9 CisKKyNlbmRpZgotLSAKMi40My4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3Rz LmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9saW51eC1yaXNjdgo=