mirror of
https://github.com/torvalds/linux
synced 2024-07-22 03:01:14 +00:00
Merge branches 'acpi-scan' and 'acpi-processor'
Merge ACPI device enumeration updates and ACPI processor driver updates for 6.8-rc1: - Add CSI-2 and DisCo for Imaging support to the ACPI device enumeration code (Sakari Ailus, Rafael J. Wysocki). - Adjust the cpufreq thermal reduction algorithm in the ACPI processor driver for Tegra241 (Srikar Srimath Tirumala, Arnd Bergmann). - Make acpi_proc_quirk_mwait_check() x86-specific (Rafael J. Wysocki). * acpi-scan: ACPI: scan: Fix an error message in DisCo for Imaging support ACPI: property: Replicate DT-aligned u32 properties from DisCo for Imaging ACPI: property: Dig "rotation" property for devices with CSI2 _CRS ACPI: scan: Extract MIPI DisCo for Imaging data into swnodes device property: Add SOFTWARE_NODE() macro for defining software nodes ACPI: scan: Extract _CRS CSI-2 connection information into swnodes ACPI: scan: Extract CSI-2 connection graph from _CRS ACPI: property: Support using strings in reference properties * acpi-processor: ACPI: arm64: export acpi_arch_thermal_cpufreq_pctg() ACPI: processor: reduce CPUFREQ thermal reduction pctg for Tegra241 ACPI: processor: Provide empty stub of acpi_proc_quirk_mwait_check()
This commit is contained in:
Rafael J. Wysocki
commit
e3f4440753
|
|
@ -37,7 +37,7 @@ acpi-$(CONFIG_ACPI_SLEEP) += proc.o
|
|||
# ACPI Bus and Device Drivers
|
||||
#
|
||||
acpi-y += bus.o glue.o
|
||||
acpi-y += scan.o
|
||||
acpi-y += scan.o mipi-disco-img.o
|
||||
acpi-y += resource.o
|
||||
acpi-y += acpi_processor.o
|
||||
acpi-y += processor_core.o
|
||||
|
|
|
|||
|
|
@ -5,3 +5,4 @@ obj-$(CONFIG_ACPI_GTDT) += gtdt.o
|
|||
obj-$(CONFIG_ACPI_APMT) += apmt.o
|
||||
obj-$(CONFIG_ARM_AMBA) += amba.o
|
||||
obj-y += dma.o init.o
|
||||
obj-y += thermal_cpufreq.o
|
||||
|
|
|
|||
22
drivers/acpi/arm64/thermal_cpufreq.c
Normal file
22
drivers/acpi/arm64/thermal_cpufreq.c
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/export.h>
|
||||
|
||||
#include "../internal.h"
|
||||
|
||||
#define SMCCC_SOC_ID_T241 0x036b0241
|
||||
|
||||
int acpi_arch_thermal_cpufreq_pctg(void)
|
||||
{
|
||||
s32 soc_id = arm_smccc_get_soc_id_version();
|
||||
|
||||
/*
|
||||
* Check JEP106 code for NVIDIA Tegra241 chip (036b:0241) and
|
||||
* reduce the CPUFREQ Thermal reduction percentage to 5%.
|
||||
*/
|
||||
if (soc_id == SMCCC_SOC_ID_T241)
|
||||
return 5;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_arch_thermal_cpufreq_pctg);
|
||||
|
|
@ -85,6 +85,15 @@ bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent);
|
|||
acpi_status acpi_sysfs_table_handler(u32 event, void *table, void *context);
|
||||
void acpi_scan_table_notify(void);
|
||||
|
||||
#ifdef CONFIG_ARM64
|
||||
int acpi_arch_thermal_cpufreq_pctg(void);
|
||||
#else
|
||||
static inline int acpi_arch_thermal_cpufreq_pctg(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
Device Node Initialization / Removal
|
||||
-------------------------------------------------------------------------- */
|
||||
|
|
@ -148,8 +157,11 @@ int acpi_wakeup_device_init(void);
|
|||
#ifdef CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC
|
||||
void acpi_early_processor_control_setup(void);
|
||||
void acpi_early_processor_set_pdc(void);
|
||||
|
||||
#ifdef CONFIG_X86
|
||||
void acpi_proc_quirk_mwait_check(void);
|
||||
#else
|
||||
static inline void acpi_proc_quirk_mwait_check(void) {}
|
||||
#endif
|
||||
bool processor_physically_present(acpi_handle handle);
|
||||
#else
|
||||
static inline void acpi_early_processor_control_setup(void) {}
|
||||
|
|
@ -276,4 +288,13 @@ void acpi_init_lpit(void);
|
|||
static inline void acpi_init_lpit(void) { }
|
||||
#endif
|
||||
|
||||
/*--------------------------------------------------------------------------
|
||||
ACPI _CRS CSI-2 and MIPI DisCo for Imaging
|
||||
-------------------------------------------------------------------------- */
|
||||
|
||||
void acpi_mipi_check_crs_csi2(acpi_handle handle);
|
||||
void acpi_mipi_scan_crs_csi2(void);
|
||||
void acpi_mipi_init_crs_csi2_swnodes(void);
|
||||
void acpi_mipi_crs_csi2_cleanup(void);
|
||||
|
||||
#endif /* _ACPI_INTERNAL_H_ */
|
||||
|
|
|
|||
725
drivers/acpi/mipi-disco-img.c
Normal file
725
drivers/acpi/mipi-disco-img.c
Normal file
|
|
@ -0,0 +1,725 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
/*
|
||||
* MIPI DisCo for Imaging support.
|
||||
*
|
||||
* Copyright (C) 2023 Intel Corporation
|
||||
*
|
||||
* Support MIPI DisCo for Imaging by parsing ACPI _CRS CSI-2 records defined in
|
||||
* Section 6.4.3.8.2.4 "Camera Serial Interface (CSI-2) Connection Resource
|
||||
* Descriptor" of ACPI 6.5 and using device properties defined by the MIPI DisCo
|
||||
* for Imaging specification.
|
||||
*
|
||||
* The implementation looks for the information in the ACPI namespace (CSI-2
|
||||
* resource descriptors in _CRS) and constructs software nodes compatible with
|
||||
* Documentation/firmware-guide/acpi/dsd/graph.rst to represent the CSI-2
|
||||
* connection graph. The software nodes are then populated with the data
|
||||
* extracted from the _CRS CSI-2 resource descriptors and the MIPI DisCo
|
||||
* for Imaging device properties present in _DSD for the ACPI device objects
|
||||
* with CSI-2 connections.
|
||||
*/
|
||||
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/limits.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/overflow.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
#include <media/v4l2-fwnode.h>
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
static LIST_HEAD(acpi_mipi_crs_csi2_list);
|
||||
|
||||
static void acpi_mipi_data_tag(acpi_handle handle, void *context)
|
||||
{
|
||||
}
|
||||
|
||||
/* Connection data extracted from one _CRS CSI-2 resource descriptor. */
|
||||
struct crs_csi2_connection {
|
||||
struct list_head entry;
|
||||
struct acpi_resource_csi2_serialbus csi2_data;
|
||||
acpi_handle remote_handle;
|
||||
char remote_name[];
|
||||
};
|
||||
|
||||
/* Data extracted from _CRS CSI-2 resource descriptors for one device. */
|
||||
struct crs_csi2 {
|
||||
struct list_head entry;
|
||||
acpi_handle handle;
|
||||
struct acpi_device_software_nodes *swnodes;
|
||||
struct list_head connections;
|
||||
u32 port_count;
|
||||
};
|
||||
|
||||
struct csi2_resources_walk_data {
|
||||
acpi_handle handle;
|
||||
struct list_head connections;
|
||||
};
|
||||
|
||||
static acpi_status parse_csi2_resource(struct acpi_resource *res, void *context)
|
||||
{
|
||||
struct csi2_resources_walk_data *crwd = context;
|
||||
struct acpi_resource_csi2_serialbus *csi2_res;
|
||||
struct acpi_resource_source *csi2_res_src;
|
||||
u16 csi2_res_src_length;
|
||||
struct crs_csi2_connection *conn;
|
||||
acpi_handle remote_handle;
|
||||
|
||||
if (res->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
|
||||
return AE_OK;
|
||||
|
||||
csi2_res = &res->data.csi2_serial_bus;
|
||||
|
||||
if (csi2_res->type != ACPI_RESOURCE_SERIAL_TYPE_CSI2)
|
||||
return AE_OK;
|
||||
|
||||
csi2_res_src = &csi2_res->resource_source;
|
||||
if (ACPI_FAILURE(acpi_get_handle(NULL, csi2_res_src->string_ptr,
|
||||
&remote_handle))) {
|
||||
acpi_handle_debug(crwd->handle,
|
||||
"unable to find resource source\n");
|
||||
return AE_OK;
|
||||
}
|
||||
csi2_res_src_length = csi2_res_src->string_length;
|
||||
if (!csi2_res_src_length) {
|
||||
acpi_handle_debug(crwd->handle,
|
||||
"invalid resource source string length\n");
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
conn = kmalloc(struct_size(conn, remote_name, csi2_res_src_length + 1),
|
||||
GFP_KERNEL);
|
||||
if (!conn)
|
||||
return AE_OK;
|
||||
|
||||
conn->csi2_data = *csi2_res;
|
||||
strscpy(conn->remote_name, csi2_res_src->string_ptr, csi2_res_src_length);
|
||||
conn->csi2_data.resource_source.string_ptr = conn->remote_name;
|
||||
conn->remote_handle = remote_handle;
|
||||
|
||||
list_add(&conn->entry, &crwd->connections);
|
||||
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
static struct crs_csi2 *acpi_mipi_add_crs_csi2(acpi_handle handle,
|
||||
struct list_head *list)
|
||||
{
|
||||
struct crs_csi2 *csi2;
|
||||
|
||||
csi2 = kzalloc(sizeof(*csi2), GFP_KERNEL);
|
||||
if (!csi2)
|
||||
return NULL;
|
||||
|
||||
csi2->handle = handle;
|
||||
INIT_LIST_HEAD(&csi2->connections);
|
||||
csi2->port_count = 1;
|
||||
|
||||
if (ACPI_FAILURE(acpi_attach_data(handle, acpi_mipi_data_tag, csi2))) {
|
||||
kfree(csi2);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
list_add(&csi2->entry, list);
|
||||
|
||||
return csi2;
|
||||
}
|
||||
|
||||
static struct crs_csi2 *acpi_mipi_get_crs_csi2(acpi_handle handle)
|
||||
{
|
||||
struct crs_csi2 *csi2;
|
||||
|
||||
if (ACPI_FAILURE(acpi_get_data_full(handle, acpi_mipi_data_tag,
|
||||
(void **)&csi2, NULL)))
|
||||
return NULL;
|
||||
|
||||
return csi2;
|
||||
}
|
||||
|
||||
static void csi_csr2_release_connections(struct list_head *list)
|
||||
{
|
||||
struct crs_csi2_connection *conn, *conn_tmp;
|
||||
|
||||
list_for_each_entry_safe(conn, conn_tmp, list, entry) {
|
||||
list_del(&conn->entry);
|
||||
kfree(conn);
|
||||
}
|
||||
}
|
||||
|
||||
static void acpi_mipi_del_crs_csi2(struct crs_csi2 *csi2)
|
||||
{
|
||||
list_del(&csi2->entry);
|
||||
acpi_detach_data(csi2->handle, acpi_mipi_data_tag);
|
||||
kfree(csi2->swnodes);
|
||||
csi_csr2_release_connections(&csi2->connections);
|
||||
kfree(csi2);
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_mipi_check_crs_csi2 - Look for CSI-2 resources in _CRS
|
||||
* @handle: Device object handle to evaluate _CRS for.
|
||||
*
|
||||
* Find all CSI-2 resource descriptors in the given device's _CRS
|
||||
* and collect them into a list.
|
||||
*/
|
||||
void acpi_mipi_check_crs_csi2(acpi_handle handle)
|
||||
{
|
||||
struct csi2_resources_walk_data crwd = {
|
||||
.handle = handle,
|
||||
.connections = LIST_HEAD_INIT(crwd.connections),
|
||||
};
|
||||
struct crs_csi2 *csi2;
|
||||
|
||||
/*
|
||||
* Avoid allocating _CRS CSI-2 objects for devices without any CSI-2
|
||||
* resource descriptions in _CRS to reduce overhead.
|
||||
*/
|
||||
acpi_walk_resources(handle, METHOD_NAME__CRS, parse_csi2_resource, &crwd);
|
||||
if (list_empty(&crwd.connections))
|
||||
return;
|
||||
|
||||
/*
|
||||
* Create a _CRS CSI-2 entry to store the extracted connection
|
||||
* information and add it to the global list.
|
||||
*/
|
||||
csi2 = acpi_mipi_add_crs_csi2(handle, &acpi_mipi_crs_csi2_list);
|
||||
if (!csi2) {
|
||||
csi_csr2_release_connections(&crwd.connections);
|
||||
return; /* Nothing really can be done about this. */
|
||||
}
|
||||
|
||||
list_replace(&crwd.connections, &csi2->connections);
|
||||
}
|
||||
|
||||
#define NO_CSI2_PORT (UINT_MAX - 1)
|
||||
|
||||
static void alloc_crs_csi2_swnodes(struct crs_csi2 *csi2)
|
||||
{
|
||||
size_t port_count = csi2->port_count;
|
||||
struct acpi_device_software_nodes *swnodes;
|
||||
size_t alloc_size;
|
||||
unsigned int i;
|
||||
|
||||
/*
|
||||
* Allocate memory for ports, node pointers (number of nodes +
|
||||
* 1 (guardian), nodes (root + number of ports * 2 (because for
|
||||
* every port there is an endpoint)).
|
||||
*/
|
||||
if (check_mul_overflow(sizeof(*swnodes->ports) +
|
||||
sizeof(*swnodes->nodes) * 2 +
|
||||
sizeof(*swnodes->nodeptrs) * 2,
|
||||
port_count, &alloc_size) ||
|
||||
check_add_overflow(sizeof(*swnodes) +
|
||||
sizeof(*swnodes->nodes) +
|
||||
sizeof(*swnodes->nodeptrs) * 2,
|
||||
alloc_size, &alloc_size)) {
|
||||
acpi_handle_info(csi2->handle,
|
||||
"too many _CRS CSI-2 resource handles (%zu)",
|
||||
port_count);
|
||||
return;
|
||||
}
|
||||
|
||||
swnodes = kmalloc(alloc_size, GFP_KERNEL);
|
||||
if (!swnodes)
|
||||
return;
|
||||
|
||||
swnodes->ports = (struct acpi_device_software_node_port *)(swnodes + 1);
|
||||
swnodes->nodes = (struct software_node *)(swnodes->ports + port_count);
|
||||
swnodes->nodeptrs = (const struct software_node **)(swnodes->nodes + 1 +
|
||||
2 * port_count);
|
||||
swnodes->num_ports = port_count;
|
||||
|
||||
for (i = 0; i < 2 * port_count + 1; i++)
|
||||
swnodes->nodeptrs[i] = &swnodes->nodes[i];
|
||||
|
||||
swnodes->nodeptrs[i] = NULL;
|
||||
|
||||
for (i = 0; i < port_count; i++)
|
||||
swnodes->ports[i].port_nr = NO_CSI2_PORT;
|
||||
|
||||
csi2->swnodes = swnodes;
|
||||
}
|
||||
|
||||
#define ACPI_CRS_CSI2_PHY_TYPE_C 0
|
||||
#define ACPI_CRS_CSI2_PHY_TYPE_D 1
|
||||
|
||||
static unsigned int next_csi2_port_index(struct acpi_device_software_nodes *swnodes,
|
||||
unsigned int port_nr)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < swnodes->num_ports; i++) {
|
||||
struct acpi_device_software_node_port *port = &swnodes->ports[i];
|
||||
|
||||
if (port->port_nr == port_nr)
|
||||
return i;
|
||||
|
||||
if (port->port_nr == NO_CSI2_PORT) {
|
||||
port->port_nr = port_nr;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return NO_CSI2_PORT;
|
||||
}
|
||||
|
||||
/* Print graph port name into a buffer, return non-zero on failure. */
|
||||
#define GRAPH_PORT_NAME(var, num) \
|
||||
(snprintf((var), sizeof(var), SWNODE_GRAPH_PORT_NAME_FMT, (num)) >= \
|
||||
sizeof(var))
|
||||
|
||||
static void extract_crs_csi2_conn_info(acpi_handle local_handle,
|
||||
struct acpi_device_software_nodes *local_swnodes,
|
||||
struct crs_csi2_connection *conn)
|
||||
{
|
||||
struct crs_csi2 *remote_csi2 = acpi_mipi_get_crs_csi2(conn->remote_handle);
|
||||
struct acpi_device_software_nodes *remote_swnodes;
|
||||
struct acpi_device_software_node_port *local_port, *remote_port;
|
||||
struct software_node *local_node, *remote_node;
|
||||
unsigned int local_index, remote_index;
|
||||
unsigned int bus_type;
|
||||
|
||||
/*
|
||||
* If the previous steps have failed to make room for a _CRS CSI-2
|
||||
* representation for the remote end of the given connection, skip it.
|
||||
*/
|
||||
if (!remote_csi2)
|
||||
return;
|
||||
|
||||
remote_swnodes = remote_csi2->swnodes;
|
||||
if (!remote_swnodes)
|
||||
return;
|
||||
|
||||
switch (conn->csi2_data.phy_type) {
|
||||
case ACPI_CRS_CSI2_PHY_TYPE_C:
|
||||
bus_type = V4L2_FWNODE_BUS_TYPE_CSI2_CPHY;
|
||||
break;
|
||||
|
||||
case ACPI_CRS_CSI2_PHY_TYPE_D:
|
||||
bus_type = V4L2_FWNODE_BUS_TYPE_CSI2_DPHY;
|
||||
break;
|
||||
|
||||
default:
|
||||
acpi_handle_info(local_handle, "unknown CSI-2 PHY type %u\n",
|
||||
conn->csi2_data.phy_type);
|
||||
return;
|
||||
}
|
||||
|
||||
local_index = next_csi2_port_index(local_swnodes,
|
||||
conn->csi2_data.local_port_instance);
|
||||
if (WARN_ON_ONCE(local_index >= local_swnodes->num_ports))
|
||||
return;
|
||||
|
||||
remote_index = next_csi2_port_index(remote_swnodes,
|
||||
conn->csi2_data.resource_source.index);
|
||||
if (WARN_ON_ONCE(remote_index >= remote_swnodes->num_ports))
|
||||
return;
|
||||
|
||||
local_port = &local_swnodes->ports[local_index];
|
||||
local_node = &local_swnodes->nodes[ACPI_DEVICE_SWNODE_EP(local_index)];
|
||||
local_port->crs_csi2_local = true;
|
||||
|
||||
remote_port = &remote_swnodes->ports[remote_index];
|
||||
remote_node = &remote_swnodes->nodes[ACPI_DEVICE_SWNODE_EP(remote_index)];
|
||||
|
||||
local_port->remote_ep[0] = SOFTWARE_NODE_REFERENCE(remote_node);
|
||||
remote_port->remote_ep[0] = SOFTWARE_NODE_REFERENCE(local_node);
|
||||
|
||||
local_port->ep_props[ACPI_DEVICE_SWNODE_EP_REMOTE_EP] =
|
||||
PROPERTY_ENTRY_REF_ARRAY("remote-endpoint",
|
||||
local_port->remote_ep);
|
||||
|
||||
local_port->ep_props[ACPI_DEVICE_SWNODE_EP_BUS_TYPE] =
|
||||
PROPERTY_ENTRY_U32("bus-type", bus_type);
|
||||
|
||||
local_port->ep_props[ACPI_DEVICE_SWNODE_EP_REG] =
|
||||
PROPERTY_ENTRY_U32("reg", 0);
|
||||
|
||||
local_port->port_props[ACPI_DEVICE_SWNODE_PORT_REG] =
|
||||
PROPERTY_ENTRY_U32("reg", conn->csi2_data.local_port_instance);
|
||||
|
||||
if (GRAPH_PORT_NAME(local_port->port_name,
|
||||
conn->csi2_data.local_port_instance))
|
||||
acpi_handle_info(local_handle, "local port %u name too long",
|
||||
conn->csi2_data.local_port_instance);
|
||||
|
||||
remote_port->ep_props[ACPI_DEVICE_SWNODE_EP_REMOTE_EP] =
|
||||
PROPERTY_ENTRY_REF_ARRAY("remote-endpoint",
|
||||
remote_port->remote_ep);
|
||||
|
||||
remote_port->ep_props[ACPI_DEVICE_SWNODE_EP_BUS_TYPE] =
|
||||
PROPERTY_ENTRY_U32("bus-type", bus_type);
|
||||
|
||||
remote_port->ep_props[ACPI_DEVICE_SWNODE_EP_REG] =
|
||||
PROPERTY_ENTRY_U32("reg", 0);
|
||||
|
||||
remote_port->port_props[ACPI_DEVICE_SWNODE_PORT_REG] =
|
||||
PROPERTY_ENTRY_U32("reg", conn->csi2_data.resource_source.index);
|
||||
|
||||
if (GRAPH_PORT_NAME(remote_port->port_name,
|
||||
conn->csi2_data.resource_source.index))
|
||||
acpi_handle_info(local_handle, "remote port %u name too long",
|
||||
conn->csi2_data.resource_source.index);
|
||||
}
|
||||
|
||||
static void prepare_crs_csi2_swnodes(struct crs_csi2 *csi2)
|
||||
{
|
||||
struct acpi_device_software_nodes *local_swnodes = csi2->swnodes;
|
||||
acpi_handle local_handle = csi2->handle;
|
||||
struct crs_csi2_connection *conn;
|
||||
|
||||
/* Bail out if the allocation of swnodes has failed. */
|
||||
if (!local_swnodes)
|
||||
return;
|
||||
|
||||
list_for_each_entry(conn, &csi2->connections, entry)
|
||||
extract_crs_csi2_conn_info(local_handle, local_swnodes, conn);
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_mipi_scan_crs_csi2 - Create ACPI _CRS CSI-2 software nodes
|
||||
*
|
||||
* Note that this function must be called before any struct acpi_device objects
|
||||
* are bound to any ACPI drivers or scan handlers, so it cannot assume the
|
||||
* existence of struct acpi_device objects for every device present in the ACPI
|
||||
* namespace.
|
||||
*
|
||||
* acpi_scan_lock in scan.c must be held when calling this function.
|
||||
*/
|
||||
void acpi_mipi_scan_crs_csi2(void)
|
||||
{
|
||||
struct crs_csi2 *csi2;
|
||||
LIST_HEAD(aux_list);
|
||||
|
||||
/* Count references to each ACPI handle in the CSI-2 connection graph. */
|
||||
list_for_each_entry(csi2, &acpi_mipi_crs_csi2_list, entry) {
|
||||
struct crs_csi2_connection *conn;
|
||||
|
||||
list_for_each_entry(conn, &csi2->connections, entry) {
|
||||
struct crs_csi2 *remote_csi2;
|
||||
|
||||
csi2->port_count++;
|
||||
|
||||
remote_csi2 = acpi_mipi_get_crs_csi2(conn->remote_handle);
|
||||
if (remote_csi2) {
|
||||
remote_csi2->port_count++;
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* The remote endpoint has no _CRS CSI-2 list entry yet,
|
||||
* so create one for it and add it to the list.
|
||||
*/
|
||||
acpi_mipi_add_crs_csi2(conn->remote_handle, &aux_list);
|
||||
}
|
||||
}
|
||||
list_splice(&aux_list, &acpi_mipi_crs_csi2_list);
|
||||
|
||||
/*
|
||||
* Allocate software nodes for representing the CSI-2 information.
|
||||
*
|
||||
* This needs to be done for all of the list entries in one go, because
|
||||
* they may point to each other without restrictions and the next step
|
||||
* relies on the availability of swnodes memory for each list entry.
|
||||
*/
|
||||
list_for_each_entry(csi2, &acpi_mipi_crs_csi2_list, entry)
|
||||
alloc_crs_csi2_swnodes(csi2);
|
||||
|
||||
/*
|
||||
* Set up software node properties using data from _CRS CSI-2 resource
|
||||
* descriptors.
|
||||
*/
|
||||
list_for_each_entry(csi2, &acpi_mipi_crs_csi2_list, entry)
|
||||
prepare_crs_csi2_swnodes(csi2);
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the index of the next property in the property array, with a given
|
||||
* maximum value.
|
||||
*/
|
||||
#define NEXT_PROPERTY(index, max) \
|
||||
(WARN_ON((index) > ACPI_DEVICE_SWNODE_##max) ? \
|
||||
ACPI_DEVICE_SWNODE_##max : (index)++)
|
||||
|
||||
static void init_csi2_port_local(struct acpi_device *adev,
|
||||
struct acpi_device_software_node_port *port,
|
||||
struct fwnode_handle *port_fwnode,
|
||||
unsigned int index)
|
||||
{
|
||||
acpi_handle handle = acpi_device_handle(adev);
|
||||
unsigned int num_link_freqs;
|
||||
int ret;
|
||||
|
||||
ret = fwnode_property_count_u64(port_fwnode, "mipi-img-link-frequencies");
|
||||
if (ret <= 0)
|
||||
return;
|
||||
|
||||
num_link_freqs = ret;
|
||||
if (num_link_freqs > ACPI_DEVICE_CSI2_DATA_LANES) {
|
||||
acpi_handle_info(handle, "Too many link frequencies: %u\n",
|
||||
num_link_freqs);
|
||||
num_link_freqs = ACPI_DEVICE_CSI2_DATA_LANES;
|
||||
}
|
||||
|
||||
ret = fwnode_property_read_u64_array(port_fwnode,
|
||||
"mipi-img-link-frequencies",
|
||||
port->link_frequencies,
|
||||
num_link_freqs);
|
||||
if (ret) {
|
||||
acpi_handle_info(handle, "Unable to get link frequencies (%d)\n",
|
||||
ret);
|
||||
return;
|
||||
}
|
||||
|
||||
port->ep_props[NEXT_PROPERTY(index, EP_LINK_FREQUENCIES)] =
|
||||
PROPERTY_ENTRY_U64_ARRAY_LEN("link-frequencies",
|
||||
port->link_frequencies,
|
||||
num_link_freqs);
|
||||
}
|
||||
|
||||
static void init_csi2_port(struct acpi_device *adev,
|
||||
struct acpi_device_software_nodes *swnodes,
|
||||
struct acpi_device_software_node_port *port,
|
||||
struct fwnode_handle *port_fwnode,
|
||||
unsigned int port_index)
|
||||
{
|
||||
unsigned int ep_prop_index = ACPI_DEVICE_SWNODE_EP_CLOCK_LANES;
|
||||
acpi_handle handle = acpi_device_handle(adev);
|
||||
u8 val[ACPI_DEVICE_CSI2_DATA_LANES];
|
||||
int num_lanes = 0;
|
||||
int ret;
|
||||
|
||||
if (GRAPH_PORT_NAME(port->port_name, port->port_nr))
|
||||
return;
|
||||
|
||||
swnodes->nodes[ACPI_DEVICE_SWNODE_PORT(port_index)] =
|
||||
SOFTWARE_NODE(port->port_name, port->port_props,
|
||||
&swnodes->nodes[ACPI_DEVICE_SWNODE_ROOT]);
|
||||
|
||||
ret = fwnode_property_read_u8(port_fwnode, "mipi-img-clock-lane", val);
|
||||
if (!ret)
|
||||
port->ep_props[NEXT_PROPERTY(ep_prop_index, EP_CLOCK_LANES)] =
|
||||
PROPERTY_ENTRY_U32("clock-lanes", val[0]);
|
||||
|
||||
ret = fwnode_property_count_u8(port_fwnode, "mipi-img-data-lanes");
|
||||
if (ret > 0) {
|
||||
num_lanes = ret;
|
||||
|
||||
if (num_lanes > ACPI_DEVICE_CSI2_DATA_LANES) {
|
||||
acpi_handle_info(handle, "Too many data lanes: %u\n",
|
||||
num_lanes);
|
||||
num_lanes = ACPI_DEVICE_CSI2_DATA_LANES;
|
||||
}
|
||||
|
||||
ret = fwnode_property_read_u8_array(port_fwnode,
|
||||
"mipi-img-data-lanes",
|
||||
val, num_lanes);
|
||||
if (!ret) {
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < num_lanes; i++)
|
||||
port->data_lanes[i] = val[i];
|
||||
|
||||
port->ep_props[NEXT_PROPERTY(ep_prop_index, EP_DATA_LANES)] =
|
||||
PROPERTY_ENTRY_U32_ARRAY_LEN("data-lanes",
|
||||
port->data_lanes,
|
||||
num_lanes);
|
||||
}
|
||||
}
|
||||
|
||||
ret = fwnode_property_count_u8(port_fwnode, "mipi-img-lane-polarities");
|
||||
if (ret < 0) {
|
||||
acpi_handle_debug(handle, "Lane polarity bytes missing\n");
|
||||
} else if (ret * BITS_PER_TYPE(u8) < num_lanes + 1) {
|
||||
acpi_handle_info(handle, "Too few lane polarity bits (%zu vs. %d)\n",
|
||||
ret * BITS_PER_TYPE(u8), num_lanes + 1);
|
||||
} else {
|
||||
unsigned long mask = 0;
|
||||
int byte_count = ret;
|
||||
unsigned int i;
|
||||
|
||||
/*
|
||||
* The total number of lanes is ACPI_DEVICE_CSI2_DATA_LANES + 1
|
||||
* (data lanes + clock lane). It is not expected to ever be
|
||||
* greater than the number of bits in an unsigned long
|
||||
* variable, but ensure that this is the case.
|
||||
*/
|
||||
BUILD_BUG_ON(BITS_PER_TYPE(unsigned long) <= ACPI_DEVICE_CSI2_DATA_LANES);
|
||||
|
||||
if (byte_count > sizeof(mask)) {
|
||||
acpi_handle_info(handle, "Too many lane polarities: %d\n",
|
||||
byte_count);
|
||||
byte_count = sizeof(mask);
|
||||
}
|
||||
fwnode_property_read_u8_array(port_fwnode, "mipi-img-lane-polarities",
|
||||
val, byte_count);
|
||||
|
||||
for (i = 0; i < byte_count; i++)
|
||||
mask |= (unsigned long)val[i] << BITS_PER_TYPE(u8) * i;
|
||||
|
||||
for (i = 0; i <= num_lanes; i++)
|
||||
port->lane_polarities[i] = test_bit(i, &mask);
|
||||
|
||||
port->ep_props[NEXT_PROPERTY(ep_prop_index, EP_LANE_POLARITIES)] =
|
||||
PROPERTY_ENTRY_U32_ARRAY_LEN("lane-polarities",
|
||||
port->lane_polarities,
|
||||
num_lanes + 1);
|
||||
}
|
||||
|
||||
swnodes->nodes[ACPI_DEVICE_SWNODE_EP(port_index)] =
|
||||
SOFTWARE_NODE("endpoint@0", swnodes->ports[port_index].ep_props,
|
||||
&swnodes->nodes[ACPI_DEVICE_SWNODE_PORT(port_index)]);
|
||||
|
||||
if (port->crs_csi2_local)
|
||||
init_csi2_port_local(adev, port, port_fwnode, ep_prop_index);
|
||||
}
|
||||
|
||||
#define MIPI_IMG_PORT_PREFIX "mipi-img-port-"
|
||||
|
||||
static struct fwnode_handle *get_mipi_port_handle(struct fwnode_handle *adev_fwnode,
|
||||
unsigned int port_nr)
|
||||
{
|
||||
char port_name[sizeof(MIPI_IMG_PORT_PREFIX) + 2];
|
||||
|
||||
if (snprintf(port_name, sizeof(port_name), "%s%u",
|
||||
MIPI_IMG_PORT_PREFIX, port_nr) >= sizeof(port_name))
|
||||
return NULL;
|
||||
|
||||
return fwnode_get_named_child_node(adev_fwnode, port_name);
|
||||
}
|
||||
|
||||
static void init_crs_csi2_swnodes(struct crs_csi2 *csi2)
|
||||
{
|
||||
struct acpi_buffer buffer = { .length = ACPI_ALLOCATE_BUFFER };
|
||||
struct acpi_device_software_nodes *swnodes = csi2->swnodes;
|
||||
acpi_handle handle = csi2->handle;
|
||||
unsigned int prop_index = 0;
|
||||
struct fwnode_handle *adev_fwnode;
|
||||
struct acpi_device *adev;
|
||||
acpi_status status;
|
||||
unsigned int i;
|
||||
u32 val;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* Bail out if the swnodes are not available (either they have not been
|
||||
* allocated or they have been assigned to the device already).
|
||||
*/
|
||||
if (!swnodes)
|
||||
return;
|
||||
|
||||
adev = acpi_fetch_acpi_dev(handle);
|
||||
if (!adev)
|
||||
return;
|
||||
|
||||
adev_fwnode = acpi_fwnode_handle(adev);
|
||||
|
||||
/*
|
||||
* If the "rotation" property is not present, but _PLD is there,
|
||||
* evaluate it to get the "rotation" value.
|
||||
*/
|
||||
if (!fwnode_property_present(adev_fwnode, "rotation")) {
|
||||
struct acpi_pld_info *pld;
|
||||
|
||||
status = acpi_get_physical_device_location(handle, &pld);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
swnodes->dev_props[NEXT_PROPERTY(prop_index, DEV_ROTATION)] =
|
||||
PROPERTY_ENTRY_U32("rotation",
|
||||
pld->rotation * 45U);
|
||||
kfree(pld);
|
||||
}
|
||||
}
|
||||
|
||||
if (!fwnode_property_read_u32(adev_fwnode, "mipi-img-clock-frequency", &val))
|
||||
swnodes->dev_props[NEXT_PROPERTY(prop_index, DEV_CLOCK_FREQUENCY)] =
|
||||
PROPERTY_ENTRY_U32("clock-frequency", val);
|
||||
|
||||
if (!fwnode_property_read_u32(adev_fwnode, "mipi-img-led-max-current", &val))
|
||||
swnodes->dev_props[NEXT_PROPERTY(prop_index, DEV_LED_MAX_MICROAMP)] =
|
||||
PROPERTY_ENTRY_U32("led-max-microamp", val);
|
||||
|
||||
if (!fwnode_property_read_u32(adev_fwnode, "mipi-img-flash-max-current", &val))
|
||||
swnodes->dev_props[NEXT_PROPERTY(prop_index, DEV_FLASH_MAX_MICROAMP)] =
|
||||
PROPERTY_ENTRY_U32("flash-max-microamp", val);
|
||||
|
||||
if (!fwnode_property_read_u32(adev_fwnode, "mipi-img-flash-max-timeout-us", &val))
|
||||
swnodes->dev_props[NEXT_PROPERTY(prop_index, DEV_FLASH_MAX_TIMEOUT_US)] =
|
||||
PROPERTY_ENTRY_U32("flash-max-timeout-us", val);
|
||||
|
||||
status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
acpi_handle_info(handle, "Unable to get the path name\n");
|
||||
return;
|
||||
}
|
||||
|
||||
swnodes->nodes[ACPI_DEVICE_SWNODE_ROOT] =
|
||||
SOFTWARE_NODE(buffer.pointer, swnodes->dev_props, NULL);
|
||||
|
||||
for (i = 0; i < swnodes->num_ports; i++) {
|
||||
struct acpi_device_software_node_port *port = &swnodes->ports[i];
|
||||
struct fwnode_handle *port_fwnode;
|
||||
|
||||
/*
|
||||
* The MIPI DisCo for Imaging specification defines _DSD device
|
||||
* properties for providing CSI-2 port parameters that can be
|
||||
* accessed through the generic device properties framework. To
|
||||
* access them, it is first necessary to find the data node
|
||||
* representing the port under the given ACPI device object.
|
||||
*/
|
||||
port_fwnode = get_mipi_port_handle(adev_fwnode, port->port_nr);
|
||||
if (!port_fwnode) {
|
||||
acpi_handle_info(handle,
|
||||
"MIPI port name too long for port %u\n",
|
||||
port->port_nr);
|
||||
continue;
|
||||
}
|
||||
|
||||
init_csi2_port(adev, swnodes, port, port_fwnode, i);
|
||||
|
||||
fwnode_handle_put(port_fwnode);
|
||||
}
|
||||
|
||||
ret = software_node_register_node_group(swnodes->nodeptrs);
|
||||
if (ret < 0) {
|
||||
acpi_handle_info(handle,
|
||||
"Unable to register software nodes (%d)\n", ret);
|
||||
return;
|
||||
}
|
||||
|
||||
adev->swnodes = swnodes;
|
||||
adev_fwnode->secondary = software_node_fwnode(swnodes->nodes);
|
||||
|
||||
/*
|
||||
* Prevents the swnodes from this csi2 entry from being assigned again
|
||||
* or freed prematurely.
|
||||
*/
|
||||
csi2->swnodes = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_mipi_init_crs_csi2_swnodes - Initialize _CRS CSI-2 software nodes
|
||||
*
|
||||
* Use MIPI DisCo for Imaging device properties to finalize the initialization
|
||||
* of CSI-2 software nodes for all ACPI device objects that have been already
|
||||
* enumerated.
|
||||
*/
|
||||
void acpi_mipi_init_crs_csi2_swnodes(void)
|
||||
{
|
||||
struct crs_csi2 *csi2, *csi2_tmp;
|
||||
|
||||
list_for_each_entry_safe(csi2, csi2_tmp, &acpi_mipi_crs_csi2_list, entry)
|
||||
init_crs_csi2_swnodes(csi2);
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_mipi_crs_csi2_cleanup - Free _CRS CSI-2 temporary data
|
||||
*/
|
||||
void acpi_mipi_crs_csi2_cleanup(void)
|
||||
{
|
||||
struct crs_csi2 *csi2, *csi2_tmp;
|
||||
|
||||
list_for_each_entry_safe(csi2, csi2_tmp, &acpi_mipi_crs_csi2_list, entry)
|
||||
acpi_mipi_del_crs_csi2(csi2);
|
||||
}
|
||||
|
|
@ -17,6 +17,8 @@
|
|||
#include <acpi/processor.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
#ifdef CONFIG_CPU_FREQ
|
||||
|
||||
/* If a passive cooling situation is detected, primarily CPUfreq is used, as it
|
||||
|
|
@ -26,12 +28,21 @@
|
|||
*/
|
||||
|
||||
#define CPUFREQ_THERMAL_MIN_STEP 0
|
||||
#define CPUFREQ_THERMAL_MAX_STEP 3
|
||||
|
||||
static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
|
||||
static int cpufreq_thermal_max_step __read_mostly = 3;
|
||||
|
||||
#define reduction_pctg(cpu) \
|
||||
per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu))
|
||||
/*
|
||||
* Minimum throttle percentage for processor_thermal cooling device.
|
||||
* The processor_thermal driver uses it to calculate the percentage amount by
|
||||
* which cpu frequency must be reduced for each cooling state. This is also used
|
||||
* to calculate the maximum number of throttling steps or cooling states.
|
||||
*/
|
||||
static int cpufreq_thermal_reduction_pctg __read_mostly = 20;
|
||||
|
||||
static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_step);
|
||||
|
||||
#define reduction_step(cpu) \
|
||||
per_cpu(cpufreq_thermal_reduction_step, phys_package_first_cpu(cpu))
|
||||
|
||||
/*
|
||||
* Emulate "per package data" using per cpu data (which should really be
|
||||
|
|
@ -71,7 +82,7 @@ static int cpufreq_get_max_state(unsigned int cpu)
|
|||
if (!cpu_has_cpufreq(cpu))
|
||||
return 0;
|
||||
|
||||
return CPUFREQ_THERMAL_MAX_STEP;
|
||||
return cpufreq_thermal_max_step;
|
||||
}
|
||||
|
||||
static int cpufreq_get_cur_state(unsigned int cpu)
|
||||
|
|
@ -79,7 +90,7 @@ static int cpufreq_get_cur_state(unsigned int cpu)
|
|||
if (!cpu_has_cpufreq(cpu))
|
||||
return 0;
|
||||
|
||||
return reduction_pctg(cpu);
|
||||
return reduction_step(cpu);
|
||||
}
|
||||
|
||||
static int cpufreq_set_cur_state(unsigned int cpu, int state)
|
||||
|
|
@ -92,7 +103,7 @@ static int cpufreq_set_cur_state(unsigned int cpu, int state)
|
|||
if (!cpu_has_cpufreq(cpu))
|
||||
return 0;
|
||||
|
||||
reduction_pctg(cpu) = state;
|
||||
reduction_step(cpu) = state;
|
||||
|
||||
/*
|
||||
* Update all the CPUs in the same package because they all
|
||||
|
|
@ -113,7 +124,8 @@ static int cpufreq_set_cur_state(unsigned int cpu, int state)
|
|||
if (!policy)
|
||||
return -EINVAL;
|
||||
|
||||
max_freq = (policy->cpuinfo.max_freq * (100 - reduction_pctg(i) * 20)) / 100;
|
||||
max_freq = (policy->cpuinfo.max_freq *
|
||||
(100 - reduction_step(i) * cpufreq_thermal_reduction_pctg)) / 100;
|
||||
|
||||
cpufreq_cpu_put(policy);
|
||||
|
||||
|
|
@ -126,10 +138,29 @@ static int cpufreq_set_cur_state(unsigned int cpu, int state)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void acpi_thermal_cpufreq_config(void)
|
||||
{
|
||||
int cpufreq_pctg = acpi_arch_thermal_cpufreq_pctg();
|
||||
|
||||
if (!cpufreq_pctg)
|
||||
return;
|
||||
|
||||
cpufreq_thermal_reduction_pctg = cpufreq_pctg;
|
||||
|
||||
/*
|
||||
* Derive the MAX_STEP from minimum throttle percentage so that the reduction
|
||||
* percentage doesn't end up becoming negative. Also, cap the MAX_STEP so that
|
||||
* the CPU performance doesn't become 0.
|
||||
*/
|
||||
cpufreq_thermal_max_step = (100 / cpufreq_pctg) - 2;
|
||||
}
|
||||
|
||||
void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy)
|
||||
{
|
||||
unsigned int cpu;
|
||||
|
||||
acpi_thermal_cpufreq_config();
|
||||
|
||||
for_each_cpu(cpu, policy->related_cpus) {
|
||||
struct acpi_processor *pr = per_cpu(processors, cpu);
|
||||
int ret;
|
||||
|
|
@ -190,7 +221,7 @@ static int acpi_processor_max_state(struct acpi_processor *pr)
|
|||
|
||||
/*
|
||||
* There exists four states according to
|
||||
* cpufreq_thermal_reduction_pctg. 0, 1, 2, 3
|
||||
* cpufreq_thermal_reduction_step. 0, 1, 2, 3
|
||||
*/
|
||||
max_state += cpufreq_get_max_state(pr->id);
|
||||
if (pr->flags.throttling)
|
||||
|
|
|
|||
|
|
@ -2,14 +2,17 @@
|
|||
/*
|
||||
* ACPI device specific properties support.
|
||||
*
|
||||
* Copyright (C) 2014, Intel Corporation
|
||||
* Copyright (C) 2014 - 2023, Intel Corporation
|
||||
* All rights reserved.
|
||||
*
|
||||
* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
|
||||
* Darren Hart <dvhart@linux.intel.com>
|
||||
* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
|
||||
* Sakari Ailus <sakari.ailus@linux.intel.com>
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) "ACPI: " fmt
|
||||
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/export.h>
|
||||
|
|
@ -800,28 +803,16 @@ static int acpi_get_ref_args(struct fwnode_reference_args *args,
|
|||
{
|
||||
u32 nargs = 0, i;
|
||||
|
||||
/*
|
||||
* Find the referred data extension node under the
|
||||
* referred device node.
|
||||
*/
|
||||
for (; *element < end && (*element)->type == ACPI_TYPE_STRING;
|
||||
(*element)++) {
|
||||
const char *child_name = (*element)->string.pointer;
|
||||
|
||||
ref_fwnode = acpi_fwnode_get_named_child_node(ref_fwnode, child_name);
|
||||
if (!ref_fwnode)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Assume the following integer elements are all args. Stop counting on
|
||||
* the first reference or end of the package arguments. In case of
|
||||
* neither reference, nor integer, return an error, we can't parse it.
|
||||
* the first reference (possibly represented as a string) or end of the
|
||||
* package arguments. In case of neither reference, nor integer, return
|
||||
* an error, we can't parse it.
|
||||
*/
|
||||
for (i = 0; (*element) + i < end && i < num_args; i++) {
|
||||
acpi_object_type type = (*element)[i].type;
|
||||
|
||||
if (type == ACPI_TYPE_LOCAL_REFERENCE)
|
||||
if (type == ACPI_TYPE_LOCAL_REFERENCE || type == ACPI_TYPE_STRING)
|
||||
break;
|
||||
|
||||
if (type == ACPI_TYPE_INTEGER)
|
||||
|
|
@ -845,6 +836,44 @@ static int acpi_get_ref_args(struct fwnode_reference_args *args,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static struct fwnode_handle *acpi_parse_string_ref(const struct fwnode_handle *fwnode,
|
||||
const char *refstring)
|
||||
{
|
||||
acpi_handle scope, handle;
|
||||
struct acpi_data_node *dn;
|
||||
struct acpi_device *device;
|
||||
acpi_status status;
|
||||
|
||||
if (is_acpi_device_node(fwnode)) {
|
||||
scope = to_acpi_device_node(fwnode)->handle;
|
||||
} else if (is_acpi_data_node(fwnode)) {
|
||||
scope = to_acpi_data_node(fwnode)->handle;
|
||||
} else {
|
||||
pr_debug("Bad node type for node %pfw\n", fwnode);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
status = acpi_get_handle(scope, refstring, &handle);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
acpi_handle_debug(scope, "Unable to get an ACPI handle for %s\n",
|
||||
refstring);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
device = acpi_fetch_acpi_dev(handle);
|
||||
if (device)
|
||||
return acpi_fwnode_handle(device);
|
||||
|
||||
status = acpi_get_data_full(handle, acpi_nondev_subnode_tag,
|
||||
(void **)&dn, NULL);
|
||||
if (ACPI_FAILURE(status) || !dn) {
|
||||
acpi_handle_debug(handle, "Subnode not found\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return &dn->fwnode;
|
||||
}
|
||||
|
||||
/**
|
||||
* __acpi_node_get_property_reference - returns handle to the referenced object
|
||||
* @fwnode: Firmware node to get the property from
|
||||
|
|
@ -887,6 +916,7 @@ int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
|
|||
const union acpi_object *element, *end;
|
||||
const union acpi_object *obj;
|
||||
const struct acpi_device_data *data;
|
||||
struct fwnode_handle *ref_fwnode;
|
||||
struct acpi_device *device;
|
||||
int ret, idx = 0;
|
||||
|
||||
|
|
@ -910,16 +940,30 @@ int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
|
|||
|
||||
args->fwnode = acpi_fwnode_handle(device);
|
||||
args->nargs = 0;
|
||||
|
||||
return 0;
|
||||
case ACPI_TYPE_STRING:
|
||||
if (index)
|
||||
return -ENOENT;
|
||||
|
||||
ref_fwnode = acpi_parse_string_ref(fwnode, obj->string.pointer);
|
||||
if (!ref_fwnode)
|
||||
return -EINVAL;
|
||||
|
||||
args->fwnode = ref_fwnode;
|
||||
args->nargs = 0;
|
||||
|
||||
return 0;
|
||||
case ACPI_TYPE_PACKAGE:
|
||||
/*
|
||||
* If it is not a single reference, then it is a package of
|
||||
* references followed by number of ints as follows:
|
||||
* references, followed by number of ints as follows:
|
||||
*
|
||||
* Package () { REF, INT, REF, INT, INT }
|
||||
*
|
||||
* The index argument is then used to determine which reference
|
||||
* the caller wants (along with the arguments).
|
||||
* Here, REF may be either a local reference or a string. The
|
||||
* index argument is then used to determine which reference the
|
||||
* caller wants (along with the arguments).
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
|
|
@ -950,6 +994,24 @@ int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
|
|||
if (idx == index)
|
||||
return 0;
|
||||
|
||||
break;
|
||||
case ACPI_TYPE_STRING:
|
||||
ref_fwnode = acpi_parse_string_ref(fwnode,
|
||||
element->string.pointer);
|
||||
if (!ref_fwnode)
|
||||
return -EINVAL;
|
||||
|
||||
element++;
|
||||
|
||||
ret = acpi_get_ref_args(idx == index ? args : NULL,
|
||||
ref_fwnode, &element, end,
|
||||
num_args);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (idx == index)
|
||||
return 0;
|
||||
|
||||
break;
|
||||
case ACPI_TYPE_INTEGER:
|
||||
if (idx == index)
|
||||
|
|
|
|||
|
|
@ -1981,7 +1981,7 @@ static void acpi_scan_init_hotplug(struct acpi_device *adev)
|
|||
}
|
||||
}
|
||||
|
||||
static u32 acpi_scan_check_dep(acpi_handle handle, bool check_dep)
|
||||
static u32 acpi_scan_check_dep(acpi_handle handle)
|
||||
{
|
||||
struct acpi_handle_list dep_devices;
|
||||
acpi_status status;
|
||||
|
|
@ -1994,8 +1994,7 @@ static u32 acpi_scan_check_dep(acpi_handle handle, bool check_dep)
|
|||
* 2. ACPI nodes describing USB ports.
|
||||
* Still, checking for _HID catches more then just these cases ...
|
||||
*/
|
||||
if (!check_dep || !acpi_has_method(handle, "_DEP") ||
|
||||
!acpi_has_method(handle, "_HID"))
|
||||
if (!acpi_has_method(handle, "_DEP") || !acpi_has_method(handle, "_HID"))
|
||||
return 0;
|
||||
|
||||
status = acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices);
|
||||
|
|
@ -2041,7 +2040,13 @@ static u32 acpi_scan_check_dep(acpi_handle handle, bool check_dep)
|
|||
return count;
|
||||
}
|
||||
|
||||
static acpi_status acpi_bus_check_add(acpi_handle handle, bool check_dep,
|
||||
static acpi_status acpi_scan_check_crs_csi2_cb(acpi_handle handle, u32 a, void *b, void **c)
|
||||
{
|
||||
acpi_mipi_check_crs_csi2(handle);
|
||||
return AE_OK;
|
||||
}
|
||||
|
||||
static acpi_status acpi_bus_check_add(acpi_handle handle, bool first_pass,
|
||||
struct acpi_device **adev_p)
|
||||
{
|
||||
struct acpi_device *device = acpi_fetch_acpi_dev(handle);
|
||||
|
|
@ -2059,9 +2064,25 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, bool check_dep,
|
|||
if (acpi_device_should_be_hidden(handle))
|
||||
return AE_OK;
|
||||
|
||||
/* Bail out if there are dependencies. */
|
||||
if (acpi_scan_check_dep(handle, check_dep) > 0)
|
||||
return AE_CTRL_DEPTH;
|
||||
if (first_pass) {
|
||||
acpi_mipi_check_crs_csi2(handle);
|
||||
|
||||
/* Bail out if there are dependencies. */
|
||||
if (acpi_scan_check_dep(handle) > 0) {
|
||||
/*
|
||||
* The entire CSI-2 connection graph needs to be
|
||||
* extracted before any drivers or scan handlers
|
||||
* are bound to struct device objects, so scan
|
||||
* _CRS CSI-2 resource descriptors for all
|
||||
* devices below the current handle.
|
||||
*/
|
||||
acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
|
||||
ACPI_UINT32_MAX,
|
||||
acpi_scan_check_crs_csi2_cb,
|
||||
NULL, NULL, NULL);
|
||||
return AE_CTRL_DEPTH;
|
||||
}
|
||||
}
|
||||
|
||||
fallthrough;
|
||||
case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */
|
||||
|
|
@ -2084,10 +2105,10 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, bool check_dep,
|
|||
}
|
||||
|
||||
/*
|
||||
* If check_dep is true at this point, the device has no dependencies,
|
||||
* If first_pass is true at this point, the device has no dependencies,
|
||||
* or the creation of the device object would have been postponed above.
|
||||
*/
|
||||
acpi_add_single_object(&device, handle, type, !check_dep);
|
||||
acpi_add_single_object(&device, handle, type, !first_pass);
|
||||
if (!device)
|
||||
return AE_CTRL_DEPTH;
|
||||
|
||||
|
|
@ -2431,6 +2452,13 @@ static void acpi_scan_postponed_branch(acpi_handle handle)
|
|||
|
||||
acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
|
||||
acpi_bus_check_add_2, NULL, NULL, (void **)&adev);
|
||||
|
||||
/*
|
||||
* Populate the ACPI _CRS CSI-2 software nodes for the ACPI devices that
|
||||
* have been added above.
|
||||
*/
|
||||
acpi_mipi_init_crs_csi2_swnodes();
|
||||
|
||||
acpi_bus_attach(adev, NULL);
|
||||
}
|
||||
|
||||
|
|
@ -2499,12 +2527,22 @@ int acpi_bus_scan(acpi_handle handle)
|
|||
if (!device)
|
||||
return -ENODEV;
|
||||
|
||||
/*
|
||||
* Set up ACPI _CRS CSI-2 software nodes using information extracted
|
||||
* from the _CRS CSI-2 resource descriptors during the ACPI namespace
|
||||
* walk above and MIPI DisCo for Imaging device properties.
|
||||
*/
|
||||
acpi_mipi_scan_crs_csi2();
|
||||
acpi_mipi_init_crs_csi2_swnodes();
|
||||
|
||||
acpi_bus_attach(device, (void *)true);
|
||||
|
||||
/* Pass 2: Enumerate all of the remaining devices. */
|
||||
|
||||
acpi_scan_postponed();
|
||||
|
||||
acpi_mipi_crs_csi2_cleanup();
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(acpi_bus_scan);
|
||||
|
|
|
|||
|
|
@ -366,6 +366,98 @@ struct acpi_device_data {
|
|||
|
||||
struct acpi_gpio_mapping;
|
||||
|
||||
#define ACPI_DEVICE_SWNODE_ROOT 0
|
||||
|
||||
/*
|
||||
* The maximum expected number of CSI-2 data lanes.
|
||||
*
|
||||
* This number is not expected to ever have to be equal to or greater than the
|
||||
* number of bits in an unsigned long variable, but if it needs to be increased
|
||||
* above that limit, code will need to be adjusted accordingly.
|
||||
*/
|
||||
#define ACPI_DEVICE_CSI2_DATA_LANES 8
|
||||
|
||||
#define ACPI_DEVICE_SWNODE_PORT_NAME_LENGTH 8
|
||||
|
||||
enum acpi_device_swnode_dev_props {
|
||||
ACPI_DEVICE_SWNODE_DEV_ROTATION,
|
||||
ACPI_DEVICE_SWNODE_DEV_CLOCK_FREQUENCY,
|
||||
ACPI_DEVICE_SWNODE_DEV_LED_MAX_MICROAMP,
|
||||
ACPI_DEVICE_SWNODE_DEV_FLASH_MAX_MICROAMP,
|
||||
ACPI_DEVICE_SWNODE_DEV_FLASH_MAX_TIMEOUT_US,
|
||||
ACPI_DEVICE_SWNODE_DEV_NUM_OF,
|
||||
ACPI_DEVICE_SWNODE_DEV_NUM_ENTRIES
|
||||
};
|
||||
|
||||
enum acpi_device_swnode_port_props {
|
||||
ACPI_DEVICE_SWNODE_PORT_REG,
|
||||
ACPI_DEVICE_SWNODE_PORT_NUM_OF,
|
||||
ACPI_DEVICE_SWNODE_PORT_NUM_ENTRIES
|
||||
};
|
||||
|
||||
enum acpi_device_swnode_ep_props {
|
||||
ACPI_DEVICE_SWNODE_EP_REMOTE_EP,
|
||||
ACPI_DEVICE_SWNODE_EP_BUS_TYPE,
|
||||
ACPI_DEVICE_SWNODE_EP_REG,
|
||||
ACPI_DEVICE_SWNODE_EP_CLOCK_LANES,
|
||||
ACPI_DEVICE_SWNODE_EP_DATA_LANES,
|
||||
ACPI_DEVICE_SWNODE_EP_LANE_POLARITIES,
|
||||
/* TX only */
|
||||
ACPI_DEVICE_SWNODE_EP_LINK_FREQUENCIES,
|
||||
ACPI_DEVICE_SWNODE_EP_NUM_OF,
|
||||
ACPI_DEVICE_SWNODE_EP_NUM_ENTRIES
|
||||
};
|
||||
|
||||
/*
|
||||
* Each device has a root software node plus two times as many nodes as the
|
||||
* number of CSI-2 ports.
|
||||
*/
|
||||
#define ACPI_DEVICE_SWNODE_PORT(port) (2 * (port) + 1)
|
||||
#define ACPI_DEVICE_SWNODE_EP(endpoint) \
|
||||
(ACPI_DEVICE_SWNODE_PORT(endpoint) + 1)
|
||||
|
||||
/**
|
||||
* struct acpi_device_software_node_port - MIPI DisCo for Imaging CSI-2 port
|
||||
* @port_name: Port name.
|
||||
* @data_lanes: "data-lanes" property values.
|
||||
* @lane_polarities: "lane-polarities" property values.
|
||||
* @link_frequencies: "link_frequencies" property values.
|
||||
* @port_nr: Port number.
|
||||
* @crs_crs2_local: _CRS CSI2 record present (i.e. this is a transmitter one).
|
||||
* @port_props: Port properties.
|
||||
* @ep_props: Endpoint properties.
|
||||
* @remote_ep: Reference to the remote endpoint.
|
||||
*/
|
||||
struct acpi_device_software_node_port {
|
||||
char port_name[ACPI_DEVICE_SWNODE_PORT_NAME_LENGTH + 1];
|
||||
u32 data_lanes[ACPI_DEVICE_CSI2_DATA_LANES];
|
||||
u32 lane_polarities[ACPI_DEVICE_CSI2_DATA_LANES + 1 /* clock lane */];
|
||||
u64 link_frequencies[ACPI_DEVICE_CSI2_DATA_LANES];
|
||||
unsigned int port_nr;
|
||||
bool crs_csi2_local;
|
||||
|
||||
struct property_entry port_props[ACPI_DEVICE_SWNODE_PORT_NUM_ENTRIES];
|
||||
struct property_entry ep_props[ACPI_DEVICE_SWNODE_EP_NUM_ENTRIES];
|
||||
|
||||
struct software_node_ref_args remote_ep[1];
|
||||
};
|
||||
|
||||
/**
|
||||
* struct acpi_device_software_nodes - Software nodes for an ACPI device
|
||||
* @dev_props: Device properties.
|
||||
* @nodes: Software nodes for root as well as ports and endpoints.
|
||||
* @nodeprts: Array of software node pointers, for (un)registering them.
|
||||
* @ports: Information related to each port and endpoint within a port.
|
||||
* @num_ports: The number of ports.
|
||||
*/
|
||||
struct acpi_device_software_nodes {
|
||||
struct property_entry dev_props[ACPI_DEVICE_SWNODE_DEV_NUM_ENTRIES];
|
||||
struct software_node *nodes;
|
||||
const struct software_node **nodeptrs;
|
||||
struct acpi_device_software_node_port *ports;
|
||||
unsigned int num_ports;
|
||||
};
|
||||
|
||||
/* Device */
|
||||
struct acpi_device {
|
||||
u32 pld_crc;
|
||||
|
|
@ -384,6 +476,7 @@ struct acpi_device {
|
|||
struct acpi_device_data data;
|
||||
struct acpi_scan_handler *handler;
|
||||
struct acpi_hotplug_context *hp;
|
||||
struct acpi_device_software_nodes *swnodes;
|
||||
const struct acpi_gpio_mapping *driver_gpios;
|
||||
void *driver_data;
|
||||
struct device dev;
|
||||
|
|
|
|||
|
|
@ -489,6 +489,13 @@ struct software_node {
|
|||
const struct property_entry *properties;
|
||||
};
|
||||
|
||||
#define SOFTWARE_NODE(_name_, _properties_, _parent_) \
|
||||
(struct software_node) { \
|
||||
.name = _name_, \
|
||||
.properties = _properties_, \
|
||||
.parent = _parent_, \
|
||||
}
|
||||
|
||||
bool is_software_node(const struct fwnode_handle *fwnode);
|
||||
const struct software_node *
|
||||
to_software_node(const struct fwnode_handle *fwnode);
|
||||
|
|
|
|||
Loading…
Reference in a new issue