AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-12-15 13:46:47 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity
e36c8c161c
linux_dsm_epyc7002/drivers/isdn/mISDN/dsp_cmx.c
Johannes Berg 59ae1d127a 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 11:48:37 -04:00

1962 lines
53 KiB
C
Raw Blame History

/*
* 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
* will not be disabled but blocked to the upper layer.
*
* 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 <linux/slab.h>
#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 */
/*#define CMX_DELAY_DEBUG * gives rx-buffer delay overview */
/*#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) {
printk(KERN_DEBUG "* %s hardecho=%d softecho=%d txmix=%d",
odsp->name, odsp->echo.hardware, odsp->echo.software,
odsp->tx_mix);
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
" - 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*" : "");
}
}
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",
__func__);
return -EINVAL;
}
if (dsp->conf) {
printk(KERN_WARNING "%s: dsp is already in a conf.\n",
__func__);
return -EINVAL;
}
member = kzalloc(sizeof(struct dsp_conf_member), GFP_ATOMIC);
if (!member) {
printk(KERN_ERR "kzalloc struct dsp_conf_member failed\n");
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",
__func__);
return -EINVAL;
}
if (!dsp->conf) {
printk(KERN_WARNING "%s: dsp is not in a conf.\n",
__func__);
return -EINVAL;
}
if (list_empty(&dsp->conf->mlist)) {
printk(KERN_WARNING "%s: dsp has linked an empty conf.\n",
__func__);
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
"%s: dsp is not present in its own conf_member list.\n",
__func__);
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",
__func__);
return NULL;
}
conf = kzalloc(sizeof(struct dsp_conf), GFP_ATOMIC);
if (!conf) {
printk(KERN_ERR "kzalloc struct dsp_conf failed\n");
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",
__func__);
return -EINVAL;
}
if (!list_empty(&conf->mlist)) {
printk(KERN_WARNING "%s: conf not empty.\n",
__func__);
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,
u32 param3, u32 param4)
{
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,
all_conf = 1, tx_data = 0;
/* dsp gets updated (no conf) */
if (!conf) {
if (!dsp)
return;
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG "%s checking dsp %s\n",
__func__, dsp->name);
one_member:
/* remove HFC conference if enabled */
if (dsp->hfc_conf >= 0) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s removing %s from HFC conf %d "
"because dsp is split\n", __func__,
dsp->name, dsp->hfc_conf);
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_CONF_SPLIT,
0, 0, 0, 0);
dsp->hfc_conf = -1;
}
/* process hw echo */
if (dsp->features.pcm_banks < 1)
return;
if (!dsp->echo.software && !dsp->echo.hardware) {
/* 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"
" PCM slot %d (TX) %d (RX) because"
" dsp is split (no echo)\n",
__func__, dsp->name,
dsp->pcm_slot_tx, dsp->pcm_slot_rx);
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_DISC,
0, 0, 0, 0);
dsp->pcm_slot_tx = -1;
dsp->pcm_bank_tx = -1;
dsp->pcm_slot_rx = -1;
dsp->pcm_bank_rx = -1;
}
return;
}
/* echo is enabled, find out if we use soft or hardware */
dsp->echo.software = dsp->tx_data;
dsp->echo.hardware = 0;
/* ECHO: already echo */
if (dsp->pcm_slot_tx >= 0 && dsp->pcm_slot_rx < 0 &&
dsp->pcm_bank_tx == 2 && dsp->pcm_bank_rx == 2) {
dsp->echo.hardware = 1;
return;
}
/* 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
"%s refresh %s for echo using slot %d\n",
__func__, dsp->name,
dsp->pcm_slot_tx);
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN,
dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2);
dsp->echo.hardware = 1;
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))
freeslots[finddsp->pcm_slot_rx] = 0;
if (finddsp->pcm_slot_tx >= 0 &&
finddsp->pcm_slot_tx < sizeof(freeslots))
freeslots[finddsp->pcm_slot_tx] = 0;
}
}
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
"%s no slot available for echo\n",
__func__);
/* no more slots available */
dsp->echo.software = 1;
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
"%s assign echo for %s using slot %d\n",
__func__, dsp->name, dsp->pcm_slot_tx);
dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN,
dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2);
dsp->echo.hardware = 1;
return;
}
/* conf gets updated (all members) */
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG "%s checking conference %d\n",
__func__, conf->id);
if (list_empty(&conf->mlist)) {
printk(KERN_ERR "%s: conference without members\n",
__func__);
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
"%s dsp %s cannot form a conf, because "
"tx_mix is turned on\n", __func__,
member->dsp->name);
conf_software:
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
"%s removing %s from HFC "
"conf %d because not "
"possible with hardware\n",
__func__,
dsp->name,
dsp->hfc_conf);
dsp_cmx_hw_message(dsp,
MISDN_CTRL_HFC_CONF_SPLIT,
0, 0, 0, 0);
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 "
"%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);
dsp_cmx_hw_message(dsp,
MISDN_CTRL_HFC_PCM_DISC,
0, 0, 0, 0);
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 */
if (member->dsp->echo.hardware || member->dsp->echo.software) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s dsp %s cannot form a conf, because "
"echo is turned on\n", __func__,
member->dsp->name);
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
"%s dsp %s cannot form a conf, because "
"tx_mix is turned on\n",
__func__, member->dsp->name);
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
"%s dsp %s cannot form a conf, because "
"tx_volume is changed\n",
__func__, member->dsp->name);
goto conf_software;
}
if (member->dsp->rx_volume) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s dsp %s cannot form a conf, because "
"rx_volume is changed\n",
__func__, member->dsp->name);
goto conf_software;
}
/* check if tx-data turned on */
if (member->dsp->tx_data) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s dsp %s tx_data is turned on\n",
__func__, member->dsp->name);
tx_data = 1;
}
/* check if pipeline exists */
if (member->dsp->pipeline.inuse) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s dsp %s cannot form a conf, because "
"pipeline exists\n", __func__,
member->dsp->name);
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 "
"conf, because encryption is enabled\n",
__func__, member->dsp->name);
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
"%s dsp %s cannot form a conf, because "
"dsp has no PCM bus\n",
__func__, member->dsp->name);
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
"%s dsp %s cannot form a conf, because "
"dsp is on a different PCM bus than the "
"first dsp\n",
__func__, member->dsp->name);
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
"%s conf %d cannot form a HW conference, "
"because dsp is alone\n", __func__, conf->id);
conf->hardware = 0;
conf->software = 0;
member = list_entry(conf->mlist.next, struct dsp_conf_member,
list);
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,
list);
nextm = list_entry(member->list.next, struct dsp_conf_member,
list);
/* remove HFC conference if enabled */
if (member->dsp->hfc_conf >= 0) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s removing %s from HFC conf %d because "
"two parties require only a PCM slot\n",
__func__, member->dsp->name,
member->dsp->hfc_conf);
dsp_cmx_hw_message(member->dsp,
MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0);
member->dsp->hfc_conf = -1;
}
if (nextm->dsp->hfc_conf >= 0) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s removing %s from HFC conf %d because "
"two parties require only a PCM slot\n",
__func__, nextm->dsp->name,
nextm->dsp->hfc_conf);
dsp_cmx_hw_message(nextm->dsp,
MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0);
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
"%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);
conf->hardware = 1;
conf->software = tx_data;
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))
freeslots[dsp->pcm_slot_rx] = 0;
if (dsp->pcm_slot_tx >= 0 &&
dsp->pcm_slot_tx <
sizeof(freeslots))
freeslots[dsp->pcm_slot_tx] = 0;
}
}
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
"%s no slot available for "
"%s & %s\n", __func__,
member->dsp->name,
nextm->dsp->name);
/* 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
"%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);
dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx,
member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx);
dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN,
nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx,
nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx);
conf->hardware = 1;
conf->software = tx_data;
return;
/* if members have one bank (or on the same chip) */
} 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
"%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);
conf->hardware = 1;
conf->software = tx_data;
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))
freeslots[dsp->pcm_slot_rx] = 0;
if (dsp->pcm_slot_tx >= 0 &&
dsp->pcm_slot_tx <
sizeof(freeslots))
freeslots[dsp->pcm_slot_tx] = 0;
}
}
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
"%s no slot available "
"for %s & %s\n", __func__,
member->dsp->name,
nextm->dsp->name);
/* no more slots available */
goto conf_software;
}
i2 = i1 + 1;
while (i2 < ii) {
if (freeslots[i2])
break;
i2++;
}
if (i2 == ii) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s no slot available "
"for %s & %s\n",
__func__,
member->dsp->name,
nextm->dsp->name);
/* 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
"%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);
dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx,
member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx);
dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN,
nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx,
nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx);
conf->hardware = 1;
conf->software = tx_data;
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
"%s conference %d cannot be formed, because "
"members are on different chips or not "
"on HFC chip\n",
__func__, conf->id);
goto conf_software;
}
/* for more than two members.. */
/* if all members already have the same conference */
if (all_conf) {
conf->hardware = 1;
conf->software = tx_data;
return;
}
/*
* if there is an existing conference, but not all members have joined
*/
if (current_conf >= 0) {
join_members:
list_for_each_entry(member, &conf->mlist, list) {
/* if no conference engine on our chip, change to
* software */
if (!member->dsp->features.hfc_conf)
goto conf_software;
/* in case of hdlc, change to software */
if (member->dsp->hdlc)
goto conf_software;
/* 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 (
dsp != member->dsp &&
/* dsp must be on the same PCM */
member->dsp->features.pcm_id ==
dsp->features.pcm_id) {
/* 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
"%s conference %d cannot be formed,"
" because no slot free\n",
__func__, conf->id);
goto conf_software;
}
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"%s changing dsp %s to HW conference "
"%d slot %d\n", __func__,
member->dsp->name, current_conf, i);
/* 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,
i, 2, i, 2);
dsp_cmx_hw_message(member->dsp,
MISDN_CTRL_HFC_CONF_JOIN, current_conf, 0, 0, 0);
}
conf->hardware = 1;
conf->software = tx_data;
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
"%s conference %d cannot be formed, because "
"no conference number free\n",
__func__, conf->id);
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",
dsp->conf->id);
/* 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
"conference is empty, so we remove it.\n");
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",
conf_id);
conf = dsp_cmx_search_conf(conf_id);
if (!conf) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"conference doesn't exist yet, creating.\n");
/* 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,
list);
if (dsp->hdlc && !member->dsp->hdlc) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"cannot join transparent conference.\n");
return -EINVAL;
}
if (!dsp->hdlc && member->dsp->hdlc) {
if (dsp_debug & DEBUG_DSP_CMX)
printk(KERN_DEBUG
"cannot join hdlc conference.\n");
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
"we are alone in this conference, so exit.\n");
/* update hardware */
dsp_cmx_hardware(NULL, dsp);
return 0;
}
/* update members on conf */
dsp_cmx_hardware(conf, NULL);
return 0;
}
#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,
sdelay > 50 ? "..." : bar + 50 - sdelay);
}
#endif
/*
* 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
"%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);
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);
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;
} else {
dsp->rx_R = 0;
if (dsp->cmx_delay)
dsp->rx_W = dsp->cmx_delay;
else
dsp->rx_W = dsp_poll >> 1;
}
}
/* 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) {
if (dsp_debug & DEBUG_DSP_CLOCK)
printk(KERN_DEBUG
"cmx_receive(dsp=%lx): UNDERRUN (or overrun the "
"maximum delay), adjusting read pointer! "
"(inst %s)\n", (u_long)dsp, dsp->name);
/* flush rx buffer and set delay to dsp_poll / 2 */
if (dsp->features.unordered) {
dsp->rx_R = (hh->id & CMX_BUFF_MASK);
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;
} else {
dsp->rx_R = 0;
if (dsp->cmx_delay)
dsp->rx_W = dsp->cmx_delay;
else
dsp->rx_W = dsp_poll >> 1;
}
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)) {
if (dsp_debug & DEBUG_DSP_CLOCK)
printk(KERN_DEBUG
"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));
}
/* show where to write */
#ifdef CMX_DEBUG
printk(KERN_DEBUG
"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);
#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 */
dsp->rx_W = ((dsp->rx_W + len) & CMX_BUFF_MASK);
#ifdef CMX_DELAY_DEBUG
showdelay(dsp, len, (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK);
#endif
}
/*
* 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;
int tx_data_only = 0;
/* don't process if: */
if (!dsp->b_active) { /* if not active */
dsp->last_tx = 0;
return;
}
if (((dsp->conf && dsp->conf->hardware) || /* hardware conf */
dsp->echo.hardware) && /* OR hardware echo */
dsp->tx_R == dsp->tx_W && /* AND no tx-data */
!(dsp->tone.tone && dsp->tone.software)) { /* AND not soft tones */
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;
if (dsp->echo.software && dsp->echo.hardware)
tx_data_only = 1;
}
#ifdef CMX_DEBUG
printk(KERN_DEBUG
"SEND members=%d dsp=%s, conf=%p, rx_R=%05x rx_W=%05x\n",
members, dsp->name, conf, dsp->rx_R, dsp->rx_W);
#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
"FATAL ERROR in mISDN_dsp.o: cannot alloc %d bytes\n",
len + preload);
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
sprintf(debugbuf, "TX sending (%04x-%04x)%p: ", t, tt, p);
#endif
while (r != rr && t != tt) {
#ifdef CMX_TX_DEBUG
if (strlen(debugbuf) < 48)
sprintf(debugbuf + strlen(debugbuf), " %02x",
p[t]);
#endif
*d++ = p[t]; /* write tx_buff */
t = (t + 1) & CMX_BUFF_MASK;
r = (r + 1) & CMX_BUFF_MASK;
}
if (r == rr) {
dsp->tx_R = t;
#ifdef CMX_TX_DEBUG
printk(KERN_DEBUG "%s\n", debugbuf);
#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 */
if (!dsp->echo.software) {
/* -> send tx-data if available or use 0-volume */
while (r != rr && t != tt) {
*d++ = p[t]; /* write tx_buff */
t = (t + 1) & CMX_BUFF_MASK;
r = (r + 1) & CMX_BUFF_MASK;
}
if (r != rr) {
if (dsp_debug & DEBUG_DSP_CLOCK)
printk(KERN_DEBUG "%s: RX empty\n",
__func__);
memset(d, dsp_silence, (rr - r) & CMX_BUFF_MASK);
}
/* -> if echo is enabled */
} else {
/*
* -> mix tx-data with echo if available,
* or use echo only
*/
while (r != rr && t != tt) {
*d++ = dsp_audio_mix_law[(p[t] << 8) | q[r]];
t = (t + 1) & CMX_BUFF_MASK;
r = (r + 1) & CMX_BUFF_MASK;
}
while (r != rr) {
*d++ = q[r]; /* echo */
r = (r + 1) & CMX_BUFF_MASK;
}
}
dsp->tx_R = t;
goto send_packet;
}
/* PROCESS DATA (two members) */
#ifdef CMX_CONF_DEBUG
if (0) {
#else
if (members == 2) {
#endif
/* "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;
}
}
dsp->tx_R = t;
goto send_packet;
}
/* PROCESS DATA (three or more members) */
/* -> if echo is NOT enabled */
if (!dsp->echo.software) {
/*
* -> subtract rx-data from conf-data,
* if tx-data is available, mix
*/
while (r != rr && t != tt) {
sample = dsp_audio_law_to_s32[p[t]] + *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];
/* conf-rx+tx */
r = (r + 1) & CMX_BUFF_MASK;
t = (t + 1) & CMX_BUFF_MASK;
}
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];
/* conf-rx */
r = (r + 1) & CMX_BUFF_MASK;
}
/* -> if echo is enabled */
} 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];
/* conf(echo)+tx */
t = (t + 1) & CMX_BUFF_MASK;
r = (r + 1) & CMX_BUFF_MASK;
}
while (r != rr) {
sample = *c++;
if (sample < -32768)
sample = -32768;
else if (sample > 32767)
sample = 32767;
*d++ = dsp_audio_s16_to_law[sample & 0xffff];
/* conf(echo) */
r = (r + 1) & CMX_BUFF_MASK;
}
}
dsp->tx_R = t;
goto send_packet;
send_packet:
/*
* send tx-data if enabled - don't filter,
* because we want what we send, not what we filtered
*/
if (dsp->tx_data) {
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;
} else {
txskb = mI_alloc_skb(len, GFP_ATOMIC);
if (!txskb) {
printk(KERN_ERR
"FATAL ERROR in mISDN_dsp.o: "
"cannot alloc %d bytes\n", len);
} else {
thh = mISDN_HEAD_P(txskb);
thh->prim = DL_DATA_REQ;
thh->id = 0;
skb_put_data(txskb, nskb->data + preload, len);
/* queue (trigger later) */
skb_queue_tail(&dsp->sendq, txskb);
}
}
}
/* send data only to card, if we don't just calculated tx_data */
/* adjust volume */
if (dsp->tx_volume)
dsp_change_volume(nskb, dsp->tx_volume);
/* pipeline */
if (dsp->pipeline.inuse)
dsp_pipeline_process_tx(&dsp->pipeline, nskb->data,
nskb->len);
/* 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);
}
static u32 jittercount; /* counter for jitter check */
struct timer_list dsp_spl_tl;
unsigned long dsp_spl_jiffies; /* calculate the next time to fire */
static u16 dsp_count; /* last sample count */
static int dsp_count_valid; /* if we have last sample count */
void
dsp_cmx_send(void *arg)
{
struct dsp_conf *conf;
struct dsp_conf_member *member;
struct dsp *dsp;
int mustmix, members;
static s32 mixbuffer[MAX_POLL + 100];
s32 *c;
u8 *p, *q;
int r, rr;
int jittercheck = 0, delay, i;
u_long flags;
u16 length, count;
/* lock */
spin_lock_irqsave(&dsp_lock, flags);
if (!dsp_count_valid) {
dsp_count = mISDN_clock_get();
length = dsp_poll;
dsp_count_valid = 1;
} else {
count = mISDN_clock_get();
length = count - dsp_count;
dsp_count = count;
}
if (length > MAX_POLL + 100)
length = MAX_POLL + 100;
/* printk(KERN_DEBUG "len=%d dsp_count=0x%x\n", length, dsp_count); */
/*
* check if jitter needs to be checked (this is every second)
*/
jittercount += length;
if (jittercount >= 8000) {
jittercount -= 8000;
jittercheck = 1;
}
/* 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
if (conf->software && members > 2)
#endif
mustmix = 1;
}
/* 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
if (conf->software && members > 2) {
#endif
/* 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;
}
}
/* 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;
}
/* increment rx-buffer pointer */
dsp->rx_R = r; /* write incremented read pointer */
}
/* 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;
/* delete rx-data */
while (r != rr) {
p[r] = dsp_silence;
r = (r + 1) & CMX_BUFF_MASK;
}
/* increment rx-buffer pointer */
dsp->rx_R = r;
/* write incremented read pointer */
}
/* 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;
}
/* increment rx-buffer pointer */
dsp->tx_R = r;
/* write incremented read pointer */
}
/* 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 */
}
}
/* 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;
dsp_spl_tl.expires = dsp_spl_jiffies;
add_timer(&dsp_spl_tl);
/* unlock */
spin_unlock_irqrestore(&dsp_lock, flags);
}
/*
* audio data is transmitted from upper layer to the dsp
*/
void
dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb)
{
u_int w, ww;
u8 *d, *p;
int space; /* todo: , l = skb->len; */
#ifdef CMX_TX_DEBUG
char debugbuf[256] = "";
#endif
/* 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;
/* show current buffer */
#ifdef CMX_DEBUG
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);
#endif
/* copy transmit data to tx-buffer */
#ifdef CMX_TX_DEBUG
sprintf(debugbuf, "TX getting (%04x-%04x)%p: ", w, ww, p);
#endif
while (w != ww) {
#ifdef CMX_TX_DEBUG
if (strlen(debugbuf) < 48)
sprintf(debugbuf + strlen(debugbuf), " %02x", *d);
#endif
p[w] = *d++;
w = (w + 1) & CMX_BUFF_MASK;
}
#ifdef CMX_TX_DEBUG
printk(KERN_DEBUG "%s\n", debugbuf);
#endif
}
/*
* hdlc data is received from card and sent to all members.
*/
void
dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb)
{
struct sk_buff *nskb = NULL;
struct dsp_conf_member *member;
struct mISDNhead *hh;
/* not if not active */
if (!dsp->b_active)
return;
/* 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);
}
}
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);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink