239 lines
7.1 KiB
C
239 lines
7.1 KiB
C
/*
|
|
* sound\soc\sunxi\snd_sunxi_rxsync.c
|
|
* (C) Copyright 2021-2025
|
|
* AllWinner Technology Co., Ltd. <www.allwinnertech.com>
|
|
* caiyongheng <caiyongheng@allwinnertech.com>
|
|
* Dby <dby@allwinnertech.com>
|
|
*
|
|
* 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 (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <sound/core.h>
|
|
#include <sound/pcm.h>
|
|
#include <sound/soc.h>
|
|
|
|
#include "snd_sunxi_log.h"
|
|
#include "snd_sunxi_rxsync.h"
|
|
|
|
#define HLOG "RXSYNC"
|
|
|
|
#define RX_SYNC_DEV_MAX 8
|
|
|
|
typedef void (*enable_func)(void *data, bool enable);
|
|
|
|
typedef struct {
|
|
void *data;
|
|
/*enable_func route_enable;*/
|
|
enable_func rx_enable;
|
|
} rx_sync_dev_t;
|
|
|
|
static struct {
|
|
int total_count[RX_SYNC_DOMAIN_CNT];
|
|
int enabled_count[RX_SYNC_DOMAIN_CNT];
|
|
rx_sync_dev_t dev[RX_SYNC_DOMAIN_CNT][RX_SYNC_DEV_MAX];
|
|
rx_sync_dev_t *last_enabled_dev[RX_SYNC_DOMAIN_CNT];
|
|
} rx_sync_data;
|
|
|
|
DEFINE_SPINLOCK(rx_sync_lock);
|
|
|
|
/* Return the rx_sync id. The id is unique in its own domain. */
|
|
int sunxi_rx_sync_probe(rx_sync_domain_t domain)
|
|
{
|
|
int ret = 0;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&rx_sync_lock, flags);
|
|
rx_sync_data.total_count[domain]++;
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, total_count=%d\n",
|
|
domain, rx_sync_data.total_count[domain]);
|
|
if (rx_sync_data.total_count[domain] > RX_SYNC_DEV_MAX) {
|
|
SND_LOG_ERR(HLOG, "domain=%d, too many rx_sync devices "
|
|
"(current=%d, max=%d)\n", domain,
|
|
rx_sync_data.total_count[domain], RX_SYNC_DEV_MAX);
|
|
ret = -EINVAL;
|
|
goto unlock;
|
|
}
|
|
/* use total_count to define rx_sync id */
|
|
ret = rx_sync_data.total_count[domain] - 1;
|
|
unlock:
|
|
spin_unlock_irqrestore(&rx_sync_lock, flags);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(sunxi_rx_sync_probe);
|
|
|
|
void sunxi_rx_sync_remove(rx_sync_domain_t domain)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&rx_sync_lock, flags);
|
|
rx_sync_data.total_count[domain]--;
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, total_count=%d\n",
|
|
domain, rx_sync_data.total_count[domain]);
|
|
if (rx_sync_data.total_count[domain] < 0)
|
|
rx_sync_data.total_count[domain] = 0;
|
|
spin_unlock_irqrestore(&rx_sync_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(sunxi_rx_sync_remove);
|
|
|
|
void sunxi_rx_sync_startup(void *data, rx_sync_domain_t domain, int id,
|
|
void (*rx_enable)(void *data, bool enable))
|
|
{
|
|
unsigned long flags;
|
|
|
|
if (id < 0 || id >= RX_SYNC_DEV_MAX) {
|
|
SND_LOG_ERR(HLOG, "unsupport rx sync id\n");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&rx_sync_lock, flags);
|
|
rx_sync_data.dev[domain][id].data = data;
|
|
rx_sync_data.dev[domain][id].rx_enable = rx_enable;
|
|
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, id=%d\n", domain, id);
|
|
spin_unlock_irqrestore(&rx_sync_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(sunxi_rx_sync_startup);
|
|
|
|
void sunxi_rx_sync_shutdown(rx_sync_domain_t domain, int id)
|
|
{
|
|
unsigned long flags;
|
|
int i;
|
|
int enabled_count = 0;
|
|
|
|
if (id < 0 || id >= RX_SYNC_DEV_MAX) {
|
|
SND_LOG_ERR(HLOG, "unsupport rx sync id\n");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&rx_sync_lock, flags);
|
|
SND_LOG_DEBUG(HLOG, "domian=%d, id=%d, enabled_count=%d\n",
|
|
domain, id, rx_sync_data.enabled_count[domain]);
|
|
|
|
/* ensure that only if all devices in all domains have been disabled,
|
|
* the rx_sync_data could be reset.
|
|
*/
|
|
for (i = 0; i < RX_SYNC_DOMAIN_CNT; i++)
|
|
enabled_count += rx_sync_data.enabled_count[i];
|
|
if (enabled_count > 0)
|
|
goto unlock;
|
|
SND_LOG_DEBUG(HLOG, "domian=%d, id=%d, sum of enabled_count is %d, "
|
|
"reset rx_sync_data\n", domain, id, enabled_count);
|
|
memset(rx_sync_data.dev, 0, sizeof(rx_sync_dev_t) * RX_SYNC_DOMAIN_CNT * RX_SYNC_DEV_MAX);
|
|
for (i = 0; i < RX_SYNC_DOMAIN_CNT; i++)
|
|
rx_sync_data.last_enabled_dev[i] = NULL;
|
|
|
|
unlock:
|
|
spin_unlock_irqrestore(&rx_sync_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(sunxi_rx_sync_shutdown);
|
|
|
|
void sunxi_rx_sync_control(rx_sync_domain_t domain, int id, bool enable)
|
|
{
|
|
unsigned long flags;
|
|
int i;
|
|
int total_count = 0;
|
|
int enabled_count = 0;
|
|
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, id=%d, enable=%d, enabled_count=%d\n",
|
|
domain, id, enable, rx_sync_data.enabled_count[domain]);
|
|
if (id < 0 || id >= RX_SYNC_DEV_MAX) {
|
|
SND_LOG_ERR(HLOG, "unsupport rx sync id\n");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&rx_sync_lock, flags);
|
|
if (enable) {
|
|
rx_sync_data.enabled_count[domain]++;
|
|
/* store the pointer of last enabled device. */
|
|
if (rx_sync_data.enabled_count[domain] == \
|
|
rx_sync_data.total_count[domain]) {
|
|
rx_sync_data.last_enabled_dev[domain] = \
|
|
&rx_sync_data.dev[domain][id];
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, id=%d, "
|
|
"last_enabled_dev=0x%p\n", domain, id,
|
|
rx_sync_data.last_enabled_dev[domain]);
|
|
} else if (rx_sync_data.enabled_count[domain] > \
|
|
rx_sync_data.total_count[domain]) {
|
|
SND_LOG_ERR(HLOG, "domain=%d, enabled_count(%d) "
|
|
"is more than total_count(%d). "
|
|
"%s was called incorrectly?\n",
|
|
domain, rx_sync_data.enabled_count[domain],
|
|
rx_sync_data.total_count[domain], __func__);
|
|
goto unlock;
|
|
}
|
|
|
|
/* Check all devices in all domains. Only if the last device in
|
|
* all domains runs here, we will run rx_enable(1) in only
|
|
* the last device in each domain.
|
|
*/
|
|
for (i = 0; i < RX_SYNC_DOMAIN_CNT; i++) {
|
|
total_count += rx_sync_data.total_count[i];
|
|
enabled_count += rx_sync_data.enabled_count[i];
|
|
}
|
|
if (enabled_count < total_count) {
|
|
goto unlock;
|
|
} else if (enabled_count > total_count) {
|
|
SND_LOG_ERR(HLOG, "sum of enabled_count(%d) is "
|
|
"more than total_count(%d). "
|
|
"%s was called incorrectly?\n",
|
|
enabled_count, total_count, __func__);
|
|
goto unlock;
|
|
}
|
|
for (i = 0; i < RX_SYNC_DOMAIN_CNT; i++) {
|
|
rx_sync_dev_t *dev = rx_sync_data.last_enabled_dev[i];
|
|
if (!dev)
|
|
continue;
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, rx enable\n", i);
|
|
dev->rx_enable(dev->data, 1);
|
|
}
|
|
} else {
|
|
rx_sync_data.enabled_count[domain]--;
|
|
|
|
if (rx_sync_data.enabled_count[domain] > 0) {
|
|
goto unlock;
|
|
} else if (rx_sync_data.enabled_count[domain] < 0) {
|
|
SND_LOG_ERR(HLOG, "domain=%d, enabled_count(%d) is "
|
|
"less than 0. %s was called incorrectly?\n",
|
|
domain, rx_sync_data.enabled_count[domain],
|
|
__func__);
|
|
goto unlock;
|
|
}
|
|
|
|
/* Check all devices in all domains. Only if the last device in
|
|
* all domains runs here, we will run rx_enable(0) in only
|
|
* the last device in each domain.
|
|
*/
|
|
for (i = 0; i < RX_SYNC_DOMAIN_CNT; i++) {
|
|
enabled_count += rx_sync_data.enabled_count[i];
|
|
}
|
|
if (enabled_count > 0) {
|
|
goto unlock;
|
|
} else if (enabled_count < 0) {
|
|
SND_LOG_ERR(HLOG, "sum of enabled_count(%d) is "
|
|
"less than 0.%s was called incorrectly?\n",
|
|
enabled_count, __func__);
|
|
goto unlock;
|
|
}
|
|
for (i = 0; i < RX_SYNC_DOMAIN_CNT; i++) {
|
|
rx_sync_dev_t *dev = rx_sync_data.last_enabled_dev[i];
|
|
if (!dev)
|
|
continue;
|
|
SND_LOG_DEBUG(HLOG, "domain=%d, rx disable\n", i);
|
|
dev->rx_enable(dev->data, 0);
|
|
}
|
|
}
|
|
unlock:
|
|
spin_unlock_irqrestore(&rx_sync_lock, flags);
|
|
return;
|
|
}
|
|
EXPORT_SYMBOL(sunxi_rx_sync_control);
|
|
|
|
MODULE_AUTHOR("Dby@allwinnertech.com");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("sunxi rx sync compontens");
|