drivers/telephony/ixj.c

   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  * $Log: ixj.c,v $
  46  *
  47  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  48  * Audit some copy_*_user and minor cleanup.
  49  *
  50  * Revision 4.7  2001/08/13 06:19:33  craigs
  51  * Added additional changes from Alan Cox and John Anderson for
  52  * 2.2 to 2.4 cleanup and bounds checking
  53  *
  54  * Revision 4.6  2001/08/13 01:05:05  craigs
  55  * Really fixed PHONE_QUERY_CODEC problem this time
  56  *
  57  * Revision 4.5  2001/08/13 00:11:03  craigs
  58  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  59  *
  60  * Revision 4.4  2001/08/07 07:58:12  craigs
  61  * Changed back to three digit version numbers
  62  * Added tagbuild target to allow automatic and easy tagging of versions
  63  *
  64  * Revision 4.3  2001/08/07 07:24:47  craigs
  65  * Added ixj-ver.h to allow easy configuration management of driver
  66  * Added display of version number in /prox/ixj
  67  *
  68  * Revision 4.2  2001/08/06 07:07:19  craigs
  69  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  70  * behaviour of returning int rather than short *
  71  *
  72  * Revision 4.1  2001/08/05 00:17:37  craigs
  73  * More changes for correct PCMCIA installation
  74  * Start of changes for backward Linux compatibility
  75  *
  76  * Revision 4.0  2001/08/04 12:33:12  craigs
  77  * New version using GNU autoconf
  78  *
  79  * Revision 3.105  2001/07/20 23:14:32  eokerson
  80  * More work on CallerID generation when using ring cadences.
  81  *
  82  * Revision 3.104  2001/07/06 01:33:55  eokerson
  83  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  84  *
  85  * Revision 3.103  2001/07/05 19:20:16  eokerson
  86  * Updated HOWTO
  87  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  88  *
  89  * Revision 3.102  2001/07/03 23:51:21  eokerson
  90  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  91  *
  92  * Revision 3.101  2001/07/02 19:26:56  eokerson
  93  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  94  *
  95  * Revision 3.100  2001/07/02 19:18:27  eokerson
  96  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  97  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  98  * Fixed speaker mode on Internet LineJACK.
  99  *
 100  * Revision 3.99  2001/05/09 14:11:16  eokerson
 101  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 102  *
 103  * Revision 3.98  2001/05/08 19:55:33  eokerson
 104  * Fixed POTS hookstate detection while it is connected to PSTN port.
 105  *
 106  * Revision 3.97  2001/05/08 00:01:04  eokerson
 107  * Fixed kernel oops when sending caller ID data.
 108  *
 109  * Revision 3.96  2001/05/04 23:09:30  eokerson
 110  * Now uses one kernel timer for each card, instead of one for the entire driver.
 111  *
 112  * Revision 3.95  2001/04/25 22:06:47  eokerson
 113  * Fixed squawking at beginning of some G.723.1 calls.
 114  *
 115  * Revision 3.94  2001/04/03 23:42:00  eokerson
 116  * Added linear volume ioctls
 117  * Added raw filter load ioctl
 118  *
 119  * Revision 3.93  2001/02/27 01:00:06  eokerson
 120  * Fixed blocking in CallerID.
 121  * Reduced size of ixj structure for smaller driver footprint.
 122  *
 123  * Revision 3.92  2001/02/20 22:02:59  eokerson
 124  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 125  * Improved PSTN ring detection.
 126  * Fixed wink generation on POTS ports.
 127  *
 128  * Revision 3.91  2001/02/13 00:55:44  eokerson
 129  * Turn AEC back on after changing frame sizes.
 130  *
 131  * Revision 3.90  2001/02/12 16:42:00  eokerson
 132  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 133  *
 134  * Revision 3.89  2001/02/12 15:41:16  eokerson
 135  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 136  *
 137  * Revision 3.88  2001/02/05 23:25:42  eokerson
 138  * Fixed lockup bugs with deregister.
 139  *
 140  * Revision 3.87  2001/01/29 21:00:39  eokerson
 141  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 142  * Updated copyright date.
 143  *
 144  * Revision 3.86  2001/01/23 23:53:46  eokerson
 145  * Fixes to G.729 compatibility.
 146  *
 147  * Revision 3.85  2001/01/23 21:30:36  eokerson
 148  * Added verbage about cards supported.
 149  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 150  *
 151  * Revision 3.84  2001/01/22 23:32:10  eokerson
 152  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 153  *
 154  * Revision 3.83  2001/01/19 14:51:41  eokerson
 155  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 156  *
 157  * Revision 3.82  2001/01/19 00:34:49  eokerson
 158  * Added verbosity to write overlap errors.
 159  *
 160  * Revision 3.81  2001/01/18 23:56:54  eokerson
 161  * Fixed PSTN line test functions.
 162  *
 163  * Revision 3.80  2001/01/18 22:29:27  eokerson
 164  * Updated AEC/AGC values for different cards.
 165  *
 166  * Revision 3.79  2001/01/17 02:58:54  eokerson
 167  * Fixed AEC reset after Caller ID.
 168  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 169  *
 170  * Revision 3.78  2001/01/16 19:43:09  eokerson
 171  * Added support for Linux 2.4.x kernels.
 172  *
 173  * Revision 3.77  2001/01/09 04:00:52  eokerson
 174  * Linetest will now test the line, even if it has previously succeded.
 175  *
 176  * Revision 3.76  2001/01/08 19:27:00  eokerson
 177  * Fixed problem with standard cable on Internet PhoneCARD.
 178  *
 179  * Revision 3.75  2000/12/22 16:52:14  eokerson
 180  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 181  *
 182  * Revision 3.74  2000/12/08 22:41:50  eokerson
 183  * Added capability for G729B.
 184  *
 185  * Revision 3.73  2000/12/07 23:35:16  eokerson
 186  * Added capability to have different ring pattern before CallerID data.
 187  * Added hookstate checks in CallerID routines to stop FSK.
 188  *
 189  * Revision 3.72  2000/12/06 19:31:31  eokerson
 190  * Modified signal behavior to only send one signal per event.
 191  *
 192  * Revision 3.71  2000/12/06 03:23:08  eokerson
 193  * Fixed CallerID on Call Waiting.
 194  *
 195  * Revision 3.70  2000/12/04 21:29:37  eokerson
 196  * Added checking to Smart Cable gain functions.
 197  *
 198  * Revision 3.69  2000/12/04 21:05:20  eokerson
 199  * Changed ixjdebug levels.
 200  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 201  *
 202  * Revision 3.68  2000/12/04 00:17:21  craigs
 203  * Changed mixer voice gain to +6dB rather than 0dB
 204  *
 205  * Revision 3.67  2000/11/30 21:25:51  eokerson
 206  * Fixed write signal errors.
 207  *
 208  * Revision 3.66  2000/11/29 22:42:44  eokerson
 209  * Fixed PSTN ring detect problems.
 210  *
 211  * Revision 3.65  2000/11/29 07:31:55  craigs
 212  * Added new 425Hz filter co-efficients
 213  * Added card-specific DTMF prescaler initialisation
 214  *
 215  * Revision 3.64  2000/11/28 14:03:32  craigs
 216  * Changed certain mixer initialisations to be 0dB rather than 12dB
 217  * Added additional information to /proc/ixj
 218  *
 219  * Revision 3.63  2000/11/28 11:38:41  craigs
 220  * Added display of AEC modes in AUTO and AGC mode
 221  *
 222  * Revision 3.62  2000/11/28 04:05:44  eokerson
 223  * Improved PSTN ring detection routine.
 224  *
 225  * Revision 3.61  2000/11/27 21:53:12  eokerson
 226  * Fixed flash detection.
 227  *
 228  * Revision 3.60  2000/11/27 15:57:29  eokerson
 229  * More work on G.729 load routines.
 230  *
 231  * Revision 3.59  2000/11/25 21:55:12  eokerson
 232  * Fixed errors in G.729 load routine.
 233  *
 234  * Revision 3.58  2000/11/25 04:08:29  eokerson
 235  * Added board locks around G.729 and TS85 load routines.
 236  *
 237  * Revision 3.57  2000/11/24 05:35:17  craigs
 238  * Added ability to retrieve mixer values on LineJACK
 239  * Added complete initialisation of all mixer values at startup
 240  * Fixed spelling mistake
 241  *
 242  * Revision 3.56  2000/11/23 02:52:11  robertj
 243  * Added cvs change log keyword.
 244  * Fixed bug in capabilities list when using G.729 module.
 245  *
 246  */
 247
 248 #include "ixj-ver.h"
 249
 250 #define PERFMON_STATS
 251 #define IXJDEBUG 0
 252 #define MAXRINGS 5
 253
 254 #include <linux/module.h>
 255
 256 #include <linux/init.h>
 257 #include <linux/sched.h>
 258 #include <linux/kernel.h>       /* printk() */
 259 #include <linux/fs.h>           /* everything... */
 260 #include <linux/errno.h>        /* error codes */
 261 #include <linux/slab.h>
 262 #include <linux/mm.h>
 263 #include <linux/ioport.h>
 264 #include <linux/interrupt.h>
 265 #include <linux/proc_fs.h>
 266 #include <linux/poll.h>
 267 #include <linux/timer.h>
 268 #include <linux/delay.h>
 269 #include <linux/pci.h>
 270
 271 #include <asm/io.h>
 272 #include <asm/uaccess.h>
 273
 274 #include <linux/isapnp.h>
 275
 276 #include "ixj.h"
 277
 278 #define TYPE(inode) (iminor(inode) >> 4)
 279 #define NUM(inode) (iminor(inode) & 0xf)
 280
 281 static int ixjdebug;
 282 static int hertz = HZ;
 283 static int samplerate = 100;
 284
 285 module_param(ixjdebug, int, 0);
 286
 287 /************************************************************************
 288 *
 289 * ixjdebug meanings are now bit mapped instead of level based
 290 * Values can be or'ed together to turn on multiple messages
 291 *
 292 * bit  0 (0x0001) = any failure
 293 * bit  1 (0x0002) = general messages
 294 * bit  2 (0x0004) = POTS ringing related
 295 * bit  3 (0x0008) = PSTN events
 296 * bit  4 (0x0010) = PSTN Cadence state details
 297 * bit  5 (0x0020) = Tone detection triggers
 298 * bit  6 (0x0040) = Tone detection cadence details
 299 * bit  7 (0x0080) = ioctl tracking
 300 * bit  8 (0x0100) = signal tracking
 301 * bit  9 (0x0200) = CallerID generation details
 302 *
 303 ************************************************************************/
 304
 305 #ifdef IXJ_DYN_ALLOC
 306
 307 static IXJ *ixj[IXJMAX];
 308 #define get_ixj(b)      ixj[(b)]
 309
 310 /*
 311  *      Allocate a free IXJ device
 312  */
 313
 314 static IXJ *ixj_alloc()
 315 {
 316         for(cnt=0; cnt<IXJMAX; cnt++)
 317         {
 318                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 319                 {
 320                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 321                         if (j == NULL)
 322                                 return NULL;
 323                         ixj[cnt] = j;
 324                         return j;
 325                 }
 326         }
 327         return NULL;
 328 }
 329
 330 static void ixj_fsk_free(IXJ *j)
 331 {
 332         if(j->fskdata != NULL) {
 333                 kfree(j->fskdata);
 334                 j->fskdata = NULL;
 335         }
 336 }
 337
 338 static void ixj_fsk_alloc(IXJ *j)
 339 {
 340         if(!j->fskdata) {
 341                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 342                 if (!j->fskdata) {
 343                         if(ixjdebug & 0x0200) {
 344                                 printk("IXJ phone%d - allocate failed\n", j->board);
 345                         }
 346                         return;
 347                 } else {
 348                         j->fsksize = 8000;
 349                         if(ixjdebug & 0x0200) {
 350                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 351                         }
 352                 }
 353         }
 354 }
 355
 356 #else
 357
 358 static IXJ ixj[IXJMAX];
 359 #define get_ixj(b)      (&ixj[(b)])
 360
 361 /*
 362  *      Allocate a free IXJ device
 363  */
 364
 365 static IXJ *ixj_alloc(void)
 366 {
 367         int cnt;
 368         for(cnt=0; cnt<IXJMAX; cnt++) {
 369                 if(!ixj[cnt].DSPbase)
 370                         return &ixj[cnt];
 371         }
 372         return NULL;
 373 }
 374
 375 static inline void ixj_fsk_free(IXJ *j) {;}
 376
 377 static inline void ixj_fsk_alloc(IXJ *j)
 378 {
 379         j->fsksize = 8000;
 380 }
 381
 382 #endif
 383
 384 #ifdef PERFMON_STATS
 385 #define ixj_perfmon(x)  ((x)++)
 386 #else
 387 #define ixj_perfmon(x)  do { } while(0)
 388 #endif
 389
 390 static int ixj_convert_loaded;
 391
 392 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 393
 394 /************************************************************************
 395 *
 396 * These are function definitions to allow external modules to register
 397 * enhanced functionality call backs.
 398 *
 399 ************************************************************************/
 400
 401 static int Stub(IXJ * J, unsigned long arg)
 402 {
 403         return 0;
 404 }
 405
 406 static IXJ_REGFUNC ixj_PreRead = &Stub;
 407 static IXJ_REGFUNC ixj_PostRead = &Stub;
 408 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 409 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 410
 411 static void ixj_read_frame(IXJ *j);
 412 static void ixj_write_frame(IXJ *j);
 413 static void ixj_init_timer(IXJ *j);
 414 static void ixj_add_timer(IXJ * j);
 415 static void ixj_timeout(unsigned long ptr);
 416 static int read_filters(IXJ *j);
 417 static int LineMonitor(IXJ *j);
 418 static int ixj_fasync(int fd, struct file *, int mode);
 419 static int ixj_set_port(IXJ *j, int arg);
 420 static int ixj_set_pots(IXJ *j, int arg);
 421 static int ixj_hookstate(IXJ *j);
 422 static int ixj_record_start(IXJ *j);
 423 static void ixj_record_stop(IXJ *j);
 424 static void set_rec_volume(IXJ *j, int volume);
 425 static int get_rec_volume(IXJ *j);
 426 static int set_rec_codec(IXJ *j, int rate);
 427 static void ixj_vad(IXJ *j, int arg);
 428 static int ixj_play_start(IXJ *j);
 429 static void ixj_play_stop(IXJ *j);
 430 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 431 static int ixj_set_tone_off(unsigned short, IXJ *j);
 432 static int ixj_play_tone(IXJ *j, char tone);
 433 static void ixj_aec_start(IXJ *j, int level);
 434 static int idle(IXJ *j);
 435 static void ixj_ring_on(IXJ *j);
 436 static void ixj_ring_off(IXJ *j);
 437 static void aec_stop(IXJ *j);
 438 static void ixj_ringback(IXJ *j);
 439 static void ixj_busytone(IXJ *j);
 440 static void ixj_dialtone(IXJ *j);
 441 static void ixj_cpt_stop(IXJ *j);
 442 static char daa_int_read(IXJ *j);
 443 static char daa_CR_read(IXJ *j, int cr);
 444 static int daa_set_mode(IXJ *j, int mode);
 445 static int ixj_linetest(IXJ *j);
 446 static int ixj_daa_write(IXJ *j);
 447 static int ixj_daa_cid_read(IXJ *j);
 448 static void DAA_Coeff_US(IXJ *j);
 449 static void DAA_Coeff_UK(IXJ *j);
 450 static void DAA_Coeff_France(IXJ *j);
 451 static void DAA_Coeff_Germany(IXJ *j);
 452 static void DAA_Coeff_Australia(IXJ *j);
 453 static void DAA_Coeff_Japan(IXJ *j);
 454 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 455 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 456 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 457 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 458 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 459 /* Serial Control Interface funtions */
 460 static int SCI_Control(IXJ *j, int control);
 461 static int SCI_Prepare(IXJ *j);
 462 static int SCI_WaitHighSCI(IXJ *j);
 463 static int SCI_WaitLowSCI(IXJ *j);
 464 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 465 static int ixj_PCcontrol_wait(IXJ *j);
 466 static void ixj_pre_cid(IXJ *j);
 467 static void ixj_write_cid(IXJ *j);
 468 static void ixj_write_cid_bit(IXJ *j, int bit);
 469 static int set_base_frame(IXJ *j, int size);
 470 static int set_play_codec(IXJ *j, int rate);
 471 static void set_rec_depth(IXJ *j, int depth);
 472 static int ixj_mixer(long val, IXJ *j);
 473
 474 /************************************************************************
 475 CT8020/CT8021 Host Programmers Model
 476 Host address    Function                                        Access
 477 DSPbase +
 478 0-1             Aux Software Status Register (reserved)         Read Only
 479 2-3             Software Status Register                        Read Only
 480 4-5             Aux Software Control Register (reserved)        Read Write
 481 6-7             Software Control Register                       Read Write
 482 8-9             Hardware Status Register                        Read Only
 483 A-B             Hardware Control Register                       Read Write
 484 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 485 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 486 ************************************************************************/
 487
 488 static inline void ixj_read_HSR(IXJ *j)
 489 {
 490         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 491         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 492 }
 493
 494 static inline int IsControlReady(IXJ *j)
 495 {
 496         ixj_read_HSR(j);
 497         return j->hsr.bits.controlrdy ? 1 : 0;
 498 }
 499
 500 static inline int IsPCControlReady(IXJ *j)
 501 {
 502         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 503         return j->pccr1.bits.crr ? 1 : 0;
 504 }
 505
 506 static inline int IsStatusReady(IXJ *j)
 507 {
 508         ixj_read_HSR(j);
 509         return j->hsr.bits.statusrdy ? 1 : 0;
 510 }
 511
 512 static inline int IsRxReady(IXJ *j)
 513 {
 514         ixj_read_HSR(j);
 515         ixj_perfmon(j->rxreadycheck);
 516         return j->hsr.bits.rxrdy ? 1 : 0;
 517 }
 518
 519 static inline int IsTxReady(IXJ *j)
 520 {
 521         ixj_read_HSR(j);
 522         ixj_perfmon(j->txreadycheck);
 523         return j->hsr.bits.txrdy ? 1 : 0;
 524 }
 525
 526 static inline void set_play_volume(IXJ *j, int volume)
 527 {
 528         if (ixjdebug & 0x0002)
 529                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 530         ixj_WriteDSPCommand(0xCF02, j);
 531         ixj_WriteDSPCommand(volume, j);
 532 }
 533
 534 static int set_play_volume_linear(IXJ *j, int volume)
 535 {
 536         int newvolume, dspplaymax;
 537
 538         if (ixjdebug & 0x0002)
 539                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 540         if(volume > 100 || volume < 0) {
 541                 return -1;
 542         }
 543
 544         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 545         switch (j->cardtype) {
 546         case QTI_PHONEJACK:
 547                 dspplaymax = 0x380;
 548                 break;
 549         case QTI_LINEJACK:
 550                 if(j->port == PORT_PSTN) {
 551                         dspplaymax = 0x48;
 552                 } else {
 553                         dspplaymax = 0x100;
 554                 }
 555                 break;
 556         case QTI_PHONEJACK_LITE:
 557                 dspplaymax = 0x380;
 558                 break;
 559         case QTI_PHONEJACK_PCI:
 560                 dspplaymax = 0x6C;
 561                 break;
 562         case QTI_PHONECARD:
 563                 dspplaymax = 0x50;
 564                 break;
 565         default:
 566                 return -1;
 567         }
 568         newvolume = (dspplaymax * volume) / 100;
 569         set_play_volume(j, newvolume);
 570         return 0;
 571 }
 572
 573 static inline void set_play_depth(IXJ *j, int depth)
 574 {
 575         if (depth > 60)
 576                 depth = 60;
 577         if (depth < 0)
 578                 depth = 0;
 579         ixj_WriteDSPCommand(0x5280 + depth, j);
 580 }
 581
 582 static inline int get_play_volume(IXJ *j)
 583 {
 584         ixj_WriteDSPCommand(0xCF00, j);
 585         return j->ssr.high << 8 | j->ssr.low;
 586 }
 587
 588 static int get_play_volume_linear(IXJ *j)
 589 {
 590         int volume, newvolume, dspplaymax;
 591
 592         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 593         switch (j->cardtype) {
 594         case QTI_PHONEJACK:
 595                 dspplaymax = 0x380;
 596                 break;
 597         case QTI_LINEJACK:
 598                 if(j->port == PORT_PSTN) {
 599                         dspplaymax = 0x48;
 600                 } else {
 601                         dspplaymax = 0x100;
 602                 }
 603                 break;
 604         case QTI_PHONEJACK_LITE:
 605                 dspplaymax = 0x380;
 606                 break;
 607         case QTI_PHONEJACK_PCI:
 608                 dspplaymax = 0x6C;
 609                 break;
 610         case QTI_PHONECARD:
 611                 dspplaymax = 100;
 612                 break;
 613         default:
 614                 return -1;
 615         }
 616         volume = get_play_volume(j);
 617         newvolume = (volume * 100) / dspplaymax;
 618         if(newvolume > 100)
 619                 newvolume = 100;
 620         return newvolume;
 621 }
 622
 623 static inline BYTE SLIC_GetState(IXJ *j)
 624 {
 625         if (j->cardtype == QTI_PHONECARD) {
 626                 j->pccr1.byte = 0;
 627                 j->psccr.bits.dev = 3;
 628                 j->psccr.bits.rw = 1;
 629                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 630                 ixj_PCcontrol_wait(j);
 631                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 632                 ixj_PCcontrol_wait(j);
 633                 if (j->pslic.bits.powerdown)
 634                         return PLD_SLIC_STATE_OC;
 635                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 636                         return PLD_SLIC_STATE_ACTIVE;
 637                 else
 638                         return PLD_SLIC_STATE_RINGING;
 639         } else {
 640                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 641         }
 642         return j->pld_slicr.bits.state;
 643 }
 644
 645 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
 646 {
 647         BOOL fRetVal = FALSE;
 648
 649         if (j->cardtype == QTI_PHONECARD) {
 650                 if (j->flags.pcmciasct) {
 651                         switch (byState) {
 652                         case PLD_SLIC_STATE_TIPOPEN:
 653                         case PLD_SLIC_STATE_OC:
 654                                 j->pslic.bits.powerdown = 1;
 655                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 656                                 fRetVal = TRUE;
 657                                 break;
 658                         case PLD_SLIC_STATE_RINGING:
 659                                 if (j->readers || j->writers) {
 660                                         j->pslic.bits.powerdown = 0;
 661                                         j->pslic.bits.ring0 = 1;
 662                                         j->pslic.bits.ring1 = 0;
 663                                         fRetVal = TRUE;
 664                                 }
 665                                 break;
 666                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 667
 668                         case PLD_SLIC_STATE_STANDBY:
 669                         case PLD_SLIC_STATE_ACTIVE:
 670                                 if (j->readers || j->writers) {
 671                                         j->pslic.bits.powerdown = 0;
 672                                 } else {
 673                                         j->pslic.bits.powerdown = 1;
 674                                 }
 675                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 676                                 fRetVal = TRUE;
 677                                 break;
 678                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 679
 680                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 681
 682                         default:
 683                                 fRetVal = FALSE;
 684                                 break;
 685                         }
 686                         j->psccr.bits.dev = 3;
 687                         j->psccr.bits.rw = 0;
 688                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 689                         ixj_PCcontrol_wait(j);
 690                 }
 691         } else {
 692                 /* Set the C1, C2, C3 & B2EN signals. */
 693                 switch (byState) {
 694                 case PLD_SLIC_STATE_OC:
 695                         j->pld_slicw.bits.c1 = 0;
 696                         j->pld_slicw.bits.c2 = 0;
 697                         j->pld_slicw.bits.c3 = 0;
 698                         j->pld_slicw.bits.b2en = 0;
 699                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 700                         fRetVal = TRUE;
 701                         break;
 702                 case PLD_SLIC_STATE_RINGING:
 703                         j->pld_slicw.bits.c1 = 1;
 704                         j->pld_slicw.bits.c2 = 0;
 705                         j->pld_slicw.bits.c3 = 0;
 706                         j->pld_slicw.bits.b2en = 1;
 707                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 708                         fRetVal = TRUE;
 709                         break;
 710                 case PLD_SLIC_STATE_ACTIVE:
 711                         j->pld_slicw.bits.c1 = 0;
 712                         j->pld_slicw.bits.c2 = 1;
 713                         j->pld_slicw.bits.c3 = 0;
 714                         j->pld_slicw.bits.b2en = 0;
 715                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 716                         fRetVal = TRUE;
 717                         break;
 718                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 719
 720                         j->pld_slicw.bits.c1 = 1;
 721                         j->pld_slicw.bits.c2 = 1;
 722                         j->pld_slicw.bits.c3 = 0;
 723                         j->pld_slicw.bits.b2en = 0;
 724                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 725                         fRetVal = TRUE;
 726                         break;
 727                 case PLD_SLIC_STATE_TIPOPEN:
 728                         j->pld_slicw.bits.c1 = 0;
 729                         j->pld_slicw.bits.c2 = 0;
 730                         j->pld_slicw.bits.c3 = 1;
 731                         j->pld_slicw.bits.b2en = 0;
 732                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 733                         fRetVal = TRUE;
 734                         break;
 735                 case PLD_SLIC_STATE_STANDBY:
 736                         j->pld_slicw.bits.c1 = 1;
 737                         j->pld_slicw.bits.c2 = 0;
 738                         j->pld_slicw.bits.c3 = 1;
 739                         j->pld_slicw.bits.b2en = 1;
 740                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 741                         fRetVal = TRUE;
 742                         break;
 743                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 744
 745                         j->pld_slicw.bits.c1 = 0;
 746                         j->pld_slicw.bits.c2 = 1;
 747                         j->pld_slicw.bits.c3 = 1;
 748                         j->pld_slicw.bits.b2en = 0;
 749                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 750                         fRetVal = TRUE;
 751                         break;
 752                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 753
 754                         j->pld_slicw.bits.c1 = 1;
 755                         j->pld_slicw.bits.c2 = 1;
 756                         j->pld_slicw.bits.c3 = 1;
 757                         j->pld_slicw.bits.b2en = 0;
 758                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 759                         fRetVal = TRUE;
 760                         break;
 761                 default:
 762                         fRetVal = FALSE;
 763                         break;
 764                 }
 765         }
 766
 767         return fRetVal;
 768 }
 769
 770 static int ixj_wink(IXJ *j)
 771 {
 772         BYTE slicnow;
 773
 774         slicnow = SLIC_GetState(j);
 775
 776         j->pots_winkstart = jiffies;
 777         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 778
 779         while (time_before(jiffies, j->pots_winkstart + j->winktime)) {
 780                 set_current_state(TASK_INTERRUPTIBLE);
 781                 schedule_timeout(1);
 782         }
 783
 784         SLIC_SetState(slicnow, j);
 785         return 0;
 786 }
 787
 788 static void ixj_init_timer(IXJ *j)
 789 {
 790         init_timer(&j->timer);
 791         j->timer.function = ixj_timeout;
 792         j->timer.data = (unsigned long)j;
 793 }
 794
 795 static void ixj_add_timer(IXJ *j)
 796 {
 797         j->timer.expires = jiffies + (hertz / samplerate);
 798         add_timer(&j->timer);
 799 }
 800
 801 static void ixj_tone_timeout(IXJ *j)
 802 {
 803         IXJ_TONE ti;
 804
 805         j->tone_state++;
 806         if (j->tone_state == 3) {
 807                 j->tone_state = 0;
 808                 if (j->cadence_t) {
 809                         j->tone_cadence_state++;
 810                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 811                                 switch (j->cadence_t->termination) {
 812                                 case PLAY_ONCE:
 813                                         ixj_cpt_stop(j);
 814                                         break;
 815                                 case REPEAT_LAST_ELEMENT:
 816                                         j->tone_cadence_state--;
 817                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 818                                         break;
 819                                 case REPEAT_ALL:
 820                                         j->tone_cadence_state = 0;
 821                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 822                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 823                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 824                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 825                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 826                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 827                                                 ixj_init_tone(j, &ti);
 828                                         }
 829                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 830                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 831                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 832                                         break;
 833                                 }
 834                         } else {
 835                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 836                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 837                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 838                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 839                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 840                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 841                                         ixj_init_tone(j, &ti);
 842                                 }
 843                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 844                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 845                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 846                         }
 847                 }
 848         }
 849 }
 850
 851 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 852 {
 853         if(j->ixj_signals[event]) {
 854                 if(ixjdebug & 0x0100)
 855                         printk("Sending signal for event %d\n", event);
 856                         /* Send apps notice of change */
 857                 /* see config.h for macro definition */
 858                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 859         }
 860 }
 861
 862 static void ixj_pstn_state(IXJ *j)
 863 {
 864         int var;
 865         union XOPXR0 XR0, daaint;
 866
 867         var = 10;
 868
 869         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 870         daaint.reg = 0;
 871         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 872
 873         j->pld_scrr.byte = inb_p(j->XILINXbase);
 874         if (j->pld_scrr.bits.daaflag) {
 875                 daa_int_read(j);
 876                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 877                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 878                                 daaint.bitreg.RING = 1;
 879                                 if(ixjdebug & 0x0008) {
 880                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 881                                 }
 882                         } else {
 883                                 daa_set_mode(j, SOP_PU_RESET);
 884                         }
 885                 }
 886                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 887                         daaint.bitreg.Caller_ID = 1;
 888                         j->pstn_cid_intr = 1;
 889                         j->pstn_cid_received = jiffies;
 890                         if(ixjdebug & 0x0008) {
 891                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 892                         }
 893                 }
 894                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 895                         daaint.bitreg.Cadence = 1;
 896                         if(ixjdebug & 0x0008) {
 897                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 898                         }
 899                 }
 900                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 901                         daaint.bitreg.VDD_OK = 1;
 902                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 903                 }
 904         }
 905         daa_CR_read(j, 1);
 906         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)) {
 907                 daaint.bitreg.RMR = 1;
 908                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 909                 if(ixjdebug & 0x0008) {
 910                         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);
 911                 }
 912                 j->pstn_prev_rmr = j->pstn_last_rmr;
 913                 j->pstn_last_rmr = jiffies;
 914         }
 915         switch(j->daa_mode) {
 916                 case SOP_PU_SLEEP:
 917                         if (daaint.bitreg.RING) {
 918                                 if (!j->flags.pstn_ringing) {
 919                                         if (j->daa_mode != SOP_PU_RINGING) {
 920                                                 j->pstn_ring_int = jiffies;
 921                                                 daa_set_mode(j, SOP_PU_RINGING);
 922                                         }
 923                                 }
 924                         }
 925                         break;
 926                 case SOP_PU_RINGING:
 927                         if (daaint.bitreg.RMR) {
 928                                 if (ixjdebug & 0x0008) {
 929                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 930                                 }
 931                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 932                                         j->flags.pstn_rmr = 1;
 933                                         j->pstn_ring_start = jiffies;
 934                                         j->pstn_ring_stop = 0;
 935                                         j->ex.bits.pstn_ring = 0;
 936                                         if (j->cadence_f[4].state == 0) {
 937                                                 j->cadence_f[4].state = 1;
 938                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 939                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 940                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 941                                         } else if (j->cadence_f[4].state == 2) {
 942                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 943                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 944                                                         if (j->cadence_f[4].on2) {
 945                                                                 j->cadence_f[4].state = 3;
 946                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 947                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 948                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 949                                                         } else {
 950                                                                 j->cadence_f[4].state = 7;
 951                                                         }
 952                                                 } else {
 953                                                         if (ixjdebug & 0x0008) {
 954                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 955                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 956                                                                                 j->cadence_f[4].off1);
 957                                                         }
 958                                                         j->cadence_f[4].state = 0;
 959                                                 }
 960                                         } else if (j->cadence_f[4].state == 4) {
 961                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 962                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 963                                                         if (j->cadence_f[4].on3) {
 964                                                                 j->cadence_f[4].state = 5;
 965                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 966                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 967                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 968                                                         } else {
 969                                                                 j->cadence_f[4].state = 7;
 970                                                         }
 971                                                 } else {
 972                                                         if (ixjdebug & 0x0008) {
 973                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 974                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 975                                                                                 j->cadence_f[4].off2);
 976                                                         }
 977                                                         j->cadence_f[4].state = 0;
 978                                                 }
 979                                         } else if (j->cadence_f[4].state == 6) {
 980                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 981                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 982                                                         j->cadence_f[4].state = 7;
 983                                                 } else {
 984                                                         if (ixjdebug & 0x0008) {
 985                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 986                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 987                                                                                 j->cadence_f[4].off3);
 988                                                         }
 989                                                         j->cadence_f[4].state = 0;
 990                                                 }
 991                                         } else {
 992                                                 j->cadence_f[4].state = 0;
 993                                         }
 994                                 } else {                                /* Falling edge of RMR */
 995                                         j->pstn_ring_start = 0;
 996                                         j->pstn_ring_stop = jiffies;
 997                                         if (j->cadence_f[4].state == 1) {
 998                                                 if(!j->cadence_f[4].on1) {
 999                                                         j->cadence_f[4].state = 7;
1000                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1001                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1002                                                         if (j->cadence_f[4].off1) {
1003                                                                 j->cadence_f[4].state = 2;
1004                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1005                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1006                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1007                                                         } else {
1008                                                                 j->cadence_f[4].state = 7;
1009                                                         }
1010                                                 } else {
1011                                                         if (ixjdebug & 0x0008) {
1012                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1013                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1014                                                                                 j->cadence_f[4].on1);
1015                                                         }
1016                                                         j->cadence_f[4].state = 0;
1017                                                 }
1018                                         } else if (j->cadence_f[4].state == 3) {
1019                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1020                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1021                                                         if (j->cadence_f[4].off2) {
1022                                                                 j->cadence_f[4].state = 4;
1023                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1024                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1025                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1026                                                         } else {
1027                                                                 j->cadence_f[4].state = 7;
1028                                                         }
1029                                                 } else {
1030                                                         if (ixjdebug & 0x0008) {
1031                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1032                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1033                                                                                 j->cadence_f[4].on2);
1034                                                         }
1035                                                         j->cadence_f[4].state = 0;
1036                                                 }
1037                                         } else if (j->cadence_f[4].state == 5) {
1038                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1039                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1040                                                         if (j->cadence_f[4].off3) {
1041                                                                 j->cadence_f[4].state = 6;
1042                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1043                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1044                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1045                                                         } else {
1046                                                                 j->cadence_f[4].state = 7;
1047                                                         }
1048                                                 } else {
1049                                                         j->cadence_f[4].state = 0;
1050                                                 }
1051                                         } else {
1052                                                 if (ixjdebug & 0x0008) {
1053                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1054                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1055                                                                         j->cadence_f[4].on3);
1056                                                 }
1057                                                 j->cadence_f[4].state = 0;
1058                                         }
1059                                 }
1060                                 if (ixjdebug & 0x0010) {
1061                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1062                                 }
1063                                 if (ixjdebug & 0x0010) {
1064                                         switch(j->cadence_f[4].state) {
1065                                                 case 1:
1066                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1067                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1068                                                         break;
1069                                                 case 2:
1070                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1071                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1072                                                         break;
1073                                                 case 3:
1074                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1075                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1076                                                         break;
1077                                                 case 4:
1078                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1079                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1080                                                         break;
1081                                                 case 5:
1082                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1083                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1084                                                         break;
1085                                                 case 6:
1086                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1087                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1088                                                         break;
1089                                         }
1090                                 }
1091                         }
1092                         if (j->cadence_f[4].state == 7) {
1093                                 j->cadence_f[4].state = 0;
1094                                 j->pstn_ring_stop = jiffies;
1095                                 j->ex.bits.pstn_ring = 1;
1096                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1097                                 if(ixjdebug & 0x0008) {
1098                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1099                                 }
1100                         }
1101                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1102                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1103                                 if(ixjdebug & 0x0008) {
1104                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1105                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1106                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1107                                 }
1108                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1109                                 daa_set_mode(j, SOP_PU_SLEEP);
1110                         }
1111                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1112                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1113                                 ixj_daa_cid_read(j);
1114                                 j->ex.bits.caller_id = 1;
1115                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1116                                 j->pstn_cid_intr = 0;
1117                         }
1118                         if (daaint.bitreg.Cadence) {
1119                                 if(ixjdebug & 0x0008) {
1120                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1121                                 }
1122                                 daa_set_mode(j, SOP_PU_SLEEP);
1123                                 j->ex.bits.pstn_ring = 0;
1124                         }
1125                         break;
1126                 case SOP_PU_CONVERSATION:
1127                         if (daaint.bitreg.VDD_OK) {
1128                                 if(!daaint.bitreg.SI_0) {
1129                                         if (!j->pstn_winkstart) {
1130                                                 if(ixjdebug & 0x0008) {
1131                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1132                                                 }
1133                                                 j->pstn_winkstart = jiffies;
1134                                         }
1135                                 } else {
1136                                         if (j->pstn_winkstart) {
1137                                                 if(ixjdebug & 0x0008) {
1138                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1139                                                 }
1140                                                 j->pstn_winkstart = 0;
1141                                         }
1142                                 }
1143                         }
1144                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1145                                 if(ixjdebug & 0x0008) {
1146                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1147                                 }
1148                                 daa_set_mode(j, SOP_PU_SLEEP);
1149                                 j->pstn_winkstart = 0;
1150                                 j->ex.bits.pstn_wink = 1;
1151                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1152                         }
1153                         break;
1154         }
1155 }
1156
1157 static void ixj_timeout(unsigned long ptr)
1158 {
1159         int board;
1160         unsigned long jifon;
1161         IXJ *j = (IXJ *)ptr;
1162         board = j->board;
1163
1164         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1165                 ixj_perfmon(j->timerchecks);
1166                 j->hookstate = ixj_hookstate(j);
1167                 if (j->tone_state) {
1168                         if (!(j->hookstate)) {
1169                                 ixj_cpt_stop(j);
1170                                 if (j->m_hook) {
1171                                         j->m_hook = 0;
1172                                         j->ex.bits.hookstate = 1;
1173                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1174                                 }
1175                                 clear_bit(board, &j->busyflags);
1176                                 ixj_add_timer(j);
1177                                 return;
1178                         }
1179                         if (j->tone_state == 1)
1180                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1181                         else
1182                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1183                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1184                                 if (j->tone_state == 1) {
1185                                         ixj_play_tone(j, j->tone_index);
1186                                         if (j->dsp.low == 0x20) {
1187                                                 clear_bit(board, &j->busyflags);
1188                                                 ixj_add_timer(j);
1189                                                 return;
1190                                         }
1191                                 } else {
1192                                         ixj_play_tone(j, 0);
1193                                         if (j->dsp.low == 0x20) {
1194                                                 clear_bit(board, &j->busyflags);
1195                                                 ixj_add_timer(j);
1196                                                 return;
1197                                         }
1198                                 }
1199                         } else {
1200                                 ixj_tone_timeout(j);
1201                                 if (j->flags.dialtone) {
1202                                         ixj_dialtone(j);
1203                                 }
1204                                 if (j->flags.busytone) {
1205                                         ixj_busytone(j);
1206                                         if (j->dsp.low == 0x20) {
1207                                                 clear_bit(board, &j->busyflags);
1208                                                 ixj_add_timer(j);
1209                                                 return;
1210                                         }
1211                                 }
1212                                 if (j->flags.ringback) {
1213                                         ixj_ringback(j);
1214                                         if (j->dsp.low == 0x20) {
1215                                                 clear_bit(board, &j->busyflags);
1216                                                 ixj_add_timer(j);
1217                                                 return;
1218                                         }
1219                                 }
1220                                 if (!j->tone_state) {
1221                                         ixj_cpt_stop(j);
1222                                 }
1223                         }
1224                 }
1225                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1226                         if (IsRxReady(j)) {
1227                                 ixj_read_frame(j);
1228                         }
1229                         if (IsTxReady(j)) {
1230                                 ixj_write_frame(j);
1231                         }
1232                 }
1233                 if (j->flags.cringing) {
1234                         if (j->hookstate & 1) {
1235                                 j->flags.cringing = 0;
1236                                 ixj_ring_off(j);
1237                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1238                                 switch(j->cadence_f[5].state) {
1239                                         case 0:
1240                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1241                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1242                                                         if(ixjdebug & 0x0004) {
1243                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1244                                                         }
1245                                                         ixj_ring_on(j);
1246                                                 }
1247                                                 j->cadence_f[5].state = 1;
1248                                                 break;
1249                                         case 1:
1250                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1251                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1252                                                         if(ixjdebug & 0x0004) {
1253                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1254                                                         }
1255                                                         ixj_ring_off(j);
1256                                                         j->cadence_f[5].state = 2;
1257                                                 }
1258                                                 break;
1259                                         case 2:
1260                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1261                                                         if(ixjdebug & 0x0004) {
1262                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1263                                                         }
1264                                                         ixj_ring_on(j);
1265                                                         if (j->cadence_f[5].on2) {
1266                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1267                                                                 j->cadence_f[5].state = 3;
1268                                                         } else {
1269                                                                 j->cadence_f[5].state = 7;
1270                                                         }
1271                                                 }
1272                                                 break;
1273                                         case 3:
1274                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1275                                                         if(ixjdebug & 0x0004) {
1276                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1277                                                         }
1278                                                         ixj_ring_off(j);
1279                                                         if (j->cadence_f[5].off2) {
1280                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1281                                                                 j->cadence_f[5].state = 4;
1282                                                         } else {
1283                                                                 j->cadence_f[5].state = 7;
1284                                                         }
1285                                                 }
1286                                                 break;
1287                                         case 4:
1288                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1289                                                         if(ixjdebug & 0x0004) {
1290                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1291                                                         }
1292                                                         ixj_ring_on(j);
1293                                                         if (j->cadence_f[5].on3) {
1294                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1295                                                                 j->cadence_f[5].state = 5;
1296                                                         } else {
1297                                                                 j->cadence_f[5].state = 7;
1298                                                         }
1299                                                 }
1300                                                 break;
1301                                         case 5:
1302                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1303                                                         if(ixjdebug & 0x0004) {
1304                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1305                                                         }
1306                                                         ixj_ring_off(j);
1307                                                         if (j->cadence_f[5].off3) {
1308                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1309                                                                 j->cadence_f[5].state = 6;
1310                                                         } else {
1311                                                                 j->cadence_f[5].state = 7;
1312                                                         }
1313                                                 }
1314                                                 break;
1315                                         case 6:
1316                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1317                                                         if(ixjdebug & 0x0004) {
1318                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1319                                                         }
1320                                                         j->cadence_f[5].state = 7;
1321                                                 }
1322                                                 break;
1323                                         case 7:
1324                                                 if(ixjdebug & 0x0004) {
1325                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1326                                                 }
1327                                                 j->flags.cidring = 1;
1328                                                 j->cadence_f[5].state = 0;
1329                                                 break;
1330                                 }
1331                                 if (j->flags.cidring && !j->flags.cidsent) {
1332                                         j->flags.cidsent = 1;
1333                                         if(j->fskdcnt) {
1334                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1335                                                 ixj_pre_cid(j);
1336                                         }
1337                                         j->flags.cidring = 0;
1338                                 }
1339                                 clear_bit(board, &j->busyflags);
1340                                 ixj_add_timer(j);
1341                                 return;
1342                         } else {
1343                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1344                                         if (j->flags.cidring && !j->flags.cidsent) {
1345                                                 j->flags.cidsent = 1;
1346                                                 if(j->fskdcnt) {
1347                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1348                                                         ixj_pre_cid(j);
1349                                                 }
1350                                                 j->flags.cidring = 0;
1351                                         }
1352                                         j->ring_cadence_t--;
1353                                         if (j->ring_cadence_t == -1)
1354                                                 j->ring_cadence_t = 15;
1355                                         j->ring_cadence_jif = jiffies;
1356
1357                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1358                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1359                                                         j->flags.firstring = 1;
1360                                                 else
1361                                                         ixj_ring_on(j);
1362                                         } else {
1363                                                 ixj_ring_off(j);
1364                                                 if(!j->flags.cidsent)
1365                                                         j->flags.cidring = 1;
1366                                         }
1367                                 }
1368                                 clear_bit(board, &j->busyflags);
1369                                 ixj_add_timer(j);
1370                                 return;
1371                         }
1372                 }
1373                 if (!j->flags.ringing) {
1374                         if (j->hookstate) { /* & 1) { */
1375                                 if (j->dsp.low != 0x20 &&
1376                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1377                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1378                                 }
1379                                 LineMonitor(j);
1380                                 read_filters(j);
1381                                 ixj_WriteDSPCommand(0x511B, j);
1382                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1383                                 if (!j->m_hook && (j->hookstate & 1)) {
1384                                         j->m_hook = j->ex.bits.hookstate = 1;
1385                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1386                                 }
1387                         } else {
1388                                 if (j->ex.bits.dtmf_ready) {
1389                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1390                                 }
1391                                 if (j->m_hook) {
1392                                         j->m_hook = 0;
1393                                         j->ex.bits.hookstate = 1;
1394                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1395                                 }
1396                         }
1397                 }
1398                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1399                         ixj_pstn_state(j);
1400                 }
1401                 if (j->ex.bytes) {
1402                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1403                 }
1404                 clear_bit(board, &j->busyflags);
1405         }
1406         ixj_add_timer(j);
1407 }
1408
1409 static int ixj_status_wait(IXJ *j)
1410 {
1411         unsigned long jif;
1412
1413         jif = jiffies + ((60 * hertz) / 100);
1414         while (!IsStatusReady(j)) {
1415                 ixj_perfmon(j->statuswait);
1416                 if (time_after(jiffies, jif)) {
1417                         ixj_perfmon(j->statuswaitfail);
1418                         return -1;
1419                 }
1420         }
1421         return 0;
1422 }
1423
1424 static int ixj_PCcontrol_wait(IXJ *j)
1425 {
1426         unsigned long jif;
1427
1428         jif = jiffies + ((60 * hertz) / 100);
1429         while (!IsPCControlReady(j)) {
1430                 ixj_perfmon(j->pcontrolwait);
1431                 if (time_after(jiffies, jif)) {
1432                         ixj_perfmon(j->pcontrolwaitfail);
1433                         return -1;
1434                 }
1435         }
1436         return 0;
1437 }
1438
1439 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1440 {
1441         BYTES bytes;
1442         unsigned long jif;
1443
1444         atomic_inc(&j->DSPWrite);
1445         if(atomic_read(&j->DSPWrite) > 1) {
1446                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1447                 return -1;
1448         }
1449         bytes.high = (cmd & 0xFF00) >> 8;
1450         bytes.low = cmd & 0x00FF;
1451         jif = jiffies + ((60 * hertz) / 100);
1452         while (!IsControlReady(j)) {
1453                 ixj_perfmon(j->iscontrolready);
1454                 if (time_after(jiffies, jif)) {
1455                         ixj_perfmon(j->iscontrolreadyfail);
1456                         atomic_dec(&j->DSPWrite);
1457                         if(atomic_read(&j->DSPWrite) > 0) {
1458                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1459                                 while(atomic_read(&j->DSPWrite) > 0) {
1460                                         atomic_dec(&j->DSPWrite);
1461                                 }
1462                         }
1463                         return -1;
1464                 }
1465         }
1466         outb(bytes.low, j->DSPbase + 6);
1467         outb(bytes.high, j->DSPbase + 7);
1468
1469         if (ixj_status_wait(j)) {
1470                 j->ssr.low = 0xFF;
1471                 j->ssr.high = 0xFF;
1472                 atomic_dec(&j->DSPWrite);
1473                 if(atomic_read(&j->DSPWrite) > 0) {
1474                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1475                         while(atomic_read(&j->DSPWrite) > 0) {
1476                                 atomic_dec(&j->DSPWrite);
1477                         }
1478                 }
1479                 return -1;
1480         }
1481 /* Read Software Status Register */
1482         j->ssr.low = inb_p(j->DSPbase + 2);
1483         j->ssr.high = inb_p(j->DSPbase + 3);
1484         atomic_dec(&j->DSPWrite);
1485         if(atomic_read(&j->DSPWrite) > 0) {
1486                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1487                 while(atomic_read(&j->DSPWrite) > 0) {
1488                         atomic_dec(&j->DSPWrite);
1489                 }
1490         }
1491         return 0;
1492 }
1493
1494 /***************************************************************************
1495 *
1496 *  General Purpose IO Register read routine
1497 *
1498 ***************************************************************************/
1499 static inline int ixj_gpio_read(IXJ *j)
1500 {
1501         if (ixj_WriteDSPCommand(0x5143, j))
1502                 return -1;
1503
1504         j->gpio.bytes.low = j->ssr.low;
1505         j->gpio.bytes.high = j->ssr.high;
1506
1507         return 0;
1508 }
1509
1510 static inline void LED_SetState(int state, IXJ *j)
1511 {
1512         if (j->cardtype == QTI_LINEJACK) {
1513                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1514                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1515                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1516                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1517
1518                 outb(j->pld_scrw.byte, j->XILINXbase);
1519         }
1520 }
1521
1522 /*********************************************************************
1523 *  GPIO Pins are configured as follows on the Quicknet Internet
1524 *  PhoneJACK Telephony Cards
1525 *
1526 * POTS Select        GPIO_6=0 GPIO_7=0
1527 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1528 * Handset Select     GPIO_6=1 GPIO_7=0
1529 *
1530 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1531 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1532 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1533 *
1534 * Hook Switch changes reported on GPIO_3
1535 *********************************************************************/
1536 static int ixj_set_port(IXJ *j, int arg)
1537 {
1538         if (j->cardtype == QTI_PHONEJACK_LITE) {
1539                 if (arg != PORT_POTS)
1540                         return 10;
1541                 else
1542                         return 0;
1543         }
1544         switch (arg) {
1545         case PORT_POTS:
1546                 j->port = PORT_POTS;
1547                 switch (j->cardtype) {
1548                 case QTI_PHONECARD:
1549                         if (j->flags.pcmciasct == 1)
1550                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1551                         else
1552                                 return 11;
1553                         break;
1554                 case QTI_PHONEJACK_PCI:
1555                         j->pld_slicw.pcib.mic = 0;
1556                         j->pld_slicw.pcib.spk = 0;
1557                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1558                         break;
1559                 case QTI_LINEJACK:
1560                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1561                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1562                                                                            Software Control Register */
1563                                 return 2;
1564                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1565
1566                         outb(j->pld_scrw.byte, j->XILINXbase);
1567                         j->pld_clock.byte = 0;
1568                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1569                         j->pld_slicw.bits.rly1 = 1;
1570                         j->pld_slicw.bits.spken = 0;
1571                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1572                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1573                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1574                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1575                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1576                         ixj_mixer(0x0E80, j);   /*Mic mute */
1577                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1578                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1579                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1580                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1581 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1582                         break;
1583                 case QTI_PHONEJACK:
1584                         j->gpio.bytes.high = 0x0B;
1585                         j->gpio.bits.gpio6 = 0;
1586                         j->gpio.bits.gpio7 = 0;
1587                         ixj_WriteDSPCommand(j->gpio.word, j);
1588                         break;
1589                 }
1590                 break;
1591         case PORT_PSTN:
1592                 if (j->cardtype == QTI_LINEJACK) {
1593                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1594
1595                         j->pld_slicw.bits.rly3 = 0;
1596                         j->pld_slicw.bits.rly1 = 1;
1597                         j->pld_slicw.bits.spken = 0;
1598                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1599                         j->port = PORT_PSTN;
1600                 } else {
1601                         return 4;
1602                 }
1603                 break;
1604         case PORT_SPEAKER:
1605                 j->port = PORT_SPEAKER;
1606                 switch (j->cardtype) {
1607                 case QTI_PHONECARD:
1608                         if (j->flags.pcmciasct) {
1609                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1610                         }
1611                         break;
1612                 case QTI_PHONEJACK_PCI:
1613                         j->pld_slicw.pcib.mic = 1;
1614                         j->pld_slicw.pcib.spk = 1;
1615                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1616                         break;
1617                 case QTI_LINEJACK:
1618                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1619                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1620                                                                            Software Control Register */
1621                                 return 2;
1622                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1623
1624                         outb(j->pld_scrw.byte, j->XILINXbase);
1625                         j->pld_clock.byte = 0;
1626                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1627                         j->pld_slicw.bits.rly1 = 1;
1628                         j->pld_slicw.bits.spken = 1;
1629                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1630                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1631                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1632                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1633                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1634                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1635                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1636                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1637                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1638                         break;
1639                 case QTI_PHONEJACK:
1640                         j->gpio.bytes.high = 0x0B;
1641                         j->gpio.bits.gpio6 = 0;
1642                         j->gpio.bits.gpio7 = 1;
1643                         ixj_WriteDSPCommand(j->gpio.word, j);
1644                         break;
1645                 }
1646                 break;
1647         case PORT_HANDSET:
1648                 if (j->cardtype != QTI_PHONEJACK) {
1649                         return 5;
1650                 } else {
1651                         j->gpio.bytes.high = 0x0B;
1652                         j->gpio.bits.gpio6 = 1;
1653                         j->gpio.bits.gpio7 = 0;
1654                         ixj_WriteDSPCommand(j->gpio.word, j);
1655                         j->port = PORT_HANDSET;
1656                 }
1657                 break;
1658         default:
1659                 return 6;
1660                 break;
1661         }
1662         return 0;
1663 }
1664
1665 static int ixj_set_pots(IXJ *j, int arg)
1666 {
1667         if (j->cardtype == QTI_LINEJACK) {
1668                 if (arg) {
1669                         if (j->port == PORT_PSTN) {
1670                                 j->pld_slicw.bits.rly1 = 0;
1671                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1672                                 j->flags.pots_pstn = 1;
1673                                 return 1;
1674                         } else {
1675                                 j->flags.pots_pstn = 0;
1676                                 return 0;
1677                         }
1678                 } else {
1679                         j->pld_slicw.bits.rly1 = 1;
1680                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1681                         j->flags.pots_pstn = 0;
1682                         return 1;
1683                 }
1684         } else {
1685                 return 0;
1686         }
1687 }
1688
1689 static void ixj_ring_on(IXJ *j)
1690 {
1691         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1692          {
1693                 if (ixjdebug & 0x0004)
1694                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1695
1696                 j->gpio.bytes.high = 0x0B;
1697                 j->gpio.bytes.low = 0x00;
1698                 j->gpio.bits.gpio1 = 1;
1699                 j->gpio.bits.gpio2 = 1;
1700                 j->gpio.bits.gpio5 = 0;
1701                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1702         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1703         {
1704                 if (ixjdebug & 0x0004)
1705                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1706
1707                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1708         }
1709 }
1710
1711 static int ixj_siadc(IXJ *j, int val)
1712 {
1713         if(j->cardtype == QTI_PHONECARD){
1714                 if(j->flags.pcmciascp){
1715                         if(val == -1)
1716                                 return j->siadc.bits.rxg;
1717
1718                         if(val < 0 || val > 0x1F)
1719                                 return -1;
1720
1721                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1722                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1723                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1724                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1725                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1726                         j->psccr.bits.dev = 0;
1727                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1728                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1729                         ixj_PCcontrol_wait(j);
1730                         return j->siadc.bits.rxg;
1731                 }
1732         }
1733         return -1;
1734 }
1735
1736 static int ixj_sidac(IXJ *j, int val)
1737 {
1738         if(j->cardtype == QTI_PHONECARD){
1739                 if(j->flags.pcmciascp){
1740                         if(val == -1)
1741                                 return j->sidac.bits.txg;
1742
1743                         if(val < 0 || val > 0x1F)
1744                                 return -1;
1745
1746                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1747                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1748                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1749                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1750                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1751                         j->psccr.bits.dev = 0;
1752                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1753                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1754                         ixj_PCcontrol_wait(j);
1755                         return j->sidac.bits.txg;
1756                 }
1757         }
1758         return -1;
1759 }
1760
1761 static int ixj_pcmcia_cable_check(IXJ *j)
1762 {
1763         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1764         if (!j->flags.pcmciastate) {
1765                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1766                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1767                         j->flags.pcmciastate = 4;
1768                         return 0;
1769                 }
1770                 if (j->pccr1.bits.ed) {
1771                         j->pccr1.bits.ed = 0;
1772                         j->psccr.bits.dev = 3;
1773                         j->psccr.bits.rw = 1;
1774                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1775                         ixj_PCcontrol_wait(j);
1776                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1777                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1778                         j->psccr.bits.dev = 3;
1779                         j->psccr.bits.rw = 0;
1780                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1781                         ixj_PCcontrol_wait(j);
1782                         return j->pslic.bits.led2 ? 1 : 0;
1783                 } else if (j->flags.pcmciasct) {
1784                         return j->r_hook;
1785                 } else {
1786                         return 1;
1787                 }
1788         } else if (j->flags.pcmciastate == 4) {
1789                 if (!j->pccr1.bits.drf) {
1790                         j->flags.pcmciastate = 3;
1791                 }
1792                 return 0;
1793         } else if (j->flags.pcmciastate == 3) {
1794                 j->pccr2.bits.pwr = 0;
1795                 j->pccr2.bits.rstc = 1;
1796                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1797                 j->checkwait = jiffies + (hertz * 2);
1798                 j->flags.incheck = 1;
1799                 j->flags.pcmciastate = 2;
1800                 return 0;
1801         } else if (j->flags.pcmciastate == 2) {
1802                 if (j->flags.incheck) {
1803                         if (time_before(jiffies, j->checkwait)) {
1804                                 return 0;
1805                         } else {
1806                                 j->flags.incheck = 0;
1807                         }
1808                 }
1809                 j->pccr2.bits.pwr = 0;
1810                 j->pccr2.bits.rstc = 0;
1811                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1812                 j->flags.pcmciastate = 1;
1813                 return 0;
1814         } else if (j->flags.pcmciastate == 1) {
1815                 j->flags.pcmciastate = 0;
1816                 if (!j->pccr1.bits.drf) {
1817                         j->psccr.bits.dev = 3;
1818                         j->psccr.bits.rw = 1;
1819                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1820                         ixj_PCcontrol_wait(j);
1821                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1822
1823                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1824
1825                         if (j->flags.pcmciasct == 3) {
1826                                 j->flags.pcmciastate = 4;
1827                                 return 0;
1828                         } else if (j->flags.pcmciasct == 0) {
1829                                 j->pccr2.bits.pwr = 1;
1830                                 j->pccr2.bits.rstc = 0;
1831                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1832                                 j->port = PORT_SPEAKER;
1833                         } else {
1834                                 j->port = PORT_POTS;
1835                         }
1836                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1837                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1838                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1839                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1840                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1841                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1842                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1843                         j->psccr.bits.dev = 0;
1844                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1845                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1846                         ixj_PCcontrol_wait(j);
1847
1848                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1849                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1850                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1851                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1852                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1853                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1854                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1855                         j->psccr.bits.dev = 0;
1856                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1857                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1858                         ixj_PCcontrol_wait(j);
1859
1860                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1861                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1862                         j->psccr.bits.dev = 0;
1863                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1864                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1865                         ixj_PCcontrol_wait(j);
1866
1867                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1868                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1869                         j->psccr.bits.dev = 0;
1870                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1871                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1872                         ixj_PCcontrol_wait(j);
1873
1874                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1875                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1876                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1877                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1878                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1879                         j->sirxg.bits.iir = 1;                          /* IIR */
1880                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1881                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1882                         j->psccr.bits.dev = 0;
1883                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1884                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1885                         ixj_PCcontrol_wait(j);
1886
1887                         ixj_siadc(j, 0x17);
1888                         ixj_sidac(j, 0x1D);
1889
1890                         j->siaatt.bits.sot = 0;
1891                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1892                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1893                         j->psccr.bits.dev = 0;
1894                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1895                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1896                         ixj_PCcontrol_wait(j);
1897
1898                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1899                                 j->psccr.byte = j->pslic.byte = 0;
1900                                 j->pslic.bits.powerdown = 1;
1901                                 j->psccr.bits.dev = 3;
1902                                 j->psccr.bits.rw = 0;
1903                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1904                                 ixj_PCcontrol_wait(j);
1905                         }
1906                 }
1907                 return 0;
1908         } else {
1909                 j->flags.pcmciascp = 0;
1910                 return 0;
1911         }
1912         return 0;
1913 }
1914
1915 static int ixj_hookstate(IXJ *j)
1916 {
1917         unsigned long det;
1918         int fOffHook = 0;
1919
1920         switch (j->cardtype) {
1921         case QTI_PHONEJACK:
1922                 ixj_gpio_read(j);
1923                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1924                 break;
1925         case QTI_LINEJACK:
1926         case QTI_PHONEJACK_LITE:
1927         case QTI_PHONEJACK_PCI:
1928                 SLIC_GetState(j);
1929                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1930                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1931                         if(fOffHook != j->p_hook) {
1932                                 if(!j->checkwait) {
1933                                         j->checkwait = jiffies;
1934                                 }
1935                                 if(time_before(jiffies, j->checkwait + 2)) {
1936                                         fOffHook ^= 1;
1937                                 } else {
1938                                         j->checkwait = 0;
1939                                 }
1940                                 j->p_hook = fOffHook;
1941                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1942                         }
1943                 } else {
1944                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1945                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1946                                 if (j->flags.ringing || j->flags.cringing) {
1947                                         if (!in_interrupt()) {
1948                                                 det = jiffies + (hertz / 50);
1949                                                 while (time_before(jiffies, det)) {
1950                                                         set_current_state(TASK_INTERRUPTIBLE);
1951                                                         schedule_timeout(1);
1952                                                 }
1953                                         }
1954                                         SLIC_GetState(j);
1955                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1956                                                 ixj_ring_on(j);
1957                                         }
1958                                 }
1959                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1960                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1961                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1962                                 } else
1963                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1964                         }
1965                 }
1966                 break;
1967         case QTI_PHONECARD:
1968                 fOffHook = ixj_pcmcia_cable_check(j);
1969                 break;
1970         }
1971         if (j->r_hook != fOffHook) {
1972                 j->r_hook = fOffHook;
1973                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1974                         j->ex.bits.hookstate = 1;
1975                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1976                 } else if (!fOffHook) {
1977                         j->flash_end = jiffies + ((60 * hertz) / 100);
1978                 }
1979         }
1980         if (fOffHook) {
1981                 if(time_before(jiffies, j->flash_end)) {
1982                         j->ex.bits.flash = 1;
1983                         j->flash_end = 0;
1984                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1985                 }
1986         } else {
1987                 if(time_before(jiffies, j->flash_end)) {
1988                         fOffHook = 1;
1989                 }
1990         }
1991
1992         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1993                 fOffHook |= 2;
1994
1995         if (j->port == PORT_SPEAKER) {
1996                 if(j->cardtype == QTI_PHONECARD) {
1997                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1998                                 fOffHook |= 2;
1999                         }
2000                 } else {
2001                         fOffHook |= 2;
2002                 }
2003         }
2004
2005         if (j->port == PORT_HANDSET)
2006                 fOffHook |= 2;
2007
2008         return fOffHook;
2009 }
2010
2011 static void ixj_ring_off(IXJ *j)
2012 {
2013         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2014          {
2015                 if (ixjdebug & 0x0004)
2016                         printk(KERN_INFO "IXJ Ring Off\n");
2017                 j->gpio.bytes.high = 0x0B;
2018                 j->gpio.bytes.low = 0x00;
2019                 j->gpio.bits.gpio1 = 0;
2020                 j->gpio.bits.gpio2 = 1;
2021                 j->gpio.bits.gpio5 = 0;
2022                 ixj_WriteDSPCommand(j->gpio.word, j);
2023         } else                  /* Internet LineJACK */
2024         {
2025                 if (ixjdebug & 0x0004)
2026                         printk(KERN_INFO "IXJ Ring Off\n");
2027
2028                 if(!j->flags.cidplay)
2029                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2030
2031                 SLIC_GetState(j);
2032         }
2033 }
2034
2035 static void ixj_ring_start(IXJ *j)
2036 {
2037         j->flags.cringing = 1;
2038         if (ixjdebug & 0x0004)
2039                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2040         if (ixj_hookstate(j) & 1) {
2041                 if (j->port == PORT_POTS)
2042                         ixj_ring_off(j);
2043                 j->flags.cringing = 0;
2044                 if (ixjdebug & 0x0004)
2045                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2046         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2047                 j->ring_cadence_jif = jiffies;
2048                 j->flags.cidsent = j->flags.cidring = 0;
2049                 j->cadence_f[5].state = 0;
2050                 if(j->cadence_f[5].on1)
2051                         ixj_ring_on(j);
2052         } else {
2053                 j->ring_cadence_jif = jiffies;
2054                 j->ring_cadence_t = 15;
2055                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2056                         ixj_ring_on(j);
2057                 } else {
2058                         ixj_ring_off(j);
2059                 }
2060                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2061         }
2062 }
2063
2064 static int ixj_ring(IXJ *j)
2065 {
2066         char cntr;
2067         unsigned long jif, det;
2068
2069         j->flags.ringing = 1;
2070         if (ixj_hookstate(j) & 1) {
2071                 ixj_ring_off(j);
2072                 j->flags.ringing = 0;
2073                 return 1;
2074         }
2075         det = 0;
2076         for (cntr = 0; cntr < j->maxrings; cntr++) {
2077                 jif = jiffies + (1 * hertz);
2078                 ixj_ring_on(j);
2079                 while (time_before(jiffies, jif)) {
2080                         if (ixj_hookstate(j) & 1) {
2081                                 ixj_ring_off(j);
2082                                 j->flags.ringing = 0;
2083                                 return 1;
2084                         }
2085                         set_current_state(TASK_INTERRUPTIBLE);
2086                         schedule_timeout(1);
2087                         if (signal_pending(current))
2088                                 break;
2089                 }
2090                 jif = jiffies + (3 * hertz);
2091                 ixj_ring_off(j);
2092                 while (time_before(jiffies, jif)) {
2093                         if (ixj_hookstate(j) & 1) {
2094                                 det = jiffies + (hertz / 100);
2095                                 while (time_before(jiffies, det)) {
2096                                         set_current_state(TASK_INTERRUPTIBLE);
2097                                         schedule_timeout(1);
2098                                         if (signal_pending(current))
2099                                                 break;
2100                                 }
2101                                 if (ixj_hookstate(j) & 1) {
2102                                         j->flags.ringing = 0;
2103                                         return 1;
2104                                 }
2105                         }
2106                         set_current_state(TASK_INTERRUPTIBLE);
2107                         schedule_timeout(1);
2108                         if (signal_pending(current))
2109                                 break;
2110                 }
2111         }
2112         ixj_ring_off(j);
2113         j->flags.ringing = 0;
2114         return 0;
2115 }
2116
2117 static int ixj_open(struct phone_device *p, struct file *file_p)
2118 {
2119         IXJ *j = get_ixj(p->board);
2120         file_p->private_data = j;
2121
2122         if (!j->DSPbase)
2123                 return -ENODEV;
2124
2125         if (file_p->f_mode & FMODE_READ) {
2126                 if(!j->readers) {
2127                         j->readers++;
2128                 } else {
2129                         return -EBUSY;
2130                 }
2131         }
2132
2133         if (file_p->f_mode & FMODE_WRITE) {
2134                 if(!j->writers) {
2135                         j->writers++;
2136                 } else {
2137                         if (file_p->f_mode & FMODE_READ){
2138                                 j->readers--;
2139                         }
2140                         return -EBUSY;
2141                 }
2142         }
2143
2144         if (j->cardtype == QTI_PHONECARD) {
2145                 j->pslic.bits.powerdown = 0;
2146                 j->psccr.bits.dev = 3;
2147                 j->psccr.bits.rw = 0;
2148                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2149                 ixj_PCcontrol_wait(j);
2150         }
2151
2152         j->flags.cidplay = 0;
2153         j->flags.cidcw_ack = 0;
2154
2155         if (ixjdebug & 0x0002)
2156                 printk(KERN_INFO "Opening board %d\n", p->board);
2157
2158         j->framesread = j->frameswritten = 0;
2159         return 0;
2160 }
2161
2162 static int ixj_release(struct inode *inode, struct file *file_p)
2163 {
2164         IXJ_TONE ti;
2165         int cnt;
2166         IXJ *j = file_p->private_data;
2167         int board = j->p.board;
2168
2169         /*
2170          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2171          *    This is necessary to keep the DSP from locking up.
2172          */
2173         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
2174                 set_current_state(TASK_INTERRUPTIBLE);
2175                 schedule_timeout(1);
2176         }
2177         if (ixjdebug & 0x0002)
2178                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2179
2180         if (j->cardtype == QTI_PHONECARD)
2181                 ixj_set_port(j, PORT_SPEAKER);
2182         else
2183                 ixj_set_port(j, PORT_POTS);
2184
2185         aec_stop(j);
2186         ixj_play_stop(j);
2187         ixj_record_stop(j);
2188         set_play_volume(j, 0x100);
2189         set_rec_volume(j, 0x100);
2190         ixj_ring_off(j);
2191
2192         /* Restore the tone table to default settings. */
2193         ti.tone_index = 10;
2194         ti.gain0 = 1;
2195         ti.freq0 = hz941;
2196         ti.gain1 = 0;
2197         ti.freq1 = hz1209;
2198         ixj_init_tone(j, &ti);
2199         ti.tone_index = 11;
2200         ti.gain0 = 1;
2201         ti.freq0 = hz941;
2202         ti.gain1 = 0;
2203         ti.freq1 = hz1336;
2204         ixj_init_tone(j, &ti);
2205         ti.tone_index = 12;
2206         ti.gain0 = 1;
2207         ti.freq0 = hz941;
2208         ti.gain1 = 0;
2209         ti.freq1 = hz1477;
2210         ixj_init_tone(j, &ti);
2211         ti.tone_index = 13;
2212         ti.gain0 = 1;
2213         ti.freq0 = hz800;
2214         ti.gain1 = 0;
2215         ti.freq1 = 0;
2216         ixj_init_tone(j, &ti);
2217         ti.tone_index = 14;
2218         ti.gain0 = 1;
2219         ti.freq0 = hz1000;
2220         ti.gain1 = 0;
2221         ti.freq1 = 0;
2222         ixj_init_tone(j, &ti);
2223         ti.tone_index = 15;
2224         ti.gain0 = 1;
2225         ti.freq0 = hz1250;
2226         ti.gain1 = 0;
2227         ti.freq1 = 0;
2228         ixj_init_tone(j, &ti);
2229         ti.tone_index = 16;
2230         ti.gain0 = 1;
2231         ti.freq0 = hz950;
2232         ti.gain1 = 0;
2233         ti.freq1 = 0;
2234         ixj_init_tone(j, &ti);
2235         ti.tone_index = 17;
2236         ti.gain0 = 1;
2237         ti.freq0 = hz1100;
2238         ti.gain1 = 0;
2239         ti.freq1 = 0;
2240         ixj_init_tone(j, &ti);
2241         ti.tone_index = 18;
2242         ti.gain0 = 1;
2243         ti.freq0 = hz1400;
2244         ti.gain1 = 0;
2245         ti.freq1 = 0;
2246         ixj_init_tone(j, &ti);
2247         ti.tone_index = 19;
2248         ti.gain0 = 1;
2249         ti.freq0 = hz1500;
2250         ti.gain1 = 0;
2251         ti.freq1 = 0;
2252         ixj_init_tone(j, &ti);
2253         ti.tone_index = 20;
2254         ti.gain0 = 1;
2255         ti.freq0 = hz1600;
2256         ti.gain1 = 0;
2257         ti.freq1 = 0;
2258         ixj_init_tone(j, &ti);
2259         ti.tone_index = 21;
2260         ti.gain0 = 1;
2261         ti.freq0 = hz1800;
2262         ti.gain1 = 0;
2263         ti.freq1 = 0;
2264         ixj_init_tone(j, &ti);
2265         ti.tone_index = 22;
2266         ti.gain0 = 1;
2267         ti.freq0 = hz2100;
2268         ti.gain1 = 0;
2269         ti.freq1 = 0;
2270         ixj_init_tone(j, &ti);
2271         ti.tone_index = 23;
2272         ti.gain0 = 1;
2273         ti.freq0 = hz1300;
2274         ti.gain1 = 0;
2275         ti.freq1 = 0;
2276         ixj_init_tone(j, &ti);
2277         ti.tone_index = 24;
2278         ti.gain0 = 1;
2279         ti.freq0 = hz2450;
2280         ti.gain1 = 0;
2281         ti.freq1 = 0;
2282         ixj_init_tone(j, &ti);
2283         ti.tone_index = 25;
2284         ti.gain0 = 1;
2285         ti.freq0 = hz350;
2286         ti.gain1 = 0;
2287         ti.freq1 = hz440;
2288         ixj_init_tone(j, &ti);
2289         ti.tone_index = 26;
2290         ti.gain0 = 1;
2291         ti.freq0 = hz440;
2292         ti.gain1 = 0;
2293         ti.freq1 = hz480;
2294         ixj_init_tone(j, &ti);
2295         ti.tone_index = 27;
2296         ti.gain0 = 1;
2297         ti.freq0 = hz480;
2298         ti.gain1 = 0;
2299         ti.freq1 = hz620;
2300         ixj_init_tone(j, &ti);
2301
2302         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2303
2304         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2305
2306         j->ex.bits.dtmf_ready = 0;
2307         j->dtmf_state = 0;
2308         j->dtmf_wp = j->dtmf_rp = 0;
2309         j->rec_mode = j->play_mode = -1;
2310         j->flags.ringing = 0;
2311         j->maxrings = MAXRINGS;
2312         j->ring_cadence = USA_RING_CADENCE;
2313         if(j->cadence_f[5].enable) {
2314                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2315         }
2316         j->drybuffer = 0;
2317         j->winktime = 320;
2318         j->flags.dtmf_oob = 0;
2319         for (cnt = 0; cnt < 4; cnt++)
2320                 j->cadence_f[cnt].enable = 0;
2321
2322         idle(j);
2323
2324         if(j->cardtype == QTI_PHONECARD) {
2325                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2326         }
2327
2328         if (file_p->f_mode & FMODE_READ)
2329                 j->readers--;
2330         if (file_p->f_mode & FMODE_WRITE)
2331                 j->writers--;
2332
2333         if (j->read_buffer && !j->readers) {
2334                 kfree(j->read_buffer);
2335                 j->read_buffer = NULL;
2336                 j->read_buffer_size = 0;
2337         }
2338         if (j->write_buffer && !j->writers) {
2339                 kfree(j->write_buffer);
2340                 j->write_buffer = NULL;
2341                 j->write_buffer_size = 0;
2342         }
2343         j->rec_codec = j->play_codec = 0;
2344         j->rec_frame_size = j->play_frame_size = 0;
2345         j->flags.cidsent = j->flags.cidring = 0;
2346         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2347
2348         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2349                 ixj_set_port(j, PORT_PSTN);
2350                 daa_set_mode(j, SOP_PU_SLEEP);
2351                 ixj_set_pots(j, 1);
2352         }
2353         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2354
2355         /* Set up the default signals for events */
2356         for (cnt = 0; cnt < 35; cnt++)
2357                 j->ixj_signals[cnt] = SIGIO;
2358
2359         /* Set the excetion signal enable flags */
2360         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2361         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 =
2362         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;
2363
2364         file_p->private_data = NULL;
2365         clear_bit(board, &j->busyflags);
2366         return 0;
2367 }
2368
2369 static int read_filters(IXJ *j)
2370 {
2371         unsigned short fc, cnt, trg;
2372         int var;
2373
2374         trg = 0;
2375         if (ixj_WriteDSPCommand(0x5144, j)) {
2376                 if(ixjdebug & 0x0001) {
2377                         printk(KERN_INFO "Read Frame Counter failed!\n");
2378                 }
2379                 return -1;
2380         }
2381         fc = j->ssr.high << 8 | j->ssr.low;
2382         if (fc == j->frame_count)
2383                 return 1;
2384
2385         j->frame_count = fc;
2386
2387         if (j->dtmf_proc)
2388                 return 1;
2389
2390         var = 10;
2391
2392         for (cnt = 0; cnt < 4; cnt++) {
2393                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2394                         if(ixjdebug & 0x0001) {
2395                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2396                         }
2397                         return -1;
2398                 }
2399                 if (ixj_WriteDSPCommand(0x515C, j)) {
2400                         if(ixjdebug & 0x0001) {
2401                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2402                         }
2403                         return -1;
2404                 }
2405                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2406
2407                 if (j->cadence_f[cnt].enable) {
2408                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2409                                 if (j->cadence_f[cnt].state == 0) {
2410                                         j->cadence_f[cnt].state = 1;
2411                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2412                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2413                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2414                                 } else if (j->cadence_f[cnt].state == 2 &&
2415                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2416                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2417                                         if (j->cadence_f[cnt].on2) {
2418                                                 j->cadence_f[cnt].state = 3;
2419                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2420                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2421                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2422                                         } else {
2423                                                 j->cadence_f[cnt].state = 7;
2424                                         }
2425                                 } else if (j->cadence_f[cnt].state == 4 &&
2426                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2427                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2428                                         if (j->cadence_f[cnt].on3) {
2429                                                 j->cadence_f[cnt].state = 5;
2430                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2431                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2432                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2433                                         } else {
2434                                                 j->cadence_f[cnt].state = 7;
2435                                         }
2436                                 } else {
2437                                         j->cadence_f[cnt].state = 0;
2438                                 }
2439                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2440                                 if (j->cadence_f[cnt].state == 1) {
2441                                         if(!j->cadence_f[cnt].on1) {
2442                                                 j->cadence_f[cnt].state = 7;
2443                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2444                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2445                                                 if(j->cadence_f[cnt].off1) {
2446                                                         j->cadence_f[cnt].state = 2;
2447                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2448                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2449                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2450                                                 } else {
2451                                                         j->cadence_f[cnt].state = 7;
2452                                                 }
2453                                         } else {
2454                                                 j->cadence_f[cnt].state = 0;
2455                                         }
2456                                 } else if (j->cadence_f[cnt].state == 3) {
2457                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2458                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2459                                                 if(j->cadence_f[cnt].off2) {
2460                                                         j->cadence_f[cnt].state = 4;
2461                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2462                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2463                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2464                                                 } else {
2465                                                         j->cadence_f[cnt].state = 7;
2466                                                 }
2467                                         } else {
2468                                                 j->cadence_f[cnt].state = 0;
2469                                         }
2470                                 } else if (j->cadence_f[cnt].state == 5) {
2471                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2472                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2473                                                 if(j->cadence_f[cnt].off3) {
2474                                                         j->cadence_f[cnt].state = 6;
2475                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2476                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2477                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2478                                                 } else {
2479                                                         j->cadence_f[cnt].state = 7;
2480                                                 }
2481                                         } else {
2482                                                 j->cadence_f[cnt].state = 0;
2483                                         }
2484                                 } else {
2485                                         j->cadence_f[cnt].state = 0;
2486                                 }
2487                         } else {
2488                                 switch(j->cadence_f[cnt].state) {
2489                                         case 1:
2490                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2491                                                    !j->cadence_f[cnt].off1 &&
2492                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2493                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2494                                                         j->cadence_f[cnt].state = 7;
2495                                                 }
2496                                                 break;
2497                                         case 3:
2498                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2499                                                    !j->cadence_f[cnt].off2 &&
2500                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2501                                                         j->cadence_f[cnt].state = 7;
2502                                                 }
2503                                                 break;
2504                                         case 5:
2505                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2506                                                    !j->cadence_f[cnt].off3) {
2507                                                         j->cadence_f[cnt].state = 7;
2508                                                 }
2509                                                 break;
2510                                 }
2511                         }
2512
2513                         if (ixjdebug & 0x0040) {
2514                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2515                                 switch(j->cadence_f[cnt].state) {
2516                                         case 0:
2517                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2518                                                 break;
2519                                         case 1:
2520                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2521                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2522                                                 break;
2523                                         case 2:
2524                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2525                                                                                                                         j->cadence_f[cnt].off1max);
2526                                                 break;
2527                                         case 3:
2528                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2529                                                                                                                         j->cadence_f[cnt].on2max);
2530                                                 break;
2531                                         case 4:
2532                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2533                                                                                                                         j->cadence_f[cnt].off2max);
2534                                                 break;
2535                                         case 5:
2536                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2537                                                                                                                         j->cadence_f[cnt].on3max);
2538                                                 break;
2539                                         case 6:
2540                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2541                                                                                                                         j->cadence_f[cnt].off3max);
2542                                                 break;
2543                                 }
2544                         }
2545                 }
2546                 if (j->cadence_f[cnt].state == 7) {
2547                         j->cadence_f[cnt].state = 0;
2548                         if (j->cadence_f[cnt].enable == 1)
2549                                 j->cadence_f[cnt].enable = 0;
2550                         switch (cnt) {
2551                         case 0:
2552                                 if(ixjdebug & 0x0020) {
2553                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2554                                 }
2555                                 j->ex.bits.fc0 = 1;
2556                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2557                                 break;
2558                         case 1:
2559                                 if(ixjdebug & 0x0020) {
2560                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2561                                 }
2562                                 j->ex.bits.fc1 = 1;
2563                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2564                                 break;
2565                         case 2:
2566                                 if(ixjdebug & 0x0020) {
2567                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2568                                 }
2569                                 j->ex.bits.fc2 = 1;
2570                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2571                                 break;
2572                         case 3:
2573                                 if(ixjdebug & 0x0020) {
2574                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2575                                 }
2576                                 j->ex.bits.fc3 = 1;
2577                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2578                                 break;
2579                         }
2580                 }
2581                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2582                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2583                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2584                                 trg = 1;
2585                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2586                                 trg = 0;
2587                         }
2588                         switch (cnt) {
2589                         case 0:
2590                                 if(ixjdebug & 0x0020) {
2591                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2592                                 }
2593                                 j->ex.bits.f0 = 1;
2594                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2595                                 break;
2596                         case 1:
2597                                 if(ixjdebug & 0x0020) {
2598                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2599                                 }
2600                                 j->ex.bits.f1 = 1;
2601                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2602                                 break;
2603                         case 2:
2604                                 if(ixjdebug & 0x0020) {
2605                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2606                                 }
2607                                 j->ex.bits.f2 = 1;
2608                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2609                                 break;
2610                         case 3:
2611                                 if(ixjdebug & 0x0020) {
2612                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2613                                 }
2614                                 j->ex.bits.f3 = 1;
2615                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2616                                 break;
2617                         }
2618                 }
2619         }
2620         return 0;
2621 }
2622
2623 static int LineMonitor(IXJ *j)
2624 {
2625         if (j->dtmf_proc) {
2626                 return -1;
2627         }
2628         j->dtmf_proc = 1;
2629
2630         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2631                 return -1;
2632
2633         j->dtmf.bytes.high = j->ssr.high;
2634         j->dtmf.bytes.low = j->ssr.low;
2635         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2636                 j->dtmf_state = 1;
2637                 j->dtmf_current = j->dtmf.bits.digit;
2638         }
2639         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2640          {
2641                 if(!j->cidcw_wait) {
2642                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2643                         j->dtmf_wp++;
2644                         if (j->dtmf_wp == 79)
2645                                 j->dtmf_wp = 0;
2646                         j->ex.bits.dtmf_ready = 1;
2647                         if(j->ex_sig.bits.dtmf_ready) {
2648                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2649                         }
2650                 }
2651                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2652                         if(ixjdebug & 0x0020) {
2653                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2654                         }
2655                         j->flags.cidcw_ack = 1;
2656                 }
2657                 j->dtmf_state = 0;
2658         }
2659         j->dtmf_proc = 0;
2660
2661         return 0;
2662 }
2663
2664 /************************************************************************
2665 *
2666 * Functions to allow alaw <-> ulaw conversions.
2667 *
2668 ************************************************************************/
2669
2670 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2671 {
2672         static unsigned char table_ulaw2alaw[] =
2673         {
2674                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2675                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2676                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2677                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2678                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2679                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2680                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2681                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2682                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2683                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2684                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2685                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2686                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2687                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2688                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2689                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2690                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2691                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2692                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2693                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2694                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2695                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2696                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2697                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2698                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2699                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2700                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2701                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2702                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2703                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2704                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2705                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2706         };
2707
2708         while (len--)
2709         {
2710                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2711                 buff++;
2712         }
2713 }
2714
2715 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2716 {
2717         static unsigned char table_alaw2ulaw[] =
2718         {
2719                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2720                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2721                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2722                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2723                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2724                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2725                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2726                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2727                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2728                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2729                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2730                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2731                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2732                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2733                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2734                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2735                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2736                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2737                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2738                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2739                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2740                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2741                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2742                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2743                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2744                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2745                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2746                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2747                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2748                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2749                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2750                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2751         };
2752
2753         while (len--)
2754         {
2755                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2756                 buff++;
2757         }
2758 }
2759
2760 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2761 {
2762         unsigned long i = *ppos;
2763         IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2764
2765         DECLARE_WAITQUEUE(wait, current);
2766
2767         if (j->flags.inread)
2768                 return -EALREADY;
2769
2770         j->flags.inread = 1;
2771
2772         add_wait_queue(&j->read_q, &wait);
2773         set_current_state(TASK_INTERRUPTIBLE);
2774         mb();
2775
2776         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2777                 ++j->read_wait;
2778                 if (file_p->f_flags & O_NONBLOCK) {
2779                         set_current_state(TASK_RUNNING);
2780                         remove_wait_queue(&j->read_q, &wait);
2781                         j->flags.inread = 0;
2782                         return -EAGAIN;
2783                 }
2784                 if (!ixj_hookstate(j)) {
2785                         set_current_state(TASK_RUNNING);
2786                         remove_wait_queue(&j->read_q, &wait);
2787                         j->flags.inread = 0;
2788                         return 0;
2789                 }
2790                 interruptible_sleep_on(&j->read_q);
2791                 if (signal_pending(current)) {
2792                         set_current_state(TASK_RUNNING);
2793                         remove_wait_queue(&j->read_q, &wait);
2794                         j->flags.inread = 0;
2795                         return -EINTR;
2796                 }
2797         }
2798
2799         remove_wait_queue(&j->read_q, &wait);
2800         set_current_state(TASK_RUNNING);
2801         /* Don't ever copy more than the user asks */
2802         if(j->rec_codec == ALAW)
2803                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2804         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2805         j->read_buffer_ready = 0;
2806         if (i) {
2807                 j->flags.inread = 0;
2808                 return -EFAULT;
2809         } else {
2810                 j->flags.inread = 0;
2811                 return min(length, j->read_buffer_size);
2812         }
2813 }
2814
2815 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2816                           loff_t * ppos)
2817 {
2818         int pre_retval;
2819         ssize_t read_retval = 0;
2820         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2821
2822         pre_retval = ixj_PreRead(j, 0L);
2823         switch (pre_retval) {
2824         case NORMAL:
2825                 read_retval = ixj_read(file_p, buf, length, ppos);
2826                 ixj_PostRead(j, 0L);
2827                 break;
2828         case NOPOST:
2829                 read_retval = ixj_read(file_p, buf, length, ppos);
2830                 break;
2831         case POSTONLY:
2832                 ixj_PostRead(j, 0L);
2833                 break;
2834         default:
2835                 read_retval = pre_retval;
2836         }
2837         return read_retval;
2838 }
2839
2840 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2841 {
2842         unsigned long i = *ppos;
2843         IXJ *j = file_p->private_data;
2844
2845         DECLARE_WAITQUEUE(wait, current);
2846
2847         if (j->flags.inwrite)
2848                 return -EALREADY;
2849
2850         j->flags.inwrite = 1;
2851
2852         add_wait_queue(&j->write_q, &wait);
2853         set_current_state(TASK_INTERRUPTIBLE);
2854         mb();
2855
2856
2857         while (!j->write_buffers_empty) {
2858                 ++j->write_wait;
2859                 if (file_p->f_flags & O_NONBLOCK) {
2860                         set_current_state(TASK_RUNNING);
2861                         remove_wait_queue(&j->write_q, &wait);
2862                         j->flags.inwrite = 0;
2863                         return -EAGAIN;
2864                 }
2865                 if (!ixj_hookstate(j)) {
2866                         set_current_state(TASK_RUNNING);
2867                         remove_wait_queue(&j->write_q, &wait);
2868                         j->flags.inwrite = 0;
2869                         return 0;
2870                 }
2871                 interruptible_sleep_on(&j->write_q);
2872                 if (signal_pending(current)) {
2873                         set_current_state(TASK_RUNNING);
2874                         remove_wait_queue(&j->write_q, &wait);
2875                         j->flags.inwrite = 0;
2876                         return -EINTR;
2877                 }
2878         }
2879         set_current_state(TASK_RUNNING);
2880         remove_wait_queue(&j->write_q, &wait);
2881         if (j->write_buffer_wp + count >= j->write_buffer_end)
2882                 j->write_buffer_wp = j->write_buffer;
2883         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2884         if (i) {
2885                 j->flags.inwrite = 0;
2886                 return -EFAULT;
2887         }
2888        if(j->play_codec == ALAW)
2889                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2890         j->flags.inwrite = 0;
2891         return min(count, j->write_buffer_size);
2892 }
2893
2894 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2895 {
2896         int pre_retval;
2897         ssize_t write_retval = 0;
2898
2899         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2900
2901         pre_retval = ixj_PreWrite(j, 0L);
2902         switch (pre_retval) {
2903         case NORMAL:
2904                 write_retval = ixj_write(file_p, buf, count, ppos);
2905                 if (write_retval > 0) {
2906                         ixj_PostWrite(j, 0L);
2907                         j->write_buffer_wp += write_retval;
2908                         j->write_buffers_empty--;
2909                 }
2910                 break;
2911         case NOPOST:
2912                 write_retval = ixj_write(file_p, buf, count, ppos);
2913                 if (write_retval > 0) {
2914                         j->write_buffer_wp += write_retval;
2915                         j->write_buffers_empty--;
2916                 }
2917                 break;
2918         case POSTONLY:
2919                 ixj_PostWrite(j, 0L);
2920                 break;
2921         default:
2922                 write_retval = pre_retval;
2923         }
2924         return write_retval;
2925 }
2926
2927 static void ixj_read_frame(IXJ *j)
2928 {
2929         int cnt, dly;
2930
2931         if (j->read_buffer) {
2932                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2933                         if (!(cnt % 16) && !IsRxReady(j)) {
2934                                 dly = 0;
2935                                 while (!IsRxReady(j)) {
2936                                         if (dly++ > 5) {
2937                                                 dly = 0;
2938                                                 break;
2939                                         }
2940                                         udelay(10);
2941                                 }
2942                         }
2943                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2944                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2945                                 inb_p(j->DSPbase + 0x0E);
2946                                 inb_p(j->DSPbase + 0x0F);
2947                         }
2948                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2949                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2950                 }
2951                 ++j->framesread;
2952                 if (j->intercom != -1) {
2953                         if (IsTxReady(get_ixj(j->intercom))) {
2954                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2955                                         if (!(cnt % 16) && !IsTxReady(j)) {
2956                                                 dly = 0;
2957                                                 while (!IsTxReady(j)) {
2958                                                         if (dly++ > 5) {
2959                                                                 dly = 0;
2960                                                                 break;
2961                                                         }
2962                                                         udelay(10);
2963                                                 }
2964                                         }
2965                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2966                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2967                                 }
2968                                 get_ixj(j->intercom)->frameswritten++;
2969                         }
2970                 } else {
2971                         j->read_buffer_ready = 1;
2972                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2973
2974                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2975
2976                         if(j->ixj_signals[SIG_READ_READY])
2977                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2978                 }
2979         }
2980 }
2981
2982 static short fsk[][6][20] =
2983 {
2984         {
2985                 {
2986                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2987                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2988                 },
2989                 {
2990                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2991                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2992                 },
2993                 {
2994                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2995                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2996                 },
2997                 {
2998                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2999                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
3000                 },
3001                 {
3002                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
3003                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
3004                 },
3005                 {
3006                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
3007                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
3008                 }
3009         },
3010         {
3011                 {
3012                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3013                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3014                 },
3015                 {
3016                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3017                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3018                 },
3019                 {
3020                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3021                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3022                 },
3023                 {
3024                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3025                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3026                 },
3027                 {
3028                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3029                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3030                 },
3031                 {
3032                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3033                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3034                 }
3035         }
3036 };
3037
3038
3039 static void ixj_write_cid_bit(IXJ *j, int bit)
3040 {
3041         while (j->fskcnt < 20) {
3042                 if(j->fskdcnt < (j->fsksize - 1))
3043                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3044
3045                 j->fskcnt += 3;
3046         }
3047         j->fskcnt %= 20;
3048
3049         if (!bit)
3050                 j->fskz++;
3051         if (j->fskz >= 6)
3052                 j->fskz = 0;
3053
3054 }
3055
3056 static void ixj_write_cid_byte(IXJ *j, char byte)
3057 {
3058         IXJ_CBYTE cb;
3059
3060                 cb.cbyte = byte;
3061                 ixj_write_cid_bit(j, 0);
3062                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3063                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3064                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3065                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3066                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3067                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3068                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3069                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3070                 ixj_write_cid_bit(j, 1);
3071 }
3072
3073 static void ixj_write_cid_seize(IXJ *j)
3074 {
3075         int cnt;
3076
3077         for (cnt = 0; cnt < 150; cnt++) {
3078                 ixj_write_cid_bit(j, 0);
3079                 ixj_write_cid_bit(j, 1);
3080         }
3081         for (cnt = 0; cnt < 180; cnt++) {
3082                 ixj_write_cid_bit(j, 1);
3083         }
3084 }
3085
3086 static void ixj_write_cidcw_seize(IXJ *j)
3087 {
3088         int cnt;
3089
3090         for (cnt = 0; cnt < 80; cnt++) {
3091                 ixj_write_cid_bit(j, 1);
3092         }
3093 }
3094
3095 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3096 {
3097         int cnt;
3098
3099         for (cnt = 0; cnt < strlen(s); cnt++) {
3100                 ixj_write_cid_byte(j, s[cnt]);
3101                 checksum = (checksum + s[cnt]);
3102         }
3103         return checksum;
3104 }
3105
3106 static void ixj_pad_fsk(IXJ *j, int pad)
3107 {
3108         int cnt;
3109
3110         for (cnt = 0; cnt < pad; cnt++) {
3111                 if(j->fskdcnt < (j->fsksize - 1))
3112                         j->fskdata[j->fskdcnt++] = 0x0000;
3113         }
3114         for (cnt = 0; cnt < 720; cnt++) {
3115                 if(j->fskdcnt < (j->fsksize - 1))
3116                         j->fskdata[j->fskdcnt++] = 0x0000;
3117         }
3118 }
3119
3120 static void ixj_pre_cid(IXJ *j)
3121 {
3122         j->cid_play_codec = j->play_codec;
3123         j->cid_play_frame_size = j->play_frame_size;
3124         j->cid_play_volume = get_play_volume(j);
3125         j->cid_play_flag = j->flags.playing;
3126
3127         j->cid_rec_codec = j->rec_codec;
3128         j->cid_rec_volume = get_rec_volume(j);
3129         j->cid_rec_flag = j->flags.recording;
3130
3131         j->cid_play_aec_level = j->aec_level;
3132
3133         switch(j->baseframe.low) {
3134                 case 0xA0:
3135                         j->cid_base_frame_size = 20;
3136                         break;
3137                 case 0x50:
3138                         j->cid_base_frame_size = 10;
3139                         break;
3140                 case 0xF0:
3141                         j->cid_base_frame_size = 30;
3142                         break;
3143         }
3144
3145         ixj_play_stop(j);
3146         ixj_cpt_stop(j);
3147
3148         j->flags.cidplay = 1;
3149
3150         set_base_frame(j, 30);
3151         set_play_codec(j, LINEAR16);
3152         set_play_volume(j, 0x1B);
3153         ixj_play_start(j);
3154 }
3155
3156 static void ixj_post_cid(IXJ *j)
3157 {
3158         ixj_play_stop(j);
3159
3160         if(j->cidsize > 5000) {
3161                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3162         }
3163         j->flags.cidplay = 0;
3164         if(ixjdebug & 0x0200) {
3165                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3166         }
3167
3168         ixj_fsk_free(j);
3169
3170         j->fskdcnt = 0;
3171         set_base_frame(j, j->cid_base_frame_size);
3172         set_play_codec(j, j->cid_play_codec);
3173         ixj_aec_start(j, j->cid_play_aec_level);
3174         set_play_volume(j, j->cid_play_volume);
3175
3176         set_rec_codec(j, j->cid_rec_codec);
3177         set_rec_volume(j, j->cid_rec_volume);
3178
3179         if(j->cid_rec_flag)
3180                 ixj_record_start(j);
3181
3182         if(j->cid_play_flag)
3183                 ixj_play_start(j);
3184
3185         if(j->cid_play_flag) {
3186                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3187         }
3188 }
3189
3190 static void ixj_write_cid(IXJ *j)
3191 {
3192         char sdmf1[50];
3193         char sdmf2[50];
3194         char sdmf3[80];
3195         char mdmflen, len1, len2, len3;
3196         int pad;
3197
3198         int checksum = 0;
3199
3200         if (j->dsp.low == 0x20 || j->flags.cidplay)
3201                 return;
3202
3203         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3204         j->cidsize = j->cidcnt = 0;
3205
3206         ixj_fsk_alloc(j);
3207
3208         strcpy(sdmf1, j->cid_send.month);
3209         strcat(sdmf1, j->cid_send.day);
3210         strcat(sdmf1, j->cid_send.hour);
3211         strcat(sdmf1, j->cid_send.min);
3212         strcpy(sdmf2, j->cid_send.number);
3213         strcpy(sdmf3, j->cid_send.name);
3214
3215         len1 = strlen(sdmf1);
3216         len2 = strlen(sdmf2);
3217         len3 = strlen(sdmf3);
3218         mdmflen = len1 + len2 + len3 + 6;
3219
3220         while(1){
3221                 ixj_write_cid_seize(j);
3222
3223                 ixj_write_cid_byte(j, 0x80);
3224                 checksum = 0x80;
3225                 ixj_write_cid_byte(j, mdmflen);
3226                 checksum = checksum + mdmflen;
3227
3228                 ixj_write_cid_byte(j, 0x01);
3229                 checksum = checksum + 0x01;
3230                 ixj_write_cid_byte(j, len1);
3231                 checksum = checksum + len1;
3232                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3233                 if(ixj_hookstate(j) & 1)
3234                         break;
3235
3236                 ixj_write_cid_byte(j, 0x02);
3237                 checksum = checksum + 0x02;
3238                 ixj_write_cid_byte(j, len2);
3239                 checksum = checksum + len2;
3240                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3241                 if(ixj_hookstate(j) & 1)
3242                         break;
3243
3244                 ixj_write_cid_byte(j, 0x07);
3245                 checksum = checksum + 0x07;
3246                 ixj_write_cid_byte(j, len3);
3247                 checksum = checksum + len3;
3248                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3249                 if(ixj_hookstate(j) & 1)
3250                         break;
3251
3252                 checksum %= 256;
3253                 checksum ^= 0xFF;
3254                 checksum += 1;
3255
3256                 ixj_write_cid_byte(j, (char) checksum);
3257
3258                 pad = j->fskdcnt % 240;
3259                 if (pad) {
3260                         pad = 240 - pad;
3261                 }
3262                 ixj_pad_fsk(j, pad);
3263                 break;
3264         }
3265
3266         ixj_write_frame(j);
3267 }
3268
3269 static void ixj_write_cidcw(IXJ *j)
3270 {
3271         IXJ_TONE ti;
3272
3273         char sdmf1[50];
3274         char sdmf2[50];
3275         char sdmf3[80];
3276         char mdmflen, len1, len2, len3;
3277         int pad;
3278
3279         int checksum = 0;
3280
3281         if (j->dsp.low == 0x20 || j->flags.cidplay)
3282                 return;
3283
3284         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3285         j->cidsize = j->cidcnt = 0;
3286
3287         ixj_fsk_alloc(j);
3288
3289         j->flags.cidcw_ack = 0;
3290
3291         ti.tone_index = 23;
3292         ti.gain0 = 1;
3293         ti.freq0 = hz440;
3294         ti.gain1 = 0;
3295         ti.freq1 = 0;
3296         ixj_init_tone(j, &ti);
3297
3298         ixj_set_tone_on(1500, j);
3299         ixj_set_tone_off(32, j);
3300         if(ixjdebug & 0x0200) {
3301                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3302         }
3303         ixj_play_tone(j, 23);
3304
3305         clear_bit(j->board, &j->busyflags);
3306         while(j->tone_state) {
3307                 set_current_state(TASK_INTERRUPTIBLE);
3308                 schedule_timeout(1);
3309         }
3310         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3311                 set_current_state(TASK_INTERRUPTIBLE);
3312                 schedule_timeout(1);
3313         }
3314         if(ixjdebug & 0x0200) {
3315                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3316         }
3317
3318         ti.tone_index = 24;
3319         ti.gain0 = 1;
3320         ti.freq0 = hz2130;
3321         ti.gain1 = 0;
3322         ti.freq1 = hz2750;
3323         ixj_init_tone(j, &ti);
3324
3325         ixj_set_tone_off(10, j);
3326         ixj_set_tone_on(600, j);
3327         if(ixjdebug & 0x0200) {
3328                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3329         }
3330         ixj_play_tone(j, 24);
3331
3332         clear_bit(j->board, &j->busyflags);
3333         while(j->tone_state) {
3334                 set_current_state(TASK_INTERRUPTIBLE);
3335                 schedule_timeout(1);
3336         }
3337         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3338                 set_current_state(TASK_INTERRUPTIBLE);
3339                 schedule_timeout(1);
3340         }
3341         if(ixjdebug & 0x0200) {
3342                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3343         }
3344
3345         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3346
3347         clear_bit(j->board, &j->busyflags);
3348         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait)) {
3349                 set_current_state(TASK_INTERRUPTIBLE);
3350                 schedule_timeout(1);
3351         }
3352         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0) {
3353                 set_current_state(TASK_INTERRUPTIBLE);
3354                 schedule_timeout(1);
3355         }
3356         j->cidcw_wait = 0;
3357         if(!j->flags.cidcw_ack) {
3358                 if(ixjdebug & 0x0200) {
3359                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3360                 }
3361                 ixj_post_cid(j);
3362                 if(j->cid_play_flag) {
3363                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3364                 }
3365                 return;
3366         } else {
3367                 ixj_pre_cid(j);
3368         }
3369         j->flags.cidcw_ack = 0;
3370         strcpy(sdmf1, j->cid_send.month);
3371         strcat(sdmf1, j->cid_send.day);
3372         strcat(sdmf1, j->cid_send.hour);
3373         strcat(sdmf1, j->cid_send.min);
3374         strcpy(sdmf2, j->cid_send.number);
3375         strcpy(sdmf3, j->cid_send.name);
3376
3377         len1 = strlen(sdmf1);
3378         len2 = strlen(sdmf2);
3379         len3 = strlen(sdmf3);
3380         mdmflen = len1 + len2 + len3 + 6;
3381
3382         ixj_write_cidcw_seize(j);
3383
3384         ixj_write_cid_byte(j, 0x80);
3385         checksum = 0x80;
3386         ixj_write_cid_byte(j, mdmflen);
3387         checksum = checksum + mdmflen;
3388
3389         ixj_write_cid_byte(j, 0x01);
3390         checksum = checksum + 0x01;
3391         ixj_write_cid_byte(j, len1);
3392         checksum = checksum + len1;
3393         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3394
3395         ixj_write_cid_byte(j, 0x02);
3396         checksum = checksum + 0x02;
3397         ixj_write_cid_byte(j, len2);
3398         checksum = checksum + len2;
3399         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3400
3401         ixj_write_cid_byte(j, 0x07);
3402         checksum = checksum + 0x07;
3403         ixj_write_cid_byte(j, len3);
3404         checksum = checksum + len3;
3405         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3406
3407         checksum %= 256;
3408         checksum ^= 0xFF;
3409         checksum += 1;
3410
3411         ixj_write_cid_byte(j, (char) checksum);
3412
3413         pad = j->fskdcnt % 240;
3414         if (pad) {
3415                 pad = 240 - pad;
3416         }
3417         ixj_pad_fsk(j, pad);
3418         if(ixjdebug & 0x0200) {
3419                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3420         }
3421 }
3422
3423 static void ixj_write_vmwi(IXJ *j, int msg)
3424 {
3425         char mdmflen;
3426         int pad;
3427
3428         int checksum = 0;
3429
3430         if (j->dsp.low == 0x20 || j->flags.cidplay)
3431                 return;
3432
3433         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3434         j->cidsize = j->cidcnt = 0;
3435
3436         ixj_fsk_alloc(j);
3437
3438         mdmflen = 3;
3439
3440         if (j->port == PORT_POTS)
3441                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3442
3443         ixj_write_cid_seize(j);
3444
3445         ixj_write_cid_byte(j, 0x82);
3446         checksum = 0x82;
3447         ixj_write_cid_byte(j, mdmflen);
3448         checksum = checksum + mdmflen;
3449
3450         ixj_write_cid_byte(j, 0x0B);
3451         checksum = checksum + 0x0B;
3452         ixj_write_cid_byte(j, 1);
3453         checksum = checksum + 1;
3454
3455         if(msg) {
3456                 ixj_write_cid_byte(j, 0xFF);
3457                 checksum = checksum + 0xFF;
3458         }
3459         else {
3460                 ixj_write_cid_byte(j, 0x00);
3461                 checksum = checksum + 0x00;
3462         }
3463
3464         checksum %= 256;
3465         checksum ^= 0xFF;
3466         checksum += 1;
3467
3468         ixj_write_cid_byte(j, (char) checksum);
3469
3470         pad = j->fskdcnt % 240;
3471         if (pad) {
3472                 pad = 240 - pad;
3473         }
3474         ixj_pad_fsk(j, pad);
3475 }
3476
3477 static void ixj_write_frame(IXJ *j)
3478 {
3479         int cnt, frame_count, dly;
3480         IXJ_WORD dat;
3481         BYTES blankword;
3482
3483         frame_count = 0;
3484         if(j->flags.cidplay) {
3485                 for(cnt = 0; cnt < 480; cnt++) {
3486                         if (!(cnt % 16) && !IsTxReady(j)) {
3487                                 dly = 0;
3488                                 while (!IsTxReady(j)) {
3489                                         if (dly++ > 5) {
3490                                                 dly = 0;
3491                                                 break;
3492                                         }
3493                                         udelay(10);
3494                                 }
3495                         }
3496                         dat.word = j->fskdata[j->cidcnt++];
3497                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3498                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3499                         cnt++;
3500                 }
3501                 if(j->cidcnt >= j->fskdcnt) {
3502                         ixj_post_cid(j);
3503                 }
3504                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3505                    and there is real audio data in the buffer, we need to throw it away because
3506                    we just used it's time slot */
3507                 if (j->write_buffer_rp > j->write_buffer_wp) {
3508                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3509                         if (j->write_buffer_rp >= j->write_buffer_end) {
3510                                 j->write_buffer_rp = j->write_buffer;
3511                         }
3512                         j->write_buffers_empty++;
3513                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3514
3515                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3516                 }
3517         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3518                 if (j->write_buffer_wp > j->write_buffer_rp) {
3519                         frame_count =
3520                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3521                 }
3522                 if (j->write_buffer_rp > j->write_buffer_wp) {
3523                         frame_count =
3524                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3525                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3526                 }
3527                 if (frame_count >= 1) {
3528                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3529                                 switch (j->play_mode) {
3530                                 case PLAYBACK_MODE_ULAW:
3531                                 case PLAYBACK_MODE_ALAW:
3532                                         blankword.low = blankword.high = 0xFF;
3533                                         break;
3534                                 case PLAYBACK_MODE_8LINEAR:
3535                                 case PLAYBACK_MODE_16LINEAR:
3536                                         blankword.low = blankword.high = 0x00;
3537                                         break;
3538                                 case PLAYBACK_MODE_8LINEAR_WSS:
3539                                         blankword.low = blankword.high = 0x80;
3540                                         break;
3541                                 }
3542                                 for (cnt = 0; cnt < 16; cnt++) {
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                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3558                                 for (cnt = 0; cnt < 24; cnt++) {
3559                                         if(cnt == 12) {
3560                                                 blankword.low = 0x02;
3561                                                 blankword.high = 0x00;
3562                                         }
3563                                         else {
3564                                                 blankword.low = blankword.high = 0x00;
3565                                         }
3566                                         if (!(cnt % 16) && !IsTxReady(j)) {
3567                                                 dly = 0;
3568                                                 while (!IsTxReady(j)) {
3569                                                         if (dly++ > 5) {
3570                                                                 dly = 0;
3571                                                                 break;
3572                                                         }
3573                                                         udelay(10);
3574                                                 }
3575                                         }
3576                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3577                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3578                                 }
3579                                 j->flags.play_first_frame = 0;
3580                         }
3581                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3582                                 if (!(cnt % 16) && !IsTxReady(j)) {
3583                                         dly = 0;
3584                                         while (!IsTxReady(j)) {
3585                                                 if (dly++ > 5) {
3586                                                         dly = 0;
3587                                                         break;
3588                                                 }
3589                                                 udelay(10);
3590                                         }
3591                                 }
3592                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3593                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3594                                         if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
3595                                            j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
3596                                            j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
3597                                            j->write_buffer_rp + cnt + 9 == 0) {
3598                                         /* someone is trying to write silence lets make this a type 0 frame. */
3599                                                 outb_p(0x00, j->DSPbase + 0x0C);
3600                                                 outb_p(0x00, j->DSPbase + 0x0D);
3601                                         } else {
3602                                         /* so all other frames are type 1. */
3603                                                 outb_p(0x01, j->DSPbase + 0x0C);
3604                                                 outb_p(0x00, j->DSPbase + 0x0D);
3605                                         }
3606                                 }
3607                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3608                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3609                                 *(j->write_buffer_rp + cnt) = 0;
3610                                 *(j->write_buffer_rp + cnt + 1) = 0;
3611                         }
3612                         j->write_buffer_rp += j->play_frame_size * 2;
3613                         if (j->write_buffer_rp >= j->write_buffer_end) {
3614                                 j->write_buffer_rp = j->write_buffer;
3615                         }
3616                         j->write_buffers_empty++;
3617                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3618
3619                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3620
3621                         ++j->frameswritten;
3622                 }
3623         } else {
3624                 j->drybuffer++;
3625         }
3626         if(j->ixj_signals[SIG_WRITE_READY]) {
3627                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3628         }
3629 }
3630
3631 static int idle(IXJ *j)
3632 {
3633         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3634
3635                 return 0;
3636
3637         if (j->ssr.high || j->ssr.low) {
3638                 return 0;
3639         } else {
3640                 j->play_mode = -1;
3641                 j->flags.playing = 0;
3642                 j->rec_mode = -1;
3643                 j->flags.recording = 0;
3644                 return 1;
3645         }
3646 }
3647
3648 static int set_base_frame(IXJ *j, int size)
3649 {
3650         unsigned short cmd;
3651         int cnt;
3652
3653         idle(j);
3654         j->cid_play_aec_level = j->aec_level;
3655         aec_stop(j);
3656         for (cnt = 0; cnt < 10; cnt++) {
3657                 if (idle(j))
3658                         break;
3659         }
3660         if (j->ssr.high || j->ssr.low)
3661                 return -1;
3662         if (j->dsp.low != 0x20) {
3663                 switch (size) {
3664                 case 30:
3665                         cmd = 0x07F0;
3666                         /* Set Base Frame Size to 240 pg9-10 8021 */
3667                         break;
3668                 case 20:
3669                         cmd = 0x07A0;
3670                         /* Set Base Frame Size to 160 pg9-10 8021 */
3671                         break;
3672                 case 10:
3673                         cmd = 0x0750;
3674                         /* Set Base Frame Size to 80 pg9-10 8021 */
3675                         break;
3676                 default:
3677                         return -1;
3678                 }
3679         } else {
3680                 if (size == 30)
3681                         return size;
3682                 else
3683                         return -1;
3684         }
3685         if (ixj_WriteDSPCommand(cmd, j)) {
3686                 j->baseframe.high = j->baseframe.low = 0xFF;
3687                 return -1;
3688         } else {
3689                 j->baseframe.high = j->ssr.high;
3690                 j->baseframe.low = j->ssr.low;
3691                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3692                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3693                         return -1;
3694                 }
3695         }
3696         ixj_aec_start(j, j->cid_play_aec_level);
3697         return size;
3698 }
3699
3700 static int set_rec_codec(IXJ *j, int rate)
3701 {
3702         int retval = 0;
3703
3704         j->rec_codec = rate;
3705
3706         switch (rate) {
3707         case G723_63:
3708                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3709                         j->rec_frame_size = 12;
3710                         j->rec_mode = 0;
3711                 } else {
3712                         retval = 1;
3713                 }
3714                 break;
3715         case G723_53:
3716                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3717                         j->rec_frame_size = 10;
3718                         j->rec_mode = 0;
3719                 } else {
3720                         retval = 1;
3721                 }
3722                 break;
3723         case TS85:
3724                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3725                         j->rec_frame_size = 16;
3726                         j->rec_mode = 0;
3727                 } else {
3728                         retval = 1;
3729                 }
3730                 break;
3731         case TS48:
3732                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3733                         j->rec_frame_size = 9;
3734                         j->rec_mode = 0;
3735                 } else {
3736                         retval = 1;
3737                 }
3738                 break;
3739         case TS41:
3740                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3741                         j->rec_frame_size = 8;
3742                         j->rec_mode = 0;
3743                 } else {
3744                         retval = 1;
3745                 }
3746                 break;
3747         case G728:
3748                 if (j->dsp.low != 0x20) {
3749                         j->rec_frame_size = 48;
3750                         j->rec_mode = 0;
3751                 } else {
3752                         retval = 1;
3753                 }
3754                 break;
3755         case G729:
3756                 if (j->dsp.low != 0x20) {
3757                         if (!j->flags.g729_loaded) {
3758                                 retval = 1;
3759                                 break;
3760                         }
3761                         switch (j->baseframe.low) {
3762                         case 0xA0:
3763                                 j->rec_frame_size = 10;
3764                                 break;
3765                         case 0x50:
3766                                 j->rec_frame_size = 5;
3767                                 break;
3768                         default:
3769                                 j->rec_frame_size = 15;
3770                                 break;
3771                         }
3772                         j->rec_mode = 0;
3773                 } else {
3774                         retval = 1;
3775                 }
3776                 break;
3777         case G729B:
3778                 if (j->dsp.low != 0x20) {
3779                         if (!j->flags.g729_loaded) {
3780                                 retval = 1;
3781                                 break;
3782                         }
3783                         switch (j->baseframe.low) {
3784                         case 0xA0:
3785                                 j->rec_frame_size = 12;
3786                                 break;
3787                         case 0x50:
3788                                 j->rec_frame_size = 6;
3789                                 break;
3790                         default:
3791                                 j->rec_frame_size = 18;
3792                                 break;
3793                         }
3794                         j->rec_mode = 0;
3795                 } else {
3796                         retval = 1;
3797                 }
3798                 break;
3799         case ULAW:
3800                 switch (j->baseframe.low) {
3801                 case 0xA0:
3802                         j->rec_frame_size = 80;
3803                         break;
3804                 case 0x50:
3805                         j->rec_frame_size = 40;
3806                         break;
3807                 default:
3808                         j->rec_frame_size = 120;
3809                         break;
3810                 }
3811                 j->rec_mode = 4;
3812                 break;
3813         case ALAW:
3814                 switch (j->baseframe.low) {
3815                 case 0xA0:
3816                         j->rec_frame_size = 80;
3817                         break;
3818                 case 0x50:
3819                         j->rec_frame_size = 40;
3820                         break;
3821                 default:
3822                         j->rec_frame_size = 120;
3823                         break;
3824                 }
3825                 j->rec_mode = 4;
3826                 break;
3827         case LINEAR16:
3828                 switch (j->baseframe.low) {
3829                 case 0xA0:
3830                         j->rec_frame_size = 160;
3831                         break;
3832                 case 0x50:
3833                         j->rec_frame_size = 80;
3834                         break;
3835                 default:
3836                         j->rec_frame_size = 240;
3837                         break;
3838                 }
3839                 j->rec_mode = 5;
3840                 break;
3841         case LINEAR8:
3842                 switch (j->baseframe.low) {
3843                 case 0xA0:
3844                         j->rec_frame_size = 80;
3845                         break;
3846                 case 0x50:
3847                         j->rec_frame_size = 40;
3848                         break;
3849                 default:
3850                         j->rec_frame_size = 120;
3851                         break;
3852                 }
3853                 j->rec_mode = 6;
3854                 break;
3855         case WSS:
3856                 switch (j->baseframe.low) {
3857                 case 0xA0:
3858                         j->rec_frame_size = 80;
3859                         break;
3860                 case 0x50:
3861                         j->rec_frame_size = 40;
3862                         break;
3863                 default:
3864                         j->rec_frame_size = 120;
3865                         break;
3866                 }
3867                 j->rec_mode = 7;
3868                 break;
3869         default:
3870                 j->rec_frame_size = 0;
3871                 j->rec_mode = -1;
3872                 if (j->read_buffer) {
3873                         kfree(j->read_buffer);
3874                         j->read_buffer = NULL;
3875                         j->read_buffer_size = 0;
3876                 }
3877                 retval = 1;
3878                 break;
3879         }
3880         return retval;
3881 }
3882
3883 static int ixj_record_start(IXJ *j)
3884 {
3885         unsigned short cmd = 0x0000;
3886
3887         if (j->read_buffer) {
3888                 ixj_record_stop(j);
3889         }
3890         j->flags.recording = 1;
3891         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3892
3893         if(ixjdebug & 0x0002)
3894                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3895
3896         if (!j->rec_mode) {
3897                 switch (j->rec_codec) {
3898                 case G723_63:
3899                         cmd = 0x5131;
3900                         break;
3901                 case G723_53:
3902                         cmd = 0x5132;
3903                         break;
3904                 case TS85:
3905                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3906
3907                         break;
3908                 case TS48:
3909                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3910
3911                         break;
3912                 case TS41:
3913                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3914
3915                         break;
3916                 case G728:
3917                         cmd = 0x5135;
3918                         break;
3919                 case G729:
3920                 case G729B:
3921                         cmd = 0x5136;
3922                         break;
3923                 default:
3924                         return 1;
3925                 }
3926                 if (ixj_WriteDSPCommand(cmd, j))
3927                         return -1;
3928         }
3929         if (!j->read_buffer) {
3930                 if (!j->read_buffer)
3931                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3932                 if (!j->read_buffer) {
3933                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3934                         return -ENOMEM;
3935                 }
3936         }
3937         j->read_buffer_size = j->rec_frame_size * 2;
3938
3939         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3940
3941                 return -1;
3942
3943         switch (j->rec_mode) {
3944         case 0:
3945                 cmd = 0x1C03;   /* Record C1 */
3946
3947                 break;
3948         case 4:
3949                 if (j->ver.low == 0x12) {
3950                         cmd = 0x1E03;   /* Record C1 */
3951
3952                 } else {
3953                         cmd = 0x1E01;   /* Record C1 */
3954
3955                 }
3956                 break;
3957         case 5:
3958                 if (j->ver.low == 0x12) {
3959                         cmd = 0x1E83;   /* Record C1 */
3960
3961                 } else {
3962                         cmd = 0x1E81;   /* Record C1 */
3963
3964                 }
3965                 break;
3966         case 6:
3967                 if (j->ver.low == 0x12) {
3968                         cmd = 0x1F03;   /* Record C1 */
3969
3970                 } else {
3971                         cmd = 0x1F01;   /* Record C1 */
3972
3973                 }
3974                 break;
3975         case 7:
3976                 if (j->ver.low == 0x12) {
3977                         cmd = 0x1F83;   /* Record C1 */
3978                 } else {
3979                         cmd = 0x1F81;   /* Record C1 */
3980                 }
3981                 break;
3982         }
3983         if (ixj_WriteDSPCommand(cmd, j))
3984                 return -1;
3985
3986         if (j->flags.playing) {
3987                 ixj_aec_start(j, j->aec_level);
3988         }
3989         return 0;
3990 }
3991
3992 static void ixj_record_stop(IXJ *j)
3993 {
3994         if(ixjdebug & 0x0002)
3995                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3996
3997         if (j->read_buffer) {
3998                 kfree(j->read_buffer);
3999                 j->read_buffer = NULL;
4000                 j->read_buffer_size = 0;
4001         }
4002         if (j->rec_mode > -1) {
4003                 ixj_WriteDSPCommand(0x5120, j);
4004                 j->rec_mode = -1;
4005         }
4006         j->flags.recording = 0;
4007 }
4008 static void ixj_vad(IXJ *j, int arg)
4009 {
4010         if (arg)
4011                 ixj_WriteDSPCommand(0x513F, j);
4012         else
4013                 ixj_WriteDSPCommand(0x513E, j);
4014 }
4015
4016 static void set_rec_depth(IXJ *j, int depth)
4017 {
4018         if (depth > 60)
4019                 depth = 60;
4020         if (depth < 0)
4021                 depth = 0;
4022         ixj_WriteDSPCommand(0x5180 + depth, j);
4023 }
4024
4025 static void set_dtmf_prescale(IXJ *j, int volume)
4026 {
4027         ixj_WriteDSPCommand(0xCF07, j);
4028         ixj_WriteDSPCommand(volume, j);
4029 }
4030
4031 static int get_dtmf_prescale(IXJ *j)
4032 {
4033         ixj_WriteDSPCommand(0xCF05, j);
4034         return j->ssr.high << 8 | j->ssr.low;
4035 }
4036
4037 static void set_rec_volume(IXJ *j, int volume)
4038 {
4039         if(j->aec_level == AEC_AGC) {
4040                 if (ixjdebug & 0x0002)
4041                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4042                 ixj_WriteDSPCommand(0xCF96, j);
4043                 ixj_WriteDSPCommand(volume, j);
4044         } else {
4045                 if (ixjdebug & 0x0002)
4046                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4047                 ixj_WriteDSPCommand(0xCF03, j);
4048                 ixj_WriteDSPCommand(volume, j);
4049         }
4050 }
4051
4052 static int set_rec_volume_linear(IXJ *j, int volume)
4053 {
4054         int newvolume, dsprecmax;
4055
4056         if (ixjdebug & 0x0002)
4057                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4058         if(volume > 100 || volume < 0) {
4059           return -1;
4060         }
4061
4062         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4063         switch (j->cardtype) {
4064         case QTI_PHONEJACK:
4065                 dsprecmax = 0x440;
4066                 break;
4067         case QTI_LINEJACK:
4068                 dsprecmax = 0x180;
4069                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4070                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4071                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4072                 break;
4073         case QTI_PHONEJACK_LITE:
4074                 dsprecmax = 0x4C0;
4075                 break;
4076         case QTI_PHONEJACK_PCI:
4077                 dsprecmax = 0x100;
4078                 break;
4079         case QTI_PHONECARD:
4080                 dsprecmax = 0x400;
4081                 break;
4082         default:
4083                 return -1;
4084         }
4085         newvolume = (dsprecmax * volume) / 100;
4086         set_rec_volume(j, newvolume);
4087         return 0;
4088 }
4089
4090 static int get_rec_volume(IXJ *j)
4091 {
4092         if(j->aec_level == AEC_AGC) {
4093                 if (ixjdebug & 0x0002)
4094                         printk(KERN_INFO "Getting AGC Threshold\n");
4095                 ixj_WriteDSPCommand(0xCF86, j);
4096                 if (ixjdebug & 0x0002)
4097                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4098                 return j->ssr.high << 8 | j->ssr.low;
4099         } else {
4100                 if (ixjdebug & 0x0002)
4101                         printk(KERN_INFO "Getting Record Volume\n");
4102                 ixj_WriteDSPCommand(0xCF01, j);
4103                 return j->ssr.high << 8 | j->ssr.low;
4104         }
4105 }
4106
4107 static int get_rec_volume_linear(IXJ *j)
4108 {
4109         int volume, newvolume, dsprecmax;
4110
4111         switch (j->cardtype) {
4112         case QTI_PHONEJACK:
4113                 dsprecmax = 0x440;
4114                 break;
4115         case QTI_LINEJACK:
4116                 dsprecmax = 0x180;
4117                 break;
4118         case QTI_PHONEJACK_LITE:
4119                 dsprecmax = 0x4C0;
4120                 break;
4121         case QTI_PHONEJACK_PCI:
4122                 dsprecmax = 0x100;
4123                 break;
4124         case QTI_PHONECARD:
4125                 dsprecmax = 0x400;
4126                 break;
4127         default:
4128                 return -1;
4129         }
4130         volume = get_rec_volume(j);
4131         newvolume = (volume * 100) / dsprecmax;
4132         if(newvolume > 100)
4133                 newvolume = 100;
4134         return newvolume;
4135 }
4136
4137 static int get_rec_level(IXJ *j)
4138 {
4139         int retval;
4140
4141         ixj_WriteDSPCommand(0xCF88, j);
4142
4143         retval = j->ssr.high << 8 | j->ssr.low;
4144         retval = (retval * 256) / 240;
4145         return retval;
4146 }
4147
4148 static void ixj_aec_start(IXJ *j, int level)
4149 {
4150         j->aec_level = level;
4151         if (ixjdebug & 0x0002)
4152                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4153         if (!level) {
4154                 aec_stop(j);
4155         } else {
4156                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4157                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4158
4159                         ixj_WriteDSPCommand(0x0300, j);
4160                 }
4161                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4162
4163                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4164
4165                 switch (level) {
4166                 case AEC_LOW:
4167                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4168
4169                         ixj_WriteDSPCommand(0xE011, j);
4170                         ixj_WriteDSPCommand(0xFFFF, j);
4171
4172                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4173                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4174
4175                         break;
4176
4177                 case AEC_MED:
4178                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4179
4180                         ixj_WriteDSPCommand(0xE011, j);
4181                         ixj_WriteDSPCommand(0x0080, j);
4182
4183                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4184                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4185
4186                         break;
4187
4188                 case AEC_HIGH:
4189                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4190
4191                         ixj_WriteDSPCommand(0xE011, j);
4192                         ixj_WriteDSPCommand(0x0080, j);
4193
4194                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4195                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4196
4197                         break;
4198
4199                 case AEC_AGC:
4200                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4201                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4202
4203                         ixj_WriteDSPCommand(0xE011, j);
4204                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4205
4206                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4207
4208                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4209                                 ixj_WriteDSPCommand(0x0224, j);
4210                         else
4211                                 ixj_WriteDSPCommand(0x1224, j);
4212
4213                         ixj_WriteDSPCommand(0xE014, j);
4214                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4215
4216                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4217
4218                         /* Now we can set the AGC initial parameters and turn it on */
4219                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4220                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4221
4222                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4223                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4224
4225                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4226                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4227
4228                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4229                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4230
4231                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4232                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4233
4234                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4235                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4236
4237                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4238                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4239
4240                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4241                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4242
4243                         break;
4244
4245                 case AEC_AUTO:
4246                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4247
4248                         ixj_WriteDSPCommand(0xE011, j);
4249                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4250
4251                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4252
4253                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4254                                 ixj_WriteDSPCommand(0x0224, j);
4255                         else
4256                                 ixj_WriteDSPCommand(0x1224, j);
4257
4258                         ixj_WriteDSPCommand(0xE014, j);
4259                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4260
4261                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4262
4263                         break;
4264                 }
4265         }
4266 }
4267
4268 static void aec_stop(IXJ *j)
4269 {
4270         j->aec_level = AEC_OFF;
4271         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4272                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4273
4274                 ixj_WriteDSPCommand(0x0700, j);
4275         }
4276         if (j->play_mode != -1 && j->rec_mode != -1)
4277         {
4278                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4279         }
4280 }
4281
4282 static int set_play_codec(IXJ *j, int rate)
4283 {
4284         int retval = 0;
4285
4286         j->play_codec = rate;
4287
4288         switch (rate) {
4289         case G723_63:
4290                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4291                         j->play_frame_size = 12;
4292                         j->play_mode = 0;
4293                 } else {
4294                         retval = 1;
4295                 }
4296                 break;
4297         case G723_53:
4298                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4299                         j->play_frame_size = 10;
4300                         j->play_mode = 0;
4301                 } else {
4302                         retval = 1;
4303                 }
4304                 break;
4305         case TS85:
4306                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4307                         j->play_frame_size = 16;
4308                         j->play_mode = 0;
4309                 } else {
4310                         retval = 1;
4311                 }
4312                 break;
4313         case TS48:
4314                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4315                         j->play_frame_size = 9;
4316                         j->play_mode = 0;
4317                 } else {
4318                         retval = 1;
4319                 }
4320                 break;
4321         case TS41:
4322                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4323                         j->play_frame_size = 8;
4324                         j->play_mode = 0;
4325                 } else {
4326                         retval = 1;
4327                 }
4328                 break;
4329         case G728:
4330                 if (j->dsp.low != 0x20) {
4331                         j->play_frame_size = 48;
4332                         j->play_mode = 0;
4333                 } else {
4334                         retval = 1;
4335                 }
4336                 break;
4337         case G729:
4338                 if (j->dsp.low != 0x20) {
4339                         if (!j->flags.g729_loaded) {
4340                                 retval = 1;
4341                                 break;
4342                         }
4343                         switch (j->baseframe.low) {
4344                         case 0xA0:
4345                                 j->play_frame_size = 10;
4346                                 break;
4347                         case 0x50:
4348                                 j->play_frame_size = 5;
4349                                 break;
4350                         default:
4351                                 j->play_frame_size = 15;
4352                                 break;
4353                         }
4354                         j->play_mode = 0;
4355                 } else {
4356                         retval = 1;
4357                 }
4358                 break;
4359         case G729B:
4360                 if (j->dsp.low != 0x20) {
4361                         if (!j->flags.g729_loaded) {
4362                                 retval = 1;
4363                                 break;
4364                         }
4365                         switch (j->baseframe.low) {
4366                         case 0xA0:
4367                                 j->play_frame_size = 12;
4368                                 break;
4369                         case 0x50:
4370                                 j->play_frame_size = 6;
4371                                 break;
4372                         default:
4373                                 j->play_frame_size = 18;
4374                                 break;
4375                         }
4376                         j->play_mode = 0;
4377                 } else {
4378                         retval = 1;
4379                 }
4380                 break;
4381         case ULAW:
4382                 switch (j->baseframe.low) {
4383                 case 0xA0:
4384                         j->play_frame_size = 80;
4385                         break;
4386                 case 0x50:
4387                         j->play_frame_size = 40;
4388                         break;
4389                 default:
4390                         j->play_frame_size = 120;
4391                         break;
4392                 }
4393                 j->play_mode = 2;
4394                 break;
4395         case ALAW:
4396                 switch (j->baseframe.low) {
4397                 case 0xA0:
4398                         j->play_frame_size = 80;
4399                         break;
4400                 case 0x50:
4401                         j->play_frame_size = 40;
4402                         break;
4403                 default:
4404                         j->play_frame_size = 120;
4405                         break;
4406                 }
4407                 j->play_mode = 2;
4408                 break;
4409         case LINEAR16:
4410                 switch (j->baseframe.low) {
4411                 case 0xA0:
4412                         j->play_frame_size = 160;
4413                         break;
4414                 case 0x50:
4415                         j->play_frame_size = 80;
4416                         break;
4417                 default:
4418                         j->play_frame_size = 240;
4419                         break;
4420                 }
4421                 j->play_mode = 6;
4422                 break;
4423         case LINEAR8:
4424                 switch (j->baseframe.low) {
4425                 case 0xA0:
4426                         j->play_frame_size = 80;
4427                         break;
4428                 case 0x50:
4429                         j->play_frame_size = 40;
4430                         break;
4431                 default:
4432                         j->play_frame_size = 120;
4433                         break;
4434                 }
4435                 j->play_mode = 4;
4436                 break;
4437         case WSS:
4438                 switch (j->baseframe.low) {
4439                 case 0xA0:
4440                         j->play_frame_size = 80;
4441                         break;
4442                 case 0x50:
4443                         j->play_frame_size = 40;
4444                         break;
4445                 default:
4446                         j->play_frame_size = 120;
4447                         break;
4448                 }
4449                 j->play_mode = 5;
4450                 break;
4451         default:
4452                 j->play_frame_size = 0;
4453                 j->play_mode = -1;
4454                 if (j->write_buffer) {
4455                         kfree(j->write_buffer);
4456                         j->write_buffer = NULL;
4457                         j->write_buffer_size = 0;
4458                 }
4459                 retval = 1;
4460                 break;
4461         }
4462         return retval;
4463 }
4464
4465 static int ixj_play_start(IXJ *j)
4466 {
4467         unsigned short cmd = 0x0000;
4468
4469         if (j->write_buffer) {
4470                 ixj_play_stop(j);
4471         }
4472
4473         if(ixjdebug & 0x0002)
4474                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4475
4476         j->flags.playing = 1;
4477         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4478
4479         j->flags.play_first_frame = 1;
4480         j->drybuffer = 0;
4481
4482         if (!j->play_mode) {
4483                 switch (j->play_codec) {
4484                 case G723_63:
4485                         cmd = 0x5231;
4486                         break;
4487                 case G723_53:
4488                         cmd = 0x5232;
4489                         break;
4490                 case TS85:
4491                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4492
4493                         break;
4494                 case TS48:
4495                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4496
4497                         break;
4498                 case TS41:
4499                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4500
4501                         break;
4502                 case G728:
4503                         cmd = 0x5235;
4504                         break;
4505                 case G729:
4506                 case G729B:
4507                         cmd = 0x5236;
4508                         break;
4509                 default:
4510                         return 1;
4511                 }
4512                 if (ixj_WriteDSPCommand(cmd, j))
4513                         return -1;
4514         }
4515         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4516         if (!j->write_buffer) {
4517                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4518                 return -ENOMEM;
4519         }
4520 /*      j->write_buffers_empty = 2; */
4521         j->write_buffers_empty = 1;
4522         j->write_buffer_size = j->play_frame_size * 2;
4523         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4524         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4525
4526         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4527
4528                 return -1;
4529
4530         switch (j->play_mode) {
4531         case 0:
4532                 cmd = 0x2C03;
4533                 break;
4534         case 2:
4535                 if (j->ver.low == 0x12) {
4536                         cmd = 0x2C23;
4537                 } else {
4538                         cmd = 0x2C21;
4539                 }
4540                 break;
4541         case 4:
4542                 if (j->ver.low == 0x12) {
4543                         cmd = 0x2C43;
4544                 } else {
4545                         cmd = 0x2C41;
4546                 }
4547                 break;
4548         case 5:
4549                 if (j->ver.low == 0x12) {
4550                         cmd = 0x2C53;
4551                 } else {
4552                         cmd = 0x2C51;
4553                 }
4554                 break;
4555         case 6:
4556                 if (j->ver.low == 0x12) {
4557                         cmd = 0x2C63;
4558                 } else {
4559                         cmd = 0x2C61;
4560                 }
4561                 break;
4562         }
4563         if (ixj_WriteDSPCommand(cmd, j))
4564                 return -1;
4565
4566         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4567                 return -1;
4568
4569         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4570                 return -1;
4571
4572         if (j->flags.recording) {
4573                 ixj_aec_start(j, j->aec_level);
4574         }
4575
4576         return 0;
4577 }
4578
4579 static void ixj_play_stop(IXJ *j)
4580 {
4581         if(ixjdebug & 0x0002)
4582                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4583
4584         if (j->write_buffer) {
4585                 kfree(j->write_buffer);
4586                 j->write_buffer = NULL;
4587                 j->write_buffer_size = 0;
4588         }
4589         if (j->play_mode > -1) {
4590                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4591
4592                 j->play_mode = -1;
4593         }
4594         j->flags.playing = 0;
4595 }
4596
4597 static inline int get_play_level(IXJ *j)
4598 {
4599         int retval;
4600
4601         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4602         return j->ssr.high << 8 | j->ssr.low;
4603         retval = j->ssr.high << 8 | j->ssr.low;
4604         retval = (retval * 256) / 240;
4605         return retval;
4606 }
4607
4608 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4609 {
4610         unsigned int mask = 0;
4611
4612         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4613
4614         poll_wait(file_p, &(j->poll_q), wait);
4615         if (j->read_buffer_ready > 0)
4616                 mask |= POLLIN | POLLRDNORM;    /* readable */
4617         if (j->write_buffers_empty > 0)
4618                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4619         if (j->ex.bytes)
4620                 mask |= POLLPRI;
4621         return mask;
4622 }
4623
4624 static int ixj_play_tone(IXJ *j, char tone)
4625 {
4626         if (!j->tone_state) {
4627                 if(ixjdebug & 0x0002) {
4628                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4629                 }
4630                 if (j->dsp.low == 0x20) {
4631                         idle(j);
4632                 }
4633                 j->tone_start_jif = jiffies;
4634
4635                 j->tone_state = 1;
4636         }
4637
4638         j->tone_index = tone;
4639         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4640                 return -1;
4641
4642         return 0;
4643 }
4644
4645 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4646 {
4647         j->tone_on_time = arg;
4648
4649         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4650
4651                 return -1;
4652
4653         if (ixj_WriteDSPCommand(arg, j))
4654                 return -1;
4655
4656         return 0;
4657 }
4658
4659 static int SCI_WaitHighSCI(IXJ *j)
4660 {
4661         int cnt;
4662
4663         j->pld_scrr.byte = inb_p(j->XILINXbase);
4664         if (!j->pld_scrr.bits.sci) {
4665                 for (cnt = 0; cnt < 10; cnt++) {
4666                         udelay(32);
4667                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4668
4669                         if ((j->pld_scrr.bits.sci))
4670                                 return 1;
4671                 }
4672                 if (ixjdebug & 0x0001)
4673                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4674                 return 0;
4675         } else
4676                 return 1;
4677 }
4678
4679 static int SCI_WaitLowSCI(IXJ *j)
4680 {
4681         int cnt;
4682
4683         j->pld_scrr.byte = inb_p(j->XILINXbase);
4684         if (j->pld_scrr.bits.sci) {
4685                 for (cnt = 0; cnt < 10; cnt++) {
4686                         udelay(32);
4687                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4688
4689                         if (!(j->pld_scrr.bits.sci))
4690                                 return 1;
4691                 }
4692                 if (ixjdebug & 0x0001)
4693                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4694                 return 0;
4695         } else
4696                 return 1;
4697 }
4698
4699 static int SCI_Control(IXJ *j, int control)
4700 {
4701         switch (control) {
4702         case SCI_End:
4703                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4704
4705                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4706
4707                 break;
4708         case SCI_Enable_DAA:
4709                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4710
4711                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4712
4713                 break;
4714         case SCI_Enable_Mixer:
4715                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4716
4717                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4718
4719                 break;
4720         case SCI_Enable_EEPROM:
4721                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4722
4723                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4724
4725                 break;
4726         default:
4727                 return 0;
4728                 break;
4729         }
4730         outb_p(j->pld_scrw.byte, j->XILINXbase);
4731
4732         switch (control) {
4733         case SCI_End:
4734                 return 1;
4735                 break;
4736         case SCI_Enable_DAA:
4737         case SCI_Enable_Mixer:
4738         case SCI_Enable_EEPROM:
4739                 if (!SCI_WaitHighSCI(j))
4740                         return 0;
4741                 break;
4742         default:
4743                 return 0;
4744                 break;
4745         }
4746         return 1;
4747 }
4748
4749 static int SCI_Prepare(IXJ *j)
4750 {
4751         if (!SCI_Control(j, SCI_End))
4752                 return 0;
4753
4754         if (!SCI_WaitLowSCI(j))
4755                 return 0;
4756
4757         return 1;
4758 }
4759
4760 static int ixj_get_mixer(long val, IXJ *j)
4761 {
4762         int reg = (val & 0x1F00) >> 8;
4763         return j->mix.vol[reg];
4764 }
4765
4766 static int ixj_mixer(long val, IXJ *j)
4767 {
4768         BYTES bytes;
4769
4770         bytes.high = (val & 0x1F00) >> 8;
4771         bytes.low = val & 0x00FF;
4772
4773         /* save mixer value so we can get back later on */
4774         j->mix.vol[bytes.high] = bytes.low;
4775
4776         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4777
4778         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4779
4780         SCI_Control(j, SCI_Enable_Mixer);
4781
4782         SCI_Control(j, SCI_End);
4783
4784         return 0;
4785 }
4786
4787 static int daa_load(BYTES * p_bytes, IXJ *j)
4788 {
4789         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4790         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4791         if (!SCI_Control(j, SCI_Enable_DAA))
4792                 return 0;
4793         else
4794                 return 1;
4795 }
4796
4797 static int ixj_daa_cr4(IXJ *j, char reg)
4798 {
4799         BYTES bytes;
4800
4801         switch (j->daa_mode) {
4802         case SOP_PU_SLEEP:
4803                 bytes.high = 0x14;
4804                 break;
4805         case SOP_PU_RINGING:
4806                 bytes.high = 0x54;
4807                 break;
4808         case SOP_PU_CONVERSATION:
4809                 bytes.high = 0x94;
4810                 break;
4811         case SOP_PU_PULSEDIALING:
4812                 bytes.high = 0xD4;
4813                 break;
4814         }
4815
4816         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4817
4818         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4819         case 0:
4820                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4821                 break;
4822         case 1:
4823                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4824                 break;
4825         case 2:
4826                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4827                 break;
4828         case 3:
4829                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4830                 break;
4831         }
4832
4833         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4834
4835         if (!daa_load(&bytes, j))
4836                 return 0;
4837
4838         if (!SCI_Prepare(j))
4839                 return 0;
4840
4841         return 1;
4842 }
4843
4844 static char daa_int_read(IXJ *j)
4845 {
4846         BYTES bytes;
4847
4848         if (!SCI_Prepare(j))
4849                 return 0;
4850
4851         bytes.high = 0x38;
4852         bytes.low = 0x00;
4853         outb_p(bytes.high, j->XILINXbase + 0x03);
4854         outb_p(bytes.low, j->XILINXbase + 0x02);
4855
4856         if (!SCI_Control(j, SCI_Enable_DAA))
4857                 return 0;
4858
4859         bytes.high = inb_p(j->XILINXbase + 0x03);
4860         bytes.low = inb_p(j->XILINXbase + 0x02);
4861         if (bytes.low != ALISDAA_ID_BYTE) {
4862                 if (ixjdebug & 0x0001)
4863                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4864                 return 0;
4865         }
4866         if (!SCI_Control(j, SCI_Enable_DAA))
4867                 return 0;
4868         if (!SCI_Control(j, SCI_End))
4869                 return 0;
4870
4871         bytes.high = inb_p(j->XILINXbase + 0x03);
4872         bytes.low = inb_p(j->XILINXbase + 0x02);
4873
4874         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4875
4876         return 1;
4877 }
4878
4879 static char daa_CR_read(IXJ *j, int cr)
4880 {
4881         IXJ_WORD wdata;
4882         BYTES bytes;
4883
4884         if (!SCI_Prepare(j))
4885                 return 0;
4886
4887         switch (j->daa_mode) {
4888         case SOP_PU_SLEEP:
4889                 bytes.high = 0x30 + cr;
4890                 break;
4891         case SOP_PU_RINGING:
4892                 bytes.high = 0x70 + cr;
4893                 break;
4894         case SOP_PU_CONVERSATION:
4895                 bytes.high = 0xB0 + cr;
4896                 break;
4897         case SOP_PU_PULSEDIALING:
4898                 bytes.high = 0xF0 + cr;
4899                 break;
4900         }
4901
4902         bytes.low = 0x00;
4903
4904         outb_p(bytes.high, j->XILINXbase + 0x03);
4905         outb_p(bytes.low, j->XILINXbase + 0x02);
4906
4907         if (!SCI_Control(j, SCI_Enable_DAA))
4908                 return 0;
4909
4910         bytes.high = inb_p(j->XILINXbase + 0x03);
4911         bytes.low = inb_p(j->XILINXbase + 0x02);
4912         if (bytes.low != ALISDAA_ID_BYTE) {
4913                 if (ixjdebug & 0x0001)
4914                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4915                 return 0;
4916         }
4917         if (!SCI_Control(j, SCI_Enable_DAA))
4918                 return 0;
4919         if (!SCI_Control(j, SCI_End))
4920                 return 0;
4921
4922         wdata.word = inw_p(j->XILINXbase + 0x02);
4923
4924         switch(cr){
4925                 case 5:
4926                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4927                         break;
4928                 case 4:
4929                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4930                         break;
4931                 case 3:
4932                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4933                         break;
4934                 case 2:
4935                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4936                         break;
4937                 case 1:
4938                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4939                         break;
4940                 case 0:
4941                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4942                         break;
4943                 default:
4944                         return 0;
4945         }
4946         return 1;
4947 }
4948
4949 static int ixj_daa_cid_reset(IXJ *j)
4950 {
4951         int i;
4952         BYTES bytes;
4953
4954         if (ixjdebug & 0x0002)
4955                 printk("DAA Clearing CID ram\n");
4956
4957         if (!SCI_Prepare(j))
4958                 return 0;
4959
4960         bytes.high = 0x58;
4961         bytes.low = 0x00;
4962         outb_p(bytes.high, j->XILINXbase + 0x03);
4963         outb_p(bytes.low, j->XILINXbase + 0x02);
4964
4965         if (!SCI_Control(j, SCI_Enable_DAA))
4966                 return 0;
4967
4968         if (!SCI_WaitHighSCI(j))
4969                 return 0;
4970
4971         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4972                 bytes.high = bytes.low = 0x00;
4973                 outb_p(bytes.high, j->XILINXbase + 0x03);
4974
4975                 if (i < ALISDAA_CALLERID_SIZE - 1)
4976                         outb_p(bytes.low, j->XILINXbase + 0x02);
4977
4978                 if (!SCI_Control(j, SCI_Enable_DAA))
4979                         return 0;
4980
4981                 if (!SCI_WaitHighSCI(j))
4982                         return 0;
4983
4984         }
4985
4986         if (!SCI_Control(j, SCI_End))
4987                 return 0;
4988
4989         if (ixjdebug & 0x0002)
4990                 printk("DAA CID ram cleared\n");
4991
4992         return 1;
4993 }
4994
4995 static int ixj_daa_cid_read(IXJ *j)
4996 {
4997         int i;
4998         BYTES bytes;
4999         char CID[ALISDAA_CALLERID_SIZE], mContinue;
5000         char *pIn, *pOut;
5001
5002         if (!SCI_Prepare(j))
5003                 return 0;
5004
5005         bytes.high = 0x78;
5006         bytes.low = 0x00;
5007         outb_p(bytes.high, j->XILINXbase + 0x03);
5008         outb_p(bytes.low, j->XILINXbase + 0x02);
5009
5010         if (!SCI_Control(j, SCI_Enable_DAA))
5011                 return 0;
5012
5013         if (!SCI_WaitHighSCI(j))
5014                 return 0;
5015
5016         bytes.high = inb_p(j->XILINXbase + 0x03);
5017         bytes.low = inb_p(j->XILINXbase + 0x02);
5018         if (bytes.low != ALISDAA_ID_BYTE) {
5019                 if (ixjdebug & 0x0001)
5020                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5021                 return 0;
5022         }
5023         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5024                 bytes.high = bytes.low = 0x00;
5025                 outb_p(bytes.high, j->XILINXbase + 0x03);
5026                 outb_p(bytes.low, j->XILINXbase + 0x02);
5027
5028                 if (!SCI_Control(j, SCI_Enable_DAA))
5029                         return 0;
5030
5031                 if (!SCI_WaitHighSCI(j))
5032                         return 0;
5033
5034                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5035                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5036         }
5037
5038         if (!SCI_Control(j, SCI_End))
5039                 return 0;
5040
5041         pIn = CID;
5042         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5043         mContinue = 1;
5044         while (mContinue) {
5045                 if ((pIn[1] & 0x03) == 0x01) {
5046                         pOut[0] = pIn[0];
5047                 }
5048                 if ((pIn[2] & 0x0c) == 0x04) {
5049                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5050                 }
5051                 if ((pIn[3] & 0x30) == 0x10) {
5052                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5053                 }
5054                 if ((pIn[4] & 0xc0) == 0x40) {
5055                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5056                 } else {
5057                         mContinue = FALSE;
5058                 }
5059                 pIn += 5, pOut += 4;
5060         }
5061         memset(&j->cid, 0, sizeof(PHONE_CID));
5062         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5063         pOut += 4;
5064         strncpy(j->cid.month, pOut, 2);
5065         pOut += 2;
5066         strncpy(j->cid.day, pOut, 2);
5067         pOut += 2;
5068         strncpy(j->cid.hour, pOut, 2);
5069         pOut += 2;
5070         strncpy(j->cid.min, pOut, 2);
5071         pOut += 3;
5072         j->cid.numlen = *pOut;
5073         pOut += 1;
5074         strncpy(j->cid.number, pOut, j->cid.numlen);
5075         pOut += j->cid.numlen + 1;
5076         j->cid.namelen = *pOut;
5077         pOut += 1;
5078         strncpy(j->cid.name, pOut, j->cid.namelen);
5079
5080         ixj_daa_cid_reset(j);
5081         return 1;
5082 }
5083
5084 static char daa_get_version(IXJ *j)
5085 {
5086         BYTES bytes;
5087
5088         if (!SCI_Prepare(j))
5089                 return 0;
5090
5091         bytes.high = 0x35;
5092         bytes.low = 0x00;
5093         outb_p(bytes.high, j->XILINXbase + 0x03);
5094         outb_p(bytes.low, j->XILINXbase + 0x02);
5095
5096         if (!SCI_Control(j, SCI_Enable_DAA))
5097                 return 0;
5098
5099         bytes.high = inb_p(j->XILINXbase + 0x03);
5100         bytes.low = inb_p(j->XILINXbase + 0x02);
5101         if (bytes.low != ALISDAA_ID_BYTE) {
5102                 if (ixjdebug & 0x0001)
5103                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5104                 return 0;
5105         }
5106         if (!SCI_Control(j, SCI_Enable_DAA))
5107                 return 0;
5108
5109         if (!SCI_Control(j, SCI_End))
5110                 return 0;
5111
5112         bytes.high = inb_p(j->XILINXbase + 0x03);
5113         bytes.low = inb_p(j->XILINXbase + 0x02);
5114         if (ixjdebug & 0x0002)
5115                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5116         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5117         return bytes.high;
5118 }
5119
5120 static int daa_set_mode(IXJ *j, int mode)
5121 {
5122         /* NOTE:
5123               The DAA *MUST* be in the conversation mode if the
5124               PSTN line is to be seized (PSTN line off-hook).
5125               Taking the PSTN line off-hook while the DAA is in
5126               a mode other than conversation mode will cause a
5127               hardware failure of the ALIS-A part.
5128
5129            NOTE:
5130               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5131               if the PSTN line is on-hook.  Failure to have the PSTN line
5132               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5133               ALIS-A part.
5134         */
5135
5136         BYTES bytes;
5137
5138         j->flags.pstn_rmr = 0;
5139
5140         if (!SCI_Prepare(j))
5141                 return 0;
5142
5143         switch (mode) {
5144         case SOP_PU_RESET:
5145                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5146
5147                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5148                 j->pld_slicw.bits.rly2 = 0;
5149                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5150                 bytes.high = 0x10;
5151                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5152                 daa_load(&bytes, j);
5153                 if (!SCI_Prepare(j))
5154                         return 0;
5155
5156                 j->daa_mode = SOP_PU_SLEEP;
5157                 break;
5158         case SOP_PU_SLEEP:
5159                 if(j->daa_mode == SOP_PU_SLEEP)
5160                 {
5161                         break;
5162                 }
5163                 if (ixjdebug & 0x0008)
5164                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5165 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5166                 {
5167                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5168
5169                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5170                         j->pld_slicw.bits.rly2 = 0;
5171                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5172                         bytes.high = 0x10;
5173                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5174                         daa_load(&bytes, j);
5175                         if (!SCI_Prepare(j))
5176                                 return 0;
5177                 }
5178                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5179
5180                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5181                 j->pld_slicw.bits.rly2 = 0;
5182                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5183                 bytes.high = 0x10;
5184                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5185                 daa_load(&bytes, j);
5186                 if (!SCI_Prepare(j))
5187                         return 0;
5188
5189                 j->daa_mode = SOP_PU_SLEEP;
5190                 j->flags.pstn_ringing = 0;
5191                 j->ex.bits.pstn_ring = 0;
5192                 j->pstn_sleeptil = jiffies + (hertz / 4);
5193                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5194                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5195                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5196                 break;
5197         case SOP_PU_RINGING:
5198                 if (ixjdebug & 0x0008)
5199                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5200                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5201
5202                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5203                 j->pld_slicw.bits.rly2 = 0;
5204                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5205                 bytes.high = 0x50;
5206                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5207                 daa_load(&bytes, j);
5208                 if (!SCI_Prepare(j))
5209                         return 0;
5210                 j->daa_mode = SOP_PU_RINGING;
5211                 break;
5212         case SOP_PU_CONVERSATION:
5213                 if (ixjdebug & 0x0008)
5214                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5215                 bytes.high = 0x90;
5216                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5217                 daa_load(&bytes, j);
5218                 if (!SCI_Prepare(j))
5219                         return 0;
5220                 j->pld_slicw.bits.rly2 = 1;
5221                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5222                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5223
5224                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5225                 j->daa_mode = SOP_PU_CONVERSATION;
5226                 j->flags.pstn_ringing = 0;
5227                 j->ex.bits.pstn_ring = 0;
5228                 j->pstn_sleeptil = jiffies;
5229                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5230                 break;
5231         case SOP_PU_PULSEDIALING:
5232                 if (ixjdebug & 0x0008)
5233                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5234                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5235
5236                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5237                 j->pld_slicw.bits.rly2 = 0;
5238                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5239                 bytes.high = 0xD0;
5240                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5241                 daa_load(&bytes, j);
5242                 if (!SCI_Prepare(j))
5243                         return 0;
5244                 j->daa_mode = SOP_PU_PULSEDIALING;
5245                 break;
5246         default:
5247                 break;
5248         }
5249         return 1;
5250 }
5251
5252 static int ixj_daa_write(IXJ *j)
5253 {
5254         BYTES bytes;
5255
5256         j->flags.pstncheck = 1;
5257
5258         daa_set_mode(j, SOP_PU_SLEEP);
5259
5260         if (!SCI_Prepare(j))
5261                 return 0;
5262
5263         outb_p(j->pld_scrw.byte, j->XILINXbase);
5264
5265         bytes.high = 0x14;
5266         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5267         if (!daa_load(&bytes, j))
5268                 return 0;
5269
5270         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5271         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5272         if (!daa_load(&bytes, j))
5273                 return 0;
5274
5275         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5276         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5277         if (!daa_load(&bytes, j))
5278                 return 0;
5279
5280         if (!SCI_Prepare(j))
5281                 return 0;
5282
5283         bytes.high = 0x1F;
5284         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5285         if (!daa_load(&bytes, j))
5286                 return 0;
5287
5288         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5289         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5290         if (!daa_load(&bytes, j))
5291                 return 0;
5292
5293         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5294         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5295         if (!daa_load(&bytes, j))
5296                 return 0;
5297
5298         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5299         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5300         if (!daa_load(&bytes, j))
5301                 return 0;
5302
5303         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5304         bytes.low = 0x00;
5305         if (!daa_load(&bytes, j))
5306                 return 0;
5307
5308         if (!SCI_Prepare(j))
5309                 return 0;
5310
5311         bytes.high = 0x00;
5312         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5313         if (!daa_load(&bytes, j))
5314                 return 0;
5315
5316         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5317         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5318         if (!daa_load(&bytes, j))
5319                 return 0;
5320
5321         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5322         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5323         if (!daa_load(&bytes, j))
5324                 return 0;
5325
5326         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5327         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5328         if (!daa_load(&bytes, j))
5329                 return 0;
5330
5331         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5332         bytes.low = 0x00;
5333         if (!daa_load(&bytes, j))
5334                 return 0;
5335
5336         if (!SCI_Control(j, SCI_End))
5337                 return 0;
5338         if (!SCI_WaitLowSCI(j))
5339                 return 0;
5340
5341         bytes.high = 0x01;
5342         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5343         if (!daa_load(&bytes, j))
5344                 return 0;
5345
5346         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5347         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5348         if (!daa_load(&bytes, j))
5349                 return 0;
5350
5351         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5352         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5353         if (!daa_load(&bytes, j))
5354                 return 0;
5355
5356         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5357         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5358         if (!daa_load(&bytes, j))
5359                 return 0;
5360
5361         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5362         bytes.low = 0x00;
5363         if (!daa_load(&bytes, j))
5364                 return 0;
5365
5366         if (!SCI_Control(j, SCI_End))
5367                 return 0;
5368         if (!SCI_WaitLowSCI(j))
5369                 return 0;
5370
5371         bytes.high = 0x02;
5372         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5373         if (!daa_load(&bytes, j))
5374                 return 0;
5375
5376         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5377         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5378         if (!daa_load(&bytes, j))
5379                 return 0;
5380
5381         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5382         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5383         if (!daa_load(&bytes, j))
5384                 return 0;
5385
5386         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5387         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5388         if (!daa_load(&bytes, j))
5389                 return 0;
5390
5391         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5392         bytes.low = 0x00;
5393         if (!daa_load(&bytes, j))
5394                 return 0;
5395
5396         if (!SCI_Control(j, SCI_End))
5397                 return 0;
5398         if (!SCI_WaitLowSCI(j))
5399                 return 0;
5400
5401         bytes.high = 0x03;
5402         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5403         if (!daa_load(&bytes, j))
5404                 return 0;
5405
5406         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5407         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5408         if (!daa_load(&bytes, j))
5409                 return 0;
5410
5411         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5412         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5413         if (!daa_load(&bytes, j))
5414                 return 0;
5415
5416         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5417         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5418         if (!daa_load(&bytes, j))
5419                 return 0;
5420
5421         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5422         bytes.low = 0x00;
5423         if (!daa_load(&bytes, j))
5424                 return 0;
5425
5426         if (!SCI_Control(j, SCI_End))
5427                 return 0;
5428         if (!SCI_WaitLowSCI(j))
5429                 return 0;
5430
5431         bytes.high = 0x04;
5432         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5433         if (!daa_load(&bytes, j))
5434                 return 0;
5435
5436         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5437         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5438         if (!daa_load(&bytes, j))
5439                 return 0;
5440
5441         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5442         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5443         if (!daa_load(&bytes, j))
5444                 return 0;
5445
5446         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5447         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5448         if (!daa_load(&bytes, j))
5449                 return 0;
5450
5451         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5452         bytes.low = 0x00;
5453         if (!daa_load(&bytes, j))
5454                 return 0;
5455
5456         if (!SCI_Control(j, SCI_End))
5457                 return 0;
5458         if (!SCI_WaitLowSCI(j))
5459                 return 0;
5460
5461         bytes.high = 0x05;
5462         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5463         if (!daa_load(&bytes, j))
5464                 return 0;
5465
5466         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5467         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5468         if (!daa_load(&bytes, j))
5469                 return 0;
5470
5471         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5472         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5473         if (!daa_load(&bytes, j))
5474                 return 0;
5475
5476         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5477         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5478         if (!daa_load(&bytes, j))
5479                 return 0;
5480
5481         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5482         bytes.low = 0x00;
5483         if (!daa_load(&bytes, j))
5484                 return 0;
5485
5486         if (!SCI_Control(j, SCI_End))
5487                 return 0;
5488         if (!SCI_WaitLowSCI(j))
5489                 return 0;
5490
5491         bytes.high = 0x06;
5492         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5493         if (!daa_load(&bytes, j))
5494                 return 0;
5495
5496         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5497         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5498         if (!daa_load(&bytes, j))
5499                 return 0;
5500
5501         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5502         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5503         if (!daa_load(&bytes, j))
5504                 return 0;
5505
5506         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5507         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5508         if (!daa_load(&bytes, j))
5509                 return 0;
5510
5511         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5512         bytes.low = 0x00;
5513         if (!daa_load(&bytes, j))
5514                 return 0;
5515
5516         if (!SCI_Control(j, SCI_End))
5517                 return 0;
5518         if (!SCI_WaitLowSCI(j))
5519                 return 0;
5520
5521         bytes.high = 0x07;
5522         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5523         if (!daa_load(&bytes, j))
5524                 return 0;
5525
5526         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5527         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5528         if (!daa_load(&bytes, j))
5529                 return 0;
5530
5531         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5532         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5533         if (!daa_load(&bytes, j))
5534                 return 0;
5535
5536         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5537         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5538         if (!daa_load(&bytes, j))
5539                 return 0;
5540
5541         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5542         bytes.low = 0x00;
5543         if (!daa_load(&bytes, j))
5544                 return 0;
5545
5546         if (!SCI_Control(j, SCI_End))
5547                 return 0;
5548         if (!SCI_WaitLowSCI(j))
5549                 return 0;
5550
5551         bytes.high = 0x08;
5552         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5553         if (!daa_load(&bytes, j))
5554                 return 0;
5555
5556         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5557         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5558         if (!daa_load(&bytes, j))
5559                 return 0;
5560
5561         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5562         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5563         if (!daa_load(&bytes, j))
5564                 return 0;
5565
5566         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5567         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5568         if (!daa_load(&bytes, j))
5569                 return 0;
5570
5571         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5572         bytes.low = 0x00;
5573         if (!daa_load(&bytes, j))
5574                 return 0;
5575
5576         if (!SCI_Control(j, SCI_End))
5577                 return 0;
5578         if (!SCI_WaitLowSCI(j))
5579                 return 0;
5580
5581         bytes.high = 0x09;
5582         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5583         if (!daa_load(&bytes, j))
5584                 return 0;
5585
5586         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5587         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5588         if (!daa_load(&bytes, j))
5589                 return 0;
5590
5591         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5592         bytes.low = 0x00;
5593         if (!daa_load(&bytes, j))
5594                 return 0;
5595
5596         if (!SCI_Control(j, SCI_End))
5597                 return 0;
5598         if (!SCI_WaitLowSCI(j))
5599                 return 0;
5600
5601         bytes.high = 0x0A;
5602         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5603         if (!daa_load(&bytes, j))
5604                 return 0;
5605
5606         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5607         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5608         if (!daa_load(&bytes, j))
5609                 return 0;
5610
5611         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5612         bytes.low = 0x00;
5613         if (!daa_load(&bytes, j))
5614                 return 0;
5615
5616         if (!SCI_Control(j, SCI_End))
5617                 return 0;
5618         if (!SCI_WaitLowSCI(j))
5619                 return 0;
5620
5621         bytes.high = 0x0B;
5622         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5623         if (!daa_load(&bytes, j))
5624                 return 0;
5625
5626         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5627         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5628         if (!daa_load(&bytes, j))
5629                 return 0;
5630
5631         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5632         bytes.low = 0x00;
5633         if (!daa_load(&bytes, j))
5634                 return 0;
5635
5636         if (!SCI_Control(j, SCI_End))
5637                 return 0;
5638         if (!SCI_WaitLowSCI(j))
5639                 return 0;
5640
5641         bytes.high = 0x0C;
5642         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5643         if (!daa_load(&bytes, j))
5644                 return 0;
5645
5646         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5647         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5648         if (!daa_load(&bytes, j))
5649                 return 0;
5650
5651         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5652         bytes.low = 0x00;
5653         if (!daa_load(&bytes, j))
5654                 return 0;
5655
5656         if (!SCI_Control(j, SCI_End))
5657                 return 0;
5658         if (!SCI_WaitLowSCI(j))
5659                 return 0;
5660
5661         bytes.high = 0x0D;
5662         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5663         if (!daa_load(&bytes, j))
5664                 return 0;
5665
5666         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5667         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5668         if (!daa_load(&bytes, j))
5669                 return 0;
5670
5671         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5672         bytes.low = 0x00;
5673         if (!daa_load(&bytes, j))
5674                 return 0;
5675
5676         if (!SCI_Control(j, SCI_End))
5677                 return 0;
5678         if (!SCI_WaitLowSCI(j))
5679                 return 0;
5680
5681         bytes.high = 0x0E;
5682         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5683         if (!daa_load(&bytes, j))
5684                 return 0;
5685
5686         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5687         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5688         if (!daa_load(&bytes, j))
5689                 return 0;
5690
5691         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5692         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5693         if (!daa_load(&bytes, j))
5694                 return 0;
5695
5696         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5697         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5698         if (!daa_load(&bytes, j))
5699                 return 0;
5700
5701         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5702         bytes.low = 0x00;
5703         if (!daa_load(&bytes, j))
5704                 return 0;
5705
5706         if (!SCI_Control(j, SCI_End))
5707                 return 0;
5708         if (!SCI_WaitLowSCI(j))
5709                 return 0;
5710
5711         bytes.high = 0x0F;
5712         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5713         if (!daa_load(&bytes, j))
5714                 return 0;
5715
5716         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5717         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5718         if (!daa_load(&bytes, j))
5719                 return 0;
5720
5721         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5722         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5723         if (!daa_load(&bytes, j))
5724                 return 0;
5725
5726         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5727         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5728         if (!daa_load(&bytes, j))
5729                 return 0;
5730
5731         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5732         bytes.low = 0x00;
5733         if (!daa_load(&bytes, j))
5734                 return 0;
5735
5736         udelay(32);
5737         j->pld_scrr.byte = inb_p(j->XILINXbase);
5738         if (!SCI_Control(j, SCI_End))
5739                 return 0;
5740
5741         outb_p(j->pld_scrw.byte, j->XILINXbase);
5742
5743         if (ixjdebug & 0x0002)
5744                 printk("DAA Coefficients Loaded\n");
5745
5746         j->flags.pstncheck = 0;
5747         return 1;
5748 }
5749
5750 int ixj_set_tone_off(unsigned short arg, IXJ *j)
5751 {
5752         j->tone_off_time = arg;
5753         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5754
5755                 return -1;
5756         if (ixj_WriteDSPCommand(arg, j))
5757                 return -1;
5758         return 0;
5759 }
5760
5761 static int ixj_get_tone_on(IXJ *j)
5762 {
5763         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5764
5765                 return -1;
5766         return 0;
5767 }
5768
5769 static int ixj_get_tone_off(IXJ *j)
5770 {
5771         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5772
5773                 return -1;
5774         return 0;
5775 }
5776
5777 static void ixj_busytone(IXJ *j)
5778 {
5779         j->flags.ringback = 0;
5780         j->flags.dialtone = 0;
5781         j->flags.busytone = 1;
5782         ixj_set_tone_on(0x07D0, j);
5783         ixj_set_tone_off(0x07D0, j);
5784         ixj_play_tone(j, 27);
5785 }
5786
5787 static void ixj_dialtone(IXJ *j)
5788 {
5789         j->flags.ringback = 0;
5790         j->flags.dialtone = 1;
5791         j->flags.busytone = 0;
5792         if (j->dsp.low == 0x20) {
5793                 return;
5794         } else {
5795                 ixj_set_tone_on(0xFFFF, j);
5796                 ixj_set_tone_off(0x0000, j);
5797                 ixj_play_tone(j, 25);
5798         }
5799 }
5800
5801 static void ixj_cpt_stop(IXJ *j)
5802 {
5803         if(j->tone_state || j->tone_cadence_state)
5804         {
5805                 j->flags.dialtone = 0;
5806                 j->flags.busytone = 0;
5807                 j->flags.ringback = 0;
5808                 ixj_set_tone_on(0x0001, j);
5809                 ixj_set_tone_off(0x0000, j);
5810                 ixj_play_tone(j, 0);
5811                 j->tone_state = j->tone_cadence_state = 0;
5812                 if (j->cadence_t) {
5813                         if (j->cadence_t->ce) {
5814                                 kfree(j->cadence_t->ce);
5815                         }
5816                         kfree(j->cadence_t);
5817                         j->cadence_t = NULL;
5818                 }
5819         }
5820         if (j->play_mode == -1 && j->rec_mode == -1)
5821                 idle(j);
5822         if (j->play_mode != -1 && j->dsp.low == 0x20)
5823                 ixj_play_start(j);
5824         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5825                 ixj_record_start(j);
5826 }
5827
5828 static void ixj_ringback(IXJ *j)
5829 {
5830         j->flags.busytone = 0;
5831         j->flags.dialtone = 0;
5832         j->flags.ringback = 1;
5833         ixj_set_tone_on(0x0FA0, j);
5834         ixj_set_tone_off(0x2EE0, j);
5835         ixj_play_tone(j, 26);
5836 }
5837
5838 static void ixj_testram(IXJ *j)
5839 {
5840         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5841 }
5842
5843 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5844 {
5845         ixj_cadence *lcp;
5846         IXJ_CADENCE_ELEMENT __user *cep;
5847         IXJ_CADENCE_ELEMENT *lcep;
5848         IXJ_TONE ti;
5849         int err;
5850
5851         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5852         if (lcp == NULL)
5853                 return -ENOMEM;
5854
5855         err = -EFAULT;
5856         if (copy_from_user(&lcp->elements_used,
5857                            &cp->elements_used, sizeof(int)))
5858                 goto out;
5859         if (copy_from_user(&lcp->termination,
5860                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5861                 goto out;
5862         if (get_user(cep, &cp->ce))
5863                 goto out;
5864
5865         err = -EINVAL;
5866         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5867                 goto out;
5868
5869         err = -ENOMEM;
5870         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5871         if (!lcep)
5872                 goto out;
5873
5874         err = -EFAULT;
5875         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5876                 goto out1;
5877
5878         if (j->cadence_t) {
5879                 kfree(j->cadence_t->ce);
5880                 kfree(j->cadence_t);
5881         }
5882         lcp->ce = (void *) lcep;
5883         j->cadence_t = lcp;
5884         j->tone_cadence_state = 0;
5885         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5886         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5887         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5888                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5889                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5890                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5891                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5892                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5893                 ixj_init_tone(j, &ti);
5894         }
5895         ixj_play_tone(j, lcp->ce[0].index);
5896         return 1;
5897 out1:
5898         kfree(lcep);
5899 out:
5900         kfree(lcp);
5901         return err;
5902 }
5903
5904 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5905 {
5906         IXJ_FILTER_CADENCE *lcp;
5907         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5908         if (lcp == NULL) {
5909                 if(ixjdebug & 0x0001) {
5910                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5911                 }
5912                 return -ENOMEM;
5913         }
5914         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5915                 if(ixjdebug & 0x0001) {
5916                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5917                 }
5918                 kfree(lcp);
5919                 return -EFAULT;
5920         }
5921         if (lcp->filter > 5) {
5922                 if(ixjdebug & 0x0001) {
5923                         printk(KERN_INFO "Cadence out of range\n");
5924                 }
5925                 kfree(lcp);
5926                 return -1;
5927         }
5928         j->cadence_f[lcp->filter].state = 0;
5929         j->cadence_f[lcp->filter].enable = lcp->enable;
5930         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5931         j->cadence_f[lcp->filter].on1 = lcp->on1;
5932         j->cadence_f[lcp->filter].on1min = 0;
5933         j->cadence_f[lcp->filter].on1max = 0;
5934         j->cadence_f[lcp->filter].off1 = lcp->off1;
5935         j->cadence_f[lcp->filter].off1min = 0;
5936         j->cadence_f[lcp->filter].off1max = 0;
5937         j->cadence_f[lcp->filter].on2 = lcp->on2;
5938         j->cadence_f[lcp->filter].on2min = 0;
5939         j->cadence_f[lcp->filter].on2max = 0;
5940         j->cadence_f[lcp->filter].off2 = lcp->off2;
5941         j->cadence_f[lcp->filter].off2min = 0;
5942         j->cadence_f[lcp->filter].off2max = 0;
5943         j->cadence_f[lcp->filter].on3 = lcp->on3;
5944         j->cadence_f[lcp->filter].on3min = 0;
5945         j->cadence_f[lcp->filter].on3max = 0;
5946         j->cadence_f[lcp->filter].off3 = lcp->off3;
5947         j->cadence_f[lcp->filter].off3min = 0;
5948         j->cadence_f[lcp->filter].off3max = 0;
5949         if(ixjdebug & 0x0002) {
5950                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5951         }
5952         kfree(lcp);
5953         return 0;
5954 }
5955
5956 static void add_caps(IXJ *j)
5957 {
5958         j->caps = 0;
5959         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5960         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5961         j->caplist[j->caps].captype = vendor;
5962         j->caplist[j->caps].handle = j->caps++;
5963         j->caplist[j->caps].captype = device;
5964         switch (j->cardtype) {
5965         case QTI_PHONEJACK:
5966                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5967                 break;
5968         case QTI_LINEJACK:
5969                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5970                 break;
5971         case QTI_PHONEJACK_LITE:
5972                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5973                 break;
5974         case QTI_PHONEJACK_PCI:
5975                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5976                 break;
5977         case QTI_PHONECARD:
5978                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5979                 break;
5980         }
5981         j->caplist[j->caps].cap = j->cardtype;
5982         j->caplist[j->caps].handle = j->caps++;
5983         strcpy(j->caplist[j->caps].desc, "POTS");
5984         j->caplist[j->caps].captype = port;
5985         j->caplist[j->caps].cap = pots;
5986         j->caplist[j->caps].handle = j->caps++;
5987
5988         /* add devices that can do speaker/mic */
5989         switch (j->cardtype) {
5990         case QTI_PHONEJACK:
5991         case QTI_LINEJACK:
5992         case QTI_PHONEJACK_PCI:
5993         case QTI_PHONECARD:
5994                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5995                 j->caplist[j->caps].captype = port;
5996                 j->caplist[j->caps].cap = speaker;
5997                 j->caplist[j->caps].handle = j->caps++;
5998         default:
5999                 break;
6000         }
6001
6002         /* add devices that can do handset */
6003         switch (j->cardtype) {
6004         case QTI_PHONEJACK:
6005                 strcpy(j->caplist[j->caps].desc, "HANDSET");
6006                 j->caplist[j->caps].captype = port;
6007                 j->caplist[j->caps].cap = handset;
6008                 j->caplist[j->caps].handle = j->caps++;
6009                 break;
6010         default:
6011                 break;
6012         }
6013
6014         /* add devices that can do PSTN */
6015         switch (j->cardtype) {
6016         case QTI_LINEJACK:
6017                 strcpy(j->caplist[j->caps].desc, "PSTN");
6018                 j->caplist[j->caps].captype = port;
6019                 j->caplist[j->caps].cap = pstn;
6020                 j->caplist[j->caps].handle = j->caps++;
6021                 break;
6022         default:
6023                 break;
6024         }
6025
6026         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6027         strcpy(j->caplist[j->caps].desc, "ULAW");
6028         j->caplist[j->caps].captype = codec;
6029         j->caplist[j->caps].cap = ULAW;
6030         j->caplist[j->caps].handle = j->caps++;
6031
6032         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6033         j->caplist[j->caps].captype = codec;
6034         j->caplist[j->caps].cap = LINEAR16;
6035         j->caplist[j->caps].handle = j->caps++;
6036
6037         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6038         j->caplist[j->caps].captype = codec;
6039         j->caplist[j->caps].cap = LINEAR8;
6040         j->caplist[j->caps].handle = j->caps++;
6041
6042         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6043         j->caplist[j->caps].captype = codec;
6044         j->caplist[j->caps].cap = WSS;
6045         j->caplist[j->caps].handle = j->caps++;
6046
6047         /* software ALAW codec, made from ULAW */
6048         strcpy(j->caplist[j->caps].desc, "ALAW");
6049         j->caplist[j->caps].captype = codec;
6050         j->caplist[j->caps].cap = ALAW;
6051         j->caplist[j->caps].handle = j->caps++;
6052
6053         /* version 12 of the 8020 does the following codecs in a broken way */
6054         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6055                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6056                 j->caplist[j->caps].captype = codec;
6057                 j->caplist[j->caps].cap = G723_63;
6058                 j->caplist[j->caps].handle = j->caps++;
6059
6060                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6061                 j->caplist[j->caps].captype = codec;
6062                 j->caplist[j->caps].cap = G723_53;
6063                 j->caplist[j->caps].handle = j->caps++;
6064
6065                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6066                 j->caplist[j->caps].captype = codec;
6067                 j->caplist[j->caps].cap = TS48;
6068                 j->caplist[j->caps].handle = j->caps++;
6069
6070                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6071                 j->caplist[j->caps].captype = codec;
6072                 j->caplist[j->caps].cap = TS41;
6073                 j->caplist[j->caps].handle = j->caps++;
6074         }
6075
6076         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6077         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6078                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6079                 j->caplist[j->caps].captype = codec;
6080                 j->caplist[j->caps].cap = TS85;
6081                 j->caplist[j->caps].handle = j->caps++;
6082         }
6083
6084         /* 8021 chips can do G728 */
6085         if (j->dsp.low == 0x21) {
6086                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6087                 j->caplist[j->caps].captype = codec;
6088                 j->caplist[j->caps].cap = G728;
6089                 j->caplist[j->caps].handle = j->caps++;
6090         }
6091
6092         /* 8021/8022 chips can do G729 if loaded */
6093         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6094                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6095                 j->caplist[j->caps].captype = codec;
6096                 j->caplist[j->caps].cap = G729;
6097                 j->caplist[j->caps].handle = j->caps++;
6098         }
6099         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6100                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6101                 j->caplist[j->caps].captype = codec;
6102                 j->caplist[j->caps].cap = G729B;
6103                 j->caplist[j->caps].handle = j->caps++;
6104         }
6105 }
6106
6107 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6108 {
6109         int cnt;
6110         int retval = 0;
6111         for (cnt = 0; cnt < j->caps; cnt++) {
6112                 if (pcreq->captype == j->caplist[cnt].captype
6113                     && pcreq->cap == j->caplist[cnt].cap) {
6114                         retval = 1;
6115                         break;
6116                 }
6117         }
6118         return retval;
6119 }
6120
6121 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6122 {
6123         IXJ_TONE ti;
6124         IXJ_FILTER jf;
6125         IXJ_FILTER_RAW jfr;
6126         void __user *argp = (void __user *)arg;
6127
6128         unsigned int raise, mant;
6129         unsigned int minor = iminor(inode);
6130         int board = NUM(inode);
6131
6132         IXJ *j = get_ixj(NUM(inode));
6133
6134         int retval = 0;
6135
6136         /*
6137          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6138          *    This is necessary to keep the DSP from locking up.
6139          */
6140         while(test_and_set_bit(board, (void *)&j->busyflags) != 0) {
6141                 set_current_state(TASK_INTERRUPTIBLE);
6142                 schedule_timeout(1);
6143         }
6144         if (ixjdebug & 0x0040)
6145                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6146         if (minor >= IXJMAX) {
6147                 clear_bit(board, &j->busyflags);
6148                 return -ENODEV;
6149         }
6150         /*
6151          *    Check ioctls only root can use.
6152          */
6153         if (!capable(CAP_SYS_ADMIN)) {
6154                 switch (cmd) {
6155                 case IXJCTL_TESTRAM:
6156                 case IXJCTL_HZ:
6157                         retval = -EPERM;
6158                 }
6159         }
6160         switch (cmd) {
6161         case IXJCTL_TESTRAM:
6162                 ixj_testram(j);
6163                 retval = (j->ssr.high << 8) + j->ssr.low;
6164                 break;
6165         case IXJCTL_CARDTYPE:
6166                 retval = j->cardtype;
6167                 break;
6168         case IXJCTL_SERIAL:
6169                 retval = j->serial;
6170                 break;
6171         case IXJCTL_VERSION:
6172                 {
6173                         char arg_str[100];
6174                         snprintf(arg_str, sizeof(arg_str),
6175                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6176                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6177                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6178                                 retval = -EFAULT;
6179                 }
6180                 break;
6181         case PHONE_RING_CADENCE:
6182                 j->ring_cadence = arg;
6183                 break;
6184         case IXJCTL_CIDCW:
6185                 if(arg) {
6186                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6187                                 retval = -EFAULT;
6188                                 break;
6189                         }
6190                 } else {
6191                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6192                 }
6193                 ixj_write_cidcw(j);
6194                 break;
6195         /* Binary compatbility */
6196         case OLD_PHONE_RING_START:
6197                 arg = 0;
6198                 /* Fall through */
6199         case PHONE_RING_START:
6200                 if(arg) {
6201                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6202                                 retval = -EFAULT;
6203                                 break;
6204                         }
6205                         ixj_write_cid(j);
6206                 } else {
6207                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6208                 }
6209                 ixj_ring_start(j);
6210                 break;
6211         case PHONE_RING_STOP:
6212                 j->flags.cringing = 0;
6213                 if(j->cadence_f[5].enable) {
6214                         j->cadence_f[5].state = 0;
6215                 }
6216                 ixj_ring_off(j);
6217                 break;
6218         case PHONE_RING:
6219                 retval = ixj_ring(j);
6220                 break;
6221         case PHONE_EXCEPTION:
6222                 retval = j->ex.bytes;
6223                 if(j->ex.bits.flash) {
6224                         j->flash_end = 0;
6225                         j->ex.bits.flash = 0;
6226                 }
6227                 j->ex.bits.pstn_ring = 0;
6228                 j->ex.bits.caller_id = 0;
6229                 j->ex.bits.pstn_wink = 0;
6230                 j->ex.bits.f0 = 0;
6231                 j->ex.bits.f1 = 0;
6232                 j->ex.bits.f2 = 0;
6233                 j->ex.bits.f3 = 0;
6234                 j->ex.bits.fc0 = 0;
6235                 j->ex.bits.fc1 = 0;
6236                 j->ex.bits.fc2 = 0;
6237                 j->ex.bits.fc3 = 0;
6238                 j->ex.bits.reserved = 0;
6239                 break;
6240         case PHONE_HOOKSTATE:
6241                 j->ex.bits.hookstate = 0;
6242                 retval = j->hookstate;  //j->r_hook;
6243                 break;
6244         case IXJCTL_SET_LED:
6245                 LED_SetState(arg, j);
6246                 break;
6247         case PHONE_FRAME:
6248                 retval = set_base_frame(j, arg);
6249                 break;
6250         case PHONE_REC_CODEC:
6251                 retval = set_rec_codec(j, arg);
6252                 break;
6253         case PHONE_VAD:
6254                 ixj_vad(j, arg);
6255                 break;
6256         case PHONE_REC_START:
6257                 ixj_record_start(j);
6258                 break;
6259         case PHONE_REC_STOP:
6260                 ixj_record_stop(j);
6261                 break;
6262         case PHONE_REC_DEPTH:
6263                 set_rec_depth(j, arg);
6264                 break;
6265         case PHONE_REC_VOLUME:
6266                 if(arg == -1) {
6267                         retval = get_rec_volume(j);
6268                 }
6269                 else {
6270                         set_rec_volume(j, arg);
6271                         retval = arg;
6272                 }
6273                 break;
6274         case PHONE_REC_VOLUME_LINEAR:
6275                 if(arg == -1) {
6276                         retval = get_rec_volume_linear(j);
6277                 }
6278                 else {
6279                         set_rec_volume_linear(j, arg);
6280                         retval = arg;
6281                 }
6282                 break;
6283         case IXJCTL_DTMF_PRESCALE:
6284                 if(arg == -1) {
6285                         retval = get_dtmf_prescale(j);
6286                 }
6287                 else {
6288                         set_dtmf_prescale(j, arg);
6289                         retval = arg;
6290                 }
6291                 break;
6292         case PHONE_REC_LEVEL:
6293                 retval = get_rec_level(j);
6294                 break;
6295         case IXJCTL_SC_RXG:
6296                 retval = ixj_siadc(j, arg);
6297                 break;
6298         case IXJCTL_SC_TXG:
6299                 retval = ixj_sidac(j, arg);
6300                 break;
6301         case IXJCTL_AEC_START:
6302                 ixj_aec_start(j, arg);
6303                 break;
6304         case IXJCTL_AEC_STOP:
6305                 aec_stop(j);
6306                 break;
6307         case IXJCTL_AEC_GET_LEVEL:
6308                 retval = j->aec_level;
6309                 break;
6310         case PHONE_PLAY_CODEC:
6311                 retval = set_play_codec(j, arg);
6312                 break;
6313         case PHONE_PLAY_START:
6314                 retval = ixj_play_start(j);
6315                 break;
6316         case PHONE_PLAY_STOP:
6317                 ixj_play_stop(j);
6318                 break;
6319         case PHONE_PLAY_DEPTH:
6320                 set_play_depth(j, arg);
6321                 break;
6322         case PHONE_PLAY_VOLUME:
6323                 if(arg == -1) {
6324                         retval = get_play_volume(j);
6325                 }
6326                 else {
6327                         set_play_volume(j, arg);
6328                         retval = arg;
6329                 }
6330                 break;
6331         case PHONE_PLAY_VOLUME_LINEAR:
6332                 if(arg == -1) {
6333                         retval = get_play_volume_linear(j);
6334                 }
6335                 else {
6336                         set_play_volume_linear(j, arg);
6337                         retval = arg;
6338                 }
6339                 break;
6340         case PHONE_PLAY_LEVEL:
6341                 retval = get_play_level(j);
6342                 break;
6343         case IXJCTL_DSP_TYPE:
6344                 retval = (j->dsp.high << 8) + j->dsp.low;
6345                 break;
6346         case IXJCTL_DSP_VERSION:
6347                 retval = (j->ver.high << 8) + j->ver.low;
6348                 break;
6349         case IXJCTL_HZ:
6350                 hertz = arg;
6351                 break;
6352         case IXJCTL_RATE:
6353                 if (arg > hertz)
6354                         retval = -1;
6355                 else
6356                         samplerate = arg;
6357                 break;
6358         case IXJCTL_DRYBUFFER_READ:
6359                 put_user(j->drybuffer, (unsigned long __user *) argp);
6360                 break;
6361         case IXJCTL_DRYBUFFER_CLEAR:
6362                 j->drybuffer = 0;
6363                 break;
6364         case IXJCTL_FRAMES_READ:
6365                 put_user(j->framesread, (unsigned long __user *) argp);
6366                 break;
6367         case IXJCTL_FRAMES_WRITTEN:
6368                 put_user(j->frameswritten, (unsigned long __user *) argp);
6369                 break;
6370         case IXJCTL_READ_WAIT:
6371                 put_user(j->read_wait, (unsigned long __user *) argp);
6372                 break;
6373         case IXJCTL_WRITE_WAIT:
6374                 put_user(j->write_wait, (unsigned long __user *) argp);
6375                 break;
6376         case PHONE_MAXRINGS:
6377                 j->maxrings = arg;
6378                 break;
6379         case PHONE_SET_TONE_ON_TIME:
6380                 ixj_set_tone_on(arg, j);
6381                 break;
6382         case PHONE_SET_TONE_OFF_TIME:
6383                 ixj_set_tone_off(arg, j);
6384                 break;
6385         case PHONE_GET_TONE_ON_TIME:
6386                 if (ixj_get_tone_on(j)) {
6387                         retval = -1;
6388                 } else {
6389                         retval = (j->ssr.high << 8) + j->ssr.low;
6390                 }
6391                 break;
6392         case PHONE_GET_TONE_OFF_TIME:
6393                 if (ixj_get_tone_off(j)) {
6394                         retval = -1;
6395                 } else {
6396                         retval = (j->ssr.high << 8) + j->ssr.low;
6397                 }
6398                 break;
6399         case PHONE_PLAY_TONE:
6400                 if (!j->tone_state)
6401                         retval = ixj_play_tone(j, arg);
6402                 else
6403                         retval = -1;
6404                 break;
6405         case PHONE_GET_TONE_STATE:
6406                 retval = j->tone_state;
6407                 break;
6408         case PHONE_DTMF_READY:
6409                 retval = j->ex.bits.dtmf_ready;
6410                 break;
6411         case PHONE_GET_DTMF:
6412                 if (ixj_hookstate(j)) {
6413                         if (j->dtmf_rp != j->dtmf_wp) {
6414                                 retval = j->dtmfbuffer[j->dtmf_rp];
6415                                 j->dtmf_rp++;
6416                                 if (j->dtmf_rp == 79)
6417                                         j->dtmf_rp = 0;
6418                                 if (j->dtmf_rp == j->dtmf_wp) {
6419                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6420                                 }
6421                         }
6422                 }
6423                 break;
6424         case PHONE_GET_DTMF_ASCII:
6425                 if (ixj_hookstate(j)) {
6426                         if (j->dtmf_rp != j->dtmf_wp) {
6427                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6428                                 case 10:
6429                                         retval = 42;    /* '*'; */
6430
6431                                         break;
6432                                 case 11:
6433                                         retval = 48;    /*'0'; */
6434
6435                                         break;
6436                                 case 12:
6437                                         retval = 35;    /*'#'; */
6438
6439                                         break;
6440                                 case 28:
6441                                         retval = 65;    /*'A'; */
6442
6443                                         break;
6444                                 case 29:
6445                                         retval = 66;    /*'B'; */
6446
6447                                         break;
6448                                 case 30:
6449                                         retval = 67;    /*'C'; */
6450
6451                                         break;
6452                                 case 31:
6453                                         retval = 68;    /*'D'; */
6454
6455                                         break;
6456                                 default:
6457                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6458                                         break;
6459                                 }
6460                                 j->dtmf_rp++;
6461                                 if (j->dtmf_rp == 79)
6462                                         j->dtmf_rp = 0;
6463                                 if(j->dtmf_rp == j->dtmf_wp)
6464                                 {
6465                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6466                                 }
6467                         }
6468                 }
6469                 break;
6470         case PHONE_DTMF_OOB:
6471                 j->flags.dtmf_oob = arg;
6472                 break;
6473         case PHONE_DIALTONE:
6474                 ixj_dialtone(j);
6475                 break;
6476         case PHONE_BUSY:
6477                 ixj_busytone(j);
6478                 break;
6479         case PHONE_RINGBACK:
6480                 ixj_ringback(j);
6481                 break;
6482         case PHONE_WINK:
6483                 if(j->cardtype == QTI_PHONEJACK)
6484                         retval = -1;
6485                 else
6486                         retval = ixj_wink(j);
6487                 break;
6488         case PHONE_CPT_STOP:
6489                 ixj_cpt_stop(j);
6490                 break;
6491         case PHONE_QUERY_CODEC:
6492         {
6493                 struct phone_codec_data pd;
6494                 int val;
6495                 int proto_size[] = {
6496                         -1,
6497                         12, 10, 16, 9, 8, 48, 5,
6498                         40, 40, 80, 40, 40, 6
6499                 };
6500                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6501                         retval = -EFAULT;
6502                         break;
6503                 }
6504                 if(pd.type<1 || pd.type>13) {
6505                         retval = -EPROTONOSUPPORT;
6506                         break;
6507                 }
6508                 if(pd.type<G729)
6509                         val=proto_size[pd.type];
6510                 else switch(j->baseframe.low)
6511                 {
6512                         case 0xA0:val=2*proto_size[pd.type];break;
6513                         case 0x50:val=proto_size[pd.type];break;
6514                         default:val=proto_size[pd.type]*3;break;
6515                 }
6516                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6517                 if(copy_to_user(argp, &pd, sizeof(pd)))
6518                         retval = -EFAULT;
6519                 break;
6520         }
6521         case IXJCTL_DSP_IDLE:
6522                 idle(j);
6523                 break;
6524         case IXJCTL_MIXER:
6525                 if ((arg & 0xff) == 0xff)
6526                         retval = ixj_get_mixer(arg, j);
6527                 else
6528                         ixj_mixer(arg, j);
6529                 break;
6530         case IXJCTL_DAA_COEFF_SET:
6531                 switch (arg) {
6532                 case DAA_US:
6533                         DAA_Coeff_US(j);
6534                         retval = ixj_daa_write(j);
6535                         break;
6536                 case DAA_UK:
6537                         DAA_Coeff_UK(j);
6538                         retval = ixj_daa_write(j);
6539                         break;
6540                 case DAA_FRANCE:
6541                         DAA_Coeff_France(j);
6542                         retval = ixj_daa_write(j);
6543                         break;
6544                 case DAA_GERMANY:
6545                         DAA_Coeff_Germany(j);
6546                         retval = ixj_daa_write(j);
6547                         break;
6548                 case DAA_AUSTRALIA:
6549                         DAA_Coeff_Australia(j);
6550                         retval = ixj_daa_write(j);
6551                         break;
6552                 case DAA_JAPAN:
6553                         DAA_Coeff_Japan(j);
6554                         retval = ixj_daa_write(j);
6555                         break;
6556                 default:
6557                         retval = 1;
6558                         break;
6559                 }
6560                 break;
6561         case IXJCTL_DAA_AGAIN:
6562                 ixj_daa_cr4(j, arg | 0x02);
6563                 break;
6564         case IXJCTL_PSTN_LINETEST:
6565                 retval = ixj_linetest(j);
6566                 break;
6567         case IXJCTL_VMWI:
6568                 ixj_write_vmwi(j, arg);
6569                 break;
6570         case IXJCTL_CID:
6571                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6572                         retval = -EFAULT;
6573                 j->ex.bits.caller_id = 0;
6574                 break;
6575         case IXJCTL_WINK_DURATION:
6576                 j->winktime = arg;
6577                 break;
6578         case IXJCTL_PORT:
6579                 if (arg)
6580                         retval = ixj_set_port(j, arg);
6581                 else
6582                         retval = j->port;
6583                 break;
6584         case IXJCTL_POTS_PSTN:
6585                 retval = ixj_set_pots(j, arg);
6586                 break;
6587         case PHONE_CAPABILITIES:
6588                 add_caps(j);
6589                 retval = j->caps;
6590                 break;
6591         case PHONE_CAPABILITIES_LIST:
6592                 add_caps(j);
6593                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6594                         retval = -EFAULT;
6595                 break;
6596         case PHONE_CAPABILITIES_CHECK:
6597                 {
6598                         struct phone_capability cap;
6599                         if (copy_from_user(&cap, argp, sizeof(cap)))
6600                                 retval = -EFAULT;
6601                         else {
6602                                 add_caps(j);
6603                                 retval = capabilities_check(j, &cap);
6604                         }
6605                 }
6606                 break;
6607         case PHONE_PSTN_SET_STATE:
6608                 daa_set_mode(j, arg);
6609                 break;
6610         case PHONE_PSTN_GET_STATE:
6611                 retval = j->daa_mode;
6612                 j->ex.bits.pstn_ring = 0;
6613                 break;
6614         case IXJCTL_SET_FILTER:
6615                 if (copy_from_user(&jf, argp, sizeof(jf)))
6616                         retval = -EFAULT;
6617                 retval = ixj_init_filter(j, &jf);
6618                 break;
6619         case IXJCTL_SET_FILTER_RAW:
6620                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6621                         retval = -EFAULT;
6622                 else
6623                         retval = ixj_init_filter_raw(j, &jfr);
6624                 break;
6625         case IXJCTL_GET_FILTER_HIST:
6626                 if(arg<0||arg>3)
6627                         retval = -EINVAL;
6628                 else
6629                         retval = j->filter_hist[arg];
6630                 break;
6631         case IXJCTL_INIT_TONE:
6632                 if (copy_from_user(&ti, argp, sizeof(ti)))
6633                         retval = -EFAULT;
6634                 else
6635                         retval = ixj_init_tone(j, &ti);
6636                 break;
6637         case IXJCTL_TONE_CADENCE:
6638                 retval = ixj_build_cadence(j, argp);
6639                 break;
6640         case IXJCTL_FILTER_CADENCE:
6641                 retval = ixj_build_filter_cadence(j, argp);
6642                 break;
6643         case IXJCTL_SIGCTL:
6644                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6645                         retval = -EFAULT;
6646                         break;
6647                 }
6648                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6649                 if(j->sigdef.event < 33) {
6650                         raise = 1;
6651                         for(mant = 0; mant < j->sigdef.event; mant++){
6652                                 raise *= 2;
6653                         }
6654                         if(j->sigdef.signal)
6655                                 j->ex_sig.bytes |= raise;
6656                         else
6657                                 j->ex_sig.bytes &= (raise^0xffff);
6658                 }
6659                 break;
6660         case IXJCTL_INTERCOM_STOP:
6661                 if(arg < 0 || arg >= IXJMAX)
6662                         return -EINVAL;
6663                 j->intercom = -1;
6664                 ixj_record_stop(j);
6665                 ixj_play_stop(j);
6666                 idle(j);
6667                 get_ixj(arg)->intercom = -1;
6668                 ixj_record_stop(get_ixj(arg));
6669                 ixj_play_stop(get_ixj(arg));
6670                 idle(get_ixj(arg));
6671                 break;
6672         case IXJCTL_INTERCOM_START:
6673                 if(arg < 0 || arg >= IXJMAX)
6674                         return -EINVAL;
6675                 j->intercom = arg;
6676                 ixj_record_start(j);
6677                 ixj_play_start(j);
6678                 get_ixj(arg)->intercom = board;
6679                 ixj_play_start(get_ixj(arg));
6680                 ixj_record_start(get_ixj(arg));
6681                 break;
6682         }
6683         if (ixjdebug & 0x0040)
6684                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6685         clear_bit(board, &j->busyflags);
6686         return retval;
6687 }
6688
6689 static int ixj_fasync(int fd, struct file *file_p, int mode)
6690 {
6691         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6692
6693         return fasync_helper(fd, file_p, mode, &j->async_queue);
6694 }
6695
6696 static struct file_operations ixj_fops =
6697 {
6698         .owner          = THIS_MODULE,
6699         .read           = ixj_enhanced_read,
6700         .write          = ixj_enhanced_write,
6701         .poll           = ixj_poll,
6702         .ioctl          = ixj_ioctl,
6703         .release        = ixj_release,
6704         .fasync         = ixj_fasync
6705 };
6706
6707 static int ixj_linetest(IXJ *j)
6708 {
6709         unsigned long jifwait;
6710
6711         j->flags.pstncheck = 1; /* Testing */
6712         j->flags.pstn_present = 0; /* Assume the line is not there */
6713
6714         daa_int_read(j);        /*Clear DAA Interrupt flags */
6715         /* */
6716         /* Hold all relays in the normally de-energized position. */
6717         /* */
6718
6719         j->pld_slicw.bits.rly1 = 0;
6720         j->pld_slicw.bits.rly2 = 0;
6721         j->pld_slicw.bits.rly3 = 0;
6722         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6723         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6724
6725         outb_p(j->pld_scrw.byte, j->XILINXbase);
6726         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6727         if (j->pld_slicr.bits.potspstn) {
6728                 j->flags.pots_pstn = 1;
6729                 j->flags.pots_correct = 0;
6730                 LED_SetState(0x4, j);
6731         } else {
6732                 j->flags.pots_pstn = 0;
6733                 j->pld_slicw.bits.rly1 = 0;
6734                 j->pld_slicw.bits.rly2 = 0;
6735                 j->pld_slicw.bits.rly3 = 1;
6736                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6737                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6738
6739                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6740                 daa_set_mode(j, SOP_PU_CONVERSATION);
6741                 jifwait = jiffies + hertz;
6742                 while (time_before(jiffies, jifwait)) {
6743                         set_current_state(TASK_INTERRUPTIBLE);
6744                         schedule_timeout(1);
6745                 }
6746                 daa_int_read(j);
6747                 daa_set_mode(j, SOP_PU_RESET);
6748                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6749                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6750                         LED_SetState(0x4, j);
6751                         j->pld_slicw.bits.rly3 = 0;
6752                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6753                 } else {
6754                         j->flags.pots_correct = 1;
6755                         LED_SetState(0x8, j);
6756                         j->pld_slicw.bits.rly1 = 1;
6757                         j->pld_slicw.bits.rly2 = 0;
6758                         j->pld_slicw.bits.rly3 = 0;
6759                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6760                 }
6761         }
6762         j->pld_slicw.bits.rly3 = 0;
6763         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6764         daa_set_mode(j, SOP_PU_CONVERSATION);
6765         jifwait = jiffies + hertz;
6766         while (time_before(jiffies, jifwait)) {
6767                 set_current_state(TASK_INTERRUPTIBLE);
6768                 schedule_timeout(1);
6769         }
6770         daa_int_read(j);
6771         daa_set_mode(j, SOP_PU_RESET);
6772         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6773                 j->pstn_sleeptil = jiffies + (hertz / 4);
6774                 j->flags.pstn_present = 1;
6775         } else {
6776                 j->flags.pstn_present = 0;
6777         }
6778         if (j->flags.pstn_present) {
6779                 if (j->flags.pots_correct) {
6780                         LED_SetState(0xA, j);
6781                 } else {
6782                         LED_SetState(0x6, j);
6783                 }
6784         } else {
6785                 if (j->flags.pots_correct) {
6786                         LED_SetState(0x9, j);
6787                 } else {
6788                         LED_SetState(0x5, j);
6789                 }
6790         }
6791         j->flags.pstncheck = 0; /* Testing */
6792         return j->flags.pstn_present;
6793 }
6794
6795 static int ixj_selfprobe(IXJ *j)
6796 {
6797         unsigned short cmd;
6798         unsigned long jif;
6799         int cnt;
6800         BYTES bytes;
6801
6802         init_waitqueue_head(&j->poll_q);
6803         init_waitqueue_head(&j->read_q);
6804         init_waitqueue_head(&j->write_q);
6805
6806         while(atomic_read(&j->DSPWrite) > 0)
6807                 atomic_dec(&j->DSPWrite);
6808         if (ixjdebug & 0x0002)
6809                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6810         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6811
6812         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6813                 return -1;
6814 /* The read values of the SSR should be 0x00 for the IDLE command */
6815         if (j->ssr.low || j->ssr.high)
6816                 return -1;
6817         if (ixjdebug & 0x0002)
6818                 printk(KERN_INFO "Get Device ID Code\n");
6819         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6820                 return -1;
6821         j->dsp.low = j->ssr.low;
6822         j->dsp.high = j->ssr.high;
6823         if (ixjdebug & 0x0002)
6824                 printk(KERN_INFO "Get Device Version Code\n");
6825         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6826                 return -1;
6827         j->ver.low = j->ssr.low;
6828         j->ver.high = j->ssr.high;
6829         if (!j->cardtype) {
6830                 if (j->dsp.low == 0x21) {
6831                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6832                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6833 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6834                         bytes.low = inb_p(j->XILINXbase + 0x02);
6835                         if (bytes.low == bytes.high)    /*  Register is read only on */
6836                                 /*  Internet PhoneJack Lite */
6837                          {
6838                                 j->cardtype = QTI_PHONEJACK_LITE;
6839                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6840                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6841                                         return -1;
6842                                 }
6843                                 j->pld_slicw.pcib.e1 = 1;
6844                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6845                         } else {
6846                                 j->cardtype = QTI_LINEJACK;
6847
6848                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6849                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6850                                         return -1;
6851                                 }
6852                         }
6853                 } else if (j->dsp.low == 0x22) {
6854                         j->cardtype = QTI_PHONEJACK_PCI;
6855                         request_region(j->XILINXbase, 4, "ixj control");
6856                         j->pld_slicw.pcib.e1 = 1;
6857                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6858                 } else
6859                         j->cardtype = QTI_PHONEJACK;
6860         } else {
6861                 switch (j->cardtype) {
6862                 case QTI_PHONEJACK:
6863                         if (!j->dsp.low != 0x20) {
6864                                 j->dsp.high = 0x80;
6865                                 j->dsp.low = 0x20;
6866                                 ixj_WriteDSPCommand(0x3800, j);
6867                                 j->ver.low = j->ssr.low;
6868                                 j->ver.high = j->ssr.high;
6869                         }
6870                         break;
6871                 case QTI_LINEJACK:
6872                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6873                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6874                                 return -1;
6875                         }
6876                         break;
6877                 case QTI_PHONEJACK_LITE:
6878                 case QTI_PHONEJACK_PCI:
6879                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6880                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6881                                 return -1;
6882                         }
6883                         j->pld_slicw.pcib.e1 = 1;
6884                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6885                         break;
6886                 case QTI_PHONECARD:
6887                         break;
6888                 }
6889         }
6890         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6891                 if (ixjdebug & 0x0002)
6892                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6893                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6894                         return -1;
6895                 if (ixjdebug & 0x0002)
6896                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6897                 if (j->cardtype == QTI_PHONEJACK) {
6898                         cmd = 0x9FF2;
6899                 } else {
6900                         cmd = 0x9FF5;
6901                 }
6902                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6903                         return -1;
6904         } else {
6905                 if (set_base_frame(j, 30) != 30)
6906                         return -1;
6907                 if (ixjdebug & 0x0002)
6908                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6909                 if (j->cardtype == QTI_PHONECARD) {
6910                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6911                                 return -1;
6912                 }
6913                 if (j->cardtype == QTI_LINEJACK) {
6914                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6915                                 return -1;
6916                         if (ixjdebug & 0x0002)
6917                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6918                         j->pld_clock.byte = 0;
6919                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6920                 }
6921         }
6922
6923         if (j->dsp.low == 0x20) {
6924                 if (ixjdebug & 0x0002)
6925                         printk(KERN_INFO "Configure GPIO pins\n");
6926                 j->gpio.bytes.high = 0x09;
6927 /*  bytes.low = 0xEF;  0xF7 */
6928                 j->gpio.bits.gpio1 = 1;
6929                 j->gpio.bits.gpio2 = 1;
6930                 j->gpio.bits.gpio3 = 0;
6931                 j->gpio.bits.gpio4 = 1;
6932                 j->gpio.bits.gpio5 = 1;
6933                 j->gpio.bits.gpio6 = 1;
6934                 j->gpio.bits.gpio7 = 1;
6935                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6936                 if (ixjdebug & 0x0002)
6937                         printk(KERN_INFO "Enable SLIC\n");
6938                 j->gpio.bytes.high = 0x0B;
6939                 j->gpio.bytes.low = 0x00;
6940                 j->gpio.bits.gpio1 = 0;
6941                 j->gpio.bits.gpio2 = 1;
6942                 j->gpio.bits.gpio5 = 0;
6943                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6944                 j->port = PORT_POTS;
6945         } else {
6946                 if (j->cardtype == QTI_LINEJACK) {
6947                         LED_SetState(0x1, j);
6948                         jif = jiffies + (hertz / 10);
6949                         while (time_before(jiffies, jif)) {
6950                                 set_current_state(TASK_INTERRUPTIBLE);
6951                                 schedule_timeout(1);
6952                         }
6953                         LED_SetState(0x2, j);
6954                         jif = jiffies + (hertz / 10);
6955                         while (time_before(jiffies, jif)) {
6956                                 set_current_state(TASK_INTERRUPTIBLE);
6957                                 schedule_timeout(1);
6958                         }
6959                         LED_SetState(0x4, j);
6960                         jif = jiffies + (hertz / 10);
6961                         while (time_before(jiffies, jif)) {
6962                                 set_current_state(TASK_INTERRUPTIBLE);
6963                                 schedule_timeout(1);
6964                         }
6965                         LED_SetState(0x8, j);
6966                         jif = jiffies + (hertz / 10);
6967                         while (time_before(jiffies, jif)) {
6968                                 set_current_state(TASK_INTERRUPTIBLE);
6969                                 schedule_timeout(1);
6970                         }
6971                         LED_SetState(0x0, j);
6972                         daa_get_version(j);
6973                         if (ixjdebug & 0x0002)
6974                                 printk("Loading DAA Coefficients\n");
6975                         DAA_Coeff_US(j);
6976                         if (!ixj_daa_write(j)) {
6977                                 printk("DAA write failed on board %d\n", j->board);
6978                                 return -1;
6979                         }
6980                         if(!ixj_daa_cid_reset(j)) {
6981                                 printk("DAA CID reset failed on board %d\n", j->board);
6982                                 return -1;
6983                         }
6984                         j->flags.pots_correct = 0;
6985                         j->flags.pstn_present = 0;
6986                         ixj_linetest(j);
6987                         if (j->flags.pots_correct) {
6988                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6989
6990                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6991                                 j->pld_slicw.bits.rly1 = 1;
6992                                 j->pld_slicw.bits.spken = 1;
6993                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6994                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6995 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6996                                 j->port = PORT_POTS;
6997                         }
6998                         ixj_set_port(j, PORT_PSTN);
6999                         ixj_set_pots(j, 1);
7000                         if (ixjdebug & 0x0002)
7001                                 printk(KERN_INFO "Enable Mixer\n");
7002                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
7003                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
7004
7005                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
7006                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
7007
7008                         ixj_mixer(0x0480, j);   /*FM Left mute */
7009                         ixj_mixer(0x0580, j);   /*FM Right mute */
7010
7011                         ixj_mixer(0x0680, j);   /*CD Left mute */
7012                         ixj_mixer(0x0780, j);   /*CD Right mute */
7013
7014                         ixj_mixer(0x0880, j);   /*Line Left mute */
7015                         ixj_mixer(0x0980, j);   /*Line Right mute */
7016
7017                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
7018                         ixj_mixer(0x0B80, j);   /*Aux right mute */
7019
7020                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
7021                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
7022
7023                         ixj_mixer(0x0E80, j);   /*Mic mute */
7024
7025                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
7026
7027                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
7028                         ixj_mixer(0x110C, j);
7029
7030
7031                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
7032                         ixj_mixer(0x1401, j);
7033
7034                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
7035                         ixj_mixer(0x1501, j);
7036
7037                         ixj_mixer(0x1700, j);   /*Clock select */
7038
7039                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
7040
7041                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
7042
7043                         if (ixjdebug & 0x0002)
7044                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7045                         j->cadence_f[4].state = 0;
7046                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7047                         j->cadence_f[4].off1 = 0;
7048                         j->cadence_f[4].on2 = 0;
7049                         j->cadence_f[4].off2 = 0;
7050                         j->cadence_f[4].on3 = 0;
7051                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7052                         j->pstn_last_rmr = jiffies;
7053
7054                 } else {
7055                         if (j->cardtype == QTI_PHONECARD) {
7056                                 ixj_WriteDSPCommand(0xCF07, j);
7057                                 ixj_WriteDSPCommand(0x00B0, j);
7058                                 ixj_set_port(j, PORT_SPEAKER);
7059                         } else {
7060                                 ixj_set_port(j, PORT_POTS);
7061                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7062 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7063                         }
7064                 }
7065         }
7066
7067         j->intercom = -1;
7068         j->framesread = j->frameswritten = 0;
7069         j->read_wait = j->write_wait = 0;
7070         j->rxreadycheck = j->txreadycheck = 0;
7071
7072         /* initialise the DTMF prescale to a sensible value */
7073         if (j->cardtype == QTI_LINEJACK) {
7074                 set_dtmf_prescale(j, 0x10);
7075         } else {
7076                 set_dtmf_prescale(j, 0x40);
7077         }
7078         set_play_volume(j, 0x100);
7079         set_rec_volume(j, 0x100);
7080
7081         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7082                 return -1;
7083 /* The read values of the SSR should be 0x00 for the IDLE command */
7084         if (j->ssr.low || j->ssr.high)
7085                 return -1;
7086
7087         if (ixjdebug & 0x0002)
7088                 printk(KERN_INFO "Enable Line Monitor\n");
7089
7090         if (ixjdebug & 0x0002)
7091                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7092
7093         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7094                 return -1;
7095
7096         if (ixjdebug & 0x002)
7097                 printk(KERN_INFO "Enable DTMF Detectors\n");
7098
7099         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7100                 return -1;
7101
7102         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7103                 return -1;
7104
7105         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7106
7107         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7108
7109         j->ex.bits.dtmf_ready = 0;
7110         j->dtmf_state = 0;
7111         j->dtmf_wp = j->dtmf_rp = 0;
7112         j->rec_mode = j->play_mode = -1;
7113         j->flags.ringing = 0;
7114         j->maxrings = MAXRINGS;
7115         j->ring_cadence = USA_RING_CADENCE;
7116         j->drybuffer = 0;
7117         j->winktime = 320;
7118         j->flags.dtmf_oob = 0;
7119         for (cnt = 0; cnt < 4; cnt++)
7120                 j->cadence_f[cnt].enable = 0;
7121         /* must be a device on the specified address */
7122         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7123
7124         /* Set up the default signals for events */
7125         for (cnt = 0; cnt < 35; cnt++)
7126                 j->ixj_signals[cnt] = SIGIO;
7127
7128         /* Set the excetion signal enable flags */
7129         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7130         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 =
7131         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;
7132 #ifdef IXJ_DYN_ALLOC
7133         j->fskdata = NULL;
7134 #endif
7135         j->fskdcnt = 0;
7136         j->cidcw_wait = 0;
7137
7138         /* Register with the Telephony for Linux subsystem */
7139         j->p.f_op = &ixj_fops;
7140         j->p.open = ixj_open;
7141         j->p.board = j->board;
7142         phone_register_device(&j->p, PHONE_UNIT_ANY);
7143
7144         ixj_init_timer(j);
7145         ixj_add_timer(j);
7146         return 0;
7147 }
7148
7149 /*
7150  *      Exported service for pcmcia card handling
7151  */
7152
7153 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7154 {
7155         IXJ *j = ixj_alloc();
7156
7157         j->board = 0;
7158
7159         j->DSPbase = dsp;
7160         j->XILINXbase = xilinx;
7161         j->cardtype = QTI_PHONECARD;
7162         ixj_selfprobe(j);
7163         return j;
7164 }
7165
7166 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7167
7168 static int ixj_get_status_proc(char *buf)
7169 {
7170         int len;
7171         int cnt;
7172         IXJ *j;
7173         len = 0;
7174         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7175         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7176         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7177         len += sprintf(buf + len, "\nUsing old telephony API");
7178         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7179
7180         for (cnt = 0; cnt < IXJMAX; cnt++) {
7181                 j = get_ixj(cnt);
7182                 if(j==NULL)
7183                         continue;
7184                 if (j->DSPbase) {
7185                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7186                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7187                         if (j->cardtype != QTI_PHONEJACK)
7188                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7189                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7190                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7191                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7192                         switch (j->cardtype) {
7193                         case (QTI_PHONEJACK):
7194                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7195                                 break;
7196                         case (QTI_LINEJACK):
7197                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7198                                 if (j->flags.g729_loaded)
7199                                         len += sprintf(buf + len, " w/G.729 A/B");
7200                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7201                                 break;
7202                         case (QTI_PHONEJACK_LITE):
7203                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7204                                 if (j->flags.g729_loaded)
7205                                         len += sprintf(buf + len, " w/G.729 A/B");
7206                                 break;
7207                         case (QTI_PHONEJACK_PCI):
7208                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7209                                 if (j->flags.g729_loaded)
7210                                         len += sprintf(buf + len, " w/G.729 A/B");
7211                                 break;
7212                         case (QTI_PHONECARD):
7213                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7214                                 if (j->flags.g729_loaded)
7215                                         len += sprintf(buf + len, " w/G.729 A/B");
7216                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7217                                 if (!j->pccr1.bits.drf)
7218                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7219                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7220                                 break;
7221                         default:
7222                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7223                                 break;
7224                         }
7225                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7226                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7227                         add_caps(j);
7228                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7229                         if (j->dsp.low != 0x20)
7230                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7231                         if (j->flags.cidsent)
7232                                 len += sprintf(buf + len, "\nCaller ID data sent");
7233                         else
7234                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7235
7236                         len += sprintf(buf + len, "\nPlay CODEC ");
7237                         switch (j->play_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, "\nRecord CODEC ");
7282                         switch (j->rec_codec) {
7283                         case G723_63:
7284                                 len += sprintf(buf + len, "G.723.1 6.3");
7285                                 break;
7286                         case G723_53:
7287                                 len += sprintf(buf + len, "G.723.1 5.3");
7288                                 break;
7289                         case TS85:
7290                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7291                                 break;
7292                         case TS48:
7293                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7294                                 break;
7295                         case TS41:
7296                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7297                                 break;
7298                         case G728:
7299                                 len += sprintf(buf + len, "G.728");
7300                                 break;
7301                         case G729:
7302                                 len += sprintf(buf + len, "G.729");
7303                                 break;
7304                         case G729B:
7305                                 len += sprintf(buf + len, "G.729B");
7306                                 break;
7307                         case ULAW:
7308                                 len += sprintf(buf + len, "uLaw");
7309                                 break;
7310                         case ALAW:
7311                                 len += sprintf(buf + len, "aLaw");
7312                                 break;
7313                         case LINEAR16:
7314                                 len += sprintf(buf + len, "16 bit Linear");
7315                                 break;
7316                         case LINEAR8:
7317                                 len += sprintf(buf + len, "8 bit Linear");
7318                                 break;
7319                         case WSS:
7320                                 len += sprintf(buf + len, "Windows Sound System");
7321                                 break;
7322                         default:
7323                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7324                                 break;
7325                         }
7326                         len += sprintf(buf + len, "\nAEC ");
7327                         switch (j->aec_level) {
7328                         case AEC_OFF:
7329                                 len += sprintf(buf + len, "Off");
7330                                 break;
7331                         case AEC_LOW:
7332                                 len += sprintf(buf + len, "Low");
7333                                 break;
7334                         case AEC_MED:
7335                                 len += sprintf(buf + len, "Med");
7336                                 break;
7337                         case AEC_HIGH:
7338                                 len += sprintf(buf + len, "High");
7339                                 break;
7340                         case AEC_AUTO:
7341                                 len += sprintf(buf + len, "Auto");
7342                                 break;
7343                         case AEC_AGC:
7344                                 len += sprintf(buf + len, "AEC/AGC");
7345                                 break;
7346                         default:
7347                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7348                                 break;
7349                         }
7350
7351                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7352                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7353                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7354
7355                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7356
7357                         if (j->cardtype == QTI_LINEJACK) {
7358                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7359                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7360                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7361                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7362                                 switch (j->daa_mode) {
7363                                 case SOP_PU_SLEEP:
7364                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7365                                         break;
7366                                 case SOP_PU_RINGING:
7367                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7368                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7369                                         break;
7370                                 case SOP_PU_CONVERSATION:
7371                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7372                                         break;
7373                                 case SOP_PU_PULSEDIALING:
7374                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7375                                         break;
7376                                 }
7377                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7378                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7379                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7380                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7381                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7382                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7383                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7384                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7385                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7386                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7387                         }
7388                         switch (j->port) {
7389                         case PORT_POTS:
7390                                 len += sprintf(buf + len, "\nPort POTS");
7391                                 break;
7392                         case PORT_PSTN:
7393                                 len += sprintf(buf + len, "\nPort PSTN");
7394                                 break;
7395                         case PORT_SPEAKER:
7396                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7397                                 break;
7398                         case PORT_HANDSET:
7399                                 len += sprintf(buf + len, "\nPort HANDSET");
7400                                 break;
7401                         }
7402                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7403                                 len += sprintf(buf + len, "\nSLIC state ");
7404                                 switch (SLIC_GetState(j)) {
7405                                 case PLD_SLIC_STATE_OC:
7406                                         len += sprintf(buf + len, "OC");
7407                                         break;
7408                                 case PLD_SLIC_STATE_RINGING:
7409                                         len += sprintf(buf + len, "RINGING");
7410                                         break;
7411                                 case PLD_SLIC_STATE_ACTIVE:
7412                                         len += sprintf(buf + len, "ACTIVE");
7413                                         break;
7414                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7415                                         len += sprintf(buf + len, "OHT");
7416                                         break;
7417                                 case PLD_SLIC_STATE_TIPOPEN:
7418                                         len += sprintf(buf + len, "TIPOPEN");
7419                                         break;
7420                                 case PLD_SLIC_STATE_STANDBY:
7421                                         len += sprintf(buf + len, "STANDBY");
7422                                         break;
7423                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7424                                         len += sprintf(buf + len, "APR");
7425                                         break;
7426                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7427                                         len += sprintf(buf + len, "OHTPR");
7428                                         break;
7429                                 default:
7430                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7431                                         break;
7432                                 }
7433                         }
7434                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7435                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7436 #ifdef PERFMON_STATS
7437                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7438                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7439                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7440                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7441                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7442                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7443                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7444                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7445                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7446                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7447                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7448                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7449                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7450                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7451
7452 #endif
7453                         len += sprintf(buf + len, "\n");
7454                 }
7455         }
7456         return len;
7457 }
7458
7459 static int ixj_read_proc(char *page, char **start, off_t off,
7460                               int count, int *eof, void *data)
7461 {
7462         int len = ixj_get_status_proc(page);
7463         if (len <= off+count) *eof = 1;
7464         *start = page + off;
7465         len -= off;
7466         if (len>count) len = count;
7467         if (len<0) len = 0;
7468         return len;
7469 }
7470
7471
7472 static void cleanup(void)
7473 {
7474         int cnt;
7475         IXJ *j;
7476
7477         for (cnt = 0; cnt < IXJMAX; cnt++) {
7478                 j = get_ixj(cnt);
7479                 if(j != NULL && j->DSPbase) {
7480                         if (ixjdebug & 0x0002)
7481                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7482                         del_timer(&j->timer);
7483                         if (j->cardtype == QTI_LINEJACK) {
7484                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7485
7486                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7487                                 j->pld_slicw.bits.rly1 = 0;
7488                                 j->pld_slicw.bits.rly2 = 0;
7489                                 j->pld_slicw.bits.rly3 = 0;
7490                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7491                                 LED_SetState(0x0, j);
7492                                 if (ixjdebug & 0x0002)
7493                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7494                                 release_region(j->XILINXbase, 8);
7495                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7496                                 if (ixjdebug & 0x0002)
7497                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7498                                 release_region(j->XILINXbase, 4);
7499                         }
7500                         if (j->read_buffer)
7501                                 kfree(j->read_buffer);
7502                         if (j->write_buffer)
7503                                 kfree(j->write_buffer);
7504                         if (j->dev)
7505                                 pnp_device_detach(j->dev);
7506                         if (ixjdebug & 0x0002)
7507                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7508                         phone_unregister_device(&j->p);
7509                         if (ixjdebug & 0x0002)
7510                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7511                         release_region(j->DSPbase, 16);
7512 #ifdef IXJ_DYN_ALLOC
7513                         if (ixjdebug & 0x0002)
7514                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7515                         kfree(j);
7516                         ixj[cnt] = NULL;
7517 #endif
7518                 }
7519         }
7520         if (ixjdebug & 0x0002)
7521                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7522         remove_proc_entry ("ixj", NULL);
7523 }
7524
7525 /* Typedefs */
7526 typedef struct {
7527         BYTE length;
7528         DWORD bits;
7529 } DATABLOCK;
7530
7531 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7532 {
7533         lastLCC = lastLCC & 0xfb;
7534         lastLCC = lastLCC | (byData ? 4 : 0);
7535         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7536
7537         mdelay(1);
7538         lastLCC = lastLCC | 0x01;
7539         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7540
7541         byData = byData << 1;
7542         lastLCC = lastLCC & 0xfe;
7543         mdelay(1);
7544         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7545
7546 }
7547
7548 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7549 {
7550         mdelay(1);
7551         lastLCC = lastLCC | 0x01;
7552         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7553
7554         lastLCC = lastLCC & 0xfe;
7555         mdelay(1);
7556         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7557
7558         return ((inb(wEEPROMAddress) >> 3) & 1);
7559 }
7560
7561 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7562 {
7563         BYTE lastLCC;
7564         WORD wEEPROMAddress = wAddress + 3;
7565         DWORD i;
7566         BYTE byResult;
7567         *pwResult = 0;
7568         lastLCC = inb(wEEPROMAddress);
7569         lastLCC = lastLCC | 0x02;
7570         lastLCC = lastLCC & 0xfe;
7571         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7572
7573         mdelay(1);              /* delay */
7574
7575         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7576         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7577         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7578         for (i = 0; i < 8; i++) {
7579                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7580                 wLoc <<= 1;
7581         }
7582
7583         for (i = 0; i < 16; i++) {
7584                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7585                 *pwResult = (*pwResult << 1) | byResult;
7586         }
7587
7588         mdelay(1);              /* another delay */
7589
7590         lastLCC = lastLCC & 0xfd;
7591         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7592
7593         return 0;
7594 }
7595
7596 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7597 {
7598         WORD wLo, wHi;
7599         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7600                 return 0;
7601         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7602                 return 0;
7603         return (((DWORD) wHi << 16) | wLo);
7604 }
7605
7606 static int dspio[IXJMAX + 1] =
7607 {
7608         0,
7609 };
7610 static int xio[IXJMAX + 1] =
7611 {
7612         0,
7613 };
7614
7615 module_param_array(dspio, int, NULL, 0);
7616 module_param_array(xio, int, NULL, 0);
7617 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7618 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7619 MODULE_LICENSE("GPL");
7620
7621 static void __exit ixj_exit(void)
7622 {
7623         cleanup();
7624 }
7625
7626 static IXJ *new_ixj(unsigned long port)
7627 {
7628         IXJ *res;
7629         if (!request_region(port, 16, "ixj DSP")) {
7630                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7631                 return NULL;
7632         }
7633         res = ixj_alloc();
7634         if (!res) {
7635                 release_region(port, 16);
7636                 printk(KERN_INFO "ixj: out of memory\n");
7637                 return NULL;
7638         }
7639         res->DSPbase = port;
7640         return res;
7641 }
7642
7643 static int __init ixj_probe_isapnp(int *cnt)
7644 {
7645         int probe = 0;
7646         int func = 0x110;
7647         struct pnp_dev *dev = NULL, *old_dev = NULL;
7648
7649         while (1) {
7650                 do {
7651                         IXJ *j;
7652                         int result;
7653
7654                         old_dev = dev;
7655                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7656                                          ISAPNP_FUNCTION(func), old_dev);
7657                         if (!dev || !dev->card)
7658                                 break;
7659                         result = pnp_device_attach(dev);
7660                         if (result < 0) {
7661                                 printk("pnp attach failed %d \n", result);
7662                                 break;
7663                         }
7664                         if (pnp_activate_dev(dev) < 0) {
7665                                 printk("pnp activate failed (out of resources?)\n");
7666                                 pnp_device_detach(dev);
7667                                 return -ENOMEM;
7668                         }
7669
7670                         if (!pnp_port_valid(dev, 0)) {
7671                                 pnp_device_detach(dev);
7672                                 return -ENODEV;
7673                         }
7674
7675                         j = new_ixj(pnp_port_start(dev, 0));
7676                         if (!j)
7677                                 break;
7678
7679                         if (func != 0x110)
7680                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7681
7682                         switch (func) {
7683                         case (0x110):
7684                                 j->cardtype = QTI_PHONEJACK;
7685                                 break;
7686                         case (0x310):
7687                                 j->cardtype = QTI_LINEJACK;
7688                                 break;
7689                         case (0x410):
7690                                 j->cardtype = QTI_PHONEJACK_LITE;
7691                                 break;
7692                         }
7693                         j->board = *cnt;
7694                         probe = ixj_selfprobe(j);
7695                         if(!probe) {
7696                                 j->serial = dev->card->serial;
7697                                 j->dev = dev;
7698                                 switch (func) {
7699                                 case 0x110:
7700                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7701                                         break;
7702                                 case 0x310:
7703                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7704                                         break;
7705                                 case 0x410:
7706                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7707                                         break;
7708                                 }
7709                         }
7710                         ++*cnt;
7711                 } while (dev);
7712                 if (func == 0x410)
7713                         break;
7714                 if (func == 0x310)
7715                         func = 0x410;
7716                 if (func == 0x110)
7717                         func = 0x310;
7718                 dev = NULL;
7719         }
7720         return probe;
7721 }
7722
7723 static int __init ixj_probe_isa(int *cnt)
7724 {
7725         int i, probe;
7726
7727         /* Use passed parameters for older kernels without PnP */
7728         for (i = 0; i < IXJMAX; i++) {
7729                 if (dspio[i]) {
7730                         IXJ *j = new_ixj(dspio[i]);
7731
7732                         if (!j)
7733                                 break;
7734
7735                         j->XILINXbase = xio[i];
7736                         j->cardtype = 0;
7737
7738                         j->board = *cnt;
7739                         probe = ixj_selfprobe(j);
7740                         j->dev = NULL;
7741                         ++*cnt;
7742                 }
7743         }
7744         return 0;
7745 }
7746
7747 static int __init ixj_probe_pci(int *cnt)
7748 {
7749         struct pci_dev *pci = NULL;
7750         int i, probe = 0;
7751         IXJ *j = NULL;
7752
7753         for (i = 0; i < IXJMAX - *cnt; i++) {
7754                 pci = pci_find_device(0x15E2, 0x0500, pci);
7755                 if (!pci)
7756                         break;
7757
7758                 if (pci_enable_device(pci))
7759                         break;
7760                 j = new_ixj(pci_resource_start(pci, 0));
7761                 if (!j)
7762                         break;
7763
7764                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7765                 j->XILINXbase = j->DSPbase + 0x10;
7766                 j->cardtype = QTI_PHONEJACK_PCI;
7767                 j->board = *cnt;
7768                 probe = ixj_selfprobe(j);
7769                 if (!probe)
7770                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7771                 ++*cnt;
7772         }
7773         return probe;
7774 }
7775
7776 static int __init ixj_init(void)
7777 {
7778         int cnt = 0;
7779         int probe = 0;
7780
7781         cnt = 0;
7782
7783         /* These might be no-ops, see above. */
7784         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7785                 return probe;
7786         }
7787         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7788                 return probe;
7789         }
7790         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7791                 return probe;
7792         }
7793         printk(KERN_INFO "ixj driver initialized.\n");
7794         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7795         return probe;
7796 }
7797
7798 module_init(ixj_init);
7799 module_exit(ixj_exit);
7800
7801 static void DAA_Coeff_US(IXJ *j)
7802 {
7803         int i;
7804
7805         j->daa_country = DAA_US;
7806         /*----------------------------------------------- */
7807         /* CAO */
7808         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7809                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7810         }
7811
7812 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7813         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7814         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7815         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7816         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7817         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7818         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7819         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7820         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7821 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7822         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7823         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7824         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7825         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7826         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7827         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7828         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7829         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7830 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7831         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7832         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7833         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7834         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7835         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7836         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7837         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7838         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7839 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7840         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7841         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7842         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7843         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7844         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7845         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7846         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7847         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7848 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7849         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7850         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7851         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7852         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7853 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7854         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7855         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7856         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7857         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7858 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7859         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7860         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7861         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7862         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7863         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7864         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7865         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7866         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7867 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7868         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7869         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7870         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7871         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7872         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7873         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7874         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7875         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7876 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7877         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7878         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7879         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7880         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7881         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7882         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7883         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7884         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7885 /* ;  (10K, 0.68uF) */
7886         /*  */
7887         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7888         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7889         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7890         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7891         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7892         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7893         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7894         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7895         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7896         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7897         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7898         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7899         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7900         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7901         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7902         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7903         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7904         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7905
7906         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7907         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7908         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7909         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7910         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7911
7912         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7913 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7914 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7915 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7916 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7917 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7918 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7919 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7920 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7921         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7922 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7923 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7924 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7925 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7926 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7927 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7928 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7929 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7930 /* */
7931         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7932 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7933 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7934 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7935 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7936
7937         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7938         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7939         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7940         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7941         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7942         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7943         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7944         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7945         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7946 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7947         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7948         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7949         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7950         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7951         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7952         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7953         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7954         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7955 /*  */
7956         /* ;CR Registers */
7957         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7958         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7959 /* Config. Reg. 1 (dialing)       (cr1):05 */
7960         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7961 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7962         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7963 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7964         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7965 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7966         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7967         /* Config. Reg. 5 (Version)       (cr5):02 */
7968         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7969         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7970         /*  */
7971         /* ;xr Registers */
7972         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7973
7974         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7975         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7976
7977         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7978 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7979         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7980 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7981         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7982         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7983
7984         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7985 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7986         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7987 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7988         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7989 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7990         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7991         /*  */
7992         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7993         /*                                       12,33,5A,C3 ;  770 Hz   */
7994         /*                                       13,3C,5B,32 ;  852 Hz   */
7995         /*                                       1D,1B,5C,CC ;  941 Hz   */
7996
7997         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7998         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7999         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8000         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8001 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
8002         /*                                       EC,1D,52,22 ;  1336 Hz   */
8003         /*                                       AA,AC,51,D2 ;  1477 Hz   */
8004         /*                                       9B,3B,51,25 ;  1633 Hz   */
8005         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8006         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8007         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8008         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8009 }
8010
8011 static void DAA_Coeff_UK(IXJ *j)
8012 {
8013         int i;
8014
8015         j->daa_country = DAA_UK;
8016         /*----------------------------------------------- */
8017         /* CAO */
8018         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8019                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8020         }
8021
8022 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
8023         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8024         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
8025         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8026         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
8027         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
8028         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8029         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8030         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8031 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
8032         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
8033         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
8034         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8035         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
8036         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
8037         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8038         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8039         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8040 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
8041         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8042         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8043         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8044         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8045         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8046         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8047         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8048         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8049 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8050         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8051         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8052         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8053         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8054         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8055         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8056         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8057         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8058 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8059         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8060         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8061         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8062         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8063 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8064         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8065         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8066         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8067         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8068 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8069         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8070         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8071         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8072         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8073         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8074         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8075         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8076         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8077 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8078         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8079         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8080         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8081         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8082         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8083         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8084         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8085         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8086 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8087         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8088         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8089         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8090         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8091         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8092         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8093         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8094         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8095 /* ; idle */
8096         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8097         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8098         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8099         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8100         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8101         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8102         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8103         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8104         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8105 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8106         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8107         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8108         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8109         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8110         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8111         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8112         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8113         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8114 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8115         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8116         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8117         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8118         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8119 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8120         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8121         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8122         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8123         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8124         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8125         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8126         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8127         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8128 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8129         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8130         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8131         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8132         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8133         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8134         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8135         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8136         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8137 /* ;CR Registers */
8138         /* Config. Reg. 0 (filters)        (cr0):FF */
8139         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8140 /* Config. Reg. 1 (dialing)        (cr1):05 */
8141         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8142 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8143         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8144 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8145         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8146 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8147         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8148         /* Config. Reg. 5 (Version)        (cr5):02 */
8149         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8150         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8151         /* ;xr Registers */
8152         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8153
8154         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8155         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8156
8157         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8158         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8159
8160         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8161 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8162         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8163 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8164         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8165 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8166         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8167 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8168         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8169 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8170         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8171         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8172         /*                                       12,33,5A,C3    ;  770 Hz   */
8173         /*                                       13,3C,5B,32    ;  852 Hz   */
8174         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8175
8176         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8177         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8178         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8179         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8180 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8181         /*                                       EC,1D,52,22    ;  1336 Hz   */
8182         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8183         /*                                       9B,3B,51,25    ;  1633 Hz   */
8184         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8185         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8186         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8187         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8188 }
8189
8190
8191 static void DAA_Coeff_France(IXJ *j)
8192 {
8193         int i;
8194
8195         j->daa_country = DAA_FRANCE;
8196         /*----------------------------------------------- */
8197         /* CAO */
8198         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8199                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8200         }
8201
8202 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8203         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8204         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8205         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8206         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8207         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8208         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8209         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8210         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8211 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8212         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8213         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8214         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8215         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8216         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8217         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8218         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8219         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8220 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8221         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8222         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8223         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8224         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8225         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8226         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8227         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8228         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8229 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8230         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8231         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8232         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8233         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8234         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8235         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8236         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8237         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8238 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8239         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8240         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8241         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8242         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8243 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8244         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8245         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8246         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8247         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8248 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8249         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8250         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8251         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8252         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8253         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8254         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8255         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8256         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8257 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8258         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8259         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8260         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8261         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8262         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8263         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8264         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8265         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8266 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8267         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8268         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8269         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8270         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8271         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8272         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8273         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8274         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8275 /* ; idle */
8276         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8277         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8278         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8279         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8280         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8281         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8282         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8283         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8284         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8285 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8286         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8287         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8288         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8289         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8290         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8291         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8292         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8293         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8294 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8295         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8296         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8297         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8298         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8299 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8300         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8301         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8302         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8303         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8304         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8305         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8306         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8307         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8308 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8309         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8310         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8311         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8312         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8313         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8314         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8315         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8316         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8317 /* ;CR Registers */
8318         /* Config. Reg. 0 (filters)        (cr0):FF */
8319         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8320 /* Config. Reg. 1 (dialing)        (cr1):05 */
8321         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8322 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8323         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8324 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8325         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8326 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8327         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8328         /* Config. Reg. 5 (Version)        (cr5):02 */
8329         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8330         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8331         /* ;xr Registers */
8332         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8333
8334         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8335         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8336
8337         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8338         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8339
8340         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8341 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8342         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8343 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8344         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8345 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8346         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8347 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8348         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8349 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8350         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8351         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8352         /*                                       12,33,5A,C3    ;  770 Hz   */
8353         /*                                       13,3C,5B,32    ;  852 Hz   */
8354         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8355
8356         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8357         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8358         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8359         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8360 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8361         /*                                       EC,1D,52,22    ;  1336 Hz   */
8362         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8363         /*                                       9B,3B,51,25    ;  1633 Hz   */
8364         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8365         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8366         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8367         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8368 }
8369
8370
8371 static void DAA_Coeff_Germany(IXJ *j)
8372 {
8373         int i;
8374
8375         j->daa_country = DAA_GERMANY;
8376         /*----------------------------------------------- */
8377         /* CAO */
8378         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8379                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8380         }
8381
8382 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8383         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8384         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8385         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8386         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8387         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8388         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8389         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8390         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8391 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8392         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8393         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8394         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8395         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8396         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8397         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8398         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8399         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8400 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8401         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8402         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8403         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8404         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8405         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8406         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8407         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8408         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8409 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8410         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8411         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8412         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8413         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8414         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8415         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8416         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8417         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8418 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8419         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8420         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8421         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8422         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8423 /* Bytes for AR-filter        (09): 72,42,13,4B */
8424         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8425         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8426         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8427         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8428 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8429         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8430         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8431         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8432         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8433         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8434         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8435         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8436         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8437 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8438         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8439         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8440         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8441         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8442         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8443         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8444         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8445         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8446 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8447         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8448         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8449         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8450         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8451         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8452         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8453         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8454         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8455 /* ;  (10K, 0.68uF) */
8456         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8457         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8458         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8459         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8460         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8461         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8462         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8463         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8464         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8465 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8466         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8467         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8468         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8469         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8470         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8471         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8472         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8473         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8474 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8475         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8476         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8477         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8478         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8479 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8480         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8481         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8482         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8483         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8484         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8485         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8486         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8487         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8488 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8489         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8490         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8491         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8492         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8493         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8494         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8495         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8496         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8497 /* ;CR Registers */
8498         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8499         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8500 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8501         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8502 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8503         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8504 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8505         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8506 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8507         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8508         /* Config. Reg. 5 (Version)        (cr5):02 */
8509         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8510         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8511         /* ;xr Registers */
8512         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8513
8514         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8515         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8516
8517         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8518         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8519
8520         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8521 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8522         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8523 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8524         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8525 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8526         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8527 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8528         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8529 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8530         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8531         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8532         /*                                       12,33,5A,C3    ;  770 Hz   */
8533         /*                                       13,3C,5B,32    ;  852 Hz   */
8534         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8535
8536         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8537         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8538         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8539         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8540 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8541         /*                                       EC,1D,52,22    ;  1336 Hz   */
8542         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8543         /*                                       9B,3B,51,25    ;  1633 Hz   */
8544         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8545         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8546         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8547         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8548 }
8549
8550
8551 static void DAA_Coeff_Australia(IXJ *j)
8552 {
8553         int i;
8554
8555         j->daa_country = DAA_AUSTRALIA;
8556         /*----------------------------------------------- */
8557         /* CAO */
8558         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8559                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8560         }
8561
8562 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8563         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8564         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8565         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8566         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8567         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8568         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8569         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8570         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8571 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8572         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8573         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8574         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8575         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8576         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8577         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8578         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8579         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8580 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8581         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8582         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8583         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8584         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8585         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8586         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8587         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8588         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8589 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8590         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8591         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8592         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8593         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8594         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8595         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8596         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8597         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8598 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8599         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8600         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8601         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8602         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8603 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8604         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8605         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8606         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8607         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8608 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8609         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8610         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8611         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8612         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8613         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8614         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8615         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8616         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8617 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8618         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8619         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8620         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8621         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8622         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8623         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8624         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8625         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8626 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8627         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8628         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8629         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8630         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8631         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8632         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8633         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8634         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8635 /* ;  idle */
8636         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8637         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8638         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8639         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8640         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8641         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8642         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8643         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8644         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8645 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8646         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8647         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8648         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8649         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8650         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8651         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8652         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8653         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8654 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8655         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8656         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8657         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8658         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8659 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8660         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8661         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8662         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8663         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8664         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8665         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8666         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8667         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8668 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8669         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8670         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8671         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8672         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8673         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8674         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8675         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8676         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8677 /* ;CR Registers */
8678         /* Config. Reg. 0 (filters)        (cr0):FF */
8679         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8680 /* Config. Reg. 1 (dialing)        (cr1):05 */
8681         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8682 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8683         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8684 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8685         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8686 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8687         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8688         /* Config. Reg. 5 (Version)        (cr5):02 */
8689         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8690         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8691         /* ;xr Registers */
8692         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8693
8694         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8695         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8696
8697         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8698         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8699
8700         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8701 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8702         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8703 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8704         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8705 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8706         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8707 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8708         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8709 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8710         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8711
8712         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8713         /*                                       12,33,5A,C3    ;  770 Hz   */
8714         /*                                       13,3C,5B,32    ;  852 Hz   */
8715         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8716         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8717         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8718         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8719         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8720
8721         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8722         /*                                       EC,1D,52,22    ;  1336 Hz   */
8723         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8724         /*                                       9B,3B,51,25    ;  1633 Hz   */
8725         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8726         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8727         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8728         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8729 }
8730
8731 static void DAA_Coeff_Japan(IXJ *j)
8732 {
8733         int i;
8734
8735         j->daa_country = DAA_JAPAN;
8736         /*----------------------------------------------- */
8737         /* CAO */
8738         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8739                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8740         }
8741
8742 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8743         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8744         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8745         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8746         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8747         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8748         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8749         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8750         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8751 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8752         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8753         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8754         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8755         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8756         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8757         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8758         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8759         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8760 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8761         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8762         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8763         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8764         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8765         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8766         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8767         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8768         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8769 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8770         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8771         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8772         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8773         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8774         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8775         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8776         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8777         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8778 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8779         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8780         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8781         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8782         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8783 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8784         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8785         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8786         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8787         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8788 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8789         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8790         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8791         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8792         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8793         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8794         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8795         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8796         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8797 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8798         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8799         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8800         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8801         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8802         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8803         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8804         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8805         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8806 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8807         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8808         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8809         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8810         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8811         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8812         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8813         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8815 /* ;  idle */
8816         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8817         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8818         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8819         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8820         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8821         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8822         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8823         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8824         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8825 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8826         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8827         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8828         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8829         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8830         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8831         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8832         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8833         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8834 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8835         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8836         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8837         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8838         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8839 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8840         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8841         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8842         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8843         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8844         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8845         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8846         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8847         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8848 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8849         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8850         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8851         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8852         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8853         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8854         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8855         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8856         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8857 /* ;CR Registers */
8858         /* Config. Reg. 0 (filters)        (cr0):FF */
8859         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8860 /* Config. Reg. 1 (dialing)        (cr1):05 */
8861         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8862 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8863         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8864 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8865         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8866 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8867         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8868         /* Config. Reg. 5 (Version)        (cr5):02 */
8869         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8870         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8871         /* ;xr Registers */
8872         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8873
8874         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8875         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8876
8877         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8878         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8879
8880         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8881 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8882         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8883 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8884         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8885 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8886         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8887 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8888         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8889 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8890         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8891         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8892         /*                                       12,33,5A,C3    ;  770 Hz   */
8893         /*                                       13,3C,5B,32    ;  852 Hz   */
8894         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8895
8896         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8897         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8898         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8899         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8900 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8901         /*                                       EC,1D,52,22    ;  1336 Hz   */
8902         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8903         /*                                       9B,3B,51,25    ;  1633 Hz   */
8904         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8905         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8906         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8907         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8908 }
8909
8910 static s16 tone_table[][19] =
8911 {
8912         {                       /* f20_50[] 11 */
8913                 32538,          /* A1 = 1.985962 */
8914                  -32325,        /* A2 = -0.986511 */
8915                  -343,          /* B2 = -0.010493 */
8916                  0,             /* B1 = 0 */
8917                  343,           /* B0 = 0.010493 */
8918                  32619,         /* A1 = 1.990906 */
8919                  -32520,        /* A2 = -0.992462 */
8920                  19179,         /* B2 = 0.585327 */
8921                  -19178,        /* B1 = -1.170593 */
8922                  19179,         /* B0 = 0.585327 */
8923                  32723,         /* A1 = 1.997314 */
8924                  -32686,        /* A2 = -0.997528 */
8925                  9973,          /* B2 = 0.304352 */
8926                  -9955,         /* B1 = -0.607605 */
8927                  9973,          /* B0 = 0.304352 */
8928                  7,             /* Internal filter scaling */
8929                  159,           /* Minimum in-band energy threshold */
8930                  21,            /* 21/32 in-band to broad-band ratio */
8931                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8932         },
8933         {                       /* f133_200[] 12 */
8934                 32072,          /* A1 = 1.95752 */
8935                  -31896,        /* A2 = -0.973419 */
8936                  -435,          /* B2 = -0.013294 */
8937                  0,             /* B1 = 0 */
8938                  435,           /* B0 = 0.013294 */
8939                  32188,         /* A1 = 1.9646 */
8940                  -32400,        /* A2 = -0.98877 */
8941                  15139,         /* B2 = 0.462036 */
8942                  -14882,        /* B1 = -0.908356 */
8943                  15139,         /* B0 = 0.462036 */
8944                  32473,         /* A1 = 1.981995 */
8945                  -32524,        /* A2 = -0.992584 */
8946                  23200,         /* B2 = 0.708008 */
8947                  -23113,        /* B1 = -1.410706 */
8948                  23200,         /* B0 = 0.708008 */
8949                  7,             /* Internal filter scaling */
8950                  159,           /* Minimum in-band energy threshold */
8951                  21,            /* 21/32 in-band to broad-band ratio */
8952                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8953         },
8954         {                       /* f300 13 */
8955                 31769,          /* A1 = -1.939026 */
8956                  -32584,        /* A2 = 0.994385 */
8957                  -475,          /* B2 = -0.014522 */
8958                  0,             /* B1 = 0.000000 */
8959                  475,           /* B0 = 0.014522 */
8960                  31789,         /* A1 = -1.940247 */
8961                  -32679,        /* A2 = 0.997284 */
8962                  17280,         /* B2 = 0.527344 */
8963                  -16865,        /* B1 = -1.029358 */
8964                  17280,         /* B0 = 0.527344 */
8965                  31841,         /* A1 = -1.943481 */
8966                  -32681,        /* A2 = 0.997345 */
8967                  543,           /* B2 = 0.016579 */
8968                  -525,          /* B1 = -0.032097 */
8969                  543,           /* B0 = 0.016579 */
8970                  5,             /* Internal filter scaling */
8971                  159,           /* Minimum in-band energy threshold */
8972                  21,            /* 21/32 in-band to broad-band ratio */
8973                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8974         },
8975         {                       /* f300_420[] 14 */
8976                 30750,          /* A1 = 1.876892 */
8977                  -31212,        /* A2 = -0.952515 */
8978                  -804,          /* B2 = -0.024541 */
8979                  0,             /* B1 = 0 */
8980                  804,           /* B0 = 0.024541 */
8981                  30686,         /* A1 = 1.872925 */
8982                  -32145,        /* A2 = -0.980988 */
8983                  14747,         /* B2 = 0.450043 */
8984                  -13703,        /* B1 = -0.836395 */
8985                  14747,         /* B0 = 0.450043 */
8986                  31651,         /* A1 = 1.931824 */
8987                  -32321,        /* A2 = -0.986389 */
8988                  24425,         /* B2 = 0.745422 */
8989                  -23914,        /* B1 = -1.459595 */
8990                  24427,         /* B0 = 0.745483 */
8991                  7,             /* Internal filter scaling */
8992                  159,           /* Minimum in-band energy threshold */
8993                  21,            /* 21/32 in-band to broad-band ratio */
8994                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8995         },
8996         {                       /* f330 15 */
8997                 31613,          /* A1 = -1.929565 */
8998                  -32646,        /* A2 = 0.996277 */
8999                  -185,          /* B2 = -0.005657 */
9000                  0,             /* B1 = 0.000000 */
9001                  185,           /* B0 = 0.005657 */
9002                  31620,         /* A1 = -1.929932 */
9003                  -32713,        /* A2 = 0.998352 */
9004                  19253,         /* B2 = 0.587585 */
9005                  -18566,        /* B1 = -1.133179 */
9006                  19253,         /* B0 = 0.587585 */
9007                  31674,         /* A1 = -1.933228 */
9008                  -32715,        /* A2 = 0.998413 */
9009                  2575,          /* B2 = 0.078590 */
9010                  -2495,         /* B1 = -0.152283 */
9011                  2575,          /* B0 = 0.078590 */
9012                  5,             /* Internal filter scaling */
9013                  159,           /* Minimum in-band energy threshold */
9014                  21,            /* 21/32 in-band to broad-band ratio */
9015                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9016         },
9017         {                       /* f300_425[] 16 */
9018                 30741,          /* A1 = 1.876282 */
9019                  -31475,        /* A2 = -0.960541 */
9020                  -703,          /* B2 = -0.021484 */
9021                  0,             /* B1 = 0 */
9022                  703,           /* B0 = 0.021484 */
9023                  30688,         /* A1 = 1.873047 */
9024                  -32248,        /* A2 = -0.984161 */
9025                  14542,         /* B2 = 0.443787 */
9026                  -13523,        /* B1 = -0.825439 */
9027                  14542,         /* B0 = 0.443817 */
9028                  31494,         /* A1 = 1.922302 */
9029                  -32366,        /* A2 = -0.987762 */
9030                  21577,         /* B2 = 0.658508 */
9031                  -21013,        /* B1 = -1.282532 */
9032                  21577,         /* B0 = 0.658508 */
9033                  7,             /* Internal filter scaling */
9034                  159,           /* Minimum in-band energy threshold */
9035                  21,            /* 21/32 in-band to broad-band ratio */
9036                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9037         },
9038         {                       /* f330_440[] 17 */
9039                 30627,          /* A1 = 1.869324 */
9040                  -31338,        /* A2 = -0.95636 */
9041                  -843,          /* B2 = -0.025749 */
9042                  0,             /* B1 = 0 */
9043                  843,           /* B0 = 0.025749 */
9044                  30550,         /* A1 = 1.864685 */
9045                  -32221,        /* A2 = -0.983337 */
9046                  13594,         /* B2 = 0.414886 */
9047                  -12589,        /* B1 = -0.768402 */
9048                  13594,         /* B0 = 0.414886 */
9049                  31488,         /* A1 = 1.921936 */
9050                  -32358,        /* A2 = -0.987518 */
9051                  24684,         /* B2 = 0.753296 */
9052                  -24029,        /* B1 = -1.466614 */
9053                  24684,         /* B0 = 0.753296 */
9054                  7,             /* Internal filter scaling */
9055                  159,           /* Minimum in-band energy threshold */
9056                  21,            /* 21/32 in-band to broad-band ratio */
9057                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9058         },
9059         {                       /* f340 18 */
9060                 31546,          /* A1 = -1.925476 */
9061                  -32646,        /* A2 = 0.996277 */
9062                  -445,          /* B2 = -0.013588 */
9063                  0,             /* B1 = 0.000000 */
9064                  445,           /* B0 = 0.013588 */
9065                  31551,         /* A1 = -1.925781 */
9066                  -32713,        /* A2 = 0.998352 */
9067                  23884,         /* B2 = 0.728882 */
9068                  -22979,        /* B1 = -1.402527 */
9069                  23884,         /* B0 = 0.728882 */
9070                  31606,         /* A1 = -1.929138 */
9071                  -32715,        /* A2 = 0.998413 */
9072                  863,           /* B2 = 0.026367 */
9073                  -835,          /* B1 = -0.050985 */
9074                  863,           /* B0 = 0.026367 */
9075                  5,             /* Internal filter scaling */
9076                  159,           /* Minimum in-band energy threshold */
9077                  21,            /* 21/32 in-band to broad-band ratio */
9078                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9079         },
9080         {                       /* f350_400[] 19 */
9081                 31006,          /* A1 = 1.892517 */
9082                  -32029,        /* A2 = -0.977448 */
9083                  -461,          /* B2 = -0.014096 */
9084                  0,             /* B1 = 0 */
9085                  461,           /* B0 = 0.014096 */
9086                  30999,         /* A1 = 1.892029 */
9087                  -32487,        /* A2 = -0.991455 */
9088                  11325,         /* B2 = 0.345612 */
9089                  -10682,        /* B1 = -0.651978 */
9090                  11325,         /* B0 = 0.345612 */
9091                  31441,         /* A1 = 1.919067 */
9092                  -32526,        /* A2 = -0.992615 */
9093                  24324,         /* B2 = 0.74231 */
9094                  -23535,        /* B1 = -1.436523 */
9095                  24324,         /* B0 = 0.74231 */
9096                  7,             /* Internal filter scaling */
9097                  159,           /* Minimum in-band energy threshold */
9098                  21,            /* 21/32 in-band to broad-band ratio */
9099                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9100         },
9101         {                       /* f350_440[] */
9102                 30634,          /* A1 = 1.869751 */
9103                  -31533,        /* A2 = -0.962341 */
9104                  -680,          /* B2 = -0.020782 */
9105                  0,             /* B1 = 0 */
9106                  680,           /* B0 = 0.020782 */
9107                  30571,         /* A1 = 1.865906 */
9108                  -32277,        /* A2 = -0.985016 */
9109                  12894,         /* B2 = 0.393524 */
9110                  -11945,        /* B1 = -0.729065 */
9111                  12894,         /* B0 = 0.393524 */
9112                  31367,         /* A1 = 1.91449 */
9113                  -32379,        /* A2 = -0.988129 */
9114                  23820,         /* B2 = 0.726929 */
9115                  -23104,        /* B1 = -1.410217 */
9116                  23820,         /* B0 = 0.726929 */
9117                  7,             /* Internal filter scaling */
9118                  159,           /* Minimum in-band energy threshold */
9119                  21,            /* 21/32 in-band to broad-band ratio */
9120                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9121         },
9122         {                       /* f350_450[] */
9123                 30552,          /* A1 = 1.864807 */
9124                  -31434,        /* A2 = -0.95929 */
9125                  -690,          /* B2 = -0.021066 */
9126                  0,             /* B1 = 0 */
9127                  690,           /* B0 = 0.021066 */
9128                  30472,         /* A1 = 1.859924 */
9129                  -32248,        /* A2 = -0.984161 */
9130                  13385,         /* B2 = 0.408478 */
9131                  -12357,        /* B1 = -0.754242 */
9132                  13385,         /* B0 = 0.408478 */
9133                  31358,         /* A1 = 1.914001 */
9134                  -32366,        /* A2 = -0.987732 */
9135                  26488,         /* B2 = 0.80835 */
9136                  -25692,        /* B1 = -1.568176 */
9137                  26490,         /* B0 = 0.808411 */
9138                  7,             /* Internal filter scaling */
9139                  159,           /* Minimum in-band energy threshold */
9140                  21,            /* 21/32 in-band to broad-band ratio */
9141                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9142         },
9143         {                       /* f360 */
9144                 31397,          /* A1 = -1.916321 */
9145                  -32623,        /* A2 = 0.995605 */
9146                  -117,          /* B2 = -0.003598 */
9147                  0,             /* B1 = 0.000000 */
9148                  117,           /* B0 = 0.003598 */
9149                  31403,         /* A1 = -1.916687 */
9150                  -32700,        /* A2 = 0.997925 */
9151                  3388,          /* B2 = 0.103401 */
9152                  -3240,         /* B1 = -0.197784 */
9153                  3388,          /* B0 = 0.103401 */
9154                  31463,         /* A1 = -1.920410 */
9155                  -32702,        /* A2 = 0.997986 */
9156                  13346,         /* B2 = 0.407288 */
9157                  -12863,        /* B1 = -0.785126 */
9158                  13346,         /* B0 = 0.407288 */
9159                  5,             /* Internal filter scaling */
9160                  159,           /* Minimum in-band energy threshold */
9161                  21,            /* 21/32 in-band to broad-band ratio */
9162                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9163         },
9164         {                       /* f380_420[] */
9165                 30831,          /* A1 = 1.881775 */
9166                  -32064,        /* A2 = -0.978546 */
9167                  -367,          /* B2 = -0.01122 */
9168                  0,             /* B1 = 0 */
9169                  367,           /* B0 = 0.01122 */
9170                  30813,         /* A1 = 1.880737 */
9171                  -32456,        /* A2 = -0.990509 */
9172                  11068,         /* B2 = 0.337769 */
9173                  -10338,        /* B1 = -0.631042 */
9174                  11068,         /* B0 = 0.337769 */
9175                  31214,         /* A1 = 1.905212 */
9176                  -32491,        /* A2 = -0.991577 */
9177                  16374,         /* B2 = 0.499695 */
9178                  -15781,        /* B1 = -0.963196 */
9179                  16374,         /* B0 = 0.499695 */
9180                  7,             /* Internal filter scaling */
9181                  159,           /* Minimum in-band energy threshold */
9182                  21,            /* 21/32 in-band to broad-band ratio */
9183                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9184         },
9185         {                       /* f392 */
9186                 31152,          /* A1 = -1.901428 */
9187                  -32613,        /* A2 = 0.995300 */
9188                  -314,          /* B2 = -0.009605 */
9189                  0,             /* B1 = 0.000000 */
9190                  314,           /* B0 = 0.009605 */
9191                  31156,         /* A1 = -1.901672 */
9192                  -32694,        /* A2 = 0.997742 */
9193                  28847,         /* B2 = 0.880371 */
9194                  -2734,         /* B1 = -0.166901 */
9195                  28847,         /* B0 = 0.880371 */
9196                  31225,         /* A1 = -1.905823 */
9197                  -32696,        /* A2 = 0.997803 */
9198                  462,           /* B2 = 0.014108 */
9199                  -442,          /* B1 = -0.027019 */
9200                  462,           /* B0 = 0.014108 */
9201                  5,             /* Internal filter scaling */
9202                  159,           /* Minimum in-band energy threshold */
9203                  21,            /* 21/32 in-band to broad-band ratio */
9204                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9205         },
9206         {                       /* f400_425[] */
9207                 30836,          /* A1 = 1.882141 */
9208                  -32296,        /* A2 = -0.985596 */
9209                  -324,          /* B2 = -0.009903 */
9210                  0,             /* B1 = 0 */
9211                  324,           /* B0 = 0.009903 */
9212                  30825,         /* A1 = 1.881409 */
9213                  -32570,        /* A2 = -0.993958 */
9214                  16847,         /* B2 = 0.51416 */
9215                  -15792,        /* B1 = -0.963898 */
9216                  16847,         /* B0 = 0.51416 */
9217                  31106,         /* A1 = 1.89856 */
9218                  -32584,        /* A2 = -0.994415 */
9219                  9579,          /* B2 = 0.292328 */
9220                  -9164,         /* B1 = -0.559357 */
9221                  9579,          /* B0 = 0.292328 */
9222                  7,             /* Internal filter scaling */
9223                  159,           /* Minimum in-band energy threshold */
9224                  21,            /* 21/32 in-band to broad-band ratio */
9225                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9226         },
9227         {                       /* f400_440[] */
9228                 30702,          /* A1 = 1.873962 */
9229                  -32134,        /* A2 = -0.980682 */
9230                  -517,          /* B2 = -0.015793 */
9231                  0,             /* B1 = 0 */
9232                  517,           /* B0 = 0.015793 */
9233                  30676,         /* A1 = 1.872375 */
9234                  -32520,        /* A2 = -0.992462 */
9235                  8144,          /* B2 = 0.24855 */
9236                  -7596,         /* B1 = -0.463684 */
9237                  8144,          /* B0 = 0.24855 */
9238                  31084,         /* A1 = 1.897217 */
9239                  -32547,        /* A2 = -0.993256 */
9240                  22713,         /* B2 = 0.693176 */
9241                  -21734,        /* B1 = -1.326599 */
9242                  22713,         /* B0 = 0.693176 */
9243                  7,             /* Internal filter scaling */
9244                  159,           /* Minimum in-band energy threshold */
9245                  21,            /* 21/32 in-band to broad-band ratio */
9246                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9247         },
9248         {                       /* f400_450[] */
9249                 30613,          /* A1 = 1.86853 */
9250                  -32031,        /* A2 = -0.977509 */
9251                  -618,          /* B2 = -0.018866 */
9252                  0,             /* B1 = 0 */
9253                  618,           /* B0 = 0.018866 */
9254                  30577,         /* A1 = 1.866272 */
9255                  -32491,        /* A2 = -0.991577 */
9256                  9612,          /* B2 = 0.293335 */
9257                  -8935,         /* B1 = -0.54541 */
9258                  9612,          /* B0 = 0.293335 */
9259                  31071,         /* A1 = 1.896484 */
9260                  -32524,        /* A2 = -0.992584 */
9261                  21596,         /* B2 = 0.659058 */
9262                  -20667,        /* B1 = -1.261414 */
9263                  21596,         /* B0 = 0.659058 */
9264                  7,             /* Internal filter scaling */
9265                  159,           /* Minimum in-band energy threshold */
9266                  21,            /* 21/32 in-band to broad-band ratio */
9267                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9268         },
9269         {                       /* f420 */
9270                 30914,          /* A1 = -1.886841 */
9271                  -32584,        /* A2 = 0.994385 */
9272                  -426,          /* B2 = -0.013020 */
9273                  0,             /* B1 = 0.000000 */
9274                  426,           /* B0 = 0.013020 */
9275                  30914,         /* A1 = -1.886841 */
9276                  -32679,        /* A2 = 0.997314 */
9277                  17520,         /* B2 = 0.534668 */
9278                  -16471,        /* B1 = -1.005310 */
9279                  17520,         /* B0 = 0.534668 */
9280                  31004,         /* A1 = -1.892334 */
9281                  -32683,        /* A2 = 0.997406 */
9282                  819,           /* B2 = 0.025023 */
9283                  -780,          /* B1 = -0.047619 */
9284                  819,           /* B0 = 0.025023 */
9285                  5,             /* Internal filter scaling */
9286                  159,           /* Minimum in-band energy threshold */
9287                  21,            /* 21/32 in-band to broad-band ratio */
9288                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9289         },
9290 #if 0
9291         {                       /* f425 */
9292                 30881,          /* A1 = -1.884827 */
9293                  -32603,        /* A2 = 0.994965 */
9294                  -496,          /* B2 = -0.015144 */
9295                  0,             /* B1 = 0.000000 */
9296                  496,           /* B0 = 0.015144 */
9297                  30880,         /* A1 = -1.884766 */
9298                  -32692,        /* A2 = 0.997711 */
9299                  24767,         /* B2 = 0.755859 */
9300                  -23290,        /* B1 = -1.421509 */
9301                  24767,         /* B0 = 0.755859 */
9302                  30967,         /* A1 = -1.890076 */
9303                  -32694,        /* A2 = 0.997772 */
9304                  728,           /* B2 = 0.022232 */
9305                  -691,          /* B1 = -0.042194 */
9306                  728,           /* B0 = 0.022232 */
9307                  5,             /* Internal filter scaling */
9308                  159,           /* Minimum in-band energy threshold */
9309                  21,            /* 21/32 in-band to broad-band ratio */
9310                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9311         },
9312 #else
9313         {
9314                 30850,
9315                 -32534,
9316                 -504,
9317                 0,
9318                 504,
9319                 30831,
9320                 -32669,
9321                 24303,
9322                 -22080,
9323                 24303,
9324                 30994,
9325                 -32673,
9326                 1905,
9327                 -1811,
9328                 1905,
9329                 5,
9330                 129,
9331                 17,
9332                 0xff5
9333         },
9334 #endif
9335         {                       /* f425_450[] */
9336                 30646,          /* A1 = 1.870544 */
9337                  -32327,        /* A2 = -0.986572 */
9338                  -287,          /* B2 = -0.008769 */
9339                  0,             /* B1 = 0 */
9340                  287,           /* B0 = 0.008769 */
9341                  30627,         /* A1 = 1.869324 */
9342                  -32607,        /* A2 = -0.995087 */
9343                  13269,         /* B2 = 0.404968 */
9344                  -12376,        /* B1 = -0.755432 */
9345                  13269,         /* B0 = 0.404968 */
9346                  30924,         /* A1 = 1.887512 */
9347                  -32619,        /* A2 = -0.995453 */
9348                  19950,         /* B2 = 0.608826 */
9349                  -18940,        /* B1 = -1.156006 */
9350                  19950,         /* B0 = 0.608826 */
9351                  7,             /* Internal filter scaling */
9352                  159,           /* Minimum in-band energy threshold */
9353                  21,            /* 21/32 in-band to broad-band ratio */
9354                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9355         },
9356         {                       /* f425_475[] */
9357                 30396,          /* A1 = 1.855225 */
9358                  -32014,        /* A2 = -0.97699 */
9359                  -395,          /* B2 = -0.012055 */
9360                  0,             /* B1 = 0 */
9361                  395,           /* B0 = 0.012055 */
9362                  30343,         /* A1 = 1.85199 */
9363                  -32482,        /* A2 = -0.991302 */
9364                  17823,         /* B2 = 0.543945 */
9365                  -16431,        /* B1 = -1.002869 */
9366                  17823,         /* B0 = 0.543945 */
9367                  30872,         /* A1 = 1.884338 */
9368                  -32516,        /* A2 = -0.99231 */
9369                  18124,         /* B2 = 0.553101 */
9370                  -17246,        /* B1 = -1.052673 */
9371                  18124,         /* B0 = 0.553101 */
9372                  7,             /* Internal filter scaling */
9373                  159,           /* Minimum in-band energy threshold */
9374                  21,            /* 21/32 in-band to broad-band ratio */
9375                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9376         },
9377         {                       /* f435 */
9378                 30796,          /* A1 = -1.879639 */
9379                  -32603,        /* A2 = 0.994965 */
9380                  -254,          /* B2 = -0.007762 */
9381                  0,             /* B1 = 0.000000 */
9382                  254,           /* B0 = 0.007762 */
9383                  30793,         /* A1 = -1.879456 */
9384                  -32692,        /* A2 = 0.997711 */
9385                  18934,         /* B2 = 0.577820 */
9386                  -17751,        /* B1 = -1.083496 */
9387                  18934,         /* B0 = 0.577820 */
9388                  30882,         /* A1 = -1.884888 */
9389                  -32694,        /* A2 = 0.997772 */
9390                  1858,          /* B2 = 0.056713 */
9391                  -1758,         /* B1 = -0.107357 */
9392                  1858,          /* B0 = 0.056713 */
9393                  5,             /* Internal filter scaling */
9394                  159,           /* Minimum in-band energy threshold */
9395                  21,            /* 21/32 in-band to broad-band ratio */
9396                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9397         },
9398         {                       /* f440_450[] */
9399                 30641,          /* A1 = 1.870239 */
9400                  -32458,        /* A2 = -0.99057 */
9401                  -155,          /* B2 = -0.004735 */
9402                  0,             /* B1 = 0 */
9403                  155,           /* B0 = 0.004735 */
9404                  30631,         /* A1 = 1.869568 */
9405                  -32630,        /* A2 = -0.995789 */
9406                  11453,         /* B2 = 0.349548 */
9407                  -10666,        /* B1 = -0.651001 */
9408                  11453,         /* B0 = 0.349548 */
9409                  30810,         /* A1 = 1.880554 */
9410                  -32634,        /* A2 = -0.995941 */
9411                  12237,         /* B2 = 0.373474 */
9412                  -11588,        /* B1 = -0.707336 */
9413                  12237,         /* B0 = 0.373474 */
9414                  7,             /* Internal filter scaling */
9415                  159,           /* Minimum in-band energy threshold */
9416                  21,            /* 21/32 in-band to broad-band ratio */
9417                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9418         },
9419         {                       /* f440_480[] */
9420                 30367,          /* A1 = 1.853455 */
9421                  -32147,        /* A2 = -0.981079 */
9422                  -495,          /* B2 = -0.015113 */
9423                  0,             /* B1 = 0 */
9424                  495,           /* B0 = 0.015113 */
9425                  30322,         /* A1 = 1.850769 */
9426                  -32543,        /* A2 = -0.993134 */
9427                  10031,         /* B2 = 0.306152 */
9428                  -9252,         /* B1 = -0.564728 */
9429                  10031,         /* B0 = 0.306152 */
9430                  30770,         /* A1 = 1.878052 */
9431                  -32563,        /* A2 = -0.993774 */
9432                  22674,         /* B2 = 0.691956 */
9433                  -21465,        /* B1 = -1.31012 */
9434                  22674,         /* B0 = 0.691956 */
9435                  7,             /* Internal filter scaling */
9436                  159,           /* Minimum in-band energy threshold */
9437                  21,            /* 21/32 in-band to broad-band ratio */
9438                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9439         },
9440         {                       /* f445 */
9441                 30709,          /* A1 = -1.874329 */
9442                  -32603,        /* A2 = 0.994965 */
9443                  -83,           /* B2 = -0.002545 */
9444                  0,             /* B1 = 0.000000 */
9445                  83,            /* B0 = 0.002545 */
9446                  30704,         /* A1 = -1.874084 */
9447                  -32692,        /* A2 = 0.997711 */
9448                  10641,         /* B2 = 0.324738 */
9449                  -9947,         /* B1 = -0.607147 */
9450                  10641,         /* B0 = 0.324738 */
9451                  30796,         /* A1 = -1.879639 */
9452                  -32694,        /* A2 = 0.997772 */
9453                  10079,         /* B2 = 0.307587 */
9454                  9513,          /* B1 = 0.580688 */
9455                  10079,         /* B0 = 0.307587 */
9456                  5,             /* Internal filter scaling */
9457                  159,           /* Minimum in-band energy threshold */
9458                  21,            /* 21/32 in-band to broad-band ratio */
9459                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9460         },
9461         {                       /* f450 */
9462                 30664,          /* A1 = -1.871643 */
9463                  -32603,        /* A2 = 0.994965 */
9464                  -164,          /* B2 = -0.005029 */
9465                  0,             /* B1 = 0.000000 */
9466                  164,           /* B0 = 0.005029 */
9467                  30661,         /* A1 = -1.871399 */
9468                  -32692,        /* A2 = 0.997711 */
9469                  15294,         /* B2 = 0.466736 */
9470                  -14275,        /* B1 = -0.871307 */
9471                  15294,         /* B0 = 0.466736 */
9472                  30751,         /* A1 = -1.876953 */
9473                  -32694,        /* A2 = 0.997772 */
9474                  3548,          /* B2 = 0.108284 */
9475                  -3344,         /* B1 = -0.204155 */
9476                  3548,          /* B0 = 0.108284 */
9477                  5,             /* Internal filter scaling */
9478                  159,           /* Minimum in-band energy threshold */
9479                  21,            /* 21/32 in-band to broad-band ratio */
9480                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9481         },
9482         {                       /* f452 */
9483                 30653,          /* A1 = -1.870911 */
9484                  -32615,        /* A2 = 0.995361 */
9485                  -209,          /* B2 = -0.006382 */
9486                  0,             /* B1 = 0.000000 */
9487                  209,           /* B0 = 0.006382 */
9488                  30647,         /* A1 = -1.870605 */
9489                  -32702,        /* A2 = 0.997986 */
9490                  18971,         /* B2 = 0.578979 */
9491                  -17716,        /* B1 = -1.081299 */
9492                  18971,         /* B0 = 0.578979 */
9493                  30738,         /* A1 = -1.876099 */
9494                  -32702,        /* A2 = 0.998016 */
9495                  2967,          /* B2 = 0.090561 */
9496                  -2793,         /* B1 = -0.170502 */
9497                  2967,          /* B0 = 0.090561 */
9498                  5,             /* Internal filter scaling */
9499                  159,           /* Minimum in-band energy threshold */
9500                  21,            /* 21/32 in-band to broad-band ratio */
9501                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9502         },
9503         {                       /* f475 */
9504                 30437,          /* A1 = -1.857727 */
9505                  -32603,        /* A2 = 0.994965 */
9506                  -264,          /* B2 = -0.008062 */
9507                  0,             /* B1 = 0.000000 */
9508                  264,           /* B0 = 0.008062 */
9509                  30430,         /* A1 = -1.857300 */
9510                  -32692,        /* A2 = 0.997711 */
9511                  21681,         /* B2 = 0.661682 */
9512                  -20082,        /* B1 = -1.225708 */
9513                  21681,         /* B0 = 0.661682 */
9514                  30526,         /* A1 = -1.863220 */
9515                  -32694,        /* A2 = 0.997742 */
9516                  1559,          /* B2 = 0.047600 */
9517                  -1459,         /* B1 = -0.089096 */
9518                  1559,          /* B0 = 0.047600 */
9519                  5,             /* Internal filter scaling */
9520                  159,           /* Minimum in-band energy threshold */
9521                  21,            /* 21/32 in-band to broad-band ratio */
9522                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9523         },
9524         {                       /* f480_620[] */
9525                 28975,          /* A1 = 1.768494 */
9526                  -30955,        /* A2 = -0.944672 */
9527                  -1026,         /* B2 = -0.03133 */
9528                  0,             /* B1 = 0 */
9529                  1026,          /* B0 = 0.03133 */
9530                  28613,         /* A1 = 1.746399 */
9531                  -32089,        /* A2 = -0.979309 */
9532                  14214,         /* B2 = 0.433807 */
9533                  -12202,        /* B1 = -0.744812 */
9534                  14214,         /* B0 = 0.433807 */
9535                  30243,         /* A1 = 1.845947 */
9536                  -32238,        /* A2 = -0.983856 */
9537                  24825,         /* B2 = 0.757629 */
9538                  -23402,        /* B1 = -1.428345 */
9539                  24825,         /* B0 = 0.757629 */
9540                  7,             /* Internal filter scaling */
9541                  159,           /* Minimum in-band energy threshold */
9542                  21,            /* 21/32 in-band to broad-band ratio */
9543                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9544         },
9545         {                       /* f494 */
9546                 30257,          /* A1 = -1.846741 */
9547                  -32605,        /* A2 = 0.995056 */
9548                  -249,          /* B2 = -0.007625 */
9549                  0,             /* B1 = 0.000000 */
9550                  249,           /* B0 = 0.007625 */
9551                  30247,         /* A1 = -1.846191 */
9552                  -32694,        /* A2 = 0.997772 */
9553                  18088,         /* B2 = 0.552002 */
9554                  -16652,        /* B1 = -1.016418 */
9555                  18088,         /* B0 = 0.552002 */
9556                  30348,         /* A1 = -1.852295 */
9557                  -32696,        /* A2 = 0.997803 */
9558                  2099,          /* B2 = 0.064064 */
9559                  -1953,         /* B1 = -0.119202 */
9560                  2099,          /* B0 = 0.064064 */
9561                  5,             /* Internal filter scaling */
9562                  159,           /* Minimum in-band energy threshold */
9563                  21,            /* 21/32 in-band to broad-band ratio */
9564                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9565         },
9566         {                       /* f500 */
9567                 30202,          /* A1 = -1.843431 */
9568                  -32624,        /* A2 = 0.995622 */
9569                  -413,          /* B2 = -0.012622 */
9570                  0,             /* B1 = 0.000000 */
9571                  413,           /* B0 = 0.012622 */
9572                  30191,         /* A1 = -1.842721 */
9573                  -32714,        /* A2 = 0.998364 */
9574                  25954,         /* B2 = 0.792057 */
9575                  -23890,        /* B1 = -1.458131 */
9576                  25954,         /* B0 = 0.792057 */
9577                  30296,         /* A1 = -1.849172 */
9578                  -32715,        /* A2 = 0.998397 */
9579                  2007,          /* B2 = 0.061264 */
9580                  -1860,         /* B1 = -0.113568 */
9581                  2007,          /* B0 = 0.061264 */
9582                  5,             /* Internal filter scaling */
9583                  159,           /* Minimum in-band energy threshold */
9584                  21,            /* 21/32 in-band to broad-band ratio */
9585                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9586         },
9587         {                       /* f520 */
9588                 30001,          /* A1 = -1.831116 */
9589                  -32613,        /* A2 = 0.995270 */
9590                  -155,          /* B2 = -0.004750 */
9591                  0,             /* B1 = 0.000000 */
9592                  155,           /* B0 = 0.004750 */
9593                  29985,         /* A1 = -1.830200 */
9594                  -32710,        /* A2 = 0.998260 */
9595                  6584,          /* B2 = 0.200928 */
9596                  -6018,         /* B1 = -0.367355 */
9597                  6584,          /* B0 = 0.200928 */
9598                  30105,         /* A1 = -1.837524 */
9599                  -32712,        /* A2 = 0.998291 */
9600                  23812,         /* B2 = 0.726685 */
9601                  -21936,        /* B1 = -1.338928 */
9602                  23812,         /* B0 = 0.726685 */
9603                  5,             /* Internal filter scaling */
9604                  159,           /* Minimum in-band energy threshold */
9605                  21,            /* 21/32 in-band to broad-band ratio */
9606                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9607         },
9608         {                       /* f523 */
9609                 29964,          /* A1 = -1.828918 */
9610                  -32601,        /* A2 = 0.994904 */
9611                  -101,          /* B2 = -0.003110 */
9612                  0,             /* B1 = 0.000000 */
9613                  101,           /* B0 = 0.003110 */
9614                  29949,         /* A1 = -1.827942 */
9615                  -32700,        /* A2 = 0.997925 */
9616                  11041,         /* B2 = 0.336975 */
9617                  -10075,        /* B1 = -0.614960 */
9618                  11041,         /* B0 = 0.336975 */
9619                  30070,         /* A1 = -1.835388 */
9620                  -32702,        /* A2 = 0.997986 */
9621                  16762,         /* B2 = 0.511536 */
9622                  -15437,        /* B1 = -0.942230 */
9623                  16762,         /* B0 = 0.511536 */
9624                  5,             /* Internal filter scaling */
9625                  159,           /* Minimum in-band energy threshold */
9626                  21,            /* 21/32 in-band to broad-band ratio */
9627                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9628         },
9629         {                       /* f525 */
9630                 29936,          /* A1 = -1.827209 */
9631                  -32584,        /* A2 = 0.994415 */
9632                  -91,           /* B2 = -0.002806 */
9633                  0,             /* B1 = 0.000000 */
9634                  91,            /* B0 = 0.002806 */
9635                  29921,         /* A1 = -1.826233 */
9636                  -32688,        /* A2 = 0.997559 */
9637                  11449,         /* B2 = 0.349396 */
9638                  -10426,        /* B1 = -0.636383 */
9639                  11449,         /* B0 = 0.349396 */
9640                  30045,         /* A1 = -1.833862 */
9641                  -32688,        /* A2 = 0.997589 */
9642                  13055,         /* B2 = 0.398407 */
9643                  -12028,        /* B1 = -0.734161 */
9644                  13055,         /* B0 = 0.398407 */
9645                  5,             /* Internal filter scaling */
9646                  159,           /* Minimum in-band energy threshold */
9647                  21,            /* 21/32 in-band to broad-band ratio */
9648                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9649         },
9650         {                       /* f540_660[] */
9651                 28499,          /* A1 = 1.739441 */
9652                  -31129,        /* A2 = -0.949982 */
9653                  -849,          /* B2 = -0.025922 */
9654                  0,             /* B1 = 0 */
9655                  849,           /* B0 = 0.025922 */
9656                  28128,         /* A1 = 1.716797 */
9657                  -32130,        /* A2 = -0.98056 */
9658                  14556,         /* B2 = 0.444214 */
9659                  -12251,        /* B1 = -0.747772 */
9660                  14556,         /* B0 = 0.444244 */
9661                  29667,         /* A1 = 1.81073 */
9662                  -32244,        /* A2 = -0.984039 */
9663                  23038,         /* B2 = 0.703064 */
9664                  -21358,        /* B1 = -1.303589 */
9665                  23040,         /* B0 = 0.703125 */
9666                  7,             /* Internal filter scaling */
9667                  159,           /* Minimum in-band energy threshold */
9668                  21,            /* 21/32 in-band to broad-band ratio */
9669                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9670         },
9671         {                       /* f587 */
9672                 29271,          /* A1 = -1.786560 */
9673                  -32599,        /* A2 = 0.994873 */
9674                  -490,          /* B2 = -0.014957 */
9675                  0,             /* B1 = 0.000000 */
9676                  490,           /* B0 = 0.014957 */
9677                  29246,         /* A1 = -1.785095 */
9678                  -32700,        /* A2 = 0.997925 */
9679                  28961,         /* B2 = 0.883850 */
9680                  -25796,        /* B1 = -1.574463 */
9681                  28961,         /* B0 = 0.883850 */
9682                  29383,         /* A1 = -1.793396 */
9683                  -32700,        /* A2 = 0.997955 */
9684                  1299,          /* B2 = 0.039650 */
9685                  -1169,         /* B1 = -0.071396 */
9686                  1299,          /* B0 = 0.039650 */
9687                  5,             /* Internal filter scaling */
9688                  159,           /* Minimum in-band energy threshold */
9689                  21,            /* 21/32 in-band to broad-band ratio */
9690                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9691         },
9692         {                       /* f590 */
9693                 29230,          /* A1 = -1.784058 */
9694                  -32584,        /* A2 = 0.994415 */
9695                  -418,          /* B2 = -0.012757 */
9696                  0,             /* B1 = 0.000000 */
9697                  418,           /* B0 = 0.012757 */
9698                  29206,         /* A1 = -1.782593 */
9699                  -32688,        /* A2 = 0.997559 */
9700                  36556,         /* B2 = 1.115601 */
9701                  -32478,        /* B1 = -1.982300 */
9702                  36556,         /* B0 = 1.115601 */
9703                  29345,         /* A1 = -1.791077 */
9704                  -32688,        /* A2 = 0.997589 */
9705                  897,           /* B2 = 0.027397 */
9706                  -808,          /* B1 = -0.049334 */
9707                  897,           /* B0 = 0.027397 */
9708                  5,             /* Internal filter scaling */
9709                  159,           /* Minimum in-band energy threshold */
9710                  21,            /* 21/32 in-band to broad-band ratio */
9711                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9712         },
9713         {                       /* f600 */
9714                 29116,          /* A1 = -1.777100 */
9715                  -32603,        /* A2 = 0.994965 */
9716                  -165,          /* B2 = -0.005039 */
9717                  0,             /* B1 = 0.000000 */
9718                  165,           /* B0 = 0.005039 */
9719                  29089,         /* A1 = -1.775452 */
9720                  -32708,        /* A2 = 0.998199 */
9721                  6963,          /* B2 = 0.212494 */
9722                  -6172,         /* B1 = -0.376770 */
9723                  6963,          /* B0 = 0.212494 */
9724                  29237,         /* A1 = -1.784485 */
9725                  -32710,        /* A2 = 0.998230 */
9726                  24197,         /* B2 = 0.738464 */
9727                  -21657,        /* B1 = -1.321899 */
9728                  24197,         /* B0 = 0.738464 */
9729                  5,             /* Internal filter scaling */
9730                  159,           /* Minimum in-band energy threshold */
9731                  21,            /* 21/32 in-band to broad-band ratio */
9732                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9733         },
9734         {                       /* f660 */
9735                 28376,          /* A1 = -1.731934 */
9736                  -32567,        /* A2 = 0.993896 */
9737                  -363,          /* B2 = -0.011102 */
9738                  0,             /* B1 = 0.000000 */
9739                  363,           /* B0 = 0.011102 */
9740                  28337,         /* A1 = -1.729614 */
9741                  -32683,        /* A2 = 0.997434 */
9742                  21766,         /* B2 = 0.664246 */
9743                  -18761,        /* B1 = -1.145081 */
9744                  21766,         /* B0 = 0.664246 */
9745                  28513,         /* A1 = -1.740356 */
9746                  -32686,        /* A2 = 0.997498 */
9747                  2509,          /* B2 = 0.076584 */
9748                  -2196,         /* B1 = -0.134041 */
9749                  2509,          /* B0 = 0.076584 */
9750                  5,             /* Internal filter scaling */
9751                  159,           /* Minimum in-band energy threshold */
9752                  21,            /* 21/32 in-band to broad-band ratio */
9753                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9754         },
9755         {                       /* f700 */
9756                 27844,          /* A1 = -1.699463 */
9757                  -32563,        /* A2 = 0.993744 */
9758                  -366,          /* B2 = -0.011187 */
9759                  0,             /* B1 = 0.000000 */
9760                  366,           /* B0 = 0.011187 */
9761                  27797,         /* A1 = -1.696655 */
9762                  -32686,        /* A2 = 0.997498 */
9763                  22748,         /* B2 = 0.694214 */
9764                  -19235,        /* B1 = -1.174072 */
9765                  22748,         /* B0 = 0.694214 */
9766                  27995,         /* A1 = -1.708740 */
9767                  -32688,        /* A2 = 0.997559 */
9768                  2964,          /* B2 = 0.090477 */
9769                  -2546,         /* B1 = -0.155449 */
9770                  2964,          /* B0 = 0.090477 */
9771                  5,             /* Internal filter scaling */
9772                  159,           /* Minimum in-band energy threshold */
9773                  21,            /* 21/32 in-band to broad-band ratio */
9774                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9775         },
9776         {                       /* f740 */
9777                 27297,          /* A1 = -1.666077 */
9778                  -32551,        /* A2 = 0.993408 */
9779                  -345,          /* B2 = -0.010540 */
9780                  0,             /* B1 = 0.000000 */
9781                  345,           /* B0 = 0.010540 */
9782                  27240,         /* A1 = -1.662598 */
9783                  -32683,        /* A2 = 0.997406 */
9784                  22560,         /* B2 = 0.688477 */
9785                  -18688,        /* B1 = -1.140625 */
9786                  22560,         /* B0 = 0.688477 */
9787                  27461,         /* A1 = -1.676147 */
9788                  -32684,        /* A2 = 0.997467 */
9789                  3541,          /* B2 = 0.108086 */
9790                  -2985,         /* B1 = -0.182220 */
9791                  3541,          /* B0 = 0.108086 */
9792                  5,             /* Internal filter scaling */
9793                  159,           /* Minimum in-band energy threshold */
9794                  21,            /* 21/32 in-band to broad-band ratio */
9795                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9796         },
9797         {                       /* f750 */
9798                 27155,          /* A1 = -1.657410 */
9799                  -32551,        /* A2 = 0.993408 */
9800                  -462,          /* B2 = -0.014117 */
9801                  0,             /* B1 = 0.000000 */
9802                  462,           /* B0 = 0.014117 */
9803                  27097,         /* A1 = -1.653870 */
9804                  -32683,        /* A2 = 0.997406 */
9805                  32495,         /* B2 = 0.991699 */
9806                  -26776,        /* B1 = -1.634338 */
9807                  32495,         /* B0 = 0.991699 */
9808                  27321,         /* A1 = -1.667542 */
9809                  -32684,        /* A2 = 0.997467 */
9810                  1835,          /* B2 = 0.056007 */
9811                  -1539,         /* B1 = -0.093948 */
9812                  1835,          /* B0 = 0.056007 */
9813                  5,             /* Internal filter scaling */
9814                  159,           /* Minimum in-band energy threshold */
9815                  21,            /* 21/32 in-band to broad-band ratio */
9816                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9817         },
9818         {                       /* f750_1450[] */
9819                 19298,          /* A1 = 1.177917 */
9820                  -24471,        /* A2 = -0.746796 */
9821                  -4152,         /* B2 = -0.126709 */
9822                  0,             /* B1 = 0 */
9823                  4152,          /* B0 = 0.126709 */
9824                  12902,         /* A1 = 0.787476 */
9825                  -29091,        /* A2 = -0.887817 */
9826                  12491,         /* B2 = 0.38121 */
9827                  -1794,         /* B1 = -0.109528 */
9828                  12494,         /* B0 = 0.381317 */
9829                  26291,         /* A1 = 1.604736 */
9830                  -30470,        /* A2 = -0.929901 */
9831                  28859,         /* B2 = 0.880737 */
9832                  -26084,        /* B1 = -1.592102 */
9833                  28861,         /* B0 = 0.880798 */
9834                  7,             /* Internal filter scaling */
9835                  159,           /* Minimum in-band energy threshold */
9836                  21,            /* 21/32 in-band to broad-band ratio */
9837                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9838         },
9839         {                       /* f770 */
9840                 26867,          /* A1 = -1.639832 */
9841                  -32551,        /* A2 = 0.993408 */
9842                  -123,          /* B2 = -0.003755 */
9843                  0,             /* B1 = 0.000000 */
9844                  123,           /* B0 = 0.003755 */
9845                  26805,         /* A1 = -1.636108 */
9846                  -32683,        /* A2 = 0.997406 */
9847                  17297,         /* B2 = 0.527863 */
9848                  -14096,        /* B1 = -0.860382 */
9849                  17297,         /* B0 = 0.527863 */
9850                  27034,         /* A1 = -1.650085 */
9851                  -32684,        /* A2 = 0.997467 */
9852                  12958,         /* B2 = 0.395477 */
9853                  -10756,        /* B1 = -0.656525 */
9854                  12958,         /* B0 = 0.395477 */
9855                  5,             /* Internal filter scaling */
9856                  159,           /* Minimum in-band energy threshold */
9857                  21,            /* 21/32 in-band to broad-band ratio */
9858                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9859         },
9860         {                       /* f800 */
9861                 26413,          /* A1 = -1.612122 */
9862                  -32547,        /* A2 = 0.993286 */
9863                  -223,          /* B2 = -0.006825 */
9864                  0,             /* B1 = 0.000000 */
9865                  223,           /* B0 = 0.006825 */
9866                  26342,         /* A1 = -1.607849 */
9867                  -32686,        /* A2 = 0.997498 */
9868                  6391,          /* B2 = 0.195053 */
9869                  -5120,         /* B1 = -0.312531 */
9870                  6391,          /* B0 = 0.195053 */
9871                  26593,         /* A1 = -1.623108 */
9872                  -32688,        /* A2 = 0.997559 */
9873                  23681,         /* B2 = 0.722717 */
9874                  -19328,        /* B1 = -1.179688 */
9875                  23681,         /* B0 = 0.722717 */
9876                  5,             /* Internal filter scaling */
9877                  159,           /* Minimum in-band energy threshold */
9878                  21,            /* 21/32 in-band to broad-band ratio */
9879                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9880         },
9881         {                       /* f816 */
9882                 26168,          /* A1 = -1.597209 */
9883                  -32528,        /* A2 = 0.992706 */
9884                  -235,          /* B2 = -0.007182 */
9885                  0,             /* B1 = 0.000000 */
9886                  235,           /* B0 = 0.007182 */
9887                  26092,         /* A1 = -1.592590 */
9888                  -32675,        /* A2 = 0.997192 */
9889                  20823,         /* B2 = 0.635498 */
9890                  -16510,        /* B1 = -1.007751 */
9891                  20823,         /* B0 = 0.635498 */
9892                  26363,         /* A1 = -1.609070 */
9893                  -32677,        /* A2 = 0.997253 */
9894                  6739,          /* B2 = 0.205688 */
9895                  -5459,         /* B1 = -0.333206 */
9896                  6739,          /* B0 = 0.205688 */
9897                  5,             /* Internal filter scaling */
9898                  159,           /* Minimum in-band energy threshold */
9899                  21,            /* 21/32 in-band to broad-band ratio */
9900                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9901         },
9902         {                       /* f850 */
9903                 25641,          /* A1 = -1.565063 */
9904                  -32536,        /* A2 = 0.992950 */
9905                  -121,          /* B2 = -0.003707 */
9906                  0,             /* B1 = 0.000000 */
9907                  121,           /* B0 = 0.003707 */
9908                  25560,         /* A1 = -1.560059 */
9909                  -32684,        /* A2 = 0.997437 */
9910                  18341,         /* B2 = 0.559753 */
9911                  -14252,        /* B1 = -0.869904 */
9912                  18341,         /* B0 = 0.559753 */
9913                  25837,         /* A1 = -1.577026 */
9914                  -32684,        /* A2 = 0.997467 */
9915                  16679,         /* B2 = 0.509003 */
9916                  -13232,        /* B1 = -0.807648 */
9917                  16679,         /* B0 = 0.509003 */
9918                  5,             /* Internal filter scaling */
9919                  159,           /* Minimum in-band energy threshold */
9920                  21,            /* 21/32 in-band to broad-band ratio */
9921                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9922         },
9923         {                       /* f857_1645[] */
9924                 16415,          /* A1 = 1.001953 */
9925                  -23669,        /* A2 = -0.722321 */
9926                  -4549,         /* B2 = -0.138847 */
9927                  0,             /* B1 = 0 */
9928                  4549,          /* B0 = 0.138847 */
9929                  8456,          /* A1 = 0.516174 */
9930                  -28996,        /* A2 = -0.884918 */
9931                  13753,         /* B2 = 0.419724 */
9932                  -12,           /* B1 = -0.000763 */
9933                  13757,         /* B0 = 0.419846 */
9934                  24632,         /* A1 = 1.503418 */
9935                  -30271,        /* A2 = -0.923828 */
9936                  29070,         /* B2 = 0.887146 */
9937                  -25265,        /* B1 = -1.542114 */
9938                  29073,         /* B0 = 0.887268 */
9939                  7,             /* Internal filter scaling */
9940                  159,           /* Minimum in-band energy threshold */
9941                  21,            /* 21/32 in-band to broad-band ratio */
9942                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9943         },
9944         {                       /* f900 */
9945                 24806,          /* A1 = -1.514099 */
9946                  -32501,        /* A2 = 0.991852 */
9947                  -326,          /* B2 = -0.009969 */
9948                  0,             /* B1 = 0.000000 */
9949                  326,           /* B0 = 0.009969 */
9950                  24709,         /* A1 = -1.508118 */
9951                  -32659,        /* A2 = 0.996674 */
9952                  20277,         /* B2 = 0.618835 */
9953                  -15182,        /* B1 = -0.926636 */
9954                  20277,         /* B0 = 0.618835 */
9955                  25022,         /* A1 = -1.527222 */
9956                  -32661,        /* A2 = 0.996735 */
9957                  4320,          /* B2 = 0.131836 */
9958                  -3331,         /* B1 = -0.203339 */
9959                  4320,          /* B0 = 0.131836 */
9960                  5,             /* Internal filter scaling */
9961                  159,           /* Minimum in-band energy threshold */
9962                  21,            /* 21/32 in-band to broad-band ratio */
9963                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9964         },
9965         {                       /* f900_1300[] */
9966                 19776,          /* A1 = 1.207092 */
9967                  -27437,        /* A2 = -0.837341 */
9968                  -2666,         /* B2 = -0.081371 */
9969                  0,             /* B1 = 0 */
9970                  2666,          /* B0 = 0.081371 */
9971                  16302,         /* A1 = 0.995026 */
9972                  -30354,        /* A2 = -0.926361 */
9973                  10389,         /* B2 = 0.317062 */
9974                  -3327,         /* B1 = -0.203064 */
9975                  10389,         /* B0 = 0.317062 */
9976                  24299,         /* A1 = 1.483154 */
9977                  -30930,        /* A2 = -0.943909 */
9978                  25016,         /* B2 = 0.763428 */
9979                  -21171,        /* B1 = -1.292236 */
9980                  25016,         /* B0 = 0.763428 */
9981                  7,             /* Internal filter scaling */
9982                  159,           /* Minimum in-band energy threshold */
9983                  21,            /* 21/32 in-band to broad-band ratio */
9984                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9985         },
9986         {                       /* f935_1215[] */
9987                 20554,          /* A1 = 1.254517 */
9988                  -28764,        /* A2 = -0.877838 */
9989                  -2048,         /* B2 = -0.062515 */
9990                  0,             /* B1 = 0 */
9991                  2048,          /* B0 = 0.062515 */
9992                  18209,         /* A1 = 1.11145 */
9993                  -30951,        /* A2 = -0.94458 */
9994                  9390,          /* B2 = 0.286575 */
9995                  -3955,         /* B1 = -0.241455 */
9996                  9390,          /* B0 = 0.286575 */
9997                  23902,         /* A1 = 1.458923 */
9998                  -31286,        /* A2 = -0.954803 */
9999                  23252,         /* B2 = 0.709595 */
10000                  -19132,        /* B1 = -1.167725 */
10001                  23252,         /* B0 = 0.709595 */
10002                  7,             /* Internal filter scaling */
10003                  159,           /* Minimum in-band energy threshold */
10004                  21,            /* 21/32 in-band to broad-band ratio */
10005                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10006         },
10007         {                       /* f941_1477[] */
10008                 17543,          /* A1 = 1.07074 */
10009                  -26220,        /* A2 = -0.800201 */
10010                  -3298,         /* B2 = -0.100647 */
10011                  0,             /* B1 = 0 */
10012                  3298,          /* B0 = 0.100647 */
10013                  12423,         /* A1 = 0.75827 */
10014                  -30036,        /* A2 = -0.916626 */
10015                  12651,         /* B2 = 0.386078 */
10016                  -2444,         /* B1 = -0.14917 */
10017                  12653,         /* B0 = 0.386154 */
10018                  23518,         /* A1 = 1.435425 */
10019                  -30745,        /* A2 = -0.938293 */
10020                  27282,         /* B2 = 0.832581 */
10021                  -22529,        /* B1 = -1.375122 */
10022                  27286,         /* B0 = 0.832703 */
10023                  7,             /* Internal filter scaling */
10024                  159,           /* Minimum in-band energy threshold */
10025                  21,            /* 21/32 in-band to broad-band ratio */
10026                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10027         },
10028         {                       /* f942 */
10029                 24104,          /* A1 = -1.471252 */
10030                  -32507,        /* A2 = 0.992065 */
10031                  -351,          /* B2 = -0.010722 */
10032                  0,             /* B1 = 0.000000 */
10033                  351,           /* B0 = 0.010722 */
10034                  23996,         /* A1 = -1.464600 */
10035                  -32671,        /* A2 = 0.997040 */
10036                  22848,         /* B2 = 0.697266 */
10037                  -16639,        /* B1 = -1.015564 */
10038                  22848,         /* B0 = 0.697266 */
10039                  24332,         /* A1 = -1.485168 */
10040                  -32673,        /* A2 = 0.997101 */
10041                  4906,          /* B2 = 0.149727 */
10042                  -3672,         /* B1 = -0.224174 */
10043                  4906,          /* B0 = 0.149727 */
10044                  5,             /* Internal filter scaling */
10045                  159,           /* Minimum in-band energy threshold */
10046                  21,            /* 21/32 in-band to broad-band ratio */
10047                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10048         },
10049         {                       /* f950 */
10050                 23967,          /* A1 = -1.462830 */
10051                  -32507,        /* A2 = 0.992065 */
10052                  -518,          /* B2 = -0.015821 */
10053                  0,             /* B1 = 0.000000 */
10054                  518,           /* B0 = 0.015821 */
10055                  23856,         /* A1 = -1.456055 */
10056                  -32671,        /* A2 = 0.997040 */
10057                  26287,         /* B2 = 0.802246 */
10058                  -19031,        /* B1 = -1.161560 */
10059                  26287,         /* B0 = 0.802246 */
10060                  24195,         /* A1 = -1.476746 */
10061                  -32673,        /* A2 = 0.997101 */
10062                  2890,          /* B2 = 0.088196 */
10063                  -2151,         /* B1 = -0.131317 */
10064                  2890,          /* B0 = 0.088196 */
10065                  5,             /* Internal filter scaling */
10066                  159,           /* Minimum in-band energy threshold */
10067                  21,            /* 21/32 in-band to broad-band ratio */
10068                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10069         },
10070         {                       /* f950_1400[] */
10071                 18294,          /* A1 = 1.116638 */
10072                  -26962,        /* A2 = -0.822845 */
10073                  -2914,         /* B2 = -0.088936 */
10074                  0,             /* B1 = 0 */
10075                  2914,          /* B0 = 0.088936 */
10076                  14119,         /* A1 = 0.861786 */
10077                  -30227,        /* A2 = -0.922455 */
10078                  11466,         /* B2 = 0.349945 */
10079                  -2833,         /* B1 = -0.172943 */
10080                  11466,         /* B0 = 0.349945 */
10081                  23431,         /* A1 = 1.430115 */
10082                  -30828,        /* A2 = -0.940796 */
10083                  25331,         /* B2 = 0.773071 */
10084                  -20911,        /* B1 = -1.276367 */
10085                  25331,         /* B0 = 0.773071 */
10086                  7,             /* Internal filter scaling */
10087                  159,           /* Minimum in-band energy threshold */
10088                  21,            /* 21/32 in-band to broad-band ratio */
10089                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10090         },
10091         {                       /* f975 */
10092                 23521,          /* A1 = -1.435608 */
10093                  -32489,        /* A2 = 0.991516 */
10094                  -193,          /* B2 = -0.005915 */
10095                  0,             /* B1 = 0.000000 */
10096                  193,           /* B0 = 0.005915 */
10097                  23404,         /* A1 = -1.428467 */
10098                  -32655,        /* A2 = 0.996582 */
10099                  17740,         /* B2 = 0.541412 */
10100                  -12567,        /* B1 = -0.767029 */
10101                  17740,         /* B0 = 0.541412 */
10102                  23753,         /* A1 = -1.449829 */
10103                  -32657,        /* A2 = 0.996613 */
10104                  9090,          /* B2 = 0.277405 */
10105                  -6662,         /* B1 = -0.406647 */
10106                  9090,          /* B0 = 0.277405 */
10107                  5,             /* Internal filter scaling */
10108                  159,           /* Minimum in-band energy threshold */
10109                  21,            /* 21/32 in-band to broad-band ratio */
10110                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10111         },
10112         {                       /* f1000 */
10113                 23071,          /* A1 = -1.408203 */
10114                  -32489,        /* A2 = 0.991516 */
10115                  -293,          /* B2 = -0.008965 */
10116                  0,             /* B1 = 0.000000 */
10117                  293,           /* B0 = 0.008965 */
10118                  22951,         /* A1 = -1.400818 */
10119                  -32655,        /* A2 = 0.996582 */
10120                  5689,          /* B2 = 0.173645 */
10121                  -3951,         /* B1 = -0.241150 */
10122                  5689,          /* B0 = 0.173645 */
10123                  23307,         /* A1 = -1.422607 */
10124                  -32657,        /* A2 = 0.996613 */
10125                  18692,         /* B2 = 0.570435 */
10126                  -13447,        /* B1 = -0.820770 */
10127                  18692,         /* B0 = 0.570435 */
10128                  5,             /* Internal filter scaling */
10129                  159,           /* Minimum in-band energy threshold */
10130                  21,            /* 21/32 in-band to broad-band ratio */
10131                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10132         },
10133         {                       /* f1020 */
10134                 22701,          /* A1 = -1.385620 */
10135                  -32474,        /* A2 = 0.991058 */
10136                  -292,          /* B2 = -0.008933 */
10137                  0,             /*163840      , B1 = 10.000000 */
10138                  292,           /* B0 = 0.008933 */
10139                  22564,         /* A1 = -1.377258 */
10140                  -32655,        /* A2 = 0.996552 */
10141                  20756,         /* B2 = 0.633423 */
10142                  -14176,        /* B1 = -0.865295 */
10143                  20756,         /* B0 = 0.633423 */
10144                  22960,         /* A1 = -1.401428 */
10145                  -32657,        /* A2 = 0.996613 */
10146                  6520,          /* B2 = 0.198990 */
10147                  -4619,         /* B1 = -0.281937 */
10148                  6520,          /* B0 = 0.198990 */
10149                  5,             /* Internal filter scaling */
10150                  159,           /* Minimum in-band energy threshold */
10151                  21,            /* 21/32 in-band to broad-band ratio */
10152                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10153         },
10154         {                       /* f1050 */
10155                 22142,          /* A1 = -1.351501 */
10156                  -32474,        /* A2 = 0.991058 */
10157                  -147,          /* B2 = -0.004493 */
10158                  0,             /* B1 = 0.000000 */
10159                  147,           /* B0 = 0.004493 */
10160                  22000,         /* A1 = -1.342834 */
10161                  -32655,        /* A2 = 0.996552 */
10162                  15379,         /* B2 = 0.469360 */
10163                  -10237,        /* B1 = -0.624847 */
10164                  15379,         /* B0 = 0.469360 */
10165                  22406,         /* A1 = -1.367554 */
10166                  -32657,        /* A2 = 0.996613 */
10167                  17491,         /* B2 = 0.533783 */
10168                  -12096,        /* B1 = -0.738312 */
10169                  17491,         /* B0 = 0.533783 */
10170                  5,             /* Internal filter scaling */
10171                  159,           /* Minimum in-band energy threshold */
10172                  21,            /* 21/32 in-band to broad-band ratio */
10173                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10174         },
10175         {                       /* f1100_1750[] */
10176                 12973,          /* A1 = 0.79184 */
10177                  -24916,        /* A2 = -0.760376 */
10178                  6655,          /* B2 = 0.203102 */
10179                  367,           /* B1 = 0.0224 */
10180                  6657,          /* B0 = 0.203171 */
10181                  5915,          /* A1 = 0.361053 */
10182                  -29560,        /* A2 = -0.90213 */
10183                  -7777,         /* B2 = -0.23735 */
10184                  0,             /* B1 = 0 */
10185                  7777,          /* B0 = 0.23735 */
10186                  20510,         /* A1 = 1.251892 */
10187                  -30260,        /* A2 = -0.923462 */
10188                  26662,         /* B2 = 0.81366 */
10189                  -20573,        /* B1 = -1.255737 */
10190                  26668,         /* B0 = 0.813843 */
10191                  7,             /* Internal filter scaling */
10192                  159,           /* Minimum in-band energy threshold */
10193                  21,            /* 21/32 in-band to broad-band ratio */
10194                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10195         },
10196         {                       /* f1140 */
10197                 20392,          /* A1 = -1.244629 */
10198                  -32460,        /* A2 = 0.990601 */
10199                  -270,          /* B2 = -0.008240 */
10200                  0,             /* B1 = 0.000000 */
10201                  270,           /* B0 = 0.008240 */
10202                  20218,         /* A1 = -1.234009 */
10203                  -32655,        /* A2 = 0.996582 */
10204                  21337,         /* B2 = 0.651154 */
10205                  -13044,        /* B1 = -0.796143 */
10206                  21337,         /* B0 = 0.651154 */
10207                  20684,         /* A1 = -1.262512 */
10208                  -32657,        /* A2 = 0.996643 */
10209                  8572,          /* B2 = 0.261612 */
10210                  -5476,         /* B1 = -0.334244 */
10211                  8572,          /* B0 = 0.261612 */
10212                  5,             /* Internal filter scaling */
10213                  159,           /* Minimum in-band energy threshold */
10214                  21,            /* 21/32 in-band to broad-band ratio */
10215                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10216         },
10217         {                       /* f1200 */
10218                 19159,          /* A1 = -1.169373 */
10219                  -32456,        /* A2 = 0.990509 */
10220                  -335,          /* B2 = -0.010252 */
10221                  0,             /* B1 = 0.000000 */
10222                  335,           /* B0 = 0.010252 */
10223                  18966,         /* A1 = -1.157593 */
10224                  -32661,        /* A2 = 0.996735 */
10225                  6802,          /* B2 = 0.207588 */
10226                  -3900,         /* B1 = -0.238098 */
10227                  6802,          /* B0 = 0.207588 */
10228                  19467,         /* A1 = -1.188232 */
10229                  -32661,        /* A2 = 0.996765 */
10230                  25035,         /* B2 = 0.764008 */
10231                  -15049,        /* B1 = -0.918579 */
10232                  25035,         /* B0 = 0.764008 */
10233                  5,             /* Internal filter scaling */
10234                  159,           /* Minimum in-band energy threshold */
10235                  21,            /* 21/32 in-band to broad-band ratio */
10236                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10237         },
10238         {                       /* f1209 */
10239                 18976,          /* A1 = -1.158264 */
10240                  -32439,        /* A2 = 0.989990 */
10241                  -183,          /* B2 = -0.005588 */
10242                  0,             /* B1 = 0.000000 */
10243                  183,           /* B0 = 0.005588 */
10244                  18774,         /* A1 = -1.145874 */
10245                  -32650,        /* A2 = 0.996429 */
10246                  15468,         /* B2 = 0.472076 */
10247                  -8768,         /* B1 = -0.535217 */
10248                  15468,         /* B0 = 0.472076 */
10249                  19300,         /* A1 = -1.177979 */
10250                  -32652,        /* A2 = 0.996490 */
10251                  19840,         /* B2 = 0.605499 */
10252                  -11842,        /* B1 = -0.722809 */
10253                  19840,         /* B0 = 0.605499 */
10254                  5,             /* Internal filter scaling */
10255                  159,           /* Minimum in-band energy threshold */
10256                  21,            /* 21/32 in-band to broad-band ratio */
10257                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10258         },
10259         {                       /* f1330 */
10260                 16357,          /* A1 = -0.998413 */
10261                  -32368,        /* A2 = 0.987793 */
10262                  -217,          /* B2 = -0.006652 */
10263                  0,             /* B1 = 0.000000 */
10264                  217,           /* B0 = 0.006652 */
10265                  16107,         /* A1 = -0.983126 */
10266                  -32601,        /* A2 = 0.994904 */
10267                  11602,         /* B2 = 0.354065 */
10268                  -5555,         /* B1 = -0.339111 */
10269                  11602,         /* B0 = 0.354065 */
10270                  16722,         /* A1 = -1.020630 */
10271                  -32603,        /* A2 = 0.994965 */
10272                  15574,         /* B2 = 0.475311 */
10273                  -8176,         /* B1 = -0.499069 */
10274                  15574,         /* B0 = 0.475311 */
10275                  5,             /* Internal filter scaling */
10276                  159,           /* Minimum in-band energy threshold */
10277                  21,            /* 21/32 in-band to broad-band ratio */
10278                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10279         },
10280         {                       /* f1336 */
10281                 16234,          /* A1 = -0.990875 */
10282                  32404,         /* A2 = -0.988922 */
10283                  -193,          /* B2 = -0.005908 */
10284                  0,             /* B1 = 0.000000 */
10285                  193,           /* B0 = 0.005908 */
10286                  15986,         /* A1 = -0.975769 */
10287                  -32632,        /* A2 = 0.995880 */
10288                  18051,         /* B2 = 0.550903 */
10289                  -8658,         /* B1 = -0.528473 */
10290                  18051,         /* B0 = 0.550903 */
10291                  16591,         /* A1 = -1.012695 */
10292                  -32634,        /* A2 = 0.995941 */
10293                  15736,         /* B2 = 0.480240 */
10294                  -8125,         /* B1 = -0.495926 */
10295                  15736,         /* B0 = 0.480240 */
10296                  5,             /* Internal filter scaling */
10297                  159,           /* Minimum in-band energy threshold */
10298                  21,            /* 21/32 in-band to broad-band ratio */
10299                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10300         },
10301         {                       /* f1366 */
10302                 15564,          /* A1 = -0.949982 */
10303                  -32404,        /* A2 = 0.988922 */
10304                  -269,          /* B2 = -0.008216 */
10305                  0,             /* B1 = 0.000000 */
10306                  269,           /* B0 = 0.008216 */
10307                  15310,         /* A1 = -0.934479 */
10308                  -32632,        /* A2 = 0.995880 */
10309                  10815,         /* B2 = 0.330063 */
10310                  -4962,         /* B1 = -0.302887 */
10311                  10815,         /* B0 = 0.330063 */
10312                  15924,         /* A1 = -0.971924 */
10313                  -32634,        /* A2 = 0.995941 */
10314                  18880,         /* B2 = 0.576172 */
10315                  -9364,         /* B1 = -0.571594 */
10316                  18880,         /* B0 = 0.576172 */
10317                  5,             /* Internal filter scaling */
10318                  159,           /* Minimum in-band energy threshold */
10319                  21,            /* 21/32 in-band to broad-band ratio */
10320                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10321         },
10322         {                       /* f1380 */
10323                 15247,          /* A1 = -0.930603 */
10324                  -32397,        /* A2 = 0.988708 */
10325                  -244,          /* B2 = -0.007451 */
10326                  0,             /* B1 = 0.000000 */
10327                  244,           /* B0 = 0.007451 */
10328                  14989,         /* A1 = -0.914886 */
10329                  -32627,        /* A2 = 0.995697 */
10330                  18961,         /* B2 = 0.578644 */
10331                  -8498,         /* B1 = -0.518707 */
10332                  18961,         /* B0 = 0.578644 */
10333                  15608,         /* A1 = -0.952667 */
10334                  -32628,        /* A2 = 0.995758 */
10335                  11145,         /* B2 = 0.340134 */
10336                  -5430,         /* B1 = -0.331467 */
10337                  11145,         /* B0 = 0.340134 */
10338                  5,             /* Internal filter scaling */
10339                  159,           /* Minimum in-band energy threshold */
10340                  21,            /* 21/32 in-band to broad-band ratio */
10341                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10342         },
10343         {                       /* f1400 */
10344                 14780,          /* A1 = -0.902130 */
10345                  -32393,        /* A2 = 0.988586 */
10346                  -396,          /* B2 = -0.012086 */
10347                  0,             /* B1 = 0.000000 */
10348                  396,           /* B0 = 0.012086 */
10349                  14510,         /* A1 = -0.885651 */
10350                  -32630,        /* A2 = 0.995819 */
10351                  6326,          /* B2 = 0.193069 */
10352                  -2747,         /* B1 = -0.167671 */
10353                  6326,          /* B0 = 0.193069 */
10354                  15154,         /* A1 = -0.924957 */
10355                  -32632,        /* A2 = 0.995850 */
10356                  23235,         /* B2 = 0.709076 */
10357                  -10983,        /* B1 = -0.670380 */
10358                  23235,         /* B0 = 0.709076 */
10359                  5,             /* Internal filter scaling */
10360                  159,           /* Minimum in-band energy threshold */
10361                  21,            /* 21/32 in-band to broad-band ratio */
10362                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10363         },
10364         {                       /* f1477 */
10365                 13005,          /* A1 = -0.793793 */
10366                  -32368,        /* A2 = 0.987823 */
10367                  -500,          /* B2 = -0.015265 */
10368                  0,             /* B1 = 0.000000 */
10369                  500,           /* B0 = 0.015265 */
10370                  12708,         /* A1 = -0.775665 */
10371                  -32615,        /* A2 = 0.995331 */
10372                  11420,         /* B2 = 0.348526 */
10373                  -4306,         /* B1 = -0.262833 */
10374                  11420,         /* B0 = 0.348526 */
10375                  13397,         /* A1 = -0.817688 */
10376                  -32615,        /* A2 = 0.995361 */
10377                  9454,          /* B2 = 0.288528 */
10378                  -3981,         /* B1 = -0.243027 */
10379                  9454,          /* B0 = 0.288528 */
10380                  5,             /* Internal filter scaling */
10381                  159,           /* Minimum in-band energy threshold */
10382                  21,            /* 21/32 in-band to broad-band ratio */
10383                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10384         },
10385         {                       /* f1600 */
10386                 10046,          /* A1 = -0.613190 */
10387                  -32331,        /* A2 = 0.986694 */
10388                  -455,          /* B2 = -0.013915 */
10389                  0,             /* B1 = 0.000000 */
10390                  455,           /* B0 = 0.013915 */
10391                  9694,          /* A1 = -0.591705 */
10392                  -32601,        /* A2 = 0.994934 */
10393                  6023,          /* B2 = 0.183815 */
10394                  -1708,         /* B1 = -0.104279 */
10395                  6023,          /* B0 = 0.183815 */
10396                  10478,         /* A1 = -0.639587 */
10397                  -32603,        /* A2 = 0.994965 */
10398                  22031,         /* B2 = 0.672333 */
10399                  -7342,         /* B1 = -0.448151 */
10400                  22031,         /* B0 = 0.672333 */
10401                  5,             /* Internal filter scaling */
10402                  159,           /* Minimum in-band energy threshold */
10403                  21,            /* 21/32 in-band to broad-band ratio */
10404                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10405         },
10406         {                       /* f1633_1638[] */
10407                 9181,           /* A1 = 0.560394 */
10408                  -32256,        /* A2 = -0.984375 */
10409                  -556,          /* B2 = -0.016975 */
10410                  0,             /* B1 = 0 */
10411                  556,           /* B0 = 0.016975 */
10412                  8757,          /* A1 = 0.534515 */
10413                  -32574,        /* A2 = -0.99408 */
10414                  8443,          /* B2 = 0.25769 */
10415                  -2135,         /* B1 = -0.130341 */
10416                  8443,          /* B0 = 0.25769 */
10417                  9691,          /* A1 = 0.591522 */
10418                  -32574,        /* A2 = -0.99411 */
10419                  15446,         /* B2 = 0.471375 */
10420                  -4809,         /* B1 = -0.293579 */
10421                  15446,         /* B0 = 0.471375 */
10422                  7,             /* Internal filter scaling */
10423                  159,           /* Minimum in-band energy threshold */
10424                  21,            /* 21/32 in-band to broad-band ratio */
10425                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10426         },
10427         {                       /* f1800 */
10428                 5076,           /* A1 = -0.309875 */
10429                  -32304,        /* A2 = 0.985840 */
10430                  -508,          /* B2 = -0.015503 */
10431                  0,             /* B1 = 0.000000 */
10432                  508,           /* B0 = 0.015503 */
10433                  4646,          /* A1 = -0.283600 */
10434                  -32605,        /* A2 = 0.995026 */
10435                  6742,          /* B2 = 0.205780 */
10436                  -878,          /* B1 = -0.053635 */
10437                  6742,          /* B0 = 0.205780 */
10438                  5552,          /* A1 = -0.338928 */
10439                  -32605,        /* A2 = 0.995056 */
10440                  23667,         /* B2 = 0.722260 */
10441                  -4297,         /* B1 = -0.262329 */
10442                  23667,         /* B0 = 0.722260 */
10443                  5,             /* Internal filter scaling */
10444                  159,           /* Minimum in-band energy threshold */
10445                  21,            /* 21/32 in-band to broad-band ratio */
10446                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10447         },
10448         {                       /* f1860 */
10449                 3569,           /* A1 = -0.217865 */
10450                  -32292,        /* A2 = 0.985504 */
10451                  -239,          /* B2 = -0.007322 */
10452                  0,             /* B1 = 0.000000 */
10453                  239,           /* B0 = 0.007322 */
10454                  3117,          /* A1 = -0.190277 */
10455                  -32603,        /* A2 = 0.994965 */
10456                  18658,         /* B2 = 0.569427 */
10457                  -1557,         /* B1 = -0.095032 */
10458                  18658,         /* B0 = 0.569427 */
10459                  4054,          /* A1 = -0.247437 */
10460                  -32603,        /* A2 = 0.994965 */
10461                  18886,         /* B2 = 0.576385 */
10462                  -2566,         /* B1 = -0.156647 */
10463                  18886,         /* B0 = 0.576385 */
10464                  5,             /* Internal filter scaling */
10465                  159,           /* Minimum in-band energy threshold */
10466                  21,            /* 21/32 in-band to broad-band ratio */
10467                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10468         },
10469 };
10470 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10471 {
10472         unsigned short cmd;
10473         int cnt, max;
10474
10475         if (jf->filter > 3) {
10476                 return -1;
10477         }
10478         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10479
10480                 return -1;
10481         if (!jf->enable) {
10482                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10483
10484                         return -1;
10485                 else
10486                         return 0;
10487         } else {
10488                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10489
10490                         return -1;
10491                 /* Select the filter (f0 - f3) to use. */
10492                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10493                         return -1;
10494         }
10495         if (jf->freq < 12 && jf->freq > 3) {
10496                 /* Select the frequency for the selected filter. */
10497                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10498                         return -1;
10499         } else if (jf->freq > 11) {
10500                 /* We need to load a programmable filter set for undefined */
10501                 /* frequencies.  So we will point the filter to a programmable set. */
10502                 /* Since there are only 4 filters and 4 programmable sets, we will */
10503                 /* just point the filter to the same number set and program it for the */
10504                 /* frequency we want. */
10505                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10506                         return -1;
10507                 if (j->ver.low != 0x12) {
10508                         cmd = 0x515B;
10509                         max = 19;
10510                 } else {
10511                         cmd = 0x515E;
10512                         max = 15;
10513                 }
10514                 if (ixj_WriteDSPCommand(cmd, j))
10515                         return -1;
10516                 for (cnt = 0; cnt < max; cnt++) {
10517                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10518                                 return -1;
10519                 }
10520         }
10521         j->filter_en[jf->filter] = jf->enable;
10522         return 0;
10523 }
10524
10525 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10526 {
10527         unsigned short cmd;
10528         int cnt, max;
10529         if (jfr->filter > 3) {
10530                 return -1;
10531         }
10532         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10533                 return -1;
10534
10535         if (!jfr->enable) {
10536                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10537                         return -1;
10538                 else
10539                         return 0;
10540         } else {
10541                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10542                         return -1;
10543                 /* Select the filter (f0 - f3) to use. */
10544                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10545                         return -1;
10546         }
10547         /* We need to load a programmable filter set for undefined */
10548         /* frequencies.  So we will point the filter to a programmable set. */
10549         /* Since there are only 4 filters and 4 programmable sets, we will */
10550         /* just point the filter to the same number set and program it for the */
10551         /* frequency we want. */
10552         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10553                 return -1;
10554         if (j->ver.low != 0x12) {
10555                 cmd = 0x515B;
10556                 max = 19;
10557         } else {
10558                 cmd = 0x515E;
10559                 max = 15;
10560         }
10561         if (ixj_WriteDSPCommand(cmd, j))
10562                 return -1;
10563         for (cnt = 0; cnt < max; cnt++) {
10564                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10565                         return -1;
10566         }
10567         j->filter_en[jfr->filter] = jfr->enable;
10568         return 0;
10569 }
10570
10571 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10572 {
10573         int freq0, freq1;
10574         unsigned short data;
10575         if (ti->freq0) {
10576                 freq0 = ti->freq0;
10577         } else {
10578                 freq0 = 0x7FFF;
10579         }
10580
10581         if (ti->freq1) {
10582                 freq1 = ti->freq1;
10583         } else {
10584                 freq1 = 0x7FFF;
10585         }
10586
10587         if(ti->tone_index > 12 && ti->tone_index < 28)
10588         {
10589                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10590                         return -1;
10591                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10592                         return -1;
10593                 data = freq0;
10594                 if (ixj_WriteDSPCommand(data, j))
10595                         return -1;
10596                 data = freq1;
10597                 if (ixj_WriteDSPCommand(data, j))
10598                         return -1;
10599         }
10600         return freq0;
10601 }
10602