linux/drivers/telephony/ixj.c
<<
>>
Prefs
   1/****************************************************************************
   2 *    ixj.c
   3 *
   4 * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
   5 * including the Internet PhoneJACK, Internet PhoneJACK Lite,
   6 * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
   7 * SmartCABLE
   8 *
   9 *    (c) Copyright 1999-2001  Quicknet Technologies, Inc.
  10 *
  11 *    This program is free software; you can redistribute it and/or
  12 *    modify it under the terms of the GNU General Public License
  13 *    as published by the Free Software Foundation; either version
  14 *    2 of the License, or (at your option) any later version.
  15 *
  16 * Author:          Ed Okerson, <eokerson@quicknet.net>
  17 *
  18 * Contributors:    Greg Herlein, <gherlein@quicknet.net>
  19 *                  David W. Erhart, <derhart@quicknet.net>
  20 *                  John Sellers, <jsellers@quicknet.net>
  21 *                  Mike Preston, <mpreston@quicknet.net>
  22 *    
  23 * Fixes:           David Huggins-Daines, <dhd@cepstral.com>
  24 *                  Fabio Ferrari, <fabio.ferrari@digitro.com.br>
  25 *                  Artis Kugevics, <artis@mt.lv>
  26 *                  Daniele Bellucci, <bellucda@tiscali.it>
  27 *
  28 * More information about the hardware related to this driver can be found  
  29 * at our website:    http://www.quicknet.net
  30 *
  31 * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
  32 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  33 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
  34 * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35 *    
  36 * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  37 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  38 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  39 * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
  40 * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  41 *
  42 ***************************************************************************/
  43
  44/*
  45 * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  46 * Audit some copy_*_user and minor cleanup.
  47 *
  48 * Revision 4.7  2001/08/13 06:19:33  craigs
  49 * Added additional changes from Alan Cox and John Anderson for
  50 * 2.2 to 2.4 cleanup and bounds checking
  51 *
  52 * Revision 4.6  2001/08/13 01:05:05  craigs
  53 * Really fixed PHONE_QUERY_CODEC problem this time
  54 *
  55 * Revision 4.5  2001/08/13 00:11:03  craigs
  56 * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  57 *
  58 * Revision 4.4  2001/08/07 07:58:12  craigs
  59 * Changed back to three digit version numbers
  60 * Added tagbuild target to allow automatic and easy tagging of versions
  61 *
  62 * Revision 4.3  2001/08/07 07:24:47  craigs
  63 * Added ixj-ver.h to allow easy configuration management of driver
  64 * Added display of version number in /prox/ixj
  65 *
  66 * Revision 4.2  2001/08/06 07:07:19  craigs
  67 * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  68 * behaviour of returning int rather than short *
  69 *
  70 * Revision 4.1  2001/08/05 00:17:37  craigs
  71 * More changes for correct PCMCIA installation
  72 * Start of changes for backward Linux compatibility
  73 *
  74 * Revision 4.0  2001/08/04 12:33:12  craigs
  75 * New version using GNU autoconf
  76 *
  77 * Revision 3.105  2001/07/20 23:14:32  eokerson
  78 * More work on CallerID generation when using ring cadences.
  79 *
  80 * Revision 3.104  2001/07/06 01:33:55  eokerson
  81 * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  82 *
  83 * Revision 3.103  2001/07/05 19:20:16  eokerson
  84 * Updated HOWTO
  85 * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  86 *
  87 * Revision 3.102  2001/07/03 23:51:21  eokerson
  88 * Un-mute mic on Internet LineJACK when in speakerphone mode.
  89 *
  90 * Revision 3.101  2001/07/02 19:26:56  eokerson
  91 * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  92 *
  93 * Revision 3.100  2001/07/02 19:18:27  eokerson
  94 * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  95 * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  96 * Fixed speaker mode on Internet LineJACK.
  97 *
  98 * Revision 3.99  2001/05/09 14:11:16  eokerson
  99 * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 100 *
 101 * Revision 3.98  2001/05/08 19:55:33  eokerson
 102 * Fixed POTS hookstate detection while it is connected to PSTN port.
 103 *
 104 * Revision 3.97  2001/05/08 00:01:04  eokerson
 105 * Fixed kernel oops when sending caller ID data.
 106 *
 107 * Revision 3.96  2001/05/04 23:09:30  eokerson
 108 * Now uses one kernel timer for each card, instead of one for the entire driver.
 109 *
 110 * Revision 3.95  2001/04/25 22:06:47  eokerson
 111 * Fixed squawking at beginning of some G.723.1 calls.
 112 *
 113 * Revision 3.94  2001/04/03 23:42:00  eokerson
 114 * Added linear volume ioctls
 115 * Added raw filter load ioctl
 116 *
 117 * Revision 3.93  2001/02/27 01:00:06  eokerson
 118 * Fixed blocking in CallerID.
 119 * Reduced size of ixj structure for smaller driver footprint.
 120 *
 121 * Revision 3.92  2001/02/20 22:02:59  eokerson
 122 * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 123 * Improved PSTN ring detection.
 124 * Fixed wink generation on POTS ports.
 125 *
 126 * Revision 3.91  2001/02/13 00:55:44  eokerson
 127 * Turn AEC back on after changing frame sizes.
 128 *
 129 * Revision 3.90  2001/02/12 16:42:00  eokerson
 130 * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 131 *
 132 * Revision 3.89  2001/02/12 15:41:16  eokerson
 133 * Fix from Artis Kugevics - Tone gains were not being set correctly.
 134 *
 135 * Revision 3.88  2001/02/05 23:25:42  eokerson
 136 * Fixed lockup bugs with deregister.
 137 *
 138 * Revision 3.87  2001/01/29 21:00:39  eokerson
 139 * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 140 * Updated copyright date.
 141 *
 142 * Revision 3.86  2001/01/23 23:53:46  eokerson
 143 * Fixes to G.729 compatibility.
 144 *
 145 * Revision 3.85  2001/01/23 21:30:36  eokerson
 146 * Added verbage about cards supported.
 147 * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 148 *
 149 * Revision 3.84  2001/01/22 23:32:10  eokerson
 150 * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 151 *
 152 * Revision 3.83  2001/01/19 14:51:41  eokerson
 153 * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 154 *
 155 * Revision 3.82  2001/01/19 00:34:49  eokerson
 156 * Added verbosity to write overlap errors.
 157 *
 158 * Revision 3.81  2001/01/18 23:56:54  eokerson
 159 * Fixed PSTN line test functions.
 160 *
 161 * Revision 3.80  2001/01/18 22:29:27  eokerson
 162 * Updated AEC/AGC values for different cards.
 163 *
 164 * Revision 3.79  2001/01/17 02:58:54  eokerson
 165 * Fixed AEC reset after Caller ID.
 166 * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 167 *
 168 * Revision 3.78  2001/01/16 19:43:09  eokerson
 169 * Added support for Linux 2.4.x kernels.
 170 *
 171 * Revision 3.77  2001/01/09 04:00:52  eokerson
 172 * Linetest will now test the line, even if it has previously succeded.
 173 *
 174 * Revision 3.76  2001/01/08 19:27:00  eokerson
 175 * Fixed problem with standard cable on Internet PhoneCARD.
 176 *
 177 * Revision 3.75  2000/12/22 16:52:14  eokerson
 178 * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 179 *
 180 * Revision 3.74  2000/12/08 22:41:50  eokerson
 181 * Added capability for G729B.
 182 *
 183 * Revision 3.73  2000/12/07 23:35:16  eokerson
 184 * Added capability to have different ring pattern before CallerID data.
 185 * Added hookstate checks in CallerID routines to stop FSK.
 186 *
 187 * Revision 3.72  2000/12/06 19:31:31  eokerson
 188 * Modified signal behavior to only send one signal per event.
 189 *
 190 * Revision 3.71  2000/12/06 03:23:08  eokerson
 191 * Fixed CallerID on Call Waiting.
 192 *
 193 * Revision 3.70  2000/12/04 21:29:37  eokerson
 194 * Added checking to Smart Cable gain functions.
 195 *
 196 * Revision 3.69  2000/12/04 21:05:20  eokerson
 197 * Changed ixjdebug levels.
 198 * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 199 *
 200 * Revision 3.68  2000/12/04 00:17:21  craigs
 201 * Changed mixer voice gain to +6dB rather than 0dB
 202 *
 203 * Revision 3.67  2000/11/30 21:25:51  eokerson
 204 * Fixed write signal errors.
 205 *
 206 * Revision 3.66  2000/11/29 22:42:44  eokerson
 207 * Fixed PSTN ring detect problems.
 208 *
 209 * Revision 3.65  2000/11/29 07:31:55  craigs
 210 * Added new 425Hz filter co-efficients
 211 * Added card-specific DTMF prescaler initialisation
 212 *
 213 * Revision 3.64  2000/11/28 14:03:32  craigs
 214 * Changed certain mixer initialisations to be 0dB rather than 12dB
 215 * Added additional information to /proc/ixj
 216 *
 217 * Revision 3.63  2000/11/28 11:38:41  craigs
 218 * Added display of AEC modes in AUTO and AGC mode
 219 *
 220 * Revision 3.62  2000/11/28 04:05:44  eokerson
 221 * Improved PSTN ring detection routine.
 222 *
 223 * Revision 3.61  2000/11/27 21:53:12  eokerson
 224 * Fixed flash detection.
 225 *
 226 * Revision 3.60  2000/11/27 15:57:29  eokerson
 227 * More work on G.729 load routines.
 228 *
 229 * Revision 3.59  2000/11/25 21:55:12  eokerson
 230 * Fixed errors in G.729 load routine.
 231 *
 232 * Revision 3.58  2000/11/25 04:08:29  eokerson
 233 * Added board locks around G.729 and TS85 load routines.
 234 *
 235 * Revision 3.57  2000/11/24 05:35:17  craigs
 236 * Added ability to retrieve mixer values on LineJACK
 237 * Added complete initialisation of all mixer values at startup
 238 * Fixed spelling mistake
 239 *
 240 * Revision 3.56  2000/11/23 02:52:11  robertj
 241 * Added cvs change log keyword.
 242 * Fixed bug in capabilities list when using G.729 module.
 243 *
 244 */
 245
 246#include "ixj-ver.h"
 247
 248#define PERFMON_STATS
 249#define IXJDEBUG 0
 250#define MAXRINGS 5
 251
 252#include <linux/module.h>
 253
 254#include <linux/init.h>
 255#include <linux/sched.h>
 256#include <linux/kernel.h>       /* printk() */
 257#include <linux/fs.h>           /* everything... */
 258#include <linux/errno.h>        /* error codes */
 259#include <linux/slab.h>
 260#include <linux/smp_lock.h>
 261#include <linux/mm.h>
 262#include <linux/ioport.h>
 263#include <linux/interrupt.h>
 264#include <linux/proc_fs.h>
 265#include <linux/poll.h>
 266#include <linux/timer.h>
 267#include <linux/delay.h>
 268#include <linux/pci.h>
 269
 270#include <asm/io.h>
 271#include <asm/uaccess.h>
 272
 273#include <linux/isapnp.h>
 274
 275#include "ixj.h"
 276
 277#define TYPE(inode) (iminor(inode) >> 4)
 278#define NUM(inode) (iminor(inode) & 0xf)
 279
 280static int ixjdebug;
 281static int hertz = HZ;
 282static int samplerate = 100;
 283
 284module_param(ixjdebug, int, 0);
 285
 286static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
 287        { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
 288          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 289        { }
 290};
 291
 292MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 293
 294/************************************************************************
 295*
 296* ixjdebug meanings are now bit mapped instead of level based
 297* Values can be or'ed together to turn on multiple messages
 298*
 299* bit  0 (0x0001) = any failure
 300* bit  1 (0x0002) = general messages
 301* bit  2 (0x0004) = POTS ringing related
 302* bit  3 (0x0008) = PSTN events
 303* bit  4 (0x0010) = PSTN Cadence state details
 304* bit  5 (0x0020) = Tone detection triggers
 305* bit  6 (0x0040) = Tone detection cadence details
 306* bit  7 (0x0080) = ioctl tracking
 307* bit  8 (0x0100) = signal tracking
 308* bit  9 (0x0200) = CallerID generation details
 309*
 310************************************************************************/
 311
 312#ifdef IXJ_DYN_ALLOC
 313
 314static IXJ *ixj[IXJMAX];
 315#define get_ixj(b)      ixj[(b)]
 316
 317/*
 318 *      Allocate a free IXJ device
 319 */
 320 
 321static IXJ *ixj_alloc()
 322{
 323        for(cnt=0; cnt<IXJMAX; cnt++)
 324        {
 325                if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 326                {
 327                        j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 328                        if (j == NULL)
 329                                return NULL;
 330                        ixj[cnt] = j;
 331                        return j;
 332                }
 333        }
 334        return NULL;
 335}
 336
 337static void ixj_fsk_free(IXJ *j)
 338{
 339        kfree(j->fskdata);
 340        j->fskdata = NULL;
 341}
 342
 343static void ixj_fsk_alloc(IXJ *j)
 344{
 345        if(!j->fskdata) {
 346                j->fskdata = kmalloc(8000, GFP_KERNEL);
 347                if (!j->fskdata) {
 348                        if(ixjdebug & 0x0200) {
 349                                printk("IXJ phone%d - allocate failed\n", j->board);
 350                        }
 351                        return;
 352                } else {
 353                        j->fsksize = 8000;
 354                        if(ixjdebug & 0x0200) {
 355                                printk("IXJ phone%d - allocate succeded\n", j->board);
 356                        }
 357                }
 358        }
 359}
 360
 361#else
 362
 363static IXJ ixj[IXJMAX];
 364#define get_ixj(b)      (&ixj[(b)])
 365
 366/*
 367 *      Allocate a free IXJ device
 368 */
 369 
 370static IXJ *ixj_alloc(void)
 371{
 372        int cnt;
 373        for(cnt=0; cnt<IXJMAX; cnt++) {
 374                if(!ixj[cnt].DSPbase)
 375                        return &ixj[cnt];
 376        }
 377        return NULL;
 378}
 379
 380static inline void ixj_fsk_free(IXJ *j) {;}
 381
 382static inline void ixj_fsk_alloc(IXJ *j)
 383{
 384        j->fsksize = 8000;
 385}
 386
 387#endif
 388
 389#ifdef PERFMON_STATS
 390#define ixj_perfmon(x)  ((x)++)
 391#else
 392#define ixj_perfmon(x)  do { } while(0)
 393#endif
 394
 395static int ixj_convert_loaded;
 396
 397static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 398
 399/************************************************************************
 400*
 401* These are function definitions to allow external modules to register
 402* enhanced functionality call backs.
 403*
 404************************************************************************/
 405
 406static int Stub(IXJ * J, unsigned long arg)
 407{
 408        return 0;
 409}
 410
 411static IXJ_REGFUNC ixj_PreRead = &Stub;
 412static IXJ_REGFUNC ixj_PostRead = &Stub;
 413static IXJ_REGFUNC ixj_PreWrite = &Stub;
 414static IXJ_REGFUNC ixj_PostWrite = &Stub;
 415
 416static void ixj_read_frame(IXJ *j);
 417static void ixj_write_frame(IXJ *j);
 418static void ixj_init_timer(IXJ *j);
 419static void ixj_add_timer(IXJ * j);
 420static void ixj_timeout(unsigned long ptr);
 421static int read_filters(IXJ *j);
 422static int LineMonitor(IXJ *j);
 423static int ixj_fasync(int fd, struct file *, int mode);
 424static int ixj_set_port(IXJ *j, int arg);
 425static int ixj_set_pots(IXJ *j, int arg);
 426static int ixj_hookstate(IXJ *j);
 427static int ixj_record_start(IXJ *j);
 428static void ixj_record_stop(IXJ *j);
 429static void set_rec_volume(IXJ *j, int volume);
 430static int get_rec_volume(IXJ *j);
 431static int set_rec_codec(IXJ *j, int rate);
 432static void ixj_vad(IXJ *j, int arg);
 433static int ixj_play_start(IXJ *j);
 434static void ixj_play_stop(IXJ *j);
 435static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 436static int ixj_set_tone_off(unsigned short, IXJ *j);
 437static int ixj_play_tone(IXJ *j, char tone);
 438static void ixj_aec_start(IXJ *j, int level);
 439static int idle(IXJ *j);
 440static void ixj_ring_on(IXJ *j);
 441static void ixj_ring_off(IXJ *j);
 442static void aec_stop(IXJ *j);
 443static void ixj_ringback(IXJ *j);
 444static void ixj_busytone(IXJ *j);
 445static void ixj_dialtone(IXJ *j);
 446static void ixj_cpt_stop(IXJ *j);
 447static char daa_int_read(IXJ *j);
 448static char daa_CR_read(IXJ *j, int cr);
 449static int daa_set_mode(IXJ *j, int mode);
 450static int ixj_linetest(IXJ *j);
 451static int ixj_daa_write(IXJ *j);
 452static int ixj_daa_cid_read(IXJ *j);
 453static void DAA_Coeff_US(IXJ *j);
 454static void DAA_Coeff_UK(IXJ *j);
 455static void DAA_Coeff_France(IXJ *j);
 456static void DAA_Coeff_Germany(IXJ *j);
 457static void DAA_Coeff_Australia(IXJ *j);
 458static void DAA_Coeff_Japan(IXJ *j);
 459static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 460static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 461static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 462static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 463static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 464/* Serial Control Interface funtions */
 465static int SCI_Control(IXJ *j, int control);
 466static int SCI_Prepare(IXJ *j);
 467static int SCI_WaitHighSCI(IXJ *j);
 468static int SCI_WaitLowSCI(IXJ *j);
 469static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 470static int ixj_PCcontrol_wait(IXJ *j);
 471static void ixj_pre_cid(IXJ *j);
 472static void ixj_write_cid(IXJ *j);
 473static void ixj_write_cid_bit(IXJ *j, int bit);
 474static int set_base_frame(IXJ *j, int size);
 475static int set_play_codec(IXJ *j, int rate);
 476static void set_rec_depth(IXJ *j, int depth);
 477static int ixj_mixer(long val, IXJ *j);
 478
 479/************************************************************************
 480CT8020/CT8021 Host Programmers Model
 481Host address    Function                                        Access
 482DSPbase +
 4830-1             Aux Software Status Register (reserved)         Read Only
 4842-3             Software Status Register                        Read Only
 4854-5             Aux Software Control Register (reserved)        Read Write
 4866-7             Software Control Register                       Read Write
 4878-9             Hardware Status Register                        Read Only
 488A-B             Hardware Control Register                       Read Write
 489C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 490E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 491************************************************************************/
 492
 493static inline void ixj_read_HSR(IXJ *j)
 494{
 495        j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 496        j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 497}
 498
 499static inline int IsControlReady(IXJ *j)
 500{
 501        ixj_read_HSR(j);
 502        return j->hsr.bits.controlrdy ? 1 : 0;
 503}
 504
 505static inline int IsPCControlReady(IXJ *j)
 506{
 507        j->pccr1.byte = inb_p(j->XILINXbase + 3);
 508        return j->pccr1.bits.crr ? 1 : 0;
 509}
 510
 511static inline int IsStatusReady(IXJ *j)
 512{
 513        ixj_read_HSR(j);
 514        return j->hsr.bits.statusrdy ? 1 : 0;
 515}
 516
 517static inline int IsRxReady(IXJ *j)
 518{
 519        ixj_read_HSR(j);
 520        ixj_perfmon(j->rxreadycheck);
 521        return j->hsr.bits.rxrdy ? 1 : 0;
 522}
 523
 524static inline int IsTxReady(IXJ *j)
 525{
 526        ixj_read_HSR(j);
 527        ixj_perfmon(j->txreadycheck);
 528        return j->hsr.bits.txrdy ? 1 : 0;
 529}
 530
 531static inline void set_play_volume(IXJ *j, int volume)
 532{
 533        if (ixjdebug & 0x0002)
 534                printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 535        ixj_WriteDSPCommand(0xCF02, j);
 536        ixj_WriteDSPCommand(volume, j);
 537}
 538
 539static int set_play_volume_linear(IXJ *j, int volume)
 540{
 541        int newvolume, dspplaymax;
 542
 543        if (ixjdebug & 0x0002)
 544                printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 545        if(volume > 100 || volume < 0) {
 546                return -1;
 547        }
 548
 549        /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 550        switch (j->cardtype) {
 551        case QTI_PHONEJACK:
 552                dspplaymax = 0x380;
 553                break;
 554        case QTI_LINEJACK:
 555                if(j->port == PORT_PSTN) {
 556                        dspplaymax = 0x48;
 557                } else {
 558                        dspplaymax = 0x100;
 559                }
 560                break;
 561        case QTI_PHONEJACK_LITE:
 562                dspplaymax = 0x380;
 563                break;
 564        case QTI_PHONEJACK_PCI:
 565                dspplaymax = 0x6C;
 566                break;
 567        case QTI_PHONECARD:
 568                dspplaymax = 0x50;
 569                break;
 570        default:
 571                return -1;
 572        }
 573        newvolume = (dspplaymax * volume) / 100;
 574        set_play_volume(j, newvolume);
 575        return 0;
 576}
 577
 578static inline void set_play_depth(IXJ *j, int depth)
 579{
 580        if (depth > 60)
 581                depth = 60;
 582        if (depth < 0)
 583                depth = 0;
 584        ixj_WriteDSPCommand(0x5280 + depth, j);
 585}
 586
 587static inline int get_play_volume(IXJ *j)
 588{
 589        ixj_WriteDSPCommand(0xCF00, j);
 590        return j->ssr.high << 8 | j->ssr.low;
 591}
 592
 593static int get_play_volume_linear(IXJ *j)
 594{
 595        int volume, newvolume, dspplaymax;
 596
 597        /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 598        switch (j->cardtype) {
 599        case QTI_PHONEJACK:
 600                dspplaymax = 0x380;
 601                break;
 602        case QTI_LINEJACK:
 603                if(j->port == PORT_PSTN) {
 604                        dspplaymax = 0x48;
 605                } else {
 606                        dspplaymax = 0x100;
 607                }
 608                break;
 609        case QTI_PHONEJACK_LITE:
 610                dspplaymax = 0x380;
 611                break;
 612        case QTI_PHONEJACK_PCI:
 613                dspplaymax = 0x6C;
 614                break;
 615        case QTI_PHONECARD:
 616                dspplaymax = 100;
 617                break;
 618        default:
 619                return -1;
 620        }
 621        volume = get_play_volume(j);
 622        newvolume = (volume * 100) / dspplaymax;
 623        if(newvolume > 100)
 624                newvolume = 100;
 625        return newvolume;
 626}
 627
 628static inline BYTE SLIC_GetState(IXJ *j)
 629{
 630        if (j->cardtype == QTI_PHONECARD) {
 631                j->pccr1.byte = 0;
 632                j->psccr.bits.dev = 3;
 633                j->psccr.bits.rw = 1;
 634                outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 635                ixj_PCcontrol_wait(j);
 636                j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 637                ixj_PCcontrol_wait(j);
 638                if (j->pslic.bits.powerdown)
 639                        return PLD_SLIC_STATE_OC;
 640                else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 641                        return PLD_SLIC_STATE_ACTIVE;
 642                else
 643                        return PLD_SLIC_STATE_RINGING;
 644        } else {
 645                j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 646        }
 647        return j->pld_slicr.bits.state;
 648}
 649
 650static bool SLIC_SetState(BYTE byState, IXJ *j)
 651{
 652        bool fRetVal = false;
 653
 654        if (j->cardtype == QTI_PHONECARD) {
 655                if (j->flags.pcmciasct) {
 656                        switch (byState) {
 657                        case PLD_SLIC_STATE_TIPOPEN:
 658                        case PLD_SLIC_STATE_OC:
 659                                j->pslic.bits.powerdown = 1;
 660                                j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 661                                fRetVal = true;
 662                                break;
 663                        case PLD_SLIC_STATE_RINGING:
 664                                if (j->readers || j->writers) {
 665                                        j->pslic.bits.powerdown = 0;
 666                                        j->pslic.bits.ring0 = 1;
 667                                        j->pslic.bits.ring1 = 0;
 668                                        fRetVal = true;
 669                                }
 670                                break;
 671                        case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 672
 673                        case PLD_SLIC_STATE_STANDBY:
 674                        case PLD_SLIC_STATE_ACTIVE:
 675                                if (j->readers || j->writers) {
 676                                        j->pslic.bits.powerdown = 0;
 677                                } else {
 678                                        j->pslic.bits.powerdown = 1;
 679                                }
 680                                j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 681                                fRetVal = true;
 682                                break;
 683                        case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 684
 685                        case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 686
 687                        default:
 688                                fRetVal = false;
 689                                break;
 690                        }
 691                        j->psccr.bits.dev = 3;
 692                        j->psccr.bits.rw = 0;
 693                        outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 694                        ixj_PCcontrol_wait(j);
 695                }
 696        } else {
 697                /* Set the C1, C2, C3 & B2EN signals. */
 698                switch (byState) {
 699                case PLD_SLIC_STATE_OC:
 700                        j->pld_slicw.bits.c1 = 0;
 701                        j->pld_slicw.bits.c2 = 0;
 702                        j->pld_slicw.bits.c3 = 0;
 703                        j->pld_slicw.bits.b2en = 0;
 704                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 705                        fRetVal = true;
 706                        break;
 707                case PLD_SLIC_STATE_RINGING:
 708                        j->pld_slicw.bits.c1 = 1;
 709                        j->pld_slicw.bits.c2 = 0;
 710                        j->pld_slicw.bits.c3 = 0;
 711                        j->pld_slicw.bits.b2en = 1;
 712                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 713                        fRetVal = true;
 714                        break;
 715                case PLD_SLIC_STATE_ACTIVE:
 716                        j->pld_slicw.bits.c1 = 0;
 717                        j->pld_slicw.bits.c2 = 1;
 718                        j->pld_slicw.bits.c3 = 0;
 719                        j->pld_slicw.bits.b2en = 0;
 720                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 721                        fRetVal = true;
 722                        break;
 723                case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 724
 725                        j->pld_slicw.bits.c1 = 1;
 726                        j->pld_slicw.bits.c2 = 1;
 727                        j->pld_slicw.bits.c3 = 0;
 728                        j->pld_slicw.bits.b2en = 0;
 729                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 730                        fRetVal = true;
 731                        break;
 732                case PLD_SLIC_STATE_TIPOPEN:
 733                        j->pld_slicw.bits.c1 = 0;
 734                        j->pld_slicw.bits.c2 = 0;
 735                        j->pld_slicw.bits.c3 = 1;
 736                        j->pld_slicw.bits.b2en = 0;
 737                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 738                        fRetVal = true;
 739                        break;
 740                case PLD_SLIC_STATE_STANDBY:
 741                        j->pld_slicw.bits.c1 = 1;
 742                        j->pld_slicw.bits.c2 = 0;
 743                        j->pld_slicw.bits.c3 = 1;
 744                        j->pld_slicw.bits.b2en = 1;
 745                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 746                        fRetVal = true;
 747                        break;
 748                case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 749
 750                        j->pld_slicw.bits.c1 = 0;
 751                        j->pld_slicw.bits.c2 = 1;
 752                        j->pld_slicw.bits.c3 = 1;
 753                        j->pld_slicw.bits.b2en = 0;
 754                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 755                        fRetVal = true;
 756                        break;
 757                case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 758
 759                        j->pld_slicw.bits.c1 = 1;
 760                        j->pld_slicw.bits.c2 = 1;
 761                        j->pld_slicw.bits.c3 = 1;
 762                        j->pld_slicw.bits.b2en = 0;
 763                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 764                        fRetVal = true;
 765                        break;
 766                default:
 767                        fRetVal = false;
 768                        break;
 769                }
 770        }
 771
 772        return fRetVal;
 773}
 774
 775static int ixj_wink(IXJ *j)
 776{
 777        BYTE slicnow;
 778
 779        slicnow = SLIC_GetState(j);
 780
 781        j->pots_winkstart = jiffies;
 782        SLIC_SetState(PLD_SLIC_STATE_OC, j);
 783
 784        msleep(jiffies_to_msecs(j->winktime));
 785
 786        SLIC_SetState(slicnow, j);
 787        return 0;
 788}
 789
 790static void ixj_init_timer(IXJ *j)
 791{
 792        init_timer(&j->timer);
 793        j->timer.function = ixj_timeout;
 794        j->timer.data = (unsigned long)j;
 795}
 796
 797static void ixj_add_timer(IXJ *j)
 798{
 799        j->timer.expires = jiffies + (hertz / samplerate);
 800        add_timer(&j->timer);
 801}
 802
 803static void ixj_tone_timeout(IXJ *j)
 804{
 805        IXJ_TONE ti;
 806
 807        j->tone_state++;
 808        if (j->tone_state == 3) {
 809                j->tone_state = 0;
 810                if (j->cadence_t) {
 811                        j->tone_cadence_state++;
 812                        if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 813                                switch (j->cadence_t->termination) {
 814                                case PLAY_ONCE:
 815                                        ixj_cpt_stop(j);
 816                                        break;
 817                                case REPEAT_LAST_ELEMENT:
 818                                        j->tone_cadence_state--;
 819                                        ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 820                                        break;
 821                                case REPEAT_ALL:
 822                                        j->tone_cadence_state = 0;
 823                                        if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 824                                                ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 825                                                ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 826                                                ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 827                                                ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 828                                                ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 829                                                ixj_init_tone(j, &ti);
 830                                        }
 831                                        ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 832                                        ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 833                                        ixj_play_tone(j, j->cadence_t->ce[0].index);
 834                                        break;
 835                                }
 836                        } else {
 837                                if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 838                                        ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 839                                        ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 840                                        ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 841                                        ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 842                                        ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 843                                        ixj_init_tone(j, &ti);
 844                                }
 845                                ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 846                                ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 847                                ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 848                        }
 849                }
 850        }
 851}
 852
 853static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 854{
 855        if(j->ixj_signals[event]) {
 856                if(ixjdebug & 0x0100)
 857                        printk("Sending signal for event %d\n", event);
 858                        /* Send apps notice of change */
 859                /* see config.h for macro definition */
 860                kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 861        }
 862}
 863
 864static void ixj_pstn_state(IXJ *j)
 865{
 866        int var;
 867        union XOPXR0 XR0, daaint;
 868
 869        var = 10;
 870
 871        XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 872        daaint.reg = 0;
 873        XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 874
 875        j->pld_scrr.byte = inb_p(j->XILINXbase);
 876        if (j->pld_scrr.bits.daaflag) {
 877                daa_int_read(j);
 878                if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 879                        if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 880                                daaint.bitreg.RING = 1;
 881                                if(ixjdebug & 0x0008) {
 882                                        printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 883                                }
 884                        } else {
 885                                daa_set_mode(j, SOP_PU_RESET);
 886                        }
 887                }
 888                if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 889                        daaint.bitreg.Caller_ID = 1;
 890                        j->pstn_cid_intr = 1;
 891                        j->pstn_cid_received = jiffies;
 892                        if(ixjdebug & 0x0008) {
 893                                printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 894                        }
 895                }
 896                if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 897                        daaint.bitreg.Cadence = 1;
 898                        if(ixjdebug & 0x0008) {
 899                                printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 900                        }
 901                }
 902                if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 903                        daaint.bitreg.VDD_OK = 1;
 904                        daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 905                }
 906        }
 907        daa_CR_read(j, 1);
 908        if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 909                daaint.bitreg.RMR = 1;
 910                daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 911                if(ixjdebug & 0x0008) {
 912                        printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
 913                }
 914                j->pstn_prev_rmr = j->pstn_last_rmr;
 915                j->pstn_last_rmr = jiffies;
 916        }
 917        switch(j->daa_mode) {
 918                case SOP_PU_SLEEP:
 919                        if (daaint.bitreg.RING) {
 920                                if (!j->flags.pstn_ringing) {
 921                                        if (j->daa_mode != SOP_PU_RINGING) {
 922                                                j->pstn_ring_int = jiffies;
 923                                                daa_set_mode(j, SOP_PU_RINGING);
 924                                        }
 925                                }
 926                        }
 927                        break;
 928                case SOP_PU_RINGING:
 929                        if (daaint.bitreg.RMR) {
 930                                if (ixjdebug & 0x0008) {
 931                                        printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 932                                }
 933                                if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 934                                        j->flags.pstn_rmr = 1;
 935                                        j->pstn_ring_start = jiffies;
 936                                        j->pstn_ring_stop = 0;
 937                                        j->ex.bits.pstn_ring = 0;
 938                                        if (j->cadence_f[4].state == 0) {
 939                                                j->cadence_f[4].state = 1;
 940                                                j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 941                                                j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 942                                                j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 943                                        } else if (j->cadence_f[4].state == 2) {
 944                                                if((time_after(jiffies, j->cadence_f[4].off1min) &&
 945                                                    time_before(jiffies, j->cadence_f[4].off1max))) {
 946                                                        if (j->cadence_f[4].on2) {
 947                                                                j->cadence_f[4].state = 3;
 948                                                                j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 949                                                                j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 950                                                                j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 951                                                        } else {
 952                                                                j->cadence_f[4].state = 7;
 953                                                        }
 954                                                } else {
 955                                                        if (ixjdebug & 0x0008) {
 956                                                                printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 957                                                                                j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 958                                                                                j->cadence_f[4].off1);
 959                                                        }
 960                                                        j->cadence_f[4].state = 0;
 961                                                }
 962                                        } else if (j->cadence_f[4].state == 4) {
 963                                                if((time_after(jiffies, j->cadence_f[4].off2min) &&
 964                                                    time_before(jiffies, j->cadence_f[4].off2max))) {
 965                                                        if (j->cadence_f[4].on3) {
 966                                                                j->cadence_f[4].state = 5;
 967                                                                j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 968                                                                j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 969                                                                j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 970                                                        } else {
 971                                                                j->cadence_f[4].state = 7;
 972                                                        }
 973                                                } else {
 974                                                        if (ixjdebug & 0x0008) {
 975                                                                printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 976                                                                                j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 977                                                                                j->cadence_f[4].off2);
 978                                                        }
 979                                                        j->cadence_f[4].state = 0;
 980                                                }
 981                                        } else if (j->cadence_f[4].state == 6) {
 982                                                if((time_after(jiffies, j->cadence_f[4].off3min) &&
 983                                                    time_before(jiffies, j->cadence_f[4].off3max))) {
 984                                                        j->cadence_f[4].state = 7;
 985                                                } else {
 986                                                        if (ixjdebug & 0x0008) {
 987                                                                printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 988                                                                                j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 989                                                                                j->cadence_f[4].off3);
 990                                                        }
 991                                                        j->cadence_f[4].state = 0;
 992                                                }
 993                                        } else {
 994                                                j->cadence_f[4].state = 0;
 995                                        }
 996                                } else {                                /* Falling edge of RMR */
 997                                        j->pstn_ring_start = 0;
 998                                        j->pstn_ring_stop = jiffies;
 999                                        if (j->cadence_f[4].state == 1) {
1000                                                if(!j->cadence_f[4].on1) {
1001                                                        j->cadence_f[4].state = 7;
1002                                                } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003                                                  time_before(jiffies, j->cadence_f[4].on1max))) {
1004                                                        if (j->cadence_f[4].off1) {
1005                                                                j->cadence_f[4].state = 2;
1006                                                                j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007                                                                j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008                                                                j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009                                                        } else {
1010                                                                j->cadence_f[4].state = 7;
1011                                                        }
1012                                                } else {
1013                                                        if (ixjdebug & 0x0008) {
1014                                                                printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015                                                                                j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016                                                                                j->cadence_f[4].on1);
1017                                                        }
1018                                                        j->cadence_f[4].state = 0;
1019                                                }
1020                                        } else if (j->cadence_f[4].state == 3) {
1021                                                if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022                                                    time_before(jiffies, j->cadence_f[4].on2max))) {
1023                                                        if (j->cadence_f[4].off2) {
1024                                                                j->cadence_f[4].state = 4;
1025                                                                j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026                                                                j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027                                                                j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028                                                        } else {
1029                                                                j->cadence_f[4].state = 7;
1030                                                        }
1031                                                } else {
1032                                                        if (ixjdebug & 0x0008) {
1033                                                                printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034                                                                                j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035                                                                                j->cadence_f[4].on2);
1036                                                        }
1037                                                        j->cadence_f[4].state = 0;
1038                                                }
1039                                        } else if (j->cadence_f[4].state == 5) {
1040                                                if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041                                                    time_before(jiffies, j->cadence_f[4].on3max))) {
1042                                                        if (j->cadence_f[4].off3) {
1043                                                                j->cadence_f[4].state = 6;
1044                                                                j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045                                                                j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046                                                                j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047                                                        } else {
1048                                                                j->cadence_f[4].state = 7;
1049                                                        }
1050                                                } else {
1051                                                        j->cadence_f[4].state = 0;
1052                                                }
1053                                        } else {
1054                                                if (ixjdebug & 0x0008) {
1055                                                        printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056                                                                        j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057                                                                        j->cadence_f[4].on3);
1058                                                }
1059                                                j->cadence_f[4].state = 0;
1060                                        }
1061                                }
1062                                if (ixjdebug & 0x0010) {
1063                                        printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064                                }
1065                                if (ixjdebug & 0x0010) {
1066                                        switch(j->cadence_f[4].state) {
1067                                                case 1:
1068                                                        printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069                                                j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070                                                        break;
1071                                                case 2:
1072                                                        printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073                                                j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074                                                        break;
1075                                                case 3:
1076                                                        printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077                                                j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078                                                        break;
1079                                                case 4:
1080                                                        printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081                                                j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082                                                        break;
1083                                                case 5:
1084                                                        printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085                                                j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086                                                        break;
1087                                                case 6: 
1088                                                        printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089                                                j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090                                                        break;
1091                                        }
1092                                }
1093                        }
1094                        if (j->cadence_f[4].state == 7) {
1095                                j->cadence_f[4].state = 0;
1096                                j->pstn_ring_stop = jiffies;
1097                                j->ex.bits.pstn_ring = 1;
1098                                ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099                                if(ixjdebug & 0x0008) {
1100                                        printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101                                }
1102                        }
1103                        if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104                           (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105                                if(ixjdebug & 0x0008) {
1106                                        printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107                                        printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108                                        printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109                                }
1110                                j->pstn_ring_stop = j->pstn_ring_int = 0;
1111                                daa_set_mode(j, SOP_PU_SLEEP);
1112                        } 
1113                        outb_p(j->pld_scrw.byte, j->XILINXbase);
1114                        if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115                                ixj_daa_cid_read(j);
1116                                j->ex.bits.caller_id = 1;
1117                                ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118                                j->pstn_cid_intr = 0;
1119                        }
1120                        if (daaint.bitreg.Cadence) {
1121                                if(ixjdebug & 0x0008) {
1122                                        printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123                                }
1124                                daa_set_mode(j, SOP_PU_SLEEP);
1125                                j->ex.bits.pstn_ring = 0;
1126                        }
1127                        break;
1128                case SOP_PU_CONVERSATION:
1129                        if (daaint.bitreg.VDD_OK) {
1130                                if(!daaint.bitreg.SI_0) {
1131                                        if (!j->pstn_winkstart) {
1132                                                if(ixjdebug & 0x0008) {
1133                                                        printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134                                                }
1135                                                j->pstn_winkstart = jiffies;
1136                                        } 
1137                                } else {
1138                                        if (j->pstn_winkstart) {
1139                                                if(ixjdebug & 0x0008) {
1140                                                        printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141                                                }
1142                                                j->pstn_winkstart = 0;
1143                                        }
1144                                }
1145                        }
1146                        if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147                                if(ixjdebug & 0x0008) {
1148                                        printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149                                }
1150                                daa_set_mode(j, SOP_PU_SLEEP);
1151                                j->pstn_winkstart = 0;
1152                                j->ex.bits.pstn_wink = 1;
1153                                ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154                        }
1155                        break;
1156        }
1157}
1158
1159static void ixj_timeout(unsigned long ptr)
1160{
1161        int board;
1162        unsigned long jifon;
1163        IXJ *j = (IXJ *)ptr;
1164        board = j->board;
1165
1166        if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167                ixj_perfmon(j->timerchecks);
1168                j->hookstate = ixj_hookstate(j);
1169                if (j->tone_state) {
1170                        if (!(j->hookstate)) {
1171                                ixj_cpt_stop(j);
1172                                if (j->m_hook) {
1173                                        j->m_hook = 0;
1174                                        j->ex.bits.hookstate = 1;
1175                                        ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176                                }
1177                                clear_bit(board, &j->busyflags);
1178                                ixj_add_timer(j);
1179                                return;
1180                        }
1181                        if (j->tone_state == 1)
1182                                jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183                        else
1184                                jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185                        if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186                                if (j->tone_state == 1) {
1187                                        ixj_play_tone(j, j->tone_index);
1188                                        if (j->dsp.low == 0x20) {
1189                                                clear_bit(board, &j->busyflags);
1190                                                ixj_add_timer(j);
1191                                                return;
1192                                        }
1193                                } else {
1194                                        ixj_play_tone(j, 0);
1195                                        if (j->dsp.low == 0x20) {
1196                                                clear_bit(board, &j->busyflags);
1197                                                ixj_add_timer(j);
1198                                                return;
1199                                        }
1200                                }
1201                        } else {
1202                                ixj_tone_timeout(j);
1203                                if (j->flags.dialtone) {
1204                                        ixj_dialtone(j);
1205                                }
1206                                if (j->flags.busytone) {
1207                                        ixj_busytone(j);
1208                                        if (j->dsp.low == 0x20) {
1209                                                clear_bit(board, &j->busyflags);
1210                                                ixj_add_timer(j);
1211                                                return;
1212                                        }
1213                                }
1214                                if (j->flags.ringback) {
1215                                        ixj_ringback(j);
1216                                        if (j->dsp.low == 0x20) {
1217                                                clear_bit(board, &j->busyflags);
1218                                                ixj_add_timer(j);
1219                                                return;
1220                                        }
1221                                }
1222                                if (!j->tone_state) {
1223                                        ixj_cpt_stop(j);
1224                                }
1225                        }
1226                }
1227                if (!(j->tone_state && j->dsp.low == 0x20)) {
1228                        if (IsRxReady(j)) {
1229                                ixj_read_frame(j);
1230                        }
1231                        if (IsTxReady(j)) {
1232                                ixj_write_frame(j);
1233                        }
1234                }
1235                if (j->flags.cringing) {
1236                        if (j->hookstate & 1) {
1237                                j->flags.cringing = 0;
1238                                ixj_ring_off(j);
1239                        } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240                                switch(j->cadence_f[5].state) {
1241                                        case 0:
1242                                                j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243                                                if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244                                                        if(ixjdebug & 0x0004) {
1245                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246                                                        }
1247                                                        ixj_ring_on(j);
1248                                                }
1249                                                j->cadence_f[5].state = 1;
1250                                                break;
1251                                        case 1:
1252                                                if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253                                                        j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254                                                        if(ixjdebug & 0x0004) {
1255                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256                                                        }
1257                                                        ixj_ring_off(j);
1258                                                        j->cadence_f[5].state = 2;
1259                                                }
1260                                                break;
1261                                        case 2:
1262                                                if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263                                                        if(ixjdebug & 0x0004) {
1264                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265                                                        }
1266                                                        ixj_ring_on(j);
1267                                                        if (j->cadence_f[5].on2) {
1268                                                                j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269                                                                j->cadence_f[5].state = 3;
1270                                                        } else {
1271                                                                j->cadence_f[5].state = 7;
1272                                                        }
1273                                                }
1274                                                break;
1275                                        case 3:
1276                                                if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277                                                        if(ixjdebug & 0x0004) {
1278                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279                                                        }
1280                                                        ixj_ring_off(j);
1281                                                        if (j->cadence_f[5].off2) {
1282                                                                j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283                                                                j->cadence_f[5].state = 4;
1284                                                        } else {
1285                                                                j->cadence_f[5].state = 7;
1286                                                        }
1287                                                }
1288                                                break;
1289                                        case 4:
1290                                                if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291                                                        if(ixjdebug & 0x0004) {
1292                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293                                                        }
1294                                                        ixj_ring_on(j);
1295                                                        if (j->cadence_f[5].on3) {
1296                                                                j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297                                                                j->cadence_f[5].state = 5;
1298                                                        } else {
1299                                                                j->cadence_f[5].state = 7;
1300                                                        }
1301                                                }
1302                                                break;
1303                                        case 5:
1304                                                if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305                                                        if(ixjdebug & 0x0004) {
1306                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307                                                        }
1308                                                        ixj_ring_off(j);
1309                                                        if (j->cadence_f[5].off3) {
1310                                                                j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311                                                                j->cadence_f[5].state = 6;
1312                                                        } else {
1313                                                                j->cadence_f[5].state = 7;
1314                                                        }
1315                                                }
1316                                                break;
1317                                        case 6:
1318                                                if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319                                                        if(ixjdebug & 0x0004) {
1320                                                                printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321                                                        }
1322                                                        j->cadence_f[5].state = 7;
1323                                                }
1324                                                break;
1325                                        case 7:
1326                                                if(ixjdebug & 0x0004) {
1327                                                        printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328                                                }
1329                                                j->flags.cidring = 1;
1330                                                j->cadence_f[5].state = 0;
1331                                                break;
1332                                }
1333                                if (j->flags.cidring && !j->flags.cidsent) {
1334                                        j->flags.cidsent = 1;
1335                                        if(j->fskdcnt) {
1336                                                SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337                                                ixj_pre_cid(j);
1338                                        }
1339                                        j->flags.cidring = 0;
1340                                }
1341                                clear_bit(board, &j->busyflags);
1342                                ixj_add_timer(j);
1343                                return;
1344                        } else {
1345                                if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346                                        if (j->flags.cidring && !j->flags.cidsent) {
1347                                                j->flags.cidsent = 1;
1348                                                if(j->fskdcnt) {
1349                                                        SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350                                                        ixj_pre_cid(j);
1351                                                }
1352                                                j->flags.cidring = 0;
1353                                        }
1354                                        j->ring_cadence_t--;
1355                                        if (j->ring_cadence_t == -1)
1356                                                j->ring_cadence_t = 15;
1357                                        j->ring_cadence_jif = jiffies;
1358
1359                                        if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360                                                if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361                                                        j->flags.firstring = 1;
1362                                                else
1363                                                        ixj_ring_on(j);
1364                                        } else {
1365                                                ixj_ring_off(j);
1366                                                if(!j->flags.cidsent)
1367                                                        j->flags.cidring = 1;
1368                                        }
1369                                }
1370                                clear_bit(board, &j->busyflags);
1371                                ixj_add_timer(j);
1372                                return;
1373                        }
1374                }
1375                if (!j->flags.ringing) {
1376                        if (j->hookstate) { /* & 1) { */
1377                                if (j->dsp.low != 0x20 &&
1378                                    SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379                                        SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380                                }
1381                                LineMonitor(j);
1382                                read_filters(j);
1383                                ixj_WriteDSPCommand(0x511B, j);
1384                                j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385                                if (!j->m_hook && (j->hookstate & 1)) {
1386                                        j->m_hook = j->ex.bits.hookstate = 1;
1387                                        ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388                                }
1389                        } else {
1390                                if (j->ex.bits.dtmf_ready) {
1391                                        j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392                                }
1393                                if (j->m_hook) {
1394                                        j->m_hook = 0;
1395                                        j->ex.bits.hookstate = 1;
1396                                        ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397                                }
1398                        }
1399                }
1400                if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401                        ixj_pstn_state(j);
1402                }
1403                if (j->ex.bytes) {
1404                        wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1405                }
1406                clear_bit(board, &j->busyflags);
1407        }
1408        ixj_add_timer(j);
1409}
1410
1411static int ixj_status_wait(IXJ *j)
1412{
1413        unsigned long jif;
1414
1415        jif = jiffies + ((60 * hertz) / 100);
1416        while (!IsStatusReady(j)) {
1417                ixj_perfmon(j->statuswait);
1418                if (time_after(jiffies, jif)) {
1419                        ixj_perfmon(j->statuswaitfail);
1420                        return -1;
1421                }
1422        }
1423        return 0;
1424}
1425
1426static int ixj_PCcontrol_wait(IXJ *j)
1427{
1428        unsigned long jif;
1429
1430        jif = jiffies + ((60 * hertz) / 100);
1431        while (!IsPCControlReady(j)) {
1432                ixj_perfmon(j->pcontrolwait);
1433                if (time_after(jiffies, jif)) {
1434                        ixj_perfmon(j->pcontrolwaitfail);
1435                        return -1;
1436                }
1437        }
1438        return 0;
1439}
1440
1441static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442{
1443        BYTES bytes;
1444        unsigned long jif;
1445
1446        atomic_inc(&j->DSPWrite);
1447        if(atomic_read(&j->DSPWrite) > 1) {
1448                printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449                return -1;
1450        }
1451        bytes.high = (cmd & 0xFF00) >> 8;
1452        bytes.low = cmd & 0x00FF;
1453        jif = jiffies + ((60 * hertz) / 100);
1454        while (!IsControlReady(j)) {
1455                ixj_perfmon(j->iscontrolready);
1456                if (time_after(jiffies, jif)) {
1457                        ixj_perfmon(j->iscontrolreadyfail);
1458                        atomic_dec(&j->DSPWrite);
1459                        if(atomic_read(&j->DSPWrite) > 0) {
1460                                printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461                                while(atomic_read(&j->DSPWrite) > 0) {
1462                                        atomic_dec(&j->DSPWrite);
1463                                }
1464                        }
1465                        return -1;
1466                }
1467        }
1468        outb(bytes.low, j->DSPbase + 6);
1469        outb(bytes.high, j->DSPbase + 7);
1470
1471        if (ixj_status_wait(j)) {
1472                j->ssr.low = 0xFF;
1473                j->ssr.high = 0xFF;
1474                atomic_dec(&j->DSPWrite);
1475                if(atomic_read(&j->DSPWrite) > 0) {
1476                        printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477                        while(atomic_read(&j->DSPWrite) > 0) {
1478                                atomic_dec(&j->DSPWrite);
1479                        }
1480                }
1481                return -1;
1482        }
1483/* Read Software Status Register */
1484        j->ssr.low = inb_p(j->DSPbase + 2);
1485        j->ssr.high = inb_p(j->DSPbase + 3);
1486        atomic_dec(&j->DSPWrite);
1487        if(atomic_read(&j->DSPWrite) > 0) {
1488                printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489                while(atomic_read(&j->DSPWrite) > 0) {
1490                        atomic_dec(&j->DSPWrite);
1491                }
1492        }
1493        return 0;
1494}
1495
1496/***************************************************************************
1497*
1498*  General Purpose IO Register read routine
1499*
1500***************************************************************************/
1501static inline int ixj_gpio_read(IXJ *j)
1502{
1503        if (ixj_WriteDSPCommand(0x5143, j))
1504                return -1;
1505
1506        j->gpio.bytes.low = j->ssr.low;
1507        j->gpio.bytes.high = j->ssr.high;
1508
1509        return 0;
1510}
1511
1512static inline void LED_SetState(int state, IXJ *j)
1513{
1514        if (j->cardtype == QTI_LINEJACK) {
1515                j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516                j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517                j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518                j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519
1520                outb(j->pld_scrw.byte, j->XILINXbase);
1521        }
1522}
1523
1524/*********************************************************************
1525*  GPIO Pins are configured as follows on the Quicknet Internet
1526*  PhoneJACK Telephony Cards
1527* 
1528* POTS Select        GPIO_6=0 GPIO_7=0
1529* Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530* Handset Select     GPIO_6=1 GPIO_7=0
1531*
1532* SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1533* SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1534* SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1535*
1536* Hook Switch changes reported on GPIO_3
1537*********************************************************************/
1538static int ixj_set_port(IXJ *j, int arg)
1539{
1540        if (j->cardtype == QTI_PHONEJACK_LITE) {
1541                if (arg != PORT_POTS)
1542                        return 10;
1543                else
1544                        return 0;
1545        }
1546        switch (arg) {
1547        case PORT_POTS:
1548                j->port = PORT_POTS;
1549                switch (j->cardtype) {
1550                case QTI_PHONECARD:
1551                        if (j->flags.pcmciasct == 1)
1552                                SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553                        else
1554                                return 11;
1555                        break;
1556                case QTI_PHONEJACK_PCI:
1557                        j->pld_slicw.pcib.mic = 0;
1558                        j->pld_slicw.pcib.spk = 0;
1559                        outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560                        break;
1561                case QTI_LINEJACK:
1562                        ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1563                        if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1564                                                                           Software Control Register */
1565                                return 2;
1566                        j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1567
1568                        outb(j->pld_scrw.byte, j->XILINXbase);
1569                        j->pld_clock.byte = 0;
1570                        outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571                        j->pld_slicw.bits.rly1 = 1;
1572                        j->pld_slicw.bits.spken = 0;
1573                        outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574                        ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1575                        ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1576                        ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1577                        ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1578                        ixj_mixer(0x0E80, j);   /*Mic mute */
1579                        ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1580                        ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1581                        ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1582                        SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583/*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584                        break;
1585                case QTI_PHONEJACK:
1586                        j->gpio.bytes.high = 0x0B;
1587                        j->gpio.bits.gpio6 = 0;
1588                        j->gpio.bits.gpio7 = 0;
1589                        ixj_WriteDSPCommand(j->gpio.word, j);
1590                        break;
1591                }
1592                break;
1593        case PORT_PSTN:
1594                if (j->cardtype == QTI_LINEJACK) {
1595                        ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596
1597                        j->pld_slicw.bits.rly3 = 0;
1598                        j->pld_slicw.bits.rly1 = 1;
1599                        j->pld_slicw.bits.spken = 0;
1600                        outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601                        j->port = PORT_PSTN;
1602                } else {
1603                        return 4;
1604                }
1605                break;
1606        case PORT_SPEAKER:
1607                j->port = PORT_SPEAKER;
1608                switch (j->cardtype) {
1609                case QTI_PHONECARD:
1610                        if (j->flags.pcmciasct) {
1611                                SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612                        }
1613                        break;
1614                case QTI_PHONEJACK_PCI:
1615                        j->pld_slicw.pcib.mic = 1;
1616                        j->pld_slicw.pcib.spk = 1;
1617                        outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618                        break;
1619                case QTI_LINEJACK:
1620                        ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1621                        if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1622                                                                           Software Control Register */
1623                                return 2;
1624                        j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1625
1626                        outb(j->pld_scrw.byte, j->XILINXbase);
1627                        j->pld_clock.byte = 0;
1628                        outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629                        j->pld_slicw.bits.rly1 = 1;
1630                        j->pld_slicw.bits.spken = 1;
1631                        outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632                        ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1633                        ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1634                        ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1635                        ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1636                        ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1637                        ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1638                        ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1639                        ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1640                        break;
1641                case QTI_PHONEJACK:
1642                        j->gpio.bytes.high = 0x0B;
1643                        j->gpio.bits.gpio6 = 0;
1644                        j->gpio.bits.gpio7 = 1;
1645                        ixj_WriteDSPCommand(j->gpio.word, j);
1646                        break;
1647                }
1648                break;
1649        case PORT_HANDSET:
1650                if (j->cardtype != QTI_PHONEJACK) {
1651                        return 5;
1652                } else {
1653                        j->gpio.bytes.high = 0x0B;
1654                        j->gpio.bits.gpio6 = 1;
1655                        j->gpio.bits.gpio7 = 0;
1656                        ixj_WriteDSPCommand(j->gpio.word, j);
1657                        j->port = PORT_HANDSET;
1658                }
1659                break;
1660        default:
1661                return 6;
1662                break;
1663        }
1664        return 0;
1665}
1666
1667static int ixj_set_pots(IXJ *j, int arg)
1668{
1669        if (j->cardtype == QTI_LINEJACK) {
1670                if (arg) {
1671                        if (j->port == PORT_PSTN) {
1672                                j->pld_slicw.bits.rly1 = 0;
1673                                outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674                                j->flags.pots_pstn = 1;
1675                                return 1;
1676                        } else {
1677                                j->flags.pots_pstn = 0;
1678                                return 0;
1679                        }
1680                } else {
1681                        j->pld_slicw.bits.rly1 = 1;
1682                        outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683                        j->flags.pots_pstn = 0;
1684                        return 1;
1685                }
1686        } else {
1687                return 0;
1688        }
1689}
1690
1691static void ixj_ring_on(IXJ *j)
1692{
1693        if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694         {
1695                if (ixjdebug & 0x0004)
1696                        printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1697
1698                j->gpio.bytes.high = 0x0B;
1699                j->gpio.bytes.low = 0x00;
1700                j->gpio.bits.gpio1 = 1;
1701                j->gpio.bits.gpio2 = 1;
1702                j->gpio.bits.gpio5 = 0;
1703                ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1704        } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705        {
1706                if (ixjdebug & 0x0004)
1707                        printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708
1709                SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710        }
1711}
1712
1713static int ixj_siadc(IXJ *j, int val)
1714{
1715        if(j->cardtype == QTI_PHONECARD){
1716                if(j->flags.pcmciascp){
1717                        if(val == -1)
1718                                return j->siadc.bits.rxg;
1719
1720                        if(val < 0 || val > 0x1F)
1721                                return -1;
1722
1723                        j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1724                        j->siadc.bits.lom = 0;                          /* Line Out Mute */
1725                        j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1726                        j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1727                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1728                        j->psccr.bits.dev = 0;
1729                        outb(j->siadc.byte, j->XILINXbase + 0x00);
1730                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1731                        ixj_PCcontrol_wait(j);
1732                        return j->siadc.bits.rxg;
1733                }
1734        }
1735        return -1;
1736}
1737
1738static int ixj_sidac(IXJ *j, int val)
1739{
1740        if(j->cardtype == QTI_PHONECARD){
1741                if(j->flags.pcmciascp){
1742                        if(val == -1)
1743                                return j->sidac.bits.txg;
1744
1745                        if(val < 0 || val > 0x1F)
1746                                return -1;
1747
1748                        j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1749                        j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1750                        j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1751                        j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1752                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1753                        j->psccr.bits.dev = 0;
1754                        outb(j->sidac.byte, j->XILINXbase + 0x00);
1755                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1756                        ixj_PCcontrol_wait(j);
1757                        return j->sidac.bits.txg;
1758                }
1759        }
1760        return -1;
1761}
1762
1763static int ixj_pcmcia_cable_check(IXJ *j)
1764{
1765        j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766        if (!j->flags.pcmciastate) {
1767                j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768                if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769                        j->flags.pcmciastate = 4;
1770                        return 0;
1771                }
1772                if (j->pccr1.bits.ed) {
1773                        j->pccr1.bits.ed = 0;
1774                        j->psccr.bits.dev = 3;
1775                        j->psccr.bits.rw = 1;
1776                        outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777                        ixj_PCcontrol_wait(j);
1778                        j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779                        j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780                        j->psccr.bits.dev = 3;
1781                        j->psccr.bits.rw = 0;
1782                        outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783                        ixj_PCcontrol_wait(j);
1784                        return j->pslic.bits.led2 ? 1 : 0;
1785                } else if (j->flags.pcmciasct) {
1786                        return j->r_hook;
1787                } else {
1788                        return 1;
1789                }
1790        } else if (j->flags.pcmciastate == 4) {
1791                if (!j->pccr1.bits.drf) {
1792                        j->flags.pcmciastate = 3;
1793                }
1794                return 0;
1795        } else if (j->flags.pcmciastate == 3) {
1796                j->pccr2.bits.pwr = 0;
1797                j->pccr2.bits.rstc = 1;
1798                outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799                j->checkwait = jiffies + (hertz * 2);
1800                j->flags.incheck = 1;
1801                j->flags.pcmciastate = 2;
1802                return 0;
1803        } else if (j->flags.pcmciastate == 2) {
1804                if (j->flags.incheck) {
1805                        if (time_before(jiffies, j->checkwait)) {
1806                                return 0;
1807                        } else {
1808                                j->flags.incheck = 0;
1809                        }
1810                }
1811                j->pccr2.bits.pwr = 0;
1812                j->pccr2.bits.rstc = 0;
1813                outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814                j->flags.pcmciastate = 1;
1815                return 0;
1816        } else if (j->flags.pcmciastate == 1) {
1817                j->flags.pcmciastate = 0;
1818                if (!j->pccr1.bits.drf) {
1819                        j->psccr.bits.dev = 3;
1820                        j->psccr.bits.rw = 1;
1821                        outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822                        ixj_PCcontrol_wait(j);
1823                        j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1824
1825                        j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1826
1827                        if (j->flags.pcmciasct == 3) {
1828                                j->flags.pcmciastate = 4;
1829                                return 0;
1830                        } else if (j->flags.pcmciasct == 0) {
1831                                j->pccr2.bits.pwr = 1;
1832                                j->pccr2.bits.rstc = 0;
1833                                outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834                                j->port = PORT_SPEAKER;
1835                        } else {
1836                                j->port = PORT_POTS;
1837                        }
1838                        j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1839                        j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1840                        j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1841                        j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1842                        j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1843                        j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1844                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1845                        j->psccr.bits.dev = 0;
1846                        outb(j->sic1.byte, j->XILINXbase + 0x00);
1847                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1848                        ixj_PCcontrol_wait(j);
1849
1850                        j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1851                        j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1852                        j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1853                        j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1854                        j->sic2.bits.hpd = 0;                           /* HPF disable */
1855                        j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1856                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1857                        j->psccr.bits.dev = 0;
1858                        outb(j->sic2.byte, j->XILINXbase + 0x00);
1859                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1860                        ixj_PCcontrol_wait(j);
1861
1862                        j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1863                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1864                        j->psccr.bits.dev = 0;
1865                        outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1866                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1867                        ixj_PCcontrol_wait(j);
1868
1869                        j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1870                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1871                        j->psccr.bits.dev = 0;
1872                        outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1873                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1874                        ixj_PCcontrol_wait(j);
1875
1876                        j->sirxg.bits.lig = 1;                          /* Line In Gain */
1877                        j->sirxg.bits.lim = 1;                          /* Line In Mute */
1878                        j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1879                        j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1880                        j->sirxg.bits.him = 0;                          /* Handset In Mute */
1881                        j->sirxg.bits.iir = 1;                          /* IIR */
1882                        j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1883                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1884                        j->psccr.bits.dev = 0;
1885                        outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1887                        ixj_PCcontrol_wait(j);
1888
1889                        ixj_siadc(j, 0x17);
1890                        ixj_sidac(j, 0x1D);
1891
1892                        j->siaatt.bits.sot = 0;
1893                        j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1894                        j->psccr.bits.rw = 0;                           /* Read / Write flag */
1895                        j->psccr.bits.dev = 0;
1896                        outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897                        outb(j->psccr.byte, j->XILINXbase + 0x01);
1898                        ixj_PCcontrol_wait(j);
1899
1900                        if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901                                j->psccr.byte = j->pslic.byte = 0;
1902                                j->pslic.bits.powerdown = 1;
1903                                j->psccr.bits.dev = 3;
1904                                j->psccr.bits.rw = 0;
1905                                outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906                                ixj_PCcontrol_wait(j);
1907                        }
1908                }
1909                return 0;
1910        } else {
1911                j->flags.pcmciascp = 0;
1912                return 0;
1913        }
1914        return 0;
1915}
1916
1917static int ixj_hookstate(IXJ *j)
1918{
1919        int fOffHook = 0;
1920
1921        switch (j->cardtype) {
1922        case QTI_PHONEJACK:
1923                ixj_gpio_read(j);
1924                fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925                break;
1926        case QTI_LINEJACK:
1927        case QTI_PHONEJACK_LITE:
1928        case QTI_PHONEJACK_PCI:
1929                SLIC_GetState(j);
1930                if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931                        fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932                        if(fOffHook != j->p_hook) {
1933                                if(!j->checkwait) {
1934                                        j->checkwait = jiffies;
1935                                } 
1936                                if(time_before(jiffies, j->checkwait + 2)) {
1937                                        fOffHook ^= 1;
1938                                } else {
1939                                        j->checkwait = 0;
1940                                }
1941                                j->p_hook = fOffHook;
1942                                printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943                        }
1944                } else {
1945                        if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946                            j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947                                if (j->flags.ringing || j->flags.cringing) {
1948                                        if (!in_interrupt()) {
1949                                                msleep(20);
1950                                        }
1951                                        SLIC_GetState(j);
1952                                        if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953                                                ixj_ring_on(j);
1954                                        }
1955                                }
1956                                if (j->cardtype == QTI_PHONEJACK_PCI) {
1957                                        j->pld_scrr.byte = inb_p(j->XILINXbase);
1958                                        fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959                                } else
1960                                        fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961                        }
1962                }
1963                break;
1964        case QTI_PHONECARD:
1965                fOffHook = ixj_pcmcia_cable_check(j);
1966                break;
1967        }
1968        if (j->r_hook != fOffHook) {
1969                j->r_hook = fOffHook;
1970                if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971                        j->ex.bits.hookstate = 1;
1972                        ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973                } else if (!fOffHook) {
1974                        j->flash_end = jiffies + ((60 * hertz) / 100);
1975                }
1976        }
1977        if (fOffHook) {
1978                if(time_before(jiffies, j->flash_end)) {
1979                        j->ex.bits.flash = 1;
1980                        j->flash_end = 0;
1981                        ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982                }
1983        } else {
1984                if(time_before(jiffies, j->flash_end)) {
1985                        fOffHook = 1;
1986                }
1987        }
1988
1989        if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990                fOffHook |= 2;
1991
1992        if (j->port == PORT_SPEAKER) {
1993                if(j->cardtype == QTI_PHONECARD) {
1994                        if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995                                fOffHook |= 2;
1996                        }
1997                } else {
1998                        fOffHook |= 2;
1999                }
2000        }
2001
2002        if (j->port == PORT_HANDSET)
2003                fOffHook |= 2;
2004
2005        return fOffHook;
2006}
2007
2008static void ixj_ring_off(IXJ *j)
2009{
2010        if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011         {
2012                if (ixjdebug & 0x0004)
2013                        printk(KERN_INFO "IXJ Ring Off\n");
2014                j->gpio.bytes.high = 0x0B;
2015                j->gpio.bytes.low = 0x00;
2016                j->gpio.bits.gpio1 = 0;
2017                j->gpio.bits.gpio2 = 1;
2018                j->gpio.bits.gpio5 = 0;
2019                ixj_WriteDSPCommand(j->gpio.word, j);
2020        } else                  /* Internet LineJACK */
2021        {
2022                if (ixjdebug & 0x0004)
2023                        printk(KERN_INFO "IXJ Ring Off\n");
2024
2025                if(!j->flags.cidplay)
2026                        SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027
2028                SLIC_GetState(j);
2029        }
2030}
2031
2032static void ixj_ring_start(IXJ *j)
2033{
2034        j->flags.cringing = 1;
2035        if (ixjdebug & 0x0004)
2036                printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037        if (ixj_hookstate(j) & 1) {
2038                if (j->port == PORT_POTS)
2039                        ixj_ring_off(j);
2040                j->flags.cringing = 0;
2041                if (ixjdebug & 0x0004)
2042                        printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043        } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044                j->ring_cadence_jif = jiffies;
2045                j->flags.cidsent = j->flags.cidring = 0;
2046                j->cadence_f[5].state = 0;
2047                if(j->cadence_f[5].on1)
2048                        ixj_ring_on(j);
2049        } else {
2050                j->ring_cadence_jif = jiffies;
2051                j->ring_cadence_t = 15;
2052                if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053                        ixj_ring_on(j);
2054                } else {
2055                        ixj_ring_off(j);
2056                }
2057                j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058        }
2059}
2060
2061static int ixj_ring(IXJ *j)
2062{
2063        char cntr;
2064        unsigned long jif;
2065
2066        j->flags.ringing = 1;
2067        if (ixj_hookstate(j) & 1) {
2068                ixj_ring_off(j);
2069                j->flags.ringing = 0;
2070                return 1;
2071        }
2072        for (cntr = 0; cntr < j->maxrings; cntr++) {
2073                jif = jiffies + (1 * hertz);
2074                ixj_ring_on(j);
2075                while (time_before(jiffies, jif)) {
2076                        if (ixj_hookstate(j) & 1) {
2077                                ixj_ring_off(j);
2078                                j->flags.ringing = 0;
2079                                return 1;
2080                        }
2081                        schedule_timeout_interruptible(1);
2082                        if (signal_pending(current))
2083                                break;
2084                }
2085                jif = jiffies + (3 * hertz);
2086                ixj_ring_off(j);
2087                while (time_before(jiffies, jif)) {
2088                        if (ixj_hookstate(j) & 1) {
2089                                msleep(10);
2090                                if (ixj_hookstate(j) & 1) {
2091                                        j->flags.ringing = 0;
2092                                        return 1;
2093                                }
2094                        }
2095                        schedule_timeout_interruptible(1);
2096                        if (signal_pending(current))
2097                                break;
2098                }
2099        }
2100        ixj_ring_off(j);
2101        j->flags.ringing = 0;
2102        return 0;
2103}
2104
2105static int ixj_open(struct phone_device *p, struct file *file_p)
2106{
2107        IXJ *j = get_ixj(p->board);
2108        file_p->private_data = j;
2109
2110        if (!j->DSPbase)
2111                return -ENODEV;
2112
2113        if (file_p->f_mode & FMODE_READ) {
2114                if(!j->readers) {
2115                        j->readers++;
2116                } else {
2117                        return -EBUSY;
2118                }
2119        }
2120
2121        if (file_p->f_mode & FMODE_WRITE) {
2122                if(!j->writers) {
2123                        j->writers++;
2124                } else {
2125                        if (file_p->f_mode & FMODE_READ){
2126                                j->readers--;
2127                        }
2128                        return -EBUSY;
2129                }
2130        }
2131
2132        if (j->cardtype == QTI_PHONECARD) {
2133                j->pslic.bits.powerdown = 0;
2134                j->psccr.bits.dev = 3;
2135                j->psccr.bits.rw = 0;
2136                outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137                ixj_PCcontrol_wait(j);
2138        }
2139
2140        j->flags.cidplay = 0;
2141        j->flags.cidcw_ack = 0;
2142
2143        if (ixjdebug & 0x0002)
2144                printk(KERN_INFO "Opening board %d\n", p->board);
2145
2146        j->framesread = j->frameswritten = 0;
2147        return 0;
2148}
2149
2150static int ixj_release(struct inode *inode, struct file *file_p)
2151{
2152        IXJ_TONE ti;
2153        int cnt;
2154        IXJ *j = file_p->private_data;
2155        int board = j->p.board;
2156
2157        /*
2158         *    Set up locks to ensure that only one process is talking to the DSP at a time.
2159         *    This is necessary to keep the DSP from locking up.
2160         */
2161        while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162                schedule_timeout_interruptible(1);
2163        if (ixjdebug & 0x0002)
2164                printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165
2166        if (j->cardtype == QTI_PHONECARD)
2167                ixj_set_port(j, PORT_SPEAKER);
2168        else
2169                ixj_set_port(j, PORT_POTS);
2170
2171        aec_stop(j);
2172        ixj_play_stop(j);
2173        ixj_record_stop(j);
2174        set_play_volume(j, 0x100);
2175        set_rec_volume(j, 0x100);
2176        ixj_ring_off(j);
2177
2178        /* Restore the tone table to default settings. */
2179        ti.tone_index = 10;
2180        ti.gain0 = 1;
2181        ti.freq0 = hz941;
2182        ti.gain1 = 0;
2183        ti.freq1 = hz1209;
2184        ixj_init_tone(j, &ti);
2185        ti.tone_index = 11;
2186        ti.gain0 = 1;
2187        ti.freq0 = hz941;
2188        ti.gain1 = 0;
2189        ti.freq1 = hz1336;
2190        ixj_init_tone(j, &ti);
2191        ti.tone_index = 12;
2192        ti.gain0 = 1;
2193        ti.freq0 = hz941;
2194        ti.gain1 = 0;
2195        ti.freq1 = hz1477;
2196        ixj_init_tone(j, &ti);
2197        ti.tone_index = 13;
2198        ti.gain0 = 1;
2199        ti.freq0 = hz800;
2200        ti.gain1 = 0;
2201        ti.freq1 = 0;
2202        ixj_init_tone(j, &ti);
2203        ti.tone_index = 14;
2204        ti.gain0 = 1;
2205        ti.freq0 = hz1000;
2206        ti.gain1 = 0;
2207        ti.freq1 = 0;
2208        ixj_init_tone(j, &ti);
2209        ti.tone_index = 15;
2210        ti.gain0 = 1;
2211        ti.freq0 = hz1250;
2212        ti.gain1 = 0;
2213        ti.freq1 = 0;
2214        ixj_init_tone(j, &ti);
2215        ti.tone_index = 16;
2216        ti.gain0 = 1;
2217        ti.freq0 = hz950;
2218        ti.gain1 = 0;
2219        ti.freq1 = 0;
2220        ixj_init_tone(j, &ti);
2221        ti.tone_index = 17;
2222        ti.gain0 = 1;
2223        ti.freq0 = hz1100;
2224        ti.gain1 = 0;
2225        ti.freq1 = 0;
2226        ixj_init_tone(j, &ti);
2227        ti.tone_index = 18;
2228        ti.gain0 = 1;
2229        ti.freq0 = hz1400;
2230        ti.gain1 = 0;
2231        ti.freq1 = 0;
2232        ixj_init_tone(j, &ti);
2233        ti.tone_index = 19;
2234        ti.gain0 = 1;
2235        ti.freq0 = hz1500;
2236        ti.gain1 = 0;
2237        ti.freq1 = 0;
2238        ixj_init_tone(j, &ti);
2239        ti.tone_index = 20;
2240        ti.gain0 = 1;
2241        ti.freq0 = hz1600;
2242        ti.gain1 = 0;
2243        ti.freq1 = 0;
2244        ixj_init_tone(j, &ti);
2245        ti.tone_index = 21;
2246        ti.gain0 = 1;
2247        ti.freq0 = hz1800;
2248        ti.gain1 = 0;
2249        ti.freq1 = 0;
2250        ixj_init_tone(j, &ti);
2251        ti.tone_index = 22;
2252        ti.gain0 = 1;
2253        ti.freq0 = hz2100;
2254        ti.gain1 = 0;
2255        ti.freq1 = 0;
2256        ixj_init_tone(j, &ti);
2257        ti.tone_index = 23;
2258        ti.gain0 = 1;
2259        ti.freq0 = hz1300;
2260        ti.gain1 = 0;
2261        ti.freq1 = 0;
2262        ixj_init_tone(j, &ti);
2263        ti.tone_index = 24;
2264        ti.gain0 = 1;
2265        ti.freq0 = hz2450;
2266        ti.gain1 = 0;
2267        ti.freq1 = 0;
2268        ixj_init_tone(j, &ti);
2269        ti.tone_index = 25;
2270        ti.gain0 = 1;
2271        ti.freq0 = hz350;
2272        ti.gain1 = 0;
2273        ti.freq1 = hz440;
2274        ixj_init_tone(j, &ti);
2275        ti.tone_index = 26;
2276        ti.gain0 = 1;
2277        ti.freq0 = hz440;
2278        ti.gain1 = 0;
2279        ti.freq1 = hz480;
2280        ixj_init_tone(j, &ti);
2281        ti.tone_index = 27;
2282        ti.gain0 = 1;
2283        ti.freq0 = hz480;
2284        ti.gain1 = 0;
2285        ti.freq1 = hz620;
2286        ixj_init_tone(j, &ti);
2287
2288        set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2289
2290        set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2291
2292        j->ex.bits.dtmf_ready = 0;
2293        j->dtmf_state = 0;
2294        j->dtmf_wp = j->dtmf_rp = 0;
2295        j->rec_mode = j->play_mode = -1;
2296        j->flags.ringing = 0;
2297        j->maxrings = MAXRINGS;
2298        j->ring_cadence = USA_RING_CADENCE;
2299        if(j->cadence_f[5].enable) {
2300                j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301        }
2302        j->drybuffer = 0;
2303        j->winktime = 320;
2304        j->flags.dtmf_oob = 0;
2305        for (cnt = 0; cnt < 4; cnt++)
2306                j->cadence_f[cnt].enable = 0;
2307
2308        idle(j);
2309
2310        if(j->cardtype == QTI_PHONECARD) {
2311                SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312        }
2313
2314        if (file_p->f_mode & FMODE_READ)
2315                j->readers--;
2316        if (file_p->f_mode & FMODE_WRITE)
2317                j->writers--;
2318
2319        if (j->read_buffer && !j->readers) {
2320                kfree(j->read_buffer);
2321                j->read_buffer = NULL;
2322                j->read_buffer_size = 0;
2323        }
2324        if (j->write_buffer && !j->writers) {
2325                kfree(j->write_buffer);
2326                j->write_buffer = NULL;
2327                j->write_buffer_size = 0;
2328        }
2329        j->rec_codec = j->play_codec = 0;
2330        j->rec_frame_size = j->play_frame_size = 0;
2331        j->flags.cidsent = j->flags.cidring = 0;
2332
2333        if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334                ixj_set_port(j, PORT_PSTN);
2335                daa_set_mode(j, SOP_PU_SLEEP);
2336                ixj_set_pots(j, 1);
2337        }
2338        ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340        /* Set up the default signals for events */
2341        for (cnt = 0; cnt < 35; cnt++)
2342                j->ixj_signals[cnt] = SIGIO;
2343
2344        /* Set the excetion signal enable flags */
2345        j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring = 
2346        j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 = 
2347        j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348
2349        file_p->private_data = NULL;
2350        clear_bit(board, &j->busyflags);
2351        return 0;
2352}
2353
2354static int read_filters(IXJ *j)
2355{
2356        unsigned short fc, cnt, trg;
2357        int var;
2358
2359        trg = 0;
2360        if (ixj_WriteDSPCommand(0x5144, j)) {
2361                if(ixjdebug & 0x0001) {
2362                        printk(KERN_INFO "Read Frame Counter failed!\n");
2363                }
2364                return -1;
2365        }
2366        fc = j->ssr.high << 8 | j->ssr.low;
2367        if (fc == j->frame_count)
2368                return 1;
2369
2370        j->frame_count = fc;
2371
2372        if (j->dtmf_proc)
2373                return 1;
2374
2375        var = 10;
2376
2377        for (cnt = 0; cnt < 4; cnt++) {
2378                if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379                        if(ixjdebug & 0x0001) {
2380                                printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381                        }
2382                        return -1;
2383                }
2384                if (ixj_WriteDSPCommand(0x515C, j)) {
2385                        if(ixjdebug & 0x0001) {
2386                                printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387                        }
2388                        return -1;
2389                }
2390                j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392                if (j->cadence_f[cnt].enable) {
2393                        if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394                                if (j->cadence_f[cnt].state == 0) {
2395                                        j->cadence_f[cnt].state = 1;
2396                                        j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397                                        j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398                                        j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399                                } else if (j->cadence_f[cnt].state == 2 &&
2400                                           (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401                                            time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402                                        if (j->cadence_f[cnt].on2) {
2403                                                j->cadence_f[cnt].state = 3;
2404                                                j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405                                                j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406                                                j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407                                        } else {
2408                                                j->cadence_f[cnt].state = 7;
2409                                        }
2410                                } else if (j->cadence_f[cnt].state == 4 &&
2411                                           (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412                                            time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413                                        if (j->cadence_f[cnt].on3) {
2414                                                j->cadence_f[cnt].state = 5;
2415                                                j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416                                                j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417                                                j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418                                        } else {
2419                                                j->cadence_f[cnt].state = 7;
2420                                        }
2421                                } else {
2422                                        j->cadence_f[cnt].state = 0;
2423                                }
2424                        } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425                                if (j->cadence_f[cnt].state == 1) {
2426                                        if(!j->cadence_f[cnt].on1) {
2427                                                j->cadence_f[cnt].state = 7;
2428                                        } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429                                          time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430                                                if(j->cadence_f[cnt].off1) {
2431                                                        j->cadence_f[cnt].state = 2;
2432                                                        j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433                                                        j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434                                                        j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435                                                } else {
2436                                                        j->cadence_f[cnt].state = 7;
2437                                                }
2438                                        } else {
2439                                                j->cadence_f[cnt].state = 0;
2440                                        }
2441                                } else if (j->cadence_f[cnt].state == 3) {
2442                                        if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443                                            time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444                                                if(j->cadence_f[cnt].off2) {
2445                                                        j->cadence_f[cnt].state = 4;
2446                                                        j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447                                                        j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448                                                        j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449                                                } else {
2450                                                        j->cadence_f[cnt].state = 7;
2451                                                }
2452                                        } else {
2453                                                j->cadence_f[cnt].state = 0;
2454                                        }
2455                                } else if (j->cadence_f[cnt].state == 5) {
2456                                        if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457                                            time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458                                                if(j->cadence_f[cnt].off3) {
2459                                                        j->cadence_f[cnt].state = 6;
2460                                                        j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461                                                        j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462                                                        j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463                                                } else {
2464                                                        j->cadence_f[cnt].state = 7;
2465                                                }
2466                                        } else {
2467                                                j->cadence_f[cnt].state = 0;
2468                                        }
2469                                } else {
2470                                        j->cadence_f[cnt].state = 0;
2471                                }
2472                        } else {
2473                                switch(j->cadence_f[cnt].state) {
2474                                        case 1:
2475                                                if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476                                                   !j->cadence_f[cnt].off1 &&
2477                                                   !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478                                                   !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479                                                        j->cadence_f[cnt].state = 7;
2480                                                }
2481                                                break;
2482                                        case 3:
2483                                                if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484                                                   !j->cadence_f[cnt].off2 &&
2485                                                   !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486                                                        j->cadence_f[cnt].state = 7;
2487                                                }
2488                                                break;
2489                                        case 5:
2490                                                if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491                                                   !j->cadence_f[cnt].off3) {
2492                                                        j->cadence_f[cnt].state = 7;
2493                                                }
2494                                                break;
2495                                }
2496                        }
2497
2498                        if (ixjdebug & 0x0040) {
2499                                printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500                                switch(j->cadence_f[cnt].state) {
2501                                        case 0:
2502                                                printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503                                                break;
2504                                        case 1:
2505                                                printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506                                        j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507                                                break;
2508                                        case 2:
2509                                                printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min, 
2510                                                                                                                        j->cadence_f[cnt].off1max);
2511                                                break;
2512                                        case 3:
2513                                                printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514                                                                                                                        j->cadence_f[cnt].on2max);
2515                                                break;
2516                                        case 4:
2517                                                printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518                                                                                                                        j->cadence_f[cnt].off2max);
2519                                                break;
2520                                        case 5:
2521                                                printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522                                                                                                                        j->cadence_f[cnt].on3max);
2523                                                break;
2524                                        case 6: 
2525                                                printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526                                                                                                                        j->cadence_f[cnt].off3max);
2527                                                break;
2528                                }
2529                        } 
2530                }
2531                if (j->cadence_f[cnt].state == 7) {
2532                        j->cadence_f[cnt].state = 0;
2533                        if (j->cadence_f[cnt].enable == 1)
2534                                j->cadence_f[cnt].enable = 0;
2535                        switch (cnt) {
2536                        case 0:
2537                                if(ixjdebug & 0x0020) {
2538                                        printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539                                }
2540                                j->ex.bits.fc0 = 1;
2541                                ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542                                break;
2543                        case 1:
2544                                if(ixjdebug & 0x0020) {
2545                                        printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546                                }
2547                                j->ex.bits.fc1 = 1;
2548                                ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549                                break;
2550                        case 2:
2551                                if(ixjdebug & 0x0020) {
2552                                        printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553                                }
2554                                j->ex.bits.fc2 = 1;
2555                                ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556                                break;
2557                        case 3:
2558                                if(ixjdebug & 0x0020) {
2559                                        printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560                                }
2561                                j->ex.bits.fc3 = 1;
2562                                ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563                                break;
2564                        }
2565                }
2566                if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567                                          (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568                        if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569                                trg = 1;
2570                        } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571                                trg = 0;
2572                        }
2573                        switch (cnt) {
2574                        case 0:
2575                                if(ixjdebug & 0x0020) {
2576                                        printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577                                }
2578                                j->ex.bits.f0 = 1;
2579                                ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580                                break;
2581                        case 1:
2582                                if(ixjdebug & 0x0020) {
2583                                        printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584                                }
2585                                j->ex.bits.f1 = 1;
2586                                ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587                                break;
2588                        case 2:
2589                                if(ixjdebug & 0x0020) {
2590                                        printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591                                }
2592                                j->ex.bits.f2 = 1;
2593                                ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594                                break;
2595                        case 3:
2596                                if(ixjdebug & 0x0020) {
2597                                        printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598                                }
2599                                j->ex.bits.f3 = 1;
2600                                ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601                                break;
2602                        }
2603                }
2604        }
2605        return 0;
2606}
2607
2608static int LineMonitor(IXJ *j)
2609{
2610        if (j->dtmf_proc) {
2611                return -1;
2612        }
2613        j->dtmf_proc = 1;
2614
2615        if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2616                return -1;
2617
2618        j->dtmf.bytes.high = j->ssr.high;
2619        j->dtmf.bytes.low = j->ssr.low;
2620        if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621                j->dtmf_state = 1;
2622                j->dtmf_current = j->dtmf.bits.digit;
2623        }
2624        if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2625         {
2626                if(!j->cidcw_wait) {
2627                        j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628                        j->dtmf_wp++;
2629                        if (j->dtmf_wp == 79)
2630                                j->dtmf_wp = 0;
2631                        j->ex.bits.dtmf_ready = 1;
2632                        if(j->ex_sig.bits.dtmf_ready) {
2633                                ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634                        }
2635                }
2636                else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637                        if(ixjdebug & 0x0020) {
2638                                printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639                        }
2640                        j->flags.cidcw_ack = 1;
2641                }
2642                j->dtmf_state = 0;
2643        }
2644        j->dtmf_proc = 0;
2645
2646        return 0;
2647}
2648
2649/************************************************************************
2650*
2651* Functions to allow alaw <-> ulaw conversions.
2652*
2653************************************************************************/
2654
2655static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656{
2657        static unsigned char table_ulaw2alaw[] =
2658        {
2659                0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D, 
2660                0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25, 
2661                0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D, 
2662                0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35, 
2663                0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02, 
2664                0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A, 
2665                0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12, 
2666                0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B, 
2667                0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63, 
2668                0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79, 
2669                0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71, 
2670                0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D, 
2671                0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45, 
2672                0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D, 
2673                0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51, 
2674                0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5, 
2675                0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD, 
2676                0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5, 
2677                0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD, 
2678                0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5, 
2679                0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82, 
2680                0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A, 
2681                0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92, 
2682                0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB, 
2683                0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3, 
2684                0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9, 
2685                0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1, 
2686                0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD, 
2687                0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5, 
2688                0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD, 
2689                0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1, 
2690                0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691        };
2692
2693        while (len--)
2694        {
2695                *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696                buff++;
2697        }
2698}
2699
2700static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701{
2702        static unsigned char table_alaw2ulaw[] =
2703        {
2704                0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C, 
2705                0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24, 
2706                0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C, 
2707                0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34, 
2708                0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 
2709                0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 
2710                0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 
2711                0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 
2712                0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 
2713                0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E, 
2714                0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A, 
2715                0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 
2716                0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B, 
2717                0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43, 
2718                0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59, 
2719                0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51, 
2720                0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC, 
2721                0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4, 
2722                0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC, 
2723                0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4, 
2724                0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 
2725                0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 
2726                0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 
2727                0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 
2728                0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 
2729                0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE, 
2730                0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA, 
2731                0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 
2732                0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB, 
2733                0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3, 
2734                0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9, 
2735                0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736        };
2737
2738        while (len--)
2739        {
2740                *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741                buff++;
2742        }
2743}
2744
2745static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746{
2747        unsigned long i = *ppos;
2748        IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750        DECLARE_WAITQUEUE(wait, current);
2751
2752        if (j->flags.inread)
2753                return -EALREADY;
2754
2755        j->flags.inread = 1;
2756
2757        add_wait_queue(&j->read_q, &wait);
2758        set_current_state(TASK_INTERRUPTIBLE);
2759        mb();
2760
2761        while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762                ++j->read_wait;
2763                if (file_p->f_flags & O_NONBLOCK) {
2764                        set_current_state(TASK_RUNNING);
2765                        remove_wait_queue(&j->read_q, &wait);
2766                        j->flags.inread = 0;
2767                        return -EAGAIN;
2768                }
2769                if (!ixj_hookstate(j)) {
2770                        set_current_state(TASK_RUNNING);
2771                        remove_wait_queue(&j->read_q, &wait);
2772                        j->flags.inread = 0;
2773                        return 0;
2774                }
2775                interruptible_sleep_on(&j->read_q);
2776                if (signal_pending(current)) {
2777                        set_current_state(TASK_RUNNING);
2778                        remove_wait_queue(&j->read_q, &wait);
2779                        j->flags.inread = 0;
2780                        return -EINTR;
2781                }
2782        }
2783
2784        remove_wait_queue(&j->read_q, &wait);
2785        set_current_state(TASK_RUNNING);
2786        /* Don't ever copy more than the user asks */
2787        if(j->rec_codec == ALAW)
2788                ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789        i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790        j->read_buffer_ready = 0;
2791        if (i) {
2792                j->flags.inread = 0;
2793                return -EFAULT;
2794        } else {
2795                j->flags.inread = 0;
2796                return min(length, j->read_buffer_size);
2797        }
2798}
2799
2800static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801                          loff_t * ppos)
2802{
2803        int pre_retval;
2804        ssize_t read_retval = 0;
2805        IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807        pre_retval = ixj_PreRead(j, 0L);
2808        switch (pre_retval) {
2809        case NORMAL:
2810                read_retval = ixj_read(file_p, buf, length, ppos);
2811                ixj_PostRead(j, 0L);
2812                break;
2813        case NOPOST:
2814                read_retval = ixj_read(file_p, buf, length, ppos);
2815                break;
2816        case POSTONLY:
2817                ixj_PostRead(j, 0L);
2818                break;
2819        default:
2820                read_retval = pre_retval;
2821        }
2822        return read_retval;
2823}
2824
2825static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826{
2827        unsigned long i = *ppos;
2828        IXJ *j = file_p->private_data;
2829
2830        DECLARE_WAITQUEUE(wait, current);
2831
2832        if (j->flags.inwrite)
2833                return -EALREADY;
2834
2835        j->flags.inwrite = 1;
2836
2837        add_wait_queue(&j->write_q, &wait);
2838        set_current_state(TASK_INTERRUPTIBLE);
2839        mb();
2840
2841
2842        while (!j->write_buffers_empty) {
2843                ++j->write_wait;
2844                if (file_p->f_flags & O_NONBLOCK) {
2845                        set_current_state(TASK_RUNNING);
2846                        remove_wait_queue(&j->write_q, &wait);
2847                        j->flags.inwrite = 0;
2848                        return -EAGAIN;
2849                }
2850                if (!ixj_hookstate(j)) {
2851                        set_current_state(TASK_RUNNING);
2852                        remove_wait_queue(&j->write_q, &wait);
2853                        j->flags.inwrite = 0;
2854                        return 0;
2855                }
2856                interruptible_sleep_on(&j->write_q);
2857                if (signal_pending(current)) {
2858                        set_current_state(TASK_RUNNING);
2859                        remove_wait_queue(&j->write_q, &wait);
2860                        j->flags.inwrite = 0;
2861                        return -EINTR;
2862                }
2863        }
2864        set_current_state(TASK_RUNNING);
2865        remove_wait_queue(&j->write_q, &wait);
2866        if (j->write_buffer_wp + count >= j->write_buffer_end)
2867                j->write_buffer_wp = j->write_buffer;
2868        i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869        if (i) {
2870                j->flags.inwrite = 0;
2871                return -EFAULT;
2872        }
2873       if(j->play_codec == ALAW)
2874               alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875        j->flags.inwrite = 0;
2876        return min(count, j->write_buffer_size);
2877}
2878
2879static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880{
2881        int pre_retval;
2882        ssize_t write_retval = 0;
2883
2884        IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886        pre_retval = ixj_PreWrite(j, 0L);
2887        switch (pre_retval) {
2888        case NORMAL:
2889                write_retval = ixj_write(file_p, buf, count, ppos);
2890                if (write_retval > 0) {
2891                        ixj_PostWrite(j, 0L);
2892                        j->write_buffer_wp += write_retval;
2893                        j->write_buffers_empty--;
2894                }
2895                break;
2896        case NOPOST:
2897                write_retval = ixj_write(file_p, buf, count, ppos);
2898                if (write_retval > 0) {
2899                        j->write_buffer_wp += write_retval;
2900                        j->write_buffers_empty--;
2901                }
2902                break;
2903        case POSTONLY:
2904                ixj_PostWrite(j, 0L);
2905                break;
2906        default:
2907                write_retval = pre_retval;
2908        }
2909        return write_retval;
2910}
2911
2912static void ixj_read_frame(IXJ *j)
2913{
2914        int cnt, dly;
2915
2916        if (j->read_buffer) {
2917                for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918                        if (!(cnt % 16) && !IsRxReady(j)) {
2919                                dly = 0;
2920                                while (!IsRxReady(j)) {
2921                                        if (dly++ > 5) {
2922                                                dly = 0;
2923                                                break;
2924                                        }
2925                                        udelay(10);
2926                                }
2927                        }
2928                        /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929                        if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930                                inb_p(j->DSPbase + 0x0E);
2931                                inb_p(j->DSPbase + 0x0F);
2932                        }
2933                        *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934                        *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935                }
2936                ++j->framesread;
2937                if (j->intercom != -1) {
2938                        if (IsTxReady(get_ixj(j->intercom))) {
2939                                for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940                                        if (!(cnt % 16) && !IsTxReady(j)) {
2941                                                dly = 0;
2942                                                while (!IsTxReady(j)) {
2943                                                        if (dly++ > 5) {
2944                                                                dly = 0;
2945                                                                break;
2946                                                        }
2947                                                        udelay(10);
2948                                                }
2949                                        }
2950                                        outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951                                        outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952                                }
2953                                get_ixj(j->intercom)->frameswritten++;
2954                        }
2955                } else {
2956                        j->read_buffer_ready = 1;
2957                        wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2958
2959                        wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2960
2961                        if(j->ixj_signals[SIG_READ_READY])
2962                                ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963                }
2964        }
2965}
2966
2967static short fsk[][6][20] =
2968{
2969        {
2970                {
2971                        0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972                        -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973                },
2974                {
2975                        -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976                        -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977                },
2978                {
2979                        -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980                        -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981                },
2982                {
2983                        0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984                        16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985                },
2986                {
2987                        28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988                        32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989                },
2990                {
2991                        28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992                        16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993                }
2994        },
2995        {
2996                {
2997                        0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998                        0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999                },
3000                {
3001                        -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002                        28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003                },
3004                {
3005                        -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006                        28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007                },
3008                {
3009                        0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010                        0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011                },
3012                {
3013                        28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014                        -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015                },
3016                {
3017                        28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018                        -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019                }
3020        }
3021};
3022
3023
3024static void ixj_write_cid_bit(IXJ *j, int bit)
3025{
3026        while (j->fskcnt < 20) {
3027                if(j->fskdcnt < (j->fsksize - 1))
3028                        j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030                j->fskcnt += 3;
3031        }
3032        j->fskcnt %= 20;
3033
3034        if (!bit)
3035                j->fskz++;
3036        if (j->fskz >= 6)
3037                j->fskz = 0;
3038
3039}
3040
3041static void ixj_write_cid_byte(IXJ *j, char byte)
3042{
3043        IXJ_CBYTE cb;
3044
3045                cb.cbyte = byte;
3046                ixj_write_cid_bit(j, 0);
3047                ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048                ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049                ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050                ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051                ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052                ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053                ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054                ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055                ixj_write_cid_bit(j, 1);
3056}
3057
3058static void ixj_write_cid_seize(IXJ *j)
3059{
3060        int cnt;
3061
3062        for (cnt = 0; cnt < 150; cnt++) {
3063                ixj_write_cid_bit(j, 0);
3064                ixj_write_cid_bit(j, 1);
3065        }
3066        for (cnt = 0; cnt < 180; cnt++) {
3067                ixj_write_cid_bit(j, 1);
3068        }
3069}
3070
3071static void ixj_write_cidcw_seize(IXJ *j)
3072{
3073        int cnt;
3074
3075        for (cnt = 0; cnt < 80; cnt++) {
3076                ixj_write_cid_bit(j, 1);
3077        }
3078}
3079
3080static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081{
3082        int cnt;
3083
3084        for (cnt = 0; cnt < strlen(s); cnt++) {
3085                ixj_write_cid_byte(j, s[cnt]);
3086                checksum = (checksum + s[cnt]);
3087        }
3088        return checksum;
3089}
3090
3091static void ixj_pad_fsk(IXJ *j, int pad)
3092{
3093        int cnt; 
3094
3095        for (cnt = 0; cnt < pad; cnt++) {
3096                if(j->fskdcnt < (j->fsksize - 1))
3097                        j->fskdata[j->fskdcnt++] = 0x0000;
3098        }
3099        for (cnt = 0; cnt < 720; cnt++) {
3100                if(j->fskdcnt < (j->fsksize - 1))
3101                        j->fskdata[j->fskdcnt++] = 0x0000;
3102        }
3103}
3104
3105static void ixj_pre_cid(IXJ *j)
3106{
3107        j->cid_play_codec = j->play_codec;
3108        j->cid_play_frame_size = j->play_frame_size;
3109        j->cid_play_volume = get_play_volume(j);
3110        j->cid_play_flag = j->flags.playing;
3111
3112        j->cid_rec_codec = j->rec_codec;
3113        j->cid_rec_volume = get_rec_volume(j);
3114        j->cid_rec_flag = j->flags.recording;
3115
3116        j->cid_play_aec_level = j->aec_level;
3117
3118        switch(j->baseframe.low) {
3119                case 0xA0:
3120                        j->cid_base_frame_size = 20;
3121                        break;
3122                case 0x50:
3123                        j->cid_base_frame_size = 10;
3124                        break;
3125                case 0xF0:
3126                        j->cid_base_frame_size = 30;
3127                        break;
3128        }
3129
3130        ixj_play_stop(j);
3131        ixj_cpt_stop(j);
3132
3133        j->flags.cidplay = 1;
3134
3135        set_base_frame(j, 30);
3136        set_play_codec(j, LINEAR16);
3137        set_play_volume(j, 0x1B);
3138        ixj_play_start(j);
3139}
3140
3141static void ixj_post_cid(IXJ *j)
3142{
3143        ixj_play_stop(j);
3144
3145        if(j->cidsize > 5000) {
3146                SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147        }
3148        j->flags.cidplay = 0;
3149        if(ixjdebug & 0x0200) {
3150                printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151        }
3152
3153        ixj_fsk_free(j);
3154
3155        j->fskdcnt = 0;
3156        set_base_frame(j, j->cid_base_frame_size);
3157        set_play_codec(j, j->cid_play_codec);
3158        ixj_aec_start(j, j->cid_play_aec_level);
3159        set_play_volume(j, j->cid_play_volume);
3160
3161        set_rec_codec(j, j->cid_rec_codec);
3162        set_rec_volume(j, j->cid_rec_volume);
3163
3164        if(j->cid_rec_flag)
3165                ixj_record_start(j);
3166
3167        if(j->cid_play_flag)
3168                ixj_play_start(j);
3169
3170        if(j->cid_play_flag) {
3171                wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3172        }
3173}
3174
3175static void ixj_write_cid(IXJ *j)
3176{
3177        char sdmf1[50];
3178        char sdmf2[50];
3179        char sdmf3[80];
3180        char mdmflen, len1, len2, len3;
3181        int pad;
3182
3183        int checksum = 0;
3184
3185        if (j->dsp.low == 0x20 || j->flags.cidplay)
3186                return;
3187
3188        j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189        j->cidsize = j->cidcnt = 0;
3190
3191        ixj_fsk_alloc(j);
3192
3193        strcpy(sdmf1, j->cid_send.month);
3194        strcat(sdmf1, j->cid_send.day);
3195        strcat(sdmf1, j->cid_send.hour);
3196        strcat(sdmf1, j->cid_send.min);
3197        strcpy(sdmf2, j->cid_send.number);
3198        strcpy(sdmf3, j->cid_send.name);
3199
3200        len1 = strlen(sdmf1);
3201        len2 = strlen(sdmf2);
3202        len3 = strlen(sdmf3);
3203        mdmflen = len1 + len2 + len3 + 6;
3204
3205        while(1){
3206                ixj_write_cid_seize(j);
3207
3208                ixj_write_cid_byte(j, 0x80);
3209                checksum = 0x80;
3210                ixj_write_cid_byte(j, mdmflen);
3211                checksum = checksum + mdmflen;
3212
3213                ixj_write_cid_byte(j, 0x01);
3214                checksum = checksum + 0x01;
3215                ixj_write_cid_byte(j, len1);
3216                checksum = checksum + len1;
3217                checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218                if(ixj_hookstate(j) & 1)
3219                        break;
3220
3221                ixj_write_cid_byte(j, 0x02);
3222                checksum = checksum + 0x02;
3223                ixj_write_cid_byte(j, len2);
3224                checksum = checksum + len2;
3225                checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226                if(ixj_hookstate(j) & 1)
3227                        break;
3228
3229                ixj_write_cid_byte(j, 0x07);
3230                checksum = checksum + 0x07;
3231                ixj_write_cid_byte(j, len3);
3232                checksum = checksum + len3;
3233                checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234                if(ixj_hookstate(j) & 1)
3235                        break;
3236
3237                checksum %= 256;
3238                checksum ^= 0xFF;
3239                checksum += 1;
3240
3241                ixj_write_cid_byte(j, (char) checksum);
3242
3243                pad = j->fskdcnt % 240;
3244                if (pad) {
3245                        pad = 240 - pad;
3246                }
3247                ixj_pad_fsk(j, pad);
3248                break;
3249        }
3250
3251        ixj_write_frame(j);
3252}
3253
3254static void ixj_write_cidcw(IXJ *j)
3255{
3256        IXJ_TONE ti;
3257
3258        char sdmf1[50];
3259        char sdmf2[50];
3260        char sdmf3[80];
3261        char mdmflen, len1, len2, len3;
3262        int pad;
3263
3264        int checksum = 0;
3265
3266        if (j->dsp.low == 0x20 || j->flags.cidplay)
3267                return;
3268
3269        j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270        j->cidsize = j->cidcnt = 0;
3271
3272        ixj_fsk_alloc(j);
3273
3274        j->flags.cidcw_ack = 0;
3275
3276        ti.tone_index = 23;
3277        ti.gain0 = 1;
3278        ti.freq0 = hz440;
3279        ti.gain1 = 0;
3280        ti.freq1 = 0;
3281        ixj_init_tone(j, &ti);
3282
3283        ixj_set_tone_on(1500, j);
3284        ixj_set_tone_off(32, j);
3285        if(ixjdebug & 0x0200) {
3286                printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287        }
3288        ixj_play_tone(j, 23);
3289
3290        clear_bit(j->board, &j->busyflags);
3291        while(j->tone_state)
3292                schedule_timeout_interruptible(1);
3293        while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294                schedule_timeout_interruptible(1);
3295        if(ixjdebug & 0x0200) {
3296                printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297        }
3298
3299        ti.tone_index = 24;
3300        ti.gain0 = 1;
3301        ti.freq0 = hz2130;
3302        ti.gain1 = 0;
3303        ti.freq1 = hz2750;
3304        ixj_init_tone(j, &ti);
3305
3306        ixj_set_tone_off(10, j);
3307        ixj_set_tone_on(600, j);
3308        if(ixjdebug & 0x0200) {
3309                printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310        }
3311        ixj_play_tone(j, 24);
3312
3313        clear_bit(j->board, &j->busyflags);
3314        while(j->tone_state)
3315                schedule_timeout_interruptible(1);
3316        while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317                schedule_timeout_interruptible(1);
3318        if(ixjdebug & 0x0200) {
3319                printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320        }
3321
3322        j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323
3324        clear_bit(j->board, &j->busyflags);
3325        while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326                schedule_timeout_interruptible(1);
3327        while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328                schedule_timeout_interruptible(1);
3329        j->cidcw_wait = 0;
3330        if(!j->flags.cidcw_ack) {
3331                if(ixjdebug & 0x0200) {
3332                        printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333                }
3334                ixj_post_cid(j);
3335                if(j->cid_play_flag) {
3336                        wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3337                }
3338                return;
3339        } else {
3340                ixj_pre_cid(j);
3341        }
3342        j->flags.cidcw_ack = 0;
3343        strcpy(sdmf1, j->cid_send.month);
3344        strcat(sdmf1, j->cid_send.day);
3345        strcat(sdmf1, j->cid_send.hour);
3346        strcat(sdmf1, j->cid_send.min);
3347        strcpy(sdmf2, j->cid_send.number);
3348        strcpy(sdmf3, j->cid_send.name);
3349
3350        len1 = strlen(sdmf1);
3351        len2 = strlen(sdmf2);
3352        len3 = strlen(sdmf3);
3353        mdmflen = len1 + len2 + len3 + 6;
3354
3355        ixj_write_cidcw_seize(j);
3356
3357        ixj_write_cid_byte(j, 0x80);
3358        checksum = 0x80;
3359        ixj_write_cid_byte(j, mdmflen);
3360        checksum = checksum + mdmflen;
3361
3362        ixj_write_cid_byte(j, 0x01);
3363        checksum = checksum + 0x01;
3364        ixj_write_cid_byte(j, len1);
3365        checksum = checksum + len1;
3366        checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367
3368        ixj_write_cid_byte(j, 0x02);
3369        checksum = checksum + 0x02;
3370        ixj_write_cid_byte(j, len2);
3371        checksum = checksum + len2;
3372        checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373
3374        ixj_write_cid_byte(j, 0x07);
3375        checksum = checksum + 0x07;
3376        ixj_write_cid_byte(j, len3);
3377        checksum = checksum + len3;
3378        checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379
3380        checksum %= 256;
3381        checksum ^= 0xFF;
3382        checksum += 1;
3383
3384        ixj_write_cid_byte(j, (char) checksum);
3385
3386        pad = j->fskdcnt % 240;
3387        if (pad) {
3388                pad = 240 - pad;
3389        }
3390        ixj_pad_fsk(j, pad);
3391        if(ixjdebug & 0x0200) {
3392                printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393        }
3394}
3395
3396static void ixj_write_vmwi(IXJ *j, int msg)
3397{
3398        char mdmflen;
3399        int pad;
3400
3401        int checksum = 0;
3402
3403        if (j->dsp.low == 0x20 || j->flags.cidplay)
3404                return;
3405
3406        j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407        j->cidsize = j->cidcnt = 0;
3408
3409        ixj_fsk_alloc(j);
3410
3411        mdmflen = 3;
3412
3413        if (j->port == PORT_POTS)
3414                SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415
3416        ixj_write_cid_seize(j);
3417
3418        ixj_write_cid_byte(j, 0x82);
3419        checksum = 0x82;
3420        ixj_write_cid_byte(j, mdmflen);
3421        checksum = checksum + mdmflen;
3422
3423        ixj_write_cid_byte(j, 0x0B);
3424        checksum = checksum + 0x0B;
3425        ixj_write_cid_byte(j, 1);
3426        checksum = checksum + 1;
3427
3428        if(msg) {
3429                ixj_write_cid_byte(j, 0xFF);
3430                checksum = checksum + 0xFF;
3431        }
3432        else {
3433                ixj_write_cid_byte(j, 0x00);
3434                checksum = checksum + 0x00;
3435        }
3436
3437        checksum %= 256;
3438        checksum ^= 0xFF;
3439        checksum += 1;
3440
3441        ixj_write_cid_byte(j, (char) checksum);
3442
3443        pad = j->fskdcnt % 240;
3444        if (pad) {
3445                pad = 240 - pad;
3446        }
3447        ixj_pad_fsk(j, pad);
3448}
3449
3450static void ixj_write_frame(IXJ *j)
3451{
3452        int cnt, frame_count, dly;
3453        IXJ_WORD dat;
3454
3455        frame_count = 0;
3456        if(j->flags.cidplay) {
3457                for(cnt = 0; cnt < 480; cnt++) {
3458                        if (!(cnt % 16) && !IsTxReady(j)) {
3459                                dly = 0;
3460                                while (!IsTxReady(j)) {
3461                                        if (dly++ > 5) {
3462                                                dly = 0;
3463                                                break;
3464                                        }
3465                                        udelay(10);
3466                                }
3467                        }
3468                        dat.word = j->fskdata[j->cidcnt++];
3469                        outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470                        outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471                        cnt++;
3472                }
3473                if(j->cidcnt >= j->fskdcnt) {
3474                        ixj_post_cid(j);
3475                }
3476                /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477                   and there is real audio data in the buffer, we need to throw it away because 
3478                   we just used it's time slot */
3479                if (j->write_buffer_rp > j->write_buffer_wp) {
3480                        j->write_buffer_rp += j->cid_play_frame_size * 2;
3481                        if (j->write_buffer_rp >= j->write_buffer_end) {
3482                                j->write_buffer_rp = j->write_buffer;
3483                        }
3484                        j->write_buffers_empty++;
3485                        wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3486
3487                        wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3488                }
3489        } else if (j->write_buffer && j->write_buffers_empty < 1) { 
3490                if (j->write_buffer_wp > j->write_buffer_rp) {
3491                        frame_count =
3492                            (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493                }
3494                if (j->write_buffer_rp > j->write_buffer_wp) {
3495                        frame_count =
3496                            (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497                            (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498                }
3499                if (frame_count >= 1) {
3500                        if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501                                BYTES blankword;
3502
3503                                switch (j->play_mode) {
3504                                case PLAYBACK_MODE_ULAW:
3505                                case PLAYBACK_MODE_ALAW:
3506                                        blankword.low = blankword.high = 0xFF;
3507                                        break;
3508                                case PLAYBACK_MODE_8LINEAR:
3509                                case PLAYBACK_MODE_16LINEAR:
3510                                default:
3511                                        blankword.low = blankword.high = 0x00;
3512                                        break;
3513                                case PLAYBACK_MODE_8LINEAR_WSS:
3514                                        blankword.low = blankword.high = 0x80;
3515                                        break;
3516                                }
3517                                for (cnt = 0; cnt < 16; cnt++) {
3518                                        if (!(cnt % 16) && !IsTxReady(j)) {
3519                                                dly = 0;
3520                                                while (!IsTxReady(j)) {
3521                                                        if (dly++ > 5) {
3522                                                                dly = 0;
3523                                                                break;
3524                                                        }
3525                                                        udelay(10);
3526                                                }
3527                                        }
3528                                        outb_p((blankword.low), j->DSPbase + 0x0C);
3529                                        outb_p((blankword.high), j->DSPbase + 0x0D);
3530                                }
3531                                j->flags.play_first_frame = 0;
3532                        } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533                                for (cnt = 0; cnt < 24; cnt++) {
3534                                        BYTES blankword;
3535
3536                                        if(cnt == 12) {
3537                                                blankword.low = 0x02;
3538                                                blankword.high = 0x00;
3539                                        }
3540                                        else {
3541                                                blankword.low = blankword.high = 0x00;
3542                                        }
3543                                        if (!(cnt % 16) && !IsTxReady(j)) {
3544                                                dly = 0;
3545                                                while (!IsTxReady(j)) {
3546                                                        if (dly++ > 5) {
3547                                                                dly = 0;
3548                                                                break;
3549                                                        }
3550                                                        udelay(10);
3551                                                }
3552                                        }
3553                                        outb_p((blankword.low), j->DSPbase + 0x0C);
3554                                        outb_p((blankword.high), j->DSPbase + 0x0D);
3555                                }
3556                                j->flags.play_first_frame = 0;
3557                        }
3558                        for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559                                if (!(cnt % 16) && !IsTxReady(j)) {
3560                                        dly = 0;
3561                                        while (!IsTxReady(j)) {
3562                                                if (dly++ > 5) {
3563                                                        dly = 0;
3564                                                        break;
3565                                                }
3566                                                udelay(10);
3567                                        }
3568                                }
3569                        /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3570                                if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571                                        if (j->write_buffer_rp[cnt] == 0 &&
3572                                            j->write_buffer_rp[cnt + 1] == 0 &&
3573                                            j->write_buffer_rp[cnt + 2] == 0 &&
3574                                            j->write_buffer_rp[cnt + 3] == 0 &&
3575                                            j->write_buffer_rp[cnt + 4] == 0 &&
3576                                            j->write_buffer_rp[cnt + 5] == 0 &&
3577                                            j->write_buffer_rp[cnt + 6] == 0 &&
3578                                            j->write_buffer_rp[cnt + 7] == 0 &&
3579                                            j->write_buffer_rp[cnt + 8] == 0 &&
3580                                            j->write_buffer_rp[cnt + 9] == 0) {
3581                                        /* someone is trying to write silence lets make this a type 0 frame. */
3582                                                outb_p(0x00, j->DSPbase + 0x0C);
3583                                                outb_p(0x00, j->DSPbase + 0x0D);
3584                                        } else {
3585                                        /* so all other frames are type 1. */
3586                                                outb_p(0x01, j->DSPbase + 0x0C);
3587                                                outb_p(0x00, j->DSPbase + 0x0D);
3588                                        }
3589                                }
3590                                outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591                                outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592                                *(j->write_buffer_rp + cnt) = 0;
3593                                *(j->write_buffer_rp + cnt + 1) = 0;
3594                        }
3595                        j->write_buffer_rp += j->play_frame_size * 2;
3596                        if (j->write_buffer_rp >= j->write_buffer_end) {
3597                                j->write_buffer_rp = j->write_buffer;
3598                        }
3599                        j->write_buffers_empty++;
3600                        wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3601
3602                        wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3603
3604                        ++j->frameswritten;
3605                }
3606        } else {
3607                j->drybuffer++;
3608        }
3609        if(j->ixj_signals[SIG_WRITE_READY]) {
3610                ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611        }
3612}
3613
3614static int idle(IXJ *j)
3615{
3616        if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3617
3618                return 0;
3619
3620        if (j->ssr.high || j->ssr.low) {
3621                return 0;
3622        } else {
3623                j->play_mode = -1;
3624                j->flags.playing = 0;
3625                j->rec_mode = -1;
3626                j->flags.recording = 0;
3627                return 1;
3628        }
3629}
3630
3631static int set_base_frame(IXJ *j, int size)
3632{
3633        unsigned short cmd;
3634        int cnt;
3635
3636        idle(j);
3637        j->cid_play_aec_level = j->aec_level;
3638        aec_stop(j);
3639        for (cnt = 0; cnt < 10; cnt++) {
3640                if (idle(j))
3641                        break;
3642        }
3643        if (j->ssr.high || j->ssr.low)
3644                return -1;
3645        if (j->dsp.low != 0x20) {
3646                switch (size) {
3647                case 30:
3648                        cmd = 0x07F0;
3649                        /* Set Base Frame Size to 240 pg9-10 8021 */
3650                        break;
3651                case 20:
3652                        cmd = 0x07A0;
3653                        /* Set Base Frame Size to 160 pg9-10 8021 */
3654                        break;
3655                case 10:
3656                        cmd = 0x0750;
3657                        /* Set Base Frame Size to 80 pg9-10 8021 */
3658                        break;
3659                default:
3660                        return -1;
3661                }
3662        } else {
3663                if (size == 30)
3664                        return size;
3665                else
3666                        return -1;
3667        }
3668        if (ixj_WriteDSPCommand(cmd, j)) {
3669                j->baseframe.high = j->baseframe.low = 0xFF;
3670                return -1;
3671        } else {
3672                j->baseframe.high = j->ssr.high;
3673                j->baseframe.low = j->ssr.low;
3674                /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675                if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676                        return -1;
3677                }
3678        }
3679        ixj_aec_start(j, j->cid_play_aec_level);
3680        return size;
3681}
3682
3683static int set_rec_codec(IXJ *j, int rate)
3684{
3685        int retval = 0;
3686
3687        j->rec_codec = rate;
3688
3689        switch (rate) {
3690        case G723_63:
3691                if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692                        j->rec_frame_size = 12;
3693                        j->rec_mode = 0;
3694                } else {
3695                        retval = 1;
3696                }
3697                break;
3698        case G723_53:
3699                if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700                        j->rec_frame_size = 10;
3701                        j->rec_mode = 0;
3702                } else {
3703                        retval = 1;
3704                }
3705                break;
3706        case TS85:
3707                if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708                        j->rec_frame_size = 16;
3709                        j->rec_mode = 0;
3710                } else {
3711                        retval = 1;
3712                }
3713                break;
3714        case TS48:
3715                if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716                        j->rec_frame_size = 9;
3717                        j->rec_mode = 0;
3718                } else {
3719                        retval = 1;
3720                }
3721                break;
3722        case TS41:
3723                if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724                        j->rec_frame_size = 8;
3725                        j->rec_mode = 0;
3726                } else {
3727                        retval = 1;
3728                }
3729                break;
3730        case G728:
3731                if (j->dsp.low != 0x20) {
3732                        j->rec_frame_size = 48;
3733                        j->rec_mode = 0;
3734                } else {
3735                        retval = 1;
3736                }
3737                break;
3738        case G729:
3739                if (j->dsp.low != 0x20) {
3740                        if (!j->flags.g729_loaded) {
3741                                retval = 1;
3742                                break;
3743                        }
3744                        switch (j->baseframe.low) {
3745                        case 0xA0:
3746                                j->rec_frame_size = 10;
3747                                break;
3748                        case 0x50:
3749                                j->rec_frame_size = 5;
3750                                break;
3751                        default:
3752                                j->rec_frame_size = 15;
3753                                break;
3754                        }
3755                        j->rec_mode = 0;
3756                } else {
3757                        retval = 1;
3758                }
3759                break;
3760        case G729B:
3761                if (j->dsp.low != 0x20) {
3762                        if (!j->flags.g729_loaded) {
3763                                retval = 1;
3764                                break;
3765                        }
3766                        switch (j->baseframe.low) {
3767                        case 0xA0:
3768                                j->rec_frame_size = 12;
3769                                break;
3770                        case 0x50:
3771                                j->rec_frame_size = 6;
3772                                break;
3773                        default:
3774                                j->rec_frame_size = 18;
3775                                break;
3776                        }
3777                        j->rec_mode = 0;
3778                } else {
3779                        retval = 1;
3780                }
3781                break;
3782        case ULAW:
3783                switch (j->baseframe.low) {
3784                case 0xA0:
3785                        j->rec_frame_size = 80;
3786                        break;
3787                case 0x50:
3788                        j->rec_frame_size = 40;
3789                        break;
3790                default:
3791                        j->rec_frame_size = 120;
3792                        break;
3793                }
3794                j->rec_mode = 4;
3795                break;
3796        case ALAW:
3797                switch (j->baseframe.low) {
3798                case 0xA0:
3799                        j->rec_frame_size = 80;
3800                        break;
3801                case 0x50:
3802                        j->rec_frame_size = 40;
3803                        break;
3804                default:
3805                        j->rec_frame_size = 120;
3806                        break;
3807                }
3808                j->rec_mode = 4;
3809                break;
3810        case LINEAR16:
3811                switch (j->baseframe.low) {
3812                case 0xA0:
3813                        j->rec_frame_size = 160;
3814                        break;
3815                case 0x50:
3816                        j->rec_frame_size = 80;
3817                        break;
3818                default:
3819                        j->rec_frame_size = 240;
3820                        break;
3821                }
3822                j->rec_mode = 5;
3823                break;
3824        case LINEAR8:
3825                switch (j->baseframe.low) {
3826                case 0xA0:
3827                        j->rec_frame_size = 80;
3828                        break;
3829                case 0x50:
3830                        j->rec_frame_size = 40;
3831                        break;
3832                default:
3833                        j->rec_frame_size = 120;
3834                        break;
3835                }
3836                j->rec_mode = 6;
3837                break;
3838        case WSS:
3839                switch (j->baseframe.low) {
3840                case 0xA0:
3841                        j->rec_frame_size = 80;
3842                        break;
3843                case 0x50:
3844                        j->rec_frame_size = 40;
3845                        break;
3846                default:
3847                        j->rec_frame_size = 120;
3848                        break;
3849                }
3850                j->rec_mode = 7;
3851                break;
3852        default:
3853                kfree(j->read_buffer);
3854                j->rec_frame_size = 0;
3855                j->rec_mode = -1;
3856                j->read_buffer = NULL;
3857                j->read_buffer_size = 0;
3858                retval = 1;
3859                break;
3860        }
3861        return retval;
3862}
3863
3864static int ixj_record_start(IXJ *j)
3865{
3866        unsigned short cmd = 0x0000;
3867
3868        if (j->read_buffer) {
3869                ixj_record_stop(j);
3870        }
3871        j->flags.recording = 1;
3872        ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873
3874        if(ixjdebug & 0x0002)
3875                printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876
3877        if (!j->rec_mode) {
3878                switch (j->rec_codec) {
3879                case G723_63:
3880                        cmd = 0x5131;
3881                        break;
3882                case G723_53:
3883                        cmd = 0x5132;
3884                        break;
3885                case TS85:
3886                        cmd = 0x5130;   /* TrueSpeech 8.5 */
3887
3888                        break;
3889                case TS48:
3890                        cmd = 0x5133;   /* TrueSpeech 4.8 */
3891
3892                        break;
3893                case TS41:
3894                        cmd = 0x5134;   /* TrueSpeech 4.1 */
3895
3896                        break;
3897                case G728:
3898                        cmd = 0x5135;
3899                        break;
3900                case G729:
3901                case G729B:
3902                        cmd = 0x5136;
3903                        break;
3904                default:
3905                        return 1;
3906                }
3907                if (ixj_WriteDSPCommand(cmd, j))
3908                        return -1;
3909        }
3910        if (!j->read_buffer) {
3911                if (!j->read_buffer)
3912                        j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913                if (!j->read_buffer) {
3914                        printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915                        return -ENOMEM;
3916                }
3917        }
3918        j->read_buffer_size = j->rec_frame_size * 2;
3919
3920        if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3921
3922                return -1;
3923
3924        switch (j->rec_mode) {
3925        case 0:
3926                cmd = 0x1C03;   /* Record C1 */
3927
3928                break;
3929        case 4:
3930                if (j->ver.low == 0x12) {
3931                        cmd = 0x1E03;   /* Record C1 */
3932
3933                } else {
3934                        cmd = 0x1E01;   /* Record C1 */
3935
3936                }
3937                break;
3938        case 5:
3939                if (j->ver.low == 0x12) {
3940                        cmd = 0x1E83;   /* Record C1 */
3941
3942                } else {
3943                        cmd = 0x1E81;   /* Record C1 */
3944
3945                }
3946                break;
3947        case 6:
3948                if (j->ver.low == 0x12) {
3949                        cmd = 0x1F03;   /* Record C1 */
3950
3951                } else {
3952                        cmd = 0x1F01;   /* Record C1 */
3953
3954                }
3955                break;
3956        case 7:
3957                if (j->ver.low == 0x12) {
3958                        cmd = 0x1F83;   /* Record C1 */
3959                } else {
3960                        cmd = 0x1F81;   /* Record C1 */
3961                }
3962                break;
3963        }
3964        if (ixj_WriteDSPCommand(cmd, j))
3965                return -1;
3966
3967        if (j->flags.playing) {
3968                ixj_aec_start(j, j->aec_level);
3969        }
3970        return 0;
3971}
3972
3973static void ixj_record_stop(IXJ *j)
3974{
3975        if (ixjdebug & 0x0002)
3976                printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
3978        kfree(j->read_buffer);
3979        j->read_buffer = NULL;
3980        j->read_buffer_size = 0;
3981        if (j->rec_mode > -1) {
3982                ixj_WriteDSPCommand(0x5120, j);
3983                j->rec_mode = -1;
3984        }
3985        j->flags.recording = 0;
3986}
3987static void ixj_vad(IXJ *j, int arg)
3988{
3989        if (arg)
3990                ixj_WriteDSPCommand(0x513F, j);
3991        else
3992                ixj_WriteDSPCommand(0x513E, j);
3993}
3994
3995static void set_rec_depth(IXJ *j, int depth)
3996{
3997        if (depth > 60)
3998                depth = 60;
3999        if (depth < 0)
4000                depth = 0;
4001        ixj_WriteDSPCommand(0x5180 + depth, j);
4002}
4003
4004static void set_dtmf_prescale(IXJ *j, int volume)
4005{
4006        ixj_WriteDSPCommand(0xCF07, j);
4007        ixj_WriteDSPCommand(volume, j);
4008}
4009
4010static int get_dtmf_prescale(IXJ *j)
4011{
4012        ixj_WriteDSPCommand(0xCF05, j);
4013        return j->ssr.high << 8 | j->ssr.low;
4014}
4015
4016static void set_rec_volume(IXJ *j, int volume)
4017{
4018        if(j->aec_level == AEC_AGC) {
4019                if (ixjdebug & 0x0002)
4020                        printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021                ixj_WriteDSPCommand(0xCF96, j);
4022                ixj_WriteDSPCommand(volume, j);
4023        } else {
4024                if (ixjdebug & 0x0002)
4025                        printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026                ixj_WriteDSPCommand(0xCF03, j);
4027                ixj_WriteDSPCommand(volume, j);
4028        }
4029}
4030
4031static int set_rec_volume_linear(IXJ *j, int volume)
4032{
4033        int newvolume, dsprecmax;
4034
4035        if (ixjdebug & 0x0002)
4036                printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037        if(volume > 100 || volume < 0) {
4038          return -1;
4039        }
4040
4041        /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042        switch (j->cardtype) {
4043        case QTI_PHONEJACK:
4044                dsprecmax = 0x440;
4045                break;
4046        case QTI_LINEJACK:
4047                dsprecmax = 0x180;
4048                ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4049                ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4050                ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4051                break;
4052        case QTI_PHONEJACK_LITE:
4053                dsprecmax = 0x4C0;
4054                break;
4055        case QTI_PHONEJACK_PCI:
4056                dsprecmax = 0x100;
4057                break;
4058        case QTI_PHONECARD:
4059                dsprecmax = 0x400;
4060                break;
4061        default:
4062                return -1;
4063        }
4064        newvolume = (dsprecmax * volume) / 100;
4065        set_rec_volume(j, newvolume);
4066        return 0;
4067}
4068
4069static int get_rec_volume(IXJ *j)
4070{
4071        if(j->aec_level == AEC_AGC) {
4072                if (ixjdebug & 0x0002)
4073                        printk(KERN_INFO "Getting AGC Threshold\n");
4074                ixj_WriteDSPCommand(0xCF86, j);
4075                if (ixjdebug & 0x0002)
4076                        printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077                return j->ssr.high << 8 | j->ssr.low;
4078        } else {
4079                if (ixjdebug & 0x0002)
4080                        printk(KERN_INFO "Getting Record Volume\n");
4081                ixj_WriteDSPCommand(0xCF01, j);
4082                return j->ssr.high << 8 | j->ssr.low;
4083        }
4084}
4085
4086static int get_rec_volume_linear(IXJ *j)
4087{
4088        int volume, newvolume, dsprecmax;
4089
4090        switch (j->cardtype) {
4091        case QTI_PHONEJACK:
4092                dsprecmax = 0x440;
4093                break;
4094        case QTI_LINEJACK:
4095                dsprecmax = 0x180;
4096                break;
4097        case QTI_PHONEJACK_LITE:
4098                dsprecmax = 0x4C0;
4099                break;
4100        case QTI_PHONEJACK_PCI:
4101                dsprecmax = 0x100;
4102                break;
4103        case QTI_PHONECARD:
4104                dsprecmax = 0x400;
4105                break;
4106        default:
4107                return -1;
4108        }
4109        volume = get_rec_volume(j);
4110        newvolume = (volume * 100) / dsprecmax;
4111        if(newvolume > 100)
4112                newvolume = 100;
4113        return newvolume;
4114}
4115
4116static int get_rec_level(IXJ *j)
4117{
4118        int retval;
4119
4120        ixj_WriteDSPCommand(0xCF88, j);
4121
4122        retval = j->ssr.high << 8 | j->ssr.low;
4123        retval = (retval * 256) / 240;
4124        return retval;
4125}
4126
4127static void ixj_aec_start(IXJ *j, int level)
4128{
4129        j->aec_level = level;
4130        if (ixjdebug & 0x0002)
4131                printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132        if (!level) {
4133                aec_stop(j);
4134        } else {
4135                if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136                        ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137
4138                        ixj_WriteDSPCommand(0x0300, j);
4139                }
4140                ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141
4142                ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143
4144                switch (level) {
4145                case AEC_LOW:
4146                        ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147
4148                        ixj_WriteDSPCommand(0xE011, j);
4149                        ixj_WriteDSPCommand(0xFFFF, j);
4150
4151                        ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152                        ixj_WriteDSPCommand(0x0000, j); /* to off */
4153                        
4154                        break;
4155
4156                case AEC_MED:
4157                        ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158
4159                        ixj_WriteDSPCommand(0xE011, j);
4160                        ixj_WriteDSPCommand(0x0080, j);
4161
4162                        ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163                        ixj_WriteDSPCommand(0x0000, j); /* to off */
4164                        
4165                        break;
4166
4167                case AEC_HIGH:
4168                        ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169
4170                        ixj_WriteDSPCommand(0xE011, j);
4171                        ixj_WriteDSPCommand(0x0080, j);
4172
4173                        ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174                        ixj_WriteDSPCommand(0x0000, j); /* to off */
4175                        
4176                        break;
4177
4178                case AEC_AGC:
4179                        /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180                        ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181
4182                        ixj_WriteDSPCommand(0xE011, j);
4183                        ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184
4185                        ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186
4187                        if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188                                ixj_WriteDSPCommand(0x0224, j);
4189                        else
4190                                ixj_WriteDSPCommand(0x1224, j);
4191
4192                        ixj_WriteDSPCommand(0xE014, j);
4193                        ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4194
4195                        ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196
4197                        /* Now we can set the AGC initial parameters and turn it on */
4198                        ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4199                        ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200        
4201                        ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202                        ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203                        
4204                        ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205                        ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206                
4207                        ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208                        ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209                        
4210                        ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211                        ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212                        
4213                        ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214                        ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215                        
4216                        ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217                        ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218                        
4219                        ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220                        ixj_WriteDSPCommand(0x0001, j); /* to on */
4221                        
4222                        break;
4223
4224                case AEC_AUTO:
4225                        ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227                        ixj_WriteDSPCommand(0xE011, j);
4228                        ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230                        ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232                        if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233                                ixj_WriteDSPCommand(0x0224, j);
4234                        else
4235                                ixj_WriteDSPCommand(0x1224, j);
4236
4237                        ixj_WriteDSPCommand(0xE014, j);
4238                        ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4239
4240                        ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242                        break;
4243                }
4244        }
4245}
4246
4247static void aec_stop(IXJ *j)
4248{
4249        j->aec_level = AEC_OFF;
4250        if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251                ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252
4253                ixj_WriteDSPCommand(0x0700, j);
4254        }
4255        if (j->play_mode != -1 && j->rec_mode != -1)
4256        {
4257                ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258        }
4259}
4260
4261static int set_play_codec(IXJ *j, int rate)
4262{
4263        int retval = 0;
4264
4265        j->play_codec = rate;
4266
4267        switch (rate) {
4268        case G723_63:
4269                if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270                        j->play_frame_size = 12;
4271                        j->play_mode = 0;
4272                } else {
4273                        retval = 1;
4274                }
4275                break;
4276        case G723_53:
4277                if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278                        j->play_frame_size = 10;
4279                        j->play_mode = 0;
4280                } else {
4281                        retval = 1;
4282                }
4283                break;
4284        case TS85:
4285                if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286                        j->play_frame_size = 16;
4287                        j->play_mode = 0;
4288                } else {
4289                        retval = 1;
4290                }
4291                break;
4292        case TS48:
4293                if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294                        j->play_frame_size = 9;
4295                        j->play_mode = 0;
4296                } else {
4297                        retval = 1;
4298                }
4299                break;
4300        case TS41:
4301                if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302                        j->play_frame_size = 8;
4303                        j->play_mode = 0;
4304                } else {
4305                        retval = 1;
4306                }
4307                break;
4308        case G728:
4309                if (j->dsp.low != 0x20) {
4310                        j->play_frame_size = 48;
4311                        j->play_mode = 0;
4312                } else {
4313                        retval = 1;
4314                }
4315                break;
4316        case G729:
4317                if (j->dsp.low != 0x20) {
4318                        if (!j->flags.g729_loaded) {
4319                                retval = 1;
4320                                break;
4321                        }
4322                        switch (j->baseframe.low) {
4323                        case 0xA0:
4324                                j->play_frame_size = 10;
4325                                break;
4326                        case 0x50:
4327                                j->play_frame_size = 5;
4328                                break;
4329                        default:
4330                                j->play_frame_size = 15;
4331                                break;
4332                        }
4333                        j->play_mode = 0;
4334                } else {
4335                        retval = 1;
4336                }
4337                break;
4338        case G729B:
4339                if (j->dsp.low != 0x20) {
4340                        if (!j->flags.g729_loaded) {
4341                                retval = 1;
4342                                break;
4343                        }
4344                        switch (j->baseframe.low) {
4345                        case 0xA0:
4346                                j->play_frame_size = 12;
4347                                break;
4348                        case 0x50:
4349                                j->play_frame_size = 6;
4350                                break;
4351                        default:
4352                                j->play_frame_size = 18;
4353                                break;
4354                        }
4355                        j->play_mode = 0;
4356                } else {
4357                        retval = 1;
4358                }
4359                break;
4360        case ULAW:
4361                switch (j->baseframe.low) {
4362                case 0xA0:
4363                        j->play_frame_size = 80;
4364                        break;
4365                case 0x50:
4366                        j->play_frame_size = 40;
4367                        break;
4368                default:
4369                        j->play_frame_size = 120;
4370                        break;
4371                }
4372                j->play_mode = 2;
4373                break;
4374        case ALAW:
4375                switch (j->baseframe.low) {
4376                case 0xA0:
4377                        j->play_frame_size = 80;
4378                        break;
4379                case 0x50:
4380                        j->play_frame_size = 40;
4381                        break;
4382                default:
4383                        j->play_frame_size = 120;
4384                        break;
4385                }
4386                j->play_mode = 2;
4387                break;
4388        case LINEAR16:
4389                switch (j->baseframe.low) {
4390                case 0xA0:
4391                        j->play_frame_size = 160;
4392                        break;
4393                case 0x50:
4394                        j->play_frame_size = 80;
4395                        break;
4396                default:
4397                        j->play_frame_size = 240;
4398                        break;
4399                }
4400                j->play_mode = 6;
4401                break;
4402        case LINEAR8:
4403                switch (j->baseframe.low) {
4404                case 0xA0:
4405                        j->play_frame_size = 80;
4406                        break;
4407                case 0x50:
4408                        j->play_frame_size = 40;
4409                        break;
4410                default:
4411                        j->play_frame_size = 120;
4412                        break;
4413                }
4414                j->play_mode = 4;
4415                break;
4416        case WSS:
4417                switch (j->baseframe.low) {
4418                case 0xA0:
4419                        j->play_frame_size = 80;
4420                        break;
4421                case 0x50:
4422                        j->play_frame_size = 40;
4423                        break;
4424                default:
4425                        j->play_frame_size = 120;
4426                        break;
4427                }
4428                j->play_mode = 5;
4429                break;
4430        default:
4431                kfree(j->write_buffer);
4432                j->play_frame_size = 0;
4433                j->play_mode = -1;
4434                j->write_buffer = NULL;
4435                j->write_buffer_size = 0;
4436                retval = 1;
4437                break;
4438        }
4439        return retval;
4440}
4441
4442static int ixj_play_start(IXJ *j)
4443{
4444        unsigned short cmd = 0x0000;
4445
4446        if (j->write_buffer) {
4447                ixj_play_stop(j);
4448        }
4449
4450        if(ixjdebug & 0x0002)
4451                printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452
4453        j->flags.playing = 1;
4454        ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455
4456        j->flags.play_first_frame = 1;
4457        j->drybuffer = 0;
4458
4459        if (!j->play_mode) {
4460                switch (j->play_codec) {
4461                case G723_63:
4462                        cmd = 0x5231;
4463                        break;
4464                case G723_53:
4465                        cmd = 0x5232;
4466                        break;
4467                case TS85:
4468                        cmd = 0x5230;   /* TrueSpeech 8.5 */
4469
4470                        break;
4471                case TS48:
4472                        cmd = 0x5233;   /* TrueSpeech 4.8 */
4473
4474                        break;
4475                case TS41:
4476                        cmd = 0x5234;   /* TrueSpeech 4.1 */
4477
4478                        break;
4479                case G728:
4480                        cmd = 0x5235;
4481                        break;
4482                case G729:
4483                case G729B:
4484                        cmd = 0x5236;
4485                        break;
4486                default:
4487                        return 1;
4488                }
4489                if (ixj_WriteDSPCommand(cmd, j))
4490                        return -1;
4491        }
4492        j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493        if (!j->write_buffer) {
4494                printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495                return -ENOMEM;
4496        }
4497/*      j->write_buffers_empty = 2; */
4498        j->write_buffers_empty = 1; 
4499        j->write_buffer_size = j->play_frame_size * 2;
4500        j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501        j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502
4503        if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4504
4505                return -1;
4506
4507        switch (j->play_mode) {
4508        case 0:
4509                cmd = 0x2C03;
4510                break;
4511        case 2:
4512                if (j->ver.low == 0x12) {
4513                        cmd = 0x2C23;
4514                } else {
4515                        cmd = 0x2C21;
4516                }
4517                break;
4518        case 4:
4519                if (j->ver.low == 0x12) {
4520                        cmd = 0x2C43;
4521                } else {
4522                        cmd = 0x2C41;
4523                }
4524                break;
4525        case 5:
4526                if (j->ver.low == 0x12) {
4527                        cmd = 0x2C53;
4528                } else {
4529                        cmd = 0x2C51;
4530                }
4531                break;
4532        case 6:
4533                if (j->ver.low == 0x12) {
4534                        cmd = 0x2C63;
4535                } else {
4536                        cmd = 0x2C61;
4537                }
4538                break;
4539        }
4540        if (ixj_WriteDSPCommand(cmd, j))
4541                return -1;
4542
4543        if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4544                return -1;
4545
4546        if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4547                return -1;
4548
4549        if (j->flags.recording) {
4550                ixj_aec_start(j, j->aec_level);
4551        }
4552
4553        return 0;
4554}
4555
4556static void ixj_play_stop(IXJ *j)
4557{
4558        if (ixjdebug & 0x0002)
4559                printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
4561        kfree(j->write_buffer);
4562        j->write_buffer = NULL;
4563        j->write_buffer_size = 0;
4564        if (j->play_mode > -1) {
4565                ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4566
4567                j->play_mode = -1;
4568        }
4569        j->flags.playing = 0;
4570}
4571
4572static inline int get_play_level(IXJ *j)
4573{
4574        int retval;
4575
4576        ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577        return j->ssr.high << 8 | j->ssr.low;
4578        retval = j->ssr.high << 8 | j->ssr.low;
4579        retval = (retval * 256) / 240;
4580        return retval;
4581}
4582
4583static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584{
4585        unsigned int mask = 0;
4586
4587        IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4588
4589        poll_wait(file_p, &(j->poll_q), wait);
4590        if (j->read_buffer_ready > 0)
4591                mask |= POLLIN | POLLRDNORM;    /* readable */
4592        if (j->write_buffers_empty > 0)
4593                mask |= POLLOUT | POLLWRNORM;   /* writable */
4594        if (j->ex.bytes)
4595                mask |= POLLPRI;
4596        return mask;
4597}
4598
4599static int ixj_play_tone(IXJ *j, char tone)
4600{
4601        if (!j->tone_state) {
4602                if(ixjdebug & 0x0002) {
4603                        printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604                }
4605                if (j->dsp.low == 0x20) {
4606                        idle(j);
4607                }
4608                j->tone_start_jif = jiffies;
4609
4610                j->tone_state = 1;
4611        }
4612
4613        j->tone_index = tone;
4614        if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615                return -1;
4616
4617        return 0;
4618}
4619
4620static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621{
4622        j->tone_on_time = arg;
4623
4624        if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4625
4626                return -1;
4627
4628        if (ixj_WriteDSPCommand(arg, j))
4629                return -1;
4630
4631        return 0;
4632}
4633
4634static int SCI_WaitHighSCI(IXJ *j)
4635{
4636        int cnt;
4637
4638        j->pld_scrr.byte = inb_p(j->XILINXbase);
4639        if (!j->pld_scrr.bits.sci) {
4640                for (cnt = 0; cnt < 10; cnt++) {
4641                        udelay(32);
4642                        j->pld_scrr.byte = inb_p(j->XILINXbase);
4643
4644                        if ((j->pld_scrr.bits.sci))
4645                                return 1;
4646                }
4647                if (ixjdebug & 0x0001)
4648                        printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649                return 0;
4650        } else
4651                return 1;
4652}
4653
4654static int SCI_WaitLowSCI(IXJ *j)
4655{
4656        int cnt;
4657
4658        j->pld_scrr.byte = inb_p(j->XILINXbase);
4659        if (j->pld_scrr.bits.sci) {
4660                for (cnt = 0; cnt < 10; cnt++) {
4661                        udelay(32);
4662                        j->pld_scrr.byte = inb_p(j->XILINXbase);
4663
4664                        if (!(j->pld_scrr.bits.sci))
4665                                return 1;
4666                }
4667                if (ixjdebug & 0x0001)
4668                        printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669                return 0;
4670        } else
4671                return 1;
4672}
4673
4674static int SCI_Control(IXJ *j, int control)
4675{
4676        switch (control) {
4677        case SCI_End:
4678                j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4679
4680                j->pld_scrw.bits.c1 = 0;        /* to no selection */
4681
4682                break;
4683        case SCI_Enable_DAA:
4684                j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4685
4686                j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4687
4688                break;
4689        case SCI_Enable_Mixer:
4690                j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4691
4692                j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4693
4694                break;
4695        case SCI_Enable_EEPROM:
4696                j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4697
4698                j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4699
4700                break;
4701        default:
4702                return 0;
4703                break;
4704        }
4705        outb_p(j->pld_scrw.byte, j->XILINXbase);
4706
4707        switch (control) {
4708        case SCI_End:
4709                return 1;
4710                break;
4711        case SCI_Enable_DAA:
4712        case SCI_Enable_Mixer:
4713        case SCI_Enable_EEPROM:
4714                if (!SCI_WaitHighSCI(j))
4715                        return 0;
4716                break;
4717        default:
4718                return 0;
4719                break;
4720        }
4721        return 1;
4722}
4723
4724static int SCI_Prepare(IXJ *j)
4725{
4726        if (!SCI_Control(j, SCI_End))
4727                return 0;
4728
4729        if (!SCI_WaitLowSCI(j))
4730                return 0;
4731
4732        return 1;
4733}
4734
4735static int ixj_get_mixer(long val, IXJ *j)
4736{
4737        int reg = (val & 0x1F00) >> 8;
4738        return j->mix.vol[reg];
4739}
4740
4741static int ixj_mixer(long val, IXJ *j)
4742{
4743        BYTES bytes;
4744
4745        bytes.high = (val & 0x1F00) >> 8;
4746        bytes.low = val & 0x00FF;
4747
4748        /* save mixer value so we can get back later on */
4749        j->mix.vol[bytes.high] = bytes.low;
4750
4751        outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4752
4753        outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4754
4755        SCI_Control(j, SCI_Enable_Mixer);
4756
4757        SCI_Control(j, SCI_End);
4758
4759        return 0;
4760}
4761
4762static int daa_load(BYTES * p_bytes, IXJ *j)
4763{
4764        outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765        outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766        if (!SCI_Control(j, SCI_Enable_DAA))
4767                return 0;
4768        else
4769                return 1;
4770}
4771
4772static int ixj_daa_cr4(IXJ *j, char reg)
4773{
4774        BYTES bytes;
4775
4776        switch (j->daa_mode) {
4777        case SOP_PU_SLEEP:
4778                bytes.high = 0x14;
4779                break;
4780        case SOP_PU_RINGING:
4781                bytes.high = 0x54;
4782                break;
4783        case SOP_PU_CONVERSATION:
4784                bytes.high = 0x94;
4785                break;
4786        case SOP_PU_PULSEDIALING:
4787                bytes.high = 0xD4;
4788                break;
4789        }
4790
4791        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792
4793        switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794        case 0:
4795                j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796                break;
4797        case 1:
4798                j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799                break;
4800        case 2:
4801                j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802                break;
4803        case 3:
4804                j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805                break;
4806        }
4807
4808        bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809
4810        if (!daa_load(&bytes, j))
4811                return 0;
4812
4813        if (!SCI_Prepare(j))
4814                return 0;
4815
4816        return 1;
4817}
4818
4819static char daa_int_read(IXJ *j)
4820{
4821        BYTES bytes;
4822
4823        if (!SCI_Prepare(j))
4824                return 0;
4825
4826        bytes.high = 0x38;
4827        bytes.low = 0x00;
4828        outb_p(bytes.high, j->XILINXbase + 0x03);
4829        outb_p(bytes.low, j->XILINXbase + 0x02);
4830
4831        if (!SCI_Control(j, SCI_Enable_DAA))
4832                return 0;
4833
4834        bytes.high = inb_p(j->XILINXbase + 0x03);
4835        bytes.low = inb_p(j->XILINXbase + 0x02);
4836        if (bytes.low != ALISDAA_ID_BYTE) {
4837                if (ixjdebug & 0x0001)
4838                        printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839                return 0;
4840        }
4841        if (!SCI_Control(j, SCI_Enable_DAA))
4842                return 0;
4843        if (!SCI_Control(j, SCI_End))
4844                return 0;
4845
4846        bytes.high = inb_p(j->XILINXbase + 0x03);
4847        bytes.low = inb_p(j->XILINXbase + 0x02);
4848
4849        j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850
4851        return 1;
4852}
4853
4854static char daa_CR_read(IXJ *j, int cr)
4855{
4856        IXJ_WORD wdata;
4857        BYTES bytes;
4858
4859        if (!SCI_Prepare(j))
4860                return 0;
4861
4862        switch (j->daa_mode) {
4863        case SOP_PU_SLEEP:
4864                bytes.high = 0x30 + cr;
4865                break;
4866        case SOP_PU_RINGING:
4867                bytes.high = 0x70 + cr;
4868                break;
4869        case SOP_PU_CONVERSATION:
4870                bytes.high = 0xB0 + cr;
4871                break;
4872        case SOP_PU_PULSEDIALING:
4873        default:
4874                bytes.high = 0xF0 + cr;
4875                break;
4876        }
4877
4878        bytes.low = 0x00;
4879
4880        outb_p(bytes.high, j->XILINXbase + 0x03);
4881        outb_p(bytes.low, j->XILINXbase + 0x02);
4882
4883        if (!SCI_Control(j, SCI_Enable_DAA))
4884                return 0;
4885
4886        bytes.high = inb_p(j->XILINXbase + 0x03);
4887        bytes.low = inb_p(j->XILINXbase + 0x02);
4888        if (bytes.low != ALISDAA_ID_BYTE) {
4889                if (ixjdebug & 0x0001)
4890                        printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891                return 0;
4892        }
4893        if (!SCI_Control(j, SCI_Enable_DAA))
4894                return 0;
4895        if (!SCI_Control(j, SCI_End))
4896                return 0;
4897
4898        wdata.word = inw_p(j->XILINXbase + 0x02);
4899
4900        switch(cr){
4901                case 5:
4902                        j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903                        break;
4904                case 4:
4905                        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906                        break;
4907                case 3:
4908                        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909                        break;
4910                case 2:
4911                        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912                        break;
4913                case 1:
4914                        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915                        break;
4916                case 0:
4917                        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918                        break;
4919                default:
4920                        return 0;
4921        }
4922        return 1;
4923}
4924
4925static int ixj_daa_cid_reset(IXJ *j)
4926{
4927        int i;
4928        BYTES bytes;
4929
4930        if (ixjdebug & 0x0002)
4931                printk("DAA Clearing CID ram\n");
4932
4933        if (!SCI_Prepare(j))
4934                return 0;
4935
4936        bytes.high = 0x58;
4937        bytes.low = 0x00;
4938        outb_p(bytes.high, j->XILINXbase + 0x03);
4939        outb_p(bytes.low, j->XILINXbase + 0x02);
4940
4941        if (!SCI_Control(j, SCI_Enable_DAA))
4942                return 0;
4943
4944        if (!SCI_WaitHighSCI(j))
4945                return 0;
4946
4947        for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948                bytes.high = bytes.low = 0x00;
4949                outb_p(bytes.high, j->XILINXbase + 0x03);
4950
4951                if (i < ALISDAA_CALLERID_SIZE - 1)
4952                        outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954                if (!SCI_Control(j, SCI_Enable_DAA))
4955                        return 0;
4956
4957                if (!SCI_WaitHighSCI(j))
4958                        return 0;
4959
4960        }
4961
4962        if (!SCI_Control(j, SCI_End))
4963                return 0;
4964
4965        if (ixjdebug & 0x0002)
4966                printk("DAA CID ram cleared\n");
4967
4968        return 1;
4969}
4970
4971static int ixj_daa_cid_read(IXJ *j)
4972{
4973        int i;
4974        BYTES bytes;
4975        char CID[ALISDAA_CALLERID_SIZE];
4976        bool mContinue;
4977        char *pIn, *pOut;
4978
4979        if (!SCI_Prepare(j))
4980                return 0;
4981
4982        bytes.high = 0x78;
4983        bytes.low = 0x00;
4984        outb_p(bytes.high, j->XILINXbase + 0x03);
4985        outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987        if (!SCI_Control(j, SCI_Enable_DAA))
4988                return 0;
4989
4990        if (!SCI_WaitHighSCI(j))
4991                return 0;
4992
4993        bytes.high = inb_p(j->XILINXbase + 0x03);
4994        bytes.low = inb_p(j->XILINXbase + 0x02);
4995        if (bytes.low != ALISDAA_ID_BYTE) {
4996                if (ixjdebug & 0x0001)
4997                        printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998                return 0;
4999        }
5000        for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001                bytes.high = bytes.low = 0x00;
5002                outb_p(bytes.high, j->XILINXbase + 0x03);
5003                outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005                if (!SCI_Control(j, SCI_Enable_DAA))
5006                        return 0;
5007
5008                if (!SCI_WaitHighSCI(j))
5009                        return 0;
5010
5011                CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012                CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013        }
5014
5015        if (!SCI_Control(j, SCI_End))
5016                return 0;
5017
5018        pIn = CID;
5019        pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020        mContinue = true;
5021        while (mContinue) {
5022                if ((pIn[1] & 0x03) == 0x01) {
5023                        pOut[0] = pIn[0];
5024                }
5025                if ((pIn[2] & 0x0c) == 0x04) {
5026                        pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027                }
5028                if ((pIn[3] & 0x30) == 0x10) {
5029                        pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030                }
5031                if ((pIn[4] & 0xc0) == 0x40) {
5032                        pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033                } else {
5034                        mContinue = false;
5035                }
5036                pIn += 5, pOut += 4;
5037        }
5038        memset(&j->cid, 0, sizeof(PHONE_CID));
5039        pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040        pOut += 4;
5041        strncpy(j->cid.month, pOut, 2);
5042        pOut += 2;
5043        strncpy(j->cid.day, pOut, 2);
5044        pOut += 2;
5045        strncpy(j->cid.hour, pOut, 2);
5046        pOut += 2;
5047        strncpy(j->cid.min, pOut, 2);
5048        pOut += 3;
5049        j->cid.numlen = *pOut;
5050        pOut += 1;
5051        strncpy(j->cid.number, pOut, j->cid.numlen);
5052        pOut += j->cid.numlen + 1;
5053        j->cid.namelen = *pOut;
5054        pOut += 1;
5055        strncpy(j->cid.name, pOut, j->cid.namelen);
5056
5057        ixj_daa_cid_reset(j);
5058        return 1;
5059}
5060
5061static char daa_get_version(IXJ *j)
5062{
5063        BYTES bytes;
5064
5065        if (!SCI_Prepare(j))
5066                return 0;
5067
5068        bytes.high = 0x35;
5069        bytes.low = 0x00;
5070        outb_p(bytes.high, j->XILINXbase + 0x03);
5071        outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073        if (!SCI_Control(j, SCI_Enable_DAA))
5074                return 0;
5075
5076        bytes.high = inb_p(j->XILINXbase + 0x03);
5077        bytes.low = inb_p(j->XILINXbase + 0x02);
5078        if (bytes.low != ALISDAA_ID_BYTE) {
5079                if (ixjdebug & 0x0001)
5080                        printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081                return 0;
5082        }
5083        if (!SCI_Control(j, SCI_Enable_DAA))
5084                return 0;
5085
5086        if (!SCI_Control(j, SCI_End))
5087                return 0;
5088
5089        bytes.high = inb_p(j->XILINXbase + 0x03);
5090        bytes.low = inb_p(j->XILINXbase + 0x02);
5091        if (ixjdebug & 0x0002)
5092                printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093        j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094        return bytes.high;
5095}
5096
5097static int daa_set_mode(IXJ *j, int mode)
5098{
5099        /* NOTE:
5100              The DAA *MUST* be in the conversation mode if the
5101              PSTN line is to be seized (PSTN line off-hook).
5102              Taking the PSTN line off-hook while the DAA is in
5103              a mode other than conversation mode will cause a
5104              hardware failure of the ALIS-A part.
5105
5106           NOTE:
5107              The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108              if the PSTN line is on-hook.  Failure to have the PSTN line
5109              in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110              ALIS-A part.
5111        */
5112
5113        BYTES bytes;
5114
5115        j->flags.pstn_rmr = 0;
5116
5117        if (!SCI_Prepare(j))
5118                return 0;
5119
5120        switch (mode) {
5121        case SOP_PU_RESET:
5122                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5123
5124                outb_p(j->pld_scrw.byte, j->XILINXbase);
5125                j->pld_slicw.bits.rly2 = 0;
5126                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127                bytes.high = 0x10;
5128                bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129                daa_load(&bytes, j);
5130                if (!SCI_Prepare(j))
5131                        return 0;
5132
5133                j->daa_mode = SOP_PU_SLEEP;
5134                break;
5135        case SOP_PU_SLEEP:
5136                if(j->daa_mode == SOP_PU_SLEEP)
5137                {
5138                        break;
5139                }
5140                if (ixjdebug & 0x0008)
5141                        printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142/*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5143                {
5144                        j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5145
5146                        outb_p(j->pld_scrw.byte, j->XILINXbase);
5147                        j->pld_slicw.bits.rly2 = 0;
5148                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149                        bytes.high = 0x10;
5150                        bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151                        daa_load(&bytes, j);
5152                        if (!SCI_Prepare(j))
5153                                return 0;
5154                }
5155                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5156
5157                outb_p(j->pld_scrw.byte, j->XILINXbase);
5158                j->pld_slicw.bits.rly2 = 0;
5159                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160                bytes.high = 0x10;
5161                bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162                daa_load(&bytes, j);
5163                if (!SCI_Prepare(j))
5164                        return 0;
5165
5166                j->daa_mode = SOP_PU_SLEEP;
5167                j->flags.pstn_ringing = 0;
5168                j->ex.bits.pstn_ring = 0;
5169                j->pstn_sleeptil = jiffies + (hertz / 4);
5170                wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5171                wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5172                wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5173                break;
5174        case SOP_PU_RINGING:
5175                if (ixjdebug & 0x0008)
5176                        printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5178
5179                outb_p(j->pld_scrw.byte, j->XILINXbase);
5180                j->pld_slicw.bits.rly2 = 0;
5181                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182                bytes.high = 0x50;
5183                bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184                daa_load(&bytes, j);
5185                if (!SCI_Prepare(j))
5186                        return 0;
5187                j->daa_mode = SOP_PU_RINGING;
5188                break;
5189        case SOP_PU_CONVERSATION:
5190                if (ixjdebug & 0x0008)
5191                        printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192                bytes.high = 0x90;
5193                bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194                daa_load(&bytes, j);
5195                if (!SCI_Prepare(j))
5196                        return 0;
5197                j->pld_slicw.bits.rly2 = 1;
5198                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199                j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5200
5201                outb_p(j->pld_scrw.byte, j->XILINXbase);
5202                j->daa_mode = SOP_PU_CONVERSATION;
5203                j->flags.pstn_ringing = 0;
5204                j->ex.bits.pstn_ring = 0;
5205                j->pstn_sleeptil = jiffies;
5206                j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207                break;
5208        case SOP_PU_PULSEDIALING:
5209                if (ixjdebug & 0x0008)
5210                        printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5212
5213                outb_p(j->pld_scrw.byte, j->XILINXbase);
5214                j->pld_slicw.bits.rly2 = 0;
5215                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216                bytes.high = 0xD0;
5217                bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218                daa_load(&bytes, j);
5219                if (!SCI_Prepare(j))
5220                        return 0;
5221                j->daa_mode = SOP_PU_PULSEDIALING;
5222                break;
5223        default:
5224                break;
5225        }
5226        return 1;
5227}
5228
5229static int ixj_daa_write(IXJ *j)
5230{
5231        BYTES bytes;
5232
5233        j->flags.pstncheck = 1;
5234
5235        daa_set_mode(j, SOP_PU_SLEEP);
5236
5237        if (!SCI_Prepare(j))
5238                return 0;
5239
5240        outb_p(j->pld_scrw.byte, j->XILINXbase);
5241
5242        bytes.high = 0x14;
5243        bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244        if (!daa_load(&bytes, j))
5245                return 0;
5246
5247        bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248        bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249        if (!daa_load(&bytes, j))
5250                return 0;
5251
5252        bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253        bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254        if (!daa_load(&bytes, j))
5255                return 0;
5256
5257        if (!SCI_Prepare(j))
5258                return 0;
5259
5260        bytes.high = 0x1F;
5261        bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262        if (!daa_load(&bytes, j))
5263                return 0;
5264
5265        bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266        bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267        if (!daa_load(&bytes, j))
5268                return 0;
5269
5270        bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271        bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272        if (!daa_load(&bytes, j))
5273                return 0;
5274
5275        bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276        bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277        if (!daa_load(&bytes, j))
5278                return 0;
5279
5280        bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281        bytes.low = 0x00;
5282        if (!daa_load(&bytes, j))
5283                return 0;
5284
5285        if (!SCI_Prepare(j))
5286                return 0;
5287
5288        bytes.high = 0x00;
5289        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290        if (!daa_load(&bytes, j))
5291                return 0;
5292
5293        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295        if (!daa_load(&bytes, j))
5296                return 0;
5297
5298        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300        if (!daa_load(&bytes, j))
5301                return 0;
5302
5303        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305        if (!daa_load(&bytes, j))
5306                return 0;
5307
5308        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309        bytes.low = 0x00;
5310        if (!daa_load(&bytes, j))
5311                return 0;
5312
5313        if (!SCI_Control(j, SCI_End))
5314                return 0;
5315        if (!SCI_WaitLowSCI(j))
5316                return 0;
5317
5318        bytes.high = 0x01;
5319        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320        if (!daa_load(&bytes, j))
5321                return 0;
5322
5323        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325        if (!daa_load(&bytes, j))
5326                return 0;
5327
5328        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330        if (!daa_load(&bytes, j))
5331                return 0;
5332
5333        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335        if (!daa_load(&bytes, j))
5336                return 0;
5337
5338        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339        bytes.low = 0x00;
5340        if (!daa_load(&bytes, j))
5341                return 0;
5342
5343        if (!SCI_Control(j, SCI_End))
5344                return 0;
5345        if (!SCI_WaitLowSCI(j))
5346                return 0;
5347
5348        bytes.high = 0x02;
5349        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350        if (!daa_load(&bytes, j))
5351                return 0;
5352
5353        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355        if (!daa_load(&bytes, j))
5356                return 0;
5357
5358        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360        if (!daa_load(&bytes, j))
5361                return 0;
5362
5363        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365        if (!daa_load(&bytes, j))
5366                return 0;
5367
5368        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369        bytes.low = 0x00;
5370        if (!daa_load(&bytes, j))
5371                return 0;
5372
5373        if (!SCI_Control(j, SCI_End))
5374                return 0;
5375        if (!SCI_WaitLowSCI(j))
5376                return 0;
5377
5378        bytes.high = 0x03;
5379        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380        if (!daa_load(&bytes, j))
5381                return 0;
5382
5383        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385        if (!daa_load(&bytes, j))
5386                return 0;
5387
5388        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390        if (!daa_load(&bytes, j))
5391                return 0;
5392
5393        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395        if (!daa_load(&bytes, j))
5396                return 0;
5397
5398        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399        bytes.low = 0x00;
5400        if (!daa_load(&bytes, j))
5401                return 0;
5402
5403        if (!SCI_Control(j, SCI_End))
5404                return 0;
5405        if (!SCI_WaitLowSCI(j))
5406                return 0;
5407
5408        bytes.high = 0x04;
5409        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410        if (!daa_load(&bytes, j))
5411                return 0;
5412
5413        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415        if (!daa_load(&bytes, j))
5416                return 0;
5417
5418        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420        if (!daa_load(&bytes, j))
5421                return 0;
5422
5423        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425        if (!daa_load(&bytes, j))
5426                return 0;
5427
5428        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429        bytes.low = 0x00;
5430        if (!daa_load(&bytes, j))
5431                return 0;
5432
5433        if (!SCI_Control(j, SCI_End))
5434                return 0;
5435        if (!SCI_WaitLowSCI(j))
5436                return 0;
5437
5438        bytes.high = 0x05;
5439        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440        if (!daa_load(&bytes, j))
5441                return 0;
5442
5443        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445        if (!daa_load(&bytes, j))
5446                return 0;
5447
5448        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450        if (!daa_load(&bytes, j))
5451                return 0;
5452
5453        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455        if (!daa_load(&bytes, j))
5456                return 0;
5457
5458        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459        bytes.low = 0x00;
5460        if (!daa_load(&bytes, j))
5461                return 0;
5462
5463        if (!SCI_Control(j, SCI_End))
5464                return 0;
5465        if (!SCI_WaitLowSCI(j))
5466                return 0;
5467
5468        bytes.high = 0x06;
5469        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470        if (!daa_load(&bytes, j))
5471                return 0;
5472
5473        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475        if (!daa_load(&bytes, j))
5476                return 0;
5477
5478        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480        if (!daa_load(&bytes, j))
5481                return 0;
5482
5483        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485        if (!daa_load(&bytes, j))
5486                return 0;
5487
5488        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489        bytes.low = 0x00;
5490        if (!daa_load(&bytes, j))
5491                return 0;
5492
5493        if (!SCI_Control(j, SCI_End))
5494                return 0;
5495        if (!SCI_WaitLowSCI(j))
5496                return 0;
5497
5498        bytes.high = 0x07;
5499        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500        if (!daa_load(&bytes, j))
5501                return 0;
5502
5503        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505        if (!daa_load(&bytes, j))
5506                return 0;
5507
5508        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510        if (!daa_load(&bytes, j))
5511                return 0;
5512
5513        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515        if (!daa_load(&bytes, j))
5516                return 0;
5517
5518        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519        bytes.low = 0x00;
5520        if (!daa_load(&bytes, j))
5521                return 0;
5522
5523        if (!SCI_Control(j, SCI_End))
5524                return 0;
5525        if (!SCI_WaitLowSCI(j))
5526                return 0;
5527
5528        bytes.high = 0x08;
5529        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530        if (!daa_load(&bytes, j))
5531                return 0;
5532
5533        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535        if (!daa_load(&bytes, j))
5536                return 0;
5537
5538        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540        if (!daa_load(&bytes, j))
5541                return 0;
5542
5543        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545        if (!daa_load(&bytes, j))
5546                return 0;
5547
5548        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549        bytes.low = 0x00;
5550        if (!daa_load(&bytes, j))
5551                return 0;
5552
5553        if (!SCI_Control(j, SCI_End))
5554                return 0;
5555        if (!SCI_WaitLowSCI(j))
5556                return 0;
5557
5558        bytes.high = 0x09;
5559        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560        if (!daa_load(&bytes, j))
5561                return 0;
5562
5563        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565        if (!daa_load(&bytes, j))
5566                return 0;
5567
5568        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569        bytes.low = 0x00;
5570        if (!daa_load(&bytes, j))
5571                return 0;
5572
5573        if (!SCI_Control(j, SCI_End))
5574                return 0;
5575        if (!SCI_WaitLowSCI(j))
5576                return 0;
5577
5578        bytes.high = 0x0A;
5579        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580        if (!daa_load(&bytes, j))
5581                return 0;
5582
5583        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585        if (!daa_load(&bytes, j))
5586                return 0;
5587
5588        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589        bytes.low = 0x00;
5590        if (!daa_load(&bytes, j))
5591                return 0;
5592
5593        if (!SCI_Control(j, SCI_End))
5594                return 0;
5595        if (!SCI_WaitLowSCI(j))
5596                return 0;
5597
5598        bytes.high = 0x0B;
5599        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600        if (!daa_load(&bytes, j))
5601                return 0;
5602
5603        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605        if (!daa_load(&bytes, j))
5606                return 0;
5607
5608        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609        bytes.low = 0x00;
5610        if (!daa_load(&bytes, j))
5611                return 0;
5612
5613        if (!SCI_Control(j, SCI_End))
5614                return 0;
5615        if (!SCI_WaitLowSCI(j))
5616                return 0;
5617
5618        bytes.high = 0x0C;
5619        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620        if (!daa_load(&bytes, j))
5621                return 0;
5622
5623        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625        if (!daa_load(&bytes, j))
5626                return 0;
5627
5628        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629        bytes.low = 0x00;
5630        if (!daa_load(&bytes, j))
5631                return 0;
5632
5633        if (!SCI_Control(j, SCI_End))
5634                return 0;
5635        if (!SCI_WaitLowSCI(j))
5636                return 0;
5637
5638        bytes.high = 0x0D;
5639        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640        if (!daa_load(&bytes, j))
5641                return 0;
5642
5643        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645        if (!daa_load(&bytes, j))
5646                return 0;
5647
5648        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649        bytes.low = 0x00;
5650        if (!daa_load(&bytes, j))
5651                return 0;
5652
5653        if (!SCI_Control(j, SCI_End))
5654                return 0;
5655        if (!SCI_WaitLowSCI(j))
5656                return 0;
5657
5658        bytes.high = 0x0E;
5659        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660        if (!daa_load(&bytes, j))
5661                return 0;
5662
5663        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665        if (!daa_load(&bytes, j))
5666                return 0;
5667
5668        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670        if (!daa_load(&bytes, j))
5671                return 0;
5672
5673        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675        if (!daa_load(&bytes, j))
5676                return 0;
5677
5678        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679        bytes.low = 0x00;
5680        if (!daa_load(&bytes, j))
5681                return 0;
5682
5683        if (!SCI_Control(j, SCI_End))
5684                return 0;
5685        if (!SCI_WaitLowSCI(j))
5686                return 0;
5687
5688        bytes.high = 0x0F;
5689        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690        if (!daa_load(&bytes, j))
5691                return 0;
5692
5693        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695        if (!daa_load(&bytes, j))
5696                return 0;
5697
5698        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700        if (!daa_load(&bytes, j))
5701                return 0;
5702
5703        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704        bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705        if (!daa_load(&bytes, j))
5706                return 0;
5707
5708        bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709        bytes.low = 0x00;
5710        if (!daa_load(&bytes, j))
5711                return 0;
5712
5713        udelay(32);
5714        j->pld_scrr.byte = inb_p(j->XILINXbase);
5715        if (!SCI_Control(j, SCI_End))
5716                return 0;
5717
5718        outb_p(j->pld_scrw.byte, j->XILINXbase);
5719
5720        if (ixjdebug & 0x0002)
5721                printk("DAA Coefficients Loaded\n");
5722
5723        j->flags.pstncheck = 0;
5724        return 1;
5725}
5726
5727static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728{
5729        j->tone_off_time = arg;
5730        if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5731
5732                return -1;
5733        if (ixj_WriteDSPCommand(arg, j))
5734                return -1;
5735        return 0;
5736}
5737
5738static int ixj_get_tone_on(IXJ *j)
5739{
5740        if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5741
5742                return -1;
5743        return 0;
5744}
5745
5746static int ixj_get_tone_off(IXJ *j)
5747{
5748        if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5749
5750                return -1;
5751        return 0;
5752}
5753
5754static void ixj_busytone(IXJ *j)
5755{
5756        j->flags.ringback = 0;
5757        j->flags.dialtone = 0;
5758        j->flags.busytone = 1;
5759        ixj_set_tone_on(0x07D0, j);
5760        ixj_set_tone_off(0x07D0, j);
5761        ixj_play_tone(j, 27);
5762}
5763
5764static void ixj_dialtone(IXJ *j)
5765{
5766        j->flags.ringback = 0;
5767        j->flags.dialtone = 1;
5768        j->flags.busytone = 0;
5769        if (j->dsp.low == 0x20) {
5770                return;
5771        } else {
5772                ixj_set_tone_on(0xFFFF, j);
5773                ixj_set_tone_off(0x0000, j);
5774                ixj_play_tone(j, 25);
5775        }
5776}
5777
5778static void ixj_cpt_stop(IXJ *j)
5779{
5780        if(j->tone_state || j->tone_cadence_state)
5781        {
5782                j->flags.dialtone = 0;
5783                j->flags.busytone = 0;
5784                j->flags.ringback = 0;
5785                ixj_set_tone_on(0x0001, j);
5786                ixj_set_tone_off(0x0000, j);
5787                ixj_play_tone(j, 0);
5788                j->tone_state = j->tone_cadence_state = 0;
5789                if (j->cadence_t) {
5790                        kfree(j->cadence_t->ce);
5791                        kfree(j->cadence_t);
5792                        j->cadence_t = NULL;
5793                }
5794        }
5795        if (j->play_mode == -1 && j->rec_mode == -1)
5796                idle(j);
5797        if (j->play_mode != -1 && j->dsp.low == 0x20)
5798                ixj_play_start(j);
5799        if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800                ixj_record_start(j);
5801}
5802
5803static void ixj_ringback(IXJ *j)
5804{
5805        j->flags.busytone = 0;
5806        j->flags.dialtone = 0;
5807        j->flags.ringback = 1;
5808        ixj_set_tone_on(0x0FA0, j);
5809        ixj_set_tone_off(0x2EE0, j);
5810        ixj_play_tone(j, 26);
5811}
5812
5813static void ixj_testram(IXJ *j)
5814{
5815        ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816}
5817
5818static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819{
5820        ixj_cadence *lcp;
5821        IXJ_CADENCE_ELEMENT __user *cep;
5822        IXJ_CADENCE_ELEMENT *lcep;
5823        IXJ_TONE ti;
5824        int err;
5825
5826        lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827        if (lcp == NULL)
5828                return -ENOMEM;
5829
5830        err = -EFAULT;
5831        if (copy_from_user(&lcp->elements_used,
5832                           &cp->elements_used, sizeof(int)))
5833                goto out;
5834        if (copy_from_user(&lcp->termination,
5835                           &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836                goto out;
5837        if (get_user(cep, &cp->ce))
5838                goto out;
5839
5840        err = -EINVAL;
5841        if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842                goto out;
5843
5844        err = -ENOMEM;
5845        lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846        if (!lcep)
5847                goto out;
5848
5849        err = -EFAULT;
5850        if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851                goto out1;
5852
5853        if (j->cadence_t) {
5854                kfree(j->cadence_t->ce);
5855                kfree(j->cadence_t);
5856        }
5857        lcp->ce = (void *) lcep;
5858        j->cadence_t = lcp;
5859        j->tone_cadence_state = 0;
5860        ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861        ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862        if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863                ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864                ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865                ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866                ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867                ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868                ixj_init_tone(j, &ti);
5869        }
5870        ixj_play_tone(j, lcp->ce[0].index);
5871        return 1;
5872out1:
5873        kfree(lcep);
5874out:
5875        kfree(lcp);
5876        return err;
5877}
5878
5879static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880{
5881        IXJ_FILTER_CADENCE *lcp;
5882        lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5883        if (lcp == NULL) {
5884                if(ixjdebug & 0x0001) {
5885                        printk(KERN_INFO "Could not allocate memory for cadence\n");
5886                }
5887                return -ENOMEM;
5888        }
5889        if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5890                if(ixjdebug & 0x0001) {
5891                        printk(KERN_INFO "Could not copy cadence to kernel\n");
5892                }
5893                kfree(lcp);
5894                return -EFAULT;
5895        }
5896        if (lcp->filter > 5) {
5897                if(ixjdebug & 0x0001) {
5898                        printk(KERN_INFO "Cadence out of range\n");
5899                }
5900                kfree(lcp);
5901                return -1;
5902        }
5903        j->cadence_f[lcp->filter].state = 0;
5904        j->cadence_f[lcp->filter].enable = lcp->enable;
5905        j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5906        j->cadence_f[lcp->filter].on1 = lcp->on1;
5907        j->cadence_f[lcp->filter].on1min = 0;
5908        j->cadence_f[lcp->filter].on1max = 0;
5909        j->cadence_f[lcp->filter].off1 = lcp->off1;
5910        j->cadence_f[lcp->filter].off1min = 0;
5911        j->cadence_f[lcp->filter].off1max = 0;
5912        j->cadence_f[lcp->filter].on2 = lcp->on2;
5913        j->cadence_f[lcp->filter].on2min = 0;
5914        j->cadence_f[lcp->filter].on2max = 0;
5915        j->cadence_f[lcp->filter].off2 = lcp->off2;
5916        j->cadence_f[lcp->filter].off2min = 0;
5917        j->cadence_f[lcp->filter].off2max = 0;
5918        j->cadence_f[lcp->filter].on3 = lcp->on3;
5919        j->cadence_f[lcp->filter].on3min = 0;
5920        j->cadence_f[lcp->filter].on3max = 0;
5921        j->cadence_f[lcp->filter].off3 = lcp->off3;
5922        j->cadence_f[lcp->filter].off3min = 0;
5923        j->cadence_f[lcp->filter].off3max = 0;
5924        if(ixjdebug & 0x0002) {
5925                printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5926        }
5927        kfree(lcp);
5928        return 0;
5929}
5930
5931static void add_caps(IXJ *j)
5932{
5933        j->caps = 0;
5934        j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5935        strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5936        j->caplist[j->caps].captype = vendor;
5937        j->caplist[j->caps].handle = j->caps++;
5938        j->caplist[j->caps].captype = device;
5939        switch (j->cardtype) {
5940        case QTI_PHONEJACK:
5941                strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5942                break;
5943        case QTI_LINEJACK:
5944                strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5945                break;
5946        case QTI_PHONEJACK_LITE:
5947                strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5948                break;
5949        case QTI_PHONEJACK_PCI:
5950                strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5951                break;
5952        case QTI_PHONECARD:
5953                strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5954                break;
5955        }
5956        j->caplist[j->caps].cap = j->cardtype;
5957        j->caplist[j->caps].handle = j->caps++;
5958        strcpy(j->caplist[j->caps].desc, "POTS");
5959        j->caplist[j->caps].captype = port;
5960        j->caplist[j->caps].cap = pots;
5961        j->caplist[j->caps].handle = j->caps++;
5962
5963        /* add devices that can do speaker/mic */
5964        switch (j->cardtype) {
5965        case QTI_PHONEJACK:
5966        case QTI_LINEJACK:
5967        case QTI_PHONEJACK_PCI:
5968        case QTI_PHONECARD:
5969                strcpy(j->caplist[j->caps].desc, "SPEAKER");
5970                j->caplist[j->caps].captype = port;
5971                j->caplist[j->caps].cap = speaker;
5972                j->caplist[j->caps].handle = j->caps++;
5973        default:
5974                break;
5975        }
5976
5977        /* add devices that can do handset */
5978        switch (j->cardtype) {
5979        case QTI_PHONEJACK:
5980                strcpy(j->caplist[j->caps].desc, "HANDSET");
5981                j->caplist[j->caps].captype = port;
5982                j->caplist[j->caps].cap = handset;
5983                j->caplist[j->caps].handle = j->caps++;
5984                break;
5985        default:
5986                break;
5987        }
5988
5989        /* add devices that can do PSTN */
5990        switch (j->cardtype) {
5991        case QTI_LINEJACK:
5992                strcpy(j->caplist[j->caps].desc, "PSTN");
5993                j->caplist[j->caps].captype = port;
5994                j->caplist[j->caps].cap = pstn;
5995                j->caplist[j->caps].handle = j->caps++;
5996                break;
5997        default:
5998                break;
5999        }
6000
6001        /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6002        strcpy(j->caplist[j->caps].desc, "ULAW");
6003        j->caplist[j->caps].captype = codec;
6004        j->caplist[j->caps].cap = ULAW;
6005        j->caplist[j->caps].handle = j->caps++;
6006
6007        strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6008        j->caplist[j->caps].captype = codec;
6009        j->caplist[j->caps].cap = LINEAR16;
6010        j->caplist[j->caps].handle = j->caps++;
6011
6012        strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6013        j->caplist[j->caps].captype = codec;
6014        j->caplist[j->caps].cap = LINEAR8;
6015        j->caplist[j->caps].handle = j->caps++;
6016
6017        strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6018        j->caplist[j->caps].captype = codec;
6019        j->caplist[j->caps].cap = WSS;
6020        j->caplist[j->caps].handle = j->caps++;
6021
6022        /* software ALAW codec, made from ULAW */
6023        strcpy(j->caplist[j->caps].desc, "ALAW");
6024        j->caplist[j->caps].captype = codec;
6025        j->caplist[j->caps].cap = ALAW;
6026        j->caplist[j->caps].handle = j->caps++;
6027
6028        /* version 12 of the 8020 does the following codecs in a broken way */
6029        if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6030                strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6031                j->caplist[j->caps].captype = codec;
6032                j->caplist[j->caps].cap = G723_63;
6033                j->caplist[j->caps].handle = j->caps++;
6034
6035                strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6036                j->caplist[j->caps].captype = codec;
6037                j->caplist[j->caps].cap = G723_53;
6038                j->caplist[j->caps].handle = j->caps++;
6039
6040                strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6041                j->caplist[j->caps].captype = codec;
6042                j->caplist[j->caps].cap = TS48;
6043                j->caplist[j->caps].handle = j->caps++;
6044
6045                strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6046                j->caplist[j->caps].captype = codec;
6047                j->caplist[j->caps].cap = TS41;
6048                j->caplist[j->caps].handle = j->caps++;
6049        }
6050
6051        /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6052        if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6053                strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6054                j->caplist[j->caps].captype = codec;
6055                j->caplist[j->caps].cap = TS85;
6056                j->caplist[j->caps].handle = j->caps++;
6057        }
6058
6059        /* 8021 chips can do G728 */
6060        if (j->dsp.low == 0x21) {
6061                strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6062                j->caplist[j->caps].captype = codec;
6063                j->caplist[j->caps].cap = G728;
6064                j->caplist[j->caps].handle = j->caps++;
6065        }
6066
6067        /* 8021/8022 chips can do G729 if loaded */
6068        if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6069                strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6070                j->caplist[j->caps].captype = codec;
6071                j->caplist[j->caps].cap = G729;
6072                j->caplist[j->caps].handle = j->caps++;
6073        }
6074        if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6075                strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6076                j->caplist[j->caps].captype = codec;
6077                j->caplist[j->caps].cap = G729B;
6078                j->caplist[j->caps].handle = j->caps++;
6079        }
6080}
6081
6082static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6083{
6084        int cnt;
6085        int retval = 0;
6086        for (cnt = 0; cnt < j->caps; cnt++) {
6087                if (pcreq->captype == j->caplist[cnt].captype
6088                    && pcreq->cap == j->caplist[cnt].cap) {
6089                        retval = 1;
6090                        break;
6091                }
6092        }
6093        return retval;
6094}
6095
6096static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6097{
6098        IXJ_TONE ti;
6099        IXJ_FILTER jf;
6100        IXJ_FILTER_RAW jfr;
6101        void __user *argp = (void __user *)arg;
6102        struct inode *inode = file_p->f_path.dentry->d_inode;
6103        unsigned int minor = iminor(inode);
6104        unsigned int raise, mant;
6105        int board = NUM(inode);
6106
6107        IXJ *j = get_ixj(NUM(inode));
6108
6109        int retval = 0;
6110
6111        /*
6112         *    Set up locks to ensure that only one process is talking to the DSP at a time.
6113         *    This is necessary to keep the DSP from locking up.
6114         */
6115        while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6116                schedule_timeout_interruptible(1);
6117        if (ixjdebug & 0x0040)
6118                printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6119        if (minor >= IXJMAX) {
6120                clear_bit(board, &j->busyflags);
6121                return -ENODEV;
6122        }
6123        /*
6124         *    Check ioctls only root can use.
6125         */
6126        if (!capable(CAP_SYS_ADMIN)) {
6127                switch (cmd) {
6128                case IXJCTL_TESTRAM:
6129                case IXJCTL_HZ:
6130                        retval = -EPERM;
6131                }
6132        }
6133        switch (cmd) {
6134        case IXJCTL_TESTRAM:
6135                ixj_testram(j);
6136                retval = (j->ssr.high << 8) + j->ssr.low;
6137                break;
6138        case IXJCTL_CARDTYPE:
6139                retval = j->cardtype;
6140                break;
6141        case IXJCTL_SERIAL:
6142                retval = j->serial;
6143                break;
6144        case IXJCTL_VERSION:
6145                {
6146                        char arg_str[100];
6147                        snprintf(arg_str, sizeof(arg_str),
6148                                "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6149                                IXJ_VER_MINOR, IXJ_BLD_VER);
6150                        if (copy_to_user(argp, arg_str, strlen(arg_str)))
6151                                retval = -EFAULT;
6152                }
6153                break;
6154        case PHONE_RING_CADENCE:
6155                j->ring_cadence = arg;
6156                break;
6157        case IXJCTL_CIDCW:
6158                if(arg) {
6159                        if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6160                                retval = -EFAULT;
6161                                break;
6162                        }
6163                } else {
6164                        memset(&j->cid_send, 0, sizeof(PHONE_CID));
6165                }
6166                ixj_write_cidcw(j);
6167                break;
6168        /* Binary compatbility */
6169        case OLD_PHONE_RING_START:
6170                arg = 0;
6171                /* Fall through */
6172        case PHONE_RING_START:
6173                if(arg) {
6174                        if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6175                                retval = -EFAULT;
6176                                break;
6177                        }
6178                        ixj_write_cid(j);
6179                } else {
6180                        memset(&j->cid_send, 0, sizeof(PHONE_CID));
6181                }
6182                ixj_ring_start(j);
6183                break;
6184        case PHONE_RING_STOP:
6185                j->flags.cringing = 0;
6186                if(j->cadence_f[5].enable) {
6187                        j->cadence_f[5].state = 0;
6188                }
6189                ixj_ring_off(j);
6190                break;
6191        case PHONE_RING:
6192                retval = ixj_ring(j);
6193                break;
6194        case PHONE_EXCEPTION:
6195                retval = j->ex.bytes;
6196                if(j->ex.bits.flash) {
6197                        j->flash_end = 0;
6198                        j->ex.bits.flash = 0;
6199                }
6200                j->ex.bits.pstn_ring = 0;
6201                j->ex.bits.caller_id = 0;
6202                j->ex.bits.pstn_wink = 0;
6203                j->ex.bits.f0 = 0;
6204                j->ex.bits.f1 = 0;
6205                j->ex.bits.f2 = 0;
6206                j->ex.bits.f3 = 0;
6207                j->ex.bits.fc0 = 0;
6208                j->ex.bits.fc1 = 0;
6209                j->ex.bits.fc2 = 0;
6210                j->ex.bits.fc3 = 0;
6211                j->ex.bits.reserved = 0;
6212                break;
6213        case PHONE_HOOKSTATE:
6214                j->ex.bits.hookstate = 0;
6215                retval = j->hookstate;  //j->r_hook;
6216                break;
6217        case IXJCTL_SET_LED:
6218                LED_SetState(arg, j);
6219                break;
6220        case PHONE_FRAME:
6221                retval = set_base_frame(j, arg);
6222                break;
6223        case PHONE_REC_CODEC:
6224                retval = set_rec_codec(j, arg);
6225                break;
6226        case PHONE_VAD:
6227                ixj_vad(j, arg);
6228                break;
6229        case PHONE_REC_START:
6230                ixj_record_start(j);
6231                break;
6232        case PHONE_REC_STOP:
6233                ixj_record_stop(j);
6234                break;
6235        case PHONE_REC_DEPTH:
6236                set_rec_depth(j, arg);
6237                break;
6238        case PHONE_REC_VOLUME:
6239                if(arg == -1) {
6240                        retval = get_rec_volume(j);
6241                }
6242                else {
6243                        set_rec_volume(j, arg);
6244                        retval = arg;
6245                }
6246                break;
6247        case PHONE_REC_VOLUME_LINEAR:
6248                if(arg == -1) {
6249                        retval = get_rec_volume_linear(j);
6250                }
6251                else {
6252                        set_rec_volume_linear(j, arg);
6253                        retval = arg;
6254                }
6255                break;
6256        case IXJCTL_DTMF_PRESCALE:
6257                if(arg == -1) {
6258                        retval = get_dtmf_prescale(j);
6259                }
6260                else {
6261                        set_dtmf_prescale(j, arg);
6262                        retval = arg;
6263                }
6264                break;
6265        case PHONE_REC_LEVEL:
6266                retval = get_rec_level(j);
6267                break;
6268        case IXJCTL_SC_RXG:
6269                retval = ixj_siadc(j, arg);
6270                break;
6271        case IXJCTL_SC_TXG:
6272                retval = ixj_sidac(j, arg);
6273                break;
6274        case IXJCTL_AEC_START:
6275                ixj_aec_start(j, arg);
6276                break;
6277        case IXJCTL_AEC_STOP:
6278                aec_stop(j);
6279                break;
6280        case IXJCTL_AEC_GET_LEVEL:
6281                retval = j->aec_level;
6282                break;
6283        case PHONE_PLAY_CODEC:
6284                retval = set_play_codec(j, arg);
6285                break;
6286        case PHONE_PLAY_START:
6287                retval = ixj_play_start(j);
6288                break;
6289        case PHONE_PLAY_STOP:
6290                ixj_play_stop(j);
6291                break;
6292        case PHONE_PLAY_DEPTH:
6293                set_play_depth(j, arg);
6294                break;
6295        case PHONE_PLAY_VOLUME:
6296                if(arg == -1) {
6297                        retval = get_play_volume(j);
6298                }
6299                else {
6300                        set_play_volume(j, arg);
6301                        retval = arg;
6302                }
6303                break;
6304        case PHONE_PLAY_VOLUME_LINEAR:
6305                if(arg == -1) {
6306                        retval = get_play_volume_linear(j);
6307                }
6308                else {
6309                        set_play_volume_linear(j, arg);
6310                        retval = arg;
6311                }
6312                break;
6313        case PHONE_PLAY_LEVEL:
6314                retval = get_play_level(j);
6315                break;
6316        case IXJCTL_DSP_TYPE:
6317                retval = (j->dsp.high << 8) + j->dsp.low;
6318                break;
6319        case IXJCTL_DSP_VERSION:
6320                retval = (j->ver.high << 8) + j->ver.low;
6321                break;
6322        case IXJCTL_HZ:
6323                hertz = arg;
6324                break;
6325        case IXJCTL_RATE:
6326                if (arg > hertz)
6327                        retval = -1;
6328                else
6329                        samplerate = arg;
6330                break;
6331        case IXJCTL_DRYBUFFER_READ:
6332                put_user(j->drybuffer, (unsigned long __user *) argp);
6333                break;
6334        case IXJCTL_DRYBUFFER_CLEAR:
6335                j->drybuffer = 0;
6336                break;
6337        case IXJCTL_FRAMES_READ:
6338                put_user(j->framesread, (unsigned long __user *) argp);
6339                break;
6340        case IXJCTL_FRAMES_WRITTEN:
6341                put_user(j->frameswritten, (unsigned long __user *) argp);
6342                break;
6343        case IXJCTL_READ_WAIT:
6344                put_user(j->read_wait, (unsigned long __user *) argp);
6345                break;
6346        case IXJCTL_WRITE_WAIT:
6347                put_user(j->write_wait, (unsigned long __user *) argp);
6348                break;
6349        case PHONE_MAXRINGS:
6350                j->maxrings = arg;
6351                break;
6352        case PHONE_SET_TONE_ON_TIME:
6353                ixj_set_tone_on(arg, j);
6354                break;
6355        case PHONE_SET_TONE_OFF_TIME:
6356                ixj_set_tone_off(arg, j);
6357                break;
6358        case PHONE_GET_TONE_ON_TIME:
6359                if (ixj_get_tone_on(j)) {
6360                        retval = -1;
6361                } else {
6362                        retval = (j->ssr.high << 8) + j->ssr.low;
6363                }
6364                break;
6365        case PHONE_GET_TONE_OFF_TIME:
6366                if (ixj_get_tone_off(j)) {
6367                        retval = -1;
6368                } else {
6369                        retval = (j->ssr.high << 8) + j->ssr.low;
6370                }
6371                break;
6372        case PHONE_PLAY_TONE:
6373                if (!j->tone_state)
6374                        retval = ixj_play_tone(j, arg);
6375                else
6376                        retval = -1;
6377                break;
6378        case PHONE_GET_TONE_STATE:
6379                retval = j->tone_state;
6380                break;
6381        case PHONE_DTMF_READY:
6382                retval = j->ex.bits.dtmf_ready;
6383                break;
6384        case PHONE_GET_DTMF:
6385                if (ixj_hookstate(j)) {
6386                        if (j->dtmf_rp != j->dtmf_wp) {
6387                                retval = j->dtmfbuffer[j->dtmf_rp];
6388                                j->dtmf_rp++;
6389                                if (j->dtmf_rp == 79)
6390                                        j->dtmf_rp = 0;
6391                                if (j->dtmf_rp == j->dtmf_wp) {
6392                                        j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6393                                }
6394                        }
6395                }
6396                break;
6397        case PHONE_GET_DTMF_ASCII:
6398                if (ixj_hookstate(j)) {
6399                        if (j->dtmf_rp != j->dtmf_wp) {
6400                                switch (j->dtmfbuffer[j->dtmf_rp]) {
6401                                case 10:
6402                                        retval = 42;    /* '*'; */
6403
6404                                        break;
6405                                case 11:
6406                                        retval = 48;    /*'0'; */
6407
6408                                        break;
6409                                case 12:
6410                                        retval = 35;    /*'#'; */
6411
6412                                        break;
6413                                case 28:
6414                                        retval = 65;    /*'A'; */
6415
6416                                        break;
6417                                case 29:
6418                                        retval = 66;    /*'B'; */
6419
6420                                        break;
6421                                case 30:
6422                                        retval = 67;    /*'C'; */
6423
6424                                        break;
6425                                case 31:
6426                                        retval = 68;    /*'D'; */
6427
6428                                        break;
6429                                default:
6430                                        retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6431                                        break;
6432                                }
6433                                j->dtmf_rp++;
6434                                if (j->dtmf_rp == 79)
6435                                        j->dtmf_rp = 0;
6436                                if(j->dtmf_rp == j->dtmf_wp)
6437                                {
6438                                        j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6439                                }
6440                        }
6441                }
6442                break;
6443        case PHONE_DTMF_OOB:
6444                j->flags.dtmf_oob = arg;
6445                break;
6446        case PHONE_DIALTONE:
6447                ixj_dialtone(j);
6448                break;
6449        case PHONE_BUSY:
6450                ixj_busytone(j);
6451                break;
6452        case PHONE_RINGBACK:
6453                ixj_ringback(j);
6454                break;
6455        case PHONE_WINK:
6456                if(j->cardtype == QTI_PHONEJACK) 
6457                        retval = -1;
6458                else 
6459                        retval = ixj_wink(j);
6460                break;
6461        case PHONE_CPT_STOP:
6462                ixj_cpt_stop(j);
6463                break;
6464        case PHONE_QUERY_CODEC:
6465        {
6466                struct phone_codec_data pd;
6467                int val;
6468                int proto_size[] = {
6469                        -1,
6470                        12, 10, 16, 9, 8, 48, 5,
6471                        40, 40, 80, 40, 40, 6
6472                };
6473                if(copy_from_user(&pd, argp, sizeof(pd))) {
6474                        retval = -EFAULT;
6475                        break;
6476                }
6477                if(pd.type<1 || pd.type>13) {
6478                        retval = -EPROTONOSUPPORT;
6479                        break;
6480                }
6481                if(pd.type<G729)
6482                        val=proto_size[pd.type];
6483                else switch(j->baseframe.low)
6484                {
6485                        case 0xA0:val=2*proto_size[pd.type];break;
6486                        case 0x50:val=proto_size[pd.type];break;
6487                        default:val=proto_size[pd.type]*3;break;
6488                }
6489                pd.buf_min=pd.buf_max=pd.buf_opt=val;
6490                if(copy_to_user(argp, &pd, sizeof(pd)))
6491                        retval = -EFAULT;
6492                break;
6493        }
6494        case IXJCTL_DSP_IDLE:
6495                idle(j);
6496                break;
6497        case IXJCTL_MIXER:
6498                if ((arg & 0xff) == 0xff)
6499                        retval = ixj_get_mixer(arg, j);
6500                else
6501                        ixj_mixer(arg, j);
6502                break;
6503        case IXJCTL_DAA_COEFF_SET:
6504                switch (arg) {
6505                case DAA_US:
6506                        DAA_Coeff_US(j);
6507                        retval = ixj_daa_write(j);
6508                        break;
6509                case DAA_UK:
6510                        DAA_Coeff_UK(j);
6511                        retval = ixj_daa_write(j);
6512                        break;
6513                case DAA_FRANCE:
6514                        DAA_Coeff_France(j);
6515                        retval = ixj_daa_write(j);
6516                        break;
6517                case DAA_GERMANY:
6518                        DAA_Coeff_Germany(j);
6519                        retval = ixj_daa_write(j);
6520                        break;
6521                case DAA_AUSTRALIA:
6522                        DAA_Coeff_Australia(j);
6523                        retval = ixj_daa_write(j);
6524                        break;
6525                case DAA_JAPAN:
6526                        DAA_Coeff_Japan(j);
6527                        retval = ixj_daa_write(j);
6528                        break;
6529                default:
6530                        retval = 1;
6531                        break;
6532                }
6533                break;
6534        case IXJCTL_DAA_AGAIN:
6535                ixj_daa_cr4(j, arg | 0x02);
6536                break;
6537        case IXJCTL_PSTN_LINETEST:
6538                retval = ixj_linetest(j);
6539                break;
6540        case IXJCTL_VMWI:
6541                ixj_write_vmwi(j, arg);
6542                break;
6543        case IXJCTL_CID:
6544                if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID))) 
6545                        retval = -EFAULT;
6546                j->ex.bits.caller_id = 0;
6547                break;
6548        case IXJCTL_WINK_DURATION:
6549                j->winktime = arg;
6550                break;
6551        case IXJCTL_PORT:
6552                if (arg)
6553                        retval = ixj_set_port(j, arg);
6554                else
6555                        retval = j->port;
6556                break;
6557        case IXJCTL_POTS_PSTN:
6558                retval = ixj_set_pots(j, arg);
6559                break;
6560        case PHONE_CAPABILITIES:
6561                add_caps(j);
6562                retval = j->caps;
6563                break;
6564        case PHONE_CAPABILITIES_LIST:
6565                add_caps(j);
6566                if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps)) 
6567                        retval = -EFAULT;
6568                break;
6569        case PHONE_CAPABILITIES_CHECK:
6570                {
6571                        struct phone_capability cap;
6572                        if (copy_from_user(&cap, argp, sizeof(cap))) 
6573                                retval = -EFAULT;
6574                        else {
6575                                add_caps(j);
6576                                retval = capabilities_check(j, &cap);
6577                        }
6578                }
6579                break;
6580        case PHONE_PSTN_SET_STATE:
6581                daa_set_mode(j, arg);
6582                break;
6583        case PHONE_PSTN_GET_STATE:
6584                retval = j->daa_mode;
6585                j->ex.bits.pstn_ring = 0;
6586                break;
6587        case IXJCTL_SET_FILTER:
6588                if (copy_from_user(&jf, argp, sizeof(jf))) 
6589                        retval = -EFAULT;
6590                retval = ixj_init_filter(j, &jf);
6591                break;
6592        case IXJCTL_SET_FILTER_RAW:
6593                if (copy_from_user(&jfr, argp, sizeof(jfr))) 
6594                        retval = -EFAULT;
6595                else
6596                        retval = ixj_init_filter_raw(j, &jfr);
6597                break;
6598        case IXJCTL_GET_FILTER_HIST:
6599                if(arg<0||arg>3)
6600                        retval = -EINVAL;
6601                else
6602                        retval = j->filter_hist[arg];
6603                break;
6604        case IXJCTL_INIT_TONE:
6605                if (copy_from_user(&ti, argp, sizeof(ti)))
6606                        retval = -EFAULT;
6607                else
6608                        retval = ixj_init_tone(j, &ti);
6609                break;
6610        case IXJCTL_TONE_CADENCE:
6611                retval = ixj_build_cadence(j, argp);
6612                break;
6613        case IXJCTL_FILTER_CADENCE:
6614                retval = ixj_build_filter_cadence(j, argp);
6615                break;
6616        case IXJCTL_SIGCTL:
6617                if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6618                        retval = -EFAULT;
6619                        break;
6620                }
6621                j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6622                if(j->sigdef.event < 33) {
6623                        raise = 1;
6624                        for(mant = 0; mant < j->sigdef.event; mant++){
6625                                raise *= 2;
6626                        }
6627                        if(j->sigdef.signal)
6628                                j->ex_sig.bytes |= raise; 
6629                        else
6630                                j->ex_sig.bytes &= (raise^0xffff); 
6631                }
6632                break;
6633        case IXJCTL_INTERCOM_STOP:
6634                if(arg < 0 || arg >= IXJMAX)
6635                        return -EINVAL;
6636                j->intercom = -1;
6637                ixj_record_stop(j);
6638                ixj_play_stop(j);
6639                idle(j);
6640                get_ixj(arg)->intercom = -1;
6641                ixj_record_stop(get_ixj(arg));
6642                ixj_play_stop(get_ixj(arg));
6643                idle(get_ixj(arg));
6644                break;
6645        case IXJCTL_INTERCOM_START:
6646                if(arg < 0 || arg >= IXJMAX)
6647                        return -EINVAL;
6648                j->intercom = arg;
6649                ixj_record_start(j);
6650                ixj_play_start(j);
6651                get_ixj(arg)->intercom = board;
6652                ixj_play_start(get_ixj(arg));
6653                ixj_record_start(get_ixj(arg));
6654                break;
6655        }
6656        if (ixjdebug & 0x0040)
6657                printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6658        clear_bit(board, &j->busyflags);
6659        return retval;
6660}
6661
6662static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6663{
6664        long ret;
6665        lock_kernel();
6666        ret = do_ixj_ioctl(file_p, cmd, arg);
6667        unlock_kernel();
6668        return ret;
6669}
6670
6671static int ixj_fasync(int fd, struct file *file_p, int mode)
6672{
6673        IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6674
6675        return fasync_helper(fd, file_p, mode, &j->async_queue);
6676}
6677
6678static const struct file_operations ixj_fops =
6679{
6680        .owner          = THIS_MODULE,
6681        .read           = ixj_enhanced_read,
6682        .write          = ixj_enhanced_write,
6683        .poll           = ixj_poll,
6684        .unlocked_ioctl = ixj_ioctl,
6685        .release        = ixj_release,
6686        .fasync         = ixj_fasync
6687};
6688
6689static int ixj_linetest(IXJ *j)
6690{
6691        j->flags.pstncheck = 1; /* Testing */
6692        j->flags.pstn_present = 0; /* Assume the line is not there */
6693
6694        daa_int_read(j);        /*Clear DAA Interrupt flags */
6695        /* */
6696        /* Hold all relays in the normally de-energized position. */
6697        /* */
6698
6699        j->pld_slicw.bits.rly1 = 0;
6700        j->pld_slicw.bits.rly2 = 0;
6701        j->pld_slicw.bits.rly3 = 0;
6702        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6703        j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6704
6705        outb_p(j->pld_scrw.byte, j->XILINXbase);
6706        j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6707        if (j->pld_slicr.bits.potspstn) {
6708                j->flags.pots_pstn = 1;
6709                j->flags.pots_correct = 0;
6710                LED_SetState(0x4, j);
6711        } else {
6712                j->flags.pots_pstn = 0;
6713                j->pld_slicw.bits.rly1 = 0;
6714                j->pld_slicw.bits.rly2 = 0;
6715                j->pld_slicw.bits.rly3 = 1;
6716                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6717                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6718
6719                outb_p(j->pld_scrw.byte, j->XILINXbase);
6720                daa_set_mode(j, SOP_PU_CONVERSATION);
6721                msleep(1000);
6722                daa_int_read(j);
6723                daa_set_mode(j, SOP_PU_RESET);
6724                if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6725                        j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6726                        LED_SetState(0x4, j);
6727                        j->pld_slicw.bits.rly3 = 0;
6728                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6729                } else {
6730                        j->flags.pots_correct = 1;
6731                        LED_SetState(0x8, j);
6732                        j->pld_slicw.bits.rly1 = 1;
6733                        j->pld_slicw.bits.rly2 = 0;
6734                        j->pld_slicw.bits.rly3 = 0;
6735                        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6736                }
6737        }
6738        j->pld_slicw.bits.rly3 = 0;
6739        outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6740        daa_set_mode(j, SOP_PU_CONVERSATION);
6741        msleep(1000);
6742        daa_int_read(j);
6743        daa_set_mode(j, SOP_PU_RESET);
6744        if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6745                j->pstn_sleeptil = jiffies + (hertz / 4);
6746                j->flags.pstn_present = 1;
6747        } else {
6748                j->flags.pstn_present = 0;
6749        }
6750        if (j->flags.pstn_present) {
6751                if (j->flags.pots_correct) {
6752                        LED_SetState(0xA, j);
6753                } else {
6754                        LED_SetState(0x6, j);
6755                }
6756        } else {
6757                if (j->flags.pots_correct) {
6758                        LED_SetState(0x9, j);
6759                } else {
6760                        LED_SetState(0x5, j);
6761                }
6762        }
6763        j->flags.pstncheck = 0; /* Testing */
6764        return j->flags.pstn_present;
6765}
6766
6767static int ixj_selfprobe(IXJ *j)
6768{
6769        unsigned short cmd;
6770        int cnt;
6771        BYTES bytes;
6772
6773        init_waitqueue_head(&j->poll_q);
6774        init_waitqueue_head(&j->read_q);
6775        init_waitqueue_head(&j->write_q);
6776
6777        while(atomic_read(&j->DSPWrite) > 0)
6778                atomic_dec(&j->DSPWrite);
6779        if (ixjdebug & 0x0002)
6780                printk(KERN_INFO "Write IDLE to Software Control Register\n");
6781        ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6782
6783        if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6784                return -1;
6785/* The read values of the SSR should be 0x00 for the IDLE command */
6786        if (j->ssr.low || j->ssr.high)
6787                return -1;
6788        if (ixjdebug & 0x0002)
6789                printk(KERN_INFO "Get Device ID Code\n");
6790        if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6791                return -1;
6792        j->dsp.low = j->ssr.low;
6793        j->dsp.high = j->ssr.high;
6794        if (ixjdebug & 0x0002)
6795                printk(KERN_INFO "Get Device Version Code\n");
6796        if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6797                return -1;
6798        j->ver.low = j->ssr.low;
6799        j->ver.high = j->ssr.high;
6800        if (!j->cardtype) {
6801                if (j->dsp.low == 0x21) {
6802                        bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6803                        outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6804/* Test for Internet LineJACK or Internet PhoneJACK Lite */
6805                        bytes.low = inb_p(j->XILINXbase + 0x02);
6806                        if (bytes.low == bytes.high)    /*  Register is read only on */
6807                                /*  Internet PhoneJack Lite */
6808                         {
6809                                j->cardtype = QTI_PHONEJACK_LITE;
6810                                if (!request_region(j->XILINXbase, 4, "ixj control")) {
6811                                        printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6812                                        return -1;
6813                                }
6814                                j->pld_slicw.pcib.e1 = 1;
6815                                outb_p(j->pld_slicw.byte, j->XILINXbase);
6816                        } else {
6817                                j->cardtype = QTI_LINEJACK;
6818
6819                                if (!request_region(j->XILINXbase, 8, "ixj control")) {
6820                                        printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6821                                        return -1;
6822                                }
6823                        }
6824                } else if (j->dsp.low == 0x22) {
6825                        j->cardtype = QTI_PHONEJACK_PCI;
6826                        request_region(j->XILINXbase, 4, "ixj control");
6827                        j->pld_slicw.pcib.e1 = 1;
6828                        outb_p(j->pld_slicw.byte, j->XILINXbase);
6829                } else
6830                        j->cardtype = QTI_PHONEJACK;
6831        } else {
6832                switch (j->cardtype) {
6833                case QTI_PHONEJACK:
6834                        if (!j->dsp.low != 0x20) {
6835                                j->dsp.high = 0x80;
6836                                j->dsp.low = 0x20;
6837                                ixj_WriteDSPCommand(0x3800, j);
6838                                j->ver.low = j->ssr.low;
6839                                j->ver.high = j->ssr.high;
6840                        }
6841                        break;
6842                case QTI_LINEJACK:
6843                        if (!request_region(j->XILINXbase, 8, "ixj control")) {
6844                                printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6845                                return -1;
6846                        }
6847                        break;
6848                case QTI_PHONEJACK_LITE:
6849                case QTI_PHONEJACK_PCI:
6850                        if (!request_region(j->XILINXbase, 4, "ixj control")) {
6851                                printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6852                                return -1;
6853                        }
6854                        j->pld_slicw.pcib.e1 = 1;
6855                        outb_p(j->pld_slicw.byte, j->XILINXbase);
6856                        break;
6857                case QTI_PHONECARD:
6858                        break;
6859                }
6860        }
6861        if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6862                if (ixjdebug & 0x0002)
6863                        printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6864                if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6865                        return -1;
6866                if (ixjdebug & 0x0002)
6867                        printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6868                if (j->cardtype == QTI_PHONEJACK) {
6869                        cmd = 0x9FF2;
6870                } else {
6871                        cmd = 0x9FF5;
6872                }
6873                if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6874                        return -1;
6875        } else {
6876                if (set_base_frame(j, 30) != 30)
6877                        return -1;
6878                if (ixjdebug & 0x0002)
6879                        printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6880                if (j->cardtype == QTI_PHONECARD) {
6881                        if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6882                                return -1;
6883                }
6884                if (j->cardtype == QTI_LINEJACK) {
6885                        if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6886                                return -1;
6887                        if (ixjdebug & 0x0002)
6888                                printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6889                        j->pld_clock.byte = 0;
6890                        outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6891                }
6892        }
6893
6894        if (j->dsp.low == 0x20) {
6895                if (ixjdebug & 0x0002)
6896                        printk(KERN_INFO "Configure GPIO pins\n");
6897                j->gpio.bytes.high = 0x09;
6898/*  bytes.low = 0xEF;  0xF7 */
6899                j->gpio.bits.gpio1 = 1;
6900                j->gpio.bits.gpio2 = 1;
6901                j->gpio.bits.gpio3 = 0;
6902                j->gpio.bits.gpio4 = 1;
6903                j->gpio.bits.gpio5 = 1;
6904                j->gpio.bits.gpio6 = 1;
6905                j->gpio.bits.gpio7 = 1;
6906                ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6907                if (ixjdebug & 0x0002)
6908                        printk(KERN_INFO "Enable SLIC\n");
6909                j->gpio.bytes.high = 0x0B;
6910                j->gpio.bytes.low = 0x00;
6911                j->gpio.bits.gpio1 = 0;
6912                j->gpio.bits.gpio2 = 1;
6913                j->gpio.bits.gpio5 = 0;
6914                ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6915                j->port = PORT_POTS;
6916        } else {
6917                if (j->cardtype == QTI_LINEJACK) {
6918                        LED_SetState(0x1, j);
6919                        msleep(100);
6920                        LED_SetState(0x2, j);
6921                        msleep(100);
6922                        LED_SetState(0x4, j);
6923                        msleep(100);
6924                        LED_SetState(0x8, j);
6925                        msleep(100);
6926                        LED_SetState(0x0, j);
6927                        daa_get_version(j);
6928                        if (ixjdebug & 0x0002)
6929                                printk("Loading DAA Coefficients\n");
6930                        DAA_Coeff_US(j);
6931                        if (!ixj_daa_write(j)) {
6932                                printk("DAA write failed on board %d\n", j->board);
6933                                return -1;
6934                        }
6935                        if(!ixj_daa_cid_reset(j)) {
6936                                printk("DAA CID reset failed on board %d\n", j->board);
6937                                return -1;
6938                        }
6939                        j->flags.pots_correct = 0;
6940                        j->flags.pstn_present = 0;
6941                        ixj_linetest(j);
6942                        if (j->flags.pots_correct) {
6943                                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6944
6945                                outb_p(j->pld_scrw.byte, j->XILINXbase);
6946                                j->pld_slicw.bits.rly1 = 1;
6947                                j->pld_slicw.bits.spken = 1;
6948                                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6949                                SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6950/*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6951                                j->port = PORT_POTS;
6952                        }
6953                        ixj_set_port(j, PORT_PSTN);
6954                        ixj_set_pots(j, 1);
6955                        if (ixjdebug & 0x0002)
6956                                printk(KERN_INFO "Enable Mixer\n");
6957                        ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6958                        ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6959
6960                        ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6961                        ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6962
6963                        ixj_mixer(0x0480, j);   /*FM Left mute */
6964                        ixj_mixer(0x0580, j);   /*FM Right mute */
6965
6966                        ixj_mixer(0x0680, j);   /*CD Left mute */
6967                        ixj_mixer(0x0780, j);   /*CD Right mute */
6968
6969                        ixj_mixer(0x0880, j);   /*Line Left mute */
6970                        ixj_mixer(0x0980, j);   /*Line Right mute */
6971
6972                        ixj_mixer(0x0A80, j);   /*Aux left mute  */
6973                        ixj_mixer(0x0B80, j);   /*Aux right mute */
6974
6975                        ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6976                        ixj_mixer(0x0D80, j);   /*Mono2 mute */
6977
6978                        ixj_mixer(0x0E80, j);   /*Mic mute */
6979
6980                        ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6981
6982                        ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6983                        ixj_mixer(0x110C, j);
6984
6985
6986                        ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6987                        ixj_mixer(0x1401, j);
6988
6989                        ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6990                        ixj_mixer(0x1501, j);
6991
6992                        ixj_mixer(0x1700, j);   /*Clock select */
6993
6994                        ixj_mixer(0x1800, j);   /*ADC input from mixer */
6995
6996                        ixj_mixer(0x1901, j);   /*Mic gain 30db */
6997
6998                        if (ixjdebug & 0x0002)
6999                                printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7000                        j->cadence_f[4].state = 0;
7001                        j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7002                        j->cadence_f[4].off1 = 0;
7003                        j->cadence_f[4].on2 = 0;
7004                        j->cadence_f[4].off2 = 0;
7005                        j->cadence_f[4].on3 = 0;
7006                        j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7007                        j->pstn_last_rmr = jiffies;
7008
7009                } else {
7010                        if (j->cardtype == QTI_PHONECARD) {
7011                                ixj_WriteDSPCommand(0xCF07, j);
7012                                ixj_WriteDSPCommand(0x00B0, j);
7013                                ixj_set_port(j, PORT_SPEAKER);
7014                        } else {
7015                                ixj_set_port(j, PORT_POTS);
7016                                SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7017/*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7018                        }
7019                }
7020        }
7021
7022        j->intercom = -1;
7023        j->framesread = j->frameswritten = 0;
7024        j->read_wait = j->write_wait = 0;
7025        j->rxreadycheck = j->txreadycheck = 0;
7026
7027        /* initialise the DTMF prescale to a sensible value */
7028        if (j->cardtype == QTI_LINEJACK) {
7029                set_dtmf_prescale(j, 0x10); 
7030        } else {
7031                set_dtmf_prescale(j, 0x40); 
7032        }
7033        set_play_volume(j, 0x100);
7034        set_rec_volume(j, 0x100);
7035
7036        if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7037                return -1;
7038/* The read values of the SSR should be 0x00 for the IDLE command */
7039        if (j->ssr.low || j->ssr.high)
7040                return -1;
7041
7042        if (ixjdebug & 0x0002)
7043                printk(KERN_INFO "Enable Line Monitor\n");
7044
7045        if (ixjdebug & 0x0002)
7046                printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7047
7048        if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7049                return -1;
7050
7051        if (ixjdebug & 0x002)
7052                printk(KERN_INFO "Enable DTMF Detectors\n");
7053
7054        if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7055                return -1;
7056
7057        if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7058                return -1;
7059
7060        set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7061
7062        set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7063
7064        j->ex.bits.dtmf_ready = 0;
7065        j->dtmf_state = 0;
7066        j->dtmf_wp = j->dtmf_rp = 0;
7067        j->rec_mode = j->play_mode = -1;
7068        j->flags.ringing = 0;
7069        j->maxrings = MAXRINGS;
7070        j->ring_cadence = USA_RING_CADENCE;
7071        j->drybuffer = 0;
7072        j->winktime = 320;
7073        j->flags.dtmf_oob = 0;
7074        for (cnt = 0; cnt < 4; cnt++)
7075                j->cadence_f[cnt].enable = 0;
7076        /* must be a device on the specified address */
7077        ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7078
7079        /* Set up the default signals for events */
7080        for (cnt = 0; cnt < 35; cnt++)
7081                j->ixj_signals[cnt] = SIGIO;
7082
7083        /* Set the excetion signal enable flags */
7084        j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring = 
7085        j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 = 
7086        j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
7087#ifdef IXJ_DYN_ALLOC
7088        j->fskdata = NULL;
7089#endif
7090        j->fskdcnt = 0;
7091        j->cidcw_wait = 0;
7092 
7093        /* Register with the Telephony for Linux subsystem */
7094        j->p.f_op = &ixj_fops;
7095        j->p.open = ixj_open;
7096        j->p.board = j->board;
7097        phone_register_device(&j->p, PHONE_UNIT_ANY);
7098
7099        ixj_init_timer(j);
7100        ixj_add_timer(j);
7101        return 0;
7102}
7103
7104/*
7105 *      Exported service for pcmcia card handling
7106 */
7107 
7108IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7109{
7110        IXJ *j = ixj_alloc();
7111
7112        j->board = 0;
7113
7114        j->DSPbase = dsp;
7115        j->XILINXbase = xilinx;
7116        j->cardtype = QTI_PHONECARD;
7117        ixj_selfprobe(j);
7118        return j;
7119}
7120
7121EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7122
7123static int ixj_get_status_proc(char *buf)
7124{
7125        int len;
7126        int cnt;
7127        IXJ *j;
7128        len = 0;
7129        len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7130        len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7131        len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7132        len += sprintf(buf + len, "\nUsing old telephony API");
7133        len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7134
7135        for (cnt = 0; cnt < IXJMAX; cnt++) {
7136                j = get_ixj(cnt);
7137                if(j==NULL)
7138                        continue;
7139                if (j->DSPbase) {
7140                        len += sprintf(buf + len, "\nCard Num %d", cnt);
7141                        len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7142                        if (j->cardtype != QTI_PHONEJACK)
7143                                len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7144                        len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7145                        len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7146                        len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7147                        switch (j->cardtype) {
7148                        case (QTI_PHONEJACK):
7149                                len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7150                                break;
7151                        case (QTI_LINEJACK):
7152                                len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7153                                if (j->flags.g729_loaded)
7154                                        len += sprintf(buf + len, " w/G.729 A/B");
7155                                len += sprintf(buf + len, " Country = %d", j->daa_country);
7156                                break;
7157                        case (QTI_PHONEJACK_LITE):
7158                                len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7159                                if (j->flags.g729_loaded)
7160                                        len += sprintf(buf + len, " w/G.729 A/B");
7161                                break;
7162                        case (QTI_PHONEJACK_PCI):
7163                                len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7164                                if (j->flags.g729_loaded)
7165                                        len += sprintf(buf + len, " w/G.729 A/B");
7166                                break;
7167                        case (QTI_PHONECARD):
7168                                len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7169                                if (j->flags.g729_loaded)
7170                                        len += sprintf(buf + len, " w/G.729 A/B");
7171                                len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7172                                if (!j->pccr1.bits.drf)
7173                                        len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7174                                len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7175                                break;
7176                        default:
7177                                len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7178                                break;
7179                        }
7180                        len += sprintf(buf + len, "\nReaders %d", j->readers);
7181                        len += sprintf(buf + len, "\nWriters %d", j->writers);
7182                        add_caps(j);
7183                        len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7184                        if (j->dsp.low != 0x20)
7185                                len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7186                        if (j->flags.cidsent)
7187                                len += sprintf(buf + len, "\nCaller ID data sent");
7188                        else
7189                                len += sprintf(buf + len, "\nCaller ID data not sent");
7190
7191                        len += sprintf(buf + len, "\nPlay CODEC ");
7192                        switch (j->play_codec) {
7193                        case G723_63:
7194                                len += sprintf(buf + len, "G.723.1 6.3");
7195                                break;
7196                        case G723_53:
7197                                len += sprintf(buf + len, "G.723.1 5.3");
7198                                break;
7199                        case TS85:
7200                                len += sprintf(buf + len, "TrueSpeech 8.5");
7201                                break;
7202                        case TS48:
7203                                len += sprintf(buf + len, "TrueSpeech 4.8");
7204                                break;
7205                        case TS41:
7206                                len += sprintf(buf + len, "TrueSpeech 4.1");
7207                                break;
7208                        case G728:
7209                                len += sprintf(buf + len, "G.728");
7210                                break;
7211                        case G729:
7212                                len += sprintf(buf + len, "G.729");
7213                                break;
7214                        case G729B:
7215                                len += sprintf(buf + len, "G.729B");
7216                                break;
7217                        case ULAW:
7218                                len += sprintf(buf + len, "uLaw");
7219                                break;
7220                        case ALAW:
7221                                len += sprintf(buf + len, "aLaw");
7222                                break;
7223                        case LINEAR16:
7224                                len += sprintf(buf + len, "16 bit Linear");
7225                                break;
7226                        case LINEAR8:
7227                                len += sprintf(buf + len, "8 bit Linear");
7228                                break;
7229                        case WSS:
7230                                len += sprintf(buf + len, "Windows Sound System");
7231                                break;
7232                        default:
7233                                len += sprintf(buf + len, "NO CODEC CHOSEN");
7234                                break;
7235                        }
7236                        len += sprintf(buf + len, "\nRecord CODEC ");
7237                        switch (j->rec_codec) {
7238                        case G723_63:
7239                                len += sprintf(buf + len, "G.723.1 6.3");
7240                                break;
7241                        case G723_53:
7242                                len += sprintf(buf + len, "G.723.1 5.3");
7243                                break;
7244                        case TS85:
7245                                len += sprintf(buf + len, "TrueSpeech 8.5");
7246                                break;
7247                        case TS48:
7248                                len += sprintf(buf + len, "TrueSpeech 4.8");
7249                                break;
7250                        case TS41:
7251                                len += sprintf(buf + len, "TrueSpeech 4.1");
7252                                break;
7253                        case G728:
7254                                len += sprintf(buf + len, "G.728");
7255                                break;
7256                        case G729:
7257                                len += sprintf(buf + len, "G.729");
7258                                break;
7259                        case G729B:
7260                                len += sprintf(buf + len, "G.729B");
7261                                break;
7262                        case ULAW:
7263                                len += sprintf(buf + len, "uLaw");
7264                                break;
7265                        case ALAW:
7266                                len += sprintf(buf + len, "aLaw");
7267                                break;
7268                        case LINEAR16:
7269                                len += sprintf(buf + len, "16 bit Linear");
7270                                break;
7271                        case LINEAR8:
7272                                len += sprintf(buf + len, "8 bit Linear");
7273                                break;
7274                        case WSS:
7275                                len += sprintf(buf + len, "Windows Sound System");
7276                                break;
7277                        default:
7278                                len += sprintf(buf + len, "NO CODEC CHOSEN");
7279                                break;
7280                        }
7281                        len += sprintf(buf + len, "\nAEC ");
7282                        switch (j->aec_level) {
7283                        case AEC_OFF:
7284                                len += sprintf(buf + len, "Off");
7285                                break;
7286                        case AEC_LOW:
7287                                len += sprintf(buf + len, "Low");
7288                                break;
7289                        case AEC_MED:
7290                                len += sprintf(buf + len, "Med");
7291                                break;
7292                        case AEC_HIGH:
7293                                len += sprintf(buf + len, "High");
7294                                break;
7295                        case AEC_AUTO:
7296                                len += sprintf(buf + len, "Auto");
7297                                break;
7298                        case AEC_AGC:
7299                                len += sprintf(buf + len, "AEC/AGC");
7300                                break;
7301                        default:
7302                                len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7303                                break;
7304                        }
7305
7306                        len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7307                        len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7308                        len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7309                        
7310                        len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7311
7312                        if (j->cardtype == QTI_LINEJACK) {
7313                                len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7314                                len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7315                                len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7316                                len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7317                                switch (j->daa_mode) {
7318                                case SOP_PU_SLEEP:
7319                                        len += sprintf(buf + len, "\nDAA PSTN On Hook");
7320                                        break;
7321                                case SOP_PU_RINGING:
7322                                        len += sprintf(buf + len, "\nDAA PSTN Ringing");
7323                                        len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7324                                        break;
7325                                case SOP_PU_CONVERSATION:
7326                                        len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7327                                        break;
7328                                case SOP_PU_PULSEDIALING:
7329                                        len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7330                                        break;
7331                                }
7332                                len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7333                                len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7334                                len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7335                                len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7336                                len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7337                                len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7338                                len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7339                                len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7340                                len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7341                                len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7342                        }
7343                        switch (j->port) {
7344                        case PORT_POTS:
7345                                len += sprintf(buf + len, "\nPort POTS");
7346                                break;
7347                        case PORT_PSTN:
7348                                len += sprintf(buf + len, "\nPort PSTN");
7349                                break;
7350                        case PORT_SPEAKER:
7351                                len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7352                                break;
7353                        case PORT_HANDSET:
7354                                len += sprintf(buf + len, "\nPort HANDSET");
7355                                break;
7356                        }
7357                        if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7358                                len += sprintf(buf + len, "\nSLIC state ");
7359                                switch (SLIC_GetState(j)) {
7360                                case PLD_SLIC_STATE_OC:
7361                                        len += sprintf(buf + len, "OC");
7362                                        break;
7363                                case PLD_SLIC_STATE_RINGING:
7364                                        len += sprintf(buf + len, "RINGING");
7365                                        break;
7366                                case PLD_SLIC_STATE_ACTIVE:
7367                                        len += sprintf(buf + len, "ACTIVE");
7368                                        break;
7369                                case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7370                                        len += sprintf(buf + len, "OHT");
7371                                        break;
7372                                case PLD_SLIC_STATE_TIPOPEN:
7373                                        len += sprintf(buf + len, "TIPOPEN");
7374                                        break;
7375                                case PLD_SLIC_STATE_STANDBY:
7376                                        len += sprintf(buf + len, "STANDBY");
7377                                        break;
7378                                case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7379                                        len += sprintf(buf + len, "APR");
7380                                        break;
7381                                case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7382                                        len += sprintf(buf + len, "OHTPR");
7383                                        break;
7384                                default:
7385                                        len += sprintf(buf + len, "%d", SLIC_GetState(j));
7386                                        break;
7387                                }
7388                        }
7389                        len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7390                        len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7391#ifdef PERFMON_STATS
7392                        len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7393                        len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7394                        len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7395                        len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7396                        len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7397                        len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7398                        len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7399                        len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7400                        len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7401                        len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7402                        len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7403                        len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7404                        len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7405                        len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7406 
7407#endif
7408                        len += sprintf(buf + len, "\n");
7409                }
7410        }
7411        return len;
7412}
7413
7414static int ixj_read_proc(char *page, char **start, off_t off,
7415                              int count, int *eof, void *data)
7416{
7417        int len = ixj_get_status_proc(page);
7418        if (len <= off+count) *eof = 1;
7419        *start = page + off;
7420        len -= off;
7421        if (len>count) len = count;
7422        if (len<0) len = 0;
7423        return len;
7424}
7425
7426
7427static void cleanup(void)
7428{
7429        int cnt;
7430        IXJ *j;
7431
7432        for (cnt = 0; cnt < IXJMAX; cnt++) {
7433                j = get_ixj(cnt);
7434                if(j != NULL && j->DSPbase) {
7435                        if (ixjdebug & 0x0002)
7436                                printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7437                        del_timer(&j->timer);
7438                        if (j->cardtype == QTI_LINEJACK) {
7439                                j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7440
7441                                outb_p(j->pld_scrw.byte, j->XILINXbase);
7442                                j->pld_slicw.bits.rly1 = 0;
7443                                j->pld_slicw.bits.rly2 = 0;
7444                                j->pld_slicw.bits.rly3 = 0;
7445                                outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7446                                LED_SetState(0x0, j);
7447                                if (ixjdebug & 0x0002)
7448                                        printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7449                                release_region(j->XILINXbase, 8);
7450                        } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7451                                if (ixjdebug & 0x0002)
7452                                        printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7453                                release_region(j->XILINXbase, 4);
7454                        }
7455                        kfree(j->read_buffer);
7456                        kfree(j->write_buffer);
7457                        if (j->dev)
7458                                pnp_device_detach(j->dev);
7459                        if (ixjdebug & 0x0002)
7460                                printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7461                        phone_unregister_device(&j->p);
7462                        if (ixjdebug & 0x0002)
7463                                printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7464                        release_region(j->DSPbase, 16);
7465#ifdef IXJ_DYN_ALLOC
7466                        if (ixjdebug & 0x0002)
7467                                printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7468                        kfree(j);
7469                        ixj[cnt] = NULL;
7470#endif
7471                }
7472        }
7473        if (ixjdebug & 0x0002)
7474                printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7475        remove_proc_entry ("ixj", NULL);
7476}
7477
7478/* Typedefs */
7479typedef struct {
7480        BYTE length;
7481        DWORD bits;
7482} DATABLOCK;
7483
7484static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7485{
7486        lastLCC = lastLCC & 0xfb;
7487        lastLCC = lastLCC | (byData ? 4 : 0);
7488        outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7489
7490        mdelay(1);
7491        lastLCC = lastLCC | 0x01;
7492        outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7493
7494        byData = byData << 1;
7495        lastLCC = lastLCC & 0xfe;
7496        mdelay(1);
7497        outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7498
7499}
7500
7501static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7502{
7503        mdelay(1);
7504        lastLCC = lastLCC | 0x01;
7505        outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7506
7507        lastLCC = lastLCC & 0xfe;
7508        mdelay(1);
7509        outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7510
7511        return ((inb(wEEPROMAddress) >> 3) & 1);
7512}
7513
7514static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7515{
7516        BYTE lastLCC;
7517        WORD wEEPROMAddress = wAddress + 3;
7518        DWORD i;
7519        BYTE byResult;
7520        *pwResult = 0;
7521        lastLCC = inb(wEEPROMAddress);
7522        lastLCC = lastLCC | 0x02;
7523        lastLCC = lastLCC & 0xfe;
7524        outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7525
7526        mdelay(1);              /* delay */
7527
7528        PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7529        PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7530        PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7531        for (i = 0; i < 8; i++) {
7532                PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7533                wLoc <<= 1;
7534        }
7535
7536        for (i = 0; i < 16; i++) {
7537                byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7538                *pwResult = (*pwResult << 1) | byResult;
7539        }
7540
7541        mdelay(1);              /* another delay */
7542
7543        lastLCC = lastLCC & 0xfd;
7544        outb(lastLCC, wEEPROMAddress);  /* negate CS */
7545
7546        return 0;
7547}
7548
7549static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7550{
7551        WORD wLo, wHi;
7552        if (PCIEE_ReadWord(wAddress, 62, &wLo))
7553                return 0;
7554        if (PCIEE_ReadWord(wAddress, 63, &wHi))
7555                return 0;
7556        return (((DWORD) wHi << 16) | wLo);
7557}
7558
7559static int dspio[IXJMAX + 1] =
7560{
7561        0,
7562};
7563static int xio[IXJMAX + 1] =
7564{
7565        0,
7566};
7567
7568module_param_array(dspio, int, NULL, 0);
7569module_param_array(xio, int, NULL, 0);
7570MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7571MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7572MODULE_LICENSE("GPL");
7573
7574static void __exit ixj_exit(void)
7575{
7576        cleanup();
7577}
7578
7579static IXJ *new_ixj(unsigned long port)
7580{
7581        IXJ *res;
7582        if (!request_region(port, 16, "ixj DSP")) {
7583                printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7584                return NULL;
7585        }
7586        res = ixj_alloc();
7587        if (!res) {
7588                release_region(port, 16);
7589                printk(KERN_INFO "ixj: out of memory\n");
7590                return NULL;
7591        }
7592        res->DSPbase = port;
7593        return res;
7594}
7595
7596static int __init ixj_probe_isapnp(int *cnt)
7597{               
7598        int probe = 0;
7599        int func = 0x110;
7600        struct pnp_dev *dev = NULL, *old_dev = NULL;
7601
7602        while (1) {
7603                do {
7604                        IXJ *j;
7605                        int result;
7606
7607                        old_dev = dev;
7608                        dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7609                                         ISAPNP_FUNCTION(func), old_dev);
7610                        if (!dev || !dev->card)
7611                                break;
7612                        result = pnp_device_attach(dev);
7613                        if (result < 0) {
7614                                printk("pnp attach failed %d \n", result);
7615                                break;
7616                        }
7617                        if (pnp_activate_dev(dev) < 0) {
7618                                printk("pnp activate failed (out of resources?)\n");
7619                                pnp_device_detach(dev);
7620                                return -ENOMEM;
7621                        }
7622
7623                        if (!pnp_port_valid(dev, 0)) {
7624                                pnp_device_detach(dev);
7625                                return -ENODEV;
7626                        }
7627
7628                        j = new_ixj(pnp_port_start(dev, 0));
7629                        if (!j)
7630                                break;
7631
7632                        if (func != 0x110)
7633                                j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7634
7635                        switch (func) {
7636                        case (0x110):
7637                                j->cardtype = QTI_PHONEJACK;
7638                                break;
7639                        case (0x310):
7640                                j->cardtype = QTI_LINEJACK;
7641                                break;
7642                        case (0x410):
7643                                j->cardtype = QTI_PHONEJACK_LITE;
7644                                break;
7645                        }
7646                        j->board = *cnt;
7647                        probe = ixj_selfprobe(j);
7648                        if(!probe) {
7649                                j->serial = dev->card->serial;
7650                                j->dev = dev;
7651                                switch (func) {
7652                                case 0x110:
7653                                        printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7654                                        break;
7655                                case 0x310:
7656                                        printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7657                                        break;
7658                                case 0x410:
7659                                        printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7660                                        break;
7661                                }
7662                        }
7663                        ++*cnt;
7664                } while (dev);
7665                if (func == 0x410)
7666                        break;
7667                if (func == 0x310)
7668                        func = 0x410;
7669                if (func == 0x110)
7670                        func = 0x310;
7671                dev = NULL;
7672        }
7673        return probe;
7674}
7675                        
7676static int __init ixj_probe_isa(int *cnt)
7677{
7678        int i, probe;
7679
7680        /* Use passed parameters for older kernels without PnP */
7681        for (i = 0; i < IXJMAX; i++) {
7682                if (dspio[i]) {
7683                        IXJ *j = new_ixj(dspio[i]);
7684
7685                        if (!j)
7686                                break;
7687
7688                        j->XILINXbase = xio[i];
7689                        j->cardtype = 0;
7690
7691                        j->board = *cnt;
7692                        probe = ixj_selfprobe(j);
7693                        j->dev = NULL;
7694                        ++*cnt;
7695                }
7696        }
7697        return 0;
7698}
7699
7700static int __init ixj_probe_pci(int *cnt)
7701{
7702        struct pci_dev *pci = NULL;   
7703        int i, probe = 0;
7704        IXJ *j = NULL;
7705
7706        for (i = 0; i < IXJMAX - *cnt; i++) {
7707                pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7708                                      PCI_DEVICE_ID_QUICKNET_XJ, pci);
7709                if (!pci)
7710                        break;
7711
7712                if (pci_enable_device(pci))
7713                        break;
7714                j = new_ixj(pci_resource_start(pci, 0));
7715                if (!j)
7716                        break;
7717
7718                j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7719                j->XILINXbase = j->DSPbase + 0x10;
7720                j->cardtype = QTI_PHONEJACK_PCI;
7721                j->board = *cnt;
7722                probe = ixj_selfprobe(j);
7723                if (!probe)
7724                        printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7725                ++*cnt;
7726        }
7727        pci_dev_put(pci);
7728        return probe;
7729}
7730
7731static int __init ixj_init(void)
7732{
7733        int cnt = 0;
7734        int probe = 0;   
7735
7736        cnt = 0;
7737
7738        /* These might be no-ops, see above. */
7739        if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7740                return probe;
7741        }
7742        if ((probe = ixj_probe_isa(&cnt)) < 0) {
7743                return probe;
7744        }
7745        if ((probe = ixj_probe_pci(&cnt)) < 0) {
7746                return probe;
7747        }
7748        printk(KERN_INFO "ixj driver initialized.\n");
7749        create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7750        return probe;
7751}
7752
7753module_init(ixj_init);
7754module_exit(ixj_exit);
7755
7756static void DAA_Coeff_US(IXJ *j)
7757{
7758        int i;
7759
7760        j->daa_country = DAA_US;
7761        /*----------------------------------------------- */
7762        /* CAO */
7763        for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7764                j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7765        }
7766
7767/* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7768        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7769        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7770        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7771        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7772        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7773        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7774        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7775        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7776/* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7777        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7778        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7779        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7780        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7781        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7782        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7783        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7784        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7785/* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7786        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7787        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7788        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7789        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7790        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7791        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7792        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7793        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7794/* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7795        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7796        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7797        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7798        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7799        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7800        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7801        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7802        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7803/* Bytes for AX-filter        (0A): 16,55,DD,CA */
7804        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7805        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7806        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7807        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7808/* Bytes for AR-filter        (09): 52,D3,11,42 */
7809        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7810        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7811        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7812        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7813/* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7814        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7815        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7816        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7817        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7818        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7819        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7820        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7821        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7822/* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7823        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7824        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7825        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7826        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7827        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7828        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7829        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7830        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7831/* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7832        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7833        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7834        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7835        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7836        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7837        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7838        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7839        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7840/* ;  (10K, 0.68uF) */
7841        /*  */
7842        /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7843        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7844        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7845        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7846        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7847        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7848        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7849        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7850        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7851        /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7852        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7853        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7854        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7855        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7856        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7857        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7858        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7859        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7860
7861        /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7862        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7863        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7864        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7865        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7866
7867        /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7868/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7869/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7870/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7871/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7872/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7873/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7874/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7875/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7876        /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */ 
7877/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7878/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7879/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7880/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7881/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7882/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7883/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7884/*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7885/* */
7886        /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7887/*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7888/*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7889/*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7890/*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7891
7892        /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7893        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7894        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7895        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7896        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7897        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7898        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7899        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7900        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7901/* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7902        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7903        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7904        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7905        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7906        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7907        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7908        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7909        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7910/*  */
7911        /* ;CR Registers */
7912        /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7913        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7914/* Config. Reg. 1 (dialing)       (cr1):05 */
7915        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7916/* Config. Reg. 2 (caller ID)     (cr2):04 */
7917        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7918/* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7919        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7920/* Config. Reg. 4 (analog gain)   (cr4):02 */
7921        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7922        /* Config. Reg. 5 (Version)       (cr5):02 */
7923        /* Config. Reg. 6 (Reserved)      (cr6):00 */
7924        /* Config. Reg. 7 (Reserved)      (cr7):00 */
7925        /*  */
7926        /* ;xr Registers */
7927        /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7928
7929        j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7930        /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7931
7932        j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7933/* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7934        j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7935/* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7936        j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7937        /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7938
7939        j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7940/* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7941        j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7942/* Ext. Reg. 6 (Power State)      (xr6):00 */
7943        j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7944/* Ext. Reg. 7 (Vdd)              (xr7):40 */
7945        j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7946        /*  */
7947        /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7948        /*                                       12,33,5A,C3 ;  770 Hz   */
7949        /*                                       13,3C,5B,32 ;  852 Hz   */
7950        /*                                       1D,1B,5C,CC ;  941 Hz   */
7951
7952        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7953        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7954        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7955        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7956/* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7957        /*                                       EC,1D,52,22 ;  1336 Hz   */
7958        /*                                       AA,AC,51,D2 ;  1477 Hz   */
7959        /*                                       9B,3B,51,25 ;  1633 Hz   */
7960        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7961        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7962        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7963        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7964}
7965
7966static void DAA_Coeff_UK(IXJ *j)
7967{
7968        int i;
7969
7970        j->daa_country = DAA_UK;
7971        /*----------------------------------------------- */
7972        /* CAO */
7973        for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7974                j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7975        }
7976
7977/*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7978        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7979        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7980        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7981        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7982        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7983        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7984        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7985        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7986/* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7987        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7988        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7989        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7990        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7991        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7992        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7993        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7994        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7995/* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7996        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7997        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7998        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7999        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8000        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8001        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8002        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8003        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8004/* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8005        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8006        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8007        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8008        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8009        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8010        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8011        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8012        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8013/* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8014        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8015        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8016        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8017        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8018/* Bytes for AR-filter        (09): E2,27,10,D6 */
8019        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8020        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8021        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8022        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8023/* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8024        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8025        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8026        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8027        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8028        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8029        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8030        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8031        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8032/* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8033        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8034        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8035        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8036        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8037        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8038        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8039        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8040        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8041/* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8042        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8043        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8044        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8045        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8046        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8047        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8048        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8049        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8050/* ; idle */
8051        /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8052        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8053        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8054        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8055        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8056        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8057        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8058        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8059        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8060/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8061        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8062        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8063        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8064        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8065        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8066        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8067        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8068        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8069/* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8070        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8071        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8072        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8073        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8074/* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8075        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8076        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8077        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8078        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8079        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8080        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8081        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8082        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8083/* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8084        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8085        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8086        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8087        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8088        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8089        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8090        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8091        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8092/* ;CR Registers */
8093        /* Config. Reg. 0 (filters)        (cr0):FF */
8094        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8095/* Config. Reg. 1 (dialing)        (cr1):05 */
8096        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8097/* Config. Reg. 2 (caller ID)      (cr2):04 */
8098        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8099/* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8100        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8101/* Config. Reg. 4 (analog gain)    (cr4):02 */
8102        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8103        /* Config. Reg. 5 (Version)        (cr5):02 */
8104        /* Config. Reg. 6 (Reserved)       (cr6):00 */
8105        /* Config. Reg. 7 (Reserved)       (cr7):00 */
8106        /* ;xr Registers */
8107        /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8108
8109        j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8110        /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8111
8112        j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8113        /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8114
8115        j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8116/* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8117        j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8118/* Ext. Reg. 4 (Cadence)           (xr4):00 */
8119        j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8120/* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8121        j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8122/* Ext. Reg. 6 (Power State)       (xr6):00 */
8123        j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8124/* Ext. Reg. 7 (Vdd)               (xr7):46 */
8125        j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8126        /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8127        /*                                       12,33,5A,C3    ;  770 Hz   */
8128        /*                                       13,3C,5B,32    ;  852 Hz   */
8129        /*                                       1D,1B,5C,CC    ;  941 Hz   */
8130
8131        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8132        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8133        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8134        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8135/* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8136        /*                                       EC,1D,52,22    ;  1336 Hz   */
8137        /*                                       AA,AC,51,D2    ;  1477 Hz   */
8138        /*                                       9B,3B,51,25    ;  1633 Hz   */
8139        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8140        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8141        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8142        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8143}
8144
8145
8146static void DAA_Coeff_France(IXJ *j)
8147{
8148        int i;
8149
8150        j->daa_country = DAA_FRANCE;
8151        /*----------------------------------------------- */
8152        /* CAO */
8153        for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8154                j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8155        }
8156
8157/* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8158        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8159        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8160        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8161        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8162        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8163        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8164        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8165        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8166/* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8167        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8168        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8169        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8170        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8171        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8172        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8173        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8174        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8175/* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8176        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8177        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8178        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8179        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8180        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8181        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8182        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8183        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8184/* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8185        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8186        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8187        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8188        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8189        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8190        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8191        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8192        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8193/* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8194        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8195        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8196        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8197        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8198/* Bytes for AR-filter        (09): 52,C7,10,D6 */
8199        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8200        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8201        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8202        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8203/* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8204        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8205        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8206        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8207        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8208        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8209        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8210        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8211        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8212/* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8213        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8214        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8215        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8216        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8217        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8218        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8219        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8220        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8221/* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8222        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8223        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8224        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8225        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8226        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8227        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8228        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8229        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8230/* ; idle */
8231        /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8232        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8233        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8234        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8235        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8236        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8237        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8238        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8239        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8240/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8241        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8242        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8243        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8244        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8245        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8246        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8247        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8248        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8249/* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8250        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8251        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8252        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8253        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8254/* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8255        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8256        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8257        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8258        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8259        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8260        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8261        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8262        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8263/* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8264        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8265        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8266        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8267        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8268        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8269        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8270        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8271        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8272/* ;CR Registers */
8273        /* Config. Reg. 0 (filters)        (cr0):FF */
8274        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8275/* Config. Reg. 1 (dialing)        (cr1):05 */
8276        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8277/* Config. Reg. 2 (caller ID)      (cr2):04 */
8278        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8279/* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8280        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8281/* Config. Reg. 4 (analog gain)    (cr4):02 */
8282        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8283        /* Config. Reg. 5 (Version)        (cr5):02 */
8284        /* Config. Reg. 6 (Reserved)       (cr6):00 */
8285        /* Config. Reg. 7 (Reserved)       (cr7):00 */
8286        /* ;xr Registers */
8287        /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8288
8289        j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8290        /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8291
8292        j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8293        /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8294
8295        j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8296/* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8297        j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8298/* Ext. Reg. 4 (Cadence)           (xr4):00 */
8299        j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8300/* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8301        j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8302/* Ext. Reg. 6 (Power State)       (xr6):00 */
8303        j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8304/* Ext. Reg. 7 (Vdd)               (xr7):46 */
8305        j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8306        /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8307        /*                                       12,33,5A,C3    ;  770 Hz   */
8308        /*                                       13,3C,5B,32    ;  852 Hz   */
8309        /*                                       1D,1B,5C,CC    ;  941 Hz   */
8310
8311        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8312        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8313        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8314        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8315/* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8316        /*                                       EC,1D,52,22    ;  1336 Hz   */
8317        /*                                       AA,AC,51,D2    ;  1477 Hz   */
8318        /*                                       9B,3B,51,25    ;  1633 Hz   */
8319        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8320        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8321        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8322        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8323}
8324
8325
8326static void DAA_Coeff_Germany(IXJ *j)
8327{
8328        int i;
8329
8330        j->daa_country = DAA_GERMANY;
8331        /*----------------------------------------------- */
8332        /* CAO */
8333        for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8334                j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8335        }
8336
8337/* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8338        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8339        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8340        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8341        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8342        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8343        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8344        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8345        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8346/* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8347        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8348        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8349        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8350        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8351        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8352        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8353        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8354        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8355/* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8356        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8357        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8358        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8359        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8360        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8361        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8362        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8363        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8364/* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8365        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8366        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8367        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8368        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8369        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8370        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8371        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8372        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8373/* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8374        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8375        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8376        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8377        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8378/* Bytes for AR-filter        (09): 72,42,13,4B */
8379        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8380        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8381        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8382        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8383/* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8384        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8385        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8386        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8387        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8388        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8389        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8390        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8391        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8392/* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8393        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8394        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8395        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8396        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8397        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8398        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8399        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8400        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8401/* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8402        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8403        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8404        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8405        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8406        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8407        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8408        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8409        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8410/* ;  (10K, 0.68uF) */
8411        /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8412        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8413        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8414        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8415        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8416        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8417        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8418        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8419        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8420/* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8421        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8422        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8423        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8424        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8425        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8426        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8427        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8428        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8429/* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8430        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8431        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8432        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8433        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8434/* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8435        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8436        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8437        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8438        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8439        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8440        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8441        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8442        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8443/* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8444        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8445        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8446        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8447        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8448        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8449        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8450        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8451        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8452/* ;CR Registers */
8453        /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8454        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8455/* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8456        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8457/* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8458        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8459/* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8460        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8461/* Config. Reg. 4 (analog gain)    (cr4):02 */
8462        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8463        /* Config. Reg. 5 (Version)        (cr5):02 */
8464        /* Config. Reg. 6 (Reserved)       (cr6):00 */
8465        /* Config. Reg. 7 (Reserved)       (cr7):00 */
8466        /* ;xr Registers */
8467        /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8468
8469        j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8470        /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8471
8472        j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8473        /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8474
8475        j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8476/* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8477        j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8478/* Ext. Reg. 4 (Cadence)           (xr4):00 */
8479        j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8480/* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8481        j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8482/* Ext. Reg. 6 (Power State)       (xr6):00 */
8483        j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8484/* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8485        j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8486        /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8487        /*                                       12,33,5A,C3    ;  770 Hz   */
8488        /*                                       13,3C,5B,32    ;  852 Hz   */
8489        /*                                       1D,1B,5C,CC    ;  941 Hz   */
8490
8491        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8492        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8493        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8494        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8495/* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8496        /*                                       EC,1D,52,22    ;  1336 Hz   */
8497        /*                                       AA,AC,51,D2    ;  1477 Hz   */
8498        /*                                       9B,3B,51,25    ;  1633 Hz   */
8499        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8500        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8501        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8502        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8503}
8504
8505
8506static void DAA_Coeff_Australia(IXJ *j)
8507{
8508        int i;
8509
8510        j->daa_country = DAA_AUSTRALIA;
8511        /*----------------------------------------------- */
8512        /* CAO */
8513        for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8514                j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8515        }
8516
8517/* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8518        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8519        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8520        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8521        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8522        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8523        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8524        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8525        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8526/* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8527        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8528        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8529        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8530        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8531        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8532        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8533        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8534        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8535/* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8536        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8537        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8538        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8539        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8540        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8541        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8542        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8543        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8544/* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8545        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8546        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8547        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8548        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8549        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8550        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8551        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8552        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8553/* Bytes for AX-filter        (0A): CB,45,DD,CA */
8554        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8555        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8556        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8557        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8558/* Bytes for AR-filter        (09): 1B,67,10,D6 */
8559        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8560        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8561        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8562        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8563/* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8564        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8565        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8566        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8567        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8568        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8569        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8570        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8571        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8572/* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8573        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8574        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8575        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8576        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8577        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8578        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8579        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8580        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8581/* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8582        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8583        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8584        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8585        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8586        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8587        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8588        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8589        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8590/* ;  idle */
8591        /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8592        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8593        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8594        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8595        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8596        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8597        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8598        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8599        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8600/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8601        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8602        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8603        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8604        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8605        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8606        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8607        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8608        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8609/* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8610        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8611        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8612        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8613        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8614/* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8615        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8616        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8617        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8618        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8619        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8620        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8621        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8622        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8623/* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8624        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8625        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8626        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8627        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8628        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8629        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8630        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8631        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8632/* ;CR Registers */
8633        /* Config. Reg. 0 (filters)        (cr0):FF */
8634        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8635/* Config. Reg. 1 (dialing)        (cr1):05 */
8636        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8637/* Config. Reg. 2 (caller ID)      (cr2):04 */
8638        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8639/* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8640        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8641/* Config. Reg. 4 (analog gain)    (cr4):02 */
8642        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8643        /* Config. Reg. 5 (Version)        (cr5):02 */
8644        /* Config. Reg. 6 (Reserved)       (cr6):00 */
8645        /* Config. Reg. 7 (Reserved)       (cr7):00 */
8646        /* ;xr Registers */
8647        /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8648
8649        j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8650        /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8651
8652        j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8653        /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8654
8655        j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8656/* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8657        j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8658/* Ext. Reg. 4 (Cadence)           (xr4):00 */
8659        j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8660/* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8661        j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8662/* Ext. Reg. 6 (Power State)       (xr6):00 */
8663        j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8664/* Ext. Reg. 7 (Vdd)               (xr7):40 */
8665        j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8666
8667        /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8668        /*                                       12,33,5A,C3    ;  770 Hz   */
8669        /*                                       13,3C,5B,32    ;  852 Hz   */
8670        /*                                       1D,1B,5C,CC    ;  941 Hz   */
8671        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8672        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8673        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8674        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8675
8676        /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8677        /*                                       EC,1D,52,22    ;  1336 Hz   */
8678        /*                                       AA,AC,51,D2    ;  1477 Hz   */
8679        /*                                       9B,3B,51,25    ;  1633 Hz   */
8680        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8681        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8682        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8683        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8684}
8685
8686static void DAA_Coeff_Japan(IXJ *j)
8687{
8688        int i;
8689
8690        j->daa_country = DAA_JAPAN;
8691        /*----------------------------------------------- */
8692        /* CAO */
8693        for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8694                j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8695        }
8696
8697/* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8698        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8699        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8700        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8701        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8702        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8703        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8704        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8705        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8706/* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8707        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8708        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8709        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8710        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8711        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8712        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8713        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8714        j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8715/* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8716        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8717        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8718        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8719        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8720        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8721        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8722        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8723        j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8724/* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8725        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8726        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8727        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8728        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8729        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8730        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8731        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8732        j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8733/* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8734        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8735        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8736        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8737        j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8738/* Bytes for AR-filter        (09): 25,A7,10,D6 */
8739        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8740        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8741        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8742        j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8743/* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8744        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8745        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8746        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8747        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8748        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8749        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8750        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8751        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8752/* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8753        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8754        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8755        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8756        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8757        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8758        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8759        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8760        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8761/* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8762        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8763        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8764        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8765        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8766        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8767        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8768        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8769        j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8770/* ;  idle */
8771        /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8772        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8773        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8774        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8775        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8776        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8777        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8778        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8779        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8780/* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8781        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8782        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8783        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8784        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8785        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8786        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8787        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8788        j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8789/* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8790        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8791        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8792        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8793        j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8794/* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8795        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8796        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8797        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8798        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8799        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8800        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8801        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8802        j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8803/* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8804        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8805        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8806        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8807        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8808        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8809        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8810        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8811        j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8812/* ;CR Registers */
8813        /* Config. Reg. 0 (filters)        (cr0):FF */
8814        j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8815/* Config. Reg. 1 (dialing)        (cr1):05 */
8816        j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8817/* Config. Reg. 2 (caller ID)      (cr2):04 */
8818        j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8819/* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8820        j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8821/* Config. Reg. 4 (analog gain)    (cr4):02 */
8822        j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8823        /* Config. Reg. 5 (Version)        (cr5):02 */
8824        /* Config. Reg. 6 (Reserved)       (cr6):00 */
8825        /* Config. Reg. 7 (Reserved)       (cr7):00 */
8826        /* ;xr Registers */
8827        /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8828
8829        j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8830        /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8831
8832        j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8833        /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8834
8835        j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8836/* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8837        j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8838/* Ext. Reg. 4 (Cadence)           (xr4):00 */
8839        j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8840/* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8841        j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8842/* Ext. Reg. 6 (Power State)       (xr6):00 */
8843        j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8844/* Ext. Reg. 7 (Vdd)               (xr7):40 */
8845        j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8846        /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8847        /*                                       12,33,5A,C3    ;  770 Hz   */
8848        /*                                       13,3C,5B,32    ;  852 Hz   */
8849        /*                                       1D,1B,5C,CC    ;  941 Hz   */
8850
8851        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8852        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8853        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8854        j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8855/* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8856        /*                                       EC,1D,52,22    ;  1336 Hz   */
8857        /*                                       AA,AC,51,D2    ;  1477 Hz   */
8858        /*                                       9B,3B,51,25    ;  1633 Hz   */
8859        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8860        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8861        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8862        j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8863}
8864
8865static s16 tone_table[][19] =
8866{
8867        {                       /* f20_50[] 11 */
8868                32538,          /* A1 = 1.985962 */
8869                 -32325,        /* A2 = -0.986511 */
8870                 -343,          /* B2 = -0.010493 */
8871                 0,             /* B1 = 0 */
8872                 343,           /* B0 = 0.010493 */
8873                 32619,         /* A1 = 1.990906 */
8874                 -32520,        /* A2 = -0.992462 */
8875                 19179,         /* B2 = 0.585327 */
8876                 -19178,        /* B1 = -1.170593 */
8877                 19179,         /* B0 = 0.585327 */
8878                 32723,         /* A1 = 1.997314 */
8879                 -32686,        /* A2 = -0.997528 */
8880                 9973,          /* B2 = 0.304352 */
8881                 -9955,         /* B1 = -0.607605 */
8882                 9973,          /* B0 = 0.304352 */
8883                 7,             /* Internal filter scaling */
8884                 159,           /* Minimum in-band energy threshold */
8885                 21,            /* 21/32 in-band to broad-band ratio */
8886                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8887        },
8888        {                       /* f133_200[] 12 */
8889                32072,          /* A1 = 1.95752 */
8890                 -31896,        /* A2 = -0.973419 */
8891                 -435,          /* B2 = -0.013294 */
8892                 0,             /* B1 = 0 */
8893                 435,           /* B0 = 0.013294 */
8894                 32188,         /* A1 = 1.9646 */
8895                 -32400,        /* A2 = -0.98877 */
8896                 15139,         /* B2 = 0.462036 */
8897                 -14882,        /* B1 = -0.908356 */
8898                 15139,         /* B0 = 0.462036 */
8899                 32473,         /* A1 = 1.981995 */
8900                 -32524,        /* A2 = -0.992584 */
8901                 23200,         /* B2 = 0.708008 */
8902                 -23113,        /* B1 = -1.410706 */
8903                 23200,         /* B0 = 0.708008 */
8904                 7,             /* Internal filter scaling */
8905                 159,           /* Minimum in-band energy threshold */
8906                 21,            /* 21/32 in-band to broad-band ratio */
8907                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8908        },
8909        {                       /* f300 13 */
8910                31769,          /* A1 = -1.939026 */
8911                 -32584,        /* A2 = 0.994385 */
8912                 -475,          /* B2 = -0.014522 */
8913                 0,             /* B1 = 0.000000 */
8914                 475,           /* B0 = 0.014522 */
8915                 31789,         /* A1 = -1.940247 */
8916                 -32679,        /* A2 = 0.997284 */
8917                 17280,         /* B2 = 0.527344 */
8918                 -16865,        /* B1 = -1.029358 */
8919                 17280,         /* B0 = 0.527344 */
8920                 31841,         /* A1 = -1.943481 */
8921                 -32681,        /* A2 = 0.997345 */
8922                 543,           /* B2 = 0.016579 */
8923                 -525,          /* B1 = -0.032097 */
8924                 543,           /* B0 = 0.016579 */
8925                 5,             /* Internal filter scaling */
8926                 159,           /* Minimum in-band energy threshold */
8927                 21,            /* 21/32 in-band to broad-band ratio */
8928                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8929        },
8930        {                       /* f300_420[] 14 */
8931                30750,          /* A1 = 1.876892 */
8932                 -31212,        /* A2 = -0.952515 */
8933                 -804,          /* B2 = -0.024541 */
8934                 0,             /* B1 = 0 */
8935                 804,           /* B0 = 0.024541 */
8936                 30686,         /* A1 = 1.872925 */
8937                 -32145,        /* A2 = -0.980988 */
8938                 14747,         /* B2 = 0.450043 */
8939                 -13703,        /* B1 = -0.836395 */
8940                 14747,         /* B0 = 0.450043 */
8941                 31651,         /* A1 = 1.931824 */
8942                 -32321,        /* A2 = -0.986389 */
8943                 24425,         /* B2 = 0.745422 */
8944                 -23914,        /* B1 = -1.459595 */
8945                 24427,         /* B0 = 0.745483 */
8946                 7,             /* Internal filter scaling */
8947                 159,           /* Minimum in-band energy threshold */
8948                 21,            /* 21/32 in-band to broad-band ratio */
8949                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8950        },
8951        {                       /* f330 15 */
8952                31613,          /* A1 = -1.929565 */
8953                 -32646,        /* A2 = 0.996277 */
8954                 -185,          /* B2 = -0.005657 */
8955                 0,             /* B1 = 0.000000 */
8956                 185,           /* B0 = 0.005657 */
8957                 31620,         /* A1 = -1.929932 */
8958                 -32713,        /* A2 = 0.998352 */
8959                 19253,         /* B2 = 0.587585 */
8960                 -18566,        /* B1 = -1.133179 */
8961                 19253,         /* B0 = 0.587585 */
8962                 31674,         /* A1 = -1.933228 */
8963                 -32715,        /* A2 = 0.998413 */
8964                 2575,          /* B2 = 0.078590 */
8965                 -2495,         /* B1 = -0.152283 */
8966                 2575,          /* B0 = 0.078590 */
8967                 5,             /* Internal filter scaling */
8968                 159,           /* Minimum in-band energy threshold */
8969                 21,            /* 21/32 in-band to broad-band ratio */
8970                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8971        },
8972        {                       /* f300_425[] 16 */
8973                30741,          /* A1 = 1.876282 */
8974                 -31475,        /* A2 = -0.960541 */
8975                 -703,          /* B2 = -0.021484 */
8976                 0,             /* B1 = 0 */
8977                 703,           /* B0 = 0.021484 */
8978                 30688,         /* A1 = 1.873047 */
8979                 -32248,        /* A2 = -0.984161 */
8980                 14542,         /* B2 = 0.443787 */
8981                 -13523,        /* B1 = -0.825439 */
8982                 14542,         /* B0 = 0.443817 */
8983                 31494,         /* A1 = 1.922302 */
8984                 -32366,        /* A2 = -0.987762 */
8985                 21577,         /* B2 = 0.658508 */
8986                 -21013,        /* B1 = -1.282532 */
8987                 21577,         /* B0 = 0.658508 */
8988                 7,             /* Internal filter scaling */
8989                 159,           /* Minimum in-band energy threshold */
8990                 21,            /* 21/32 in-band to broad-band ratio */
8991                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8992        },
8993        {                       /* f330_440[] 17 */
8994                30627,          /* A1 = 1.869324 */
8995                 -31338,        /* A2 = -0.95636 */
8996                 -843,          /* B2 = -0.025749 */
8997                 0,             /* B1 = 0 */
8998                 843,           /* B0 = 0.025749 */
8999                 30550,         /* A1 = 1.864685 */
9000                 -32221,        /* A2 = -0.983337 */
9001                 13594,         /* B2 = 0.414886 */
9002                 -12589,        /* B1 = -0.768402 */
9003                 13594,         /* B0 = 0.414886 */
9004                 31488,         /* A1 = 1.921936 */
9005                 -32358,        /* A2 = -0.987518 */
9006                 24684,         /* B2 = 0.753296 */
9007                 -24029,        /* B1 = -1.466614 */
9008                 24684,         /* B0 = 0.753296 */
9009                 7,             /* Internal filter scaling */
9010                 159,           /* Minimum in-band energy threshold */
9011                 21,            /* 21/32 in-band to broad-band ratio */
9012                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9013        },
9014        {                       /* f340 18 */
9015                31546,          /* A1 = -1.925476 */
9016                 -32646,        /* A2 = 0.996277 */
9017                 -445,          /* B2 = -0.013588 */
9018                 0,             /* B1 = 0.000000 */
9019                 445,           /* B0 = 0.013588 */
9020                 31551,         /* A1 = -1.925781 */
9021                 -32713,        /* A2 = 0.998352 */
9022                 23884,         /* B2 = 0.728882 */
9023                 -22979,        /* B1 = -1.402527 */
9024                 23884,         /* B0 = 0.728882 */
9025                 31606,         /* A1 = -1.929138 */
9026                 -32715,        /* A2 = 0.998413 */
9027                 863,           /* B2 = 0.026367 */
9028                 -835,          /* B1 = -0.050985 */
9029                 863,           /* B0 = 0.026367 */
9030                 5,             /* Internal filter scaling */
9031                 159,           /* Minimum in-band energy threshold */
9032                 21,            /* 21/32 in-band to broad-band ratio */
9033                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9034        },
9035        {                       /* f350_400[] 19 */
9036                31006,          /* A1 = 1.892517 */
9037                 -32029,        /* A2 = -0.977448 */
9038                 -461,          /* B2 = -0.014096 */
9039                 0,             /* B1 = 0 */
9040                 461,           /* B0 = 0.014096 */
9041                 30999,         /* A1 = 1.892029 */
9042                 -32487,        /* A2 = -0.991455 */
9043                 11325,         /* B2 = 0.345612 */
9044                 -10682,        /* B1 = -0.651978 */
9045                 11325,         /* B0 = 0.345612 */
9046                 31441,         /* A1 = 1.919067 */
9047                 -32526,        /* A2 = -0.992615 */
9048                 24324,         /* B2 = 0.74231 */
9049                 -23535,        /* B1 = -1.436523 */
9050                 24324,         /* B0 = 0.74231 */
9051                 7,             /* Internal filter scaling */
9052                 159,           /* Minimum in-band energy threshold */
9053                 21,            /* 21/32 in-band to broad-band ratio */
9054                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9055        },
9056        {                       /* f350_440[] */
9057                30634,          /* A1 = 1.869751 */
9058                 -31533,        /* A2 = -0.962341 */
9059                 -680,          /* B2 = -0.020782 */
9060                 0,             /* B1 = 0 */
9061                 680,           /* B0 = 0.020782 */
9062                 30571,         /* A1 = 1.865906 */
9063                 -32277,        /* A2 = -0.985016 */
9064                 12894,         /* B2 = 0.393524 */
9065                 -11945,        /* B1 = -0.729065 */
9066                 12894,         /* B0 = 0.393524 */
9067                 31367,         /* A1 = 1.91449 */
9068                 -32379,        /* A2 = -0.988129 */
9069                 23820,         /* B2 = 0.726929 */
9070                 -23104,        /* B1 = -1.410217 */
9071                 23820,         /* B0 = 0.726929 */
9072                 7,             /* Internal filter scaling */
9073                 159,           /* Minimum in-band energy threshold */
9074                 21,            /* 21/32 in-band to broad-band ratio */
9075                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9076        },
9077        {                       /* f350_450[] */
9078                30552,          /* A1 = 1.864807 */
9079                 -31434,        /* A2 = -0.95929 */
9080                 -690,          /* B2 = -0.021066 */
9081                 0,             /* B1 = 0 */
9082                 690,           /* B0 = 0.021066 */
9083                 30472,         /* A1 = 1.859924 */
9084                 -32248,        /* A2 = -0.984161 */
9085                 13385,         /* B2 = 0.408478 */
9086                 -12357,        /* B1 = -0.754242 */
9087                 13385,         /* B0 = 0.408478 */
9088                 31358,         /* A1 = 1.914001 */
9089                 -32366,        /* A2 = -0.987732 */
9090                 26488,         /* B2 = 0.80835 */
9091                 -25692,        /* B1 = -1.568176 */
9092                 26490,         /* B0 = 0.808411 */
9093                 7,             /* Internal filter scaling */
9094                 159,           /* Minimum in-band energy threshold */
9095                 21,            /* 21/32 in-band to broad-band ratio */
9096                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9097        },
9098        {                       /* f360 */
9099                31397,          /* A1 = -1.916321 */
9100                 -32623,        /* A2 = 0.995605 */
9101                 -117,          /* B2 = -0.003598 */
9102                 0,             /* B1 = 0.000000 */
9103                 117,           /* B0 = 0.003598 */
9104                 31403,         /* A1 = -1.916687 */
9105                 -32700,        /* A2 = 0.997925 */
9106                 3388,          /* B2 = 0.103401 */
9107                 -3240,         /* B1 = -0.197784 */
9108                 3388,          /* B0 = 0.103401 */
9109                 31463,         /* A1 = -1.920410 */
9110                 -32702,        /* A2 = 0.997986 */
9111                 13346,         /* B2 = 0.407288 */
9112                 -12863,        /* B1 = -0.785126 */
9113                 13346,         /* B0 = 0.407288 */
9114                 5,             /* Internal filter scaling */
9115                 159,           /* Minimum in-band energy threshold */
9116                 21,            /* 21/32 in-band to broad-band ratio */
9117                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9118        },
9119        {                       /* f380_420[] */
9120                30831,          /* A1 = 1.881775 */
9121                 -32064,        /* A2 = -0.978546 */
9122                 -367,          /* B2 = -0.01122 */
9123                 0,             /* B1 = 0 */
9124                 367,           /* B0 = 0.01122 */
9125                 30813,         /* A1 = 1.880737 */
9126                 -32456,        /* A2 = -0.990509 */
9127                 11068,         /* B2 = 0.337769 */
9128                 -10338,        /* B1 = -0.631042 */
9129                 11068,         /* B0 = 0.337769 */
9130                 31214,         /* A1 = 1.905212 */
9131                 -32491,        /* A2 = -0.991577 */
9132                 16374,         /* B2 = 0.499695 */
9133                 -15781,        /* B1 = -0.963196 */
9134                 16374,         /* B0 = 0.499695 */
9135                 7,             /* Internal filter scaling */
9136                 159,           /* Minimum in-band energy threshold */
9137                 21,            /* 21/32 in-band to broad-band ratio */
9138                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9139        },
9140        {                       /* f392 */
9141                31152,          /* A1 = -1.901428 */
9142                 -32613,        /* A2 = 0.995300 */
9143                 -314,          /* B2 = -0.009605 */
9144                 0,             /* B1 = 0.000000 */
9145                 314,           /* B0 = 0.009605 */
9146                 31156,         /* A1 = -1.901672 */
9147                 -32694,        /* A2 = 0.997742 */
9148                 28847,         /* B2 = 0.880371 */
9149                 -2734,         /* B1 = -0.166901 */
9150                 28847,         /* B0 = 0.880371 */
9151                 31225,         /* A1 = -1.905823 */
9152                 -32696,        /* A2 = 0.997803 */
9153                 462,           /* B2 = 0.014108 */
9154                 -442,          /* B1 = -0.027019 */
9155                 462,           /* B0 = 0.014108 */
9156                 5,             /* Internal filter scaling */
9157                 159,           /* Minimum in-band energy threshold */
9158                 21,            /* 21/32 in-band to broad-band ratio */
9159                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9160        },
9161        {                       /* f400_425[] */
9162                30836,          /* A1 = 1.882141 */
9163                 -32296,        /* A2 = -0.985596 */
9164                 -324,          /* B2 = -0.009903 */
9165                 0,             /* B1 = 0 */
9166                 324,           /* B0 = 0.009903 */
9167                 30825,         /* A1 = 1.881409 */
9168                 -32570,        /* A2 = -0.993958 */
9169                 16847,         /* B2 = 0.51416 */
9170                 -15792,        /* B1 = -0.963898 */
9171                 16847,         /* B0 = 0.51416 */
9172                 31106,         /* A1 = 1.89856 */
9173                 -32584,        /* A2 = -0.994415 */
9174                 9579,          /* B2 = 0.292328 */
9175                 -9164,         /* B1 = -0.559357 */
9176                 9579,          /* B0 = 0.292328 */
9177                 7,             /* Internal filter scaling */
9178                 159,           /* Minimum in-band energy threshold */
9179                 21,            /* 21/32 in-band to broad-band ratio */
9180                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9181        },
9182        {                       /* f400_440[] */
9183                30702,          /* A1 = 1.873962 */
9184                 -32134,        /* A2 = -0.980682 */
9185                 -517,          /* B2 = -0.015793 */
9186                 0,             /* B1 = 0 */
9187                 517,           /* B0 = 0.015793 */
9188                 30676,         /* A1 = 1.872375 */
9189                 -32520,        /* A2 = -0.992462 */
9190                 8144,          /* B2 = 0.24855 */
9191                 -7596,         /* B1 = -0.463684 */
9192                 8144,          /* B0 = 0.24855 */
9193                 31084,         /* A1 = 1.897217 */
9194                 -32547,        /* A2 = -0.993256 */
9195                 22713,         /* B2 = 0.693176 */
9196                 -21734,        /* B1 = -1.326599 */
9197                 22713,         /* B0 = 0.693176 */
9198                 7,             /* Internal filter scaling */
9199                 159,           /* Minimum in-band energy threshold */
9200                 21,            /* 21/32 in-band to broad-band ratio */
9201                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9202        },
9203        {                       /* f400_450[] */
9204                30613,          /* A1 = 1.86853 */
9205                 -32031,        /* A2 = -0.977509 */
9206                 -618,          /* B2 = -0.018866 */
9207                 0,             /* B1 = 0 */
9208                 618,           /* B0 = 0.018866 */
9209                 30577,         /* A1 = 1.866272 */
9210                 -32491,        /* A2 = -0.991577 */
9211                 9612,          /* B2 = 0.293335 */
9212                 -8935,         /* B1 = -0.54541 */
9213                 9612,          /* B0 = 0.293335 */
9214                 31071,         /* A1 = 1.896484 */
9215                 -32524,        /* A2 = -0.992584 */
9216                 21596,         /* B2 = 0.659058 */
9217                 -20667,        /* B1 = -1.261414 */
9218                 21596,         /* B0 = 0.659058 */
9219                 7,             /* Internal filter scaling */
9220                 159,           /* Minimum in-band energy threshold */
9221                 21,            /* 21/32 in-band to broad-band ratio */
9222                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9223        },
9224        {                       /* f420 */
9225                30914,          /* A1 = -1.886841 */
9226                 -32584,        /* A2 = 0.994385 */
9227                 -426,          /* B2 = -0.013020 */
9228                 0,             /* B1 = 0.000000 */
9229                 426,           /* B0 = 0.013020 */
9230                 30914,         /* A1 = -1.886841 */
9231                 -32679,        /* A2 = 0.997314 */
9232                 17520,         /* B2 = 0.534668 */
9233                 -16471,        /* B1 = -1.005310 */
9234                 17520,         /* B0 = 0.534668 */
9235                 31004,         /* A1 = -1.892334 */
9236                 -32683,        /* A2 = 0.997406 */
9237                 819,           /* B2 = 0.025023 */
9238                 -780,          /* B1 = -0.047619 */
9239                 819,           /* B0 = 0.025023 */
9240                 5,             /* Internal filter scaling */
9241                 159,           /* Minimum in-band energy threshold */
9242                 21,            /* 21/32 in-band to broad-band ratio */
9243                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9244        },
9245#if 0
9246        {                       /* f425 */
9247                30881,          /* A1 = -1.884827 */
9248                 -32603,        /* A2 = 0.994965 */
9249                 -496,          /* B2 = -0.015144 */
9250                 0,             /* B1 = 0.000000 */
9251                 496,           /* B0 = 0.015144 */
9252                 30880,         /* A1 = -1.884766 */
9253                 -32692,        /* A2 = 0.997711 */
9254                 24767,         /* B2 = 0.755859 */
9255                 -23290,        /* B1 = -1.421509 */
9256                 24767,         /* B0 = 0.755859 */
9257                 30967,         /* A1 = -1.890076 */
9258                 -32694,        /* A2 = 0.997772 */
9259                 728,           /* B2 = 0.022232 */
9260                 -691,          /* B1 = -0.042194 */
9261                 728,           /* B0 = 0.022232 */
9262                 5,             /* Internal filter scaling */
9263                 159,           /* Minimum in-band energy threshold */
9264                 21,            /* 21/32 in-band to broad-band ratio */
9265                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9266        },
9267#else
9268        {
9269                30850,
9270                -32534,
9271                -504,
9272                0,
9273                504,
9274                30831,
9275                -32669,
9276                24303,
9277                -22080,
9278                24303,
9279                30994,
9280                -32673,
9281                1905,
9282                -1811,
9283                1905,
9284                5,
9285                129,
9286                17,
9287                0xff5
9288        },
9289#endif
9290        {                       /* f425_450[] */
9291                30646,          /* A1 = 1.870544 */
9292                 -32327,        /* A2 = -0.986572 */
9293                 -287,          /* B2 = -0.008769 */
9294                 0,             /* B1 = 0 */
9295                 287,           /* B0 = 0.008769 */
9296                 30627,         /* A1 = 1.869324 */
9297                 -32607,        /* A2 = -0.995087 */
9298                 13269,         /* B2 = 0.404968 */
9299                 -12376,        /* B1 = -0.755432 */
9300                 13269,         /* B0 = 0.404968 */
9301                 30924,         /* A1 = 1.887512 */
9302                 -32619,        /* A2 = -0.995453 */
9303                 19950,         /* B2 = 0.608826 */
9304                 -18940,        /* B1 = -1.156006 */
9305                 19950,         /* B0 = 0.608826 */
9306                 7,             /* Internal filter scaling */
9307                 159,           /* Minimum in-band energy threshold */
9308                 21,            /* 21/32 in-band to broad-band ratio */
9309                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9310        },
9311        {                       /* f425_475[] */
9312                30396,          /* A1 = 1.855225 */
9313                 -32014,        /* A2 = -0.97699 */
9314                 -395,          /* B2 = -0.012055 */
9315                 0,             /* B1 = 0 */
9316                 395,           /* B0 = 0.012055 */
9317                 30343,         /* A1 = 1.85199 */
9318                 -32482,        /* A2 = -0.991302 */
9319                 17823,         /* B2 = 0.543945 */
9320                 -16431,        /* B1 = -1.002869 */
9321                 17823,         /* B0 = 0.543945 */
9322                 30872,         /* A1 = 1.884338 */
9323                 -32516,        /* A2 = -0.99231 */
9324                 18124,         /* B2 = 0.553101 */
9325                 -17246,        /* B1 = -1.052673 */
9326                 18124,         /* B0 = 0.553101 */
9327                 7,             /* Internal filter scaling */
9328                 159,           /* Minimum in-band energy threshold */
9329                 21,            /* 21/32 in-band to broad-band ratio */
9330                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9331        },
9332        {                       /* f435 */
9333                30796,          /* A1 = -1.879639 */
9334                 -32603,        /* A2 = 0.994965 */
9335                 -254,          /* B2 = -0.007762 */
9336                 0,             /* B1 = 0.000000 */
9337                 254,           /* B0 = 0.007762 */
9338                 30793,         /* A1 = -1.879456 */
9339                 -32692,        /* A2 = 0.997711 */
9340                 18934,         /* B2 = 0.577820 */
9341                 -17751,        /* B1 = -1.083496 */
9342                 18934,         /* B0 = 0.577820 */
9343                 30882,         /* A1 = -1.884888 */
9344                 -32694,        /* A2 = 0.997772 */
9345                 1858,          /* B2 = 0.056713 */
9346                 -1758,         /* B1 = -0.107357 */
9347                 1858,          /* B0 = 0.056713 */
9348                 5,             /* Internal filter scaling */
9349                 159,           /* Minimum in-band energy threshold */
9350                 21,            /* 21/32 in-band to broad-band ratio */
9351                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9352        },
9353        {                       /* f440_450[] */
9354                30641,          /* A1 = 1.870239 */
9355                 -32458,        /* A2 = -0.99057 */
9356                 -155,          /* B2 = -0.004735 */
9357                 0,             /* B1 = 0 */
9358                 155,           /* B0 = 0.004735 */
9359                 30631,         /* A1 = 1.869568 */
9360                 -32630,        /* A2 = -0.995789 */
9361                 11453,         /* B2 = 0.349548 */
9362                 -10666,        /* B1 = -0.651001 */
9363                 11453,         /* B0 = 0.349548 */
9364                 30810,         /* A1 = 1.880554 */
9365                 -32634,        /* A2 = -0.995941 */
9366                 12237,         /* B2 = 0.373474 */
9367                 -11588,        /* B1 = -0.707336 */
9368                 12237,         /* B0 = 0.373474 */
9369                 7,             /* Internal filter scaling */
9370                 159,           /* Minimum in-band energy threshold */
9371                 21,            /* 21/32 in-band to broad-band ratio */
9372                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9373        },
9374        {                       /* f440_480[] */
9375                30367,          /* A1 = 1.853455 */
9376                 -32147,        /* A2 = -0.981079 */
9377                 -495,          /* B2 = -0.015113 */
9378                 0,             /* B1 = 0 */
9379                 495,           /* B0 = 0.015113 */
9380                 30322,         /* A1 = 1.850769 */
9381                 -32543,        /* A2 = -0.993134 */
9382                 10031,         /* B2 = 0.306152 */
9383                 -9252,         /* B1 = -0.564728 */
9384                 10031,         /* B0 = 0.306152 */
9385                 30770,         /* A1 = 1.878052 */
9386                 -32563,        /* A2 = -0.993774 */
9387                 22674,         /* B2 = 0.691956 */
9388                 -21465,        /* B1 = -1.31012 */
9389                 22674,         /* B0 = 0.691956 */
9390                 7,             /* Internal filter scaling */
9391                 159,           /* Minimum in-band energy threshold */
9392                 21,            /* 21/32 in-band to broad-band ratio */
9393                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9394        },
9395        {                       /* f445 */
9396                30709,          /* A1 = -1.874329 */
9397                 -32603,        /* A2 = 0.994965 */
9398                 -83,           /* B2 = -0.002545 */
9399                 0,             /* B1 = 0.000000 */
9400                 83,            /* B0 = 0.002545 */
9401                 30704,         /* A1 = -1.874084 */
9402                 -32692,        /* A2 = 0.997711 */
9403                 10641,         /* B2 = 0.324738 */
9404                 -9947,         /* B1 = -0.607147 */
9405                 10641,         /* B0 = 0.324738 */
9406                 30796,         /* A1 = -1.879639 */
9407                 -32694,        /* A2 = 0.997772 */
9408                 10079,         /* B2 = 0.307587 */
9409                 9513,          /* B1 = 0.580688 */
9410                 10079,         /* B0 = 0.307587 */
9411                 5,             /* Internal filter scaling */
9412                 159,           /* Minimum in-band energy threshold */
9413                 21,            /* 21/32 in-band to broad-band ratio */
9414                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9415        },
9416        {                       /* f450 */
9417                30664,          /* A1 = -1.871643 */
9418                 -32603,        /* A2 = 0.994965 */
9419                 -164,          /* B2 = -0.005029 */
9420                 0,             /* B1 = 0.000000 */
9421                 164,           /* B0 = 0.005029 */
9422                 30661,         /* A1 = -1.871399 */
9423                 -32692,        /* A2 = 0.997711 */
9424                 15294,         /* B2 = 0.466736 */
9425                 -14275,        /* B1 = -0.871307 */
9426                 15294,         /* B0 = 0.466736 */
9427                 30751,         /* A1 = -1.876953 */
9428                 -32694,        /* A2 = 0.997772 */
9429                 3548,          /* B2 = 0.108284 */
9430                 -3344,         /* B1 = -0.204155 */
9431                 3548,          /* B0 = 0.108284 */
9432                 5,             /* Internal filter scaling */
9433                 159,           /* Minimum in-band energy threshold */
9434                 21,            /* 21/32 in-band to broad-band ratio */
9435                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9436        },
9437        {                       /* f452 */
9438                30653,          /* A1 = -1.870911 */
9439                 -32615,        /* A2 = 0.995361 */
9440                 -209,          /* B2 = -0.006382 */
9441                 0,             /* B1 = 0.000000 */
9442                 209,           /* B0 = 0.006382 */
9443                 30647,         /* A1 = -1.870605 */
9444                 -32702,        /* A2 = 0.997986 */
9445                 18971,         /* B2 = 0.578979 */
9446                 -17716,        /* B1 = -1.081299 */
9447                 18971,         /* B0 = 0.578979 */
9448                 30738,         /* A1 = -1.876099 */
9449                 -32702,        /* A2 = 0.998016 */
9450                 2967,          /* B2 = 0.090561 */
9451                 -2793,         /* B1 = -0.170502 */
9452                 2967,          /* B0 = 0.090561 */
9453                 5,             /* Internal filter scaling */
9454                 159,           /* Minimum in-band energy threshold */
9455                 21,            /* 21/32 in-band to broad-band ratio */
9456                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9457        },
9458        {                       /* f475 */
9459                30437,          /* A1 = -1.857727 */
9460                 -32603,        /* A2 = 0.994965 */
9461                 -264,          /* B2 = -0.008062 */
9462                 0,             /* B1 = 0.000000 */
9463                 264,           /* B0 = 0.008062 */
9464                 30430,         /* A1 = -1.857300 */
9465                 -32692,        /* A2 = 0.997711 */
9466                 21681,         /* B2 = 0.661682 */
9467                 -20082,        /* B1 = -1.225708 */
9468                 21681,         /* B0 = 0.661682 */
9469                 30526,         /* A1 = -1.863220 */
9470                 -32694,        /* A2 = 0.997742 */
9471                 1559,          /* B2 = 0.047600 */
9472                 -1459,         /* B1 = -0.089096 */
9473                 1559,          /* B0 = 0.047600 */
9474                 5,             /* Internal filter scaling */
9475                 159,           /* Minimum in-band energy threshold */
9476                 21,            /* 21/32 in-band to broad-band ratio */
9477                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9478        },
9479        {                       /* f480_620[] */
9480                28975,          /* A1 = 1.768494 */
9481                 -30955,        /* A2 = -0.944672 */
9482                 -1026,         /* B2 = -0.03133 */
9483                 0,             /* B1 = 0 */
9484                 1026,          /* B0 = 0.03133 */
9485                 28613,         /* A1 = 1.746399 */
9486                 -32089,        /* A2 = -0.979309 */
9487                 14214,         /* B2 = 0.433807 */
9488                 -12202,        /* B1 = -0.744812 */
9489                 14214,         /* B0 = 0.433807 */
9490                 30243,         /* A1 = 1.845947 */
9491                 -32238,        /* A2 = -0.983856 */
9492                 24825,         /* B2 = 0.757629 */
9493                 -23402,        /* B1 = -1.428345 */
9494                 24825,         /* B0 = 0.757629 */
9495                 7,             /* Internal filter scaling */
9496                 159,           /* Minimum in-band energy threshold */
9497                 21,            /* 21/32 in-band to broad-band ratio */
9498                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9499        },
9500        {                       /* f494 */
9501                30257,          /* A1 = -1.846741 */
9502                 -32605,        /* A2 = 0.995056 */
9503                 -249,          /* B2 = -0.007625 */
9504                 0,             /* B1 = 0.000000 */
9505                 249,           /* B0 = 0.007625 */
9506                 30247,         /* A1 = -1.846191 */
9507                 -32694,        /* A2 = 0.997772 */
9508                 18088,         /* B2 = 0.552002 */
9509                 -16652,        /* B1 = -1.016418 */
9510                 18088,         /* B0 = 0.552002 */
9511                 30348,         /* A1 = -1.852295 */
9512                 -32696,        /* A2 = 0.997803 */
9513                 2099,          /* B2 = 0.064064 */
9514                 -1953,         /* B1 = -0.119202 */
9515                 2099,          /* B0 = 0.064064 */
9516                 5,             /* Internal filter scaling */
9517                 159,           /* Minimum in-band energy threshold */
9518                 21,            /* 21/32 in-band to broad-band ratio */
9519                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9520        },
9521        {                       /* f500 */
9522                30202,          /* A1 = -1.843431 */
9523                 -32624,        /* A2 = 0.995622 */
9524                 -413,          /* B2 = -0.012622 */
9525                 0,             /* B1 = 0.000000 */
9526                 413,           /* B0 = 0.012622 */
9527                 30191,         /* A1 = -1.842721 */
9528                 -32714,        /* A2 = 0.998364 */
9529                 25954,         /* B2 = 0.792057 */
9530                 -23890,        /* B1 = -1.458131 */
9531                 25954,         /* B0 = 0.792057 */
9532                 30296,         /* A1 = -1.849172 */
9533                 -32715,        /* A2 = 0.998397 */
9534                 2007,          /* B2 = 0.061264 */
9535                 -1860,         /* B1 = -0.113568 */
9536                 2007,          /* B0 = 0.061264 */
9537                 5,             /* Internal filter scaling */
9538                 159,           /* Minimum in-band energy threshold */
9539                 21,            /* 21/32 in-band to broad-band ratio */
9540                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9541        },
9542        {                       /* f520 */
9543                30001,          /* A1 = -1.831116 */
9544                 -32613,        /* A2 = 0.995270 */
9545                 -155,          /* B2 = -0.004750 */
9546                 0,             /* B1 = 0.000000 */
9547                 155,           /* B0 = 0.004750 */
9548                 29985,         /* A1 = -1.830200 */
9549                 -32710,        /* A2 = 0.998260 */
9550                 6584,          /* B2 = 0.200928 */
9551                 -6018,         /* B1 = -0.367355 */
9552                 6584,          /* B0 = 0.200928 */
9553                 30105,         /* A1 = -1.837524 */
9554                 -32712,        /* A2 = 0.998291 */
9555                 23812,         /* B2 = 0.726685 */
9556                 -21936,        /* B1 = -1.338928 */
9557                 23812,         /* B0 = 0.726685 */
9558                 5,             /* Internal filter scaling */
9559                 159,           /* Minimum in-band energy threshold */
9560                 21,            /* 21/32 in-band to broad-band ratio */
9561                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9562        },
9563        {                       /* f523 */
9564                29964,          /* A1 = -1.828918 */
9565                 -32601,        /* A2 = 0.994904 */
9566                 -101,          /* B2 = -0.003110 */
9567                 0,             /* B1 = 0.000000 */
9568                 101,           /* B0 = 0.003110 */
9569                 29949,         /* A1 = -1.827942 */
9570                 -32700,        /* A2 = 0.997925 */
9571                 11041,         /* B2 = 0.336975 */
9572                 -10075,        /* B1 = -0.614960 */
9573                 11041,         /* B0 = 0.336975 */
9574                 30070,         /* A1 = -1.835388 */
9575                 -32702,        /* A2 = 0.997986 */
9576                 16762,         /* B2 = 0.511536 */
9577                 -15437,        /* B1 = -0.942230 */
9578                 16762,         /* B0 = 0.511536 */
9579                 5,             /* Internal filter scaling */
9580                 159,           /* Minimum in-band energy threshold */
9581                 21,            /* 21/32 in-band to broad-band ratio */
9582                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9583        },
9584        {                       /* f525 */
9585                29936,          /* A1 = -1.827209 */
9586                 -32584,        /* A2 = 0.994415 */
9587                 -91,           /* B2 = -0.002806 */
9588                 0,             /* B1 = 0.000000 */
9589                 91,            /* B0 = 0.002806 */
9590                 29921,         /* A1 = -1.826233 */
9591                 -32688,        /* A2 = 0.997559 */
9592                 11449,         /* B2 = 0.349396 */
9593                 -10426,        /* B1 = -0.636383 */
9594                 11449,         /* B0 = 0.349396 */
9595                 30045,         /* A1 = -1.833862 */
9596                 -32688,        /* A2 = 0.997589 */
9597                 13055,         /* B2 = 0.398407 */
9598                 -12028,        /* B1 = -0.734161 */
9599                 13055,         /* B0 = 0.398407 */
9600                 5,             /* Internal filter scaling */
9601                 159,           /* Minimum in-band energy threshold */
9602                 21,            /* 21/32 in-band to broad-band ratio */
9603                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9604        },
9605        {                       /* f540_660[] */
9606                28499,          /* A1 = 1.739441 */
9607                 -31129,        /* A2 = -0.949982 */
9608                 -849,          /* B2 = -0.025922 */
9609                 0,             /* B1 = 0 */
9610                 849,           /* B0 = 0.025922 */
9611                 28128,         /* A1 = 1.716797 */
9612                 -32130,        /* A2 = -0.98056 */
9613                 14556,         /* B2 = 0.444214 */
9614                 -12251,        /* B1 = -0.747772 */
9615                 14556,         /* B0 = 0.444244 */
9616                 29667,         /* A1 = 1.81073 */
9617                 -32244,        /* A2 = -0.984039 */
9618                 23038,         /* B2 = 0.703064 */
9619                 -21358,        /* B1 = -1.303589 */
9620                 23040,         /* B0 = 0.703125 */
9621                 7,             /* Internal filter scaling */
9622                 159,           /* Minimum in-band energy threshold */
9623                 21,            /* 21/32 in-band to broad-band ratio */
9624                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9625        },
9626        {                       /* f587 */
9627                29271,          /* A1 = -1.786560 */
9628                 -32599,        /* A2 = 0.994873 */
9629                 -490,          /* B2 = -0.014957 */
9630                 0,             /* B1 = 0.000000 */
9631                 490,           /* B0 = 0.014957 */
9632                 29246,         /* A1 = -1.785095 */
9633                 -32700,        /* A2 = 0.997925 */
9634                 28961,         /* B2 = 0.883850 */
9635                 -25796,        /* B1 = -1.574463 */
9636                 28961,         /* B0 = 0.883850 */
9637                 29383,         /* A1 = -1.793396 */
9638                 -32700,        /* A2 = 0.997955 */
9639                 1299,          /* B2 = 0.039650 */
9640                 -1169,         /* B1 = -0.071396 */
9641                 1299,          /* B0 = 0.039650 */
9642                 5,             /* Internal filter scaling */
9643                 159,           /* Minimum in-band energy threshold */
9644                 21,            /* 21/32 in-band to broad-band ratio */
9645                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9646        },
9647        {                       /* f590 */
9648                29230,          /* A1 = -1.784058 */
9649                 -32584,        /* A2 = 0.994415 */
9650                 -418,          /* B2 = -0.012757 */
9651                 0,             /* B1 = 0.000000 */
9652                 418,           /* B0 = 0.012757 */
9653                 29206,         /* A1 = -1.782593 */
9654                 -32688,        /* A2 = 0.997559 */
9655                 36556,         /* B2 = 1.115601 */
9656                 -32478,        /* B1 = -1.982300 */
9657                 36556,         /* B0 = 1.115601 */
9658                 29345,         /* A1 = -1.791077 */
9659                 -32688,        /* A2 = 0.997589 */
9660                 897,           /* B2 = 0.027397 */
9661                 -808,          /* B1 = -0.049334 */
9662                 897,           /* B0 = 0.027397 */
9663                 5,             /* Internal filter scaling */
9664                 159,           /* Minimum in-band energy threshold */
9665                 21,            /* 21/32 in-band to broad-band ratio */
9666                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9667        },
9668        {                       /* f600 */
9669                29116,          /* A1 = -1.777100 */
9670                 -32603,        /* A2 = 0.994965 */
9671                 -165,          /* B2 = -0.005039 */
9672                 0,             /* B1 = 0.000000 */
9673                 165,           /* B0 = 0.005039 */
9674                 29089,         /* A1 = -1.775452 */
9675                 -32708,        /* A2 = 0.998199 */
9676                 6963,          /* B2 = 0.212494 */
9677                 -6172,         /* B1 = -0.376770 */
9678                 6963,          /* B0 = 0.212494 */
9679                 29237,         /* A1 = -1.784485 */
9680                 -32710,        /* A2 = 0.998230 */
9681                 24197,         /* B2 = 0.738464 */
9682                 -21657,        /* B1 = -1.321899 */
9683                 24197,         /* B0 = 0.738464 */
9684                 5,             /* Internal filter scaling */
9685                 159,           /* Minimum in-band energy threshold */
9686                 21,            /* 21/32 in-band to broad-band ratio */
9687                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9688        },
9689        {                       /* f660 */
9690                28376,          /* A1 = -1.731934 */
9691                 -32567,        /* A2 = 0.993896 */
9692                 -363,          /* B2 = -0.011102 */
9693                 0,             /* B1 = 0.000000 */
9694                 363,           /* B0 = 0.011102 */
9695                 28337,         /* A1 = -1.729614 */
9696                 -32683,        /* A2 = 0.997434 */
9697                 21766,         /* B2 = 0.664246 */
9698                 -18761,        /* B1 = -1.145081 */
9699                 21766,         /* B0 = 0.664246 */
9700                 28513,         /* A1 = -1.740356 */
9701                 -32686,        /* A2 = 0.997498 */
9702                 2509,          /* B2 = 0.076584 */
9703                 -2196,         /* B1 = -0.134041 */
9704                 2509,          /* B0 = 0.076584 */
9705                 5,             /* Internal filter scaling */
9706                 159,           /* Minimum in-band energy threshold */
9707                 21,            /* 21/32 in-band to broad-band ratio */
9708                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9709        },
9710        {                       /* f700 */
9711                27844,          /* A1 = -1.699463 */
9712                 -32563,        /* A2 = 0.993744 */
9713                 -366,          /* B2 = -0.011187 */
9714                 0,             /* B1 = 0.000000 */
9715                 366,           /* B0 = 0.011187 */
9716                 27797,         /* A1 = -1.696655 */
9717                 -32686,        /* A2 = 0.997498 */
9718                 22748,         /* B2 = 0.694214 */
9719                 -19235,        /* B1 = -1.174072 */
9720                 22748,         /* B0 = 0.694214 */
9721                 27995,         /* A1 = -1.708740 */
9722                 -32688,        /* A2 = 0.997559 */
9723                 2964,          /* B2 = 0.090477 */
9724                 -2546,         /* B1 = -0.155449 */
9725                 2964,          /* B0 = 0.090477 */
9726                 5,             /* Internal filter scaling */
9727                 159,           /* Minimum in-band energy threshold */
9728                 21,            /* 21/32 in-band to broad-band ratio */
9729                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9730        },
9731        {                       /* f740 */
9732                27297,          /* A1 = -1.666077 */
9733                 -32551,        /* A2 = 0.993408 */
9734                 -345,          /* B2 = -0.010540 */
9735                 0,             /* B1 = 0.000000 */
9736                 345,           /* B0 = 0.010540 */
9737                 27240,         /* A1 = -1.662598 */
9738                 -32683,        /* A2 = 0.997406 */
9739                 22560,         /* B2 = 0.688477 */
9740                 -18688,        /* B1 = -1.140625 */
9741                 22560,         /* B0 = 0.688477 */
9742                 27461,         /* A1 = -1.676147 */
9743                 -32684,        /* A2 = 0.997467 */
9744                 3541,          /* B2 = 0.108086 */
9745                 -2985,         /* B1 = -0.182220 */
9746                 3541,          /* B0 = 0.108086 */
9747                 5,             /* Internal filter scaling */
9748                 159,           /* Minimum in-band energy threshold */
9749                 21,            /* 21/32 in-band to broad-band ratio */
9750                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9751        },
9752        {                       /* f750 */
9753                27155,          /* A1 = -1.657410 */
9754                 -32551,        /* A2 = 0.993408 */
9755                 -462,          /* B2 = -0.014117 */
9756                 0,             /* B1 = 0.000000 */
9757                 462,           /* B0 = 0.014117 */
9758                 27097,         /* A1 = -1.653870 */
9759                 -32683,        /* A2 = 0.997406 */
9760                 32495,         /* B2 = 0.991699 */
9761                 -26776,        /* B1 = -1.634338 */
9762                 32495,         /* B0 = 0.991699 */
9763                 27321,         /* A1 = -1.667542 */
9764                 -32684,        /* A2 = 0.997467 */
9765                 1835,          /* B2 = 0.056007 */
9766                 -1539,         /* B1 = -0.093948 */
9767                 1835,          /* B0 = 0.056007 */
9768                 5,             /* Internal filter scaling */
9769                 159,           /* Minimum in-band energy threshold */
9770                 21,            /* 21/32 in-band to broad-band ratio */
9771                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9772        },
9773        {                       /* f750_1450[] */
9774                19298,          /* A1 = 1.177917 */
9775                 -24471,        /* A2 = -0.746796 */
9776                 -4152,         /* B2 = -0.126709 */
9777                 0,             /* B1 = 0 */
9778                 4152,          /* B0 = 0.126709 */
9779                 12902,         /* A1 = 0.787476 */
9780                 -29091,        /* A2 = -0.887817 */
9781                 12491,         /* B2 = 0.38121 */
9782                 -1794,         /* B1 = -0.109528 */
9783                 12494,         /* B0 = 0.381317 */
9784                 26291,         /* A1 = 1.604736 */
9785                 -30470,        /* A2 = -0.929901 */
9786                 28859,         /* B2 = 0.880737 */
9787                 -26084,        /* B1 = -1.592102 */
9788                 28861,         /* B0 = 0.880798 */
9789                 7,             /* Internal filter scaling */
9790                 159,           /* Minimum in-band energy threshold */
9791                 21,            /* 21/32 in-band to broad-band ratio */
9792                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9793        },
9794        {                       /* f770 */
9795                26867,          /* A1 = -1.639832 */
9796                 -32551,        /* A2 = 0.993408 */
9797                 -123,          /* B2 = -0.003755 */
9798                 0,             /* B1 = 0.000000 */
9799                 123,           /* B0 = 0.003755 */
9800                 26805,         /* A1 = -1.636108 */
9801                 -32683,        /* A2 = 0.997406 */
9802                 17297,         /* B2 = 0.527863 */
9803                 -14096,        /* B1 = -0.860382 */
9804                 17297,         /* B0 = 0.527863 */
9805                 27034,         /* A1 = -1.650085 */
9806                 -32684,        /* A2 = 0.997467 */
9807                 12958,         /* B2 = 0.395477 */
9808                 -10756,        /* B1 = -0.656525 */
9809                 12958,         /* B0 = 0.395477 */
9810                 5,             /* Internal filter scaling */
9811                 159,           /* Minimum in-band energy threshold */
9812                 21,            /* 21/32 in-band to broad-band ratio */
9813                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9814        },
9815        {                       /* f800 */
9816                26413,          /* A1 = -1.612122 */
9817                 -32547,        /* A2 = 0.993286 */
9818                 -223,          /* B2 = -0.006825 */
9819                 0,             /* B1 = 0.000000 */
9820                 223,           /* B0 = 0.006825 */
9821                 26342,         /* A1 = -1.607849 */
9822                 -32686,        /* A2 = 0.997498 */
9823                 6391,          /* B2 = 0.195053 */
9824                 -5120,         /* B1 = -0.312531 */
9825                 6391,          /* B0 = 0.195053 */
9826                 26593,         /* A1 = -1.623108 */
9827                 -32688,        /* A2 = 0.997559 */
9828                 23681,         /* B2 = 0.722717 */
9829                 -19328,        /* B1 = -1.179688 */
9830                 23681,         /* B0 = 0.722717 */
9831                 5,             /* Internal filter scaling */
9832                 159,           /* Minimum in-band energy threshold */
9833                 21,            /* 21/32 in-band to broad-band ratio */
9834                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9835        },
9836        {                       /* f816 */
9837                26168,          /* A1 = -1.597209 */
9838                 -32528,        /* A2 = 0.992706 */
9839                 -235,          /* B2 = -0.007182 */
9840                 0,             /* B1 = 0.000000 */
9841                 235,           /* B0 = 0.007182 */
9842                 26092,         /* A1 = -1.592590 */
9843                 -32675,        /* A2 = 0.997192 */
9844                 20823,         /* B2 = 0.635498 */
9845                 -16510,        /* B1 = -1.007751 */
9846                 20823,         /* B0 = 0.635498 */
9847                 26363,         /* A1 = -1.609070 */
9848                 -32677,        /* A2 = 0.997253 */
9849                 6739,          /* B2 = 0.205688 */
9850                 -5459,         /* B1 = -0.333206 */
9851                 6739,          /* B0 = 0.205688 */
9852                 5,             /* Internal filter scaling */
9853                 159,           /* Minimum in-band energy threshold */
9854                 21,            /* 21/32 in-band to broad-band ratio */
9855                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9856        },
9857        {                       /* f850 */
9858                25641,          /* A1 = -1.565063 */
9859                 -32536,        /* A2 = 0.992950 */
9860                 -121,          /* B2 = -0.003707 */
9861                 0,             /* B1 = 0.000000 */
9862                 121,           /* B0 = 0.003707 */
9863                 25560,         /* A1 = -1.560059 */
9864                 -32684,        /* A2 = 0.997437 */
9865                 18341,         /* B2 = 0.559753 */
9866                 -14252,        /* B1 = -0.869904 */
9867                 18341,         /* B0 = 0.559753 */
9868                 25837,         /* A1 = -1.577026 */
9869                 -32684,        /* A2 = 0.997467 */
9870                 16679,         /* B2 = 0.509003 */
9871                 -13232,        /* B1 = -0.807648 */
9872                 16679,         /* B0 = 0.509003 */
9873                 5,             /* Internal filter scaling */
9874                 159,           /* Minimum in-band energy threshold */
9875                 21,            /* 21/32 in-band to broad-band ratio */
9876                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9877        },
9878        {                       /* f857_1645[] */
9879                16415,          /* A1 = 1.001953 */
9880                 -23669,        /* A2 = -0.722321 */
9881                 -4549,         /* B2 = -0.138847 */
9882                 0,             /* B1 = 0 */
9883                 4549,          /* B0 = 0.138847 */
9884                 8456,          /* A1 = 0.516174 */
9885                 -28996,        /* A2 = -0.884918 */
9886                 13753,         /* B2 = 0.419724 */
9887                 -12,           /* B1 = -0.000763 */
9888                 13757,         /* B0 = 0.419846 */
9889                 24632,         /* A1 = 1.503418 */
9890                 -30271,        /* A2 = -0.923828 */
9891                 29070,         /* B2 = 0.887146 */
9892                 -25265,        /* B1 = -1.542114 */
9893                 29073,         /* B0 = 0.887268 */
9894                 7,             /* Internal filter scaling */
9895                 159,           /* Minimum in-band energy threshold */
9896                 21,            /* 21/32 in-band to broad-band ratio */
9897                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9898        },
9899        {                       /* f900 */
9900                24806,          /* A1 = -1.514099 */
9901                 -32501,        /* A2 = 0.991852 */
9902                 -326,          /* B2 = -0.009969 */
9903                 0,             /* B1 = 0.000000 */
9904                 326,           /* B0 = 0.009969 */
9905                 24709,         /* A1 = -1.508118 */
9906                 -32659,        /* A2 = 0.996674 */
9907                 20277,         /* B2 = 0.618835 */
9908                 -15182,        /* B1 = -0.926636 */
9909                 20277,         /* B0 = 0.618835 */
9910                 25022,         /* A1 = -1.527222 */
9911                 -32661,        /* A2 = 0.996735 */
9912                 4320,          /* B2 = 0.131836 */
9913                 -3331,         /* B1 = -0.203339 */
9914                 4320,          /* B0 = 0.131836 */
9915                 5,             /* Internal filter scaling */
9916                 159,           /* Minimum in-band energy threshold */
9917                 21,            /* 21/32 in-band to broad-band ratio */
9918                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9919        },
9920        {                       /* f900_1300[] */
9921                19776,          /* A1 = 1.207092 */
9922                 -27437,        /* A2 = -0.837341 */
9923                 -2666,         /* B2 = -0.081371 */
9924                 0,             /* B1 = 0 */
9925                 2666,          /* B0 = 0.081371 */
9926                 16302,         /* A1 = 0.995026 */
9927                 -30354,        /* A2 = -0.926361 */
9928                 10389,         /* B2 = 0.317062 */
9929                 -3327,         /* B1 = -0.203064 */
9930                 10389,         /* B0 = 0.317062 */
9931                 24299,         /* A1 = 1.483154 */
9932                 -30930,        /* A2 = -0.943909 */
9933                 25016,         /* B2 = 0.763428 */
9934                 -21171,        /* B1 = -1.292236 */
9935                 25016,         /* B0 = 0.763428 */
9936                 7,             /* Internal filter scaling */
9937                 159,           /* Minimum in-band energy threshold */
9938                 21,            /* 21/32 in-band to broad-band ratio */
9939                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9940        },
9941        {                       /* f935_1215[] */
9942                20554,          /* A1 = 1.254517 */
9943                 -28764,        /* A2 = -0.877838 */
9944                 -2048,         /* B2 = -0.062515 */
9945                 0,             /* B1 = 0 */
9946                 2048,          /* B0 = 0.062515 */
9947                 18209,         /* A1 = 1.11145 */
9948                 -30951,        /* A2 = -0.94458 */
9949                 9390,          /* B2 = 0.286575 */
9950                 -3955,         /* B1 = -0.241455 */
9951                 9390,          /* B0 = 0.286575 */
9952                 23902,         /* A1 = 1.458923 */
9953                 -31286,        /* A2 = -0.954803 */
9954                 23252,         /* B2 = 0.709595 */
9955                 -19132,        /* B1 = -1.167725 */
9956                 23252,         /* B0 = 0.709595 */
9957                 7,             /* Internal filter scaling */
9958                 159,           /* Minimum in-band energy threshold */
9959                 21,            /* 21/32 in-band to broad-band ratio */
9960                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9961        },
9962        {                       /* f941_1477[] */
9963                17543,          /* A1 = 1.07074 */
9964                 -26220,        /* A2 = -0.800201 */
9965                 -3298,         /* B2 = -0.100647 */
9966                 0,             /* B1 = 0 */
9967                 3298,          /* B0 = 0.100647 */
9968                 12423,         /* A1 = 0.75827 */
9969                 -30036,        /* A2 = -0.916626 */
9970                 12651,         /* B2 = 0.386078 */
9971                 -2444,         /* B1 = -0.14917 */
9972                 12653,         /* B0 = 0.386154 */
9973                 23518,         /* A1 = 1.435425 */
9974                 -30745,        /* A2 = -0.938293 */
9975                 27282,         /* B2 = 0.832581 */
9976                 -22529,        /* B1 = -1.375122 */
9977                 27286,         /* B0 = 0.832703 */
9978                 7,             /* Internal filter scaling */
9979                 159,           /* Minimum in-band energy threshold */
9980                 21,            /* 21/32 in-band to broad-band ratio */
9981                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9982        },
9983        {                       /* f942 */
9984                24104,          /* A1 = -1.471252 */
9985                 -32507,        /* A2 = 0.992065 */
9986                 -351,          /* B2 = -0.010722 */
9987                 0,             /* B1 = 0.000000 */
9988                 351,           /* B0 = 0.010722 */
9989                 23996,         /* A1 = -1.464600 */
9990                 -32671,        /* A2 = 0.997040 */
9991                 22848,         /* B2 = 0.697266 */
9992                 -16639,        /* B1 = -1.015564 */
9993                 22848,         /* B0 = 0.697266 */
9994                 24332,         /* A1 = -1.485168 */
9995                 -32673,        /* A2 = 0.997101 */
9996                 4906,          /* B2 = 0.149727 */
9997                 -3672,         /* B1 = -0.224174 */
9998                 4906,          /* B0 = 0.149727 */
9999                 5,             /* Internal filter scaling */
10000                 159,           /* Minimum in-band energy threshold */
10001                 21,            /* 21/32 in-band to broad-band ratio */
10002                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10003        },
10004        {                       /* f950 */
10005                23967,          /* A1 = -1.462830 */
10006                 -32507,        /* A2 = 0.992065 */
10007                 -518,          /* B2 = -0.015821 */
10008                 0,             /* B1 = 0.000000 */
10009                 518,           /* B0 = 0.015821 */
10010                 23856,         /* A1 = -1.456055 */
10011                 -32671,        /* A2 = 0.997040 */
10012                 26287,         /* B2 = 0.802246 */
10013                 -19031,        /* B1 = -1.161560 */
10014                 26287,         /* B0 = 0.802246 */
10015                 24195,         /* A1 = -1.476746 */
10016                 -32673,        /* A2 = 0.997101 */
10017                 2890,          /* B2 = 0.088196 */
10018                 -2151,         /* B1 = -0.131317 */
10019                 2890,          /* B0 = 0.088196 */
10020                 5,             /* Internal filter scaling */
10021                 159,           /* Minimum in-band energy threshold */
10022                 21,            /* 21/32 in-band to broad-band ratio */
10023                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10024        },
10025        {                       /* f950_1400[] */
10026                18294,          /* A1 = 1.116638 */
10027                 -26962,        /* A2 = -0.822845 */
10028                 -2914,         /* B2 = -0.088936 */
10029                 0,             /* B1 = 0 */
10030                 2914,          /* B0 = 0.088936 */
10031                 14119,         /* A1 = 0.861786 */
10032                 -30227,        /* A2 = -0.922455 */
10033                 11466,         /* B2 = 0.349945 */
10034                 -2833,         /* B1 = -0.172943 */
10035                 11466,         /* B0 = 0.349945 */
10036                 23431,         /* A1 = 1.430115 */
10037                 -30828,        /* A2 = -0.940796 */
10038                 25331,         /* B2 = 0.773071 */
10039                 -20911,        /* B1 = -1.276367 */
10040                 25331,         /* B0 = 0.773071 */
10041                 7,             /* Internal filter scaling */
10042                 159,           /* Minimum in-band energy threshold */
10043                 21,            /* 21/32 in-band to broad-band ratio */
10044                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10045        },
10046        {                       /* f975 */
10047                23521,          /* A1 = -1.435608 */
10048                 -32489,        /* A2 = 0.991516 */
10049                 -193,          /* B2 = -0.005915 */
10050                 0,             /* B1 = 0.000000 */
10051                 193,           /* B0 = 0.005915 */
10052                 23404,         /* A1 = -1.428467 */
10053                 -32655,        /* A2 = 0.996582 */
10054                 17740,         /* B2 = 0.541412 */
10055                 -12567,        /* B1 = -0.767029 */
10056                 17740,         /* B0 = 0.541412 */
10057                 23753,         /* A1 = -1.449829 */
10058                 -32657,        /* A2 = 0.996613 */
10059                 9090,          /* B2 = 0.277405 */
10060                 -6662,         /* B1 = -0.406647 */
10061                 9090,          /* B0 = 0.277405 */
10062                 5,             /* Internal filter scaling */
10063                 159,           /* Minimum in-band energy threshold */
10064                 21,            /* 21/32 in-band to broad-band ratio */
10065                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10066        },
10067        {                       /* f1000 */
10068                23071,          /* A1 = -1.408203 */
10069                 -32489,        /* A2 = 0.991516 */
10070                 -293,          /* B2 = -0.008965 */
10071                 0,             /* B1 = 0.000000 */
10072                 293,           /* B0 = 0.008965 */
10073                 22951,         /* A1 = -1.400818 */
10074                 -32655,        /* A2 = 0.996582 */
10075                 5689,          /* B2 = 0.173645 */
10076                 -3951,         /* B1 = -0.241150 */
10077                 5689,          /* B0 = 0.173645 */
10078                 23307,         /* A1 = -1.422607 */
10079                 -32657,        /* A2 = 0.996613 */
10080                 18692,         /* B2 = 0.570435 */
10081                 -13447,        /* B1 = -0.820770 */
10082                 18692,         /* B0 = 0.570435 */
10083                 5,             /* Internal filter scaling */
10084                 159,           /* Minimum in-band energy threshold */
10085                 21,            /* 21/32 in-band to broad-band ratio */
10086                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10087        },
10088        {                       /* f1020 */
10089                22701,          /* A1 = -1.385620 */
10090                 -32474,        /* A2 = 0.991058 */
10091                 -292,          /* B2 = -0.008933 */
10092                 0,             /*163840      , B1 = 10.000000 */
10093                 292,           /* B0 = 0.008933 */
10094                 22564,         /* A1 = -1.377258 */
10095                 -32655,        /* A2 = 0.996552 */
10096                 20756,         /* B2 = 0.633423 */
10097                 -14176,        /* B1 = -0.865295 */
10098                 20756,         /* B0 = 0.633423 */
10099                 22960,         /* A1 = -1.401428 */
10100                 -32657,        /* A2 = 0.996613 */
10101                 6520,          /* B2 = 0.198990 */
10102                 -4619,         /* B1 = -0.281937 */
10103                 6520,          /* B0 = 0.198990 */
10104                 5,             /* Internal filter scaling */
10105                 159,           /* Minimum in-band energy threshold */
10106                 21,            /* 21/32 in-band to broad-band ratio */
10107                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10108        },
10109        {                       /* f1050 */
10110                22142,          /* A1 = -1.351501 */
10111                 -32474,        /* A2 = 0.991058 */
10112                 -147,          /* B2 = -0.004493 */
10113                 0,             /* B1 = 0.000000 */
10114                 147,           /* B0 = 0.004493 */
10115                 22000,         /* A1 = -1.342834 */
10116                 -32655,        /* A2 = 0.996552 */
10117                 15379,         /* B2 = 0.469360 */
10118                 -10237,        /* B1 = -0.624847 */
10119                 15379,         /* B0 = 0.469360 */
10120                 22406,         /* A1 = -1.367554 */
10121                 -32657,        /* A2 = 0.996613 */
10122                 17491,         /* B2 = 0.533783 */
10123                 -12096,        /* B1 = -0.738312 */
10124                 17491,         /* B0 = 0.533783 */
10125                 5,             /* Internal filter scaling */
10126                 159,           /* Minimum in-band energy threshold */
10127                 21,            /* 21/32 in-band to broad-band ratio */
10128                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10129        },
10130        {                       /* f1100_1750[] */
10131                12973,          /* A1 = 0.79184 */
10132                 -24916,        /* A2 = -0.760376 */
10133                 6655,          /* B2 = 0.203102 */
10134                 367,           /* B1 = 0.0224 */
10135                 6657,          /* B0 = 0.203171 */
10136                 5915,          /* A1 = 0.361053 */
10137                 -29560,        /* A2 = -0.90213 */
10138                 -7777,         /* B2 = -0.23735 */
10139                 0,             /* B1 = 0 */
10140                 7777,          /* B0 = 0.23735 */
10141                 20510,         /* A1 = 1.251892 */
10142                 -30260,        /* A2 = -0.923462 */
10143                 26662,         /* B2 = 0.81366 */
10144                 -20573,        /* B1 = -1.255737 */
10145                 26668,         /* B0 = 0.813843 */
10146                 7,             /* Internal filter scaling */
10147                 159,           /* Minimum in-band energy threshold */
10148                 21,            /* 21/32 in-band to broad-band ratio */
10149                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10150        },
10151        {                       /* f1140 */
10152                20392,          /* A1 = -1.244629 */
10153                 -32460,        /* A2 = 0.990601 */
10154                 -270,          /* B2 = -0.008240 */
10155                 0,             /* B1 = 0.000000 */
10156                 270,           /* B0 = 0.008240 */
10157                 20218,         /* A1 = -1.234009 */
10158                 -32655,        /* A2 = 0.996582 */
10159                 21337,         /* B2 = 0.651154 */
10160                 -13044,        /* B1 = -0.796143 */
10161                 21337,         /* B0 = 0.651154 */
10162                 20684,         /* A1 = -1.262512 */
10163                 -32657,        /* A2 = 0.996643 */
10164                 8572,          /* B2 = 0.261612 */
10165                 -5476,         /* B1 = -0.334244 */
10166                 8572,          /* B0 = 0.261612 */
10167                 5,             /* Internal filter scaling */
10168                 159,           /* Minimum in-band energy threshold */
10169                 21,            /* 21/32 in-band to broad-band ratio */
10170                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10171        },
10172        {                       /* f1200 */
10173                19159,          /* A1 = -1.169373 */
10174                 -32456,        /* A2 = 0.990509 */
10175                 -335,          /* B2 = -0.010252 */
10176                 0,             /* B1 = 0.000000 */
10177                 335,           /* B0 = 0.010252 */
10178                 18966,         /* A1 = -1.157593 */
10179                 -32661,        /* A2 = 0.996735 */
10180                 6802,          /* B2 = 0.207588 */
10181                 -3900,         /* B1 = -0.238098 */
10182                 6802,          /* B0 = 0.207588 */
10183                 19467,         /* A1 = -1.188232 */
10184                 -32661,        /* A2 = 0.996765 */
10185                 25035,         /* B2 = 0.764008 */
10186                 -15049,        /* B1 = -0.918579 */
10187                 25035,         /* B0 = 0.764008 */
10188                 5,             /* Internal filter scaling */
10189                 159,           /* Minimum in-band energy threshold */
10190                 21,            /* 21/32 in-band to broad-band ratio */
10191                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10192        },
10193        {                       /* f1209 */
10194                18976,          /* A1 = -1.158264 */
10195                 -32439,        /* A2 = 0.989990 */
10196                 -183,          /* B2 = -0.005588 */
10197                 0,             /* B1 = 0.000000 */
10198                 183,           /* B0 = 0.005588 */
10199                 18774,         /* A1 = -1.145874 */
10200                 -32650,        /* A2 = 0.996429 */
10201                 15468,         /* B2 = 0.472076 */
10202                 -8768,         /* B1 = -0.535217 */
10203                 15468,         /* B0 = 0.472076 */
10204                 19300,         /* A1 = -1.177979 */
10205                 -32652,        /* A2 = 0.996490 */
10206                 19840,         /* B2 = 0.605499 */
10207                 -11842,        /* B1 = -0.722809 */
10208                 19840,         /* B0 = 0.605499 */
10209                 5,             /* Internal filter scaling */
10210                 159,           /* Minimum in-band energy threshold */
10211                 21,            /* 21/32 in-band to broad-band ratio */
10212                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10213        },
10214        {                       /* f1330 */
10215                16357,          /* A1 = -0.998413 */
10216                 -32368,        /* A2 = 0.987793 */
10217                 -217,          /* B2 = -0.006652 */
10218                 0,             /* B1 = 0.000000 */
10219                 217,           /* B0 = 0.006652 */
10220                 16107,         /* A1 = -0.983126 */
10221                 -32601,        /* A2 = 0.994904 */
10222                 11602,         /* B2 = 0.354065 */
10223                 -5555,         /* B1 = -0.339111 */
10224                 11602,         /* B0 = 0.354065 */
10225                 16722,         /* A1 = -1.020630 */
10226                 -32603,        /* A2 = 0.994965 */
10227                 15574,         /* B2 = 0.475311 */
10228                 -8176,         /* B1 = -0.499069 */
10229                 15574,         /* B0 = 0.475311 */
10230                 5,             /* Internal filter scaling */
10231                 159,           /* Minimum in-band energy threshold */
10232                 21,            /* 21/32 in-band to broad-band ratio */
10233                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10234        },
10235        {                       /* f1336 */
10236                16234,          /* A1 = -0.990875 */
10237                 32404,         /* A2 = -0.988922 */
10238                 -193,          /* B2 = -0.005908 */
10239                 0,             /* B1 = 0.000000 */
10240                 193,           /* B0 = 0.005908 */
10241                 15986,         /* A1 = -0.975769 */
10242                 -32632,        /* A2 = 0.995880 */
10243                 18051,         /* B2 = 0.550903 */
10244                 -8658,         /* B1 = -0.528473 */
10245                 18051,         /* B0 = 0.550903 */
10246                 16591,         /* A1 = -1.012695 */
10247                 -32634,        /* A2 = 0.995941 */
10248                 15736,         /* B2 = 0.480240 */
10249                 -8125,         /* B1 = -0.495926 */
10250                 15736,         /* B0 = 0.480240 */
10251                 5,             /* Internal filter scaling */
10252                 159,           /* Minimum in-band energy threshold */
10253                 21,            /* 21/32 in-band to broad-band ratio */
10254                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10255        },
10256        {                       /* f1366 */
10257                15564,          /* A1 = -0.949982 */
10258                 -32404,        /* A2 = 0.988922 */
10259                 -269,          /* B2 = -0.008216 */
10260                 0,             /* B1 = 0.000000 */
10261                 269,           /* B0 = 0.008216 */
10262                 15310,         /* A1 = -0.934479 */
10263                 -32632,        /* A2 = 0.995880 */
10264                 10815,         /* B2 = 0.330063 */
10265                 -4962,         /* B1 = -0.302887 */
10266                 10815,         /* B0 = 0.330063 */
10267                 15924,         /* A1 = -0.971924 */
10268                 -32634,        /* A2 = 0.995941 */
10269                 18880,         /* B2 = 0.576172 */
10270                 -9364,         /* B1 = -0.571594 */
10271                 18880,         /* B0 = 0.576172 */
10272                 5,             /* Internal filter scaling */
10273                 159,           /* Minimum in-band energy threshold */
10274                 21,            /* 21/32 in-band to broad-band ratio */
10275                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10276        },
10277        {                       /* f1380 */
10278                15247,          /* A1 = -0.930603 */
10279                 -32397,        /* A2 = 0.988708 */
10280                 -244,          /* B2 = -0.007451 */
10281                 0,             /* B1 = 0.000000 */
10282                 244,           /* B0 = 0.007451 */
10283                 14989,         /* A1 = -0.914886 */
10284                 -32627,        /* A2 = 0.995697 */
10285                 18961,         /* B2 = 0.578644 */
10286                 -8498,         /* B1 = -0.518707 */
10287                 18961,         /* B0 = 0.578644 */
10288                 15608,         /* A1 = -0.952667 */
10289                 -32628,        /* A2 = 0.995758 */
10290                 11145,         /* B2 = 0.340134 */
10291                 -5430,         /* B1 = -0.331467 */
10292                 11145,         /* B0 = 0.340134 */
10293                 5,             /* Internal filter scaling */
10294                 159,           /* Minimum in-band energy threshold */
10295                 21,            /* 21/32 in-band to broad-band ratio */
10296                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10297        },
10298        {                       /* f1400 */
10299                14780,          /* A1 = -0.902130 */
10300                 -32393,        /* A2 = 0.988586 */
10301                 -396,          /* B2 = -0.012086 */
10302                 0,             /* B1 = 0.000000 */
10303                 396,           /* B0 = 0.012086 */
10304                 14510,         /* A1 = -0.885651 */
10305                 -32630,        /* A2 = 0.995819 */
10306                 6326,          /* B2 = 0.193069 */
10307                 -2747,         /* B1 = -0.167671 */
10308                 6326,          /* B0 = 0.193069 */
10309                 15154,         /* A1 = -0.924957 */
10310                 -32632,        /* A2 = 0.995850 */
10311                 23235,         /* B2 = 0.709076 */
10312                 -10983,        /* B1 = -0.670380 */
10313                 23235,         /* B0 = 0.709076 */
10314                 5,             /* Internal filter scaling */
10315                 159,           /* Minimum in-band energy threshold */
10316                 21,            /* 21/32 in-band to broad-band ratio */
10317                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10318        },
10319        {                       /* f1477 */
10320                13005,          /* A1 = -0.793793 */
10321                 -32368,        /* A2 = 0.987823 */
10322                 -500,          /* B2 = -0.015265 */
10323                 0,             /* B1 = 0.000000 */
10324                 500,           /* B0 = 0.015265 */
10325                 12708,         /* A1 = -0.775665 */
10326                 -32615,        /* A2 = 0.995331 */
10327                 11420,         /* B2 = 0.348526 */
10328                 -4306,         /* B1 = -0.262833 */
10329                 11420,         /* B0 = 0.348526 */
10330                 13397,         /* A1 = -0.817688 */
10331                 -32615,        /* A2 = 0.995361 */
10332                 9454,          /* B2 = 0.288528 */
10333                 -3981,         /* B1 = -0.243027 */
10334                 9454,          /* B0 = 0.288528 */
10335                 5,             /* Internal filter scaling */
10336                 159,           /* Minimum in-band energy threshold */
10337                 21,            /* 21/32 in-band to broad-band ratio */
10338                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10339        },
10340        {                       /* f1600 */
10341                10046,          /* A1 = -0.613190 */
10342                 -32331,        /* A2 = 0.986694 */
10343                 -455,          /* B2 = -0.013915 */
10344                 0,             /* B1 = 0.000000 */
10345                 455,           /* B0 = 0.013915 */
10346                 9694,          /* A1 = -0.591705 */
10347                 -32601,        /* A2 = 0.994934 */
10348                 6023,          /* B2 = 0.183815 */
10349                 -1708,         /* B1 = -0.104279 */
10350                 6023,          /* B0 = 0.183815 */
10351                 10478,         /* A1 = -0.639587 */
10352                 -32603,        /* A2 = 0.994965 */
10353                 22031,         /* B2 = 0.672333 */
10354                 -7342,         /* B1 = -0.448151 */
10355                 22031,         /* B0 = 0.672333 */
10356                 5,             /* Internal filter scaling */
10357                 159,           /* Minimum in-band energy threshold */
10358                 21,            /* 21/32 in-band to broad-band ratio */
10359                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10360        },
10361        {                       /* f1633_1638[] */
10362                9181,           /* A1 = 0.560394 */
10363                 -32256,        /* A2 = -0.984375 */
10364                 -556,          /* B2 = -0.016975 */
10365                 0,             /* B1 = 0 */
10366                 556,           /* B0 = 0.016975 */
10367                 8757,          /* A1 = 0.534515 */
10368                 -32574,        /* A2 = -0.99408 */
10369                 8443,          /* B2 = 0.25769 */
10370                 -2135,         /* B1 = -0.130341 */
10371                 8443,          /* B0 = 0.25769 */
10372                 9691,          /* A1 = 0.591522 */
10373                 -32574,        /* A2 = -0.99411 */
10374                 15446,         /* B2 = 0.471375 */
10375                 -4809,         /* B1 = -0.293579 */
10376                 15446,         /* B0 = 0.471375 */
10377                 7,             /* Internal filter scaling */
10378                 159,           /* Minimum in-band energy threshold */
10379                 21,            /* 21/32 in-band to broad-band ratio */
10380                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10381        },
10382        {                       /* f1800 */
10383                5076,           /* A1 = -0.309875 */
10384                 -32304,        /* A2 = 0.985840 */
10385                 -508,          /* B2 = -0.015503 */
10386                 0,             /* B1 = 0.000000 */
10387                 508,           /* B0 = 0.015503 */
10388                 4646,          /* A1 = -0.283600 */
10389                 -32605,        /* A2 = 0.995026 */
10390                 6742,          /* B2 = 0.205780 */
10391                 -878,          /* B1 = -0.053635 */
10392                 6742,          /* B0 = 0.205780 */
10393                 5552,          /* A1 = -0.338928 */
10394                 -32605,        /* A2 = 0.995056 */
10395                 23667,         /* B2 = 0.722260 */
10396                 -4297,         /* B1 = -0.262329 */
10397                 23667,         /* B0 = 0.722260 */
10398                 5,             /* Internal filter scaling */
10399                 159,           /* Minimum in-band energy threshold */
10400                 21,            /* 21/32 in-band to broad-band ratio */
10401                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10402        },
10403        {                       /* f1860 */
10404                3569,           /* A1 = -0.217865 */
10405                 -32292,        /* A2 = 0.985504 */
10406                 -239,          /* B2 = -0.007322 */
10407                 0,             /* B1 = 0.000000 */
10408                 239,           /* B0 = 0.007322 */
10409                 3117,          /* A1 = -0.190277 */
10410                 -32603,        /* A2 = 0.994965 */
10411                 18658,         /* B2 = 0.569427 */
10412                 -1557,         /* B1 = -0.095032 */
10413                 18658,         /* B0 = 0.569427 */
10414                 4054,          /* A1 = -0.247437 */
10415                 -32603,        /* A2 = 0.994965 */
10416                 18886,         /* B2 = 0.576385 */
10417                 -2566,         /* B1 = -0.156647 */
10418                 18886,         /* B0 = 0.576385 */
10419                 5,             /* Internal filter scaling */
10420                 159,           /* Minimum in-band energy threshold */
10421                 21,            /* 21/32 in-band to broad-band ratio */
10422                 0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10423        },
10424};
10425static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10426{
10427        unsigned short cmd;
10428        int cnt, max;
10429
10430        if (jf->filter > 3) {
10431                return -1;
10432        }
10433        if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10434
10435                return -1;
10436        if (!jf->enable) {
10437                if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10438
10439                        return -1;
10440                else
10441                        return 0;
10442        } else {
10443                if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10444
10445                        return -1;
10446                /* Select the filter (f0 - f3) to use. */
10447                if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10448                        return -1;
10449        }
10450        if (jf->freq < 12 && jf->freq > 3) {
10451                /* Select the frequency for the selected filter. */
10452                if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10453                        return -1;
10454        } else if (jf->freq > 11) {
10455                /* We need to load a programmable filter set for undefined */
10456                /* frequencies.  So we will point the filter to a programmable set. */
10457                /* Since there are only 4 filters and 4 programmable sets, we will */
10458                /* just point the filter to the same number set and program it for the */
10459                /* frequency we want. */
10460                if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10461                        return -1;
10462                if (j->ver.low != 0x12) {
10463                        cmd = 0x515B;
10464                        max = 19;
10465                } else {
10466                        cmd = 0x515E;
10467                        max = 15;
10468                }
10469                if (ixj_WriteDSPCommand(cmd, j))
10470                        return -1;
10471                for (cnt = 0; cnt < max; cnt++) {
10472                        if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10473                                return -1;
10474                }
10475        }
10476        j->filter_en[jf->filter] = jf->enable;
10477        return 0;
10478}
10479
10480static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10481{
10482        unsigned short cmd;
10483        int cnt, max;
10484        if (jfr->filter > 3) {
10485                return -1;
10486        }
10487        if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10488                return -1;
10489
10490        if (!jfr->enable) {
10491                if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10492                        return -1;
10493                else
10494                        return 0;
10495        } else {
10496                if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10497                        return -1;
10498                /* Select the filter (f0 - f3) to use. */
10499                if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10500                        return -1;
10501        }
10502        /* We need to load a programmable filter set for undefined */
10503        /* frequencies.  So we will point the filter to a programmable set. */
10504        /* Since there are only 4 filters and 4 programmable sets, we will */
10505        /* just point the filter to the same number set and program it for the */
10506        /* frequency we want. */
10507        if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10508                return -1;
10509        if (j->ver.low != 0x12) {
10510                cmd = 0x515B;
10511                max = 19;
10512        } else {
10513                cmd = 0x515E;
10514                max = 15;
10515        }
10516        if (ixj_WriteDSPCommand(cmd, j))
10517                return -1;
10518        for (cnt = 0; cnt < max; cnt++) {
10519                if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10520                        return -1;
10521        }
10522        j->filter_en[jfr->filter] = jfr->enable;
10523        return 0;
10524}
10525
10526static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10527{
10528        int freq0, freq1;
10529        unsigned short data;
10530        if (ti->freq0) {
10531                freq0 = ti->freq0;
10532        } else {
10533                freq0 = 0x7FFF;
10534        }
10535
10536        if (ti->freq1) {
10537                freq1 = ti->freq1;
10538        } else {
10539                freq1 = 0x7FFF;
10540        }
10541
10542        if(ti->tone_index > 12 && ti->tone_index < 28)
10543        {
10544                if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10545                        return -1;
10546                if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10547                        return -1;
10548                data = freq0;
10549                if (ixj_WriteDSPCommand(data, j))
10550                        return -1;
10551                data = freq1;
10552                if (ixj_WriteDSPCommand(data, j))
10553                        return -1;
10554        }
10555        return freq0;
10556}
10557
10558