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
  26 #if !defined(_FIR_H_)
  27 #define _FIR_H_
  28
  29 /*
  30    Blackfin NOTES & IDEAS:
  31
  32    A simple dot product function is used to implement the filter.  This performs
  33    just one MAC/cycle which is inefficient but was easy to implement as a first
  34    pass.  The current Blackfin code also uses an unrolled form of the filter
  35    history to avoid 0 length hardware loop issues.  This is wasteful of
  36    memory.
  37
  38    Ideas for improvement:
  39
  40    1/ Rewrite filter for dual MAC inner loop.  The issue here is handling
  41    history sample offsets that are 16 bit aligned - the dual MAC needs
  42    32 bit aligmnent.  There are some good examples in libbfdsp.
  43
  44    2/ Use the hardware circular buffer facility tohalve memory usage.
  45
  46    3/ Consider using internal memory.
  47
  48    Using less memory might also improve speed as cache misses will be
  49    reduced. A drop in MIPs and memory approaching 50% should be
  50    possible.
  51
  52    The foreground and background filters currenlty use a total of
  53    about 10 MIPs/ch as measured with speedtest.c on a 256 TAP echo
  54    can.
  55 */
  56
  57 /*
  58  * 16 bit integer FIR descriptor. This defines the working state for a single
  59  * instance of an FIR filter using 16 bit integer coefficients.
  60  */
  61 struct fir16_state_t {
  62         int taps;
  63         int curr_pos;
  64         const int16_t *coeffs;
  65         int16_t *history;
  66 };
  67
  68 /*
  69  * 32 bit integer FIR descriptor. This defines the working state for a single
  70  * instance of an FIR filter using 32 bit integer coefficients, and filtering
  71  * 16 bit integer data.
  72  */
  73 struct fir32_state_t {
  74         int taps;
  75         int curr_pos;
  76         const int32_t *coeffs;
  77         int16_t *history;
  78 };
  79
  80 /*
  81  * Floating point FIR descriptor. This defines the working state for a single
  82  * instance of an FIR filter using floating point coefficients and data.
  83  */
  84 struct fir_float_state_t {
  85         int taps;
  86         int curr_pos;
  87         const float *coeffs;
  88         float *history;
  89 };
  90
  91 static inline const int16_t *fir16_create(struct fir16_state_t *fir,
  92                                               const int16_t *coeffs, int taps)
  93 {
  94         fir->taps = taps;
  95         fir->curr_pos = taps - 1;
  96         fir->coeffs = coeffs;
  97 #if defined(__bfin__)
  98         fir->history = kcalloc(2 * taps, sizeof(int16_t), GFP_KERNEL);
  99 #else
 100         fir->history = kcalloc(taps, sizeof(int16_t), GFP_KERNEL);
 101 #endif
 102         return fir->history;
 103 }
 104
 105 static inline void fir16_flush(struct fir16_state_t *fir)
 106 {
 107 #if defined(__bfin__)
 108         memset(fir->history, 0, 2 * fir->taps * sizeof(int16_t));
 109 #else
 110         memset(fir->history, 0, fir->taps * sizeof(int16_t));
 111 #endif
 112 }
 113
 114 static inline void fir16_free(struct fir16_state_t *fir)
 115 {
 116         kfree(fir->history);
 117 }
 118
 119 #ifdef __bfin__
 120 static inline int32_t dot_asm(short *x, short *y, int len)
 121 {
 122         int dot;
 123
 124         len--;
 125
 126         __asm__("I0 = %1;\n\t"
 127                 "I1 = %2;\n\t"
 128                 "A0 = 0;\n\t"
 129                 "R0.L = W[I0++] || R1.L = W[I1++];\n\t"
 130                 "LOOP dot%= LC0 = %3;\n\t"
 131                 "LOOP_BEGIN dot%=;\n\t"
 132                 "A0 += R0.L * R1.L (IS) || R0.L = W[I0++] || R1.L = W[I1++];\n\t"
 133                 "LOOP_END dot%=;\n\t"
 134                 "A0 += R0.L*R1.L (IS);\n\t"
 135                 "R0 = A0;\n\t"
 136                 "%0 = R0;\n\t"
 137                 : "=&d"(dot)
 138                 : "a"(x), "a"(y), "a"(len)
 139                 : "I0", "I1", "A1", "A0", "R0", "R1"
 140         );
 141
 142         return dot;
 143 }
 144 #endif
 145
 146 static inline int16_t fir16(struct fir16_state_t *fir, int16_t sample)
 147 {
 148         int32_t y;
 149 #if defined(__bfin__)
 150         fir->history[fir->curr_pos] = sample;
 151         fir->history[fir->curr_pos + fir->taps] = sample;
 152         y = dot_asm((int16_t *) fir->coeffs, &fir->history[fir->curr_pos],
 153                     fir->taps);
 154 #else
 155         int i;
 156         int offset1;
 157         int offset2;
 158
 159         fir->history[fir->curr_pos] = sample;
 160
 161         offset2 = fir->curr_pos;
 162         offset1 = fir->taps - offset2;
 163         y = 0;
 164         for (i = fir->taps - 1; i >= offset1; i--)
 165                 y += fir->coeffs[i] * fir->history[i - offset1];
 166         for (; i >= 0; i--)
 167                 y += fir->coeffs[i] * fir->history[i + offset2];
 168 #endif
 169         if (fir->curr_pos <= 0)
 170                 fir->curr_pos = fir->taps;
 171         fir->curr_pos--;
 172         return (int16_t) (y >> 15);
 173 }
 174
 175 static inline const int16_t *fir32_create(struct fir32_state_t *fir,
 176                                               const int32_t *coeffs, int taps)
 177 {
 178         fir->taps = taps;
 179         fir->curr_pos = taps - 1;
 180         fir->coeffs = coeffs;
 181         fir->history = kcalloc(taps, sizeof(int16_t), GFP_KERNEL);
 182         return fir->history;
 183 }
 184
 185 static inline void fir32_flush(struct fir32_state_t *fir)
 186 {
 187         memset(fir->history, 0, fir->taps * sizeof(int16_t));
 188 }
 189
 190 static inline void fir32_free(struct fir32_state_t *fir)
 191 {
 192         kfree(fir->history);
 193 }
 194
 195 static inline int16_t fir32(struct fir32_state_t *fir, int16_t sample)
 196 {
 197         int i;
 198         int32_t y;
 199         int offset1;
 200         int offset2;
 201
 202         fir->history[fir->curr_pos] = sample;
 203         offset2 = fir->curr_pos;
 204         offset1 = fir->taps - offset2;
 205         y = 0;
 206         for (i = fir->taps - 1; i >= offset1; i--)
 207                 y += fir->coeffs[i] * fir->history[i - offset1];
 208         for (; i >= 0; i--)
 209                 y += fir->coeffs[i] * fir->history[i + offset2];
 210         if (fir->curr_pos <= 0)
 211                 fir->curr_pos = fir->taps;
 212         fir->curr_pos--;
 213         return (int16_t) (y >> 15);
 214 }
 215
 216 #endif