sound/soc/sdca/sdca_ump.c - third_party/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 // Copyright (C) 2025 Cirrus Logic, Inc. and
 //                    Cirrus Logic International Semiconductor Ltd.

 /*
  * The MIPI SDCA specification is available for public downloads at
  * https://www.mipi.org/mipi-sdca-v1-0-download
  */

 #include <linux/dev_printk.h>
 #include <linux/device.h>
 #include <linux/regmap.h>
 #include <sound/sdca.h>
 #include <sound/sdca_function.h>
 #include <sound/sdca_ump.h>
 #include <sound/soc-component.h>
 #include <linux/soundwire/sdw_registers.h>

 /**
  * sdca_ump_get_owner_host - check a UMP buffer is owned by the host
  * @dev: Pointer to the struct device used for error messages.
  * @function_regmap: Pointer to the regmap for the SDCA Function.
  * @function: Pointer to the Function information.
  * @entity: Pointer to the SDCA Entity.
  * @control: Pointer to the SDCA Control for the UMP Owner.
  *
  * Return: Returns zero on success, and a negative error code on failure.
  */
 int sdca_ump_get_owner_host(struct device *dev,
 			    struct regmap *function_regmap,
 			    struct sdca_function_data *function,
 			    struct sdca_entity *entity,
 			    struct sdca_control *control)
 {
 	unsigned int reg, owner;
 	int ret;

 	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, control->sel, 0);
 	ret = regmap_read(function_regmap, reg, &owner);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to read UMP owner: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	if (owner != SDCA_UMP_OWNER_HOST) {
 		dev_err(dev, "%s: host is not the UMP owner\n", entity->label);
 		return -EINVAL;
 	}

 	return 0;
 }
 EXPORT_SYMBOL_NS_GPL(sdca_ump_get_owner_host, "SND_SOC_SDCA");

 /**
  * sdca_ump_set_owner_device - set a UMP buffer's ownership back to the device
  * @dev: Pointer to the struct device used for error messages.
  * @function_regmap: Pointer to the regmap for the SDCA Function.
  * @function: Pointer to the Function information.
  * @entity: Pointer to the SDCA Entity.
  * @control: Pointer to the SDCA Control for the UMP Owner.
  *
  * Return: Returns zero on success, and a negative error code on failure.
  */
 int sdca_ump_set_owner_device(struct device *dev,
 			      struct regmap *function_regmap,
 			      struct sdca_function_data *function,
 			      struct sdca_entity *entity,
 			      struct sdca_control *control)
 {
 	unsigned int reg;
 	int ret;

 	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, control->sel, 0);
 	ret = regmap_write(function_regmap, reg, SDCA_UMP_OWNER_DEVICE);
 	if (ret < 0)
 		dev_err(dev, "%s: failed to write UMP owner: %d\n",
 			entity->label, ret);

 	return ret;
 }
 EXPORT_SYMBOL_NS_GPL(sdca_ump_set_owner_device, "SND_SOC_SDCA");

 /**
  * sdca_ump_read_message - read a UMP message from the device
  * @dev: Pointer to the struct device used for error messages.
  * @device_regmap: Pointer to the Device register map.
  * @function_regmap: Pointer to the regmap for the SDCA Function.
  * @function: Pointer to the Function information.
  * @entity: Pointer to the SDCA Entity.
  * @offset_sel: Control Selector for the UMP Offset Control.
  * @length_sel: Control Selector for the UMP Length Control.
  * @msg: Pointer that will be populated with an dynamically buffer
  * containing the UMP message. Note this needs to be freed by the
  * caller.
  *
  * The caller should first call sdca_ump_get_owner_host() to ensure the host
  * currently owns the UMP buffer, and then this function can be used to
  * retrieve a message. It is the callers responsibility to free the
  * message once it is finished with it. Finally sdca_ump_set_owner_device()
  * should be called to return the buffer to the device.
  *
  * Return: Returns the message length on success, and a negative error
  * code on failure.
  */
 int sdca_ump_read_message(struct device *dev,
 			  struct regmap *device_regmap,
 			  struct regmap *function_regmap,
 			  struct sdca_function_data *function,
 			  struct sdca_entity *entity,
 			  unsigned int offset_sel, unsigned int length_sel,
 			  void **msg)
 {
 	struct sdca_control_range *range;
 	unsigned int msg_offset, msg_len;
 	unsigned int buf_addr, buf_len;
 	unsigned int reg;
 	int ret;

 	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, offset_sel, 0);
 	ret = regmap_read(function_regmap, reg, &msg_offset);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to read UMP offset: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	range = sdca_selector_find_range(dev, entity, offset_sel,
 					 SDCA_MESSAGEOFFSET_NCOLS, 1);
 	if (!range)
 		return -ENOENT;

 	buf_addr = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_START_ADDRESS, 0);
 	buf_len = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_LENGTH, 0);

 	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, length_sel, 0);
 	ret = regmap_read(function_regmap, reg, &msg_len);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to read UMP length: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	if (msg_len > buf_len - msg_offset) {
 		dev_err(dev, "%s: message too big for UMP buffer: %d\n",
 			entity->label, msg_len);
 		return -EINVAL;
 	}

 	*msg = kmalloc(msg_len, GFP_KERNEL);
 	if (!*msg)
 		return -ENOMEM;

 	ret = regmap_raw_read(device_regmap, buf_addr + msg_offset, *msg, msg_len);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to read UMP message: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	return msg_len;
 }
 EXPORT_SYMBOL_NS_GPL(sdca_ump_read_message, "SND_SOC_SDCA");

 /**
  * sdca_ump_write_message - write a UMP message to the device
  * @dev: Pointer to the struct device used for error messages.
  * @device_regmap: Pointer to the Device register map.
  * @function_regmap: Pointer to the regmap for the SDCA Function.
  * @function: Pointer to the Function information.
  * @entity: Pointer to the SDCA Entity.
  * @offset_sel: Control Selector for the UMP Offset Control.
  * @msg_offset: Offset within the UMP buffer at which the message should
  * be written.
  * @length_sel: Control Selector for the UMP Length Control.
  * @msg: Pointer to the data that should be written to the UMP buffer.
  * @msg_len: Length of the message data in bytes.
  *
  * The caller should first call sdca_ump_get_owner_host() to ensure the host
  * currently owns the UMP buffer, and then this function can be used to
  * write a message. Finally sdca_ump_set_owner_device() should be called to
  * return the buffer to the device, allowing the device to access the
  * message.
  *
  * Return: Returns zero on success, and a negative error code on failure.
  */
 int sdca_ump_write_message(struct device *dev,
 			   struct regmap *device_regmap,
 			   struct regmap *function_regmap,
 			   struct sdca_function_data *function,
 			   struct sdca_entity *entity,
 			   unsigned int offset_sel, unsigned int msg_offset,
 			   unsigned int length_sel,
 			   void *msg, int msg_len)
 {
 	struct sdca_control_range *range;
 	unsigned int buf_addr, buf_len, ump_mode;
 	unsigned int reg;
 	int ret;

 	range = sdca_selector_find_range(dev, entity, offset_sel,
 					 SDCA_MESSAGEOFFSET_NCOLS, 1);
 	if (!range)
 		return -ENOENT;

 	buf_addr = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_START_ADDRESS, 0);
 	buf_len = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_LENGTH, 0);
 	ump_mode = sdca_range(range, SDCA_MESSAGEOFFSET_UMP_MODE, 0);

 	if (msg_len > buf_len - msg_offset) {
 		dev_err(dev, "%s: message too big for UMP buffer: %d\n",
 			entity->label, msg_len);
 		return -EINVAL;
 	}

 	if (ump_mode != SDCA_UMP_MODE_DIRECT) {
 		dev_err(dev, "%s: only direct mode currently supported\n",
 			entity->label);
 		return -EINVAL;
 	}

 	ret = regmap_raw_write(device_regmap, buf_addr + msg_offset, msg, msg_len);
 	if (ret) {
 		dev_err(dev, "%s: failed to write UMP message: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, offset_sel, 0);
 	ret = regmap_write(function_regmap, reg, msg_offset);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to write UMP offset: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, length_sel, 0);
 	ret = regmap_write(function_regmap, reg, msg_len);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to write UMP length: %d\n",
 			entity->label, ret);
 		return ret;
 	}

 	return 0;
 }
 EXPORT_SYMBOL_NS_GPL(sdca_ump_write_message, "SND_SOC_SDCA");

 void sdca_ump_cancel_timeout(struct delayed_work *work)
 {
 	cancel_delayed_work_sync(work);
 }
 EXPORT_SYMBOL_NS_GPL(sdca_ump_cancel_timeout, "SND_SOC_SDCA");

 void sdca_ump_schedule_timeout(struct delayed_work *work, unsigned int timeout_us)
 {
 	if (!timeout_us)
 		return;

 	queue_delayed_work(system_dfl_wq, work, usecs_to_jiffies(timeout_us));
 }
 EXPORT_SYMBOL_NS_GPL(sdca_ump_schedule_timeout, "SND_SOC_SDCA");
	// SPDX-License-Identifier: GPL-2.0
	// Copyright (C) 2025 Cirrus Logic, Inc. and
	// Cirrus Logic International Semiconductor Ltd.

	/*
	* The MIPI SDCA specification is available for public downloads at
	* https://www.mipi.org/mipi-sdca-v1-0-download
	*/

	#include <linux/dev_printk.h>
	#include <linux/device.h>
	#include <linux/regmap.h>
	#include <sound/sdca.h>
	#include <sound/sdca_function.h>
	#include <sound/sdca_ump.h>
	#include <sound/soc-component.h>
	#include <linux/soundwire/sdw_registers.h>

	/**
	* sdca_ump_get_owner_host - check a UMP buffer is owned by the host
	* @dev: Pointer to the struct device used for error messages.
	* @function_regmap: Pointer to the regmap for the SDCA Function.
	* @function: Pointer to the Function information.
	* @entity: Pointer to the SDCA Entity.
	* @control: Pointer to the SDCA Control for the UMP Owner.
	*
	* Return: Returns zero on success, and a negative error code on failure.
	*/
	int sdca_ump_get_owner_host(struct device *dev,
	struct regmap *function_regmap,
	struct sdca_function_data *function,
	struct sdca_entity *entity,
	struct sdca_control *control)
	{
	unsigned int reg, owner;
	int ret;

	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, control->sel, 0);
	ret = regmap_read(function_regmap, reg, &owner);
	if (ret < 0) {
	dev_err(dev, "%s: failed to read UMP owner: %d\n",
	entity->label, ret);
	return ret;
	}

	if (owner != SDCA_UMP_OWNER_HOST) {
	dev_err(dev, "%s: host is not the UMP owner\n", entity->label);
	return -EINVAL;
	}

	return 0;
	}
	EXPORT_SYMBOL_NS_GPL(sdca_ump_get_owner_host, "SND_SOC_SDCA");

	/**
	* sdca_ump_set_owner_device - set a UMP buffer's ownership back to the device
	* @dev: Pointer to the struct device used for error messages.
	* @function_regmap: Pointer to the regmap for the SDCA Function.
	* @function: Pointer to the Function information.
	* @entity: Pointer to the SDCA Entity.
	* @control: Pointer to the SDCA Control for the UMP Owner.
	*
	* Return: Returns zero on success, and a negative error code on failure.
	*/
	int sdca_ump_set_owner_device(struct device *dev,
	struct regmap *function_regmap,
	struct sdca_function_data *function,
	struct sdca_entity *entity,
	struct sdca_control *control)
	{
	unsigned int reg;
	int ret;

	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, control->sel, 0);
	ret = regmap_write(function_regmap, reg, SDCA_UMP_OWNER_DEVICE);
	if (ret < 0)
	dev_err(dev, "%s: failed to write UMP owner: %d\n",
	entity->label, ret);

	return ret;
	}
	EXPORT_SYMBOL_NS_GPL(sdca_ump_set_owner_device, "SND_SOC_SDCA");

	/**
	* sdca_ump_read_message - read a UMP message from the device
	* @dev: Pointer to the struct device used for error messages.
	* @device_regmap: Pointer to the Device register map.
	* @function_regmap: Pointer to the regmap for the SDCA Function.
	* @function: Pointer to the Function information.
	* @entity: Pointer to the SDCA Entity.
	* @offset_sel: Control Selector for the UMP Offset Control.
	* @length_sel: Control Selector for the UMP Length Control.
	* @msg: Pointer that will be populated with an dynamically buffer
	* containing the UMP message. Note this needs to be freed by the
	* caller.
	*
	* The caller should first call sdca_ump_get_owner_host() to ensure the host
	* currently owns the UMP buffer, and then this function can be used to
	* retrieve a message. It is the callers responsibility to free the
	* message once it is finished with it. Finally sdca_ump_set_owner_device()
	* should be called to return the buffer to the device.
	*
	* Return: Returns the message length on success, and a negative error
	* code on failure.
	*/
	int sdca_ump_read_message(struct device *dev,
	struct regmap *device_regmap,
	struct regmap *function_regmap,
	struct sdca_function_data *function,
	struct sdca_entity *entity,
	unsigned int offset_sel, unsigned int length_sel,
	void **msg)
	{
	struct sdca_control_range *range;
	unsigned int msg_offset, msg_len;
	unsigned int buf_addr, buf_len;
	unsigned int reg;
	int ret;

	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, offset_sel, 0);
	ret = regmap_read(function_regmap, reg, &msg_offset);
	if (ret < 0) {
	dev_err(dev, "%s: failed to read UMP offset: %d\n",
	entity->label, ret);
	return ret;
	}

	range = sdca_selector_find_range(dev, entity, offset_sel,
	SDCA_MESSAGEOFFSET_NCOLS, 1);
	if (!range)
	return -ENOENT;

	buf_addr = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_START_ADDRESS, 0);
	buf_len = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_LENGTH, 0);

	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, length_sel, 0);
	ret = regmap_read(function_regmap, reg, &msg_len);
	if (ret < 0) {
	dev_err(dev, "%s: failed to read UMP length: %d\n",
	entity->label, ret);
	return ret;
	}

	if (msg_len > buf_len - msg_offset) {
	dev_err(dev, "%s: message too big for UMP buffer: %d\n",
	entity->label, msg_len);
	return -EINVAL;
	}

	*msg = kmalloc(msg_len, GFP_KERNEL);
	if (!*msg)
	return -ENOMEM;

	ret = regmap_raw_read(device_regmap, buf_addr + msg_offset, *msg, msg_len);
	if (ret < 0) {
	dev_err(dev, "%s: failed to read UMP message: %d\n",
	entity->label, ret);
	return ret;
	}

	return msg_len;
	}
	EXPORT_SYMBOL_NS_GPL(sdca_ump_read_message, "SND_SOC_SDCA");

	/**
	* sdca_ump_write_message - write a UMP message to the device
	* @dev: Pointer to the struct device used for error messages.
	* @device_regmap: Pointer to the Device register map.
	* @function_regmap: Pointer to the regmap for the SDCA Function.
	* @function: Pointer to the Function information.
	* @entity: Pointer to the SDCA Entity.
	* @offset_sel: Control Selector for the UMP Offset Control.
	* @msg_offset: Offset within the UMP buffer at which the message should
	* be written.
	* @length_sel: Control Selector for the UMP Length Control.
	* @msg: Pointer to the data that should be written to the UMP buffer.
	* @msg_len: Length of the message data in bytes.
	*
	* The caller should first call sdca_ump_get_owner_host() to ensure the host
	* currently owns the UMP buffer, and then this function can be used to
	* write a message. Finally sdca_ump_set_owner_device() should be called to
	* return the buffer to the device, allowing the device to access the
	* message.
	*
	* Return: Returns zero on success, and a negative error code on failure.
	*/
	int sdca_ump_write_message(struct device *dev,
	struct regmap *device_regmap,
	struct regmap *function_regmap,
	struct sdca_function_data *function,
	struct sdca_entity *entity,
	unsigned int offset_sel, unsigned int msg_offset,
	unsigned int length_sel,
	void *msg, int msg_len)
	{
	struct sdca_control_range *range;
	unsigned int buf_addr, buf_len, ump_mode;
	unsigned int reg;
	int ret;

	range = sdca_selector_find_range(dev, entity, offset_sel,
	SDCA_MESSAGEOFFSET_NCOLS, 1);
	if (!range)
	return -ENOENT;

	buf_addr = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_START_ADDRESS, 0);
	buf_len = sdca_range(range, SDCA_MESSAGEOFFSET_BUFFER_LENGTH, 0);
	ump_mode = sdca_range(range, SDCA_MESSAGEOFFSET_UMP_MODE, 0);

	if (msg_len > buf_len - msg_offset) {
	dev_err(dev, "%s: message too big for UMP buffer: %d\n",
	entity->label, msg_len);
	return -EINVAL;
	}

	if (ump_mode != SDCA_UMP_MODE_DIRECT) {
	dev_err(dev, "%s: only direct mode currently supported\n",
	entity->label);
	return -EINVAL;
	}

	ret = regmap_raw_write(device_regmap, buf_addr + msg_offset, msg, msg_len);
	if (ret) {
	dev_err(dev, "%s: failed to write UMP message: %d\n",
	entity->label, ret);
	return ret;
	}

	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, offset_sel, 0);
	ret = regmap_write(function_regmap, reg, msg_offset);
	if (ret < 0) {
	dev_err(dev, "%s: failed to write UMP offset: %d\n",
	entity->label, ret);
	return ret;
	}

	reg = SDW_SDCA_CTL(function->desc->adr, entity->id, length_sel, 0);
	ret = regmap_write(function_regmap, reg, msg_len);
	if (ret < 0) {
	dev_err(dev, "%s: failed to write UMP length: %d\n",
	entity->label, ret);
	return ret;
	}

	return 0;
	}
	EXPORT_SYMBOL_NS_GPL(sdca_ump_write_message, "SND_SOC_SDCA");

	void sdca_ump_cancel_timeout(struct delayed_work *work)
	{
	cancel_delayed_work_sync(work);
	}
	EXPORT_SYMBOL_NS_GPL(sdca_ump_cancel_timeout, "SND_SOC_SDCA");

	void sdca_ump_schedule_timeout(struct delayed_work *work, unsigned int timeout_us)
	{
	if (!timeout_us)
	return;

	queue_delayed_work(system_dfl_wq, work, usecs_to_jiffies(timeout_us));
	}
	EXPORT_SYMBOL_NS_GPL(sdca_ump_schedule_timeout, "SND_SOC_SDCA");