/tools/perf/scripts/python/bin/

diff --git a/include/linux/8250_pci.h b/include/linux/8250_pci.h
index b24ff086a662..9c777d2c98f5 100644
--- a/include/linux/8250_pci.h
+++ b/include/linux/8250_pci.h

diff --git a/include/linux/a.out.h b/include/linux/a.out.h
deleted file mode 100644
index ee884168989f..000000000000
--- a/include/linux/a.out.h
+++ /dev/null

diff --git a/include/linux/acct.h b/include/linux/acct.h
index dccc2d4fe7de..2718c4854815 100644
--- a/include/linux/acct.h
+++ b/include/linux/acct.h

extern void acct_collect(long exitcode, int group_dead);

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 502af53ec012..fbf0c3a65f59 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h

- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

- * 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

- * 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. See the

- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <linux/ioport.h> /* for struct resource */

+#define EXPORT_SYMBOL_ACPI_LIB(x) EXPORT_SYMBOL_NS_GPL(x, "ACPI")

static inline acpi_handle acpi_device_handle(struct acpi_device *adev)

@@ -56,6 +59,8 @@ static inline acpi_handle acpi_device_handle(struct acpi_device *adev)

#define ACPI_COMPANION_SET(dev, adev) set_primary_fwnode(dev, (adev) ? \

#define ACPI_HANDLE(dev) acpi_device_handle(ACPI_COMPANION(dev))

static inline struct fwnode_handle *acpi_alloc_fwnode_static(void)

@@ -65,7 +70,7 @@ static inline struct fwnode_handle *acpi_alloc_fwnode_static(void)

@@ -78,19 +83,6 @@ static inline void acpi_free_fwnode_static(struct fwnode_handle *fwnode)

- * ACPI_DEVICE_CLASS - macro used to describe an ACPI device with

- * @_cls : the class, subclass, prog-if triple for this device

- * This macro is used to create a struct acpi_device_id that matches a

- * specific PCI class. The .id and .driver_data fields will be left

-#define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (_cls), .cls_msk = (_msk),

static inline bool has_acpi_companion(struct device *dev)

@@ -99,7 +91,7 @@ static inline bool has_acpi_companion(struct device *dev)

static inline void acpi_preset_companion(struct device *dev,

- ACPI_COMPANION_SET(dev, acpi_find_child_device(parent, addr, NULL));

+ ACPI_COMPANION_SET(dev, acpi_find_child_device(parent, addr, false));

static inline const char *acpi_dev_name(struct acpi_device *adev)

typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table);

-typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *header,

@@ -218,39 +208,49 @@ static inline int acpi_debugger_notify_command_complete(void)

(!entry) || (unsigned long)entry + sizeof(*entry) > end || \

((struct acpi_subtable_header *)entry)->length < sizeof(*entry))

void __iomem *__acpi_map_table(unsigned long phys, unsigned long size);

void __acpi_unmap_table(void __iomem *map, unsigned long size);

+static inline struct acpi_table_header *acpi_get_table_pointer(char *signature, u32 instance)

+ int status = acpi_get_table(signature, instance, &table);

+DEFINE_FREE(acpi_put_table, struct acpi_table_header *, if (!IS_ERR_OR_NULL(_T)) acpi_put_table(_T))

int acpi_table_parse(char *id, acpi_tbl_table_handler handler);

-int __init acpi_table_parse_entries(char *id, unsigned long table_size,

-int __init acpi_table_parse_entries_array(char *id, unsigned long table_size,

+int __init_or_acpilib acpi_table_parse_entries(char *id,

+ acpi_tbl_entry_handler handler, unsigned int max_entries);

+int __init_or_acpilib acpi_table_parse_entries_array(char *id,

+ unsigned long table_size, struct acpi_subtable_proc *proc,

+ acpi_tbl_entry_handler_arg handler_arg, void *arg);

int acpi_parse_mcfg (struct acpi_table_header *header);

void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);

-/* the following numa functions are architecture-dependent */

-void acpi_numa_slit_init (struct acpi_table_slit *slit);

+#if defined(CONFIG_X86) || defined(CONFIG_LOONGARCH)

void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);

@@ -259,6 +259,12 @@ acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) { }

void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);

+#if defined(CONFIG_ARM64) || defined(CONFIG_LOONGARCH)

+static inline void acpi_arch_dma_setup(struct device *dev) { }

void acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa);

acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa) { }

-int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);

+void acpi_numa_rintc_affinity_init(struct acpi_srat_rintc_affinity *pa);

+static inline void acpi_numa_rintc_affinity_init(struct acpi_srat_rintc_affinity *pa) { }

@@ -283,8 +293,26 @@ static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id)

+int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu,

+static inline bool acpi_processor_claim_cst_control(void) { return false; }

+static inline int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu,

/* Arch dependent functions for cpu hotplug support */

@@ -293,6 +321,8 @@ int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id,

int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);

@@ -312,19 +342,31 @@ static inline bool acpi_sci_irq_valid(void)

int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);

int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);

+typedef struct fwnode_handle *(*acpi_gsi_domain_disp_fn)(u32);

void acpi_set_irq_model(enum acpi_irq_model_id model,

+acpi_gsi_domain_disp_fn acpi_get_gsi_dispatcher(void);

+struct irq_domain *acpi_irq_create_hierarchy(unsigned int flags,

extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);

-#define acpi_get_override_irq(gsi, trigger, polarity) (-1)

+static inline int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity)

* This function undoes the effect of one call to acpi_register_gsi().

@@ -335,10 +377,18 @@ void acpi_unregister_gsi (u32 gsi);

+struct acpi_prt_entry *acpi_pci_irq_lookup(struct pci_dev *dev, int pin);

void acpi_penalize_sci_irq(int irq, int trigger, int polarity);

+static inline void acpi_penalize_sci_irq(int irq, int trigger,

@@ -352,7 +402,9 @@ extern bool acpi_is_pnp_device(struct acpi_device *);

#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)

-typedef void (*wmi_notify_handler) (u32 value, void *context);

+typedef void (*wmi_notify_handler) (union acpi_object *data, void *context);

extern acpi_status wmi_evaluate_method(const char *guid, u8 instance,

@@ -365,8 +417,8 @@ extern acpi_status wmi_set_block(const char *guid, u8 instance,

extern acpi_status wmi_install_notify_handler(const char *guid,

extern acpi_status wmi_remove_notify_handler(const char *guid);

-extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out);

+extern char *wmi_get_acpi_device_uid(const char *guid);

@@ -385,15 +437,57 @@ extern bool wmi_has_guid(const char *guid);

extern long acpi_is_video_device(acpi_handle handle);

+int thermal_acpi_active_trip_temp(struct acpi_device *adev, int id, int *ret_temp);

+int thermal_acpi_passive_trip_temp(struct acpi_device *adev, int *ret_temp);

+int thermal_acpi_hot_trip_temp(struct acpi_device *adev, int *ret_temp);

+int thermal_acpi_critical_trip_temp(struct acpi_device *adev, int *ret_temp);

+int acpi_get_genport_coordinates(u32 uid, struct access_coordinate *coord);

+static inline int acpi_get_genport_coordinates(u32 uid,

+ * pxm_to_online_node - Map proximity ID to online node

+ * This is similar to pxm_to_node(), but always returns an online

+ * node. When the mapped node from a given proximity ID is offline, it

+ * looks up the node distance table and returns the nearest online node.

+ * ACPI device drivers, which are called after the NUMA initialization has

+ * completed in the kernel, can call this interface to obtain their device

+ * NUMA topology from ACPI tables. Such drivers do not have to deal with

+ * offline nodes. A node may be offline when SRAT memory entry does not exist,

-static inline int acpi_map_pxm_to_online_node(int pxm)

@@ -402,8 +496,6 @@ static inline int acpi_get_node(acpi_handle handle)

-extern int acpi_paddr_to_node(u64 start_addr, u64 size);

@@ -414,7 +506,7 @@ bool acpi_dev_resource_address_space(struct acpi_resource *ares,

bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,

-unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);

+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable, u8 wake_capable);

unsigned int acpi_dev_get_irq_type(int triggering, int polarity);

bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,

@@ -425,6 +517,7 @@ int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,

int acpi_dev_get_dma_resources(struct acpi_device *adev,

+int acpi_dev_get_memory_resources(struct acpi_device *adev, struct list_head *list);

int acpi_dev_filter_resource_type(struct acpi_resource *ares,

@@ -444,15 +537,21 @@ int acpi_check_region(resource_size_t start, resource_size_t n,

+ int wake_irq, bool (*wakeup)(void *context), void *context);

acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);

-/* Indexes into _OSC Capabilities Buffer (DWORDs 2 & 3 are device-specific) */

+/* Number of _OSC capability DWORDS depends on bridge type */

+/* Indexes into _OSC Capabilities Buffer (DWORDs 2 to 5 are device-specific) */

/* _OSC Capabilities DWORD 1: Query/Control and Error Returns (generic) */

@@ -484,10 +589,31 @@ acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);

+#define OSC_SB_FAST_THERMAL_SAMPLING_SUPPORT 0x00000200

+#define OSC_SB_OVER_16_PSTATES_SUPPORT 0x00000400

#define OSC_SB_CPC_DIVERSE_HIGH_SUPPORT 0x00001000

+#define OSC_SB_IRQ_RESOURCE_SOURCE_SUPPORT 0x00002000

+#define OSC_SB_GENERIC_INITIATOR_SUPPORT 0x00020000

+#define OSC_SB_BATTERY_CHARGE_LIMITING_SUPPORT 0x00080000

+extern bool osc_sb_native_usb4_support_confirmed;

+extern bool osc_cpc_flexible_adr_space_confirmed;

/* PCI Host Bridge _OSC: Capabilities DWORD 2: Support Field */

@@ -495,7 +621,8 @@ extern bool osc_pc_lpi_support_confirmed;

/* PCI Host Bridge _OSC: Capabilities DWORD 3: Control Field */

#define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL 0x00000001

@@ -503,7 +630,31 @@ extern bool osc_pc_lpi_support_confirmed;

#define OSC_PCI_EXPRESS_CAPABILITY_CONTROL 0x00000010

+/* CXL _OSC: Capabilities DWORD 4: Support Field */

+#define OSC_CXL_1_1_PORT_REG_ACCESS_SUPPORT 0x00000001

+#define OSC_CXL_2_0_PORT_DEV_REG_ACCESS_SUPPORT 0x00000002

+#define OSC_CXL_PROTOCOL_ERR_REPORTING_SUPPORT 0x00000004

+/* CXL _OSC: Capabilities DWORD 5: Control Field */

+#define OSC_CXL_ERROR_REPORTING_CONTROL 0x00000001

+static inline u32 acpi_osc_ctx_get_pci_control(struct acpi_osc_context *context)

+static inline u32 acpi_osc_ctx_get_cxl_control(struct acpi_osc_context *context)

#define ACPI_GSB_ACCESS_ATTRIB_SEND_RCV 0x00000004

@@ -516,9 +667,6 @@ extern bool osc_pc_lpi_support_confirmed;

#define ACPI_GSB_ACCESS_ATTRIB_RAW_BYTES 0x0000000E

#define ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS 0x0000000F

-extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,

/* Enable _OST when all relevant hotplug operations are enabled */

@@ -581,17 +729,20 @@ extern int acpi_nvs_register(__u64 start, __u64 size);

extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),

+const struct acpi_device_id *acpi_match_acpi_device(const struct acpi_device_id *ids,

const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,

+const void *acpi_device_get_match_data(const struct device *dev);

extern bool acpi_driver_match_device(struct device *dev,

-int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);

+int acpi_device_uevent_modalias(const struct device *, struct kobj_uevent_env *);

int acpi_device_modalias(struct device *, char *, int);

-void acpi_walk_dep_device_list(acpi_handle handle);

struct platform_device *acpi_create_platform_device(struct acpi_device *,

static inline void acpi_device_set_enumerated(struct acpi_device *adev)

@@ -616,7 +767,27 @@ int acpi_reconfig_notifier_unregister(struct notifier_block *nb);

int acpi_gtdt_init(struct acpi_table_header *table, int *platform_timer_count);

-int acpi_arch_timer_mem_init(struct arch_timer_mem *timer_mem, int *timer_count);

+static __always_inline void acpi_arch_set_root_pointer(u64 addr)

+static __always_inline u64 acpi_arch_get_root_pointer(void)

+int acpi_get_local_u64_address(acpi_handle handle, u64 *addr);

+int acpi_get_local_address(acpi_handle handle, u32 *addr);

+const char *acpi_get_subsystem_id(acpi_handle handle);

@@ -626,7 +797,11 @@ int acpi_arch_timer_mem_init(struct arch_timer_mem *timer_mem, int *timer_count)

#define ACPI_COMPANION_SET(dev, adev) do { } while (0)

-#define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (0), .cls_msk = (0),

+#define acpi_dev_uid_match(adev, uid2) (adev && false)

+#define acpi_dev_hid_uid_match(adev, hid2, uid2) (adev && false)

@@ -640,32 +815,52 @@ static inline bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)

-static inline bool is_acpi_node(struct fwnode_handle *fwnode)

+static inline int acpi_dev_uid_to_integer(struct acpi_device *adev, u64 *integer)

+acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv)

+static inline void acpi_dev_put(struct acpi_device *adev) {}

+static inline bool is_acpi_node(const struct fwnode_handle *fwnode)

-static inline bool is_acpi_device_node(struct fwnode_handle *fwnode)

+static inline bool is_acpi_device_node(const struct fwnode_handle *fwnode)

-static inline struct acpi_device *to_acpi_device_node(struct fwnode_handle *fwnode)

+static inline struct acpi_device *to_acpi_device_node(const struct fwnode_handle *fwnode)

-static inline bool is_acpi_data_node(struct fwnode_handle *fwnode)

+static inline bool is_acpi_data_node(const struct fwnode_handle *fwnode)

-static inline struct acpi_data_node *to_acpi_data_node(struct fwnode_handle *fwnode)

+static inline struct acpi_data_node *to_acpi_data_node(const struct fwnode_handle *fwnode)

-static inline bool acpi_data_node_match(struct fwnode_handle *fwnode,

+static inline bool acpi_data_node_match(const struct fwnode_handle *fwnode,

@@ -676,6 +871,11 @@ static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)

+static inline acpi_handle acpi_device_handle(struct acpi_device *adev)

static inline bool has_acpi_companion(struct device *dev)

@@ -708,9 +908,12 @@ static inline int acpi_boot_init(void)

@@ -749,27 +952,53 @@ static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),

+static inline const struct acpi_device_id *acpi_match_acpi_device(

+ const struct acpi_device_id *ids, const struct acpi_device *adev)

static inline const struct acpi_device_id *acpi_match_device(

const struct acpi_device_id *ids, const struct device *dev)

+static inline const void *acpi_device_get_match_data(const struct device *dev)

static inline bool acpi_driver_match_device(struct device *dev,

+static inline bool acpi_check_dsm(acpi_handle handle, const guid_t *guid,

static inline union acpi_object *acpi_evaluate_dsm(acpi_handle handle,

-static inline int acpi_device_uevent_modalias(struct device *dev,

+static inline union acpi_object *acpi_evaluate_dsm_typed(acpi_handle handle,

+static inline int acpi_device_uevent_modalias(const struct device *dev,

@@ -781,7 +1010,14 @@ static inline int acpi_device_modalias(struct device *dev,

-static inline bool acpi_dma_supported(struct acpi_device *adev)

+acpi_create_platform_device(struct acpi_device *adev,

+static inline bool acpi_dma_supported(const struct acpi_device *adev)

@@ -791,8 +1027,7 @@ static inline enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)

-static inline int acpi_dma_get_range(struct device *dev, u64 *dma_addr,

+static inline int acpi_dma_get_range(struct device *dev, const struct bus_dma_region **map)

@@ -803,7 +1038,12 @@ static inline int acpi_dma_configure(struct device *dev,

-static inline void acpi_dma_deconfigure(struct device *dev) { }

+static inline int acpi_dma_configure_id(struct device *dev,

@@ -830,8 +1070,66 @@ static inline struct acpi_device *acpi_resource_consumer(struct resource *res)

+static inline int acpi_get_local_address(acpi_handle handle, u32 *addr)

+static inline const char *acpi_get_subsystem_id(acpi_handle handle)

+static inline int acpi_register_wakeup_handler(int wake_irq,

+static inline void acpi_unregister_wakeup_handler(

+ bool (*wakeup)(void *context), void *context) { }

+static inline u32 acpi_osc_ctx_get_pci_control(struct acpi_osc_context *context)

+static inline u32 acpi_osc_ctx_get_cxl_control(struct acpi_osc_context *context)

+static inline bool acpi_sleep_state_supported(u8 sleep_state)

+static inline acpi_handle acpi_get_processor_handle(int cpu)

+int hmat_get_extended_linear_cache_size(struct resource *backing_res, int nid,

+static inline int hmat_get_extended_linear_cache_size(struct resource *backing_res,

@@ -850,76 +1148,100 @@ void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,

acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state,

-void arch_reserve_mem_area(acpi_physical_address addr, size_t size);

-static inline void arch_reserve_mem_area(acpi_physical_address addr,

+#if defined(CONFIG_SUSPEND) && defined(CONFIG_X86)

+int acpi_register_lps0_dev(struct acpi_s2idle_dev_ops *arg);

+void acpi_unregister_lps0_dev(struct acpi_s2idle_dev_ops *arg);

+static inline int acpi_register_lps0_dev(struct acpi_s2idle_dev_ops *arg)

+static inline void acpi_unregister_lps0_dev(struct acpi_s2idle_dev_ops *arg)

+void arch_reserve_mem_area(acpi_physical_address addr, size_t size);

#define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)

-int acpi_dev_runtime_suspend(struct device *dev);

+int acpi_dev_suspend(struct device *dev, bool wakeup);

int acpi_subsys_runtime_suspend(struct device *dev);

int acpi_subsys_runtime_resume(struct device *dev);

-struct acpi_device *acpi_dev_pm_get_node(struct device *dev);

int acpi_dev_pm_attach(struct device *dev, bool power_on);

-static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; }

-static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; }

static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }

static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }

-static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev)

+static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)

-static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)

+static inline bool acpi_storage_d3(struct device *dev)

+static inline bool acpi_dev_state_d0(struct device *dev)

#if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)

-int acpi_subsys_resume_early(struct device *dev);

+int acpi_subsys_suspend_noirq(struct device *dev);

+int acpi_subsys_restore_early(struct device *dev);

-static inline int acpi_dev_suspend_late(struct device *dev) { return 0; }

-static inline int acpi_dev_resume_early(struct device *dev) { return 0; }

static inline int acpi_subsys_prepare(struct device *dev) { return 0; }

static inline void acpi_subsys_complete(struct device *dev) {}

static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; }

-static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }

+static inline int acpi_subsys_suspend_noirq(struct device *dev) { return 0; }

static inline int acpi_subsys_suspend(struct device *dev) { return 0; }

static inline int acpi_subsys_freeze(struct device *dev) { return 0; }

+static inline int acpi_subsys_poweroff(struct device *dev) { return 0; }

+static inline int acpi_subsys_restore_early(struct device *dev) { return 0; }

+#if defined(CONFIG_ACPI_EC) && defined(CONFIG_PM_SLEEP)

+static inline void acpi_ec_mark_gpe_for_wake(void) {}

+static inline void acpi_ec_set_gpe_wake_mask(u8 action) {}

void acpi_handle_printk(const char *level, acpi_handle handle,

+void acpi_evaluation_failure_warn(acpi_handle handle, const char *name,

acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {}

+static inline void acpi_evaluation_failure_warn(acpi_handle handle,

#if defined(CONFIG_ACPI) && defined(CONFIG_DYNAMIC_DEBUG)

void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...);

-#define __acpi_handle_debug(descriptor, handle, fmt, ...) \

- acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__);

@@ -949,12 +1271,8 @@ void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const c

- DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \

- if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \

- __acpi_handle_debug(&descriptor, handle, pr_fmt(fmt), \

#if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB)

-int acpi_dev_add_driver_gpios(struct acpi_device *adev,

-static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev)

-int devm_acpi_dev_add_driver_gpios(struct device *dev,

-void devm_acpi_dev_remove_driver_gpios(struct device *dev);

bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,

-int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);

+bool acpi_gpio_get_io_resource(struct acpi_resource *ares,

+int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *con_id, int index,

-static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,

+static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,

+static inline bool acpi_gpio_get_io_resource(struct acpi_resource *ares,

+static inline int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *con_id,

-static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}

-static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,

+static inline int acpi_dev_gpio_irq_wake_get(struct acpi_device *adev, int index,

+ return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, wake_capable);

-static inline void devm_acpi_dev_remove_driver_gpios(struct device *dev) {}

-static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,

+static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *con_id,

+ return acpi_dev_gpio_irq_wake_get_by(adev, con_id, index, NULL);

static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)

+ return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, NULL);

int acpi_dev_get_property(const struct acpi_device *adev, const char *name,

acpi_object_type type, const union acpi_object **obj);

int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,

static inline int acpi_node_get_property_reference(

return __acpi_node_get_property_reference(fwnode, name, index,

+static inline bool acpi_dev_has_props(const struct acpi_device *adev)

+acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,

int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname,

-int acpi_dev_prop_read_single(struct acpi_device *adev,

- const char *propname, enum dev_prop_type proptype,

-int acpi_node_prop_read(const struct fwnode_handle *fwnode,

- const char *propname, enum dev_prop_type proptype,

-int acpi_dev_prop_read(const struct acpi_device *adev, const char *propname,

- enum dev_prop_type proptype, void *val, size_t nval);

-struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,

-struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode);

-acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,

-int acpi_graph_get_remote_endpoint(const struct fwnode_handle *fwnode,

typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,

-#define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn) \

+void arch_sort_irqchip_probe(struct acpi_probe_entry *ap_head, int nr);

+#define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, \

static const struct acpi_probe_entry __acpi_probe_##name \

- __used __section(__##table##_acpi_probe_table) \

+ __used __section("__" #table "_acpi_probe_table") = { \

+#define ACPI_DECLARE_SUBTABLE_PROBE_ENTRY(table, name, table_id, \

+ static const struct acpi_probe_entry __acpi_probe_##name \

+ __used __section("__" #table "_acpi_probe_table") = { \

#define ACPI_PROBE_TABLE(name) __##name##_acpi_probe_table

#define ACPI_PROBE_TABLE_END(name) __##name##_acpi_probe_table_end

@@ -1133,7 +1433,7 @@ static inline int acpi_dev_get_property(struct acpi_device *adev,

__acpi_node_get_property_reference(const struct fwnode_handle *fwnode,

@@ -1141,7 +1441,7 @@ __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,

acpi_node_get_property_reference(const struct fwnode_handle *fwnode,

@@ -1153,50 +1453,6 @@ static inline int acpi_node_prop_get(const struct fwnode_handle *fwnode,

-static inline int acpi_dev_prop_get(const struct acpi_device *adev,

-static inline int acpi_dev_prop_read_single(const struct acpi_device *adev,

-static inline int acpi_node_prop_read(const struct fwnode_handle *fwnode,

-static inline int acpi_dev_prop_read(const struct acpi_device *adev,

-acpi_get_next_subnode(const struct fwnode_handle *fwnode,

-acpi_node_get_parent(const struct fwnode_handle *fwnode)

acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,

@@ -1239,19 +1495,130 @@ static inline bool acpi_has_watchdog(void) { return false; }

+int acpi_parse_spcr(bool enable_earlycon, bool enable_console);

-static inline int parse_spcr(bool earlycon) { return 0; }

+static inline int acpi_parse_spcr(bool enable_earlycon, bool enable_console)

int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res);

+const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,

int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)

+static inline const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,

+int lpit_read_residency_count_address(u64 *address);

+static inline int lpit_read_residency_count_address(u64 *address)

+static inline unsigned int arch_get_idle_state_flags(u32 arch_flags)

+int find_acpi_cpu_topology(unsigned int cpu, int level);

+int find_acpi_cpu_topology_cluster(unsigned int cpu);

+int find_acpi_cpu_topology_package(unsigned int cpu);

+int find_acpi_cpu_topology_hetero_id(unsigned int cpu);

+void acpi_pptt_get_cpus_from_container(u32 acpi_cpu_id, cpumask_t *cpus);

+int acpi_pptt_get_cpumask_from_cache_id(u32 cache_id, cpumask_t *cpus);

+static inline int acpi_pptt_cpu_is_thread(unsigned int cpu)

+static inline int find_acpi_cpu_topology(unsigned int cpu, int level)

+static inline int find_acpi_cpu_topology_cluster(unsigned int cpu)

+static inline int find_acpi_cpu_topology_package(unsigned int cpu)

+static inline int find_acpi_cpu_topology_hetero_id(unsigned int cpu)

+static inline void acpi_pptt_get_cpus_from_container(u32 acpi_cpu_id,

+static inline int find_acpi_cache_level_from_id(u32 cache_id)

+static inline int acpi_pptt_get_cpumask_from_cache_id(u32 cache_id,

+extern int acpi_ffh_address_space_arch_setup(void *handler_ctxt,

+extern int acpi_ffh_address_space_arch_handler(acpi_integer *value,

+extern void acpi_device_notify(struct device *dev);

+extern void acpi_device_notify_remove(struct device *dev);

+static inline void acpi_device_notify(struct device *dev) { }

+static inline void acpi_device_notify_remove(struct device *dev) { }

+static inline void acpi_use_parent_companion(struct device *dev)

+ ACPI_COMPANION_SET(dev, ACPI_COMPANION(dev->parent));

+static inline bool acpi_node_backed_by_real_pxm(int nid)

diff --git a/include/linux/acpi_amd_wbrf.h b/include/linux/acpi_amd_wbrf.h
new file mode 100644
index 000000000000..898f31d536d4
--- /dev/null
+++ b/include/linux/acpi_amd_wbrf.h

+ * Wifi Band Exclusion Interface (AMD ACPI Implementation)

+/* The maximum number of frequency band ranges */

+ * struct freq_band_range - Wifi frequency band range definition

+ * @num_of_ranges: total number of band ranges in this struct

+ struct freq_band_range band_list[MAX_NUM_OF_WBRF_RANGES];

+ * enum wbrf_notifier_actions - wbrf notifier actions index

+ * @WBRF_CHANGED: there was some frequency band updates. The consumers

+ * should retrieve the latest active frequency bands.

+bool acpi_amd_wbrf_supported_producer(struct device *dev);

+int acpi_amd_wbrf_add_remove(struct device *dev, uint8_t action, struct wbrf_ranges_in_out *in);

+bool acpi_amd_wbrf_supported_consumer(struct device *dev);

+int amd_wbrf_retrieve_freq_band(struct device *dev, struct wbrf_ranges_in_out *out);

+int amd_wbrf_register_notifier(struct notifier_block *nb);

+int amd_wbrf_unregister_notifier(struct notifier_block *nb);

+bool acpi_amd_wbrf_supported_consumer(struct device *dev)

+int acpi_amd_wbrf_add_remove(struct device *dev, uint8_t action, struct wbrf_ranges_in_out *in)

+bool acpi_amd_wbrf_supported_producer(struct device *dev)

+int amd_wbrf_retrieve_freq_band(struct device *dev, struct wbrf_ranges_in_out *out)

+int amd_wbrf_register_notifier(struct notifier_block *nb)

+int amd_wbrf_unregister_notifier(struct notifier_block *nb)

diff --git a/include/linux/acpi_dma.h b/include/linux/acpi_dma.h
index 329436d38e66..e748b2877602 100644
--- a/include/linux/acpi_dma.h
+++ b/include/linux/acpi_dma.h

* Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License version 2 as

* struct acpi_dma_spec - slave device DMA resources

@@ -68,7 +66,6 @@ int devm_acpi_dma_controller_register(struct device *dev,

-void devm_acpi_dma_controller_free(struct device *dev);

struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev,

@@ -97,9 +94,6 @@ static inline int devm_acpi_dma_controller_register(struct device *dev,

-static inline void devm_acpi_dma_controller_free(struct device *dev)

static inline struct dma_chan *acpi_dma_request_slave_chan_by_index(

diff --git a/include/linux/acpi_iort.h b/include/linux/acpi_iort.h
index 8d3f0bf80379..d4ed5622cf2b 100644
--- a/include/linux/acpi_iort.h
+++ b/include/linux/acpi_iort.h

- * This program is free software; you can redistribute it and/or modify it

- * under the terms and conditions of the GNU General Public License,

- * version 2, as published by the Free Software Foundation.

- * This program is distributed in the hope it will be useful, but WITHOUT

- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

- * 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., 59 Temple

#define IORT_IRQ_TRIGGER_MASK(irq) ((irq >> 32) & 0xffffffffULL)

-int iort_register_domain_token(int trans_id, struct fwnode_handle *fw_node);

+ * PMCG model identifiers for use in smmu pmu driver. Please note

+ * that this is purely for the use of software and has nothing to

+#define IORT_SMMU_V3_PMCG_GENERIC 0x00000000 /* Generic SMMUv3 PMCG */

+#define IORT_SMMU_V3_PMCG_HISI_HIP08 0x00000001 /* HiSilicon HIP08 PMCG */

+#define IORT_SMMU_V3_PMCG_HISI_HIP09 0x00000002 /* HiSilicon HIP09 PMCG */

+int iort_register_domain_token(int trans_id, phys_addr_t base,

struct fwnode_handle *iort_find_domain_token(int trans_id);

+int iort_pmsi_get_dev_id(struct device *dev, u32 *dev_id);

-u32 iort_msi_map_rid(struct device *dev, u32 req_id);

-struct irq_domain *iort_get_device_domain(struct device *dev, u32 req_id);

+struct irq_domain *iort_get_device_domain(struct device *dev, u32 id,

void acpi_configure_pmsi_domain(struct device *dev);

-int iort_pmsi_get_dev_id(struct device *dev, u32 *dev_id);

+void iort_get_rmr_sids(struct fwnode_handle *iommu_fwnode,

+void iort_put_rmr_sids(struct fwnode_handle *iommu_fwnode,

-void iort_dma_setup(struct device *dev, u64 *dma_addr, u64 *size);

-const struct iommu_ops *iort_iommu_configure(struct device *dev);

+int iort_dma_get_ranges(struct device *dev, u64 *limit);

+int iort_iommu_configure_id(struct device *dev, const u32 *id_in);

+void iort_iommu_get_resv_regions(struct device *dev, struct list_head *head);

+phys_addr_t acpi_iort_dma_get_max_cpu_address(void);

-static inline u32 iort_msi_map_rid(struct device *dev, u32 req_id)

-static inline struct irq_domain *iort_get_device_domain(struct device *dev,

+static inline u32 iort_msi_map_id(struct device *dev, u32 id)

+static inline struct irq_domain *iort_get_device_domain(

+ struct device *dev, u32 id, enum irq_domain_bus_token bus_token)

static inline void acpi_configure_pmsi_domain(struct device *dev) { }

+void iort_get_rmr_sids(struct fwnode_handle *iommu_fwnode, struct list_head *head) { }

+void iort_put_rmr_sids(struct fwnode_handle *iommu_fwnode, struct list_head *head) { }

-static inline void iort_dma_setup(struct device *dev, u64 *dma_addr,

+static inline int iort_dma_get_ranges(struct device *dev, u64 *limit)

+static inline int iort_iommu_configure_id(struct device *dev, const u32 *id_in)

-const struct iommu_ops *iort_iommu_configure(struct device *dev)

+void iort_iommu_get_resv_regions(struct device *dev, struct list_head *head)

+static inline phys_addr_t acpi_iort_dma_get_max_cpu_address(void)

diff --git a/include/linux/acpi_mdio.h b/include/linux/acpi_mdio.h
new file mode 100644
index 000000000000..8e2eefa9fbc0
--- /dev/null
+++ b/include/linux/acpi_mdio.h

+int __acpi_mdiobus_register(struct mii_bus *mdio, struct fwnode_handle *fwnode,

+acpi_mdiobus_register(struct mii_bus *mdio, struct fwnode_handle *handle)

+ return __acpi_mdiobus_register(mdio, handle, THIS_MODULE);

+acpi_mdiobus_register(struct mii_bus *mdio, struct fwnode_handle *fwnode)

+ * Fall back to mdiobus_register() function to register a bus.

+ * This way, we don't have to keep compat bits around in drivers.

diff --git a/include/linux/acpi_pmtmr.h b/include/linux/acpi_pmtmr.h
index 1d0ef1ae8036..0ded9220d379 100644
--- a/include/linux/acpi_pmtmr.h
+++ b/include/linux/acpi_pmtmr.h

@@ -25,6 +26,19 @@ static inline u32 acpi_pm_read_early(void)

+ * Register callback for suspend and resume event

+void acpi_pmtmr_register_suspend_resume_callback(void (*cb)(void *data, bool suspend), void *data);

+ * Remove registered callback for suspend and resume event

+void acpi_pmtmr_unregister_suspend_resume_callback(void);

diff --git a/include/linux/acpi_rimt.h b/include/linux/acpi_rimt.h
new file mode 100644
index 000000000000..fad3adc4d899
--- /dev/null
+++ b/include/linux/acpi_rimt.h

+static inline int rimt_iommu_register(struct device *dev)

+#if defined(CONFIG_IOMMU_API) && defined(CONFIG_ACPI_RIMT)

+int rimt_iommu_configure_id(struct device *dev, const u32 *id_in);

+static inline int rimt_iommu_configure_id(struct device *dev, const u32 *id_in)

diff --git a/include/linux/acpi_viot.h b/include/linux/acpi_viot.h
new file mode 100644
index 000000000000..a5a122431563
--- /dev/null
+++ b/include/linux/acpi_viot.h

+static inline int viot_iommu_configure(struct device *dev)

diff --git a/include/linux/adb.h b/include/linux/adb.h
index cde41300c7ad..f6306fc86015 100644
--- a/include/linux/adb.h
+++ b/include/linux/adb.h

* Definitions for ADB (Apple Desktop Bus) support.

diff --git a/include/linux/adfs_fs.h b/include/linux/adfs_fs.h
index 0d991071a9d4..4836e382ad52 100644
--- a/include/linux/adfs_fs.h
+++ b/include/linux/adfs_fs.h

diff --git a/include/linux/adi-axi-common.h b/include/linux/adi-axi-common.h
new file mode 100644
index 000000000000..37962ba530df
--- /dev/null
+++ b/include/linux/adi-axi-common.h

+ * Analog Devices AXI common registers & definitions

+ * https://wiki.analog.com/resources/fpga/docs/axi_ip

+ * https://wiki.analog.com/resources/fpga/docs/hdl/regmap

+#define ADI_AXI_PCORE_VER_MAJOR(version) (((version) >> 16) & 0xff)

+#define ADI_AXI_PCORE_VER_MINOR(version) (((version) >> 8) & 0xff)

+#define ADI_AXI_PCORE_VER_PATCH(version) ((version) & 0xff)

+ * adi_axi_pcore_ver_gteq() - check if a version is satisfied

+ * @version: the full version read from the hardware

+ * ADI AXI IP Cores use semantic versioning, so this can be used to check for

+ * Return: true if the version is greater than or equal to the specified

+static inline bool adi_axi_pcore_ver_gteq(u32 version, u32 major, u32 minor)

+ return ADI_AXI_PCORE_VER_MAJOR(version) > (major) ||

+#define ADI_AXI_INFO_FPGA_TECH(info) (((info) >> 24) & 0xff)

+#define ADI_AXI_INFO_FPGA_FAMILY(info) (((info) >> 16) & 0xff)

+#define ADI_AXI_INFO_FPGA_SPEED_GRADE(info) (((info) >> 8) & 0xff)

diff --git a/include/linux/adreno-smmu-priv.h b/include/linux/adreno-smmu-priv.h
new file mode 100644
index 000000000000..d83c9175828f
--- /dev/null
+++ b/include/linux/adreno-smmu-priv.h

+ * struct adreno_smmu_fault_info - container for key fault information

+ * @ttbr0: The current TTBR0 pagetable from ARM_SMMU_CB_TTBR0

+ * @contextidr: The value of ARM_SMMU_CB_CONTEXTIDR

+ * @fsynr0: The value of FSYNR0 from ARM_SMMU_CB_FSYNR0

+ * @fsynr1: The value of FSYNR1 from ARM_SMMU_CB_FSYNR0

+ * @cbfrsynra: The value of CBFRSYNRA from ARM_SMMU_GR1_CBFRSYNRA(idx)

+ * This struct passes back key page fault information to the GPU driver

+ * The GPU driver can use this information to print informative

+ * log messages and provide deeper GPU specific insight into the fault.

+ * struct adreno_smmu_priv - private interface between adreno-smmu and GPU

+ * @cookie: An opque token provided by adreno-smmu and passed

+ * @get_ttbr1_cfg: Get the TTBR1 config for the GPUs context-bank

+ * @set_ttbr0_cfg: Set the TTBR0 config for the GPUs context bank. A

+ * NULL config disables TTBR0 translation, otherwise

+ * TTBR0 translation is enabled with the specified cfg

+ * @get_fault_info: Called by the GPU fault handler to get information about

+ * @set_stall: Configure whether stall on fault (CFCFG) is enabled. If

+ * stalling on fault is enabled, the GPU driver must call

+ * @resume_translation: Resume translation after a fault

+ * @set_prr_bit: [optional] Configure the GPU's Partially Resident

+ * @set_prr_addr: [optional] Configure the PRR_CFG_*ADDR register with

+ * the physical address of PRR page passed from GPU

+ * The GPU driver (drm/msm) and adreno-smmu work together for controlling

+ * the GPU's SMMU instance. This is by necessity, as the GPU is directly

+ * updating the SMMU for context switches, while on the other hand we do

+ * not want to duplicate all of the initial setup logic from arm-smmu.

+ * This private interface is used for the two drivers to coordinate. The

+ * cookie and callback functions are populated when the GPU driver attaches

+ const struct io_pgtable_cfg *(*get_ttbr1_cfg)(const void *cookie);

+ int (*set_ttbr0_cfg)(const void *cookie, const struct io_pgtable_cfg *cfg);

+ void (*get_fault_info)(const void *cookie, struct adreno_smmu_fault_info *info);

+ void (*set_stall)(const void *cookie, bool enabled);

+ void (*resume_translation)(const void *cookie, bool terminate);

+ void (*set_prr_bit)(const void *cookie, bool set);

+ void (*set_prr_addr)(const void *cookie, phys_addr_t page_addr);

diff --git a/include/linux/adxl.h b/include/linux/adxl.h
new file mode 100644
index 000000000000..2a629acb4c3f
--- /dev/null
+++ b/include/linux/adxl.h

+const char * const *adxl_get_component_names(void);

+int adxl_decode(u64 addr, u64 component_values[]);

diff --git a/include/linux/aer.h b/include/linux/aer.h
index 04602cbe85dc..02940be66324 100644
--- a/include/linux/aer.h
+++ b/include/linux/aer.h

+ * AER and DPC capabilities TLP Logging register sizes (PCIe r6.2, sec 7.8.4

+#define PCIE_STD_MAX_TLP_HEADERLOG (PCIE_STD_NUM_TLP_HEADERLOG + 10)

+ u8 header_len; /* Length of the Logged TLP Header in DWORDs */

+ bool flit; /* TLP was logged when in Flit mode */

-/* pci-e port driver needs this function to enable aer */

-int pci_enable_pcie_error_reporting(struct pci_dev *dev);

-int pci_disable_pcie_error_reporting(struct pci_dev *dev);

-int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev);

-int pci_cleanup_aer_error_status_regs(struct pci_dev *dev);

+int pci_aer_clear_nonfatal_status(struct pci_dev *dev);

-static inline int pci_enable_pcie_error_reporting(struct pci_dev *dev)

-static inline int pci_disable_pcie_error_reporting(struct pci_dev *dev)

-static inline int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)

-static inline int pci_cleanup_aer_error_status_regs(struct pci_dev *dev)

+static inline int pci_aer_clear_nonfatal_status(struct pci_dev *dev)

+static inline int pcie_aer_is_native(struct pci_dev *dev) { return 0; }

-void cper_print_aer(struct pci_dev *dev, int aer_severity,

+void pci_print_aer(struct pci_dev *dev, int aer_severity,

void aer_recover_queue(int domain, unsigned int bus, unsigned int devfn,

+ int severity, struct aer_capability_regs *aer_regs);

diff --git a/include/linux/agpgart.h b/include/linux/agpgart.h
index c6b61ca97053..21b34a96cfd8 100644
--- a/include/linux/agpgart.h
+++ b/include/linux/agpgart.h

struct agp_version version; /* version of the driver */

diff --git a/include/linux/ahci-remap.h b/include/linux/ahci-remap.h
index 62be3a40239d..230c871ba084 100644
--- a/include/linux/ahci-remap.h
+++ b/include/linux/ahci-remap.h

diff --git a/include/linux/ahci_platform.h b/include/linux/ahci_platform.h
index a270f25ee7c7..fe0760ce34c8 100644
--- a/include/linux/ahci_platform.h
+++ b/include/linux/ahci_platform.h

- * 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, or (at your option)

+int ahci_platform_enable_phys(struct ahci_host_priv *hpriv);

+void ahci_platform_disable_phys(struct ahci_host_priv *hpriv);

+struct clk *ahci_platform_find_clk(struct ahci_host_priv *hpriv,

int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);

void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);

+int ahci_platform_deassert_rsts(struct ahci_host_priv *hpriv);

+int ahci_platform_assert_rsts(struct ahci_host_priv *hpriv);

int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);

void ahci_platform_disable_regulators(struct ahci_host_priv *hpriv);

int ahci_platform_enable_resources(struct ahci_host_priv *hpriv);

void ahci_platform_disable_resources(struct ahci_host_priv *hpriv);

struct ahci_host_priv *ahci_platform_get_resources(

+ struct platform_device *pdev, unsigned int flags);

int ahci_platform_init_host(struct platform_device *pdev,

+void ahci_platform_shutdown(struct platform_device *pdev);

int ahci_platform_suspend_host(struct device *dev);

int ahci_platform_resume_host(struct device *dev);

diff --git a/include/linux/aio.h b/include/linux/aio.h
index fdd0a343f455..86892a4fe7c8 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h

@@ -21,8 +20,4 @@ static inline void kiocb_set_cancel_fn(struct kiocb *req,

diff --git a/include/linux/alarmtimer.h b/include/linux/alarmtimer.h
index c70aac13244a..3ffa5341dce2 100644
--- a/include/linux/alarmtimer.h
+++ b/include/linux/alarmtimer.h

- enum alarmtimer_restart (*function)(struct alarm *, ktime_t now);

void alarm_init(struct alarm *alarm, enum alarmtimer_type type,

- enum alarmtimer_restart (*function)(struct alarm *, ktime_t));

void alarm_start(struct alarm *alarm, ktime_t start);

void alarm_start_relative(struct alarm *alarm, ktime_t start);

@@ -58,7 +54,11 @@ u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval);

u64 alarm_forward_now(struct alarm *alarm, ktime_t interval);

ktime_t alarm_expires_remaining(const struct alarm *alarm);

/* Provide way to access the rtc device being used by alarmtimers */

+static inline struct rtc_device *alarmtimer_get_rtcdev(void) { return NULL; }

diff --git a/include/linux/alcor_pci.h b/include/linux/alcor_pci.h
new file mode 100644
index 000000000000..dcb1d37dabc2
--- /dev/null
+++ b/include/linux/alcor_pci.h

+ * Driver for Alcor Micro AU6601 and AU6621 controllers

+/* registers spotter by reverse engineering but still

+ * The au6601 and au6621 have different DMA engines with different issues. One

+ * For example au6621 engine is triggered by addr change. No other interaction

+ * is needed. This means, if we get two buffers with same address, then engine

+/* default timeout set to 125: 125 * 40ms = 5 sec

+/* Some power related reg, used together with AU6601_OUTPUT_ENABLE */

+/* AU6601_MS_CARD_ACTIVE - will cativate MS card section? */

+/* card slot state. It should automatically detect type of

+#define AU6601_CLK_POSITIVE_EDGE_ALL (AU6601_CLK_CMD_POSITIVE_EDGE \

+#define AU6601_INT_CMD_MASK (AU6601_INT_CMD_END | \

+ AU6601_INT_CMD_TIMEOUT_ERR | AU6601_INT_CMD_CRC_ERR | \

+ AU6601_INT_CMD_END_BIT_ERR | AU6601_INT_CMD_INDEX_ERR)

+#define AU6601_INT_DATA_MASK (AU6601_INT_DATA_END | AU6601_INT_DMA_END | \

+ AU6601_INT_READ_BUF_RDY | AU6601_INT_WRITE_BUF_RDY | \

+ AU6601_INT_DATA_TIMEOUT_ERR | AU6601_INT_DATA_CRC_ERR | \

+void alcor_write8(struct alcor_pci_priv *priv, u8 val, unsigned int addr);

+void alcor_write16(struct alcor_pci_priv *priv, u16 val, unsigned int addr);

+void alcor_write32(struct alcor_pci_priv *priv, u32 val, unsigned int addr);

+void alcor_write32be(struct alcor_pci_priv *priv, u32 val, unsigned int addr);

+u8 alcor_read8(struct alcor_pci_priv *priv, unsigned int addr);

+u32 alcor_read32(struct alcor_pci_priv *priv, unsigned int addr);

+u32 alcor_read32be(struct alcor_pci_priv *priv, unsigned int addr);

diff --git a/include/linux/align.h b/include/linux/align.h
new file mode 100644
index 000000000000..55debf105a5d
--- /dev/null
+++ b/include/linux/align.h

diff --git a/include/linux/alloc_tag.h b/include/linux/alloc_tag.h
new file mode 100644
index 000000000000..d40ac39bfbe8
--- /dev/null
+++ b/include/linux/alloc_tag.h

+ * An instance of this structure is created in a special ELF section at every

+ * allocation callsite. At runtime, the special section is treated as

+ * an array of these. Embedded codetag utilizes codetag framework.

+static inline bool is_codetag_empty(union codetag_ref *ref)

+static inline void set_codetag_empty(union codetag_ref *ref)

+static inline bool is_codetag_empty(union codetag_ref *ref) { return false; }

+static inline void set_codetag_empty(union codetag_ref *ref)

+size_t alloc_tag_top_users(struct codetag_bytes *tags, size_t count, bool can_sleep);

+static inline struct alloc_tag *ct_to_alloc_tag(struct codetag *ct)

+#if defined(CONFIG_ARCH_MODULE_NEEDS_WEAK_PER_CPU) && defined(MODULE)

+ * When percpu variables are required to be defined as weak, static percpu

+ * variables can't be used inside a function (see comments for DECLARE_PER_CPU_SECTION).

+ * Instead we will account all module allocations to a single counter.

+DECLARE_PER_CPU(struct alloc_tag_counters, _shared_alloc_tag);

+ static struct alloc_tag _alloc_tag __used __aligned(8) \

+#else /* CONFIG_ARCH_MODULE_NEEDS_WEAK_PER_CPU && MODULE */

+ static struct alloc_tag _alloc_tag __used __aligned(8) \

+ static DEFINE_PER_CPU(struct alloc_tag_counters, _alloc_tag_cntr); \

+ static struct alloc_tag _alloc_tag __used __aligned(8) \

+#endif /* CONFIG_ARCH_MODULE_NEEDS_WEAK_PER_CPU && MODULE */

+DECLARE_STATIC_KEY_MAYBE(CONFIG_MEM_ALLOC_PROFILING_ENABLED_BY_DEFAULT,

+static inline bool mem_alloc_profiling_enabled(void)

+ return static_branch_maybe(CONFIG_MEM_ALLOC_PROFILING_ENABLED_BY_DEFAULT,

+static inline struct alloc_tag_counters alloc_tag_read(struct alloc_tag *tag)

+static inline void alloc_tag_add_check(union codetag_ref *ref, struct alloc_tag *tag)

+ WARN_ONCE(ref && ref->ct && !is_codetag_empty(ref),

+ "alloc_tag was not cleared (got tag for %s:%u)\n",

+ WARN_ONCE(!tag, "current->alloc_tag not set\n");

+static inline void alloc_tag_sub_check(union codetag_ref *ref)

+ WARN_ONCE(ref && !ref->ct, "alloc_tag was not set\n");

+static inline void alloc_tag_add_check(union codetag_ref *ref, struct alloc_tag *tag) {}

+static inline void alloc_tag_sub_check(union codetag_ref *ref) {}

+/* Caller should verify both ref and tag to be valid */

+static inline bool __alloc_tag_ref_set(union codetag_ref *ref, struct alloc_tag *tag)

+static inline bool alloc_tag_ref_set(union codetag_ref *ref, struct alloc_tag *tag)

+ * We need in increment the call counter every time we have a new

+ * allocation or when we split a large allocation into smaller ones.

+ * Each new reference for every sub-allocation needs to increment call

+ * counter because when we free each part the counter will be decremented.

+static inline void alloc_tag_add(union codetag_ref *ref, struct alloc_tag *tag, size_t bytes)

+static inline void alloc_tag_sub(union codetag_ref *ref, size_t bytes)

+static inline void alloc_tag_set_inaccurate(struct alloc_tag *tag)

+static inline bool alloc_tag_is_inaccurate(struct alloc_tag *tag)

+ return !!(tag->ct.flags & CODETAG_FLAG_INACCURATE);

+#define alloc_tag_record(p) ((p) = current->alloc_tag)

+static inline bool mem_alloc_profiling_enabled(void) { return false; }

+static inline void alloc_tag_add(union codetag_ref *ref, struct alloc_tag *tag,

+static inline void alloc_tag_sub(union codetag_ref *ref, size_t bytes) {}

+static inline void alloc_tag_set_inaccurate(struct alloc_tag *tag) {}

+static inline bool alloc_tag_is_inaccurate(struct alloc_tag *tag) { return false; }

diff --git a/include/linux/altera_jtaguart.h b/include/linux/altera_jtaguart.h
index 953b178a1650..527a142cd530 100644
--- a/include/linux/altera_jtaguart.h
+++ b/include/linux/altera_jtaguart.h

* altera_jtaguart.h -- Altera JTAG UART driver defines.

diff --git a/include/linux/altera_uart.h b/include/linux/altera_uart.h
index c022c82db7ca..3eb73b8c49c8 100644
--- a/include/linux/altera_uart.h
+++ b/include/linux/altera_uart.h

diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
index d143c13bed26..9946276aff73 100644
--- a/include/linux/amba/bus.h
+++ b/include/linux/amba/bus.h

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License version 2 as

+ * CoreSight Architecture specification updates the ID specification

+ * for components on the AMBA bus. (ARM IHI 0029E)

+ * Class 0xF remains for PrimeCell and legacy components. (AMBA_CID above)

+ * Class 0x9 defines the component as CoreSight (CORESIGHT_CID above)

+ * Class 0x0, 0x1, 0xB, 0xE define components that do not have driver support

+ * Class 0x2-0x8,0xA and 0xD-0xD are presently reserved.

+ * Class 0x9 components use additional values to form a Unique Component

+ * Identifier (UCI), where peripheral ID values are identical for different

+ * components. Passed to the amba bus code from the component driver via

+ * @devarch_mask: mask bits used for matching. 0 indicates UCI not used.

+ * @data : additional driver data. As we have usurped the original

+ * pointer some devices may still need additional data

+ * Driver name to force a match. Do not set directly, because core

+ * frees it. Use driver_set_override() to set or clear it.

int (*probe)(struct amba_device *, const struct amba_id *);

+ * For most device drivers, no need to care about this flag as long as

+ * all DMAs are handled through the kernel DMA API. For some special

+ * ones, for example VFIO drivers, they know how to manage the DMA

+ * themselves and set this flag so that the IOMMU layer will allow them

+ * to setup and manage their own I/O address space.

- AMBA_VENDOR_LINUX = 0xfe, /* This value is not official */

-/* This is used to generate pseudo-ID for AMBA device */

- (((conf) & 0xff) << 24 | ((rev) & 0xf) << 20 | \

-#define to_amba_device(d) container_of(d, struct amba_device, dev)

+#define to_amba_device(d) container_of_const(d, struct amba_device, dev)

#define amba_get_drvdata(d) dev_get_drvdata(&d->dev)

#define amba_set_drvdata(d,p) dev_set_drvdata(&d->dev, p)

-void amba_driver_unregister(struct amba_driver *);

-struct amba_device *amba_device_alloc(const char *, resource_size_t, size_t);

-int amba_device_add(struct amba_device *, struct resource *);

-int amba_device_register(struct amba_device *, struct resource *);

-struct amba_device *amba_apb_device_add(struct device *parent, const char *name,

-struct amba_device *amba_ahb_device_add(struct device *parent, const char *name,

-amba_apb_device_add_res(struct device *parent, const char *name,

-amba_ahb_device_add_res(struct device *parent, const char *name,

-void amba_device_unregister(struct amba_device *);

-struct amba_device *amba_find_device(const char *, struct device *, unsigned int, unsigned int);

-int amba_request_regions(struct amba_device *, const char *);

+ * use a macro to avoid include chaining to get THIS_MODULE

-static inline int amba_pclk_enable(struct amba_device *dev)

+int __amba_driver_register(struct amba_driver *, struct module *);

+void amba_driver_unregister(struct amba_driver *);

+static inline int __amba_driver_register(struct amba_driver *drv,

-static inline void amba_pclk_disable(struct amba_device *dev)

+static inline void amba_driver_unregister(struct amba_driver *drv)

-static inline int amba_pclk_prepare(struct amba_device *dev)

+static inline bool dev_is_amba(const struct device *dev)

-static inline void amba_pclk_unprepare(struct amba_device *dev)

+struct amba_device *amba_device_alloc(const char *, resource_size_t, size_t);

+int amba_device_add(struct amba_device *, struct resource *);

+int amba_device_register(struct amba_device *, struct resource *);

+void amba_device_unregister(struct amba_device *);

+int amba_request_regions(struct amba_device *, const char *);

/* Some drivers don't use the struct amba_device */

diff --git a/include/linux/amba/clcd-regs.h b/include/linux/amba/clcd-regs.h
deleted file mode 100644
index 516a6fda83c5..000000000000
--- a/include/linux/amba/clcd-regs.h
+++ /dev/null

- * This file is subject to the terms and conditions of the GNU General Public

- * License. See the file COPYING in the main directory of this archive

diff --git a/include/linux/amba/clcd.h b/include/linux/amba/clcd.h
deleted file mode 100644
index d0c3be77c18e..000000000000
--- a/include/linux/amba/clcd.h
+++ /dev/null

- * linux/include/asm-arm/hardware/amba_clcd.h -- Integrator LCD panel.

- * This file is subject to the terms and conditions of the GNU General Public

- * License. See the file COPYING in the main directory of this archive

- CLCD_CAP_444 = CLCD_CAP_RGB444 | CLCD_CAP_BGR444,

- CLCD_CAP_5551 = CLCD_CAP_RGB5551 | CLCD_CAP_BGR5551,

- CLCD_CAP_565 = CLCD_CAP_RGB565 | CLCD_CAP_BGR565,

- CLCD_CAP_888 = CLCD_CAP_RGB888 | CLCD_CAP_BGR888,

- CLCD_CAP_RGB = CLCD_CAP_RGB444 | CLCD_CAP_RGB5551 |

- CLCD_CAP_BGR = CLCD_CAP_BGR444 | CLCD_CAP_BGR5551 |

- * If the B/R lines are switched between the CLCD

- * and the panel we need to know this and not try to

- * compensate with the BGR bit in the control register.

- * Optional. Check whether the var structure is acceptable

- int (*check)(struct clcd_fb *fb, struct fb_var_screeninfo *var);

- * Compulsory. Decode fb->fb.var into regs->*. In the case of

- * fixed timing, set regs->* to the register values required.

- void (*decode)(struct clcd_fb *fb, struct clcd_regs *regs);

- int (*mmap)(struct clcd_fb *, struct vm_area_struct *);

- * struct clcd_vendor_data - holds hardware (IP-block) vendor-specific

- * @clock_timregs: the CLCD needs to be clocked when accessing the

- * @packed_24_bit_pixels: this variant supports 24bit packed pixel data,

- * so that RGB accesses 3 bytes at a time, not just on even 32bit

- * boundaries, packing the pixel data in memory. ST Microelectronics

- * @st_bitmux_control: ST Microelectronics have implemented output

- * bit line multiplexing into the CLCD control register. This indicates

- * @init_board: custom board init function for this variant

- * @init_panel: custom panel init function for this variant

-/* this data structure describes each frame buffer device we find */

-static inline void clcdfb_decode(struct clcd_fb *fb, struct clcd_regs *regs)

- * Program the CLCD controller registers and start the CLCD

- val |= var->sync & FB_SYNC_HOR_HIGH_ACT ? 0 : TIM2_IHS;

- val |= var->sync & FB_SYNC_VERT_HIGH_ACT ? 0 : TIM2_IVS;

- else if (fb->panel->cntl & CNTL_LCDMONO8) /* STN monochrome, 8bit */

- if (fb->panel->caps && fb->board->caps && var->bits_per_pixel >= 16) {

- * if board and panel supply capabilities, we can support

- * changing BGR/RGB depending on supplied parameters. Here

- * we switch to what the framebuffer is providing if need

- * be, so if the framebuffer is BGR but the display connection

- * is RGB (first case) we switch it around. Vice versa mutatis

- * mutandis if the framebuffer is RGB but the display connection

- * PL110 cannot choose between 5551 and 565 modes in its

- * control register. It is possible to use 565 with

- /* Modified variant supporting 24 bit packed pixels */

-static inline int clcdfb_check(struct clcd_fb *fb, struct fb_var_screeninfo *var)

- var->xres_virtual = var->xres = (var->xres + 15) & ~15;

- var->yres_virtual = var->yres = (var->yres + 1) & ~1;

- if (CHECK(right_margin, (5+1), 256) || /* back porch */

- CHECK(left_margin, (5+1), 256) || /* front porch */

- (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)

diff --git a/include/linux/amba/kmi.h b/include/linux/amba/kmi.h
index a39e5be751b3..94dd727f1aea 100644
--- a/include/linux/amba/kmi.h
+++ b/include/linux/amba/kmi.h

- * 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

- * 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. See the

- * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

* ---------------------------------------------------------------------------

* From ARM PrimeCell(tm) PS2 Keyboard/Mouse Interface (PL050) Technical

* Reference Manual - ARM DDI 0143B - see http://www.arm.com/

diff --git a/include/linux/amba/mmci.h b/include/linux/amba/mmci.h
index 8c98113069ce..6f96dc2209c0 100644
--- a/include/linux/amba/mmci.h
+++ b/include/linux/amba/mmci.h

* @ocr_mask: available voltages on the 4 pins from the block, this

* is ignored if a regulator is used, see the MMC_VDD_* masks in

- * @ios_handler: a callback function to act on specfic ios changes,

- * mask into a value to be binary (or set some other custom bits

- * in MMCIPWR) or:ed and written into the MMCIPWR register of the

- * block. May also control external power based on the power_mode.

- * @status: if no GPIO read function was given to the block in

- * gpio_wp (below) this function will be called to determine

- * whether a card is present in the MMC slot or not

- * @gpio_wp: read this GPIO pin to see if the card is write protected

- * @gpio_cd: read this GPIO pin to detect card insertion

- * @cd_invert: true if the gpio_cd pin value is active low

+ * @status: if no GPIO line was given to the block in this function will

+ * be called to determine whether a card is present in the MMC slot or not

- int (*ios_handler)(struct device *, struct mmc_ios *);

diff --git a/include/linux/amba/pl022.h b/include/linux/amba/pl022.h
index 854b7294f6c6..d7b07d0311e1 100644
--- a/include/linux/amba/pl022.h
+++ b/include/linux/amba/pl022.h

- * 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

- * 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. See the

* struct pl022_ssp_master - device.platform_data for SPI controller devices.

- * @num_chipselect: chipselects are used to distinguish individual

- * SPI slaves, and are numbered from zero to num_chipselects - 1.

- * each slave has a chipselect signal, but it's common that not

* @enable_dma: if true enables DMA driven transfers.

+ * @dma_filter: callback filter for dma_request_channel.

* @dma_rx_param: parameter to locate an RX DMA channel.

* @dma_tx_param: parameter to locate a TX DMA channel.

* @autosuspend_delay: delay in ms following transfer completion before the

* indicates no delay and the device will be suspended immediately.

* @rt: indicates the controller should run the message pump with realtime

* priority to minimise the transfer latency on the bus.

- * @chipselects: list of <num_chipselects> chip select gpios

- bool (*dma_filter)(struct dma_chan *chan, void *filter_param);

* @clkdelay: on the PL023 variant, the delay in feeback clock cycles

- * @cs_control: function pointer to board-specific function to

- * assert/deassert I/O port to control HW generation of devices chip-select.

diff --git a/include/linux/amba/pl080.h b/include/linux/amba/pl080.h
index ab036b6b1804..e192d546639b 100644
--- a/include/linux/amba/pl080.h
+++ b/include/linux/amba/pl080.h

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License version 2 as

/* Note, there are some Samsung updates to this controller block which

diff --git a/include/linux/amba/pl08x.h b/include/linux/amba/pl08x.h
index 79d1bcee738d..3100e0debcdd 100644
--- a/include/linux/amba/pl08x.h
+++ b/include/linux/amba/pl08x.h

* linux/amba/pl08x.h - ARM PrimeCell DMA Controller driver

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License version 2 as

diff --git a/include/linux/amba/pl093.h b/include/linux/amba/pl093.h
deleted file mode 100644
index 2983e3671adb..000000000000
--- a/include/linux/amba/pl093.h
+++ /dev/null

- * AMBA PL093 SSMC (synchronous static memory controller)

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License version 2 as

-#define SMB_BANK(x) ((x) * 0x20) /* each bank control set is 0x20 apart */

diff --git a/include/linux/amba/serial.h b/include/linux/amba/serial.h
index ad0965e21a5e..9120de05ead0 100644
--- a/include/linux/amba/serial.h
+++ b/include/linux/amba/serial.h