/*
 * 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 jiffy 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 */

/*
 * 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_obj(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_obj(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(struct timer_list *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 = list_count_nodes(&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 = list_count_nodes(&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);
                        }
                }
        }
}