// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2022-2025 Qualcomm Innovation Center, Inc. All rights reserved.
 */
#include <linux/of.h>
#include <linux/usb.h>

#include <sound/jack.h>
#include <sound/soc-usb.h>

#include "../usb/card.h"

static DEFINE_MUTEX(ctx_mutex);
static LIST_HEAD(usb_ctx_list);

static struct device_node *snd_soc_find_phandle(struct device *dev)
{
 struct device_node *node;

 node = of_parse_phandle(dev->of_node, "usb-soc-be", 0);
 if (!node)
  return ERR_PTR(-ENODEV);

 return node;
}

static struct snd_soc_usb *snd_soc_usb_ctx_lookup(struct device_node *node)
{
 struct snd_soc_usb *ctx;

 if (!node)
  return NULL;

 list_for_each_entry(ctx, &usb_ctx_list, list) {
  if (ctx->component->dev->of_node == node)
   return ctx;
 }

 return NULL;
}

static struct snd_soc_usb *snd_soc_find_usb_ctx(struct device *dev)
{
 struct snd_soc_usb *ctx;
 struct device_node *node;

 node = snd_soc_find_phandle(dev);
 if (!IS_ERR(node)) {
  ctx = snd_soc_usb_ctx_lookup(node);
  of_node_put(node);
 } else {
  ctx = snd_soc_usb_ctx_lookup(dev->of_node);
 }

 return ctx ? ctx : NULL;
}

/* SOC USB sound kcontrols */
/**
 * snd_soc_usb_setup_offload_jack() - Create USB offloading jack
 * @component: USB DPCM backend DAI component
 * @jack: jack structure to create
 *
 * Creates a jack device for notifying userspace of the availability
 * of an offload capable device.
 *
 * Returns 0 on success, negative on error.
 *
 */
int snd_soc_usb_setup_offload_jack(struct snd_soc_component *component,
       struct snd_soc_jack *jack)
{
 int ret;

 ret = snd_soc_card_jack_new(component->card, "USB Offload Jack",
        SND_JACK_USB, jack);
 if (ret < 0) {
  dev_err(component->card->dev, "Unable to add USB offload jack: %d\n",
   ret);
  return ret;
 }

 ret = snd_soc_component_set_jack(component, jack, NULL);
 if (ret) {
  dev_err(component->card->dev, "Failed to set jack: %d\n", ret);
  return ret;
 }

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_setup_offload_jack);

/**
 * snd_soc_usb_update_offload_route - Find active USB offload path
 * @dev: USB device to get offload status
 * @card: USB card index
 * @pcm: USB PCM device index
 * @direction: playback or capture direction
 * @path: pcm or card index
 * @route: pointer to route output array
 *
 * Fetch the current status for the USB SND card and PCM device indexes
 * specified.  The "route" argument should be an array of integers being
 * used for a kcontrol output.  The first element should have the selected
 * card index, and the second element should have the selected pcm device
 * index.
 */
int snd_soc_usb_update_offload_route(struct device *dev, int card, int pcm,
         int direction, enum snd_soc_usb_kctl path,
         long *route)
{
 struct snd_soc_usb *ctx;
 int ret = -ENODEV;

 mutex_lock(&ctx_mutex);
 ctx = snd_soc_find_usb_ctx(dev);
 if (!ctx)
  goto exit;

 if (ctx->update_offload_route_info)
  ret = ctx->update_offload_route_info(ctx->component, card, pcm,
           direction, path, route);
exit:
 mutex_unlock(&ctx_mutex);

 return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_update_offload_route);

/**
 * snd_soc_usb_find_priv_data() - Retrieve private data stored
 * @usbdev: device reference
 *
 * Fetch the private data stored in the USB SND SoC structure.
 *
 */
void *snd_soc_usb_find_priv_data(struct device *usbdev)
{
 struct snd_soc_usb *ctx;

 mutex_lock(&ctx_mutex);
 ctx = snd_soc_find_usb_ctx(usbdev);
 mutex_unlock(&ctx_mutex);

 return ctx ? ctx->priv_data : NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_find_priv_data);

/**
 * snd_soc_usb_find_supported_format() - Check if audio format is supported
 * @card_idx: USB sound chip array index
 * @params: PCM parameters
 * @direction: capture or playback
 *
 * Ensure that a requested audio profile from the ASoC side is able to be
 * supported by the USB device.
 *
 * Return 0 on success, negative on error.
 *
 */
int snd_soc_usb_find_supported_format(int card_idx,
          struct snd_pcm_hw_params *params,
          int direction)
{
 struct snd_usb_stream *as;

 as = snd_usb_find_suppported_substream(card_idx, params, direction);
 if (!as)
  return -EOPNOTSUPP;

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_find_supported_format);

/**
 * snd_soc_usb_allocate_port() - allocate a SoC USB port for offloading support
 * @component: USB DPCM backend DAI component
 * @data: private data
 *
 * Allocate and initialize a SoC USB port.  The SoC USB port is used to communicate
 * different USB audio devices attached, in order to start audio offloading handled
 * by an ASoC entity.  USB device plug in/out events are signaled with a
 * notification, but don't directly impact the memory allocated for the SoC USB
 * port.
 *
 */
struct snd_soc_usb *snd_soc_usb_allocate_port(struct snd_soc_component *component,
           void *data)
{
 struct snd_soc_usb *usb;

 usb = kzalloc(sizeof(*usb), GFP_KERNEL);
 if (!usb)
  return ERR_PTR(-ENOMEM);

 usb->component = component;
 usb->priv_data = data;

 return usb;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_allocate_port);

/**
 * snd_soc_usb_free_port() - free a SoC USB port used for offloading support
 * @usb: allocated SoC USB port
 *
 * Free and remove the SoC USB port from the available list of ports.  This will
 * ensure that the communication between USB SND and ASoC is halted.
 *
 */
void snd_soc_usb_free_port(struct snd_soc_usb *usb)
{
 snd_soc_usb_remove_port(usb);
 kfree(usb);
}
EXPORT_SYMBOL_GPL(snd_soc_usb_free_port);

/**
 * snd_soc_usb_add_port() - Add a USB backend port
 * @usb: soc usb port to add
 *
 * Register a USB backend DAI link to the USB SoC framework.  Memory is allocated
 * as part of the USB backend DAI link.
 *
 */
void snd_soc_usb_add_port(struct snd_soc_usb *usb)
{
 mutex_lock(&ctx_mutex);
 list_add_tail(&usb->list, &usb_ctx_list);
 mutex_unlock(&ctx_mutex);

 snd_usb_rediscover_devices();
}
EXPORT_SYMBOL_GPL(snd_soc_usb_add_port);

/**
 * snd_soc_usb_remove_port() - Remove a USB backend port
 * @usb: soc usb port to remove
 *
 * Remove a USB backend DAI link from USB SoC.  Memory is freed when USB backend
 * DAI is removed, or when snd_soc_usb_free_port() is called.
 *
 */
void snd_soc_usb_remove_port(struct snd_soc_usb *usb)
{
 struct snd_soc_usb *ctx, *tmp;

 mutex_lock(&ctx_mutex);
 list_for_each_entry_safe(ctx, tmp, &usb_ctx_list, list) {
  if (ctx == usb) {
   list_del(&ctx->list);
   break;
  }
 }
 mutex_unlock(&ctx_mutex);
}
EXPORT_SYMBOL_GPL(snd_soc_usb_remove_port);

/**
 * snd_soc_usb_connect() - Notification of USB device connection
 * @usbdev: USB bus device
 * @sdev: USB SND device to add
 *
 * Notify of a new USB SND device connection.  The sdev->card_idx can be used to
 * handle how the DPCM backend selects, which device to enable USB offloading
 * on.
 *
 */
int snd_soc_usb_connect(struct device *usbdev, struct snd_soc_usb_device *sdev)
{
 struct snd_soc_usb *ctx;

 if (!usbdev)
  return -ENODEV;

 mutex_lock(&ctx_mutex);
 ctx = snd_soc_find_usb_ctx(usbdev);
 if (!ctx)
  goto exit;

 if (ctx->connection_status_cb)
  ctx->connection_status_cb(ctx, sdev, true);

exit:
 mutex_unlock(&ctx_mutex);

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_connect);

/**
 * snd_soc_usb_disconnect() - Notification of USB device disconnection
 * @usbdev: USB bus device
 * @sdev: USB SND device to remove
 *
 * Notify of a new USB SND device disconnection to the USB backend.
 *
 */
int snd_soc_usb_disconnect(struct device *usbdev, struct snd_soc_usb_device *sdev)
{
 struct snd_soc_usb *ctx;

 if (!usbdev)
  return -ENODEV;

 mutex_lock(&ctx_mutex);
 ctx = snd_soc_find_usb_ctx(usbdev);
 if (!ctx)
  goto exit;

 if (ctx->connection_status_cb)
  ctx->connection_status_cb(ctx, sdev, false);

exit:
 mutex_unlock(&ctx_mutex);

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_usb_disconnect);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SoC USB driver for offloading");