linux/sound/soc/codecs/wcd939x-sdw.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2023, Linaro Limited
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/component.h>
#include <linux/pm_runtime.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/of.h>
#include <linux/soundwire/sdw.h>
#include <linux/soundwire/sdw_type.h>
#include <linux/soundwire/sdw_registers.h>
#include <linux/regmap.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include "wcd939x.h"

#define SWRS_SCP_HOST_CLK_DIV2_CTL_BANK(m) …

static const struct wcd939x_sdw_ch_info wcd939x_sdw_rx_ch_info[] = …;

static const struct wcd939x_sdw_ch_info wcd939x_sdw_tx_ch_info[] = …;

static struct sdw_dpn_prop wcd939x_rx_dpn_prop[WCD939X_MAX_RX_SWR_PORTS] = …;

static struct sdw_dpn_prop wcd939x_tx_dpn_prop[WCD939X_MAX_TX_SWR_PORTS] = …;

struct device *wcd939x_sdw_device_get(struct device_node *np)
{ … }
EXPORT_SYMBOL_GPL(…);

unsigned int wcd939x_swr_get_current_bank(struct sdw_slave *sdev)
{ … }
EXPORT_SYMBOL_GPL(…);

int wcd939x_sdw_hw_params(struct wcd939x_sdw_priv *wcd,
			  struct snd_pcm_substream *substream,
			  struct snd_pcm_hw_params *params,
			  struct snd_soc_dai *dai)
{ … }
EXPORT_SYMBOL_GPL(…);

int wcd939x_sdw_free(struct wcd939x_sdw_priv *wcd,
		     struct snd_pcm_substream *substream,
		     struct snd_soc_dai *dai)
{ … }
EXPORT_SYMBOL_GPL(…);

int wcd939x_sdw_set_sdw_stream(struct wcd939x_sdw_priv *wcd,
			       struct snd_soc_dai *dai, void *stream,
			       int direction)
{ … }
EXPORT_SYMBOL_GPL(…);

struct regmap *wcd939x_swr_get_regmap(struct wcd939x_sdw_priv *wcd)
{ … }
EXPORT_SYMBOL_GPL(…);

static int wcd9390_update_status(struct sdw_slave *slave,
				 enum sdw_slave_status status)
{ … }

static int wcd9390_bus_config(struct sdw_slave *slave,
			      struct sdw_bus_params *params)
{ … }

/*
 * Handle Soundwire out-of-band interrupt event by triggering
 * the first irq of the slave_irq irq domain, which then will
 * be handled by the regmap_irq threaded irq.
 * Looping is to ensure no interrupts were missed in the process.
 */
static int wcd9390_interrupt_callback(struct sdw_slave *slave,
				      struct sdw_slave_intr_status *status)
{ … }

static const struct reg_default wcd939x_defaults[] = …;

static bool wcd939x_rdwr_register(struct device *dev, unsigned int reg)
{ … }

static bool wcd939x_readable_register(struct device *dev, unsigned int reg)
{ … }

static bool wcd939x_volatile_register(struct device *dev, unsigned int reg)
{ … }

static bool wcd939x_writeable_register(struct device *dev, unsigned int reg)
{ … }

static const struct regmap_config wcd939x_regmap_config = …;

static const struct sdw_slave_ops wcd9390_slave_ops = …;

static int wcd939x_sdw_component_bind(struct device *dev, struct device *master,
				      void *data)
{ … }

static void wcd939x_sdw_component_unbind(struct device *dev,
					 struct device *master, void *data)
{ … }

static const struct component_ops wcd939x_sdw_component_ops = …;

static int wcd9390_probe(struct sdw_slave *pdev, const struct sdw_device_id *id)
{ … }

static int wcd9390_remove(struct sdw_slave *pdev)
{ … }

static const struct sdw_device_id wcd9390_slave_id[] = …;
MODULE_DEVICE_TABLE(sdw, wcd9390_slave_id);

static int __maybe_unused wcd939x_sdw_runtime_suspend(struct device *dev)
{ … }

static int __maybe_unused wcd939x_sdw_runtime_resume(struct device *dev)
{ … }

static const struct dev_pm_ops wcd939x_sdw_pm_ops = …;

static struct sdw_driver wcd9390_codec_driver = …;
module_sdw_driver(…) …;

MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;