2008-07-26 23:56:38 +00:00
|
|
|
/*
|
|
|
|
* Audio crossconnecting/conferrencing (hardware level).
|
|
|
|
*
|
|
|
|
* Copyright 2002 by Andreas Eversberg (jolly@eversberg.eu)
|
|
|
|
*
|
|
|
|
* This software may be used and distributed according to the terms
|
|
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The process of adding and removing parties to/from a conference:
|
|
|
|
*
|
|
|
|
* There is a chain of struct dsp_conf which has one or more members in a chain
|
|
|
|
* of struct dsp_conf_member.
|
|
|
|
*
|
|
|
|
* After a party is added, the conference is checked for hardware capability.
|
|
|
|
* Also if a party is removed, the conference is checked again.
|
|
|
|
*
|
|
|
|
* There are 3 different solutions: -1 = software, 0 = hardware-crossconnect
|
|
|
|
* 1-n = hardware-conference. The n will give the conference number.
|
|
|
|
*
|
|
|
|
* Depending on the change after removal or insertion of a party, hardware
|
|
|
|
* commands are given.
|
|
|
|
*
|
|
|
|
* The current solution is stored within the struct dsp_conf entry.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HOW THE CMX WORKS:
|
|
|
|
*
|
|
|
|
* There are 3 types of interaction: One member is alone, in this case only
|
|
|
|
* data flow from upper to lower layer is done.
|
|
|
|
* Two members will also exchange their data so they are crossconnected.
|
|
|
|
* Three or more members will be added in a conference and will hear each
|
|
|
|
* other but will not receive their own speech (echo) if not enabled.
|
|
|
|
*
|
|
|
|
* Features of CMX are:
|
|
|
|
* - Crossconnecting or even conference, if more than two members are together.
|
|
|
|
* - Force mixing of transmit data with other crossconnect/conference members.
|
|
|
|
* - Echo generation to benchmark the delay of audio processing.
|
|
|
|
* - Use hardware to minimize cpu load, disable FIFO load and minimize delay.
|
|
|
|
* - Dejittering and clock generation.
|
|
|
|
*
|
|
|
|
* There are 2 buffers:
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* RX-Buffer
|
|
|
|
* R W
|
|
|
|
* | |
|
|
|
|
* ----------------+-------------+-------------------
|
|
|
|
*
|
|
|
|
* The rx-buffer is a ring buffer used to store the received data for each
|
|
|
|
* individual member. This is only the case if data needs to be dejittered
|
|
|
|
* or in case of a conference where different clocks require reclocking.
|
|
|
|
* The transmit-clock (R) will read the buffer.
|
|
|
|
* If the clock overruns the write-pointer, we will have a buffer underrun.
|
|
|
|
* If the write pointer always has a certain distance from the transmit-
|
|
|
|
* clock, we will have a delay. The delay will dynamically be increased and
|
|
|
|
* reduced.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* TX-Buffer
|
|
|
|
* R W
|
|
|
|
* | |
|
|
|
|
* -----------------+--------+-----------------------
|
|
|
|
*
|
|
|
|
* The tx-buffer is a ring buffer to queue the transmit data from user space
|
|
|
|
* until it will be mixed or sent. There are two pointers, R and W. If the write
|
|
|
|
* pointer W would reach or overrun R, the buffer would overrun. In this case
|
|
|
|
* (some) data is dropped so that it will not overrun.
|
|
|
|
* Additionally a dynamic dejittering can be enabled. this allows data from
|
|
|
|
* user space that have jitter and different clock source.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Clock:
|
|
|
|
*
|
|
|
|
* A Clock is not required, if the data source has exactly one clock. In this
|
|
|
|
* case the data source is forwarded to the destination.
|
|
|
|
*
|
|
|
|
* A Clock is required, because the data source
|
|
|
|
* - has multiple clocks.
|
|
|
|
* - has no usable clock due to jitter or packet loss (VoIP).
|
|
|
|
* In this case the system's clock is used. The clock resolution depends on
|
|
|
|
* the jiffie resolution.
|
|
|
|
*
|
|
|
|
* If a member joins a conference:
|
|
|
|
*
|
|
|
|
* - If a member joins, its rx_buff is set to silence and change read pointer
|
|
|
|
* to transmit clock.
|
|
|
|
*
|
|
|
|
* The procedure of received data from card is explained in cmx_receive.
|
|
|
|
* The procedure of received data from user space is explained in cmx_transmit.
|
|
|
|
* The procedure of transmit data to card is cmx_send.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Interaction with other features:
|
|
|
|
*
|
|
|
|
* DTMF:
|
|
|
|
* DTMF decoding is done before the data is crossconnected.
|
|
|
|
*
|
|
|
|
* Volume change:
|
|
|
|
* Changing rx-volume is done before the data is crossconnected. The tx-volume
|
|
|
|
* must be changed whenever data is transmitted to the card by the cmx.
|
|
|
|
*
|
|
|
|
* Tones:
|
|
|
|
* If a tone is enabled, it will be processed whenever data is transmitted to
|
|
|
|
* the card. It will replace the tx-data from the user space.
|
|
|
|
* If tones are generated by hardware, this conference member is removed for
|
|
|
|
* this time.
|
|
|
|
*
|
|
|
|
* Disable rx-data:
|
|
|
|
* If cmx is realized in hardware, rx data will be disabled if requested by
|
|
|
|
* the upper layer. If dtmf decoding is done by software and enabled, rx data
|
2010-12-30 23:07:58 +00:00
|
|
|
* will not be disabled but blocked to the upper layer.
|
2008-07-26 23:56:38 +00:00
|
|
|
*
|
|
|
|
* HFC conference engine:
|
|
|
|
* If it is possible to realize all features using hardware, hardware will be
|
|
|
|
* used if not forbidden by control command. Disabling rx-data provides
|
|
|
|
* absolutely traffic free audio processing. (except for the quick 1-frame
|
|
|
|
* upload of a tone loop, only once for a new tone)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* delay.h is required for hw_lock.h */
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-07-26 23:56:38 +00:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/mISDNif.h>
|
|
|
|
#include <linux/mISDNdsp.h>
|
|
|
|
#include "core.h"
|
|
|
|
#include "dsp.h"
|
|
|
|
/*
|
|
|
|
* debugging of multi party conference,
|
|
|
|
* by using conference even with two members
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* #define CMX_CONF_DEBUG */
|
|
|
|
|
|
|
|
/*#define CMX_DEBUG * massive read/write pointer output */
|
2008-09-28 11:01:01 +00:00
|
|
|
/*#define CMX_DELAY_DEBUG * gives rx-buffer delay overview */
|
2008-07-26 23:56:38 +00:00
|
|
|
/*#define CMX_TX_DEBUG * massive read/write on tx-buffer with content */
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
count_list_member(struct list_head *head)
|
|
|
|
{
|
|
|
|
int cnt = 0;
|
|
|
|
struct list_head *m;
|
|
|
|
|
|
|
|
list_for_each(m, head)
|
|
|
|
cnt++;
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* debug cmx memory structure
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dsp_cmx_debug(struct dsp *dsp)
|
|
|
|
{
|
|
|
|
struct dsp_conf *conf;
|
|
|
|
struct dsp_conf_member *member;
|
|
|
|
struct dsp *odsp;
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "-----Current DSP\n");
|
|
|
|
list_for_each_entry(odsp, &dsp_ilist, list) {
|
2009-05-22 11:04:49 +00:00
|
|
|
printk(KERN_DEBUG "* %s hardecho=%d softecho=%d txmix=%d",
|
2012-02-20 03:52:38 +00:00
|
|
|
odsp->name, odsp->echo.hardware, odsp->echo.software,
|
|
|
|
odsp->tx_mix);
|
2008-07-26 23:56:38 +00:00
|
|
|
if (odsp->conf)
|
|
|
|
printk(" (Conf %d)", odsp->conf->id);
|
|
|
|
if (dsp == odsp)
|
|
|
|
printk(" *this*");
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
printk(KERN_DEBUG "-----Current Conf:\n");
|
|
|
|
list_for_each_entry(conf, &conf_ilist, list) {
|
|
|
|
printk(KERN_DEBUG "* Conf %d (%p)\n", conf->id, conf);
|
|
|
|
list_for_each_entry(member, &conf->mlist, list) {
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
" - member = %s (slot_tx %d, bank_tx %d, "
|
|
|
|
"slot_rx %d, bank_rx %d hfc_conf %d "
|
|
|
|
"tx_data %d rx_is_off %d)%s\n",
|
|
|
|
member->dsp->name, member->dsp->pcm_slot_tx,
|
|
|
|
member->dsp->pcm_bank_tx, member->dsp->pcm_slot_rx,
|
|
|
|
member->dsp->pcm_bank_rx, member->dsp->hfc_conf,
|
|
|
|
member->dsp->tx_data, member->dsp->rx_is_off,
|
|
|
|
(member->dsp == dsp) ? " *this*" : "");
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
printk(KERN_DEBUG "-----end\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* search conference
|
|
|
|
*/
|
|
|
|
static struct dsp_conf *
|
|
|
|
dsp_cmx_search_conf(u32 id)
|
|
|
|
{
|
|
|
|
struct dsp_conf *conf;
|
|
|
|
|
|
|
|
if (!id) {
|
|
|
|
printk(KERN_WARNING "%s: conference ID is 0.\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* search conference */
|
|
|
|
list_for_each_entry(conf, &conf_ilist, list)
|
|
|
|
if (conf->id == id)
|
|
|
|
return conf;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add member to conference
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
dsp_cmx_add_conf_member(struct dsp *dsp, struct dsp_conf *conf)
|
|
|
|
{
|
|
|
|
struct dsp_conf_member *member;
|
|
|
|
|
|
|
|
if (!conf || !dsp) {
|
|
|
|
printk(KERN_WARNING "%s: conf or dsp is 0.\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (dsp->member) {
|
|
|
|
printk(KERN_WARNING "%s: dsp is already member in a conf.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dsp->conf) {
|
|
|
|
printk(KERN_WARNING "%s: dsp is already in a conf.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
member = kzalloc(sizeof(struct dsp_conf_member), GFP_ATOMIC);
|
|
|
|
if (!member) {
|
2009-05-22 11:04:56 +00:00
|
|
|
printk(KERN_ERR "kzalloc struct dsp_conf_member failed\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
member->dsp = dsp;
|
|
|
|
/* clear rx buffer */
|
|
|
|
memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
|
|
|
|
dsp->rx_init = 1; /* rx_W and rx_R will be adjusted on first frame */
|
|
|
|
dsp->rx_W = 0;
|
|
|
|
dsp->rx_R = 0;
|
|
|
|
|
|
|
|
list_add_tail(&member->list, &conf->mlist);
|
|
|
|
|
|
|
|
dsp->conf = conf;
|
|
|
|
dsp->member = member;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* del member from conference
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
dsp_cmx_del_conf_member(struct dsp *dsp)
|
|
|
|
{
|
|
|
|
struct dsp_conf_member *member;
|
|
|
|
|
|
|
|
if (!dsp) {
|
|
|
|
printk(KERN_WARNING "%s: dsp is 0.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dsp->conf) {
|
|
|
|
printk(KERN_WARNING "%s: dsp is not in a conf.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (list_empty(&dsp->conf->mlist)) {
|
|
|
|
printk(KERN_WARNING "%s: dsp has linked an empty conf.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find us in conf */
|
|
|
|
list_for_each_entry(member, &dsp->conf->mlist, list) {
|
|
|
|
if (member->dsp == dsp) {
|
|
|
|
list_del(&member->list);
|
|
|
|
dsp->conf = NULL;
|
|
|
|
dsp->member = NULL;
|
|
|
|
kfree(member);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printk(KERN_WARNING
|
2015-02-27 14:52:31 +00:00
|
|
|
"%s: dsp is not present in its own conf_member list.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* new conference
|
|
|
|
*/
|
|
|
|
static struct dsp_conf
|
|
|
|
*dsp_cmx_new_conf(u32 id)
|
|
|
|
{
|
|
|
|
struct dsp_conf *conf;
|
|
|
|
|
|
|
|
if (!id) {
|
|
|
|
printk(KERN_WARNING "%s: id is 0.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
conf = kzalloc(sizeof(struct dsp_conf), GFP_ATOMIC);
|
|
|
|
if (!conf) {
|
2009-05-22 11:04:56 +00:00
|
|
|
printk(KERN_ERR "kzalloc struct dsp_conf failed\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
INIT_LIST_HEAD(&conf->mlist);
|
|
|
|
conf->id = id;
|
|
|
|
|
|
|
|
list_add_tail(&conf->list, &conf_ilist);
|
|
|
|
|
|
|
|
return conf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* del conference
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
dsp_cmx_del_conf(struct dsp_conf *conf)
|
|
|
|
{
|
|
|
|
if (!conf) {
|
|
|
|
printk(KERN_WARNING "%s: conf is null.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!list_empty(&conf->mlist)) {
|
|
|
|
printk(KERN_WARNING "%s: conf not empty.\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
list_del(&conf->list);
|
|
|
|
kfree(conf);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* send HW message to hfc card
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dsp_cmx_hw_message(struct dsp *dsp, u32 message, u32 param1, u32 param2,
|
2012-02-20 03:52:38 +00:00
|
|
|
u32 param3, u32 param4)
|
2008-07-26 23:56:38 +00:00
|
|
|
{
|
|
|
|
struct mISDN_ctrl_req cq;
|
|
|
|
|
|
|
|
memset(&cq, 0, sizeof(cq));
|
|
|
|
cq.op = message;
|
|
|
|
cq.p1 = param1 | (param2 << 8);
|
|
|
|
cq.p2 = param3 | (param4 << 8);
|
|
|
|
if (dsp->ch.peer)
|
|
|
|
dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* do hardware update and set the software/hardware flag
|
|
|
|
*
|
|
|
|
* either a conference or a dsp instance can be given
|
|
|
|
* if only dsp instance is given, the instance is not associated with a conf
|
|
|
|
* and therefore removed. if a conference is given, the dsp is expected to
|
|
|
|
* be member of that conference.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dsp_cmx_hardware(struct dsp_conf *conf, struct dsp *dsp)
|
|
|
|
{
|
|
|
|
struct dsp_conf_member *member, *nextm;
|
|
|
|
struct dsp *finddsp;
|
|
|
|
int memb = 0, i, ii, i1, i2;
|
|
|
|
int freeunits[8];
|
|
|
|
u_char freeslots[256];
|
|
|
|
int same_hfc = -1, same_pcm = -1, current_conf = -1,
|
2012-02-20 03:52:38 +00:00
|
|
|
all_conf = 1, tx_data = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/* dsp gets updated (no conf) */
|
|
|
|
if (!conf) {
|
|
|
|
if (!dsp)
|
|
|
|
return;
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "%s checking dsp %s\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__, dsp->name);
|
|
|
|
one_member:
|
2008-07-26 23:56:38 +00:00
|
|
|
/* remove HFC conference if enabled */
|
|
|
|
if (dsp->hfc_conf >= 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s removing %s from HFC conf %d "
|
|
|
|
"because dsp is split\n", __func__,
|
|
|
|
dsp->name, dsp->hfc_conf);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_CONF_SPLIT,
|
2012-02-20 03:52:38 +00:00
|
|
|
0, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp->hfc_conf = -1;
|
|
|
|
}
|
|
|
|
/* process hw echo */
|
|
|
|
if (dsp->features.pcm_banks < 1)
|
|
|
|
return;
|
2009-05-22 11:04:49 +00:00
|
|
|
if (!dsp->echo.software && !dsp->echo.hardware) {
|
2008-07-26 23:56:38 +00:00
|
|
|
/* NO ECHO: remove PCM slot if assigned */
|
|
|
|
if (dsp->pcm_slot_tx >= 0 || dsp->pcm_slot_rx >= 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "%s removing %s from"
|
2012-02-20 03:52:38 +00:00
|
|
|
" PCM slot %d (TX) %d (RX) because"
|
|
|
|
" dsp is split (no echo)\n",
|
|
|
|
__func__, dsp->name,
|
|
|
|
dsp->pcm_slot_tx, dsp->pcm_slot_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_DISC,
|
2012-02-20 03:52:38 +00:00
|
|
|
0, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp->pcm_slot_tx = -1;
|
|
|
|
dsp->pcm_bank_tx = -1;
|
|
|
|
dsp->pcm_slot_rx = -1;
|
|
|
|
dsp->pcm_bank_rx = -1;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2009-05-22 11:04:49 +00:00
|
|
|
/* echo is enabled, find out if we use soft or hardware */
|
|
|
|
dsp->echo.software = dsp->tx_data;
|
|
|
|
dsp->echo.hardware = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
/* ECHO: already echo */
|
|
|
|
if (dsp->pcm_slot_tx >= 0 && dsp->pcm_slot_rx < 0 &&
|
2009-05-22 11:04:49 +00:00
|
|
|
dsp->pcm_bank_tx == 2 && dsp->pcm_bank_rx == 2) {
|
|
|
|
dsp->echo.hardware = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
2009-05-22 11:04:49 +00:00
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
/* ECHO: if slot already assigned */
|
|
|
|
if (dsp->pcm_slot_tx >= 0) {
|
|
|
|
dsp->pcm_slot_rx = dsp->pcm_slot_tx;
|
|
|
|
dsp->pcm_bank_tx = 2; /* 2 means loop */
|
|
|
|
dsp->pcm_bank_rx = 2;
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s refresh %s for echo using slot %d\n",
|
|
|
|
__func__, dsp->name,
|
|
|
|
dsp->pcm_slot_tx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2);
|
2009-05-22 11:04:49 +00:00
|
|
|
dsp->echo.hardware = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* ECHO: find slot */
|
|
|
|
dsp->pcm_slot_tx = -1;
|
|
|
|
dsp->pcm_slot_rx = -1;
|
|
|
|
memset(freeslots, 1, sizeof(freeslots));
|
|
|
|
list_for_each_entry(finddsp, &dsp_ilist, list) {
|
|
|
|
if (finddsp->features.pcm_id == dsp->features.pcm_id) {
|
|
|
|
if (finddsp->pcm_slot_rx >= 0 &&
|
|
|
|
finddsp->pcm_slot_rx < sizeof(freeslots))
|
2008-10-14 01:42:55 +00:00
|
|
|
freeslots[finddsp->pcm_slot_rx] = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
if (finddsp->pcm_slot_tx >= 0 &&
|
|
|
|
finddsp->pcm_slot_tx < sizeof(freeslots))
|
2008-10-14 01:42:55 +00:00
|
|
|
freeslots[finddsp->pcm_slot_tx] = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
i = 0;
|
|
|
|
ii = dsp->features.pcm_slots;
|
|
|
|
while (i < ii) {
|
|
|
|
if (freeslots[i])
|
|
|
|
break;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (i == ii) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s no slot available for echo\n",
|
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* no more slots available */
|
2009-05-22 11:04:49 +00:00
|
|
|
dsp->echo.software = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* assign free slot */
|
|
|
|
dsp->pcm_slot_tx = i;
|
|
|
|
dsp->pcm_slot_rx = i;
|
|
|
|
dsp->pcm_bank_tx = 2; /* loop */
|
|
|
|
dsp->pcm_bank_rx = 2;
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s assign echo for %s using slot %d\n",
|
|
|
|
__func__, dsp->name, dsp->pcm_slot_tx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2);
|
2009-05-22 11:04:49 +00:00
|
|
|
dsp->echo.hardware = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* conf gets updated (all members) */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "%s checking conference %d\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__, conf->id);
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
if (list_empty(&conf->mlist)) {
|
2015-05-20 14:54:02 +00:00
|
|
|
printk(KERN_ERR "%s: conference without members\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
member = list_entry(conf->mlist.next, struct dsp_conf_member, list);
|
|
|
|
same_hfc = member->dsp->features.hfc_id;
|
|
|
|
same_pcm = member->dsp->features.pcm_id;
|
|
|
|
/* check all members in our conference */
|
|
|
|
list_for_each_entry(member, &conf->mlist, list) {
|
|
|
|
/* check if member uses mixing */
|
|
|
|
if (member->dsp->tx_mix) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"tx_mix is turned on\n", __func__,
|
|
|
|
member->dsp->name);
|
|
|
|
conf_software:
|
2008-07-26 23:56:38 +00:00
|
|
|
list_for_each_entry(member, &conf->mlist, list) {
|
|
|
|
dsp = member->dsp;
|
|
|
|
/* remove HFC conference if enabled */
|
|
|
|
if (dsp->hfc_conf >= 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s removing %s from HFC "
|
|
|
|
"conf %d because not "
|
|
|
|
"possible with hardware\n",
|
|
|
|
__func__,
|
|
|
|
dsp->name,
|
|
|
|
dsp->hfc_conf);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(dsp,
|
2012-02-20 03:52:38 +00:00
|
|
|
MISDN_CTRL_HFC_CONF_SPLIT,
|
|
|
|
0, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp->hfc_conf = -1;
|
|
|
|
}
|
|
|
|
/* remove PCM slot if assigned */
|
|
|
|
if (dsp->pcm_slot_tx >= 0 ||
|
|
|
|
dsp->pcm_slot_rx >= 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "%s removing "
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s from PCM slot %d (TX)"
|
|
|
|
" slot %d (RX) because not"
|
|
|
|
" possible with hardware\n",
|
|
|
|
__func__,
|
|
|
|
dsp->name,
|
|
|
|
dsp->pcm_slot_tx,
|
|
|
|
dsp->pcm_slot_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(dsp,
|
2012-02-20 03:52:38 +00:00
|
|
|
MISDN_CTRL_HFC_PCM_DISC,
|
|
|
|
0, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp->pcm_slot_tx = -1;
|
|
|
|
dsp->pcm_bank_tx = -1;
|
|
|
|
dsp->pcm_slot_rx = -1;
|
|
|
|
dsp->pcm_bank_rx = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
conf->hardware = 0;
|
|
|
|
conf->software = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* check if member has echo turned on */
|
2009-05-22 11:04:49 +00:00
|
|
|
if (member->dsp->echo.hardware || member->dsp->echo.software) {
|
2008-07-26 23:56:38 +00:00
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"echo is turned on\n", __func__,
|
|
|
|
member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* check if member has tx_mix turned on */
|
|
|
|
if (member->dsp->tx_mix) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"tx_mix is turned on\n",
|
|
|
|
__func__, member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* check if member changes volume at an not suppoted level */
|
|
|
|
if (member->dsp->tx_volume) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"tx_volume is changed\n",
|
|
|
|
__func__, member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
if (member->dsp->rx_volume) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"rx_volume is changed\n",
|
|
|
|
__func__, member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* check if tx-data turned on */
|
|
|
|
if (member->dsp->tx_data) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s tx_data is turned on\n",
|
|
|
|
__func__, member->dsp->name);
|
2009-05-22 11:04:49 +00:00
|
|
|
tx_data = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
/* check if pipeline exists */
|
|
|
|
if (member->dsp->pipeline.inuse) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"pipeline exists\n", __func__,
|
|
|
|
member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* check if encryption is enabled */
|
|
|
|
if (member->dsp->bf_enable) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "%s dsp %s cannot form a "
|
2012-02-20 03:52:38 +00:00
|
|
|
"conf, because encryption is enabled\n",
|
|
|
|
__func__, member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* check if member is on a card with PCM support */
|
|
|
|
if (member->dsp->features.pcm_id < 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"dsp has no PCM bus\n",
|
|
|
|
__func__, member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* check if relations are on the same PCM bus */
|
|
|
|
if (member->dsp->features.pcm_id != same_pcm) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s cannot form a conf, because "
|
|
|
|
"dsp is on a different PCM bus than the "
|
|
|
|
"first dsp\n",
|
|
|
|
__func__, member->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* determine if members are on the same hfc chip */
|
|
|
|
if (same_hfc != member->dsp->features.hfc_id)
|
|
|
|
same_hfc = -1;
|
|
|
|
/* if there are members already in a conference */
|
|
|
|
if (current_conf < 0 && member->dsp->hfc_conf >= 0)
|
|
|
|
current_conf = member->dsp->hfc_conf;
|
|
|
|
/* if any member is not in a conference */
|
|
|
|
if (member->dsp->hfc_conf < 0)
|
|
|
|
all_conf = 0;
|
|
|
|
|
|
|
|
memb++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if no member, this is an error */
|
|
|
|
if (memb < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* one member */
|
|
|
|
if (memb == 1) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s conf %d cannot form a HW conference, "
|
|
|
|
"because dsp is alone\n", __func__, conf->id);
|
2008-07-26 23:56:38 +00:00
|
|
|
conf->hardware = 0;
|
|
|
|
conf->software = 0;
|
|
|
|
member = list_entry(conf->mlist.next, struct dsp_conf_member,
|
2012-02-20 03:52:38 +00:00
|
|
|
list);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp = member->dsp;
|
|
|
|
goto one_member;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ok, now we are sure that all members are on the same pcm.
|
|
|
|
* now we will see if we have only two members, so we can do
|
|
|
|
* crossconnections, which don't have any limitations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* if we have only two members */
|
|
|
|
if (memb == 2) {
|
|
|
|
member = list_entry(conf->mlist.next, struct dsp_conf_member,
|
2012-02-20 03:52:38 +00:00
|
|
|
list);
|
2008-07-26 23:56:38 +00:00
|
|
|
nextm = list_entry(member->list.next, struct dsp_conf_member,
|
2012-02-20 03:52:38 +00:00
|
|
|
list);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* remove HFC conference if enabled */
|
|
|
|
if (member->dsp->hfc_conf >= 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s removing %s from HFC conf %d because "
|
|
|
|
"two parties require only a PCM slot\n",
|
|
|
|
__func__, member->dsp->name,
|
|
|
|
member->dsp->hfc_conf);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(member->dsp,
|
2012-02-20 03:52:38 +00:00
|
|
|
MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
member->dsp->hfc_conf = -1;
|
|
|
|
}
|
|
|
|
if (nextm->dsp->hfc_conf >= 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s removing %s from HFC conf %d because "
|
|
|
|
"two parties require only a PCM slot\n",
|
|
|
|
__func__, nextm->dsp->name,
|
|
|
|
nextm->dsp->hfc_conf);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(nextm->dsp,
|
2012-02-20 03:52:38 +00:00
|
|
|
MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
nextm->dsp->hfc_conf = -1;
|
|
|
|
}
|
|
|
|
/* if members have two banks (and not on the same chip) */
|
|
|
|
if (member->dsp->features.pcm_banks > 1 &&
|
|
|
|
nextm->dsp->features.pcm_banks > 1 &&
|
|
|
|
member->dsp->features.hfc_id !=
|
|
|
|
nextm->dsp->features.hfc_id) {
|
|
|
|
/* if both members have same slots with crossed banks */
|
|
|
|
if (member->dsp->pcm_slot_tx >= 0 &&
|
|
|
|
member->dsp->pcm_slot_rx >= 0 &&
|
|
|
|
nextm->dsp->pcm_slot_tx >= 0 &&
|
|
|
|
nextm->dsp->pcm_slot_rx >= 0 &&
|
|
|
|
nextm->dsp->pcm_slot_tx ==
|
|
|
|
member->dsp->pcm_slot_rx &&
|
|
|
|
nextm->dsp->pcm_slot_rx ==
|
|
|
|
member->dsp->pcm_slot_tx &&
|
|
|
|
nextm->dsp->pcm_slot_tx ==
|
|
|
|
member->dsp->pcm_slot_tx &&
|
|
|
|
member->dsp->pcm_bank_tx !=
|
|
|
|
member->dsp->pcm_bank_rx &&
|
|
|
|
nextm->dsp->pcm_bank_tx !=
|
|
|
|
nextm->dsp->pcm_bank_rx) {
|
|
|
|
/* all members have same slot */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s & %s stay joined on "
|
|
|
|
"PCM slot %d bank %d (TX) bank %d "
|
|
|
|
"(RX) (on different chips)\n",
|
|
|
|
__func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name,
|
|
|
|
member->dsp->pcm_slot_tx,
|
|
|
|
member->dsp->pcm_bank_tx,
|
|
|
|
member->dsp->pcm_bank_rx);
|
2012-04-24 02:51:50 +00:00
|
|
|
conf->hardware = 1;
|
|
|
|
conf->software = tx_data;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* find a new slot */
|
|
|
|
memset(freeslots, 1, sizeof(freeslots));
|
|
|
|
list_for_each_entry(dsp, &dsp_ilist, list) {
|
|
|
|
if (dsp != member->dsp &&
|
|
|
|
dsp != nextm->dsp &&
|
|
|
|
member->dsp->features.pcm_id ==
|
|
|
|
dsp->features.pcm_id) {
|
|
|
|
if (dsp->pcm_slot_rx >= 0 &&
|
|
|
|
dsp->pcm_slot_rx <
|
|
|
|
sizeof(freeslots))
|
2008-08-30 04:50:34 +00:00
|
|
|
freeslots[dsp->pcm_slot_rx] = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
if (dsp->pcm_slot_tx >= 0 &&
|
|
|
|
dsp->pcm_slot_tx <
|
|
|
|
sizeof(freeslots))
|
2008-08-30 04:50:34 +00:00
|
|
|
freeslots[dsp->pcm_slot_tx] = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
i = 0;
|
|
|
|
ii = member->dsp->features.pcm_slots;
|
|
|
|
while (i < ii) {
|
|
|
|
if (freeslots[i])
|
|
|
|
break;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (i == ii) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s no slot available for "
|
|
|
|
"%s & %s\n", __func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* no more slots available */
|
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* assign free slot */
|
|
|
|
member->dsp->pcm_slot_tx = i;
|
|
|
|
member->dsp->pcm_slot_rx = i;
|
|
|
|
nextm->dsp->pcm_slot_tx = i;
|
|
|
|
nextm->dsp->pcm_slot_rx = i;
|
|
|
|
member->dsp->pcm_bank_rx = 0;
|
|
|
|
member->dsp->pcm_bank_tx = 1;
|
|
|
|
nextm->dsp->pcm_bank_rx = 1;
|
|
|
|
nextm->dsp->pcm_bank_tx = 0;
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s adding %s & %s to new PCM slot %d "
|
|
|
|
"(TX and RX on different chips) because "
|
|
|
|
"both members have not same slots\n",
|
|
|
|
__func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name,
|
|
|
|
member->dsp->pcm_slot_tx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx,
|
|
|
|
member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx,
|
|
|
|
nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
conf->hardware = 1;
|
2009-05-22 11:04:49 +00:00
|
|
|
conf->software = tx_data;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
2012-02-20 03:52:38 +00:00
|
|
|
/* if members have one bank (or on the same chip) */
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
|
|
|
/* if both members have different crossed slots */
|
|
|
|
if (member->dsp->pcm_slot_tx >= 0 &&
|
|
|
|
member->dsp->pcm_slot_rx >= 0 &&
|
|
|
|
nextm->dsp->pcm_slot_tx >= 0 &&
|
|
|
|
nextm->dsp->pcm_slot_rx >= 0 &&
|
|
|
|
nextm->dsp->pcm_slot_tx ==
|
|
|
|
member->dsp->pcm_slot_rx &&
|
|
|
|
nextm->dsp->pcm_slot_rx ==
|
|
|
|
member->dsp->pcm_slot_tx &&
|
|
|
|
member->dsp->pcm_slot_tx !=
|
|
|
|
member->dsp->pcm_slot_rx &&
|
|
|
|
member->dsp->pcm_bank_tx == 0 &&
|
|
|
|
member->dsp->pcm_bank_rx == 0 &&
|
|
|
|
nextm->dsp->pcm_bank_tx == 0 &&
|
|
|
|
nextm->dsp->pcm_bank_rx == 0) {
|
|
|
|
/* all members have same slot */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s dsp %s & %s stay joined on PCM "
|
|
|
|
"slot %d (TX) %d (RX) on same chip "
|
|
|
|
"or one bank PCM)\n", __func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name,
|
|
|
|
member->dsp->pcm_slot_tx,
|
|
|
|
member->dsp->pcm_slot_rx);
|
2012-04-24 02:51:50 +00:00
|
|
|
conf->hardware = 1;
|
|
|
|
conf->software = tx_data;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* find two new slot */
|
|
|
|
memset(freeslots, 1, sizeof(freeslots));
|
|
|
|
list_for_each_entry(dsp, &dsp_ilist, list) {
|
|
|
|
if (dsp != member->dsp &&
|
|
|
|
dsp != nextm->dsp &&
|
|
|
|
member->dsp->features.pcm_id ==
|
|
|
|
dsp->features.pcm_id) {
|
|
|
|
if (dsp->pcm_slot_rx >= 0 &&
|
|
|
|
dsp->pcm_slot_rx <
|
|
|
|
sizeof(freeslots))
|
2008-08-30 04:50:34 +00:00
|
|
|
freeslots[dsp->pcm_slot_rx] = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
if (dsp->pcm_slot_tx >= 0 &&
|
|
|
|
dsp->pcm_slot_tx <
|
|
|
|
sizeof(freeslots))
|
2008-08-30 04:50:34 +00:00
|
|
|
freeslots[dsp->pcm_slot_tx] = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
i1 = 0;
|
|
|
|
ii = member->dsp->features.pcm_slots;
|
|
|
|
while (i1 < ii) {
|
|
|
|
if (freeslots[i1])
|
|
|
|
break;
|
|
|
|
i1++;
|
|
|
|
}
|
|
|
|
if (i1 == ii) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s no slot available "
|
|
|
|
"for %s & %s\n", __func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* no more slots available */
|
|
|
|
goto conf_software;
|
|
|
|
}
|
2012-02-20 03:52:38 +00:00
|
|
|
i2 = i1 + 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
while (i2 < ii) {
|
|
|
|
if (freeslots[i2])
|
|
|
|
break;
|
|
|
|
i2++;
|
|
|
|
}
|
|
|
|
if (i2 == ii) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s no slot available "
|
|
|
|
"for %s & %s\n",
|
|
|
|
__func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* no more slots available */
|
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* assign free slots */
|
|
|
|
member->dsp->pcm_slot_tx = i1;
|
|
|
|
member->dsp->pcm_slot_rx = i2;
|
|
|
|
nextm->dsp->pcm_slot_tx = i2;
|
|
|
|
nextm->dsp->pcm_slot_rx = i1;
|
|
|
|
member->dsp->pcm_bank_rx = 0;
|
|
|
|
member->dsp->pcm_bank_tx = 0;
|
|
|
|
nextm->dsp->pcm_bank_rx = 0;
|
|
|
|
nextm->dsp->pcm_bank_tx = 0;
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s adding %s & %s to new PCM slot %d "
|
|
|
|
"(TX) %d (RX) on same chip or one bank "
|
|
|
|
"PCM, because both members have not "
|
|
|
|
"crossed slots\n", __func__,
|
|
|
|
member->dsp->name,
|
|
|
|
nextm->dsp->name,
|
|
|
|
member->dsp->pcm_slot_tx,
|
|
|
|
member->dsp->pcm_slot_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx,
|
|
|
|
member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx,
|
|
|
|
nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx);
|
2008-07-26 23:56:38 +00:00
|
|
|
conf->hardware = 1;
|
2009-05-22 11:04:49 +00:00
|
|
|
conf->software = tx_data;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if we have more than two, we may check if we have a conference
|
|
|
|
* unit available on the chip. also all members must be on the same
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* if not the same HFC chip */
|
|
|
|
if (same_hfc < 0) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s conference %d cannot be formed, because "
|
|
|
|
"members are on different chips or not "
|
|
|
|
"on HFC chip\n",
|
|
|
|
__func__, conf->id);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* for more than two members.. */
|
|
|
|
|
|
|
|
/* if all members already have the same conference */
|
2012-04-24 02:51:50 +00:00
|
|
|
if (all_conf) {
|
|
|
|
conf->hardware = 1;
|
|
|
|
conf->software = tx_data;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
2012-04-24 02:51:50 +00:00
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if there is an existing conference, but not all members have joined
|
|
|
|
*/
|
|
|
|
if (current_conf >= 0) {
|
2012-02-20 03:52:38 +00:00
|
|
|
join_members:
|
2008-07-26 23:56:38 +00:00
|
|
|
list_for_each_entry(member, &conf->mlist, list) {
|
2009-05-22 11:04:53 +00:00
|
|
|
/* if no conference engine on our chip, change to
|
|
|
|
* software */
|
|
|
|
if (!member->dsp->features.hfc_conf)
|
|
|
|
goto conf_software;
|
2008-12-28 15:31:26 +00:00
|
|
|
/* in case of hdlc, change to software */
|
|
|
|
if (member->dsp->hdlc)
|
|
|
|
goto conf_software;
|
2008-07-26 23:56:38 +00:00
|
|
|
/* join to current conference */
|
|
|
|
if (member->dsp->hfc_conf == current_conf)
|
|
|
|
continue;
|
|
|
|
/* get a free timeslot first */
|
|
|
|
memset(freeslots, 1, sizeof(freeslots));
|
|
|
|
list_for_each_entry(dsp, &dsp_ilist, list) {
|
|
|
|
/*
|
|
|
|
* not checking current member, because
|
|
|
|
* slot will be overwritten.
|
|
|
|
*/
|
|
|
|
if (
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp != member->dsp &&
|
|
|
|
/* dsp must be on the same PCM */
|
|
|
|
member->dsp->features.pcm_id ==
|
|
|
|
dsp->features.pcm_id) {
|
2008-07-26 23:56:38 +00:00
|
|
|
/* dsp must be on a slot */
|
|
|
|
if (dsp->pcm_slot_tx >= 0 &&
|
|
|
|
dsp->pcm_slot_tx <
|
|
|
|
sizeof(freeslots))
|
|
|
|
freeslots[dsp->pcm_slot_tx] = 0;
|
|
|
|
if (dsp->pcm_slot_rx >= 0 &&
|
|
|
|
dsp->pcm_slot_rx <
|
|
|
|
sizeof(freeslots))
|
|
|
|
freeslots[dsp->pcm_slot_rx] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i = 0;
|
|
|
|
ii = member->dsp->features.pcm_slots;
|
|
|
|
while (i < ii) {
|
|
|
|
if (freeslots[i])
|
|
|
|
break;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (i == ii) {
|
|
|
|
/* no more slots available */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s conference %d cannot be formed,"
|
|
|
|
" because no slot free\n",
|
|
|
|
__func__, conf->id);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s changing dsp %s to HW conference "
|
|
|
|
"%d slot %d\n", __func__,
|
|
|
|
member->dsp->name, current_conf, i);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* assign free slot & set PCM & join conf */
|
|
|
|
member->dsp->pcm_slot_tx = i;
|
|
|
|
member->dsp->pcm_slot_rx = i;
|
|
|
|
member->dsp->pcm_bank_tx = 2; /* loop */
|
|
|
|
member->dsp->pcm_bank_rx = 2;
|
|
|
|
member->dsp->hfc_conf = current_conf;
|
|
|
|
dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
|
2012-02-20 03:52:38 +00:00
|
|
|
i, 2, i, 2);
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp_cmx_hw_message(member->dsp,
|
2012-02-20 03:52:38 +00:00
|
|
|
MISDN_CTRL_HFC_CONF_JOIN, current_conf, 0, 0, 0);
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2012-04-24 02:51:50 +00:00
|
|
|
conf->hardware = 1;
|
|
|
|
conf->software = tx_data;
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* no member is in a conference yet, so we find a free one
|
|
|
|
*/
|
|
|
|
memset(freeunits, 1, sizeof(freeunits));
|
|
|
|
list_for_each_entry(dsp, &dsp_ilist, list) {
|
|
|
|
/* dsp must be on the same chip */
|
|
|
|
if (dsp->features.hfc_id == same_hfc &&
|
|
|
|
/* dsp must have joined a HW conference */
|
|
|
|
dsp->hfc_conf >= 0 &&
|
|
|
|
/* slot must be within range */
|
|
|
|
dsp->hfc_conf < 8)
|
|
|
|
freeunits[dsp->hfc_conf] = 0;
|
|
|
|
}
|
|
|
|
i = 0;
|
|
|
|
ii = 8;
|
|
|
|
while (i < ii) {
|
|
|
|
if (freeunits[i])
|
|
|
|
break;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (i == ii) {
|
|
|
|
/* no more conferences available */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s conference %d cannot be formed, because "
|
|
|
|
"no conference number free\n",
|
|
|
|
__func__, conf->id);
|
2008-07-26 23:56:38 +00:00
|
|
|
goto conf_software;
|
|
|
|
}
|
|
|
|
/* join all members */
|
|
|
|
current_conf = i;
|
|
|
|
goto join_members;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* conf_id != 0: join or change conference
|
|
|
|
* conf_id == 0: split from conference if not already
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
dsp_cmx_conf(struct dsp *dsp, u32 conf_id)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct dsp_conf *conf;
|
|
|
|
struct dsp_conf_member *member;
|
|
|
|
|
|
|
|
/* if conference doesn't change */
|
|
|
|
if (dsp->conf_id == conf_id)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* first remove us from current conf */
|
|
|
|
if (dsp->conf_id) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "removing us from conference %d\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp->conf->id);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* remove us from conf */
|
|
|
|
conf = dsp->conf;
|
|
|
|
err = dsp_cmx_del_conf_member(dsp);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
dsp->conf_id = 0;
|
|
|
|
|
|
|
|
/* update hardware */
|
|
|
|
dsp_cmx_hardware(NULL, dsp);
|
|
|
|
|
|
|
|
/* conf now empty? */
|
|
|
|
if (list_empty(&conf->mlist)) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"conference is empty, so we remove it.\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
err = dsp_cmx_del_conf(conf);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
} else {
|
|
|
|
/* update members left on conf */
|
|
|
|
dsp_cmx_hardware(conf, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if split */
|
|
|
|
if (!conf_id)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* now add us to conf */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG "searching conference %d\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
conf_id);
|
2008-07-26 23:56:38 +00:00
|
|
|
conf = dsp_cmx_search_conf(conf_id);
|
|
|
|
if (!conf) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"conference doesn't exist yet, creating.\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
/* the conference doesn't exist, so we create */
|
|
|
|
conf = dsp_cmx_new_conf(conf_id);
|
|
|
|
if (!conf)
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (!list_empty(&conf->mlist)) {
|
|
|
|
member = list_entry(conf->mlist.next, struct dsp_conf_member,
|
2012-02-20 03:52:38 +00:00
|
|
|
list);
|
2008-07-26 23:56:38 +00:00
|
|
|
if (dsp->hdlc && !member->dsp->hdlc) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"cannot join transparent conference.\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (!dsp->hdlc && member->dsp->hdlc) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"cannot join hdlc conference.\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* add conference member */
|
|
|
|
err = dsp_cmx_add_conf_member(dsp, conf);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
dsp->conf_id = conf_id;
|
|
|
|
|
|
|
|
/* if we are alone, we do nothing! */
|
|
|
|
if (list_empty(&conf->mlist)) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CMX)
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"we are alone in this conference, so exit.\n");
|
2008-07-26 23:56:38 +00:00
|
|
|
/* update hardware */
|
|
|
|
dsp_cmx_hardware(NULL, dsp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update members on conf */
|
|
|
|
dsp_cmx_hardware(conf, NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-28 11:01:01 +00:00
|
|
|
#ifdef CMX_DELAY_DEBUG
|
|
|
|
int delaycount;
|
|
|
|
static void
|
|
|
|
showdelay(struct dsp *dsp, int samples, int delay)
|
|
|
|
{
|
|
|
|
char bar[] = "--------------------------------------------------|";
|
|
|
|
int sdelay;
|
|
|
|
|
|
|
|
delaycount += samples;
|
|
|
|
if (delaycount < 8000)
|
|
|
|
return;
|
|
|
|
delaycount = 0;
|
|
|
|
|
|
|
|
sdelay = delay * 50 / (dsp_poll << 2);
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "DELAY (%s) %3d >%s\n", dsp->name, delay,
|
2012-02-20 03:52:38 +00:00
|
|
|
sdelay > 50 ? "..." : bar + 50 - sdelay);
|
2008-09-28 11:01:01 +00:00
|
|
|
}
|
|
|
|
#endif
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* audio data is received from card
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
u8 *d, *p;
|
|
|
|
int len = skb->len;
|
|
|
|
struct mISDNhead *hh = mISDN_HEAD_P(skb);
|
|
|
|
int w, i, ii;
|
|
|
|
|
|
|
|
/* check if we have sompen */
|
|
|
|
if (len < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* half of the buffer should be larger than maximum packet size */
|
|
|
|
if (len >= CMX_BUFF_HALF) {
|
|
|
|
printk(KERN_ERR
|
2012-02-20 03:52:38 +00:00
|
|
|
"%s line %d: packet from card is too large (%d bytes). "
|
|
|
|
"please make card send smaller packets OR increase "
|
|
|
|
"CMX_BUFF_SIZE\n", __FILE__, __LINE__, len);
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* initialize pointers if not already -
|
|
|
|
* also add delay if requested by PH_SIGNAL
|
|
|
|
*/
|
|
|
|
if (dsp->rx_init) {
|
|
|
|
dsp->rx_init = 0;
|
|
|
|
if (dsp->features.unordered) {
|
|
|
|
dsp->rx_R = (hh->id & CMX_BUFF_MASK);
|
2008-08-02 20:51:52 +00:00
|
|
|
if (dsp->cmx_delay)
|
|
|
|
dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
|
|
|
|
& CMX_BUFF_MASK;
|
|
|
|
else
|
|
|
|
dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1))
|
|
|
|
& CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
|
|
|
dsp->rx_R = 0;
|
2008-08-02 20:51:52 +00:00
|
|
|
if (dsp->cmx_delay)
|
|
|
|
dsp->rx_W = dsp->cmx_delay;
|
|
|
|
else
|
|
|
|
dsp->rx_W = dsp_poll >> 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* if frame contains time code, write directly */
|
|
|
|
if (dsp->features.unordered) {
|
|
|
|
dsp->rx_W = (hh->id & CMX_BUFF_MASK);
|
|
|
|
/* printk(KERN_DEBUG "%s %08x\n", dsp->name, hh->id); */
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* if we underrun (or maybe overrun),
|
|
|
|
* we set our new read pointer, and write silence to buffer
|
|
|
|
*/
|
|
|
|
if (((dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK) >= CMX_BUFF_HALF) {
|
2008-08-03 08:36:53 +00:00
|
|
|
if (dsp_debug & DEBUG_DSP_CLOCK)
|
2008-07-26 23:56:38 +00:00
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"cmx_receive(dsp=%lx): UNDERRUN (or overrun the "
|
|
|
|
"maximum delay), adjusting read pointer! "
|
|
|
|
"(inst %s)\n", (u_long)dsp, dsp->name);
|
2008-08-02 20:51:52 +00:00
|
|
|
/* flush rx buffer and set delay to dsp_poll / 2 */
|
2008-07-26 23:56:38 +00:00
|
|
|
if (dsp->features.unordered) {
|
|
|
|
dsp->rx_R = (hh->id & CMX_BUFF_MASK);
|
2008-08-02 20:51:52 +00:00
|
|
|
if (dsp->cmx_delay)
|
|
|
|
dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
|
|
|
|
& CMX_BUFF_MASK;
|
2010-08-05 10:29:19 +00:00
|
|
|
else
|
2008-08-02 20:51:52 +00:00
|
|
|
dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1))
|
|
|
|
& CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
|
|
|
dsp->rx_R = 0;
|
2008-08-02 20:51:52 +00:00
|
|
|
if (dsp->cmx_delay)
|
|
|
|
dsp->rx_W = dsp->cmx_delay;
|
|
|
|
else
|
|
|
|
dsp->rx_W = dsp_poll >> 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
|
|
|
|
}
|
|
|
|
/* if we have reached double delay, jump back to middle */
|
|
|
|
if (dsp->cmx_delay)
|
|
|
|
if (((dsp->rx_W - dsp->rx_R) & CMX_BUFF_MASK) >=
|
|
|
|
(dsp->cmx_delay << 1)) {
|
2008-08-03 08:36:53 +00:00
|
|
|
if (dsp_debug & DEBUG_DSP_CLOCK)
|
2008-07-26 23:56:38 +00:00
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"cmx_receive(dsp=%lx): OVERRUN (because "
|
|
|
|
"twice the delay is reached), adjusting "
|
|
|
|
"read pointer! (inst %s)\n",
|
|
|
|
(u_long)dsp, dsp->name);
|
|
|
|
/* flush buffer */
|
|
|
|
if (dsp->features.unordered) {
|
|
|
|
dsp->rx_R = (hh->id & CMX_BUFF_MASK);
|
|
|
|
dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
|
|
|
|
& CMX_BUFF_MASK;
|
|
|
|
} else {
|
|
|
|
dsp->rx_R = 0;
|
|
|
|
dsp->rx_W = dsp->cmx_delay;
|
|
|
|
}
|
|
|
|
memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* show where to write */
|
|
|
|
#ifdef CMX_DEBUG
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"cmx_receive(dsp=%lx): rx_R(dsp)=%05x rx_W(dsp)=%05x len=%d %s\n",
|
|
|
|
(u_long)dsp, dsp->rx_R, dsp->rx_W, len, dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* write data into rx_buffer */
|
|
|
|
p = skb->data;
|
|
|
|
d = dsp->rx_buff;
|
|
|
|
w = dsp->rx_W;
|
|
|
|
i = 0;
|
|
|
|
ii = len;
|
|
|
|
while (i < ii) {
|
|
|
|
d[w++ & CMX_BUFF_MASK] = *p++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* increase write-pointer */
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp->rx_W = ((dsp->rx_W + len) & CMX_BUFF_MASK);
|
2008-09-28 11:01:01 +00:00
|
|
|
#ifdef CMX_DELAY_DEBUG
|
|
|
|
showdelay(dsp, len, (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK);
|
|
|
|
#endif
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* send (mixed) audio data to card and control jitter
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dsp_cmx_send_member(struct dsp *dsp, int len, s32 *c, int members)
|
|
|
|
{
|
|
|
|
struct dsp_conf *conf = dsp->conf;
|
|
|
|
struct dsp *member, *other;
|
|
|
|
register s32 sample;
|
|
|
|
u8 *d, *p, *q, *o_q;
|
|
|
|
struct sk_buff *nskb, *txskb;
|
|
|
|
int r, rr, t, tt, o_r, o_rr;
|
|
|
|
int preload = 0;
|
|
|
|
struct mISDNhead *hh, *thh;
|
2009-05-22 11:04:49 +00:00
|
|
|
int tx_data_only = 0;
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/* don't process if: */
|
|
|
|
if (!dsp->b_active) { /* if not active */
|
|
|
|
dsp->last_tx = 0;
|
|
|
|
return;
|
|
|
|
}
|
2009-05-22 11:04:49 +00:00
|
|
|
if (((dsp->conf && dsp->conf->hardware) || /* hardware conf */
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp->echo.hardware) && /* OR hardware echo */
|
2008-07-26 23:56:38 +00:00
|
|
|
dsp->tx_R == dsp->tx_W && /* AND no tx-data */
|
|
|
|
!(dsp->tone.tone && dsp->tone.software)) { /* AND not soft tones */
|
2009-05-22 11:04:49 +00:00
|
|
|
if (!dsp->tx_data) { /* no tx_data for user space required */
|
|
|
|
dsp->last_tx = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (dsp->conf && dsp->conf->software && dsp->conf->hardware)
|
|
|
|
tx_data_only = 1;
|
2012-04-24 02:51:49 +00:00
|
|
|
if (dsp->echo.software && dsp->echo.hardware)
|
2009-05-22 11:04:49 +00:00
|
|
|
tx_data_only = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CMX_DEBUG
|
|
|
|
printk(KERN_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
"SEND members=%d dsp=%s, conf=%p, rx_R=%05x rx_W=%05x\n",
|
|
|
|
members, dsp->name, conf, dsp->rx_R, dsp->rx_W);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* preload if we have delay set */
|
|
|
|
if (dsp->cmx_delay && !dsp->last_tx) {
|
|
|
|
preload = len;
|
|
|
|
if (preload < 128)
|
|
|
|
preload = 128;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PREPARE RESULT */
|
|
|
|
nskb = mI_alloc_skb(len + preload, GFP_ATOMIC);
|
|
|
|
if (!nskb) {
|
|
|
|
printk(KERN_ERR
|
2012-02-20 03:52:38 +00:00
|
|
|
"FATAL ERROR in mISDN_dsp.o: cannot alloc %d bytes\n",
|
|
|
|
len + preload);
|
2008-07-26 23:56:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
hh = mISDN_HEAD_P(nskb);
|
|
|
|
hh->prim = PH_DATA_REQ;
|
|
|
|
hh->id = 0;
|
|
|
|
dsp->last_tx = 1;
|
|
|
|
|
|
|
|
/* set pointers, indexes and stuff */
|
|
|
|
member = dsp;
|
|
|
|
p = dsp->tx_buff; /* transmit data */
|
|
|
|
q = dsp->rx_buff; /* received data */
|
|
|
|
d = skb_put(nskb, preload + len); /* result */
|
|
|
|
t = dsp->tx_R; /* tx-pointers */
|
|
|
|
tt = dsp->tx_W;
|
|
|
|
r = dsp->rx_R; /* rx-pointers */
|
|
|
|
rr = (r + len) & CMX_BUFF_MASK;
|
|
|
|
|
|
|
|
/* preload with silence, if required */
|
|
|
|
if (preload) {
|
|
|
|
memset(d, dsp_silence, preload);
|
|
|
|
d += preload;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PROCESS TONES/TX-DATA ONLY */
|
|
|
|
if (dsp->tone.tone && dsp->tone.software) {
|
|
|
|
/* -> copy tone */
|
|
|
|
dsp_tone_copy(dsp, d, len);
|
|
|
|
dsp->tx_R = 0; /* clear tx buffer */
|
|
|
|
dsp->tx_W = 0;
|
|
|
|
goto send_packet;
|
|
|
|
}
|
|
|
|
/* if we have tx-data but do not use mixing */
|
|
|
|
if (!dsp->tx_mix && t != tt) {
|
|
|
|
/* -> send tx-data and continue when not enough */
|
|
|
|
#ifdef CMX_TX_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
sprintf(debugbuf, "TX sending (%04x-%04x)%p: ", t, tt, p);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
while (r != rr && t != tt) {
|
|
|
|
#ifdef CMX_TX_DEBUG
|
|
|
|
if (strlen(debugbuf) < 48)
|
2012-02-20 03:52:38 +00:00
|
|
|
sprintf(debugbuf + strlen(debugbuf), " %02x",
|
|
|
|
p[t]);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
*d++ = p[t]; /* write tx_buff */
|
2012-02-20 03:52:38 +00:00
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
if (r == rr) {
|
|
|
|
dsp->tx_R = t;
|
|
|
|
#ifdef CMX_TX_DEBUG
|
2012-02-20 03:52:38 +00:00
|
|
|
printk(KERN_DEBUG "%s\n", debugbuf);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
goto send_packet;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef CMX_TX_DEBUG
|
|
|
|
printk(KERN_DEBUG "%s\n", debugbuf);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* PROCESS DATA (one member / no conf) */
|
|
|
|
if (!conf || members <= 1) {
|
|
|
|
/* -> if echo is NOT enabled */
|
2009-05-22 11:04:49 +00:00
|
|
|
if (!dsp->echo.software) {
|
2008-07-26 23:56:38 +00:00
|
|
|
/* -> send tx-data if available or use 0-volume */
|
|
|
|
while (r != rr && t != tt) {
|
|
|
|
*d++ = p[t]; /* write tx_buff */
|
2012-02-20 03:52:38 +00:00
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2008-08-02 20:51:52 +00:00
|
|
|
if (r != rr) {
|
2008-08-03 08:36:53 +00:00
|
|
|
if (dsp_debug & DEBUG_DSP_CLOCK)
|
|
|
|
printk(KERN_DEBUG "%s: RX empty\n",
|
2012-02-20 03:52:38 +00:00
|
|
|
__func__);
|
|
|
|
memset(d, dsp_silence, (rr - r) & CMX_BUFF_MASK);
|
2008-08-02 20:51:52 +00:00
|
|
|
}
|
2012-02-20 03:52:38 +00:00
|
|
|
/* -> if echo is enabled */
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* -> mix tx-data with echo if available,
|
|
|
|
* or use echo only
|
|
|
|
*/
|
|
|
|
while (r != rr && t != tt) {
|
2012-02-20 03:52:38 +00:00
|
|
|
*d++ = dsp_audio_mix_law[(p[t] << 8) | q[r]];
|
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
while (r != rr) {
|
|
|
|
*d++ = q[r]; /* echo */
|
2012-02-20 03:52:38 +00:00
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
dsp->tx_R = t;
|
|
|
|
goto send_packet;
|
|
|
|
}
|
|
|
|
/* PROCESS DATA (two members) */
|
|
|
|
#ifdef CMX_CONF_DEBUG
|
|
|
|
if (0) {
|
|
|
|
#else
|
2014-09-05 13:26:11 +00:00
|
|
|
if (members == 2) {
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
2014-09-05 13:26:11 +00:00
|
|
|
/* "other" becomes other party */
|
|
|
|
other = (list_entry(conf->mlist.next,
|
|
|
|
struct dsp_conf_member, list))->dsp;
|
|
|
|
if (other == member)
|
|
|
|
other = (list_entry(conf->mlist.prev,
|
|
|
|
struct dsp_conf_member, list))->dsp;
|
|
|
|
o_q = other->rx_buff; /* received data */
|
|
|
|
o_rr = (other->rx_R + len) & CMX_BUFF_MASK;
|
|
|
|
/* end of rx-pointer */
|
|
|
|
o_r = (o_rr - rr + r) & CMX_BUFF_MASK;
|
|
|
|
/* start rx-pointer at current read position*/
|
|
|
|
/* -> if echo is NOT enabled */
|
|
|
|
if (!dsp->echo.software) {
|
|
|
|
/*
|
|
|
|
* -> copy other member's rx-data,
|
|
|
|
* if tx-data is available, mix
|
|
|
|
*/
|
|
|
|
while (o_r != o_rr && t != tt) {
|
|
|
|
*d++ = dsp_audio_mix_law[(p[t] << 8) | o_q[o_r]];
|
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
|
|
|
o_r = (o_r + 1) & CMX_BUFF_MASK;
|
|
|
|
}
|
|
|
|
while (o_r != o_rr) {
|
|
|
|
*d++ = o_q[o_r];
|
|
|
|
o_r = (o_r + 1) & CMX_BUFF_MASK;
|
|
|
|
}
|
|
|
|
/* -> if echo is enabled */
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* -> mix other member's rx-data with echo,
|
|
|
|
* if tx-data is available, mix
|
|
|
|
*/
|
|
|
|
while (r != rr && t != tt) {
|
|
|
|
sample = dsp_audio_law_to_s32[p[t]] +
|
|
|
|
dsp_audio_law_to_s32[q[r]] +
|
|
|
|
dsp_audio_law_to_s32[o_q[o_r]];
|
|
|
|
if (sample < -32768)
|
|
|
|
sample = -32768;
|
|
|
|
else if (sample > 32767)
|
|
|
|
sample = 32767;
|
|
|
|
*d++ = dsp_audio_s16_to_law[sample & 0xffff];
|
|
|
|
/* tx-data + rx_data + echo */
|
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
|
|
|
o_r = (o_r + 1) & CMX_BUFF_MASK;
|
|
|
|
}
|
|
|
|
while (r != rr) {
|
|
|
|
*d++ = dsp_audio_mix_law[(q[r] << 8) | o_q[o_r]];
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
|
|
|
o_r = (o_r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
2014-09-05 13:26:11 +00:00
|
|
|
dsp->tx_R = t;
|
|
|
|
goto send_packet;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
/* PROCESS DATA (three or more members) */
|
|
|
|
/* -> if echo is NOT enabled */
|
2009-05-22 11:04:49 +00:00
|
|
|
if (!dsp->echo.software) {
|
2008-07-26 23:56:38 +00:00
|
|
|
/*
|
2011-03-31 01:57:33 +00:00
|
|
|
* -> subtract rx-data from conf-data,
|
2008-07-26 23:56:38 +00:00
|
|
|
* if tx-data is available, mix
|
|
|
|
*/
|
|
|
|
while (r != rr && t != tt) {
|
|
|
|
sample = dsp_audio_law_to_s32[p[t]] + *c++ -
|
2012-02-20 03:52:38 +00:00
|
|
|
dsp_audio_law_to_s32[q[r]];
|
2008-07-26 23:56:38 +00:00
|
|
|
if (sample < -32768)
|
|
|
|
sample = -32768;
|
|
|
|
else if (sample > 32767)
|
|
|
|
sample = 32767;
|
|
|
|
*d++ = dsp_audio_s16_to_law[sample & 0xffff];
|
2012-02-20 03:52:38 +00:00
|
|
|
/* conf-rx+tx */
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
while (r != rr) {
|
|
|
|
sample = *c++ - dsp_audio_law_to_s32[q[r]];
|
|
|
|
if (sample < -32768)
|
|
|
|
sample = -32768;
|
|
|
|
else if (sample > 32767)
|
|
|
|
sample = 32767;
|
|
|
|
*d++ = dsp_audio_s16_to_law[sample & 0xffff];
|
2012-02-20 03:52:38 +00:00
|
|
|
/* conf-rx */
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2012-02-20 03:52:38 +00:00
|
|
|
/* -> if echo is enabled */
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* -> encode conf-data, if tx-data
|
|
|
|
* is available, mix
|
|
|
|
*/
|
|
|
|
while (r != rr && t != tt) {
|
|
|
|
sample = dsp_audio_law_to_s32[p[t]] + *c++;
|
|
|
|
if (sample < -32768)
|
|
|
|
sample = -32768;
|
|
|
|
else if (sample > 32767)
|
|
|
|
sample = 32767;
|
|
|
|
*d++ = dsp_audio_s16_to_law[sample & 0xffff];
|
2012-02-20 03:52:38 +00:00
|
|
|
/* conf(echo)+tx */
|
|
|
|
t = (t + 1) & CMX_BUFF_MASK;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
while (r != rr) {
|
|
|
|
sample = *c++;
|
|
|
|
if (sample < -32768)
|
|
|
|
sample = -32768;
|
|
|
|
else if (sample > 32767)
|
|
|
|
sample = 32767;
|
|
|
|
*d++ = dsp_audio_s16_to_law[sample & 0xffff];
|
2012-02-20 03:52:38 +00:00
|
|
|
/* conf(echo) */
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
dsp->tx_R = t;
|
|
|
|
goto send_packet;
|
|
|
|
|
|
|
|
send_packet:
|
|
|
|
/*
|
|
|
|
* send tx-data if enabled - don't filter,
|
2011-03-31 01:57:33 +00:00
|
|
|
* because we want what we send, not what we filtered
|
2008-07-26 23:56:38 +00:00
|
|
|
*/
|
|
|
|
if (dsp->tx_data) {
|
2009-05-22 11:04:49 +00:00
|
|
|
if (tx_data_only) {
|
|
|
|
hh->prim = DL_DATA_REQ;
|
|
|
|
hh->id = 0;
|
|
|
|
/* queue and trigger */
|
|
|
|
skb_queue_tail(&dsp->sendq, nskb);
|
|
|
|
schedule_work(&dsp->workq);
|
|
|
|
/* exit because only tx_data is used */
|
|
|
|
return;
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
2009-05-22 11:04:49 +00:00
|
|
|
txskb = mI_alloc_skb(len, GFP_ATOMIC);
|
|
|
|
if (!txskb) {
|
|
|
|
printk(KERN_ERR
|
2012-02-20 03:52:38 +00:00
|
|
|
"FATAL ERROR in mISDN_dsp.o: "
|
|
|
|
"cannot alloc %d bytes\n", len);
|
2009-05-22 11:04:49 +00:00
|
|
|
} else {
|
|
|
|
thh = mISDN_HEAD_P(txskb);
|
|
|
|
thh->prim = DL_DATA_REQ;
|
|
|
|
thh->id = 0;
|
networking: introduce and use skb_put_data()
A common pattern with skb_put() is to just want to memcpy()
some data into the new space, introduce skb_put_data() for
this.
An spatch similar to the one for skb_put_zero() converts many
of the places using it:
@@
identifier p, p2;
expression len, skb, data;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_data(skb, data, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_data(skb, data, len);
)
(
p2 = (t2)p;
-memcpy(p2, data, len);
|
-memcpy(p, data, len);
)
@@
type t, t2;
identifier p, p2;
expression skb, data;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
)
(
p2 = (t2)p;
-memcpy(p2, data, sizeof(*p));
|
-memcpy(p, data, sizeof(*p));
)
@@
expression skb, len, data;
@@
-memcpy(skb_put(skb, len), data, len);
+skb_put_data(skb, data, len);
(again, manually post-processed to retain some comments)
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 12:29:20 +00:00
|
|
|
skb_put_data(txskb, nskb->data + preload, len);
|
2009-05-22 11:04:49 +00:00
|
|
|
/* queue (trigger later) */
|
|
|
|
skb_queue_tail(&dsp->sendq, txskb);
|
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
2009-05-22 11:04:49 +00:00
|
|
|
|
|
|
|
/* send data only to card, if we don't just calculated tx_data */
|
2008-07-26 23:56:38 +00:00
|
|
|
/* adjust volume */
|
|
|
|
if (dsp->tx_volume)
|
|
|
|
dsp_change_volume(nskb, dsp->tx_volume);
|
|
|
|
/* pipeline */
|
|
|
|
if (dsp->pipeline.inuse)
|
2009-05-22 11:04:49 +00:00
|
|
|
dsp_pipeline_process_tx(&dsp->pipeline, nskb->data,
|
2012-02-20 03:52:38 +00:00
|
|
|
nskb->len);
|
2008-07-26 23:56:38 +00:00
|
|
|
/* crypt */
|
|
|
|
if (dsp->bf_enable)
|
|
|
|
dsp_bf_encrypt(dsp, nskb->data, nskb->len);
|
|
|
|
/* queue and trigger */
|
|
|
|
skb_queue_tail(&dsp->sendq, nskb);
|
|
|
|
schedule_work(&dsp->workq);
|
|
|
|
}
|
|
|
|
|
2009-01-11 17:36:30 +00:00
|
|
|
static u32 jittercount; /* counter for jitter check */
|
2008-07-26 23:56:38 +00:00
|
|
|
struct timer_list dsp_spl_tl;
|
2012-04-25 20:54:48 +00:00
|
|
|
unsigned long dsp_spl_jiffies; /* calculate the next time to fire */
|
2008-09-06 07:03:46 +00:00
|
|
|
static u16 dsp_count; /* last sample count */
|
2012-02-20 03:52:38 +00:00
|
|
|
static int dsp_count_valid; /* if we have last sample count */
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
dsp_cmx_send(void *arg)
|
|
|
|
{
|
|
|
|
struct dsp_conf *conf;
|
|
|
|
struct dsp_conf_member *member;
|
|
|
|
struct dsp *dsp;
|
|
|
|
int mustmix, members;
|
2012-02-20 03:52:38 +00:00
|
|
|
static s32 mixbuffer[MAX_POLL + 100];
|
2009-05-22 11:04:47 +00:00
|
|
|
s32 *c;
|
2008-07-26 23:56:38 +00:00
|
|
|
u8 *p, *q;
|
|
|
|
int r, rr;
|
|
|
|
int jittercheck = 0, delay, i;
|
|
|
|
u_long flags;
|
2008-09-06 07:03:46 +00:00
|
|
|
u16 length, count;
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/* lock */
|
|
|
|
spin_lock_irqsave(&dsp_lock, flags);
|
|
|
|
|
2008-09-06 07:03:46 +00:00
|
|
|
if (!dsp_count_valid) {
|
|
|
|
dsp_count = mISDN_clock_get();
|
2008-07-26 23:56:38 +00:00
|
|
|
length = dsp_poll;
|
2008-09-06 07:03:46 +00:00
|
|
|
dsp_count_valid = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
} else {
|
2008-09-06 07:03:46 +00:00
|
|
|
count = mISDN_clock_get();
|
|
|
|
length = count - dsp_count;
|
|
|
|
dsp_count = count;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
if (length > MAX_POLL + 100)
|
|
|
|
length = MAX_POLL + 100;
|
2008-09-06 07:03:46 +00:00
|
|
|
/* printk(KERN_DEBUG "len=%d dsp_count=0x%x\n", length, dsp_count); */
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/*
|
2008-09-06 07:03:46 +00:00
|
|
|
* check if jitter needs to be checked (this is every second)
|
2008-07-26 23:56:38 +00:00
|
|
|
*/
|
2008-09-06 07:03:46 +00:00
|
|
|
jittercount += length;
|
|
|
|
if (jittercount >= 8000) {
|
|
|
|
jittercount -= 8000;
|
2008-07-26 23:56:38 +00:00
|
|
|
jittercheck = 1;
|
2008-09-06 07:03:46 +00:00
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/* loop all members that do not require conference mixing */
|
|
|
|
list_for_each_entry(dsp, &dsp_ilist, list) {
|
|
|
|
if (dsp->hdlc)
|
|
|
|
continue;
|
|
|
|
conf = dsp->conf;
|
|
|
|
mustmix = 0;
|
|
|
|
members = 0;
|
|
|
|
if (conf) {
|
|
|
|
members = count_list_member(&conf->mlist);
|
|
|
|
#ifdef CMX_CONF_DEBUG
|
|
|
|
if (conf->software && members > 1)
|
|
|
|
#else
|
2019-05-21 09:42:56 +00:00
|
|
|
if (conf->software && members > 2)
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
2019-05-21 09:42:56 +00:00
|
|
|
mustmix = 1;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* transmission required */
|
|
|
|
if (!mustmix) {
|
|
|
|
dsp_cmx_send_member(dsp, length, mixbuffer, members);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* unused mixbuffer is given to prevent a
|
|
|
|
* potential null-pointer-bug
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* loop all members that require conference mixing */
|
|
|
|
list_for_each_entry(conf, &conf_ilist, list) {
|
|
|
|
/* count members and check hardware */
|
|
|
|
members = count_list_member(&conf->mlist);
|
|
|
|
#ifdef CMX_CONF_DEBUG
|
|
|
|
if (conf->software && members > 1) {
|
|
|
|
#else
|
2019-05-21 09:42:56 +00:00
|
|
|
if (conf->software && members > 2) {
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
2019-05-21 09:42:56 +00:00
|
|
|
/* check for hdlc conf */
|
|
|
|
member = list_entry(conf->mlist.next,
|
|
|
|
struct dsp_conf_member, list);
|
|
|
|
if (member->dsp->hdlc)
|
|
|
|
continue;
|
|
|
|
/* mix all data */
|
|
|
|
memset(mixbuffer, 0, length * sizeof(s32));
|
|
|
|
list_for_each_entry(member, &conf->mlist, list) {
|
|
|
|
dsp = member->dsp;
|
|
|
|
/* get range of data to mix */
|
|
|
|
c = mixbuffer;
|
|
|
|
q = dsp->rx_buff;
|
|
|
|
r = dsp->rx_R;
|
|
|
|
rr = (r + length) & CMX_BUFF_MASK;
|
|
|
|
/* add member's data */
|
|
|
|
while (r != rr) {
|
|
|
|
*c++ += dsp_audio_law_to_s32[q[r]];
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* process each member */
|
|
|
|
list_for_each_entry(member, &conf->mlist, list) {
|
|
|
|
/* transmission */
|
|
|
|
dsp_cmx_send_member(member->dsp, length,
|
|
|
|
mixbuffer, members);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* delete rx-data, increment buffers, change pointers */
|
|
|
|
list_for_each_entry(dsp, &dsp_ilist, list) {
|
|
|
|
if (dsp->hdlc)
|
|
|
|
continue;
|
|
|
|
p = dsp->rx_buff;
|
|
|
|
q = dsp->tx_buff;
|
|
|
|
r = dsp->rx_R;
|
|
|
|
/* move receive pointer when receiving */
|
|
|
|
if (!dsp->rx_is_off) {
|
|
|
|
rr = (r + length) & CMX_BUFF_MASK;
|
|
|
|
/* delete rx-data */
|
|
|
|
while (r != rr) {
|
|
|
|
p[r] = dsp_silence;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
/* increment rx-buffer pointer */
|
|
|
|
dsp->rx_R = r; /* write incremented read pointer */
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* check current rx_delay */
|
|
|
|
delay = (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK;
|
|
|
|
if (delay >= CMX_BUFF_HALF)
|
|
|
|
delay = 0; /* will be the delay before next write */
|
|
|
|
/* check for lower delay */
|
|
|
|
if (delay < dsp->rx_delay[0])
|
|
|
|
dsp->rx_delay[0] = delay;
|
|
|
|
/* check current tx_delay */
|
|
|
|
delay = (dsp->tx_W-dsp->tx_R) & CMX_BUFF_MASK;
|
|
|
|
if (delay >= CMX_BUFF_HALF)
|
|
|
|
delay = 0; /* will be the delay before next write */
|
|
|
|
/* check for lower delay */
|
|
|
|
if (delay < dsp->tx_delay[0])
|
|
|
|
dsp->tx_delay[0] = delay;
|
|
|
|
if (jittercheck) {
|
|
|
|
/* find the lowest of all rx_delays */
|
|
|
|
delay = dsp->rx_delay[0];
|
|
|
|
i = 1;
|
|
|
|
while (i < MAX_SECONDS_JITTER_CHECK) {
|
|
|
|
if (delay > dsp->rx_delay[i])
|
|
|
|
delay = dsp->rx_delay[i];
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* remove rx_delay only if we have delay AND we
|
|
|
|
* have not preset cmx_delay AND
|
|
|
|
* the delay is greater dsp_poll
|
|
|
|
*/
|
|
|
|
if (delay > dsp_poll && !dsp->cmx_delay) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CLOCK)
|
|
|
|
printk(KERN_DEBUG
|
|
|
|
"%s lowest rx_delay of %d bytes for"
|
|
|
|
" dsp %s are now removed.\n",
|
|
|
|
__func__, delay,
|
|
|
|
dsp->name);
|
|
|
|
r = dsp->rx_R;
|
|
|
|
rr = (r + delay - (dsp_poll >> 1))
|
|
|
|
& CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
/* delete rx-data */
|
|
|
|
while (r != rr) {
|
|
|
|
p[r] = dsp_silence;
|
2012-02-20 03:52:38 +00:00
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
/* increment rx-buffer pointer */
|
2019-05-21 09:42:56 +00:00
|
|
|
dsp->rx_R = r;
|
|
|
|
/* write incremented read pointer */
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
/* find the lowest of all tx_delays */
|
|
|
|
delay = dsp->tx_delay[0];
|
|
|
|
i = 1;
|
|
|
|
while (i < MAX_SECONDS_JITTER_CHECK) {
|
|
|
|
if (delay > dsp->tx_delay[i])
|
|
|
|
delay = dsp->tx_delay[i];
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* remove delay only if we have delay AND we
|
|
|
|
* have enabled tx_dejitter
|
|
|
|
*/
|
|
|
|
if (delay > dsp_poll && dsp->tx_dejitter) {
|
|
|
|
if (dsp_debug & DEBUG_DSP_CLOCK)
|
|
|
|
printk(KERN_DEBUG
|
|
|
|
"%s lowest tx_delay of %d bytes for"
|
|
|
|
" dsp %s are now removed.\n",
|
|
|
|
__func__, delay,
|
|
|
|
dsp->name);
|
|
|
|
r = dsp->tx_R;
|
|
|
|
rr = (r + delay - (dsp_poll >> 1))
|
|
|
|
& CMX_BUFF_MASK;
|
|
|
|
/* delete tx-data */
|
|
|
|
while (r != rr) {
|
|
|
|
q[r] = dsp_silence;
|
|
|
|
r = (r + 1) & CMX_BUFF_MASK;
|
2012-02-20 03:52:38 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
/* increment rx-buffer pointer */
|
|
|
|
dsp->tx_R = r;
|
|
|
|
/* write incremented read pointer */
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
/* scroll up delays */
|
|
|
|
i = MAX_SECONDS_JITTER_CHECK - 1;
|
|
|
|
while (i) {
|
|
|
|
dsp->rx_delay[i] = dsp->rx_delay[i - 1];
|
|
|
|
dsp->tx_delay[i] = dsp->tx_delay[i - 1];
|
|
|
|
i--;
|
|
|
|
}
|
|
|
|
dsp->tx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */
|
|
|
|
dsp->rx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* if next event would be in the past ... */
|
|
|
|
if ((s32)(dsp_spl_jiffies + dsp_tics-jiffies) <= 0)
|
|
|
|
dsp_spl_jiffies = jiffies + 1;
|
|
|
|
else
|
|
|
|
dsp_spl_jiffies += dsp_tics;
|
2008-07-26 23:56:38 +00:00
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
dsp_spl_tl.expires = dsp_spl_jiffies;
|
|
|
|
add_timer(&dsp_spl_tl);
|
2008-07-26 23:56:38 +00:00
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* unlock */
|
|
|
|
spin_unlock_irqrestore(&dsp_lock, flags);
|
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* audio data is transmitted from upper layer to the dsp
|
|
|
|
*/
|
2019-05-21 09:42:56 +00:00
|
|
|
void
|
|
|
|
dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
u_int w, ww;
|
|
|
|
u8 *d, *p;
|
|
|
|
int space; /* todo: , l = skb->len; */
|
2008-07-26 23:56:38 +00:00
|
|
|
#ifdef CMX_TX_DEBUG
|
2019-05-21 09:42:56 +00:00
|
|
|
char debugbuf[256] = "";
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* check if there is enough space, and then copy */
|
|
|
|
w = dsp->tx_W;
|
|
|
|
ww = dsp->tx_R;
|
|
|
|
p = dsp->tx_buff;
|
|
|
|
d = skb->data;
|
|
|
|
space = (ww - w - 1) & CMX_BUFF_MASK;
|
|
|
|
/* write-pointer should not overrun nor reach read pointer */
|
|
|
|
if (space < skb->len) {
|
|
|
|
/* write to the space we have left */
|
|
|
|
ww = (ww - 1) & CMX_BUFF_MASK; /* end one byte prior tx_R */
|
|
|
|
if (dsp_debug & DEBUG_DSP_CLOCK)
|
|
|
|
printk(KERN_DEBUG "%s: TX overflow space=%d skb->len="
|
|
|
|
"%d, w=0x%04x, ww=0x%04x\n", __func__, space,
|
|
|
|
skb->len, w, ww);
|
|
|
|
} else
|
|
|
|
/* write until all byte are copied */
|
|
|
|
ww = (w + skb->len) & CMX_BUFF_MASK;
|
|
|
|
dsp->tx_W = ww;
|
2012-02-20 03:52:38 +00:00
|
|
|
/* show current buffer */
|
2008-07-26 23:56:38 +00:00
|
|
|
#ifdef CMX_DEBUG
|
2019-05-21 09:42:56 +00:00
|
|
|
printk(KERN_DEBUG
|
|
|
|
"cmx_transmit(dsp=%lx) %d bytes to 0x%x-0x%x. %s\n",
|
|
|
|
(u_long)dsp, (ww - w) & CMX_BUFF_MASK, w, ww, dsp->name);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* copy transmit data to tx-buffer */
|
2008-07-26 23:56:38 +00:00
|
|
|
#ifdef CMX_TX_DEBUG
|
2019-05-21 09:42:56 +00:00
|
|
|
sprintf(debugbuf, "TX getting (%04x-%04x)%p: ", w, ww, p);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
2019-05-21 09:42:56 +00:00
|
|
|
while (w != ww) {
|
2008-07-26 23:56:38 +00:00
|
|
|
#ifdef CMX_TX_DEBUG
|
2019-05-21 09:42:56 +00:00
|
|
|
if (strlen(debugbuf) < 48)
|
|
|
|
sprintf(debugbuf + strlen(debugbuf), " %02x", *d);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
2019-05-21 09:42:56 +00:00
|
|
|
p[w] = *d++;
|
|
|
|
w = (w + 1) & CMX_BUFF_MASK;
|
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
#ifdef CMX_TX_DEBUG
|
2019-05-21 09:42:56 +00:00
|
|
|
printk(KERN_DEBUG "%s\n", debugbuf);
|
2008-07-26 23:56:38 +00:00
|
|
|
#endif
|
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
}
|
2008-07-26 23:56:38 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* hdlc data is received from card and sent to all members.
|
|
|
|
*/
|
2019-05-21 09:42:56 +00:00
|
|
|
void
|
|
|
|
dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct sk_buff *nskb = NULL;
|
|
|
|
struct dsp_conf_member *member;
|
|
|
|
struct mISDNhead *hh;
|
2008-07-26 23:56:38 +00:00
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* not if not active */
|
|
|
|
if (!dsp->b_active)
|
|
|
|
return;
|
2008-07-26 23:56:38 +00:00
|
|
|
|
2019-05-21 09:42:56 +00:00
|
|
|
/* check if we have sompen */
|
|
|
|
if (skb->len < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* no conf */
|
|
|
|
if (!dsp->conf) {
|
|
|
|
/* in case of software echo */
|
|
|
|
if (dsp->echo.software) {
|
|
|
|
nskb = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (nskb) {
|
|
|
|
hh = mISDN_HEAD_P(nskb);
|
|
|
|
hh->prim = PH_DATA_REQ;
|
|
|
|
hh->id = 0;
|
|
|
|
skb_queue_tail(&dsp->sendq, nskb);
|
|
|
|
schedule_work(&dsp->workq);
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
2009-01-09 20:22:50 +00:00
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* in case of hardware conference */
|
|
|
|
if (dsp->conf->hardware)
|
|
|
|
return;
|
|
|
|
list_for_each_entry(member, &dsp->conf->mlist, list) {
|
|
|
|
if (dsp->echo.software || member->dsp != dsp) {
|
|
|
|
nskb = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (nskb) {
|
|
|
|
hh = mISDN_HEAD_P(nskb);
|
|
|
|
hh->prim = PH_DATA_REQ;
|
|
|
|
hh->id = 0;
|
|
|
|
skb_queue_tail(&member->dsp->sendq, nskb);
|
|
|
|
schedule_work(&member->dsp->workq);
|
2008-07-26 23:56:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-05-21 09:42:56 +00:00
|
|
|
}
|