forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1960 lines
52 KiB
1960 lines
52 KiB
/* |
|
* Audio crossconnecting/conferrencing (hardware level). |
|
* |
|
* Copyright 2002 by Andreas Eversberg ([email protected]) |
|
* |
|
* 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); |
|
} |
|
} |
|
} |
|
}
|
|
|