drivers/staging/echo/fir.h

   1 /*
   2  * SpanDSP - a series of DSP components for telephony
   3  *
   4  * fir.h - General telephony FIR routines
   5  *
   6  * Written by Steve Underwood <steveu@coppice.org>
   7  *
   8  * Copyright (C) 2002 Steve Underwood
   9  *
  10  * All rights reserved.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License version 2, as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  * $Id: fir.h,v 1.8 2006/10/24 13:45:28 steveu Exp $
  26  */
  27
  28 /*! \page fir_page FIR filtering
  29 \section fir_page_sec_1 What does it do?
  30 ???.
  31
  32 \section fir_page_sec_2 How does it work?
  33 ???.
  34 */
  35
  36 #if !defined(_FIR_H_)
  37 #define _FIR_H_
  38
  39 /*
  40    Blackfin NOTES & IDEAS:
  41
  42    A simple dot product function is used to implement the filter.  This performs
  43    just one MAC/cycle which is inefficient but was easy to implement as a first
  44    pass.  The current Blackfin code also uses an unrolled form of the filter
  45    history to avoid 0 length hardware loop issues.  This is wasteful of
  46    memory.
  47
  48    Ideas for improvement:
  49
  50    1/ Rewrite filter for dual MAC inner loop.  The issue here is handling
  51    history sample offsets that are 16 bit aligned - the dual MAC needs
  52    32 bit aligmnent.  There are some good examples in libbfdsp.
  53
  54    2/ Use the hardware circular buffer facility tohalve memory usage.
  55
  56    3/ Consider using internal memory.
  57
  58    Using less memory might also improve speed as cache misses will be
  59    reduced. A drop in MIPs and memory approaching 50% should be
  60    possible.
  61
  62    The foreground and background filters currenlty use a total of
  63    about 10 MIPs/ch as measured with speedtest.c on a 256 TAP echo
  64    can.
  65 */
  66
  67 #if defined(USE_MMX)  ||  defined(USE_SSE2)
  68 #include "mmx.h"
  69 #endif
  70
  71 /*!
  72     16 bit integer FIR descriptor. This defines the working state for a single
  73     instance of an FIR filter using 16 bit integer coefficients.
  74 */
  75 typedef struct
  76 {
  77         int taps;
  78         int curr_pos;
  79         const int16_t *coeffs;
  80         int16_t *history;
  81 } fir16_state_t;
  82
  83 /*!
  84     32 bit integer FIR descriptor. This defines the working state for a single
  85     instance of an FIR filter using 32 bit integer coefficients, and filtering
  86     16 bit integer data.
  87 */
  88 typedef struct
  89 {
  90         int taps;
  91         int curr_pos;
  92         const int32_t *coeffs;
  93         int16_t *history;
  94 } fir32_state_t;
  95
  96 /*!
  97     Floating point FIR descriptor. This defines the working state for a single
  98     instance of an FIR filter using floating point coefficients and data.
  99 */
 100 typedef struct
 101 {
 102         int taps;
 103         int curr_pos;
 104         const float *coeffs;
 105         float *history;
 106 } fir_float_state_t;
 107
 108 static __inline__ const int16_t *fir16_create(fir16_state_t *fir,
 109                                               const int16_t *coeffs,
 110                                               int taps)
 111 {
 112         fir->taps = taps;
 113         fir->curr_pos = taps - 1;
 114         fir->coeffs = coeffs;
 115 #if defined(USE_MMX)  ||  defined(USE_SSE2) || defined(__bfin__)
 116         fir->history = kcalloc(2*taps, sizeof(int16_t), GFP_KERNEL);
 117 #else
 118         fir->history = kcalloc(taps, sizeof(int16_t), GFP_KERNEL);
 119 #endif
 120         return fir->history;
 121 }
 122 /*- End of function --------------------------------------------------------*/
 123
 124 static __inline__ void fir16_flush(fir16_state_t *fir)
 125 {
 126 #if defined(USE_MMX)  ||  defined(USE_SSE2) || defined(__bfin__)
 127     memset(fir->history, 0, 2*fir->taps*sizeof(int16_t));
 128 #else
 129     memset(fir->history, 0, fir->taps*sizeof(int16_t));
 130 #endif
 131 }
 132 /*- End of function --------------------------------------------------------*/
 133
 134 static __inline__ void fir16_free(fir16_state_t *fir)
 135 {
 136         kfree(fir->history);
 137 }
 138 /*- End of function --------------------------------------------------------*/
 139
 140 #ifdef __bfin__
 141 static inline int32_t dot_asm(short *x, short *y, int len)
 142 {
 143    int dot;
 144
 145    len--;
 146
 147    __asm__
 148    (
 149    "I0 = %1;\n\t"
 150    "I1 = %2;\n\t"
 151    "A0 = 0;\n\t"
 152    "R0.L = W[I0++] || R1.L = W[I1++];\n\t"
 153    "LOOP dot%= LC0 = %3;\n\t"
 154    "LOOP_BEGIN dot%=;\n\t"
 155       "A0 += R0.L * R1.L (IS) || R0.L = W[I0++] || R1.L = W[I1++];\n\t"
 156    "LOOP_END dot%=;\n\t"
 157    "A0 += R0.L*R1.L (IS);\n\t"
 158    "R0 = A0;\n\t"
 159    "%0 = R0;\n\t"
 160    : "=&d" (dot)
 161    : "a" (x), "a" (y), "a" (len)
 162    : "I0", "I1", "A1", "A0", "R0", "R1"
 163    );
 164
 165    return dot;
 166 }
 167 #endif
 168 /*- End of function --------------------------------------------------------*/
 169
 170 static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
 171 {
 172     int32_t y;
 173 #if defined(USE_MMX)
 174     int i;
 175     mmx_t *mmx_coeffs;
 176     mmx_t *mmx_hist;
 177
 178     fir->history[fir->curr_pos] = sample;
 179     fir->history[fir->curr_pos + fir->taps] = sample;
 180
 181     mmx_coeffs = (mmx_t *) fir->coeffs;
 182     mmx_hist = (mmx_t *) &fir->history[fir->curr_pos];
 183     i = fir->taps;
 184     pxor_r2r(mm4, mm4);
 185     /* 8 samples per iteration, so the filter must be a multiple of 8 long. */
 186     while (i > 0)
 187     {
 188         movq_m2r(mmx_coeffs[0], mm0);
 189         movq_m2r(mmx_coeffs[1], mm2);
 190         movq_m2r(mmx_hist[0], mm1);
 191         movq_m2r(mmx_hist[1], mm3);
 192         mmx_coeffs += 2;
 193         mmx_hist += 2;
 194         pmaddwd_r2r(mm1, mm0);
 195         pmaddwd_r2r(mm3, mm2);
 196         paddd_r2r(mm0, mm4);
 197         paddd_r2r(mm2, mm4);
 198         i -= 8;
 199     }
 200     movq_r2r(mm4, mm0);
 201     psrlq_i2r(32, mm0);
 202     paddd_r2r(mm0, mm4);
 203     movd_r2m(mm4, y);
 204     emms();
 205 #elif defined(USE_SSE2)
 206     int i;
 207     xmm_t *xmm_coeffs;
 208     xmm_t *xmm_hist;
 209
 210     fir->history[fir->curr_pos] = sample;
 211     fir->history[fir->curr_pos + fir->taps] = sample;
 212
 213     xmm_coeffs = (xmm_t *) fir->coeffs;
 214     xmm_hist = (xmm_t *) &fir->history[fir->curr_pos];
 215     i = fir->taps;
 216     pxor_r2r(xmm4, xmm4);
 217     /* 16 samples per iteration, so the filter must be a multiple of 16 long. */
 218     while (i > 0)
 219     {
 220         movdqu_m2r(xmm_coeffs[0], xmm0);
 221         movdqu_m2r(xmm_coeffs[1], xmm2);
 222         movdqu_m2r(xmm_hist[0], xmm1);
 223         movdqu_m2r(xmm_hist[1], xmm3);
 224         xmm_coeffs += 2;
 225         xmm_hist += 2;
 226         pmaddwd_r2r(xmm1, xmm0);
 227         pmaddwd_r2r(xmm3, xmm2);
 228         paddd_r2r(xmm0, xmm4);
 229         paddd_r2r(xmm2, xmm4);
 230         i -= 16;
 231     }
 232     movdqa_r2r(xmm4, xmm0);
 233     psrldq_i2r(8, xmm0);
 234     paddd_r2r(xmm0, xmm4);
 235     movdqa_r2r(xmm4, xmm0);
 236     psrldq_i2r(4, xmm0);
 237     paddd_r2r(xmm0, xmm4);
 238     movd_r2m(xmm4, y);
 239 #elif defined(__bfin__)
 240     fir->history[fir->curr_pos] = sample;
 241     fir->history[fir->curr_pos + fir->taps] = sample;
 242     y = dot_asm((int16_t*)fir->coeffs, &fir->history[fir->curr_pos], fir->taps);
 243 #else
 244     int i;
 245     int offset1;
 246     int offset2;
 247
 248     fir->history[fir->curr_pos] = sample;
 249
 250     offset2 = fir->curr_pos;
 251     offset1 = fir->taps - offset2;
 252     y = 0;
 253     for (i = fir->taps - 1;  i >= offset1;  i--)
 254         y += fir->coeffs[i]*fir->history[i - offset1];
 255     for (  ;  i >= 0;  i--)
 256         y += fir->coeffs[i]*fir->history[i + offset2];
 257 #endif
 258     if (fir->curr_pos <= 0)
 259         fir->curr_pos = fir->taps;
 260     fir->curr_pos--;
 261     return (int16_t) (y >> 15);
 262 }
 263 /*- End of function --------------------------------------------------------*/
 264
 265 static __inline__ const int16_t *fir32_create(fir32_state_t *fir,
 266                                               const int32_t *coeffs,
 267                                               int taps)
 268 {
 269     fir->taps = taps;
 270     fir->curr_pos = taps - 1;
 271     fir->coeffs = coeffs;
 272     fir->history = kcalloc(taps, sizeof(int16_t), GFP_KERNEL);
 273     return fir->history;
 274 }
 275 /*- End of function --------------------------------------------------------*/
 276
 277 static __inline__ void fir32_flush(fir32_state_t *fir)
 278 {
 279     memset(fir->history, 0, fir->taps*sizeof(int16_t));
 280 }
 281 /*- End of function --------------------------------------------------------*/
 282
 283 static __inline__ void fir32_free(fir32_state_t *fir)
 284 {
 285     kfree(fir->history);
 286 }
 287 /*- End of function --------------------------------------------------------*/
 288
 289 static __inline__ int16_t fir32(fir32_state_t *fir, int16_t sample)
 290 {
 291     int i;
 292     int32_t y;
 293     int offset1;
 294     int offset2;
 295
 296     fir->history[fir->curr_pos] = sample;
 297     offset2 = fir->curr_pos;
 298     offset1 = fir->taps - offset2;
 299     y = 0;
 300     for (i = fir->taps - 1;  i >= offset1;  i--)
 301         y += fir->coeffs[i]*fir->history[i - offset1];
 302     for (  ;  i >= 0;  i--)
 303         y += fir->coeffs[i]*fir->history[i + offset2];
 304     if (fir->curr_pos <= 0)
 305         fir->curr_pos = fir->taps;
 306     fir->curr_pos--;
 307     return (int16_t) (y >> 15);
 308 }
 309 /*- End of function --------------------------------------------------------*/
 310
 311 #endif
 312 /*- End of file ------------------------------------------------------------*/