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  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  46  * Audit some copy_*_user and minor cleanup.
  47  *
  48  * Revision 4.7  2001/08/13 06:19:33  craigs
  49  * Added additional changes from Alan Cox and John Anderson for
  50  * 2.2 to 2.4 cleanup and bounds checking
  51  *
  52  * Revision 4.6  2001/08/13 01:05:05  craigs
  53  * Really fixed PHONE_QUERY_CODEC problem this time
  54  *
  55  * Revision 4.5  2001/08/13 00:11:03  craigs
  56  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  57  *
  58  * Revision 4.4  2001/08/07 07:58:12  craigs
  59  * Changed back to three digit version numbers
  60  * Added tagbuild target to allow automatic and easy tagging of versions
  61  *
  62  * Revision 4.3  2001/08/07 07:24:47  craigs
  63  * Added ixj-ver.h to allow easy configuration management of driver
  64  * Added display of version number in /prox/ixj
  65  *
  66  * Revision 4.2  2001/08/06 07:07:19  craigs
  67  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  68  * behaviour of returning int rather than short *
  69  *
  70  * Revision 4.1  2001/08/05 00:17:37  craigs
  71  * More changes for correct PCMCIA installation
  72  * Start of changes for backward Linux compatibility
  73  *
  74  * Revision 4.0  2001/08/04 12:33:12  craigs
  75  * New version using GNU autoconf
  76  *
  77  * Revision 3.105  2001/07/20 23:14:32  eokerson
  78  * More work on CallerID generation when using ring cadences.
  79  *
  80  * Revision 3.104  2001/07/06 01:33:55  eokerson
  81  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  82  *
  83  * Revision 3.103  2001/07/05 19:20:16  eokerson
  84  * Updated HOWTO
  85  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  86  *
  87  * Revision 3.102  2001/07/03 23:51:21  eokerson
  88  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  89  *
  90  * Revision 3.101  2001/07/02 19:26:56  eokerson
  91  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  92  *
  93  * Revision 3.100  2001/07/02 19:18:27  eokerson
  94  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  95  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  96  * Fixed speaker mode on Internet LineJACK.
  97  *
  98  * Revision 3.99  2001/05/09 14:11:16  eokerson
  99  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 100  *
 101  * Revision 3.98  2001/05/08 19:55:33  eokerson
 102  * Fixed POTS hookstate detection while it is connected to PSTN port.
 103  *
 104  * Revision 3.97  2001/05/08 00:01:04  eokerson
 105  * Fixed kernel oops when sending caller ID data.
 106  *
 107  * Revision 3.96  2001/05/04 23:09:30  eokerson
 108  * Now uses one kernel timer for each card, instead of one for the entire driver.
 109  *
 110  * Revision 3.95  2001/04/25 22:06:47  eokerson
 111  * Fixed squawking at beginning of some G.723.1 calls.
 112  *
 113  * Revision 3.94  2001/04/03 23:42:00  eokerson
 114  * Added linear volume ioctls
 115  * Added raw filter load ioctl
 116  *
 117  * Revision 3.93  2001/02/27 01:00:06  eokerson
 118  * Fixed blocking in CallerID.
 119  * Reduced size of ixj structure for smaller driver footprint.
 120  *
 121  * Revision 3.92  2001/02/20 22:02:59  eokerson
 122  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 123  * Improved PSTN ring detection.
 124  * Fixed wink generation on POTS ports.
 125  *
 126  * Revision 3.91  2001/02/13 00:55:44  eokerson
 127  * Turn AEC back on after changing frame sizes.
 128  *
 129  * Revision 3.90  2001/02/12 16:42:00  eokerson
 130  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 131  *
 132  * Revision 3.89  2001/02/12 15:41:16  eokerson
 133  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 134  *
 135  * Revision 3.88  2001/02/05 23:25:42  eokerson
 136  * Fixed lockup bugs with deregister.
 137  *
 138  * Revision 3.87  2001/01/29 21:00:39  eokerson
 139  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 140  * Updated copyright date.
 141  *
 142  * Revision 3.86  2001/01/23 23:53:46  eokerson
 143  * Fixes to G.729 compatibility.
 144  *
 145  * Revision 3.85  2001/01/23 21:30:36  eokerson
 146  * Added verbage about cards supported.
 147  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 148  *
 149  * Revision 3.84  2001/01/22 23:32:10  eokerson
 150  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 151  *
 152  * Revision 3.83  2001/01/19 14:51:41  eokerson
 153  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 154  *
 155  * Revision 3.82  2001/01/19 00:34:49  eokerson
 156  * Added verbosity to write overlap errors.
 157  *
 158  * Revision 3.81  2001/01/18 23:56:54  eokerson
 159  * Fixed PSTN line test functions.
 160  *
 161  * Revision 3.80  2001/01/18 22:29:27  eokerson
 162  * Updated AEC/AGC values for different cards.
 163  *
 164  * Revision 3.79  2001/01/17 02:58:54  eokerson
 165  * Fixed AEC reset after Caller ID.
 166  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 167  *
 168  * Revision 3.78  2001/01/16 19:43:09  eokerson
 169  * Added support for Linux 2.4.x kernels.
 170  *
 171  * Revision 3.77  2001/01/09 04:00:52  eokerson
 172  * Linetest will now test the line, even if it has previously succeded.
 173  *
 174  * Revision 3.76  2001/01/08 19:27:00  eokerson
 175  * Fixed problem with standard cable on Internet PhoneCARD.
 176  *
 177  * Revision 3.75  2000/12/22 16:52:14  eokerson
 178  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 179  *
 180  * Revision 3.74  2000/12/08 22:41:50  eokerson
 181  * Added capability for G729B.
 182  *
 183  * Revision 3.73  2000/12/07 23:35:16  eokerson
 184  * Added capability to have different ring pattern before CallerID data.
 185  * Added hookstate checks in CallerID routines to stop FSK.
 186  *
 187  * Revision 3.72  2000/12/06 19:31:31  eokerson
 188  * Modified signal behavior to only send one signal per event.
 189  *
 190  * Revision 3.71  2000/12/06 03:23:08  eokerson
 191  * Fixed CallerID on Call Waiting.
 192  *
 193  * Revision 3.70  2000/12/04 21:29:37  eokerson
 194  * Added checking to Smart Cable gain functions.
 195  *
 196  * Revision 3.69  2000/12/04 21:05:20  eokerson
 197  * Changed ixjdebug levels.
 198  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 199  *
 200  * Revision 3.68  2000/12/04 00:17:21  craigs
 201  * Changed mixer voice gain to +6dB rather than 0dB
 202  *
 203  * Revision 3.67  2000/11/30 21:25:51  eokerson
 204  * Fixed write signal errors.
 205  *
 206  * Revision 3.66  2000/11/29 22:42:44  eokerson
 207  * Fixed PSTN ring detect problems.
 208  *
 209  * Revision 3.65  2000/11/29 07:31:55  craigs
 210  * Added new 425Hz filter co-efficients
 211  * Added card-specific DTMF prescaler initialisation
 212  *
 213  * Revision 3.64  2000/11/28 14:03:32  craigs
 214  * Changed certain mixer initialisations to be 0dB rather than 12dB
 215  * Added additional information to /proc/ixj
 216  *
 217  * Revision 3.63  2000/11/28 11:38:41  craigs
 218  * Added display of AEC modes in AUTO and AGC mode
 219  *
 220  * Revision 3.62  2000/11/28 04:05:44  eokerson
 221  * Improved PSTN ring detection routine.
 222  *
 223  * Revision 3.61  2000/11/27 21:53:12  eokerson
 224  * Fixed flash detection.
 225  *
 226  * Revision 3.60  2000/11/27 15:57:29  eokerson
 227  * More work on G.729 load routines.
 228  *
 229  * Revision 3.59  2000/11/25 21:55:12  eokerson
 230  * Fixed errors in G.729 load routine.
 231  *
 232  * Revision 3.58  2000/11/25 04:08:29  eokerson
 233  * Added board locks around G.729 and TS85 load routines.
 234  *
 235  * Revision 3.57  2000/11/24 05:35:17  craigs
 236  * Added ability to retrieve mixer values on LineJACK
 237  * Added complete initialisation of all mixer values at startup
 238  * Fixed spelling mistake
 239  *
 240  * Revision 3.56  2000/11/23 02:52:11  robertj
 241  * Added cvs change log keyword.
 242  * Fixed bug in capabilities list when using G.729 module.
 243  *
 244  */
 245
 246 #include "ixj-ver.h"
 247
 248 #define PERFMON_STATS
 249 #define IXJDEBUG 0
 250 #define MAXRINGS 5
 251
 252 #include <linux/module.h>
 253
 254 #include <linux/init.h>
 255 #include <linux/sched.h>
 256 #include <linux/kernel.h>       /* printk() */
 257 #include <linux/fs.h>           /* everything... */
 258 #include <linux/errno.h>        /* error codes */
 259 #include <linux/slab.h>
 260 #include <linux/smp_lock.h>
 261 #include <linux/mm.h>
 262 #include <linux/ioport.h>
 263 #include <linux/interrupt.h>
 264 #include <linux/proc_fs.h>
 265 #include <linux/poll.h>
 266 #include <linux/timer.h>
 267 #include <linux/delay.h>
 268 #include <linux/pci.h>
 269
 270 #include <asm/io.h>
 271 #include <asm/uaccess.h>
 272
 273 #include <linux/isapnp.h>
 274
 275 #include "ixj.h"
 276
 277 #define TYPE(inode) (iminor(inode) >> 4)
 278 #define NUM(inode) (iminor(inode) & 0xf)
 279
 280 static int ixjdebug;
 281 static int hertz = HZ;
 282 static int samplerate = 100;
 283
 284 module_param(ixjdebug, int, 0);
 285
 286 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
 287         { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
 288           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 289         { }
 290 };
 291
 292 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 293
 294 /************************************************************************
 295 *
 296 * ixjdebug meanings are now bit mapped instead of level based
 297 * Values can be or'ed together to turn on multiple messages
 298 *
 299 * bit  0 (0x0001) = any failure
 300 * bit  1 (0x0002) = general messages
 301 * bit  2 (0x0004) = POTS ringing related
 302 * bit  3 (0x0008) = PSTN events
 303 * bit  4 (0x0010) = PSTN Cadence state details
 304 * bit  5 (0x0020) = Tone detection triggers
 305 * bit  6 (0x0040) = Tone detection cadence details
 306 * bit  7 (0x0080) = ioctl tracking
 307 * bit  8 (0x0100) = signal tracking
 308 * bit  9 (0x0200) = CallerID generation details
 309 *
 310 ************************************************************************/
 311
 312 #ifdef IXJ_DYN_ALLOC
 313
 314 static IXJ *ixj[IXJMAX];
 315 #define get_ixj(b)      ixj[(b)]
 316
 317 /*
 318  *      Allocate a free IXJ device
 319  */
 320
 321 static IXJ *ixj_alloc()
 322 {
 323         for(cnt=0; cnt<IXJMAX; cnt++)
 324         {
 325                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 326                 {
 327                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 328                         if (j == NULL)
 329                                 return NULL;
 330                         ixj[cnt] = j;
 331                         return j;
 332                 }
 333         }
 334         return NULL;
 335 }
 336
 337 static void ixj_fsk_free(IXJ *j)
 338 {
 339         kfree(j->fskdata);
 340         j->fskdata = NULL;
 341 }
 342
 343 static void ixj_fsk_alloc(IXJ *j)
 344 {
 345         if(!j->fskdata) {
 346                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 347                 if (!j->fskdata) {
 348                         if(ixjdebug & 0x0200) {
 349                                 printk("IXJ phone%d - allocate failed\n", j->board);
 350                         }
 351                         return;
 352                 } else {
 353                         j->fsksize = 8000;
 354                         if(ixjdebug & 0x0200) {
 355                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 356                         }
 357                 }
 358         }
 359 }
 360
 361 #else
 362
 363 static IXJ ixj[IXJMAX];
 364 #define get_ixj(b)      (&ixj[(b)])
 365
 366 /*
 367  *      Allocate a free IXJ device
 368  */
 369
 370 static IXJ *ixj_alloc(void)
 371 {
 372         int cnt;
 373         for(cnt=0; cnt<IXJMAX; cnt++) {
 374                 if(!ixj[cnt].DSPbase)
 375                         return &ixj[cnt];
 376         }
 377         return NULL;
 378 }
 379
 380 static inline void ixj_fsk_free(IXJ *j) {;}
 381
 382 static inline void ixj_fsk_alloc(IXJ *j)
 383 {
 384         j->fsksize = 8000;
 385 }
 386
 387 #endif
 388
 389 #ifdef PERFMON_STATS
 390 #define ixj_perfmon(x)  ((x)++)
 391 #else
 392 #define ixj_perfmon(x)  do { } while(0)
 393 #endif
 394
 395 static int ixj_convert_loaded;
 396
 397 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 398
 399 /************************************************************************
 400 *
 401 * These are function definitions to allow external modules to register
 402 * enhanced functionality call backs.
 403 *
 404 ************************************************************************/
 405
 406 static int Stub(IXJ * J, unsigned long arg)
 407 {
 408         return 0;
 409 }
 410
 411 static IXJ_REGFUNC ixj_PreRead = &Stub;
 412 static IXJ_REGFUNC ixj_PostRead = &Stub;
 413 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 414 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 415
 416 static void ixj_read_frame(IXJ *j);
 417 static void ixj_write_frame(IXJ *j);
 418 static void ixj_init_timer(IXJ *j);
 419 static void ixj_add_timer(IXJ * j);
 420 static void ixj_timeout(unsigned long ptr);
 421 static int read_filters(IXJ *j);
 422 static int LineMonitor(IXJ *j);
 423 static int ixj_fasync(int fd, struct file *, int mode);
 424 static int ixj_set_port(IXJ *j, int arg);
 425 static int ixj_set_pots(IXJ *j, int arg);
 426 static int ixj_hookstate(IXJ *j);
 427 static int ixj_record_start(IXJ *j);
 428 static void ixj_record_stop(IXJ *j);
 429 static void set_rec_volume(IXJ *j, int volume);
 430 static int get_rec_volume(IXJ *j);
 431 static int set_rec_codec(IXJ *j, int rate);
 432 static void ixj_vad(IXJ *j, int arg);
 433 static int ixj_play_start(IXJ *j);
 434 static void ixj_play_stop(IXJ *j);
 435 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 436 static int ixj_set_tone_off(unsigned short, IXJ *j);
 437 static int ixj_play_tone(IXJ *j, char tone);
 438 static void ixj_aec_start(IXJ *j, int level);
 439 static int idle(IXJ *j);
 440 static void ixj_ring_on(IXJ *j);
 441 static void ixj_ring_off(IXJ *j);
 442 static void aec_stop(IXJ *j);
 443 static void ixj_ringback(IXJ *j);
 444 static void ixj_busytone(IXJ *j);
 445 static void ixj_dialtone(IXJ *j);
 446 static void ixj_cpt_stop(IXJ *j);
 447 static char daa_int_read(IXJ *j);
 448 static char daa_CR_read(IXJ *j, int cr);
 449 static int daa_set_mode(IXJ *j, int mode);
 450 static int ixj_linetest(IXJ *j);
 451 static int ixj_daa_write(IXJ *j);
 452 static int ixj_daa_cid_read(IXJ *j);
 453 static void DAA_Coeff_US(IXJ *j);
 454 static void DAA_Coeff_UK(IXJ *j);
 455 static void DAA_Coeff_France(IXJ *j);
 456 static void DAA_Coeff_Germany(IXJ *j);
 457 static void DAA_Coeff_Australia(IXJ *j);
 458 static void DAA_Coeff_Japan(IXJ *j);
 459 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 460 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 461 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 462 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 463 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 464 /* Serial Control Interface funtions */
 465 static int SCI_Control(IXJ *j, int control);
 466 static int SCI_Prepare(IXJ *j);
 467 static int SCI_WaitHighSCI(IXJ *j);
 468 static int SCI_WaitLowSCI(IXJ *j);
 469 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 470 static int ixj_PCcontrol_wait(IXJ *j);
 471 static void ixj_pre_cid(IXJ *j);
 472 static void ixj_write_cid(IXJ *j);
 473 static void ixj_write_cid_bit(IXJ *j, int bit);
 474 static int set_base_frame(IXJ *j, int size);
 475 static int set_play_codec(IXJ *j, int rate);
 476 static void set_rec_depth(IXJ *j, int depth);
 477 static int ixj_mixer(long val, IXJ *j);
 478
 479 /************************************************************************
 480 CT8020/CT8021 Host Programmers Model
 481 Host address    Function                                        Access
 482 DSPbase +
 483 0-1             Aux Software Status Register (reserved)         Read Only
 484 2-3             Software Status Register                        Read Only
 485 4-5             Aux Software Control Register (reserved)        Read Write
 486 6-7             Software Control Register                       Read Write
 487 8-9             Hardware Status Register                        Read Only
 488 A-B             Hardware Control Register                       Read Write
 489 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 490 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 491 ************************************************************************/
 492
 493 static inline void ixj_read_HSR(IXJ *j)
 494 {
 495         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 496         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 497 }
 498
 499 static inline int IsControlReady(IXJ *j)
 500 {
 501         ixj_read_HSR(j);
 502         return j->hsr.bits.controlrdy ? 1 : 0;
 503 }
 504
 505 static inline int IsPCControlReady(IXJ *j)
 506 {
 507         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 508         return j->pccr1.bits.crr ? 1 : 0;
 509 }
 510
 511 static inline int IsStatusReady(IXJ *j)
 512 {
 513         ixj_read_HSR(j);
 514         return j->hsr.bits.statusrdy ? 1 : 0;
 515 }
 516
 517 static inline int IsRxReady(IXJ *j)
 518 {
 519         ixj_read_HSR(j);
 520         ixj_perfmon(j->rxreadycheck);
 521         return j->hsr.bits.rxrdy ? 1 : 0;
 522 }
 523
 524 static inline int IsTxReady(IXJ *j)
 525 {
 526         ixj_read_HSR(j);
 527         ixj_perfmon(j->txreadycheck);
 528         return j->hsr.bits.txrdy ? 1 : 0;
 529 }
 530
 531 static inline void set_play_volume(IXJ *j, int volume)
 532 {
 533         if (ixjdebug & 0x0002)
 534                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 535         ixj_WriteDSPCommand(0xCF02, j);
 536         ixj_WriteDSPCommand(volume, j);
 537 }
 538
 539 static int set_play_volume_linear(IXJ *j, int volume)
 540 {
 541         int newvolume, dspplaymax;
 542
 543         if (ixjdebug & 0x0002)
 544                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 545         if(volume > 100 || volume < 0) {
 546                 return -1;
 547         }
 548
 549         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 550         switch (j->cardtype) {
 551         case QTI_PHONEJACK:
 552                 dspplaymax = 0x380;
 553                 break;
 554         case QTI_LINEJACK:
 555                 if(j->port == PORT_PSTN) {
 556                         dspplaymax = 0x48;
 557                 } else {
 558                         dspplaymax = 0x100;
 559                 }
 560                 break;
 561         case QTI_PHONEJACK_LITE:
 562                 dspplaymax = 0x380;
 563                 break;
 564         case QTI_PHONEJACK_PCI:
 565                 dspplaymax = 0x6C;
 566                 break;
 567         case QTI_PHONECARD:
 568                 dspplaymax = 0x50;
 569                 break;
 570         default:
 571                 return -1;
 572         }
 573         newvolume = (dspplaymax * volume) / 100;
 574         set_play_volume(j, newvolume);
 575         return 0;
 576 }
 577
 578 static inline void set_play_depth(IXJ *j, int depth)
 579 {
 580         if (depth > 60)
 581                 depth = 60;
 582         if (depth < 0)
 583                 depth = 0;
 584         ixj_WriteDSPCommand(0x5280 + depth, j);
 585 }
 586
 587 static inline int get_play_volume(IXJ *j)
 588 {
 589         ixj_WriteDSPCommand(0xCF00, j);
 590         return j->ssr.high << 8 | j->ssr.low;
 591 }
 592
 593 static int get_play_volume_linear(IXJ *j)
 594 {
 595         int volume, newvolume, dspplaymax;
 596
 597         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 598         switch (j->cardtype) {
 599         case QTI_PHONEJACK:
 600                 dspplaymax = 0x380;
 601                 break;
 602         case QTI_LINEJACK:
 603                 if(j->port == PORT_PSTN) {
 604                         dspplaymax = 0x48;
 605                 } else {
 606                         dspplaymax = 0x100;
 607                 }
 608                 break;
 609         case QTI_PHONEJACK_LITE:
 610                 dspplaymax = 0x380;
 611                 break;
 612         case QTI_PHONEJACK_PCI:
 613                 dspplaymax = 0x6C;
 614                 break;
 615         case QTI_PHONECARD:
 616                 dspplaymax = 100;
 617                 break;
 618         default:
 619                 return -1;
 620         }
 621         volume = get_play_volume(j);
 622         newvolume = (volume * 100) / dspplaymax;
 623         if(newvolume > 100)
 624                 newvolume = 100;
 625         return newvolume;
 626 }
 627
 628 static inline BYTE SLIC_GetState(IXJ *j)
 629 {
 630         if (j->cardtype == QTI_PHONECARD) {
 631                 j->pccr1.byte = 0;
 632                 j->psccr.bits.dev = 3;
 633                 j->psccr.bits.rw = 1;
 634                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 635                 ixj_PCcontrol_wait(j);
 636                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 637                 ixj_PCcontrol_wait(j);
 638                 if (j->pslic.bits.powerdown)
 639                         return PLD_SLIC_STATE_OC;
 640                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 641                         return PLD_SLIC_STATE_ACTIVE;
 642                 else
 643                         return PLD_SLIC_STATE_RINGING;
 644         } else {
 645                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 646         }
 647         return j->pld_slicr.bits.state;
 648 }
 649
 650 static bool SLIC_SetState(BYTE byState, IXJ *j)
 651 {
 652         bool fRetVal = false;
 653
 654         if (j->cardtype == QTI_PHONECARD) {
 655                 if (j->flags.pcmciasct) {
 656                         switch (byState) {
 657                         case PLD_SLIC_STATE_TIPOPEN:
 658                         case PLD_SLIC_STATE_OC:
 659                                 j->pslic.bits.powerdown = 1;
 660                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 661                                 fRetVal = true;
 662                                 break;
 663                         case PLD_SLIC_STATE_RINGING:
 664                                 if (j->readers || j->writers) {
 665                                         j->pslic.bits.powerdown = 0;
 666                                         j->pslic.bits.ring0 = 1;
 667                                         j->pslic.bits.ring1 = 0;
 668                                         fRetVal = true;
 669                                 }
 670                                 break;
 671                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 672
 673                         case PLD_SLIC_STATE_STANDBY:
 674                         case PLD_SLIC_STATE_ACTIVE:
 675                                 if (j->readers || j->writers) {
 676                                         j->pslic.bits.powerdown = 0;
 677                                 } else {
 678                                         j->pslic.bits.powerdown = 1;
 679                                 }
 680                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 681                                 fRetVal = true;
 682                                 break;
 683                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 684
 685                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 686
 687                         default:
 688                                 fRetVal = false;
 689                                 break;
 690                         }
 691                         j->psccr.bits.dev = 3;
 692                         j->psccr.bits.rw = 0;
 693                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 694                         ixj_PCcontrol_wait(j);
 695                 }
 696         } else {
 697                 /* Set the C1, C2, C3 & B2EN signals. */
 698                 switch (byState) {
 699                 case PLD_SLIC_STATE_OC:
 700                         j->pld_slicw.bits.c1 = 0;
 701                         j->pld_slicw.bits.c2 = 0;
 702                         j->pld_slicw.bits.c3 = 0;
 703                         j->pld_slicw.bits.b2en = 0;
 704                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 705                         fRetVal = true;
 706                         break;
 707                 case PLD_SLIC_STATE_RINGING:
 708                         j->pld_slicw.bits.c1 = 1;
 709                         j->pld_slicw.bits.c2 = 0;
 710                         j->pld_slicw.bits.c3 = 0;
 711                         j->pld_slicw.bits.b2en = 1;
 712                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 713                         fRetVal = true;
 714                         break;
 715                 case PLD_SLIC_STATE_ACTIVE:
 716                         j->pld_slicw.bits.c1 = 0;
 717                         j->pld_slicw.bits.c2 = 1;
 718                         j->pld_slicw.bits.c3 = 0;
 719                         j->pld_slicw.bits.b2en = 0;
 720                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 721                         fRetVal = true;
 722                         break;
 723                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 724
 725                         j->pld_slicw.bits.c1 = 1;
 726                         j->pld_slicw.bits.c2 = 1;
 727                         j->pld_slicw.bits.c3 = 0;
 728                         j->pld_slicw.bits.b2en = 0;
 729                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 730                         fRetVal = true;
 731                         break;
 732                 case PLD_SLIC_STATE_TIPOPEN:
 733                         j->pld_slicw.bits.c1 = 0;
 734                         j->pld_slicw.bits.c2 = 0;
 735                         j->pld_slicw.bits.c3 = 1;
 736                         j->pld_slicw.bits.b2en = 0;
 737                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 738                         fRetVal = true;
 739                         break;
 740                 case PLD_SLIC_STATE_STANDBY:
 741                         j->pld_slicw.bits.c1 = 1;
 742                         j->pld_slicw.bits.c2 = 0;
 743                         j->pld_slicw.bits.c3 = 1;
 744                         j->pld_slicw.bits.b2en = 1;
 745                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 746                         fRetVal = true;
 747                         break;
 748                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 749
 750                         j->pld_slicw.bits.c1 = 0;
 751                         j->pld_slicw.bits.c2 = 1;
 752                         j->pld_slicw.bits.c3 = 1;
 753                         j->pld_slicw.bits.b2en = 0;
 754                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 755                         fRetVal = true;
 756                         break;
 757                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 758
 759                         j->pld_slicw.bits.c1 = 1;
 760                         j->pld_slicw.bits.c2 = 1;
 761                         j->pld_slicw.bits.c3 = 1;
 762                         j->pld_slicw.bits.b2en = 0;
 763                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 764                         fRetVal = true;
 765                         break;
 766                 default:
 767                         fRetVal = false;
 768                         break;
 769                 }
 770         }
 771
 772         return fRetVal;
 773 }
 774
 775 static int ixj_wink(IXJ *j)
 776 {
 777         BYTE slicnow;
 778
 779         slicnow = SLIC_GetState(j);
 780
 781         j->pots_winkstart = jiffies;
 782         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 783
 784         msleep(jiffies_to_msecs(j->winktime));
 785
 786         SLIC_SetState(slicnow, j);
 787         return 0;
 788 }
 789
 790 static void ixj_init_timer(IXJ *j)
 791 {
 792         init_timer(&j->timer);
 793         j->timer.function = ixj_timeout;
 794         j->timer.data = (unsigned long)j;
 795 }
 796
 797 static void ixj_add_timer(IXJ *j)
 798 {
 799         j->timer.expires = jiffies + (hertz / samplerate);
 800         add_timer(&j->timer);
 801 }
 802
 803 static void ixj_tone_timeout(IXJ *j)
 804 {
 805         IXJ_TONE ti;
 806
 807         j->tone_state++;
 808         if (j->tone_state == 3) {
 809                 j->tone_state = 0;
 810                 if (j->cadence_t) {
 811                         j->tone_cadence_state++;
 812                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 813                                 switch (j->cadence_t->termination) {
 814                                 case PLAY_ONCE:
 815                                         ixj_cpt_stop(j);
 816                                         break;
 817                                 case REPEAT_LAST_ELEMENT:
 818                                         j->tone_cadence_state--;
 819                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 820                                         break;
 821                                 case REPEAT_ALL:
 822                                         j->tone_cadence_state = 0;
 823                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 824                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 825                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 826                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 827                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 828                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 829                                                 ixj_init_tone(j, &ti);
 830                                         }
 831                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 832                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 833                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 834                                         break;
 835                                 }
 836                         } else {
 837                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 838                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 839                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 840                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 841                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 842                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 843                                         ixj_init_tone(j, &ti);
 844                                 }
 845                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 846                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 847                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 848                         }
 849                 }
 850         }
 851 }
 852
 853 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 854 {
 855         if(j->ixj_signals[event]) {
 856                 if(ixjdebug & 0x0100)
 857                         printk("Sending signal for event %d\n", event);
 858                         /* Send apps notice of change */
 859                 /* see config.h for macro definition */
 860                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 861         }
 862 }
 863
 864 static void ixj_pstn_state(IXJ *j)
 865 {
 866         int var;
 867         union XOPXR0 XR0, daaint;
 868
 869         var = 10;
 870
 871         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 872         daaint.reg = 0;
 873         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 874
 875         j->pld_scrr.byte = inb_p(j->XILINXbase);
 876         if (j->pld_scrr.bits.daaflag) {
 877                 daa_int_read(j);
 878                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 879                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 880                                 daaint.bitreg.RING = 1;
 881                                 if(ixjdebug & 0x0008) {
 882                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 883                                 }
 884                         } else {
 885                                 daa_set_mode(j, SOP_PU_RESET);
 886                         }
 887                 }
 888                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 889                         daaint.bitreg.Caller_ID = 1;
 890                         j->pstn_cid_intr = 1;
 891                         j->pstn_cid_received = jiffies;
 892                         if(ixjdebug & 0x0008) {
 893                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 894                         }
 895                 }
 896                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 897                         daaint.bitreg.Cadence = 1;
 898                         if(ixjdebug & 0x0008) {
 899                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 900                         }
 901                 }
 902                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 903                         daaint.bitreg.VDD_OK = 1;
 904                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 905                 }
 906         }
 907         daa_CR_read(j, 1);
 908         if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 909                 daaint.bitreg.RMR = 1;
 910                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 911                 if(ixjdebug & 0x0008) {
 912                         printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
 913                 }
 914                 j->pstn_prev_rmr = j->pstn_last_rmr;
 915                 j->pstn_last_rmr = jiffies;
 916         }
 917         switch(j->daa_mode) {
 918                 case SOP_PU_SLEEP:
 919                         if (daaint.bitreg.RING) {
 920                                 if (!j->flags.pstn_ringing) {
 921                                         if (j->daa_mode != SOP_PU_RINGING) {
 922                                                 j->pstn_ring_int = jiffies;
 923                                                 daa_set_mode(j, SOP_PU_RINGING);
 924                                         }
 925                                 }
 926                         }
 927                         break;
 928                 case SOP_PU_RINGING:
 929                         if (daaint.bitreg.RMR) {
 930                                 if (ixjdebug & 0x0008) {
 931                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 932                                 }
 933                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 934                                         j->flags.pstn_rmr = 1;
 935                                         j->pstn_ring_start = jiffies;
 936                                         j->pstn_ring_stop = 0;
 937                                         j->ex.bits.pstn_ring = 0;
 938                                         if (j->cadence_f[4].state == 0) {
 939                                                 j->cadence_f[4].state = 1;
 940                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 941                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 942                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 943                                         } else if (j->cadence_f[4].state == 2) {
 944                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 945                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 946                                                         if (j->cadence_f[4].on2) {
 947                                                                 j->cadence_f[4].state = 3;
 948                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 949                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 950                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 951                                                         } else {
 952                                                                 j->cadence_f[4].state = 7;
 953                                                         }
 954                                                 } else {
 955                                                         if (ixjdebug & 0x0008) {
 956                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 957                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 958                                                                                 j->cadence_f[4].off1);
 959                                                         }
 960                                                         j->cadence_f[4].state = 0;
 961                                                 }
 962                                         } else if (j->cadence_f[4].state == 4) {
 963                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 964                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 965                                                         if (j->cadence_f[4].on3) {
 966                                                                 j->cadence_f[4].state = 5;
 967                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 968                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 969                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 970                                                         } else {
 971                                                                 j->cadence_f[4].state = 7;
 972                                                         }
 973                                                 } else {
 974                                                         if (ixjdebug & 0x0008) {
 975                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 976                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 977                                                                                 j->cadence_f[4].off2);
 978                                                         }
 979                                                         j->cadence_f[4].state = 0;
 980                                                 }
 981                                         } else if (j->cadence_f[4].state == 6) {
 982                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 983                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 984                                                         j->cadence_f[4].state = 7;
 985                                                 } else {
 986                                                         if (ixjdebug & 0x0008) {
 987                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 988                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 989                                                                                 j->cadence_f[4].off3);
 990                                                         }
 991                                                         j->cadence_f[4].state = 0;
 992                                                 }
 993                                         } else {
 994                                                 j->cadence_f[4].state = 0;
 995                                         }
 996                                 } else {                                /* Falling edge of RMR */
 997                                         j->pstn_ring_start = 0;
 998                                         j->pstn_ring_stop = jiffies;
 999                                         if (j->cadence_f[4].state == 1) {
1000                                                 if(!j->cadence_f[4].on1) {
1001                                                         j->cadence_f[4].state = 7;
1002                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1003                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1004                                                         if (j->cadence_f[4].off1) {
1005                                                                 j->cadence_f[4].state = 2;
1006                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1007                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1008                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1009                                                         } else {
1010                                                                 j->cadence_f[4].state = 7;
1011                                                         }
1012                                                 } else {
1013                                                         if (ixjdebug & 0x0008) {
1014                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1015                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1016                                                                                 j->cadence_f[4].on1);
1017                                                         }
1018                                                         j->cadence_f[4].state = 0;
1019                                                 }
1020                                         } else if (j->cadence_f[4].state == 3) {
1021                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1022                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1023                                                         if (j->cadence_f[4].off2) {
1024                                                                 j->cadence_f[4].state = 4;
1025                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1026                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1027                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1028                                                         } else {
1029                                                                 j->cadence_f[4].state = 7;
1030                                                         }
1031                                                 } else {
1032                                                         if (ixjdebug & 0x0008) {
1033                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1034                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1035                                                                                 j->cadence_f[4].on2);
1036                                                         }
1037                                                         j->cadence_f[4].state = 0;
1038                                                 }
1039                                         } else if (j->cadence_f[4].state == 5) {
1040                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1041                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1042                                                         if (j->cadence_f[4].off3) {
1043                                                                 j->cadence_f[4].state = 6;
1044                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1045                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1046                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1047                                                         } else {
1048                                                                 j->cadence_f[4].state = 7;
1049                                                         }
1050                                                 } else {
1051                                                         j->cadence_f[4].state = 0;
1052                                                 }
1053                                         } else {
1054                                                 if (ixjdebug & 0x0008) {
1055                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1056                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1057                                                                         j->cadence_f[4].on3);
1058                                                 }
1059                                                 j->cadence_f[4].state = 0;
1060                                         }
1061                                 }
1062                                 if (ixjdebug & 0x0010) {
1063                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1064                                 }
1065                                 if (ixjdebug & 0x0010) {
1066                                         switch(j->cadence_f[4].state) {
1067                                                 case 1:
1068                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1069                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1070                                                         break;
1071                                                 case 2:
1072                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1073                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1074                                                         break;
1075                                                 case 3:
1076                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1077                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1078                                                         break;
1079                                                 case 4:
1080                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1081                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1082                                                         break;
1083                                                 case 5:
1084                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1085                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1086                                                         break;
1087                                                 case 6:
1088                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1089                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1090                                                         break;
1091                                         }
1092                                 }
1093                         }
1094                         if (j->cadence_f[4].state == 7) {
1095                                 j->cadence_f[4].state = 0;
1096                                 j->pstn_ring_stop = jiffies;
1097                                 j->ex.bits.pstn_ring = 1;
1098                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1099                                 if(ixjdebug & 0x0008) {
1100                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1101                                 }
1102                         }
1103                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1104                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1105                                 if(ixjdebug & 0x0008) {
1106                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1107                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1108                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1109                                 }
1110                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1111                                 daa_set_mode(j, SOP_PU_SLEEP);
1112                         }
1113                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1114                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1115                                 ixj_daa_cid_read(j);
1116                                 j->ex.bits.caller_id = 1;
1117                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1118                                 j->pstn_cid_intr = 0;
1119                         }
1120                         if (daaint.bitreg.Cadence) {
1121                                 if(ixjdebug & 0x0008) {
1122                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1123                                 }
1124                                 daa_set_mode(j, SOP_PU_SLEEP);
1125                                 j->ex.bits.pstn_ring = 0;
1126                         }
1127                         break;
1128                 case SOP_PU_CONVERSATION:
1129                         if (daaint.bitreg.VDD_OK) {
1130                                 if(!daaint.bitreg.SI_0) {
1131                                         if (!j->pstn_winkstart) {
1132                                                 if(ixjdebug & 0x0008) {
1133                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1134                                                 }
1135                                                 j->pstn_winkstart = jiffies;
1136                                         }
1137                                 } else {
1138                                         if (j->pstn_winkstart) {
1139                                                 if(ixjdebug & 0x0008) {
1140                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1141                                                 }
1142                                                 j->pstn_winkstart = 0;
1143                                         }
1144                                 }
1145                         }
1146                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1147                                 if(ixjdebug & 0x0008) {
1148                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1149                                 }
1150                                 daa_set_mode(j, SOP_PU_SLEEP);
1151                                 j->pstn_winkstart = 0;
1152                                 j->ex.bits.pstn_wink = 1;
1153                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1154                         }
1155                         break;
1156         }
1157 }
1158
1159 static void ixj_timeout(unsigned long ptr)
1160 {
1161         int board;
1162         unsigned long jifon;
1163         IXJ *j = (IXJ *)ptr;
1164         board = j->board;
1165
1166         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1167                 ixj_perfmon(j->timerchecks);
1168                 j->hookstate = ixj_hookstate(j);
1169                 if (j->tone_state) {
1170                         if (!(j->hookstate)) {
1171                                 ixj_cpt_stop(j);
1172                                 if (j->m_hook) {
1173                                         j->m_hook = 0;
1174                                         j->ex.bits.hookstate = 1;
1175                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1176                                 }
1177                                 clear_bit(board, &j->busyflags);
1178                                 ixj_add_timer(j);
1179                                 return;
1180                         }
1181                         if (j->tone_state == 1)
1182                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1183                         else
1184                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1185                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1186                                 if (j->tone_state == 1) {
1187                                         ixj_play_tone(j, j->tone_index);
1188                                         if (j->dsp.low == 0x20) {
1189                                                 clear_bit(board, &j->busyflags);
1190                                                 ixj_add_timer(j);
1191                                                 return;
1192                                         }
1193                                 } else {
1194                                         ixj_play_tone(j, 0);
1195                                         if (j->dsp.low == 0x20) {
1196                                                 clear_bit(board, &j->busyflags);
1197                                                 ixj_add_timer(j);
1198                                                 return;
1199                                         }
1200                                 }
1201                         } else {
1202                                 ixj_tone_timeout(j);
1203                                 if (j->flags.dialtone) {
1204                                         ixj_dialtone(j);
1205                                 }
1206                                 if (j->flags.busytone) {
1207                                         ixj_busytone(j);
1208                                         if (j->dsp.low == 0x20) {
1209                                                 clear_bit(board, &j->busyflags);
1210                                                 ixj_add_timer(j);
1211                                                 return;
1212                                         }
1213                                 }
1214                                 if (j->flags.ringback) {
1215                                         ixj_ringback(j);
1216                                         if (j->dsp.low == 0x20) {
1217                                                 clear_bit(board, &j->busyflags);
1218                                                 ixj_add_timer(j);
1219                                                 return;
1220                                         }
1221                                 }
1222                                 if (!j->tone_state) {
1223                                         ixj_cpt_stop(j);
1224                                 }
1225                         }
1226                 }
1227                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1228                         if (IsRxReady(j)) {
1229                                 ixj_read_frame(j);
1230                         }
1231                         if (IsTxReady(j)) {
1232                                 ixj_write_frame(j);
1233                         }
1234                 }
1235                 if (j->flags.cringing) {
1236                         if (j->hookstate & 1) {
1237                                 j->flags.cringing = 0;
1238                                 ixj_ring_off(j);
1239                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1240                                 switch(j->cadence_f[5].state) {
1241                                         case 0:
1242                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1243                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1244                                                         if(ixjdebug & 0x0004) {
1245                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1246                                                         }
1247                                                         ixj_ring_on(j);
1248                                                 }
1249                                                 j->cadence_f[5].state = 1;
1250                                                 break;
1251                                         case 1:
1252                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1253                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1254                                                         if(ixjdebug & 0x0004) {
1255                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1256                                                         }
1257                                                         ixj_ring_off(j);
1258                                                         j->cadence_f[5].state = 2;
1259                                                 }
1260                                                 break;
1261                                         case 2:
1262                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1263                                                         if(ixjdebug & 0x0004) {
1264                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1265                                                         }
1266                                                         ixj_ring_on(j);
1267                                                         if (j->cadence_f[5].on2) {
1268                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1269                                                                 j->cadence_f[5].state = 3;
1270                                                         } else {
1271                                                                 j->cadence_f[5].state = 7;
1272                                                         }
1273                                                 }
1274                                                 break;
1275                                         case 3:
1276                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1277                                                         if(ixjdebug & 0x0004) {
1278                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1279                                                         }
1280                                                         ixj_ring_off(j);
1281                                                         if (j->cadence_f[5].off2) {
1282                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1283                                                                 j->cadence_f[5].state = 4;
1284                                                         } else {
1285                                                                 j->cadence_f[5].state = 7;
1286                                                         }
1287                                                 }
1288                                                 break;
1289                                         case 4:
1290                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1291                                                         if(ixjdebug & 0x0004) {
1292                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1293                                                         }
1294                                                         ixj_ring_on(j);
1295                                                         if (j->cadence_f[5].on3) {
1296                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1297                                                                 j->cadence_f[5].state = 5;
1298                                                         } else {
1299                                                                 j->cadence_f[5].state = 7;
1300                                                         }
1301                                                 }
1302                                                 break;
1303                                         case 5:
1304                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1305                                                         if(ixjdebug & 0x0004) {
1306                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1307                                                         }
1308                                                         ixj_ring_off(j);
1309                                                         if (j->cadence_f[5].off3) {
1310                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1311                                                                 j->cadence_f[5].state = 6;
1312                                                         } else {
1313                                                                 j->cadence_f[5].state = 7;
1314                                                         }
1315                                                 }
1316                                                 break;
1317                                         case 6:
1318                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1319                                                         if(ixjdebug & 0x0004) {
1320                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1321                                                         }
1322                                                         j->cadence_f[5].state = 7;
1323                                                 }
1324                                                 break;
1325                                         case 7:
1326                                                 if(ixjdebug & 0x0004) {
1327                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1328                                                 }
1329                                                 j->flags.cidring = 1;
1330                                                 j->cadence_f[5].state = 0;
1331                                                 break;
1332                                 }
1333                                 if (j->flags.cidring && !j->flags.cidsent) {
1334                                         j->flags.cidsent = 1;
1335                                         if(j->fskdcnt) {
1336                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1337                                                 ixj_pre_cid(j);
1338                                         }
1339                                         j->flags.cidring = 0;
1340                                 }
1341                                 clear_bit(board, &j->busyflags);
1342                                 ixj_add_timer(j);
1343                                 return;
1344                         } else {
1345                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1346                                         if (j->flags.cidring && !j->flags.cidsent) {
1347                                                 j->flags.cidsent = 1;
1348                                                 if(j->fskdcnt) {
1349                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1350                                                         ixj_pre_cid(j);
1351                                                 }
1352                                                 j->flags.cidring = 0;
1353                                         }
1354                                         j->ring_cadence_t--;
1355                                         if (j->ring_cadence_t == -1)
1356                                                 j->ring_cadence_t = 15;
1357                                         j->ring_cadence_jif = jiffies;
1358
1359                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1360                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1361                                                         j->flags.firstring = 1;
1362                                                 else
1363                                                         ixj_ring_on(j);
1364                                         } else {
1365                                                 ixj_ring_off(j);
1366                                                 if(!j->flags.cidsent)
1367                                                         j->flags.cidring = 1;
1368                                         }
1369                                 }
1370                                 clear_bit(board, &j->busyflags);
1371                                 ixj_add_timer(j);
1372                                 return;
1373                         }
1374                 }
1375                 if (!j->flags.ringing) {
1376                         if (j->hookstate) { /* & 1) { */
1377                                 if (j->dsp.low != 0x20 &&
1378                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1379                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1380                                 }
1381                                 LineMonitor(j);
1382                                 read_filters(j);
1383                                 ixj_WriteDSPCommand(0x511B, j);
1384                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1385                                 if (!j->m_hook && (j->hookstate & 1)) {
1386                                         j->m_hook = j->ex.bits.hookstate = 1;
1387                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1388                                 }
1389                         } else {
1390                                 if (j->ex.bits.dtmf_ready) {
1391                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1392                                 }
1393                                 if (j->m_hook) {
1394                                         j->m_hook = 0;
1395                                         j->ex.bits.hookstate = 1;
1396                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1397                                 }
1398                         }
1399                 }
1400                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1401                         ixj_pstn_state(j);
1402                 }
1403                 if (j->ex.bytes) {
1404                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1405                 }
1406                 clear_bit(board, &j->busyflags);
1407         }
1408         ixj_add_timer(j);
1409 }
1410
1411 static int ixj_status_wait(IXJ *j)
1412 {
1413         unsigned long jif;
1414
1415         jif = jiffies + ((60 * hertz) / 100);
1416         while (!IsStatusReady(j)) {
1417                 ixj_perfmon(j->statuswait);
1418                 if (time_after(jiffies, jif)) {
1419                         ixj_perfmon(j->statuswaitfail);
1420                         return -1;
1421                 }
1422         }
1423         return 0;
1424 }
1425
1426 static int ixj_PCcontrol_wait(IXJ *j)
1427 {
1428         unsigned long jif;
1429
1430         jif = jiffies + ((60 * hertz) / 100);
1431         while (!IsPCControlReady(j)) {
1432                 ixj_perfmon(j->pcontrolwait);
1433                 if (time_after(jiffies, jif)) {
1434                         ixj_perfmon(j->pcontrolwaitfail);
1435                         return -1;
1436                 }
1437         }
1438         return 0;
1439 }
1440
1441 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1442 {
1443         BYTES bytes;
1444         unsigned long jif;
1445
1446         atomic_inc(&j->DSPWrite);
1447         if(atomic_read(&j->DSPWrite) > 1) {
1448                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1449                 return -1;
1450         }
1451         bytes.high = (cmd & 0xFF00) >> 8;
1452         bytes.low = cmd & 0x00FF;
1453         jif = jiffies + ((60 * hertz) / 100);
1454         while (!IsControlReady(j)) {
1455                 ixj_perfmon(j->iscontrolready);
1456                 if (time_after(jiffies, jif)) {
1457                         ixj_perfmon(j->iscontrolreadyfail);
1458                         atomic_dec(&j->DSPWrite);
1459                         if(atomic_read(&j->DSPWrite) > 0) {
1460                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1461                                 while(atomic_read(&j->DSPWrite) > 0) {
1462                                         atomic_dec(&j->DSPWrite);
1463                                 }
1464                         }
1465                         return -1;
1466                 }
1467         }
1468         outb(bytes.low, j->DSPbase + 6);
1469         outb(bytes.high, j->DSPbase + 7);
1470
1471         if (ixj_status_wait(j)) {
1472                 j->ssr.low = 0xFF;
1473                 j->ssr.high = 0xFF;
1474                 atomic_dec(&j->DSPWrite);
1475                 if(atomic_read(&j->DSPWrite) > 0) {
1476                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1477                         while(atomic_read(&j->DSPWrite) > 0) {
1478                                 atomic_dec(&j->DSPWrite);
1479                         }
1480                 }
1481                 return -1;
1482         }
1483 /* Read Software Status Register */
1484         j->ssr.low = inb_p(j->DSPbase + 2);
1485         j->ssr.high = inb_p(j->DSPbase + 3);
1486         atomic_dec(&j->DSPWrite);
1487         if(atomic_read(&j->DSPWrite) > 0) {
1488                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1489                 while(atomic_read(&j->DSPWrite) > 0) {
1490                         atomic_dec(&j->DSPWrite);
1491                 }
1492         }
1493         return 0;
1494 }
1495
1496 /***************************************************************************
1497 *
1498 *  General Purpose IO Register read routine
1499 *
1500 ***************************************************************************/
1501 static inline int ixj_gpio_read(IXJ *j)
1502 {
1503         if (ixj_WriteDSPCommand(0x5143, j))
1504                 return -1;
1505
1506         j->gpio.bytes.low = j->ssr.low;
1507         j->gpio.bytes.high = j->ssr.high;
1508
1509         return 0;
1510 }
1511
1512 static inline void LED_SetState(int state, IXJ *j)
1513 {
1514         if (j->cardtype == QTI_LINEJACK) {
1515                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1516                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1517                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1518                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1519
1520                 outb(j->pld_scrw.byte, j->XILINXbase);
1521         }
1522 }
1523
1524 /*********************************************************************
1525 *  GPIO Pins are configured as follows on the Quicknet Internet
1526 *  PhoneJACK Telephony Cards
1527 *
1528 * POTS Select        GPIO_6=0 GPIO_7=0
1529 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1530 * Handset Select     GPIO_6=1 GPIO_7=0
1531 *
1532 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1533 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1534 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1535 *
1536 * Hook Switch changes reported on GPIO_3
1537 *********************************************************************/
1538 static int ixj_set_port(IXJ *j, int arg)
1539 {
1540         if (j->cardtype == QTI_PHONEJACK_LITE) {
1541                 if (arg != PORT_POTS)
1542                         return 10;
1543                 else
1544                         return 0;
1545         }
1546         switch (arg) {
1547         case PORT_POTS:
1548                 j->port = PORT_POTS;
1549                 switch (j->cardtype) {
1550                 case QTI_PHONECARD:
1551                         if (j->flags.pcmciasct == 1)
1552                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1553                         else
1554                                 return 11;
1555                         break;
1556                 case QTI_PHONEJACK_PCI:
1557                         j->pld_slicw.pcib.mic = 0;
1558                         j->pld_slicw.pcib.spk = 0;
1559                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1560                         break;
1561                 case QTI_LINEJACK:
1562                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1563                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1564                                                                            Software Control Register */
1565                                 return 2;
1566                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1567
1568                         outb(j->pld_scrw.byte, j->XILINXbase);
1569                         j->pld_clock.byte = 0;
1570                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1571                         j->pld_slicw.bits.rly1 = 1;
1572                         j->pld_slicw.bits.spken = 0;
1573                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1574                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1575                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1576                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1577                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1578                         ixj_mixer(0x0E80, j);   /*Mic mute */
1579                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1580                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1581                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1582                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1583 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1584                         break;
1585                 case QTI_PHONEJACK:
1586                         j->gpio.bytes.high = 0x0B;
1587                         j->gpio.bits.gpio6 = 0;
1588                         j->gpio.bits.gpio7 = 0;
1589                         ixj_WriteDSPCommand(j->gpio.word, j);
1590                         break;
1591                 }
1592                 break;
1593         case PORT_PSTN:
1594                 if (j->cardtype == QTI_LINEJACK) {
1595                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1596
1597                         j->pld_slicw.bits.rly3 = 0;
1598                         j->pld_slicw.bits.rly1 = 1;
1599                         j->pld_slicw.bits.spken = 0;
1600                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1601                         j->port = PORT_PSTN;
1602                 } else {
1603                         return 4;
1604                 }
1605                 break;
1606         case PORT_SPEAKER:
1607                 j->port = PORT_SPEAKER;
1608                 switch (j->cardtype) {
1609                 case QTI_PHONECARD:
1610                         if (j->flags.pcmciasct) {
1611                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1612                         }
1613                         break;
1614                 case QTI_PHONEJACK_PCI:
1615                         j->pld_slicw.pcib.mic = 1;
1616                         j->pld_slicw.pcib.spk = 1;
1617                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1618                         break;
1619                 case QTI_LINEJACK:
1620                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1621                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1622                                                                            Software Control Register */
1623                                 return 2;
1624                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1625
1626                         outb(j->pld_scrw.byte, j->XILINXbase);
1627                         j->pld_clock.byte = 0;
1628                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1629                         j->pld_slicw.bits.rly1 = 1;
1630                         j->pld_slicw.bits.spken = 1;
1631                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1632                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1633                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1634                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1635                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1636                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1637                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1638                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1639                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1640                         break;
1641                 case QTI_PHONEJACK:
1642                         j->gpio.bytes.high = 0x0B;
1643                         j->gpio.bits.gpio6 = 0;
1644                         j->gpio.bits.gpio7 = 1;
1645                         ixj_WriteDSPCommand(j->gpio.word, j);
1646                         break;
1647                 }
1648                 break;
1649         case PORT_HANDSET:
1650                 if (j->cardtype != QTI_PHONEJACK) {
1651                         return 5;
1652                 } else {
1653                         j->gpio.bytes.high = 0x0B;
1654                         j->gpio.bits.gpio6 = 1;
1655                         j->gpio.bits.gpio7 = 0;
1656                         ixj_WriteDSPCommand(j->gpio.word, j);
1657                         j->port = PORT_HANDSET;
1658                 }
1659                 break;
1660         default:
1661                 return 6;
1662                 break;
1663         }
1664         return 0;
1665 }
1666
1667 static int ixj_set_pots(IXJ *j, int arg)
1668 {
1669         if (j->cardtype == QTI_LINEJACK) {
1670                 if (arg) {
1671                         if (j->port == PORT_PSTN) {
1672                                 j->pld_slicw.bits.rly1 = 0;
1673                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1674                                 j->flags.pots_pstn = 1;
1675                                 return 1;
1676                         } else {
1677                                 j->flags.pots_pstn = 0;
1678                                 return 0;
1679                         }
1680                 } else {
1681                         j->pld_slicw.bits.rly1 = 1;
1682                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1683                         j->flags.pots_pstn = 0;
1684                         return 1;
1685                 }
1686         } else {
1687                 return 0;
1688         }
1689 }
1690
1691 static void ixj_ring_on(IXJ *j)
1692 {
1693         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1694          {
1695                 if (ixjdebug & 0x0004)
1696                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1697
1698                 j->gpio.bytes.high = 0x0B;
1699                 j->gpio.bytes.low = 0x00;
1700                 j->gpio.bits.gpio1 = 1;
1701                 j->gpio.bits.gpio2 = 1;
1702                 j->gpio.bits.gpio5 = 0;
1703                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1704         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1705         {
1706                 if (ixjdebug & 0x0004)
1707                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1708
1709                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1710         }
1711 }
1712
1713 static int ixj_siadc(IXJ *j, int val)
1714 {
1715         if(j->cardtype == QTI_PHONECARD){
1716                 if(j->flags.pcmciascp){
1717                         if(val == -1)
1718                                 return j->siadc.bits.rxg;
1719
1720                         if(val < 0 || val > 0x1F)
1721                                 return -1;
1722
1723                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1724                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1725                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1726                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1727                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1728                         j->psccr.bits.dev = 0;
1729                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1730                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1731                         ixj_PCcontrol_wait(j);
1732                         return j->siadc.bits.rxg;
1733                 }
1734         }
1735         return -1;
1736 }
1737
1738 static int ixj_sidac(IXJ *j, int val)
1739 {
1740         if(j->cardtype == QTI_PHONECARD){
1741                 if(j->flags.pcmciascp){
1742                         if(val == -1)
1743                                 return j->sidac.bits.txg;
1744
1745                         if(val < 0 || val > 0x1F)
1746                                 return -1;
1747
1748                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1749                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1750                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1751                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1752                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1753                         j->psccr.bits.dev = 0;
1754                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1755                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1756                         ixj_PCcontrol_wait(j);
1757                         return j->sidac.bits.txg;
1758                 }
1759         }
1760         return -1;
1761 }
1762
1763 static int ixj_pcmcia_cable_check(IXJ *j)
1764 {
1765         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1766         if (!j->flags.pcmciastate) {
1767                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1768                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1769                         j->flags.pcmciastate = 4;
1770                         return 0;
1771                 }
1772                 if (j->pccr1.bits.ed) {
1773                         j->pccr1.bits.ed = 0;
1774                         j->psccr.bits.dev = 3;
1775                         j->psccr.bits.rw = 1;
1776                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1777                         ixj_PCcontrol_wait(j);
1778                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1779                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1780                         j->psccr.bits.dev = 3;
1781                         j->psccr.bits.rw = 0;
1782                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1783                         ixj_PCcontrol_wait(j);
1784                         return j->pslic.bits.led2 ? 1 : 0;
1785                 } else if (j->flags.pcmciasct) {
1786                         return j->r_hook;
1787                 } else {
1788                         return 1;
1789                 }
1790         } else if (j->flags.pcmciastate == 4) {
1791                 if (!j->pccr1.bits.drf) {
1792                         j->flags.pcmciastate = 3;
1793                 }
1794                 return 0;
1795         } else if (j->flags.pcmciastate == 3) {
1796                 j->pccr2.bits.pwr = 0;
1797                 j->pccr2.bits.rstc = 1;
1798                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1799                 j->checkwait = jiffies + (hertz * 2);
1800                 j->flags.incheck = 1;
1801                 j->flags.pcmciastate = 2;
1802                 return 0;
1803         } else if (j->flags.pcmciastate == 2) {
1804                 if (j->flags.incheck) {
1805                         if (time_before(jiffies, j->checkwait)) {
1806                                 return 0;
1807                         } else {
1808                                 j->flags.incheck = 0;
1809                         }
1810                 }
1811                 j->pccr2.bits.pwr = 0;
1812                 j->pccr2.bits.rstc = 0;
1813                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1814                 j->flags.pcmciastate = 1;
1815                 return 0;
1816         } else if (j->flags.pcmciastate == 1) {
1817                 j->flags.pcmciastate = 0;
1818                 if (!j->pccr1.bits.drf) {
1819                         j->psccr.bits.dev = 3;
1820                         j->psccr.bits.rw = 1;
1821                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1822                         ixj_PCcontrol_wait(j);
1823                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1824
1825                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1826
1827                         if (j->flags.pcmciasct == 3) {
1828                                 j->flags.pcmciastate = 4;
1829                                 return 0;
1830                         } else if (j->flags.pcmciasct == 0) {
1831                                 j->pccr2.bits.pwr = 1;
1832                                 j->pccr2.bits.rstc = 0;
1833                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1834                                 j->port = PORT_SPEAKER;
1835                         } else {
1836                                 j->port = PORT_POTS;
1837                         }
1838                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1839                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1840                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1841                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1842                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1843                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1844                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1845                         j->psccr.bits.dev = 0;
1846                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1847                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1848                         ixj_PCcontrol_wait(j);
1849
1850                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1851                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1852                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1853                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1854                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1855                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1856                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1857                         j->psccr.bits.dev = 0;
1858                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1859                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1860                         ixj_PCcontrol_wait(j);
1861
1862                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1863                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1864                         j->psccr.bits.dev = 0;
1865                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1866                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1867                         ixj_PCcontrol_wait(j);
1868
1869                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1870                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1871                         j->psccr.bits.dev = 0;
1872                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1873                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1874                         ixj_PCcontrol_wait(j);
1875
1876                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1877                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1878                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1879                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1880                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1881                         j->sirxg.bits.iir = 1;                          /* IIR */
1882                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1883                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1884                         j->psccr.bits.dev = 0;
1885                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1886                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1887                         ixj_PCcontrol_wait(j);
1888
1889                         ixj_siadc(j, 0x17);
1890                         ixj_sidac(j, 0x1D);
1891
1892                         j->siaatt.bits.sot = 0;
1893                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1894                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1895                         j->psccr.bits.dev = 0;
1896                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1897                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1898                         ixj_PCcontrol_wait(j);
1899
1900                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1901                                 j->psccr.byte = j->pslic.byte = 0;
1902                                 j->pslic.bits.powerdown = 1;
1903                                 j->psccr.bits.dev = 3;
1904                                 j->psccr.bits.rw = 0;
1905                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1906                                 ixj_PCcontrol_wait(j);
1907                         }
1908                 }
1909                 return 0;
1910         } else {
1911                 j->flags.pcmciascp = 0;
1912                 return 0;
1913         }
1914         return 0;
1915 }
1916
1917 static int ixj_hookstate(IXJ *j)
1918 {
1919         int fOffHook = 0;
1920
1921         switch (j->cardtype) {
1922         case QTI_PHONEJACK:
1923                 ixj_gpio_read(j);
1924                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1925                 break;
1926         case QTI_LINEJACK:
1927         case QTI_PHONEJACK_LITE:
1928         case QTI_PHONEJACK_PCI:
1929                 SLIC_GetState(j);
1930                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1931                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1932                         if(fOffHook != j->p_hook) {
1933                                 if(!j->checkwait) {
1934                                         j->checkwait = jiffies;
1935                                 }
1936                                 if(time_before(jiffies, j->checkwait + 2)) {
1937                                         fOffHook ^= 1;
1938                                 } else {
1939                                         j->checkwait = 0;
1940                                 }
1941                                 j->p_hook = fOffHook;
1942                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1943                         }
1944                 } else {
1945                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1946                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1947                                 if (j->flags.ringing || j->flags.cringing) {
1948                                         if (!in_interrupt()) {
1949                                                 msleep(20);
1950                                         }
1951                                         SLIC_GetState(j);
1952                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1953                                                 ixj_ring_on(j);
1954                                         }
1955                                 }
1956                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1957                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1958                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1959                                 } else
1960                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1961                         }
1962                 }
1963                 break;
1964         case QTI_PHONECARD:
1965                 fOffHook = ixj_pcmcia_cable_check(j);
1966                 break;
1967         }
1968         if (j->r_hook != fOffHook) {
1969                 j->r_hook = fOffHook;
1970                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1971                         j->ex.bits.hookstate = 1;
1972                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1973                 } else if (!fOffHook) {
1974                         j->flash_end = jiffies + ((60 * hertz) / 100);
1975                 }
1976         }
1977         if (fOffHook) {
1978                 if(time_before(jiffies, j->flash_end)) {
1979                         j->ex.bits.flash = 1;
1980                         j->flash_end = 0;
1981                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1982                 }
1983         } else {
1984                 if(time_before(jiffies, j->flash_end)) {
1985                         fOffHook = 1;
1986                 }
1987         }
1988
1989         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1990                 fOffHook |= 2;
1991
1992         if (j->port == PORT_SPEAKER) {
1993                 if(j->cardtype == QTI_PHONECARD) {
1994                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1995                                 fOffHook |= 2;
1996                         }
1997                 } else {
1998                         fOffHook |= 2;
1999                 }
2000         }
2001
2002         if (j->port == PORT_HANDSET)
2003                 fOffHook |= 2;
2004
2005         return fOffHook;
2006 }
2007
2008 static void ixj_ring_off(IXJ *j)
2009 {
2010         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2011          {
2012                 if (ixjdebug & 0x0004)
2013                         printk(KERN_INFO "IXJ Ring Off\n");
2014                 j->gpio.bytes.high = 0x0B;
2015                 j->gpio.bytes.low = 0x00;
2016                 j->gpio.bits.gpio1 = 0;
2017                 j->gpio.bits.gpio2 = 1;
2018                 j->gpio.bits.gpio5 = 0;
2019                 ixj_WriteDSPCommand(j->gpio.word, j);
2020         } else                  /* Internet LineJACK */
2021         {
2022                 if (ixjdebug & 0x0004)
2023                         printk(KERN_INFO "IXJ Ring Off\n");
2024
2025                 if(!j->flags.cidplay)
2026                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2027
2028                 SLIC_GetState(j);
2029         }
2030 }
2031
2032 static void ixj_ring_start(IXJ *j)
2033 {
2034         j->flags.cringing = 1;
2035         if (ixjdebug & 0x0004)
2036                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2037         if (ixj_hookstate(j) & 1) {
2038                 if (j->port == PORT_POTS)
2039                         ixj_ring_off(j);
2040                 j->flags.cringing = 0;
2041                 if (ixjdebug & 0x0004)
2042                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2043         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2044                 j->ring_cadence_jif = jiffies;
2045                 j->flags.cidsent = j->flags.cidring = 0;
2046                 j->cadence_f[5].state = 0;
2047                 if(j->cadence_f[5].on1)
2048                         ixj_ring_on(j);
2049         } else {
2050                 j->ring_cadence_jif = jiffies;
2051                 j->ring_cadence_t = 15;
2052                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2053                         ixj_ring_on(j);
2054                 } else {
2055                         ixj_ring_off(j);
2056                 }
2057                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2058         }
2059 }
2060
2061 static int ixj_ring(IXJ *j)
2062 {
2063         char cntr;
2064         unsigned long jif;
2065
2066         j->flags.ringing = 1;
2067         if (ixj_hookstate(j) & 1) {
2068                 ixj_ring_off(j);
2069                 j->flags.ringing = 0;
2070                 return 1;
2071         }
2072         for (cntr = 0; cntr < j->maxrings; cntr++) {
2073                 jif = jiffies + (1 * hertz);
2074                 ixj_ring_on(j);
2075                 while (time_before(jiffies, jif)) {
2076                         if (ixj_hookstate(j) & 1) {
2077                                 ixj_ring_off(j);
2078                                 j->flags.ringing = 0;
2079                                 return 1;
2080                         }
2081                         schedule_timeout_interruptible(1);
2082                         if (signal_pending(current))
2083                                 break;
2084                 }
2085                 jif = jiffies + (3 * hertz);
2086                 ixj_ring_off(j);
2087                 while (time_before(jiffies, jif)) {
2088                         if (ixj_hookstate(j) & 1) {
2089                                 msleep(10);
2090                                 if (ixj_hookstate(j) & 1) {
2091                                         j->flags.ringing = 0;
2092                                         return 1;
2093                                 }
2094                         }
2095                         schedule_timeout_interruptible(1);
2096                         if (signal_pending(current))
2097                                 break;
2098                 }
2099         }
2100         ixj_ring_off(j);
2101         j->flags.ringing = 0;
2102         return 0;
2103 }
2104
2105 static int ixj_open(struct phone_device *p, struct file *file_p)
2106 {
2107         IXJ *j = get_ixj(p->board);
2108         file_p->private_data = j;
2109
2110         if (!j->DSPbase)
2111                 return -ENODEV;
2112
2113         if (file_p->f_mode & FMODE_READ) {
2114                 if(!j->readers) {
2115                         j->readers++;
2116                 } else {
2117                         return -EBUSY;
2118                 }
2119         }
2120
2121         if (file_p->f_mode & FMODE_WRITE) {
2122                 if(!j->writers) {
2123                         j->writers++;
2124                 } else {
2125                         if (file_p->f_mode & FMODE_READ){
2126                                 j->readers--;
2127                         }
2128                         return -EBUSY;
2129                 }
2130         }
2131
2132         if (j->cardtype == QTI_PHONECARD) {
2133                 j->pslic.bits.powerdown = 0;
2134                 j->psccr.bits.dev = 3;
2135                 j->psccr.bits.rw = 0;
2136                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2137                 ixj_PCcontrol_wait(j);
2138         }
2139
2140         j->flags.cidplay = 0;
2141         j->flags.cidcw_ack = 0;
2142
2143         if (ixjdebug & 0x0002)
2144                 printk(KERN_INFO "Opening board %d\n", p->board);
2145
2146         j->framesread = j->frameswritten = 0;
2147         return 0;
2148 }
2149
2150 static int ixj_release(struct inode *inode, struct file *file_p)
2151 {
2152         IXJ_TONE ti;
2153         int cnt;
2154         IXJ *j = file_p->private_data;
2155         int board = j->p.board;
2156
2157         /*
2158          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2159          *    This is necessary to keep the DSP from locking up.
2160          */
2161         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2162                 schedule_timeout_interruptible(1);
2163         if (ixjdebug & 0x0002)
2164                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2165
2166         if (j->cardtype == QTI_PHONECARD)
2167                 ixj_set_port(j, PORT_SPEAKER);
2168         else
2169                 ixj_set_port(j, PORT_POTS);
2170
2171         aec_stop(j);
2172         ixj_play_stop(j);
2173         ixj_record_stop(j);
2174         set_play_volume(j, 0x100);
2175         set_rec_volume(j, 0x100);
2176         ixj_ring_off(j);
2177
2178         /* Restore the tone table to default settings. */
2179         ti.tone_index = 10;
2180         ti.gain0 = 1;
2181         ti.freq0 = hz941;
2182         ti.gain1 = 0;
2183         ti.freq1 = hz1209;
2184         ixj_init_tone(j, &ti);
2185         ti.tone_index = 11;
2186         ti.gain0 = 1;
2187         ti.freq0 = hz941;
2188         ti.gain1 = 0;
2189         ti.freq1 = hz1336;
2190         ixj_init_tone(j, &ti);
2191         ti.tone_index = 12;
2192         ti.gain0 = 1;
2193         ti.freq0 = hz941;
2194         ti.gain1 = 0;
2195         ti.freq1 = hz1477;
2196         ixj_init_tone(j, &ti);
2197         ti.tone_index = 13;
2198         ti.gain0 = 1;
2199         ti.freq0 = hz800;
2200         ti.gain1 = 0;
2201         ti.freq1 = 0;
2202         ixj_init_tone(j, &ti);
2203         ti.tone_index = 14;
2204         ti.gain0 = 1;
2205         ti.freq0 = hz1000;
2206         ti.gain1 = 0;
2207         ti.freq1 = 0;
2208         ixj_init_tone(j, &ti);
2209         ti.tone_index = 15;
2210         ti.gain0 = 1;
2211         ti.freq0 = hz1250;
2212         ti.gain1 = 0;
2213         ti.freq1 = 0;
2214         ixj_init_tone(j, &ti);
2215         ti.tone_index = 16;
2216         ti.gain0 = 1;
2217         ti.freq0 = hz950;
2218         ti.gain1 = 0;
2219         ti.freq1 = 0;
2220         ixj_init_tone(j, &ti);
2221         ti.tone_index = 17;
2222         ti.gain0 = 1;
2223         ti.freq0 = hz1100;
2224         ti.gain1 = 0;
2225         ti.freq1 = 0;
2226         ixj_init_tone(j, &ti);
2227         ti.tone_index = 18;
2228         ti.gain0 = 1;
2229         ti.freq0 = hz1400;
2230         ti.gain1 = 0;
2231         ti.freq1 = 0;
2232         ixj_init_tone(j, &ti);
2233         ti.tone_index = 19;
2234         ti.gain0 = 1;
2235         ti.freq0 = hz1500;
2236         ti.gain1 = 0;
2237         ti.freq1 = 0;
2238         ixj_init_tone(j, &ti);
2239         ti.tone_index = 20;
2240         ti.gain0 = 1;
2241         ti.freq0 = hz1600;
2242         ti.gain1 = 0;
2243         ti.freq1 = 0;
2244         ixj_init_tone(j, &ti);
2245         ti.tone_index = 21;
2246         ti.gain0 = 1;
2247         ti.freq0 = hz1800;
2248         ti.gain1 = 0;
2249         ti.freq1 = 0;
2250         ixj_init_tone(j, &ti);
2251         ti.tone_index = 22;
2252         ti.gain0 = 1;
2253         ti.freq0 = hz2100;
2254         ti.gain1 = 0;
2255         ti.freq1 = 0;
2256         ixj_init_tone(j, &ti);
2257         ti.tone_index = 23;
2258         ti.gain0 = 1;
2259         ti.freq0 = hz1300;
2260         ti.gain1 = 0;
2261         ti.freq1 = 0;
2262         ixj_init_tone(j, &ti);
2263         ti.tone_index = 24;
2264         ti.gain0 = 1;
2265         ti.freq0 = hz2450;
2266         ti.gain1 = 0;
2267         ti.freq1 = 0;
2268         ixj_init_tone(j, &ti);
2269         ti.tone_index = 25;
2270         ti.gain0 = 1;
2271         ti.freq0 = hz350;
2272         ti.gain1 = 0;
2273         ti.freq1 = hz440;
2274         ixj_init_tone(j, &ti);
2275         ti.tone_index = 26;
2276         ti.gain0 = 1;
2277         ti.freq0 = hz440;
2278         ti.gain1 = 0;
2279         ti.freq1 = hz480;
2280         ixj_init_tone(j, &ti);
2281         ti.tone_index = 27;
2282         ti.gain0 = 1;
2283         ti.freq0 = hz480;
2284         ti.gain1 = 0;
2285         ti.freq1 = hz620;
2286         ixj_init_tone(j, &ti);
2287
2288         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2289
2290         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2291
2292         j->ex.bits.dtmf_ready = 0;
2293         j->dtmf_state = 0;
2294         j->dtmf_wp = j->dtmf_rp = 0;
2295         j->rec_mode = j->play_mode = -1;
2296         j->flags.ringing = 0;
2297         j->maxrings = MAXRINGS;
2298         j->ring_cadence = USA_RING_CADENCE;
2299         if(j->cadence_f[5].enable) {
2300                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2301         }
2302         j->drybuffer = 0;
2303         j->winktime = 320;
2304         j->flags.dtmf_oob = 0;
2305         for (cnt = 0; cnt < 4; cnt++)
2306                 j->cadence_f[cnt].enable = 0;
2307
2308         idle(j);
2309
2310         if(j->cardtype == QTI_PHONECARD) {
2311                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2312         }
2313
2314         if (file_p->f_mode & FMODE_READ)
2315                 j->readers--;
2316         if (file_p->f_mode & FMODE_WRITE)
2317                 j->writers--;
2318
2319         if (j->read_buffer && !j->readers) {
2320                 kfree(j->read_buffer);
2321                 j->read_buffer = NULL;
2322                 j->read_buffer_size = 0;
2323         }
2324         if (j->write_buffer && !j->writers) {
2325                 kfree(j->write_buffer);
2326                 j->write_buffer = NULL;
2327                 j->write_buffer_size = 0;
2328         }
2329         j->rec_codec = j->play_codec = 0;
2330         j->rec_frame_size = j->play_frame_size = 0;
2331         j->flags.cidsent = j->flags.cidring = 0;
2332
2333         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2334                 ixj_set_port(j, PORT_PSTN);
2335                 daa_set_mode(j, SOP_PU_SLEEP);
2336                 ixj_set_pots(j, 1);
2337         }
2338         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2339
2340         /* Set up the default signals for events */
2341         for (cnt = 0; cnt < 35; cnt++)
2342                 j->ixj_signals[cnt] = SIGIO;
2343
2344         /* Set the excetion signal enable flags */
2345         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2346         j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2347         j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2348
2349         file_p->private_data = NULL;
2350         clear_bit(board, &j->busyflags);
2351         return 0;
2352 }
2353
2354 static int read_filters(IXJ *j)
2355 {
2356         unsigned short fc, cnt, trg;
2357         int var;
2358
2359         trg = 0;
2360         if (ixj_WriteDSPCommand(0x5144, j)) {
2361                 if(ixjdebug & 0x0001) {
2362                         printk(KERN_INFO "Read Frame Counter failed!\n");
2363                 }
2364                 return -1;
2365         }
2366         fc = j->ssr.high << 8 | j->ssr.low;
2367         if (fc == j->frame_count)
2368                 return 1;
2369
2370         j->frame_count = fc;
2371
2372         if (j->dtmf_proc)
2373                 return 1;
2374
2375         var = 10;
2376
2377         for (cnt = 0; cnt < 4; cnt++) {
2378                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2379                         if(ixjdebug & 0x0001) {
2380                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2381                         }
2382                         return -1;
2383                 }
2384                 if (ixj_WriteDSPCommand(0x515C, j)) {
2385                         if(ixjdebug & 0x0001) {
2386                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2387                         }
2388                         return -1;
2389                 }
2390                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2391
2392                 if (j->cadence_f[cnt].enable) {
2393                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2394                                 if (j->cadence_f[cnt].state == 0) {
2395                                         j->cadence_f[cnt].state = 1;
2396                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2397                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2398                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2399                                 } else if (j->cadence_f[cnt].state == 2 &&
2400                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2401                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2402                                         if (j->cadence_f[cnt].on2) {
2403                                                 j->cadence_f[cnt].state = 3;
2404                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2405                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2406                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2407                                         } else {
2408                                                 j->cadence_f[cnt].state = 7;
2409                                         }
2410                                 } else if (j->cadence_f[cnt].state == 4 &&
2411                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2412                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2413                                         if (j->cadence_f[cnt].on3) {
2414                                                 j->cadence_f[cnt].state = 5;
2415                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2416                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2417                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2418                                         } else {
2419                                                 j->cadence_f[cnt].state = 7;
2420                                         }
2421                                 } else {
2422                                         j->cadence_f[cnt].state = 0;
2423                                 }
2424                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2425                                 if (j->cadence_f[cnt].state == 1) {
2426                                         if(!j->cadence_f[cnt].on1) {
2427                                                 j->cadence_f[cnt].state = 7;
2428                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2429                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2430                                                 if(j->cadence_f[cnt].off1) {
2431                                                         j->cadence_f[cnt].state = 2;
2432                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2433                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2434                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2435                                                 } else {
2436                                                         j->cadence_f[cnt].state = 7;
2437                                                 }
2438                                         } else {
2439                                                 j->cadence_f[cnt].state = 0;
2440                                         }
2441                                 } else if (j->cadence_f[cnt].state == 3) {
2442                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2443                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2444                                                 if(j->cadence_f[cnt].off2) {
2445                                                         j->cadence_f[cnt].state = 4;
2446                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2447                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2448                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2449                                                 } else {
2450                                                         j->cadence_f[cnt].state = 7;
2451                                                 }
2452                                         } else {
2453                                                 j->cadence_f[cnt].state = 0;
2454                                         }
2455                                 } else if (j->cadence_f[cnt].state == 5) {
2456                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2457                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2458                                                 if(j->cadence_f[cnt].off3) {
2459                                                         j->cadence_f[cnt].state = 6;
2460                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2461                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2462                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2463                                                 } else {
2464                                                         j->cadence_f[cnt].state = 7;
2465                                                 }
2466                                         } else {
2467                                                 j->cadence_f[cnt].state = 0;
2468                                         }
2469                                 } else {
2470                                         j->cadence_f[cnt].state = 0;
2471                                 }
2472                         } else {
2473                                 switch(j->cadence_f[cnt].state) {
2474                                         case 1:
2475                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2476                                                    !j->cadence_f[cnt].off1 &&
2477                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2478                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2479                                                         j->cadence_f[cnt].state = 7;
2480                                                 }
2481                                                 break;
2482                                         case 3:
2483                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2484                                                    !j->cadence_f[cnt].off2 &&
2485                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2486                                                         j->cadence_f[cnt].state = 7;
2487                                                 }
2488                                                 break;
2489                                         case 5:
2490                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2491                                                    !j->cadence_f[cnt].off3) {
2492                                                         j->cadence_f[cnt].state = 7;
2493                                                 }
2494                                                 break;
2495                                 }
2496                         }
2497
2498                         if (ixjdebug & 0x0040) {
2499                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2500                                 switch(j->cadence_f[cnt].state) {
2501                                         case 0:
2502                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2503                                                 break;
2504                                         case 1:
2505                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2506                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2507                                                 break;
2508                                         case 2:
2509                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2510                                                                                                                         j->cadence_f[cnt].off1max);
2511                                                 break;
2512                                         case 3:
2513                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2514                                                                                                                         j->cadence_f[cnt].on2max);
2515                                                 break;
2516                                         case 4:
2517                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2518                                                                                                                         j->cadence_f[cnt].off2max);
2519                                                 break;
2520                                         case 5:
2521                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2522                                                                                                                         j->cadence_f[cnt].on3max);
2523                                                 break;
2524                                         case 6:
2525                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2526                                                                                                                         j->cadence_f[cnt].off3max);
2527                                                 break;
2528                                 }
2529                         }
2530                 }
2531                 if (j->cadence_f[cnt].state == 7) {
2532                         j->cadence_f[cnt].state = 0;
2533                         if (j->cadence_f[cnt].enable == 1)
2534                                 j->cadence_f[cnt].enable = 0;
2535                         switch (cnt) {
2536                         case 0:
2537                                 if(ixjdebug & 0x0020) {
2538                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2539                                 }
2540                                 j->ex.bits.fc0 = 1;
2541                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2542                                 break;
2543                         case 1:
2544                                 if(ixjdebug & 0x0020) {
2545                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2546                                 }
2547                                 j->ex.bits.fc1 = 1;
2548                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2549                                 break;
2550                         case 2:
2551                                 if(ixjdebug & 0x0020) {
2552                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2553                                 }
2554                                 j->ex.bits.fc2 = 1;
2555                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2556                                 break;
2557                         case 3:
2558                                 if(ixjdebug & 0x0020) {
2559                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2560                                 }
2561                                 j->ex.bits.fc3 = 1;
2562                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2563                                 break;
2564                         }
2565                 }
2566                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2567                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2568                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2569                                 trg = 1;
2570                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2571                                 trg = 0;
2572                         }
2573                         switch (cnt) {
2574                         case 0:
2575                                 if(ixjdebug & 0x0020) {
2576                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2577                                 }
2578                                 j->ex.bits.f0 = 1;
2579                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2580                                 break;
2581                         case 1:
2582                                 if(ixjdebug & 0x0020) {
2583                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2584                                 }
2585                                 j->ex.bits.f1 = 1;
2586                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2587                                 break;
2588                         case 2:
2589                                 if(ixjdebug & 0x0020) {
2590                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2591                                 }
2592                                 j->ex.bits.f2 = 1;
2593                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2594                                 break;
2595                         case 3:
2596                                 if(ixjdebug & 0x0020) {
2597                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2598                                 }
2599                                 j->ex.bits.f3 = 1;
2600                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2601                                 break;
2602                         }
2603                 }
2604         }
2605         return 0;
2606 }
2607
2608 static int LineMonitor(IXJ *j)
2609 {
2610         if (j->dtmf_proc) {
2611                 return -1;
2612         }
2613         j->dtmf_proc = 1;
2614
2615         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2616                 return -1;
2617
2618         j->dtmf.bytes.high = j->ssr.high;
2619         j->dtmf.bytes.low = j->ssr.low;
2620         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2621                 j->dtmf_state = 1;
2622                 j->dtmf_current = j->dtmf.bits.digit;
2623         }
2624         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2625          {
2626                 if(!j->cidcw_wait) {
2627                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2628                         j->dtmf_wp++;
2629                         if (j->dtmf_wp == 79)
2630                                 j->dtmf_wp = 0;
2631                         j->ex.bits.dtmf_ready = 1;
2632                         if(j->ex_sig.bits.dtmf_ready) {
2633                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2634                         }
2635                 }
2636                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2637                         if(ixjdebug & 0x0020) {
2638                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2639                         }
2640                         j->flags.cidcw_ack = 1;
2641                 }
2642                 j->dtmf_state = 0;
2643         }
2644         j->dtmf_proc = 0;
2645
2646         return 0;
2647 }
2648
2649 /************************************************************************
2650 *
2651 * Functions to allow alaw <-> ulaw conversions.
2652 *
2653 ************************************************************************/
2654
2655 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2656 {
2657         static unsigned char table_ulaw2alaw[] =
2658         {
2659                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2660                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2661                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2662                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2663                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2664                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2665                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2666                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2667                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2668                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2669                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2670                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2671                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2672                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2673                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2674                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2675                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2676                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2677                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2678                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2679                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2680                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2681                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2682                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2683                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2684                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2685                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2686                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2687                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2688                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2689                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2690                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2691         };
2692
2693         while (len--)
2694         {
2695                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2696                 buff++;
2697         }
2698 }
2699
2700 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2701 {
2702         static unsigned char table_alaw2ulaw[] =
2703         {
2704                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2705                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2706                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2707                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2708                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2709                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2710                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2711                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2712                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2713                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2714                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2715                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2716                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2717                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2718                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2719                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2720                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2721                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2722                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2723                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2724                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2725                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2726                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2727                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2728                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2729                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2730                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2731                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2732                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2733                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2734                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2735                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2736         };
2737
2738         while (len--)
2739         {
2740                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2741                 buff++;
2742         }
2743 }
2744
2745 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2746 {
2747         unsigned long i = *ppos;
2748         IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2749
2750         DECLARE_WAITQUEUE(wait, current);
2751
2752         if (j->flags.inread)
2753                 return -EALREADY;
2754
2755         j->flags.inread = 1;
2756
2757         add_wait_queue(&j->read_q, &wait);
2758         set_current_state(TASK_INTERRUPTIBLE);
2759         mb();
2760
2761         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2762                 ++j->read_wait;
2763                 if (file_p->f_flags & O_NONBLOCK) {
2764                         set_current_state(TASK_RUNNING);
2765                         remove_wait_queue(&j->read_q, &wait);
2766                         j->flags.inread = 0;
2767                         return -EAGAIN;
2768                 }
2769                 if (!ixj_hookstate(j)) {
2770                         set_current_state(TASK_RUNNING);
2771                         remove_wait_queue(&j->read_q, &wait);
2772                         j->flags.inread = 0;
2773                         return 0;
2774                 }
2775                 interruptible_sleep_on(&j->read_q);
2776                 if (signal_pending(current)) {
2777                         set_current_state(TASK_RUNNING);
2778                         remove_wait_queue(&j->read_q, &wait);
2779                         j->flags.inread = 0;
2780                         return -EINTR;
2781                 }
2782         }
2783
2784         remove_wait_queue(&j->read_q, &wait);
2785         set_current_state(TASK_RUNNING);
2786         /* Don't ever copy more than the user asks */
2787         if(j->rec_codec == ALAW)
2788                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2789         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2790         j->read_buffer_ready = 0;
2791         if (i) {
2792                 j->flags.inread = 0;
2793                 return -EFAULT;
2794         } else {
2795                 j->flags.inread = 0;
2796                 return min(length, j->read_buffer_size);
2797         }
2798 }
2799
2800 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2801                           loff_t * ppos)
2802 {
2803         int pre_retval;
2804         ssize_t read_retval = 0;
2805         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2806
2807         pre_retval = ixj_PreRead(j, 0L);
2808         switch (pre_retval) {
2809         case NORMAL:
2810                 read_retval = ixj_read(file_p, buf, length, ppos);
2811                 ixj_PostRead(j, 0L);
2812                 break;
2813         case NOPOST:
2814                 read_retval = ixj_read(file_p, buf, length, ppos);
2815                 break;
2816         case POSTONLY:
2817                 ixj_PostRead(j, 0L);
2818                 break;
2819         default:
2820                 read_retval = pre_retval;
2821         }
2822         return read_retval;
2823 }
2824
2825 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2826 {
2827         unsigned long i = *ppos;
2828         IXJ *j = file_p->private_data;
2829
2830         DECLARE_WAITQUEUE(wait, current);
2831
2832         if (j->flags.inwrite)
2833                 return -EALREADY;
2834
2835         j->flags.inwrite = 1;
2836
2837         add_wait_queue(&j->write_q, &wait);
2838         set_current_state(TASK_INTERRUPTIBLE);
2839         mb();
2840
2841
2842         while (!j->write_buffers_empty) {
2843                 ++j->write_wait;
2844                 if (file_p->f_flags & O_NONBLOCK) {
2845                         set_current_state(TASK_RUNNING);
2846                         remove_wait_queue(&j->write_q, &wait);
2847                         j->flags.inwrite = 0;
2848                         return -EAGAIN;
2849                 }
2850                 if (!ixj_hookstate(j)) {
2851                         set_current_state(TASK_RUNNING);
2852                         remove_wait_queue(&j->write_q, &wait);
2853                         j->flags.inwrite = 0;
2854                         return 0;
2855                 }
2856                 interruptible_sleep_on(&j->write_q);
2857                 if (signal_pending(current)) {
2858                         set_current_state(TASK_RUNNING);
2859                         remove_wait_queue(&j->write_q, &wait);
2860                         j->flags.inwrite = 0;
2861                         return -EINTR;
2862                 }
2863         }
2864         set_current_state(TASK_RUNNING);
2865         remove_wait_queue(&j->write_q, &wait);
2866         if (j->write_buffer_wp + count >= j->write_buffer_end)
2867                 j->write_buffer_wp = j->write_buffer;
2868         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2869         if (i) {
2870                 j->flags.inwrite = 0;
2871                 return -EFAULT;
2872         }
2873        if(j->play_codec == ALAW)
2874                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2875         j->flags.inwrite = 0;
2876         return min(count, j->write_buffer_size);
2877 }
2878
2879 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2880 {
2881         int pre_retval;
2882         ssize_t write_retval = 0;
2883
2884         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2885
2886         pre_retval = ixj_PreWrite(j, 0L);
2887         switch (pre_retval) {
2888         case NORMAL:
2889                 write_retval = ixj_write(file_p, buf, count, ppos);
2890                 if (write_retval > 0) {
2891                         ixj_PostWrite(j, 0L);
2892                         j->write_buffer_wp += write_retval;
2893                         j->write_buffers_empty--;
2894                 }
2895                 break;
2896         case NOPOST:
2897                 write_retval = ixj_write(file_p, buf, count, ppos);
2898                 if (write_retval > 0) {
2899                         j->write_buffer_wp += write_retval;
2900                         j->write_buffers_empty--;
2901                 }
2902                 break;
2903         case POSTONLY:
2904                 ixj_PostWrite(j, 0L);
2905                 break;
2906         default:
2907                 write_retval = pre_retval;
2908         }
2909         return write_retval;
2910 }
2911
2912 static void ixj_read_frame(IXJ *j)
2913 {
2914         int cnt, dly;
2915
2916         if (j->read_buffer) {
2917                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2918                         if (!(cnt % 16) && !IsRxReady(j)) {
2919                                 dly = 0;
2920                                 while (!IsRxReady(j)) {
2921                                         if (dly++ > 5) {
2922                                                 dly = 0;
2923                                                 break;
2924                                         }
2925                                         udelay(10);
2926                                 }
2927                         }
2928                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2929                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2930                                 inb_p(j->DSPbase + 0x0E);
2931                                 inb_p(j->DSPbase + 0x0F);
2932                         }
2933                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2934                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2935                 }
2936                 ++j->framesread;
2937                 if (j->intercom != -1) {
2938                         if (IsTxReady(get_ixj(j->intercom))) {
2939                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2940                                         if (!(cnt % 16) && !IsTxReady(j)) {
2941                                                 dly = 0;
2942                                                 while (!IsTxReady(j)) {
2943                                                         if (dly++ > 5) {
2944                                                                 dly = 0;
2945                                                                 break;
2946                                                         }
2947                                                         udelay(10);
2948                                                 }
2949                                         }
2950                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2951                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2952                                 }
2953                                 get_ixj(j->intercom)->frameswritten++;
2954                         }
2955                 } else {
2956                         j->read_buffer_ready = 1;
2957                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2958
2959                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2960
2961                         if(j->ixj_signals[SIG_READ_READY])
2962                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2963                 }
2964         }
2965 }
2966
2967 static short fsk[][6][20] =
2968 {
2969         {
2970                 {
2971                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2972                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2973                 },
2974                 {
2975                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2976                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2977                 },
2978                 {
2979                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2980                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2981                 },
2982                 {
2983                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2984                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2985                 },
2986                 {
2987                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2988                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2989                 },
2990                 {
2991                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2992                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2993                 }
2994         },
2995         {
2996                 {
2997                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2998                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2999                 },
3000                 {
3001                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3002                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3003                 },
3004                 {
3005                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3006                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3007                 },
3008                 {
3009                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3010                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3011                 },
3012                 {
3013                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3014                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3015                 },
3016                 {
3017                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3018                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3019                 }
3020         }
3021 };
3022
3023
3024 static void ixj_write_cid_bit(IXJ *j, int bit)
3025 {
3026         while (j->fskcnt < 20) {
3027                 if(j->fskdcnt < (j->fsksize - 1))
3028                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3029
3030                 j->fskcnt += 3;
3031         }
3032         j->fskcnt %= 20;
3033
3034         if (!bit)
3035                 j->fskz++;
3036         if (j->fskz >= 6)
3037                 j->fskz = 0;
3038
3039 }
3040
3041 static void ixj_write_cid_byte(IXJ *j, char byte)
3042 {
3043         IXJ_CBYTE cb;
3044
3045                 cb.cbyte = byte;
3046                 ixj_write_cid_bit(j, 0);
3047                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3048                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3053                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3054                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3055                 ixj_write_cid_bit(j, 1);
3056 }
3057
3058 static void ixj_write_cid_seize(IXJ *j)
3059 {
3060         int cnt;
3061
3062         for (cnt = 0; cnt < 150; cnt++) {
3063                 ixj_write_cid_bit(j, 0);
3064                 ixj_write_cid_bit(j, 1);
3065         }
3066         for (cnt = 0; cnt < 180; cnt++) {
3067                 ixj_write_cid_bit(j, 1);
3068         }
3069 }
3070
3071 static void ixj_write_cidcw_seize(IXJ *j)
3072 {
3073         int cnt;
3074
3075         for (cnt = 0; cnt < 80; cnt++) {
3076                 ixj_write_cid_bit(j, 1);
3077         }
3078 }
3079
3080 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3081 {
3082         int cnt;
3083
3084         for (cnt = 0; cnt < strlen(s); cnt++) {
3085                 ixj_write_cid_byte(j, s[cnt]);
3086                 checksum = (checksum + s[cnt]);
3087         }
3088         return checksum;
3089 }
3090
3091 static void ixj_pad_fsk(IXJ *j, int pad)
3092 {
3093         int cnt;
3094
3095         for (cnt = 0; cnt < pad; cnt++) {
3096                 if(j->fskdcnt < (j->fsksize - 1))
3097                         j->fskdata[j->fskdcnt++] = 0x0000;
3098         }
3099         for (cnt = 0; cnt < 720; cnt++) {
3100                 if(j->fskdcnt < (j->fsksize - 1))
3101                         j->fskdata[j->fskdcnt++] = 0x0000;
3102         }
3103 }
3104
3105 static void ixj_pre_cid(IXJ *j)
3106 {
3107         j->cid_play_codec = j->play_codec;
3108         j->cid_play_frame_size = j->play_frame_size;
3109         j->cid_play_volume = get_play_volume(j);
3110         j->cid_play_flag = j->flags.playing;
3111
3112         j->cid_rec_codec = j->rec_codec;
3113         j->cid_rec_volume = get_rec_volume(j);
3114         j->cid_rec_flag = j->flags.recording;
3115
3116         j->cid_play_aec_level = j->aec_level;
3117
3118         switch(j->baseframe.low) {
3119                 case 0xA0:
3120                         j->cid_base_frame_size = 20;
3121                         break;
3122                 case 0x50:
3123                         j->cid_base_frame_size = 10;
3124                         break;
3125                 case 0xF0:
3126                         j->cid_base_frame_size = 30;
3127                         break;
3128         }
3129
3130         ixj_play_stop(j);
3131         ixj_cpt_stop(j);
3132
3133         j->flags.cidplay = 1;
3134
3135         set_base_frame(j, 30);
3136         set_play_codec(j, LINEAR16);
3137         set_play_volume(j, 0x1B);
3138         ixj_play_start(j);
3139 }
3140
3141 static void ixj_post_cid(IXJ *j)
3142 {
3143         ixj_play_stop(j);
3144
3145         if(j->cidsize > 5000) {
3146                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3147         }
3148         j->flags.cidplay = 0;
3149         if(ixjdebug & 0x0200) {
3150                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3151         }
3152
3153         ixj_fsk_free(j);
3154
3155         j->fskdcnt = 0;
3156         set_base_frame(j, j->cid_base_frame_size);
3157         set_play_codec(j, j->cid_play_codec);
3158         ixj_aec_start(j, j->cid_play_aec_level);
3159         set_play_volume(j, j->cid_play_volume);
3160
3161         set_rec_codec(j, j->cid_rec_codec);
3162         set_rec_volume(j, j->cid_rec_volume);
3163
3164         if(j->cid_rec_flag)
3165                 ixj_record_start(j);
3166
3167         if(j->cid_play_flag)
3168                 ixj_play_start(j);
3169
3170         if(j->cid_play_flag) {
3171                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3172         }
3173 }
3174
3175 static void ixj_write_cid(IXJ *j)
3176 {
3177         char sdmf1[50];
3178         char sdmf2[50];
3179         char sdmf3[80];
3180         char mdmflen, len1, len2, len3;
3181         int pad;
3182
3183         int checksum = 0;
3184
3185         if (j->dsp.low == 0x20 || j->flags.cidplay)
3186                 return;
3187
3188         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3189         j->cidsize = j->cidcnt = 0;
3190
3191         ixj_fsk_alloc(j);
3192
3193         strcpy(sdmf1, j->cid_send.month);
3194         strcat(sdmf1, j->cid_send.day);
3195         strcat(sdmf1, j->cid_send.hour);
3196         strcat(sdmf1, j->cid_send.min);
3197         strcpy(sdmf2, j->cid_send.number);
3198         strcpy(sdmf3, j->cid_send.name);
3199
3200         len1 = strlen(sdmf1);
3201         len2 = strlen(sdmf2);
3202         len3 = strlen(sdmf3);
3203         mdmflen = len1 + len2 + len3 + 6;
3204
3205         while(1){
3206                 ixj_write_cid_seize(j);
3207
3208                 ixj_write_cid_byte(j, 0x80);
3209                 checksum = 0x80;
3210                 ixj_write_cid_byte(j, mdmflen);
3211                 checksum = checksum + mdmflen;
3212
3213                 ixj_write_cid_byte(j, 0x01);
3214                 checksum = checksum + 0x01;
3215                 ixj_write_cid_byte(j, len1);
3216                 checksum = checksum + len1;
3217                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3218                 if(ixj_hookstate(j) & 1)
3219                         break;
3220
3221                 ixj_write_cid_byte(j, 0x02);
3222                 checksum = checksum + 0x02;
3223                 ixj_write_cid_byte(j, len2);
3224                 checksum = checksum + len2;
3225                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3226                 if(ixj_hookstate(j) & 1)
3227                         break;
3228
3229                 ixj_write_cid_byte(j, 0x07);
3230                 checksum = checksum + 0x07;
3231                 ixj_write_cid_byte(j, len3);
3232                 checksum = checksum + len3;
3233                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3234                 if(ixj_hookstate(j) & 1)
3235                         break;
3236
3237                 checksum %= 256;
3238                 checksum ^= 0xFF;
3239                 checksum += 1;
3240
3241                 ixj_write_cid_byte(j, (char) checksum);
3242
3243                 pad = j->fskdcnt % 240;
3244                 if (pad) {
3245                         pad = 240 - pad;
3246                 }
3247                 ixj_pad_fsk(j, pad);
3248                 break;
3249         }
3250
3251         ixj_write_frame(j);
3252 }
3253
3254 static void ixj_write_cidcw(IXJ *j)
3255 {
3256         IXJ_TONE ti;
3257
3258         char sdmf1[50];
3259         char sdmf2[50];
3260         char sdmf3[80];
3261         char mdmflen, len1, len2, len3;
3262         int pad;
3263
3264         int checksum = 0;
3265
3266         if (j->dsp.low == 0x20 || j->flags.cidplay)
3267                 return;
3268
3269         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3270         j->cidsize = j->cidcnt = 0;
3271
3272         ixj_fsk_alloc(j);
3273
3274         j->flags.cidcw_ack = 0;
3275
3276         ti.tone_index = 23;
3277         ti.gain0 = 1;
3278         ti.freq0 = hz440;
3279         ti.gain1 = 0;
3280         ti.freq1 = 0;
3281         ixj_init_tone(j, &ti);
3282
3283         ixj_set_tone_on(1500, j);
3284         ixj_set_tone_off(32, j);
3285         if(ixjdebug & 0x0200) {
3286                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3287         }
3288         ixj_play_tone(j, 23);
3289
3290         clear_bit(j->board, &j->busyflags);
3291         while(j->tone_state)
3292                 schedule_timeout_interruptible(1);
3293         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3294                 schedule_timeout_interruptible(1);
3295         if(ixjdebug & 0x0200) {
3296                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3297         }
3298
3299         ti.tone_index = 24;
3300         ti.gain0 = 1;
3301         ti.freq0 = hz2130;
3302         ti.gain1 = 0;
3303         ti.freq1 = hz2750;
3304         ixj_init_tone(j, &ti);
3305
3306         ixj_set_tone_off(10, j);
3307         ixj_set_tone_on(600, j);
3308         if(ixjdebug & 0x0200) {
3309                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3310         }
3311         ixj_play_tone(j, 24);
3312
3313         clear_bit(j->board, &j->busyflags);
3314         while(j->tone_state)
3315                 schedule_timeout_interruptible(1);
3316         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3317                 schedule_timeout_interruptible(1);
3318         if(ixjdebug & 0x0200) {
3319                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3320         }
3321
3322         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3323
3324         clear_bit(j->board, &j->busyflags);
3325         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3326                 schedule_timeout_interruptible(1);
3327         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3328                 schedule_timeout_interruptible(1);
3329         j->cidcw_wait = 0;
3330         if(!j->flags.cidcw_ack) {
3331                 if(ixjdebug & 0x0200) {
3332                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3333                 }
3334                 ixj_post_cid(j);
3335                 if(j->cid_play_flag) {
3336                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3337                 }
3338                 return;
3339         } else {
3340                 ixj_pre_cid(j);
3341         }
3342         j->flags.cidcw_ack = 0;
3343         strcpy(sdmf1, j->cid_send.month);
3344         strcat(sdmf1, j->cid_send.day);
3345         strcat(sdmf1, j->cid_send.hour);
3346         strcat(sdmf1, j->cid_send.min);
3347         strcpy(sdmf2, j->cid_send.number);
3348         strcpy(sdmf3, j->cid_send.name);
3349
3350         len1 = strlen(sdmf1);
3351         len2 = strlen(sdmf2);
3352         len3 = strlen(sdmf3);
3353         mdmflen = len1 + len2 + len3 + 6;
3354
3355         ixj_write_cidcw_seize(j);
3356
3357         ixj_write_cid_byte(j, 0x80);
3358         checksum = 0x80;
3359         ixj_write_cid_byte(j, mdmflen);
3360         checksum = checksum + mdmflen;
3361
3362         ixj_write_cid_byte(j, 0x01);
3363         checksum = checksum + 0x01;
3364         ixj_write_cid_byte(j, len1);
3365         checksum = checksum + len1;
3366         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3367
3368         ixj_write_cid_byte(j, 0x02);
3369         checksum = checksum + 0x02;
3370         ixj_write_cid_byte(j, len2);
3371         checksum = checksum + len2;
3372         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3373
3374         ixj_write_cid_byte(j, 0x07);
3375         checksum = checksum + 0x07;
3376         ixj_write_cid_byte(j, len3);
3377         checksum = checksum + len3;
3378         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3379
3380         checksum %= 256;
3381         checksum ^= 0xFF;
3382         checksum += 1;
3383
3384         ixj_write_cid_byte(j, (char) checksum);
3385
3386         pad = j->fskdcnt % 240;
3387         if (pad) {
3388                 pad = 240 - pad;
3389         }
3390         ixj_pad_fsk(j, pad);
3391         if(ixjdebug & 0x0200) {
3392                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3393         }
3394 }
3395
3396 static void ixj_write_vmwi(IXJ *j, int msg)
3397 {
3398         char mdmflen;
3399         int pad;
3400
3401         int checksum = 0;
3402
3403         if (j->dsp.low == 0x20 || j->flags.cidplay)
3404                 return;
3405
3406         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3407         j->cidsize = j->cidcnt = 0;
3408
3409         ixj_fsk_alloc(j);
3410
3411         mdmflen = 3;
3412
3413         if (j->port == PORT_POTS)
3414                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3415
3416         ixj_write_cid_seize(j);
3417
3418         ixj_write_cid_byte(j, 0x82);
3419         checksum = 0x82;
3420         ixj_write_cid_byte(j, mdmflen);
3421         checksum = checksum + mdmflen;
3422
3423         ixj_write_cid_byte(j, 0x0B);
3424         checksum = checksum + 0x0B;
3425         ixj_write_cid_byte(j, 1);
3426         checksum = checksum + 1;
3427
3428         if(msg) {
3429                 ixj_write_cid_byte(j, 0xFF);
3430                 checksum = checksum + 0xFF;
3431         }
3432         else {
3433                 ixj_write_cid_byte(j, 0x00);
3434                 checksum = checksum + 0x00;
3435         }
3436
3437         checksum %= 256;
3438         checksum ^= 0xFF;
3439         checksum += 1;
3440
3441         ixj_write_cid_byte(j, (char) checksum);
3442
3443         pad = j->fskdcnt % 240;
3444         if (pad) {
3445                 pad = 240 - pad;
3446         }
3447         ixj_pad_fsk(j, pad);
3448 }
3449
3450 static void ixj_write_frame(IXJ *j)
3451 {
3452         int cnt, frame_count, dly;
3453         IXJ_WORD dat;
3454
3455         frame_count = 0;
3456         if(j->flags.cidplay) {
3457                 for(cnt = 0; cnt < 480; cnt++) {
3458                         if (!(cnt % 16) && !IsTxReady(j)) {
3459                                 dly = 0;
3460                                 while (!IsTxReady(j)) {
3461                                         if (dly++ > 5) {
3462                                                 dly = 0;
3463                                                 break;
3464                                         }
3465                                         udelay(10);
3466                                 }
3467                         }
3468                         dat.word = j->fskdata[j->cidcnt++];
3469                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3470                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3471                         cnt++;
3472                 }
3473                 if(j->cidcnt >= j->fskdcnt) {
3474                         ixj_post_cid(j);
3475                 }
3476                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3477                    and there is real audio data in the buffer, we need to throw it away because
3478                    we just used it's time slot */
3479                 if (j->write_buffer_rp > j->write_buffer_wp) {
3480                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3481                         if (j->write_buffer_rp >= j->write_buffer_end) {
3482                                 j->write_buffer_rp = j->write_buffer;
3483                         }
3484                         j->write_buffers_empty++;
3485                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3486
3487                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3488                 }
3489         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3490                 if (j->write_buffer_wp > j->write_buffer_rp) {
3491                         frame_count =
3492                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3493                 }
3494                 if (j->write_buffer_rp > j->write_buffer_wp) {
3495                         frame_count =
3496                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3497                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3498                 }
3499                 if (frame_count >= 1) {
3500                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3501                                 BYTES blankword;
3502
3503                                 switch (j->play_mode) {
3504                                 case PLAYBACK_MODE_ULAW:
3505                                 case PLAYBACK_MODE_ALAW:
3506                                         blankword.low = blankword.high = 0xFF;
3507                                         break;
3508                                 case PLAYBACK_MODE_8LINEAR:
3509                                 case PLAYBACK_MODE_16LINEAR:
3510                                 default:
3511                                         blankword.low = blankword.high = 0x00;
3512                                         break;
3513                                 case PLAYBACK_MODE_8LINEAR_WSS:
3514                                         blankword.low = blankword.high = 0x80;
3515                                         break;
3516                                 }
3517                                 for (cnt = 0; cnt < 16; cnt++) {
3518                                         if (!(cnt % 16) && !IsTxReady(j)) {
3519                                                 dly = 0;
3520                                                 while (!IsTxReady(j)) {
3521                                                         if (dly++ > 5) {
3522                                                                 dly = 0;
3523                                                                 break;
3524                                                         }
3525                                                         udelay(10);
3526                                                 }
3527                                         }
3528                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3529                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3530                                 }
3531                                 j->flags.play_first_frame = 0;
3532                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533                                 for (cnt = 0; cnt < 24; cnt++) {
3534                                         BYTES blankword;
3535
3536                                         if(cnt == 12) {
3537                                                 blankword.low = 0x02;
3538                                                 blankword.high = 0x00;
3539                                         }
3540                                         else {
3541                                                 blankword.low = blankword.high = 0x00;
3542                                         }
3543                                         if (!(cnt % 16) && !IsTxReady(j)) {
3544                                                 dly = 0;
3545                                                 while (!IsTxReady(j)) {
3546                                                         if (dly++ > 5) {
3547                                                                 dly = 0;
3548                                                                 break;
3549                                                         }
3550                                                         udelay(10);
3551                                                 }
3552                                         }
3553                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3554                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3555                                 }
3556                                 j->flags.play_first_frame = 0;
3557                         }
3558                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3559                                 if (!(cnt % 16) && !IsTxReady(j)) {
3560                                         dly = 0;
3561                                         while (!IsTxReady(j)) {
3562                                                 if (dly++ > 5) {
3563                                                         dly = 0;
3564                                                         break;
3565                                                 }
3566                                                 udelay(10);
3567                                         }
3568                                 }
3569                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3570                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3571                                         if (j->write_buffer_rp[cnt] == 0 &&
3572                                             j->write_buffer_rp[cnt + 1] == 0 &&
3573                                             j->write_buffer_rp[cnt + 2] == 0 &&
3574                                             j->write_buffer_rp[cnt + 3] == 0 &&
3575                                             j->write_buffer_rp[cnt + 4] == 0 &&
3576                                             j->write_buffer_rp[cnt + 5] == 0 &&
3577                                             j->write_buffer_rp[cnt + 6] == 0 &&
3578                                             j->write_buffer_rp[cnt + 7] == 0 &&
3579                                             j->write_buffer_rp[cnt + 8] == 0 &&
3580                                             j->write_buffer_rp[cnt + 9] == 0) {
3581                                         /* someone is trying to write silence lets make this a type 0 frame. */
3582                                                 outb_p(0x00, j->DSPbase + 0x0C);
3583                                                 outb_p(0x00, j->DSPbase + 0x0D);
3584                                         } else {
3585                                         /* so all other frames are type 1. */
3586                                                 outb_p(0x01, j->DSPbase + 0x0C);
3587                                                 outb_p(0x00, j->DSPbase + 0x0D);
3588                                         }
3589                                 }
3590                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3591                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3592                                 *(j->write_buffer_rp + cnt) = 0;
3593                                 *(j->write_buffer_rp + cnt + 1) = 0;
3594                         }
3595                         j->write_buffer_rp += j->play_frame_size * 2;
3596                         if (j->write_buffer_rp >= j->write_buffer_end) {
3597                                 j->write_buffer_rp = j->write_buffer;
3598                         }
3599                         j->write_buffers_empty++;
3600                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3601
3602                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3603
3604                         ++j->frameswritten;
3605                 }
3606         } else {
3607                 j->drybuffer++;
3608         }
3609         if(j->ixj_signals[SIG_WRITE_READY]) {
3610                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3611         }
3612 }
3613
3614 static int idle(IXJ *j)
3615 {
3616         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3617
3618                 return 0;
3619
3620         if (j->ssr.high || j->ssr.low) {
3621                 return 0;
3622         } else {
3623                 j->play_mode = -1;
3624                 j->flags.playing = 0;
3625                 j->rec_mode = -1;
3626                 j->flags.recording = 0;
3627                 return 1;
3628         }
3629 }
3630
3631 static int set_base_frame(IXJ *j, int size)
3632 {
3633         unsigned short cmd;
3634         int cnt;
3635
3636         idle(j);
3637         j->cid_play_aec_level = j->aec_level;
3638         aec_stop(j);
3639         for (cnt = 0; cnt < 10; cnt++) {
3640                 if (idle(j))
3641                         break;
3642         }
3643         if (j->ssr.high || j->ssr.low)
3644                 return -1;
3645         if (j->dsp.low != 0x20) {
3646                 switch (size) {
3647                 case 30:
3648                         cmd = 0x07F0;
3649                         /* Set Base Frame Size to 240 pg9-10 8021 */
3650                         break;
3651                 case 20:
3652                         cmd = 0x07A0;
3653                         /* Set Base Frame Size to 160 pg9-10 8021 */
3654                         break;
3655                 case 10:
3656                         cmd = 0x0750;
3657                         /* Set Base Frame Size to 80 pg9-10 8021 */
3658                         break;
3659                 default:
3660                         return -1;
3661                 }
3662         } else {
3663                 if (size == 30)
3664                         return size;
3665                 else
3666                         return -1;
3667         }
3668         if (ixj_WriteDSPCommand(cmd, j)) {
3669                 j->baseframe.high = j->baseframe.low = 0xFF;
3670                 return -1;
3671         } else {
3672                 j->baseframe.high = j->ssr.high;
3673                 j->baseframe.low = j->ssr.low;
3674                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3675                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3676                         return -1;
3677                 }
3678         }
3679         ixj_aec_start(j, j->cid_play_aec_level);
3680         return size;
3681 }
3682
3683 static int set_rec_codec(IXJ *j, int rate)
3684 {
3685         int retval = 0;
3686
3687         j->rec_codec = rate;
3688
3689         switch (rate) {
3690         case G723_63:
3691                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3692                         j->rec_frame_size = 12;
3693                         j->rec_mode = 0;
3694                 } else {
3695                         retval = 1;
3696                 }
3697                 break;
3698         case G723_53:
3699                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3700                         j->rec_frame_size = 10;
3701                         j->rec_mode = 0;
3702                 } else {
3703                         retval = 1;
3704                 }
3705                 break;
3706         case TS85:
3707                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3708                         j->rec_frame_size = 16;
3709                         j->rec_mode = 0;
3710                 } else {
3711                         retval = 1;
3712                 }
3713                 break;
3714         case TS48:
3715                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3716                         j->rec_frame_size = 9;
3717                         j->rec_mode = 0;
3718                 } else {
3719                         retval = 1;
3720                 }
3721                 break;
3722         case TS41:
3723                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3724                         j->rec_frame_size = 8;
3725                         j->rec_mode = 0;
3726                 } else {
3727                         retval = 1;
3728                 }
3729                 break;
3730         case G728:
3731                 if (j->dsp.low != 0x20) {
3732                         j->rec_frame_size = 48;
3733                         j->rec_mode = 0;
3734                 } else {
3735                         retval = 1;
3736                 }
3737                 break;
3738         case G729:
3739                 if (j->dsp.low != 0x20) {
3740                         if (!j->flags.g729_loaded) {
3741                                 retval = 1;
3742                                 break;
3743                         }
3744                         switch (j->baseframe.low) {
3745                         case 0xA0:
3746                                 j->rec_frame_size = 10;
3747                                 break;
3748                         case 0x50:
3749                                 j->rec_frame_size = 5;
3750                                 break;
3751                         default:
3752                                 j->rec_frame_size = 15;
3753                                 break;
3754                         }
3755                         j->rec_mode = 0;
3756                 } else {
3757                         retval = 1;
3758                 }
3759                 break;
3760         case G729B:
3761                 if (j->dsp.low != 0x20) {
3762                         if (!j->flags.g729_loaded) {
3763                                 retval = 1;
3764                                 break;
3765                         }
3766                         switch (j->baseframe.low) {
3767                         case 0xA0:
3768                                 j->rec_frame_size = 12;
3769                                 break;
3770                         case 0x50:
3771                                 j->rec_frame_size = 6;
3772                                 break;
3773                         default:
3774                                 j->rec_frame_size = 18;
3775                                 break;
3776                         }
3777                         j->rec_mode = 0;
3778                 } else {
3779                         retval = 1;
3780                 }
3781                 break;
3782         case ULAW:
3783                 switch (j->baseframe.low) {
3784                 case 0xA0:
3785                         j->rec_frame_size = 80;
3786                         break;
3787                 case 0x50:
3788                         j->rec_frame_size = 40;
3789                         break;
3790                 default:
3791                         j->rec_frame_size = 120;
3792                         break;
3793                 }
3794                 j->rec_mode = 4;
3795                 break;
3796         case ALAW:
3797                 switch (j->baseframe.low) {
3798                 case 0xA0:
3799                         j->rec_frame_size = 80;
3800                         break;
3801                 case 0x50:
3802                         j->rec_frame_size = 40;
3803                         break;
3804                 default:
3805                         j->rec_frame_size = 120;
3806                         break;
3807                 }
3808                 j->rec_mode = 4;
3809                 break;
3810         case LINEAR16:
3811                 switch (j->baseframe.low) {
3812                 case 0xA0:
3813                         j->rec_frame_size = 160;
3814                         break;
3815                 case 0x50:
3816                         j->rec_frame_size = 80;
3817                         break;
3818                 default:
3819                         j->rec_frame_size = 240;
3820                         break;
3821                 }
3822                 j->rec_mode = 5;
3823                 break;
3824         case LINEAR8:
3825                 switch (j->baseframe.low) {
3826                 case 0xA0:
3827                         j->rec_frame_size = 80;
3828                         break;
3829                 case 0x50:
3830                         j->rec_frame_size = 40;
3831                         break;
3832                 default:
3833                         j->rec_frame_size = 120;
3834                         break;
3835                 }
3836                 j->rec_mode = 6;
3837                 break;
3838         case WSS:
3839                 switch (j->baseframe.low) {
3840                 case 0xA0:
3841                         j->rec_frame_size = 80;
3842                         break;
3843                 case 0x50:
3844                         j->rec_frame_size = 40;
3845                         break;
3846                 default:
3847                         j->rec_frame_size = 120;
3848                         break;
3849                 }
3850                 j->rec_mode = 7;
3851                 break;
3852         default:
3853                 kfree(j->read_buffer);
3854                 j->rec_frame_size = 0;
3855                 j->rec_mode = -1;
3856                 j->read_buffer = NULL;
3857                 j->read_buffer_size = 0;
3858                 retval = 1;
3859                 break;
3860         }
3861         return retval;
3862 }
3863
3864 static int ixj_record_start(IXJ *j)
3865 {
3866         unsigned short cmd = 0x0000;
3867
3868         if (j->read_buffer) {
3869                 ixj_record_stop(j);
3870         }
3871         j->flags.recording = 1;
3872         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3873
3874         if(ixjdebug & 0x0002)
3875                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3876
3877         if (!j->rec_mode) {
3878                 switch (j->rec_codec) {
3879                 case G723_63:
3880                         cmd = 0x5131;
3881                         break;
3882                 case G723_53:
3883                         cmd = 0x5132;
3884                         break;
3885                 case TS85:
3886                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3887
3888                         break;
3889                 case TS48:
3890                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3891
3892                         break;
3893                 case TS41:
3894                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3895
3896                         break;
3897                 case G728:
3898                         cmd = 0x5135;
3899                         break;
3900                 case G729:
3901                 case G729B:
3902                         cmd = 0x5136;
3903                         break;
3904                 default:
3905                         return 1;
3906                 }
3907                 if (ixj_WriteDSPCommand(cmd, j))
3908                         return -1;
3909         }
3910         if (!j->read_buffer) {
3911                 if (!j->read_buffer)
3912                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3913                 if (!j->read_buffer) {
3914                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3915                         return -ENOMEM;
3916                 }
3917         }
3918         j->read_buffer_size = j->rec_frame_size * 2;
3919
3920         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3921
3922                 return -1;
3923
3924         switch (j->rec_mode) {
3925         case 0:
3926                 cmd = 0x1C03;   /* Record C1 */
3927
3928                 break;
3929         case 4:
3930                 if (j->ver.low == 0x12) {
3931                         cmd = 0x1E03;   /* Record C1 */
3932
3933                 } else {
3934                         cmd = 0x1E01;   /* Record C1 */
3935
3936                 }
3937                 break;
3938         case 5:
3939                 if (j->ver.low == 0x12) {
3940                         cmd = 0x1E83;   /* Record C1 */
3941
3942                 } else {
3943                         cmd = 0x1E81;   /* Record C1 */
3944
3945                 }
3946                 break;
3947         case 6:
3948                 if (j->ver.low == 0x12) {
3949                         cmd = 0x1F03;   /* Record C1 */
3950
3951                 } else {
3952                         cmd = 0x1F01;   /* Record C1 */
3953
3954                 }
3955                 break;
3956         case 7:
3957                 if (j->ver.low == 0x12) {
3958                         cmd = 0x1F83;   /* Record C1 */
3959                 } else {
3960                         cmd = 0x1F81;   /* Record C1 */
3961                 }
3962                 break;
3963         }
3964         if (ixj_WriteDSPCommand(cmd, j))
3965                 return -1;
3966
3967         if (j->flags.playing) {
3968                 ixj_aec_start(j, j->aec_level);
3969         }
3970         return 0;
3971 }
3972
3973 static void ixj_record_stop(IXJ *j)
3974 {
3975         if (ixjdebug & 0x0002)
3976                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3977
3978         kfree(j->read_buffer);
3979         j->read_buffer = NULL;
3980         j->read_buffer_size = 0;
3981         if (j->rec_mode > -1) {
3982                 ixj_WriteDSPCommand(0x5120, j);
3983                 j->rec_mode = -1;
3984         }
3985         j->flags.recording = 0;
3986 }
3987 static void ixj_vad(IXJ *j, int arg)
3988 {
3989         if (arg)
3990                 ixj_WriteDSPCommand(0x513F, j);
3991         else
3992                 ixj_WriteDSPCommand(0x513E, j);
3993 }
3994
3995 static void set_rec_depth(IXJ *j, int depth)
3996 {
3997         if (depth > 60)
3998                 depth = 60;
3999         if (depth < 0)
4000                 depth = 0;
4001         ixj_WriteDSPCommand(0x5180 + depth, j);
4002 }
4003
4004 static void set_dtmf_prescale(IXJ *j, int volume)
4005 {
4006         ixj_WriteDSPCommand(0xCF07, j);
4007         ixj_WriteDSPCommand(volume, j);
4008 }
4009
4010 static int get_dtmf_prescale(IXJ *j)
4011 {
4012         ixj_WriteDSPCommand(0xCF05, j);
4013         return j->ssr.high << 8 | j->ssr.low;
4014 }
4015
4016 static void set_rec_volume(IXJ *j, int volume)
4017 {
4018         if(j->aec_level == AEC_AGC) {
4019                 if (ixjdebug & 0x0002)
4020                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4021                 ixj_WriteDSPCommand(0xCF96, j);
4022                 ixj_WriteDSPCommand(volume, j);
4023         } else {
4024                 if (ixjdebug & 0x0002)
4025                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4026                 ixj_WriteDSPCommand(0xCF03, j);
4027                 ixj_WriteDSPCommand(volume, j);
4028         }
4029 }
4030
4031 static int set_rec_volume_linear(IXJ *j, int volume)
4032 {
4033         int newvolume, dsprecmax;
4034
4035         if (ixjdebug & 0x0002)
4036                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4037         if(volume > 100 || volume < 0) {
4038           return -1;
4039         }
4040
4041         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4042         switch (j->cardtype) {
4043         case QTI_PHONEJACK:
4044                 dsprecmax = 0x440;
4045                 break;
4046         case QTI_LINEJACK:
4047                 dsprecmax = 0x180;
4048                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4049                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4050                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4051                 break;
4052         case QTI_PHONEJACK_LITE:
4053                 dsprecmax = 0x4C0;
4054                 break;
4055         case QTI_PHONEJACK_PCI:
4056                 dsprecmax = 0x100;
4057                 break;
4058         case QTI_PHONECARD:
4059                 dsprecmax = 0x400;
4060                 break;
4061         default:
4062                 return -1;
4063         }
4064         newvolume = (dsprecmax * volume) / 100;
4065         set_rec_volume(j, newvolume);
4066         return 0;
4067 }
4068
4069 static int get_rec_volume(IXJ *j)
4070 {
4071         if(j->aec_level == AEC_AGC) {
4072                 if (ixjdebug & 0x0002)
4073                         printk(KERN_INFO "Getting AGC Threshold\n");
4074                 ixj_WriteDSPCommand(0xCF86, j);
4075                 if (ixjdebug & 0x0002)
4076                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4077                 return j->ssr.high << 8 | j->ssr.low;
4078         } else {
4079                 if (ixjdebug & 0x0002)
4080                         printk(KERN_INFO "Getting Record Volume\n");
4081                 ixj_WriteDSPCommand(0xCF01, j);
4082                 return j->ssr.high << 8 | j->ssr.low;
4083         }
4084 }
4085
4086 static int get_rec_volume_linear(IXJ *j)
4087 {
4088         int volume, newvolume, dsprecmax;
4089
4090         switch (j->cardtype) {
4091         case QTI_PHONEJACK:
4092                 dsprecmax = 0x440;
4093                 break;
4094         case QTI_LINEJACK:
4095                 dsprecmax = 0x180;
4096                 break;
4097         case QTI_PHONEJACK_LITE:
4098                 dsprecmax = 0x4C0;
4099                 break;
4100         case QTI_PHONEJACK_PCI:
4101                 dsprecmax = 0x100;
4102                 break;
4103         case QTI_PHONECARD:
4104                 dsprecmax = 0x400;
4105                 break;
4106         default:
4107                 return -1;
4108         }
4109         volume = get_rec_volume(j);
4110         newvolume = (volume * 100) / dsprecmax;
4111         if(newvolume > 100)
4112                 newvolume = 100;
4113         return newvolume;
4114 }
4115
4116 static int get_rec_level(IXJ *j)
4117 {
4118         int retval;
4119
4120         ixj_WriteDSPCommand(0xCF88, j);
4121
4122         retval = j->ssr.high << 8 | j->ssr.low;
4123         retval = (retval * 256) / 240;
4124         return retval;
4125 }
4126
4127 static void ixj_aec_start(IXJ *j, int level)
4128 {
4129         j->aec_level = level;
4130         if (ixjdebug & 0x0002)
4131                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4132         if (!level) {
4133                 aec_stop(j);
4134         } else {
4135                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4136                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4137
4138                         ixj_WriteDSPCommand(0x0300, j);
4139                 }
4140                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4141
4142                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4143
4144                 switch (level) {
4145                 case AEC_LOW:
4146                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4147
4148                         ixj_WriteDSPCommand(0xE011, j);
4149                         ixj_WriteDSPCommand(0xFFFF, j);
4150
4151                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4152                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4153
4154                         break;
4155
4156                 case AEC_MED:
4157                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4158
4159                         ixj_WriteDSPCommand(0xE011, j);
4160                         ixj_WriteDSPCommand(0x0080, j);
4161
4162                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4163                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4164
4165                         break;
4166
4167                 case AEC_HIGH:
4168                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4169
4170                         ixj_WriteDSPCommand(0xE011, j);
4171                         ixj_WriteDSPCommand(0x0080, j);
4172
4173                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4174                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4175
4176                         break;
4177
4178                 case AEC_AGC:
4179                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4180                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4181
4182                         ixj_WriteDSPCommand(0xE011, j);
4183                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4184
4185                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4186
4187                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4188                                 ixj_WriteDSPCommand(0x0224, j);
4189                         else
4190                                 ixj_WriteDSPCommand(0x1224, j);
4191
4192                         ixj_WriteDSPCommand(0xE014, j);
4193                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4194
4195                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4196
4197                         /* Now we can set the AGC initial parameters and turn it on */
4198                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4199                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4200
4201                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4202                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4203
4204                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4205                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4206
4207                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4208                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4209
4210                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4211                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4212
4213                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4214                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4215
4216                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4217                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4218
4219                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4220                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4221
4222                         break;
4223
4224                 case AEC_AUTO:
4225                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4226
4227                         ixj_WriteDSPCommand(0xE011, j);
4228                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4229
4230                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4231
4232                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4233                                 ixj_WriteDSPCommand(0x0224, j);
4234                         else
4235                                 ixj_WriteDSPCommand(0x1224, j);
4236
4237                         ixj_WriteDSPCommand(0xE014, j);
4238                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4239
4240                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4241
4242                         break;
4243                 }
4244         }
4245 }
4246
4247 static void aec_stop(IXJ *j)
4248 {
4249         j->aec_level = AEC_OFF;
4250         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4251                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4252
4253                 ixj_WriteDSPCommand(0x0700, j);
4254         }
4255         if (j->play_mode != -1 && j->rec_mode != -1)
4256         {
4257                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4258         }
4259 }
4260
4261 static int set_play_codec(IXJ *j, int rate)
4262 {
4263         int retval = 0;
4264
4265         j->play_codec = rate;
4266
4267         switch (rate) {
4268         case G723_63:
4269                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4270                         j->play_frame_size = 12;
4271                         j->play_mode = 0;
4272                 } else {
4273                         retval = 1;
4274                 }
4275                 break;
4276         case G723_53:
4277                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4278                         j->play_frame_size = 10;
4279                         j->play_mode = 0;
4280                 } else {
4281                         retval = 1;
4282                 }
4283                 break;
4284         case TS85:
4285                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4286                         j->play_frame_size = 16;
4287                         j->play_mode = 0;
4288                 } else {
4289                         retval = 1;
4290                 }
4291                 break;
4292         case TS48:
4293                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4294                         j->play_frame_size = 9;
4295                         j->play_mode = 0;
4296                 } else {
4297                         retval = 1;
4298                 }
4299                 break;
4300         case TS41:
4301                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4302                         j->play_frame_size = 8;
4303                         j->play_mode = 0;
4304                 } else {
4305                         retval = 1;
4306                 }
4307                 break;
4308         case G728:
4309                 if (j->dsp.low != 0x20) {
4310                         j->play_frame_size = 48;
4311                         j->play_mode = 0;
4312                 } else {
4313                         retval = 1;
4314                 }
4315                 break;
4316         case G729:
4317                 if (j->dsp.low != 0x20) {
4318                         if (!j->flags.g729_loaded) {
4319                                 retval = 1;
4320                                 break;
4321                         }
4322                         switch (j->baseframe.low) {
4323                         case 0xA0:
4324                                 j->play_frame_size = 10;
4325                                 break;
4326                         case 0x50:
4327                                 j->play_frame_size = 5;
4328                                 break;
4329                         default:
4330                                 j->play_frame_size = 15;
4331                                 break;
4332                         }
4333                         j->play_mode = 0;
4334                 } else {
4335                         retval = 1;
4336                 }
4337                 break;
4338         case G729B:
4339                 if (j->dsp.low != 0x20) {
4340                         if (!j->flags.g729_loaded) {
4341                                 retval = 1;
4342                                 break;
4343                         }
4344                         switch (j->baseframe.low) {
4345                         case 0xA0:
4346                                 j->play_frame_size = 12;
4347                                 break;
4348                         case 0x50:
4349                                 j->play_frame_size = 6;
4350                                 break;
4351                         default:
4352                                 j->play_frame_size = 18;
4353                                 break;
4354                         }
4355                         j->play_mode = 0;
4356                 } else {
4357                         retval = 1;
4358                 }
4359                 break;
4360         case ULAW:
4361                 switch (j->baseframe.low) {
4362                 case 0xA0:
4363                         j->play_frame_size = 80;
4364                         break;
4365                 case 0x50:
4366                         j->play_frame_size = 40;
4367                         break;
4368                 default:
4369                         j->play_frame_size = 120;
4370                         break;
4371                 }
4372                 j->play_mode = 2;
4373                 break;
4374         case ALAW:
4375                 switch (j->baseframe.low) {
4376                 case 0xA0:
4377                         j->play_frame_size = 80;
4378                         break;
4379                 case 0x50:
4380                         j->play_frame_size = 40;
4381                         break;
4382                 default:
4383                         j->play_frame_size = 120;
4384                         break;
4385                 }
4386                 j->play_mode = 2;
4387                 break;
4388         case LINEAR16:
4389                 switch (j->baseframe.low) {
4390                 case 0xA0:
4391                         j->play_frame_size = 160;
4392                         break;
4393                 case 0x50:
4394                         j->play_frame_size = 80;
4395                         break;
4396                 default:
4397                         j->play_frame_size = 240;
4398                         break;
4399                 }
4400                 j->play_mode = 6;
4401                 break;
4402         case LINEAR8:
4403                 switch (j->baseframe.low) {
4404                 case 0xA0:
4405                         j->play_frame_size = 80;
4406                         break;
4407                 case 0x50:
4408                         j->play_frame_size = 40;
4409                         break;
4410                 default:
4411                         j->play_frame_size = 120;
4412                         break;
4413                 }
4414                 j->play_mode = 4;
4415                 break;
4416         case WSS:
4417                 switch (j->baseframe.low) {
4418                 case 0xA0:
4419                         j->play_frame_size = 80;
4420                         break;
4421                 case 0x50:
4422                         j->play_frame_size = 40;
4423                         break;
4424                 default:
4425                         j->play_frame_size = 120;
4426                         break;
4427                 }
4428                 j->play_mode = 5;
4429                 break;
4430         default:
4431                 kfree(j->write_buffer);
4432                 j->play_frame_size = 0;
4433                 j->play_mode = -1;
4434                 j->write_buffer = NULL;
4435                 j->write_buffer_size = 0;
4436                 retval = 1;
4437                 break;
4438         }
4439         return retval;
4440 }
4441
4442 static int ixj_play_start(IXJ *j)
4443 {
4444         unsigned short cmd = 0x0000;
4445
4446         if (j->write_buffer) {
4447                 ixj_play_stop(j);
4448         }
4449
4450         if(ixjdebug & 0x0002)
4451                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4452
4453         j->flags.playing = 1;
4454         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4455
4456         j->flags.play_first_frame = 1;
4457         j->drybuffer = 0;
4458
4459         if (!j->play_mode) {
4460                 switch (j->play_codec) {
4461                 case G723_63:
4462                         cmd = 0x5231;
4463                         break;
4464                 case G723_53:
4465                         cmd = 0x5232;
4466                         break;
4467                 case TS85:
4468                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4469
4470                         break;
4471                 case TS48:
4472                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4473
4474                         break;
4475                 case TS41:
4476                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4477
4478                         break;
4479                 case G728:
4480                         cmd = 0x5235;
4481                         break;
4482                 case G729:
4483                 case G729B:
4484                         cmd = 0x5236;
4485                         break;
4486                 default:
4487                         return 1;
4488                 }
4489                 if (ixj_WriteDSPCommand(cmd, j))
4490                         return -1;
4491         }
4492         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4493         if (!j->write_buffer) {
4494                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4495                 return -ENOMEM;
4496         }
4497 /*      j->write_buffers_empty = 2; */
4498         j->write_buffers_empty = 1;
4499         j->write_buffer_size = j->play_frame_size * 2;
4500         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4501         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4502
4503         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4504
4505                 return -1;
4506
4507         switch (j->play_mode) {
4508         case 0:
4509                 cmd = 0x2C03;
4510                 break;
4511         case 2:
4512                 if (j->ver.low == 0x12) {
4513                         cmd = 0x2C23;
4514                 } else {
4515                         cmd = 0x2C21;
4516                 }
4517                 break;
4518         case 4:
4519                 if (j->ver.low == 0x12) {
4520                         cmd = 0x2C43;
4521                 } else {
4522                         cmd = 0x2C41;
4523                 }
4524                 break;
4525         case 5:
4526                 if (j->ver.low == 0x12) {
4527                         cmd = 0x2C53;
4528                 } else {
4529                         cmd = 0x2C51;
4530                 }
4531                 break;
4532         case 6:
4533                 if (j->ver.low == 0x12) {
4534                         cmd = 0x2C63;
4535                 } else {
4536                         cmd = 0x2C61;
4537                 }
4538                 break;
4539         }
4540         if (ixj_WriteDSPCommand(cmd, j))
4541                 return -1;
4542
4543         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4544                 return -1;
4545
4546         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4547                 return -1;
4548
4549         if (j->flags.recording) {
4550                 ixj_aec_start(j, j->aec_level);
4551         }
4552
4553         return 0;
4554 }
4555
4556 static void ixj_play_stop(IXJ *j)
4557 {
4558         if (ixjdebug & 0x0002)
4559                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4560
4561         kfree(j->write_buffer);
4562         j->write_buffer = NULL;
4563         j->write_buffer_size = 0;
4564         if (j->play_mode > -1) {
4565                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4566
4567                 j->play_mode = -1;
4568         }
4569         j->flags.playing = 0;
4570 }
4571
4572 static inline int get_play_level(IXJ *j)
4573 {
4574         int retval;
4575
4576         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4577         return j->ssr.high << 8 | j->ssr.low;
4578         retval = j->ssr.high << 8 | j->ssr.low;
4579         retval = (retval * 256) / 240;
4580         return retval;
4581 }
4582
4583 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4584 {
4585         unsigned int mask = 0;
4586
4587         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4588
4589         poll_wait(file_p, &(j->poll_q), wait);
4590         if (j->read_buffer_ready > 0)
4591                 mask |= POLLIN | POLLRDNORM;    /* readable */
4592         if (j->write_buffers_empty > 0)
4593                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4594         if (j->ex.bytes)
4595                 mask |= POLLPRI;
4596         return mask;
4597 }
4598
4599 static int ixj_play_tone(IXJ *j, char tone)
4600 {
4601         if (!j->tone_state) {
4602                 if(ixjdebug & 0x0002) {
4603                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4604                 }
4605                 if (j->dsp.low == 0x20) {
4606                         idle(j);
4607                 }
4608                 j->tone_start_jif = jiffies;
4609
4610                 j->tone_state = 1;
4611         }
4612
4613         j->tone_index = tone;
4614         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4615                 return -1;
4616
4617         return 0;
4618 }
4619
4620 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4621 {
4622         j->tone_on_time = arg;
4623
4624         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4625
4626                 return -1;
4627
4628         if (ixj_WriteDSPCommand(arg, j))
4629                 return -1;
4630
4631         return 0;
4632 }
4633
4634 static int SCI_WaitHighSCI(IXJ *j)
4635 {
4636         int cnt;
4637
4638         j->pld_scrr.byte = inb_p(j->XILINXbase);
4639         if (!j->pld_scrr.bits.sci) {
4640                 for (cnt = 0; cnt < 10; cnt++) {
4641                         udelay(32);
4642                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4643
4644                         if ((j->pld_scrr.bits.sci))
4645                                 return 1;
4646                 }
4647                 if (ixjdebug & 0x0001)
4648                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4649                 return 0;
4650         } else
4651                 return 1;
4652 }
4653
4654 static int SCI_WaitLowSCI(IXJ *j)
4655 {
4656         int cnt;
4657
4658         j->pld_scrr.byte = inb_p(j->XILINXbase);
4659         if (j->pld_scrr.bits.sci) {
4660                 for (cnt = 0; cnt < 10; cnt++) {
4661                         udelay(32);
4662                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4663
4664                         if (!(j->pld_scrr.bits.sci))
4665                                 return 1;
4666                 }
4667                 if (ixjdebug & 0x0001)
4668                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4669                 return 0;
4670         } else
4671                 return 1;
4672 }
4673
4674 static int SCI_Control(IXJ *j, int control)
4675 {
4676         switch (control) {
4677         case SCI_End:
4678                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4679
4680                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4681
4682                 break;
4683         case SCI_Enable_DAA:
4684                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4685
4686                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4687
4688                 break;
4689         case SCI_Enable_Mixer:
4690                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4691
4692                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4693
4694                 break;
4695         case SCI_Enable_EEPROM:
4696                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4697
4698                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4699
4700                 break;
4701         default:
4702                 return 0;
4703                 break;
4704         }
4705         outb_p(j->pld_scrw.byte, j->XILINXbase);
4706
4707         switch (control) {
4708         case SCI_End:
4709                 return 1;
4710                 break;
4711         case SCI_Enable_DAA:
4712         case SCI_Enable_Mixer:
4713         case SCI_Enable_EEPROM:
4714                 if (!SCI_WaitHighSCI(j))
4715                         return 0;
4716                 break;
4717         default:
4718                 return 0;
4719                 break;
4720         }
4721         return 1;
4722 }
4723
4724 static int SCI_Prepare(IXJ *j)
4725 {
4726         if (!SCI_Control(j, SCI_End))
4727                 return 0;
4728
4729         if (!SCI_WaitLowSCI(j))
4730                 return 0;
4731
4732         return 1;
4733 }
4734
4735 static int ixj_get_mixer(long val, IXJ *j)
4736 {
4737         int reg = (val & 0x1F00) >> 8;
4738         return j->mix.vol[reg];
4739 }
4740
4741 static int ixj_mixer(long val, IXJ *j)
4742 {
4743         BYTES bytes;
4744
4745         bytes.high = (val & 0x1F00) >> 8;
4746         bytes.low = val & 0x00FF;
4747
4748         /* save mixer value so we can get back later on */
4749         j->mix.vol[bytes.high] = bytes.low;
4750
4751         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4752
4753         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4754
4755         SCI_Control(j, SCI_Enable_Mixer);
4756
4757         SCI_Control(j, SCI_End);
4758
4759         return 0;
4760 }
4761
4762 static int daa_load(BYTES * p_bytes, IXJ *j)
4763 {
4764         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4765         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4766         if (!SCI_Control(j, SCI_Enable_DAA))
4767                 return 0;
4768         else
4769                 return 1;
4770 }
4771
4772 static int ixj_daa_cr4(IXJ *j, char reg)
4773 {
4774         BYTES bytes;
4775
4776         switch (j->daa_mode) {
4777         case SOP_PU_SLEEP:
4778                 bytes.high = 0x14;
4779                 break;
4780         case SOP_PU_RINGING:
4781                 bytes.high = 0x54;
4782                 break;
4783         case SOP_PU_CONVERSATION:
4784                 bytes.high = 0x94;
4785                 break;
4786         case SOP_PU_PULSEDIALING:
4787                 bytes.high = 0xD4;
4788                 break;
4789         }
4790
4791         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4792
4793         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4794         case 0:
4795                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4796                 break;
4797         case 1:
4798                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4799                 break;
4800         case 2:
4801                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4802                 break;
4803         case 3:
4804                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4805                 break;
4806         }
4807
4808         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4809
4810         if (!daa_load(&bytes, j))
4811                 return 0;
4812
4813         if (!SCI_Prepare(j))
4814                 return 0;
4815
4816         return 1;
4817 }
4818
4819 static char daa_int_read(IXJ *j)
4820 {
4821         BYTES bytes;
4822
4823         if (!SCI_Prepare(j))
4824                 return 0;
4825
4826         bytes.high = 0x38;
4827         bytes.low = 0x00;
4828         outb_p(bytes.high, j->XILINXbase + 0x03);
4829         outb_p(bytes.low, j->XILINXbase + 0x02);
4830
4831         if (!SCI_Control(j, SCI_Enable_DAA))
4832                 return 0;
4833
4834         bytes.high = inb_p(j->XILINXbase + 0x03);
4835         bytes.low = inb_p(j->XILINXbase + 0x02);
4836         if (bytes.low != ALISDAA_ID_BYTE) {
4837                 if (ixjdebug & 0x0001)
4838                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4839                 return 0;
4840         }
4841         if (!SCI_Control(j, SCI_Enable_DAA))
4842                 return 0;
4843         if (!SCI_Control(j, SCI_End))
4844                 return 0;
4845
4846         bytes.high = inb_p(j->XILINXbase + 0x03);
4847         bytes.low = inb_p(j->XILINXbase + 0x02);
4848
4849         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4850
4851         return 1;
4852 }
4853
4854 static char daa_CR_read(IXJ *j, int cr)
4855 {
4856         IXJ_WORD wdata;
4857         BYTES bytes;
4858
4859         if (!SCI_Prepare(j))
4860                 return 0;
4861
4862         switch (j->daa_mode) {
4863         case SOP_PU_SLEEP:
4864                 bytes.high = 0x30 + cr;
4865                 break;
4866         case SOP_PU_RINGING:
4867                 bytes.high = 0x70 + cr;
4868                 break;
4869         case SOP_PU_CONVERSATION:
4870                 bytes.high = 0xB0 + cr;
4871                 break;
4872         case SOP_PU_PULSEDIALING:
4873         default:
4874                 bytes.high = 0xF0 + cr;
4875                 break;
4876         }
4877
4878         bytes.low = 0x00;
4879
4880         outb_p(bytes.high, j->XILINXbase + 0x03);
4881         outb_p(bytes.low, j->XILINXbase + 0x02);
4882
4883         if (!SCI_Control(j, SCI_Enable_DAA))
4884                 return 0;
4885
4886         bytes.high = inb_p(j->XILINXbase + 0x03);
4887         bytes.low = inb_p(j->XILINXbase + 0x02);
4888         if (bytes.low != ALISDAA_ID_BYTE) {
4889                 if (ixjdebug & 0x0001)
4890                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4891                 return 0;
4892         }
4893         if (!SCI_Control(j, SCI_Enable_DAA))
4894                 return 0;
4895         if (!SCI_Control(j, SCI_End))
4896                 return 0;
4897
4898         wdata.word = inw_p(j->XILINXbase + 0x02);
4899
4900         switch(cr){
4901                 case 5:
4902                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4903                         break;
4904                 case 4:
4905                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4906                         break;
4907                 case 3:
4908                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4909                         break;
4910                 case 2:
4911                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4912                         break;
4913                 case 1:
4914                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4915                         break;
4916                 case 0:
4917                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4918                         break;
4919                 default:
4920                         return 0;
4921         }
4922         return 1;
4923 }
4924
4925 static int ixj_daa_cid_reset(IXJ *j)
4926 {
4927         int i;
4928         BYTES bytes;
4929
4930         if (ixjdebug & 0x0002)
4931                 printk("DAA Clearing CID ram\n");
4932
4933         if (!SCI_Prepare(j))
4934                 return 0;
4935
4936         bytes.high = 0x58;
4937         bytes.low = 0x00;
4938         outb_p(bytes.high, j->XILINXbase + 0x03);
4939         outb_p(bytes.low, j->XILINXbase + 0x02);
4940
4941         if (!SCI_Control(j, SCI_Enable_DAA))
4942                 return 0;
4943
4944         if (!SCI_WaitHighSCI(j))
4945                 return 0;
4946
4947         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4948                 bytes.high = bytes.low = 0x00;
4949                 outb_p(bytes.high, j->XILINXbase + 0x03);
4950
4951                 if (i < ALISDAA_CALLERID_SIZE - 1)
4952                         outb_p(bytes.low, j->XILINXbase + 0x02);
4953
4954                 if (!SCI_Control(j, SCI_Enable_DAA))
4955                         return 0;
4956
4957                 if (!SCI_WaitHighSCI(j))
4958                         return 0;
4959
4960         }
4961
4962         if (!SCI_Control(j, SCI_End))
4963                 return 0;
4964
4965         if (ixjdebug & 0x0002)
4966                 printk("DAA CID ram cleared\n");
4967
4968         return 1;
4969 }
4970
4971 static int ixj_daa_cid_read(IXJ *j)
4972 {
4973         int i;
4974         BYTES bytes;
4975         char CID[ALISDAA_CALLERID_SIZE];
4976         bool mContinue;
4977         char *pIn, *pOut;
4978
4979         if (!SCI_Prepare(j))
4980                 return 0;
4981
4982         bytes.high = 0x78;
4983         bytes.low = 0x00;
4984         outb_p(bytes.high, j->XILINXbase + 0x03);
4985         outb_p(bytes.low, j->XILINXbase + 0x02);
4986
4987         if (!SCI_Control(j, SCI_Enable_DAA))
4988                 return 0;
4989
4990         if (!SCI_WaitHighSCI(j))
4991                 return 0;
4992
4993         bytes.high = inb_p(j->XILINXbase + 0x03);
4994         bytes.low = inb_p(j->XILINXbase + 0x02);
4995         if (bytes.low != ALISDAA_ID_BYTE) {
4996                 if (ixjdebug & 0x0001)
4997                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4998                 return 0;
4999         }
5000         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5001                 bytes.high = bytes.low = 0x00;
5002                 outb_p(bytes.high, j->XILINXbase + 0x03);
5003                 outb_p(bytes.low, j->XILINXbase + 0x02);
5004
5005                 if (!SCI_Control(j, SCI_Enable_DAA))
5006                         return 0;
5007
5008                 if (!SCI_WaitHighSCI(j))
5009                         return 0;
5010
5011                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5012                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5013         }
5014
5015         if (!SCI_Control(j, SCI_End))
5016                 return 0;
5017
5018         pIn = CID;
5019         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5020         mContinue = true;
5021         while (mContinue) {
5022                 if ((pIn[1] & 0x03) == 0x01) {
5023                         pOut[0] = pIn[0];
5024                 }
5025                 if ((pIn[2] & 0x0c) == 0x04) {
5026                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5027                 }
5028                 if ((pIn[3] & 0x30) == 0x10) {
5029                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5030                 }
5031                 if ((pIn[4] & 0xc0) == 0x40) {
5032                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5033                 } else {
5034                         mContinue = false;
5035                 }
5036                 pIn += 5, pOut += 4;
5037         }
5038         memset(&j->cid, 0, sizeof(PHONE_CID));
5039         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5040         pOut += 4;
5041         strncpy(j->cid.month, pOut, 2);
5042         pOut += 2;
5043         strncpy(j->cid.day, pOut, 2);
5044         pOut += 2;
5045         strncpy(j->cid.hour, pOut, 2);
5046         pOut += 2;
5047         strncpy(j->cid.min, pOut, 2);
5048         pOut += 3;
5049         j->cid.numlen = *pOut;
5050         pOut += 1;
5051         strncpy(j->cid.number, pOut, j->cid.numlen);
5052         pOut += j->cid.numlen + 1;
5053         j->cid.namelen = *pOut;
5054         pOut += 1;
5055         strncpy(j->cid.name, pOut, j->cid.namelen);
5056
5057         ixj_daa_cid_reset(j);
5058         return 1;
5059 }
5060
5061 static char daa_get_version(IXJ *j)
5062 {
5063         BYTES bytes;
5064
5065         if (!SCI_Prepare(j))
5066                 return 0;
5067
5068         bytes.high = 0x35;
5069         bytes.low = 0x00;
5070         outb_p(bytes.high, j->XILINXbase + 0x03);
5071         outb_p(bytes.low, j->XILINXbase + 0x02);
5072
5073         if (!SCI_Control(j, SCI_Enable_DAA))
5074                 return 0;
5075
5076         bytes.high = inb_p(j->XILINXbase + 0x03);
5077         bytes.low = inb_p(j->XILINXbase + 0x02);
5078         if (bytes.low != ALISDAA_ID_BYTE) {
5079                 if (ixjdebug & 0x0001)
5080                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5081                 return 0;
5082         }
5083         if (!SCI_Control(j, SCI_Enable_DAA))
5084                 return 0;
5085
5086         if (!SCI_Control(j, SCI_End))
5087                 return 0;
5088
5089         bytes.high = inb_p(j->XILINXbase + 0x03);
5090         bytes.low = inb_p(j->XILINXbase + 0x02);
5091         if (ixjdebug & 0x0002)
5092                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5093         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5094         return bytes.high;
5095 }
5096
5097 static int daa_set_mode(IXJ *j, int mode)
5098 {
5099         /* NOTE:
5100               The DAA *MUST* be in the conversation mode if the
5101               PSTN line is to be seized (PSTN line off-hook).
5102               Taking the PSTN line off-hook while the DAA is in
5103               a mode other than conversation mode will cause a
5104               hardware failure of the ALIS-A part.
5105
5106            NOTE:
5107               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5108               if the PSTN line is on-hook.  Failure to have the PSTN line
5109               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5110               ALIS-A part.
5111         */
5112
5113         BYTES bytes;
5114
5115         j->flags.pstn_rmr = 0;
5116
5117         if (!SCI_Prepare(j))
5118                 return 0;
5119
5120         switch (mode) {
5121         case SOP_PU_RESET:
5122                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5123
5124                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5125                 j->pld_slicw.bits.rly2 = 0;
5126                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5127                 bytes.high = 0x10;
5128                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5129                 daa_load(&bytes, j);
5130                 if (!SCI_Prepare(j))
5131                         return 0;
5132
5133                 j->daa_mode = SOP_PU_SLEEP;
5134                 break;
5135         case SOP_PU_SLEEP:
5136                 if(j->daa_mode == SOP_PU_SLEEP)
5137                 {
5138                         break;
5139                 }
5140                 if (ixjdebug & 0x0008)
5141                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5142 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5143                 {
5144                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5145
5146                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5147                         j->pld_slicw.bits.rly2 = 0;
5148                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5149                         bytes.high = 0x10;
5150                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5151                         daa_load(&bytes, j);
5152                         if (!SCI_Prepare(j))
5153                                 return 0;
5154                 }
5155                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5156
5157                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5158                 j->pld_slicw.bits.rly2 = 0;
5159                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5160                 bytes.high = 0x10;
5161                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5162                 daa_load(&bytes, j);
5163                 if (!SCI_Prepare(j))
5164                         return 0;
5165
5166                 j->daa_mode = SOP_PU_SLEEP;
5167                 j->flags.pstn_ringing = 0;
5168                 j->ex.bits.pstn_ring = 0;
5169                 j->pstn_sleeptil = jiffies + (hertz / 4);
5170                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5171                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5172                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5173                 break;
5174         case SOP_PU_RINGING:
5175                 if (ixjdebug & 0x0008)
5176                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5177                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5178
5179                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5180                 j->pld_slicw.bits.rly2 = 0;
5181                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5182                 bytes.high = 0x50;
5183                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5184                 daa_load(&bytes, j);
5185                 if (!SCI_Prepare(j))
5186                         return 0;
5187                 j->daa_mode = SOP_PU_RINGING;
5188                 break;
5189         case SOP_PU_CONVERSATION:
5190                 if (ixjdebug & 0x0008)
5191                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5192                 bytes.high = 0x90;
5193                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5194                 daa_load(&bytes, j);
5195                 if (!SCI_Prepare(j))
5196                         return 0;
5197                 j->pld_slicw.bits.rly2 = 1;
5198                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5199                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5200
5201                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5202                 j->daa_mode = SOP_PU_CONVERSATION;
5203                 j->flags.pstn_ringing = 0;
5204                 j->ex.bits.pstn_ring = 0;
5205                 j->pstn_sleeptil = jiffies;
5206                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5207                 break;
5208         case SOP_PU_PULSEDIALING:
5209                 if (ixjdebug & 0x0008)
5210                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5211                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5212
5213                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5214                 j->pld_slicw.bits.rly2 = 0;
5215                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5216                 bytes.high = 0xD0;
5217                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5218                 daa_load(&bytes, j);
5219                 if (!SCI_Prepare(j))
5220                         return 0;
5221                 j->daa_mode = SOP_PU_PULSEDIALING;
5222                 break;
5223         default:
5224                 break;
5225         }
5226         return 1;
5227 }
5228
5229 static int ixj_daa_write(IXJ *j)
5230 {
5231         BYTES bytes;
5232
5233         j->flags.pstncheck = 1;
5234
5235         daa_set_mode(j, SOP_PU_SLEEP);
5236
5237         if (!SCI_Prepare(j))
5238                 return 0;
5239
5240         outb_p(j->pld_scrw.byte, j->XILINXbase);
5241
5242         bytes.high = 0x14;
5243         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5244         if (!daa_load(&bytes, j))
5245                 return 0;
5246
5247         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5248         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5249         if (!daa_load(&bytes, j))
5250                 return 0;
5251
5252         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5253         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5254         if (!daa_load(&bytes, j))
5255                 return 0;
5256
5257         if (!SCI_Prepare(j))
5258                 return 0;
5259
5260         bytes.high = 0x1F;
5261         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5262         if (!daa_load(&bytes, j))
5263                 return 0;
5264
5265         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5266         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5267         if (!daa_load(&bytes, j))
5268                 return 0;
5269
5270         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5271         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5272         if (!daa_load(&bytes, j))
5273                 return 0;
5274
5275         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5276         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5277         if (!daa_load(&bytes, j))
5278                 return 0;
5279
5280         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5281         bytes.low = 0x00;
5282         if (!daa_load(&bytes, j))
5283                 return 0;
5284
5285         if (!SCI_Prepare(j))
5286                 return 0;
5287
5288         bytes.high = 0x00;
5289         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5290         if (!daa_load(&bytes, j))
5291                 return 0;
5292
5293         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5294         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5295         if (!daa_load(&bytes, j))
5296                 return 0;
5297
5298         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5299         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5300         if (!daa_load(&bytes, j))
5301                 return 0;
5302
5303         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5304         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5305         if (!daa_load(&bytes, j))
5306                 return 0;
5307
5308         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5309         bytes.low = 0x00;
5310         if (!daa_load(&bytes, j))
5311                 return 0;
5312
5313         if (!SCI_Control(j, SCI_End))
5314                 return 0;
5315         if (!SCI_WaitLowSCI(j))
5316                 return 0;
5317
5318         bytes.high = 0x01;
5319         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5320         if (!daa_load(&bytes, j))
5321                 return 0;
5322
5323         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5324         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5325         if (!daa_load(&bytes, j))
5326                 return 0;
5327
5328         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5329         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5330         if (!daa_load(&bytes, j))
5331                 return 0;
5332
5333         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5334         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5335         if (!daa_load(&bytes, j))
5336                 return 0;
5337
5338         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5339         bytes.low = 0x00;
5340         if (!daa_load(&bytes, j))
5341                 return 0;
5342
5343         if (!SCI_Control(j, SCI_End))
5344                 return 0;
5345         if (!SCI_WaitLowSCI(j))
5346                 return 0;
5347
5348         bytes.high = 0x02;
5349         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5350         if (!daa_load(&bytes, j))
5351                 return 0;
5352
5353         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5354         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5355         if (!daa_load(&bytes, j))
5356                 return 0;
5357
5358         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5359         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5360         if (!daa_load(&bytes, j))
5361                 return 0;
5362
5363         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5364         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5365         if (!daa_load(&bytes, j))
5366                 return 0;
5367
5368         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5369         bytes.low = 0x00;
5370         if (!daa_load(&bytes, j))
5371                 return 0;
5372
5373         if (!SCI_Control(j, SCI_End))
5374                 return 0;
5375         if (!SCI_WaitLowSCI(j))
5376                 return 0;
5377
5378         bytes.high = 0x03;
5379         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5380         if (!daa_load(&bytes, j))
5381                 return 0;
5382
5383         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5384         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5385         if (!daa_load(&bytes, j))
5386                 return 0;
5387
5388         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5389         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5390         if (!daa_load(&bytes, j))
5391                 return 0;
5392
5393         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5394         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5395         if (!daa_load(&bytes, j))
5396                 return 0;
5397
5398         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5399         bytes.low = 0x00;
5400         if (!daa_load(&bytes, j))
5401                 return 0;
5402
5403         if (!SCI_Control(j, SCI_End))
5404                 return 0;
5405         if (!SCI_WaitLowSCI(j))
5406                 return 0;
5407
5408         bytes.high = 0x04;
5409         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5410         if (!daa_load(&bytes, j))
5411                 return 0;
5412
5413         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5414         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5415         if (!daa_load(&bytes, j))
5416                 return 0;
5417
5418         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5419         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5420         if (!daa_load(&bytes, j))
5421                 return 0;
5422
5423         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5424         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5425         if (!daa_load(&bytes, j))
5426                 return 0;
5427
5428         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5429         bytes.low = 0x00;
5430         if (!daa_load(&bytes, j))
5431                 return 0;
5432
5433         if (!SCI_Control(j, SCI_End))
5434                 return 0;
5435         if (!SCI_WaitLowSCI(j))
5436                 return 0;
5437
5438         bytes.high = 0x05;
5439         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5440         if (!daa_load(&bytes, j))
5441                 return 0;
5442
5443         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5444         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5445         if (!daa_load(&bytes, j))
5446                 return 0;
5447
5448         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5449         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5450         if (!daa_load(&bytes, j))
5451                 return 0;
5452
5453         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5454         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5455         if (!daa_load(&bytes, j))
5456                 return 0;
5457
5458         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5459         bytes.low = 0x00;
5460         if (!daa_load(&bytes, j))
5461                 return 0;
5462
5463         if (!SCI_Control(j, SCI_End))
5464                 return 0;
5465         if (!SCI_WaitLowSCI(j))
5466                 return 0;
5467
5468         bytes.high = 0x06;
5469         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5470         if (!daa_load(&bytes, j))
5471                 return 0;
5472
5473         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5474         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5475         if (!daa_load(&bytes, j))
5476                 return 0;
5477
5478         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5479         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5480         if (!daa_load(&bytes, j))
5481                 return 0;
5482
5483         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5484         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5485         if (!daa_load(&bytes, j))
5486                 return 0;
5487
5488         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5489         bytes.low = 0x00;
5490         if (!daa_load(&bytes, j))
5491                 return 0;
5492
5493         if (!SCI_Control(j, SCI_End))
5494                 return 0;
5495         if (!SCI_WaitLowSCI(j))
5496                 return 0;
5497
5498         bytes.high = 0x07;
5499         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5500         if (!daa_load(&bytes, j))
5501                 return 0;
5502
5503         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5504         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5505         if (!daa_load(&bytes, j))
5506                 return 0;
5507
5508         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5509         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5510         if (!daa_load(&bytes, j))
5511                 return 0;
5512
5513         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5514         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5515         if (!daa_load(&bytes, j))
5516                 return 0;
5517
5518         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5519         bytes.low = 0x00;
5520         if (!daa_load(&bytes, j))
5521                 return 0;
5522
5523         if (!SCI_Control(j, SCI_End))
5524                 return 0;
5525         if (!SCI_WaitLowSCI(j))
5526                 return 0;
5527
5528         bytes.high = 0x08;
5529         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5530         if (!daa_load(&bytes, j))
5531                 return 0;
5532
5533         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5534         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5535         if (!daa_load(&bytes, j))
5536                 return 0;
5537
5538         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5539         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5540         if (!daa_load(&bytes, j))
5541                 return 0;
5542
5543         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5544         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5545         if (!daa_load(&bytes, j))
5546                 return 0;
5547
5548         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5549         bytes.low = 0x00;
5550         if (!daa_load(&bytes, j))
5551                 return 0;
5552
5553         if (!SCI_Control(j, SCI_End))
5554                 return 0;
5555         if (!SCI_WaitLowSCI(j))
5556                 return 0;
5557
5558         bytes.high = 0x09;
5559         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5560         if (!daa_load(&bytes, j))
5561                 return 0;
5562
5563         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5564         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5565         if (!daa_load(&bytes, j))
5566                 return 0;
5567
5568         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5569         bytes.low = 0x00;
5570         if (!daa_load(&bytes, j))
5571                 return 0;
5572
5573         if (!SCI_Control(j, SCI_End))
5574                 return 0;
5575         if (!SCI_WaitLowSCI(j))
5576                 return 0;
5577
5578         bytes.high = 0x0A;
5579         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5580         if (!daa_load(&bytes, j))
5581                 return 0;
5582
5583         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5584         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5585         if (!daa_load(&bytes, j))
5586                 return 0;
5587
5588         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5589         bytes.low = 0x00;
5590         if (!daa_load(&bytes, j))
5591                 return 0;
5592
5593         if (!SCI_Control(j, SCI_End))
5594                 return 0;
5595         if (!SCI_WaitLowSCI(j))
5596                 return 0;
5597
5598         bytes.high = 0x0B;
5599         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5600         if (!daa_load(&bytes, j))
5601                 return 0;
5602
5603         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5604         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5605         if (!daa_load(&bytes, j))
5606                 return 0;
5607
5608         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5609         bytes.low = 0x00;
5610         if (!daa_load(&bytes, j))
5611                 return 0;
5612
5613         if (!SCI_Control(j, SCI_End))
5614                 return 0;
5615         if (!SCI_WaitLowSCI(j))
5616                 return 0;
5617
5618         bytes.high = 0x0C;
5619         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5620         if (!daa_load(&bytes, j))
5621                 return 0;
5622
5623         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5624         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5625         if (!daa_load(&bytes, j))
5626                 return 0;
5627
5628         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5629         bytes.low = 0x00;
5630         if (!daa_load(&bytes, j))
5631                 return 0;
5632
5633         if (!SCI_Control(j, SCI_End))
5634                 return 0;
5635         if (!SCI_WaitLowSCI(j))
5636                 return 0;
5637
5638         bytes.high = 0x0D;
5639         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5640         if (!daa_load(&bytes, j))
5641                 return 0;
5642
5643         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5644         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5645         if (!daa_load(&bytes, j))
5646                 return 0;
5647
5648         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5649         bytes.low = 0x00;
5650         if (!daa_load(&bytes, j))
5651                 return 0;
5652
5653         if (!SCI_Control(j, SCI_End))
5654                 return 0;
5655         if (!SCI_WaitLowSCI(j))
5656                 return 0;
5657
5658         bytes.high = 0x0E;
5659         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5660         if (!daa_load(&bytes, j))
5661                 return 0;
5662
5663         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5664         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5665         if (!daa_load(&bytes, j))
5666                 return 0;
5667
5668         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5669         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5670         if (!daa_load(&bytes, j))
5671                 return 0;
5672
5673         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5674         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5675         if (!daa_load(&bytes, j))
5676                 return 0;
5677
5678         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5679         bytes.low = 0x00;
5680         if (!daa_load(&bytes, j))
5681                 return 0;
5682
5683         if (!SCI_Control(j, SCI_End))
5684                 return 0;
5685         if (!SCI_WaitLowSCI(j))
5686                 return 0;
5687
5688         bytes.high = 0x0F;
5689         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5690         if (!daa_load(&bytes, j))
5691                 return 0;
5692
5693         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5694         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5695         if (!daa_load(&bytes, j))
5696                 return 0;
5697
5698         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5699         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5700         if (!daa_load(&bytes, j))
5701                 return 0;
5702
5703         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5704         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5705         if (!daa_load(&bytes, j))
5706                 return 0;
5707
5708         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5709         bytes.low = 0x00;
5710         if (!daa_load(&bytes, j))
5711                 return 0;
5712
5713         udelay(32);
5714         j->pld_scrr.byte = inb_p(j->XILINXbase);
5715         if (!SCI_Control(j, SCI_End))
5716                 return 0;
5717
5718         outb_p(j->pld_scrw.byte, j->XILINXbase);
5719
5720         if (ixjdebug & 0x0002)
5721                 printk("DAA Coefficients Loaded\n");
5722
5723         j->flags.pstncheck = 0;
5724         return 1;
5725 }
5726
5727 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5728 {
5729         j->tone_off_time = arg;
5730         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5731
5732                 return -1;
5733         if (ixj_WriteDSPCommand(arg, j))
5734                 return -1;
5735         return 0;
5736 }
5737
5738 static int ixj_get_tone_on(IXJ *j)
5739 {
5740         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5741
5742                 return -1;
5743         return 0;
5744 }
5745
5746 static int ixj_get_tone_off(IXJ *j)
5747 {
5748         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5749
5750                 return -1;
5751         return 0;
5752 }
5753
5754 static void ixj_busytone(IXJ *j)
5755 {
5756         j->flags.ringback = 0;
5757         j->flags.dialtone = 0;
5758         j->flags.busytone = 1;
5759         ixj_set_tone_on(0x07D0, j);
5760         ixj_set_tone_off(0x07D0, j);
5761         ixj_play_tone(j, 27);
5762 }
5763
5764 static void ixj_dialtone(IXJ *j)
5765 {
5766         j->flags.ringback = 0;
5767         j->flags.dialtone = 1;
5768         j->flags.busytone = 0;
5769         if (j->dsp.low == 0x20) {
5770                 return;
5771         } else {
5772                 ixj_set_tone_on(0xFFFF, j);
5773                 ixj_set_tone_off(0x0000, j);
5774                 ixj_play_tone(j, 25);
5775         }
5776 }
5777
5778 static void ixj_cpt_stop(IXJ *j)
5779 {
5780         if(j->tone_state || j->tone_cadence_state)
5781         {
5782                 j->flags.dialtone = 0;
5783                 j->flags.busytone = 0;
5784                 j->flags.ringback = 0;
5785                 ixj_set_tone_on(0x0001, j);
5786                 ixj_set_tone_off(0x0000, j);
5787                 ixj_play_tone(j, 0);
5788                 j->tone_state = j->tone_cadence_state = 0;
5789                 if (j->cadence_t) {
5790                         kfree(j->cadence_t->ce);
5791                         kfree(j->cadence_t);
5792                         j->cadence_t = NULL;
5793                 }
5794         }
5795         if (j->play_mode == -1 && j->rec_mode == -1)
5796                 idle(j);
5797         if (j->play_mode != -1 && j->dsp.low == 0x20)
5798                 ixj_play_start(j);
5799         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5800                 ixj_record_start(j);
5801 }
5802
5803 static void ixj_ringback(IXJ *j)
5804 {
5805         j->flags.busytone = 0;
5806         j->flags.dialtone = 0;
5807         j->flags.ringback = 1;
5808         ixj_set_tone_on(0x0FA0, j);
5809         ixj_set_tone_off(0x2EE0, j);
5810         ixj_play_tone(j, 26);
5811 }
5812
5813 static void ixj_testram(IXJ *j)
5814 {
5815         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5816 }
5817
5818 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5819 {
5820         ixj_cadence *lcp;
5821         IXJ_CADENCE_ELEMENT __user *cep;
5822         IXJ_CADENCE_ELEMENT *lcep;
5823         IXJ_TONE ti;
5824         int err;
5825
5826         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5827         if (lcp == NULL)
5828                 return -ENOMEM;
5829
5830         err = -EFAULT;
5831         if (copy_from_user(&lcp->elements_used,
5832                            &cp->elements_used, sizeof(int)))
5833                 goto out;
5834         if (copy_from_user(&lcp->termination,
5835                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5836                 goto out;
5837         if (get_user(cep, &cp->ce))
5838                 goto out;
5839
5840         err = -EINVAL;
5841         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5842                 goto out;
5843
5844         err = -ENOMEM;
5845         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5846         if (!lcep)
5847                 goto out;
5848
5849         err = -EFAULT;
5850         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5851                 goto out1;
5852
5853         if (j->cadence_t) {
5854                 kfree(j->cadence_t->ce);
5855                 kfree(j->cadence_t);
5856         }
5857         lcp->ce = (void *) lcep;
5858         j->cadence_t = lcp;
5859         j->tone_cadence_state = 0;
5860         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5861         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5862         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5863                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5864                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5865                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5866                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5867                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5868                 ixj_init_tone(j, &ti);
5869         }
5870         ixj_play_tone(j, lcp->ce[0].index);
5871         return 1;
5872 out1:
5873         kfree(lcep);
5874 out:
5875         kfree(lcp);
5876         return err;
5877 }
5878
5879 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5880 {
5881         IXJ_FILTER_CADENCE *lcp;
5882         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5883         if (lcp == NULL) {
5884                 if(ixjdebug & 0x0001) {
5885                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5886                 }
5887                 return -ENOMEM;
5888         }
5889         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5890                 if(ixjdebug & 0x0001) {
5891                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5892                 }
5893                 kfree(lcp);
5894                 return -EFAULT;
5895         }
5896         if (lcp->filter > 5) {
5897                 if(ixjdebug & 0x0001) {
5898                         printk(KERN_INFO "Cadence out of range\n");
5899                 }
5900                 kfree(lcp);
5901                 return -1;
5902         }
5903         j->cadence_f[lcp->filter].state = 0;
5904         j->cadence_f[lcp->filter].enable = lcp->enable;
5905         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5906         j->cadence_f[lcp->filter].on1 = lcp->on1;
5907         j->cadence_f[lcp->filter].on1min = 0;
5908         j->cadence_f[lcp->filter].on1max = 0;
5909         j->cadence_f[lcp->filter].off1 = lcp->off1;
5910         j->cadence_f[lcp->filter].off1min = 0;
5911         j->cadence_f[lcp->filter].off1max = 0;
5912         j->cadence_f[lcp->filter].on2 = lcp->on2;
5913         j->cadence_f[lcp->filter].on2min = 0;
5914         j->cadence_f[lcp->filter].on2max = 0;
5915         j->cadence_f[lcp->filter].off2 = lcp->off2;
5916         j->cadence_f[lcp->filter].off2min = 0;
5917         j->cadence_f[lcp->filter].off2max = 0;
5918         j->cadence_f[lcp->filter].on3 = lcp->on3;
5919         j->cadence_f[lcp->filter].on3min = 0;
5920         j->cadence_f[lcp->filter].on3max = 0;
5921         j->cadence_f[lcp->filter].off3 = lcp->off3;
5922         j->cadence_f[lcp->filter].off3min = 0;
5923         j->cadence_f[lcp->filter].off3max = 0;
5924         if(ixjdebug & 0x0002) {
5925                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5926         }
5927         kfree(lcp);
5928         return 0;
5929 }
5930
5931 static void add_caps(IXJ *j)
5932 {
5933         j->caps = 0;
5934         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5935         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5936         j->caplist[j->caps].captype = vendor;
5937         j->caplist[j->caps].handle = j->caps++;
5938         j->caplist[j->caps].captype = device;
5939         switch (j->cardtype) {
5940         case QTI_PHONEJACK:
5941                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5942                 break;
5943         case QTI_LINEJACK:
5944                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5945                 break;
5946         case QTI_PHONEJACK_LITE:
5947                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5948                 break;
5949         case QTI_PHONEJACK_PCI:
5950                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5951                 break;
5952         case QTI_PHONECARD:
5953                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5954                 break;
5955         }
5956         j->caplist[j->caps].cap = j->cardtype;
5957         j->caplist[j->caps].handle = j->caps++;
5958         strcpy(j->caplist[j->caps].desc, "POTS");
5959         j->caplist[j->caps].captype = port;
5960         j->caplist[j->caps].cap = pots;
5961         j->caplist[j->caps].handle = j->caps++;
5962
5963         /* add devices that can do speaker/mic */
5964         switch (j->cardtype) {
5965         case QTI_PHONEJACK:
5966         case QTI_LINEJACK:
5967         case QTI_PHONEJACK_PCI:
5968         case QTI_PHONECARD:
5969                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5970                 j->caplist[j->caps].captype = port;
5971                 j->caplist[j->caps].cap = speaker;
5972                 j->caplist[j->caps].handle = j->caps++;
5973         default:
5974                 break;
5975         }
5976
5977         /* add devices that can do handset */
5978         switch (j->cardtype) {
5979         case QTI_PHONEJACK:
5980                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5981                 j->caplist[j->caps].captype = port;
5982                 j->caplist[j->caps].cap = handset;
5983                 j->caplist[j->caps].handle = j->caps++;
5984                 break;
5985         default:
5986                 break;
5987         }
5988
5989         /* add devices that can do PSTN */
5990         switch (j->cardtype) {
5991         case QTI_LINEJACK:
5992                 strcpy(j->caplist[j->caps].desc, "PSTN");
5993                 j->caplist[j->caps].captype = port;
5994                 j->caplist[j->caps].cap = pstn;
5995                 j->caplist[j->caps].handle = j->caps++;
5996                 break;
5997         default:
5998                 break;
5999         }
6000
6001         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6002         strcpy(j->caplist[j->caps].desc, "ULAW");
6003         j->caplist[j->caps].captype = codec;
6004         j->caplist[j->caps].cap = ULAW;
6005         j->caplist[j->caps].handle = j->caps++;
6006
6007         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6008         j->caplist[j->caps].captype = codec;
6009         j->caplist[j->caps].cap = LINEAR16;
6010         j->caplist[j->caps].handle = j->caps++;
6011
6012         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6013         j->caplist[j->caps].captype = codec;
6014         j->caplist[j->caps].cap = LINEAR8;
6015         j->caplist[j->caps].handle = j->caps++;
6016
6017         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6018         j->caplist[j->caps].captype = codec;
6019         j->caplist[j->caps].cap = WSS;
6020         j->caplist[j->caps].handle = j->caps++;
6021
6022         /* software ALAW codec, made from ULAW */
6023         strcpy(j->caplist[j->caps].desc, "ALAW");
6024         j->caplist[j->caps].captype = codec;
6025         j->caplist[j->caps].cap = ALAW;
6026         j->caplist[j->caps].handle = j->caps++;
6027
6028         /* version 12 of the 8020 does the following codecs in a broken way */
6029         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6030                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6031                 j->caplist[j->caps].captype = codec;
6032                 j->caplist[j->caps].cap = G723_63;
6033                 j->caplist[j->caps].handle = j->caps++;
6034
6035                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6036                 j->caplist[j->caps].captype = codec;
6037                 j->caplist[j->caps].cap = G723_53;
6038                 j->caplist[j->caps].handle = j->caps++;
6039
6040                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6041                 j->caplist[j->caps].captype = codec;
6042                 j->caplist[j->caps].cap = TS48;
6043                 j->caplist[j->caps].handle = j->caps++;
6044
6045                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6046                 j->caplist[j->caps].captype = codec;
6047                 j->caplist[j->caps].cap = TS41;
6048                 j->caplist[j->caps].handle = j->caps++;
6049         }
6050
6051         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6052         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6053                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6054                 j->caplist[j->caps].captype = codec;
6055                 j->caplist[j->caps].cap = TS85;
6056                 j->caplist[j->caps].handle = j->caps++;
6057         }
6058
6059         /* 8021 chips can do G728 */
6060         if (j->dsp.low == 0x21) {
6061                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6062                 j->caplist[j->caps].captype = codec;
6063                 j->caplist[j->caps].cap = G728;
6064                 j->caplist[j->caps].handle = j->caps++;
6065         }
6066
6067         /* 8021/8022 chips can do G729 if loaded */
6068         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6069                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6070                 j->caplist[j->caps].captype = codec;
6071                 j->caplist[j->caps].cap = G729;
6072                 j->caplist[j->caps].handle = j->caps++;
6073         }
6074         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6075                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6076                 j->caplist[j->caps].captype = codec;
6077                 j->caplist[j->caps].cap = G729B;
6078                 j->caplist[j->caps].handle = j->caps++;
6079         }
6080 }
6081
6082 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6083 {
6084         int cnt;
6085         int retval = 0;
6086         for (cnt = 0; cnt < j->caps; cnt++) {
6087                 if (pcreq->captype == j->caplist[cnt].captype
6088                     && pcreq->cap == j->caplist[cnt].cap) {
6089                         retval = 1;
6090                         break;
6091                 }
6092         }
6093         return retval;
6094 }
6095
6096 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6097 {
6098         IXJ_TONE ti;
6099         IXJ_FILTER jf;
6100         IXJ_FILTER_RAW jfr;
6101         void __user *argp = (void __user *)arg;
6102         struct inode *inode = file_p->f_path.dentry->d_inode;
6103         unsigned int minor = iminor(inode);
6104         unsigned int raise, mant;
6105         int board = NUM(inode);
6106
6107         IXJ *j = get_ixj(NUM(inode));
6108
6109         int retval = 0;
6110
6111         /*
6112          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6113          *    This is necessary to keep the DSP from locking up.
6114          */
6115         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6116                 schedule_timeout_interruptible(1);
6117         if (ixjdebug & 0x0040)
6118                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6119         if (minor >= IXJMAX) {
6120                 clear_bit(board, &j->busyflags);
6121                 return -ENODEV;
6122         }
6123         /*
6124          *    Check ioctls only root can use.
6125          */
6126         if (!capable(CAP_SYS_ADMIN)) {
6127                 switch (cmd) {
6128                 case IXJCTL_TESTRAM:
6129                 case IXJCTL_HZ:
6130                         retval = -EPERM;
6131                 }
6132         }
6133         switch (cmd) {
6134         case IXJCTL_TESTRAM:
6135                 ixj_testram(j);
6136                 retval = (j->ssr.high << 8) + j->ssr.low;
6137                 break;
6138         case IXJCTL_CARDTYPE:
6139                 retval = j->cardtype;
6140                 break;
6141         case IXJCTL_SERIAL:
6142                 retval = j->serial;
6143                 break;
6144         case IXJCTL_VERSION:
6145                 {
6146                         char arg_str[100];
6147                         snprintf(arg_str, sizeof(arg_str),
6148                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6149                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6150                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6151                                 retval = -EFAULT;
6152                 }
6153                 break;
6154         case PHONE_RING_CADENCE:
6155                 j->ring_cadence = arg;
6156                 break;
6157         case IXJCTL_CIDCW:
6158                 if(arg) {
6159                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6160                                 retval = -EFAULT;
6161                                 break;
6162                         }
6163                 } else {
6164                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6165                 }
6166                 ixj_write_cidcw(j);
6167                 break;
6168         /* Binary compatbility */
6169         case OLD_PHONE_RING_START:
6170                 arg = 0;
6171                 /* Fall through */
6172         case PHONE_RING_START:
6173                 if(arg) {
6174                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6175                                 retval = -EFAULT;
6176                                 break;
6177                         }
6178                         ixj_write_cid(j);
6179                 } else {
6180                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6181                 }
6182                 ixj_ring_start(j);
6183                 break;
6184         case PHONE_RING_STOP:
6185                 j->flags.cringing = 0;
6186                 if(j->cadence_f[5].enable) {
6187                         j->cadence_f[5].state = 0;
6188                 }
6189                 ixj_ring_off(j);
6190                 break;
6191         case PHONE_RING:
6192                 retval = ixj_ring(j);
6193                 break;
6194         case PHONE_EXCEPTION:
6195                 retval = j->ex.bytes;
6196                 if(j->ex.bits.flash) {
6197                         j->flash_end = 0;
6198                         j->ex.bits.flash = 0;
6199                 }
6200                 j->ex.bits.pstn_ring = 0;
6201                 j->ex.bits.caller_id = 0;
6202                 j->ex.bits.pstn_wink = 0;
6203                 j->ex.bits.f0 = 0;
6204                 j->ex.bits.f1 = 0;
6205                 j->ex.bits.f2 = 0;
6206                 j->ex.bits.f3 = 0;
6207                 j->ex.bits.fc0 = 0;
6208                 j->ex.bits.fc1 = 0;
6209                 j->ex.bits.fc2 = 0;
6210                 j->ex.bits.fc3 = 0;
6211                 j->ex.bits.reserved = 0;
6212                 break;
6213         case PHONE_HOOKSTATE:
6214                 j->ex.bits.hookstate = 0;
6215                 retval = j->hookstate;  //j->r_hook;
6216                 break;
6217         case IXJCTL_SET_LED:
6218                 LED_SetState(arg, j);
6219                 break;
6220         case PHONE_FRAME:
6221                 retval = set_base_frame(j, arg);
6222                 break;
6223         case PHONE_REC_CODEC:
6224                 retval = set_rec_codec(j, arg);
6225                 break;
6226         case PHONE_VAD:
6227                 ixj_vad(j, arg);
6228                 break;
6229         case PHONE_REC_START:
6230                 ixj_record_start(j);
6231                 break;
6232         case PHONE_REC_STOP:
6233                 ixj_record_stop(j);
6234                 break;
6235         case PHONE_REC_DEPTH:
6236                 set_rec_depth(j, arg);
6237                 break;
6238         case PHONE_REC_VOLUME:
6239                 if(arg == -1) {
6240                         retval = get_rec_volume(j);
6241                 }
6242                 else {
6243                         set_rec_volume(j, arg);
6244                         retval = arg;
6245                 }
6246                 break;
6247         case PHONE_REC_VOLUME_LINEAR:
6248                 if(arg == -1) {
6249                         retval = get_rec_volume_linear(j);
6250                 }
6251                 else {
6252                         set_rec_volume_linear(j, arg);
6253                         retval = arg;
6254                 }
6255                 break;
6256         case IXJCTL_DTMF_PRESCALE:
6257                 if(arg == -1) {
6258                         retval = get_dtmf_prescale(j);
6259                 }
6260                 else {
6261                         set_dtmf_prescale(j, arg);
6262                         retval = arg;
6263                 }
6264                 break;
6265         case PHONE_REC_LEVEL:
6266                 retval = get_rec_level(j);
6267                 break;
6268         case IXJCTL_SC_RXG:
6269                 retval = ixj_siadc(j, arg);
6270                 break;
6271         case IXJCTL_SC_TXG:
6272                 retval = ixj_sidac(j, arg);
6273                 break;
6274         case IXJCTL_AEC_START:
6275                 ixj_aec_start(j, arg);
6276                 break;
6277         case IXJCTL_AEC_STOP:
6278                 aec_stop(j);
6279                 break;
6280         case IXJCTL_AEC_GET_LEVEL:
6281                 retval = j->aec_level;
6282                 break;
6283         case PHONE_PLAY_CODEC:
6284                 retval = set_play_codec(j, arg);
6285                 break;
6286         case PHONE_PLAY_START:
6287                 retval = ixj_play_start(j);
6288                 break;
6289         case PHONE_PLAY_STOP:
6290                 ixj_play_stop(j);
6291                 break;
6292         case PHONE_PLAY_DEPTH:
6293                 set_play_depth(j, arg);
6294                 break;
6295         case PHONE_PLAY_VOLUME:
6296                 if(arg == -1) {
6297                         retval = get_play_volume(j);
6298                 }
6299                 else {
6300                         set_play_volume(j, arg);
6301                         retval = arg;
6302                 }
6303                 break;
6304         case PHONE_PLAY_VOLUME_LINEAR:
6305                 if(arg == -1) {
6306                         retval = get_play_volume_linear(j);
6307                 }
6308                 else {
6309                         set_play_volume_linear(j, arg);
6310                         retval = arg;
6311                 }
6312                 break;
6313         case PHONE_PLAY_LEVEL:
6314                 retval = get_play_level(j);
6315                 break;
6316         case IXJCTL_DSP_TYPE:
6317                 retval = (j->dsp.high << 8) + j->dsp.low;
6318                 break;
6319         case IXJCTL_DSP_VERSION:
6320                 retval = (j->ver.high << 8) + j->ver.low;
6321                 break;
6322         case IXJCTL_HZ:
6323                 hertz = arg;
6324                 break;
6325         case IXJCTL_RATE:
6326                 if (arg > hertz)
6327                         retval = -1;
6328                 else
6329                         samplerate = arg;
6330                 break;
6331         case IXJCTL_DRYBUFFER_READ:
6332                 put_user(j->drybuffer, (unsigned long __user *) argp);
6333                 break;
6334         case IXJCTL_DRYBUFFER_CLEAR:
6335                 j->drybuffer = 0;
6336                 break;
6337         case IXJCTL_FRAMES_READ:
6338                 put_user(j->framesread, (unsigned long __user *) argp);
6339                 break;
6340         case IXJCTL_FRAMES_WRITTEN:
6341                 put_user(j->frameswritten, (unsigned long __user *) argp);
6342                 break;
6343         case IXJCTL_READ_WAIT:
6344                 put_user(j->read_wait, (unsigned long __user *) argp);
6345                 break;
6346         case IXJCTL_WRITE_WAIT:
6347                 put_user(j->write_wait, (unsigned long __user *) argp);
6348                 break;
6349         case PHONE_MAXRINGS:
6350                 j->maxrings = arg;
6351                 break;
6352         case PHONE_SET_TONE_ON_TIME:
6353                 ixj_set_tone_on(arg, j);
6354                 break;
6355         case PHONE_SET_TONE_OFF_TIME:
6356                 ixj_set_tone_off(arg, j);
6357                 break;
6358         case PHONE_GET_TONE_ON_TIME:
6359                 if (ixj_get_tone_on(j)) {
6360                         retval = -1;
6361                 } else {
6362                         retval = (j->ssr.high << 8) + j->ssr.low;
6363                 }
6364                 break;
6365         case PHONE_GET_TONE_OFF_TIME:
6366                 if (ixj_get_tone_off(j)) {
6367                         retval = -1;
6368                 } else {
6369                         retval = (j->ssr.high << 8) + j->ssr.low;
6370                 }
6371                 break;
6372         case PHONE_PLAY_TONE:
6373                 if (!j->tone_state)
6374                         retval = ixj_play_tone(j, arg);
6375                 else
6376                         retval = -1;
6377                 break;
6378         case PHONE_GET_TONE_STATE:
6379                 retval = j->tone_state;
6380                 break;
6381         case PHONE_DTMF_READY:
6382                 retval = j->ex.bits.dtmf_ready;
6383                 break;
6384         case PHONE_GET_DTMF:
6385                 if (ixj_hookstate(j)) {
6386                         if (j->dtmf_rp != j->dtmf_wp) {
6387                                 retval = j->dtmfbuffer[j->dtmf_rp];
6388                                 j->dtmf_rp++;
6389                                 if (j->dtmf_rp == 79)
6390                                         j->dtmf_rp = 0;
6391                                 if (j->dtmf_rp == j->dtmf_wp) {
6392                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6393                                 }
6394                         }
6395                 }
6396                 break;
6397         case PHONE_GET_DTMF_ASCII:
6398                 if (ixj_hookstate(j)) {
6399                         if (j->dtmf_rp != j->dtmf_wp) {
6400                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6401                                 case 10:
6402                                         retval = 42;    /* '*'; */
6403
6404                                         break;
6405                                 case 11:
6406                                         retval = 48;    /*'0'; */
6407
6408                                         break;
6409                                 case 12:
6410                                         retval = 35;    /*'#'; */
6411
6412                                         break;
6413                                 case 28:
6414                                         retval = 65;    /*'A'; */
6415
6416                                         break;
6417                                 case 29:
6418                                         retval = 66;    /*'B'; */
6419
6420                                         break;
6421                                 case 30:
6422                                         retval = 67;    /*'C'; */
6423
6424                                         break;
6425                                 case 31:
6426                                         retval = 68;    /*'D'; */
6427
6428                                         break;
6429                                 default:
6430                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6431                                         break;
6432                                 }
6433                                 j->dtmf_rp++;
6434                                 if (j->dtmf_rp == 79)
6435                                         j->dtmf_rp = 0;
6436                                 if(j->dtmf_rp == j->dtmf_wp)
6437                                 {
6438                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6439                                 }
6440                         }
6441                 }
6442                 break;
6443         case PHONE_DTMF_OOB:
6444                 j->flags.dtmf_oob = arg;
6445                 break;
6446         case PHONE_DIALTONE:
6447                 ixj_dialtone(j);
6448                 break;
6449         case PHONE_BUSY:
6450                 ixj_busytone(j);
6451                 break;
6452         case PHONE_RINGBACK:
6453                 ixj_ringback(j);
6454                 break;
6455         case PHONE_WINK:
6456                 if(j->cardtype == QTI_PHONEJACK)
6457                         retval = -1;
6458                 else
6459                         retval = ixj_wink(j);
6460                 break;
6461         case PHONE_CPT_STOP:
6462                 ixj_cpt_stop(j);
6463                 break;
6464         case PHONE_QUERY_CODEC:
6465         {
6466                 struct phone_codec_data pd;
6467                 int val;
6468                 int proto_size[] = {
6469                         -1,
6470                         12, 10, 16, 9, 8, 48, 5,
6471                         40, 40, 80, 40, 40, 6
6472                 };
6473                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6474                         retval = -EFAULT;
6475                         break;
6476                 }
6477                 if(pd.type<1 || pd.type>13) {
6478                         retval = -EPROTONOSUPPORT;
6479                         break;
6480                 }
6481                 if(pd.type<G729)
6482                         val=proto_size[pd.type];
6483                 else switch(j->baseframe.low)
6484                 {
6485                         case 0xA0:val=2*proto_size[pd.type];break;
6486                         case 0x50:val=proto_size[pd.type];break;
6487                         default:val=proto_size[pd.type]*3;break;
6488                 }
6489                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6490                 if(copy_to_user(argp, &pd, sizeof(pd)))
6491                         retval = -EFAULT;
6492                 break;
6493         }
6494         case IXJCTL_DSP_IDLE:
6495                 idle(j);
6496                 break;
6497         case IXJCTL_MIXER:
6498                 if ((arg & 0xff) == 0xff)
6499                         retval = ixj_get_mixer(arg, j);
6500                 else
6501                         ixj_mixer(arg, j);
6502                 break;
6503         case IXJCTL_DAA_COEFF_SET:
6504                 switch (arg) {
6505                 case DAA_US:
6506                         DAA_Coeff_US(j);
6507                         retval = ixj_daa_write(j);
6508                         break;
6509                 case DAA_UK:
6510                         DAA_Coeff_UK(j);
6511                         retval = ixj_daa_write(j);
6512                         break;
6513                 case DAA_FRANCE:
6514                         DAA_Coeff_France(j);
6515                         retval = ixj_daa_write(j);
6516                         break;
6517                 case DAA_GERMANY:
6518                         DAA_Coeff_Germany(j);
6519                         retval = ixj_daa_write(j);
6520                         break;
6521                 case DAA_AUSTRALIA:
6522                         DAA_Coeff_Australia(j);
6523                         retval = ixj_daa_write(j);
6524                         break;
6525                 case DAA_JAPAN:
6526                         DAA_Coeff_Japan(j);
6527                         retval = ixj_daa_write(j);
6528                         break;
6529                 default:
6530                         retval = 1;
6531                         break;
6532                 }
6533                 break;
6534         case IXJCTL_DAA_AGAIN:
6535                 ixj_daa_cr4(j, arg | 0x02);
6536                 break;
6537         case IXJCTL_PSTN_LINETEST:
6538                 retval = ixj_linetest(j);
6539                 break;
6540         case IXJCTL_VMWI:
6541                 ixj_write_vmwi(j, arg);
6542                 break;
6543         case IXJCTL_CID:
6544                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6545                         retval = -EFAULT;
6546                 j->ex.bits.caller_id = 0;
6547                 break;
6548         case IXJCTL_WINK_DURATION:
6549                 j->winktime = arg;
6550                 break;
6551         case IXJCTL_PORT:
6552                 if (arg)
6553                         retval = ixj_set_port(j, arg);
6554                 else
6555                         retval = j->port;
6556                 break;
6557         case IXJCTL_POTS_PSTN:
6558                 retval = ixj_set_pots(j, arg);
6559                 break;
6560         case PHONE_CAPABILITIES:
6561                 add_caps(j);
6562                 retval = j->caps;
6563                 break;
6564         case PHONE_CAPABILITIES_LIST:
6565                 add_caps(j);
6566                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6567                         retval = -EFAULT;
6568                 break;
6569         case PHONE_CAPABILITIES_CHECK:
6570                 {
6571                         struct phone_capability cap;
6572                         if (copy_from_user(&cap, argp, sizeof(cap)))
6573                                 retval = -EFAULT;
6574                         else {
6575                                 add_caps(j);
6576                                 retval = capabilities_check(j, &cap);
6577                         }
6578                 }
6579                 break;
6580         case PHONE_PSTN_SET_STATE:
6581                 daa_set_mode(j, arg);
6582                 break;
6583         case PHONE_PSTN_GET_STATE:
6584                 retval = j->daa_mode;
6585                 j->ex.bits.pstn_ring = 0;
6586                 break;
6587         case IXJCTL_SET_FILTER:
6588                 if (copy_from_user(&jf, argp, sizeof(jf)))
6589                         retval = -EFAULT;
6590                 retval = ixj_init_filter(j, &jf);
6591                 break;
6592         case IXJCTL_SET_FILTER_RAW:
6593                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6594                         retval = -EFAULT;
6595                 else
6596                         retval = ixj_init_filter_raw(j, &jfr);
6597                 break;
6598         case IXJCTL_GET_FILTER_HIST:
6599                 if(arg<0||arg>3)
6600                         retval = -EINVAL;
6601                 else
6602                         retval = j->filter_hist[arg];
6603                 break;
6604         case IXJCTL_INIT_TONE:
6605                 if (copy_from_user(&ti, argp, sizeof(ti)))
6606                         retval = -EFAULT;
6607                 else
6608                         retval = ixj_init_tone(j, &ti);
6609                 break;
6610         case IXJCTL_TONE_CADENCE:
6611                 retval = ixj_build_cadence(j, argp);
6612                 break;
6613         case IXJCTL_FILTER_CADENCE:
6614                 retval = ixj_build_filter_cadence(j, argp);
6615                 break;
6616         case IXJCTL_SIGCTL:
6617                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6618                         retval = -EFAULT;
6619                         break;
6620                 }
6621                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6622                 if(j->sigdef.event < 33) {
6623                         raise = 1;
6624                         for(mant = 0; mant < j->sigdef.event; mant++){
6625                                 raise *= 2;
6626                         }
6627                         if(j->sigdef.signal)
6628                                 j->ex_sig.bytes |= raise;
6629                         else
6630                                 j->ex_sig.bytes &= (raise^0xffff);
6631                 }
6632                 break;
6633         case IXJCTL_INTERCOM_STOP:
6634                 if(arg < 0 || arg >= IXJMAX)
6635                         return -EINVAL;
6636                 j->intercom = -1;
6637                 ixj_record_stop(j);
6638                 ixj_play_stop(j);
6639                 idle(j);
6640                 get_ixj(arg)->intercom = -1;
6641                 ixj_record_stop(get_ixj(arg));
6642                 ixj_play_stop(get_ixj(arg));
6643                 idle(get_ixj(arg));
6644                 break;
6645         case IXJCTL_INTERCOM_START:
6646                 if(arg < 0 || arg >= IXJMAX)
6647                         return -EINVAL;
6648                 j->intercom = arg;
6649                 ixj_record_start(j);
6650                 ixj_play_start(j);
6651                 get_ixj(arg)->intercom = board;
6652                 ixj_play_start(get_ixj(arg));
6653                 ixj_record_start(get_ixj(arg));
6654                 break;
6655         }
6656         if (ixjdebug & 0x0040)
6657                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6658         clear_bit(board, &j->busyflags);
6659         return retval;
6660 }
6661
6662 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6663 {
6664         long ret;
6665         lock_kernel();
6666         ret = do_ixj_ioctl(file_p, cmd, arg);
6667         unlock_kernel();
6668         return ret;
6669 }
6670
6671 static int ixj_fasync(int fd, struct file *file_p, int mode)
6672 {
6673         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6674
6675         return fasync_helper(fd, file_p, mode, &j->async_queue);
6676 }
6677
6678 static const struct file_operations ixj_fops =
6679 {
6680         .owner          = THIS_MODULE,
6681         .read           = ixj_enhanced_read,
6682         .write          = ixj_enhanced_write,
6683         .poll           = ixj_poll,
6684         .unlocked_ioctl = ixj_ioctl,
6685         .release        = ixj_release,
6686         .fasync         = ixj_fasync
6687 };
6688
6689 static int ixj_linetest(IXJ *j)
6690 {
6691         j->flags.pstncheck = 1; /* Testing */
6692         j->flags.pstn_present = 0; /* Assume the line is not there */
6693
6694         daa_int_read(j);        /*Clear DAA Interrupt flags */
6695         /* */
6696         /* Hold all relays in the normally de-energized position. */
6697         /* */
6698
6699         j->pld_slicw.bits.rly1 = 0;
6700         j->pld_slicw.bits.rly2 = 0;
6701         j->pld_slicw.bits.rly3 = 0;
6702         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6703         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6704
6705         outb_p(j->pld_scrw.byte, j->XILINXbase);
6706         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6707         if (j->pld_slicr.bits.potspstn) {
6708                 j->flags.pots_pstn = 1;
6709                 j->flags.pots_correct = 0;
6710                 LED_SetState(0x4, j);
6711         } else {
6712                 j->flags.pots_pstn = 0;
6713                 j->pld_slicw.bits.rly1 = 0;
6714                 j->pld_slicw.bits.rly2 = 0;
6715                 j->pld_slicw.bits.rly3 = 1;
6716                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6717                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6718
6719                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6720                 daa_set_mode(j, SOP_PU_CONVERSATION);
6721                 msleep(1000);
6722                 daa_int_read(j);
6723                 daa_set_mode(j, SOP_PU_RESET);
6724                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6725                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6726                         LED_SetState(0x4, j);
6727                         j->pld_slicw.bits.rly3 = 0;
6728                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6729                 } else {
6730                         j->flags.pots_correct = 1;
6731                         LED_SetState(0x8, j);
6732                         j->pld_slicw.bits.rly1 = 1;
6733                         j->pld_slicw.bits.rly2 = 0;
6734                         j->pld_slicw.bits.rly3 = 0;
6735                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6736                 }
6737         }
6738         j->pld_slicw.bits.rly3 = 0;
6739         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6740         daa_set_mode(j, SOP_PU_CONVERSATION);
6741         msleep(1000);
6742         daa_int_read(j);
6743         daa_set_mode(j, SOP_PU_RESET);
6744         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6745                 j->pstn_sleeptil = jiffies + (hertz / 4);
6746                 j->flags.pstn_present = 1;
6747         } else {
6748                 j->flags.pstn_present = 0;
6749         }
6750         if (j->flags.pstn_present) {
6751                 if (j->flags.pots_correct) {
6752                         LED_SetState(0xA, j);
6753                 } else {
6754                         LED_SetState(0x6, j);
6755                 }
6756         } else {
6757                 if (j->flags.pots_correct) {
6758                         LED_SetState(0x9, j);
6759                 } else {
6760                         LED_SetState(0x5, j);
6761                 }
6762         }
6763         j->flags.pstncheck = 0; /* Testing */
6764         return j->flags.pstn_present;
6765 }
6766
6767 static int ixj_selfprobe(IXJ *j)
6768 {
6769         unsigned short cmd;
6770         int cnt;
6771         BYTES bytes;
6772
6773         init_waitqueue_head(&j->poll_q);
6774         init_waitqueue_head(&j->read_q);
6775         init_waitqueue_head(&j->write_q);
6776
6777         while(atomic_read(&j->DSPWrite) > 0)
6778                 atomic_dec(&j->DSPWrite);
6779         if (ixjdebug & 0x0002)
6780                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6781         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6782
6783         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6784                 return -1;
6785 /* The read values of the SSR should be 0x00 for the IDLE command */
6786         if (j->ssr.low || j->ssr.high)
6787                 return -1;
6788         if (ixjdebug & 0x0002)
6789                 printk(KERN_INFO "Get Device ID Code\n");
6790         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6791                 return -1;
6792         j->dsp.low = j->ssr.low;
6793         j->dsp.high = j->ssr.high;
6794         if (ixjdebug & 0x0002)
6795                 printk(KERN_INFO "Get Device Version Code\n");
6796         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6797                 return -1;
6798         j->ver.low = j->ssr.low;
6799         j->ver.high = j->ssr.high;
6800         if (!j->cardtype) {
6801                 if (j->dsp.low == 0x21) {
6802                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6803                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6804 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6805                         bytes.low = inb_p(j->XILINXbase + 0x02);
6806                         if (bytes.low == bytes.high)    /*  Register is read only on */
6807                                 /*  Internet PhoneJack Lite */
6808                          {
6809                                 j->cardtype = QTI_PHONEJACK_LITE;
6810                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6811                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6812                                         return -1;
6813                                 }
6814                                 j->pld_slicw.pcib.e1 = 1;
6815                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6816                         } else {
6817                                 j->cardtype = QTI_LINEJACK;
6818
6819                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6820                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6821                                         return -1;
6822                                 }
6823                         }
6824                 } else if (j->dsp.low == 0x22) {
6825                         j->cardtype = QTI_PHONEJACK_PCI;
6826                         request_region(j->XILINXbase, 4, "ixj control");
6827                         j->pld_slicw.pcib.e1 = 1;
6828                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6829                 } else
6830                         j->cardtype = QTI_PHONEJACK;
6831         } else {
6832                 switch (j->cardtype) {
6833                 case QTI_PHONEJACK:
6834                         if (!j->dsp.low != 0x20) {
6835                                 j->dsp.high = 0x80;
6836                                 j->dsp.low = 0x20;
6837                                 ixj_WriteDSPCommand(0x3800, j);
6838                                 j->ver.low = j->ssr.low;
6839                                 j->ver.high = j->ssr.high;
6840                         }
6841                         break;
6842                 case QTI_LINEJACK:
6843                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6844                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6845                                 return -1;
6846                         }
6847                         break;
6848                 case QTI_PHONEJACK_LITE:
6849                 case QTI_PHONEJACK_PCI:
6850                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6851                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6852                                 return -1;
6853                         }
6854                         j->pld_slicw.pcib.e1 = 1;
6855                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6856                         break;
6857                 case QTI_PHONECARD:
6858                         break;
6859                 }
6860         }
6861         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6862                 if (ixjdebug & 0x0002)
6863                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6864                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6865                         return -1;
6866                 if (ixjdebug & 0x0002)
6867                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6868                 if (j->cardtype == QTI_PHONEJACK) {
6869                         cmd = 0x9FF2;
6870                 } else {
6871                         cmd = 0x9FF5;
6872                 }
6873                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6874                         return -1;
6875         } else {
6876                 if (set_base_frame(j, 30) != 30)
6877                         return -1;
6878                 if (ixjdebug & 0x0002)
6879                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6880                 if (j->cardtype == QTI_PHONECARD) {
6881                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6882                                 return -1;
6883                 }
6884                 if (j->cardtype == QTI_LINEJACK) {
6885                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6886                                 return -1;
6887                         if (ixjdebug & 0x0002)
6888                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6889                         j->pld_clock.byte = 0;
6890                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6891                 }
6892         }
6893
6894         if (j->dsp.low == 0x20) {
6895                 if (ixjdebug & 0x0002)
6896                         printk(KERN_INFO "Configure GPIO pins\n");
6897                 j->gpio.bytes.high = 0x09;
6898 /*  bytes.low = 0xEF;  0xF7 */
6899                 j->gpio.bits.gpio1 = 1;
6900                 j->gpio.bits.gpio2 = 1;
6901                 j->gpio.bits.gpio3 = 0;
6902                 j->gpio.bits.gpio4 = 1;
6903                 j->gpio.bits.gpio5 = 1;
6904                 j->gpio.bits.gpio6 = 1;
6905                 j->gpio.bits.gpio7 = 1;
6906                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6907                 if (ixjdebug & 0x0002)
6908                         printk(KERN_INFO "Enable SLIC\n");
6909                 j->gpio.bytes.high = 0x0B;
6910                 j->gpio.bytes.low = 0x00;
6911                 j->gpio.bits.gpio1 = 0;
6912                 j->gpio.bits.gpio2 = 1;
6913                 j->gpio.bits.gpio5 = 0;
6914                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6915                 j->port = PORT_POTS;
6916         } else {
6917                 if (j->cardtype == QTI_LINEJACK) {
6918                         LED_SetState(0x1, j);
6919                         msleep(100);
6920                         LED_SetState(0x2, j);
6921                         msleep(100);
6922                         LED_SetState(0x4, j);
6923                         msleep(100);
6924                         LED_SetState(0x8, j);
6925                         msleep(100);
6926                         LED_SetState(0x0, j);
6927                         daa_get_version(j);
6928                         if (ixjdebug & 0x0002)
6929                                 printk("Loading DAA Coefficients\n");
6930                         DAA_Coeff_US(j);
6931                         if (!ixj_daa_write(j)) {
6932                                 printk("DAA write failed on board %d\n", j->board);
6933                                 return -1;
6934                         }
6935                         if(!ixj_daa_cid_reset(j)) {
6936                                 printk("DAA CID reset failed on board %d\n", j->board);
6937                                 return -1;
6938                         }
6939                         j->flags.pots_correct = 0;
6940                         j->flags.pstn_present = 0;
6941                         ixj_linetest(j);
6942                         if (j->flags.pots_correct) {
6943                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6944
6945                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6946                                 j->pld_slicw.bits.rly1 = 1;
6947                                 j->pld_slicw.bits.spken = 1;
6948                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6949                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6950 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6951                                 j->port = PORT_POTS;
6952                         }
6953                         ixj_set_port(j, PORT_PSTN);
6954                         ixj_set_pots(j, 1);
6955                         if (ixjdebug & 0x0002)
6956                                 printk(KERN_INFO "Enable Mixer\n");
6957                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6958                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6959
6960                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6961                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6962
6963                         ixj_mixer(0x0480, j);   /*FM Left mute */
6964                         ixj_mixer(0x0580, j);   /*FM Right mute */
6965
6966                         ixj_mixer(0x0680, j);   /*CD Left mute */
6967                         ixj_mixer(0x0780, j);   /*CD Right mute */
6968
6969                         ixj_mixer(0x0880, j);   /*Line Left mute */
6970                         ixj_mixer(0x0980, j);   /*Line Right mute */
6971
6972                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6973                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6974
6975                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6976                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6977
6978                         ixj_mixer(0x0E80, j);   /*Mic mute */
6979
6980                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6981
6982                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6983                         ixj_mixer(0x110C, j);
6984
6985
6986                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6987                         ixj_mixer(0x1401, j);
6988
6989                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6990                         ixj_mixer(0x1501, j);
6991
6992                         ixj_mixer(0x1700, j);   /*Clock select */
6993
6994                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6995
6996                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6997
6998                         if (ixjdebug & 0x0002)
6999                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7000                         j->cadence_f[4].state = 0;
7001                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7002                         j->cadence_f[4].off1 = 0;
7003                         j->cadence_f[4].on2 = 0;
7004                         j->cadence_f[4].off2 = 0;
7005                         j->cadence_f[4].on3 = 0;
7006                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7007                         j->pstn_last_rmr = jiffies;
7008
7009                 } else {
7010                         if (j->cardtype == QTI_PHONECARD) {
7011                                 ixj_WriteDSPCommand(0xCF07, j);
7012                                 ixj_WriteDSPCommand(0x00B0, j);
7013                                 ixj_set_port(j, PORT_SPEAKER);
7014                         } else {
7015                                 ixj_set_port(j, PORT_POTS);
7016                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7017 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7018                         }
7019                 }
7020         }
7021
7022         j->intercom = -1;
7023         j->framesread = j->frameswritten = 0;
7024         j->read_wait = j->write_wait = 0;
7025         j->rxreadycheck = j->txreadycheck = 0;
7026
7027         /* initialise the DTMF prescale to a sensible value */
7028         if (j->cardtype == QTI_LINEJACK) {
7029                 set_dtmf_prescale(j, 0x10);
7030         } else {
7031                 set_dtmf_prescale(j, 0x40);
7032         }
7033         set_play_volume(j, 0x100);
7034         set_rec_volume(j, 0x100);
7035
7036         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7037                 return -1;
7038 /* The read values of the SSR should be 0x00 for the IDLE command */
7039         if (j->ssr.low || j->ssr.high)
7040                 return -1;
7041
7042         if (ixjdebug & 0x0002)
7043                 printk(KERN_INFO "Enable Line Monitor\n");
7044
7045         if (ixjdebug & 0x0002)
7046                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7047
7048         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7049                 return -1;
7050
7051         if (ixjdebug & 0x002)
7052                 printk(KERN_INFO "Enable DTMF Detectors\n");
7053
7054         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7055                 return -1;
7056
7057         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7058                 return -1;
7059
7060         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7061
7062         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7063
7064         j->ex.bits.dtmf_ready = 0;
7065         j->dtmf_state = 0;
7066         j->dtmf_wp = j->dtmf_rp = 0;
7067         j->rec_mode = j->play_mode = -1;
7068         j->flags.ringing = 0;
7069         j->maxrings = MAXRINGS;
7070         j->ring_cadence = USA_RING_CADENCE;
7071         j->drybuffer = 0;
7072         j->winktime = 320;
7073         j->flags.dtmf_oob = 0;
7074         for (cnt = 0; cnt < 4; cnt++)
7075                 j->cadence_f[cnt].enable = 0;
7076         /* must be a device on the specified address */
7077         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7078
7079         /* Set up the default signals for events */
7080         for (cnt = 0; cnt < 35; cnt++)
7081                 j->ixj_signals[cnt] = SIGIO;
7082
7083         /* Set the excetion signal enable flags */
7084         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7085         j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
7086         j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
7087 #ifdef IXJ_DYN_ALLOC
7088         j->fskdata = NULL;
7089 #endif
7090         j->fskdcnt = 0;
7091         j->cidcw_wait = 0;
7092
7093         /* Register with the Telephony for Linux subsystem */
7094         j->p.f_op = &ixj_fops;
7095         j->p.open = ixj_open;
7096         j->p.board = j->board;
7097         phone_register_device(&j->p, PHONE_UNIT_ANY);
7098
7099         ixj_init_timer(j);
7100         ixj_add_timer(j);
7101         return 0;
7102 }
7103
7104 /*
7105  *      Exported service for pcmcia card handling
7106  */
7107
7108 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7109 {
7110         IXJ *j = ixj_alloc();
7111
7112         j->board = 0;
7113
7114         j->DSPbase = dsp;
7115         j->XILINXbase = xilinx;
7116         j->cardtype = QTI_PHONECARD;
7117         ixj_selfprobe(j);
7118         return j;
7119 }
7120
7121 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7122
7123 static int ixj_get_status_proc(char *buf)
7124 {
7125         int len;
7126         int cnt;
7127         IXJ *j;
7128         len = 0;
7129         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7130         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7131         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7132         len += sprintf(buf + len, "\nUsing old telephony API");
7133         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7134
7135         for (cnt = 0; cnt < IXJMAX; cnt++) {
7136                 j = get_ixj(cnt);
7137                 if(j==NULL)
7138                         continue;
7139                 if (j->DSPbase) {
7140                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7141                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7142                         if (j->cardtype != QTI_PHONEJACK)
7143                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7144                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7145                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7146                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7147                         switch (j->cardtype) {
7148                         case (QTI_PHONEJACK):
7149                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7150                                 break;
7151                         case (QTI_LINEJACK):
7152                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7153                                 if (j->flags.g729_loaded)
7154                                         len += sprintf(buf + len, " w/G.729 A/B");
7155                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7156                                 break;
7157                         case (QTI_PHONEJACK_LITE):
7158                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7159                                 if (j->flags.g729_loaded)
7160                                         len += sprintf(buf + len, " w/G.729 A/B");
7161                                 break;
7162                         case (QTI_PHONEJACK_PCI):
7163                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7164                                 if (j->flags.g729_loaded)
7165                                         len += sprintf(buf + len, " w/G.729 A/B");
7166                                 break;
7167                         case (QTI_PHONECARD):
7168                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7169                                 if (j->flags.g729_loaded)
7170                                         len += sprintf(buf + len, " w/G.729 A/B");
7171                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7172                                 if (!j->pccr1.bits.drf)
7173                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7174                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7175                                 break;
7176                         default:
7177                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7178                                 break;
7179                         }
7180                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7181                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7182                         add_caps(j);
7183                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7184                         if (j->dsp.low != 0x20)
7185                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7186                         if (j->flags.cidsent)
7187                                 len += sprintf(buf + len, "\nCaller ID data sent");
7188                         else
7189                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7190
7191                         len += sprintf(buf + len, "\nPlay CODEC ");
7192                         switch (j->play_codec) {
7193                         case G723_63:
7194                                 len += sprintf(buf + len, "G.723.1 6.3");
7195                                 break;
7196                         case G723_53:
7197                                 len += sprintf(buf + len, "G.723.1 5.3");
7198                                 break;
7199                         case TS85:
7200                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7201                                 break;
7202                         case TS48:
7203                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7204                                 break;
7205                         case TS41:
7206                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7207                                 break;
7208                         case G728:
7209                                 len += sprintf(buf + len, "G.728");
7210                                 break;
7211                         case G729:
7212                                 len += sprintf(buf + len, "G.729");
7213                                 break;
7214                         case G729B:
7215                                 len += sprintf(buf + len, "G.729B");
7216                                 break;
7217                         case ULAW:
7218                                 len += sprintf(buf + len, "uLaw");
7219                                 break;
7220                         case ALAW:
7221                                 len += sprintf(buf + len, "aLaw");
7222                                 break;
7223                         case LINEAR16:
7224                                 len += sprintf(buf + len, "16 bit Linear");
7225                                 break;
7226                         case LINEAR8:
7227                                 len += sprintf(buf + len, "8 bit Linear");
7228                                 break;
7229                         case WSS:
7230                                 len += sprintf(buf + len, "Windows Sound System");
7231                                 break;
7232                         default:
7233                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7234                                 break;
7235                         }
7236                         len += sprintf(buf + len, "\nRecord CODEC ");
7237                         switch (j->rec_codec) {
7238                         case G723_63:
7239                                 len += sprintf(buf + len, "G.723.1 6.3");
7240                                 break;
7241                         case G723_53:
7242                                 len += sprintf(buf + len, "G.723.1 5.3");
7243                                 break;
7244                         case TS85:
7245                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7246                                 break;
7247                         case TS48:
7248                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7249                                 break;
7250                         case TS41:
7251                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7252                                 break;
7253                         case G728:
7254                                 len += sprintf(buf + len, "G.728");
7255                                 break;
7256                         case G729:
7257                                 len += sprintf(buf + len, "G.729");
7258                                 break;
7259                         case G729B:
7260                                 len += sprintf(buf + len, "G.729B");
7261                                 break;
7262                         case ULAW:
7263                                 len += sprintf(buf + len, "uLaw");
7264                                 break;
7265                         case ALAW:
7266                                 len += sprintf(buf + len, "aLaw");
7267                                 break;
7268                         case LINEAR16:
7269                                 len += sprintf(buf + len, "16 bit Linear");
7270                                 break;
7271                         case LINEAR8:
7272                                 len += sprintf(buf + len, "8 bit Linear");
7273                                 break;
7274                         case WSS:
7275                                 len += sprintf(buf + len, "Windows Sound System");
7276                                 break;
7277                         default:
7278                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7279                                 break;
7280                         }
7281                         len += sprintf(buf + len, "\nAEC ");
7282                         switch (j->aec_level) {
7283                         case AEC_OFF:
7284                                 len += sprintf(buf + len, "Off");
7285                                 break;
7286                         case AEC_LOW:
7287                                 len += sprintf(buf + len, "Low");
7288                                 break;
7289                         case AEC_MED:
7290                                 len += sprintf(buf + len, "Med");
7291                                 break;
7292                         case AEC_HIGH:
7293                                 len += sprintf(buf + len, "High");
7294                                 break;
7295                         case AEC_AUTO:
7296                                 len += sprintf(buf + len, "Auto");
7297                                 break;
7298                         case AEC_AGC:
7299                                 len += sprintf(buf + len, "AEC/AGC");
7300                                 break;
7301                         default:
7302                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7303                                 break;
7304                         }
7305
7306                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7307                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7308                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7309
7310                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7311
7312                         if (j->cardtype == QTI_LINEJACK) {
7313                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7314                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7315                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7316                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7317                                 switch (j->daa_mode) {
7318                                 case SOP_PU_SLEEP:
7319                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7320                                         break;
7321                                 case SOP_PU_RINGING:
7322                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7323                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7324                                         break;
7325                                 case SOP_PU_CONVERSATION:
7326                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7327                                         break;
7328                                 case SOP_PU_PULSEDIALING:
7329                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7330                                         break;
7331                                 }
7332                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7333                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7334                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7335                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7336                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7337                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7338                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7339                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7340                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7341                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7342                         }
7343                         switch (j->port) {
7344                         case PORT_POTS:
7345                                 len += sprintf(buf + len, "\nPort POTS");
7346                                 break;
7347                         case PORT_PSTN:
7348                                 len += sprintf(buf + len, "\nPort PSTN");
7349                                 break;
7350                         case PORT_SPEAKER:
7351                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7352                                 break;
7353                         case PORT_HANDSET:
7354                                 len += sprintf(buf + len, "\nPort HANDSET");
7355                                 break;
7356                         }
7357                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7358                                 len += sprintf(buf + len, "\nSLIC state ");
7359                                 switch (SLIC_GetState(j)) {
7360                                 case PLD_SLIC_STATE_OC:
7361                                         len += sprintf(buf + len, "OC");
7362                                         break;
7363                                 case PLD_SLIC_STATE_RINGING:
7364                                         len += sprintf(buf + len, "RINGING");
7365                                         break;
7366                                 case PLD_SLIC_STATE_ACTIVE:
7367                                         len += sprintf(buf + len, "ACTIVE");
7368                                         break;
7369                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7370                                         len += sprintf(buf + len, "OHT");
7371                                         break;
7372                                 case PLD_SLIC_STATE_TIPOPEN:
7373                                         len += sprintf(buf + len, "TIPOPEN");
7374                                         break;
7375                                 case PLD_SLIC_STATE_STANDBY:
7376                                         len += sprintf(buf + len, "STANDBY");
7377                                         break;
7378                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7379                                         len += sprintf(buf + len, "APR");
7380                                         break;
7381                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7382                                         len += sprintf(buf + len, "OHTPR");
7383                                         break;
7384                                 default:
7385                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7386                                         break;
7387                                 }
7388                         }
7389                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7390                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7391 #ifdef PERFMON_STATS
7392                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7393                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7394                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7395                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7396                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7397                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7398                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7399                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7400                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7401                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7402                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7403                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7404                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7405                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7406
7407 #endif
7408                         len += sprintf(buf + len, "\n");
7409                 }
7410         }
7411         return len;
7412 }
7413
7414 static int ixj_read_proc(char *page, char **start, off_t off,
7415                               int count, int *eof, void *data)
7416 {
7417         int len = ixj_get_status_proc(page);
7418         if (len <= off+count) *eof = 1;
7419         *start = page + off;
7420         len -= off;
7421         if (len>count) len = count;
7422         if (len<0) len = 0;
7423         return len;
7424 }
7425
7426
7427 static void cleanup(void)
7428 {
7429         int cnt;
7430         IXJ *j;
7431
7432         for (cnt = 0; cnt < IXJMAX; cnt++) {
7433                 j = get_ixj(cnt);
7434                 if(j != NULL && j->DSPbase) {
7435                         if (ixjdebug & 0x0002)
7436                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7437                         del_timer(&j->timer);
7438                         if (j->cardtype == QTI_LINEJACK) {
7439                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7440
7441                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7442                                 j->pld_slicw.bits.rly1 = 0;
7443                                 j->pld_slicw.bits.rly2 = 0;
7444                                 j->pld_slicw.bits.rly3 = 0;
7445                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7446                                 LED_SetState(0x0, j);
7447                                 if (ixjdebug & 0x0002)
7448                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7449                                 release_region(j->XILINXbase, 8);
7450                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7451                                 if (ixjdebug & 0x0002)
7452                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7453                                 release_region(j->XILINXbase, 4);
7454                         }
7455                         kfree(j->read_buffer);
7456                         kfree(j->write_buffer);
7457                         if (j->dev)
7458                                 pnp_device_detach(j->dev);
7459                         if (ixjdebug & 0x0002)
7460                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7461                         phone_unregister_device(&j->p);
7462                         if (ixjdebug & 0x0002)
7463                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7464                         release_region(j->DSPbase, 16);
7465 #ifdef IXJ_DYN_ALLOC
7466                         if (ixjdebug & 0x0002)
7467                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7468                         kfree(j);
7469                         ixj[cnt] = NULL;
7470 #endif
7471                 }
7472         }
7473         if (ixjdebug & 0x0002)
7474                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7475         remove_proc_entry ("ixj", NULL);
7476 }
7477
7478 /* Typedefs */
7479 typedef struct {
7480         BYTE length;
7481         DWORD bits;
7482 } DATABLOCK;
7483
7484 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7485 {
7486         lastLCC = lastLCC & 0xfb;
7487         lastLCC = lastLCC | (byData ? 4 : 0);
7488         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7489
7490         mdelay(1);
7491         lastLCC = lastLCC | 0x01;
7492         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7493
7494         byData = byData << 1;
7495         lastLCC = lastLCC & 0xfe;
7496         mdelay(1);
7497         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7498
7499 }
7500
7501 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7502 {
7503         mdelay(1);
7504         lastLCC = lastLCC | 0x01;
7505         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7506
7507         lastLCC = lastLCC & 0xfe;
7508         mdelay(1);
7509         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7510
7511         return ((inb(wEEPROMAddress) >> 3) & 1);
7512 }
7513
7514 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7515 {
7516         BYTE lastLCC;
7517         WORD wEEPROMAddress = wAddress + 3;
7518         DWORD i;
7519         BYTE byResult;
7520         *pwResult = 0;
7521         lastLCC = inb(wEEPROMAddress);
7522         lastLCC = lastLCC | 0x02;
7523         lastLCC = lastLCC & 0xfe;
7524         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7525
7526         mdelay(1);              /* delay */
7527
7528         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7529         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7530         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7531         for (i = 0; i < 8; i++) {
7532                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7533                 wLoc <<= 1;
7534         }
7535
7536         for (i = 0; i < 16; i++) {
7537                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7538                 *pwResult = (*pwResult << 1) | byResult;
7539         }
7540
7541         mdelay(1);              /* another delay */
7542
7543         lastLCC = lastLCC & 0xfd;
7544         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7545
7546         return 0;
7547 }
7548
7549 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7550 {
7551         WORD wLo, wHi;
7552         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7553                 return 0;
7554         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7555                 return 0;
7556         return (((DWORD) wHi << 16) | wLo);
7557 }
7558
7559 static int dspio[IXJMAX + 1] =
7560 {
7561         0,
7562 };
7563 static int xio[IXJMAX + 1] =
7564 {
7565         0,
7566 };
7567
7568 module_param_array(dspio, int, NULL, 0);
7569 module_param_array(xio, int, NULL, 0);
7570 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7571 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7572 MODULE_LICENSE("GPL");
7573
7574 static void __exit ixj_exit(void)
7575 {
7576         cleanup();
7577 }
7578
7579 static IXJ *new_ixj(unsigned long port)
7580 {
7581         IXJ *res;
7582         if (!request_region(port, 16, "ixj DSP")) {
7583                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7584                 return NULL;
7585         }
7586         res = ixj_alloc();
7587         if (!res) {
7588                 release_region(port, 16);
7589                 printk(KERN_INFO "ixj: out of memory\n");
7590                 return NULL;
7591         }
7592         res->DSPbase = port;
7593         return res;
7594 }
7595
7596 static int __init ixj_probe_isapnp(int *cnt)
7597 {
7598         int probe = 0;
7599         int func = 0x110;
7600         struct pnp_dev *dev = NULL, *old_dev = NULL;
7601
7602         while (1) {
7603                 do {
7604                         IXJ *j;
7605                         int result;
7606
7607                         old_dev = dev;
7608                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7609                                          ISAPNP_FUNCTION(func), old_dev);
7610                         if (!dev || !dev->card)
7611                                 break;
7612                         result = pnp_device_attach(dev);
7613                         if (result < 0) {
7614                                 printk("pnp attach failed %d \n", result);
7615                                 break;
7616                         }
7617                         if (pnp_activate_dev(dev) < 0) {
7618                                 printk("pnp activate failed (out of resources?)\n");
7619                                 pnp_device_detach(dev);
7620                                 return -ENOMEM;
7621                         }
7622
7623                         if (!pnp_port_valid(dev, 0)) {
7624                                 pnp_device_detach(dev);
7625                                 return -ENODEV;
7626                         }
7627
7628                         j = new_ixj(pnp_port_start(dev, 0));
7629                         if (!j)
7630                                 break;
7631
7632                         if (func != 0x110)
7633                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7634
7635                         switch (func) {
7636                         case (0x110):
7637                                 j->cardtype = QTI_PHONEJACK;
7638                                 break;
7639                         case (0x310):
7640                                 j->cardtype = QTI_LINEJACK;
7641                                 break;
7642                         case (0x410):
7643                                 j->cardtype = QTI_PHONEJACK_LITE;
7644                                 break;
7645                         }
7646                         j->board = *cnt;
7647                         probe = ixj_selfprobe(j);
7648                         if(!probe) {
7649                                 j->serial = dev->card->serial;
7650                                 j->dev = dev;
7651                                 switch (func) {
7652                                 case 0x110:
7653                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7654                                         break;
7655                                 case 0x310:
7656                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7657                                         break;
7658                                 case 0x410:
7659                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7660                                         break;
7661                                 }
7662                         }
7663                         ++*cnt;
7664                 } while (dev);
7665                 if (func == 0x410)
7666                         break;
7667                 if (func == 0x310)
7668                         func = 0x410;
7669                 if (func == 0x110)
7670                         func = 0x310;
7671                 dev = NULL;
7672         }
7673         return probe;
7674 }
7675
7676 static int __init ixj_probe_isa(int *cnt)
7677 {
7678         int i, probe;
7679
7680         /* Use passed parameters for older kernels without PnP */
7681         for (i = 0; i < IXJMAX; i++) {
7682                 if (dspio[i]) {
7683                         IXJ *j = new_ixj(dspio[i]);
7684
7685                         if (!j)
7686                                 break;
7687
7688                         j->XILINXbase = xio[i];
7689                         j->cardtype = 0;
7690
7691                         j->board = *cnt;
7692                         probe = ixj_selfprobe(j);
7693                         j->dev = NULL;
7694                         ++*cnt;
7695                 }
7696         }
7697         return 0;
7698 }
7699
7700 static int __init ixj_probe_pci(int *cnt)
7701 {
7702         struct pci_dev *pci = NULL;
7703         int i, probe = 0;
7704         IXJ *j = NULL;
7705
7706         for (i = 0; i < IXJMAX - *cnt; i++) {
7707                 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7708                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
7709                 if (!pci)
7710                         break;
7711
7712                 if (pci_enable_device(pci))
7713                         break;
7714                 j = new_ixj(pci_resource_start(pci, 0));
7715                 if (!j)
7716                         break;
7717
7718                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7719                 j->XILINXbase = j->DSPbase + 0x10;
7720                 j->cardtype = QTI_PHONEJACK_PCI;
7721                 j->board = *cnt;
7722                 probe = ixj_selfprobe(j);
7723                 if (!probe)
7724                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7725                 ++*cnt;
7726         }
7727         pci_dev_put(pci);
7728         return probe;
7729 }
7730
7731 static int __init ixj_init(void)
7732 {
7733         int cnt = 0;
7734         int probe = 0;
7735
7736         cnt = 0;
7737
7738         /* These might be no-ops, see above. */
7739         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7740                 return probe;
7741         }
7742         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7743                 return probe;
7744         }
7745         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7746                 return probe;
7747         }
7748         printk(KERN_INFO "ixj driver initialized.\n");
7749         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7750         return probe;
7751 }
7752
7753 module_init(ixj_init);
7754 module_exit(ixj_exit);
7755
7756 static void DAA_Coeff_US(IXJ *j)
7757 {
7758         int i;
7759
7760         j->daa_country = DAA_US;
7761         /*----------------------------------------------- */
7762         /* CAO */
7763         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7764                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7765         }
7766
7767 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7768         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7769         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7771         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7772         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7773         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7774         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7775         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7776 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7777         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7778         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7779         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7780         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7781         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7782         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7783         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7784         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7785 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7786         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7787         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7789         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7790         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7791         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7792         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7793         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7794 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7795         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7796         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7797         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7798         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7799         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7800         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7801         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7802         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7803 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7804         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7805         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7806         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7807         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7808 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7809         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7810         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7811         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7812         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7813 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7817         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7818         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7820         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7821         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7822 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7824         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7826         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7827         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7828         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7829         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7830         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7831 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7832         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7833         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7834         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7835         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7836         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7837         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7838         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7839         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7840 /* ;  (10K, 0.68uF) */
7841         /*  */
7842         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7843         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7844         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7846         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7847         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7848         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7849         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7850         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7851         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7852         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7853         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7854         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7855         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7856         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7857         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7858         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7859         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7860
7861         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7862         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7863         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7864         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7865         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7866
7867         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7868 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7869 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7871 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7872 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7874 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7875 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7876         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7877 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7878 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7879 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7880 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7881 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7882 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7883 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7884 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7885 /* */
7886         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7887 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7888 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7889 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7890 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7891
7892         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7893         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7894         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7896         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7897         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7898         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7899         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7900         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7901 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7902         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7903         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7904         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7905         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7906         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7907         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7908         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7909         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7910 /*  */
7911         /* ;CR Registers */
7912         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7913         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7914 /* Config. Reg. 1 (dialing)       (cr1):05 */
7915         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7916 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7917         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7918 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7919         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7920 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7921         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7922         /* Config. Reg. 5 (Version)       (cr5):02 */
7923         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7924         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7925         /*  */
7926         /* ;xr Registers */
7927         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7928
7929         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7930         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7931
7932         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7933 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7934         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7935 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7936         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7937         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7938
7939         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7940 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7941         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7942 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7943         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7944 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7945         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7946         /*  */
7947         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7948         /*                                       12,33,5A,C3 ;  770 Hz   */
7949         /*                                       13,3C,5B,32 ;  852 Hz   */
7950         /*                                       1D,1B,5C,CC ;  941 Hz   */
7951
7952         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7953         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7954         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7955         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7956 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7957         /*                                       EC,1D,52,22 ;  1336 Hz   */
7958         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7959         /*                                       9B,3B,51,25 ;  1633 Hz   */
7960         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7961         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7962         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7963         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7964 }
7965
7966 static void DAA_Coeff_UK(IXJ *j)
7967 {
7968         int i;
7969
7970         j->daa_country = DAA_UK;
7971         /*----------------------------------------------- */
7972         /* CAO */
7973         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7974                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7975         }
7976
7977 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7978         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7979         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7981         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7982         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7983         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7984         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7985         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7986 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7987         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7988         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7989         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7990         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7991         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7992         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7993         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7994         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7995 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7996         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7997         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7999         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8000         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8001         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8002         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8003         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8004 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8005         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8006         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8007         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8008         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8009         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8010         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8011         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8012         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8013 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8014         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8015         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8016         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8017         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8018 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8019         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8020         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8021         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8022         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8023 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8027         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8028         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8030         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8031         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8032 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8034         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8036         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8037         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8038         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8039         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8040         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8041 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8042         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8043         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8044         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8045         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8046         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8047         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8048         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8049         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8050 /* ; idle */
8051         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8052         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8053         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8055         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8056         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8057         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8058         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8059         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8060 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8061         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8062         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8063         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8064         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8065         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8066         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8067         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8068         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8069 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8070         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8071         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8072         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8073         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8074 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8075         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8076         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8078         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8079         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8080         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8081         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8082         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8083 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8084         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8085         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8086         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8087         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8088         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8089         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8090         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8091         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8092 /* ;CR Registers */
8093         /* Config. Reg. 0 (filters)        (cr0):FF */
8094         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8095 /* Config. Reg. 1 (dialing)        (cr1):05 */
8096         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8097 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8098         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8099 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8100         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8101 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8102         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8103         /* Config. Reg. 5 (Version)        (cr5):02 */
8104         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8105         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8106         /* ;xr Registers */
8107         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8108
8109         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8110         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8111
8112         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8113         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8114
8115         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8116 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8117         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8118 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8119         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8120 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8121         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8122 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8123         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8124 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8125         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8126         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8127         /*                                       12,33,5A,C3    ;  770 Hz   */
8128         /*                                       13,3C,5B,32    ;  852 Hz   */
8129         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8130
8131         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8132         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8133         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8134         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8135 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8136         /*                                       EC,1D,52,22    ;  1336 Hz   */
8137         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8138         /*                                       9B,3B,51,25    ;  1633 Hz   */
8139         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8140         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8141         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8142         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8143 }
8144
8145
8146 static void DAA_Coeff_France(IXJ *j)
8147 {
8148         int i;
8149
8150         j->daa_country = DAA_FRANCE;
8151         /*----------------------------------------------- */
8152         /* CAO */
8153         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8154                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8155         }
8156
8157 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8158         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8159         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8161         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8162         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8163         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8164         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8165         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8166 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8167         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8168         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8169         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8170         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8171         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8172         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8173         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8174         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8175 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8176         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8177         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8179         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8180         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8181         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8182         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8183         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8184 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8185         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8186         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8187         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8188         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8189         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8190         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8191         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8192         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8193 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8194         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8195         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8196         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8197         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8198 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8199         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8200         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8201         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8202         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8203 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8207         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8208         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8210         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8211         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8212 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8214         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8216         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8217         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8218         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8219         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8220         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8221 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8222         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8223         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8224         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8225         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8226         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8227         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8228         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8229         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8230 /* ; idle */
8231         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8232         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8233         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8235         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8236         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8237         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8238         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8239         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8240 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8241         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8242         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8243         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8244         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8245         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8246         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8247         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8248         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8249 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8250         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8251         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8252         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8253         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8254 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8255         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8256         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8258         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8259         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8260         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8261         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8262         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8263 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8264         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8265         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8266         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8267         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8268         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8269         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8270         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8271         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8272 /* ;CR Registers */
8273         /* Config. Reg. 0 (filters)        (cr0):FF */
8274         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8275 /* Config. Reg. 1 (dialing)        (cr1):05 */
8276         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8277 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8278         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8279 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8280         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8281 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8282         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8283         /* Config. Reg. 5 (Version)        (cr5):02 */
8284         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8285         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8286         /* ;xr Registers */
8287         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8288
8289         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8290         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8291
8292         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8293         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8294
8295         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8296 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8297         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8298 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8299         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8300 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8301         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8302 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8303         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8304 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8305         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8306         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8307         /*                                       12,33,5A,C3    ;  770 Hz   */
8308         /*                                       13,3C,5B,32    ;  852 Hz   */
8309         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8310
8311         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8312         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8313         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8314         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8315 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8316         /*                                       EC,1D,52,22    ;  1336 Hz   */
8317         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8318         /*                                       9B,3B,51,25    ;  1633 Hz   */
8319         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8320         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8321         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8322         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8323 }
8324
8325
8326 static void DAA_Coeff_Germany(IXJ *j)
8327 {
8328         int i;
8329
8330         j->daa_country = DAA_GERMANY;
8331         /*----------------------------------------------- */
8332         /* CAO */
8333         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8334                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8335         }
8336
8337 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8338         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8339         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8341         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8342         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8343         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8344         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8345         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8346 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8347         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8348         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8349         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8350         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8351         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8352         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8353         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8354         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8355 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8356         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8357         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8359         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8360         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8361         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8362         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8363         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8364 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8365         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8366         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8367         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8368         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8369         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8370         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8371         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8372         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8373 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8374         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8375         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8376         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8377         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8378 /* Bytes for AR-filter        (09): 72,42,13,4B */
8379         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8380         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8381         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8382         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8383 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8387         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8388         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8390         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8391         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8392 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8394         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8396         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8397         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8398         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8399         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8400         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8401 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8402         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8403         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8404         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8405         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8406         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8407         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8408         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8409         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8410 /* ;  (10K, 0.68uF) */
8411         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8412         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8413         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8415         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8416         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8417         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8418         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8419         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8420 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8421         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8422         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8423         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8424         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8425         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8426         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8427         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8428         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8429 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8430         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8431         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8432         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8433         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8434 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8435         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8436         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8438         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8439         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8440         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8441         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8442         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8443 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8444         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8445         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8446         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8447         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8448         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8449         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8450         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8451         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8452 /* ;CR Registers */
8453         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8454         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8455 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8456         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8457 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8458         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8459 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8460         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8461 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8462         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8463         /* Config. Reg. 5 (Version)        (cr5):02 */
8464         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8465         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8466         /* ;xr Registers */
8467         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8468
8469         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8470         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8471
8472         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8473         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8474
8475         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8476 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8477         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8478 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8479         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8480 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8481         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8482 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8483         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8484 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8485         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8486         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8487         /*                                       12,33,5A,C3    ;  770 Hz   */
8488         /*                                       13,3C,5B,32    ;  852 Hz   */
8489         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8490
8491         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8492         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8493         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8494         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8495 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8496         /*                                       EC,1D,52,22    ;  1336 Hz   */
8497         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8498         /*                                       9B,3B,51,25    ;  1633 Hz   */
8499         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8500         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8501         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8502         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8503 }
8504
8505
8506 static void DAA_Coeff_Australia(IXJ *j)
8507 {
8508         int i;
8509
8510         j->daa_country = DAA_AUSTRALIA;
8511         /*----------------------------------------------- */
8512         /* CAO */
8513         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8514                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8515         }
8516
8517 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8518         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8519         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8521         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8522         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8523         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8524         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8525         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8526 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8527         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8528         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8529         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8530         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8531         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8532         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8533         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8534         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8535 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8536         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8537         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8539         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8540         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8541         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8542         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8543         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8544 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8545         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8546         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8547         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8548         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8549         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8550         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8551         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8552         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8553 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8554         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8555         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8556         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8557         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8558 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8559         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8560         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8561         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8562         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8563 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8567         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8568         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8570         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8571         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8572 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8574         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8576         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8577         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8578         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8579         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8580         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8581 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8582         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8583         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8584         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8585         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8586         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8587         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8588         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8589         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8590 /* ;  idle */
8591         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8592         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8593         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8595         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8596         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8597         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8598         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8599         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8600 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8601         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8602         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8603         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8604         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8605         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8606         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8607         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8608         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8609 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8610         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8611         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8612         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8613         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8614 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8615         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8616         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8618         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8619         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8620         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8621         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8622         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8623 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8624         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8625         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8626         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8627         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8628         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8629         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8630         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8631         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8632 /* ;CR Registers */
8633         /* Config. Reg. 0 (filters)        (cr0):FF */
8634         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8635 /* Config. Reg. 1 (dialing)        (cr1):05 */
8636         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8637 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8638         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8639 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8640         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8641 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8642         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8643         /* Config. Reg. 5 (Version)        (cr5):02 */
8644         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8645         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8646         /* ;xr Registers */
8647         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8648
8649         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8650         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8651
8652         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8653         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8654
8655         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8656 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8657         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8658 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8659         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8660 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8661         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8662 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8663         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8664 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8665         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8666
8667         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8668         /*                                       12,33,5A,C3    ;  770 Hz   */
8669         /*                                       13,3C,5B,32    ;  852 Hz   */
8670         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8671         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8672         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8673         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8674         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8675
8676         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8677         /*                                       EC,1D,52,22    ;  1336 Hz   */
8678         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8679         /*                                       9B,3B,51,25    ;  1633 Hz   */
8680         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8681         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8682         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8683         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8684 }
8685
8686 static void DAA_Coeff_Japan(IXJ *j)
8687 {
8688         int i;
8689
8690         j->daa_country = DAA_JAPAN;
8691         /*----------------------------------------------- */
8692         /* CAO */
8693         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8694                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8695         }
8696
8697 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8698         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8699         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8701         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8702         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8703         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8704         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8705         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8706 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8707         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8708         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8709         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8710         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8711         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8712         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8713         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8714         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8715 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8716         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8717         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8719         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8720         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8721         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8722         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8723         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8724 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8725         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8726         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8727         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8728         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8729         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8730         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8731         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8732         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8733 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8734         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8735         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8736         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8737         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8738 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8739         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8740         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8741         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8742         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8743 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8747         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8748         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8750         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8751         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8752 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8754         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8756         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8757         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8758         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8759         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8760         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8761 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8762         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8763         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8764         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8765         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8766         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8767         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8768         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8769         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8770 /* ;  idle */
8771         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8772         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8773         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8775         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8776         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8777         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8778         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8779         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8780 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8781         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8782         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8783         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8784         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8785         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8786         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8787         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8788         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8789 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8790         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8791         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8792         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8793         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8794 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8795         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8796         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8798         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8799         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8800         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8801         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8802         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8803 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8804         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8805         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8806         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8807         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8808         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8809         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8810         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8811         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8812 /* ;CR Registers */
8813         /* Config. Reg. 0 (filters)        (cr0):FF */
8814         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8815 /* Config. Reg. 1 (dialing)        (cr1):05 */
8816         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8817 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8818         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8819 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8820         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8821 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8822         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8823         /* Config. Reg. 5 (Version)        (cr5):02 */
8824         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8825         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8826         /* ;xr Registers */
8827         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8828
8829         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8830         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8831
8832         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8833         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8834
8835         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8836 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8837         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8838 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8839         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8840 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8841         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8842 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8843         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8844 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8845         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8846         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8847         /*                                       12,33,5A,C3    ;  770 Hz   */
8848         /*                                       13,3C,5B,32    ;  852 Hz   */
8849         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8850
8851         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8852         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8853         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8854         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8855 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8856         /*                                       EC,1D,52,22    ;  1336 Hz   */
8857         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8858         /*                                       9B,3B,51,25    ;  1633 Hz   */
8859         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8860         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8861         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8862         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8863 }
8864
8865 static s16 tone_table[][19] =
8866 {
8867         {                       /* f20_50[] 11 */
8868                 32538,          /* A1 = 1.985962 */
8869                  -32325,        /* A2 = -0.986511 */
8870                  -343,          /* B2 = -0.010493 */
8871                  0,             /* B1 = 0 */
8872                  343,           /* B0 = 0.010493 */
8873                  32619,         /* A1 = 1.990906 */
8874                  -32520,        /* A2 = -0.992462 */
8875                  19179,         /* B2 = 0.585327 */
8876                  -19178,        /* B1 = -1.170593 */
8877                  19179,         /* B0 = 0.585327 */
8878                  32723,         /* A1 = 1.997314 */
8879                  -32686,        /* A2 = -0.997528 */
8880                  9973,          /* B2 = 0.304352 */
8881                  -9955,         /* B1 = -0.607605 */
8882                  9973,          /* B0 = 0.304352 */
8883                  7,             /* Internal filter scaling */
8884                  159,           /* Minimum in-band energy threshold */
8885                  21,            /* 21/32 in-band to broad-band ratio */
8886                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8887         },
8888         {                       /* f133_200[] 12 */
8889                 32072,          /* A1 = 1.95752 */
8890                  -31896,        /* A2 = -0.973419 */
8891                  -435,          /* B2 = -0.013294 */
8892                  0,             /* B1 = 0 */
8893                  435,           /* B0 = 0.013294 */
8894                  32188,         /* A1 = 1.9646 */
8895                  -32400,        /* A2 = -0.98877 */
8896                  15139,         /* B2 = 0.462036 */
8897                  -14882,        /* B1 = -0.908356 */
8898                  15139,         /* B0 = 0.462036 */
8899                  32473,         /* A1 = 1.981995 */
8900                  -32524,        /* A2 = -0.992584 */
8901                  23200,         /* B2 = 0.708008 */
8902                  -23113,        /* B1 = -1.410706 */
8903                  23200,         /* B0 = 0.708008 */
8904                  7,             /* Internal filter scaling */
8905                  159,           /* Minimum in-band energy threshold */
8906                  21,            /* 21/32 in-band to broad-band ratio */
8907                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8908         },
8909         {                       /* f300 13 */
8910                 31769,          /* A1 = -1.939026 */
8911                  -32584,        /* A2 = 0.994385 */
8912                  -475,          /* B2 = -0.014522 */
8913                  0,             /* B1 = 0.000000 */
8914                  475,           /* B0 = 0.014522 */
8915                  31789,         /* A1 = -1.940247 */
8916                  -32679,        /* A2 = 0.997284 */
8917                  17280,         /* B2 = 0.527344 */
8918                  -16865,        /* B1 = -1.029358 */
8919                  17280,         /* B0 = 0.527344 */
8920                  31841,         /* A1 = -1.943481 */
8921                  -32681,        /* A2 = 0.997345 */
8922                  543,           /* B2 = 0.016579 */
8923                  -525,          /* B1 = -0.032097 */
8924                  543,           /* B0 = 0.016579 */
8925                  5,             /* Internal filter scaling */
8926                  159,           /* Minimum in-band energy threshold */
8927                  21,            /* 21/32 in-band to broad-band ratio */
8928                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8929         },
8930         {                       /* f300_420[] 14 */
8931                 30750,          /* A1 = 1.876892 */
8932                  -31212,        /* A2 = -0.952515 */
8933                  -804,          /* B2 = -0.024541 */
8934                  0,             /* B1 = 0 */
8935                  804,           /* B0 = 0.024541 */
8936                  30686,         /* A1 = 1.872925 */
8937                  -32145,        /* A2 = -0.980988 */
8938                  14747,         /* B2 = 0.450043 */
8939                  -13703,        /* B1 = -0.836395 */
8940                  14747,         /* B0 = 0.450043 */
8941                  31651,         /* A1 = 1.931824 */
8942                  -32321,        /* A2 = -0.986389 */
8943                  24425,         /* B2 = 0.745422 */
8944                  -23914,        /* B1 = -1.459595 */
8945                  24427,         /* B0 = 0.745483 */
8946                  7,             /* Internal filter scaling */
8947                  159,           /* Minimum in-band energy threshold */
8948                  21,            /* 21/32 in-band to broad-band ratio */
8949                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8950         },
8951         {                       /* f330 15 */
8952                 31613,          /* A1 = -1.929565 */
8953                  -32646,        /* A2 = 0.996277 */
8954                  -185,          /* B2 = -0.005657 */
8955                  0,             /* B1 = 0.000000 */
8956                  185,           /* B0 = 0.005657 */
8957                  31620,         /* A1 = -1.929932 */
8958                  -32713,        /* A2 = 0.998352 */
8959                  19253,         /* B2 = 0.587585 */
8960                  -18566,        /* B1 = -1.133179 */
8961                  19253,         /* B0 = 0.587585 */
8962                  31674,         /* A1 = -1.933228 */
8963                  -32715,        /* A2 = 0.998413 */
8964                  2575,          /* B2 = 0.078590 */
8965                  -2495,         /* B1 = -0.152283 */
8966                  2575,          /* B0 = 0.078590 */
8967                  5,             /* Internal filter scaling */
8968                  159,           /* Minimum in-band energy threshold */
8969                  21,            /* 21/32 in-band to broad-band ratio */
8970                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8971         },
8972         {                       /* f300_425[] 16 */
8973                 30741,          /* A1 = 1.876282 */
8974                  -31475,        /* A2 = -0.960541 */
8975                  -703,          /* B2 = -0.021484 */
8976                  0,             /* B1 = 0 */
8977                  703,           /* B0 = 0.021484 */
8978                  30688,         /* A1 = 1.873047 */
8979                  -32248,        /* A2 = -0.984161 */
8980                  14542,         /* B2 = 0.443787 */
8981                  -13523,        /* B1 = -0.825439 */
8982                  14542,         /* B0 = 0.443817 */
8983                  31494,         /* A1 = 1.922302 */
8984                  -32366,        /* A2 = -0.987762 */
8985                  21577,         /* B2 = 0.658508 */
8986                  -21013,        /* B1 = -1.282532 */
8987                  21577,         /* B0 = 0.658508 */
8988                  7,             /* Internal filter scaling */
8989                  159,           /* Minimum in-band energy threshold */
8990                  21,            /* 21/32 in-band to broad-band ratio */
8991                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8992         },
8993         {                       /* f330_440[] 17 */
8994                 30627,          /* A1 = 1.869324 */
8995                  -31338,        /* A2 = -0.95636 */
8996                  -843,          /* B2 = -0.025749 */
8997                  0,             /* B1 = 0 */
8998                  843,           /* B0 = 0.025749 */
8999                  30550,         /* A1 = 1.864685 */
9000                  -32221,        /* A2 = -0.983337 */
9001                  13594,         /* B2 = 0.414886 */
9002                  -12589,        /* B1 = -0.768402 */
9003                  13594,         /* B0 = 0.414886 */
9004                  31488,         /* A1 = 1.921936 */
9005                  -32358,        /* A2 = -0.987518 */
9006                  24684,         /* B2 = 0.753296 */
9007                  -24029,        /* B1 = -1.466614 */
9008                  24684,         /* B0 = 0.753296 */
9009                  7,             /* Internal filter scaling */
9010                  159,           /* Minimum in-band energy threshold */
9011                  21,            /* 21/32 in-band to broad-band ratio */
9012                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9013         },
9014         {                       /* f340 18 */
9015                 31546,          /* A1 = -1.925476 */
9016                  -32646,        /* A2 = 0.996277 */
9017                  -445,          /* B2 = -0.013588 */
9018                  0,             /* B1 = 0.000000 */
9019                  445,           /* B0 = 0.013588 */
9020                  31551,         /* A1 = -1.925781 */
9021                  -32713,        /* A2 = 0.998352 */
9022                  23884,         /* B2 = 0.728882 */
9023                  -22979,        /* B1 = -1.402527 */
9024                  23884,         /* B0 = 0.728882 */
9025                  31606,         /* A1 = -1.929138 */
9026                  -32715,        /* A2 = 0.998413 */
9027                  863,           /* B2 = 0.026367 */
9028                  -835,          /* B1 = -0.050985 */
9029                  863,           /* B0 = 0.026367 */
9030                  5,             /* Internal filter scaling */
9031                  159,           /* Minimum in-band energy threshold */
9032                  21,            /* 21/32 in-band to broad-band ratio */
9033                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9034         },
9035         {                       /* f350_400[] 19 */
9036                 31006,          /* A1 = 1.892517 */
9037                  -32029,        /* A2 = -0.977448 */
9038                  -461,          /* B2 = -0.014096 */
9039                  0,             /* B1 = 0 */
9040                  461,           /* B0 = 0.014096 */
9041                  30999,         /* A1 = 1.892029 */
9042                  -32487,        /* A2 = -0.991455 */
9043                  11325,         /* B2 = 0.345612 */
9044                  -10682,        /* B1 = -0.651978 */
9045                  11325,         /* B0 = 0.345612 */
9046                  31441,         /* A1 = 1.919067 */
9047                  -32526,        /* A2 = -0.992615 */
9048                  24324,         /* B2 = 0.74231 */
9049                  -23535,        /* B1 = -1.436523 */
9050                  24324,         /* B0 = 0.74231 */
9051                  7,             /* Internal filter scaling */
9052                  159,           /* Minimum in-band energy threshold */
9053                  21,            /* 21/32 in-band to broad-band ratio */
9054                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9055         },
9056         {                       /* f350_440[] */
9057                 30634,          /* A1 = 1.869751 */
9058                  -31533,        /* A2 = -0.962341 */
9059                  -680,          /* B2 = -0.020782 */
9060                  0,             /* B1 = 0 */
9061                  680,           /* B0 = 0.020782 */
9062                  30571,         /* A1 = 1.865906 */
9063                  -32277,        /* A2 = -0.985016 */
9064                  12894,         /* B2 = 0.393524 */
9065                  -11945,        /* B1 = -0.729065 */
9066                  12894,         /* B0 = 0.393524 */
9067                  31367,         /* A1 = 1.91449 */
9068                  -32379,        /* A2 = -0.988129 */
9069                  23820,         /* B2 = 0.726929 */
9070                  -23104,        /* B1 = -1.410217 */
9071                  23820,         /* B0 = 0.726929 */
9072                  7,             /* Internal filter scaling */
9073                  159,           /* Minimum in-band energy threshold */
9074                  21,            /* 21/32 in-band to broad-band ratio */
9075                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9076         },
9077         {                       /* f350_450[] */
9078                 30552,          /* A1 = 1.864807 */
9079                  -31434,        /* A2 = -0.95929 */
9080                  -690,          /* B2 = -0.021066 */
9081                  0,             /* B1 = 0 */
9082                  690,           /* B0 = 0.021066 */
9083                  30472,         /* A1 = 1.859924 */
9084                  -32248,        /* A2 = -0.984161 */
9085                  13385,         /* B2 = 0.408478 */
9086                  -12357,        /* B1 = -0.754242 */
9087                  13385,         /* B0 = 0.408478 */
9088                  31358,         /* A1 = 1.914001 */
9089                  -32366,        /* A2 = -0.987732 */
9090                  26488,         /* B2 = 0.80835 */
9091                  -25692,        /* B1 = -1.568176 */
9092                  26490,         /* B0 = 0.808411 */
9093                  7,             /* Internal filter scaling */
9094                  159,           /* Minimum in-band energy threshold */
9095                  21,            /* 21/32 in-band to broad-band ratio */
9096                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9097         },
9098         {                       /* f360 */
9099                 31397,          /* A1 = -1.916321 */
9100                  -32623,        /* A2 = 0.995605 */
9101                  -117,          /* B2 = -0.003598 */
9102                  0,             /* B1 = 0.000000 */
9103                  117,           /* B0 = 0.003598 */
9104                  31403,         /* A1 = -1.916687 */
9105                  -32700,        /* A2 = 0.997925 */
9106                  3388,          /* B2 = 0.103401 */
9107                  -3240,         /* B1 = -0.197784 */
9108                  3388,          /* B0 = 0.103401 */
9109                  31463,         /* A1 = -1.920410 */
9110                  -32702,        /* A2 = 0.997986 */
9111                  13346,         /* B2 = 0.407288 */
9112                  -12863,        /* B1 = -0.785126 */
9113                  13346,         /* B0 = 0.407288 */
9114                  5,             /* Internal filter scaling */
9115                  159,           /* Minimum in-band energy threshold */
9116                  21,            /* 21/32 in-band to broad-band ratio */
9117                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9118         },
9119         {                       /* f380_420[] */
9120                 30831,          /* A1 = 1.881775 */
9121                  -32064,        /* A2 = -0.978546 */
9122                  -367,          /* B2 = -0.01122 */
9123                  0,             /* B1 = 0 */
9124                  367,           /* B0 = 0.01122 */
9125                  30813,         /* A1 = 1.880737 */
9126                  -32456,        /* A2 = -0.990509 */
9127                  11068,         /* B2 = 0.337769 */
9128                  -10338,        /* B1 = -0.631042 */
9129                  11068,         /* B0 = 0.337769 */
9130                  31214,         /* A1 = 1.905212 */
9131                  -32491,        /* A2 = -0.991577 */
9132                  16374,         /* B2 = 0.499695 */
9133                  -15781,        /* B1 = -0.963196 */
9134                  16374,         /* B0 = 0.499695 */
9135                  7,             /* Internal filter scaling */
9136                  159,           /* Minimum in-band energy threshold */
9137                  21,            /* 21/32 in-band to broad-band ratio */
9138                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9139         },
9140         {                       /* f392 */
9141                 31152,          /* A1 = -1.901428 */
9142                  -32613,        /* A2 = 0.995300 */
9143                  -314,          /* B2 = -0.009605 */
9144                  0,             /* B1 = 0.000000 */
9145                  314,           /* B0 = 0.009605 */
9146                  31156,         /* A1 = -1.901672 */
9147                  -32694,        /* A2 = 0.997742 */
9148                  28847,         /* B2 = 0.880371 */
9149                  -2734,         /* B1 = -0.166901 */
9150                  28847,         /* B0 = 0.880371 */
9151                  31225,         /* A1 = -1.905823 */
9152                  -32696,        /* A2 = 0.997803 */
9153                  462,           /* B2 = 0.014108 */
9154                  -442,          /* B1 = -0.027019 */
9155                  462,           /* B0 = 0.014108 */
9156                  5,             /* Internal filter scaling */
9157                  159,           /* Minimum in-band energy threshold */
9158                  21,            /* 21/32 in-band to broad-band ratio */
9159                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9160         },
9161         {                       /* f400_425[] */
9162                 30836,          /* A1 = 1.882141 */
9163                  -32296,        /* A2 = -0.985596 */
9164                  -324,          /* B2 = -0.009903 */
9165                  0,             /* B1 = 0 */
9166                  324,           /* B0 = 0.009903 */
9167                  30825,         /* A1 = 1.881409 */
9168                  -32570,        /* A2 = -0.993958 */
9169                  16847,         /* B2 = 0.51416 */
9170                  -15792,        /* B1 = -0.963898 */
9171                  16847,         /* B0 = 0.51416 */
9172                  31106,         /* A1 = 1.89856 */
9173                  -32584,        /* A2 = -0.994415 */
9174                  9579,          /* B2 = 0.292328 */
9175                  -9164,         /* B1 = -0.559357 */
9176                  9579,          /* B0 = 0.292328 */
9177                  7,             /* Internal filter scaling */
9178                  159,           /* Minimum in-band energy threshold */
9179                  21,            /* 21/32 in-band to broad-band ratio */
9180                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9181         },
9182         {                       /* f400_440[] */
9183                 30702,          /* A1 = 1.873962 */
9184                  -32134,        /* A2 = -0.980682 */
9185                  -517,          /* B2 = -0.015793 */
9186                  0,             /* B1 = 0 */
9187                  517,           /* B0 = 0.015793 */
9188                  30676,         /* A1 = 1.872375 */
9189                  -32520,        /* A2 = -0.992462 */
9190                  8144,          /* B2 = 0.24855 */
9191                  -7596,         /* B1 = -0.463684 */
9192                  8144,          /* B0 = 0.24855 */
9193                  31084,         /* A1 = 1.897217 */
9194                  -32547,        /* A2 = -0.993256 */
9195                  22713,         /* B2 = 0.693176 */
9196                  -21734,        /* B1 = -1.326599 */
9197                  22713,         /* B0 = 0.693176 */
9198                  7,             /* Internal filter scaling */
9199                  159,           /* Minimum in-band energy threshold */
9200                  21,            /* 21/32 in-band to broad-band ratio */
9201                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9202         },
9203         {                       /* f400_450[] */
9204                 30613,          /* A1 = 1.86853 */
9205                  -32031,        /* A2 = -0.977509 */
9206                  -618,          /* B2 = -0.018866 */
9207                  0,             /* B1 = 0 */
9208                  618,           /* B0 = 0.018866 */
9209                  30577,         /* A1 = 1.866272 */
9210                  -32491,        /* A2 = -0.991577 */
9211                  9612,          /* B2 = 0.293335 */
9212                  -8935,         /* B1 = -0.54541 */
9213                  9612,          /* B0 = 0.293335 */
9214                  31071,         /* A1 = 1.896484 */
9215                  -32524,        /* A2 = -0.992584 */
9216                  21596,         /* B2 = 0.659058 */
9217                  -20667,        /* B1 = -1.261414 */
9218                  21596,         /* B0 = 0.659058 */
9219                  7,             /* Internal filter scaling */
9220                  159,           /* Minimum in-band energy threshold */
9221                  21,            /* 21/32 in-band to broad-band ratio */
9222                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9223         },
9224         {                       /* f420 */
9225                 30914,          /* A1 = -1.886841 */
9226                  -32584,        /* A2 = 0.994385 */
9227                  -426,          /* B2 = -0.013020 */
9228                  0,             /* B1 = 0.000000 */
9229                  426,           /* B0 = 0.013020 */
9230                  30914,         /* A1 = -1.886841 */
9231                  -32679,        /* A2 = 0.997314 */
9232                  17520,         /* B2 = 0.534668 */
9233                  -16471,        /* B1 = -1.005310 */
9234                  17520,         /* B0 = 0.534668 */
9235                  31004,         /* A1 = -1.892334 */
9236                  -32683,        /* A2 = 0.997406 */
9237                  819,           /* B2 = 0.025023 */
9238                  -780,          /* B1 = -0.047619 */
9239                  819,           /* B0 = 0.025023 */
9240                  5,             /* Internal filter scaling */
9241                  159,           /* Minimum in-band energy threshold */
9242                  21,            /* 21/32 in-band to broad-band ratio */
9243                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9244         },
9245 #if 0
9246         {                       /* f425 */
9247                 30881,          /* A1 = -1.884827 */
9248                  -32603,        /* A2 = 0.994965 */
9249                  -496,          /* B2 = -0.015144 */
9250                  0,             /* B1 = 0.000000 */
9251                  496,           /* B0 = 0.015144 */
9252                  30880,         /* A1 = -1.884766 */
9253                  -32692,        /* A2 = 0.997711 */
9254                  24767,         /* B2 = 0.755859 */
9255                  -23290,        /* B1 = -1.421509 */
9256                  24767,         /* B0 = 0.755859 */
9257                  30967,         /* A1 = -1.890076 */
9258                  -32694,        /* A2 = 0.997772 */
9259                  728,           /* B2 = 0.022232 */
9260                  -691,          /* B1 = -0.042194 */
9261                  728,           /* B0 = 0.022232 */
9262                  5,             /* Internal filter scaling */
9263                  159,           /* Minimum in-band energy threshold */
9264                  21,            /* 21/32 in-band to broad-band ratio */
9265                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9266         },
9267 #else
9268         {
9269                 30850,
9270                 -32534,
9271                 -504,
9272                 0,
9273                 504,
9274                 30831,
9275                 -32669,
9276                 24303,
9277                 -22080,
9278                 24303,
9279                 30994,
9280                 -32673,
9281                 1905,
9282                 -1811,
9283                 1905,
9284                 5,
9285                 129,
9286                 17,
9287                 0xff5
9288         },
9289 #endif
9290         {                       /* f425_450[] */
9291                 30646,          /* A1 = 1.870544 */
9292                  -32327,        /* A2 = -0.986572 */
9293                  -287,          /* B2 = -0.008769 */
9294                  0,             /* B1 = 0 */
9295                  287,           /* B0 = 0.008769 */
9296                  30627,         /* A1 = 1.869324 */
9297                  -32607,        /* A2 = -0.995087 */
9298                  13269,         /* B2 = 0.404968 */
9299                  -12376,        /* B1 = -0.755432 */
9300                  13269,         /* B0 = 0.404968 */
9301                  30924,         /* A1 = 1.887512 */
9302                  -32619,        /* A2 = -0.995453 */
9303                  19950,         /* B2 = 0.608826 */
9304                  -18940,        /* B1 = -1.156006 */
9305                  19950,         /* B0 = 0.608826 */
9306                  7,             /* Internal filter scaling */
9307                  159,           /* Minimum in-band energy threshold */
9308                  21,            /* 21/32 in-band to broad-band ratio */
9309                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9310         },
9311         {                       /* f425_475[] */
9312                 30396,          /* A1 = 1.855225 */
9313                  -32014,        /* A2 = -0.97699 */
9314                  -395,          /* B2 = -0.012055 */
9315                  0,             /* B1 = 0 */
9316                  395,           /* B0 = 0.012055 */
9317                  30343,         /* A1 = 1.85199 */
9318                  -32482,        /* A2 = -0.991302 */
9319                  17823,         /* B2 = 0.543945 */
9320                  -16431,        /* B1 = -1.002869 */
9321                  17823,         /* B0 = 0.543945 */
9322                  30872,         /* A1 = 1.884338 */
9323                  -32516,        /* A2 = -0.99231 */
9324                  18124,         /* B2 = 0.553101 */
9325                  -17246,        /* B1 = -1.052673 */
9326                  18124,         /* B0 = 0.553101 */
9327                  7,             /* Internal filter scaling */
9328                  159,           /* Minimum in-band energy threshold */
9329                  21,            /* 21/32 in-band to broad-band ratio */
9330                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9331         },
9332         {                       /* f435 */
9333                 30796,          /* A1 = -1.879639 */
9334                  -32603,        /* A2 = 0.994965 */
9335                  -254,          /* B2 = -0.007762 */
9336                  0,             /* B1 = 0.000000 */
9337                  254,           /* B0 = 0.007762 */
9338                  30793,         /* A1 = -1.879456 */
9339                  -32692,        /* A2 = 0.997711 */
9340                  18934,         /* B2 = 0.577820 */
9341                  -17751,        /* B1 = -1.083496 */
9342                  18934,         /* B0 = 0.577820 */
9343                  30882,         /* A1 = -1.884888 */
9344                  -32694,        /* A2 = 0.997772 */
9345                  1858,          /* B2 = 0.056713 */
9346                  -1758,         /* B1 = -0.107357 */
9347                  1858,          /* B0 = 0.056713 */
9348                  5,             /* Internal filter scaling */
9349                  159,           /* Minimum in-band energy threshold */
9350                  21,            /* 21/32 in-band to broad-band ratio */
9351                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9352         },
9353         {                       /* f440_450[] */
9354                 30641,          /* A1 = 1.870239 */
9355                  -32458,        /* A2 = -0.99057 */
9356                  -155,          /* B2 = -0.004735 */
9357                  0,             /* B1 = 0 */
9358                  155,           /* B0 = 0.004735 */
9359                  30631,         /* A1 = 1.869568 */
9360                  -32630,        /* A2 = -0.995789 */
9361                  11453,         /* B2 = 0.349548 */
9362                  -10666,        /* B1 = -0.651001 */
9363                  11453,         /* B0 = 0.349548 */
9364                  30810,         /* A1 = 1.880554 */
9365                  -32634,        /* A2 = -0.995941 */
9366                  12237,         /* B2 = 0.373474 */
9367                  -11588,        /* B1 = -0.707336 */
9368                  12237,         /* B0 = 0.373474 */
9369                  7,             /* Internal filter scaling */
9370                  159,           /* Minimum in-band energy threshold */
9371                  21,            /* 21/32 in-band to broad-band ratio */
9372                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9373         },
9374         {                       /* f440_480[] */
9375                 30367,          /* A1 = 1.853455 */
9376                  -32147,        /* A2 = -0.981079 */
9377                  -495,          /* B2 = -0.015113 */
9378                  0,             /* B1 = 0 */
9379                  495,           /* B0 = 0.015113 */
9380                  30322,         /* A1 = 1.850769 */
9381                  -32543,        /* A2 = -0.993134 */
9382                  10031,         /* B2 = 0.306152 */
9383                  -9252,         /* B1 = -0.564728 */
9384                  10031,         /* B0 = 0.306152 */
9385                  30770,         /* A1 = 1.878052 */
9386                  -32563,        /* A2 = -0.993774 */
9387                  22674,         /* B2 = 0.691956 */
9388                  -21465,        /* B1 = -1.31012 */
9389                  22674,         /* B0 = 0.691956 */
9390                  7,             /* Internal filter scaling */
9391                  159,           /* Minimum in-band energy threshold */
9392                  21,            /* 21/32 in-band to broad-band ratio */
9393                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9394         },
9395         {                       /* f445 */
9396                 30709,          /* A1 = -1.874329 */
9397                  -32603,        /* A2 = 0.994965 */
9398                  -83,           /* B2 = -0.002545 */
9399                  0,             /* B1 = 0.000000 */
9400                  83,            /* B0 = 0.002545 */
9401                  30704,         /* A1 = -1.874084 */
9402                  -32692,        /* A2 = 0.997711 */
9403                  10641,         /* B2 = 0.324738 */
9404                  -9947,         /* B1 = -0.607147 */
9405                  10641,         /* B0 = 0.324738 */
9406                  30796,         /* A1 = -1.879639 */
9407                  -32694,        /* A2 = 0.997772 */
9408                  10079,         /* B2 = 0.307587 */
9409                  9513,          /* B1 = 0.580688 */
9410                  10079,         /* B0 = 0.307587 */
9411                  5,             /* Internal filter scaling */
9412                  159,           /* Minimum in-band energy threshold */
9413                  21,            /* 21/32 in-band to broad-band ratio */
9414                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9415         },
9416         {                       /* f450 */
9417                 30664,          /* A1 = -1.871643 */
9418                  -32603,        /* A2 = 0.994965 */
9419                  -164,          /* B2 = -0.005029 */
9420                  0,             /* B1 = 0.000000 */
9421                  164,           /* B0 = 0.005029 */
9422                  30661,         /* A1 = -1.871399 */
9423                  -32692,        /* A2 = 0.997711 */
9424                  15294,         /* B2 = 0.466736 */
9425                  -14275,        /* B1 = -0.871307 */
9426                  15294,         /* B0 = 0.466736 */
9427                  30751,         /* A1 = -1.876953 */
9428                  -32694,        /* A2 = 0.997772 */
9429                  3548,          /* B2 = 0.108284 */
9430                  -3344,         /* B1 = -0.204155 */
9431                  3548,          /* B0 = 0.108284 */
9432                  5,             /* Internal filter scaling */
9433                  159,           /* Minimum in-band energy threshold */
9434                  21,            /* 21/32 in-band to broad-band ratio */
9435                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9436         },
9437         {                       /* f452 */
9438                 30653,          /* A1 = -1.870911 */
9439                  -32615,        /* A2 = 0.995361 */
9440                  -209,          /* B2 = -0.006382 */
9441                  0,             /* B1 = 0.000000 */
9442                  209,           /* B0 = 0.006382 */
9443                  30647,         /* A1 = -1.870605 */
9444                  -32702,        /* A2 = 0.997986 */
9445                  18971,         /* B2 = 0.578979 */
9446                  -17716,        /* B1 = -1.081299 */
9447                  18971,         /* B0 = 0.578979 */
9448                  30738,         /* A1 = -1.876099 */
9449                  -32702,        /* A2 = 0.998016 */
9450                  2967,          /* B2 = 0.090561 */
9451                  -2793,         /* B1 = -0.170502 */
9452                  2967,          /* B0 = 0.090561 */
9453                  5,             /* Internal filter scaling */
9454                  159,           /* Minimum in-band energy threshold */
9455                  21,            /* 21/32 in-band to broad-band ratio */
9456                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9457         },
9458         {                       /* f475 */
9459                 30437,          /* A1 = -1.857727 */
9460                  -32603,        /* A2 = 0.994965 */
9461                  -264,          /* B2 = -0.008062 */
9462                  0,             /* B1 = 0.000000 */
9463                  264,           /* B0 = 0.008062 */
9464                  30430,         /* A1 = -1.857300 */
9465                  -32692,        /* A2 = 0.997711 */
9466                  21681,         /* B2 = 0.661682 */
9467                  -20082,        /* B1 = -1.225708 */
9468                  21681,         /* B0 = 0.661682 */
9469                  30526,         /* A1 = -1.863220 */
9470                  -32694,        /* A2 = 0.997742 */
9471                  1559,          /* B2 = 0.047600 */
9472                  -1459,         /* B1 = -0.089096 */
9473                  1559,          /* B0 = 0.047600 */
9474                  5,             /* Internal filter scaling */
9475                  159,           /* Minimum in-band energy threshold */
9476                  21,            /* 21/32 in-band to broad-band ratio */
9477                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9478         },
9479         {                       /* f480_620[] */
9480                 28975,          /* A1 = 1.768494 */
9481                  -30955,        /* A2 = -0.944672 */
9482                  -1026,         /* B2 = -0.03133 */
9483                  0,             /* B1 = 0 */
9484                  1026,          /* B0 = 0.03133 */
9485                  28613,         /* A1 = 1.746399 */
9486                  -32089,        /* A2 = -0.979309 */
9487                  14214,         /* B2 = 0.433807 */
9488                  -12202,        /* B1 = -0.744812 */
9489                  14214,         /* B0 = 0.433807 */
9490                  30243,         /* A1 = 1.845947 */
9491                  -32238,        /* A2 = -0.983856 */
9492                  24825,         /* B2 = 0.757629 */
9493                  -23402,        /* B1 = -1.428345 */
9494                  24825,         /* B0 = 0.757629 */
9495                  7,             /* Internal filter scaling */
9496                  159,           /* Minimum in-band energy threshold */
9497                  21,            /* 21/32 in-band to broad-band ratio */
9498                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9499         },
9500         {                       /* f494 */
9501                 30257,          /* A1 = -1.846741 */
9502                  -32605,        /* A2 = 0.995056 */
9503                  -249,          /* B2 = -0.007625 */
9504                  0,             /* B1 = 0.000000 */
9505                  249,           /* B0 = 0.007625 */
9506                  30247,         /* A1 = -1.846191 */
9507                  -32694,        /* A2 = 0.997772 */
9508                  18088,         /* B2 = 0.552002 */
9509                  -16652,        /* B1 = -1.016418 */
9510                  18088,         /* B0 = 0.552002 */
9511                  30348,         /* A1 = -1.852295 */
9512                  -32696,        /* A2 = 0.997803 */
9513                  2099,          /* B2 = 0.064064 */
9514                  -1953,         /* B1 = -0.119202 */
9515                  2099,          /* B0 = 0.064064 */
9516                  5,             /* Internal filter scaling */
9517                  159,           /* Minimum in-band energy threshold */
9518                  21,            /* 21/32 in-band to broad-band ratio */
9519                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9520         },
9521         {                       /* f500 */
9522                 30202,          /* A1 = -1.843431 */
9523                  -32624,        /* A2 = 0.995622 */
9524                  -413,          /* B2 = -0.012622 */
9525                  0,             /* B1 = 0.000000 */
9526                  413,           /* B0 = 0.012622 */
9527                  30191,         /* A1 = -1.842721 */
9528                  -32714,        /* A2 = 0.998364 */
9529                  25954,         /* B2 = 0.792057 */
9530                  -23890,        /* B1 = -1.458131 */
9531                  25954,         /* B0 = 0.792057 */
9532                  30296,         /* A1 = -1.849172 */
9533                  -32715,        /* A2 = 0.998397 */
9534                  2007,          /* B2 = 0.061264 */
9535                  -1860,         /* B1 = -0.113568 */
9536                  2007,          /* B0 = 0.061264 */
9537                  5,             /* Internal filter scaling */
9538                  159,           /* Minimum in-band energy threshold */
9539                  21,            /* 21/32 in-band to broad-band ratio */
9540                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9541         },
9542         {                       /* f520 */
9543                 30001,          /* A1 = -1.831116 */
9544                  -32613,        /* A2 = 0.995270 */
9545                  -155,          /* B2 = -0.004750 */
9546                  0,             /* B1 = 0.000000 */
9547                  155,           /* B0 = 0.004750 */
9548                  29985,         /* A1 = -1.830200 */
9549                  -32710,        /* A2 = 0.998260 */
9550                  6584,          /* B2 = 0.200928 */
9551                  -6018,         /* B1 = -0.367355 */
9552                  6584,          /* B0 = 0.200928 */
9553                  30105,         /* A1 = -1.837524 */
9554                  -32712,        /* A2 = 0.998291 */
9555                  23812,         /* B2 = 0.726685 */
9556                  -21936,        /* B1 = -1.338928 */
9557                  23812,         /* B0 = 0.726685 */
9558                  5,             /* Internal filter scaling */
9559                  159,           /* Minimum in-band energy threshold */
9560                  21,            /* 21/32 in-band to broad-band ratio */
9561                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9562         },
9563         {                       /* f523 */
9564                 29964,          /* A1 = -1.828918 */
9565                  -32601,        /* A2 = 0.994904 */
9566                  -101,          /* B2 = -0.003110 */
9567                  0,             /* B1 = 0.000000 */
9568                  101,           /* B0 = 0.003110 */
9569                  29949,         /* A1 = -1.827942 */
9570                  -32700,        /* A2 = 0.997925 */
9571                  11041,         /* B2 = 0.336975 */
9572                  -10075,        /* B1 = -0.614960 */
9573                  11041,         /* B0 = 0.336975 */
9574                  30070,         /* A1 = -1.835388 */
9575                  -32702,        /* A2 = 0.997986 */
9576                  16762,         /* B2 = 0.511536 */
9577                  -15437,        /* B1 = -0.942230 */
9578                  16762,         /* B0 = 0.511536 */
9579                  5,             /* Internal filter scaling */
9580                  159,           /* Minimum in-band energy threshold */
9581                  21,            /* 21/32 in-band to broad-band ratio */
9582                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9583         },
9584         {                       /* f525 */
9585                 29936,          /* A1 = -1.827209 */
9586                  -32584,        /* A2 = 0.994415 */
9587                  -91,           /* B2 = -0.002806 */
9588                  0,             /* B1 = 0.000000 */
9589                  91,            /* B0 = 0.002806 */
9590                  29921,         /* A1 = -1.826233 */
9591                  -32688,        /* A2 = 0.997559 */
9592                  11449,         /* B2 = 0.349396 */
9593                  -10426,        /* B1 = -0.636383 */
9594                  11449,         /* B0 = 0.349396 */
9595                  30045,         /* A1 = -1.833862 */
9596                  -32688,        /* A2 = 0.997589 */
9597                  13055,         /* B2 = 0.398407 */
9598                  -12028,        /* B1 = -0.734161 */
9599                  13055,         /* B0 = 0.398407 */
9600                  5,             /* Internal filter scaling */
9601                  159,           /* Minimum in-band energy threshold */
9602                  21,            /* 21/32 in-band to broad-band ratio */
9603                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9604         },
9605         {                       /* f540_660[] */
9606                 28499,          /* A1 = 1.739441 */
9607                  -31129,        /* A2 = -0.949982 */
9608                  -849,          /* B2 = -0.025922 */
9609                  0,             /* B1 = 0 */
9610                  849,           /* B0 = 0.025922 */
9611                  28128,         /* A1 = 1.716797 */
9612                  -32130,        /* A2 = -0.98056 */
9613                  14556,         /* B2 = 0.444214 */
9614                  -12251,        /* B1 = -0.747772 */
9615                  14556,         /* B0 = 0.444244 */
9616                  29667,         /* A1 = 1.81073 */
9617                  -32244,        /* A2 = -0.984039 */
9618                  23038,         /* B2 = 0.703064 */
9619                  -21358,        /* B1 = -1.303589 */
9620                  23040,         /* B0 = 0.703125 */
9621                  7,             /* Internal filter scaling */
9622                  159,           /* Minimum in-band energy threshold */
9623                  21,            /* 21/32 in-band to broad-band ratio */
9624                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9625         },
9626         {                       /* f587 */
9627                 29271,          /* A1 = -1.786560 */
9628                  -32599,        /* A2 = 0.994873 */
9629                  -490,          /* B2 = -0.014957 */
9630                  0,             /* B1 = 0.000000 */
9631                  490,           /* B0 = 0.014957 */
9632                  29246,         /* A1 = -1.785095 */
9633                  -32700,        /* A2 = 0.997925 */
9634                  28961,         /* B2 = 0.883850 */
9635                  -25796,        /* B1 = -1.574463 */
9636                  28961,         /* B0 = 0.883850 */
9637                  29383,         /* A1 = -1.793396 */
9638                  -32700,        /* A2 = 0.997955 */
9639                  1299,          /* B2 = 0.039650 */
9640                  -1169,         /* B1 = -0.071396 */
9641                  1299,          /* B0 = 0.039650 */
9642                  5,             /* Internal filter scaling */
9643                  159,           /* Minimum in-band energy threshold */
9644                  21,            /* 21/32 in-band to broad-band ratio */
9645                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9646         },
9647         {                       /* f590 */
9648                 29230,          /* A1 = -1.784058 */
9649                  -32584,        /* A2 = 0.994415 */
9650                  -418,          /* B2 = -0.012757 */
9651                  0,             /* B1 = 0.000000 */
9652                  418,           /* B0 = 0.012757 */
9653                  29206,         /* A1 = -1.782593 */
9654                  -32688,        /* A2 = 0.997559 */
9655                  36556,         /* B2 = 1.115601 */
9656                  -32478,        /* B1 = -1.982300 */
9657                  36556,         /* B0 = 1.115601 */
9658                  29345,         /* A1 = -1.791077 */
9659                  -32688,        /* A2 = 0.997589 */
9660                  897,           /* B2 = 0.027397 */
9661                  -808,          /* B1 = -0.049334 */
9662                  897,           /* B0 = 0.027397 */
9663                  5,             /* Internal filter scaling */
9664                  159,           /* Minimum in-band energy threshold */
9665                  21,            /* 21/32 in-band to broad-band ratio */
9666                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9667         },
9668         {                       /* f600 */
9669                 29116,          /* A1 = -1.777100 */
9670                  -32603,        /* A2 = 0.994965 */
9671                  -165,          /* B2 = -0.005039 */
9672                  0,             /* B1 = 0.000000 */
9673                  165,           /* B0 = 0.005039 */
9674                  29089,         /* A1 = -1.775452 */
9675                  -32708,        /* A2 = 0.998199 */
9676                  6963,          /* B2 = 0.212494 */
9677                  -6172,         /* B1 = -0.376770 */
9678                  6963,          /* B0 = 0.212494 */
9679                  29237,         /* A1 = -1.784485 */
9680                  -32710,        /* A2 = 0.998230 */
9681                  24197,         /* B2 = 0.738464 */
9682                  -21657,        /* B1 = -1.321899 */
9683                  24197,         /* B0 = 0.738464 */
9684                  5,             /* Internal filter scaling */
9685                  159,           /* Minimum in-band energy threshold */
9686                  21,            /* 21/32 in-band to broad-band ratio */
9687                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9688         },
9689         {                       /* f660 */
9690                 28376,          /* A1 = -1.731934 */
9691                  -32567,        /* A2 = 0.993896 */
9692                  -363,          /* B2 = -0.011102 */
9693                  0,             /* B1 = 0.000000 */
9694                  363,           /* B0 = 0.011102 */
9695                  28337,         /* A1 = -1.729614 */
9696                  -32683,        /* A2 = 0.997434 */
9697                  21766,         /* B2 = 0.664246 */
9698                  -18761,        /* B1 = -1.145081 */
9699                  21766,         /* B0 = 0.664246 */
9700                  28513,         /* A1 = -1.740356 */
9701                  -32686,        /* A2 = 0.997498 */
9702                  2509,          /* B2 = 0.076584 */
9703                  -2196,         /* B1 = -0.134041 */
9704                  2509,          /* B0 = 0.076584 */
9705                  5,             /* Internal filter scaling */
9706                  159,           /* Minimum in-band energy threshold */
9707                  21,            /* 21/32 in-band to broad-band ratio */
9708                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9709         },
9710         {                       /* f700 */
9711                 27844,          /* A1 = -1.699463 */
9712                  -32563,        /* A2 = 0.993744 */
9713                  -366,          /* B2 = -0.011187 */
9714                  0,             /* B1 = 0.000000 */
9715                  366,           /* B0 = 0.011187 */
9716                  27797,         /* A1 = -1.696655 */
9717                  -32686,        /* A2 = 0.997498 */
9718                  22748,         /* B2 = 0.694214 */
9719                  -19235,        /* B1 = -1.174072 */
9720                  22748,         /* B0 = 0.694214 */
9721                  27995,         /* A1 = -1.708740 */
9722                  -32688,        /* A2 = 0.997559 */
9723                  2964,          /* B2 = 0.090477 */
9724                  -2546,         /* B1 = -0.155449 */
9725                  2964,          /* B0 = 0.090477 */
9726                  5,             /* Internal filter scaling */
9727                  159,           /* Minimum in-band energy threshold */
9728                  21,            /* 21/32 in-band to broad-band ratio */
9729                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9730         },
9731         {                       /* f740 */
9732                 27297,          /* A1 = -1.666077 */
9733                  -32551,        /* A2 = 0.993408 */
9734                  -345,          /* B2 = -0.010540 */
9735                  0,             /* B1 = 0.000000 */
9736                  345,           /* B0 = 0.010540 */
9737                  27240,         /* A1 = -1.662598 */
9738                  -32683,        /* A2 = 0.997406 */
9739                  22560,         /* B2 = 0.688477 */
9740                  -18688,        /* B1 = -1.140625 */
9741                  22560,         /* B0 = 0.688477 */
9742                  27461,         /* A1 = -1.676147 */
9743                  -32684,        /* A2 = 0.997467 */
9744                  3541,          /* B2 = 0.108086 */
9745                  -2985,         /* B1 = -0.182220 */
9746                  3541,          /* B0 = 0.108086 */
9747                  5,             /* Internal filter scaling */
9748                  159,           /* Minimum in-band energy threshold */
9749                  21,            /* 21/32 in-band to broad-band ratio */
9750                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9751         },
9752         {                       /* f750 */
9753                 27155,          /* A1 = -1.657410 */
9754                  -32551,        /* A2 = 0.993408 */
9755                  -462,          /* B2 = -0.014117 */
9756                  0,             /* B1 = 0.000000 */
9757                  462,           /* B0 = 0.014117 */
9758                  27097,         /* A1 = -1.653870 */
9759                  -32683,        /* A2 = 0.997406 */
9760                  32495,         /* B2 = 0.991699 */
9761                  -26776,        /* B1 = -1.634338 */
9762                  32495,         /* B0 = 0.991699 */
9763                  27321,         /* A1 = -1.667542 */
9764                  -32684,        /* A2 = 0.997467 */
9765                  1835,          /* B2 = 0.056007 */
9766                  -1539,         /* B1 = -0.093948 */
9767                  1835,          /* B0 = 0.056007 */
9768                  5,             /* Internal filter scaling */
9769                  159,           /* Minimum in-band energy threshold */
9770                  21,            /* 21/32 in-band to broad-band ratio */
9771                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9772         },
9773         {                       /* f750_1450[] */
9774                 19298,          /* A1 = 1.177917 */
9775                  -24471,        /* A2 = -0.746796 */
9776                  -4152,         /* B2 = -0.126709 */
9777                  0,             /* B1 = 0 */
9778                  4152,          /* B0 = 0.126709 */
9779                  12902,         /* A1 = 0.787476 */
9780                  -29091,        /* A2 = -0.887817 */
9781                  12491,         /* B2 = 0.38121 */
9782                  -1794,         /* B1 = -0.109528 */
9783                  12494,         /* B0 = 0.381317 */
9784                  26291,         /* A1 = 1.604736 */
9785                  -30470,        /* A2 = -0.929901 */
9786                  28859,         /* B2 = 0.880737 */
9787                  -26084,        /* B1 = -1.592102 */
9788                  28861,         /* B0 = 0.880798 */
9789                  7,             /* Internal filter scaling */
9790                  159,           /* Minimum in-band energy threshold */
9791                  21,            /* 21/32 in-band to broad-band ratio */
9792                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9793         },
9794         {                       /* f770 */
9795                 26867,          /* A1 = -1.639832 */
9796                  -32551,        /* A2 = 0.993408 */
9797                  -123,          /* B2 = -0.003755 */
9798                  0,             /* B1 = 0.000000 */
9799                  123,           /* B0 = 0.003755 */
9800                  26805,         /* A1 = -1.636108 */
9801                  -32683,        /* A2 = 0.997406 */
9802                  17297,         /* B2 = 0.527863 */
9803                  -14096,        /* B1 = -0.860382 */
9804                  17297,         /* B0 = 0.527863 */
9805                  27034,         /* A1 = -1.650085 */
9806                  -32684,        /* A2 = 0.997467 */
9807                  12958,         /* B2 = 0.395477 */
9808                  -10756,        /* B1 = -0.656525 */
9809                  12958,         /* B0 = 0.395477 */
9810                  5,             /* Internal filter scaling */
9811                  159,           /* Minimum in-band energy threshold */
9812                  21,            /* 21/32 in-band to broad-band ratio */
9813                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9814         },
9815         {                       /* f800 */
9816                 26413,          /* A1 = -1.612122 */
9817                  -32547,        /* A2 = 0.993286 */
9818                  -223,          /* B2 = -0.006825 */
9819                  0,             /* B1 = 0.000000 */
9820                  223,           /* B0 = 0.006825 */
9821                  26342,         /* A1 = -1.607849 */
9822                  -32686,        /* A2 = 0.997498 */
9823                  6391,          /* B2 = 0.195053 */
9824                  -5120,         /* B1 = -0.312531 */
9825                  6391,          /* B0 = 0.195053 */
9826                  26593,         /* A1 = -1.623108 */
9827                  -32688,        /* A2 = 0.997559 */
9828                  23681,         /* B2 = 0.722717 */
9829                  -19328,        /* B1 = -1.179688 */
9830                  23681,         /* B0 = 0.722717 */
9831                  5,             /* Internal filter scaling */
9832                  159,           /* Minimum in-band energy threshold */
9833                  21,            /* 21/32 in-band to broad-band ratio */
9834                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9835         },
9836         {                       /* f816 */
9837                 26168,          /* A1 = -1.597209 */
9838                  -32528,        /* A2 = 0.992706 */
9839                  -235,          /* B2 = -0.007182 */
9840                  0,             /* B1 = 0.000000 */
9841                  235,           /* B0 = 0.007182 */
9842                  26092,         /* A1 = -1.592590 */
9843                  -32675,        /* A2 = 0.997192 */
9844                  20823,         /* B2 = 0.635498 */
9845                  -16510,        /* B1 = -1.007751 */
9846                  20823,         /* B0 = 0.635498 */
9847                  26363,         /* A1 = -1.609070 */
9848                  -32677,        /* A2 = 0.997253 */
9849                  6739,          /* B2 = 0.205688 */
9850                  -5459,         /* B1 = -0.333206 */
9851                  6739,          /* B0 = 0.205688 */
9852                  5,             /* Internal filter scaling */
9853                  159,           /* Minimum in-band energy threshold */
9854                  21,            /* 21/32 in-band to broad-band ratio */
9855                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9856         },
9857         {                       /* f850 */
9858                 25641,          /* A1 = -1.565063 */
9859                  -32536,        /* A2 = 0.992950 */
9860                  -121,          /* B2 = -0.003707 */
9861                  0,             /* B1 = 0.000000 */
9862                  121,           /* B0 = 0.003707 */
9863                  25560,         /* A1 = -1.560059 */
9864                  -32684,        /* A2 = 0.997437 */
9865                  18341,         /* B2 = 0.559753 */
9866                  -14252,        /* B1 = -0.869904 */
9867                  18341,         /* B0 = 0.559753 */
9868                  25837,         /* A1 = -1.577026 */
9869                  -32684,        /* A2 = 0.997467 */
9870                  16679,         /* B2 = 0.509003 */
9871                  -13232,        /* B1 = -0.807648 */
9872                  16679,         /* B0 = 0.509003 */
9873                  5,             /* Internal filter scaling */
9874                  159,           /* Minimum in-band energy threshold */
9875                  21,            /* 21/32 in-band to broad-band ratio */
9876                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9877         },
9878         {                       /* f857_1645[] */
9879                 16415,          /* A1 = 1.001953 */
9880                  -23669,        /* A2 = -0.722321 */
9881                  -4549,         /* B2 = -0.138847 */
9882                  0,             /* B1 = 0 */
9883                  4549,          /* B0 = 0.138847 */
9884                  8456,          /* A1 = 0.516174 */
9885                  -28996,        /* A2 = -0.884918 */
9886                  13753,         /* B2 = 0.419724 */
9887                  -12,           /* B1 = -0.000763 */
9888                  13757,         /* B0 = 0.419846 */
9889                  24632,         /* A1 = 1.503418 */
9890                  -30271,        /* A2 = -0.923828 */
9891                  29070,         /* B2 = 0.887146 */
9892                  -25265,        /* B1 = -1.542114 */
9893                  29073,         /* B0 = 0.887268 */
9894                  7,             /* Internal filter scaling */
9895                  159,           /* Minimum in-band energy threshold */
9896                  21,            /* 21/32 in-band to broad-band ratio */
9897                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9898         },
9899         {                       /* f900 */
9900                 24806,          /* A1 = -1.514099 */
9901                  -32501,        /* A2 = 0.991852 */
9902                  -326,          /* B2 = -0.009969 */
9903                  0,             /* B1 = 0.000000 */
9904                  326,           /* B0 = 0.009969 */
9905                  24709,         /* A1 = -1.508118 */
9906                  -32659,        /* A2 = 0.996674 */
9907                  20277,         /* B2 = 0.618835 */
9908                  -15182,        /* B1 = -0.926636 */
9909                  20277,         /* B0 = 0.618835 */
9910                  25022,         /* A1 = -1.527222 */
9911                  -32661,        /* A2 = 0.996735 */
9912                  4320,          /* B2 = 0.131836 */
9913                  -3331,         /* B1 = -0.203339 */
9914                  4320,          /* B0 = 0.131836 */
9915                  5,             /* Internal filter scaling */
9916                  159,           /* Minimum in-band energy threshold */
9917                  21,            /* 21/32 in-band to broad-band ratio */
9918                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9919         },
9920         {                       /* f900_1300[] */
9921                 19776,          /* A1 = 1.207092 */
9922                  -27437,        /* A2 = -0.837341 */
9923                  -2666,         /* B2 = -0.081371 */
9924                  0,             /* B1 = 0 */
9925                  2666,          /* B0 = 0.081371 */
9926                  16302,         /* A1 = 0.995026 */
9927                  -30354,        /* A2 = -0.926361 */
9928                  10389,         /* B2 = 0.317062 */
9929                  -3327,         /* B1 = -0.203064 */
9930                  10389,         /* B0 = 0.317062 */
9931                  24299,         /* A1 = 1.483154 */
9932                  -30930,        /* A2 = -0.943909 */
9933                  25016,         /* B2 = 0.763428 */
9934                  -21171,        /* B1 = -1.292236 */
9935                  25016,         /* B0 = 0.763428 */
9936                  7,             /* Internal filter scaling */
9937                  159,           /* Minimum in-band energy threshold */
9938                  21,            /* 21/32 in-band to broad-band ratio */
9939                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9940         },
9941         {                       /* f935_1215[] */
9942                 20554,          /* A1 = 1.254517 */
9943                  -28764,        /* A2 = -0.877838 */
9944                  -2048,         /* B2 = -0.062515 */
9945                  0,             /* B1 = 0 */
9946                  2048,          /* B0 = 0.062515 */
9947                  18209,         /* A1 = 1.11145 */
9948                  -30951,        /* A2 = -0.94458 */
9949                  9390,          /* B2 = 0.286575 */
9950                  -3955,         /* B1 = -0.241455 */
9951                  9390,          /* B0 = 0.286575 */
9952                  23902,         /* A1 = 1.458923 */
9953                  -31286,        /* A2 = -0.954803 */
9954                  23252,         /* B2 = 0.709595 */
9955                  -19132,        /* B1 = -1.167725 */
9956                  23252,         /* B0 = 0.709595 */
9957                  7,             /* Internal filter scaling */
9958                  159,           /* Minimum in-band energy threshold */
9959                  21,            /* 21/32 in-band to broad-band ratio */
9960                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9961         },
9962         {                       /* f941_1477[] */
9963                 17543,          /* A1 = 1.07074 */
9964                  -26220,        /* A2 = -0.800201 */
9965                  -3298,         /* B2 = -0.100647 */
9966                  0,             /* B1 = 0 */
9967                  3298,          /* B0 = 0.100647 */
9968                  12423,         /* A1 = 0.75827 */
9969                  -30036,        /* A2 = -0.916626 */
9970                  12651,         /* B2 = 0.386078 */
9971                  -2444,         /* B1 = -0.14917 */
9972                  12653,         /* B0 = 0.386154 */
9973                  23518,         /* A1 = 1.435425 */
9974                  -30745,        /* A2 = -0.938293 */
9975                  27282,         /* B2 = 0.832581 */
9976                  -22529,        /* B1 = -1.375122 */
9977                  27286,         /* B0 = 0.832703 */
9978                  7,             /* Internal filter scaling */
9979                  159,           /* Minimum in-band energy threshold */
9980                  21,            /* 21/32 in-band to broad-band ratio */
9981                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9982         },
9983         {                       /* f942 */
9984                 24104,          /* A1 = -1.471252 */
9985                  -32507,        /* A2 = 0.992065 */
9986                  -351,          /* B2 = -0.010722 */
9987                  0,             /* B1 = 0.000000 */
9988                  351,           /* B0 = 0.010722 */
9989                  23996,         /* A1 = -1.464600 */
9990                  -32671,        /* A2 = 0.997040 */
9991                  22848,         /* B2 = 0.697266 */
9992                  -16639,        /* B1 = -1.015564 */
9993                  22848,         /* B0 = 0.697266 */
9994                  24332,         /* A1 = -1.485168 */
9995                  -32673,        /* A2 = 0.997101 */
9996                  4906,          /* B2 = 0.149727 */
9997                  -3672,         /* B1 = -0.224174 */
9998                  4906,          /* B0 = 0.149727 */
9999                  5,             /* Internal filter scaling */
10000                  159,           /* Minimum in-band energy threshold */
10001                  21,            /* 21/32 in-band to broad-band ratio */
10002                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10003         },
10004         {                       /* f950 */
10005                 23967,          /* A1 = -1.462830 */
10006                  -32507,        /* A2 = 0.992065 */
10007                  -518,          /* B2 = -0.015821 */
10008                  0,             /* B1 = 0.000000 */
10009                  518,           /* B0 = 0.015821 */
10010                  23856,         /* A1 = -1.456055 */
10011                  -32671,        /* A2 = 0.997040 */
10012                  26287,         /* B2 = 0.802246 */
10013                  -19031,        /* B1 = -1.161560 */
10014                  26287,         /* B0 = 0.802246 */
10015                  24195,         /* A1 = -1.476746 */
10016                  -32673,        /* A2 = 0.997101 */
10017                  2890,          /* B2 = 0.088196 */
10018                  -2151,         /* B1 = -0.131317 */
10019                  2890,          /* B0 = 0.088196 */
10020                  5,             /* Internal filter scaling */
10021                  159,           /* Minimum in-band energy threshold */
10022                  21,            /* 21/32 in-band to broad-band ratio */
10023                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10024         },
10025         {                       /* f950_1400[] */
10026                 18294,          /* A1 = 1.116638 */
10027                  -26962,        /* A2 = -0.822845 */
10028                  -2914,         /* B2 = -0.088936 */
10029                  0,             /* B1 = 0 */
10030                  2914,          /* B0 = 0.088936 */
10031                  14119,         /* A1 = 0.861786 */
10032                  -30227,        /* A2 = -0.922455 */
10033                  11466,         /* B2 = 0.349945 */
10034                  -2833,         /* B1 = -0.172943 */
10035                  11466,         /* B0 = 0.349945 */
10036                  23431,         /* A1 = 1.430115 */
10037                  -30828,        /* A2 = -0.940796 */
10038                  25331,         /* B2 = 0.773071 */
10039                  -20911,        /* B1 = -1.276367 */
10040                  25331,         /* B0 = 0.773071 */
10041                  7,             /* Internal filter scaling */
10042                  159,           /* Minimum in-band energy threshold */
10043                  21,            /* 21/32 in-band to broad-band ratio */
10044                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10045         },
10046         {                       /* f975 */
10047                 23521,          /* A1 = -1.435608 */
10048                  -32489,        /* A2 = 0.991516 */
10049                  -193,          /* B2 = -0.005915 */
10050                  0,             /* B1 = 0.000000 */
10051                  193,           /* B0 = 0.005915 */
10052                  23404,         /* A1 = -1.428467 */
10053                  -32655,        /* A2 = 0.996582 */
10054                  17740,         /* B2 = 0.541412 */
10055                  -12567,        /* B1 = -0.767029 */
10056                  17740,         /* B0 = 0.541412 */
10057                  23753,         /* A1 = -1.449829 */
10058                  -32657,        /* A2 = 0.996613 */
10059                  9090,          /* B2 = 0.277405 */
10060                  -6662,         /* B1 = -0.406647 */
10061                  9090,          /* B0 = 0.277405 */
10062                  5,             /* Internal filter scaling */
10063                  159,           /* Minimum in-band energy threshold */
10064                  21,            /* 21/32 in-band to broad-band ratio */
10065                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10066         },
10067         {                       /* f1000 */
10068                 23071,          /* A1 = -1.408203 */
10069                  -32489,        /* A2 = 0.991516 */
10070                  -293,          /* B2 = -0.008965 */
10071                  0,             /* B1 = 0.000000 */
10072                  293,           /* B0 = 0.008965 */
10073                  22951,         /* A1 = -1.400818 */
10074                  -32655,        /* A2 = 0.996582 */
10075                  5689,          /* B2 = 0.173645 */
10076                  -3951,         /* B1 = -0.241150 */
10077                  5689,          /* B0 = 0.173645 */
10078                  23307,         /* A1 = -1.422607 */
10079                  -32657,        /* A2 = 0.996613 */
10080                  18692,         /* B2 = 0.570435 */
10081                  -13447,        /* B1 = -0.820770 */
10082                  18692,         /* B0 = 0.570435 */
10083                  5,             /* Internal filter scaling */
10084                  159,           /* Minimum in-band energy threshold */
10085                  21,            /* 21/32 in-band to broad-band ratio */
10086                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10087         },
10088         {                       /* f1020 */
10089                 22701,          /* A1 = -1.385620 */
10090                  -32474,        /* A2 = 0.991058 */
10091                  -292,          /* B2 = -0.008933 */
10092                  0,             /*163840      , B1 = 10.000000 */
10093                  292,           /* B0 = 0.008933 */
10094                  22564,         /* A1 = -1.377258 */
10095                  -32655,        /* A2 = 0.996552 */
10096                  20756,         /* B2 = 0.633423 */
10097                  -14176,        /* B1 = -0.865295 */
10098                  20756,         /* B0 = 0.633423 */
10099                  22960,         /* A1 = -1.401428 */
10100                  -32657,        /* A2 = 0.996613 */
10101                  6520,          /* B2 = 0.198990 */
10102                  -4619,         /* B1 = -0.281937 */
10103                  6520,          /* B0 = 0.198990 */
10104                  5,             /* Internal filter scaling */
10105                  159,           /* Minimum in-band energy threshold */
10106                  21,            /* 21/32 in-band to broad-band ratio */
10107                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10108         },
10109         {                       /* f1050 */
10110                 22142,          /* A1 = -1.351501 */
10111                  -32474,        /* A2 = 0.991058 */
10112                  -147,          /* B2 = -0.004493 */
10113                  0,             /* B1 = 0.000000 */
10114                  147,           /* B0 = 0.004493 */
10115                  22000,         /* A1 = -1.342834 */
10116                  -32655,        /* A2 = 0.996552 */
10117                  15379,         /* B2 = 0.469360 */
10118                  -10237,        /* B1 = -0.624847 */
10119                  15379,         /* B0 = 0.469360 */
10120                  22406,         /* A1 = -1.367554 */
10121                  -32657,        /* A2 = 0.996613 */
10122                  17491,         /* B2 = 0.533783 */
10123                  -12096,        /* B1 = -0.738312 */
10124                  17491,         /* B0 = 0.533783 */
10125                  5,             /* Internal filter scaling */
10126                  159,           /* Minimum in-band energy threshold */
10127                  21,            /* 21/32 in-band to broad-band ratio */
10128                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10129         },
10130         {                       /* f1100_1750[] */
10131                 12973,          /* A1 = 0.79184 */
10132                  -24916,        /* A2 = -0.760376 */
10133                  6655,          /* B2 = 0.203102 */
10134                  367,           /* B1 = 0.0224 */
10135                  6657,          /* B0 = 0.203171 */
10136                  5915,          /* A1 = 0.361053 */
10137                  -29560,        /* A2 = -0.90213 */
10138                  -7777,         /* B2 = -0.23735 */
10139                  0,             /* B1 = 0 */
10140                  7777,          /* B0 = 0.23735 */
10141                  20510,         /* A1 = 1.251892 */
10142                  -30260,        /* A2 = -0.923462 */
10143                  26662,         /* B2 = 0.81366 */
10144                  -20573,        /* B1 = -1.255737 */
10145                  26668,         /* B0 = 0.813843 */
10146                  7,             /* Internal filter scaling */
10147                  159,           /* Minimum in-band energy threshold */
10148                  21,            /* 21/32 in-band to broad-band ratio */
10149                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10150         },
10151         {                       /* f1140 */
10152                 20392,          /* A1 = -1.244629 */
10153                  -32460,        /* A2 = 0.990601 */
10154                  -270,          /* B2 = -0.008240 */
10155                  0,             /* B1 = 0.000000 */
10156                  270,           /* B0 = 0.008240 */
10157                  20218,         /* A1 = -1.234009 */
10158                  -32655,        /* A2 = 0.996582 */
10159                  21337,         /* B2 = 0.651154 */
10160                  -13044,        /* B1 = -0.796143 */
10161                  21337,         /* B0 = 0.651154 */
10162                  20684,         /* A1 = -1.262512 */
10163                  -32657,        /* A2 = 0.996643 */
10164                  8572,          /* B2 = 0.261612 */
10165                  -5476,         /* B1 = -0.334244 */
10166                  8572,          /* B0 = 0.261612 */
10167                  5,             /* Internal filter scaling */
10168                  159,           /* Minimum in-band energy threshold */
10169                  21,            /* 21/32 in-band to broad-band ratio */
10170                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10171         },
10172         {                       /* f1200 */
10173                 19159,          /* A1 = -1.169373 */
10174                  -32456,        /* A2 = 0.990509 */
10175                  -335,          /* B2 = -0.010252 */
10176                  0,             /* B1 = 0.000000 */
10177                  335,           /* B0 = 0.010252 */
10178                  18966,         /* A1 = -1.157593 */
10179                  -32661,        /* A2 = 0.996735 */
10180                  6802,          /* B2 = 0.207588 */
10181                  -3900,         /* B1 = -0.238098 */
10182                  6802,          /* B0 = 0.207588 */
10183                  19467,         /* A1 = -1.188232 */
10184                  -32661,        /* A2 = 0.996765 */
10185                  25035,         /* B2 = 0.764008 */
10186                  -15049,        /* B1 = -0.918579 */
10187                  25035,         /* B0 = 0.764008 */
10188                  5,             /* Internal filter scaling */
10189                  159,           /* Minimum in-band energy threshold */
10190                  21,            /* 21/32 in-band to broad-band ratio */
10191                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10192         },
10193         {                       /* f1209 */
10194                 18976,          /* A1 = -1.158264 */
10195                  -32439,        /* A2 = 0.989990 */
10196                  -183,          /* B2 = -0.005588 */
10197                  0,             /* B1 = 0.000000 */
10198                  183,           /* B0 = 0.005588 */
10199                  18774,         /* A1 = -1.145874 */
10200                  -32650,        /* A2 = 0.996429 */
10201                  15468,         /* B2 = 0.472076 */
10202                  -8768,         /* B1 = -0.535217 */
10203                  15468,         /* B0 = 0.472076 */
10204                  19300,         /* A1 = -1.177979 */
10205                  -32652,        /* A2 = 0.996490 */
10206                  19840,         /* B2 = 0.605499 */
10207                  -11842,        /* B1 = -0.722809 */
10208                  19840,         /* B0 = 0.605499 */
10209                  5,             /* Internal filter scaling */
10210                  159,           /* Minimum in-band energy threshold */
10211                  21,            /* 21/32 in-band to broad-band ratio */
10212                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10213         },
10214         {                       /* f1330 */
10215                 16357,          /* A1 = -0.998413 */
10216                  -32368,        /* A2 = 0.987793 */
10217                  -217,          /* B2 = -0.006652 */
10218                  0,             /* B1 = 0.000000 */
10219                  217,           /* B0 = 0.006652 */
10220                  16107,         /* A1 = -0.983126 */
10221                  -32601,        /* A2 = 0.994904 */
10222                  11602,         /* B2 = 0.354065 */
10223                  -5555,         /* B1 = -0.339111 */
10224                  11602,         /* B0 = 0.354065 */
10225                  16722,         /* A1 = -1.020630 */
10226                  -32603,        /* A2 = 0.994965 */
10227                  15574,         /* B2 = 0.475311 */
10228                  -8176,         /* B1 = -0.499069 */
10229                  15574,         /* B0 = 0.475311 */
10230                  5,             /* Internal filter scaling */
10231                  159,           /* Minimum in-band energy threshold */
10232                  21,            /* 21/32 in-band to broad-band ratio */
10233                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10234         },
10235         {                       /* f1336 */
10236                 16234,          /* A1 = -0.990875 */
10237                  32404,         /* A2 = -0.988922 */
10238                  -193,          /* B2 = -0.005908 */
10239                  0,             /* B1 = 0.000000 */
10240                  193,           /* B0 = 0.005908 */
10241                  15986,         /* A1 = -0.975769 */
10242                  -32632,        /* A2 = 0.995880 */
10243                  18051,         /* B2 = 0.550903 */
10244                  -8658,         /* B1 = -0.528473 */
10245                  18051,         /* B0 = 0.550903 */
10246                  16591,         /* A1 = -1.012695 */
10247                  -32634,        /* A2 = 0.995941 */
10248                  15736,         /* B2 = 0.480240 */
10249                  -8125,         /* B1 = -0.495926 */
10250                  15736,         /* B0 = 0.480240 */
10251                  5,             /* Internal filter scaling */
10252                  159,           /* Minimum in-band energy threshold */
10253                  21,            /* 21/32 in-band to broad-band ratio */
10254                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10255         },
10256         {                       /* f1366 */
10257                 15564,          /* A1 = -0.949982 */
10258                  -32404,        /* A2 = 0.988922 */
10259                  -269,          /* B2 = -0.008216 */
10260                  0,             /* B1 = 0.000000 */
10261                  269,           /* B0 = 0.008216 */
10262                  15310,         /* A1 = -0.934479 */
10263                  -32632,        /* A2 = 0.995880 */
10264                  10815,         /* B2 = 0.330063 */
10265                  -4962,         /* B1 = -0.302887 */
10266                  10815,         /* B0 = 0.330063 */
10267                  15924,         /* A1 = -0.971924 */
10268                  -32634,        /* A2 = 0.995941 */
10269                  18880,         /* B2 = 0.576172 */
10270                  -9364,         /* B1 = -0.571594 */
10271                  18880,         /* B0 = 0.576172 */
10272                  5,             /* Internal filter scaling */
10273                  159,           /* Minimum in-band energy threshold */
10274                  21,            /* 21/32 in-band to broad-band ratio */
10275                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10276         },
10277         {                       /* f1380 */
10278                 15247,          /* A1 = -0.930603 */
10279                  -32397,        /* A2 = 0.988708 */
10280                  -244,          /* B2 = -0.007451 */
10281                  0,             /* B1 = 0.000000 */
10282                  244,           /* B0 = 0.007451 */
10283                  14989,         /* A1 = -0.914886 */
10284                  -32627,        /* A2 = 0.995697 */
10285                  18961,         /* B2 = 0.578644 */
10286                  -8498,         /* B1 = -0.518707 */
10287                  18961,         /* B0 = 0.578644 */
10288                  15608,         /* A1 = -0.952667 */
10289                  -32628,        /* A2 = 0.995758 */
10290                  11145,         /* B2 = 0.340134 */
10291                  -5430,         /* B1 = -0.331467 */
10292                  11145,         /* B0 = 0.340134 */
10293                  5,             /* Internal filter scaling */
10294                  159,           /* Minimum in-band energy threshold */
10295                  21,            /* 21/32 in-band to broad-band ratio */
10296                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10297         },
10298         {                       /* f1400 */
10299                 14780,          /* A1 = -0.902130 */
10300                  -32393,        /* A2 = 0.988586 */
10301                  -396,          /* B2 = -0.012086 */
10302                  0,             /* B1 = 0.000000 */
10303                  396,           /* B0 = 0.012086 */
10304                  14510,         /* A1 = -0.885651 */
10305                  -32630,        /* A2 = 0.995819 */
10306                  6326,          /* B2 = 0.193069 */
10307                  -2747,         /* B1 = -0.167671 */
10308                  6326,          /* B0 = 0.193069 */
10309                  15154,         /* A1 = -0.924957 */
10310                  -32632,        /* A2 = 0.995850 */
10311                  23235,         /* B2 = 0.709076 */
10312                  -10983,        /* B1 = -0.670380 */
10313                  23235,         /* B0 = 0.709076 */
10314                  5,             /* Internal filter scaling */
10315                  159,           /* Minimum in-band energy threshold */
10316                  21,            /* 21/32 in-band to broad-band ratio */
10317                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10318         },
10319         {                       /* f1477 */
10320                 13005,          /* A1 = -0.793793 */
10321                  -32368,        /* A2 = 0.987823 */
10322                  -500,          /* B2 = -0.015265 */
10323                  0,             /* B1 = 0.000000 */
10324                  500,           /* B0 = 0.015265 */
10325                  12708,         /* A1 = -0.775665 */
10326                  -32615,        /* A2 = 0.995331 */
10327                  11420,         /* B2 = 0.348526 */
10328                  -4306,         /* B1 = -0.262833 */
10329                  11420,         /* B0 = 0.348526 */
10330                  13397,         /* A1 = -0.817688 */
10331                  -32615,        /* A2 = 0.995361 */
10332                  9454,          /* B2 = 0.288528 */
10333                  -3981,         /* B1 = -0.243027 */
10334                  9454,          /* B0 = 0.288528 */
10335                  5,             /* Internal filter scaling */
10336                  159,           /* Minimum in-band energy threshold */
10337                  21,            /* 21/32 in-band to broad-band ratio */
10338                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10339         },
10340         {                       /* f1600 */
10341                 10046,          /* A1 = -0.613190 */
10342                  -32331,        /* A2 = 0.986694 */
10343                  -455,          /* B2 = -0.013915 */
10344                  0,             /* B1 = 0.000000 */
10345                  455,           /* B0 = 0.013915 */
10346                  9694,          /* A1 = -0.591705 */
10347                  -32601,        /* A2 = 0.994934 */
10348                  6023,          /* B2 = 0.183815 */
10349                  -1708,         /* B1 = -0.104279 */
10350                  6023,          /* B0 = 0.183815 */
10351                  10478,         /* A1 = -0.639587 */
10352                  -32603,        /* A2 = 0.994965 */
10353                  22031,         /* B2 = 0.672333 */
10354                  -7342,         /* B1 = -0.448151 */
10355                  22031,         /* B0 = 0.672333 */
10356                  5,             /* Internal filter scaling */
10357                  159,           /* Minimum in-band energy threshold */
10358                  21,            /* 21/32 in-band to broad-band ratio */
10359                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10360         },
10361         {                       /* f1633_1638[] */
10362                 9181,           /* A1 = 0.560394 */
10363                  -32256,        /* A2 = -0.984375 */
10364                  -556,          /* B2 = -0.016975 */
10365                  0,             /* B1 = 0 */
10366                  556,           /* B0 = 0.016975 */
10367                  8757,          /* A1 = 0.534515 */
10368                  -32574,        /* A2 = -0.99408 */
10369                  8443,          /* B2 = 0.25769 */
10370                  -2135,         /* B1 = -0.130341 */
10371                  8443,          /* B0 = 0.25769 */
10372                  9691,          /* A1 = 0.591522 */
10373                  -32574,        /* A2 = -0.99411 */
10374                  15446,         /* B2 = 0.471375 */
10375                  -4809,         /* B1 = -0.293579 */
10376                  15446,         /* B0 = 0.471375 */
10377                  7,             /* Internal filter scaling */
10378                  159,           /* Minimum in-band energy threshold */
10379                  21,            /* 21/32 in-band to broad-band ratio */
10380                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10381         },
10382         {                       /* f1800 */
10383                 5076,           /* A1 = -0.309875 */
10384                  -32304,        /* A2 = 0.985840 */
10385                  -508,          /* B2 = -0.015503 */
10386                  0,             /* B1 = 0.000000 */
10387                  508,           /* B0 = 0.015503 */
10388                  4646,          /* A1 = -0.283600 */
10389                  -32605,        /* A2 = 0.995026 */
10390                  6742,          /* B2 = 0.205780 */
10391                  -878,          /* B1 = -0.053635 */
10392                  6742,          /* B0 = 0.205780 */
10393                  5552,          /* A1 = -0.338928 */
10394                  -32605,        /* A2 = 0.995056 */
10395                  23667,         /* B2 = 0.722260 */
10396                  -4297,         /* B1 = -0.262329 */
10397                  23667,         /* B0 = 0.722260 */
10398                  5,             /* Internal filter scaling */
10399                  159,           /* Minimum in-band energy threshold */
10400                  21,            /* 21/32 in-band to broad-band ratio */
10401                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10402         },
10403         {                       /* f1860 */
10404                 3569,           /* A1 = -0.217865 */
10405                  -32292,        /* A2 = 0.985504 */
10406                  -239,          /* B2 = -0.007322 */
10407                  0,             /* B1 = 0.000000 */
10408                  239,           /* B0 = 0.007322 */
10409                  3117,          /* A1 = -0.190277 */
10410                  -32603,        /* A2 = 0.994965 */
10411                  18658,         /* B2 = 0.569427 */
10412                  -1557,         /* B1 = -0.095032 */
10413                  18658,         /* B0 = 0.569427 */
10414                  4054,          /* A1 = -0.247437 */
10415                  -32603,        /* A2 = 0.994965 */
10416                  18886,         /* B2 = 0.576385 */
10417                  -2566,         /* B1 = -0.156647 */
10418                  18886,         /* B0 = 0.576385 */
10419                  5,             /* Internal filter scaling */
10420                  159,           /* Minimum in-band energy threshold */
10421                  21,            /* 21/32 in-band to broad-band ratio */
10422                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10423         },
10424 };
10425 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10426 {
10427         unsigned short cmd;
10428         int cnt, max;
10429
10430         if (jf->filter > 3) {
10431                 return -1;
10432         }
10433         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10434
10435                 return -1;
10436         if (!jf->enable) {
10437                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10438
10439                         return -1;
10440                 else
10441                         return 0;
10442         } else {
10443                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10444
10445                         return -1;
10446                 /* Select the filter (f0 - f3) to use. */
10447                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10448                         return -1;
10449         }
10450         if (jf->freq < 12 && jf->freq > 3) {
10451                 /* Select the frequency for the selected filter. */
10452                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10453                         return -1;
10454         } else if (jf->freq > 11) {
10455                 /* We need to load a programmable filter set for undefined */
10456                 /* frequencies.  So we will point the filter to a programmable set. */
10457                 /* Since there are only 4 filters and 4 programmable sets, we will */
10458                 /* just point the filter to the same number set and program it for the */
10459                 /* frequency we want. */
10460                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10461                         return -1;
10462                 if (j->ver.low != 0x12) {
10463                         cmd = 0x515B;
10464                         max = 19;
10465                 } else {
10466                         cmd = 0x515E;
10467                         max = 15;
10468                 }
10469                 if (ixj_WriteDSPCommand(cmd, j))
10470                         return -1;
10471                 for (cnt = 0; cnt < max; cnt++) {
10472                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10473                                 return -1;
10474                 }
10475         }
10476         j->filter_en[jf->filter] = jf->enable;
10477         return 0;
10478 }
10479
10480 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10481 {
10482         unsigned short cmd;
10483         int cnt, max;
10484         if (jfr->filter > 3) {
10485                 return -1;
10486         }
10487         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10488                 return -1;
10489
10490         if (!jfr->enable) {
10491                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10492                         return -1;
10493                 else
10494                         return 0;
10495         } else {
10496                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10497                         return -1;
10498                 /* Select the filter (f0 - f3) to use. */
10499                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10500                         return -1;
10501         }
10502         /* We need to load a programmable filter set for undefined */
10503         /* frequencies.  So we will point the filter to a programmable set. */
10504         /* Since there are only 4 filters and 4 programmable sets, we will */
10505         /* just point the filter to the same number set and program it for the */
10506         /* frequency we want. */
10507         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10508                 return -1;
10509         if (j->ver.low != 0x12) {
10510                 cmd = 0x515B;
10511                 max = 19;
10512         } else {
10513                 cmd = 0x515E;
10514                 max = 15;
10515         }
10516         if (ixj_WriteDSPCommand(cmd, j))
10517                 return -1;
10518         for (cnt = 0; cnt < max; cnt++) {
10519                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10520                         return -1;
10521         }
10522         j->filter_en[jfr->filter] = jfr->enable;
10523         return 0;
10524 }
10525
10526 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10527 {
10528         int freq0, freq1;
10529         unsigned short data;
10530         if (ti->freq0) {
10531                 freq0 = ti->freq0;
10532         } else {
10533                 freq0 = 0x7FFF;
10534         }
10535
10536         if (ti->freq1) {
10537                 freq1 = ti->freq1;
10538         } else {
10539                 freq1 = 0x7FFF;
10540         }
10541
10542         if(ti->tone_index > 12 && ti->tone_index < 28)
10543         {
10544                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10545                         return -1;
10546                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10547                         return -1;
10548                 data = freq0;
10549                 if (ixj_WriteDSPCommand(data, j))
10550                         return -1;
10551                 data = freq1;
10552                 if (ixj_WriteDSPCommand(data, j))
10553                         return -1;
10554         }
10555         return freq0;
10556 }
10557