git.oblomov.eu Git - linux-2.6/blob - 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         kfree(j->fskdata);
 333         j->fskdata = NULL;
 334 }
 335
 336 static void ixj_fsk_alloc(IXJ *j)
 337 {
 338         if(!j->fskdata) {
 339                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 340                 if (!j->fskdata) {
 341                         if(ixjdebug & 0x0200) {
 342                                 printk("IXJ phone%d - allocate failed\n", j->board);
 343                         }
 344                         return;
 345                 } else {
 346                         j->fsksize = 8000;
 347                         if(ixjdebug & 0x0200) {
 348                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 349                         }
 350                 }
 351         }
 352 }
 353
 354 #else
 355
 356 static IXJ ixj[IXJMAX];
 357 #define get_ixj(b)      (&ixj[(b)])
 358
 359 /*
 360  *      Allocate a free IXJ device
 361  */
 362
 363 static IXJ *ixj_alloc(void)
 364 {
 365         int cnt;
 366         for(cnt=0; cnt<IXJMAX; cnt++) {
 367                 if(!ixj[cnt].DSPbase)
 368                         return &ixj[cnt];
 369         }
 370         return NULL;
 371 }
 372
 373 static inline void ixj_fsk_free(IXJ *j) {;}
 374
 375 static inline void ixj_fsk_alloc(IXJ *j)
 376 {
 377         j->fsksize = 8000;
 378 }
 379
 380 #endif
 381
 382 #ifdef PERFMON_STATS
 383 #define ixj_perfmon(x)  ((x)++)
 384 #else
 385 #define ixj_perfmon(x)  do { } while(0)
 386 #endif
 387
 388 static int ixj_convert_loaded;
 389
 390 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 391
 392 /************************************************************************
 393 *
 394 * These are function definitions to allow external modules to register
 395 * enhanced functionality call backs.
 396 *
 397 ************************************************************************/
 398
 399 static int Stub(IXJ * J, unsigned long arg)
 400 {
 401         return 0;
 402 }
 403
 404 static IXJ_REGFUNC ixj_PreRead = &Stub;
 405 static IXJ_REGFUNC ixj_PostRead = &Stub;
 406 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 407 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 408
 409 static void ixj_read_frame(IXJ *j);
 410 static void ixj_write_frame(IXJ *j);
 411 static void ixj_init_timer(IXJ *j);
 412 static void ixj_add_timer(IXJ * j);
 413 static void ixj_timeout(unsigned long ptr);
 414 static int read_filters(IXJ *j);
 415 static int LineMonitor(IXJ *j);
 416 static int ixj_fasync(int fd, struct file *, int mode);
 417 static int ixj_set_port(IXJ *j, int arg);
 418 static int ixj_set_pots(IXJ *j, int arg);
 419 static int ixj_hookstate(IXJ *j);
 420 static int ixj_record_start(IXJ *j);
 421 static void ixj_record_stop(IXJ *j);
 422 static void set_rec_volume(IXJ *j, int volume);
 423 static int get_rec_volume(IXJ *j);
 424 static int set_rec_codec(IXJ *j, int rate);
 425 static void ixj_vad(IXJ *j, int arg);
 426 static int ixj_play_start(IXJ *j);
 427 static void ixj_play_stop(IXJ *j);
 428 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 429 static int ixj_set_tone_off(unsigned short, IXJ *j);
 430 static int ixj_play_tone(IXJ *j, char tone);
 431 static void ixj_aec_start(IXJ *j, int level);
 432 static int idle(IXJ *j);
 433 static void ixj_ring_on(IXJ *j);
 434 static void ixj_ring_off(IXJ *j);
 435 static void aec_stop(IXJ *j);
 436 static void ixj_ringback(IXJ *j);
 437 static void ixj_busytone(IXJ *j);
 438 static void ixj_dialtone(IXJ *j);
 439 static void ixj_cpt_stop(IXJ *j);
 440 static char daa_int_read(IXJ *j);
 441 static char daa_CR_read(IXJ *j, int cr);
 442 static int daa_set_mode(IXJ *j, int mode);
 443 static int ixj_linetest(IXJ *j);
 444 static int ixj_daa_write(IXJ *j);
 445 static int ixj_daa_cid_read(IXJ *j);
 446 static void DAA_Coeff_US(IXJ *j);
 447 static void DAA_Coeff_UK(IXJ *j);
 448 static void DAA_Coeff_France(IXJ *j);
 449 static void DAA_Coeff_Germany(IXJ *j);
 450 static void DAA_Coeff_Australia(IXJ *j);
 451 static void DAA_Coeff_Japan(IXJ *j);
 452 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 453 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 454 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 455 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 456 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 457 /* Serial Control Interface funtions */
 458 static int SCI_Control(IXJ *j, int control);
 459 static int SCI_Prepare(IXJ *j);
 460 static int SCI_WaitHighSCI(IXJ *j);
 461 static int SCI_WaitLowSCI(IXJ *j);
 462 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 463 static int ixj_PCcontrol_wait(IXJ *j);
 464 static void ixj_pre_cid(IXJ *j);
 465 static void ixj_write_cid(IXJ *j);
 466 static void ixj_write_cid_bit(IXJ *j, int bit);
 467 static int set_base_frame(IXJ *j, int size);
 468 static int set_play_codec(IXJ *j, int rate);
 469 static void set_rec_depth(IXJ *j, int depth);
 470 static int ixj_mixer(long val, IXJ *j);
 471
 472 /************************************************************************
 473 CT8020/CT8021 Host Programmers Model
 474 Host address    Function                                        Access
 475 DSPbase +
 476 0-1             Aux Software Status Register (reserved)         Read Only
 477 2-3             Software Status Register                        Read Only
 478 4-5             Aux Software Control Register (reserved)        Read Write
 479 6-7             Software Control Register                       Read Write
 480 8-9             Hardware Status Register                        Read Only
 481 A-B             Hardware Control Register                       Read Write
 482 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 483 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 484 ************************************************************************/
 485
 486 static inline void ixj_read_HSR(IXJ *j)
 487 {
 488         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 489         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 490 }
 491
 492 static inline int IsControlReady(IXJ *j)
 493 {
 494         ixj_read_HSR(j);
 495         return j->hsr.bits.controlrdy ? 1 : 0;
 496 }
 497
 498 static inline int IsPCControlReady(IXJ *j)
 499 {
 500         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 501         return j->pccr1.bits.crr ? 1 : 0;
 502 }
 503
 504 static inline int IsStatusReady(IXJ *j)
 505 {
 506         ixj_read_HSR(j);
 507         return j->hsr.bits.statusrdy ? 1 : 0;
 508 }
 509
 510 static inline int IsRxReady(IXJ *j)
 511 {
 512         ixj_read_HSR(j);
 513         ixj_perfmon(j->rxreadycheck);
 514         return j->hsr.bits.rxrdy ? 1 : 0;
 515 }
 516
 517 static inline int IsTxReady(IXJ *j)
 518 {
 519         ixj_read_HSR(j);
 520         ixj_perfmon(j->txreadycheck);
 521         return j->hsr.bits.txrdy ? 1 : 0;
 522 }
 523
 524 static inline void set_play_volume(IXJ *j, int volume)
 525 {
 526         if (ixjdebug & 0x0002)
 527                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 528         ixj_WriteDSPCommand(0xCF02, j);
 529         ixj_WriteDSPCommand(volume, j);
 530 }
 531
 532 static int set_play_volume_linear(IXJ *j, int volume)
 533 {
 534         int newvolume, dspplaymax;
 535
 536         if (ixjdebug & 0x0002)
 537                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 538         if(volume > 100 || volume < 0) {
 539                 return -1;
 540         }
 541
 542         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 543         switch (j->cardtype) {
 544         case QTI_PHONEJACK:
 545                 dspplaymax = 0x380;
 546                 break;
 547         case QTI_LINEJACK:
 548                 if(j->port == PORT_PSTN) {
 549                         dspplaymax = 0x48;
 550                 } else {
 551                         dspplaymax = 0x100;
 552                 }
 553                 break;
 554         case QTI_PHONEJACK_LITE:
 555                 dspplaymax = 0x380;
 556                 break;
 557         case QTI_PHONEJACK_PCI:
 558                 dspplaymax = 0x6C;
 559                 break;
 560         case QTI_PHONECARD:
 561                 dspplaymax = 0x50;
 562                 break;
 563         default:
 564                 return -1;
 565         }
 566         newvolume = (dspplaymax * volume) / 100;
 567         set_play_volume(j, newvolume);
 568         return 0;
 569 }
 570
 571 static inline void set_play_depth(IXJ *j, int depth)
 572 {
 573         if (depth > 60)
 574                 depth = 60;
 575         if (depth < 0)
 576                 depth = 0;
 577         ixj_WriteDSPCommand(0x5280 + depth, j);
 578 }
 579
 580 static inline int get_play_volume(IXJ *j)
 581 {
 582         ixj_WriteDSPCommand(0xCF00, j);
 583         return j->ssr.high << 8 | j->ssr.low;
 584 }
 585
 586 static int get_play_volume_linear(IXJ *j)
 587 {
 588         int volume, newvolume, dspplaymax;
 589
 590         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 591         switch (j->cardtype) {
 592         case QTI_PHONEJACK:
 593                 dspplaymax = 0x380;
 594                 break;
 595         case QTI_LINEJACK:
 596                 if(j->port == PORT_PSTN) {
 597                         dspplaymax = 0x48;
 598                 } else {
 599                         dspplaymax = 0x100;
 600                 }
 601                 break;
 602         case QTI_PHONEJACK_LITE:
 603                 dspplaymax = 0x380;
 604                 break;
 605         case QTI_PHONEJACK_PCI:
 606                 dspplaymax = 0x6C;
 607                 break;
 608         case QTI_PHONECARD:
 609                 dspplaymax = 100;
 610                 break;
 611         default:
 612                 return -1;
 613         }
 614         volume = get_play_volume(j);
 615         newvolume = (volume * 100) / dspplaymax;
 616         if(newvolume > 100)
 617                 newvolume = 100;
 618         return newvolume;
 619 }
 620
 621 static inline BYTE SLIC_GetState(IXJ *j)
 622 {
 623         if (j->cardtype == QTI_PHONECARD) {
 624                 j->pccr1.byte = 0;
 625                 j->psccr.bits.dev = 3;
 626                 j->psccr.bits.rw = 1;
 627                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 628                 ixj_PCcontrol_wait(j);
 629                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 630                 ixj_PCcontrol_wait(j);
 631                 if (j->pslic.bits.powerdown)
 632                         return PLD_SLIC_STATE_OC;
 633                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 634                         return PLD_SLIC_STATE_ACTIVE;
 635                 else
 636                         return PLD_SLIC_STATE_RINGING;
 637         } else {
 638                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 639         }
 640         return j->pld_slicr.bits.state;
 641 }
 642
 643 static BOOL SLIC_SetState(BYTE byState, IXJ *j)
 644 {
 645         BOOL fRetVal = FALSE;
 646
 647         if (j->cardtype == QTI_PHONECARD) {
 648                 if (j->flags.pcmciasct) {
 649                         switch (byState) {
 650                         case PLD_SLIC_STATE_TIPOPEN:
 651                         case PLD_SLIC_STATE_OC:
 652                                 j->pslic.bits.powerdown = 1;
 653                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 654                                 fRetVal = TRUE;
 655                                 break;
 656                         case PLD_SLIC_STATE_RINGING:
 657                                 if (j->readers || j->writers) {
 658                                         j->pslic.bits.powerdown = 0;
 659                                         j->pslic.bits.ring0 = 1;
 660                                         j->pslic.bits.ring1 = 0;
 661                                         fRetVal = TRUE;
 662                                 }
 663                                 break;
 664                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 665
 666                         case PLD_SLIC_STATE_STANDBY:
 667                         case PLD_SLIC_STATE_ACTIVE:
 668                                 if (j->readers || j->writers) {
 669                                         j->pslic.bits.powerdown = 0;
 670                                 } else {
 671                                         j->pslic.bits.powerdown = 1;
 672                                 }
 673                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 674                                 fRetVal = TRUE;
 675                                 break;
 676                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 677
 678                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 679
 680                         default:
 681                                 fRetVal = FALSE;
 682                                 break;
 683                         }
 684                         j->psccr.bits.dev = 3;
 685                         j->psccr.bits.rw = 0;
 686                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 687                         ixj_PCcontrol_wait(j);
 688                 }
 689         } else {
 690                 /* Set the C1, C2, C3 & B2EN signals. */
 691                 switch (byState) {
 692                 case PLD_SLIC_STATE_OC:
 693                         j->pld_slicw.bits.c1 = 0;
 694                         j->pld_slicw.bits.c2 = 0;
 695                         j->pld_slicw.bits.c3 = 0;
 696                         j->pld_slicw.bits.b2en = 0;
 697                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 698                         fRetVal = TRUE;
 699                         break;
 700                 case PLD_SLIC_STATE_RINGING:
 701                         j->pld_slicw.bits.c1 = 1;
 702                         j->pld_slicw.bits.c2 = 0;
 703                         j->pld_slicw.bits.c3 = 0;
 704                         j->pld_slicw.bits.b2en = 1;
 705                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 706                         fRetVal = TRUE;
 707                         break;
 708                 case PLD_SLIC_STATE_ACTIVE:
 709                         j->pld_slicw.bits.c1 = 0;
 710                         j->pld_slicw.bits.c2 = 1;
 711                         j->pld_slicw.bits.c3 = 0;
 712                         j->pld_slicw.bits.b2en = 0;
 713                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 714                         fRetVal = TRUE;
 715                         break;
 716                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 717
 718                         j->pld_slicw.bits.c1 = 1;
 719                         j->pld_slicw.bits.c2 = 1;
 720                         j->pld_slicw.bits.c3 = 0;
 721                         j->pld_slicw.bits.b2en = 0;
 722                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 723                         fRetVal = TRUE;
 724                         break;
 725                 case PLD_SLIC_STATE_TIPOPEN:
 726                         j->pld_slicw.bits.c1 = 0;
 727                         j->pld_slicw.bits.c2 = 0;
 728                         j->pld_slicw.bits.c3 = 1;
 729                         j->pld_slicw.bits.b2en = 0;
 730                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 731                         fRetVal = TRUE;
 732                         break;
 733                 case PLD_SLIC_STATE_STANDBY:
 734                         j->pld_slicw.bits.c1 = 1;
 735                         j->pld_slicw.bits.c2 = 0;
 736                         j->pld_slicw.bits.c3 = 1;
 737                         j->pld_slicw.bits.b2en = 1;
 738                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 739                         fRetVal = TRUE;
 740                         break;
 741                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 742
 743                         j->pld_slicw.bits.c1 = 0;
 744                         j->pld_slicw.bits.c2 = 1;
 745                         j->pld_slicw.bits.c3 = 1;
 746                         j->pld_slicw.bits.b2en = 0;
 747                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 748                         fRetVal = TRUE;
 749                         break;
 750                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 751
 752                         j->pld_slicw.bits.c1 = 1;
 753                         j->pld_slicw.bits.c2 = 1;
 754                         j->pld_slicw.bits.c3 = 1;
 755                         j->pld_slicw.bits.b2en = 0;
 756                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 757                         fRetVal = TRUE;
 758                         break;
 759                 default:
 760                         fRetVal = FALSE;
 761                         break;
 762                 }
 763         }
 764
 765         return fRetVal;
 766 }
 767
 768 static int ixj_wink(IXJ *j)
 769 {
 770         BYTE slicnow;
 771
 772         slicnow = SLIC_GetState(j);
 773
 774         j->pots_winkstart = jiffies;
 775         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 776
 777         msleep(jiffies_to_msecs(j->winktime));
 778
 779         SLIC_SetState(slicnow, j);
 780         return 0;
 781 }
 782
 783 static void ixj_init_timer(IXJ *j)
 784 {
 785         init_timer(&j->timer);
 786         j->timer.function = ixj_timeout;
 787         j->timer.data = (unsigned long)j;
 788 }
 789
 790 static void ixj_add_timer(IXJ *j)
 791 {
 792         j->timer.expires = jiffies + (hertz / samplerate);
 793         add_timer(&j->timer);
 794 }
 795
 796 static void ixj_tone_timeout(IXJ *j)
 797 {
 798         IXJ_TONE ti;
 799
 800         j->tone_state++;
 801         if (j->tone_state == 3) {
 802                 j->tone_state = 0;
 803                 if (j->cadence_t) {
 804                         j->tone_cadence_state++;
 805                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 806                                 switch (j->cadence_t->termination) {
 807                                 case PLAY_ONCE:
 808                                         ixj_cpt_stop(j);
 809                                         break;
 810                                 case REPEAT_LAST_ELEMENT:
 811                                         j->tone_cadence_state--;
 812                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 813                                         break;
 814                                 case REPEAT_ALL:
 815                                         j->tone_cadence_state = 0;
 816                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 817                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 818                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 819                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 820                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 821                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 822                                                 ixj_init_tone(j, &ti);
 823                                         }
 824                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 825                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 826                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 827                                         break;
 828                                 }
 829                         } else {
 830                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 831                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 832                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 833                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 834                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 835                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 836                                         ixj_init_tone(j, &ti);
 837                                 }
 838                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 839                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 840                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 841                         }
 842                 }
 843         }
 844 }
 845
 846 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 847 {
 848         if(j->ixj_signals[event]) {
 849                 if(ixjdebug & 0x0100)
 850                         printk("Sending signal for event %d\n", event);
 851                         /* Send apps notice of change */
 852                 /* see config.h for macro definition */
 853                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 854         }
 855 }
 856
 857 static void ixj_pstn_state(IXJ *j)
 858 {
 859         int var;
 860         union XOPXR0 XR0, daaint;
 861
 862         var = 10;
 863
 864         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 865         daaint.reg = 0;
 866         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 867
 868         j->pld_scrr.byte = inb_p(j->XILINXbase);
 869         if (j->pld_scrr.bits.daaflag) {
 870                 daa_int_read(j);
 871                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 872                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 873                                 daaint.bitreg.RING = 1;
 874                                 if(ixjdebug & 0x0008) {
 875                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 876                                 }
 877                         } else {
 878                                 daa_set_mode(j, SOP_PU_RESET);
 879                         }
 880                 }
 881                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 882                         daaint.bitreg.Caller_ID = 1;
 883                         j->pstn_cid_intr = 1;
 884                         j->pstn_cid_received = jiffies;
 885                         if(ixjdebug & 0x0008) {
 886                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 887                         }
 888                 }
 889                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 890                         daaint.bitreg.Cadence = 1;
 891                         if(ixjdebug & 0x0008) {
 892                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 893                         }
 894                 }
 895                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 896                         daaint.bitreg.VDD_OK = 1;
 897                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 898                 }
 899         }
 900         daa_CR_read(j, 1);
 901         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)) {
 902                 daaint.bitreg.RMR = 1;
 903                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 904                 if(ixjdebug & 0x0008) {
 905                         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);
 906                 }
 907                 j->pstn_prev_rmr = j->pstn_last_rmr;
 908                 j->pstn_last_rmr = jiffies;
 909         }
 910         switch(j->daa_mode) {
 911                 case SOP_PU_SLEEP:
 912                         if (daaint.bitreg.RING) {
 913                                 if (!j->flags.pstn_ringing) {
 914                                         if (j->daa_mode != SOP_PU_RINGING) {
 915                                                 j->pstn_ring_int = jiffies;
 916                                                 daa_set_mode(j, SOP_PU_RINGING);
 917                                         }
 918                                 }
 919                         }
 920                         break;
 921                 case SOP_PU_RINGING:
 922                         if (daaint.bitreg.RMR) {
 923                                 if (ixjdebug & 0x0008) {
 924                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 925                                 }
 926                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 927                                         j->flags.pstn_rmr = 1;
 928                                         j->pstn_ring_start = jiffies;
 929                                         j->pstn_ring_stop = 0;
 930                                         j->ex.bits.pstn_ring = 0;
 931                                         if (j->cadence_f[4].state == 0) {
 932                                                 j->cadence_f[4].state = 1;
 933                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 934                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 935                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 936                                         } else if (j->cadence_f[4].state == 2) {
 937                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 938                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 939                                                         if (j->cadence_f[4].on2) {
 940                                                                 j->cadence_f[4].state = 3;
 941                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 942                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 943                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 944                                                         } else {
 945                                                                 j->cadence_f[4].state = 7;
 946                                                         }
 947                                                 } else {
 948                                                         if (ixjdebug & 0x0008) {
 949                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 950                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 951                                                                                 j->cadence_f[4].off1);
 952                                                         }
 953                                                         j->cadence_f[4].state = 0;
 954                                                 }
 955                                         } else if (j->cadence_f[4].state == 4) {
 956                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 957                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 958                                                         if (j->cadence_f[4].on3) {
 959                                                                 j->cadence_f[4].state = 5;
 960                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 961                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 962                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 963                                                         } else {
 964                                                                 j->cadence_f[4].state = 7;
 965                                                         }
 966                                                 } else {
 967                                                         if (ixjdebug & 0x0008) {
 968                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 969                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 970                                                                                 j->cadence_f[4].off2);
 971                                                         }
 972                                                         j->cadence_f[4].state = 0;
 973                                                 }
 974                                         } else if (j->cadence_f[4].state == 6) {
 975                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 976                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 977                                                         j->cadence_f[4].state = 7;
 978                                                 } else {
 979                                                         if (ixjdebug & 0x0008) {
 980                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 981                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 982                                                                                 j->cadence_f[4].off3);
 983                                                         }
 984                                                         j->cadence_f[4].state = 0;
 985                                                 }
 986                                         } else {
 987                                                 j->cadence_f[4].state = 0;
 988                                         }
 989                                 } else {                                /* Falling edge of RMR */
 990                                         j->pstn_ring_start = 0;
 991                                         j->pstn_ring_stop = jiffies;
 992                                         if (j->cadence_f[4].state == 1) {
 993                                                 if(!j->cadence_f[4].on1) {
 994                                                         j->cadence_f[4].state = 7;
 995                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
 996                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
 997                                                         if (j->cadence_f[4].off1) {
 998                                                                 j->cadence_f[4].state = 2;
 999                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1000                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1001                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1002                                                         } else {
1003                                                                 j->cadence_f[4].state = 7;
1004                                                         }
1005                                                 } else {
1006                                                         if (ixjdebug & 0x0008) {
1007                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1008                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1009                                                                                 j->cadence_f[4].on1);
1010                                                         }
1011                                                         j->cadence_f[4].state = 0;
1012                                                 }
1013                                         } else if (j->cadence_f[4].state == 3) {
1014                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1015                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1016                                                         if (j->cadence_f[4].off2) {
1017                                                                 j->cadence_f[4].state = 4;
1018                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1019                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1020                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1021                                                         } else {
1022                                                                 j->cadence_f[4].state = 7;
1023                                                         }
1024                                                 } else {
1025                                                         if (ixjdebug & 0x0008) {
1026                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1027                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1028                                                                                 j->cadence_f[4].on2);
1029                                                         }
1030                                                         j->cadence_f[4].state = 0;
1031                                                 }
1032                                         } else if (j->cadence_f[4].state == 5) {
1033                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1034                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1035                                                         if (j->cadence_f[4].off3) {
1036                                                                 j->cadence_f[4].state = 6;
1037                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1038                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1039                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1040                                                         } else {
1041                                                                 j->cadence_f[4].state = 7;
1042                                                         }
1043                                                 } else {
1044                                                         j->cadence_f[4].state = 0;
1045                                                 }
1046                                         } else {
1047                                                 if (ixjdebug & 0x0008) {
1048                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1049                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1050                                                                         j->cadence_f[4].on3);
1051                                                 }
1052                                                 j->cadence_f[4].state = 0;
1053                                         }
1054                                 }
1055                                 if (ixjdebug & 0x0010) {
1056                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1057                                 }
1058                                 if (ixjdebug & 0x0010) {
1059                                         switch(j->cadence_f[4].state) {
1060                                                 case 1:
1061                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1062                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1063                                                         break;
1064                                                 case 2:
1065                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1066                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1067                                                         break;
1068                                                 case 3:
1069                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1071                                                         break;
1072                                                 case 4:
1073                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1075                                                         break;
1076                                                 case 5:
1077                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1079                                                         break;
1080                                                 case 6:
1081                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1083                                                         break;
1084                                         }
1085                                 }
1086                         }
1087                         if (j->cadence_f[4].state == 7) {
1088                                 j->cadence_f[4].state = 0;
1089                                 j->pstn_ring_stop = jiffies;
1090                                 j->ex.bits.pstn_ring = 1;
1091                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1092                                 if(ixjdebug & 0x0008) {
1093                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1094                                 }
1095                         }
1096                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1097                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1098                                 if(ixjdebug & 0x0008) {
1099                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1100                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1101                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1102                                 }
1103                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1104                                 daa_set_mode(j, SOP_PU_SLEEP);
1105                         }
1106                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1107                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1108                                 ixj_daa_cid_read(j);
1109                                 j->ex.bits.caller_id = 1;
1110                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1111                                 j->pstn_cid_intr = 0;
1112                         }
1113                         if (daaint.bitreg.Cadence) {
1114                                 if(ixjdebug & 0x0008) {
1115                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1116                                 }
1117                                 daa_set_mode(j, SOP_PU_SLEEP);
1118                                 j->ex.bits.pstn_ring = 0;
1119                         }
1120                         break;
1121                 case SOP_PU_CONVERSATION:
1122                         if (daaint.bitreg.VDD_OK) {
1123                                 if(!daaint.bitreg.SI_0) {
1124                                         if (!j->pstn_winkstart) {
1125                                                 if(ixjdebug & 0x0008) {
1126                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1127                                                 }
1128                                                 j->pstn_winkstart = jiffies;
1129                                         }
1130                                 } else {
1131                                         if (j->pstn_winkstart) {
1132                                                 if(ixjdebug & 0x0008) {
1133                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1134                                                 }
1135                                                 j->pstn_winkstart = 0;
1136                                         }
1137                                 }
1138                         }
1139                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1140                                 if(ixjdebug & 0x0008) {
1141                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1142                                 }
1143                                 daa_set_mode(j, SOP_PU_SLEEP);
1144                                 j->pstn_winkstart = 0;
1145                                 j->ex.bits.pstn_wink = 1;
1146                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1147                         }
1148                         break;
1149         }
1150 }
1151
1152 static void ixj_timeout(unsigned long ptr)
1153 {
1154         int board;
1155         unsigned long jifon;
1156         IXJ *j = (IXJ *)ptr;
1157         board = j->board;
1158
1159         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1160                 ixj_perfmon(j->timerchecks);
1161                 j->hookstate = ixj_hookstate(j);
1162                 if (j->tone_state) {
1163                         if (!(j->hookstate)) {
1164                                 ixj_cpt_stop(j);
1165                                 if (j->m_hook) {
1166                                         j->m_hook = 0;
1167                                         j->ex.bits.hookstate = 1;
1168                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1169                                 }
1170                                 clear_bit(board, &j->busyflags);
1171                                 ixj_add_timer(j);
1172                                 return;
1173                         }
1174                         if (j->tone_state == 1)
1175                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1176                         else
1177                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1178                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1179                                 if (j->tone_state == 1) {
1180                                         ixj_play_tone(j, j->tone_index);
1181                                         if (j->dsp.low == 0x20) {
1182                                                 clear_bit(board, &j->busyflags);
1183                                                 ixj_add_timer(j);
1184                                                 return;
1185                                         }
1186                                 } else {
1187                                         ixj_play_tone(j, 0);
1188                                         if (j->dsp.low == 0x20) {
1189                                                 clear_bit(board, &j->busyflags);
1190                                                 ixj_add_timer(j);
1191                                                 return;
1192                                         }
1193                                 }
1194                         } else {
1195                                 ixj_tone_timeout(j);
1196                                 if (j->flags.dialtone) {
1197                                         ixj_dialtone(j);
1198                                 }
1199                                 if (j->flags.busytone) {
1200                                         ixj_busytone(j);
1201                                         if (j->dsp.low == 0x20) {
1202                                                 clear_bit(board, &j->busyflags);
1203                                                 ixj_add_timer(j);
1204                                                 return;
1205                                         }
1206                                 }
1207                                 if (j->flags.ringback) {
1208                                         ixj_ringback(j);
1209                                         if (j->dsp.low == 0x20) {
1210                                                 clear_bit(board, &j->busyflags);
1211                                                 ixj_add_timer(j);
1212                                                 return;
1213                                         }
1214                                 }
1215                                 if (!j->tone_state) {
1216                                         ixj_cpt_stop(j);
1217                                 }
1218                         }
1219                 }
1220                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1221                         if (IsRxReady(j)) {
1222                                 ixj_read_frame(j);
1223                         }
1224                         if (IsTxReady(j)) {
1225                                 ixj_write_frame(j);
1226                         }
1227                 }
1228                 if (j->flags.cringing) {
1229                         if (j->hookstate & 1) {
1230                                 j->flags.cringing = 0;
1231                                 ixj_ring_off(j);
1232                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1233                                 switch(j->cadence_f[5].state) {
1234                                         case 0:
1235                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1236                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1237                                                         if(ixjdebug & 0x0004) {
1238                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1239                                                         }
1240                                                         ixj_ring_on(j);
1241                                                 }
1242                                                 j->cadence_f[5].state = 1;
1243                                                 break;
1244                                         case 1:
1245                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1246                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1247                                                         if(ixjdebug & 0x0004) {
1248                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1249                                                         }
1250                                                         ixj_ring_off(j);
1251                                                         j->cadence_f[5].state = 2;
1252                                                 }
1253                                                 break;
1254                                         case 2:
1255                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1256                                                         if(ixjdebug & 0x0004) {
1257                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1258                                                         }
1259                                                         ixj_ring_on(j);
1260                                                         if (j->cadence_f[5].on2) {
1261                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1262                                                                 j->cadence_f[5].state = 3;
1263                                                         } else {
1264                                                                 j->cadence_f[5].state = 7;
1265                                                         }
1266                                                 }
1267                                                 break;
1268                                         case 3:
1269                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1270                                                         if(ixjdebug & 0x0004) {
1271                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1272                                                         }
1273                                                         ixj_ring_off(j);
1274                                                         if (j->cadence_f[5].off2) {
1275                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1276                                                                 j->cadence_f[5].state = 4;
1277                                                         } else {
1278                                                                 j->cadence_f[5].state = 7;
1279                                                         }
1280                                                 }
1281                                                 break;
1282                                         case 4:
1283                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1284                                                         if(ixjdebug & 0x0004) {
1285                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1286                                                         }
1287                                                         ixj_ring_on(j);
1288                                                         if (j->cadence_f[5].on3) {
1289                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1290                                                                 j->cadence_f[5].state = 5;
1291                                                         } else {
1292                                                                 j->cadence_f[5].state = 7;
1293                                                         }
1294                                                 }
1295                                                 break;
1296                                         case 5:
1297                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1298                                                         if(ixjdebug & 0x0004) {
1299                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1300                                                         }
1301                                                         ixj_ring_off(j);
1302                                                         if (j->cadence_f[5].off3) {
1303                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1304                                                                 j->cadence_f[5].state = 6;
1305                                                         } else {
1306                                                                 j->cadence_f[5].state = 7;
1307                                                         }
1308                                                 }
1309                                                 break;
1310                                         case 6:
1311                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1312                                                         if(ixjdebug & 0x0004) {
1313                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1314                                                         }
1315                                                         j->cadence_f[5].state = 7;
1316                                                 }
1317                                                 break;
1318                                         case 7:
1319                                                 if(ixjdebug & 0x0004) {
1320                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321                                                 }
1322                                                 j->flags.cidring = 1;
1323                                                 j->cadence_f[5].state = 0;
1324                                                 break;
1325                                 }
1326                                 if (j->flags.cidring && !j->flags.cidsent) {
1327                                         j->flags.cidsent = 1;
1328                                         if(j->fskdcnt) {
1329                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1330                                                 ixj_pre_cid(j);
1331                                         }
1332                                         j->flags.cidring = 0;
1333                                 }
1334                                 clear_bit(board, &j->busyflags);
1335                                 ixj_add_timer(j);
1336                                 return;
1337                         } else {
1338                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1339                                         if (j->flags.cidring && !j->flags.cidsent) {
1340                                                 j->flags.cidsent = 1;
1341                                                 if(j->fskdcnt) {
1342                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1343                                                         ixj_pre_cid(j);
1344                                                 }
1345                                                 j->flags.cidring = 0;
1346                                         }
1347                                         j->ring_cadence_t--;
1348                                         if (j->ring_cadence_t == -1)
1349                                                 j->ring_cadence_t = 15;
1350                                         j->ring_cadence_jif = jiffies;
1351
1352                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1353                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1354                                                         j->flags.firstring = 1;
1355                                                 else
1356                                                         ixj_ring_on(j);
1357                                         } else {
1358                                                 ixj_ring_off(j);
1359                                                 if(!j->flags.cidsent)
1360                                                         j->flags.cidring = 1;
1361                                         }
1362                                 }
1363                                 clear_bit(board, &j->busyflags);
1364                                 ixj_add_timer(j);
1365                                 return;
1366                         }
1367                 }
1368                 if (!j->flags.ringing) {
1369                         if (j->hookstate) { /* & 1) { */
1370                                 if (j->dsp.low != 0x20 &&
1371                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1372                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1373                                 }
1374                                 LineMonitor(j);
1375                                 read_filters(j);
1376                                 ixj_WriteDSPCommand(0x511B, j);
1377                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1378                                 if (!j->m_hook && (j->hookstate & 1)) {
1379                                         j->m_hook = j->ex.bits.hookstate = 1;
1380                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1381                                 }
1382                         } else {
1383                                 if (j->ex.bits.dtmf_ready) {
1384                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1385                                 }
1386                                 if (j->m_hook) {
1387                                         j->m_hook = 0;
1388                                         j->ex.bits.hookstate = 1;
1389                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1390                                 }
1391                         }
1392                 }
1393                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1394                         ixj_pstn_state(j);
1395                 }
1396                 if (j->ex.bytes) {
1397                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1398                 }
1399                 clear_bit(board, &j->busyflags);
1400         }
1401         ixj_add_timer(j);
1402 }
1403
1404 static int ixj_status_wait(IXJ *j)
1405 {
1406         unsigned long jif;
1407
1408         jif = jiffies + ((60 * hertz) / 100);
1409         while (!IsStatusReady(j)) {
1410                 ixj_perfmon(j->statuswait);
1411                 if (time_after(jiffies, jif)) {
1412                         ixj_perfmon(j->statuswaitfail);
1413                         return -1;
1414                 }
1415         }
1416         return 0;
1417 }
1418
1419 static int ixj_PCcontrol_wait(IXJ *j)
1420 {
1421         unsigned long jif;
1422
1423         jif = jiffies + ((60 * hertz) / 100);
1424         while (!IsPCControlReady(j)) {
1425                 ixj_perfmon(j->pcontrolwait);
1426                 if (time_after(jiffies, jif)) {
1427                         ixj_perfmon(j->pcontrolwaitfail);
1428                         return -1;
1429                 }
1430         }
1431         return 0;
1432 }
1433
1434 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1435 {
1436         BYTES bytes;
1437         unsigned long jif;
1438
1439         atomic_inc(&j->DSPWrite);
1440         if(atomic_read(&j->DSPWrite) > 1) {
1441                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1442                 return -1;
1443         }
1444         bytes.high = (cmd & 0xFF00) >> 8;
1445         bytes.low = cmd & 0x00FF;
1446         jif = jiffies + ((60 * hertz) / 100);
1447         while (!IsControlReady(j)) {
1448                 ixj_perfmon(j->iscontrolready);
1449                 if (time_after(jiffies, jif)) {
1450                         ixj_perfmon(j->iscontrolreadyfail);
1451                         atomic_dec(&j->DSPWrite);
1452                         if(atomic_read(&j->DSPWrite) > 0) {
1453                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1454                                 while(atomic_read(&j->DSPWrite) > 0) {
1455                                         atomic_dec(&j->DSPWrite);
1456                                 }
1457                         }
1458                         return -1;
1459                 }
1460         }
1461         outb(bytes.low, j->DSPbase + 6);
1462         outb(bytes.high, j->DSPbase + 7);
1463
1464         if (ixj_status_wait(j)) {
1465                 j->ssr.low = 0xFF;
1466                 j->ssr.high = 0xFF;
1467                 atomic_dec(&j->DSPWrite);
1468                 if(atomic_read(&j->DSPWrite) > 0) {
1469                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1470                         while(atomic_read(&j->DSPWrite) > 0) {
1471                                 atomic_dec(&j->DSPWrite);
1472                         }
1473                 }
1474                 return -1;
1475         }
1476 /* Read Software Status Register */
1477         j->ssr.low = inb_p(j->DSPbase + 2);
1478         j->ssr.high = inb_p(j->DSPbase + 3);
1479         atomic_dec(&j->DSPWrite);
1480         if(atomic_read(&j->DSPWrite) > 0) {
1481                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1482                 while(atomic_read(&j->DSPWrite) > 0) {
1483                         atomic_dec(&j->DSPWrite);
1484                 }
1485         }
1486         return 0;
1487 }
1488
1489 /***************************************************************************
1490 *
1491 *  General Purpose IO Register read routine
1492 *
1493 ***************************************************************************/
1494 static inline int ixj_gpio_read(IXJ *j)
1495 {
1496         if (ixj_WriteDSPCommand(0x5143, j))
1497                 return -1;
1498
1499         j->gpio.bytes.low = j->ssr.low;
1500         j->gpio.bytes.high = j->ssr.high;
1501
1502         return 0;
1503 }
1504
1505 static inline void LED_SetState(int state, IXJ *j)
1506 {
1507         if (j->cardtype == QTI_LINEJACK) {
1508                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1509                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1510                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1511                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1512
1513                 outb(j->pld_scrw.byte, j->XILINXbase);
1514         }
1515 }
1516
1517 /*********************************************************************
1518 *  GPIO Pins are configured as follows on the Quicknet Internet
1519 *  PhoneJACK Telephony Cards
1520 *
1521 * POTS Select        GPIO_6=0 GPIO_7=0
1522 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1523 * Handset Select     GPIO_6=1 GPIO_7=0
1524 *
1525 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1526 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1527 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1528 *
1529 * Hook Switch changes reported on GPIO_3
1530 *********************************************************************/
1531 static int ixj_set_port(IXJ *j, int arg)
1532 {
1533         if (j->cardtype == QTI_PHONEJACK_LITE) {
1534                 if (arg != PORT_POTS)
1535                         return 10;
1536                 else
1537                         return 0;
1538         }
1539         switch (arg) {
1540         case PORT_POTS:
1541                 j->port = PORT_POTS;
1542                 switch (j->cardtype) {
1543                 case QTI_PHONECARD:
1544                         if (j->flags.pcmciasct == 1)
1545                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1546                         else
1547                                 return 11;
1548                         break;
1549                 case QTI_PHONEJACK_PCI:
1550                         j->pld_slicw.pcib.mic = 0;
1551                         j->pld_slicw.pcib.spk = 0;
1552                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1553                         break;
1554                 case QTI_LINEJACK:
1555                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1556                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1557                                                                            Software Control Register */
1558                                 return 2;
1559                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1560
1561                         outb(j->pld_scrw.byte, j->XILINXbase);
1562                         j->pld_clock.byte = 0;
1563                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1564                         j->pld_slicw.bits.rly1 = 1;
1565                         j->pld_slicw.bits.spken = 0;
1566                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1567                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1568                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1569                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1570                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1571                         ixj_mixer(0x0E80, j);   /*Mic mute */
1572                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1573                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1574                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1575                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1576 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1577                         break;
1578                 case QTI_PHONEJACK:
1579                         j->gpio.bytes.high = 0x0B;
1580                         j->gpio.bits.gpio6 = 0;
1581                         j->gpio.bits.gpio7 = 0;
1582                         ixj_WriteDSPCommand(j->gpio.word, j);
1583                         break;
1584                 }
1585                 break;
1586         case PORT_PSTN:
1587                 if (j->cardtype == QTI_LINEJACK) {
1588                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1589
1590                         j->pld_slicw.bits.rly3 = 0;
1591                         j->pld_slicw.bits.rly1 = 1;
1592                         j->pld_slicw.bits.spken = 0;
1593                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1594                         j->port = PORT_PSTN;
1595                 } else {
1596                         return 4;
1597                 }
1598                 break;
1599         case PORT_SPEAKER:
1600                 j->port = PORT_SPEAKER;
1601                 switch (j->cardtype) {
1602                 case QTI_PHONECARD:
1603                         if (j->flags.pcmciasct) {
1604                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1605                         }
1606                         break;
1607                 case QTI_PHONEJACK_PCI:
1608                         j->pld_slicw.pcib.mic = 1;
1609                         j->pld_slicw.pcib.spk = 1;
1610                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1611                         break;
1612                 case QTI_LINEJACK:
1613                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1614                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1615                                                                            Software Control Register */
1616                                 return 2;
1617                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1618
1619                         outb(j->pld_scrw.byte, j->XILINXbase);
1620                         j->pld_clock.byte = 0;
1621                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1622                         j->pld_slicw.bits.rly1 = 1;
1623                         j->pld_slicw.bits.spken = 1;
1624                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1625                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1626                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1627                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1628                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1629                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1630                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1631                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1632                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1633                         break;
1634                 case QTI_PHONEJACK:
1635                         j->gpio.bytes.high = 0x0B;
1636                         j->gpio.bits.gpio6 = 0;
1637                         j->gpio.bits.gpio7 = 1;
1638                         ixj_WriteDSPCommand(j->gpio.word, j);
1639                         break;
1640                 }
1641                 break;
1642         case PORT_HANDSET:
1643                 if (j->cardtype != QTI_PHONEJACK) {
1644                         return 5;
1645                 } else {
1646                         j->gpio.bytes.high = 0x0B;
1647                         j->gpio.bits.gpio6 = 1;
1648                         j->gpio.bits.gpio7 = 0;
1649                         ixj_WriteDSPCommand(j->gpio.word, j);
1650                         j->port = PORT_HANDSET;
1651                 }
1652                 break;
1653         default:
1654                 return 6;
1655                 break;
1656         }
1657         return 0;
1658 }
1659
1660 static int ixj_set_pots(IXJ *j, int arg)
1661 {
1662         if (j->cardtype == QTI_LINEJACK) {
1663                 if (arg) {
1664                         if (j->port == PORT_PSTN) {
1665                                 j->pld_slicw.bits.rly1 = 0;
1666                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1667                                 j->flags.pots_pstn = 1;
1668                                 return 1;
1669                         } else {
1670                                 j->flags.pots_pstn = 0;
1671                                 return 0;
1672                         }
1673                 } else {
1674                         j->pld_slicw.bits.rly1 = 1;
1675                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1676                         j->flags.pots_pstn = 0;
1677                         return 1;
1678                 }
1679         } else {
1680                 return 0;
1681         }
1682 }
1683
1684 static void ixj_ring_on(IXJ *j)
1685 {
1686         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1687          {
1688                 if (ixjdebug & 0x0004)
1689                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1690
1691                 j->gpio.bytes.high = 0x0B;
1692                 j->gpio.bytes.low = 0x00;
1693                 j->gpio.bits.gpio1 = 1;
1694                 j->gpio.bits.gpio2 = 1;
1695                 j->gpio.bits.gpio5 = 0;
1696                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1697         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1698         {
1699                 if (ixjdebug & 0x0004)
1700                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1701
1702                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1703         }
1704 }
1705
1706 static int ixj_siadc(IXJ *j, int val)
1707 {
1708         if(j->cardtype == QTI_PHONECARD){
1709                 if(j->flags.pcmciascp){
1710                         if(val == -1)
1711                                 return j->siadc.bits.rxg;
1712
1713                         if(val < 0 || val > 0x1F)
1714                                 return -1;
1715
1716                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1717                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1718                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1719                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1720                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1721                         j->psccr.bits.dev = 0;
1722                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1723                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1724                         ixj_PCcontrol_wait(j);
1725                         return j->siadc.bits.rxg;
1726                 }
1727         }
1728         return -1;
1729 }
1730
1731 static int ixj_sidac(IXJ *j, int val)
1732 {
1733         if(j->cardtype == QTI_PHONECARD){
1734                 if(j->flags.pcmciascp){
1735                         if(val == -1)
1736                                 return j->sidac.bits.txg;
1737
1738                         if(val < 0 || val > 0x1F)
1739                                 return -1;
1740
1741                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1742                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1743                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1744                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1745                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1746                         j->psccr.bits.dev = 0;
1747                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1748                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1749                         ixj_PCcontrol_wait(j);
1750                         return j->sidac.bits.txg;
1751                 }
1752         }
1753         return -1;
1754 }
1755
1756 static int ixj_pcmcia_cable_check(IXJ *j)
1757 {
1758         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1759         if (!j->flags.pcmciastate) {
1760                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1761                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1762                         j->flags.pcmciastate = 4;
1763                         return 0;
1764                 }
1765                 if (j->pccr1.bits.ed) {
1766                         j->pccr1.bits.ed = 0;
1767                         j->psccr.bits.dev = 3;
1768                         j->psccr.bits.rw = 1;
1769                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1770                         ixj_PCcontrol_wait(j);
1771                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1772                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1773                         j->psccr.bits.dev = 3;
1774                         j->psccr.bits.rw = 0;
1775                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1776                         ixj_PCcontrol_wait(j);
1777                         return j->pslic.bits.led2 ? 1 : 0;
1778                 } else if (j->flags.pcmciasct) {
1779                         return j->r_hook;
1780                 } else {
1781                         return 1;
1782                 }
1783         } else if (j->flags.pcmciastate == 4) {
1784                 if (!j->pccr1.bits.drf) {
1785                         j->flags.pcmciastate = 3;
1786                 }
1787                 return 0;
1788         } else if (j->flags.pcmciastate == 3) {
1789                 j->pccr2.bits.pwr = 0;
1790                 j->pccr2.bits.rstc = 1;
1791                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1792                 j->checkwait = jiffies + (hertz * 2);
1793                 j->flags.incheck = 1;
1794                 j->flags.pcmciastate = 2;
1795                 return 0;
1796         } else if (j->flags.pcmciastate == 2) {
1797                 if (j->flags.incheck) {
1798                         if (time_before(jiffies, j->checkwait)) {
1799                                 return 0;
1800                         } else {
1801                                 j->flags.incheck = 0;
1802                         }
1803                 }
1804                 j->pccr2.bits.pwr = 0;
1805                 j->pccr2.bits.rstc = 0;
1806                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1807                 j->flags.pcmciastate = 1;
1808                 return 0;
1809         } else if (j->flags.pcmciastate == 1) {
1810                 j->flags.pcmciastate = 0;
1811                 if (!j->pccr1.bits.drf) {
1812                         j->psccr.bits.dev = 3;
1813                         j->psccr.bits.rw = 1;
1814                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1815                         ixj_PCcontrol_wait(j);
1816                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1817
1818                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1819
1820                         if (j->flags.pcmciasct == 3) {
1821                                 j->flags.pcmciastate = 4;
1822                                 return 0;
1823                         } else if (j->flags.pcmciasct == 0) {
1824                                 j->pccr2.bits.pwr = 1;
1825                                 j->pccr2.bits.rstc = 0;
1826                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1827                                 j->port = PORT_SPEAKER;
1828                         } else {
1829                                 j->port = PORT_POTS;
1830                         }
1831                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1832                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1833                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1834                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1835                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1836                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1837                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1838                         j->psccr.bits.dev = 0;
1839                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1840                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1841                         ixj_PCcontrol_wait(j);
1842
1843                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1844                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1845                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1846                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1847                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1848                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1849                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1850                         j->psccr.bits.dev = 0;
1851                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1852                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1853                         ixj_PCcontrol_wait(j);
1854
1855                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1856                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1857                         j->psccr.bits.dev = 0;
1858                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1859                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1860                         ixj_PCcontrol_wait(j);
1861
1862                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1863                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1864                         j->psccr.bits.dev = 0;
1865                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1866                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1867                         ixj_PCcontrol_wait(j);
1868
1869                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1870                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1871                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1872                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1873                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1874                         j->sirxg.bits.iir = 1;                          /* IIR */
1875                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1876                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1877                         j->psccr.bits.dev = 0;
1878                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1879                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1880                         ixj_PCcontrol_wait(j);
1881
1882                         ixj_siadc(j, 0x17);
1883                         ixj_sidac(j, 0x1D);
1884
1885                         j->siaatt.bits.sot = 0;
1886                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1887                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1888                         j->psccr.bits.dev = 0;
1889                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1890                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1891                         ixj_PCcontrol_wait(j);
1892
1893                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1894                                 j->psccr.byte = j->pslic.byte = 0;
1895                                 j->pslic.bits.powerdown = 1;
1896                                 j->psccr.bits.dev = 3;
1897                                 j->psccr.bits.rw = 0;
1898                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1899                                 ixj_PCcontrol_wait(j);
1900                         }
1901                 }
1902                 return 0;
1903         } else {
1904                 j->flags.pcmciascp = 0;
1905                 return 0;
1906         }
1907         return 0;
1908 }
1909
1910 static int ixj_hookstate(IXJ *j)
1911 {
1912         int fOffHook = 0;
1913
1914         switch (j->cardtype) {
1915         case QTI_PHONEJACK:
1916                 ixj_gpio_read(j);
1917                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1918                 break;
1919         case QTI_LINEJACK:
1920         case QTI_PHONEJACK_LITE:
1921         case QTI_PHONEJACK_PCI:
1922                 SLIC_GetState(j);
1923                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1924                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1925                         if(fOffHook != j->p_hook) {
1926                                 if(!j->checkwait) {
1927                                         j->checkwait = jiffies;
1928                                 }
1929                                 if(time_before(jiffies, j->checkwait + 2)) {
1930                                         fOffHook ^= 1;
1931                                 } else {
1932                                         j->checkwait = 0;
1933                                 }
1934                                 j->p_hook = fOffHook;
1935                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1936                         }
1937                 } else {
1938                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1939                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1940                                 if (j->flags.ringing || j->flags.cringing) {
1941                                         if (!in_interrupt()) {
1942                                                 msleep(20);
1943                                         }
1944                                         SLIC_GetState(j);
1945                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1946                                                 ixj_ring_on(j);
1947                                         }
1948                                 }
1949                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1950                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1951                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1952                                 } else
1953                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1954                         }
1955                 }
1956                 break;
1957         case QTI_PHONECARD:
1958                 fOffHook = ixj_pcmcia_cable_check(j);
1959                 break;
1960         }
1961         if (j->r_hook != fOffHook) {
1962                 j->r_hook = fOffHook;
1963                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1964                         j->ex.bits.hookstate = 1;
1965                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1966                 } else if (!fOffHook) {
1967                         j->flash_end = jiffies + ((60 * hertz) / 100);
1968                 }
1969         }
1970         if (fOffHook) {
1971                 if(time_before(jiffies, j->flash_end)) {
1972                         j->ex.bits.flash = 1;
1973                         j->flash_end = 0;
1974                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1975                 }
1976         } else {
1977                 if(time_before(jiffies, j->flash_end)) {
1978                         fOffHook = 1;
1979                 }
1980         }
1981
1982         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1983                 fOffHook |= 2;
1984
1985         if (j->port == PORT_SPEAKER) {
1986                 if(j->cardtype == QTI_PHONECARD) {
1987                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1988                                 fOffHook |= 2;
1989                         }
1990                 } else {
1991                         fOffHook |= 2;
1992                 }
1993         }
1994
1995         if (j->port == PORT_HANDSET)
1996                 fOffHook |= 2;
1997
1998         return fOffHook;
1999 }
2000
2001 static void ixj_ring_off(IXJ *j)
2002 {
2003         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2004          {
2005                 if (ixjdebug & 0x0004)
2006                         printk(KERN_INFO "IXJ Ring Off\n");
2007                 j->gpio.bytes.high = 0x0B;
2008                 j->gpio.bytes.low = 0x00;
2009                 j->gpio.bits.gpio1 = 0;
2010                 j->gpio.bits.gpio2 = 1;
2011                 j->gpio.bits.gpio5 = 0;
2012                 ixj_WriteDSPCommand(j->gpio.word, j);
2013         } else                  /* Internet LineJACK */
2014         {
2015                 if (ixjdebug & 0x0004)
2016                         printk(KERN_INFO "IXJ Ring Off\n");
2017
2018                 if(!j->flags.cidplay)
2019                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2020
2021                 SLIC_GetState(j);
2022         }
2023 }
2024
2025 static void ixj_ring_start(IXJ *j)
2026 {
2027         j->flags.cringing = 1;
2028         if (ixjdebug & 0x0004)
2029                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2030         if (ixj_hookstate(j) & 1) {
2031                 if (j->port == PORT_POTS)
2032                         ixj_ring_off(j);
2033                 j->flags.cringing = 0;
2034                 if (ixjdebug & 0x0004)
2035                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2036         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2037                 j->ring_cadence_jif = jiffies;
2038                 j->flags.cidsent = j->flags.cidring = 0;
2039                 j->cadence_f[5].state = 0;
2040                 if(j->cadence_f[5].on1)
2041                         ixj_ring_on(j);
2042         } else {
2043                 j->ring_cadence_jif = jiffies;
2044                 j->ring_cadence_t = 15;
2045                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2046                         ixj_ring_on(j);
2047                 } else {
2048                         ixj_ring_off(j);
2049                 }
2050                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2051         }
2052 }
2053
2054 static int ixj_ring(IXJ *j)
2055 {
2056         char cntr;
2057         unsigned long jif;
2058
2059         j->flags.ringing = 1;
2060         if (ixj_hookstate(j) & 1) {
2061                 ixj_ring_off(j);
2062                 j->flags.ringing = 0;
2063                 return 1;
2064         }
2065         for (cntr = 0; cntr < j->maxrings; cntr++) {
2066                 jif = jiffies + (1 * hertz);
2067                 ixj_ring_on(j);
2068                 while (time_before(jiffies, jif)) {
2069                         if (ixj_hookstate(j) & 1) {
2070                                 ixj_ring_off(j);
2071                                 j->flags.ringing = 0;
2072                                 return 1;
2073                         }
2074                         schedule_timeout_interruptible(1);
2075                         if (signal_pending(current))
2076                                 break;
2077                 }
2078                 jif = jiffies + (3 * hertz);
2079                 ixj_ring_off(j);
2080                 while (time_before(jiffies, jif)) {
2081                         if (ixj_hookstate(j) & 1) {
2082                                 msleep(10);
2083                                 if (ixj_hookstate(j) & 1) {
2084                                         j->flags.ringing = 0;
2085                                         return 1;
2086                                 }
2087                         }
2088                         schedule_timeout_interruptible(1);
2089                         if (signal_pending(current))
2090                                 break;
2091                 }
2092         }
2093         ixj_ring_off(j);
2094         j->flags.ringing = 0;
2095         return 0;
2096 }
2097
2098 static int ixj_open(struct phone_device *p, struct file *file_p)
2099 {
2100         IXJ *j = get_ixj(p->board);
2101         file_p->private_data = j;
2102
2103         if (!j->DSPbase)
2104                 return -ENODEV;
2105
2106         if (file_p->f_mode & FMODE_READ) {
2107                 if(!j->readers) {
2108                         j->readers++;
2109                 } else {
2110                         return -EBUSY;
2111                 }
2112         }
2113
2114         if (file_p->f_mode & FMODE_WRITE) {
2115                 if(!j->writers) {
2116                         j->writers++;
2117                 } else {
2118                         if (file_p->f_mode & FMODE_READ){
2119                                 j->readers--;
2120                         }
2121                         return -EBUSY;
2122                 }
2123         }
2124
2125         if (j->cardtype == QTI_PHONECARD) {
2126                 j->pslic.bits.powerdown = 0;
2127                 j->psccr.bits.dev = 3;
2128                 j->psccr.bits.rw = 0;
2129                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2130                 ixj_PCcontrol_wait(j);
2131         }
2132
2133         j->flags.cidplay = 0;
2134         j->flags.cidcw_ack = 0;
2135
2136         if (ixjdebug & 0x0002)
2137                 printk(KERN_INFO "Opening board %d\n", p->board);
2138
2139         j->framesread = j->frameswritten = 0;
2140         return 0;
2141 }
2142
2143 static int ixj_release(struct inode *inode, struct file *file_p)
2144 {
2145         IXJ_TONE ti;
2146         int cnt;
2147         IXJ *j = file_p->private_data;
2148         int board = j->p.board;
2149
2150         /*
2151          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2152          *    This is necessary to keep the DSP from locking up.
2153          */
2154         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2155                 schedule_timeout_interruptible(1);
2156         if (ixjdebug & 0x0002)
2157                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2158
2159         if (j->cardtype == QTI_PHONECARD)
2160                 ixj_set_port(j, PORT_SPEAKER);
2161         else
2162                 ixj_set_port(j, PORT_POTS);
2163
2164         aec_stop(j);
2165         ixj_play_stop(j);
2166         ixj_record_stop(j);
2167         set_play_volume(j, 0x100);
2168         set_rec_volume(j, 0x100);
2169         ixj_ring_off(j);
2170
2171         /* Restore the tone table to default settings. */
2172         ti.tone_index = 10;
2173         ti.gain0 = 1;
2174         ti.freq0 = hz941;
2175         ti.gain1 = 0;
2176         ti.freq1 = hz1209;
2177         ixj_init_tone(j, &ti);
2178         ti.tone_index = 11;
2179         ti.gain0 = 1;
2180         ti.freq0 = hz941;
2181         ti.gain1 = 0;
2182         ti.freq1 = hz1336;
2183         ixj_init_tone(j, &ti);
2184         ti.tone_index = 12;
2185         ti.gain0 = 1;
2186         ti.freq0 = hz941;
2187         ti.gain1 = 0;
2188         ti.freq1 = hz1477;
2189         ixj_init_tone(j, &ti);
2190         ti.tone_index = 13;
2191         ti.gain0 = 1;
2192         ti.freq0 = hz800;
2193         ti.gain1 = 0;
2194         ti.freq1 = 0;
2195         ixj_init_tone(j, &ti);
2196         ti.tone_index = 14;
2197         ti.gain0 = 1;
2198         ti.freq0 = hz1000;
2199         ti.gain1 = 0;
2200         ti.freq1 = 0;
2201         ixj_init_tone(j, &ti);
2202         ti.tone_index = 15;
2203         ti.gain0 = 1;
2204         ti.freq0 = hz1250;
2205         ti.gain1 = 0;
2206         ti.freq1 = 0;
2207         ixj_init_tone(j, &ti);
2208         ti.tone_index = 16;
2209         ti.gain0 = 1;
2210         ti.freq0 = hz950;
2211         ti.gain1 = 0;
2212         ti.freq1 = 0;
2213         ixj_init_tone(j, &ti);
2214         ti.tone_index = 17;
2215         ti.gain0 = 1;
2216         ti.freq0 = hz1100;
2217         ti.gain1 = 0;
2218         ti.freq1 = 0;
2219         ixj_init_tone(j, &ti);
2220         ti.tone_index = 18;
2221         ti.gain0 = 1;
2222         ti.freq0 = hz1400;
2223         ti.gain1 = 0;
2224         ti.freq1 = 0;
2225         ixj_init_tone(j, &ti);
2226         ti.tone_index = 19;
2227         ti.gain0 = 1;
2228         ti.freq0 = hz1500;
2229         ti.gain1 = 0;
2230         ti.freq1 = 0;
2231         ixj_init_tone(j, &ti);
2232         ti.tone_index = 20;
2233         ti.gain0 = 1;
2234         ti.freq0 = hz1600;
2235         ti.gain1 = 0;
2236         ti.freq1 = 0;
2237         ixj_init_tone(j, &ti);
2238         ti.tone_index = 21;
2239         ti.gain0 = 1;
2240         ti.freq0 = hz1800;
2241         ti.gain1 = 0;
2242         ti.freq1 = 0;
2243         ixj_init_tone(j, &ti);
2244         ti.tone_index = 22;
2245         ti.gain0 = 1;
2246         ti.freq0 = hz2100;
2247         ti.gain1 = 0;
2248         ti.freq1 = 0;
2249         ixj_init_tone(j, &ti);
2250         ti.tone_index = 23;
2251         ti.gain0 = 1;
2252         ti.freq0 = hz1300;
2253         ti.gain1 = 0;
2254         ti.freq1 = 0;
2255         ixj_init_tone(j, &ti);
2256         ti.tone_index = 24;
2257         ti.gain0 = 1;
2258         ti.freq0 = hz2450;
2259         ti.gain1 = 0;
2260         ti.freq1 = 0;
2261         ixj_init_tone(j, &ti);
2262         ti.tone_index = 25;
2263         ti.gain0 = 1;
2264         ti.freq0 = hz350;
2265         ti.gain1 = 0;
2266         ti.freq1 = hz440;
2267         ixj_init_tone(j, &ti);
2268         ti.tone_index = 26;
2269         ti.gain0 = 1;
2270         ti.freq0 = hz440;
2271         ti.gain1 = 0;
2272         ti.freq1 = hz480;
2273         ixj_init_tone(j, &ti);
2274         ti.tone_index = 27;
2275         ti.gain0 = 1;
2276         ti.freq0 = hz480;
2277         ti.gain1 = 0;
2278         ti.freq1 = hz620;
2279         ixj_init_tone(j, &ti);
2280
2281         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2282
2283         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2284
2285         j->ex.bits.dtmf_ready = 0;
2286         j->dtmf_state = 0;
2287         j->dtmf_wp = j->dtmf_rp = 0;
2288         j->rec_mode = j->play_mode = -1;
2289         j->flags.ringing = 0;
2290         j->maxrings = MAXRINGS;
2291         j->ring_cadence = USA_RING_CADENCE;
2292         if(j->cadence_f[5].enable) {
2293                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2294         }
2295         j->drybuffer = 0;
2296         j->winktime = 320;
2297         j->flags.dtmf_oob = 0;
2298         for (cnt = 0; cnt < 4; cnt++)
2299                 j->cadence_f[cnt].enable = 0;
2300
2301         idle(j);
2302
2303         if(j->cardtype == QTI_PHONECARD) {
2304                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2305         }
2306
2307         if (file_p->f_mode & FMODE_READ)
2308                 j->readers--;
2309         if (file_p->f_mode & FMODE_WRITE)
2310                 j->writers--;
2311
2312         if (j->read_buffer && !j->readers) {
2313                 kfree(j->read_buffer);
2314                 j->read_buffer = NULL;
2315                 j->read_buffer_size = 0;
2316         }
2317         if (j->write_buffer && !j->writers) {
2318                 kfree(j->write_buffer);
2319                 j->write_buffer = NULL;
2320                 j->write_buffer_size = 0;
2321         }
2322         j->rec_codec = j->play_codec = 0;
2323         j->rec_frame_size = j->play_frame_size = 0;
2324         j->flags.cidsent = j->flags.cidring = 0;
2325         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2326
2327         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2328                 ixj_set_port(j, PORT_PSTN);
2329                 daa_set_mode(j, SOP_PU_SLEEP);
2330                 ixj_set_pots(j, 1);
2331         }
2332         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2333
2334         /* Set up the default signals for events */
2335         for (cnt = 0; cnt < 35; cnt++)
2336                 j->ixj_signals[cnt] = SIGIO;
2337
2338         /* Set the excetion signal enable flags */
2339         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2340         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 =
2341         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;
2342
2343         file_p->private_data = NULL;
2344         clear_bit(board, &j->busyflags);
2345         return 0;
2346 }
2347
2348 static int read_filters(IXJ *j)
2349 {
2350         unsigned short fc, cnt, trg;
2351         int var;
2352
2353         trg = 0;
2354         if (ixj_WriteDSPCommand(0x5144, j)) {
2355                 if(ixjdebug & 0x0001) {
2356                         printk(KERN_INFO "Read Frame Counter failed!\n");
2357                 }
2358                 return -1;
2359         }
2360         fc = j->ssr.high << 8 | j->ssr.low;
2361         if (fc == j->frame_count)
2362                 return 1;
2363
2364         j->frame_count = fc;
2365
2366         if (j->dtmf_proc)
2367                 return 1;
2368
2369         var = 10;
2370
2371         for (cnt = 0; cnt < 4; cnt++) {
2372                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2373                         if(ixjdebug & 0x0001) {
2374                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2375                         }
2376                         return -1;
2377                 }
2378                 if (ixj_WriteDSPCommand(0x515C, j)) {
2379                         if(ixjdebug & 0x0001) {
2380                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2381                         }
2382                         return -1;
2383                 }
2384                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2385
2386                 if (j->cadence_f[cnt].enable) {
2387                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2388                                 if (j->cadence_f[cnt].state == 0) {
2389                                         j->cadence_f[cnt].state = 1;
2390                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2391                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2392                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2393                                 } else if (j->cadence_f[cnt].state == 2 &&
2394                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2395                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2396                                         if (j->cadence_f[cnt].on2) {
2397                                                 j->cadence_f[cnt].state = 3;
2398                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2399                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2400                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2401                                         } else {
2402                                                 j->cadence_f[cnt].state = 7;
2403                                         }
2404                                 } else if (j->cadence_f[cnt].state == 4 &&
2405                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2406                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2407                                         if (j->cadence_f[cnt].on3) {
2408                                                 j->cadence_f[cnt].state = 5;
2409                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2410                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2411                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2412                                         } else {
2413                                                 j->cadence_f[cnt].state = 7;
2414                                         }
2415                                 } else {
2416                                         j->cadence_f[cnt].state = 0;
2417                                 }
2418                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2419                                 if (j->cadence_f[cnt].state == 1) {
2420                                         if(!j->cadence_f[cnt].on1) {
2421                                                 j->cadence_f[cnt].state = 7;
2422                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2423                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2424                                                 if(j->cadence_f[cnt].off1) {
2425                                                         j->cadence_f[cnt].state = 2;
2426                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2427                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2428                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2429                                                 } else {
2430                                                         j->cadence_f[cnt].state = 7;
2431                                                 }
2432                                         } else {
2433                                                 j->cadence_f[cnt].state = 0;
2434                                         }
2435                                 } else if (j->cadence_f[cnt].state == 3) {
2436                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2437                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2438                                                 if(j->cadence_f[cnt].off2) {
2439                                                         j->cadence_f[cnt].state = 4;
2440                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2441                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2442                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2443                                                 } else {
2444                                                         j->cadence_f[cnt].state = 7;
2445                                                 }
2446                                         } else {
2447                                                 j->cadence_f[cnt].state = 0;
2448                                         }
2449                                 } else if (j->cadence_f[cnt].state == 5) {
2450                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2451                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2452                                                 if(j->cadence_f[cnt].off3) {
2453                                                         j->cadence_f[cnt].state = 6;
2454                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2455                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2456                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2457                                                 } else {
2458                                                         j->cadence_f[cnt].state = 7;
2459                                                 }
2460                                         } else {
2461                                                 j->cadence_f[cnt].state = 0;
2462                                         }
2463                                 } else {
2464                                         j->cadence_f[cnt].state = 0;
2465                                 }
2466                         } else {
2467                                 switch(j->cadence_f[cnt].state) {
2468                                         case 1:
2469                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2470                                                    !j->cadence_f[cnt].off1 &&
2471                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2472                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2473                                                         j->cadence_f[cnt].state = 7;
2474                                                 }
2475                                                 break;
2476                                         case 3:
2477                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2478                                                    !j->cadence_f[cnt].off2 &&
2479                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2480                                                         j->cadence_f[cnt].state = 7;
2481                                                 }
2482                                                 break;
2483                                         case 5:
2484                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2485                                                    !j->cadence_f[cnt].off3) {
2486                                                         j->cadence_f[cnt].state = 7;
2487                                                 }
2488                                                 break;
2489                                 }
2490                         }
2491
2492                         if (ixjdebug & 0x0040) {
2493                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2494                                 switch(j->cadence_f[cnt].state) {
2495                                         case 0:
2496                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2497                                                 break;
2498                                         case 1:
2499                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2500                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2501                                                 break;
2502                                         case 2:
2503                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2504                                                                                                                         j->cadence_f[cnt].off1max);
2505                                                 break;
2506                                         case 3:
2507                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2508                                                                                                                         j->cadence_f[cnt].on2max);
2509                                                 break;
2510                                         case 4:
2511                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2512                                                                                                                         j->cadence_f[cnt].off2max);
2513                                                 break;
2514                                         case 5:
2515                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2516                                                                                                                         j->cadence_f[cnt].on3max);
2517                                                 break;
2518                                         case 6:
2519                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2520                                                                                                                         j->cadence_f[cnt].off3max);
2521                                                 break;
2522                                 }
2523                         }
2524                 }
2525                 if (j->cadence_f[cnt].state == 7) {
2526                         j->cadence_f[cnt].state = 0;
2527                         if (j->cadence_f[cnt].enable == 1)
2528                                 j->cadence_f[cnt].enable = 0;
2529                         switch (cnt) {
2530                         case 0:
2531                                 if(ixjdebug & 0x0020) {
2532                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2533                                 }
2534                                 j->ex.bits.fc0 = 1;
2535                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2536                                 break;
2537                         case 1:
2538                                 if(ixjdebug & 0x0020) {
2539                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2540                                 }
2541                                 j->ex.bits.fc1 = 1;
2542                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2543                                 break;
2544                         case 2:
2545                                 if(ixjdebug & 0x0020) {
2546                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2547                                 }
2548                                 j->ex.bits.fc2 = 1;
2549                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2550                                 break;
2551                         case 3:
2552                                 if(ixjdebug & 0x0020) {
2553                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2554                                 }
2555                                 j->ex.bits.fc3 = 1;
2556                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2557                                 break;
2558                         }
2559                 }
2560                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2561                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2562                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2563                                 trg = 1;
2564                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2565                                 trg = 0;
2566                         }
2567                         switch (cnt) {
2568                         case 0:
2569                                 if(ixjdebug & 0x0020) {
2570                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2571                                 }
2572                                 j->ex.bits.f0 = 1;
2573                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2574                                 break;
2575                         case 1:
2576                                 if(ixjdebug & 0x0020) {
2577                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2578                                 }
2579                                 j->ex.bits.f1 = 1;
2580                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2581                                 break;
2582                         case 2:
2583                                 if(ixjdebug & 0x0020) {
2584                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2585                                 }
2586                                 j->ex.bits.f2 = 1;
2587                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2588                                 break;
2589                         case 3:
2590                                 if(ixjdebug & 0x0020) {
2591                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2592                                 }
2593                                 j->ex.bits.f3 = 1;
2594                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2595                                 break;
2596                         }
2597                 }
2598         }
2599         return 0;
2600 }
2601
2602 static int LineMonitor(IXJ *j)
2603 {
2604         if (j->dtmf_proc) {
2605                 return -1;
2606         }
2607         j->dtmf_proc = 1;
2608
2609         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2610                 return -1;
2611
2612         j->dtmf.bytes.high = j->ssr.high;
2613         j->dtmf.bytes.low = j->ssr.low;
2614         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2615                 j->dtmf_state = 1;
2616                 j->dtmf_current = j->dtmf.bits.digit;
2617         }
2618         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2619          {
2620                 if(!j->cidcw_wait) {
2621                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2622                         j->dtmf_wp++;
2623                         if (j->dtmf_wp == 79)
2624                                 j->dtmf_wp = 0;
2625                         j->ex.bits.dtmf_ready = 1;
2626                         if(j->ex_sig.bits.dtmf_ready) {
2627                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2628                         }
2629                 }
2630                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2631                         if(ixjdebug & 0x0020) {
2632                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2633                         }
2634                         j->flags.cidcw_ack = 1;
2635                 }
2636                 j->dtmf_state = 0;
2637         }
2638         j->dtmf_proc = 0;
2639
2640         return 0;
2641 }
2642
2643 /************************************************************************
2644 *
2645 * Functions to allow alaw <-> ulaw conversions.
2646 *
2647 ************************************************************************/
2648
2649 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2650 {
2651         static unsigned char table_ulaw2alaw[] =
2652         {
2653                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2654                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2655                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2656                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2657                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2658                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2659                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2660                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2661                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2662                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2663                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2664                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2665                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2666                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2667                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2668                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2669                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2670                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2671                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2672                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2673                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2674                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2675                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2676                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2677                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2678                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2679                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2680                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2681                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2682                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2683                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2684                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2685         };
2686
2687         while (len--)
2688         {
2689                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2690                 buff++;
2691         }
2692 }
2693
2694 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2695 {
2696         static unsigned char table_alaw2ulaw[] =
2697         {
2698                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2699                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2700                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2701                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2702                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2703                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2704                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2705                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2706                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2707                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2708                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2709                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2710                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2711                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2712                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2713                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2714                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2715                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2716                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2717                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2718                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2719                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2720                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2721                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2722                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2723                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2724                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2725                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2726                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2727                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2728                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2729                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2730         };
2731
2732         while (len--)
2733         {
2734                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2735                 buff++;
2736         }
2737 }
2738
2739 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2740 {
2741         unsigned long i = *ppos;
2742         IXJ * j = get_ixj(NUM(file_p->f_dentry->d_inode));
2743
2744         DECLARE_WAITQUEUE(wait, current);
2745
2746         if (j->flags.inread)
2747                 return -EALREADY;
2748
2749         j->flags.inread = 1;
2750
2751         add_wait_queue(&j->read_q, &wait);
2752         set_current_state(TASK_INTERRUPTIBLE);
2753         mb();
2754
2755         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2756                 ++j->read_wait;
2757                 if (file_p->f_flags & O_NONBLOCK) {
2758                         set_current_state(TASK_RUNNING);
2759                         remove_wait_queue(&j->read_q, &wait);
2760                         j->flags.inread = 0;
2761                         return -EAGAIN;
2762                 }
2763                 if (!ixj_hookstate(j)) {
2764                         set_current_state(TASK_RUNNING);
2765                         remove_wait_queue(&j->read_q, &wait);
2766                         j->flags.inread = 0;
2767                         return 0;
2768                 }
2769                 interruptible_sleep_on(&j->read_q);
2770                 if (signal_pending(current)) {
2771                         set_current_state(TASK_RUNNING);
2772                         remove_wait_queue(&j->read_q, &wait);
2773                         j->flags.inread = 0;
2774                         return -EINTR;
2775                 }
2776         }
2777
2778         remove_wait_queue(&j->read_q, &wait);
2779         set_current_state(TASK_RUNNING);
2780         /* Don't ever copy more than the user asks */
2781         if(j->rec_codec == ALAW)
2782                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2783         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2784         j->read_buffer_ready = 0;
2785         if (i) {
2786                 j->flags.inread = 0;
2787                 return -EFAULT;
2788         } else {
2789                 j->flags.inread = 0;
2790                 return min(length, j->read_buffer_size);
2791         }
2792 }
2793
2794 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2795                           loff_t * ppos)
2796 {
2797         int pre_retval;
2798         ssize_t read_retval = 0;
2799         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2800
2801         pre_retval = ixj_PreRead(j, 0L);
2802         switch (pre_retval) {
2803         case NORMAL:
2804                 read_retval = ixj_read(file_p, buf, length, ppos);
2805                 ixj_PostRead(j, 0L);
2806                 break;
2807         case NOPOST:
2808                 read_retval = ixj_read(file_p, buf, length, ppos);
2809                 break;
2810         case POSTONLY:
2811                 ixj_PostRead(j, 0L);
2812                 break;
2813         default:
2814                 read_retval = pre_retval;
2815         }
2816         return read_retval;
2817 }
2818
2819 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2820 {
2821         unsigned long i = *ppos;
2822         IXJ *j = file_p->private_data;
2823
2824         DECLARE_WAITQUEUE(wait, current);
2825
2826         if (j->flags.inwrite)
2827                 return -EALREADY;
2828
2829         j->flags.inwrite = 1;
2830
2831         add_wait_queue(&j->write_q, &wait);
2832         set_current_state(TASK_INTERRUPTIBLE);
2833         mb();
2834
2835
2836         while (!j->write_buffers_empty) {
2837                 ++j->write_wait;
2838                 if (file_p->f_flags & O_NONBLOCK) {
2839                         set_current_state(TASK_RUNNING);
2840                         remove_wait_queue(&j->write_q, &wait);
2841                         j->flags.inwrite = 0;
2842                         return -EAGAIN;
2843                 }
2844                 if (!ixj_hookstate(j)) {
2845                         set_current_state(TASK_RUNNING);
2846                         remove_wait_queue(&j->write_q, &wait);
2847                         j->flags.inwrite = 0;
2848                         return 0;
2849                 }
2850                 interruptible_sleep_on(&j->write_q);
2851                 if (signal_pending(current)) {
2852                         set_current_state(TASK_RUNNING);
2853                         remove_wait_queue(&j->write_q, &wait);
2854                         j->flags.inwrite = 0;
2855                         return -EINTR;
2856                 }
2857         }
2858         set_current_state(TASK_RUNNING);
2859         remove_wait_queue(&j->write_q, &wait);
2860         if (j->write_buffer_wp + count >= j->write_buffer_end)
2861                 j->write_buffer_wp = j->write_buffer;
2862         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2863         if (i) {
2864                 j->flags.inwrite = 0;
2865                 return -EFAULT;
2866         }
2867        if(j->play_codec == ALAW)
2868                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2869         j->flags.inwrite = 0;
2870         return min(count, j->write_buffer_size);
2871 }
2872
2873 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2874 {
2875         int pre_retval;
2876         ssize_t write_retval = 0;
2877
2878         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
2879
2880         pre_retval = ixj_PreWrite(j, 0L);
2881         switch (pre_retval) {
2882         case NORMAL:
2883                 write_retval = ixj_write(file_p, buf, count, ppos);
2884                 if (write_retval > 0) {
2885                         ixj_PostWrite(j, 0L);
2886                         j->write_buffer_wp += write_retval;
2887                         j->write_buffers_empty--;
2888                 }
2889                 break;
2890         case NOPOST:
2891                 write_retval = ixj_write(file_p, buf, count, ppos);
2892                 if (write_retval > 0) {
2893                         j->write_buffer_wp += write_retval;
2894                         j->write_buffers_empty--;
2895                 }
2896                 break;
2897         case POSTONLY:
2898                 ixj_PostWrite(j, 0L);
2899                 break;
2900         default:
2901                 write_retval = pre_retval;
2902         }
2903         return write_retval;
2904 }
2905
2906 static void ixj_read_frame(IXJ *j)
2907 {
2908         int cnt, dly;
2909
2910         if (j->read_buffer) {
2911                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2912                         if (!(cnt % 16) && !IsRxReady(j)) {
2913                                 dly = 0;
2914                                 while (!IsRxReady(j)) {
2915                                         if (dly++ > 5) {
2916                                                 dly = 0;
2917                                                 break;
2918                                         }
2919                                         udelay(10);
2920                                 }
2921                         }
2922                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2923                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2924                                 inb_p(j->DSPbase + 0x0E);
2925                                 inb_p(j->DSPbase + 0x0F);
2926                         }
2927                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2928                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2929                 }
2930                 ++j->framesread;
2931                 if (j->intercom != -1) {
2932                         if (IsTxReady(get_ixj(j->intercom))) {
2933                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2934                                         if (!(cnt % 16) && !IsTxReady(j)) {
2935                                                 dly = 0;
2936                                                 while (!IsTxReady(j)) {
2937                                                         if (dly++ > 5) {
2938                                                                 dly = 0;
2939                                                                 break;
2940                                                         }
2941                                                         udelay(10);
2942                                                 }
2943                                         }
2944                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2945                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2946                                 }
2947                                 get_ixj(j->intercom)->frameswritten++;
2948                         }
2949                 } else {
2950                         j->read_buffer_ready = 1;
2951                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2952
2953                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2954
2955                         if(j->ixj_signals[SIG_READ_READY])
2956                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2957                 }
2958         }
2959 }
2960
2961 static short fsk[][6][20] =
2962 {
2963         {
2964                 {
2965                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2966                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2967                 },
2968                 {
2969                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2970                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2971                 },
2972                 {
2973                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2974                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2975                 },
2976                 {
2977                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2978                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2979                 },
2980                 {
2981                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2982                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2983                 },
2984                 {
2985                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2986                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2987                 }
2988         },
2989         {
2990                 {
2991                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2992                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2993                 },
2994                 {
2995                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
2996                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
2997                 },
2998                 {
2999                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3000                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3001                 },
3002                 {
3003                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3004                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3005                 },
3006                 {
3007                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3008                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3009                 },
3010                 {
3011                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3012                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3013                 }
3014         }
3015 };
3016
3017
3018 static void ixj_write_cid_bit(IXJ *j, int bit)
3019 {
3020         while (j->fskcnt < 20) {
3021                 if(j->fskdcnt < (j->fsksize - 1))
3022                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3023
3024                 j->fskcnt += 3;
3025         }
3026         j->fskcnt %= 20;
3027
3028         if (!bit)
3029                 j->fskz++;
3030         if (j->fskz >= 6)
3031                 j->fskz = 0;
3032
3033 }
3034
3035 static void ixj_write_cid_byte(IXJ *j, char byte)
3036 {
3037         IXJ_CBYTE cb;
3038
3039                 cb.cbyte = byte;
3040                 ixj_write_cid_bit(j, 0);
3041                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3042                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3043                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3044                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3045                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3046                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3047                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3048                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3049                 ixj_write_cid_bit(j, 1);
3050 }
3051
3052 static void ixj_write_cid_seize(IXJ *j)
3053 {
3054         int cnt;
3055
3056         for (cnt = 0; cnt < 150; cnt++) {
3057                 ixj_write_cid_bit(j, 0);
3058                 ixj_write_cid_bit(j, 1);
3059         }
3060         for (cnt = 0; cnt < 180; cnt++) {
3061                 ixj_write_cid_bit(j, 1);
3062         }
3063 }
3064
3065 static void ixj_write_cidcw_seize(IXJ *j)
3066 {
3067         int cnt;
3068
3069         for (cnt = 0; cnt < 80; cnt++) {
3070                 ixj_write_cid_bit(j, 1);
3071         }
3072 }
3073
3074 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3075 {
3076         int cnt;
3077
3078         for (cnt = 0; cnt < strlen(s); cnt++) {
3079                 ixj_write_cid_byte(j, s[cnt]);
3080                 checksum = (checksum + s[cnt]);
3081         }
3082         return checksum;
3083 }
3084
3085 static void ixj_pad_fsk(IXJ *j, int pad)
3086 {
3087         int cnt;
3088
3089         for (cnt = 0; cnt < pad; cnt++) {
3090                 if(j->fskdcnt < (j->fsksize - 1))
3091                         j->fskdata[j->fskdcnt++] = 0x0000;
3092         }
3093         for (cnt = 0; cnt < 720; cnt++) {
3094                 if(j->fskdcnt < (j->fsksize - 1))
3095                         j->fskdata[j->fskdcnt++] = 0x0000;
3096         }
3097 }
3098
3099 static void ixj_pre_cid(IXJ *j)
3100 {
3101         j->cid_play_codec = j->play_codec;
3102         j->cid_play_frame_size = j->play_frame_size;
3103         j->cid_play_volume = get_play_volume(j);
3104         j->cid_play_flag = j->flags.playing;
3105
3106         j->cid_rec_codec = j->rec_codec;
3107         j->cid_rec_volume = get_rec_volume(j);
3108         j->cid_rec_flag = j->flags.recording;
3109
3110         j->cid_play_aec_level = j->aec_level;
3111
3112         switch(j->baseframe.low) {
3113                 case 0xA0:
3114                         j->cid_base_frame_size = 20;
3115                         break;
3116                 case 0x50:
3117                         j->cid_base_frame_size = 10;
3118                         break;
3119                 case 0xF0:
3120                         j->cid_base_frame_size = 30;
3121                         break;
3122         }
3123
3124         ixj_play_stop(j);
3125         ixj_cpt_stop(j);
3126
3127         j->flags.cidplay = 1;
3128
3129         set_base_frame(j, 30);
3130         set_play_codec(j, LINEAR16);
3131         set_play_volume(j, 0x1B);
3132         ixj_play_start(j);
3133 }
3134
3135 static void ixj_post_cid(IXJ *j)
3136 {
3137         ixj_play_stop(j);
3138
3139         if(j->cidsize > 5000) {
3140                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3141         }
3142         j->flags.cidplay = 0;
3143         if(ixjdebug & 0x0200) {
3144                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3145         }
3146
3147         ixj_fsk_free(j);
3148
3149         j->fskdcnt = 0;
3150         set_base_frame(j, j->cid_base_frame_size);
3151         set_play_codec(j, j->cid_play_codec);
3152         ixj_aec_start(j, j->cid_play_aec_level);
3153         set_play_volume(j, j->cid_play_volume);
3154
3155         set_rec_codec(j, j->cid_rec_codec);
3156         set_rec_volume(j, j->cid_rec_volume);
3157
3158         if(j->cid_rec_flag)
3159                 ixj_record_start(j);
3160
3161         if(j->cid_play_flag)
3162                 ixj_play_start(j);
3163
3164         if(j->cid_play_flag) {
3165                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3166         }
3167 }
3168
3169 static void ixj_write_cid(IXJ *j)
3170 {
3171         char sdmf1[50];
3172         char sdmf2[50];
3173         char sdmf3[80];
3174         char mdmflen, len1, len2, len3;
3175         int pad;
3176
3177         int checksum = 0;
3178
3179         if (j->dsp.low == 0x20 || j->flags.cidplay)
3180                 return;
3181
3182         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3183         j->cidsize = j->cidcnt = 0;
3184
3185         ixj_fsk_alloc(j);
3186
3187         strcpy(sdmf1, j->cid_send.month);
3188         strcat(sdmf1, j->cid_send.day);
3189         strcat(sdmf1, j->cid_send.hour);
3190         strcat(sdmf1, j->cid_send.min);
3191         strcpy(sdmf2, j->cid_send.number);
3192         strcpy(sdmf3, j->cid_send.name);
3193
3194         len1 = strlen(sdmf1);
3195         len2 = strlen(sdmf2);
3196         len3 = strlen(sdmf3);
3197         mdmflen = len1 + len2 + len3 + 6;
3198
3199         while(1){
3200                 ixj_write_cid_seize(j);
3201
3202                 ixj_write_cid_byte(j, 0x80);
3203                 checksum = 0x80;
3204                 ixj_write_cid_byte(j, mdmflen);
3205                 checksum = checksum + mdmflen;
3206
3207                 ixj_write_cid_byte(j, 0x01);
3208                 checksum = checksum + 0x01;
3209                 ixj_write_cid_byte(j, len1);
3210                 checksum = checksum + len1;
3211                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3212                 if(ixj_hookstate(j) & 1)
3213                         break;
3214
3215                 ixj_write_cid_byte(j, 0x02);
3216                 checksum = checksum + 0x02;
3217                 ixj_write_cid_byte(j, len2);
3218                 checksum = checksum + len2;
3219                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3220                 if(ixj_hookstate(j) & 1)
3221                         break;
3222
3223                 ixj_write_cid_byte(j, 0x07);
3224                 checksum = checksum + 0x07;
3225                 ixj_write_cid_byte(j, len3);
3226                 checksum = checksum + len3;
3227                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3228                 if(ixj_hookstate(j) & 1)
3229                         break;
3230
3231                 checksum %= 256;
3232                 checksum ^= 0xFF;
3233                 checksum += 1;
3234
3235                 ixj_write_cid_byte(j, (char) checksum);
3236
3237                 pad = j->fskdcnt % 240;
3238                 if (pad) {
3239                         pad = 240 - pad;
3240                 }
3241                 ixj_pad_fsk(j, pad);
3242                 break;
3243         }
3244
3245         ixj_write_frame(j);
3246 }
3247
3248 static void ixj_write_cidcw(IXJ *j)
3249 {
3250         IXJ_TONE ti;
3251
3252         char sdmf1[50];
3253         char sdmf2[50];
3254         char sdmf3[80];
3255         char mdmflen, len1, len2, len3;
3256         int pad;
3257
3258         int checksum = 0;
3259
3260         if (j->dsp.low == 0x20 || j->flags.cidplay)
3261                 return;
3262
3263         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3264         j->cidsize = j->cidcnt = 0;
3265
3266         ixj_fsk_alloc(j);
3267
3268         j->flags.cidcw_ack = 0;
3269
3270         ti.tone_index = 23;
3271         ti.gain0 = 1;
3272         ti.freq0 = hz440;
3273         ti.gain1 = 0;
3274         ti.freq1 = 0;
3275         ixj_init_tone(j, &ti);
3276
3277         ixj_set_tone_on(1500, j);
3278         ixj_set_tone_off(32, j);
3279         if(ixjdebug & 0x0200) {
3280                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3281         }
3282         ixj_play_tone(j, 23);
3283
3284         clear_bit(j->board, &j->busyflags);
3285         while(j->tone_state)
3286                 schedule_timeout_interruptible(1);
3287         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3288                 schedule_timeout_interruptible(1);
3289         if(ixjdebug & 0x0200) {
3290                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3291         }
3292
3293         ti.tone_index = 24;
3294         ti.gain0 = 1;
3295         ti.freq0 = hz2130;
3296         ti.gain1 = 0;
3297         ti.freq1 = hz2750;
3298         ixj_init_tone(j, &ti);
3299
3300         ixj_set_tone_off(10, j);
3301         ixj_set_tone_on(600, j);
3302         if(ixjdebug & 0x0200) {
3303                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3304         }
3305         ixj_play_tone(j, 24);
3306
3307         clear_bit(j->board, &j->busyflags);
3308         while(j->tone_state)
3309                 schedule_timeout_interruptible(1);
3310         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3311                 schedule_timeout_interruptible(1);
3312         if(ixjdebug & 0x0200) {
3313                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3314         }
3315
3316         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3317
3318         clear_bit(j->board, &j->busyflags);
3319         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3320                 schedule_timeout_interruptible(1);
3321         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3322                 schedule_timeout_interruptible(1);
3323         j->cidcw_wait = 0;
3324         if(!j->flags.cidcw_ack) {
3325                 if(ixjdebug & 0x0200) {
3326                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3327                 }
3328                 ixj_post_cid(j);
3329                 if(j->cid_play_flag) {
3330                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3331                 }
3332                 return;
3333         } else {
3334                 ixj_pre_cid(j);
3335         }
3336         j->flags.cidcw_ack = 0;
3337         strcpy(sdmf1, j->cid_send.month);
3338         strcat(sdmf1, j->cid_send.day);
3339         strcat(sdmf1, j->cid_send.hour);
3340         strcat(sdmf1, j->cid_send.min);
3341         strcpy(sdmf2, j->cid_send.number);
3342         strcpy(sdmf3, j->cid_send.name);
3343
3344         len1 = strlen(sdmf1);
3345         len2 = strlen(sdmf2);
3346         len3 = strlen(sdmf3);
3347         mdmflen = len1 + len2 + len3 + 6;
3348
3349         ixj_write_cidcw_seize(j);
3350
3351         ixj_write_cid_byte(j, 0x80);
3352         checksum = 0x80;
3353         ixj_write_cid_byte(j, mdmflen);
3354         checksum = checksum + mdmflen;
3355
3356         ixj_write_cid_byte(j, 0x01);
3357         checksum = checksum + 0x01;
3358         ixj_write_cid_byte(j, len1);
3359         checksum = checksum + len1;
3360         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3361
3362         ixj_write_cid_byte(j, 0x02);
3363         checksum = checksum + 0x02;
3364         ixj_write_cid_byte(j, len2);
3365         checksum = checksum + len2;
3366         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3367
3368         ixj_write_cid_byte(j, 0x07);
3369         checksum = checksum + 0x07;
3370         ixj_write_cid_byte(j, len3);
3371         checksum = checksum + len3;
3372         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3373
3374         checksum %= 256;
3375         checksum ^= 0xFF;
3376         checksum += 1;
3377
3378         ixj_write_cid_byte(j, (char) checksum);
3379
3380         pad = j->fskdcnt % 240;
3381         if (pad) {
3382                 pad = 240 - pad;
3383         }
3384         ixj_pad_fsk(j, pad);
3385         if(ixjdebug & 0x0200) {
3386                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3387         }
3388 }
3389
3390 static void ixj_write_vmwi(IXJ *j, int msg)
3391 {
3392         char mdmflen;
3393         int pad;
3394
3395         int checksum = 0;
3396
3397         if (j->dsp.low == 0x20 || j->flags.cidplay)
3398                 return;
3399
3400         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3401         j->cidsize = j->cidcnt = 0;
3402
3403         ixj_fsk_alloc(j);
3404
3405         mdmflen = 3;
3406
3407         if (j->port == PORT_POTS)
3408                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3409
3410         ixj_write_cid_seize(j);
3411
3412         ixj_write_cid_byte(j, 0x82);
3413         checksum = 0x82;
3414         ixj_write_cid_byte(j, mdmflen);
3415         checksum = checksum + mdmflen;
3416
3417         ixj_write_cid_byte(j, 0x0B);
3418         checksum = checksum + 0x0B;
3419         ixj_write_cid_byte(j, 1);
3420         checksum = checksum + 1;
3421
3422         if(msg) {
3423                 ixj_write_cid_byte(j, 0xFF);
3424                 checksum = checksum + 0xFF;
3425         }
3426         else {
3427                 ixj_write_cid_byte(j, 0x00);
3428                 checksum = checksum + 0x00;
3429         }
3430
3431         checksum %= 256;
3432         checksum ^= 0xFF;
3433         checksum += 1;
3434
3435         ixj_write_cid_byte(j, (char) checksum);
3436
3437         pad = j->fskdcnt % 240;
3438         if (pad) {
3439                 pad = 240 - pad;
3440         }
3441         ixj_pad_fsk(j, pad);
3442 }
3443
3444 static void ixj_write_frame(IXJ *j)
3445 {
3446         int cnt, frame_count, dly;
3447         IXJ_WORD dat;
3448         BYTES blankword;
3449
3450         frame_count = 0;
3451         if(j->flags.cidplay) {
3452                 for(cnt = 0; cnt < 480; cnt++) {
3453                         if (!(cnt % 16) && !IsTxReady(j)) {
3454                                 dly = 0;
3455                                 while (!IsTxReady(j)) {
3456                                         if (dly++ > 5) {
3457                                                 dly = 0;
3458                                                 break;
3459                                         }
3460                                         udelay(10);
3461                                 }
3462                         }
3463                         dat.word = j->fskdata[j->cidcnt++];
3464                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3465                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3466                         cnt++;
3467                 }
3468                 if(j->cidcnt >= j->fskdcnt) {
3469                         ixj_post_cid(j);
3470                 }
3471                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3472                    and there is real audio data in the buffer, we need to throw it away because
3473                    we just used it's time slot */
3474                 if (j->write_buffer_rp > j->write_buffer_wp) {
3475                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3476                         if (j->write_buffer_rp >= j->write_buffer_end) {
3477                                 j->write_buffer_rp = j->write_buffer;
3478                         }
3479                         j->write_buffers_empty++;
3480                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3481
3482                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3483                 }
3484         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3485                 if (j->write_buffer_wp > j->write_buffer_rp) {
3486                         frame_count =
3487                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3488                 }
3489                 if (j->write_buffer_rp > j->write_buffer_wp) {
3490                         frame_count =
3491                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3492                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3493                 }
3494                 if (frame_count >= 1) {
3495                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3496                                 switch (j->play_mode) {
3497                                 case PLAYBACK_MODE_ULAW:
3498                                 case PLAYBACK_MODE_ALAW:
3499                                         blankword.low = blankword.high = 0xFF;
3500                                         break;
3501                                 case PLAYBACK_MODE_8LINEAR:
3502                                 case PLAYBACK_MODE_16LINEAR:
3503                                         blankword.low = blankword.high = 0x00;
3504                                         break;
3505                                 case PLAYBACK_MODE_8LINEAR_WSS:
3506                                         blankword.low = blankword.high = 0x80;
3507                                         break;
3508                                 }
3509                                 for (cnt = 0; cnt < 16; cnt++) {
3510                                         if (!(cnt % 16) && !IsTxReady(j)) {
3511                                                 dly = 0;
3512                                                 while (!IsTxReady(j)) {
3513                                                         if (dly++ > 5) {
3514                                                                 dly = 0;
3515                                                                 break;
3516                                                         }
3517                                                         udelay(10);
3518                                                 }
3519                                         }
3520                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3521                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3522                                 }
3523                                 j->flags.play_first_frame = 0;
3524                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3525                                 for (cnt = 0; cnt < 24; cnt++) {
3526                                         if(cnt == 12) {
3527                                                 blankword.low = 0x02;
3528                                                 blankword.high = 0x00;
3529                                         }
3530                                         else {
3531                                                 blankword.low = blankword.high = 0x00;
3532                                         }
3533                                         if (!(cnt % 16) && !IsTxReady(j)) {
3534                                                 dly = 0;
3535                                                 while (!IsTxReady(j)) {
3536                                                         if (dly++ > 5) {
3537                                                                 dly = 0;
3538                                                                 break;
3539                                                         }
3540                                                         udelay(10);
3541                                                 }
3542                                         }
3543                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3544                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3545                                 }
3546                                 j->flags.play_first_frame = 0;
3547                         }
3548                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3549                                 if (!(cnt % 16) && !IsTxReady(j)) {
3550                                         dly = 0;
3551                                         while (!IsTxReady(j)) {
3552                                                 if (dly++ > 5) {
3553                                                         dly = 0;
3554                                                         break;
3555                                                 }
3556                                                 udelay(10);
3557                                         }
3558                                 }
3559                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3560                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3561                                         if (j->write_buffer_rp[cnt] == 0 &&
3562                                             j->write_buffer_rp[cnt + 1] == 0 &&
3563                                             j->write_buffer_rp[cnt + 2] == 0 &&
3564                                             j->write_buffer_rp[cnt + 3] == 0 &&
3565                                             j->write_buffer_rp[cnt + 4] == 0 &&
3566                                             j->write_buffer_rp[cnt + 5] == 0 &&
3567                                             j->write_buffer_rp[cnt + 6] == 0 &&
3568                                             j->write_buffer_rp[cnt + 7] == 0 &&
3569                                             j->write_buffer_rp[cnt + 8] == 0 &&
3570                                             j->write_buffer_rp[cnt + 9] == 0) {
3571                                         /* someone is trying to write silence lets make this a type 0 frame. */
3572                                                 outb_p(0x00, j->DSPbase + 0x0C);
3573                                                 outb_p(0x00, j->DSPbase + 0x0D);
3574                                         } else {
3575                                         /* so all other frames are type 1. */
3576                                                 outb_p(0x01, j->DSPbase + 0x0C);
3577                                                 outb_p(0x00, j->DSPbase + 0x0D);
3578                                         }
3579                                 }
3580                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3581                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3582                                 *(j->write_buffer_rp + cnt) = 0;
3583                                 *(j->write_buffer_rp + cnt + 1) = 0;
3584                         }
3585                         j->write_buffer_rp += j->play_frame_size * 2;
3586                         if (j->write_buffer_rp >= j->write_buffer_end) {
3587                                 j->write_buffer_rp = j->write_buffer;
3588                         }
3589                         j->write_buffers_empty++;
3590                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3591
3592                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3593
3594                         ++j->frameswritten;
3595                 }
3596         } else {
3597                 j->drybuffer++;
3598         }
3599         if(j->ixj_signals[SIG_WRITE_READY]) {
3600                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3601         }
3602 }
3603
3604 static int idle(IXJ *j)
3605 {
3606         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3607
3608                 return 0;
3609
3610         if (j->ssr.high || j->ssr.low) {
3611                 return 0;
3612         } else {
3613                 j->play_mode = -1;
3614                 j->flags.playing = 0;
3615                 j->rec_mode = -1;
3616                 j->flags.recording = 0;
3617                 return 1;
3618         }
3619 }
3620
3621 static int set_base_frame(IXJ *j, int size)
3622 {
3623         unsigned short cmd;
3624         int cnt;
3625
3626         idle(j);
3627         j->cid_play_aec_level = j->aec_level;
3628         aec_stop(j);
3629         for (cnt = 0; cnt < 10; cnt++) {
3630                 if (idle(j))
3631                         break;
3632         }
3633         if (j->ssr.high || j->ssr.low)
3634                 return -1;
3635         if (j->dsp.low != 0x20) {
3636                 switch (size) {
3637                 case 30:
3638                         cmd = 0x07F0;
3639                         /* Set Base Frame Size to 240 pg9-10 8021 */
3640                         break;
3641                 case 20:
3642                         cmd = 0x07A0;
3643                         /* Set Base Frame Size to 160 pg9-10 8021 */
3644                         break;
3645                 case 10:
3646                         cmd = 0x0750;
3647                         /* Set Base Frame Size to 80 pg9-10 8021 */
3648                         break;
3649                 default:
3650                         return -1;
3651                 }
3652         } else {
3653                 if (size == 30)
3654                         return size;
3655                 else
3656                         return -1;
3657         }
3658         if (ixj_WriteDSPCommand(cmd, j)) {
3659                 j->baseframe.high = j->baseframe.low = 0xFF;
3660                 return -1;
3661         } else {
3662                 j->baseframe.high = j->ssr.high;
3663                 j->baseframe.low = j->ssr.low;
3664                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3665                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3666                         return -1;
3667                 }
3668         }
3669         ixj_aec_start(j, j->cid_play_aec_level);
3670         return size;
3671 }
3672
3673 static int set_rec_codec(IXJ *j, int rate)
3674 {
3675         int retval = 0;
3676
3677         j->rec_codec = rate;
3678
3679         switch (rate) {
3680         case G723_63:
3681                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3682                         j->rec_frame_size = 12;
3683                         j->rec_mode = 0;
3684                 } else {
3685                         retval = 1;
3686                 }
3687                 break;
3688         case G723_53:
3689                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3690                         j->rec_frame_size = 10;
3691                         j->rec_mode = 0;
3692                 } else {
3693                         retval = 1;
3694                 }
3695                 break;
3696         case TS85:
3697                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3698                         j->rec_frame_size = 16;
3699                         j->rec_mode = 0;
3700                 } else {
3701                         retval = 1;
3702                 }
3703                 break;
3704         case TS48:
3705                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3706                         j->rec_frame_size = 9;
3707                         j->rec_mode = 0;
3708                 } else {
3709                         retval = 1;
3710                 }
3711                 break;
3712         case TS41:
3713                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3714                         j->rec_frame_size = 8;
3715                         j->rec_mode = 0;
3716                 } else {
3717                         retval = 1;
3718                 }
3719                 break;
3720         case G728:
3721                 if (j->dsp.low != 0x20) {
3722                         j->rec_frame_size = 48;
3723                         j->rec_mode = 0;
3724                 } else {
3725                         retval = 1;
3726                 }
3727                 break;
3728         case G729:
3729                 if (j->dsp.low != 0x20) {
3730                         if (!j->flags.g729_loaded) {
3731                                 retval = 1;
3732                                 break;
3733                         }
3734                         switch (j->baseframe.low) {
3735                         case 0xA0:
3736                                 j->rec_frame_size = 10;
3737                                 break;
3738                         case 0x50:
3739                                 j->rec_frame_size = 5;
3740                                 break;
3741                         default:
3742                                 j->rec_frame_size = 15;
3743                                 break;
3744                         }
3745                         j->rec_mode = 0;
3746                 } else {
3747                         retval = 1;
3748                 }
3749                 break;
3750         case G729B:
3751                 if (j->dsp.low != 0x20) {
3752                         if (!j->flags.g729_loaded) {
3753                                 retval = 1;
3754                                 break;
3755                         }
3756                         switch (j->baseframe.low) {
3757                         case 0xA0:
3758                                 j->rec_frame_size = 12;
3759                                 break;
3760                         case 0x50:
3761                                 j->rec_frame_size = 6;
3762                                 break;
3763                         default:
3764                                 j->rec_frame_size = 18;
3765                                 break;
3766                         }
3767                         j->rec_mode = 0;
3768                 } else {
3769                         retval = 1;
3770                 }
3771                 break;
3772         case ULAW:
3773                 switch (j->baseframe.low) {
3774                 case 0xA0:
3775                         j->rec_frame_size = 80;
3776                         break;
3777                 case 0x50:
3778                         j->rec_frame_size = 40;
3779                         break;
3780                 default:
3781                         j->rec_frame_size = 120;
3782                         break;
3783                 }
3784                 j->rec_mode = 4;
3785                 break;
3786         case ALAW:
3787                 switch (j->baseframe.low) {
3788                 case 0xA0:
3789                         j->rec_frame_size = 80;
3790                         break;
3791                 case 0x50:
3792                         j->rec_frame_size = 40;
3793                         break;
3794                 default:
3795                         j->rec_frame_size = 120;
3796                         break;
3797                 }
3798                 j->rec_mode = 4;
3799                 break;
3800         case LINEAR16:
3801                 switch (j->baseframe.low) {
3802                 case 0xA0:
3803                         j->rec_frame_size = 160;
3804                         break;
3805                 case 0x50:
3806                         j->rec_frame_size = 80;
3807                         break;
3808                 default:
3809                         j->rec_frame_size = 240;
3810                         break;
3811                 }
3812                 j->rec_mode = 5;
3813                 break;
3814         case LINEAR8:
3815                 switch (j->baseframe.low) {
3816                 case 0xA0:
3817                         j->rec_frame_size = 80;
3818                         break;
3819                 case 0x50:
3820                         j->rec_frame_size = 40;
3821                         break;
3822                 default:
3823                         j->rec_frame_size = 120;
3824                         break;
3825                 }
3826                 j->rec_mode = 6;
3827                 break;
3828         case WSS:
3829                 switch (j->baseframe.low) {
3830                 case 0xA0:
3831                         j->rec_frame_size = 80;
3832                         break;
3833                 case 0x50:
3834                         j->rec_frame_size = 40;
3835                         break;
3836                 default:
3837                         j->rec_frame_size = 120;
3838                         break;
3839                 }
3840                 j->rec_mode = 7;
3841                 break;
3842         default:
3843                 kfree(j->read_buffer);
3844                 j->rec_frame_size = 0;
3845                 j->rec_mode = -1;
3846                 j->read_buffer = NULL;
3847                 j->read_buffer_size = 0;
3848                 retval = 1;
3849                 break;
3850         }
3851         return retval;
3852 }
3853
3854 static int ixj_record_start(IXJ *j)
3855 {
3856         unsigned short cmd = 0x0000;
3857
3858         if (j->read_buffer) {
3859                 ixj_record_stop(j);
3860         }
3861         j->flags.recording = 1;
3862         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3863
3864         if(ixjdebug & 0x0002)
3865                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3866
3867         if (!j->rec_mode) {
3868                 switch (j->rec_codec) {
3869                 case G723_63:
3870                         cmd = 0x5131;
3871                         break;
3872                 case G723_53:
3873                         cmd = 0x5132;
3874                         break;
3875                 case TS85:
3876                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3877
3878                         break;
3879                 case TS48:
3880                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3881
3882                         break;
3883                 case TS41:
3884                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3885
3886                         break;
3887                 case G728:
3888                         cmd = 0x5135;
3889                         break;
3890                 case G729:
3891                 case G729B:
3892                         cmd = 0x5136;
3893                         break;
3894                 default:
3895                         return 1;
3896                 }
3897                 if (ixj_WriteDSPCommand(cmd, j))
3898                         return -1;
3899         }
3900         if (!j->read_buffer) {
3901                 if (!j->read_buffer)
3902                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3903                 if (!j->read_buffer) {
3904                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3905                         return -ENOMEM;
3906                 }
3907         }
3908         j->read_buffer_size = j->rec_frame_size * 2;
3909
3910         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3911
3912                 return -1;
3913
3914         switch (j->rec_mode) {
3915         case 0:
3916                 cmd = 0x1C03;   /* Record C1 */
3917
3918                 break;
3919         case 4:
3920                 if (j->ver.low == 0x12) {
3921                         cmd = 0x1E03;   /* Record C1 */
3922
3923                 } else {
3924                         cmd = 0x1E01;   /* Record C1 */
3925
3926                 }
3927                 break;
3928         case 5:
3929                 if (j->ver.low == 0x12) {
3930                         cmd = 0x1E83;   /* Record C1 */
3931
3932                 } else {
3933                         cmd = 0x1E81;   /* Record C1 */
3934
3935                 }
3936                 break;
3937         case 6:
3938                 if (j->ver.low == 0x12) {
3939                         cmd = 0x1F03;   /* Record C1 */
3940
3941                 } else {
3942                         cmd = 0x1F01;   /* Record C1 */
3943
3944                 }
3945                 break;
3946         case 7:
3947                 if (j->ver.low == 0x12) {
3948                         cmd = 0x1F83;   /* Record C1 */
3949                 } else {
3950                         cmd = 0x1F81;   /* Record C1 */
3951                 }
3952                 break;
3953         }
3954         if (ixj_WriteDSPCommand(cmd, j))
3955                 return -1;
3956
3957         if (j->flags.playing) {
3958                 ixj_aec_start(j, j->aec_level);
3959         }
3960         return 0;
3961 }
3962
3963 static void ixj_record_stop(IXJ *j)
3964 {
3965         if (ixjdebug & 0x0002)
3966                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3967
3968         kfree(j->read_buffer);
3969         j->read_buffer = NULL;
3970         j->read_buffer_size = 0;
3971         if (j->rec_mode > -1) {
3972                 ixj_WriteDSPCommand(0x5120, j);
3973                 j->rec_mode = -1;
3974         }
3975         j->flags.recording = 0;
3976 }
3977 static void ixj_vad(IXJ *j, int arg)
3978 {
3979         if (arg)
3980                 ixj_WriteDSPCommand(0x513F, j);
3981         else
3982                 ixj_WriteDSPCommand(0x513E, j);
3983 }
3984
3985 static void set_rec_depth(IXJ *j, int depth)
3986 {
3987         if (depth > 60)
3988                 depth = 60;
3989         if (depth < 0)
3990                 depth = 0;
3991         ixj_WriteDSPCommand(0x5180 + depth, j);
3992 }
3993
3994 static void set_dtmf_prescale(IXJ *j, int volume)
3995 {
3996         ixj_WriteDSPCommand(0xCF07, j);
3997         ixj_WriteDSPCommand(volume, j);
3998 }
3999
4000 static int get_dtmf_prescale(IXJ *j)
4001 {
4002         ixj_WriteDSPCommand(0xCF05, j);
4003         return j->ssr.high << 8 | j->ssr.low;
4004 }
4005
4006 static void set_rec_volume(IXJ *j, int volume)
4007 {
4008         if(j->aec_level == AEC_AGC) {
4009                 if (ixjdebug & 0x0002)
4010                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4011                 ixj_WriteDSPCommand(0xCF96, j);
4012                 ixj_WriteDSPCommand(volume, j);
4013         } else {
4014                 if (ixjdebug & 0x0002)
4015                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4016                 ixj_WriteDSPCommand(0xCF03, j);
4017                 ixj_WriteDSPCommand(volume, j);
4018         }
4019 }
4020
4021 static int set_rec_volume_linear(IXJ *j, int volume)
4022 {
4023         int newvolume, dsprecmax;
4024
4025         if (ixjdebug & 0x0002)
4026                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4027         if(volume > 100 || volume < 0) {
4028           return -1;
4029         }
4030
4031         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4032         switch (j->cardtype) {
4033         case QTI_PHONEJACK:
4034                 dsprecmax = 0x440;
4035                 break;
4036         case QTI_LINEJACK:
4037                 dsprecmax = 0x180;
4038                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4039                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4040                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4041                 break;
4042         case QTI_PHONEJACK_LITE:
4043                 dsprecmax = 0x4C0;
4044                 break;
4045         case QTI_PHONEJACK_PCI:
4046                 dsprecmax = 0x100;
4047                 break;
4048         case QTI_PHONECARD:
4049                 dsprecmax = 0x400;
4050                 break;
4051         default:
4052                 return -1;
4053         }
4054         newvolume = (dsprecmax * volume) / 100;
4055         set_rec_volume(j, newvolume);
4056         return 0;
4057 }
4058
4059 static int get_rec_volume(IXJ *j)
4060 {
4061         if(j->aec_level == AEC_AGC) {
4062                 if (ixjdebug & 0x0002)
4063                         printk(KERN_INFO "Getting AGC Threshold\n");
4064                 ixj_WriteDSPCommand(0xCF86, j);
4065                 if (ixjdebug & 0x0002)
4066                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4067                 return j->ssr.high << 8 | j->ssr.low;
4068         } else {
4069                 if (ixjdebug & 0x0002)
4070                         printk(KERN_INFO "Getting Record Volume\n");
4071                 ixj_WriteDSPCommand(0xCF01, j);
4072                 return j->ssr.high << 8 | j->ssr.low;
4073         }
4074 }
4075
4076 static int get_rec_volume_linear(IXJ *j)
4077 {
4078         int volume, newvolume, dsprecmax;
4079
4080         switch (j->cardtype) {
4081         case QTI_PHONEJACK:
4082                 dsprecmax = 0x440;
4083                 break;
4084         case QTI_LINEJACK:
4085                 dsprecmax = 0x180;
4086                 break;
4087         case QTI_PHONEJACK_LITE:
4088                 dsprecmax = 0x4C0;
4089                 break;
4090         case QTI_PHONEJACK_PCI:
4091                 dsprecmax = 0x100;
4092                 break;
4093         case QTI_PHONECARD:
4094                 dsprecmax = 0x400;
4095                 break;
4096         default:
4097                 return -1;
4098         }
4099         volume = get_rec_volume(j);
4100         newvolume = (volume * 100) / dsprecmax;
4101         if(newvolume > 100)
4102                 newvolume = 100;
4103         return newvolume;
4104 }
4105
4106 static int get_rec_level(IXJ *j)
4107 {
4108         int retval;
4109
4110         ixj_WriteDSPCommand(0xCF88, j);
4111
4112         retval = j->ssr.high << 8 | j->ssr.low;
4113         retval = (retval * 256) / 240;
4114         return retval;
4115 }
4116
4117 static void ixj_aec_start(IXJ *j, int level)
4118 {
4119         j->aec_level = level;
4120         if (ixjdebug & 0x0002)
4121                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4122         if (!level) {
4123                 aec_stop(j);
4124         } else {
4125                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4126                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4127
4128                         ixj_WriteDSPCommand(0x0300, j);
4129                 }
4130                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4131
4132                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4133
4134                 switch (level) {
4135                 case AEC_LOW:
4136                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4137
4138                         ixj_WriteDSPCommand(0xE011, j);
4139                         ixj_WriteDSPCommand(0xFFFF, j);
4140
4141                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4142                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4143
4144                         break;
4145
4146                 case AEC_MED:
4147                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4148
4149                         ixj_WriteDSPCommand(0xE011, j);
4150                         ixj_WriteDSPCommand(0x0080, j);
4151
4152                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4153                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4154
4155                         break;
4156
4157                 case AEC_HIGH:
4158                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4159
4160                         ixj_WriteDSPCommand(0xE011, j);
4161                         ixj_WriteDSPCommand(0x0080, j);
4162
4163                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4164                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4165
4166                         break;
4167
4168                 case AEC_AGC:
4169                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4170                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4171
4172                         ixj_WriteDSPCommand(0xE011, j);
4173                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4174
4175                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4176
4177                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4178                                 ixj_WriteDSPCommand(0x0224, j);
4179                         else
4180                                 ixj_WriteDSPCommand(0x1224, j);
4181
4182                         ixj_WriteDSPCommand(0xE014, j);
4183                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4184
4185                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4186
4187                         /* Now we can set the AGC initial parameters and turn it on */
4188                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4189                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4190
4191                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4192                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4193
4194                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4195                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4196
4197                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4198                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4199
4200                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4201                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4202
4203                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4204                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4205
4206                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4207                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4208
4209                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4210                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4211
4212                         break;
4213
4214                 case AEC_AUTO:
4215                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4216
4217                         ixj_WriteDSPCommand(0xE011, j);
4218                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4219
4220                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4221
4222                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4223                                 ixj_WriteDSPCommand(0x0224, j);
4224                         else
4225                                 ixj_WriteDSPCommand(0x1224, j);
4226
4227                         ixj_WriteDSPCommand(0xE014, j);
4228                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4229
4230                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4231
4232                         break;
4233                 }
4234         }
4235 }
4236
4237 static void aec_stop(IXJ *j)
4238 {
4239         j->aec_level = AEC_OFF;
4240         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4241                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4242
4243                 ixj_WriteDSPCommand(0x0700, j);
4244         }
4245         if (j->play_mode != -1 && j->rec_mode != -1)
4246         {
4247                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4248         }
4249 }
4250
4251 static int set_play_codec(IXJ *j, int rate)
4252 {
4253         int retval = 0;
4254
4255         j->play_codec = rate;
4256
4257         switch (rate) {
4258         case G723_63:
4259                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4260                         j->play_frame_size = 12;
4261                         j->play_mode = 0;
4262                 } else {
4263                         retval = 1;
4264                 }
4265                 break;
4266         case G723_53:
4267                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4268                         j->play_frame_size = 10;
4269                         j->play_mode = 0;
4270                 } else {
4271                         retval = 1;
4272                 }
4273                 break;
4274         case TS85:
4275                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4276                         j->play_frame_size = 16;
4277                         j->play_mode = 0;
4278                 } else {
4279                         retval = 1;
4280                 }
4281                 break;
4282         case TS48:
4283                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4284                         j->play_frame_size = 9;
4285                         j->play_mode = 0;
4286                 } else {
4287                         retval = 1;
4288                 }
4289                 break;
4290         case TS41:
4291                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4292                         j->play_frame_size = 8;
4293                         j->play_mode = 0;
4294                 } else {
4295                         retval = 1;
4296                 }
4297                 break;
4298         case G728:
4299                 if (j->dsp.low != 0x20) {
4300                         j->play_frame_size = 48;
4301                         j->play_mode = 0;
4302                 } else {
4303                         retval = 1;
4304                 }
4305                 break;
4306         case G729:
4307                 if (j->dsp.low != 0x20) {
4308                         if (!j->flags.g729_loaded) {
4309                                 retval = 1;
4310                                 break;
4311                         }
4312                         switch (j->baseframe.low) {
4313                         case 0xA0:
4314                                 j->play_frame_size = 10;
4315                                 break;
4316                         case 0x50:
4317                                 j->play_frame_size = 5;
4318                                 break;
4319                         default:
4320                                 j->play_frame_size = 15;
4321                                 break;
4322                         }
4323                         j->play_mode = 0;
4324                 } else {
4325                         retval = 1;
4326                 }
4327                 break;
4328         case G729B:
4329                 if (j->dsp.low != 0x20) {
4330                         if (!j->flags.g729_loaded) {
4331                                 retval = 1;
4332                                 break;
4333                         }
4334                         switch (j->baseframe.low) {
4335                         case 0xA0:
4336                                 j->play_frame_size = 12;
4337                                 break;
4338                         case 0x50:
4339                                 j->play_frame_size = 6;
4340                                 break;
4341                         default:
4342                                 j->play_frame_size = 18;
4343                                 break;
4344                         }
4345                         j->play_mode = 0;
4346                 } else {
4347                         retval = 1;
4348                 }
4349                 break;
4350         case ULAW:
4351                 switch (j->baseframe.low) {
4352                 case 0xA0:
4353                         j->play_frame_size = 80;
4354                         break;
4355                 case 0x50:
4356                         j->play_frame_size = 40;
4357                         break;
4358                 default:
4359                         j->play_frame_size = 120;
4360                         break;
4361                 }
4362                 j->play_mode = 2;
4363                 break;
4364         case ALAW:
4365                 switch (j->baseframe.low) {
4366                 case 0xA0:
4367                         j->play_frame_size = 80;
4368                         break;
4369                 case 0x50:
4370                         j->play_frame_size = 40;
4371                         break;
4372                 default:
4373                         j->play_frame_size = 120;
4374                         break;
4375                 }
4376                 j->play_mode = 2;
4377                 break;
4378         case LINEAR16:
4379                 switch (j->baseframe.low) {
4380                 case 0xA0:
4381                         j->play_frame_size = 160;
4382                         break;
4383                 case 0x50:
4384                         j->play_frame_size = 80;
4385                         break;
4386                 default:
4387                         j->play_frame_size = 240;
4388                         break;
4389                 }
4390                 j->play_mode = 6;
4391                 break;
4392         case LINEAR8:
4393                 switch (j->baseframe.low) {
4394                 case 0xA0:
4395                         j->play_frame_size = 80;
4396                         break;
4397                 case 0x50:
4398                         j->play_frame_size = 40;
4399                         break;
4400                 default:
4401                         j->play_frame_size = 120;
4402                         break;
4403                 }
4404                 j->play_mode = 4;
4405                 break;
4406         case WSS:
4407                 switch (j->baseframe.low) {
4408                 case 0xA0:
4409                         j->play_frame_size = 80;
4410                         break;
4411                 case 0x50:
4412                         j->play_frame_size = 40;
4413                         break;
4414                 default:
4415                         j->play_frame_size = 120;
4416                         break;
4417                 }
4418                 j->play_mode = 5;
4419                 break;
4420         default:
4421                 kfree(j->write_buffer);
4422                 j->play_frame_size = 0;
4423                 j->play_mode = -1;
4424                 j->write_buffer = NULL;
4425                 j->write_buffer_size = 0;
4426                 retval = 1;
4427                 break;
4428         }
4429         return retval;
4430 }
4431
4432 static int ixj_play_start(IXJ *j)
4433 {
4434         unsigned short cmd = 0x0000;
4435
4436         if (j->write_buffer) {
4437                 ixj_play_stop(j);
4438         }
4439
4440         if(ixjdebug & 0x0002)
4441                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4442
4443         j->flags.playing = 1;
4444         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4445
4446         j->flags.play_first_frame = 1;
4447         j->drybuffer = 0;
4448
4449         if (!j->play_mode) {
4450                 switch (j->play_codec) {
4451                 case G723_63:
4452                         cmd = 0x5231;
4453                         break;
4454                 case G723_53:
4455                         cmd = 0x5232;
4456                         break;
4457                 case TS85:
4458                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4459
4460                         break;
4461                 case TS48:
4462                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4463
4464                         break;
4465                 case TS41:
4466                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4467
4468                         break;
4469                 case G728:
4470                         cmd = 0x5235;
4471                         break;
4472                 case G729:
4473                 case G729B:
4474                         cmd = 0x5236;
4475                         break;
4476                 default:
4477                         return 1;
4478                 }
4479                 if (ixj_WriteDSPCommand(cmd, j))
4480                         return -1;
4481         }
4482         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4483         if (!j->write_buffer) {
4484                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4485                 return -ENOMEM;
4486         }
4487 /*      j->write_buffers_empty = 2; */
4488         j->write_buffers_empty = 1;
4489         j->write_buffer_size = j->play_frame_size * 2;
4490         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4491         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4492
4493         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4494
4495                 return -1;
4496
4497         switch (j->play_mode) {
4498         case 0:
4499                 cmd = 0x2C03;
4500                 break;
4501         case 2:
4502                 if (j->ver.low == 0x12) {
4503                         cmd = 0x2C23;
4504                 } else {
4505                         cmd = 0x2C21;
4506                 }
4507                 break;
4508         case 4:
4509                 if (j->ver.low == 0x12) {
4510                         cmd = 0x2C43;
4511                 } else {
4512                         cmd = 0x2C41;
4513                 }
4514                 break;
4515         case 5:
4516                 if (j->ver.low == 0x12) {
4517                         cmd = 0x2C53;
4518                 } else {
4519                         cmd = 0x2C51;
4520                 }
4521                 break;
4522         case 6:
4523                 if (j->ver.low == 0x12) {
4524                         cmd = 0x2C63;
4525                 } else {
4526                         cmd = 0x2C61;
4527                 }
4528                 break;
4529         }
4530         if (ixj_WriteDSPCommand(cmd, j))
4531                 return -1;
4532
4533         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4534                 return -1;
4535
4536         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4537                 return -1;
4538
4539         if (j->flags.recording) {
4540                 ixj_aec_start(j, j->aec_level);
4541         }
4542
4543         return 0;
4544 }
4545
4546 static void ixj_play_stop(IXJ *j)
4547 {
4548         if (ixjdebug & 0x0002)
4549                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4550
4551         kfree(j->write_buffer);
4552         j->write_buffer = NULL;
4553         j->write_buffer_size = 0;
4554         if (j->play_mode > -1) {
4555                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4556
4557                 j->play_mode = -1;
4558         }
4559         j->flags.playing = 0;
4560 }
4561
4562 static inline int get_play_level(IXJ *j)
4563 {
4564         int retval;
4565
4566         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4567         return j->ssr.high << 8 | j->ssr.low;
4568         retval = j->ssr.high << 8 | j->ssr.low;
4569         retval = (retval * 256) / 240;
4570         return retval;
4571 }
4572
4573 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4574 {
4575         unsigned int mask = 0;
4576
4577         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
4578
4579         poll_wait(file_p, &(j->poll_q), wait);
4580         if (j->read_buffer_ready > 0)
4581                 mask |= POLLIN | POLLRDNORM;    /* readable */
4582         if (j->write_buffers_empty > 0)
4583                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4584         if (j->ex.bytes)
4585                 mask |= POLLPRI;
4586         return mask;
4587 }
4588
4589 static int ixj_play_tone(IXJ *j, char tone)
4590 {
4591         if (!j->tone_state) {
4592                 if(ixjdebug & 0x0002) {
4593                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4594                 }
4595                 if (j->dsp.low == 0x20) {
4596                         idle(j);
4597                 }
4598                 j->tone_start_jif = jiffies;
4599
4600                 j->tone_state = 1;
4601         }
4602
4603         j->tone_index = tone;
4604         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4605                 return -1;
4606
4607         return 0;
4608 }
4609
4610 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4611 {
4612         j->tone_on_time = arg;
4613
4614         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4615
4616                 return -1;
4617
4618         if (ixj_WriteDSPCommand(arg, j))
4619                 return -1;
4620
4621         return 0;
4622 }
4623
4624 static int SCI_WaitHighSCI(IXJ *j)
4625 {
4626         int cnt;
4627
4628         j->pld_scrr.byte = inb_p(j->XILINXbase);
4629         if (!j->pld_scrr.bits.sci) {
4630                 for (cnt = 0; cnt < 10; cnt++) {
4631                         udelay(32);
4632                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4633
4634                         if ((j->pld_scrr.bits.sci))
4635                                 return 1;
4636                 }
4637                 if (ixjdebug & 0x0001)
4638                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4639                 return 0;
4640         } else
4641                 return 1;
4642 }
4643
4644 static int SCI_WaitLowSCI(IXJ *j)
4645 {
4646         int cnt;
4647
4648         j->pld_scrr.byte = inb_p(j->XILINXbase);
4649         if (j->pld_scrr.bits.sci) {
4650                 for (cnt = 0; cnt < 10; cnt++) {
4651                         udelay(32);
4652                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4653
4654                         if (!(j->pld_scrr.bits.sci))
4655                                 return 1;
4656                 }
4657                 if (ixjdebug & 0x0001)
4658                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4659                 return 0;
4660         } else
4661                 return 1;
4662 }
4663
4664 static int SCI_Control(IXJ *j, int control)
4665 {
4666         switch (control) {
4667         case SCI_End:
4668                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4669
4670                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4671
4672                 break;
4673         case SCI_Enable_DAA:
4674                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4675
4676                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4677
4678                 break;
4679         case SCI_Enable_Mixer:
4680                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4681
4682                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4683
4684                 break;
4685         case SCI_Enable_EEPROM:
4686                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4687
4688                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4689
4690                 break;
4691         default:
4692                 return 0;
4693                 break;
4694         }
4695         outb_p(j->pld_scrw.byte, j->XILINXbase);
4696
4697         switch (control) {
4698         case SCI_End:
4699                 return 1;
4700                 break;
4701         case SCI_Enable_DAA:
4702         case SCI_Enable_Mixer:
4703         case SCI_Enable_EEPROM:
4704                 if (!SCI_WaitHighSCI(j))
4705                         return 0;
4706                 break;
4707         default:
4708                 return 0;
4709                 break;
4710         }
4711         return 1;
4712 }
4713
4714 static int SCI_Prepare(IXJ *j)
4715 {
4716         if (!SCI_Control(j, SCI_End))
4717                 return 0;
4718
4719         if (!SCI_WaitLowSCI(j))
4720                 return 0;
4721
4722         return 1;
4723 }
4724
4725 static int ixj_get_mixer(long val, IXJ *j)
4726 {
4727         int reg = (val & 0x1F00) >> 8;
4728         return j->mix.vol[reg];
4729 }
4730
4731 static int ixj_mixer(long val, IXJ *j)
4732 {
4733         BYTES bytes;
4734
4735         bytes.high = (val & 0x1F00) >> 8;
4736         bytes.low = val & 0x00FF;
4737
4738         /* save mixer value so we can get back later on */
4739         j->mix.vol[bytes.high] = bytes.low;
4740
4741         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4742
4743         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4744
4745         SCI_Control(j, SCI_Enable_Mixer);
4746
4747         SCI_Control(j, SCI_End);
4748
4749         return 0;
4750 }
4751
4752 static int daa_load(BYTES * p_bytes, IXJ *j)
4753 {
4754         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4755         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4756         if (!SCI_Control(j, SCI_Enable_DAA))
4757                 return 0;
4758         else
4759                 return 1;
4760 }
4761
4762 static int ixj_daa_cr4(IXJ *j, char reg)
4763 {
4764         BYTES bytes;
4765
4766         switch (j->daa_mode) {
4767         case SOP_PU_SLEEP:
4768                 bytes.high = 0x14;
4769                 break;
4770         case SOP_PU_RINGING:
4771                 bytes.high = 0x54;
4772                 break;
4773         case SOP_PU_CONVERSATION:
4774                 bytes.high = 0x94;
4775                 break;
4776         case SOP_PU_PULSEDIALING:
4777                 bytes.high = 0xD4;
4778                 break;
4779         }
4780
4781         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4782
4783         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4784         case 0:
4785                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4786                 break;
4787         case 1:
4788                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4789                 break;
4790         case 2:
4791                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4792                 break;
4793         case 3:
4794                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4795                 break;
4796         }
4797
4798         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4799
4800         if (!daa_load(&bytes, j))
4801                 return 0;
4802
4803         if (!SCI_Prepare(j))
4804                 return 0;
4805
4806         return 1;
4807 }
4808
4809 static char daa_int_read(IXJ *j)
4810 {
4811         BYTES bytes;
4812
4813         if (!SCI_Prepare(j))
4814                 return 0;
4815
4816         bytes.high = 0x38;
4817         bytes.low = 0x00;
4818         outb_p(bytes.high, j->XILINXbase + 0x03);
4819         outb_p(bytes.low, j->XILINXbase + 0x02);
4820
4821         if (!SCI_Control(j, SCI_Enable_DAA))
4822                 return 0;
4823
4824         bytes.high = inb_p(j->XILINXbase + 0x03);
4825         bytes.low = inb_p(j->XILINXbase + 0x02);
4826         if (bytes.low != ALISDAA_ID_BYTE) {
4827                 if (ixjdebug & 0x0001)
4828                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4829                 return 0;
4830         }
4831         if (!SCI_Control(j, SCI_Enable_DAA))
4832                 return 0;
4833         if (!SCI_Control(j, SCI_End))
4834                 return 0;
4835
4836         bytes.high = inb_p(j->XILINXbase + 0x03);
4837         bytes.low = inb_p(j->XILINXbase + 0x02);
4838
4839         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4840
4841         return 1;
4842 }
4843
4844 static char daa_CR_read(IXJ *j, int cr)
4845 {
4846         IXJ_WORD wdata;
4847         BYTES bytes;
4848
4849         if (!SCI_Prepare(j))
4850                 return 0;
4851
4852         switch (j->daa_mode) {
4853         case SOP_PU_SLEEP:
4854                 bytes.high = 0x30 + cr;
4855                 break;
4856         case SOP_PU_RINGING:
4857                 bytes.high = 0x70 + cr;
4858                 break;
4859         case SOP_PU_CONVERSATION:
4860                 bytes.high = 0xB0 + cr;
4861                 break;
4862         case SOP_PU_PULSEDIALING:
4863                 bytes.high = 0xF0 + cr;
4864                 break;
4865         }
4866
4867         bytes.low = 0x00;
4868
4869         outb_p(bytes.high, j->XILINXbase + 0x03);
4870         outb_p(bytes.low, j->XILINXbase + 0x02);
4871
4872         if (!SCI_Control(j, SCI_Enable_DAA))
4873                 return 0;
4874
4875         bytes.high = inb_p(j->XILINXbase + 0x03);
4876         bytes.low = inb_p(j->XILINXbase + 0x02);
4877         if (bytes.low != ALISDAA_ID_BYTE) {
4878                 if (ixjdebug & 0x0001)
4879                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4880                 return 0;
4881         }
4882         if (!SCI_Control(j, SCI_Enable_DAA))
4883                 return 0;
4884         if (!SCI_Control(j, SCI_End))
4885                 return 0;
4886
4887         wdata.word = inw_p(j->XILINXbase + 0x02);
4888
4889         switch(cr){
4890                 case 5:
4891                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4892                         break;
4893                 case 4:
4894                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4895                         break;
4896                 case 3:
4897                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4898                         break;
4899                 case 2:
4900                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4901                         break;
4902                 case 1:
4903                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4904                         break;
4905                 case 0:
4906                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4907                         break;
4908                 default:
4909                         return 0;
4910         }
4911         return 1;
4912 }
4913
4914 static int ixj_daa_cid_reset(IXJ *j)
4915 {
4916         int i;
4917         BYTES bytes;
4918
4919         if (ixjdebug & 0x0002)
4920                 printk("DAA Clearing CID ram\n");
4921
4922         if (!SCI_Prepare(j))
4923                 return 0;
4924
4925         bytes.high = 0x58;
4926         bytes.low = 0x00;
4927         outb_p(bytes.high, j->XILINXbase + 0x03);
4928         outb_p(bytes.low, j->XILINXbase + 0x02);
4929
4930         if (!SCI_Control(j, SCI_Enable_DAA))
4931                 return 0;
4932
4933         if (!SCI_WaitHighSCI(j))
4934                 return 0;
4935
4936         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4937                 bytes.high = bytes.low = 0x00;
4938                 outb_p(bytes.high, j->XILINXbase + 0x03);
4939
4940                 if (i < ALISDAA_CALLERID_SIZE - 1)
4941                         outb_p(bytes.low, j->XILINXbase + 0x02);
4942
4943                 if (!SCI_Control(j, SCI_Enable_DAA))
4944                         return 0;
4945
4946                 if (!SCI_WaitHighSCI(j))
4947                         return 0;
4948
4949         }
4950
4951         if (!SCI_Control(j, SCI_End))
4952                 return 0;
4953
4954         if (ixjdebug & 0x0002)
4955                 printk("DAA CID ram cleared\n");
4956
4957         return 1;
4958 }
4959
4960 static int ixj_daa_cid_read(IXJ *j)
4961 {
4962         int i;
4963         BYTES bytes;
4964         char CID[ALISDAA_CALLERID_SIZE], mContinue;
4965         char *pIn, *pOut;
4966
4967         if (!SCI_Prepare(j))
4968                 return 0;
4969
4970         bytes.high = 0x78;
4971         bytes.low = 0x00;
4972         outb_p(bytes.high, j->XILINXbase + 0x03);
4973         outb_p(bytes.low, j->XILINXbase + 0x02);
4974
4975         if (!SCI_Control(j, SCI_Enable_DAA))
4976                 return 0;
4977
4978         if (!SCI_WaitHighSCI(j))
4979                 return 0;
4980
4981         bytes.high = inb_p(j->XILINXbase + 0x03);
4982         bytes.low = inb_p(j->XILINXbase + 0x02);
4983         if (bytes.low != ALISDAA_ID_BYTE) {
4984                 if (ixjdebug & 0x0001)
4985                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4986                 return 0;
4987         }
4988         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
4989                 bytes.high = bytes.low = 0x00;
4990                 outb_p(bytes.high, j->XILINXbase + 0x03);
4991                 outb_p(bytes.low, j->XILINXbase + 0x02);
4992
4993                 if (!SCI_Control(j, SCI_Enable_DAA))
4994                         return 0;
4995
4996                 if (!SCI_WaitHighSCI(j))
4997                         return 0;
4998
4999                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5000                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5001         }
5002
5003         if (!SCI_Control(j, SCI_End))
5004                 return 0;
5005
5006         pIn = CID;
5007         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5008         mContinue = 1;
5009         while (mContinue) {
5010                 if ((pIn[1] & 0x03) == 0x01) {
5011                         pOut[0] = pIn[0];
5012                 }
5013                 if ((pIn[2] & 0x0c) == 0x04) {
5014                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5015                 }
5016                 if ((pIn[3] & 0x30) == 0x10) {
5017                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5018                 }
5019                 if ((pIn[4] & 0xc0) == 0x40) {
5020                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5021                 } else {
5022                         mContinue = FALSE;
5023                 }
5024                 pIn += 5, pOut += 4;
5025         }
5026         memset(&j->cid, 0, sizeof(PHONE_CID));
5027         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5028         pOut += 4;
5029         strncpy(j->cid.month, pOut, 2);
5030         pOut += 2;
5031         strncpy(j->cid.day, pOut, 2);
5032         pOut += 2;
5033         strncpy(j->cid.hour, pOut, 2);
5034         pOut += 2;
5035         strncpy(j->cid.min, pOut, 2);
5036         pOut += 3;
5037         j->cid.numlen = *pOut;
5038         pOut += 1;
5039         strncpy(j->cid.number, pOut, j->cid.numlen);
5040         pOut += j->cid.numlen + 1;
5041         j->cid.namelen = *pOut;
5042         pOut += 1;
5043         strncpy(j->cid.name, pOut, j->cid.namelen);
5044
5045         ixj_daa_cid_reset(j);
5046         return 1;
5047 }
5048
5049 static char daa_get_version(IXJ *j)
5050 {
5051         BYTES bytes;
5052
5053         if (!SCI_Prepare(j))
5054                 return 0;
5055
5056         bytes.high = 0x35;
5057         bytes.low = 0x00;
5058         outb_p(bytes.high, j->XILINXbase + 0x03);
5059         outb_p(bytes.low, j->XILINXbase + 0x02);
5060
5061         if (!SCI_Control(j, SCI_Enable_DAA))
5062                 return 0;
5063
5064         bytes.high = inb_p(j->XILINXbase + 0x03);
5065         bytes.low = inb_p(j->XILINXbase + 0x02);
5066         if (bytes.low != ALISDAA_ID_BYTE) {
5067                 if (ixjdebug & 0x0001)
5068                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5069                 return 0;
5070         }
5071         if (!SCI_Control(j, SCI_Enable_DAA))
5072                 return 0;
5073
5074         if (!SCI_Control(j, SCI_End))
5075                 return 0;
5076
5077         bytes.high = inb_p(j->XILINXbase + 0x03);
5078         bytes.low = inb_p(j->XILINXbase + 0x02);
5079         if (ixjdebug & 0x0002)
5080                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5081         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5082         return bytes.high;
5083 }
5084
5085 static int daa_set_mode(IXJ *j, int mode)
5086 {
5087         /* NOTE:
5088               The DAA *MUST* be in the conversation mode if the
5089               PSTN line is to be seized (PSTN line off-hook).
5090               Taking the PSTN line off-hook while the DAA is in
5091               a mode other than conversation mode will cause a
5092               hardware failure of the ALIS-A part.
5093
5094            NOTE:
5095               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5096               if the PSTN line is on-hook.  Failure to have the PSTN line
5097               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5098               ALIS-A part.
5099         */
5100
5101         BYTES bytes;
5102
5103         j->flags.pstn_rmr = 0;
5104
5105         if (!SCI_Prepare(j))
5106                 return 0;
5107
5108         switch (mode) {
5109         case SOP_PU_RESET:
5110                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5111
5112                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5113                 j->pld_slicw.bits.rly2 = 0;
5114                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5115                 bytes.high = 0x10;
5116                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5117                 daa_load(&bytes, j);
5118                 if (!SCI_Prepare(j))
5119                         return 0;
5120
5121                 j->daa_mode = SOP_PU_SLEEP;
5122                 break;
5123         case SOP_PU_SLEEP:
5124                 if(j->daa_mode == SOP_PU_SLEEP)
5125                 {
5126                         break;
5127                 }
5128                 if (ixjdebug & 0x0008)
5129                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5130 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5131                 {
5132                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5133
5134                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5135                         j->pld_slicw.bits.rly2 = 0;
5136                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5137                         bytes.high = 0x10;
5138                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5139                         daa_load(&bytes, j);
5140                         if (!SCI_Prepare(j))
5141                                 return 0;
5142                 }
5143                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5144
5145                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5146                 j->pld_slicw.bits.rly2 = 0;
5147                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5148                 bytes.high = 0x10;
5149                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5150                 daa_load(&bytes, j);
5151                 if (!SCI_Prepare(j))
5152                         return 0;
5153
5154                 j->daa_mode = SOP_PU_SLEEP;
5155                 j->flags.pstn_ringing = 0;
5156                 j->ex.bits.pstn_ring = 0;
5157                 j->pstn_sleeptil = jiffies + (hertz / 4);
5158                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5159                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5160                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5161                 break;
5162         case SOP_PU_RINGING:
5163                 if (ixjdebug & 0x0008)
5164                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5165                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5166
5167                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5168                 j->pld_slicw.bits.rly2 = 0;
5169                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5170                 bytes.high = 0x50;
5171                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5172                 daa_load(&bytes, j);
5173                 if (!SCI_Prepare(j))
5174                         return 0;
5175                 j->daa_mode = SOP_PU_RINGING;
5176                 break;
5177         case SOP_PU_CONVERSATION:
5178                 if (ixjdebug & 0x0008)
5179                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5180                 bytes.high = 0x90;
5181                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5182                 daa_load(&bytes, j);
5183                 if (!SCI_Prepare(j))
5184                         return 0;
5185                 j->pld_slicw.bits.rly2 = 1;
5186                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5187                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5188
5189                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5190                 j->daa_mode = SOP_PU_CONVERSATION;
5191                 j->flags.pstn_ringing = 0;
5192                 j->ex.bits.pstn_ring = 0;
5193                 j->pstn_sleeptil = jiffies;
5194                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5195                 break;
5196         case SOP_PU_PULSEDIALING:
5197                 if (ixjdebug & 0x0008)
5198                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5199                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5200
5201                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5202                 j->pld_slicw.bits.rly2 = 0;
5203                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5204                 bytes.high = 0xD0;
5205                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5206                 daa_load(&bytes, j);
5207                 if (!SCI_Prepare(j))
5208                         return 0;
5209                 j->daa_mode = SOP_PU_PULSEDIALING;
5210                 break;
5211         default:
5212                 break;
5213         }
5214         return 1;
5215 }
5216
5217 static int ixj_daa_write(IXJ *j)
5218 {
5219         BYTES bytes;
5220
5221         j->flags.pstncheck = 1;
5222
5223         daa_set_mode(j, SOP_PU_SLEEP);
5224
5225         if (!SCI_Prepare(j))
5226                 return 0;
5227
5228         outb_p(j->pld_scrw.byte, j->XILINXbase);
5229
5230         bytes.high = 0x14;
5231         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5232         if (!daa_load(&bytes, j))
5233                 return 0;
5234
5235         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5236         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5237         if (!daa_load(&bytes, j))
5238                 return 0;
5239
5240         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5241         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5242         if (!daa_load(&bytes, j))
5243                 return 0;
5244
5245         if (!SCI_Prepare(j))
5246                 return 0;
5247
5248         bytes.high = 0x1F;
5249         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5250         if (!daa_load(&bytes, j))
5251                 return 0;
5252
5253         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5254         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5255         if (!daa_load(&bytes, j))
5256                 return 0;
5257
5258         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5259         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5260         if (!daa_load(&bytes, j))
5261                 return 0;
5262
5263         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5264         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5265         if (!daa_load(&bytes, j))
5266                 return 0;
5267
5268         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5269         bytes.low = 0x00;
5270         if (!daa_load(&bytes, j))
5271                 return 0;
5272
5273         if (!SCI_Prepare(j))
5274                 return 0;
5275
5276         bytes.high = 0x00;
5277         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5278         if (!daa_load(&bytes, j))
5279                 return 0;
5280
5281         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5282         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5283         if (!daa_load(&bytes, j))
5284                 return 0;
5285
5286         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5287         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5288         if (!daa_load(&bytes, j))
5289                 return 0;
5290
5291         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5292         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5293         if (!daa_load(&bytes, j))
5294                 return 0;
5295
5296         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5297         bytes.low = 0x00;
5298         if (!daa_load(&bytes, j))
5299                 return 0;
5300
5301         if (!SCI_Control(j, SCI_End))
5302                 return 0;
5303         if (!SCI_WaitLowSCI(j))
5304                 return 0;
5305
5306         bytes.high = 0x01;
5307         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5308         if (!daa_load(&bytes, j))
5309                 return 0;
5310
5311         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5312         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5313         if (!daa_load(&bytes, j))
5314                 return 0;
5315
5316         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5317         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5318         if (!daa_load(&bytes, j))
5319                 return 0;
5320
5321         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5322         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5323         if (!daa_load(&bytes, j))
5324                 return 0;
5325
5326         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5327         bytes.low = 0x00;
5328         if (!daa_load(&bytes, j))
5329                 return 0;
5330
5331         if (!SCI_Control(j, SCI_End))
5332                 return 0;
5333         if (!SCI_WaitLowSCI(j))
5334                 return 0;
5335
5336         bytes.high = 0x02;
5337         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5338         if (!daa_load(&bytes, j))
5339                 return 0;
5340
5341         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5342         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5343         if (!daa_load(&bytes, j))
5344                 return 0;
5345
5346         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5347         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5348         if (!daa_load(&bytes, j))
5349                 return 0;
5350
5351         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5352         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5353         if (!daa_load(&bytes, j))
5354                 return 0;
5355
5356         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5357         bytes.low = 0x00;
5358         if (!daa_load(&bytes, j))
5359                 return 0;
5360
5361         if (!SCI_Control(j, SCI_End))
5362                 return 0;
5363         if (!SCI_WaitLowSCI(j))
5364                 return 0;
5365
5366         bytes.high = 0x03;
5367         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5368         if (!daa_load(&bytes, j))
5369                 return 0;
5370
5371         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5372         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5373         if (!daa_load(&bytes, j))
5374                 return 0;
5375
5376         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5377         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5378         if (!daa_load(&bytes, j))
5379                 return 0;
5380
5381         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5382         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5383         if (!daa_load(&bytes, j))
5384                 return 0;
5385
5386         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5387         bytes.low = 0x00;
5388         if (!daa_load(&bytes, j))
5389                 return 0;
5390
5391         if (!SCI_Control(j, SCI_End))
5392                 return 0;
5393         if (!SCI_WaitLowSCI(j))
5394                 return 0;
5395
5396         bytes.high = 0x04;
5397         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5398         if (!daa_load(&bytes, j))
5399                 return 0;
5400
5401         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5402         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5403         if (!daa_load(&bytes, j))
5404                 return 0;
5405
5406         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5407         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5408         if (!daa_load(&bytes, j))
5409                 return 0;
5410
5411         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5412         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5413         if (!daa_load(&bytes, j))
5414                 return 0;
5415
5416         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5417         bytes.low = 0x00;
5418         if (!daa_load(&bytes, j))
5419                 return 0;
5420
5421         if (!SCI_Control(j, SCI_End))
5422                 return 0;
5423         if (!SCI_WaitLowSCI(j))
5424                 return 0;
5425
5426         bytes.high = 0x05;
5427         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5428         if (!daa_load(&bytes, j))
5429                 return 0;
5430
5431         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5432         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5433         if (!daa_load(&bytes, j))
5434                 return 0;
5435
5436         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5437         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5438         if (!daa_load(&bytes, j))
5439                 return 0;
5440
5441         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5442         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5443         if (!daa_load(&bytes, j))
5444                 return 0;
5445
5446         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5447         bytes.low = 0x00;
5448         if (!daa_load(&bytes, j))
5449                 return 0;
5450
5451         if (!SCI_Control(j, SCI_End))
5452                 return 0;
5453         if (!SCI_WaitLowSCI(j))
5454                 return 0;
5455
5456         bytes.high = 0x06;
5457         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5458         if (!daa_load(&bytes, j))
5459                 return 0;
5460
5461         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5462         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5463         if (!daa_load(&bytes, j))
5464                 return 0;
5465
5466         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5467         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5468         if (!daa_load(&bytes, j))
5469                 return 0;
5470
5471         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5472         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5473         if (!daa_load(&bytes, j))
5474                 return 0;
5475
5476         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5477         bytes.low = 0x00;
5478         if (!daa_load(&bytes, j))
5479                 return 0;
5480
5481         if (!SCI_Control(j, SCI_End))
5482                 return 0;
5483         if (!SCI_WaitLowSCI(j))
5484                 return 0;
5485
5486         bytes.high = 0x07;
5487         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5488         if (!daa_load(&bytes, j))
5489                 return 0;
5490
5491         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5492         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5493         if (!daa_load(&bytes, j))
5494                 return 0;
5495
5496         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5497         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5498         if (!daa_load(&bytes, j))
5499                 return 0;
5500
5501         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5502         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5503         if (!daa_load(&bytes, j))
5504                 return 0;
5505
5506         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5507         bytes.low = 0x00;
5508         if (!daa_load(&bytes, j))
5509                 return 0;
5510
5511         if (!SCI_Control(j, SCI_End))
5512                 return 0;
5513         if (!SCI_WaitLowSCI(j))
5514                 return 0;
5515
5516         bytes.high = 0x08;
5517         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5518         if (!daa_load(&bytes, j))
5519                 return 0;
5520
5521         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5522         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5523         if (!daa_load(&bytes, j))
5524                 return 0;
5525
5526         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5527         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5528         if (!daa_load(&bytes, j))
5529                 return 0;
5530
5531         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5532         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5533         if (!daa_load(&bytes, j))
5534                 return 0;
5535
5536         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5537         bytes.low = 0x00;
5538         if (!daa_load(&bytes, j))
5539                 return 0;
5540
5541         if (!SCI_Control(j, SCI_End))
5542                 return 0;
5543         if (!SCI_WaitLowSCI(j))
5544                 return 0;
5545
5546         bytes.high = 0x09;
5547         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5548         if (!daa_load(&bytes, j))
5549                 return 0;
5550
5551         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5552         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5553         if (!daa_load(&bytes, j))
5554                 return 0;
5555
5556         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5557         bytes.low = 0x00;
5558         if (!daa_load(&bytes, j))
5559                 return 0;
5560
5561         if (!SCI_Control(j, SCI_End))
5562                 return 0;
5563         if (!SCI_WaitLowSCI(j))
5564                 return 0;
5565
5566         bytes.high = 0x0A;
5567         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5568         if (!daa_load(&bytes, j))
5569                 return 0;
5570
5571         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5572         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5573         if (!daa_load(&bytes, j))
5574                 return 0;
5575
5576         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5577         bytes.low = 0x00;
5578         if (!daa_load(&bytes, j))
5579                 return 0;
5580
5581         if (!SCI_Control(j, SCI_End))
5582                 return 0;
5583         if (!SCI_WaitLowSCI(j))
5584                 return 0;
5585
5586         bytes.high = 0x0B;
5587         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5588         if (!daa_load(&bytes, j))
5589                 return 0;
5590
5591         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5592         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5593         if (!daa_load(&bytes, j))
5594                 return 0;
5595
5596         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5597         bytes.low = 0x00;
5598         if (!daa_load(&bytes, j))
5599                 return 0;
5600
5601         if (!SCI_Control(j, SCI_End))
5602                 return 0;
5603         if (!SCI_WaitLowSCI(j))
5604                 return 0;
5605
5606         bytes.high = 0x0C;
5607         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5608         if (!daa_load(&bytes, j))
5609                 return 0;
5610
5611         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5612         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5613         if (!daa_load(&bytes, j))
5614                 return 0;
5615
5616         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5617         bytes.low = 0x00;
5618         if (!daa_load(&bytes, j))
5619                 return 0;
5620
5621         if (!SCI_Control(j, SCI_End))
5622                 return 0;
5623         if (!SCI_WaitLowSCI(j))
5624                 return 0;
5625
5626         bytes.high = 0x0D;
5627         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5628         if (!daa_load(&bytes, j))
5629                 return 0;
5630
5631         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5632         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5633         if (!daa_load(&bytes, j))
5634                 return 0;
5635
5636         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5637         bytes.low = 0x00;
5638         if (!daa_load(&bytes, j))
5639                 return 0;
5640
5641         if (!SCI_Control(j, SCI_End))
5642                 return 0;
5643         if (!SCI_WaitLowSCI(j))
5644                 return 0;
5645
5646         bytes.high = 0x0E;
5647         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5648         if (!daa_load(&bytes, j))
5649                 return 0;
5650
5651         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5652         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5653         if (!daa_load(&bytes, j))
5654                 return 0;
5655
5656         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5657         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5658         if (!daa_load(&bytes, j))
5659                 return 0;
5660
5661         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5662         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5663         if (!daa_load(&bytes, j))
5664                 return 0;
5665
5666         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5667         bytes.low = 0x00;
5668         if (!daa_load(&bytes, j))
5669                 return 0;
5670
5671         if (!SCI_Control(j, SCI_End))
5672                 return 0;
5673         if (!SCI_WaitLowSCI(j))
5674                 return 0;
5675
5676         bytes.high = 0x0F;
5677         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5678         if (!daa_load(&bytes, j))
5679                 return 0;
5680
5681         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5682         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5683         if (!daa_load(&bytes, j))
5684                 return 0;
5685
5686         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5687         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5688         if (!daa_load(&bytes, j))
5689                 return 0;
5690
5691         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5692         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5693         if (!daa_load(&bytes, j))
5694                 return 0;
5695
5696         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5697         bytes.low = 0x00;
5698         if (!daa_load(&bytes, j))
5699                 return 0;
5700
5701         udelay(32);
5702         j->pld_scrr.byte = inb_p(j->XILINXbase);
5703         if (!SCI_Control(j, SCI_End))
5704                 return 0;
5705
5706         outb_p(j->pld_scrw.byte, j->XILINXbase);
5707
5708         if (ixjdebug & 0x0002)
5709                 printk("DAA Coefficients Loaded\n");
5710
5711         j->flags.pstncheck = 0;
5712         return 1;
5713 }
5714
5715 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5716 {
5717         j->tone_off_time = arg;
5718         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5719
5720                 return -1;
5721         if (ixj_WriteDSPCommand(arg, j))
5722                 return -1;
5723         return 0;
5724 }
5725
5726 static int ixj_get_tone_on(IXJ *j)
5727 {
5728         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5729
5730                 return -1;
5731         return 0;
5732 }
5733
5734 static int ixj_get_tone_off(IXJ *j)
5735 {
5736         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5737
5738                 return -1;
5739         return 0;
5740 }
5741
5742 static void ixj_busytone(IXJ *j)
5743 {
5744         j->flags.ringback = 0;
5745         j->flags.dialtone = 0;
5746         j->flags.busytone = 1;
5747         ixj_set_tone_on(0x07D0, j);
5748         ixj_set_tone_off(0x07D0, j);
5749         ixj_play_tone(j, 27);
5750 }
5751
5752 static void ixj_dialtone(IXJ *j)
5753 {
5754         j->flags.ringback = 0;
5755         j->flags.dialtone = 1;
5756         j->flags.busytone = 0;
5757         if (j->dsp.low == 0x20) {
5758                 return;
5759         } else {
5760                 ixj_set_tone_on(0xFFFF, j);
5761                 ixj_set_tone_off(0x0000, j);
5762                 ixj_play_tone(j, 25);
5763         }
5764 }
5765
5766 static void ixj_cpt_stop(IXJ *j)
5767 {
5768         if(j->tone_state || j->tone_cadence_state)
5769         {
5770                 j->flags.dialtone = 0;
5771                 j->flags.busytone = 0;
5772                 j->flags.ringback = 0;
5773                 ixj_set_tone_on(0x0001, j);
5774                 ixj_set_tone_off(0x0000, j);
5775                 ixj_play_tone(j, 0);
5776                 j->tone_state = j->tone_cadence_state = 0;
5777                 if (j->cadence_t) {
5778                         kfree(j->cadence_t->ce);
5779                         kfree(j->cadence_t);
5780                         j->cadence_t = NULL;
5781                 }
5782         }
5783         if (j->play_mode == -1 && j->rec_mode == -1)
5784                 idle(j);
5785         if (j->play_mode != -1 && j->dsp.low == 0x20)
5786                 ixj_play_start(j);
5787         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5788                 ixj_record_start(j);
5789 }
5790
5791 static void ixj_ringback(IXJ *j)
5792 {
5793         j->flags.busytone = 0;
5794         j->flags.dialtone = 0;
5795         j->flags.ringback = 1;
5796         ixj_set_tone_on(0x0FA0, j);
5797         ixj_set_tone_off(0x2EE0, j);
5798         ixj_play_tone(j, 26);
5799 }
5800
5801 static void ixj_testram(IXJ *j)
5802 {
5803         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5804 }
5805
5806 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5807 {
5808         ixj_cadence *lcp;
5809         IXJ_CADENCE_ELEMENT __user *cep;
5810         IXJ_CADENCE_ELEMENT *lcep;
5811         IXJ_TONE ti;
5812         int err;
5813
5814         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5815         if (lcp == NULL)
5816                 return -ENOMEM;
5817
5818         err = -EFAULT;
5819         if (copy_from_user(&lcp->elements_used,
5820                            &cp->elements_used, sizeof(int)))
5821                 goto out;
5822         if (copy_from_user(&lcp->termination,
5823                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5824                 goto out;
5825         if (get_user(cep, &cp->ce))
5826                 goto out;
5827
5828         err = -EINVAL;
5829         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5830                 goto out;
5831
5832         err = -ENOMEM;
5833         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5834         if (!lcep)
5835                 goto out;
5836
5837         err = -EFAULT;
5838         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5839                 goto out1;
5840
5841         if (j->cadence_t) {
5842                 kfree(j->cadence_t->ce);
5843                 kfree(j->cadence_t);
5844         }
5845         lcp->ce = (void *) lcep;
5846         j->cadence_t = lcp;
5847         j->tone_cadence_state = 0;
5848         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5849         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5850         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5851                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5852                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5853                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5854                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5855                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5856                 ixj_init_tone(j, &ti);
5857         }
5858         ixj_play_tone(j, lcp->ce[0].index);
5859         return 1;
5860 out1:
5861         kfree(lcep);
5862 out:
5863         kfree(lcp);
5864         return err;
5865 }
5866
5867 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5868 {
5869         IXJ_FILTER_CADENCE *lcp;
5870         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5871         if (lcp == NULL) {
5872                 if(ixjdebug & 0x0001) {
5873                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5874                 }
5875                 return -ENOMEM;
5876         }
5877         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5878                 if(ixjdebug & 0x0001) {
5879                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5880                 }
5881                 kfree(lcp);
5882                 return -EFAULT;
5883         }
5884         if (lcp->filter > 5) {
5885                 if(ixjdebug & 0x0001) {
5886                         printk(KERN_INFO "Cadence out of range\n");
5887                 }
5888                 kfree(lcp);
5889                 return -1;
5890         }
5891         j->cadence_f[lcp->filter].state = 0;
5892         j->cadence_f[lcp->filter].enable = lcp->enable;
5893         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5894         j->cadence_f[lcp->filter].on1 = lcp->on1;
5895         j->cadence_f[lcp->filter].on1min = 0;
5896         j->cadence_f[lcp->filter].on1max = 0;
5897         j->cadence_f[lcp->filter].off1 = lcp->off1;
5898         j->cadence_f[lcp->filter].off1min = 0;
5899         j->cadence_f[lcp->filter].off1max = 0;
5900         j->cadence_f[lcp->filter].on2 = lcp->on2;
5901         j->cadence_f[lcp->filter].on2min = 0;
5902         j->cadence_f[lcp->filter].on2max = 0;
5903         j->cadence_f[lcp->filter].off2 = lcp->off2;
5904         j->cadence_f[lcp->filter].off2min = 0;
5905         j->cadence_f[lcp->filter].off2max = 0;
5906         j->cadence_f[lcp->filter].on3 = lcp->on3;
5907         j->cadence_f[lcp->filter].on3min = 0;
5908         j->cadence_f[lcp->filter].on3max = 0;
5909         j->cadence_f[lcp->filter].off3 = lcp->off3;
5910         j->cadence_f[lcp->filter].off3min = 0;
5911         j->cadence_f[lcp->filter].off3max = 0;
5912         if(ixjdebug & 0x0002) {
5913                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5914         }
5915         kfree(lcp);
5916         return 0;
5917 }
5918
5919 static void add_caps(IXJ *j)
5920 {
5921         j->caps = 0;
5922         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5923         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5924         j->caplist[j->caps].captype = vendor;
5925         j->caplist[j->caps].handle = j->caps++;
5926         j->caplist[j->caps].captype = device;
5927         switch (j->cardtype) {
5928         case QTI_PHONEJACK:
5929                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5930                 break;
5931         case QTI_LINEJACK:
5932                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5933                 break;
5934         case QTI_PHONEJACK_LITE:
5935                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5936                 break;
5937         case QTI_PHONEJACK_PCI:
5938                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5939                 break;
5940         case QTI_PHONECARD:
5941                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5942                 break;
5943         }
5944         j->caplist[j->caps].cap = j->cardtype;
5945         j->caplist[j->caps].handle = j->caps++;
5946         strcpy(j->caplist[j->caps].desc, "POTS");
5947         j->caplist[j->caps].captype = port;
5948         j->caplist[j->caps].cap = pots;
5949         j->caplist[j->caps].handle = j->caps++;
5950
5951         /* add devices that can do speaker/mic */
5952         switch (j->cardtype) {
5953         case QTI_PHONEJACK:
5954         case QTI_LINEJACK:
5955         case QTI_PHONEJACK_PCI:
5956         case QTI_PHONECARD:
5957                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5958                 j->caplist[j->caps].captype = port;
5959                 j->caplist[j->caps].cap = speaker;
5960                 j->caplist[j->caps].handle = j->caps++;
5961         default:
5962                 break;
5963         }
5964
5965         /* add devices that can do handset */
5966         switch (j->cardtype) {
5967         case QTI_PHONEJACK:
5968                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5969                 j->caplist[j->caps].captype = port;
5970                 j->caplist[j->caps].cap = handset;
5971                 j->caplist[j->caps].handle = j->caps++;
5972                 break;
5973         default:
5974                 break;
5975         }
5976
5977         /* add devices that can do PSTN */
5978         switch (j->cardtype) {
5979         case QTI_LINEJACK:
5980                 strcpy(j->caplist[j->caps].desc, "PSTN");
5981                 j->caplist[j->caps].captype = port;
5982                 j->caplist[j->caps].cap = pstn;
5983                 j->caplist[j->caps].handle = j->caps++;
5984                 break;
5985         default:
5986                 break;
5987         }
5988
5989         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5990         strcpy(j->caplist[j->caps].desc, "ULAW");
5991         j->caplist[j->caps].captype = codec;
5992         j->caplist[j->caps].cap = ULAW;
5993         j->caplist[j->caps].handle = j->caps++;
5994
5995         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
5996         j->caplist[j->caps].captype = codec;
5997         j->caplist[j->caps].cap = LINEAR16;
5998         j->caplist[j->caps].handle = j->caps++;
5999
6000         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6001         j->caplist[j->caps].captype = codec;
6002         j->caplist[j->caps].cap = LINEAR8;
6003         j->caplist[j->caps].handle = j->caps++;
6004
6005         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6006         j->caplist[j->caps].captype = codec;
6007         j->caplist[j->caps].cap = WSS;
6008         j->caplist[j->caps].handle = j->caps++;
6009
6010         /* software ALAW codec, made from ULAW */
6011         strcpy(j->caplist[j->caps].desc, "ALAW");
6012         j->caplist[j->caps].captype = codec;
6013         j->caplist[j->caps].cap = ALAW;
6014         j->caplist[j->caps].handle = j->caps++;
6015
6016         /* version 12 of the 8020 does the following codecs in a broken way */
6017         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6018                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6019                 j->caplist[j->caps].captype = codec;
6020                 j->caplist[j->caps].cap = G723_63;
6021                 j->caplist[j->caps].handle = j->caps++;
6022
6023                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6024                 j->caplist[j->caps].captype = codec;
6025                 j->caplist[j->caps].cap = G723_53;
6026                 j->caplist[j->caps].handle = j->caps++;
6027
6028                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6029                 j->caplist[j->caps].captype = codec;
6030                 j->caplist[j->caps].cap = TS48;
6031                 j->caplist[j->caps].handle = j->caps++;
6032
6033                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6034                 j->caplist[j->caps].captype = codec;
6035                 j->caplist[j->caps].cap = TS41;
6036                 j->caplist[j->caps].handle = j->caps++;
6037         }
6038
6039         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6040         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6041                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6042                 j->caplist[j->caps].captype = codec;
6043                 j->caplist[j->caps].cap = TS85;
6044                 j->caplist[j->caps].handle = j->caps++;
6045         }
6046
6047         /* 8021 chips can do G728 */
6048         if (j->dsp.low == 0x21) {
6049                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6050                 j->caplist[j->caps].captype = codec;
6051                 j->caplist[j->caps].cap = G728;
6052                 j->caplist[j->caps].handle = j->caps++;
6053         }
6054
6055         /* 8021/8022 chips can do G729 if loaded */
6056         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6057                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6058                 j->caplist[j->caps].captype = codec;
6059                 j->caplist[j->caps].cap = G729;
6060                 j->caplist[j->caps].handle = j->caps++;
6061         }
6062         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6063                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6064                 j->caplist[j->caps].captype = codec;
6065                 j->caplist[j->caps].cap = G729B;
6066                 j->caplist[j->caps].handle = j->caps++;
6067         }
6068 }
6069
6070 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6071 {
6072         int cnt;
6073         int retval = 0;
6074         for (cnt = 0; cnt < j->caps; cnt++) {
6075                 if (pcreq->captype == j->caplist[cnt].captype
6076                     && pcreq->cap == j->caplist[cnt].cap) {
6077                         retval = 1;
6078                         break;
6079                 }
6080         }
6081         return retval;
6082 }
6083
6084 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6085 {
6086         IXJ_TONE ti;
6087         IXJ_FILTER jf;
6088         IXJ_FILTER_RAW jfr;
6089         void __user *argp = (void __user *)arg;
6090
6091         unsigned int raise, mant;
6092         unsigned int minor = iminor(inode);
6093         int board = NUM(inode);
6094
6095         IXJ *j = get_ixj(NUM(inode));
6096
6097         int retval = 0;
6098
6099         /*
6100          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6101          *    This is necessary to keep the DSP from locking up.
6102          */
6103         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6104                 schedule_timeout_interruptible(1);
6105         if (ixjdebug & 0x0040)
6106                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6107         if (minor >= IXJMAX) {
6108                 clear_bit(board, &j->busyflags);
6109                 return -ENODEV;
6110         }
6111         /*
6112          *    Check ioctls only root can use.
6113          */
6114         if (!capable(CAP_SYS_ADMIN)) {
6115                 switch (cmd) {
6116                 case IXJCTL_TESTRAM:
6117                 case IXJCTL_HZ:
6118                         retval = -EPERM;
6119                 }
6120         }
6121         switch (cmd) {
6122         case IXJCTL_TESTRAM:
6123                 ixj_testram(j);
6124                 retval = (j->ssr.high << 8) + j->ssr.low;
6125                 break;
6126         case IXJCTL_CARDTYPE:
6127                 retval = j->cardtype;
6128                 break;
6129         case IXJCTL_SERIAL:
6130                 retval = j->serial;
6131                 break;
6132         case IXJCTL_VERSION:
6133                 {
6134                         char arg_str[100];
6135                         snprintf(arg_str, sizeof(arg_str),
6136                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6137                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6138                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6139                                 retval = -EFAULT;
6140                 }
6141                 break;
6142         case PHONE_RING_CADENCE:
6143                 j->ring_cadence = arg;
6144                 break;
6145         case IXJCTL_CIDCW:
6146                 if(arg) {
6147                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6148                                 retval = -EFAULT;
6149                                 break;
6150                         }
6151                 } else {
6152                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6153                 }
6154                 ixj_write_cidcw(j);
6155                 break;
6156         /* Binary compatbility */
6157         case OLD_PHONE_RING_START:
6158                 arg = 0;
6159                 /* Fall through */
6160         case PHONE_RING_START:
6161                 if(arg) {
6162                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6163                                 retval = -EFAULT;
6164                                 break;
6165                         }
6166                         ixj_write_cid(j);
6167                 } else {
6168                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6169                 }
6170                 ixj_ring_start(j);
6171                 break;
6172         case PHONE_RING_STOP:
6173                 j->flags.cringing = 0;
6174                 if(j->cadence_f[5].enable) {
6175                         j->cadence_f[5].state = 0;
6176                 }
6177                 ixj_ring_off(j);
6178                 break;
6179         case PHONE_RING:
6180                 retval = ixj_ring(j);
6181                 break;
6182         case PHONE_EXCEPTION:
6183                 retval = j->ex.bytes;
6184                 if(j->ex.bits.flash) {
6185                         j->flash_end = 0;
6186                         j->ex.bits.flash = 0;
6187                 }
6188                 j->ex.bits.pstn_ring = 0;
6189                 j->ex.bits.caller_id = 0;
6190                 j->ex.bits.pstn_wink = 0;
6191                 j->ex.bits.f0 = 0;
6192                 j->ex.bits.f1 = 0;
6193                 j->ex.bits.f2 = 0;
6194                 j->ex.bits.f3 = 0;
6195                 j->ex.bits.fc0 = 0;
6196                 j->ex.bits.fc1 = 0;
6197                 j->ex.bits.fc2 = 0;
6198                 j->ex.bits.fc3 = 0;
6199                 j->ex.bits.reserved = 0;
6200                 break;
6201         case PHONE_HOOKSTATE:
6202                 j->ex.bits.hookstate = 0;
6203                 retval = j->hookstate;  //j->r_hook;
6204                 break;
6205         case IXJCTL_SET_LED:
6206                 LED_SetState(arg, j);
6207                 break;
6208         case PHONE_FRAME:
6209                 retval = set_base_frame(j, arg);
6210                 break;
6211         case PHONE_REC_CODEC:
6212                 retval = set_rec_codec(j, arg);
6213                 break;
6214         case PHONE_VAD:
6215                 ixj_vad(j, arg);
6216                 break;
6217         case PHONE_REC_START:
6218                 ixj_record_start(j);
6219                 break;
6220         case PHONE_REC_STOP:
6221                 ixj_record_stop(j);
6222                 break;
6223         case PHONE_REC_DEPTH:
6224                 set_rec_depth(j, arg);
6225                 break;
6226         case PHONE_REC_VOLUME:
6227                 if(arg == -1) {
6228                         retval = get_rec_volume(j);
6229                 }
6230                 else {
6231                         set_rec_volume(j, arg);
6232                         retval = arg;
6233                 }
6234                 break;
6235         case PHONE_REC_VOLUME_LINEAR:
6236                 if(arg == -1) {
6237                         retval = get_rec_volume_linear(j);
6238                 }
6239                 else {
6240                         set_rec_volume_linear(j, arg);
6241                         retval = arg;
6242                 }
6243                 break;
6244         case IXJCTL_DTMF_PRESCALE:
6245                 if(arg == -1) {
6246                         retval = get_dtmf_prescale(j);
6247                 }
6248                 else {
6249                         set_dtmf_prescale(j, arg);
6250                         retval = arg;
6251                 }
6252                 break;
6253         case PHONE_REC_LEVEL:
6254                 retval = get_rec_level(j);
6255                 break;
6256         case IXJCTL_SC_RXG:
6257                 retval = ixj_siadc(j, arg);
6258                 break;
6259         case IXJCTL_SC_TXG:
6260                 retval = ixj_sidac(j, arg);
6261                 break;
6262         case IXJCTL_AEC_START:
6263                 ixj_aec_start(j, arg);
6264                 break;
6265         case IXJCTL_AEC_STOP:
6266                 aec_stop(j);
6267                 break;
6268         case IXJCTL_AEC_GET_LEVEL:
6269                 retval = j->aec_level;
6270                 break;
6271         case PHONE_PLAY_CODEC:
6272                 retval = set_play_codec(j, arg);
6273                 break;
6274         case PHONE_PLAY_START:
6275                 retval = ixj_play_start(j);
6276                 break;
6277         case PHONE_PLAY_STOP:
6278                 ixj_play_stop(j);
6279                 break;
6280         case PHONE_PLAY_DEPTH:
6281                 set_play_depth(j, arg);
6282                 break;
6283         case PHONE_PLAY_VOLUME:
6284                 if(arg == -1) {
6285                         retval = get_play_volume(j);
6286                 }
6287                 else {
6288                         set_play_volume(j, arg);
6289                         retval = arg;
6290                 }
6291                 break;
6292         case PHONE_PLAY_VOLUME_LINEAR:
6293                 if(arg == -1) {
6294                         retval = get_play_volume_linear(j);
6295                 }
6296                 else {
6297                         set_play_volume_linear(j, arg);
6298                         retval = arg;
6299                 }
6300                 break;
6301         case PHONE_PLAY_LEVEL:
6302                 retval = get_play_level(j);
6303                 break;
6304         case IXJCTL_DSP_TYPE:
6305                 retval = (j->dsp.high << 8) + j->dsp.low;
6306                 break;
6307         case IXJCTL_DSP_VERSION:
6308                 retval = (j->ver.high << 8) + j->ver.low;
6309                 break;
6310         case IXJCTL_HZ:
6311                 hertz = arg;
6312                 break;
6313         case IXJCTL_RATE:
6314                 if (arg > hertz)
6315                         retval = -1;
6316                 else
6317                         samplerate = arg;
6318                 break;
6319         case IXJCTL_DRYBUFFER_READ:
6320                 put_user(j->drybuffer, (unsigned long __user *) argp);
6321                 break;
6322         case IXJCTL_DRYBUFFER_CLEAR:
6323                 j->drybuffer = 0;
6324                 break;
6325         case IXJCTL_FRAMES_READ:
6326                 put_user(j->framesread, (unsigned long __user *) argp);
6327                 break;
6328         case IXJCTL_FRAMES_WRITTEN:
6329                 put_user(j->frameswritten, (unsigned long __user *) argp);
6330                 break;
6331         case IXJCTL_READ_WAIT:
6332                 put_user(j->read_wait, (unsigned long __user *) argp);
6333                 break;
6334         case IXJCTL_WRITE_WAIT:
6335                 put_user(j->write_wait, (unsigned long __user *) argp);
6336                 break;
6337         case PHONE_MAXRINGS:
6338                 j->maxrings = arg;
6339                 break;
6340         case PHONE_SET_TONE_ON_TIME:
6341                 ixj_set_tone_on(arg, j);
6342                 break;
6343         case PHONE_SET_TONE_OFF_TIME:
6344                 ixj_set_tone_off(arg, j);
6345                 break;
6346         case PHONE_GET_TONE_ON_TIME:
6347                 if (ixj_get_tone_on(j)) {
6348                         retval = -1;
6349                 } else {
6350                         retval = (j->ssr.high << 8) + j->ssr.low;
6351                 }
6352                 break;
6353         case PHONE_GET_TONE_OFF_TIME:
6354                 if (ixj_get_tone_off(j)) {
6355                         retval = -1;
6356                 } else {
6357                         retval = (j->ssr.high << 8) + j->ssr.low;
6358                 }
6359                 break;
6360         case PHONE_PLAY_TONE:
6361                 if (!j->tone_state)
6362                         retval = ixj_play_tone(j, arg);
6363                 else
6364                         retval = -1;
6365                 break;
6366         case PHONE_GET_TONE_STATE:
6367                 retval = j->tone_state;
6368                 break;
6369         case PHONE_DTMF_READY:
6370                 retval = j->ex.bits.dtmf_ready;
6371                 break;
6372         case PHONE_GET_DTMF:
6373                 if (ixj_hookstate(j)) {
6374                         if (j->dtmf_rp != j->dtmf_wp) {
6375                                 retval = j->dtmfbuffer[j->dtmf_rp];
6376                                 j->dtmf_rp++;
6377                                 if (j->dtmf_rp == 79)
6378                                         j->dtmf_rp = 0;
6379                                 if (j->dtmf_rp == j->dtmf_wp) {
6380                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6381                                 }
6382                         }
6383                 }
6384                 break;
6385         case PHONE_GET_DTMF_ASCII:
6386                 if (ixj_hookstate(j)) {
6387                         if (j->dtmf_rp != j->dtmf_wp) {
6388                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6389                                 case 10:
6390                                         retval = 42;    /* '*'; */
6391
6392                                         break;
6393                                 case 11:
6394                                         retval = 48;    /*'0'; */
6395
6396                                         break;
6397                                 case 12:
6398                                         retval = 35;    /*'#'; */
6399
6400                                         break;
6401                                 case 28:
6402                                         retval = 65;    /*'A'; */
6403
6404                                         break;
6405                                 case 29:
6406                                         retval = 66;    /*'B'; */
6407
6408                                         break;
6409                                 case 30:
6410                                         retval = 67;    /*'C'; */
6411
6412                                         break;
6413                                 case 31:
6414                                         retval = 68;    /*'D'; */
6415
6416                                         break;
6417                                 default:
6418                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6419                                         break;
6420                                 }
6421                                 j->dtmf_rp++;
6422                                 if (j->dtmf_rp == 79)
6423                                         j->dtmf_rp = 0;
6424                                 if(j->dtmf_rp == j->dtmf_wp)
6425                                 {
6426                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6427                                 }
6428                         }
6429                 }
6430                 break;
6431         case PHONE_DTMF_OOB:
6432                 j->flags.dtmf_oob = arg;
6433                 break;
6434         case PHONE_DIALTONE:
6435                 ixj_dialtone(j);
6436                 break;
6437         case PHONE_BUSY:
6438                 ixj_busytone(j);
6439                 break;
6440         case PHONE_RINGBACK:
6441                 ixj_ringback(j);
6442                 break;
6443         case PHONE_WINK:
6444                 if(j->cardtype == QTI_PHONEJACK)
6445                         retval = -1;
6446                 else
6447                         retval = ixj_wink(j);
6448                 break;
6449         case PHONE_CPT_STOP:
6450                 ixj_cpt_stop(j);
6451                 break;
6452         case PHONE_QUERY_CODEC:
6453         {
6454                 struct phone_codec_data pd;
6455                 int val;
6456                 int proto_size[] = {
6457                         -1,
6458                         12, 10, 16, 9, 8, 48, 5,
6459                         40, 40, 80, 40, 40, 6
6460                 };
6461                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6462                         retval = -EFAULT;
6463                         break;
6464                 }
6465                 if(pd.type<1 || pd.type>13) {
6466                         retval = -EPROTONOSUPPORT;
6467                         break;
6468                 }
6469                 if(pd.type<G729)
6470                         val=proto_size[pd.type];
6471                 else switch(j->baseframe.low)
6472                 {
6473                         case 0xA0:val=2*proto_size[pd.type];break;
6474                         case 0x50:val=proto_size[pd.type];break;
6475                         default:val=proto_size[pd.type]*3;break;
6476                 }
6477                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6478                 if(copy_to_user(argp, &pd, sizeof(pd)))
6479                         retval = -EFAULT;
6480                 break;
6481         }
6482         case IXJCTL_DSP_IDLE:
6483                 idle(j);
6484                 break;
6485         case IXJCTL_MIXER:
6486                 if ((arg & 0xff) == 0xff)
6487                         retval = ixj_get_mixer(arg, j);
6488                 else
6489                         ixj_mixer(arg, j);
6490                 break;
6491         case IXJCTL_DAA_COEFF_SET:
6492                 switch (arg) {
6493                 case DAA_US:
6494                         DAA_Coeff_US(j);
6495                         retval = ixj_daa_write(j);
6496                         break;
6497                 case DAA_UK:
6498                         DAA_Coeff_UK(j);
6499                         retval = ixj_daa_write(j);
6500                         break;
6501                 case DAA_FRANCE:
6502                         DAA_Coeff_France(j);
6503                         retval = ixj_daa_write(j);
6504                         break;
6505                 case DAA_GERMANY:
6506                         DAA_Coeff_Germany(j);
6507                         retval = ixj_daa_write(j);
6508                         break;
6509                 case DAA_AUSTRALIA:
6510                         DAA_Coeff_Australia(j);
6511                         retval = ixj_daa_write(j);
6512                         break;
6513                 case DAA_JAPAN:
6514                         DAA_Coeff_Japan(j);
6515                         retval = ixj_daa_write(j);
6516                         break;
6517                 default:
6518                         retval = 1;
6519                         break;
6520                 }
6521                 break;
6522         case IXJCTL_DAA_AGAIN:
6523                 ixj_daa_cr4(j, arg | 0x02);
6524                 break;
6525         case IXJCTL_PSTN_LINETEST:
6526                 retval = ixj_linetest(j);
6527                 break;
6528         case IXJCTL_VMWI:
6529                 ixj_write_vmwi(j, arg);
6530                 break;
6531         case IXJCTL_CID:
6532                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6533                         retval = -EFAULT;
6534                 j->ex.bits.caller_id = 0;
6535                 break;
6536         case IXJCTL_WINK_DURATION:
6537                 j->winktime = arg;
6538                 break;
6539         case IXJCTL_PORT:
6540                 if (arg)
6541                         retval = ixj_set_port(j, arg);
6542                 else
6543                         retval = j->port;
6544                 break;
6545         case IXJCTL_POTS_PSTN:
6546                 retval = ixj_set_pots(j, arg);
6547                 break;
6548         case PHONE_CAPABILITIES:
6549                 add_caps(j);
6550                 retval = j->caps;
6551                 break;
6552         case PHONE_CAPABILITIES_LIST:
6553                 add_caps(j);
6554                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6555                         retval = -EFAULT;
6556                 break;
6557         case PHONE_CAPABILITIES_CHECK:
6558                 {
6559                         struct phone_capability cap;
6560                         if (copy_from_user(&cap, argp, sizeof(cap)))
6561                                 retval = -EFAULT;
6562                         else {
6563                                 add_caps(j);
6564                                 retval = capabilities_check(j, &cap);
6565                         }
6566                 }
6567                 break;
6568         case PHONE_PSTN_SET_STATE:
6569                 daa_set_mode(j, arg);
6570                 break;
6571         case PHONE_PSTN_GET_STATE:
6572                 retval = j->daa_mode;
6573                 j->ex.bits.pstn_ring = 0;
6574                 break;
6575         case IXJCTL_SET_FILTER:
6576                 if (copy_from_user(&jf, argp, sizeof(jf)))
6577                         retval = -EFAULT;
6578                 retval = ixj_init_filter(j, &jf);
6579                 break;
6580         case IXJCTL_SET_FILTER_RAW:
6581                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6582                         retval = -EFAULT;
6583                 else
6584                         retval = ixj_init_filter_raw(j, &jfr);
6585                 break;
6586         case IXJCTL_GET_FILTER_HIST:
6587                 if(arg<0||arg>3)
6588                         retval = -EINVAL;
6589                 else
6590                         retval = j->filter_hist[arg];
6591                 break;
6592         case IXJCTL_INIT_TONE:
6593                 if (copy_from_user(&ti, argp, sizeof(ti)))
6594                         retval = -EFAULT;
6595                 else
6596                         retval = ixj_init_tone(j, &ti);
6597                 break;
6598         case IXJCTL_TONE_CADENCE:
6599                 retval = ixj_build_cadence(j, argp);
6600                 break;
6601         case IXJCTL_FILTER_CADENCE:
6602                 retval = ixj_build_filter_cadence(j, argp);
6603                 break;
6604         case IXJCTL_SIGCTL:
6605                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6606                         retval = -EFAULT;
6607                         break;
6608                 }
6609                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6610                 if(j->sigdef.event < 33) {
6611                         raise = 1;
6612                         for(mant = 0; mant < j->sigdef.event; mant++){
6613                                 raise *= 2;
6614                         }
6615                         if(j->sigdef.signal)
6616                                 j->ex_sig.bytes |= raise;
6617                         else
6618                                 j->ex_sig.bytes &= (raise^0xffff);
6619                 }
6620                 break;
6621         case IXJCTL_INTERCOM_STOP:
6622                 if(arg < 0 || arg >= IXJMAX)
6623                         return -EINVAL;
6624                 j->intercom = -1;
6625                 ixj_record_stop(j);
6626                 ixj_play_stop(j);
6627                 idle(j);
6628                 get_ixj(arg)->intercom = -1;
6629                 ixj_record_stop(get_ixj(arg));
6630                 ixj_play_stop(get_ixj(arg));
6631                 idle(get_ixj(arg));
6632                 break;
6633         case IXJCTL_INTERCOM_START:
6634                 if(arg < 0 || arg >= IXJMAX)
6635                         return -EINVAL;
6636                 j->intercom = arg;
6637                 ixj_record_start(j);
6638                 ixj_play_start(j);
6639                 get_ixj(arg)->intercom = board;
6640                 ixj_play_start(get_ixj(arg));
6641                 ixj_record_start(get_ixj(arg));
6642                 break;
6643         }
6644         if (ixjdebug & 0x0040)
6645                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6646         clear_bit(board, &j->busyflags);
6647         return retval;
6648 }
6649
6650 static int ixj_fasync(int fd, struct file *file_p, int mode)
6651 {
6652         IXJ *j = get_ixj(NUM(file_p->f_dentry->d_inode));
6653
6654         return fasync_helper(fd, file_p, mode, &j->async_queue);
6655 }
6656
6657 static struct file_operations ixj_fops =
6658 {
6659         .owner          = THIS_MODULE,
6660         .read           = ixj_enhanced_read,
6661         .write          = ixj_enhanced_write,
6662         .poll           = ixj_poll,
6663         .ioctl          = ixj_ioctl,
6664         .release        = ixj_release,
6665         .fasync         = ixj_fasync
6666 };
6667
6668 static int ixj_linetest(IXJ *j)
6669 {
6670         j->flags.pstncheck = 1; /* Testing */
6671         j->flags.pstn_present = 0; /* Assume the line is not there */
6672
6673         daa_int_read(j);        /*Clear DAA Interrupt flags */
6674         /* */
6675         /* Hold all relays in the normally de-energized position. */
6676         /* */
6677
6678         j->pld_slicw.bits.rly1 = 0;
6679         j->pld_slicw.bits.rly2 = 0;
6680         j->pld_slicw.bits.rly3 = 0;
6681         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6682         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6683
6684         outb_p(j->pld_scrw.byte, j->XILINXbase);
6685         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6686         if (j->pld_slicr.bits.potspstn) {
6687                 j->flags.pots_pstn = 1;
6688                 j->flags.pots_correct = 0;
6689                 LED_SetState(0x4, j);
6690         } else {
6691                 j->flags.pots_pstn = 0;
6692                 j->pld_slicw.bits.rly1 = 0;
6693                 j->pld_slicw.bits.rly2 = 0;
6694                 j->pld_slicw.bits.rly3 = 1;
6695                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6696                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6697
6698                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6699                 daa_set_mode(j, SOP_PU_CONVERSATION);
6700                 msleep(1000);
6701                 daa_int_read(j);
6702                 daa_set_mode(j, SOP_PU_RESET);
6703                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6704                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6705                         LED_SetState(0x4, j);
6706                         j->pld_slicw.bits.rly3 = 0;
6707                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6708                 } else {
6709                         j->flags.pots_correct = 1;
6710                         LED_SetState(0x8, j);
6711                         j->pld_slicw.bits.rly1 = 1;
6712                         j->pld_slicw.bits.rly2 = 0;
6713                         j->pld_slicw.bits.rly3 = 0;
6714                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6715                 }
6716         }
6717         j->pld_slicw.bits.rly3 = 0;
6718         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6719         daa_set_mode(j, SOP_PU_CONVERSATION);
6720         msleep(1000);
6721         daa_int_read(j);
6722         daa_set_mode(j, SOP_PU_RESET);
6723         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6724                 j->pstn_sleeptil = jiffies + (hertz / 4);
6725                 j->flags.pstn_present = 1;
6726         } else {
6727                 j->flags.pstn_present = 0;
6728         }
6729         if (j->flags.pstn_present) {
6730                 if (j->flags.pots_correct) {
6731                         LED_SetState(0xA, j);
6732                 } else {
6733                         LED_SetState(0x6, j);
6734                 }
6735         } else {
6736                 if (j->flags.pots_correct) {
6737                         LED_SetState(0x9, j);
6738                 } else {
6739                         LED_SetState(0x5, j);
6740                 }
6741         }
6742         j->flags.pstncheck = 0; /* Testing */
6743         return j->flags.pstn_present;
6744 }
6745
6746 static int ixj_selfprobe(IXJ *j)
6747 {
6748         unsigned short cmd;
6749         int cnt;
6750         BYTES bytes;
6751
6752         init_waitqueue_head(&j->poll_q);
6753         init_waitqueue_head(&j->read_q);
6754         init_waitqueue_head(&j->write_q);
6755
6756         while(atomic_read(&j->DSPWrite) > 0)
6757                 atomic_dec(&j->DSPWrite);
6758         if (ixjdebug & 0x0002)
6759                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6760         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6761
6762         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6763                 return -1;
6764 /* The read values of the SSR should be 0x00 for the IDLE command */
6765         if (j->ssr.low || j->ssr.high)
6766                 return -1;
6767         if (ixjdebug & 0x0002)
6768                 printk(KERN_INFO "Get Device ID Code\n");
6769         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6770                 return -1;
6771         j->dsp.low = j->ssr.low;
6772         j->dsp.high = j->ssr.high;
6773         if (ixjdebug & 0x0002)
6774                 printk(KERN_INFO "Get Device Version Code\n");
6775         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6776                 return -1;
6777         j->ver.low = j->ssr.low;
6778         j->ver.high = j->ssr.high;
6779         if (!j->cardtype) {
6780                 if (j->dsp.low == 0x21) {
6781                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6782                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6783 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6784                         bytes.low = inb_p(j->XILINXbase + 0x02);
6785                         if (bytes.low == bytes.high)    /*  Register is read only on */
6786                                 /*  Internet PhoneJack Lite */
6787                          {
6788                                 j->cardtype = QTI_PHONEJACK_LITE;
6789                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6790                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6791                                         return -1;
6792                                 }
6793                                 j->pld_slicw.pcib.e1 = 1;
6794                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6795                         } else {
6796                                 j->cardtype = QTI_LINEJACK;
6797
6798                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6799                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6800                                         return -1;
6801                                 }
6802                         }
6803                 } else if (j->dsp.low == 0x22) {
6804                         j->cardtype = QTI_PHONEJACK_PCI;
6805                         request_region(j->XILINXbase, 4, "ixj control");
6806                         j->pld_slicw.pcib.e1 = 1;
6807                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6808                 } else
6809                         j->cardtype = QTI_PHONEJACK;
6810         } else {
6811                 switch (j->cardtype) {
6812                 case QTI_PHONEJACK:
6813                         if (!j->dsp.low != 0x20) {
6814                                 j->dsp.high = 0x80;
6815                                 j->dsp.low = 0x20;
6816                                 ixj_WriteDSPCommand(0x3800, j);
6817                                 j->ver.low = j->ssr.low;
6818                                 j->ver.high = j->ssr.high;
6819                         }
6820                         break;
6821                 case QTI_LINEJACK:
6822                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6823                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6824                                 return -1;
6825                         }
6826                         break;
6827                 case QTI_PHONEJACK_LITE:
6828                 case QTI_PHONEJACK_PCI:
6829                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6830                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6831                                 return -1;
6832                         }
6833                         j->pld_slicw.pcib.e1 = 1;
6834                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6835                         break;
6836                 case QTI_PHONECARD:
6837                         break;
6838                 }
6839         }
6840         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6841                 if (ixjdebug & 0x0002)
6842                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6843                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6844                         return -1;
6845                 if (ixjdebug & 0x0002)
6846                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6847                 if (j->cardtype == QTI_PHONEJACK) {
6848                         cmd = 0x9FF2;
6849                 } else {
6850                         cmd = 0x9FF5;
6851                 }
6852                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6853                         return -1;
6854         } else {
6855                 if (set_base_frame(j, 30) != 30)
6856                         return -1;
6857                 if (ixjdebug & 0x0002)
6858                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6859                 if (j->cardtype == QTI_PHONECARD) {
6860                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6861                                 return -1;
6862                 }
6863                 if (j->cardtype == QTI_LINEJACK) {
6864                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6865                                 return -1;
6866                         if (ixjdebug & 0x0002)
6867                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6868                         j->pld_clock.byte = 0;
6869                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6870                 }
6871         }
6872
6873         if (j->dsp.low == 0x20) {
6874                 if (ixjdebug & 0x0002)
6875                         printk(KERN_INFO "Configure GPIO pins\n");
6876                 j->gpio.bytes.high = 0x09;
6877 /*  bytes.low = 0xEF;  0xF7 */
6878                 j->gpio.bits.gpio1 = 1;
6879                 j->gpio.bits.gpio2 = 1;
6880                 j->gpio.bits.gpio3 = 0;
6881                 j->gpio.bits.gpio4 = 1;
6882                 j->gpio.bits.gpio5 = 1;
6883                 j->gpio.bits.gpio6 = 1;
6884                 j->gpio.bits.gpio7 = 1;
6885                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6886                 if (ixjdebug & 0x0002)
6887                         printk(KERN_INFO "Enable SLIC\n");
6888                 j->gpio.bytes.high = 0x0B;
6889                 j->gpio.bytes.low = 0x00;
6890                 j->gpio.bits.gpio1 = 0;
6891                 j->gpio.bits.gpio2 = 1;
6892                 j->gpio.bits.gpio5 = 0;
6893                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6894                 j->port = PORT_POTS;
6895         } else {
6896                 if (j->cardtype == QTI_LINEJACK) {
6897                         LED_SetState(0x1, j);
6898                         msleep(100);
6899                         LED_SetState(0x2, j);
6900                         msleep(100);
6901                         LED_SetState(0x4, j);
6902                         msleep(100);
6903                         LED_SetState(0x8, j);
6904                         msleep(100);
6905                         LED_SetState(0x0, j);
6906                         daa_get_version(j);
6907                         if (ixjdebug & 0x0002)
6908                                 printk("Loading DAA Coefficients\n");
6909                         DAA_Coeff_US(j);
6910                         if (!ixj_daa_write(j)) {
6911                                 printk("DAA write failed on board %d\n", j->board);
6912                                 return -1;
6913                         }
6914                         if(!ixj_daa_cid_reset(j)) {
6915                                 printk("DAA CID reset failed on board %d\n", j->board);
6916                                 return -1;
6917                         }
6918                         j->flags.pots_correct = 0;
6919                         j->flags.pstn_present = 0;
6920                         ixj_linetest(j);
6921                         if (j->flags.pots_correct) {
6922                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6923
6924                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6925                                 j->pld_slicw.bits.rly1 = 1;
6926                                 j->pld_slicw.bits.spken = 1;
6927                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6928                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6929 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6930                                 j->port = PORT_POTS;
6931                         }
6932                         ixj_set_port(j, PORT_PSTN);
6933                         ixj_set_pots(j, 1);
6934                         if (ixjdebug & 0x0002)
6935                                 printk(KERN_INFO "Enable Mixer\n");
6936                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6937                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6938
6939                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6940                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6941
6942                         ixj_mixer(0x0480, j);   /*FM Left mute */
6943                         ixj_mixer(0x0580, j);   /*FM Right mute */
6944
6945                         ixj_mixer(0x0680, j);   /*CD Left mute */
6946                         ixj_mixer(0x0780, j);   /*CD Right mute */
6947
6948                         ixj_mixer(0x0880, j);   /*Line Left mute */
6949                         ixj_mixer(0x0980, j);   /*Line Right mute */
6950
6951                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6952                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6953
6954                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6955                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6956
6957                         ixj_mixer(0x0E80, j);   /*Mic mute */
6958
6959                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6960
6961                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6962                         ixj_mixer(0x110C, j);
6963
6964
6965                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6966                         ixj_mixer(0x1401, j);
6967
6968                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6969                         ixj_mixer(0x1501, j);
6970
6971                         ixj_mixer(0x1700, j);   /*Clock select */
6972
6973                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6974
6975                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6976
6977                         if (ixjdebug & 0x0002)
6978                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6979                         j->cadence_f[4].state = 0;
6980                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
6981                         j->cadence_f[4].off1 = 0;
6982                         j->cadence_f[4].on2 = 0;
6983                         j->cadence_f[4].off2 = 0;
6984                         j->cadence_f[4].on3 = 0;
6985                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
6986                         j->pstn_last_rmr = jiffies;
6987
6988                 } else {
6989                         if (j->cardtype == QTI_PHONECARD) {
6990                                 ixj_WriteDSPCommand(0xCF07, j);
6991                                 ixj_WriteDSPCommand(0x00B0, j);
6992                                 ixj_set_port(j, PORT_SPEAKER);
6993                         } else {
6994                                 ixj_set_port(j, PORT_POTS);
6995                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6996 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6997                         }
6998                 }
6999         }
7000
7001         j->intercom = -1;
7002         j->framesread = j->frameswritten = 0;
7003         j->read_wait = j->write_wait = 0;
7004         j->rxreadycheck = j->txreadycheck = 0;
7005
7006         /* initialise the DTMF prescale to a sensible value */
7007         if (j->cardtype == QTI_LINEJACK) {
7008                 set_dtmf_prescale(j, 0x10);
7009         } else {
7010                 set_dtmf_prescale(j, 0x40);
7011         }
7012         set_play_volume(j, 0x100);
7013         set_rec_volume(j, 0x100);
7014
7015         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7016                 return -1;
7017 /* The read values of the SSR should be 0x00 for the IDLE command */
7018         if (j->ssr.low || j->ssr.high)
7019                 return -1;
7020
7021         if (ixjdebug & 0x0002)
7022                 printk(KERN_INFO "Enable Line Monitor\n");
7023
7024         if (ixjdebug & 0x0002)
7025                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7026
7027         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7028                 return -1;
7029
7030         if (ixjdebug & 0x002)
7031                 printk(KERN_INFO "Enable DTMF Detectors\n");
7032
7033         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7034                 return -1;
7035
7036         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7037                 return -1;
7038
7039         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7040
7041         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7042
7043         j->ex.bits.dtmf_ready = 0;
7044         j->dtmf_state = 0;
7045         j->dtmf_wp = j->dtmf_rp = 0;
7046         j->rec_mode = j->play_mode = -1;
7047         j->flags.ringing = 0;
7048         j->maxrings = MAXRINGS;
7049         j->ring_cadence = USA_RING_CADENCE;
7050         j->drybuffer = 0;
7051         j->winktime = 320;
7052         j->flags.dtmf_oob = 0;
7053         for (cnt = 0; cnt < 4; cnt++)
7054                 j->cadence_f[cnt].enable = 0;
7055         /* must be a device on the specified address */
7056         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7057
7058         /* Set up the default signals for events */
7059         for (cnt = 0; cnt < 35; cnt++)
7060                 j->ixj_signals[cnt] = SIGIO;
7061
7062         /* Set the excetion signal enable flags */
7063         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7064         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 =
7065         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;
7066 #ifdef IXJ_DYN_ALLOC
7067         j->fskdata = NULL;
7068 #endif
7069         j->fskdcnt = 0;
7070         j->cidcw_wait = 0;
7071
7072         /* Register with the Telephony for Linux subsystem */
7073         j->p.f_op = &ixj_fops;
7074         j->p.open = ixj_open;
7075         j->p.board = j->board;
7076         phone_register_device(&j->p, PHONE_UNIT_ANY);
7077
7078         ixj_init_timer(j);
7079         ixj_add_timer(j);
7080         return 0;
7081 }
7082
7083 /*
7084  *      Exported service for pcmcia card handling
7085  */
7086
7087 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7088 {
7089         IXJ *j = ixj_alloc();
7090
7091         j->board = 0;
7092
7093         j->DSPbase = dsp;
7094         j->XILINXbase = xilinx;
7095         j->cardtype = QTI_PHONECARD;
7096         ixj_selfprobe(j);
7097         return j;
7098 }
7099
7100 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7101
7102 static int ixj_get_status_proc(char *buf)
7103 {
7104         int len;
7105         int cnt;
7106         IXJ *j;
7107         len = 0;
7108         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7109         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7110         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7111         len += sprintf(buf + len, "\nUsing old telephony API");
7112         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7113
7114         for (cnt = 0; cnt < IXJMAX; cnt++) {
7115                 j = get_ixj(cnt);
7116                 if(j==NULL)
7117                         continue;
7118                 if (j->DSPbase) {
7119                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7120                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7121                         if (j->cardtype != QTI_PHONEJACK)
7122                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7123                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7124                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7125                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7126                         switch (j->cardtype) {
7127                         case (QTI_PHONEJACK):
7128                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7129                                 break;
7130                         case (QTI_LINEJACK):
7131                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7132                                 if (j->flags.g729_loaded)
7133                                         len += sprintf(buf + len, " w/G.729 A/B");
7134                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7135                                 break;
7136                         case (QTI_PHONEJACK_LITE):
7137                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7138                                 if (j->flags.g729_loaded)
7139                                         len += sprintf(buf + len, " w/G.729 A/B");
7140                                 break;
7141                         case (QTI_PHONEJACK_PCI):
7142                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7143                                 if (j->flags.g729_loaded)
7144                                         len += sprintf(buf + len, " w/G.729 A/B");
7145                                 break;
7146                         case (QTI_PHONECARD):
7147                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7148                                 if (j->flags.g729_loaded)
7149                                         len += sprintf(buf + len, " w/G.729 A/B");
7150                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7151                                 if (!j->pccr1.bits.drf)
7152                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7153                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7154                                 break;
7155                         default:
7156                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7157                                 break;
7158                         }
7159                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7160                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7161                         add_caps(j);
7162                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7163                         if (j->dsp.low != 0x20)
7164                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7165                         if (j->flags.cidsent)
7166                                 len += sprintf(buf + len, "\nCaller ID data sent");
7167                         else
7168                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7169
7170                         len += sprintf(buf + len, "\nPlay CODEC ");
7171                         switch (j->play_codec) {
7172                         case G723_63:
7173                                 len += sprintf(buf + len, "G.723.1 6.3");
7174                                 break;
7175                         case G723_53:
7176                                 len += sprintf(buf + len, "G.723.1 5.3");
7177                                 break;
7178                         case TS85:
7179                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7180                                 break;
7181                         case TS48:
7182                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7183                                 break;
7184                         case TS41:
7185                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7186                                 break;
7187                         case G728:
7188                                 len += sprintf(buf + len, "G.728");
7189                                 break;
7190                         case G729:
7191                                 len += sprintf(buf + len, "G.729");
7192                                 break;
7193                         case G729B:
7194                                 len += sprintf(buf + len, "G.729B");
7195                                 break;
7196                         case ULAW:
7197                                 len += sprintf(buf + len, "uLaw");
7198                                 break;
7199                         case ALAW:
7200                                 len += sprintf(buf + len, "aLaw");
7201                                 break;
7202                         case LINEAR16:
7203                                 len += sprintf(buf + len, "16 bit Linear");
7204                                 break;
7205                         case LINEAR8:
7206                                 len += sprintf(buf + len, "8 bit Linear");
7207                                 break;
7208                         case WSS:
7209                                 len += sprintf(buf + len, "Windows Sound System");
7210                                 break;
7211                         default:
7212                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7213                                 break;
7214                         }
7215                         len += sprintf(buf + len, "\nRecord CODEC ");
7216                         switch (j->rec_codec) {
7217                         case G723_63:
7218                                 len += sprintf(buf + len, "G.723.1 6.3");
7219                                 break;
7220                         case G723_53:
7221                                 len += sprintf(buf + len, "G.723.1 5.3");
7222                                 break;
7223                         case TS85:
7224                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7225                                 break;
7226                         case TS48:
7227                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7228                                 break;
7229                         case TS41:
7230                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7231                                 break;
7232                         case G728:
7233                                 len += sprintf(buf + len, "G.728");
7234                                 break;
7235                         case G729:
7236                                 len += sprintf(buf + len, "G.729");
7237                                 break;
7238                         case G729B:
7239                                 len += sprintf(buf + len, "G.729B");
7240                                 break;
7241                         case ULAW:
7242                                 len += sprintf(buf + len, "uLaw");
7243                                 break;
7244                         case ALAW:
7245                                 len += sprintf(buf + len, "aLaw");
7246                                 break;
7247                         case LINEAR16:
7248                                 len += sprintf(buf + len, "16 bit Linear");
7249                                 break;
7250                         case LINEAR8:
7251                                 len += sprintf(buf + len, "8 bit Linear");
7252                                 break;
7253                         case WSS:
7254                                 len += sprintf(buf + len, "Windows Sound System");
7255                                 break;
7256                         default:
7257                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7258                                 break;
7259                         }
7260                         len += sprintf(buf + len, "\nAEC ");
7261                         switch (j->aec_level) {
7262                         case AEC_OFF:
7263                                 len += sprintf(buf + len, "Off");
7264                                 break;
7265                         case AEC_LOW:
7266                                 len += sprintf(buf + len, "Low");
7267                                 break;
7268                         case AEC_MED:
7269                                 len += sprintf(buf + len, "Med");
7270                                 break;
7271                         case AEC_HIGH:
7272                                 len += sprintf(buf + len, "High");
7273                                 break;
7274                         case AEC_AUTO:
7275                                 len += sprintf(buf + len, "Auto");
7276                                 break;
7277                         case AEC_AGC:
7278                                 len += sprintf(buf + len, "AEC/AGC");
7279                                 break;
7280                         default:
7281                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7282                                 break;
7283                         }
7284
7285                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7286                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7287                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7288
7289                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7290
7291                         if (j->cardtype == QTI_LINEJACK) {
7292                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7293                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7294                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7295                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7296                                 switch (j->daa_mode) {
7297                                 case SOP_PU_SLEEP:
7298                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7299                                         break;
7300                                 case SOP_PU_RINGING:
7301                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7302                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7303                                         break;
7304                                 case SOP_PU_CONVERSATION:
7305                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7306                                         break;
7307                                 case SOP_PU_PULSEDIALING:
7308                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7309                                         break;
7310                                 }
7311                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7312                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7313                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7314                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7315                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7316                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7317                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7318                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7319                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7320                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7321                         }
7322                         switch (j->port) {
7323                         case PORT_POTS:
7324                                 len += sprintf(buf + len, "\nPort POTS");
7325                                 break;
7326                         case PORT_PSTN:
7327                                 len += sprintf(buf + len, "\nPort PSTN");
7328                                 break;
7329                         case PORT_SPEAKER:
7330                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7331                                 break;
7332                         case PORT_HANDSET:
7333                                 len += sprintf(buf + len, "\nPort HANDSET");
7334                                 break;
7335                         }
7336                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7337                                 len += sprintf(buf + len, "\nSLIC state ");
7338                                 switch (SLIC_GetState(j)) {
7339                                 case PLD_SLIC_STATE_OC:
7340                                         len += sprintf(buf + len, "OC");
7341                                         break;
7342                                 case PLD_SLIC_STATE_RINGING:
7343                                         len += sprintf(buf + len, "RINGING");
7344                                         break;
7345                                 case PLD_SLIC_STATE_ACTIVE:
7346                                         len += sprintf(buf + len, "ACTIVE");
7347                                         break;
7348                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7349                                         len += sprintf(buf + len, "OHT");
7350                                         break;
7351                                 case PLD_SLIC_STATE_TIPOPEN:
7352                                         len += sprintf(buf + len, "TIPOPEN");
7353                                         break;
7354                                 case PLD_SLIC_STATE_STANDBY:
7355                                         len += sprintf(buf + len, "STANDBY");
7356                                         break;
7357                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7358                                         len += sprintf(buf + len, "APR");
7359                                         break;
7360                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7361                                         len += sprintf(buf + len, "OHTPR");
7362                                         break;
7363                                 default:
7364                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7365                                         break;
7366                                 }
7367                         }
7368                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7369                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7370 #ifdef PERFMON_STATS
7371                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7372                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7373                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7374                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7375                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7376                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7377                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7378                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7379                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7380                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7381                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7382                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7383                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7384                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7385
7386 #endif
7387                         len += sprintf(buf + len, "\n");
7388                 }
7389         }
7390         return len;
7391 }
7392
7393 static int ixj_read_proc(char *page, char **start, off_t off,
7394                               int count, int *eof, void *data)
7395 {
7396         int len = ixj_get_status_proc(page);
7397         if (len <= off+count) *eof = 1;
7398         *start = page + off;
7399         len -= off;
7400         if (len>count) len = count;
7401         if (len<0) len = 0;
7402         return len;
7403 }
7404
7405
7406 static void cleanup(void)
7407 {
7408         int cnt;
7409         IXJ *j;
7410
7411         for (cnt = 0; cnt < IXJMAX; cnt++) {
7412                 j = get_ixj(cnt);
7413                 if(j != NULL && j->DSPbase) {
7414                         if (ixjdebug & 0x0002)
7415                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7416                         del_timer(&j->timer);
7417                         if (j->cardtype == QTI_LINEJACK) {
7418                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7419
7420                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7421                                 j->pld_slicw.bits.rly1 = 0;
7422                                 j->pld_slicw.bits.rly2 = 0;
7423                                 j->pld_slicw.bits.rly3 = 0;
7424                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7425                                 LED_SetState(0x0, j);
7426                                 if (ixjdebug & 0x0002)
7427                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7428                                 release_region(j->XILINXbase, 8);
7429                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7430                                 if (ixjdebug & 0x0002)
7431                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7432                                 release_region(j->XILINXbase, 4);
7433                         }
7434                         kfree(j->read_buffer);
7435                         kfree(j->write_buffer);
7436                         if (j->dev)
7437                                 pnp_device_detach(j->dev);
7438                         if (ixjdebug & 0x0002)
7439                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7440                         phone_unregister_device(&j->p);
7441                         if (ixjdebug & 0x0002)
7442                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7443                         release_region(j->DSPbase, 16);
7444 #ifdef IXJ_DYN_ALLOC
7445                         if (ixjdebug & 0x0002)
7446                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7447                         kfree(j);
7448                         ixj[cnt] = NULL;
7449 #endif
7450                 }
7451         }
7452         if (ixjdebug & 0x0002)
7453                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7454         remove_proc_entry ("ixj", NULL);
7455 }
7456
7457 /* Typedefs */
7458 typedef struct {
7459         BYTE length;
7460         DWORD bits;
7461 } DATABLOCK;
7462
7463 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7464 {
7465         lastLCC = lastLCC & 0xfb;
7466         lastLCC = lastLCC | (byData ? 4 : 0);
7467         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7468
7469         mdelay(1);
7470         lastLCC = lastLCC | 0x01;
7471         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7472
7473         byData = byData << 1;
7474         lastLCC = lastLCC & 0xfe;
7475         mdelay(1);
7476         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7477
7478 }
7479
7480 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7481 {
7482         mdelay(1);
7483         lastLCC = lastLCC | 0x01;
7484         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7485
7486         lastLCC = lastLCC & 0xfe;
7487         mdelay(1);
7488         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7489
7490         return ((inb(wEEPROMAddress) >> 3) & 1);
7491 }
7492
7493 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7494 {
7495         BYTE lastLCC;
7496         WORD wEEPROMAddress = wAddress + 3;
7497         DWORD i;
7498         BYTE byResult;
7499         *pwResult = 0;
7500         lastLCC = inb(wEEPROMAddress);
7501         lastLCC = lastLCC | 0x02;
7502         lastLCC = lastLCC & 0xfe;
7503         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7504
7505         mdelay(1);              /* delay */
7506
7507         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7508         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7509         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7510         for (i = 0; i < 8; i++) {
7511                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7512                 wLoc <<= 1;
7513         }
7514
7515         for (i = 0; i < 16; i++) {
7516                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7517                 *pwResult = (*pwResult << 1) | byResult;
7518         }
7519
7520         mdelay(1);              /* another delay */
7521
7522         lastLCC = lastLCC & 0xfd;
7523         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7524
7525         return 0;
7526 }
7527
7528 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7529 {
7530         WORD wLo, wHi;
7531         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7532                 return 0;
7533         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7534                 return 0;
7535         return (((DWORD) wHi << 16) | wLo);
7536 }
7537
7538 static int dspio[IXJMAX + 1] =
7539 {
7540         0,
7541 };
7542 static int xio[IXJMAX + 1] =
7543 {
7544         0,
7545 };
7546
7547 module_param_array(dspio, int, NULL, 0);
7548 module_param_array(xio, int, NULL, 0);
7549 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7550 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7551 MODULE_LICENSE("GPL");
7552
7553 static void __exit ixj_exit(void)
7554 {
7555         cleanup();
7556 }
7557
7558 static IXJ *new_ixj(unsigned long port)
7559 {
7560         IXJ *res;
7561         if (!request_region(port, 16, "ixj DSP")) {
7562                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7563                 return NULL;
7564         }
7565         res = ixj_alloc();
7566         if (!res) {
7567                 release_region(port, 16);
7568                 printk(KERN_INFO "ixj: out of memory\n");
7569                 return NULL;
7570         }
7571         res->DSPbase = port;
7572         return res;
7573 }
7574
7575 static int __init ixj_probe_isapnp(int *cnt)
7576 {
7577         int probe = 0;
7578         int func = 0x110;
7579         struct pnp_dev *dev = NULL, *old_dev = NULL;
7580
7581         while (1) {
7582                 do {
7583                         IXJ *j;
7584                         int result;
7585
7586                         old_dev = dev;
7587                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7588                                          ISAPNP_FUNCTION(func), old_dev);
7589                         if (!dev || !dev->card)
7590                                 break;
7591                         result = pnp_device_attach(dev);
7592                         if (result < 0) {
7593                                 printk("pnp attach failed %d \n", result);
7594                                 break;
7595                         }
7596                         if (pnp_activate_dev(dev) < 0) {
7597                                 printk("pnp activate failed (out of resources?)\n");
7598                                 pnp_device_detach(dev);
7599                                 return -ENOMEM;
7600                         }
7601
7602                         if (!pnp_port_valid(dev, 0)) {
7603                                 pnp_device_detach(dev);
7604                                 return -ENODEV;
7605                         }
7606
7607                         j = new_ixj(pnp_port_start(dev, 0));
7608                         if (!j)
7609                                 break;
7610
7611                         if (func != 0x110)
7612                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7613
7614                         switch (func) {
7615                         case (0x110):
7616                                 j->cardtype = QTI_PHONEJACK;
7617                                 break;
7618                         case (0x310):
7619                                 j->cardtype = QTI_LINEJACK;
7620                                 break;
7621                         case (0x410):
7622                                 j->cardtype = QTI_PHONEJACK_LITE;
7623                                 break;
7624                         }
7625                         j->board = *cnt;
7626                         probe = ixj_selfprobe(j);
7627                         if(!probe) {
7628                                 j->serial = dev->card->serial;
7629                                 j->dev = dev;
7630                                 switch (func) {
7631                                 case 0x110:
7632                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7633                                         break;
7634                                 case 0x310:
7635                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7636                                         break;
7637                                 case 0x410:
7638                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7639                                         break;
7640                                 }
7641                         }
7642                         ++*cnt;
7643                 } while (dev);
7644                 if (func == 0x410)
7645                         break;
7646                 if (func == 0x310)
7647                         func = 0x410;
7648                 if (func == 0x110)
7649                         func = 0x310;
7650                 dev = NULL;
7651         }
7652         return probe;
7653 }
7654
7655 static int __init ixj_probe_isa(int *cnt)
7656 {
7657         int i, probe;
7658
7659         /* Use passed parameters for older kernels without PnP */
7660         for (i = 0; i < IXJMAX; i++) {
7661                 if (dspio[i]) {
7662                         IXJ *j = new_ixj(dspio[i]);
7663
7664                         if (!j)
7665                                 break;
7666
7667                         j->XILINXbase = xio[i];
7668                         j->cardtype = 0;
7669
7670                         j->board = *cnt;
7671                         probe = ixj_selfprobe(j);
7672                         j->dev = NULL;
7673                         ++*cnt;
7674                 }
7675         }
7676         return 0;
7677 }
7678
7679 static int __init ixj_probe_pci(int *cnt)
7680 {
7681         struct pci_dev *pci = NULL;
7682         int i, probe = 0;
7683         IXJ *j = NULL;
7684
7685         for (i = 0; i < IXJMAX - *cnt; i++) {
7686                 pci = pci_find_device(0x15E2, 0x0500, pci);
7687                 if (!pci)
7688                         break;
7689
7690                 if (pci_enable_device(pci))
7691                         break;
7692                 j = new_ixj(pci_resource_start(pci, 0));
7693                 if (!j)
7694                         break;
7695
7696                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7697                 j->XILINXbase = j->DSPbase + 0x10;
7698                 j->cardtype = QTI_PHONEJACK_PCI;
7699                 j->board = *cnt;
7700                 probe = ixj_selfprobe(j);
7701                 if (!probe)
7702                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7703                 ++*cnt;
7704         }
7705         return probe;
7706 }
7707
7708 static int __init ixj_init(void)
7709 {
7710         int cnt = 0;
7711         int probe = 0;
7712
7713         cnt = 0;
7714
7715         /* These might be no-ops, see above. */
7716         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7717                 return probe;
7718         }
7719         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7720                 return probe;
7721         }
7722         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7723                 return probe;
7724         }
7725         printk(KERN_INFO "ixj driver initialized.\n");
7726         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7727         return probe;
7728 }
7729
7730 module_init(ixj_init);
7731 module_exit(ixj_exit);
7732
7733 static void DAA_Coeff_US(IXJ *j)
7734 {
7735         int i;
7736
7737         j->daa_country = DAA_US;
7738         /*----------------------------------------------- */
7739         /* CAO */
7740         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7741                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7742         }
7743
7744 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7745         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7746         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7747         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7748         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7749         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7750         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7751         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7752         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7753 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7754         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7755         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7756         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7757         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7758         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7759         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7760         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7761         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7762 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7763         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7764         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7765         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7766         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7767         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7768         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7769         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7770         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7771 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7772         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7773         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7774         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7775         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7776         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7777         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7778         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7779         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7780 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7781         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7782         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7783         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7784         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7785 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7786         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7787         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7788         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7789         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7790 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7791         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7792         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7793         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7794         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7795         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7796         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7797         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7798         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7799 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7800         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7801         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7802         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7803         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7804         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7805         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7806         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7807         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7808 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7809         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7810         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7811         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7812         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7813         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7817 /* ;  (10K, 0.68uF) */
7818         /*  */
7819         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7820         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7821         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7822         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7823         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7824         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7825         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7826         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7827         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7828         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7829         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7830         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7831         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7832         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7833         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7834         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7835         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7836         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7837
7838         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7839         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7840         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7841         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7842         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7843
7844         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7845 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7846 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7847 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7848 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7849 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7850 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7851 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7852 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7853         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7854 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7855 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7856 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7857 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7858 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7859 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7860 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7861 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7862 /* */
7863         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7864 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7865 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7866 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7867 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7868
7869         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7870         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7871         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7872         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7873         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7874         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7875         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7876         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7877         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7878 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7879         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7880         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7881         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7882         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7883         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7884         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7885         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7886         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7887 /*  */
7888         /* ;CR Registers */
7889         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7890         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7891 /* Config. Reg. 1 (dialing)       (cr1):05 */
7892         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7893 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7894         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7895 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7896         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7897 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7898         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7899         /* Config. Reg. 5 (Version)       (cr5):02 */
7900         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7901         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7902         /*  */
7903         /* ;xr Registers */
7904         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7905
7906         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7907         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7908
7909         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7910 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7911         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7912 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7913         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7914         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7915
7916         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7917 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7918         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7919 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7920         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7921 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7922         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7923         /*  */
7924         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7925         /*                                       12,33,5A,C3 ;  770 Hz   */
7926         /*                                       13,3C,5B,32 ;  852 Hz   */
7927         /*                                       1D,1B,5C,CC ;  941 Hz   */
7928
7929         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7930         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7931         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7932         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7933 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7934         /*                                       EC,1D,52,22 ;  1336 Hz   */
7935         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7936         /*                                       9B,3B,51,25 ;  1633 Hz   */
7937         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7938         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7939         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7940         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7941 }
7942
7943 static void DAA_Coeff_UK(IXJ *j)
7944 {
7945         int i;
7946
7947         j->daa_country = DAA_UK;
7948         /*----------------------------------------------- */
7949         /* CAO */
7950         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7951                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7952         }
7953
7954 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7955         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7956         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7957         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7958         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7959         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7960         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7961         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7962         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7963 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7964         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7965         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7966         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7967         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7968         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7969         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7970         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7971         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7972 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7973         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7974         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7975         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7976         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7977         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7978         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7979         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7980         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7981 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
7982         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7983         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
7984         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
7985         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
7986         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
7987         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
7988         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
7989         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7990 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
7991         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
7992         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
7993         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7994         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7995 /* Bytes for AR-filter        (09): E2,27,10,D6 */
7996         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
7997         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
7998         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7999         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8000 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8001         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8002         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8003         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8004         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8005         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8006         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8007         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8008         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8009 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8010         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8011         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8012         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8013         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8014         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8015         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8016         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8017         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8018 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8019         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8020         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8021         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8022         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8023         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8027 /* ; idle */
8028         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8029         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8030         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8031         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8032         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8033         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8034         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8035         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8036         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8037 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8038         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8039         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8040         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8041         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8042         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8043         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8044         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8045         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8046 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8047         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8048         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8049         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8050         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8051 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8052         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8053         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8054         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8055         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8056         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8057         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8058         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8059         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8060 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8061         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8062         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8063         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8064         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8065         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8066         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8067         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8068         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8069 /* ;CR Registers */
8070         /* Config. Reg. 0 (filters)        (cr0):FF */
8071         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8072 /* Config. Reg. 1 (dialing)        (cr1):05 */
8073         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8074 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8075         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8076 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8077         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8078 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8079         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8080         /* Config. Reg. 5 (Version)        (cr5):02 */
8081         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8082         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8083         /* ;xr Registers */
8084         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8085
8086         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8087         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8088
8089         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8090         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8091
8092         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8093 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8094         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8095 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8096         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8097 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8098         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8099 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8100         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8101 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8102         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8103         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8104         /*                                       12,33,5A,C3    ;  770 Hz   */
8105         /*                                       13,3C,5B,32    ;  852 Hz   */
8106         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8107
8108         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8109         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8110         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8111         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8112 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8113         /*                                       EC,1D,52,22    ;  1336 Hz   */
8114         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8115         /*                                       9B,3B,51,25    ;  1633 Hz   */
8116         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8117         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8118         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8119         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8120 }
8121
8122
8123 static void DAA_Coeff_France(IXJ *j)
8124 {
8125         int i;
8126
8127         j->daa_country = DAA_FRANCE;
8128         /*----------------------------------------------- */
8129         /* CAO */
8130         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8131                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8132         }
8133
8134 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8135         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8136         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8137         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8138         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8139         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8140         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8141         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8142         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8143 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8144         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8145         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8146         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8147         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8148         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8149         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8150         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8151         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8152 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8153         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8154         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8155         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8156         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8157         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8158         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8159         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8160         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8161 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8162         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8163         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8164         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8165         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8166         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8167         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8168         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8169         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8170 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8171         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8172         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8173         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8174         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8175 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8176         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8177         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8178         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8179         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8180 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8181         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8182         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8183         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8184         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8185         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8186         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8187         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8188         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8189 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8190         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8191         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8192         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8193         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8194         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8195         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8196         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8197         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8198 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8199         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8200         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8201         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8202         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8203         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8207 /* ; idle */
8208         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8209         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8210         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8211         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8212         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8213         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8214         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8215         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8216         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8217 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8218         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8219         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8220         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8221         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8222         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8223         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8224         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8225         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8226 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8227         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8228         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8229         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8230         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8231 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8232         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8233         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8234         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8235         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8236         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8237         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8238         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8239         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8240 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8241         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8242         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8243         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8244         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8245         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8246         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8247         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8248         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8249 /* ;CR Registers */
8250         /* Config. Reg. 0 (filters)        (cr0):FF */
8251         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8252 /* Config. Reg. 1 (dialing)        (cr1):05 */
8253         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8254 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8255         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8256 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8257         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8258 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8259         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8260         /* Config. Reg. 5 (Version)        (cr5):02 */
8261         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8262         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8263         /* ;xr Registers */
8264         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8265
8266         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8267         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8268
8269         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8270         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8271
8272         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8273 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8274         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8275 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8276         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8277 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8278         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8279 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8280         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8281 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8282         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8283         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8284         /*                                       12,33,5A,C3    ;  770 Hz   */
8285         /*                                       13,3C,5B,32    ;  852 Hz   */
8286         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8287
8288         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8289         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8290         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8291         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8292 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8293         /*                                       EC,1D,52,22    ;  1336 Hz   */
8294         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8295         /*                                       9B,3B,51,25    ;  1633 Hz   */
8296         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8297         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8298         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8299         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8300 }
8301
8302
8303 static void DAA_Coeff_Germany(IXJ *j)
8304 {
8305         int i;
8306
8307         j->daa_country = DAA_GERMANY;
8308         /*----------------------------------------------- */
8309         /* CAO */
8310         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8311                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8312         }
8313
8314 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8315         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8316         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8317         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8318         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8319         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8320         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8321         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8322         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8323 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8324         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8325         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8326         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8327         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8328         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8329         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8330         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8331         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8332 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8333         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8334         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8335         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8336         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8337         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8338         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8339         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8340         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8341 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8342         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8343         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8344         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8345         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8346         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8347         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8348         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8349         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8350 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8351         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8352         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8353         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8354         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8355 /* Bytes for AR-filter        (09): 72,42,13,4B */
8356         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8357         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8358         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8359         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8360 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8361         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8362         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8363         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8364         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8365         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8366         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8367         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8368         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8369 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8370         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8371         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8372         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8373         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8374         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8375         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8376         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8377         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8378 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8379         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8380         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8381         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8382         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8383         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8387 /* ;  (10K, 0.68uF) */
8388         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8389         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8390         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8391         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8392         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8393         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8394         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8395         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8396         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8397 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8398         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8399         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8400         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8401         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8402         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8403         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8404         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8405         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8406 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8407         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8408         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8409         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8410         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8411 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8412         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8413         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8414         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8415         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8416         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8417         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8418         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8419         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8420 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8421         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8422         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8423         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8424         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8425         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8426         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8427         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8428         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8429 /* ;CR Registers */
8430         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8431         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8432 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8433         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8434 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8435         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8436 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8437         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8438 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8439         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8440         /* Config. Reg. 5 (Version)        (cr5):02 */
8441         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8442         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8443         /* ;xr Registers */
8444         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8445
8446         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8447         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8448
8449         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8450         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8451
8452         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8453 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8454         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8455 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8456         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8457 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8458         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8459 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8460         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8461 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8462         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8463         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8464         /*                                       12,33,5A,C3    ;  770 Hz   */
8465         /*                                       13,3C,5B,32    ;  852 Hz   */
8466         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8467
8468         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8469         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8470         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8471         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8472 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8473         /*                                       EC,1D,52,22    ;  1336 Hz   */
8474         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8475         /*                                       9B,3B,51,25    ;  1633 Hz   */
8476         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8477         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8478         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8479         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8480 }
8481
8482
8483 static void DAA_Coeff_Australia(IXJ *j)
8484 {
8485         int i;
8486
8487         j->daa_country = DAA_AUSTRALIA;
8488         /*----------------------------------------------- */
8489         /* CAO */
8490         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8491                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8492         }
8493
8494 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8495         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8496         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8497         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8498         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8499         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8500         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8501         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8502         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8503 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8504         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8505         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8506         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8507         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8508         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8509         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8510         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8511         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8512 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8513         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8514         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8515         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8516         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8517         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8518         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8519         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8520         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8521 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8522         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8523         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8524         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8525         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8526         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8527         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8528         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8529         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8530 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8531         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8532         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8533         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8534         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8535 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8536         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8537         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8538         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8539         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8540 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8541         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8542         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8543         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8544         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8545         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8546         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8547         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8548         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8549 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8550         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8551         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8552         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8553         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8554         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8555         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8556         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8557         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8558 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8559         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8560         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8561         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8562         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8563         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8567 /* ;  idle */
8568         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8569         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8570         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8571         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8572         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8573         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8574         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8575         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8576         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8577 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8578         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8579         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8580         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8581         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8582         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8583         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8584         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8585         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8586 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8587         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8588         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8589         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8590         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8591 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8592         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8593         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8594         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8595         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8596         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8597         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8598         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8599         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8600 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8601         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8602         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8603         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8604         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8605         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8606         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8607         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8608         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8609 /* ;CR Registers */
8610         /* Config. Reg. 0 (filters)        (cr0):FF */
8611         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8612 /* Config. Reg. 1 (dialing)        (cr1):05 */
8613         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8614 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8615         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8616 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8617         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8618 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8619         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8620         /* Config. Reg. 5 (Version)        (cr5):02 */
8621         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8622         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8623         /* ;xr Registers */
8624         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8625
8626         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8627         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8628
8629         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8630         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8631
8632         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8633 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8634         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8635 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8636         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8637 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8638         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8639 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8640         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8641 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8642         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8643
8644         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8645         /*                                       12,33,5A,C3    ;  770 Hz   */
8646         /*                                       13,3C,5B,32    ;  852 Hz   */
8647         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8648         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8649         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8650         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8651         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8652
8653         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8654         /*                                       EC,1D,52,22    ;  1336 Hz   */
8655         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8656         /*                                       9B,3B,51,25    ;  1633 Hz   */
8657         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8658         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8659         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8660         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8661 }
8662
8663 static void DAA_Coeff_Japan(IXJ *j)
8664 {
8665         int i;
8666
8667         j->daa_country = DAA_JAPAN;
8668         /*----------------------------------------------- */
8669         /* CAO */
8670         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8671                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8672         }
8673
8674 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8675         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8676         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8677         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8678         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8679         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8680         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8681         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8682         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8683 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8684         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8685         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8686         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8687         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8688         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8689         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8690         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8691         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8692 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8693         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8694         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8695         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8696         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8697         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8698         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8699         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8700         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8701 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8702         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8703         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8704         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8705         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8706         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8707         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8708         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8709         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8710 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8711         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8712         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8713         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8714         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8715 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8716         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8717         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8718         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8719         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8720 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8721         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8722         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8723         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8724         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8725         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8726         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8727         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8728         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8729 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8730         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8731         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8732         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8733         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8734         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8735         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8736         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8737         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8738 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8739         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8740         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8741         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8742         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8743         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8747 /* ;  idle */
8748         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8749         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8750         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8751         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8752         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8753         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8754         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8755         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8756         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8757 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8758         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8759         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8760         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8761         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8762         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8763         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8764         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8765         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8766 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8767         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8768         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8769         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8770         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8771 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8772         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8773         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8774         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8775         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8776         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8777         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8778         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8779         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8780 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8781         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8782         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8783         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8784         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8785         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8786         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8787         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8788         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8789 /* ;CR Registers */
8790         /* Config. Reg. 0 (filters)        (cr0):FF */
8791         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8792 /* Config. Reg. 1 (dialing)        (cr1):05 */
8793         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8794 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8795         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8796 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8797         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8798 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8799         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8800         /* Config. Reg. 5 (Version)        (cr5):02 */
8801         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8802         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8803         /* ;xr Registers */
8804         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8805
8806         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8807         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8808
8809         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8810         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8811
8812         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8813 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8814         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8815 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8816         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8817 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8818         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8819 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8820         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8821 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8822         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8823         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8824         /*                                       12,33,5A,C3    ;  770 Hz   */
8825         /*                                       13,3C,5B,32    ;  852 Hz   */
8826         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8827
8828         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8829         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8830         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8831         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8832 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8833         /*                                       EC,1D,52,22    ;  1336 Hz   */
8834         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8835         /*                                       9B,3B,51,25    ;  1633 Hz   */
8836         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8837         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8838         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8839         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8840 }
8841
8842 static s16 tone_table[][19] =
8843 {
8844         {                       /* f20_50[] 11 */
8845                 32538,          /* A1 = 1.985962 */
8846                  -32325,        /* A2 = -0.986511 */
8847                  -343,          /* B2 = -0.010493 */
8848                  0,             /* B1 = 0 */
8849                  343,           /* B0 = 0.010493 */
8850                  32619,         /* A1 = 1.990906 */
8851                  -32520,        /* A2 = -0.992462 */
8852                  19179,         /* B2 = 0.585327 */
8853                  -19178,        /* B1 = -1.170593 */
8854                  19179,         /* B0 = 0.585327 */
8855                  32723,         /* A1 = 1.997314 */
8856                  -32686,        /* A2 = -0.997528 */
8857                  9973,          /* B2 = 0.304352 */
8858                  -9955,         /* B1 = -0.607605 */
8859                  9973,          /* B0 = 0.304352 */
8860                  7,             /* Internal filter scaling */
8861                  159,           /* Minimum in-band energy threshold */
8862                  21,            /* 21/32 in-band to broad-band ratio */
8863                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8864         },
8865         {                       /* f133_200[] 12 */
8866                 32072,          /* A1 = 1.95752 */
8867                  -31896,        /* A2 = -0.973419 */
8868                  -435,          /* B2 = -0.013294 */
8869                  0,             /* B1 = 0 */
8870                  435,           /* B0 = 0.013294 */
8871                  32188,         /* A1 = 1.9646 */
8872                  -32400,        /* A2 = -0.98877 */
8873                  15139,         /* B2 = 0.462036 */
8874                  -14882,        /* B1 = -0.908356 */
8875                  15139,         /* B0 = 0.462036 */
8876                  32473,         /* A1 = 1.981995 */
8877                  -32524,        /* A2 = -0.992584 */
8878                  23200,         /* B2 = 0.708008 */
8879                  -23113,        /* B1 = -1.410706 */
8880                  23200,         /* B0 = 0.708008 */
8881                  7,             /* Internal filter scaling */
8882                  159,           /* Minimum in-band energy threshold */
8883                  21,            /* 21/32 in-band to broad-band ratio */
8884                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8885         },
8886         {                       /* f300 13 */
8887                 31769,          /* A1 = -1.939026 */
8888                  -32584,        /* A2 = 0.994385 */
8889                  -475,          /* B2 = -0.014522 */
8890                  0,             /* B1 = 0.000000 */
8891                  475,           /* B0 = 0.014522 */
8892                  31789,         /* A1 = -1.940247 */
8893                  -32679,        /* A2 = 0.997284 */
8894                  17280,         /* B2 = 0.527344 */
8895                  -16865,        /* B1 = -1.029358 */
8896                  17280,         /* B0 = 0.527344 */
8897                  31841,         /* A1 = -1.943481 */
8898                  -32681,        /* A2 = 0.997345 */
8899                  543,           /* B2 = 0.016579 */
8900                  -525,          /* B1 = -0.032097 */
8901                  543,           /* B0 = 0.016579 */
8902                  5,             /* Internal filter scaling */
8903                  159,           /* Minimum in-band energy threshold */
8904                  21,            /* 21/32 in-band to broad-band ratio */
8905                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8906         },
8907         {                       /* f300_420[] 14 */
8908                 30750,          /* A1 = 1.876892 */
8909                  -31212,        /* A2 = -0.952515 */
8910                  -804,          /* B2 = -0.024541 */
8911                  0,             /* B1 = 0 */
8912                  804,           /* B0 = 0.024541 */
8913                  30686,         /* A1 = 1.872925 */
8914                  -32145,        /* A2 = -0.980988 */
8915                  14747,         /* B2 = 0.450043 */
8916                  -13703,        /* B1 = -0.836395 */
8917                  14747,         /* B0 = 0.450043 */
8918                  31651,         /* A1 = 1.931824 */
8919                  -32321,        /* A2 = -0.986389 */
8920                  24425,         /* B2 = 0.745422 */
8921                  -23914,        /* B1 = -1.459595 */
8922                  24427,         /* B0 = 0.745483 */
8923                  7,             /* Internal filter scaling */
8924                  159,           /* Minimum in-band energy threshold */
8925                  21,            /* 21/32 in-band to broad-band ratio */
8926                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8927         },
8928         {                       /* f330 15 */
8929                 31613,          /* A1 = -1.929565 */
8930                  -32646,        /* A2 = 0.996277 */
8931                  -185,          /* B2 = -0.005657 */
8932                  0,             /* B1 = 0.000000 */
8933                  185,           /* B0 = 0.005657 */
8934                  31620,         /* A1 = -1.929932 */
8935                  -32713,        /* A2 = 0.998352 */
8936                  19253,         /* B2 = 0.587585 */
8937                  -18566,        /* B1 = -1.133179 */
8938                  19253,         /* B0 = 0.587585 */
8939                  31674,         /* A1 = -1.933228 */
8940                  -32715,        /* A2 = 0.998413 */
8941                  2575,          /* B2 = 0.078590 */
8942                  -2495,         /* B1 = -0.152283 */
8943                  2575,          /* B0 = 0.078590 */
8944                  5,             /* Internal filter scaling */
8945                  159,           /* Minimum in-band energy threshold */
8946                  21,            /* 21/32 in-band to broad-band ratio */
8947                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8948         },
8949         {                       /* f300_425[] 16 */
8950                 30741,          /* A1 = 1.876282 */
8951                  -31475,        /* A2 = -0.960541 */
8952                  -703,          /* B2 = -0.021484 */
8953                  0,             /* B1 = 0 */
8954                  703,           /* B0 = 0.021484 */
8955                  30688,         /* A1 = 1.873047 */
8956                  -32248,        /* A2 = -0.984161 */
8957                  14542,         /* B2 = 0.443787 */
8958                  -13523,        /* B1 = -0.825439 */
8959                  14542,         /* B0 = 0.443817 */
8960                  31494,         /* A1 = 1.922302 */
8961                  -32366,        /* A2 = -0.987762 */
8962                  21577,         /* B2 = 0.658508 */
8963                  -21013,        /* B1 = -1.282532 */
8964                  21577,         /* B0 = 0.658508 */
8965                  7,             /* Internal filter scaling */
8966                  159,           /* Minimum in-band energy threshold */
8967                  21,            /* 21/32 in-band to broad-band ratio */
8968                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8969         },
8970         {                       /* f330_440[] 17 */
8971                 30627,          /* A1 = 1.869324 */
8972                  -31338,        /* A2 = -0.95636 */
8973                  -843,          /* B2 = -0.025749 */
8974                  0,             /* B1 = 0 */
8975                  843,           /* B0 = 0.025749 */
8976                  30550,         /* A1 = 1.864685 */
8977                  -32221,        /* A2 = -0.983337 */
8978                  13594,         /* B2 = 0.414886 */
8979                  -12589,        /* B1 = -0.768402 */
8980                  13594,         /* B0 = 0.414886 */
8981                  31488,         /* A1 = 1.921936 */
8982                  -32358,        /* A2 = -0.987518 */
8983                  24684,         /* B2 = 0.753296 */
8984                  -24029,        /* B1 = -1.466614 */
8985                  24684,         /* B0 = 0.753296 */
8986                  7,             /* Internal filter scaling */
8987                  159,           /* Minimum in-band energy threshold */
8988                  21,            /* 21/32 in-band to broad-band ratio */
8989                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8990         },
8991         {                       /* f340 18 */
8992                 31546,          /* A1 = -1.925476 */
8993                  -32646,        /* A2 = 0.996277 */
8994                  -445,          /* B2 = -0.013588 */
8995                  0,             /* B1 = 0.000000 */
8996                  445,           /* B0 = 0.013588 */
8997                  31551,         /* A1 = -1.925781 */
8998                  -32713,        /* A2 = 0.998352 */
8999                  23884,         /* B2 = 0.728882 */
9000                  -22979,        /* B1 = -1.402527 */
9001                  23884,         /* B0 = 0.728882 */
9002                  31606,         /* A1 = -1.929138 */
9003                  -32715,        /* A2 = 0.998413 */
9004                  863,           /* B2 = 0.026367 */
9005                  -835,          /* B1 = -0.050985 */
9006                  863,           /* B0 = 0.026367 */
9007                  5,             /* Internal filter scaling */
9008                  159,           /* Minimum in-band energy threshold */
9009                  21,            /* 21/32 in-band to broad-band ratio */
9010                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9011         },
9012         {                       /* f350_400[] 19 */
9013                 31006,          /* A1 = 1.892517 */
9014                  -32029,        /* A2 = -0.977448 */
9015                  -461,          /* B2 = -0.014096 */
9016                  0,             /* B1 = 0 */
9017                  461,           /* B0 = 0.014096 */
9018                  30999,         /* A1 = 1.892029 */
9019                  -32487,        /* A2 = -0.991455 */
9020                  11325,         /* B2 = 0.345612 */
9021                  -10682,        /* B1 = -0.651978 */
9022                  11325,         /* B0 = 0.345612 */
9023                  31441,         /* A1 = 1.919067 */
9024                  -32526,        /* A2 = -0.992615 */
9025                  24324,         /* B2 = 0.74231 */
9026                  -23535,        /* B1 = -1.436523 */
9027                  24324,         /* B0 = 0.74231 */
9028                  7,             /* Internal filter scaling */
9029                  159,           /* Minimum in-band energy threshold */
9030                  21,            /* 21/32 in-band to broad-band ratio */
9031                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9032         },
9033         {                       /* f350_440[] */
9034                 30634,          /* A1 = 1.869751 */
9035                  -31533,        /* A2 = -0.962341 */
9036                  -680,          /* B2 = -0.020782 */
9037                  0,             /* B1 = 0 */
9038                  680,           /* B0 = 0.020782 */
9039                  30571,         /* A1 = 1.865906 */
9040                  -32277,        /* A2 = -0.985016 */
9041                  12894,         /* B2 = 0.393524 */
9042                  -11945,        /* B1 = -0.729065 */
9043                  12894,         /* B0 = 0.393524 */
9044                  31367,         /* A1 = 1.91449 */
9045                  -32379,        /* A2 = -0.988129 */
9046                  23820,         /* B2 = 0.726929 */
9047                  -23104,        /* B1 = -1.410217 */
9048                  23820,         /* B0 = 0.726929 */
9049                  7,             /* Internal filter scaling */
9050                  159,           /* Minimum in-band energy threshold */
9051                  21,            /* 21/32 in-band to broad-band ratio */
9052                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9053         },
9054         {                       /* f350_450[] */
9055                 30552,          /* A1 = 1.864807 */
9056                  -31434,        /* A2 = -0.95929 */
9057                  -690,          /* B2 = -0.021066 */
9058                  0,             /* B1 = 0 */
9059                  690,           /* B0 = 0.021066 */
9060                  30472,         /* A1 = 1.859924 */
9061                  -32248,        /* A2 = -0.984161 */
9062                  13385,         /* B2 = 0.408478 */
9063                  -12357,        /* B1 = -0.754242 */
9064                  13385,         /* B0 = 0.408478 */
9065                  31358,         /* A1 = 1.914001 */
9066                  -32366,        /* A2 = -0.987732 */
9067                  26488,         /* B2 = 0.80835 */
9068                  -25692,        /* B1 = -1.568176 */
9069                  26490,         /* B0 = 0.808411 */
9070                  7,             /* Internal filter scaling */
9071                  159,           /* Minimum in-band energy threshold */
9072                  21,            /* 21/32 in-band to broad-band ratio */
9073                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9074         },
9075         {                       /* f360 */
9076                 31397,          /* A1 = -1.916321 */
9077                  -32623,        /* A2 = 0.995605 */
9078                  -117,          /* B2 = -0.003598 */
9079                  0,             /* B1 = 0.000000 */
9080                  117,           /* B0 = 0.003598 */
9081                  31403,         /* A1 = -1.916687 */
9082                  -32700,        /* A2 = 0.997925 */
9083                  3388,          /* B2 = 0.103401 */
9084                  -3240,         /* B1 = -0.197784 */
9085                  3388,          /* B0 = 0.103401 */
9086                  31463,         /* A1 = -1.920410 */
9087                  -32702,        /* A2 = 0.997986 */
9088                  13346,         /* B2 = 0.407288 */
9089                  -12863,        /* B1 = -0.785126 */
9090                  13346,         /* B0 = 0.407288 */
9091                  5,             /* Internal filter scaling */
9092                  159,           /* Minimum in-band energy threshold */
9093                  21,            /* 21/32 in-band to broad-band ratio */
9094                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9095         },
9096         {                       /* f380_420[] */
9097                 30831,          /* A1 = 1.881775 */
9098                  -32064,        /* A2 = -0.978546 */
9099                  -367,          /* B2 = -0.01122 */
9100                  0,             /* B1 = 0 */
9101                  367,           /* B0 = 0.01122 */
9102                  30813,         /* A1 = 1.880737 */
9103                  -32456,        /* A2 = -0.990509 */
9104                  11068,         /* B2 = 0.337769 */
9105                  -10338,        /* B1 = -0.631042 */
9106                  11068,         /* B0 = 0.337769 */
9107                  31214,         /* A1 = 1.905212 */
9108                  -32491,        /* A2 = -0.991577 */
9109                  16374,         /* B2 = 0.499695 */
9110                  -15781,        /* B1 = -0.963196 */
9111                  16374,         /* B0 = 0.499695 */
9112                  7,             /* Internal filter scaling */
9113                  159,           /* Minimum in-band energy threshold */
9114                  21,            /* 21/32 in-band to broad-band ratio */
9115                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9116         },
9117         {                       /* f392 */
9118                 31152,          /* A1 = -1.901428 */
9119                  -32613,        /* A2 = 0.995300 */
9120                  -314,          /* B2 = -0.009605 */
9121                  0,             /* B1 = 0.000000 */
9122                  314,           /* B0 = 0.009605 */
9123                  31156,         /* A1 = -1.901672 */
9124                  -32694,        /* A2 = 0.997742 */
9125                  28847,         /* B2 = 0.880371 */
9126                  -2734,         /* B1 = -0.166901 */
9127                  28847,         /* B0 = 0.880371 */
9128                  31225,         /* A1 = -1.905823 */
9129                  -32696,        /* A2 = 0.997803 */
9130                  462,           /* B2 = 0.014108 */
9131                  -442,          /* B1 = -0.027019 */
9132                  462,           /* B0 = 0.014108 */
9133                  5,             /* Internal filter scaling */
9134                  159,           /* Minimum in-band energy threshold */
9135                  21,            /* 21/32 in-band to broad-band ratio */
9136                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9137         },
9138         {                       /* f400_425[] */
9139                 30836,          /* A1 = 1.882141 */
9140                  -32296,        /* A2 = -0.985596 */
9141                  -324,          /* B2 = -0.009903 */
9142                  0,             /* B1 = 0 */
9143                  324,           /* B0 = 0.009903 */
9144                  30825,         /* A1 = 1.881409 */
9145                  -32570,        /* A2 = -0.993958 */
9146                  16847,         /* B2 = 0.51416 */
9147                  -15792,        /* B1 = -0.963898 */
9148                  16847,         /* B0 = 0.51416 */
9149                  31106,         /* A1 = 1.89856 */
9150                  -32584,        /* A2 = -0.994415 */
9151                  9579,          /* B2 = 0.292328 */
9152                  -9164,         /* B1 = -0.559357 */
9153                  9579,          /* B0 = 0.292328 */
9154                  7,             /* Internal filter scaling */
9155                  159,           /* Minimum in-band energy threshold */
9156                  21,            /* 21/32 in-band to broad-band ratio */
9157                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9158         },
9159         {                       /* f400_440[] */
9160                 30702,          /* A1 = 1.873962 */
9161                  -32134,        /* A2 = -0.980682 */
9162                  -517,          /* B2 = -0.015793 */
9163                  0,             /* B1 = 0 */
9164                  517,           /* B0 = 0.015793 */
9165                  30676,         /* A1 = 1.872375 */
9166                  -32520,        /* A2 = -0.992462 */
9167                  8144,          /* B2 = 0.24855 */
9168                  -7596,         /* B1 = -0.463684 */
9169                  8144,          /* B0 = 0.24855 */
9170                  31084,         /* A1 = 1.897217 */
9171                  -32547,        /* A2 = -0.993256 */
9172                  22713,         /* B2 = 0.693176 */
9173                  -21734,        /* B1 = -1.326599 */
9174                  22713,         /* B0 = 0.693176 */
9175                  7,             /* Internal filter scaling */
9176                  159,           /* Minimum in-band energy threshold */
9177                  21,            /* 21/32 in-band to broad-band ratio */
9178                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9179         },
9180         {                       /* f400_450[] */
9181                 30613,          /* A1 = 1.86853 */
9182                  -32031,        /* A2 = -0.977509 */
9183                  -618,          /* B2 = -0.018866 */
9184                  0,             /* B1 = 0 */
9185                  618,           /* B0 = 0.018866 */
9186                  30577,         /* A1 = 1.866272 */
9187                  -32491,        /* A2 = -0.991577 */
9188                  9612,          /* B2 = 0.293335 */
9189                  -8935,         /* B1 = -0.54541 */
9190                  9612,          /* B0 = 0.293335 */
9191                  31071,         /* A1 = 1.896484 */
9192                  -32524,        /* A2 = -0.992584 */
9193                  21596,         /* B2 = 0.659058 */
9194                  -20667,        /* B1 = -1.261414 */
9195                  21596,         /* B0 = 0.659058 */
9196                  7,             /* Internal filter scaling */
9197                  159,           /* Minimum in-band energy threshold */
9198                  21,            /* 21/32 in-band to broad-band ratio */
9199                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9200         },
9201         {                       /* f420 */
9202                 30914,          /* A1 = -1.886841 */
9203                  -32584,        /* A2 = 0.994385 */
9204                  -426,          /* B2 = -0.013020 */
9205                  0,             /* B1 = 0.000000 */
9206                  426,           /* B0 = 0.013020 */
9207                  30914,         /* A1 = -1.886841 */
9208                  -32679,        /* A2 = 0.997314 */
9209                  17520,         /* B2 = 0.534668 */
9210                  -16471,        /* B1 = -1.005310 */
9211                  17520,         /* B0 = 0.534668 */
9212                  31004,         /* A1 = -1.892334 */
9213                  -32683,        /* A2 = 0.997406 */
9214                  819,           /* B2 = 0.025023 */
9215                  -780,          /* B1 = -0.047619 */
9216                  819,           /* B0 = 0.025023 */
9217                  5,             /* Internal filter scaling */
9218                  159,           /* Minimum in-band energy threshold */
9219                  21,            /* 21/32 in-band to broad-band ratio */
9220                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9221         },
9222 #if 0
9223         {                       /* f425 */
9224                 30881,          /* A1 = -1.884827 */
9225                  -32603,        /* A2 = 0.994965 */
9226                  -496,          /* B2 = -0.015144 */
9227                  0,             /* B1 = 0.000000 */
9228                  496,           /* B0 = 0.015144 */
9229                  30880,         /* A1 = -1.884766 */
9230                  -32692,        /* A2 = 0.997711 */
9231                  24767,         /* B2 = 0.755859 */
9232                  -23290,        /* B1 = -1.421509 */
9233                  24767,         /* B0 = 0.755859 */
9234                  30967,         /* A1 = -1.890076 */
9235                  -32694,        /* A2 = 0.997772 */
9236                  728,           /* B2 = 0.022232 */
9237                  -691,          /* B1 = -0.042194 */
9238                  728,           /* B0 = 0.022232 */
9239                  5,             /* Internal filter scaling */
9240                  159,           /* Minimum in-band energy threshold */
9241                  21,            /* 21/32 in-band to broad-band ratio */
9242                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9243         },
9244 #else
9245         {
9246                 30850,
9247                 -32534,
9248                 -504,
9249                 0,
9250                 504,
9251                 30831,
9252                 -32669,
9253                 24303,
9254                 -22080,
9255                 24303,
9256                 30994,
9257                 -32673,
9258                 1905,
9259                 -1811,
9260                 1905,
9261                 5,
9262                 129,
9263                 17,
9264                 0xff5
9265         },
9266 #endif
9267         {                       /* f425_450[] */
9268                 30646,          /* A1 = 1.870544 */
9269                  -32327,        /* A2 = -0.986572 */
9270                  -287,          /* B2 = -0.008769 */
9271                  0,             /* B1 = 0 */
9272                  287,           /* B0 = 0.008769 */
9273                  30627,         /* A1 = 1.869324 */
9274                  -32607,        /* A2 = -0.995087 */
9275                  13269,         /* B2 = 0.404968 */
9276                  -12376,        /* B1 = -0.755432 */
9277                  13269,         /* B0 = 0.404968 */
9278                  30924,         /* A1 = 1.887512 */
9279                  -32619,        /* A2 = -0.995453 */
9280                  19950,         /* B2 = 0.608826 */
9281                  -18940,        /* B1 = -1.156006 */
9282                  19950,         /* B0 = 0.608826 */
9283                  7,             /* Internal filter scaling */
9284                  159,           /* Minimum in-band energy threshold */
9285                  21,            /* 21/32 in-band to broad-band ratio */
9286                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9287         },
9288         {                       /* f425_475[] */
9289                 30396,          /* A1 = 1.855225 */
9290                  -32014,        /* A2 = -0.97699 */
9291                  -395,          /* B2 = -0.012055 */
9292                  0,             /* B1 = 0 */
9293                  395,           /* B0 = 0.012055 */
9294                  30343,         /* A1 = 1.85199 */
9295                  -32482,        /* A2 = -0.991302 */
9296                  17823,         /* B2 = 0.543945 */
9297                  -16431,        /* B1 = -1.002869 */
9298                  17823,         /* B0 = 0.543945 */
9299                  30872,         /* A1 = 1.884338 */
9300                  -32516,        /* A2 = -0.99231 */
9301                  18124,         /* B2 = 0.553101 */
9302                  -17246,        /* B1 = -1.052673 */
9303                  18124,         /* B0 = 0.553101 */
9304                  7,             /* Internal filter scaling */
9305                  159,           /* Minimum in-band energy threshold */
9306                  21,            /* 21/32 in-band to broad-band ratio */
9307                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9308         },
9309         {                       /* f435 */
9310                 30796,          /* A1 = -1.879639 */
9311                  -32603,        /* A2 = 0.994965 */
9312                  -254,          /* B2 = -0.007762 */
9313                  0,             /* B1 = 0.000000 */
9314                  254,           /* B0 = 0.007762 */
9315                  30793,         /* A1 = -1.879456 */
9316                  -32692,        /* A2 = 0.997711 */
9317                  18934,         /* B2 = 0.577820 */
9318                  -17751,        /* B1 = -1.083496 */
9319                  18934,         /* B0 = 0.577820 */
9320                  30882,         /* A1 = -1.884888 */
9321                  -32694,        /* A2 = 0.997772 */
9322                  1858,          /* B2 = 0.056713 */
9323                  -1758,         /* B1 = -0.107357 */
9324                  1858,          /* B0 = 0.056713 */
9325                  5,             /* Internal filter scaling */
9326                  159,           /* Minimum in-band energy threshold */
9327                  21,            /* 21/32 in-band to broad-band ratio */
9328                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9329         },
9330         {                       /* f440_450[] */
9331                 30641,          /* A1 = 1.870239 */
9332                  -32458,        /* A2 = -0.99057 */
9333                  -155,          /* B2 = -0.004735 */
9334                  0,             /* B1 = 0 */
9335                  155,           /* B0 = 0.004735 */
9336                  30631,         /* A1 = 1.869568 */
9337                  -32630,        /* A2 = -0.995789 */
9338                  11453,         /* B2 = 0.349548 */
9339                  -10666,        /* B1 = -0.651001 */
9340                  11453,         /* B0 = 0.349548 */
9341                  30810,         /* A1 = 1.880554 */
9342                  -32634,        /* A2 = -0.995941 */
9343                  12237,         /* B2 = 0.373474 */
9344                  -11588,        /* B1 = -0.707336 */
9345                  12237,         /* B0 = 0.373474 */
9346                  7,             /* Internal filter scaling */
9347                  159,           /* Minimum in-band energy threshold */
9348                  21,            /* 21/32 in-band to broad-band ratio */
9349                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9350         },
9351         {                       /* f440_480[] */
9352                 30367,          /* A1 = 1.853455 */
9353                  -32147,        /* A2 = -0.981079 */
9354                  -495,          /* B2 = -0.015113 */
9355                  0,             /* B1 = 0 */
9356                  495,           /* B0 = 0.015113 */
9357                  30322,         /* A1 = 1.850769 */
9358                  -32543,        /* A2 = -0.993134 */
9359                  10031,         /* B2 = 0.306152 */
9360                  -9252,         /* B1 = -0.564728 */
9361                  10031,         /* B0 = 0.306152 */
9362                  30770,         /* A1 = 1.878052 */
9363                  -32563,        /* A2 = -0.993774 */
9364                  22674,         /* B2 = 0.691956 */
9365                  -21465,        /* B1 = -1.31012 */
9366                  22674,         /* B0 = 0.691956 */
9367                  7,             /* Internal filter scaling */
9368                  159,           /* Minimum in-band energy threshold */
9369                  21,            /* 21/32 in-band to broad-band ratio */
9370                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9371         },
9372         {                       /* f445 */
9373                 30709,          /* A1 = -1.874329 */
9374                  -32603,        /* A2 = 0.994965 */
9375                  -83,           /* B2 = -0.002545 */
9376                  0,             /* B1 = 0.000000 */
9377                  83,            /* B0 = 0.002545 */
9378                  30704,         /* A1 = -1.874084 */
9379                  -32692,        /* A2 = 0.997711 */
9380                  10641,         /* B2 = 0.324738 */
9381                  -9947,         /* B1 = -0.607147 */
9382                  10641,         /* B0 = 0.324738 */
9383                  30796,         /* A1 = -1.879639 */
9384                  -32694,        /* A2 = 0.997772 */
9385                  10079,         /* B2 = 0.307587 */
9386                  9513,          /* B1 = 0.580688 */
9387                  10079,         /* B0 = 0.307587 */
9388                  5,             /* Internal filter scaling */
9389                  159,           /* Minimum in-band energy threshold */
9390                  21,            /* 21/32 in-band to broad-band ratio */
9391                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9392         },
9393         {                       /* f450 */
9394                 30664,          /* A1 = -1.871643 */
9395                  -32603,        /* A2 = 0.994965 */
9396                  -164,          /* B2 = -0.005029 */
9397                  0,             /* B1 = 0.000000 */
9398                  164,           /* B0 = 0.005029 */
9399                  30661,         /* A1 = -1.871399 */
9400                  -32692,        /* A2 = 0.997711 */
9401                  15294,         /* B2 = 0.466736 */
9402                  -14275,        /* B1 = -0.871307 */
9403                  15294,         /* B0 = 0.466736 */
9404                  30751,         /* A1 = -1.876953 */
9405                  -32694,        /* A2 = 0.997772 */
9406                  3548,          /* B2 = 0.108284 */
9407                  -3344,         /* B1 = -0.204155 */
9408                  3548,          /* B0 = 0.108284 */
9409                  5,             /* Internal filter scaling */
9410                  159,           /* Minimum in-band energy threshold */
9411                  21,            /* 21/32 in-band to broad-band ratio */
9412                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9413         },
9414         {                       /* f452 */
9415                 30653,          /* A1 = -1.870911 */
9416                  -32615,        /* A2 = 0.995361 */
9417                  -209,          /* B2 = -0.006382 */
9418                  0,             /* B1 = 0.000000 */
9419                  209,           /* B0 = 0.006382 */
9420                  30647,         /* A1 = -1.870605 */
9421                  -32702,        /* A2 = 0.997986 */
9422                  18971,         /* B2 = 0.578979 */
9423                  -17716,        /* B1 = -1.081299 */
9424                  18971,         /* B0 = 0.578979 */
9425                  30738,         /* A1 = -1.876099 */
9426                  -32702,        /* A2 = 0.998016 */
9427                  2967,          /* B2 = 0.090561 */
9428                  -2793,         /* B1 = -0.170502 */
9429                  2967,          /* B0 = 0.090561 */
9430                  5,             /* Internal filter scaling */
9431                  159,           /* Minimum in-band energy threshold */
9432                  21,            /* 21/32 in-band to broad-band ratio */
9433                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9434         },
9435         {                       /* f475 */
9436                 30437,          /* A1 = -1.857727 */
9437                  -32603,        /* A2 = 0.994965 */
9438                  -264,          /* B2 = -0.008062 */
9439                  0,             /* B1 = 0.000000 */
9440                  264,           /* B0 = 0.008062 */
9441                  30430,         /* A1 = -1.857300 */
9442                  -32692,        /* A2 = 0.997711 */
9443                  21681,         /* B2 = 0.661682 */
9444                  -20082,        /* B1 = -1.225708 */
9445                  21681,         /* B0 = 0.661682 */
9446                  30526,         /* A1 = -1.863220 */
9447                  -32694,        /* A2 = 0.997742 */
9448                  1559,          /* B2 = 0.047600 */
9449                  -1459,         /* B1 = -0.089096 */
9450                  1559,          /* B0 = 0.047600 */
9451                  5,             /* Internal filter scaling */
9452                  159,           /* Minimum in-band energy threshold */
9453                  21,            /* 21/32 in-band to broad-band ratio */
9454                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9455         },
9456         {                       /* f480_620[] */
9457                 28975,          /* A1 = 1.768494 */
9458                  -30955,        /* A2 = -0.944672 */
9459                  -1026,         /* B2 = -0.03133 */
9460                  0,             /* B1 = 0 */
9461                  1026,          /* B0 = 0.03133 */
9462                  28613,         /* A1 = 1.746399 */
9463                  -32089,        /* A2 = -0.979309 */
9464                  14214,         /* B2 = 0.433807 */
9465                  -12202,        /* B1 = -0.744812 */
9466                  14214,         /* B0 = 0.433807 */
9467                  30243,         /* A1 = 1.845947 */
9468                  -32238,        /* A2 = -0.983856 */
9469                  24825,         /* B2 = 0.757629 */
9470                  -23402,        /* B1 = -1.428345 */
9471                  24825,         /* B0 = 0.757629 */
9472                  7,             /* Internal filter scaling */
9473                  159,           /* Minimum in-band energy threshold */
9474                  21,            /* 21/32 in-band to broad-band ratio */
9475                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9476         },
9477         {                       /* f494 */
9478                 30257,          /* A1 = -1.846741 */
9479                  -32605,        /* A2 = 0.995056 */
9480                  -249,          /* B2 = -0.007625 */
9481                  0,             /* B1 = 0.000000 */
9482                  249,           /* B0 = 0.007625 */
9483                  30247,         /* A1 = -1.846191 */
9484                  -32694,        /* A2 = 0.997772 */
9485                  18088,         /* B2 = 0.552002 */
9486                  -16652,        /* B1 = -1.016418 */
9487                  18088,         /* B0 = 0.552002 */
9488                  30348,         /* A1 = -1.852295 */
9489                  -32696,        /* A2 = 0.997803 */
9490                  2099,          /* B2 = 0.064064 */
9491                  -1953,         /* B1 = -0.119202 */
9492                  2099,          /* B0 = 0.064064 */
9493                  5,             /* Internal filter scaling */
9494                  159,           /* Minimum in-band energy threshold */
9495                  21,            /* 21/32 in-band to broad-band ratio */
9496                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9497         },
9498         {                       /* f500 */
9499                 30202,          /* A1 = -1.843431 */
9500                  -32624,        /* A2 = 0.995622 */
9501                  -413,          /* B2 = -0.012622 */
9502                  0,             /* B1 = 0.000000 */
9503                  413,           /* B0 = 0.012622 */
9504                  30191,         /* A1 = -1.842721 */
9505                  -32714,        /* A2 = 0.998364 */
9506                  25954,         /* B2 = 0.792057 */
9507                  -23890,        /* B1 = -1.458131 */
9508                  25954,         /* B0 = 0.792057 */
9509                  30296,         /* A1 = -1.849172 */
9510                  -32715,        /* A2 = 0.998397 */
9511                  2007,          /* B2 = 0.061264 */
9512                  -1860,         /* B1 = -0.113568 */
9513                  2007,          /* B0 = 0.061264 */
9514                  5,             /* Internal filter scaling */
9515                  159,           /* Minimum in-band energy threshold */
9516                  21,            /* 21/32 in-band to broad-band ratio */
9517                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9518         },
9519         {                       /* f520 */
9520                 30001,          /* A1 = -1.831116 */
9521                  -32613,        /* A2 = 0.995270 */
9522                  -155,          /* B2 = -0.004750 */
9523                  0,             /* B1 = 0.000000 */
9524                  155,           /* B0 = 0.004750 */
9525                  29985,         /* A1 = -1.830200 */
9526                  -32710,        /* A2 = 0.998260 */
9527                  6584,          /* B2 = 0.200928 */
9528                  -6018,         /* B1 = -0.367355 */
9529                  6584,          /* B0 = 0.200928 */
9530                  30105,         /* A1 = -1.837524 */
9531                  -32712,        /* A2 = 0.998291 */
9532                  23812,         /* B2 = 0.726685 */
9533                  -21936,        /* B1 = -1.338928 */
9534                  23812,         /* B0 = 0.726685 */
9535                  5,             /* Internal filter scaling */
9536                  159,           /* Minimum in-band energy threshold */
9537                  21,            /* 21/32 in-band to broad-band ratio */
9538                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9539         },
9540         {                       /* f523 */
9541                 29964,          /* A1 = -1.828918 */
9542                  -32601,        /* A2 = 0.994904 */
9543                  -101,          /* B2 = -0.003110 */
9544                  0,             /* B1 = 0.000000 */
9545                  101,           /* B0 = 0.003110 */
9546                  29949,         /* A1 = -1.827942 */
9547                  -32700,        /* A2 = 0.997925 */
9548                  11041,         /* B2 = 0.336975 */
9549                  -10075,        /* B1 = -0.614960 */
9550                  11041,         /* B0 = 0.336975 */
9551                  30070,         /* A1 = -1.835388 */
9552                  -32702,        /* A2 = 0.997986 */
9553                  16762,         /* B2 = 0.511536 */
9554                  -15437,        /* B1 = -0.942230 */
9555                  16762,         /* B0 = 0.511536 */
9556                  5,             /* Internal filter scaling */
9557                  159,           /* Minimum in-band energy threshold */
9558                  21,            /* 21/32 in-band to broad-band ratio */
9559                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9560         },
9561         {                       /* f525 */
9562                 29936,          /* A1 = -1.827209 */
9563                  -32584,        /* A2 = 0.994415 */
9564                  -91,           /* B2 = -0.002806 */
9565                  0,             /* B1 = 0.000000 */
9566                  91,            /* B0 = 0.002806 */
9567                  29921,         /* A1 = -1.826233 */
9568                  -32688,        /* A2 = 0.997559 */
9569                  11449,         /* B2 = 0.349396 */
9570                  -10426,        /* B1 = -0.636383 */
9571                  11449,         /* B0 = 0.349396 */
9572                  30045,         /* A1 = -1.833862 */
9573                  -32688,        /* A2 = 0.997589 */
9574                  13055,         /* B2 = 0.398407 */
9575                  -12028,        /* B1 = -0.734161 */
9576                  13055,         /* B0 = 0.398407 */
9577                  5,             /* Internal filter scaling */
9578                  159,           /* Minimum in-band energy threshold */
9579                  21,            /* 21/32 in-band to broad-band ratio */
9580                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9581         },
9582         {                       /* f540_660[] */
9583                 28499,          /* A1 = 1.739441 */
9584                  -31129,        /* A2 = -0.949982 */
9585                  -849,          /* B2 = -0.025922 */
9586                  0,             /* B1 = 0 */
9587                  849,           /* B0 = 0.025922 */
9588                  28128,         /* A1 = 1.716797 */
9589                  -32130,        /* A2 = -0.98056 */
9590                  14556,         /* B2 = 0.444214 */
9591                  -12251,        /* B1 = -0.747772 */
9592                  14556,         /* B0 = 0.444244 */
9593                  29667,         /* A1 = 1.81073 */
9594                  -32244,        /* A2 = -0.984039 */
9595                  23038,         /* B2 = 0.703064 */
9596                  -21358,        /* B1 = -1.303589 */
9597                  23040,         /* B0 = 0.703125 */
9598                  7,             /* Internal filter scaling */
9599                  159,           /* Minimum in-band energy threshold */
9600                  21,            /* 21/32 in-band to broad-band ratio */
9601                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9602         },
9603         {                       /* f587 */
9604                 29271,          /* A1 = -1.786560 */
9605                  -32599,        /* A2 = 0.994873 */
9606                  -490,          /* B2 = -0.014957 */
9607                  0,             /* B1 = 0.000000 */
9608                  490,           /* B0 = 0.014957 */
9609                  29246,         /* A1 = -1.785095 */
9610                  -32700,        /* A2 = 0.997925 */
9611                  28961,         /* B2 = 0.883850 */
9612                  -25796,        /* B1 = -1.574463 */
9613                  28961,         /* B0 = 0.883850 */
9614                  29383,         /* A1 = -1.793396 */
9615                  -32700,        /* A2 = 0.997955 */
9616                  1299,          /* B2 = 0.039650 */
9617                  -1169,         /* B1 = -0.071396 */
9618                  1299,          /* B0 = 0.039650 */
9619                  5,             /* Internal filter scaling */
9620                  159,           /* Minimum in-band energy threshold */
9621                  21,            /* 21/32 in-band to broad-band ratio */
9622                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9623         },
9624         {                       /* f590 */
9625                 29230,          /* A1 = -1.784058 */
9626                  -32584,        /* A2 = 0.994415 */
9627                  -418,          /* B2 = -0.012757 */
9628                  0,             /* B1 = 0.000000 */
9629                  418,           /* B0 = 0.012757 */
9630                  29206,         /* A1 = -1.782593 */
9631                  -32688,        /* A2 = 0.997559 */
9632                  36556,         /* B2 = 1.115601 */
9633                  -32478,        /* B1 = -1.982300 */
9634                  36556,         /* B0 = 1.115601 */
9635                  29345,         /* A1 = -1.791077 */
9636                  -32688,        /* A2 = 0.997589 */
9637                  897,           /* B2 = 0.027397 */
9638                  -808,          /* B1 = -0.049334 */
9639                  897,           /* B0 = 0.027397 */
9640                  5,             /* Internal filter scaling */
9641                  159,           /* Minimum in-band energy threshold */
9642                  21,            /* 21/32 in-band to broad-band ratio */
9643                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9644         },
9645         {                       /* f600 */
9646                 29116,          /* A1 = -1.777100 */
9647                  -32603,        /* A2 = 0.994965 */
9648                  -165,          /* B2 = -0.005039 */
9649                  0,             /* B1 = 0.000000 */
9650                  165,           /* B0 = 0.005039 */
9651                  29089,         /* A1 = -1.775452 */
9652                  -32708,        /* A2 = 0.998199 */
9653                  6963,          /* B2 = 0.212494 */
9654                  -6172,         /* B1 = -0.376770 */
9655                  6963,          /* B0 = 0.212494 */
9656                  29237,         /* A1 = -1.784485 */
9657                  -32710,        /* A2 = 0.998230 */
9658                  24197,         /* B2 = 0.738464 */
9659                  -21657,        /* B1 = -1.321899 */
9660                  24197,         /* B0 = 0.738464 */
9661                  5,             /* Internal filter scaling */
9662                  159,           /* Minimum in-band energy threshold */
9663                  21,            /* 21/32 in-band to broad-band ratio */
9664                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9665         },
9666         {                       /* f660 */
9667                 28376,          /* A1 = -1.731934 */
9668                  -32567,        /* A2 = 0.993896 */
9669                  -363,          /* B2 = -0.011102 */
9670                  0,             /* B1 = 0.000000 */
9671                  363,           /* B0 = 0.011102 */
9672                  28337,         /* A1 = -1.729614 */
9673                  -32683,        /* A2 = 0.997434 */
9674                  21766,         /* B2 = 0.664246 */
9675                  -18761,        /* B1 = -1.145081 */
9676                  21766,         /* B0 = 0.664246 */
9677                  28513,         /* A1 = -1.740356 */
9678                  -32686,        /* A2 = 0.997498 */
9679                  2509,          /* B2 = 0.076584 */
9680                  -2196,         /* B1 = -0.134041 */
9681                  2509,          /* B0 = 0.076584 */
9682                  5,             /* Internal filter scaling */
9683                  159,           /* Minimum in-band energy threshold */
9684                  21,            /* 21/32 in-band to broad-band ratio */
9685                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9686         },
9687         {                       /* f700 */
9688                 27844,          /* A1 = -1.699463 */
9689                  -32563,        /* A2 = 0.993744 */
9690                  -366,          /* B2 = -0.011187 */
9691                  0,             /* B1 = 0.000000 */
9692                  366,           /* B0 = 0.011187 */
9693                  27797,         /* A1 = -1.696655 */
9694                  -32686,        /* A2 = 0.997498 */
9695                  22748,         /* B2 = 0.694214 */
9696                  -19235,        /* B1 = -1.174072 */
9697                  22748,         /* B0 = 0.694214 */
9698                  27995,         /* A1 = -1.708740 */
9699                  -32688,        /* A2 = 0.997559 */
9700                  2964,          /* B2 = 0.090477 */
9701                  -2546,         /* B1 = -0.155449 */
9702                  2964,          /* B0 = 0.090477 */
9703                  5,             /* Internal filter scaling */
9704                  159,           /* Minimum in-band energy threshold */
9705                  21,            /* 21/32 in-band to broad-band ratio */
9706                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9707         },
9708         {                       /* f740 */
9709                 27297,          /* A1 = -1.666077 */
9710                  -32551,        /* A2 = 0.993408 */
9711                  -345,          /* B2 = -0.010540 */
9712                  0,             /* B1 = 0.000000 */
9713                  345,           /* B0 = 0.010540 */
9714                  27240,         /* A1 = -1.662598 */
9715                  -32683,        /* A2 = 0.997406 */
9716                  22560,         /* B2 = 0.688477 */
9717                  -18688,        /* B1 = -1.140625 */
9718                  22560,         /* B0 = 0.688477 */
9719                  27461,         /* A1 = -1.676147 */
9720                  -32684,        /* A2 = 0.997467 */
9721                  3541,          /* B2 = 0.108086 */
9722                  -2985,         /* B1 = -0.182220 */
9723                  3541,          /* B0 = 0.108086 */
9724                  5,             /* Internal filter scaling */
9725                  159,           /* Minimum in-band energy threshold */
9726                  21,            /* 21/32 in-band to broad-band ratio */
9727                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9728         },
9729         {                       /* f750 */
9730                 27155,          /* A1 = -1.657410 */
9731                  -32551,        /* A2 = 0.993408 */
9732                  -462,          /* B2 = -0.014117 */
9733                  0,             /* B1 = 0.000000 */
9734                  462,           /* B0 = 0.014117 */
9735                  27097,         /* A1 = -1.653870 */
9736                  -32683,        /* A2 = 0.997406 */
9737                  32495,         /* B2 = 0.991699 */
9738                  -26776,        /* B1 = -1.634338 */
9739                  32495,         /* B0 = 0.991699 */
9740                  27321,         /* A1 = -1.667542 */
9741                  -32684,        /* A2 = 0.997467 */
9742                  1835,          /* B2 = 0.056007 */
9743                  -1539,         /* B1 = -0.093948 */
9744                  1835,          /* B0 = 0.056007 */
9745                  5,             /* Internal filter scaling */
9746                  159,           /* Minimum in-band energy threshold */
9747                  21,            /* 21/32 in-band to broad-band ratio */
9748                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9749         },
9750         {                       /* f750_1450[] */
9751                 19298,          /* A1 = 1.177917 */
9752                  -24471,        /* A2 = -0.746796 */
9753                  -4152,         /* B2 = -0.126709 */
9754                  0,             /* B1 = 0 */
9755                  4152,          /* B0 = 0.126709 */
9756                  12902,         /* A1 = 0.787476 */
9757                  -29091,        /* A2 = -0.887817 */
9758                  12491,         /* B2 = 0.38121 */
9759                  -1794,         /* B1 = -0.109528 */
9760                  12494,         /* B0 = 0.381317 */
9761                  26291,         /* A1 = 1.604736 */
9762                  -30470,        /* A2 = -0.929901 */
9763                  28859,         /* B2 = 0.880737 */
9764                  -26084,        /* B1 = -1.592102 */
9765                  28861,         /* B0 = 0.880798 */
9766                  7,             /* Internal filter scaling */
9767                  159,           /* Minimum in-band energy threshold */
9768                  21,            /* 21/32 in-band to broad-band ratio */
9769                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9770         },
9771         {                       /* f770 */
9772                 26867,          /* A1 = -1.639832 */
9773                  -32551,        /* A2 = 0.993408 */
9774                  -123,          /* B2 = -0.003755 */
9775                  0,             /* B1 = 0.000000 */
9776                  123,           /* B0 = 0.003755 */
9777                  26805,         /* A1 = -1.636108 */
9778                  -32683,        /* A2 = 0.997406 */
9779                  17297,         /* B2 = 0.527863 */
9780                  -14096,        /* B1 = -0.860382 */
9781                  17297,         /* B0 = 0.527863 */
9782                  27034,         /* A1 = -1.650085 */
9783                  -32684,        /* A2 = 0.997467 */
9784                  12958,         /* B2 = 0.395477 */
9785                  -10756,        /* B1 = -0.656525 */
9786                  12958,         /* B0 = 0.395477 */
9787                  5,             /* Internal filter scaling */
9788                  159,           /* Minimum in-band energy threshold */
9789                  21,            /* 21/32 in-band to broad-band ratio */
9790                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9791         },
9792         {                       /* f800 */
9793                 26413,          /* A1 = -1.612122 */
9794                  -32547,        /* A2 = 0.993286 */
9795                  -223,          /* B2 = -0.006825 */
9796                  0,             /* B1 = 0.000000 */
9797                  223,           /* B0 = 0.006825 */
9798                  26342,         /* A1 = -1.607849 */
9799                  -32686,        /* A2 = 0.997498 */
9800                  6391,          /* B2 = 0.195053 */
9801                  -5120,         /* B1 = -0.312531 */
9802                  6391,          /* B0 = 0.195053 */
9803                  26593,         /* A1 = -1.623108 */
9804                  -32688,        /* A2 = 0.997559 */
9805                  23681,         /* B2 = 0.722717 */
9806                  -19328,        /* B1 = -1.179688 */
9807                  23681,         /* B0 = 0.722717 */
9808                  5,             /* Internal filter scaling */
9809                  159,           /* Minimum in-band energy threshold */
9810                  21,            /* 21/32 in-band to broad-band ratio */
9811                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9812         },
9813         {                       /* f816 */
9814                 26168,          /* A1 = -1.597209 */
9815                  -32528,        /* A2 = 0.992706 */
9816                  -235,          /* B2 = -0.007182 */
9817                  0,             /* B1 = 0.000000 */
9818                  235,           /* B0 = 0.007182 */
9819                  26092,         /* A1 = -1.592590 */
9820                  -32675,        /* A2 = 0.997192 */
9821                  20823,         /* B2 = 0.635498 */
9822                  -16510,        /* B1 = -1.007751 */
9823                  20823,         /* B0 = 0.635498 */
9824                  26363,         /* A1 = -1.609070 */
9825                  -32677,        /* A2 = 0.997253 */
9826                  6739,          /* B2 = 0.205688 */
9827                  -5459,         /* B1 = -0.333206 */
9828                  6739,          /* B0 = 0.205688 */
9829                  5,             /* Internal filter scaling */
9830                  159,           /* Minimum in-band energy threshold */
9831                  21,            /* 21/32 in-band to broad-band ratio */
9832                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9833         },
9834         {                       /* f850 */
9835                 25641,          /* A1 = -1.565063 */
9836                  -32536,        /* A2 = 0.992950 */
9837                  -121,          /* B2 = -0.003707 */
9838                  0,             /* B1 = 0.000000 */
9839                  121,           /* B0 = 0.003707 */
9840                  25560,         /* A1 = -1.560059 */
9841                  -32684,        /* A2 = 0.997437 */
9842                  18341,         /* B2 = 0.559753 */
9843                  -14252,        /* B1 = -0.869904 */
9844                  18341,         /* B0 = 0.559753 */
9845                  25837,         /* A1 = -1.577026 */
9846                  -32684,        /* A2 = 0.997467 */
9847                  16679,         /* B2 = 0.509003 */
9848                  -13232,        /* B1 = -0.807648 */
9849                  16679,         /* B0 = 0.509003 */
9850                  5,             /* Internal filter scaling */
9851                  159,           /* Minimum in-band energy threshold */
9852                  21,            /* 21/32 in-band to broad-band ratio */
9853                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9854         },
9855         {                       /* f857_1645[] */
9856                 16415,          /* A1 = 1.001953 */
9857                  -23669,        /* A2 = -0.722321 */
9858                  -4549,         /* B2 = -0.138847 */
9859                  0,             /* B1 = 0 */
9860                  4549,          /* B0 = 0.138847 */
9861                  8456,          /* A1 = 0.516174 */
9862                  -28996,        /* A2 = -0.884918 */
9863                  13753,         /* B2 = 0.419724 */
9864                  -12,           /* B1 = -0.000763 */
9865                  13757,         /* B0 = 0.419846 */
9866                  24632,         /* A1 = 1.503418 */
9867                  -30271,        /* A2 = -0.923828 */
9868                  29070,         /* B2 = 0.887146 */
9869                  -25265,        /* B1 = -1.542114 */
9870                  29073,         /* B0 = 0.887268 */
9871                  7,             /* Internal filter scaling */
9872                  159,           /* Minimum in-band energy threshold */
9873                  21,            /* 21/32 in-band to broad-band ratio */
9874                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9875         },
9876         {                       /* f900 */
9877                 24806,          /* A1 = -1.514099 */
9878                  -32501,        /* A2 = 0.991852 */
9879                  -326,          /* B2 = -0.009969 */
9880                  0,             /* B1 = 0.000000 */
9881                  326,           /* B0 = 0.009969 */
9882                  24709,         /* A1 = -1.508118 */
9883                  -32659,        /* A2 = 0.996674 */
9884                  20277,         /* B2 = 0.618835 */
9885                  -15182,        /* B1 = -0.926636 */
9886                  20277,         /* B0 = 0.618835 */
9887                  25022,         /* A1 = -1.527222 */
9888                  -32661,        /* A2 = 0.996735 */
9889                  4320,          /* B2 = 0.131836 */
9890                  -3331,         /* B1 = -0.203339 */
9891                  4320,          /* B0 = 0.131836 */
9892                  5,             /* Internal filter scaling */
9893                  159,           /* Minimum in-band energy threshold */
9894                  21,            /* 21/32 in-band to broad-band ratio */
9895                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9896         },
9897         {                       /* f900_1300[] */
9898                 19776,          /* A1 = 1.207092 */
9899                  -27437,        /* A2 = -0.837341 */
9900                  -2666,         /* B2 = -0.081371 */
9901                  0,             /* B1 = 0 */
9902                  2666,          /* B0 = 0.081371 */
9903                  16302,         /* A1 = 0.995026 */
9904                  -30354,        /* A2 = -0.926361 */
9905                  10389,         /* B2 = 0.317062 */
9906                  -3327,         /* B1 = -0.203064 */
9907                  10389,         /* B0 = 0.317062 */
9908                  24299,         /* A1 = 1.483154 */
9909                  -30930,        /* A2 = -0.943909 */
9910                  25016,         /* B2 = 0.763428 */
9911                  -21171,        /* B1 = -1.292236 */
9912                  25016,         /* B0 = 0.763428 */
9913                  7,             /* Internal filter scaling */
9914                  159,           /* Minimum in-band energy threshold */
9915                  21,            /* 21/32 in-band to broad-band ratio */
9916                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9917         },
9918         {                       /* f935_1215[] */
9919                 20554,          /* A1 = 1.254517 */
9920                  -28764,        /* A2 = -0.877838 */
9921                  -2048,         /* B2 = -0.062515 */
9922                  0,             /* B1 = 0 */
9923                  2048,          /* B0 = 0.062515 */
9924                  18209,         /* A1 = 1.11145 */
9925                  -30951,        /* A2 = -0.94458 */
9926                  9390,          /* B2 = 0.286575 */
9927                  -3955,         /* B1 = -0.241455 */
9928                  9390,          /* B0 = 0.286575 */
9929                  23902,         /* A1 = 1.458923 */
9930                  -31286,        /* A2 = -0.954803 */
9931                  23252,         /* B2 = 0.709595 */
9932                  -19132,        /* B1 = -1.167725 */
9933                  23252,         /* B0 = 0.709595 */
9934                  7,             /* Internal filter scaling */
9935                  159,           /* Minimum in-band energy threshold */
9936                  21,            /* 21/32 in-band to broad-band ratio */
9937                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9938         },
9939         {                       /* f941_1477[] */
9940                 17543,          /* A1 = 1.07074 */
9941                  -26220,        /* A2 = -0.800201 */
9942                  -3298,         /* B2 = -0.100647 */
9943                  0,             /* B1 = 0 */
9944                  3298,          /* B0 = 0.100647 */
9945                  12423,         /* A1 = 0.75827 */
9946                  -30036,        /* A2 = -0.916626 */
9947                  12651,         /* B2 = 0.386078 */
9948                  -2444,         /* B1 = -0.14917 */
9949                  12653,         /* B0 = 0.386154 */
9950                  23518,         /* A1 = 1.435425 */
9951                  -30745,        /* A2 = -0.938293 */
9952                  27282,         /* B2 = 0.832581 */
9953                  -22529,        /* B1 = -1.375122 */
9954                  27286,         /* B0 = 0.832703 */
9955                  7,             /* Internal filter scaling */
9956                  159,           /* Minimum in-band energy threshold */
9957                  21,            /* 21/32 in-band to broad-band ratio */
9958                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9959         },
9960         {                       /* f942 */
9961                 24104,          /* A1 = -1.471252 */
9962                  -32507,        /* A2 = 0.992065 */
9963                  -351,          /* B2 = -0.010722 */
9964                  0,             /* B1 = 0.000000 */
9965                  351,           /* B0 = 0.010722 */
9966                  23996,         /* A1 = -1.464600 */
9967                  -32671,        /* A2 = 0.997040 */
9968                  22848,         /* B2 = 0.697266 */
9969                  -16639,        /* B1 = -1.015564 */
9970                  22848,         /* B0 = 0.697266 */
9971                  24332,         /* A1 = -1.485168 */
9972                  -32673,        /* A2 = 0.997101 */
9973                  4906,          /* B2 = 0.149727 */
9974                  -3672,         /* B1 = -0.224174 */
9975                  4906,          /* B0 = 0.149727 */
9976                  5,             /* Internal filter scaling */
9977                  159,           /* Minimum in-band energy threshold */
9978                  21,            /* 21/32 in-band to broad-band ratio */
9979                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9980         },
9981         {                       /* f950 */
9982                 23967,          /* A1 = -1.462830 */
9983                  -32507,        /* A2 = 0.992065 */
9984                  -518,          /* B2 = -0.015821 */
9985                  0,             /* B1 = 0.000000 */
9986                  518,           /* B0 = 0.015821 */
9987                  23856,         /* A1 = -1.456055 */
9988                  -32671,        /* A2 = 0.997040 */
9989                  26287,         /* B2 = 0.802246 */
9990                  -19031,        /* B1 = -1.161560 */
9991                  26287,         /* B0 = 0.802246 */
9992                  24195,         /* A1 = -1.476746 */
9993                  -32673,        /* A2 = 0.997101 */
9994                  2890,          /* B2 = 0.088196 */
9995                  -2151,         /* B1 = -0.131317 */
9996                  2890,          /* B0 = 0.088196 */
9997                  5,             /* Internal filter scaling */
9998                  159,           /* Minimum in-band energy threshold */
9999                  21,            /* 21/32 in-band to broad-band ratio */
10000                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10001         },
10002         {                       /* f950_1400[] */
10003                 18294,          /* A1 = 1.116638 */
10004                  -26962,        /* A2 = -0.822845 */
10005                  -2914,         /* B2 = -0.088936 */
10006                  0,             /* B1 = 0 */
10007                  2914,          /* B0 = 0.088936 */
10008                  14119,         /* A1 = 0.861786 */
10009                  -30227,        /* A2 = -0.922455 */
10010                  11466,         /* B2 = 0.349945 */
10011                  -2833,         /* B1 = -0.172943 */
10012                  11466,         /* B0 = 0.349945 */
10013                  23431,         /* A1 = 1.430115 */
10014                  -30828,        /* A2 = -0.940796 */
10015                  25331,         /* B2 = 0.773071 */
10016                  -20911,        /* B1 = -1.276367 */
10017                  25331,         /* B0 = 0.773071 */
10018                  7,             /* Internal filter scaling */
10019                  159,           /* Minimum in-band energy threshold */
10020                  21,            /* 21/32 in-band to broad-band ratio */
10021                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10022         },
10023         {                       /* f975 */
10024                 23521,          /* A1 = -1.435608 */
10025                  -32489,        /* A2 = 0.991516 */
10026                  -193,          /* B2 = -0.005915 */
10027                  0,             /* B1 = 0.000000 */
10028                  193,           /* B0 = 0.005915 */
10029                  23404,         /* A1 = -1.428467 */
10030                  -32655,        /* A2 = 0.996582 */
10031                  17740,         /* B2 = 0.541412 */
10032                  -12567,        /* B1 = -0.767029 */
10033                  17740,         /* B0 = 0.541412 */
10034                  23753,         /* A1 = -1.449829 */
10035                  -32657,        /* A2 = 0.996613 */
10036                  9090,          /* B2 = 0.277405 */
10037                  -6662,         /* B1 = -0.406647 */
10038                  9090,          /* B0 = 0.277405 */
10039                  5,             /* Internal filter scaling */
10040                  159,           /* Minimum in-band energy threshold */
10041                  21,            /* 21/32 in-band to broad-band ratio */
10042                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10043         },
10044         {                       /* f1000 */
10045                 23071,          /* A1 = -1.408203 */
10046                  -32489,        /* A2 = 0.991516 */
10047                  -293,          /* B2 = -0.008965 */
10048                  0,             /* B1 = 0.000000 */
10049                  293,           /* B0 = 0.008965 */
10050                  22951,         /* A1 = -1.400818 */
10051                  -32655,        /* A2 = 0.996582 */
10052                  5689,          /* B2 = 0.173645 */
10053                  -3951,         /* B1 = -0.241150 */
10054                  5689,          /* B0 = 0.173645 */
10055                  23307,         /* A1 = -1.422607 */
10056                  -32657,        /* A2 = 0.996613 */
10057                  18692,         /* B2 = 0.570435 */
10058                  -13447,        /* B1 = -0.820770 */
10059                  18692,         /* B0 = 0.570435 */
10060                  5,             /* Internal filter scaling */
10061                  159,           /* Minimum in-band energy threshold */
10062                  21,            /* 21/32 in-band to broad-band ratio */
10063                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10064         },
10065         {                       /* f1020 */
10066                 22701,          /* A1 = -1.385620 */
10067                  -32474,        /* A2 = 0.991058 */
10068                  -292,          /* B2 = -0.008933 */
10069                  0,             /*163840      , B1 = 10.000000 */
10070                  292,           /* B0 = 0.008933 */
10071                  22564,         /* A1 = -1.377258 */
10072                  -32655,        /* A2 = 0.996552 */
10073                  20756,         /* B2 = 0.633423 */
10074                  -14176,        /* B1 = -0.865295 */
10075                  20756,         /* B0 = 0.633423 */
10076                  22960,         /* A1 = -1.401428 */
10077                  -32657,        /* A2 = 0.996613 */
10078                  6520,          /* B2 = 0.198990 */
10079                  -4619,         /* B1 = -0.281937 */
10080                  6520,          /* B0 = 0.198990 */
10081                  5,             /* Internal filter scaling */
10082                  159,           /* Minimum in-band energy threshold */
10083                  21,            /* 21/32 in-band to broad-band ratio */
10084                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10085         },
10086         {                       /* f1050 */
10087                 22142,          /* A1 = -1.351501 */
10088                  -32474,        /* A2 = 0.991058 */
10089                  -147,          /* B2 = -0.004493 */
10090                  0,             /* B1 = 0.000000 */
10091                  147,           /* B0 = 0.004493 */
10092                  22000,         /* A1 = -1.342834 */
10093                  -32655,        /* A2 = 0.996552 */
10094                  15379,         /* B2 = 0.469360 */
10095                  -10237,        /* B1 = -0.624847 */
10096                  15379,         /* B0 = 0.469360 */
10097                  22406,         /* A1 = -1.367554 */
10098                  -32657,        /* A2 = 0.996613 */
10099                  17491,         /* B2 = 0.533783 */
10100                  -12096,        /* B1 = -0.738312 */
10101                  17491,         /* B0 = 0.533783 */
10102                  5,             /* Internal filter scaling */
10103                  159,           /* Minimum in-band energy threshold */
10104                  21,            /* 21/32 in-band to broad-band ratio */
10105                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10106         },
10107         {                       /* f1100_1750[] */
10108                 12973,          /* A1 = 0.79184 */
10109                  -24916,        /* A2 = -0.760376 */
10110                  6655,          /* B2 = 0.203102 */
10111                  367,           /* B1 = 0.0224 */
10112                  6657,          /* B0 = 0.203171 */
10113                  5915,          /* A1 = 0.361053 */
10114                  -29560,        /* A2 = -0.90213 */
10115                  -7777,         /* B2 = -0.23735 */
10116                  0,             /* B1 = 0 */
10117                  7777,          /* B0 = 0.23735 */
10118                  20510,         /* A1 = 1.251892 */
10119                  -30260,        /* A2 = -0.923462 */
10120                  26662,         /* B2 = 0.81366 */
10121                  -20573,        /* B1 = -1.255737 */
10122                  26668,         /* B0 = 0.813843 */
10123                  7,             /* Internal filter scaling */
10124                  159,           /* Minimum in-band energy threshold */
10125                  21,            /* 21/32 in-band to broad-band ratio */
10126                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10127         },
10128         {                       /* f1140 */
10129                 20392,          /* A1 = -1.244629 */
10130                  -32460,        /* A2 = 0.990601 */
10131                  -270,          /* B2 = -0.008240 */
10132                  0,             /* B1 = 0.000000 */
10133                  270,           /* B0 = 0.008240 */
10134                  20218,         /* A1 = -1.234009 */
10135                  -32655,        /* A2 = 0.996582 */
10136                  21337,         /* B2 = 0.651154 */
10137                  -13044,        /* B1 = -0.796143 */
10138                  21337,         /* B0 = 0.651154 */
10139                  20684,         /* A1 = -1.262512 */
10140                  -32657,        /* A2 = 0.996643 */
10141                  8572,          /* B2 = 0.261612 */
10142                  -5476,         /* B1 = -0.334244 */
10143                  8572,          /* B0 = 0.261612 */
10144                  5,             /* Internal filter scaling */
10145                  159,           /* Minimum in-band energy threshold */
10146                  21,            /* 21/32 in-band to broad-band ratio */
10147                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10148         },
10149         {                       /* f1200 */
10150                 19159,          /* A1 = -1.169373 */
10151                  -32456,        /* A2 = 0.990509 */
10152                  -335,          /* B2 = -0.010252 */
10153                  0,             /* B1 = 0.000000 */
10154                  335,           /* B0 = 0.010252 */
10155                  18966,         /* A1 = -1.157593 */
10156                  -32661,        /* A2 = 0.996735 */
10157                  6802,          /* B2 = 0.207588 */
10158                  -3900,         /* B1 = -0.238098 */
10159                  6802,          /* B0 = 0.207588 */
10160                  19467,         /* A1 = -1.188232 */
10161                  -32661,        /* A2 = 0.996765 */
10162                  25035,         /* B2 = 0.764008 */
10163                  -15049,        /* B1 = -0.918579 */
10164                  25035,         /* B0 = 0.764008 */
10165                  5,             /* Internal filter scaling */
10166                  159,           /* Minimum in-band energy threshold */
10167                  21,            /* 21/32 in-band to broad-band ratio */
10168                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10169         },
10170         {                       /* f1209 */
10171                 18976,          /* A1 = -1.158264 */
10172                  -32439,        /* A2 = 0.989990 */
10173                  -183,          /* B2 = -0.005588 */
10174                  0,             /* B1 = 0.000000 */
10175                  183,           /* B0 = 0.005588 */
10176                  18774,         /* A1 = -1.145874 */
10177                  -32650,        /* A2 = 0.996429 */
10178                  15468,         /* B2 = 0.472076 */
10179                  -8768,         /* B1 = -0.535217 */
10180                  15468,         /* B0 = 0.472076 */
10181                  19300,         /* A1 = -1.177979 */
10182                  -32652,        /* A2 = 0.996490 */
10183                  19840,         /* B2 = 0.605499 */
10184                  -11842,        /* B1 = -0.722809 */
10185                  19840,         /* B0 = 0.605499 */
10186                  5,             /* Internal filter scaling */
10187                  159,           /* Minimum in-band energy threshold */
10188                  21,            /* 21/32 in-band to broad-band ratio */
10189                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10190         },
10191         {                       /* f1330 */
10192                 16357,          /* A1 = -0.998413 */
10193                  -32368,        /* A2 = 0.987793 */
10194                  -217,          /* B2 = -0.006652 */
10195                  0,             /* B1 = 0.000000 */
10196                  217,           /* B0 = 0.006652 */
10197                  16107,         /* A1 = -0.983126 */
10198                  -32601,        /* A2 = 0.994904 */
10199                  11602,         /* B2 = 0.354065 */
10200                  -5555,         /* B1 = -0.339111 */
10201                  11602,         /* B0 = 0.354065 */
10202                  16722,         /* A1 = -1.020630 */
10203                  -32603,        /* A2 = 0.994965 */
10204                  15574,         /* B2 = 0.475311 */
10205                  -8176,         /* B1 = -0.499069 */
10206                  15574,         /* B0 = 0.475311 */
10207                  5,             /* Internal filter scaling */
10208                  159,           /* Minimum in-band energy threshold */
10209                  21,            /* 21/32 in-band to broad-band ratio */
10210                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10211         },
10212         {                       /* f1336 */
10213                 16234,          /* A1 = -0.990875 */
10214                  32404,         /* A2 = -0.988922 */
10215                  -193,          /* B2 = -0.005908 */
10216                  0,             /* B1 = 0.000000 */
10217                  193,           /* B0 = 0.005908 */
10218                  15986,         /* A1 = -0.975769 */
10219                  -32632,        /* A2 = 0.995880 */
10220                  18051,         /* B2 = 0.550903 */
10221                  -8658,         /* B1 = -0.528473 */
10222                  18051,         /* B0 = 0.550903 */
10223                  16591,         /* A1 = -1.012695 */
10224                  -32634,        /* A2 = 0.995941 */
10225                  15736,         /* B2 = 0.480240 */
10226                  -8125,         /* B1 = -0.495926 */
10227                  15736,         /* B0 = 0.480240 */
10228                  5,             /* Internal filter scaling */
10229                  159,           /* Minimum in-band energy threshold */
10230                  21,            /* 21/32 in-band to broad-band ratio */
10231                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10232         },
10233         {                       /* f1366 */
10234                 15564,          /* A1 = -0.949982 */
10235                  -32404,        /* A2 = 0.988922 */
10236                  -269,          /* B2 = -0.008216 */
10237                  0,             /* B1 = 0.000000 */
10238                  269,           /* B0 = 0.008216 */
10239                  15310,         /* A1 = -0.934479 */
10240                  -32632,        /* A2 = 0.995880 */
10241                  10815,         /* B2 = 0.330063 */
10242                  -4962,         /* B1 = -0.302887 */
10243                  10815,         /* B0 = 0.330063 */
10244                  15924,         /* A1 = -0.971924 */
10245                  -32634,        /* A2 = 0.995941 */
10246                  18880,         /* B2 = 0.576172 */
10247                  -9364,         /* B1 = -0.571594 */
10248                  18880,         /* B0 = 0.576172 */
10249                  5,             /* Internal filter scaling */
10250                  159,           /* Minimum in-band energy threshold */
10251                  21,            /* 21/32 in-band to broad-band ratio */
10252                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10253         },
10254         {                       /* f1380 */
10255                 15247,          /* A1 = -0.930603 */
10256                  -32397,        /* A2 = 0.988708 */
10257                  -244,          /* B2 = -0.007451 */
10258                  0,             /* B1 = 0.000000 */
10259                  244,           /* B0 = 0.007451 */
10260                  14989,         /* A1 = -0.914886 */
10261                  -32627,        /* A2 = 0.995697 */
10262                  18961,         /* B2 = 0.578644 */
10263                  -8498,         /* B1 = -0.518707 */
10264                  18961,         /* B0 = 0.578644 */
10265                  15608,         /* A1 = -0.952667 */
10266                  -32628,        /* A2 = 0.995758 */
10267                  11145,         /* B2 = 0.340134 */
10268                  -5430,         /* B1 = -0.331467 */
10269                  11145,         /* B0 = 0.340134 */
10270                  5,             /* Internal filter scaling */
10271                  159,           /* Minimum in-band energy threshold */
10272                  21,            /* 21/32 in-band to broad-band ratio */
10273                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10274         },
10275         {                       /* f1400 */
10276                 14780,          /* A1 = -0.902130 */
10277                  -32393,        /* A2 = 0.988586 */
10278                  -396,          /* B2 = -0.012086 */
10279                  0,             /* B1 = 0.000000 */
10280                  396,           /* B0 = 0.012086 */
10281                  14510,         /* A1 = -0.885651 */
10282                  -32630,        /* A2 = 0.995819 */
10283                  6326,          /* B2 = 0.193069 */
10284                  -2747,         /* B1 = -0.167671 */
10285                  6326,          /* B0 = 0.193069 */
10286                  15154,         /* A1 = -0.924957 */
10287                  -32632,        /* A2 = 0.995850 */
10288                  23235,         /* B2 = 0.709076 */
10289                  -10983,        /* B1 = -0.670380 */
10290                  23235,         /* B0 = 0.709076 */
10291                  5,             /* Internal filter scaling */
10292                  159,           /* Minimum in-band energy threshold */
10293                  21,            /* 21/32 in-band to broad-band ratio */
10294                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10295         },
10296         {                       /* f1477 */
10297                 13005,          /* A1 = -0.793793 */
10298                  -32368,        /* A2 = 0.987823 */
10299                  -500,          /* B2 = -0.015265 */
10300                  0,             /* B1 = 0.000000 */
10301                  500,           /* B0 = 0.015265 */
10302                  12708,         /* A1 = -0.775665 */
10303                  -32615,        /* A2 = 0.995331 */
10304                  11420,         /* B2 = 0.348526 */
10305                  -4306,         /* B1 = -0.262833 */
10306                  11420,         /* B0 = 0.348526 */
10307                  13397,         /* A1 = -0.817688 */
10308                  -32615,        /* A2 = 0.995361 */
10309                  9454,          /* B2 = 0.288528 */
10310                  -3981,         /* B1 = -0.243027 */
10311                  9454,          /* B0 = 0.288528 */
10312                  5,             /* Internal filter scaling */
10313                  159,           /* Minimum in-band energy threshold */
10314                  21,            /* 21/32 in-band to broad-band ratio */
10315                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10316         },
10317         {                       /* f1600 */
10318                 10046,          /* A1 = -0.613190 */
10319                  -32331,        /* A2 = 0.986694 */
10320                  -455,          /* B2 = -0.013915 */
10321                  0,             /* B1 = 0.000000 */
10322                  455,           /* B0 = 0.013915 */
10323                  9694,          /* A1 = -0.591705 */
10324                  -32601,        /* A2 = 0.994934 */
10325                  6023,          /* B2 = 0.183815 */
10326                  -1708,         /* B1 = -0.104279 */
10327                  6023,          /* B0 = 0.183815 */
10328                  10478,         /* A1 = -0.639587 */
10329                  -32603,        /* A2 = 0.994965 */
10330                  22031,         /* B2 = 0.672333 */
10331                  -7342,         /* B1 = -0.448151 */
10332                  22031,         /* B0 = 0.672333 */
10333                  5,             /* Internal filter scaling */
10334                  159,           /* Minimum in-band energy threshold */
10335                  21,            /* 21/32 in-band to broad-band ratio */
10336                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10337         },
10338         {                       /* f1633_1638[] */
10339                 9181,           /* A1 = 0.560394 */
10340                  -32256,        /* A2 = -0.984375 */
10341                  -556,          /* B2 = -0.016975 */
10342                  0,             /* B1 = 0 */
10343                  556,           /* B0 = 0.016975 */
10344                  8757,          /* A1 = 0.534515 */
10345                  -32574,        /* A2 = -0.99408 */
10346                  8443,          /* B2 = 0.25769 */
10347                  -2135,         /* B1 = -0.130341 */
10348                  8443,          /* B0 = 0.25769 */
10349                  9691,          /* A1 = 0.591522 */
10350                  -32574,        /* A2 = -0.99411 */
10351                  15446,         /* B2 = 0.471375 */
10352                  -4809,         /* B1 = -0.293579 */
10353                  15446,         /* B0 = 0.471375 */
10354                  7,             /* Internal filter scaling */
10355                  159,           /* Minimum in-band energy threshold */
10356                  21,            /* 21/32 in-band to broad-band ratio */
10357                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10358         },
10359         {                       /* f1800 */
10360                 5076,           /* A1 = -0.309875 */
10361                  -32304,        /* A2 = 0.985840 */
10362                  -508,          /* B2 = -0.015503 */
10363                  0,             /* B1 = 0.000000 */
10364                  508,           /* B0 = 0.015503 */
10365                  4646,          /* A1 = -0.283600 */
10366                  -32605,        /* A2 = 0.995026 */
10367                  6742,          /* B2 = 0.205780 */
10368                  -878,          /* B1 = -0.053635 */
10369                  6742,          /* B0 = 0.205780 */
10370                  5552,          /* A1 = -0.338928 */
10371                  -32605,        /* A2 = 0.995056 */
10372                  23667,         /* B2 = 0.722260 */
10373                  -4297,         /* B1 = -0.262329 */
10374                  23667,         /* B0 = 0.722260 */
10375                  5,             /* Internal filter scaling */
10376                  159,           /* Minimum in-band energy threshold */
10377                  21,            /* 21/32 in-band to broad-band ratio */
10378                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10379         },
10380         {                       /* f1860 */
10381                 3569,           /* A1 = -0.217865 */
10382                  -32292,        /* A2 = 0.985504 */
10383                  -239,          /* B2 = -0.007322 */
10384                  0,             /* B1 = 0.000000 */
10385                  239,           /* B0 = 0.007322 */
10386                  3117,          /* A1 = -0.190277 */
10387                  -32603,        /* A2 = 0.994965 */
10388                  18658,         /* B2 = 0.569427 */
10389                  -1557,         /* B1 = -0.095032 */
10390                  18658,         /* B0 = 0.569427 */
10391                  4054,          /* A1 = -0.247437 */
10392                  -32603,        /* A2 = 0.994965 */
10393                  18886,         /* B2 = 0.576385 */
10394                  -2566,         /* B1 = -0.156647 */
10395                  18886,         /* B0 = 0.576385 */
10396                  5,             /* Internal filter scaling */
10397                  159,           /* Minimum in-band energy threshold */
10398                  21,            /* 21/32 in-band to broad-band ratio */
10399                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10400         },
10401 };
10402 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10403 {
10404         unsigned short cmd;
10405         int cnt, max;
10406
10407         if (jf->filter > 3) {
10408                 return -1;
10409         }
10410         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10411
10412                 return -1;
10413         if (!jf->enable) {
10414                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10415
10416                         return -1;
10417                 else
10418                         return 0;
10419         } else {
10420                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10421
10422                         return -1;
10423                 /* Select the filter (f0 - f3) to use. */
10424                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10425                         return -1;
10426         }
10427         if (jf->freq < 12 && jf->freq > 3) {
10428                 /* Select the frequency for the selected filter. */
10429                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10430                         return -1;
10431         } else if (jf->freq > 11) {
10432                 /* We need to load a programmable filter set for undefined */
10433                 /* frequencies.  So we will point the filter to a programmable set. */
10434                 /* Since there are only 4 filters and 4 programmable sets, we will */
10435                 /* just point the filter to the same number set and program it for the */
10436                 /* frequency we want. */
10437                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10438                         return -1;
10439                 if (j->ver.low != 0x12) {
10440                         cmd = 0x515B;
10441                         max = 19;
10442                 } else {
10443                         cmd = 0x515E;
10444                         max = 15;
10445                 }
10446                 if (ixj_WriteDSPCommand(cmd, j))
10447                         return -1;
10448                 for (cnt = 0; cnt < max; cnt++) {
10449                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10450                                 return -1;
10451                 }
10452         }
10453         j->filter_en[jf->filter] = jf->enable;
10454         return 0;
10455 }
10456
10457 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10458 {
10459         unsigned short cmd;
10460         int cnt, max;
10461         if (jfr->filter > 3) {
10462                 return -1;
10463         }
10464         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10465                 return -1;
10466
10467         if (!jfr->enable) {
10468                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10469                         return -1;
10470                 else
10471                         return 0;
10472         } else {
10473                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10474                         return -1;
10475                 /* Select the filter (f0 - f3) to use. */
10476                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10477                         return -1;
10478         }
10479         /* We need to load a programmable filter set for undefined */
10480         /* frequencies.  So we will point the filter to a programmable set. */
10481         /* Since there are only 4 filters and 4 programmable sets, we will */
10482         /* just point the filter to the same number set and program it for the */
10483         /* frequency we want. */
10484         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10485                 return -1;
10486         if (j->ver.low != 0x12) {
10487                 cmd = 0x515B;
10488                 max = 19;
10489         } else {
10490                 cmd = 0x515E;
10491                 max = 15;
10492         }
10493         if (ixj_WriteDSPCommand(cmd, j))
10494                 return -1;
10495         for (cnt = 0; cnt < max; cnt++) {
10496                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10497                         return -1;
10498         }
10499         j->filter_en[jfr->filter] = jfr->enable;
10500         return 0;
10501 }
10502
10503 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10504 {
10505         int freq0, freq1;
10506         unsigned short data;
10507         if (ti->freq0) {
10508                 freq0 = ti->freq0;
10509         } else {
10510                 freq0 = 0x7FFF;
10511         }
10512
10513         if (ti->freq1) {
10514                 freq1 = ti->freq1;
10515         } else {
10516                 freq1 = 0x7FFF;
10517         }
10518
10519         if(ti->tone_index > 12 && ti->tone_index < 28)
10520         {
10521                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10522                         return -1;
10523                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10524                         return -1;
10525                 data = freq0;
10526                 if (ixj_WriteDSPCommand(data, j))
10527                         return -1;
10528                 data = freq1;
10529                 if (ixj_WriteDSPCommand(data, j))
10530                         return -1;
10531         }
10532         return freq0;
10533 }
10534