Merge tag 'platform-drivers-x86-amd-wbrf-v6.8-1' into review-hans (ed289b98) · Commits · git / linux-net

Documentation/driver-api/index.rst

+1 −0

Original line number	Diff line number	Diff line
		@@ -115,6 +115,7 @@ available subsections can be seen below.
		hte/index
		wmi
		dpll
		wbrf

		.. only:: subproject and html

Documentation/driver-api/wbrf.rst

0 → 100644

+78 −0

Original line number	Diff line number	Diff line
		.. SPDX-License-Identifier: GPL-2.0-or-later

		=================================
		WBRF - Wifi Band RFI Mitigations
		=================================

		Due to electrical and mechanical constraints in certain platform designs
		there may be likely interference of relatively high-powered harmonics of
		the GPU memory clocks with local radio module frequency bands used by
		certain Wifi bands.

		To mitigate possible RFI interference producers can advertise the
		frequencies in use and consumers can use this information to avoid using
		these frequencies for sensitive features.

		When a platform is known to have this issue with any contained devices,
		the platform designer will advertise the availability of this feature via
		ACPI devices with a device specific method (_DSM).
		* Producers with this _DSM will be able to advertise the frequencies in use.
		* Consumers with this _DSM will be able to register for notifications of
		frequencies in use.

		Some general terms
		==================

		Producer: such component who can produce high-powered radio frequency
		Consumer: such component who can adjust its in-use frequency in
		response to the radio frequencies of other components to mitigate the
		possible RFI.

		To make the mechanism function, those producers should notify active use
		of their particular frequencies so that other consumers can make relative
		internal adjustments as necessary to avoid this resonance.

		ACPI interface
		==============

		Although initially used by for wifi + dGPU use cases, the ACPI interface
		can be scaled to any type of device that a platform designer discovers
		can cause interference.

		The GUID used for the _DSM is 7B7656CF-DC3D-4C1C-83E9-66E721DE3070.

		3 functions are available in this _DSM:

		* 0: discover # of functions available
		* 1: record RF bands in use
		* 2: retrieve RF bands in use

		Driver programming interface
		============================

		.. kernel-doc:: drivers/platform/x86/amd/wbrf.c

		Sample Usage
		=============

		The expected flow for the producers:
		1. During probe, call `acpi_amd_wbrf_supported_producer` to check if WBRF
		can be enabled for the device.
		2. On using some frequency band, call `acpi_amd_wbrf_add_remove` with 'add'
		param to get other consumers properly notified.
		3. Or on stopping using some frequency band, call
		`acpi_amd_wbrf_add_remove` with 'remove' param to get other consumers notified.

		The expected flow for the consumers:
		1. During probe, call `acpi_amd_wbrf_supported_consumer` to check if WBRF
		can be enabled for the device.
		2. Call `amd_wbrf_register_notifier` to register for notification
		of frequency band change(add or remove) from other producers.
		3. Call the `amd_wbrf_retrieve_freq_band` initally to retrieve
		current active frequency bands considering some producers may broadcast
		such information before the consumer is up.
		4. On receiving a notification for frequency band change, run
		`amd_wbrf_retrieve_freq_band` again to retrieve the latest
		active frequency bands.
		5. During driver cleanup, call `amd_wbrf_unregister_notifier` to
		unregister the notifier.

drivers/platform/x86/amd/Kconfig

+14 −0

Original line number	Diff line number	Diff line
		@@ -18,3 +18,17 @@ config AMD_HSMP

		If you choose to compile this driver as a module the module will be
		called amd_hsmp.

		config AMD_WBRF
		bool "AMD Wifi RF Band mitigations (WBRF)"
		depends on ACPI
		help
		WBRF(Wifi Band RFI mitigation) mechanism allows Wifi drivers
		to notify the frequencies they are using so that other hardware
		can be reconfigured to avoid harmonic conflicts.

		AMD provides an ACPI based mechanism to support WBRF on platform with
		appropriate underlying support.

		This mechanism will only be activated on platforms that advertise a
		need for it.

drivers/platform/x86/amd/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -8,3 +8,4 @@ obj-$(CONFIG_AMD_PMC) += pmc/
		amd_hsmp-y := hsmp.o
		obj-$(CONFIG_AMD_HSMP) += amd_hsmp.o
		obj-$(CONFIG_AMD_PMF) += pmf/
		obj-$(CONFIG_AMD_WBRF) += wbrf.o

drivers/platform/x86/amd/wbrf.c

0 → 100644

+317 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Wifi Frequency Band Manage Interface
		* Copyright (C) 2023 Advanced Micro Devices
		*/

		#include <linux/acpi.h>
		#include <linux/acpi_amd_wbrf.h>

		/*
		* Functions bit vector for WBRF method
		*
		* Bit 0: WBRF supported.
		* Bit 1: Function 1 (Add / Remove frequency) is supported.
		* Bit 2: Function 2 (Get frequency list) is supported.
		*/
		#define WBRF_ENABLED 0x0
		#define WBRF_RECORD 0x1
		#define WBRF_RETRIEVE 0x2

		#define WBRF_REVISION 0x1

		/*
		* The data structure used for WBRF_RETRIEVE is not naturally aligned.
		* And unfortunately the design has been settled down.
		*/
		struct amd_wbrf_ranges_out {
		u32 num_of_ranges;
		struct freq_band_range band_list[MAX_NUM_OF_WBRF_RANGES];
		} __packed;

		static const guid_t wifi_acpi_dsm_guid =
		GUID_INIT(0x7b7656cf, 0xdc3d, 0x4c1c,
		0x83, 0xe9, 0x66, 0xe7, 0x21, 0xde, 0x30, 0x70);

		/*
		* Used to notify consumer (amdgpu driver currently) about
		* the wifi frequency is change.
		*/
		static BLOCKING_NOTIFIER_HEAD(wbrf_chain_head);

		static int wbrf_record(struct acpi_device adev, uint8_t action, struct wbrf_ranges_in_out in)
		{
		union acpi_object argv4;
		union acpi_object *tmp;
		union acpi_object *obj;
		u32 num_of_ranges = 0;
		u32 num_of_elements;
		u32 arg_idx = 0;
		int ret;
		u32 i;

		if (!in)
		return -EINVAL;

		for (i = 0; i < ARRAY_SIZE(in->band_list); i++) {
		if (in->band_list[i].start && in->band_list[i].end)
		num_of_ranges++;
		}

		/*
		* The num_of_ranges value in the "in" object supplied by
		* the caller is required to be equal to the number of
		* entries in the band_list array in there.
		*/
		if (num_of_ranges != in->num_of_ranges)
		return -EINVAL;

		/*
		* Every input frequency band comes with two end points(start/end)
		* and each is accounted as an element. Meanwhile the range count
		* and action type are accounted as an element each.
		* So, the total element count = 2 * num_of_ranges + 1 + 1.
		*/
		num_of_elements = 2 * num_of_ranges + 2;

		tmp = kcalloc(num_of_elements, sizeof(*tmp), GFP_KERNEL);
		if (!tmp)
		return -ENOMEM;

		argv4.package.type = ACPI_TYPE_PACKAGE;
		argv4.package.count = num_of_elements;
		argv4.package.elements = tmp;

		/* save the number of ranges*/
		tmp[0].integer.type = ACPI_TYPE_INTEGER;
		tmp[0].integer.value = num_of_ranges;

		/* save the action(WBRF_RECORD_ADD/REMOVE/RETRIEVE) */
		tmp[1].integer.type = ACPI_TYPE_INTEGER;
		tmp[1].integer.value = action;

		arg_idx = 2;
		for (i = 0; i < ARRAY_SIZE(in->band_list); i++) {
		if (!in->band_list[i].start \|\| !in->band_list[i].end)
		continue;

		tmp[arg_idx].integer.type = ACPI_TYPE_INTEGER;
		tmp[arg_idx++].integer.value = in->band_list[i].start;
		tmp[arg_idx].integer.type = ACPI_TYPE_INTEGER;
		tmp[arg_idx++].integer.value = in->band_list[i].end;
		}

		obj = acpi_evaluate_dsm(adev->handle, &wifi_acpi_dsm_guid,
		WBRF_REVISION, WBRF_RECORD, &argv4);

		if (!obj)
		return -EINVAL;

		if (obj->type != ACPI_TYPE_INTEGER) {
		ret = -EINVAL;
		goto out;
		}

		ret = obj->integer.value;
		if (ret)
		ret = -EINVAL;

		out:
		ACPI_FREE(obj);
		kfree(tmp);

		return ret;
		}

		/**
		* acpi_amd_wbrf_add_remove - add or remove the frequency band the device is using
		*
		* @dev: device pointer
		* @action: remove or add the frequency band into bios
		* @in: input structure containing the frequency band the device is using
		*
		* Broadcast to other consumers the frequency band the device starts
		* to use. Underneath the surface the information is cached into an
		* internal buffer first. Then a notification is sent to all those
		* registered consumers. So then they can retrieve that buffer to
		* know the latest active frequency bands. Consumers that haven't
		* yet been registered can retrieve the information from the cache
		* when they register.
		*
		* Return:
		* 0 for success add/remove wifi frequency band.
		* Returns a negative error code for failure.
		*/
		int acpi_amd_wbrf_add_remove(struct device dev, uint8_t action, struct wbrf_ranges_in_out in)
		{
		struct acpi_device *adev;
		int ret;

		adev = ACPI_COMPANION(dev);
		if (!adev)
		return -ENODEV;

		ret = wbrf_record(adev, action, in);
		if (ret)
		return ret;

		blocking_notifier_call_chain(&wbrf_chain_head, WBRF_CHANGED, NULL);

		return 0;
		}
		EXPORT_SYMBOL_GPL(acpi_amd_wbrf_add_remove);

		/**
		* acpi_amd_wbrf_supported_producer - determine if the WBRF can be enabled
		* for the device as a producer
		*
		* @dev: device pointer
		*
		* Check if the platform equipped with necessary implementations to
		* support WBRF for the device as a producer.
		*
		* Return:
		* true if WBRF is supported, otherwise returns false
		*/
		bool acpi_amd_wbrf_supported_producer(struct device *dev)
		{
		struct acpi_device *adev;

		adev = ACPI_COMPANION(dev);
		if (!adev)
		return false;

		return acpi_check_dsm(adev->handle, &wifi_acpi_dsm_guid,
		WBRF_REVISION, BIT(WBRF_RECORD));
		}
		EXPORT_SYMBOL_GPL(acpi_amd_wbrf_supported_producer);

		/**
		* acpi_amd_wbrf_supported_consumer - determine if the WBRF can be enabled
		* for the device as a consumer
		*
		* @dev: device pointer
		*
		* Determine if the platform equipped with necessary implementations to
		* support WBRF for the device as a consumer.
		*
		* Return:
		* true if WBRF is supported, otherwise returns false.
		*/
		bool acpi_amd_wbrf_supported_consumer(struct device *dev)
		{
		struct acpi_device *adev;

		adev = ACPI_COMPANION(dev);
		if (!adev)
		return false;

		return acpi_check_dsm(adev->handle, &wifi_acpi_dsm_guid,
		WBRF_REVISION, BIT(WBRF_RETRIEVE));
		}
		EXPORT_SYMBOL_GPL(acpi_amd_wbrf_supported_consumer);

		/**
		* amd_wbrf_retrieve_freq_band - retrieve current active frequency bands
		*
		* @dev: device pointer
		* @out: output structure containing all the active frequency bands
		*
		* Retrieve the current active frequency bands which were broadcasted
		* by other producers. The consumer who calls this API should take
		* proper actions if any of the frequency band may cause RFI with its
		* own frequency band used.
		*
		* Return:
		* 0 for getting wifi freq band successfully.
		* Returns a negative error code for failure.
		*/
		int amd_wbrf_retrieve_freq_band(struct device dev, struct wbrf_ranges_in_out out)
		{
		struct amd_wbrf_ranges_out acpi_out = {0};
		struct acpi_device *adev;
		union acpi_object *obj;
		union acpi_object param;
		int ret = 0;

		adev = ACPI_COMPANION(dev);
		if (!adev)
		return -ENODEV;

		param.type = ACPI_TYPE_STRING;
		param.string.length = 0;
		param.string.pointer = NULL;

		obj = acpi_evaluate_dsm(adev->handle, &wifi_acpi_dsm_guid,
		WBRF_REVISION, WBRF_RETRIEVE, &param);
		if (!obj)
		return -EINVAL;

		/*
		* The return buffer is with variable length and the format below:
		* number_of_entries(1 DWORD): Number of entries
		* start_freq of 1st entry(1 QWORD): Start frequency of the 1st entry
		* end_freq of 1st entry(1 QWORD): End frequency of the 1st entry
		* ...
		* ...
		* start_freq of the last entry(1 QWORD)
		* end_freq of the last entry(1 QWORD)
		*
		* Thus the buffer length is determined by the number of entries.
		* - For zero entry scenario, the buffer length will be 4 bytes.
		* - For one entry scenario, the buffer length will be 20 bytes.
		*/
		if (obj->buffer.length > sizeof(acpi_out) \|\| obj->buffer.length < 4) {
		dev_err(dev, "Wrong sized WBRT information");
		ret = -EINVAL;
		goto out;
		}
		memcpy(&acpi_out, obj->buffer.pointer, obj->buffer.length);

		out->num_of_ranges = acpi_out.num_of_ranges;
		memcpy(out->band_list, acpi_out.band_list, sizeof(acpi_out.band_list));

		out:
		ACPI_FREE(obj);
		return ret;
		}
		EXPORT_SYMBOL_GPL(amd_wbrf_retrieve_freq_band);

		/**
		* amd_wbrf_register_notifier - register for notifications of frequency
		* band update
		*
		* @nb: driver notifier block
		*
		* The consumer should register itself via this API so that it can get
		* notified on the frequency band updates from other producers.
		*
		* Return:
		* 0 for registering a consumer driver successfully.
		* Returns a negative error code for failure.
		*/
		int amd_wbrf_register_notifier(struct notifier_block *nb)
		{
		return blocking_notifier_chain_register(&wbrf_chain_head, nb);
		}
		EXPORT_SYMBOL_GPL(amd_wbrf_register_notifier);

		/**
		* amd_wbrf_unregister_notifier - unregister for notifications of
		* frequency band update
		*
		* @nb: driver notifier block
		*
		* The consumer should call this API when it is longer interested with
		* the frequency band updates from other producers. Usually, this should
		* be performed during driver cleanup.
		*
		* Return:
		* 0 for unregistering a consumer driver.
		* Returns a negative error code for failure.
		*/
		int amd_wbrf_unregister_notifier(struct notifier_block *nb)
		{
		return blocking_notifier_chain_unregister(&wbrf_chain_head, nb);
		}
		EXPORT_SYMBOL_GPL(amd_wbrf_unregister_notifier);