linux/drivers/isdn/mISDN/dsp_cmx.c
<<
>>
Prefs
   1/*
   2 * Audio crossconnecting/conferrencing (hardware level).
   3 *
   4 * Copyright 2002 by Andreas Eversberg (jolly@eversberg.eu)
   5 *
   6 * This software may be used and distributed according to the terms
   7 * of the GNU General Public License, incorporated herein by reference.
   8 *
   9 */
  10
  11/*
  12 * The process of adding and removing parties to/from a conference:
  13 *
  14 * There is a chain of struct dsp_conf which has one or more members in a chain
  15 * of struct dsp_conf_member.
  16 *
  17 * After a party is added, the conference is checked for hardware capability.
  18 * Also if a party is removed, the conference is checked again.
  19 *
  20 * There are 3 different solutions: -1 = software, 0 = hardware-crossconnect
  21 * 1-n = hardware-conference. The n will give the conference number.
  22 *
  23 * Depending on the change after removal or insertion of a party, hardware
  24 * commands are given.
  25 *
  26 * The current solution is stored within the struct dsp_conf entry.
  27 */
  28
  29/*
  30 * HOW THE CMX WORKS:
  31 *
  32 * There are 3 types of interaction: One member is alone, in this case only
  33 * data flow from upper to lower layer is done.
  34 * Two members will also exchange their data so they are crossconnected.
  35 * Three or more members will be added in a conference and will hear each
  36 * other but will not receive their own speech (echo) if not enabled.
  37 *
  38 * Features of CMX are:
  39 *  - Crossconnecting or even conference, if more than two members are together.
  40 *  - Force mixing of transmit data with other crossconnect/conference members.
  41 *  - Echo generation to benchmark the delay of audio processing.
  42 *  - Use hardware to minimize cpu load, disable FIFO load and minimize delay.
  43 *  - Dejittering and clock generation.
  44 *
  45 * There are 2 buffers:
  46 *
  47 *
  48 * RX-Buffer
  49 *                 R             W
  50 *                 |             |
  51 * ----------------+-------------+-------------------
  52 *
  53 * The rx-buffer is a ring buffer used to store the received data for each
  54 * individual member. This is only the case if data needs to be dejittered
  55 * or in case of a conference where different clocks require reclocking.
  56 * The transmit-clock (R) will read the buffer.
  57 * If the clock overruns the write-pointer, we will have a buffer underrun.
  58 * If the write pointer always has a certain distance from the transmit-
  59 * clock, we will have a delay. The delay will dynamically be increased and
  60 * reduced.
  61 *
  62 *
  63 * TX-Buffer
  64 *                  R        W
  65 *                  |        |
  66 * -----------------+--------+-----------------------
  67 *
  68 * The tx-buffer is a ring buffer to queue the transmit data from user space
  69 * until it will be mixed or sent. There are two pointers, R and W. If the write
  70 * pointer W would reach or overrun R, the buffer would overrun. In this case
  71 * (some) data is dropped so that it will not overrun.
  72 * Additionally a dynamic dejittering can be enabled. this allows data from
  73 * user space that have jitter and different clock source.
  74 *
  75 *
  76 * Clock:
  77 *
  78 * A Clock is not required, if the data source has exactly one clock. In this
  79 * case the data source is forwarded to the destination.
  80 *
  81 * A Clock is required, because the data source
  82 *  - has multiple clocks.
  83 *  - has no usable clock due to jitter or packet loss (VoIP).
  84 * In this case the system's clock is used. The clock resolution depends on
  85 * the jiffie resolution.
  86 *
  87 * If a member joins a conference:
  88 *
  89 * - If a member joins, its rx_buff is set to silence and change read pointer
  90 *   to transmit clock.
  91 *
  92 * The procedure of received data from card is explained in cmx_receive.
  93 * The procedure of received data from user space is explained in cmx_transmit.
  94 * The procedure of transmit data to card is cmx_send.
  95 *
  96 *
  97 * Interaction with other features:
  98 *
  99 * DTMF:
 100 * DTMF decoding is done before the data is crossconnected.
 101 *
 102 * Volume change:
 103 * Changing rx-volume is done before the data is crossconnected. The tx-volume
 104 * must be changed whenever data is transmitted to the card by the cmx.
 105 *
 106 * Tones:
 107 * If a tone is enabled, it will be processed whenever data is transmitted to
 108 * the card. It will replace the tx-data from the user space.
 109 * If tones are generated by hardware, this conference member is removed for
 110 * this time.
 111 *
 112 * Disable rx-data:
 113 * If cmx is realized in hardware, rx data will be disabled if requested by
 114 * the upper layer. If dtmf decoding is done by software and enabled, rx data
 115 * will not be disabled but blocked to the upper layer.
 116 *
 117 * HFC conference engine:
 118 * If it is possible to realize all features using hardware, hardware will be
 119 * used if not forbidden by control command. Disabling rx-data provides
 120 * absolutely traffic free audio processing. (except for the quick 1-frame
 121 * upload of a tone loop, only once for a new tone)
 122 *
 123 */
 124
 125/* delay.h is required for hw_lock.h */
 126
 127#include <linux/slab.h>
 128#include <linux/delay.h>
 129#include <linux/mISDNif.h>
 130#include <linux/mISDNdsp.h>
 131#include "core.h"
 132#include "dsp.h"
 133/*
 134 * debugging of multi party conference,
 135 * by using conference even with two members
 136 */
 137
 138/* #define CMX_CONF_DEBUG */
 139
 140/*#define CMX_DEBUG * massive read/write pointer output */
 141/*#define CMX_DELAY_DEBUG * gives rx-buffer delay overview */
 142/*#define CMX_TX_DEBUG * massive read/write on tx-buffer with content */
 143
 144static inline int
 145count_list_member(struct list_head *head)
 146{
 147        int                     cnt = 0;
 148        struct list_head        *m;
 149
 150        list_for_each(m, head)
 151                cnt++;
 152        return cnt;
 153}
 154
 155/*
 156 * debug cmx memory structure
 157 */
 158void
 159dsp_cmx_debug(struct dsp *dsp)
 160{
 161        struct dsp_conf *conf;
 162        struct dsp_conf_member  *member;
 163        struct dsp              *odsp;
 164
 165        printk(KERN_DEBUG "-----Current DSP\n");
 166        list_for_each_entry(odsp, &dsp_ilist, list) {
 167                printk(KERN_DEBUG "* %s hardecho=%d softecho=%d txmix=%d",
 168                       odsp->name, odsp->echo.hardware, odsp->echo.software,
 169                       odsp->tx_mix);
 170                if (odsp->conf)
 171                        printk(" (Conf %d)", odsp->conf->id);
 172                if (dsp == odsp)
 173                        printk(" *this*");
 174                printk("\n");
 175        }
 176        printk(KERN_DEBUG "-----Current Conf:\n");
 177        list_for_each_entry(conf, &conf_ilist, list) {
 178                printk(KERN_DEBUG "* Conf %d (%p)\n", conf->id, conf);
 179                list_for_each_entry(member, &conf->mlist, list) {
 180                        printk(KERN_DEBUG
 181                               "  - member = %s (slot_tx %d, bank_tx %d, "
 182                               "slot_rx %d, bank_rx %d hfc_conf %d "
 183                               "tx_data %d rx_is_off %d)%s\n",
 184                               member->dsp->name, member->dsp->pcm_slot_tx,
 185                               member->dsp->pcm_bank_tx, member->dsp->pcm_slot_rx,
 186                               member->dsp->pcm_bank_rx, member->dsp->hfc_conf,
 187                               member->dsp->tx_data, member->dsp->rx_is_off,
 188                               (member->dsp == dsp) ? " *this*" : "");
 189                }
 190        }
 191        printk(KERN_DEBUG "-----end\n");
 192}
 193
 194/*
 195 * search conference
 196 */
 197static struct dsp_conf *
 198dsp_cmx_search_conf(u32 id)
 199{
 200        struct dsp_conf *conf;
 201
 202        if (!id) {
 203                printk(KERN_WARNING "%s: conference ID is 0.\n", __func__);
 204                return NULL;
 205        }
 206
 207        /* search conference */
 208        list_for_each_entry(conf, &conf_ilist, list)
 209                if (conf->id == id)
 210                        return conf;
 211
 212        return NULL;
 213}
 214
 215
 216/*
 217 * add member to conference
 218 */
 219static int
 220dsp_cmx_add_conf_member(struct dsp *dsp, struct dsp_conf *conf)
 221{
 222        struct dsp_conf_member *member;
 223
 224        if (!conf || !dsp) {
 225                printk(KERN_WARNING "%s: conf or dsp is 0.\n", __func__);
 226                return -EINVAL;
 227        }
 228        if (dsp->member) {
 229                printk(KERN_WARNING "%s: dsp is already member in a conf.\n",
 230                       __func__);
 231                return -EINVAL;
 232        }
 233
 234        if (dsp->conf) {
 235                printk(KERN_WARNING "%s: dsp is already in a conf.\n",
 236                       __func__);
 237                return -EINVAL;
 238        }
 239
 240        member = kzalloc(sizeof(struct dsp_conf_member), GFP_ATOMIC);
 241        if (!member) {
 242                printk(KERN_ERR "kzalloc struct dsp_conf_member failed\n");
 243                return -ENOMEM;
 244        }
 245        member->dsp = dsp;
 246        /* clear rx buffer */
 247        memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
 248        dsp->rx_init = 1; /* rx_W and rx_R will be adjusted on first frame */
 249        dsp->rx_W = 0;
 250        dsp->rx_R = 0;
 251
 252        list_add_tail(&member->list, &conf->mlist);
 253
 254        dsp->conf = conf;
 255        dsp->member = member;
 256
 257        return 0;
 258}
 259
 260
 261/*
 262 * del member from conference
 263 */
 264int
 265dsp_cmx_del_conf_member(struct dsp *dsp)
 266{
 267        struct dsp_conf_member *member;
 268
 269        if (!dsp) {
 270                printk(KERN_WARNING "%s: dsp is 0.\n",
 271                       __func__);
 272                return -EINVAL;
 273        }
 274
 275        if (!dsp->conf) {
 276                printk(KERN_WARNING "%s: dsp is not in a conf.\n",
 277                       __func__);
 278                return -EINVAL;
 279        }
 280
 281        if (list_empty(&dsp->conf->mlist)) {
 282                printk(KERN_WARNING "%s: dsp has linked an empty conf.\n",
 283                       __func__);
 284                return -EINVAL;
 285        }
 286
 287        /* find us in conf */
 288        list_for_each_entry(member, &dsp->conf->mlist, list) {
 289                if (member->dsp == dsp) {
 290                        list_del(&member->list);
 291                        dsp->conf = NULL;
 292                        dsp->member = NULL;
 293                        kfree(member);
 294                        return 0;
 295                }
 296        }
 297        printk(KERN_WARNING
 298               "%s: dsp is not present in its own conf_meber list.\n",
 299               __func__);
 300
 301        return -EINVAL;
 302}
 303
 304
 305/*
 306 * new conference
 307 */
 308static struct dsp_conf
 309*dsp_cmx_new_conf(u32 id)
 310{
 311        struct dsp_conf *conf;
 312
 313        if (!id) {
 314                printk(KERN_WARNING "%s: id is 0.\n",
 315                       __func__);
 316                return NULL;
 317        }
 318
 319        conf = kzalloc(sizeof(struct dsp_conf), GFP_ATOMIC);
 320        if (!conf) {
 321                printk(KERN_ERR "kzalloc struct dsp_conf failed\n");
 322                return NULL;
 323        }
 324        INIT_LIST_HEAD(&conf->mlist);
 325        conf->id = id;
 326
 327        list_add_tail(&conf->list, &conf_ilist);
 328
 329        return conf;
 330}
 331
 332
 333/*
 334 * del conference
 335 */
 336int
 337dsp_cmx_del_conf(struct dsp_conf *conf)
 338{
 339        if (!conf) {
 340                printk(KERN_WARNING "%s: conf is null.\n",
 341                       __func__);
 342                return -EINVAL;
 343        }
 344
 345        if (!list_empty(&conf->mlist)) {
 346                printk(KERN_WARNING "%s: conf not empty.\n",
 347                       __func__);
 348                return -EINVAL;
 349        }
 350        list_del(&conf->list);
 351        kfree(conf);
 352
 353        return 0;
 354}
 355
 356
 357/*
 358 * send HW message to hfc card
 359 */
 360static void
 361dsp_cmx_hw_message(struct dsp *dsp, u32 message, u32 param1, u32 param2,
 362                   u32 param3, u32 param4)
 363{
 364        struct mISDN_ctrl_req cq;
 365
 366        memset(&cq, 0, sizeof(cq));
 367        cq.op = message;
 368        cq.p1 = param1 | (param2 << 8);
 369        cq.p2 = param3 | (param4 << 8);
 370        if (dsp->ch.peer)
 371                dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq);
 372}
 373
 374
 375/*
 376 * do hardware update and set the software/hardware flag
 377 *
 378 * either a conference or a dsp instance can be given
 379 * if only dsp instance is given, the instance is not associated with a conf
 380 * and therefore removed. if a conference is given, the dsp is expected to
 381 * be member of that conference.
 382 */
 383void
 384dsp_cmx_hardware(struct dsp_conf *conf, struct dsp *dsp)
 385{
 386        struct dsp_conf_member  *member, *nextm;
 387        struct dsp              *finddsp;
 388        int             memb = 0, i, ii, i1, i2;
 389        int             freeunits[8];
 390        u_char          freeslots[256];
 391        int             same_hfc = -1, same_pcm = -1, current_conf = -1,
 392                all_conf = 1, tx_data = 0;
 393
 394        /* dsp gets updated (no conf) */
 395        if (!conf) {
 396                if (!dsp)
 397                        return;
 398                if (dsp_debug & DEBUG_DSP_CMX)
 399                        printk(KERN_DEBUG "%s checking dsp %s\n",
 400                               __func__, dsp->name);
 401        one_member:
 402                /* remove HFC conference if enabled */
 403                if (dsp->hfc_conf >= 0) {
 404                        if (dsp_debug & DEBUG_DSP_CMX)
 405                                printk(KERN_DEBUG
 406                                       "%s removing %s from HFC conf %d "
 407                                       "because dsp is split\n", __func__,
 408                                       dsp->name, dsp->hfc_conf);
 409                        dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_CONF_SPLIT,
 410                                           0, 0, 0, 0);
 411                        dsp->hfc_conf = -1;
 412                }
 413                /* process hw echo */
 414                if (dsp->features.pcm_banks < 1)
 415                        return;
 416                if (!dsp->echo.software && !dsp->echo.hardware) {
 417                        /* NO ECHO: remove PCM slot if assigned */
 418                        if (dsp->pcm_slot_tx >= 0 || dsp->pcm_slot_rx >= 0) {
 419                                if (dsp_debug & DEBUG_DSP_CMX)
 420                                        printk(KERN_DEBUG "%s removing %s from"
 421                                               " PCM slot %d (TX) %d (RX) because"
 422                                               " dsp is split (no echo)\n",
 423                                               __func__, dsp->name,
 424                                               dsp->pcm_slot_tx, dsp->pcm_slot_rx);
 425                                dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_DISC,
 426                                                   0, 0, 0, 0);
 427                                dsp->pcm_slot_tx = -1;
 428                                dsp->pcm_bank_tx = -1;
 429                                dsp->pcm_slot_rx = -1;
 430                                dsp->pcm_bank_rx = -1;
 431                        }
 432                        return;
 433                }
 434                /* echo is enabled, find out if we use soft or hardware */
 435                dsp->echo.software = dsp->tx_data;
 436                dsp->echo.hardware = 0;
 437                /* ECHO: already echo */
 438                if (dsp->pcm_slot_tx >= 0 && dsp->pcm_slot_rx < 0 &&
 439                    dsp->pcm_bank_tx == 2 && dsp->pcm_bank_rx == 2) {
 440                        dsp->echo.hardware = 1;
 441                        return;
 442                }
 443                /* ECHO: if slot already assigned */
 444                if (dsp->pcm_slot_tx >= 0) {
 445                        dsp->pcm_slot_rx = dsp->pcm_slot_tx;
 446                        dsp->pcm_bank_tx = 2; /* 2 means loop */
 447                        dsp->pcm_bank_rx = 2;
 448                        if (dsp_debug & DEBUG_DSP_CMX)
 449                                printk(KERN_DEBUG
 450                                       "%s refresh %s for echo using slot %d\n",
 451                                       __func__, dsp->name,
 452                                       dsp->pcm_slot_tx);
 453                        dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN,
 454                                           dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2);
 455                        dsp->echo.hardware = 1;
 456                        return;
 457                }
 458                /* ECHO: find slot */
 459                dsp->pcm_slot_tx = -1;
 460                dsp->pcm_slot_rx = -1;
 461                memset(freeslots, 1, sizeof(freeslots));
 462                list_for_each_entry(finddsp, &dsp_ilist, list) {
 463                        if (finddsp->features.pcm_id == dsp->features.pcm_id) {
 464                                if (finddsp->pcm_slot_rx >= 0 &&
 465                                    finddsp->pcm_slot_rx < sizeof(freeslots))
 466                                        freeslots[finddsp->pcm_slot_rx] = 0;
 467                                if (finddsp->pcm_slot_tx >= 0 &&
 468                                    finddsp->pcm_slot_tx < sizeof(freeslots))
 469                                        freeslots[finddsp->pcm_slot_tx] = 0;
 470                        }
 471                }
 472                i = 0;
 473                ii = dsp->features.pcm_slots;
 474                while (i < ii) {
 475                        if (freeslots[i])
 476                                break;
 477                        i++;
 478                }
 479                if (i == ii) {
 480                        if (dsp_debug & DEBUG_DSP_CMX)
 481                                printk(KERN_DEBUG
 482                                       "%s no slot available for echo\n",
 483                                       __func__);
 484                        /* no more slots available */
 485                        dsp->echo.software = 1;
 486                        return;
 487                }
 488                /* assign free slot */
 489                dsp->pcm_slot_tx = i;
 490                dsp->pcm_slot_rx = i;
 491                dsp->pcm_bank_tx = 2; /* loop */
 492                dsp->pcm_bank_rx = 2;
 493                if (dsp_debug & DEBUG_DSP_CMX)
 494                        printk(KERN_DEBUG
 495                               "%s assign echo for %s using slot %d\n",
 496                               __func__, dsp->name, dsp->pcm_slot_tx);
 497                dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN,
 498                                   dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2);
 499                dsp->echo.hardware = 1;
 500                return;
 501        }
 502
 503        /* conf gets updated (all members) */
 504        if (dsp_debug & DEBUG_DSP_CMX)
 505                printk(KERN_DEBUG "%s checking conference %d\n",
 506                       __func__, conf->id);
 507
 508        if (list_empty(&conf->mlist)) {
 509                printk(KERN_ERR "%s: conference whithout members\n",
 510                       __func__);
 511                return;
 512        }
 513        member = list_entry(conf->mlist.next, struct dsp_conf_member, list);
 514        same_hfc = member->dsp->features.hfc_id;
 515        same_pcm = member->dsp->features.pcm_id;
 516        /* check all members in our conference */
 517        list_for_each_entry(member, &conf->mlist, list) {
 518                /* check if member uses mixing */
 519                if (member->dsp->tx_mix) {
 520                        if (dsp_debug & DEBUG_DSP_CMX)
 521                                printk(KERN_DEBUG
 522                                       "%s dsp %s cannot form a conf, because "
 523                                       "tx_mix is turned on\n", __func__,
 524                                       member->dsp->name);
 525                conf_software:
 526                        list_for_each_entry(member, &conf->mlist, list) {
 527                                dsp = member->dsp;
 528                                /* remove HFC conference if enabled */
 529                                if (dsp->hfc_conf >= 0) {
 530                                        if (dsp_debug & DEBUG_DSP_CMX)
 531                                                printk(KERN_DEBUG
 532                                                       "%s removing %s from HFC "
 533                                                       "conf %d because not "
 534                                                       "possible with hardware\n",
 535                                                       __func__,
 536                                                       dsp->name,
 537                                                       dsp->hfc_conf);
 538                                        dsp_cmx_hw_message(dsp,
 539                                                           MISDN_CTRL_HFC_CONF_SPLIT,
 540                                                           0, 0, 0, 0);
 541                                        dsp->hfc_conf = -1;
 542                                }
 543                                /* remove PCM slot if assigned */
 544                                if (dsp->pcm_slot_tx >= 0 ||
 545                                    dsp->pcm_slot_rx >= 0) {
 546                                        if (dsp_debug & DEBUG_DSP_CMX)
 547                                                printk(KERN_DEBUG "%s removing "
 548                                                       "%s from PCM slot %d (TX)"
 549                                                       " slot %d (RX) because not"
 550                                                       " possible with hardware\n",
 551                                                       __func__,
 552                                                       dsp->name,
 553                                                       dsp->pcm_slot_tx,
 554                                                       dsp->pcm_slot_rx);
 555                                        dsp_cmx_hw_message(dsp,
 556                                                           MISDN_CTRL_HFC_PCM_DISC,
 557                                                           0, 0, 0, 0);
 558                                        dsp->pcm_slot_tx = -1;
 559                                        dsp->pcm_bank_tx = -1;
 560                                        dsp->pcm_slot_rx = -1;
 561                                        dsp->pcm_bank_rx = -1;
 562                                }
 563                        }
 564                        conf->hardware = 0;
 565                        conf->software = 1;
 566                        return;
 567                }
 568                /* check if member has echo turned on */
 569                if (member->dsp->echo.hardware || member->dsp->echo.software) {
 570                        if (dsp_debug & DEBUG_DSP_CMX)
 571                                printk(KERN_DEBUG
 572                                       "%s dsp %s cannot form a conf, because "
 573                                       "echo is turned on\n", __func__,
 574                                       member->dsp->name);
 575                        goto conf_software;
 576                }
 577                /* check if member has tx_mix turned on */
 578                if (member->dsp->tx_mix) {
 579                        if (dsp_debug & DEBUG_DSP_CMX)
 580                                printk(KERN_DEBUG
 581                                       "%s dsp %s cannot form a conf, because "
 582                                       "tx_mix is turned on\n",
 583                                       __func__, member->dsp->name);
 584                        goto conf_software;
 585                }
 586                /* check if member changes volume at an not suppoted level */
 587                if (member->dsp->tx_volume) {
 588                        if (dsp_debug & DEBUG_DSP_CMX)
 589                                printk(KERN_DEBUG
 590                                       "%s dsp %s cannot form a conf, because "
 591                                       "tx_volume is changed\n",
 592                                       __func__, member->dsp->name);
 593                        goto conf_software;
 594                }
 595                if (member->dsp->rx_volume) {
 596                        if (dsp_debug & DEBUG_DSP_CMX)
 597                                printk(KERN_DEBUG
 598                                       "%s dsp %s cannot form a conf, because "
 599                                       "rx_volume is changed\n",
 600                                       __func__, member->dsp->name);
 601                        goto conf_software;
 602                }
 603                /* check if tx-data turned on */
 604                if (member->dsp->tx_data) {
 605                        if (dsp_debug & DEBUG_DSP_CMX)
 606                                printk(KERN_DEBUG
 607                                       "%s dsp %s tx_data is turned on\n",
 608                                       __func__, member->dsp->name);
 609                        tx_data = 1;
 610                }
 611                /* check if pipeline exists */
 612                if (member->dsp->pipeline.inuse) {
 613                        if (dsp_debug & DEBUG_DSP_CMX)
 614                                printk(KERN_DEBUG
 615                                       "%s dsp %s cannot form a conf, because "
 616                                       "pipeline exists\n", __func__,
 617                                       member->dsp->name);
 618                        goto conf_software;
 619                }
 620                /* check if encryption is enabled */
 621                if (member->dsp->bf_enable) {
 622                        if (dsp_debug & DEBUG_DSP_CMX)
 623                                printk(KERN_DEBUG "%s dsp %s cannot form a "
 624                                       "conf, because encryption is enabled\n",
 625                                       __func__, member->dsp->name);
 626                        goto conf_software;
 627                }
 628                /* check if member is on a card with PCM support */
 629                if (member->dsp->features.pcm_id < 0) {
 630                        if (dsp_debug & DEBUG_DSP_CMX)
 631                                printk(KERN_DEBUG
 632                                       "%s dsp %s cannot form a conf, because "
 633                                       "dsp has no PCM bus\n",
 634                                       __func__, member->dsp->name);
 635                        goto conf_software;
 636                }
 637                /* check if relations are on the same PCM bus */
 638                if (member->dsp->features.pcm_id != same_pcm) {
 639                        if (dsp_debug & DEBUG_DSP_CMX)
 640                                printk(KERN_DEBUG
 641                                       "%s dsp %s cannot form a conf, because "
 642                                       "dsp is on a different PCM bus than the "
 643                                       "first dsp\n",
 644                                       __func__, member->dsp->name);
 645                        goto conf_software;
 646                }
 647                /* determine if members are on the same hfc chip */
 648                if (same_hfc != member->dsp->features.hfc_id)
 649                        same_hfc = -1;
 650                /* if there are members already in a conference */
 651                if (current_conf < 0 && member->dsp->hfc_conf >= 0)
 652                        current_conf = member->dsp->hfc_conf;
 653                /* if any member is not in a conference */
 654                if (member->dsp->hfc_conf < 0)
 655                        all_conf = 0;
 656
 657                memb++;
 658        }
 659
 660        /* if no member, this is an error */
 661        if (memb < 1)
 662                return;
 663
 664        /* one member */
 665        if (memb == 1) {
 666                if (dsp_debug & DEBUG_DSP_CMX)
 667                        printk(KERN_DEBUG
 668                               "%s conf %d cannot form a HW conference, "
 669                               "because dsp is alone\n", __func__, conf->id);
 670                conf->hardware = 0;
 671                conf->software = 0;
 672                member = list_entry(conf->mlist.next, struct dsp_conf_member,
 673                                    list);
 674                dsp = member->dsp;
 675                goto one_member;
 676        }
 677
 678        /*
 679         * ok, now we are sure that all members are on the same pcm.
 680         * now we will see if we have only two members, so we can do
 681         * crossconnections, which don't have any limitations.
 682         */
 683
 684        /* if we have only two members */
 685        if (memb == 2) {
 686                member = list_entry(conf->mlist.next, struct dsp_conf_member,
 687                                    list);
 688                nextm = list_entry(member->list.next, struct dsp_conf_member,
 689                                   list);
 690                /* remove HFC conference if enabled */
 691                if (member->dsp->hfc_conf >= 0) {
 692                        if (dsp_debug & DEBUG_DSP_CMX)
 693                                printk(KERN_DEBUG
 694                                       "%s removing %s from HFC conf %d because "
 695                                       "two parties require only a PCM slot\n",
 696                                       __func__, member->dsp->name,
 697                                       member->dsp->hfc_conf);
 698                        dsp_cmx_hw_message(member->dsp,
 699                                           MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0);
 700                        member->dsp->hfc_conf = -1;
 701                }
 702                if (nextm->dsp->hfc_conf >= 0) {
 703                        if (dsp_debug & DEBUG_DSP_CMX)
 704                                printk(KERN_DEBUG
 705                                       "%s removing %s from HFC conf %d because "
 706                                       "two parties require only a PCM slot\n",
 707                                       __func__, nextm->dsp->name,
 708                                       nextm->dsp->hfc_conf);
 709                        dsp_cmx_hw_message(nextm->dsp,
 710                                           MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0);
 711                        nextm->dsp->hfc_conf = -1;
 712                }
 713                /* if members have two banks (and not on the same chip) */
 714                if (member->dsp->features.pcm_banks > 1 &&
 715                    nextm->dsp->features.pcm_banks > 1 &&
 716                    member->dsp->features.hfc_id !=
 717                    nextm->dsp->features.hfc_id) {
 718                        /* if both members have same slots with crossed banks */
 719                        if (member->dsp->pcm_slot_tx >= 0 &&
 720                            member->dsp->pcm_slot_rx >= 0 &&
 721                            nextm->dsp->pcm_slot_tx >= 0 &&
 722                            nextm->dsp->pcm_slot_rx >= 0 &&
 723                            nextm->dsp->pcm_slot_tx ==
 724                            member->dsp->pcm_slot_rx &&
 725                            nextm->dsp->pcm_slot_rx ==
 726                            member->dsp->pcm_slot_tx &&
 727                            nextm->dsp->pcm_slot_tx ==
 728                            member->dsp->pcm_slot_tx &&
 729                            member->dsp->pcm_bank_tx !=
 730                            member->dsp->pcm_bank_rx &&
 731                            nextm->dsp->pcm_bank_tx !=
 732                            nextm->dsp->pcm_bank_rx) {
 733                                /* all members have same slot */
 734                                if (dsp_debug & DEBUG_DSP_CMX)
 735                                        printk(KERN_DEBUG
 736                                               "%s dsp %s & %s stay joined on "
 737                                               "PCM slot %d bank %d (TX) bank %d "
 738                                               "(RX) (on different chips)\n",
 739                                               __func__,
 740                                               member->dsp->name,
 741                                               nextm->dsp->name,
 742                                               member->dsp->pcm_slot_tx,
 743                                               member->dsp->pcm_bank_tx,
 744                                               member->dsp->pcm_bank_rx);
 745                                conf->hardware = 1;
 746                                conf->software = tx_data;
 747                                return;
 748                        }
 749                        /* find a new slot */
 750                        memset(freeslots, 1, sizeof(freeslots));
 751                        list_for_each_entry(dsp, &dsp_ilist, list) {
 752                                if (dsp != member->dsp &&
 753                                    dsp != nextm->dsp &&
 754                                    member->dsp->features.pcm_id ==
 755                                    dsp->features.pcm_id) {
 756                                        if (dsp->pcm_slot_rx >= 0 &&
 757                                            dsp->pcm_slot_rx <
 758                                            sizeof(freeslots))
 759                                                freeslots[dsp->pcm_slot_rx] = 0;
 760                                        if (dsp->pcm_slot_tx >= 0 &&
 761                                            dsp->pcm_slot_tx <
 762                                            sizeof(freeslots))
 763                                                freeslots[dsp->pcm_slot_tx] = 0;
 764                                }
 765                        }
 766                        i = 0;
 767                        ii = member->dsp->features.pcm_slots;
 768                        while (i < ii) {
 769                                if (freeslots[i])
 770                                        break;
 771                                i++;
 772                        }
 773                        if (i == ii) {
 774                                if (dsp_debug & DEBUG_DSP_CMX)
 775                                        printk(KERN_DEBUG
 776                                               "%s no slot available for "
 777                                               "%s & %s\n", __func__,
 778                                               member->dsp->name,
 779                                               nextm->dsp->name);
 780                                /* no more slots available */
 781                                goto conf_software;
 782                        }
 783                        /* assign free slot */
 784                        member->dsp->pcm_slot_tx = i;
 785                        member->dsp->pcm_slot_rx = i;
 786                        nextm->dsp->pcm_slot_tx = i;
 787                        nextm->dsp->pcm_slot_rx = i;
 788                        member->dsp->pcm_bank_rx = 0;
 789                        member->dsp->pcm_bank_tx = 1;
 790                        nextm->dsp->pcm_bank_rx = 1;
 791                        nextm->dsp->pcm_bank_tx = 0;
 792                        if (dsp_debug & DEBUG_DSP_CMX)
 793                                printk(KERN_DEBUG
 794                                       "%s adding %s & %s to new PCM slot %d "
 795                                       "(TX and RX on different chips) because "
 796                                       "both members have not same slots\n",
 797                                       __func__,
 798                                       member->dsp->name,
 799                                       nextm->dsp->name,
 800                                       member->dsp->pcm_slot_tx);
 801                        dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
 802                                           member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx,
 803                                           member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx);
 804                        dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN,
 805                                           nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx,
 806                                           nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx);
 807                        conf->hardware = 1;
 808                        conf->software = tx_data;
 809                        return;
 810                        /* if members have one bank (or on the same chip) */
 811                } else {
 812                        /* if both members have different crossed slots */
 813                        if (member->dsp->pcm_slot_tx >= 0 &&
 814                            member->dsp->pcm_slot_rx >= 0 &&
 815                            nextm->dsp->pcm_slot_tx >= 0 &&
 816                            nextm->dsp->pcm_slot_rx >= 0 &&
 817                            nextm->dsp->pcm_slot_tx ==
 818                            member->dsp->pcm_slot_rx &&
 819                            nextm->dsp->pcm_slot_rx ==
 820                            member->dsp->pcm_slot_tx &&
 821                            member->dsp->pcm_slot_tx !=
 822                            member->dsp->pcm_slot_rx &&
 823                            member->dsp->pcm_bank_tx == 0 &&
 824                            member->dsp->pcm_bank_rx == 0 &&
 825                            nextm->dsp->pcm_bank_tx == 0 &&
 826                            nextm->dsp->pcm_bank_rx == 0) {
 827                                /* all members have same slot */
 828                                if (dsp_debug & DEBUG_DSP_CMX)
 829                                        printk(KERN_DEBUG
 830                                               "%s dsp %s & %s stay joined on PCM "
 831                                               "slot %d (TX) %d (RX) on same chip "
 832                                               "or one bank PCM)\n", __func__,
 833                                               member->dsp->name,
 834                                               nextm->dsp->name,
 835                                               member->dsp->pcm_slot_tx,
 836                                               member->dsp->pcm_slot_rx);
 837                                conf->hardware = 1;
 838                                conf->software = tx_data;
 839                                return;
 840                        }
 841                        /* find two new slot */
 842                        memset(freeslots, 1, sizeof(freeslots));
 843                        list_for_each_entry(dsp, &dsp_ilist, list) {
 844                                if (dsp != member->dsp &&
 845                                    dsp != nextm->dsp &&
 846                                    member->dsp->features.pcm_id ==
 847                                    dsp->features.pcm_id) {
 848                                        if (dsp->pcm_slot_rx >= 0 &&
 849                                            dsp->pcm_slot_rx <
 850                                            sizeof(freeslots))
 851                                                freeslots[dsp->pcm_slot_rx] = 0;
 852                                        if (dsp->pcm_slot_tx >= 0 &&
 853                                            dsp->pcm_slot_tx <
 854                                            sizeof(freeslots))
 855                                                freeslots[dsp->pcm_slot_tx] = 0;
 856                                }
 857                        }
 858                        i1 = 0;
 859                        ii = member->dsp->features.pcm_slots;
 860                        while (i1 < ii) {
 861                                if (freeslots[i1])
 862                                        break;
 863                                i1++;
 864                        }
 865                        if (i1 == ii) {
 866                                if (dsp_debug & DEBUG_DSP_CMX)
 867                                        printk(KERN_DEBUG
 868                                               "%s no slot available "
 869                                               "for %s & %s\n", __func__,
 870                                               member->dsp->name,
 871                                               nextm->dsp->name);
 872                                /* no more slots available */
 873                                goto conf_software;
 874                        }
 875                        i2 = i1 + 1;
 876                        while (i2 < ii) {
 877                                if (freeslots[i2])
 878                                        break;
 879                                i2++;
 880                        }
 881                        if (i2 == ii) {
 882                                if (dsp_debug & DEBUG_DSP_CMX)
 883                                        printk(KERN_DEBUG
 884                                               "%s no slot available "
 885                                               "for %s & %s\n",
 886                                               __func__,
 887                                               member->dsp->name,
 888                                               nextm->dsp->name);
 889                                /* no more slots available */
 890                                goto conf_software;
 891                        }
 892                        /* assign free slots */
 893                        member->dsp->pcm_slot_tx = i1;
 894                        member->dsp->pcm_slot_rx = i2;
 895                        nextm->dsp->pcm_slot_tx = i2;
 896                        nextm->dsp->pcm_slot_rx = i1;
 897                        member->dsp->pcm_bank_rx = 0;
 898                        member->dsp->pcm_bank_tx = 0;
 899                        nextm->dsp->pcm_bank_rx = 0;
 900                        nextm->dsp->pcm_bank_tx = 0;
 901                        if (dsp_debug & DEBUG_DSP_CMX)
 902                                printk(KERN_DEBUG
 903                                       "%s adding %s & %s to new PCM slot %d "
 904                                       "(TX) %d (RX) on same chip or one bank "
 905                                       "PCM, because both members have not "
 906                                       "crossed slots\n", __func__,
 907                                       member->dsp->name,
 908                                       nextm->dsp->name,
 909                                       member->dsp->pcm_slot_tx,
 910                                       member->dsp->pcm_slot_rx);
 911                        dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
 912                                           member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx,
 913                                           member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx);
 914                        dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN,
 915                                           nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx,
 916                                           nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx);
 917                        conf->hardware = 1;
 918                        conf->software = tx_data;
 919                        return;
 920                }
 921        }
 922
 923        /*
 924         * if we have more than two, we may check if we have a conference
 925         * unit available on the chip. also all members must be on the same
 926         */
 927
 928        /* if not the same HFC chip */
 929        if (same_hfc < 0) {
 930                if (dsp_debug & DEBUG_DSP_CMX)
 931                        printk(KERN_DEBUG
 932                               "%s conference %d cannot be formed, because "
 933                               "members are on different chips or not "
 934                               "on HFC chip\n",
 935                               __func__, conf->id);
 936                goto conf_software;
 937        }
 938
 939        /* for more than two members.. */
 940
 941        /* if all members already have the same conference */
 942        if (all_conf) {
 943                conf->hardware = 1;
 944                conf->software = tx_data;
 945                return;
 946        }
 947
 948        /*
 949         * if there is an existing conference, but not all members have joined
 950         */
 951        if (current_conf >= 0) {
 952        join_members:
 953                list_for_each_entry(member, &conf->mlist, list) {
 954                        /* if no conference engine on our chip, change to
 955                         * software */
 956                        if (!member->dsp->features.hfc_conf)
 957                                goto conf_software;
 958                        /* in case of hdlc, change to software */
 959                        if (member->dsp->hdlc)
 960                                goto conf_software;
 961                        /* join to current conference */
 962                        if (member->dsp->hfc_conf == current_conf)
 963                                continue;
 964                        /* get a free timeslot first */
 965                        memset(freeslots, 1, sizeof(freeslots));
 966                        list_for_each_entry(dsp, &dsp_ilist, list) {
 967                                /*
 968                                 * not checking current member, because
 969                                 * slot will be overwritten.
 970                                 */
 971                                if (
 972                                        dsp != member->dsp &&
 973                                        /* dsp must be on the same PCM */
 974                                        member->dsp->features.pcm_id ==
 975                                        dsp->features.pcm_id) {
 976                                        /* dsp must be on a slot */
 977                                        if (dsp->pcm_slot_tx >= 0 &&
 978                                            dsp->pcm_slot_tx <
 979                                            sizeof(freeslots))
 980                                                freeslots[dsp->pcm_slot_tx] = 0;
 981                                        if (dsp->pcm_slot_rx >= 0 &&
 982                                            dsp->pcm_slot_rx <
 983                                            sizeof(freeslots))
 984                                                freeslots[dsp->pcm_slot_rx] = 0;
 985                                }
 986                        }
 987                        i = 0;
 988                        ii = member->dsp->features.pcm_slots;
 989                        while (i < ii) {
 990                                if (freeslots[i])
 991                                        break;
 992                                i++;
 993                        }
 994                        if (i == ii) {
 995                                /* no more slots available */
 996                                if (dsp_debug & DEBUG_DSP_CMX)
 997                                        printk(KERN_DEBUG
 998                                               "%s conference %d cannot be formed,"
 999                                               " because no slot free\n",
1000                                               __func__, conf->id);
1001                                goto conf_software;
1002                        }
1003                        if (dsp_debug & DEBUG_DSP_CMX)
1004                                printk(KERN_DEBUG
1005                                       "%s changing dsp %s to HW conference "
1006                                       "%d slot %d\n", __func__,
1007                                       member->dsp->name, current_conf, i);
1008                        /* assign free slot & set PCM & join conf */
1009                        member->dsp->pcm_slot_tx = i;
1010                        member->dsp->pcm_slot_rx = i;
1011                        member->dsp->pcm_bank_tx = 2; /* loop */
1012                        member->dsp->pcm_bank_rx = 2;
1013                        member->dsp->hfc_conf = current_conf;
1014                        dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN,
1015                                           i, 2, i, 2);
1016                        dsp_cmx_hw_message(member->dsp,
1017                                           MISDN_CTRL_HFC_CONF_JOIN, current_conf, 0, 0, 0);
1018                }
1019                conf->hardware = 1;
1020                conf->software = tx_data;
1021                return;
1022        }
1023
1024        /*
1025         * no member is in a conference yet, so we find a free one
1026         */
1027        memset(freeunits, 1, sizeof(freeunits));
1028        list_for_each_entry(dsp, &dsp_ilist, list) {
1029                /* dsp must be on the same chip */
1030                if (dsp->features.hfc_id == same_hfc &&
1031                    /* dsp must have joined a HW conference */
1032                    dsp->hfc_conf >= 0 &&
1033                    /* slot must be within range */
1034                    dsp->hfc_conf < 8)
1035                        freeunits[dsp->hfc_conf] = 0;
1036        }
1037        i = 0;
1038        ii = 8;
1039        while (i < ii) {
1040                if (freeunits[i])
1041                        break;
1042                i++;
1043        }
1044        if (i == ii) {
1045                /* no more conferences available */
1046                if (dsp_debug & DEBUG_DSP_CMX)
1047                        printk(KERN_DEBUG
1048                               "%s conference %d cannot be formed, because "
1049                               "no conference number free\n",
1050                               __func__, conf->id);
1051                goto conf_software;
1052        }
1053        /* join all members */
1054        current_conf = i;
1055        goto join_members;
1056}
1057
1058
1059/*
1060 * conf_id != 0: join or change conference
1061 * conf_id == 0: split from conference if not already
1062 */
1063int
1064dsp_cmx_conf(struct dsp *dsp, u32 conf_id)
1065{
1066        int err;
1067        struct dsp_conf *conf;
1068        struct dsp_conf_member  *member;
1069
1070        /* if conference doesn't change */
1071        if (dsp->conf_id == conf_id)
1072                return 0;
1073
1074        /* first remove us from current conf */
1075        if (dsp->conf_id) {
1076                if (dsp_debug & DEBUG_DSP_CMX)
1077                        printk(KERN_DEBUG "removing us from conference %d\n",
1078                               dsp->conf->id);
1079                /* remove us from conf */
1080                conf = dsp->conf;
1081                err = dsp_cmx_del_conf_member(dsp);
1082                if (err)
1083                        return err;
1084                dsp->conf_id = 0;
1085
1086                /* update hardware */
1087                dsp_cmx_hardware(NULL, dsp);
1088
1089                /* conf now empty? */
1090                if (list_empty(&conf->mlist)) {
1091                        if (dsp_debug & DEBUG_DSP_CMX)
1092                                printk(KERN_DEBUG
1093                                       "conference is empty, so we remove it.\n");
1094                        err = dsp_cmx_del_conf(conf);
1095                        if (err)
1096                                return err;
1097                } else {
1098                        /* update members left on conf */
1099                        dsp_cmx_hardware(conf, NULL);
1100                }
1101        }
1102
1103        /* if split */
1104        if (!conf_id)
1105                return 0;
1106
1107        /* now add us to conf */
1108        if (dsp_debug & DEBUG_DSP_CMX)
1109                printk(KERN_DEBUG "searching conference %d\n",
1110                       conf_id);
1111        conf = dsp_cmx_search_conf(conf_id);
1112        if (!conf) {
1113                if (dsp_debug & DEBUG_DSP_CMX)
1114                        printk(KERN_DEBUG
1115                               "conference doesn't exist yet, creating.\n");
1116                /* the conference doesn't exist, so we create */
1117                conf = dsp_cmx_new_conf(conf_id);
1118                if (!conf)
1119                        return -EINVAL;
1120        } else if (!list_empty(&conf->mlist)) {
1121                member = list_entry(conf->mlist.next, struct dsp_conf_member,
1122                                    list);
1123                if (dsp->hdlc && !member->dsp->hdlc) {
1124                        if (dsp_debug & DEBUG_DSP_CMX)
1125                                printk(KERN_DEBUG
1126                                       "cannot join transparent conference.\n");
1127                        return -EINVAL;
1128                }
1129                if (!dsp->hdlc && member->dsp->hdlc) {
1130                        if (dsp_debug & DEBUG_DSP_CMX)
1131                                printk(KERN_DEBUG
1132                                       "cannot join hdlc conference.\n");
1133                        return -EINVAL;
1134                }
1135        }
1136        /* add conference member */
1137        err = dsp_cmx_add_conf_member(dsp, conf);
1138        if (err)
1139                return err;
1140        dsp->conf_id = conf_id;
1141
1142        /* if we are alone, we do nothing! */
1143        if (list_empty(&conf->mlist)) {
1144                if (dsp_debug & DEBUG_DSP_CMX)
1145                        printk(KERN_DEBUG
1146                               "we are alone in this conference, so exit.\n");
1147                /* update hardware */
1148                dsp_cmx_hardware(NULL, dsp);
1149                return 0;
1150        }
1151
1152        /* update members on conf */
1153        dsp_cmx_hardware(conf, NULL);
1154
1155        return 0;
1156}
1157
1158#ifdef CMX_DELAY_DEBUG
1159int delaycount;
1160static void
1161showdelay(struct dsp *dsp, int samples, int delay)
1162{
1163        char bar[] = "--------------------------------------------------|";
1164        int sdelay;
1165
1166        delaycount += samples;
1167        if (delaycount < 8000)
1168                return;
1169        delaycount = 0;
1170
1171        sdelay = delay * 50 / (dsp_poll << 2);
1172
1173        printk(KERN_DEBUG "DELAY (%s) %3d >%s\n", dsp->name, delay,
1174               sdelay > 50 ? "..." : bar + 50 - sdelay);
1175}
1176#endif
1177
1178/*
1179 * audio data is received from card
1180 */
1181void
1182dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb)
1183{
1184        u8 *d, *p;
1185        int len = skb->len;
1186        struct mISDNhead *hh = mISDN_HEAD_P(skb);
1187        int w, i, ii;
1188
1189        /* check if we have sompen */
1190        if (len < 1)
1191                return;
1192
1193        /* half of the buffer should be larger than maximum packet size */
1194        if (len >= CMX_BUFF_HALF) {
1195                printk(KERN_ERR
1196                       "%s line %d: packet from card is too large (%d bytes). "
1197                       "please make card send smaller packets OR increase "
1198                       "CMX_BUFF_SIZE\n", __FILE__, __LINE__, len);
1199                return;
1200        }
1201
1202        /*
1203         * initialize pointers if not already -
1204         * also add delay if requested by PH_SIGNAL
1205         */
1206        if (dsp->rx_init) {
1207                dsp->rx_init = 0;
1208                if (dsp->features.unordered) {
1209                        dsp->rx_R = (hh->id & CMX_BUFF_MASK);
1210                        if (dsp->cmx_delay)
1211                                dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
1212                                        & CMX_BUFF_MASK;
1213                        else
1214                                dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1))
1215                                        & CMX_BUFF_MASK;
1216                } else {
1217                        dsp->rx_R = 0;
1218                        if (dsp->cmx_delay)
1219                                dsp->rx_W = dsp->cmx_delay;
1220                        else
1221                                dsp->rx_W = dsp_poll >> 1;
1222                }
1223        }
1224        /* if frame contains time code, write directly */
1225        if (dsp->features.unordered) {
1226                dsp->rx_W = (hh->id & CMX_BUFF_MASK);
1227                /* printk(KERN_DEBUG "%s %08x\n", dsp->name, hh->id); */
1228        }
1229        /*
1230         * if we underrun (or maybe overrun),
1231         * we set our new read pointer, and write silence to buffer
1232         */
1233        if (((dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK) >= CMX_BUFF_HALF) {
1234                if (dsp_debug & DEBUG_DSP_CLOCK)
1235                        printk(KERN_DEBUG
1236                               "cmx_receive(dsp=%lx): UNDERRUN (or overrun the "
1237                               "maximum delay), adjusting read pointer! "
1238                               "(inst %s)\n", (u_long)dsp, dsp->name);
1239                /* flush rx buffer and set delay to dsp_poll / 2 */
1240                if (dsp->features.unordered) {
1241                        dsp->rx_R = (hh->id & CMX_BUFF_MASK);
1242                        if (dsp->cmx_delay)
1243                                dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
1244                                        & CMX_BUFF_MASK;
1245                        else
1246                                dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1))
1247                                        & CMX_BUFF_MASK;
1248                } else {
1249                        dsp->rx_R = 0;
1250                        if (dsp->cmx_delay)
1251                                dsp->rx_W = dsp->cmx_delay;
1252                        else
1253                                dsp->rx_W = dsp_poll >> 1;
1254                }
1255                memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
1256        }
1257        /* if we have reached double delay, jump back to middle */
1258        if (dsp->cmx_delay)
1259                if (((dsp->rx_W - dsp->rx_R) & CMX_BUFF_MASK) >=
1260                    (dsp->cmx_delay << 1)) {
1261                        if (dsp_debug & DEBUG_DSP_CLOCK)
1262                                printk(KERN_DEBUG
1263                                       "cmx_receive(dsp=%lx): OVERRUN (because "
1264                                       "twice the delay is reached), adjusting "
1265                                       "read pointer! (inst %s)\n",
1266                                       (u_long)dsp, dsp->name);
1267                        /* flush buffer */
1268                        if (dsp->features.unordered) {
1269                                dsp->rx_R = (hh->id & CMX_BUFF_MASK);
1270                                dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
1271                                        & CMX_BUFF_MASK;
1272                        } else {
1273                                dsp->rx_R = 0;
1274                                dsp->rx_W = dsp->cmx_delay;
1275                        }
1276                        memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
1277                }
1278
1279        /* show where to write */
1280#ifdef CMX_DEBUG
1281        printk(KERN_DEBUG
1282               "cmx_receive(dsp=%lx): rx_R(dsp)=%05x rx_W(dsp)=%05x len=%d %s\n",
1283               (u_long)dsp, dsp->rx_R, dsp->rx_W, len, dsp->name);
1284#endif
1285
1286        /* write data into rx_buffer */
1287        p = skb->data;
1288        d = dsp->rx_buff;
1289        w = dsp->rx_W;
1290        i = 0;
1291        ii = len;
1292        while (i < ii) {
1293                d[w++ & CMX_BUFF_MASK] = *p++;
1294                i++;
1295        }
1296
1297        /* increase write-pointer */
1298        dsp->rx_W = ((dsp->rx_W + len) & CMX_BUFF_MASK);
1299#ifdef CMX_DELAY_DEBUG
1300        showdelay(dsp, len, (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK);
1301#endif
1302}
1303
1304
1305/*
1306 * send (mixed) audio data to card and control jitter
1307 */
1308static void
1309dsp_cmx_send_member(struct dsp *dsp, int len, s32 *c, int members)
1310{
1311        struct dsp_conf *conf = dsp->conf;
1312        struct dsp *member, *other;
1313        register s32 sample;
1314        u8 *d, *p, *q, *o_q;
1315        struct sk_buff *nskb, *txskb;
1316        int r, rr, t, tt, o_r, o_rr;
1317        int preload = 0;
1318        struct mISDNhead *hh, *thh;
1319        int tx_data_only = 0;
1320
1321        /* don't process if: */
1322        if (!dsp->b_active) { /* if not active */
1323                dsp->last_tx = 0;
1324                return;
1325        }
1326        if (((dsp->conf && dsp->conf->hardware) || /* hardware conf */
1327             dsp->echo.hardware) && /* OR hardware echo */
1328            dsp->tx_R == dsp->tx_W && /* AND no tx-data */
1329            !(dsp->tone.tone && dsp->tone.software)) { /* AND not soft tones */
1330                if (!dsp->tx_data) { /* no tx_data for user space required */
1331                        dsp->last_tx = 0;
1332                        return;
1333                }
1334                if (dsp->conf && dsp->conf->software && dsp->conf->hardware)
1335                        tx_data_only = 1;
1336                if (dsp->echo.software && dsp->echo.hardware)
1337                        tx_data_only = 1;
1338        }
1339
1340#ifdef CMX_DEBUG
1341        printk(KERN_DEBUG
1342               "SEND members=%d dsp=%s, conf=%p, rx_R=%05x rx_W=%05x\n",
1343               members, dsp->name, conf, dsp->rx_R, dsp->rx_W);
1344#endif
1345
1346        /* preload if we have delay set */
1347        if (dsp->cmx_delay && !dsp->last_tx) {
1348                preload = len;
1349                if (preload < 128)
1350                        preload = 128;
1351        }
1352
1353        /* PREPARE RESULT */
1354        nskb = mI_alloc_skb(len + preload, GFP_ATOMIC);
1355        if (!nskb) {
1356                printk(KERN_ERR
1357                       "FATAL ERROR in mISDN_dsp.o: cannot alloc %d bytes\n",
1358                       len + preload);
1359                return;
1360        }
1361        hh = mISDN_HEAD_P(nskb);
1362        hh->prim = PH_DATA_REQ;
1363        hh->id = 0;
1364        dsp->last_tx = 1;
1365
1366        /* set pointers, indexes and stuff */
1367        member = dsp;
1368        p = dsp->tx_buff; /* transmit data */
1369        q = dsp->rx_buff; /* received data */
1370        d = skb_put(nskb, preload + len); /* result */
1371        t = dsp->tx_R; /* tx-pointers */
1372        tt = dsp->tx_W;
1373        r = dsp->rx_R; /* rx-pointers */
1374        rr = (r + len) & CMX_BUFF_MASK;
1375
1376        /* preload with silence, if required */
1377        if (preload) {
1378                memset(d, dsp_silence, preload);
1379                d += preload;
1380        }
1381
1382        /* PROCESS TONES/TX-DATA ONLY */
1383        if (dsp->tone.tone && dsp->tone.software) {
1384                /* -> copy tone */
1385                dsp_tone_copy(dsp, d, len);
1386                dsp->tx_R = 0; /* clear tx buffer */
1387                dsp->tx_W = 0;
1388                goto send_packet;
1389        }
1390        /* if we have tx-data but do not use mixing */
1391        if (!dsp->tx_mix && t != tt) {
1392                /* -> send tx-data and continue when not enough */
1393#ifdef CMX_TX_DEBUG
1394                sprintf(debugbuf, "TX sending (%04x-%04x)%p: ", t, tt, p);
1395#endif
1396                while (r != rr && t != tt) {
1397#ifdef CMX_TX_DEBUG
1398                        if (strlen(debugbuf) < 48)
1399                                sprintf(debugbuf + strlen(debugbuf), " %02x",
1400                                        p[t]);
1401#endif
1402                        *d++ = p[t]; /* write tx_buff */
1403                        t = (t + 1) & CMX_BUFF_MASK;
1404                        r = (r + 1) & CMX_BUFF_MASK;
1405                }
1406                if (r == rr) {
1407                        dsp->tx_R = t;
1408#ifdef CMX_TX_DEBUG
1409                        printk(KERN_DEBUG "%s\n", debugbuf);
1410#endif
1411                        goto send_packet;
1412                }
1413        }
1414#ifdef CMX_TX_DEBUG
1415        printk(KERN_DEBUG "%s\n", debugbuf);
1416#endif
1417
1418        /* PROCESS DATA (one member / no conf) */
1419        if (!conf || members <= 1) {
1420                /* -> if echo is NOT enabled */
1421                if (!dsp->echo.software) {
1422                        /* -> send tx-data if available or use 0-volume */
1423                        while (r != rr && t != tt) {
1424                                *d++ = p[t]; /* write tx_buff */
1425                                t = (t + 1) & CMX_BUFF_MASK;
1426                                r = (r + 1) & CMX_BUFF_MASK;
1427                        }
1428                        if (r != rr) {
1429                                if (dsp_debug & DEBUG_DSP_CLOCK)
1430                                        printk(KERN_DEBUG "%s: RX empty\n",
1431                                               __func__);
1432                                memset(d, dsp_silence, (rr - r) & CMX_BUFF_MASK);
1433                        }
1434                        /* -> if echo is enabled */
1435                } else {
1436                        /*
1437                         * -> mix tx-data with echo if available,
1438                         * or use echo only
1439                         */
1440                        while (r != rr && t != tt) {
1441                                *d++ = dsp_audio_mix_law[(p[t] << 8) | q[r]];
1442                                t = (t + 1) & CMX_BUFF_MASK;
1443                                r = (r + 1) & CMX_BUFF_MASK;
1444                        }
1445                        while (r != rr) {
1446                                *d++ = q[r]; /* echo */
1447                                r = (r + 1) & CMX_BUFF_MASK;
1448                        }
1449                }
1450                dsp->tx_R = t;
1451                goto send_packet;
1452        }
1453        /* PROCESS DATA (two members) */
1454#ifdef CMX_CONF_DEBUG
1455        if (0) {
1456#else
1457                if (members == 2) {
1458#endif
1459                        /* "other" becomes other party */
1460                        other = (list_entry(conf->mlist.next,
1461                                            struct dsp_conf_member, list))->dsp;
1462                        if (other == member)
1463                                other = (list_entry(conf->mlist.prev,
1464                                                    struct dsp_conf_member, list))->dsp;
1465                        o_q = other->rx_buff; /* received data */
1466                        o_rr = (other->rx_R + len) & CMX_BUFF_MASK;
1467                        /* end of rx-pointer */
1468                        o_r = (o_rr - rr + r) & CMX_BUFF_MASK;
1469                        /* start rx-pointer at current read position*/
1470                        /* -> if echo is NOT enabled */
1471                        if (!dsp->echo.software) {
1472                                /*
1473                                 * -> copy other member's rx-data,
1474                                 * if tx-data is available, mix
1475                                 */
1476                                while (o_r != o_rr && t != tt) {
1477                                        *d++ = dsp_audio_mix_law[(p[t] << 8) | o_q[o_r]];
1478                                        t = (t + 1) & CMX_BUFF_MASK;
1479                                        o_r = (o_r + 1) & CMX_BUFF_MASK;
1480                                }
1481                                while (o_r != o_rr) {
1482                                        *d++ = o_q[o_r];
1483                                        o_r = (o_r + 1) & CMX_BUFF_MASK;
1484                                }
1485                                /* -> if echo is enabled */
1486                        } else {
1487                                /*
1488                                 * -> mix other member's rx-data with echo,
1489                                 * if tx-data is available, mix
1490                                 */
1491                                while (r != rr && t != tt) {
1492                                        sample = dsp_audio_law_to_s32[p[t]] +
1493                                                dsp_audio_law_to_s32[q[r]] +
1494                                                dsp_audio_law_to_s32[o_q[o_r]];
1495                                        if (sample < -32768)
1496                                                sample = -32768;
1497                                        else if (sample > 32767)
1498                                                sample = 32767;
1499                                        *d++ = dsp_audio_s16_to_law[sample & 0xffff];
1500                                        /* tx-data + rx_data + echo */
1501                                        t = (t + 1) & CMX_BUFF_MASK;
1502                                        r = (r + 1) & CMX_BUFF_MASK;
1503                                        o_r = (o_r + 1) & CMX_BUFF_MASK;
1504                                }
1505                                while (r != rr) {
1506                                        *d++ = dsp_audio_mix_law[(q[r] << 8) | o_q[o_r]];
1507                                        r = (r + 1) & CMX_BUFF_MASK;
1508                                        o_r = (o_r + 1) & CMX_BUFF_MASK;
1509                                }
1510                        }
1511                        dsp->tx_R = t;
1512                        goto send_packet;
1513                }
1514#ifdef DSP_NEVER_DEFINED
1515        }
1516#endif
1517        /* PROCESS DATA (three or more members) */
1518        /* -> if echo is NOT enabled */
1519        if (!dsp->echo.software) {
1520                /*
1521                 * -> subtract rx-data from conf-data,
1522                 * if tx-data is available, mix
1523                 */
1524                while (r != rr && t != tt) {
1525                        sample = dsp_audio_law_to_s32[p[t]] + *c++ -
1526                                dsp_audio_law_to_s32[q[r]];
1527                        if (sample < -32768)
1528                                sample = -32768;
1529                        else if (sample > 32767)
1530                                sample = 32767;
1531                        *d++ = dsp_audio_s16_to_law[sample & 0xffff];
1532                        /* conf-rx+tx */
1533                        r = (r + 1) & CMX_BUFF_MASK;
1534                        t = (t + 1) & CMX_BUFF_MASK;
1535                }
1536                while (r != rr) {
1537                        sample = *c++ - dsp_audio_law_to_s32[q[r]];
1538                        if (sample < -32768)
1539                                sample = -32768;
1540                        else if (sample > 32767)
1541                                sample = 32767;
1542                        *d++ = dsp_audio_s16_to_law[sample & 0xffff];
1543                        /* conf-rx */
1544                        r = (r + 1) & CMX_BUFF_MASK;
1545                }
1546                /* -> if echo is enabled */
1547        } else {
1548                /*
1549                 * -> encode conf-data, if tx-data
1550                 * is available, mix
1551                 */
1552                while (r != rr && t != tt) {
1553                        sample = dsp_audio_law_to_s32[p[t]] + *c++;
1554                        if (sample < -32768)
1555                                sample = -32768;
1556                        else if (sample > 32767)
1557                                sample = 32767;
1558                        *d++ = dsp_audio_s16_to_law[sample & 0xffff];
1559                        /* conf(echo)+tx */
1560                        t = (t + 1) & CMX_BUFF_MASK;
1561                        r = (r + 1) & CMX_BUFF_MASK;
1562                }
1563                while (r != rr) {
1564                        sample = *c++;
1565                        if (sample < -32768)
1566                                sample = -32768;
1567                        else if (sample > 32767)
1568                                sample = 32767;
1569                        *d++ = dsp_audio_s16_to_law[sample & 0xffff];
1570                        /* conf(echo) */
1571                        r = (r + 1) & CMX_BUFF_MASK;
1572                }
1573        }
1574        dsp->tx_R = t;
1575        goto send_packet;
1576
1577send_packet:
1578        /*
1579         * send tx-data if enabled - don't filter,
1580         * because we want what we send, not what we filtered
1581         */
1582        if (dsp->tx_data) {
1583                if (tx_data_only) {
1584                        hh->prim = DL_DATA_REQ;
1585                        hh->id = 0;
1586                        /* queue and trigger */
1587                        skb_queue_tail(&dsp->sendq, nskb);
1588                        schedule_work(&dsp->workq);
1589                        /* exit because only tx_data is used */
1590                        return;
1591                } else {
1592                        txskb = mI_alloc_skb(len, GFP_ATOMIC);
1593                        if (!txskb) {
1594                                printk(KERN_ERR
1595                                       "FATAL ERROR in mISDN_dsp.o: "
1596                                       "cannot alloc %d bytes\n", len);
1597                        } else {
1598                                thh = mISDN_HEAD_P(txskb);
1599                                thh->prim = DL_DATA_REQ;
1600                                thh->id = 0;
1601                                memcpy(skb_put(txskb, len), nskb->data + preload,
1602                                       len);
1603                                /* queue (trigger later) */
1604                                skb_queue_tail(&dsp->sendq, txskb);
1605                        }
1606                }
1607        }
1608
1609        /* send data only to card, if we don't just calculated tx_data */
1610        /* adjust volume */
1611        if (dsp->tx_volume)
1612                dsp_change_volume(nskb, dsp->tx_volume);
1613        /* pipeline */
1614        if (dsp->pipeline.inuse)
1615                dsp_pipeline_process_tx(&dsp->pipeline, nskb->data,
1616                                        nskb->len);
1617        /* crypt */
1618        if (dsp->bf_enable)
1619                dsp_bf_encrypt(dsp, nskb->data, nskb->len);
1620        /* queue and trigger */
1621        skb_queue_tail(&dsp->sendq, nskb);
1622        schedule_work(&dsp->workq);
1623}
1624
1625static u32      jittercount; /* counter for jitter check */
1626struct timer_list dsp_spl_tl;
1627unsigned long   dsp_spl_jiffies; /* calculate the next time to fire */
1628static u16      dsp_count; /* last sample count */
1629static int      dsp_count_valid; /* if we have last sample count */
1630
1631void
1632dsp_cmx_send(void *arg)
1633{
1634        struct dsp_conf *conf;
1635        struct dsp_conf_member *member;
1636        struct dsp *dsp;
1637        int mustmix, members;
1638        static s32 mixbuffer[MAX_POLL + 100];
1639        s32 *c;
1640        u8 *p, *q;
1641        int r, rr;
1642        int jittercheck = 0, delay, i;
1643        u_long flags;
1644        u16 length, count;
1645
1646        /* lock */
1647        spin_lock_irqsave(&dsp_lock, flags);
1648
1649        if (!dsp_count_valid) {
1650                dsp_count = mISDN_clock_get();
1651                length = dsp_poll;
1652                dsp_count_valid = 1;
1653        } else {
1654                count = mISDN_clock_get();
1655                length = count - dsp_count;
1656                dsp_count = count;
1657        }
1658        if (length > MAX_POLL + 100)
1659                length = MAX_POLL + 100;
1660        /* printk(KERN_DEBUG "len=%d dsp_count=0x%x\n", length, dsp_count); */
1661
1662        /*
1663         * check if jitter needs to be checked (this is every second)
1664         */
1665        jittercount += length;
1666        if (jittercount >= 8000) {
1667                jittercount -= 8000;
1668                jittercheck = 1;
1669        }
1670
1671        /* loop all members that do not require conference mixing */
1672        list_for_each_entry(dsp, &dsp_ilist, list) {
1673                if (dsp->hdlc)
1674                        continue;
1675                conf = dsp->conf;
1676                mustmix = 0;
1677                members = 0;
1678                if (conf) {
1679                        members = count_list_member(&conf->mlist);
1680#ifdef CMX_CONF_DEBUG
1681                        if (conf->software && members > 1)
1682#else
1683                                if (conf->software && members > 2)
1684#endif
1685                                        mustmix = 1;
1686                }
1687
1688                /* transmission required */
1689                if (!mustmix) {
1690                        dsp_cmx_send_member(dsp, length, mixbuffer, members);
1691
1692                        /*
1693                         * unused mixbuffer is given to prevent a
1694                         * potential null-pointer-bug
1695                         */
1696                }
1697        }
1698
1699        /* loop all members that require conference mixing */
1700        list_for_each_entry(conf, &conf_ilist, list) {
1701                /* count members and check hardware */
1702                members = count_list_member(&conf->mlist);
1703#ifdef CMX_CONF_DEBUG
1704                if (conf->software && members > 1) {
1705#else
1706                        if (conf->software && members > 2) {
1707#endif
1708                                /* check for hdlc conf */
1709                                member = list_entry(conf->mlist.next,
1710                                                    struct dsp_conf_member, list);
1711                                if (member->dsp->hdlc)
1712                                        continue;
1713                                /* mix all data */
1714                                memset(mixbuffer, 0, length * sizeof(s32));
1715                                list_for_each_entry(member, &conf->mlist, list) {
1716                                        dsp = member->dsp;
1717                                        /* get range of data to mix */
1718                                        c = mixbuffer;
1719                                        q = dsp->rx_buff;
1720                                        r = dsp->rx_R;
1721                                        rr = (r + length) & CMX_BUFF_MASK;
1722                                        /* add member's data */
1723                                        while (r != rr) {
1724                                                *c++ += dsp_audio_law_to_s32[q[r]];
1725                                                r = (r + 1) & CMX_BUFF_MASK;
1726                                        }
1727                                }
1728
1729                                /* process each member */
1730                                list_for_each_entry(member, &conf->mlist, list) {
1731                                        /* transmission */
1732                                        dsp_cmx_send_member(member->dsp, length,
1733                                                            mixbuffer, members);
1734                                }
1735                        }
1736                }
1737
1738                /* delete rx-data, increment buffers, change pointers */
1739                list_for_each_entry(dsp, &dsp_ilist, list) {
1740                        if (dsp->hdlc)
1741                                continue;
1742                        p = dsp->rx_buff;
1743                        q = dsp->tx_buff;
1744                        r = dsp->rx_R;
1745                        /* move receive pointer when receiving */
1746                        if (!dsp->rx_is_off) {
1747                                rr = (r + length) & CMX_BUFF_MASK;
1748                                /* delete rx-data */
1749                                while (r != rr) {
1750                                        p[r] = dsp_silence;
1751                                        r = (r + 1) & CMX_BUFF_MASK;
1752                                }
1753                                /* increment rx-buffer pointer */
1754                                dsp->rx_R = r; /* write incremented read pointer */
1755                        }
1756
1757                        /* check current rx_delay */
1758                        delay = (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK;
1759                        if (delay >= CMX_BUFF_HALF)
1760                                delay = 0; /* will be the delay before next write */
1761                        /* check for lower delay */
1762                        if (delay < dsp->rx_delay[0])
1763                                dsp->rx_delay[0] = delay;
1764                        /* check current tx_delay */
1765                        delay = (dsp->tx_W-dsp->tx_R) & CMX_BUFF_MASK;
1766                        if (delay >= CMX_BUFF_HALF)
1767                                delay = 0; /* will be the delay before next write */
1768                        /* check for lower delay */
1769                        if (delay < dsp->tx_delay[0])
1770                                dsp->tx_delay[0] = delay;
1771                        if (jittercheck) {
1772                                /* find the lowest of all rx_delays */
1773                                delay = dsp->rx_delay[0];
1774                                i = 1;
1775                                while (i < MAX_SECONDS_JITTER_CHECK) {
1776                                        if (delay > dsp->rx_delay[i])
1777                                                delay = dsp->rx_delay[i];
1778                                        i++;
1779                                }
1780                                /*
1781                                 * remove rx_delay only if we have delay AND we
1782                                 * have not preset cmx_delay AND
1783                                 * the delay is greater dsp_poll
1784                                 */
1785                                if (delay > dsp_poll && !dsp->cmx_delay) {
1786                                        if (dsp_debug & DEBUG_DSP_CLOCK)
1787                                                printk(KERN_DEBUG
1788                                                       "%s lowest rx_delay of %d bytes for"
1789                                                       " dsp %s are now removed.\n",
1790                                                       __func__, delay,
1791                                                       dsp->name);
1792                                        r = dsp->rx_R;
1793                                        rr = (r + delay - (dsp_poll >> 1))
1794                                                & CMX_BUFF_MASK;
1795                                        /* delete rx-data */
1796                                        while (r != rr) {
1797                                                p[r] = dsp_silence;
1798                                                r = (r + 1) & CMX_BUFF_MASK;
1799                                        }
1800                                        /* increment rx-buffer pointer */
1801                                        dsp->rx_R = r;
1802                                        /* write incremented read pointer */
1803                                }
1804                                /* find the lowest of all tx_delays */
1805                                delay = dsp->tx_delay[0];
1806                                i = 1;
1807                                while (i < MAX_SECONDS_JITTER_CHECK) {
1808                                        if (delay > dsp->tx_delay[i])
1809                                                delay = dsp->tx_delay[i];
1810                                        i++;
1811                                }
1812                                /*
1813                                 * remove delay only if we have delay AND we
1814                                 * have enabled tx_dejitter
1815                                 */
1816                                if (delay > dsp_poll && dsp->tx_dejitter) {
1817                                        if (dsp_debug & DEBUG_DSP_CLOCK)
1818                                                printk(KERN_DEBUG
1819                                                       "%s lowest tx_delay of %d bytes for"
1820                                                       " dsp %s are now removed.\n",
1821                                                       __func__, delay,
1822                                                       dsp->name);
1823                                        r = dsp->tx_R;
1824                                        rr = (r + delay - (dsp_poll >> 1))
1825                                                & CMX_BUFF_MASK;
1826                                        /* delete tx-data */
1827                                        while (r != rr) {
1828                                                q[r] = dsp_silence;
1829                                                r = (r + 1) & CMX_BUFF_MASK;
1830                                        }
1831                                        /* increment rx-buffer pointer */
1832                                        dsp->tx_R = r;
1833                                        /* write incremented read pointer */
1834                                }
1835                                /* scroll up delays */
1836                                i = MAX_SECONDS_JITTER_CHECK - 1;
1837                                while (i) {
1838                                        dsp->rx_delay[i] = dsp->rx_delay[i - 1];
1839                                        dsp->tx_delay[i] = dsp->tx_delay[i - 1];
1840                                        i--;
1841                                }
1842                                dsp->tx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */
1843                                dsp->rx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */
1844                        }
1845                }
1846
1847                /* if next event would be in the past ... */
1848                if ((s32)(dsp_spl_jiffies + dsp_tics-jiffies) <= 0)
1849                        dsp_spl_jiffies = jiffies + 1;
1850                else
1851                        dsp_spl_jiffies += dsp_tics;
1852
1853                dsp_spl_tl.expires = dsp_spl_jiffies;
1854                add_timer(&dsp_spl_tl);
1855
1856                /* unlock */
1857                spin_unlock_irqrestore(&dsp_lock, flags);
1858        }
1859
1860/*
1861 * audio data is transmitted from upper layer to the dsp
1862 */
1863        void
1864                dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb)
1865        {
1866                u_int w, ww;
1867                u8 *d, *p;
1868                int space; /* todo: , l = skb->len; */
1869#ifdef CMX_TX_DEBUG
1870                char debugbuf[256] = "";
1871#endif
1872
1873                /* check if there is enough space, and then copy */
1874                w = dsp->tx_W;
1875                ww = dsp->tx_R;
1876                p = dsp->tx_buff;
1877                d = skb->data;
1878                space = (ww - w - 1) & CMX_BUFF_MASK;
1879                /* write-pointer should not overrun nor reach read pointer */
1880                if (space < skb->len) {
1881                        /* write to the space we have left */
1882                        ww = (ww - 1) & CMX_BUFF_MASK; /* end one byte prior tx_R */
1883                        if (dsp_debug & DEBUG_DSP_CLOCK)
1884                                printk(KERN_DEBUG "%s: TX overflow space=%d skb->len="
1885                                       "%d, w=0x%04x, ww=0x%04x\n", __func__, space,
1886                                       skb->len, w, ww);
1887                } else
1888                        /* write until all byte are copied */
1889                        ww = (w + skb->len) & CMX_BUFF_MASK;
1890                dsp->tx_W = ww;
1891
1892                /* show current buffer */
1893#ifdef CMX_DEBUG
1894                printk(KERN_DEBUG
1895                       "cmx_transmit(dsp=%lx) %d bytes to 0x%x-0x%x. %s\n",
1896                       (u_long)dsp, (ww - w) & CMX_BUFF_MASK, w, ww, dsp->name);
1897#endif
1898
1899                /* copy transmit data to tx-buffer */
1900#ifdef CMX_TX_DEBUG
1901                sprintf(debugbuf, "TX getting (%04x-%04x)%p: ", w, ww, p);
1902#endif
1903                while (w != ww) {
1904#ifdef CMX_TX_DEBUG
1905                        if (strlen(debugbuf) < 48)
1906                                sprintf(debugbuf + strlen(debugbuf), " %02x", *d);
1907#endif
1908                        p[w] = *d++;
1909                        w = (w + 1) & CMX_BUFF_MASK;
1910                }
1911#ifdef CMX_TX_DEBUG
1912                printk(KERN_DEBUG "%s\n", debugbuf);
1913#endif
1914
1915        }
1916
1917/*
1918 * hdlc data is received from card and sent to all members.
1919 */
1920        void
1921                dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb)
1922        {
1923                struct sk_buff *nskb = NULL;
1924                struct dsp_conf_member *member;
1925                struct mISDNhead *hh;
1926
1927                /* not if not active */
1928                if (!dsp->b_active)
1929                        return;
1930
1931                /* check if we have sompen */
1932                if (skb->len < 1)
1933                        return;
1934
1935                /* no conf */
1936                if (!dsp->conf) {
1937                        /* in case of software echo */
1938                        if (dsp->echo.software) {
1939                                nskb = skb_clone(skb, GFP_ATOMIC);
1940                                if (nskb) {
1941                                        hh = mISDN_HEAD_P(nskb);
1942                                        hh->prim = PH_DATA_REQ;
1943                                        hh->id = 0;
1944                                        skb_queue_tail(&dsp->sendq, nskb);
1945                                        schedule_work(&dsp->workq);
1946                                }
1947                        }
1948                        return;
1949                }
1950                /* in case of hardware conference */
1951                if (dsp->conf->hardware)
1952                        return;
1953                list_for_each_entry(member, &dsp->conf->mlist, list) {
1954                        if (dsp->echo.software || member->dsp != dsp) {
1955                                nskb = skb_clone(skb, GFP_ATOMIC);
1956                                if (nskb) {
1957                                        hh = mISDN_HEAD_P(nskb);
1958                                        hh->prim = PH_DATA_REQ;
1959                                        hh->id = 0;
1960                                        skb_queue_tail(&member->dsp->sendq, nskb);
1961                                        schedule_work(&member->dsp->workq);
1962                                }
1963                        }
1964                }
1965        }
1966