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/mutex.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 DEFINE_MUTEX(ixj_mutex);
 281 static int ixjdebug;
 282 static int hertz = HZ;
 283 static int samplerate = 100;
 284
 285 module_param(ixjdebug, int, 0);
 286
 287 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
 288         { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
 289           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 290         { }
 291 };
 292
 293 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 294
 295 /************************************************************************
 296 *
 297 * ixjdebug meanings are now bit mapped instead of level based
 298 * Values can be or'ed together to turn on multiple messages
 299 *
 300 * bit  0 (0x0001) = any failure
 301 * bit  1 (0x0002) = general messages
 302 * bit  2 (0x0004) = POTS ringing related
 303 * bit  3 (0x0008) = PSTN events
 304 * bit  4 (0x0010) = PSTN Cadence state details
 305 * bit  5 (0x0020) = Tone detection triggers
 306 * bit  6 (0x0040) = Tone detection cadence details
 307 * bit  7 (0x0080) = ioctl tracking
 308 * bit  8 (0x0100) = signal tracking
 309 * bit  9 (0x0200) = CallerID generation details
 310 *
 311 ************************************************************************/
 312
 313 #ifdef IXJ_DYN_ALLOC
 314
 315 static IXJ *ixj[IXJMAX];
 316 #define get_ixj(b)      ixj[(b)]
 317
 318 /*
 319  *      Allocate a free IXJ device
 320  */
 321
 322 static IXJ *ixj_alloc()
 323 {
 324         for(cnt=0; cnt<IXJMAX; cnt++)
 325         {
 326                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 327                 {
 328                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 329                         if (j == NULL)
 330                                 return NULL;
 331                         ixj[cnt] = j;
 332                         return j;
 333                 }
 334         }
 335         return NULL;
 336 }
 337
 338 static void ixj_fsk_free(IXJ *j)
 339 {
 340         kfree(j->fskdata);
 341         j->fskdata = NULL;
 342 }
 343
 344 static void ixj_fsk_alloc(IXJ *j)
 345 {
 346         if(!j->fskdata) {
 347                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 348                 if (!j->fskdata) {
 349                         if(ixjdebug & 0x0200) {
 350                                 printk("IXJ phone%d - allocate failed\n", j->board);
 351                         }
 352                         return;
 353                 } else {
 354                         j->fsksize = 8000;
 355                         if(ixjdebug & 0x0200) {
 356                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 357                         }
 358                 }
 359         }
 360 }
 361
 362 #else
 363
 364 static IXJ ixj[IXJMAX];
 365 #define get_ixj(b)      (&ixj[(b)])
 366
 367 /*
 368  *      Allocate a free IXJ device
 369  */
 370
 371 static IXJ *ixj_alloc(void)
 372 {
 373         int cnt;
 374         for(cnt=0; cnt<IXJMAX; cnt++) {
 375                 if(!ixj[cnt].DSPbase)
 376                         return &ixj[cnt];
 377         }
 378         return NULL;
 379 }
 380
 381 static inline void ixj_fsk_free(IXJ *j) {;}
 382
 383 static inline void ixj_fsk_alloc(IXJ *j)
 384 {
 385         j->fsksize = 8000;
 386 }
 387
 388 #endif
 389
 390 #ifdef PERFMON_STATS
 391 #define ixj_perfmon(x)  ((x)++)
 392 #else
 393 #define ixj_perfmon(x)  do { } while(0)
 394 #endif
 395
 396 static int ixj_convert_loaded;
 397
 398 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 399
 400 /************************************************************************
 401 *
 402 * These are function definitions to allow external modules to register
 403 * enhanced functionality call backs.
 404 *
 405 ************************************************************************/
 406
 407 static int Stub(IXJ * J, unsigned long arg)
 408 {
 409         return 0;
 410 }
 411
 412 static IXJ_REGFUNC ixj_PreRead = &Stub;
 413 static IXJ_REGFUNC ixj_PostRead = &Stub;
 414 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 415 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 416
 417 static void ixj_read_frame(IXJ *j);
 418 static void ixj_write_frame(IXJ *j);
 419 static void ixj_init_timer(IXJ *j);
 420 static void ixj_add_timer(IXJ * j);
 421 static void ixj_timeout(unsigned long ptr);
 422 static int read_filters(IXJ *j);
 423 static int LineMonitor(IXJ *j);
 424 static int ixj_fasync(int fd, struct file *, int mode);
 425 static int ixj_set_port(IXJ *j, int arg);
 426 static int ixj_set_pots(IXJ *j, int arg);
 427 static int ixj_hookstate(IXJ *j);
 428 static int ixj_record_start(IXJ *j);
 429 static void ixj_record_stop(IXJ *j);
 430 static void set_rec_volume(IXJ *j, int volume);
 431 static int get_rec_volume(IXJ *j);
 432 static int set_rec_codec(IXJ *j, int rate);
 433 static void ixj_vad(IXJ *j, int arg);
 434 static int ixj_play_start(IXJ *j);
 435 static void ixj_play_stop(IXJ *j);
 436 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 437 static int ixj_set_tone_off(unsigned short, IXJ *j);
 438 static int ixj_play_tone(IXJ *j, char tone);
 439 static void ixj_aec_start(IXJ *j, int level);
 440 static int idle(IXJ *j);
 441 static void ixj_ring_on(IXJ *j);
 442 static void ixj_ring_off(IXJ *j);
 443 static void aec_stop(IXJ *j);
 444 static void ixj_ringback(IXJ *j);
 445 static void ixj_busytone(IXJ *j);
 446 static void ixj_dialtone(IXJ *j);
 447 static void ixj_cpt_stop(IXJ *j);
 448 static char daa_int_read(IXJ *j);
 449 static char daa_CR_read(IXJ *j, int cr);
 450 static int daa_set_mode(IXJ *j, int mode);
 451 static int ixj_linetest(IXJ *j);
 452 static int ixj_daa_write(IXJ *j);
 453 static int ixj_daa_cid_read(IXJ *j);
 454 static void DAA_Coeff_US(IXJ *j);
 455 static void DAA_Coeff_UK(IXJ *j);
 456 static void DAA_Coeff_France(IXJ *j);
 457 static void DAA_Coeff_Germany(IXJ *j);
 458 static void DAA_Coeff_Australia(IXJ *j);
 459 static void DAA_Coeff_Japan(IXJ *j);
 460 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 461 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 462 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 463 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 464 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 465 /* Serial Control Interface funtions */
 466 static int SCI_Control(IXJ *j, int control);
 467 static int SCI_Prepare(IXJ *j);
 468 static int SCI_WaitHighSCI(IXJ *j);
 469 static int SCI_WaitLowSCI(IXJ *j);
 470 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 471 static int ixj_PCcontrol_wait(IXJ *j);
 472 static void ixj_pre_cid(IXJ *j);
 473 static void ixj_write_cid(IXJ *j);
 474 static void ixj_write_cid_bit(IXJ *j, int bit);
 475 static int set_base_frame(IXJ *j, int size);
 476 static int set_play_codec(IXJ *j, int rate);
 477 static void set_rec_depth(IXJ *j, int depth);
 478 static int ixj_mixer(long val, IXJ *j);
 479
 480 /************************************************************************
 481 CT8020/CT8021 Host Programmers Model
 482 Host address    Function                                        Access
 483 DSPbase +
 484 0-1             Aux Software Status Register (reserved)         Read Only
 485 2-3             Software Status Register                        Read Only
 486 4-5             Aux Software Control Register (reserved)        Read Write
 487 6-7             Software Control Register                       Read Write
 488 8-9             Hardware Status Register                        Read Only
 489 A-B             Hardware Control Register                       Read Write
 490 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 491 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 492 ************************************************************************/
 493
 494 static inline void ixj_read_HSR(IXJ *j)
 495 {
 496         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 497         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 498 }
 499
 500 static inline int IsControlReady(IXJ *j)
 501 {
 502         ixj_read_HSR(j);
 503         return j->hsr.bits.controlrdy ? 1 : 0;
 504 }
 505
 506 static inline int IsPCControlReady(IXJ *j)
 507 {
 508         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 509         return j->pccr1.bits.crr ? 1 : 0;
 510 }
 511
 512 static inline int IsStatusReady(IXJ *j)
 513 {
 514         ixj_read_HSR(j);
 515         return j->hsr.bits.statusrdy ? 1 : 0;
 516 }
 517
 518 static inline int IsRxReady(IXJ *j)
 519 {
 520         ixj_read_HSR(j);
 521         ixj_perfmon(j->rxreadycheck);
 522         return j->hsr.bits.rxrdy ? 1 : 0;
 523 }
 524
 525 static inline int IsTxReady(IXJ *j)
 526 {
 527         ixj_read_HSR(j);
 528         ixj_perfmon(j->txreadycheck);
 529         return j->hsr.bits.txrdy ? 1 : 0;
 530 }
 531
 532 static inline void set_play_volume(IXJ *j, int volume)
 533 {
 534         if (ixjdebug & 0x0002)
 535                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 536         ixj_WriteDSPCommand(0xCF02, j);
 537         ixj_WriteDSPCommand(volume, j);
 538 }
 539
 540 static int set_play_volume_linear(IXJ *j, int volume)
 541 {
 542         int newvolume, dspplaymax;
 543
 544         if (ixjdebug & 0x0002)
 545                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 546         if(volume > 100 || volume < 0) {
 547                 return -1;
 548         }
 549
 550         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 551         switch (j->cardtype) {
 552         case QTI_PHONEJACK:
 553                 dspplaymax = 0x380;
 554                 break;
 555         case QTI_LINEJACK:
 556                 if(j->port == PORT_PSTN) {
 557                         dspplaymax = 0x48;
 558                 } else {
 559                         dspplaymax = 0x100;
 560                 }
 561                 break;
 562         case QTI_PHONEJACK_LITE:
 563                 dspplaymax = 0x380;
 564                 break;
 565         case QTI_PHONEJACK_PCI:
 566                 dspplaymax = 0x6C;
 567                 break;
 568         case QTI_PHONECARD:
 569                 dspplaymax = 0x50;
 570                 break;
 571         default:
 572                 return -1;
 573         }
 574         newvolume = (dspplaymax * volume) / 100;
 575         set_play_volume(j, newvolume);
 576         return 0;
 577 }
 578
 579 static inline void set_play_depth(IXJ *j, int depth)
 580 {
 581         if (depth > 60)
 582                 depth = 60;
 583         if (depth < 0)
 584                 depth = 0;
 585         ixj_WriteDSPCommand(0x5280 + depth, j);
 586 }
 587
 588 static inline int get_play_volume(IXJ *j)
 589 {
 590         ixj_WriteDSPCommand(0xCF00, j);
 591         return j->ssr.high << 8 | j->ssr.low;
 592 }
 593
 594 static int get_play_volume_linear(IXJ *j)
 595 {
 596         int volume, newvolume, dspplaymax;
 597
 598         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 599         switch (j->cardtype) {
 600         case QTI_PHONEJACK:
 601                 dspplaymax = 0x380;
 602                 break;
 603         case QTI_LINEJACK:
 604                 if(j->port == PORT_PSTN) {
 605                         dspplaymax = 0x48;
 606                 } else {
 607                         dspplaymax = 0x100;
 608                 }
 609                 break;
 610         case QTI_PHONEJACK_LITE:
 611                 dspplaymax = 0x380;
 612                 break;
 613         case QTI_PHONEJACK_PCI:
 614                 dspplaymax = 0x6C;
 615                 break;
 616         case QTI_PHONECARD:
 617                 dspplaymax = 100;
 618                 break;
 619         default:
 620                 return -1;
 621         }
 622         volume = get_play_volume(j);
 623         newvolume = (volume * 100) / dspplaymax;
 624         if(newvolume > 100)
 625                 newvolume = 100;
 626         return newvolume;
 627 }
 628
 629 static inline BYTE SLIC_GetState(IXJ *j)
 630 {
 631         if (j->cardtype == QTI_PHONECARD) {
 632                 j->pccr1.byte = 0;
 633                 j->psccr.bits.dev = 3;
 634                 j->psccr.bits.rw = 1;
 635                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 636                 ixj_PCcontrol_wait(j);
 637                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 638                 ixj_PCcontrol_wait(j);
 639                 if (j->pslic.bits.powerdown)
 640                         return PLD_SLIC_STATE_OC;
 641                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 642                         return PLD_SLIC_STATE_ACTIVE;
 643                 else
 644                         return PLD_SLIC_STATE_RINGING;
 645         } else {
 646                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 647         }
 648         return j->pld_slicr.bits.state;
 649 }
 650
 651 static bool SLIC_SetState(BYTE byState, IXJ *j)
 652 {
 653         bool fRetVal = false;
 654
 655         if (j->cardtype == QTI_PHONECARD) {
 656                 if (j->flags.pcmciasct) {
 657                         switch (byState) {
 658                         case PLD_SLIC_STATE_TIPOPEN:
 659                         case PLD_SLIC_STATE_OC:
 660                                 j->pslic.bits.powerdown = 1;
 661                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 662                                 fRetVal = true;
 663                                 break;
 664                         case PLD_SLIC_STATE_RINGING:
 665                                 if (j->readers || j->writers) {
 666                                         j->pslic.bits.powerdown = 0;
 667                                         j->pslic.bits.ring0 = 1;
 668                                         j->pslic.bits.ring1 = 0;
 669                                         fRetVal = true;
 670                                 }
 671                                 break;
 672                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 673
 674                         case PLD_SLIC_STATE_STANDBY:
 675                         case PLD_SLIC_STATE_ACTIVE:
 676                                 if (j->readers || j->writers) {
 677                                         j->pslic.bits.powerdown = 0;
 678                                 } else {
 679                                         j->pslic.bits.powerdown = 1;
 680                                 }
 681                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 682                                 fRetVal = true;
 683                                 break;
 684                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 685
 686                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 687
 688                         default:
 689                                 fRetVal = false;
 690                                 break;
 691                         }
 692                         j->psccr.bits.dev = 3;
 693                         j->psccr.bits.rw = 0;
 694                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 695                         ixj_PCcontrol_wait(j);
 696                 }
 697         } else {
 698                 /* Set the C1, C2, C3 & B2EN signals. */
 699                 switch (byState) {
 700                 case PLD_SLIC_STATE_OC:
 701                         j->pld_slicw.bits.c1 = 0;
 702                         j->pld_slicw.bits.c2 = 0;
 703                         j->pld_slicw.bits.c3 = 0;
 704                         j->pld_slicw.bits.b2en = 0;
 705                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 706                         fRetVal = true;
 707                         break;
 708                 case PLD_SLIC_STATE_RINGING:
 709                         j->pld_slicw.bits.c1 = 1;
 710                         j->pld_slicw.bits.c2 = 0;
 711                         j->pld_slicw.bits.c3 = 0;
 712                         j->pld_slicw.bits.b2en = 1;
 713                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 714                         fRetVal = true;
 715                         break;
 716                 case PLD_SLIC_STATE_ACTIVE:
 717                         j->pld_slicw.bits.c1 = 0;
 718                         j->pld_slicw.bits.c2 = 1;
 719                         j->pld_slicw.bits.c3 = 0;
 720                         j->pld_slicw.bits.b2en = 0;
 721                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 722                         fRetVal = true;
 723                         break;
 724                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 725
 726                         j->pld_slicw.bits.c1 = 1;
 727                         j->pld_slicw.bits.c2 = 1;
 728                         j->pld_slicw.bits.c3 = 0;
 729                         j->pld_slicw.bits.b2en = 0;
 730                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 731                         fRetVal = true;
 732                         break;
 733                 case PLD_SLIC_STATE_TIPOPEN:
 734                         j->pld_slicw.bits.c1 = 0;
 735                         j->pld_slicw.bits.c2 = 0;
 736                         j->pld_slicw.bits.c3 = 1;
 737                         j->pld_slicw.bits.b2en = 0;
 738                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 739                         fRetVal = true;
 740                         break;
 741                 case PLD_SLIC_STATE_STANDBY:
 742                         j->pld_slicw.bits.c1 = 1;
 743                         j->pld_slicw.bits.c2 = 0;
 744                         j->pld_slicw.bits.c3 = 1;
 745                         j->pld_slicw.bits.b2en = 1;
 746                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 747                         fRetVal = true;
 748                         break;
 749                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 750
 751                         j->pld_slicw.bits.c1 = 0;
 752                         j->pld_slicw.bits.c2 = 1;
 753                         j->pld_slicw.bits.c3 = 1;
 754                         j->pld_slicw.bits.b2en = 0;
 755                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 756                         fRetVal = true;
 757                         break;
 758                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 759
 760                         j->pld_slicw.bits.c1 = 1;
 761                         j->pld_slicw.bits.c2 = 1;
 762                         j->pld_slicw.bits.c3 = 1;
 763                         j->pld_slicw.bits.b2en = 0;
 764                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 765                         fRetVal = true;
 766                         break;
 767                 default:
 768                         fRetVal = false;
 769                         break;
 770                 }
 771         }
 772
 773         return fRetVal;
 774 }
 775
 776 static int ixj_wink(IXJ *j)
 777 {
 778         BYTE slicnow;
 779
 780         slicnow = SLIC_GetState(j);
 781
 782         j->pots_winkstart = jiffies;
 783         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 784
 785         msleep(jiffies_to_msecs(j->winktime));
 786
 787         SLIC_SetState(slicnow, j);
 788         return 0;
 789 }
 790
 791 static void ixj_init_timer(IXJ *j)
 792 {
 793         init_timer(&j->timer);
 794         j->timer.function = ixj_timeout;
 795         j->timer.data = (unsigned long)j;
 796 }
 797
 798 static void ixj_add_timer(IXJ *j)
 799 {
 800         j->timer.expires = jiffies + (hertz / samplerate);
 801         add_timer(&j->timer);
 802 }
 803
 804 static void ixj_tone_timeout(IXJ *j)
 805 {
 806         IXJ_TONE ti;
 807
 808         j->tone_state++;
 809         if (j->tone_state == 3) {
 810                 j->tone_state = 0;
 811                 if (j->cadence_t) {
 812                         j->tone_cadence_state++;
 813                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 814                                 switch (j->cadence_t->termination) {
 815                                 case PLAY_ONCE:
 816                                         ixj_cpt_stop(j);
 817                                         break;
 818                                 case REPEAT_LAST_ELEMENT:
 819                                         j->tone_cadence_state--;
 820                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 821                                         break;
 822                                 case REPEAT_ALL:
 823                                         j->tone_cadence_state = 0;
 824                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 825                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 826                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 827                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 828                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 829                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 830                                                 ixj_init_tone(j, &ti);
 831                                         }
 832                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 833                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 834                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 835                                         break;
 836                                 }
 837                         } else {
 838                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 839                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 840                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 841                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 842                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 843                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 844                                         ixj_init_tone(j, &ti);
 845                                 }
 846                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 847                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 848                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 849                         }
 850                 }
 851         }
 852 }
 853
 854 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 855 {
 856         if(j->ixj_signals[event]) {
 857                 if(ixjdebug & 0x0100)
 858                         printk("Sending signal for event %d\n", event);
 859                         /* Send apps notice of change */
 860                 /* see config.h for macro definition */
 861                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 862         }
 863 }
 864
 865 static void ixj_pstn_state(IXJ *j)
 866 {
 867         int var;
 868         union XOPXR0 XR0, daaint;
 869
 870         var = 10;
 871
 872         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 873         daaint.reg = 0;
 874         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 875
 876         j->pld_scrr.byte = inb_p(j->XILINXbase);
 877         if (j->pld_scrr.bits.daaflag) {
 878                 daa_int_read(j);
 879                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 880                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 881                                 daaint.bitreg.RING = 1;
 882                                 if(ixjdebug & 0x0008) {
 883                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 884                                 }
 885                         } else {
 886                                 daa_set_mode(j, SOP_PU_RESET);
 887                         }
 888                 }
 889                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 890                         daaint.bitreg.Caller_ID = 1;
 891                         j->pstn_cid_intr = 1;
 892                         j->pstn_cid_received = jiffies;
 893                         if(ixjdebug & 0x0008) {
 894                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 895                         }
 896                 }
 897                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 898                         daaint.bitreg.Cadence = 1;
 899                         if(ixjdebug & 0x0008) {
 900                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 901                         }
 902                 }
 903                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 904                         daaint.bitreg.VDD_OK = 1;
 905                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 906                 }
 907         }
 908         daa_CR_read(j, 1);
 909         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)) {
 910                 daaint.bitreg.RMR = 1;
 911                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 912                 if(ixjdebug & 0x0008) {
 913                         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);
 914                 }
 915                 j->pstn_prev_rmr = j->pstn_last_rmr;
 916                 j->pstn_last_rmr = jiffies;
 917         }
 918         switch(j->daa_mode) {
 919                 case SOP_PU_SLEEP:
 920                         if (daaint.bitreg.RING) {
 921                                 if (!j->flags.pstn_ringing) {
 922                                         if (j->daa_mode != SOP_PU_RINGING) {
 923                                                 j->pstn_ring_int = jiffies;
 924                                                 daa_set_mode(j, SOP_PU_RINGING);
 925                                         }
 926                                 }
 927                         }
 928                         break;
 929                 case SOP_PU_RINGING:
 930                         if (daaint.bitreg.RMR) {
 931                                 if (ixjdebug & 0x0008) {
 932                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 933                                 }
 934                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 935                                         j->flags.pstn_rmr = 1;
 936                                         j->pstn_ring_start = jiffies;
 937                                         j->pstn_ring_stop = 0;
 938                                         j->ex.bits.pstn_ring = 0;
 939                                         if (j->cadence_f[4].state == 0) {
 940                                                 j->cadence_f[4].state = 1;
 941                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 942                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 943                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 944                                         } else if (j->cadence_f[4].state == 2) {
 945                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 946                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 947                                                         if (j->cadence_f[4].on2) {
 948                                                                 j->cadence_f[4].state = 3;
 949                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 950                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 951                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 952                                                         } else {
 953                                                                 j->cadence_f[4].state = 7;
 954                                                         }
 955                                                 } else {
 956                                                         if (ixjdebug & 0x0008) {
 957                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 958                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 959                                                                                 j->cadence_f[4].off1);
 960                                                         }
 961                                                         j->cadence_f[4].state = 0;
 962                                                 }
 963                                         } else if (j->cadence_f[4].state == 4) {
 964                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 965                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 966                                                         if (j->cadence_f[4].on3) {
 967                                                                 j->cadence_f[4].state = 5;
 968                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 969                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 970                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 971                                                         } else {
 972                                                                 j->cadence_f[4].state = 7;
 973                                                         }
 974                                                 } else {
 975                                                         if (ixjdebug & 0x0008) {
 976                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 977                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 978                                                                                 j->cadence_f[4].off2);
 979                                                         }
 980                                                         j->cadence_f[4].state = 0;
 981                                                 }
 982                                         } else if (j->cadence_f[4].state == 6) {
 983                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 984                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 985                                                         j->cadence_f[4].state = 7;
 986                                                 } else {
 987                                                         if (ixjdebug & 0x0008) {
 988                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 989                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 990                                                                                 j->cadence_f[4].off3);
 991                                                         }
 992                                                         j->cadence_f[4].state = 0;
 993                                                 }
 994                                         } else {
 995                                                 j->cadence_f[4].state = 0;
 996                                         }
 997                                 } else {                                /* Falling edge of RMR */
 998                                         j->pstn_ring_start = 0;
 999                                         j->pstn_ring_stop = jiffies;
1000                                         if (j->cadence_f[4].state == 1) {
1001                                                 if(!j->cadence_f[4].on1) {
1002                                                         j->cadence_f[4].state = 7;
1003                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1004                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1005                                                         if (j->cadence_f[4].off1) {
1006                                                                 j->cadence_f[4].state = 2;
1007                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1008                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1009                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1010                                                         } else {
1011                                                                 j->cadence_f[4].state = 7;
1012                                                         }
1013                                                 } else {
1014                                                         if (ixjdebug & 0x0008) {
1015                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1016                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1017                                                                                 j->cadence_f[4].on1);
1018                                                         }
1019                                                         j->cadence_f[4].state = 0;
1020                                                 }
1021                                         } else if (j->cadence_f[4].state == 3) {
1022                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1023                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1024                                                         if (j->cadence_f[4].off2) {
1025                                                                 j->cadence_f[4].state = 4;
1026                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1027                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1028                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1029                                                         } else {
1030                                                                 j->cadence_f[4].state = 7;
1031                                                         }
1032                                                 } else {
1033                                                         if (ixjdebug & 0x0008) {
1034                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1035                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1036                                                                                 j->cadence_f[4].on2);
1037                                                         }
1038                                                         j->cadence_f[4].state = 0;
1039                                                 }
1040                                         } else if (j->cadence_f[4].state == 5) {
1041                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1042                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1043                                                         if (j->cadence_f[4].off3) {
1044                                                                 j->cadence_f[4].state = 6;
1045                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1046                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1047                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1048                                                         } else {
1049                                                                 j->cadence_f[4].state = 7;
1050                                                         }
1051                                                 } else {
1052                                                         j->cadence_f[4].state = 0;
1053                                                 }
1054                                         } else {
1055                                                 if (ixjdebug & 0x0008) {
1056                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1057                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1058                                                                         j->cadence_f[4].on3);
1059                                                 }
1060                                                 j->cadence_f[4].state = 0;
1061                                         }
1062                                 }
1063                                 if (ixjdebug & 0x0010) {
1064                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1065                                 }
1066                                 if (ixjdebug & 0x0010) {
1067                                         switch(j->cadence_f[4].state) {
1068                                                 case 1:
1069                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1071                                                         break;
1072                                                 case 2:
1073                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1075                                                         break;
1076                                                 case 3:
1077                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1079                                                         break;
1080                                                 case 4:
1081                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1083                                                         break;
1084                                                 case 5:
1085                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1086                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1087                                                         break;
1088                                                 case 6:
1089                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1090                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1091                                                         break;
1092                                         }
1093                                 }
1094                         }
1095                         if (j->cadence_f[4].state == 7) {
1096                                 j->cadence_f[4].state = 0;
1097                                 j->pstn_ring_stop = jiffies;
1098                                 j->ex.bits.pstn_ring = 1;
1099                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1100                                 if(ixjdebug & 0x0008) {
1101                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1102                                 }
1103                         }
1104                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1105                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1106                                 if(ixjdebug & 0x0008) {
1107                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1108                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1109                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1110                                 }
1111                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1112                                 daa_set_mode(j, SOP_PU_SLEEP);
1113                         }
1114                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1115                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1116                                 ixj_daa_cid_read(j);
1117                                 j->ex.bits.caller_id = 1;
1118                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1119                                 j->pstn_cid_intr = 0;
1120                         }
1121                         if (daaint.bitreg.Cadence) {
1122                                 if(ixjdebug & 0x0008) {
1123                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1124                                 }
1125                                 daa_set_mode(j, SOP_PU_SLEEP);
1126                                 j->ex.bits.pstn_ring = 0;
1127                         }
1128                         break;
1129                 case SOP_PU_CONVERSATION:
1130                         if (daaint.bitreg.VDD_OK) {
1131                                 if(!daaint.bitreg.SI_0) {
1132                                         if (!j->pstn_winkstart) {
1133                                                 if(ixjdebug & 0x0008) {
1134                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1135                                                 }
1136                                                 j->pstn_winkstart = jiffies;
1137                                         }
1138                                 } else {
1139                                         if (j->pstn_winkstart) {
1140                                                 if(ixjdebug & 0x0008) {
1141                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1142                                                 }
1143                                                 j->pstn_winkstart = 0;
1144                                         }
1145                                 }
1146                         }
1147                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1148                                 if(ixjdebug & 0x0008) {
1149                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1150                                 }
1151                                 daa_set_mode(j, SOP_PU_SLEEP);
1152                                 j->pstn_winkstart = 0;
1153                                 j->ex.bits.pstn_wink = 1;
1154                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1155                         }
1156                         break;
1157         }
1158 }
1159
1160 static void ixj_timeout(unsigned long ptr)
1161 {
1162         int board;
1163         unsigned long jifon;
1164         IXJ *j = (IXJ *)ptr;
1165         board = j->board;
1166
1167         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1168                 ixj_perfmon(j->timerchecks);
1169                 j->hookstate = ixj_hookstate(j);
1170                 if (j->tone_state) {
1171                         if (!(j->hookstate)) {
1172                                 ixj_cpt_stop(j);
1173                                 if (j->m_hook) {
1174                                         j->m_hook = 0;
1175                                         j->ex.bits.hookstate = 1;
1176                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1177                                 }
1178                                 clear_bit(board, &j->busyflags);
1179                                 ixj_add_timer(j);
1180                                 return;
1181                         }
1182                         if (j->tone_state == 1)
1183                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1184                         else
1185                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1186                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1187                                 if (j->tone_state == 1) {
1188                                         ixj_play_tone(j, j->tone_index);
1189                                         if (j->dsp.low == 0x20) {
1190                                                 clear_bit(board, &j->busyflags);
1191                                                 ixj_add_timer(j);
1192                                                 return;
1193                                         }
1194                                 } else {
1195                                         ixj_play_tone(j, 0);
1196                                         if (j->dsp.low == 0x20) {
1197                                                 clear_bit(board, &j->busyflags);
1198                                                 ixj_add_timer(j);
1199                                                 return;
1200                                         }
1201                                 }
1202                         } else {
1203                                 ixj_tone_timeout(j);
1204                                 if (j->flags.dialtone) {
1205                                         ixj_dialtone(j);
1206                                 }
1207                                 if (j->flags.busytone) {
1208                                         ixj_busytone(j);
1209                                         if (j->dsp.low == 0x20) {
1210                                                 clear_bit(board, &j->busyflags);
1211                                                 ixj_add_timer(j);
1212                                                 return;
1213                                         }
1214                                 }
1215                                 if (j->flags.ringback) {
1216                                         ixj_ringback(j);
1217                                         if (j->dsp.low == 0x20) {
1218                                                 clear_bit(board, &j->busyflags);
1219                                                 ixj_add_timer(j);
1220                                                 return;
1221                                         }
1222                                 }
1223                                 if (!j->tone_state) {
1224                                         ixj_cpt_stop(j);
1225                                 }
1226                         }
1227                 }
1228                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1229                         if (IsRxReady(j)) {
1230                                 ixj_read_frame(j);
1231                         }
1232                         if (IsTxReady(j)) {
1233                                 ixj_write_frame(j);
1234                         }
1235                 }
1236                 if (j->flags.cringing) {
1237                         if (j->hookstate & 1) {
1238                                 j->flags.cringing = 0;
1239                                 ixj_ring_off(j);
1240                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1241                                 switch(j->cadence_f[5].state) {
1242                                         case 0:
1243                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1244                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1245                                                         if(ixjdebug & 0x0004) {
1246                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1247                                                         }
1248                                                         ixj_ring_on(j);
1249                                                 }
1250                                                 j->cadence_f[5].state = 1;
1251                                                 break;
1252                                         case 1:
1253                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1254                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1255                                                         if(ixjdebug & 0x0004) {
1256                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1257                                                         }
1258                                                         ixj_ring_off(j);
1259                                                         j->cadence_f[5].state = 2;
1260                                                 }
1261                                                 break;
1262                                         case 2:
1263                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1264                                                         if(ixjdebug & 0x0004) {
1265                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1266                                                         }
1267                                                         ixj_ring_on(j);
1268                                                         if (j->cadence_f[5].on2) {
1269                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1270                                                                 j->cadence_f[5].state = 3;
1271                                                         } else {
1272                                                                 j->cadence_f[5].state = 7;
1273                                                         }
1274                                                 }
1275                                                 break;
1276                                         case 3:
1277                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1278                                                         if(ixjdebug & 0x0004) {
1279                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1280                                                         }
1281                                                         ixj_ring_off(j);
1282                                                         if (j->cadence_f[5].off2) {
1283                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1284                                                                 j->cadence_f[5].state = 4;
1285                                                         } else {
1286                                                                 j->cadence_f[5].state = 7;
1287                                                         }
1288                                                 }
1289                                                 break;
1290                                         case 4:
1291                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1292                                                         if(ixjdebug & 0x0004) {
1293                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1294                                                         }
1295                                                         ixj_ring_on(j);
1296                                                         if (j->cadence_f[5].on3) {
1297                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1298                                                                 j->cadence_f[5].state = 5;
1299                                                         } else {
1300                                                                 j->cadence_f[5].state = 7;
1301                                                         }
1302                                                 }
1303                                                 break;
1304                                         case 5:
1305                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1306                                                         if(ixjdebug & 0x0004) {
1307                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1308                                                         }
1309                                                         ixj_ring_off(j);
1310                                                         if (j->cadence_f[5].off3) {
1311                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1312                                                                 j->cadence_f[5].state = 6;
1313                                                         } else {
1314                                                                 j->cadence_f[5].state = 7;
1315                                                         }
1316                                                 }
1317                                                 break;
1318                                         case 6:
1319                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1320                                                         if(ixjdebug & 0x0004) {
1321                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1322                                                         }
1323                                                         j->cadence_f[5].state = 7;
1324                                                 }
1325                                                 break;
1326                                         case 7:
1327                                                 if(ixjdebug & 0x0004) {
1328                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1329                                                 }
1330                                                 j->flags.cidring = 1;
1331                                                 j->cadence_f[5].state = 0;
1332                                                 break;
1333                                 }
1334                                 if (j->flags.cidring && !j->flags.cidsent) {
1335                                         j->flags.cidsent = 1;
1336                                         if(j->fskdcnt) {
1337                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1338                                                 ixj_pre_cid(j);
1339                                         }
1340                                         j->flags.cidring = 0;
1341                                 }
1342                                 clear_bit(board, &j->busyflags);
1343                                 ixj_add_timer(j);
1344                                 return;
1345                         } else {
1346                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1347                                         if (j->flags.cidring && !j->flags.cidsent) {
1348                                                 j->flags.cidsent = 1;
1349                                                 if(j->fskdcnt) {
1350                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1351                                                         ixj_pre_cid(j);
1352                                                 }
1353                                                 j->flags.cidring = 0;
1354                                         }
1355                                         j->ring_cadence_t--;
1356                                         if (j->ring_cadence_t == -1)
1357                                                 j->ring_cadence_t = 15;
1358                                         j->ring_cadence_jif = jiffies;
1359
1360                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1361                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1362                                                         j->flags.firstring = 1;
1363                                                 else
1364                                                         ixj_ring_on(j);
1365                                         } else {
1366                                                 ixj_ring_off(j);
1367                                                 if(!j->flags.cidsent)
1368                                                         j->flags.cidring = 1;
1369                                         }
1370                                 }
1371                                 clear_bit(board, &j->busyflags);
1372                                 ixj_add_timer(j);
1373                                 return;
1374                         }
1375                 }
1376                 if (!j->flags.ringing) {
1377                         if (j->hookstate) { /* & 1) { */
1378                                 if (j->dsp.low != 0x20 &&
1379                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1380                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1381                                 }
1382                                 LineMonitor(j);
1383                                 read_filters(j);
1384                                 ixj_WriteDSPCommand(0x511B, j);
1385                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1386                                 if (!j->m_hook && (j->hookstate & 1)) {
1387                                         j->m_hook = j->ex.bits.hookstate = 1;
1388                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1389                                 }
1390                         } else {
1391                                 if (j->ex.bits.dtmf_ready) {
1392                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1393                                 }
1394                                 if (j->m_hook) {
1395                                         j->m_hook = 0;
1396                                         j->ex.bits.hookstate = 1;
1397                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1398                                 }
1399                         }
1400                 }
1401                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1402                         ixj_pstn_state(j);
1403                 }
1404                 if (j->ex.bytes) {
1405                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1406                 }
1407                 clear_bit(board, &j->busyflags);
1408         }
1409         ixj_add_timer(j);
1410 }
1411
1412 static int ixj_status_wait(IXJ *j)
1413 {
1414         unsigned long jif;
1415
1416         jif = jiffies + ((60 * hertz) / 100);
1417         while (!IsStatusReady(j)) {
1418                 ixj_perfmon(j->statuswait);
1419                 if (time_after(jiffies, jif)) {
1420                         ixj_perfmon(j->statuswaitfail);
1421                         return -1;
1422                 }
1423         }
1424         return 0;
1425 }
1426
1427 static int ixj_PCcontrol_wait(IXJ *j)
1428 {
1429         unsigned long jif;
1430
1431         jif = jiffies + ((60 * hertz) / 100);
1432         while (!IsPCControlReady(j)) {
1433                 ixj_perfmon(j->pcontrolwait);
1434                 if (time_after(jiffies, jif)) {
1435                         ixj_perfmon(j->pcontrolwaitfail);
1436                         return -1;
1437                 }
1438         }
1439         return 0;
1440 }
1441
1442 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1443 {
1444         BYTES bytes;
1445         unsigned long jif;
1446
1447         atomic_inc(&j->DSPWrite);
1448         if(atomic_read(&j->DSPWrite) > 1) {
1449                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1450                 return -1;
1451         }
1452         bytes.high = (cmd & 0xFF00) >> 8;
1453         bytes.low = cmd & 0x00FF;
1454         jif = jiffies + ((60 * hertz) / 100);
1455         while (!IsControlReady(j)) {
1456                 ixj_perfmon(j->iscontrolready);
1457                 if (time_after(jiffies, jif)) {
1458                         ixj_perfmon(j->iscontrolreadyfail);
1459                         atomic_dec(&j->DSPWrite);
1460                         if(atomic_read(&j->DSPWrite) > 0) {
1461                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1462                                 while(atomic_read(&j->DSPWrite) > 0) {
1463                                         atomic_dec(&j->DSPWrite);
1464                                 }
1465                         }
1466                         return -1;
1467                 }
1468         }
1469         outb(bytes.low, j->DSPbase + 6);
1470         outb(bytes.high, j->DSPbase + 7);
1471
1472         if (ixj_status_wait(j)) {
1473                 j->ssr.low = 0xFF;
1474                 j->ssr.high = 0xFF;
1475                 atomic_dec(&j->DSPWrite);
1476                 if(atomic_read(&j->DSPWrite) > 0) {
1477                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1478                         while(atomic_read(&j->DSPWrite) > 0) {
1479                                 atomic_dec(&j->DSPWrite);
1480                         }
1481                 }
1482                 return -1;
1483         }
1484 /* Read Software Status Register */
1485         j->ssr.low = inb_p(j->DSPbase + 2);
1486         j->ssr.high = inb_p(j->DSPbase + 3);
1487         atomic_dec(&j->DSPWrite);
1488         if(atomic_read(&j->DSPWrite) > 0) {
1489                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1490                 while(atomic_read(&j->DSPWrite) > 0) {
1491                         atomic_dec(&j->DSPWrite);
1492                 }
1493         }
1494         return 0;
1495 }
1496
1497 /***************************************************************************
1498 *
1499 *  General Purpose IO Register read routine
1500 *
1501 ***************************************************************************/
1502 static inline int ixj_gpio_read(IXJ *j)
1503 {
1504         if (ixj_WriteDSPCommand(0x5143, j))
1505                 return -1;
1506
1507         j->gpio.bytes.low = j->ssr.low;
1508         j->gpio.bytes.high = j->ssr.high;
1509
1510         return 0;
1511 }
1512
1513 static inline void LED_SetState(int state, IXJ *j)
1514 {
1515         if (j->cardtype == QTI_LINEJACK) {
1516                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1517                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1518                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1519                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1520
1521                 outb(j->pld_scrw.byte, j->XILINXbase);
1522         }
1523 }
1524
1525 /*********************************************************************
1526 *  GPIO Pins are configured as follows on the Quicknet Internet
1527 *  PhoneJACK Telephony Cards
1528 *
1529 * POTS Select        GPIO_6=0 GPIO_7=0
1530 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1531 * Handset Select     GPIO_6=1 GPIO_7=0
1532 *
1533 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1534 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1535 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1536 *
1537 * Hook Switch changes reported on GPIO_3
1538 *********************************************************************/
1539 static int ixj_set_port(IXJ *j, int arg)
1540 {
1541         if (j->cardtype == QTI_PHONEJACK_LITE) {
1542                 if (arg != PORT_POTS)
1543                         return 10;
1544                 else
1545                         return 0;
1546         }
1547         switch (arg) {
1548         case PORT_POTS:
1549                 j->port = PORT_POTS;
1550                 switch (j->cardtype) {
1551                 case QTI_PHONECARD:
1552                         if (j->flags.pcmciasct == 1)
1553                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1554                         else
1555                                 return 11;
1556                         break;
1557                 case QTI_PHONEJACK_PCI:
1558                         j->pld_slicw.pcib.mic = 0;
1559                         j->pld_slicw.pcib.spk = 0;
1560                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1561                         break;
1562                 case QTI_LINEJACK:
1563                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1564                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1565                                                                            Software Control Register */
1566                                 return 2;
1567                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1568
1569                         outb(j->pld_scrw.byte, j->XILINXbase);
1570                         j->pld_clock.byte = 0;
1571                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1572                         j->pld_slicw.bits.rly1 = 1;
1573                         j->pld_slicw.bits.spken = 0;
1574                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1575                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1576                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1577                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1578                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1579                         ixj_mixer(0x0E80, j);   /*Mic mute */
1580                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1581                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1582                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1583                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1584 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1585                         break;
1586                 case QTI_PHONEJACK:
1587                         j->gpio.bytes.high = 0x0B;
1588                         j->gpio.bits.gpio6 = 0;
1589                         j->gpio.bits.gpio7 = 0;
1590                         ixj_WriteDSPCommand(j->gpio.word, j);
1591                         break;
1592                 }
1593                 break;
1594         case PORT_PSTN:
1595                 if (j->cardtype == QTI_LINEJACK) {
1596                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1597
1598                         j->pld_slicw.bits.rly3 = 0;
1599                         j->pld_slicw.bits.rly1 = 1;
1600                         j->pld_slicw.bits.spken = 0;
1601                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1602                         j->port = PORT_PSTN;
1603                 } else {
1604                         return 4;
1605                 }
1606                 break;
1607         case PORT_SPEAKER:
1608                 j->port = PORT_SPEAKER;
1609                 switch (j->cardtype) {
1610                 case QTI_PHONECARD:
1611                         if (j->flags.pcmciasct) {
1612                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1613                         }
1614                         break;
1615                 case QTI_PHONEJACK_PCI:
1616                         j->pld_slicw.pcib.mic = 1;
1617                         j->pld_slicw.pcib.spk = 1;
1618                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1619                         break;
1620                 case QTI_LINEJACK:
1621                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1622                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1623                                                                            Software Control Register */
1624                                 return 2;
1625                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1626
1627                         outb(j->pld_scrw.byte, j->XILINXbase);
1628                         j->pld_clock.byte = 0;
1629                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1630                         j->pld_slicw.bits.rly1 = 1;
1631                         j->pld_slicw.bits.spken = 1;
1632                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1633                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1634                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1635                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1636                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1637                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1638                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1639                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1640                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1641                         break;
1642                 case QTI_PHONEJACK:
1643                         j->gpio.bytes.high = 0x0B;
1644                         j->gpio.bits.gpio6 = 0;
1645                         j->gpio.bits.gpio7 = 1;
1646                         ixj_WriteDSPCommand(j->gpio.word, j);
1647                         break;
1648                 }
1649                 break;
1650         case PORT_HANDSET:
1651                 if (j->cardtype != QTI_PHONEJACK) {
1652                         return 5;
1653                 } else {
1654                         j->gpio.bytes.high = 0x0B;
1655                         j->gpio.bits.gpio6 = 1;
1656                         j->gpio.bits.gpio7 = 0;
1657                         ixj_WriteDSPCommand(j->gpio.word, j);
1658                         j->port = PORT_HANDSET;
1659                 }
1660                 break;
1661         default:
1662                 return 6;
1663                 break;
1664         }
1665         return 0;
1666 }
1667
1668 static int ixj_set_pots(IXJ *j, int arg)
1669 {
1670         if (j->cardtype == QTI_LINEJACK) {
1671                 if (arg) {
1672                         if (j->port == PORT_PSTN) {
1673                                 j->pld_slicw.bits.rly1 = 0;
1674                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1675                                 j->flags.pots_pstn = 1;
1676                                 return 1;
1677                         } else {
1678                                 j->flags.pots_pstn = 0;
1679                                 return 0;
1680                         }
1681                 } else {
1682                         j->pld_slicw.bits.rly1 = 1;
1683                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1684                         j->flags.pots_pstn = 0;
1685                         return 1;
1686                 }
1687         } else {
1688                 return 0;
1689         }
1690 }
1691
1692 static void ixj_ring_on(IXJ *j)
1693 {
1694         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1695          {
1696                 if (ixjdebug & 0x0004)
1697                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1698
1699                 j->gpio.bytes.high = 0x0B;
1700                 j->gpio.bytes.low = 0x00;
1701                 j->gpio.bits.gpio1 = 1;
1702                 j->gpio.bits.gpio2 = 1;
1703                 j->gpio.bits.gpio5 = 0;
1704                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1705         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1706         {
1707                 if (ixjdebug & 0x0004)
1708                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1709
1710                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1711         }
1712 }
1713
1714 static int ixj_siadc(IXJ *j, int val)
1715 {
1716         if(j->cardtype == QTI_PHONECARD){
1717                 if(j->flags.pcmciascp){
1718                         if(val == -1)
1719                                 return j->siadc.bits.rxg;
1720
1721                         if(val < 0 || val > 0x1F)
1722                                 return -1;
1723
1724                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1725                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1726                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1727                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1728                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1729                         j->psccr.bits.dev = 0;
1730                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1731                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1732                         ixj_PCcontrol_wait(j);
1733                         return j->siadc.bits.rxg;
1734                 }
1735         }
1736         return -1;
1737 }
1738
1739 static int ixj_sidac(IXJ *j, int val)
1740 {
1741         if(j->cardtype == QTI_PHONECARD){
1742                 if(j->flags.pcmciascp){
1743                         if(val == -1)
1744                                 return j->sidac.bits.txg;
1745
1746                         if(val < 0 || val > 0x1F)
1747                                 return -1;
1748
1749                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1750                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1751                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1752                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1753                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1754                         j->psccr.bits.dev = 0;
1755                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1756                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1757                         ixj_PCcontrol_wait(j);
1758                         return j->sidac.bits.txg;
1759                 }
1760         }
1761         return -1;
1762 }
1763
1764 static int ixj_pcmcia_cable_check(IXJ *j)
1765 {
1766         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1767         if (!j->flags.pcmciastate) {
1768                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1769                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1770                         j->flags.pcmciastate = 4;
1771                         return 0;
1772                 }
1773                 if (j->pccr1.bits.ed) {
1774                         j->pccr1.bits.ed = 0;
1775                         j->psccr.bits.dev = 3;
1776                         j->psccr.bits.rw = 1;
1777                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1778                         ixj_PCcontrol_wait(j);
1779                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1780                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1781                         j->psccr.bits.dev = 3;
1782                         j->psccr.bits.rw = 0;
1783                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1784                         ixj_PCcontrol_wait(j);
1785                         return j->pslic.bits.led2 ? 1 : 0;
1786                 } else if (j->flags.pcmciasct) {
1787                         return j->r_hook;
1788                 } else {
1789                         return 1;
1790                 }
1791         } else if (j->flags.pcmciastate == 4) {
1792                 if (!j->pccr1.bits.drf) {
1793                         j->flags.pcmciastate = 3;
1794                 }
1795                 return 0;
1796         } else if (j->flags.pcmciastate == 3) {
1797                 j->pccr2.bits.pwr = 0;
1798                 j->pccr2.bits.rstc = 1;
1799                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1800                 j->checkwait = jiffies + (hertz * 2);
1801                 j->flags.incheck = 1;
1802                 j->flags.pcmciastate = 2;
1803                 return 0;
1804         } else if (j->flags.pcmciastate == 2) {
1805                 if (j->flags.incheck) {
1806                         if (time_before(jiffies, j->checkwait)) {
1807                                 return 0;
1808                         } else {
1809                                 j->flags.incheck = 0;
1810                         }
1811                 }
1812                 j->pccr2.bits.pwr = 0;
1813                 j->pccr2.bits.rstc = 0;
1814                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1815                 j->flags.pcmciastate = 1;
1816                 return 0;
1817         } else if (j->flags.pcmciastate == 1) {
1818                 j->flags.pcmciastate = 0;
1819                 if (!j->pccr1.bits.drf) {
1820                         j->psccr.bits.dev = 3;
1821                         j->psccr.bits.rw = 1;
1822                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1823                         ixj_PCcontrol_wait(j);
1824                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1825
1826                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1827
1828                         if (j->flags.pcmciasct == 3) {
1829                                 j->flags.pcmciastate = 4;
1830                                 return 0;
1831                         } else if (j->flags.pcmciasct == 0) {
1832                                 j->pccr2.bits.pwr = 1;
1833                                 j->pccr2.bits.rstc = 0;
1834                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1835                                 j->port = PORT_SPEAKER;
1836                         } else {
1837                                 j->port = PORT_POTS;
1838                         }
1839                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1840                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1841                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1842                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1843                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1844                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1845                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1846                         j->psccr.bits.dev = 0;
1847                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1848                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1849                         ixj_PCcontrol_wait(j);
1850
1851                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1852                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1853                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1854                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1855                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1856                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1857                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1858                         j->psccr.bits.dev = 0;
1859                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1860                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1861                         ixj_PCcontrol_wait(j);
1862
1863                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1864                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1865                         j->psccr.bits.dev = 0;
1866                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1867                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1868                         ixj_PCcontrol_wait(j);
1869
1870                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1871                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1872                         j->psccr.bits.dev = 0;
1873                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1874                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1875                         ixj_PCcontrol_wait(j);
1876
1877                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1878                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1879                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1880                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1881                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1882                         j->sirxg.bits.iir = 1;                          /* IIR */
1883                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1884                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1885                         j->psccr.bits.dev = 0;
1886                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1887                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1888                         ixj_PCcontrol_wait(j);
1889
1890                         ixj_siadc(j, 0x17);
1891                         ixj_sidac(j, 0x1D);
1892
1893                         j->siaatt.bits.sot = 0;
1894                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1895                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1896                         j->psccr.bits.dev = 0;
1897                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1898                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1899                         ixj_PCcontrol_wait(j);
1900
1901                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1902                                 j->psccr.byte = j->pslic.byte = 0;
1903                                 j->pslic.bits.powerdown = 1;
1904                                 j->psccr.bits.dev = 3;
1905                                 j->psccr.bits.rw = 0;
1906                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1907                                 ixj_PCcontrol_wait(j);
1908                         }
1909                 }
1910                 return 0;
1911         } else {
1912                 j->flags.pcmciascp = 0;
1913                 return 0;
1914         }
1915         return 0;
1916 }
1917
1918 static int ixj_hookstate(IXJ *j)
1919 {
1920         int fOffHook = 0;
1921
1922         switch (j->cardtype) {
1923         case QTI_PHONEJACK:
1924                 ixj_gpio_read(j);
1925                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1926                 break;
1927         case QTI_LINEJACK:
1928         case QTI_PHONEJACK_LITE:
1929         case QTI_PHONEJACK_PCI:
1930                 SLIC_GetState(j);
1931                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1932                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1933                         if(fOffHook != j->p_hook) {
1934                                 if(!j->checkwait) {
1935                                         j->checkwait = jiffies;
1936                                 }
1937                                 if(time_before(jiffies, j->checkwait + 2)) {
1938                                         fOffHook ^= 1;
1939                                 } else {
1940                                         j->checkwait = 0;
1941                                 }
1942                                 j->p_hook = fOffHook;
1943                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1944                         }
1945                 } else {
1946                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1947                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1948                                 if (j->flags.ringing || j->flags.cringing) {
1949                                         if (!in_interrupt()) {
1950                                                 msleep(20);
1951                                         }
1952                                         SLIC_GetState(j);
1953                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1954                                                 ixj_ring_on(j);
1955                                         }
1956                                 }
1957                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1958                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1959                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1960                                 } else
1961                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1962                         }
1963                 }
1964                 break;
1965         case QTI_PHONECARD:
1966                 fOffHook = ixj_pcmcia_cable_check(j);
1967                 break;
1968         }
1969         if (j->r_hook != fOffHook) {
1970                 j->r_hook = fOffHook;
1971                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1972                         j->ex.bits.hookstate = 1;
1973                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1974                 } else if (!fOffHook) {
1975                         j->flash_end = jiffies + ((60 * hertz) / 100);
1976                 }
1977         }
1978         if (fOffHook) {
1979                 if(time_before(jiffies, j->flash_end)) {
1980                         j->ex.bits.flash = 1;
1981                         j->flash_end = 0;
1982                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1983                 }
1984         } else {
1985                 if(time_before(jiffies, j->flash_end)) {
1986                         fOffHook = 1;
1987                 }
1988         }
1989
1990         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1991                 fOffHook |= 2;
1992
1993         if (j->port == PORT_SPEAKER) {
1994                 if(j->cardtype == QTI_PHONECARD) {
1995                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1996                                 fOffHook |= 2;
1997                         }
1998                 } else {
1999                         fOffHook |= 2;
2000                 }
2001         }
2002
2003         if (j->port == PORT_HANDSET)
2004                 fOffHook |= 2;
2005
2006         return fOffHook;
2007 }
2008
2009 static void ixj_ring_off(IXJ *j)
2010 {
2011         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2012          {
2013                 if (ixjdebug & 0x0004)
2014                         printk(KERN_INFO "IXJ Ring Off\n");
2015                 j->gpio.bytes.high = 0x0B;
2016                 j->gpio.bytes.low = 0x00;
2017                 j->gpio.bits.gpio1 = 0;
2018                 j->gpio.bits.gpio2 = 1;
2019                 j->gpio.bits.gpio5 = 0;
2020                 ixj_WriteDSPCommand(j->gpio.word, j);
2021         } else                  /* Internet LineJACK */
2022         {
2023                 if (ixjdebug & 0x0004)
2024                         printk(KERN_INFO "IXJ Ring Off\n");
2025
2026                 if(!j->flags.cidplay)
2027                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2028
2029                 SLIC_GetState(j);
2030         }
2031 }
2032
2033 static void ixj_ring_start(IXJ *j)
2034 {
2035         j->flags.cringing = 1;
2036         if (ixjdebug & 0x0004)
2037                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2038         if (ixj_hookstate(j) & 1) {
2039                 if (j->port == PORT_POTS)
2040                         ixj_ring_off(j);
2041                 j->flags.cringing = 0;
2042                 if (ixjdebug & 0x0004)
2043                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2044         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2045                 j->ring_cadence_jif = jiffies;
2046                 j->flags.cidsent = j->flags.cidring = 0;
2047                 j->cadence_f[5].state = 0;
2048                 if(j->cadence_f[5].on1)
2049                         ixj_ring_on(j);
2050         } else {
2051                 j->ring_cadence_jif = jiffies;
2052                 j->ring_cadence_t = 15;
2053                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2054                         ixj_ring_on(j);
2055                 } else {
2056                         ixj_ring_off(j);
2057                 }
2058                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2059         }
2060 }
2061
2062 static int ixj_ring(IXJ *j)
2063 {
2064         char cntr;
2065         unsigned long jif;
2066
2067         j->flags.ringing = 1;
2068         if (ixj_hookstate(j) & 1) {
2069                 ixj_ring_off(j);
2070                 j->flags.ringing = 0;
2071                 return 1;
2072         }
2073         for (cntr = 0; cntr < j->maxrings; cntr++) {
2074                 jif = jiffies + (1 * hertz);
2075                 ixj_ring_on(j);
2076                 while (time_before(jiffies, jif)) {
2077                         if (ixj_hookstate(j) & 1) {
2078                                 ixj_ring_off(j);
2079                                 j->flags.ringing = 0;
2080                                 return 1;
2081                         }
2082                         schedule_timeout_interruptible(1);
2083                         if (signal_pending(current))
2084                                 break;
2085                 }
2086                 jif = jiffies + (3 * hertz);
2087                 ixj_ring_off(j);
2088                 while (time_before(jiffies, jif)) {
2089                         if (ixj_hookstate(j) & 1) {
2090                                 msleep(10);
2091                                 if (ixj_hookstate(j) & 1) {
2092                                         j->flags.ringing = 0;
2093                                         return 1;
2094                                 }
2095                         }
2096                         schedule_timeout_interruptible(1);
2097                         if (signal_pending(current))
2098                                 break;
2099                 }
2100         }
2101         ixj_ring_off(j);
2102         j->flags.ringing = 0;
2103         return 0;
2104 }
2105
2106 static int ixj_open(struct phone_device *p, struct file *file_p)
2107 {
2108         IXJ *j = get_ixj(p->board);
2109         file_p->private_data = j;
2110
2111         if (!j->DSPbase)
2112                 return -ENODEV;
2113
2114         if (file_p->f_mode & FMODE_READ) {
2115                 if(!j->readers) {
2116                         j->readers++;
2117                 } else {
2118                         return -EBUSY;
2119                 }
2120         }
2121
2122         if (file_p->f_mode & FMODE_WRITE) {
2123                 if(!j->writers) {
2124                         j->writers++;
2125                 } else {
2126                         if (file_p->f_mode & FMODE_READ){
2127                                 j->readers--;
2128                         }
2129                         return -EBUSY;
2130                 }
2131         }
2132
2133         if (j->cardtype == QTI_PHONECARD) {
2134                 j->pslic.bits.powerdown = 0;
2135                 j->psccr.bits.dev = 3;
2136                 j->psccr.bits.rw = 0;
2137                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2138                 ixj_PCcontrol_wait(j);
2139         }
2140
2141         j->flags.cidplay = 0;
2142         j->flags.cidcw_ack = 0;
2143
2144         if (ixjdebug & 0x0002)
2145                 printk(KERN_INFO "Opening board %d\n", p->board);
2146
2147         j->framesread = j->frameswritten = 0;
2148         return 0;
2149 }
2150
2151 static int ixj_release(struct inode *inode, struct file *file_p)
2152 {
2153         IXJ_TONE ti;
2154         int cnt;
2155         IXJ *j = file_p->private_data;
2156         int board = j->p.board;
2157
2158         /*
2159          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2160          *    This is necessary to keep the DSP from locking up.
2161          */
2162         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2163                 schedule_timeout_interruptible(1);
2164         if (ixjdebug & 0x0002)
2165                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2166
2167         if (j->cardtype == QTI_PHONECARD)
2168                 ixj_set_port(j, PORT_SPEAKER);
2169         else
2170                 ixj_set_port(j, PORT_POTS);
2171
2172         aec_stop(j);
2173         ixj_play_stop(j);
2174         ixj_record_stop(j);
2175         set_play_volume(j, 0x100);
2176         set_rec_volume(j, 0x100);
2177         ixj_ring_off(j);
2178
2179         /* Restore the tone table to default settings. */
2180         ti.tone_index = 10;
2181         ti.gain0 = 1;
2182         ti.freq0 = hz941;
2183         ti.gain1 = 0;
2184         ti.freq1 = hz1209;
2185         ixj_init_tone(j, &ti);
2186         ti.tone_index = 11;
2187         ti.gain0 = 1;
2188         ti.freq0 = hz941;
2189         ti.gain1 = 0;
2190         ti.freq1 = hz1336;
2191         ixj_init_tone(j, &ti);
2192         ti.tone_index = 12;
2193         ti.gain0 = 1;
2194         ti.freq0 = hz941;
2195         ti.gain1 = 0;
2196         ti.freq1 = hz1477;
2197         ixj_init_tone(j, &ti);
2198         ti.tone_index = 13;
2199         ti.gain0 = 1;
2200         ti.freq0 = hz800;
2201         ti.gain1 = 0;
2202         ti.freq1 = 0;
2203         ixj_init_tone(j, &ti);
2204         ti.tone_index = 14;
2205         ti.gain0 = 1;
2206         ti.freq0 = hz1000;
2207         ti.gain1 = 0;
2208         ti.freq1 = 0;
2209         ixj_init_tone(j, &ti);
2210         ti.tone_index = 15;
2211         ti.gain0 = 1;
2212         ti.freq0 = hz1250;
2213         ti.gain1 = 0;
2214         ti.freq1 = 0;
2215         ixj_init_tone(j, &ti);
2216         ti.tone_index = 16;
2217         ti.gain0 = 1;
2218         ti.freq0 = hz950;
2219         ti.gain1 = 0;
2220         ti.freq1 = 0;
2221         ixj_init_tone(j, &ti);
2222         ti.tone_index = 17;
2223         ti.gain0 = 1;
2224         ti.freq0 = hz1100;
2225         ti.gain1 = 0;
2226         ti.freq1 = 0;
2227         ixj_init_tone(j, &ti);
2228         ti.tone_index = 18;
2229         ti.gain0 = 1;
2230         ti.freq0 = hz1400;
2231         ti.gain1 = 0;
2232         ti.freq1 = 0;
2233         ixj_init_tone(j, &ti);
2234         ti.tone_index = 19;
2235         ti.gain0 = 1;
2236         ti.freq0 = hz1500;
2237         ti.gain1 = 0;
2238         ti.freq1 = 0;
2239         ixj_init_tone(j, &ti);
2240         ti.tone_index = 20;
2241         ti.gain0 = 1;
2242         ti.freq0 = hz1600;
2243         ti.gain1 = 0;
2244         ti.freq1 = 0;
2245         ixj_init_tone(j, &ti);
2246         ti.tone_index = 21;
2247         ti.gain0 = 1;
2248         ti.freq0 = hz1800;
2249         ti.gain1 = 0;
2250         ti.freq1 = 0;
2251         ixj_init_tone(j, &ti);
2252         ti.tone_index = 22;
2253         ti.gain0 = 1;
2254         ti.freq0 = hz2100;
2255         ti.gain1 = 0;
2256         ti.freq1 = 0;
2257         ixj_init_tone(j, &ti);
2258         ti.tone_index = 23;
2259         ti.gain0 = 1;
2260         ti.freq0 = hz1300;
2261         ti.gain1 = 0;
2262         ti.freq1 = 0;
2263         ixj_init_tone(j, &ti);
2264         ti.tone_index = 24;
2265         ti.gain0 = 1;
2266         ti.freq0 = hz2450;
2267         ti.gain1 = 0;
2268         ti.freq1 = 0;
2269         ixj_init_tone(j, &ti);
2270         ti.tone_index = 25;
2271         ti.gain0 = 1;
2272         ti.freq0 = hz350;
2273         ti.gain1 = 0;
2274         ti.freq1 = hz440;
2275         ixj_init_tone(j, &ti);
2276         ti.tone_index = 26;
2277         ti.gain0 = 1;
2278         ti.freq0 = hz440;
2279         ti.gain1 = 0;
2280         ti.freq1 = hz480;
2281         ixj_init_tone(j, &ti);
2282         ti.tone_index = 27;
2283         ti.gain0 = 1;
2284         ti.freq0 = hz480;
2285         ti.gain1 = 0;
2286         ti.freq1 = hz620;
2287         ixj_init_tone(j, &ti);
2288
2289         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2290
2291         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2292
2293         j->ex.bits.dtmf_ready = 0;
2294         j->dtmf_state = 0;
2295         j->dtmf_wp = j->dtmf_rp = 0;
2296         j->rec_mode = j->play_mode = -1;
2297         j->flags.ringing = 0;
2298         j->maxrings = MAXRINGS;
2299         j->ring_cadence = USA_RING_CADENCE;
2300         if(j->cadence_f[5].enable) {
2301                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2302         }
2303         j->drybuffer = 0;
2304         j->winktime = 320;
2305         j->flags.dtmf_oob = 0;
2306         for (cnt = 0; cnt < 4; cnt++)
2307                 j->cadence_f[cnt].enable = 0;
2308
2309         idle(j);
2310
2311         if(j->cardtype == QTI_PHONECARD) {
2312                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2313         }
2314
2315         if (file_p->f_mode & FMODE_READ)
2316                 j->readers--;
2317         if (file_p->f_mode & FMODE_WRITE)
2318                 j->writers--;
2319
2320         if (j->read_buffer && !j->readers) {
2321                 kfree(j->read_buffer);
2322                 j->read_buffer = NULL;
2323                 j->read_buffer_size = 0;
2324         }
2325         if (j->write_buffer && !j->writers) {
2326                 kfree(j->write_buffer);
2327                 j->write_buffer = NULL;
2328                 j->write_buffer_size = 0;
2329         }
2330         j->rec_codec = j->play_codec = 0;
2331         j->rec_frame_size = j->play_frame_size = 0;
2332         j->flags.cidsent = j->flags.cidring = 0;
2333
2334         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2335                 ixj_set_port(j, PORT_PSTN);
2336                 daa_set_mode(j, SOP_PU_SLEEP);
2337                 ixj_set_pots(j, 1);
2338         }
2339         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2340
2341         /* Set up the default signals for events */
2342         for (cnt = 0; cnt < 35; cnt++)
2343                 j->ixj_signals[cnt] = SIGIO;
2344
2345         /* Set the excetion signal enable flags */
2346         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2347         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 =
2348         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;
2349
2350         file_p->private_data = NULL;
2351         clear_bit(board, &j->busyflags);
2352         return 0;
2353 }
2354
2355 static int read_filters(IXJ *j)
2356 {
2357         unsigned short fc, cnt, trg;
2358         int var;
2359
2360         trg = 0;
2361         if (ixj_WriteDSPCommand(0x5144, j)) {
2362                 if(ixjdebug & 0x0001) {
2363                         printk(KERN_INFO "Read Frame Counter failed!\n");
2364                 }
2365                 return -1;
2366         }
2367         fc = j->ssr.high << 8 | j->ssr.low;
2368         if (fc == j->frame_count)
2369                 return 1;
2370
2371         j->frame_count = fc;
2372
2373         if (j->dtmf_proc)
2374                 return 1;
2375
2376         var = 10;
2377
2378         for (cnt = 0; cnt < 4; cnt++) {
2379                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2380                         if(ixjdebug & 0x0001) {
2381                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2382                         }
2383                         return -1;
2384                 }
2385                 if (ixj_WriteDSPCommand(0x515C, j)) {
2386                         if(ixjdebug & 0x0001) {
2387                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2388                         }
2389                         return -1;
2390                 }
2391                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2392
2393                 if (j->cadence_f[cnt].enable) {
2394                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2395                                 if (j->cadence_f[cnt].state == 0) {
2396                                         j->cadence_f[cnt].state = 1;
2397                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2398                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2399                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2400                                 } else if (j->cadence_f[cnt].state == 2 &&
2401                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2402                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2403                                         if (j->cadence_f[cnt].on2) {
2404                                                 j->cadence_f[cnt].state = 3;
2405                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2406                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2407                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2408                                         } else {
2409                                                 j->cadence_f[cnt].state = 7;
2410                                         }
2411                                 } else if (j->cadence_f[cnt].state == 4 &&
2412                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2413                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2414                                         if (j->cadence_f[cnt].on3) {
2415                                                 j->cadence_f[cnt].state = 5;
2416                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2417                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2418                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2419                                         } else {
2420                                                 j->cadence_f[cnt].state = 7;
2421                                         }
2422                                 } else {
2423                                         j->cadence_f[cnt].state = 0;
2424                                 }
2425                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2426                                 if (j->cadence_f[cnt].state == 1) {
2427                                         if(!j->cadence_f[cnt].on1) {
2428                                                 j->cadence_f[cnt].state = 7;
2429                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2430                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2431                                                 if(j->cadence_f[cnt].off1) {
2432                                                         j->cadence_f[cnt].state = 2;
2433                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2434                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2435                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2436                                                 } else {
2437                                                         j->cadence_f[cnt].state = 7;
2438                                                 }
2439                                         } else {
2440                                                 j->cadence_f[cnt].state = 0;
2441                                         }
2442                                 } else if (j->cadence_f[cnt].state == 3) {
2443                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2444                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2445                                                 if(j->cadence_f[cnt].off2) {
2446                                                         j->cadence_f[cnt].state = 4;
2447                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2448                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2449                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2450                                                 } else {
2451                                                         j->cadence_f[cnt].state = 7;
2452                                                 }
2453                                         } else {
2454                                                 j->cadence_f[cnt].state = 0;
2455                                         }
2456                                 } else if (j->cadence_f[cnt].state == 5) {
2457                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2458                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2459                                                 if(j->cadence_f[cnt].off3) {
2460                                                         j->cadence_f[cnt].state = 6;
2461                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2462                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2463                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2464                                                 } else {
2465                                                         j->cadence_f[cnt].state = 7;
2466                                                 }
2467                                         } else {
2468                                                 j->cadence_f[cnt].state = 0;
2469                                         }
2470                                 } else {
2471                                         j->cadence_f[cnt].state = 0;
2472                                 }
2473                         } else {
2474                                 switch(j->cadence_f[cnt].state) {
2475                                         case 1:
2476                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2477                                                    !j->cadence_f[cnt].off1 &&
2478                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2479                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2480                                                         j->cadence_f[cnt].state = 7;
2481                                                 }
2482                                                 break;
2483                                         case 3:
2484                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2485                                                    !j->cadence_f[cnt].off2 &&
2486                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2487                                                         j->cadence_f[cnt].state = 7;
2488                                                 }
2489                                                 break;
2490                                         case 5:
2491                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2492                                                    !j->cadence_f[cnt].off3) {
2493                                                         j->cadence_f[cnt].state = 7;
2494                                                 }
2495                                                 break;
2496                                 }
2497                         }
2498
2499                         if (ixjdebug & 0x0040) {
2500                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2501                                 switch(j->cadence_f[cnt].state) {
2502                                         case 0:
2503                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2504                                                 break;
2505                                         case 1:
2506                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2507                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2508                                                 break;
2509                                         case 2:
2510                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2511                                                                                                                         j->cadence_f[cnt].off1max);
2512                                                 break;
2513                                         case 3:
2514                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2515                                                                                                                         j->cadence_f[cnt].on2max);
2516                                                 break;
2517                                         case 4:
2518                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2519                                                                                                                         j->cadence_f[cnt].off2max);
2520                                                 break;
2521                                         case 5:
2522                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2523                                                                                                                         j->cadence_f[cnt].on3max);
2524                                                 break;
2525                                         case 6:
2526                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2527                                                                                                                         j->cadence_f[cnt].off3max);
2528                                                 break;
2529                                 }
2530                         }
2531                 }
2532                 if (j->cadence_f[cnt].state == 7) {
2533                         j->cadence_f[cnt].state = 0;
2534                         if (j->cadence_f[cnt].enable == 1)
2535                                 j->cadence_f[cnt].enable = 0;
2536                         switch (cnt) {
2537                         case 0:
2538                                 if(ixjdebug & 0x0020) {
2539                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2540                                 }
2541                                 j->ex.bits.fc0 = 1;
2542                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2543                                 break;
2544                         case 1:
2545                                 if(ixjdebug & 0x0020) {
2546                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2547                                 }
2548                                 j->ex.bits.fc1 = 1;
2549                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2550                                 break;
2551                         case 2:
2552                                 if(ixjdebug & 0x0020) {
2553                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2554                                 }
2555                                 j->ex.bits.fc2 = 1;
2556                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2557                                 break;
2558                         case 3:
2559                                 if(ixjdebug & 0x0020) {
2560                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2561                                 }
2562                                 j->ex.bits.fc3 = 1;
2563                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2564                                 break;
2565                         }
2566                 }
2567                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2568                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2569                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2570                                 trg = 1;
2571                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2572                                 trg = 0;
2573                         }
2574                         switch (cnt) {
2575                         case 0:
2576                                 if(ixjdebug & 0x0020) {
2577                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2578                                 }
2579                                 j->ex.bits.f0 = 1;
2580                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2581                                 break;
2582                         case 1:
2583                                 if(ixjdebug & 0x0020) {
2584                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2585                                 }
2586                                 j->ex.bits.f1 = 1;
2587                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2588                                 break;
2589                         case 2:
2590                                 if(ixjdebug & 0x0020) {
2591                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2592                                 }
2593                                 j->ex.bits.f2 = 1;
2594                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2595                                 break;
2596                         case 3:
2597                                 if(ixjdebug & 0x0020) {
2598                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2599                                 }
2600                                 j->ex.bits.f3 = 1;
2601                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2602                                 break;
2603                         }
2604                 }
2605         }
2606         return 0;
2607 }
2608
2609 static int LineMonitor(IXJ *j)
2610 {
2611         if (j->dtmf_proc) {
2612                 return -1;
2613         }
2614         j->dtmf_proc = 1;
2615
2616         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2617                 return -1;
2618
2619         j->dtmf.bytes.high = j->ssr.high;
2620         j->dtmf.bytes.low = j->ssr.low;
2621         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2622                 j->dtmf_state = 1;
2623                 j->dtmf_current = j->dtmf.bits.digit;
2624         }
2625         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2626          {
2627                 if(!j->cidcw_wait) {
2628                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2629                         j->dtmf_wp++;
2630                         if (j->dtmf_wp == 79)
2631                                 j->dtmf_wp = 0;
2632                         j->ex.bits.dtmf_ready = 1;
2633                         if(j->ex_sig.bits.dtmf_ready) {
2634                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2635                         }
2636                 }
2637                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2638                         if(ixjdebug & 0x0020) {
2639                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2640                         }
2641                         j->flags.cidcw_ack = 1;
2642                 }
2643                 j->dtmf_state = 0;
2644         }
2645         j->dtmf_proc = 0;
2646
2647         return 0;
2648 }
2649
2650 /************************************************************************
2651 *
2652 * Functions to allow alaw <-> ulaw conversions.
2653 *
2654 ************************************************************************/
2655
2656 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2657 {
2658         static unsigned char table_ulaw2alaw[] =
2659         {
2660                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2661                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2662                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2663                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2664                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2665                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2666                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2667                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2668                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2669                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2670                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2671                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2672                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2673                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2674                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2675                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2676                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2677                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2678                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2679                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2680                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2681                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2682                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2683                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2684                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2685                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2686                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2687                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2688                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2689                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2690                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2691                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2692         };
2693
2694         while (len--)
2695         {
2696                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2697                 buff++;
2698         }
2699 }
2700
2701 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2702 {
2703         static unsigned char table_alaw2ulaw[] =
2704         {
2705                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2706                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2707                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2708                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2709                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2710                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2711                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2712                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2713                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2714                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2715                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2716                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2717                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2718                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2719                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2720                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2721                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2722                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2723                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2724                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2725                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2726                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2727                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2728                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2729                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2730                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2731                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2732                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2733                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2734                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2735                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2736                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2737         };
2738
2739         while (len--)
2740         {
2741                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2742                 buff++;
2743         }
2744 }
2745
2746 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2747 {
2748         unsigned long i = *ppos;
2749         IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2750
2751         DECLARE_WAITQUEUE(wait, current);
2752
2753         if (j->flags.inread)
2754                 return -EALREADY;
2755
2756         j->flags.inread = 1;
2757
2758         add_wait_queue(&j->read_q, &wait);
2759         set_current_state(TASK_INTERRUPTIBLE);
2760         mb();
2761
2762         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2763                 ++j->read_wait;
2764                 if (file_p->f_flags & O_NONBLOCK) {
2765                         set_current_state(TASK_RUNNING);
2766                         remove_wait_queue(&j->read_q, &wait);
2767                         j->flags.inread = 0;
2768                         return -EAGAIN;
2769                 }
2770                 if (!ixj_hookstate(j)) {
2771                         set_current_state(TASK_RUNNING);
2772                         remove_wait_queue(&j->read_q, &wait);
2773                         j->flags.inread = 0;
2774                         return 0;
2775                 }
2776                 interruptible_sleep_on(&j->read_q);
2777                 if (signal_pending(current)) {
2778                         set_current_state(TASK_RUNNING);
2779                         remove_wait_queue(&j->read_q, &wait);
2780                         j->flags.inread = 0;
2781                         return -EINTR;
2782                 }
2783         }
2784
2785         remove_wait_queue(&j->read_q, &wait);
2786         set_current_state(TASK_RUNNING);
2787         /* Don't ever copy more than the user asks */
2788         if(j->rec_codec == ALAW)
2789                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2790         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2791         j->read_buffer_ready = 0;
2792         if (i) {
2793                 j->flags.inread = 0;
2794                 return -EFAULT;
2795         } else {
2796                 j->flags.inread = 0;
2797                 return min(length, j->read_buffer_size);
2798         }
2799 }
2800
2801 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2802                           loff_t * ppos)
2803 {
2804         int pre_retval;
2805         ssize_t read_retval = 0;
2806         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2807
2808         pre_retval = ixj_PreRead(j, 0L);
2809         switch (pre_retval) {
2810         case NORMAL:
2811                 read_retval = ixj_read(file_p, buf, length, ppos);
2812                 ixj_PostRead(j, 0L);
2813                 break;
2814         case NOPOST:
2815                 read_retval = ixj_read(file_p, buf, length, ppos);
2816                 break;
2817         case POSTONLY:
2818                 ixj_PostRead(j, 0L);
2819                 break;
2820         default:
2821                 read_retval = pre_retval;
2822         }
2823         return read_retval;
2824 }
2825
2826 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2827 {
2828         unsigned long i = *ppos;
2829         IXJ *j = file_p->private_data;
2830
2831         DECLARE_WAITQUEUE(wait, current);
2832
2833         if (j->flags.inwrite)
2834                 return -EALREADY;
2835
2836         j->flags.inwrite = 1;
2837
2838         add_wait_queue(&j->write_q, &wait);
2839         set_current_state(TASK_INTERRUPTIBLE);
2840         mb();
2841
2842
2843         while (!j->write_buffers_empty) {
2844                 ++j->write_wait;
2845                 if (file_p->f_flags & O_NONBLOCK) {
2846                         set_current_state(TASK_RUNNING);
2847                         remove_wait_queue(&j->write_q, &wait);
2848                         j->flags.inwrite = 0;
2849                         return -EAGAIN;
2850                 }
2851                 if (!ixj_hookstate(j)) {
2852                         set_current_state(TASK_RUNNING);
2853                         remove_wait_queue(&j->write_q, &wait);
2854                         j->flags.inwrite = 0;
2855                         return 0;
2856                 }
2857                 interruptible_sleep_on(&j->write_q);
2858                 if (signal_pending(current)) {
2859                         set_current_state(TASK_RUNNING);
2860                         remove_wait_queue(&j->write_q, &wait);
2861                         j->flags.inwrite = 0;
2862                         return -EINTR;
2863                 }
2864         }
2865         set_current_state(TASK_RUNNING);
2866         remove_wait_queue(&j->write_q, &wait);
2867         if (j->write_buffer_wp + count >= j->write_buffer_end)
2868                 j->write_buffer_wp = j->write_buffer;
2869         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2870         if (i) {
2871                 j->flags.inwrite = 0;
2872                 return -EFAULT;
2873         }
2874        if(j->play_codec == ALAW)
2875                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2876         j->flags.inwrite = 0;
2877         return min(count, j->write_buffer_size);
2878 }
2879
2880 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2881 {
2882         int pre_retval;
2883         ssize_t write_retval = 0;
2884
2885         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2886
2887         pre_retval = ixj_PreWrite(j, 0L);
2888         switch (pre_retval) {
2889         case NORMAL:
2890                 write_retval = ixj_write(file_p, buf, count, ppos);
2891                 if (write_retval > 0) {
2892                         ixj_PostWrite(j, 0L);
2893                         j->write_buffer_wp += write_retval;
2894                         j->write_buffers_empty--;
2895                 }
2896                 break;
2897         case NOPOST:
2898                 write_retval = ixj_write(file_p, buf, count, ppos);
2899                 if (write_retval > 0) {
2900                         j->write_buffer_wp += write_retval;
2901                         j->write_buffers_empty--;
2902                 }
2903                 break;
2904         case POSTONLY:
2905                 ixj_PostWrite(j, 0L);
2906                 break;
2907         default:
2908                 write_retval = pre_retval;
2909         }
2910         return write_retval;
2911 }
2912
2913 static void ixj_read_frame(IXJ *j)
2914 {
2915         int cnt, dly;
2916
2917         if (j->read_buffer) {
2918                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2919                         if (!(cnt % 16) && !IsRxReady(j)) {
2920                                 dly = 0;
2921                                 while (!IsRxReady(j)) {
2922                                         if (dly++ > 5) {
2923                                                 dly = 0;
2924                                                 break;
2925                                         }
2926                                         udelay(10);
2927                                 }
2928                         }
2929                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2930                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2931                                 inb_p(j->DSPbase + 0x0E);
2932                                 inb_p(j->DSPbase + 0x0F);
2933                         }
2934                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2935                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2936                 }
2937                 ++j->framesread;
2938                 if (j->intercom != -1) {
2939                         if (IsTxReady(get_ixj(j->intercom))) {
2940                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2941                                         if (!(cnt % 16) && !IsTxReady(j)) {
2942                                                 dly = 0;
2943                                                 while (!IsTxReady(j)) {
2944                                                         if (dly++ > 5) {
2945                                                                 dly = 0;
2946                                                                 break;
2947                                                         }
2948                                                         udelay(10);
2949                                                 }
2950                                         }
2951                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2952                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2953                                 }
2954                                 get_ixj(j->intercom)->frameswritten++;
2955                         }
2956                 } else {
2957                         j->read_buffer_ready = 1;
2958                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2959
2960                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2961
2962                         if(j->ixj_signals[SIG_READ_READY])
2963                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2964                 }
2965         }
2966 }
2967
2968 static short fsk[][6][20] =
2969 {
2970         {
2971                 {
2972                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2973                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2974                 },
2975                 {
2976                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2977                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2978                 },
2979                 {
2980                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2981                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2982                 },
2983                 {
2984                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2985                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2986                 },
2987                 {
2988                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2989                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2990                 },
2991                 {
2992                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2993                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2994                 }
2995         },
2996         {
2997                 {
2998                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2999                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3000                 },
3001                 {
3002                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3003                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3004                 },
3005                 {
3006                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3007                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3008                 },
3009                 {
3010                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3011                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3012                 },
3013                 {
3014                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3015                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3016                 },
3017                 {
3018                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3019                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3020                 }
3021         }
3022 };
3023
3024
3025 static void ixj_write_cid_bit(IXJ *j, int bit)
3026 {
3027         while (j->fskcnt < 20) {
3028                 if(j->fskdcnt < (j->fsksize - 1))
3029                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3030
3031                 j->fskcnt += 3;
3032         }
3033         j->fskcnt %= 20;
3034
3035         if (!bit)
3036                 j->fskz++;
3037         if (j->fskz >= 6)
3038                 j->fskz = 0;
3039
3040 }
3041
3042 static void ixj_write_cid_byte(IXJ *j, char byte)
3043 {
3044         IXJ_CBYTE cb;
3045
3046                 cb.cbyte = byte;
3047                 ixj_write_cid_bit(j, 0);
3048                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3053                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3054                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3055                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3056                 ixj_write_cid_bit(j, 1);
3057 }
3058
3059 static void ixj_write_cid_seize(IXJ *j)
3060 {
3061         int cnt;
3062
3063         for (cnt = 0; cnt < 150; cnt++) {
3064                 ixj_write_cid_bit(j, 0);
3065                 ixj_write_cid_bit(j, 1);
3066         }
3067         for (cnt = 0; cnt < 180; cnt++) {
3068                 ixj_write_cid_bit(j, 1);
3069         }
3070 }
3071
3072 static void ixj_write_cidcw_seize(IXJ *j)
3073 {
3074         int cnt;
3075
3076         for (cnt = 0; cnt < 80; cnt++) {
3077                 ixj_write_cid_bit(j, 1);
3078         }
3079 }
3080
3081 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3082 {
3083         int cnt;
3084
3085         for (cnt = 0; cnt < strlen(s); cnt++) {
3086                 ixj_write_cid_byte(j, s[cnt]);
3087                 checksum = (checksum + s[cnt]);
3088         }
3089         return checksum;
3090 }
3091
3092 static void ixj_pad_fsk(IXJ *j, int pad)
3093 {
3094         int cnt;
3095
3096         for (cnt = 0; cnt < pad; cnt++) {
3097                 if(j->fskdcnt < (j->fsksize - 1))
3098                         j->fskdata[j->fskdcnt++] = 0x0000;
3099         }
3100         for (cnt = 0; cnt < 720; cnt++) {
3101                 if(j->fskdcnt < (j->fsksize - 1))
3102                         j->fskdata[j->fskdcnt++] = 0x0000;
3103         }
3104 }
3105
3106 static void ixj_pre_cid(IXJ *j)
3107 {
3108         j->cid_play_codec = j->play_codec;
3109         j->cid_play_frame_size = j->play_frame_size;
3110         j->cid_play_volume = get_play_volume(j);
3111         j->cid_play_flag = j->flags.playing;
3112
3113         j->cid_rec_codec = j->rec_codec;
3114         j->cid_rec_volume = get_rec_volume(j);
3115         j->cid_rec_flag = j->flags.recording;
3116
3117         j->cid_play_aec_level = j->aec_level;
3118
3119         switch(j->baseframe.low) {
3120                 case 0xA0:
3121                         j->cid_base_frame_size = 20;
3122                         break;
3123                 case 0x50:
3124                         j->cid_base_frame_size = 10;
3125                         break;
3126                 case 0xF0:
3127                         j->cid_base_frame_size = 30;
3128                         break;
3129         }
3130
3131         ixj_play_stop(j);
3132         ixj_cpt_stop(j);
3133
3134         j->flags.cidplay = 1;
3135
3136         set_base_frame(j, 30);
3137         set_play_codec(j, LINEAR16);
3138         set_play_volume(j, 0x1B);
3139         ixj_play_start(j);
3140 }
3141
3142 static void ixj_post_cid(IXJ *j)
3143 {
3144         ixj_play_stop(j);
3145
3146         if(j->cidsize > 5000) {
3147                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3148         }
3149         j->flags.cidplay = 0;
3150         if(ixjdebug & 0x0200) {
3151                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3152         }
3153
3154         ixj_fsk_free(j);
3155
3156         j->fskdcnt = 0;
3157         set_base_frame(j, j->cid_base_frame_size);
3158         set_play_codec(j, j->cid_play_codec);
3159         ixj_aec_start(j, j->cid_play_aec_level);
3160         set_play_volume(j, j->cid_play_volume);
3161
3162         set_rec_codec(j, j->cid_rec_codec);
3163         set_rec_volume(j, j->cid_rec_volume);
3164
3165         if(j->cid_rec_flag)
3166                 ixj_record_start(j);
3167
3168         if(j->cid_play_flag)
3169                 ixj_play_start(j);
3170
3171         if(j->cid_play_flag) {
3172                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3173         }
3174 }
3175
3176 static void ixj_write_cid(IXJ *j)
3177 {
3178         char sdmf1[50];
3179         char sdmf2[50];
3180         char sdmf3[80];
3181         char mdmflen, len1, len2, len3;
3182         int pad;
3183
3184         int checksum = 0;
3185
3186         if (j->dsp.low == 0x20 || j->flags.cidplay)
3187                 return;
3188
3189         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3190         j->cidsize = j->cidcnt = 0;
3191
3192         ixj_fsk_alloc(j);
3193
3194         strcpy(sdmf1, j->cid_send.month);
3195         strcat(sdmf1, j->cid_send.day);
3196         strcat(sdmf1, j->cid_send.hour);
3197         strcat(sdmf1, j->cid_send.min);
3198         strcpy(sdmf2, j->cid_send.number);
3199         strcpy(sdmf3, j->cid_send.name);
3200
3201         len1 = strlen(sdmf1);
3202         len2 = strlen(sdmf2);
3203         len3 = strlen(sdmf3);
3204         mdmflen = len1 + len2 + len3 + 6;
3205
3206         while(1){
3207                 ixj_write_cid_seize(j);
3208
3209                 ixj_write_cid_byte(j, 0x80);
3210                 checksum = 0x80;
3211                 ixj_write_cid_byte(j, mdmflen);
3212                 checksum = checksum + mdmflen;
3213
3214                 ixj_write_cid_byte(j, 0x01);
3215                 checksum = checksum + 0x01;
3216                 ixj_write_cid_byte(j, len1);
3217                 checksum = checksum + len1;
3218                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3219                 if(ixj_hookstate(j) & 1)
3220                         break;
3221
3222                 ixj_write_cid_byte(j, 0x02);
3223                 checksum = checksum + 0x02;
3224                 ixj_write_cid_byte(j, len2);
3225                 checksum = checksum + len2;
3226                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3227                 if(ixj_hookstate(j) & 1)
3228                         break;
3229
3230                 ixj_write_cid_byte(j, 0x07);
3231                 checksum = checksum + 0x07;
3232                 ixj_write_cid_byte(j, len3);
3233                 checksum = checksum + len3;
3234                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3235                 if(ixj_hookstate(j) & 1)
3236                         break;
3237
3238                 checksum %= 256;
3239                 checksum ^= 0xFF;
3240                 checksum += 1;
3241
3242                 ixj_write_cid_byte(j, (char) checksum);
3243
3244                 pad = j->fskdcnt % 240;
3245                 if (pad) {
3246                         pad = 240 - pad;
3247                 }
3248                 ixj_pad_fsk(j, pad);
3249                 break;
3250         }
3251
3252         ixj_write_frame(j);
3253 }
3254
3255 static void ixj_write_cidcw(IXJ *j)
3256 {
3257         IXJ_TONE ti;
3258
3259         char sdmf1[50];
3260         char sdmf2[50];
3261         char sdmf3[80];
3262         char mdmflen, len1, len2, len3;
3263         int pad;
3264
3265         int checksum = 0;
3266
3267         if (j->dsp.low == 0x20 || j->flags.cidplay)
3268                 return;
3269
3270         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3271         j->cidsize = j->cidcnt = 0;
3272
3273         ixj_fsk_alloc(j);
3274
3275         j->flags.cidcw_ack = 0;
3276
3277         ti.tone_index = 23;
3278         ti.gain0 = 1;
3279         ti.freq0 = hz440;
3280         ti.gain1 = 0;
3281         ti.freq1 = 0;
3282         ixj_init_tone(j, &ti);
3283
3284         ixj_set_tone_on(1500, j);
3285         ixj_set_tone_off(32, j);
3286         if(ixjdebug & 0x0200) {
3287                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3288         }
3289         ixj_play_tone(j, 23);
3290
3291         clear_bit(j->board, &j->busyflags);
3292         while(j->tone_state)
3293                 schedule_timeout_interruptible(1);
3294         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3295                 schedule_timeout_interruptible(1);
3296         if(ixjdebug & 0x0200) {
3297                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3298         }
3299
3300         ti.tone_index = 24;
3301         ti.gain0 = 1;
3302         ti.freq0 = hz2130;
3303         ti.gain1 = 0;
3304         ti.freq1 = hz2750;
3305         ixj_init_tone(j, &ti);
3306
3307         ixj_set_tone_off(10, j);
3308         ixj_set_tone_on(600, j);
3309         if(ixjdebug & 0x0200) {
3310                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3311         }
3312         ixj_play_tone(j, 24);
3313
3314         clear_bit(j->board, &j->busyflags);
3315         while(j->tone_state)
3316                 schedule_timeout_interruptible(1);
3317         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3318                 schedule_timeout_interruptible(1);
3319         if(ixjdebug & 0x0200) {
3320                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3321         }
3322
3323         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3324
3325         clear_bit(j->board, &j->busyflags);
3326         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3327                 schedule_timeout_interruptible(1);
3328         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3329                 schedule_timeout_interruptible(1);
3330         j->cidcw_wait = 0;
3331         if(!j->flags.cidcw_ack) {
3332                 if(ixjdebug & 0x0200) {
3333                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3334                 }
3335                 ixj_post_cid(j);
3336                 if(j->cid_play_flag) {
3337                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3338                 }
3339                 return;
3340         } else {
3341                 ixj_pre_cid(j);
3342         }
3343         j->flags.cidcw_ack = 0;
3344         strcpy(sdmf1, j->cid_send.month);
3345         strcat(sdmf1, j->cid_send.day);
3346         strcat(sdmf1, j->cid_send.hour);
3347         strcat(sdmf1, j->cid_send.min);
3348         strcpy(sdmf2, j->cid_send.number);
3349         strcpy(sdmf3, j->cid_send.name);
3350
3351         len1 = strlen(sdmf1);
3352         len2 = strlen(sdmf2);
3353         len3 = strlen(sdmf3);
3354         mdmflen = len1 + len2 + len3 + 6;
3355
3356         ixj_write_cidcw_seize(j);
3357
3358         ixj_write_cid_byte(j, 0x80);
3359         checksum = 0x80;
3360         ixj_write_cid_byte(j, mdmflen);
3361         checksum = checksum + mdmflen;
3362
3363         ixj_write_cid_byte(j, 0x01);
3364         checksum = checksum + 0x01;
3365         ixj_write_cid_byte(j, len1);
3366         checksum = checksum + len1;
3367         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3368
3369         ixj_write_cid_byte(j, 0x02);
3370         checksum = checksum + 0x02;
3371         ixj_write_cid_byte(j, len2);
3372         checksum = checksum + len2;
3373         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3374
3375         ixj_write_cid_byte(j, 0x07);
3376         checksum = checksum + 0x07;
3377         ixj_write_cid_byte(j, len3);
3378         checksum = checksum + len3;
3379         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3380
3381         checksum %= 256;
3382         checksum ^= 0xFF;
3383         checksum += 1;
3384
3385         ixj_write_cid_byte(j, (char) checksum);
3386
3387         pad = j->fskdcnt % 240;
3388         if (pad) {
3389                 pad = 240 - pad;
3390         }
3391         ixj_pad_fsk(j, pad);
3392         if(ixjdebug & 0x0200) {
3393                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3394         }
3395 }
3396
3397 static void ixj_write_vmwi(IXJ *j, int msg)
3398 {
3399         char mdmflen;
3400         int pad;
3401
3402         int checksum = 0;
3403
3404         if (j->dsp.low == 0x20 || j->flags.cidplay)
3405                 return;
3406
3407         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3408         j->cidsize = j->cidcnt = 0;
3409
3410         ixj_fsk_alloc(j);
3411
3412         mdmflen = 3;
3413
3414         if (j->port == PORT_POTS)
3415                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3416
3417         ixj_write_cid_seize(j);
3418
3419         ixj_write_cid_byte(j, 0x82);
3420         checksum = 0x82;
3421         ixj_write_cid_byte(j, mdmflen);
3422         checksum = checksum + mdmflen;
3423
3424         ixj_write_cid_byte(j, 0x0B);
3425         checksum = checksum + 0x0B;
3426         ixj_write_cid_byte(j, 1);
3427         checksum = checksum + 1;
3428
3429         if(msg) {
3430                 ixj_write_cid_byte(j, 0xFF);
3431                 checksum = checksum + 0xFF;
3432         }
3433         else {
3434                 ixj_write_cid_byte(j, 0x00);
3435                 checksum = checksum + 0x00;
3436         }
3437
3438         checksum %= 256;
3439         checksum ^= 0xFF;
3440         checksum += 1;
3441
3442         ixj_write_cid_byte(j, (char) checksum);
3443
3444         pad = j->fskdcnt % 240;
3445         if (pad) {
3446                 pad = 240 - pad;
3447         }
3448         ixj_pad_fsk(j, pad);
3449 }
3450
3451 static void ixj_write_frame(IXJ *j)
3452 {
3453         int cnt, frame_count, dly;
3454         IXJ_WORD dat;
3455
3456         frame_count = 0;
3457         if(j->flags.cidplay) {
3458                 for(cnt = 0; cnt < 480; cnt++) {
3459                         if (!(cnt % 16) && !IsTxReady(j)) {
3460                                 dly = 0;
3461                                 while (!IsTxReady(j)) {
3462                                         if (dly++ > 5) {
3463                                                 dly = 0;
3464                                                 break;
3465                                         }
3466                                         udelay(10);
3467                                 }
3468                         }
3469                         dat.word = j->fskdata[j->cidcnt++];
3470                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3471                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3472                         cnt++;
3473                 }
3474                 if(j->cidcnt >= j->fskdcnt) {
3475                         ixj_post_cid(j);
3476                 }
3477                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3478                    and there is real audio data in the buffer, we need to throw it away because
3479                    we just used it's time slot */
3480                 if (j->write_buffer_rp > j->write_buffer_wp) {
3481                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3482                         if (j->write_buffer_rp >= j->write_buffer_end) {
3483                                 j->write_buffer_rp = j->write_buffer;
3484                         }
3485                         j->write_buffers_empty++;
3486                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3487
3488                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3489                 }
3490         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3491                 if (j->write_buffer_wp > j->write_buffer_rp) {
3492                         frame_count =
3493                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3494                 }
3495                 if (j->write_buffer_rp > j->write_buffer_wp) {
3496                         frame_count =
3497                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3498                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3499                 }
3500                 if (frame_count >= 1) {
3501                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3502                                 BYTES blankword;
3503
3504                                 switch (j->play_mode) {
3505                                 case PLAYBACK_MODE_ULAW:
3506                                 case PLAYBACK_MODE_ALAW:
3507                                         blankword.low = blankword.high = 0xFF;
3508                                         break;
3509                                 case PLAYBACK_MODE_8LINEAR:
3510                                 case PLAYBACK_MODE_16LINEAR:
3511                                 default:
3512                                         blankword.low = blankword.high = 0x00;
3513                                         break;
3514                                 case PLAYBACK_MODE_8LINEAR_WSS:
3515                                         blankword.low = blankword.high = 0x80;
3516                                         break;
3517                                 }
3518                                 for (cnt = 0; cnt < 16; cnt++) {
3519                                         if (!(cnt % 16) && !IsTxReady(j)) {
3520                                                 dly = 0;
3521                                                 while (!IsTxReady(j)) {
3522                                                         if (dly++ > 5) {
3523                                                                 dly = 0;
3524                                                                 break;
3525                                                         }
3526                                                         udelay(10);
3527                                                 }
3528                                         }
3529                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3530                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3531                                 }
3532                                 j->flags.play_first_frame = 0;
3533                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3534                                 for (cnt = 0; cnt < 24; cnt++) {
3535                                         BYTES blankword;
3536
3537                                         if(cnt == 12) {
3538                                                 blankword.low = 0x02;
3539                                                 blankword.high = 0x00;
3540                                         }
3541                                         else {
3542                                                 blankword.low = blankword.high = 0x00;
3543                                         }
3544                                         if (!(cnt % 16) && !IsTxReady(j)) {
3545                                                 dly = 0;
3546                                                 while (!IsTxReady(j)) {
3547                                                         if (dly++ > 5) {
3548                                                                 dly = 0;
3549                                                                 break;
3550                                                         }
3551                                                         udelay(10);
3552                                                 }
3553                                         }
3554                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3555                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3556                                 }
3557                                 j->flags.play_first_frame = 0;
3558                         }
3559                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3560                                 if (!(cnt % 16) && !IsTxReady(j)) {
3561                                         dly = 0;
3562                                         while (!IsTxReady(j)) {
3563                                                 if (dly++ > 5) {
3564                                                         dly = 0;
3565                                                         break;
3566                                                 }
3567                                                 udelay(10);
3568                                         }
3569                                 }
3570                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3571                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3572                                         if (j->write_buffer_rp[cnt] == 0 &&
3573                                             j->write_buffer_rp[cnt + 1] == 0 &&
3574                                             j->write_buffer_rp[cnt + 2] == 0 &&
3575                                             j->write_buffer_rp[cnt + 3] == 0 &&
3576                                             j->write_buffer_rp[cnt + 4] == 0 &&
3577                                             j->write_buffer_rp[cnt + 5] == 0 &&
3578                                             j->write_buffer_rp[cnt + 6] == 0 &&
3579                                             j->write_buffer_rp[cnt + 7] == 0 &&
3580                                             j->write_buffer_rp[cnt + 8] == 0 &&
3581                                             j->write_buffer_rp[cnt + 9] == 0) {
3582                                         /* someone is trying to write silence lets make this a type 0 frame. */
3583                                                 outb_p(0x00, j->DSPbase + 0x0C);
3584                                                 outb_p(0x00, j->DSPbase + 0x0D);
3585                                         } else {
3586                                         /* so all other frames are type 1. */
3587                                                 outb_p(0x01, j->DSPbase + 0x0C);
3588                                                 outb_p(0x00, j->DSPbase + 0x0D);
3589                                         }
3590                                 }
3591                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3592                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3593                                 *(j->write_buffer_rp + cnt) = 0;
3594                                 *(j->write_buffer_rp + cnt + 1) = 0;
3595                         }
3596                         j->write_buffer_rp += j->play_frame_size * 2;
3597                         if (j->write_buffer_rp >= j->write_buffer_end) {
3598                                 j->write_buffer_rp = j->write_buffer;
3599                         }
3600                         j->write_buffers_empty++;
3601                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3602
3603                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3604
3605                         ++j->frameswritten;
3606                 }
3607         } else {
3608                 j->drybuffer++;
3609         }
3610         if(j->ixj_signals[SIG_WRITE_READY]) {
3611                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3612         }
3613 }
3614
3615 static int idle(IXJ *j)
3616 {
3617         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3618
3619                 return 0;
3620
3621         if (j->ssr.high || j->ssr.low) {
3622                 return 0;
3623         } else {
3624                 j->play_mode = -1;
3625                 j->flags.playing = 0;
3626                 j->rec_mode = -1;
3627                 j->flags.recording = 0;
3628                 return 1;
3629         }
3630 }
3631
3632 static int set_base_frame(IXJ *j, int size)
3633 {
3634         unsigned short cmd;
3635         int cnt;
3636
3637         idle(j);
3638         j->cid_play_aec_level = j->aec_level;
3639         aec_stop(j);
3640         for (cnt = 0; cnt < 10; cnt++) {
3641                 if (idle(j))
3642                         break;
3643         }
3644         if (j->ssr.high || j->ssr.low)
3645                 return -1;
3646         if (j->dsp.low != 0x20) {
3647                 switch (size) {
3648                 case 30:
3649                         cmd = 0x07F0;
3650                         /* Set Base Frame Size to 240 pg9-10 8021 */
3651                         break;
3652                 case 20:
3653                         cmd = 0x07A0;
3654                         /* Set Base Frame Size to 160 pg9-10 8021 */
3655                         break;
3656                 case 10:
3657                         cmd = 0x0750;
3658                         /* Set Base Frame Size to 80 pg9-10 8021 */
3659                         break;
3660                 default:
3661                         return -1;
3662                 }
3663         } else {
3664                 if (size == 30)
3665                         return size;
3666                 else
3667                         return -1;
3668         }
3669         if (ixj_WriteDSPCommand(cmd, j)) {
3670                 j->baseframe.high = j->baseframe.low = 0xFF;
3671                 return -1;
3672         } else {
3673                 j->baseframe.high = j->ssr.high;
3674                 j->baseframe.low = j->ssr.low;
3675                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3676                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3677                         return -1;
3678                 }
3679         }
3680         ixj_aec_start(j, j->cid_play_aec_level);
3681         return size;
3682 }
3683
3684 static int set_rec_codec(IXJ *j, int rate)
3685 {
3686         int retval = 0;
3687
3688         j->rec_codec = rate;
3689
3690         switch (rate) {
3691         case G723_63:
3692                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3693                         j->rec_frame_size = 12;
3694                         j->rec_mode = 0;
3695                 } else {
3696                         retval = 1;
3697                 }
3698                 break;
3699         case G723_53:
3700                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3701                         j->rec_frame_size = 10;
3702                         j->rec_mode = 0;
3703                 } else {
3704                         retval = 1;
3705                 }
3706                 break;
3707         case TS85:
3708                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3709                         j->rec_frame_size = 16;
3710                         j->rec_mode = 0;
3711                 } else {
3712                         retval = 1;
3713                 }
3714                 break;
3715         case TS48:
3716                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3717                         j->rec_frame_size = 9;
3718                         j->rec_mode = 0;
3719                 } else {
3720                         retval = 1;
3721                 }
3722                 break;
3723         case TS41:
3724                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3725                         j->rec_frame_size = 8;
3726                         j->rec_mode = 0;
3727                 } else {
3728                         retval = 1;
3729                 }
3730                 break;
3731         case G728:
3732                 if (j->dsp.low != 0x20) {
3733                         j->rec_frame_size = 48;
3734                         j->rec_mode = 0;
3735                 } else {
3736                         retval = 1;
3737                 }
3738                 break;
3739         case G729:
3740                 if (j->dsp.low != 0x20) {
3741                         if (!j->flags.g729_loaded) {
3742                                 retval = 1;
3743                                 break;
3744                         }
3745                         switch (j->baseframe.low) {
3746                         case 0xA0:
3747                                 j->rec_frame_size = 10;
3748                                 break;
3749                         case 0x50:
3750                                 j->rec_frame_size = 5;
3751                                 break;
3752                         default:
3753                                 j->rec_frame_size = 15;
3754                                 break;
3755                         }
3756                         j->rec_mode = 0;
3757                 } else {
3758                         retval = 1;
3759                 }
3760                 break;
3761         case G729B:
3762                 if (j->dsp.low != 0x20) {
3763                         if (!j->flags.g729_loaded) {
3764                                 retval = 1;
3765                                 break;
3766                         }
3767                         switch (j->baseframe.low) {
3768                         case 0xA0:
3769                                 j->rec_frame_size = 12;
3770                                 break;
3771                         case 0x50:
3772                                 j->rec_frame_size = 6;
3773                                 break;
3774                         default:
3775                                 j->rec_frame_size = 18;
3776                                 break;
3777                         }
3778                         j->rec_mode = 0;
3779                 } else {
3780                         retval = 1;
3781                 }
3782                 break;
3783         case ULAW:
3784                 switch (j->baseframe.low) {
3785                 case 0xA0:
3786                         j->rec_frame_size = 80;
3787                         break;
3788                 case 0x50:
3789                         j->rec_frame_size = 40;
3790                         break;
3791                 default:
3792                         j->rec_frame_size = 120;
3793                         break;
3794                 }
3795                 j->rec_mode = 4;
3796                 break;
3797         case ALAW:
3798                 switch (j->baseframe.low) {
3799                 case 0xA0:
3800                         j->rec_frame_size = 80;
3801                         break;
3802                 case 0x50:
3803                         j->rec_frame_size = 40;
3804                         break;
3805                 default:
3806                         j->rec_frame_size = 120;
3807                         break;
3808                 }
3809                 j->rec_mode = 4;
3810                 break;
3811         case LINEAR16:
3812                 switch (j->baseframe.low) {
3813                 case 0xA0:
3814                         j->rec_frame_size = 160;
3815                         break;
3816                 case 0x50:
3817                         j->rec_frame_size = 80;
3818                         break;
3819                 default:
3820                         j->rec_frame_size = 240;
3821                         break;
3822                 }
3823                 j->rec_mode = 5;
3824                 break;
3825         case LINEAR8:
3826                 switch (j->baseframe.low) {
3827                 case 0xA0:
3828                         j->rec_frame_size = 80;
3829                         break;
3830                 case 0x50:
3831                         j->rec_frame_size = 40;
3832                         break;
3833                 default:
3834                         j->rec_frame_size = 120;
3835                         break;
3836                 }
3837                 j->rec_mode = 6;
3838                 break;
3839         case WSS:
3840                 switch (j->baseframe.low) {
3841                 case 0xA0:
3842                         j->rec_frame_size = 80;
3843                         break;
3844                 case 0x50:
3845                         j->rec_frame_size = 40;
3846                         break;
3847                 default:
3848                         j->rec_frame_size = 120;
3849                         break;
3850                 }
3851                 j->rec_mode = 7;
3852                 break;
3853         default:
3854                 kfree(j->read_buffer);
3855                 j->rec_frame_size = 0;
3856                 j->rec_mode = -1;
3857                 j->read_buffer = NULL;
3858                 j->read_buffer_size = 0;
3859                 retval = 1;
3860                 break;
3861         }
3862         return retval;
3863 }
3864
3865 static int ixj_record_start(IXJ *j)
3866 {
3867         unsigned short cmd = 0x0000;
3868
3869         if (j->read_buffer) {
3870                 ixj_record_stop(j);
3871         }
3872         j->flags.recording = 1;
3873         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3874
3875         if(ixjdebug & 0x0002)
3876                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3877
3878         if (!j->rec_mode) {
3879                 switch (j->rec_codec) {
3880                 case G723_63:
3881                         cmd = 0x5131;
3882                         break;
3883                 case G723_53:
3884                         cmd = 0x5132;
3885                         break;
3886                 case TS85:
3887                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3888
3889                         break;
3890                 case TS48:
3891                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3892
3893                         break;
3894                 case TS41:
3895                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3896
3897                         break;
3898                 case G728:
3899                         cmd = 0x5135;
3900                         break;
3901                 case G729:
3902                 case G729B:
3903                         cmd = 0x5136;
3904                         break;
3905                 default:
3906                         return 1;
3907                 }
3908                 if (ixj_WriteDSPCommand(cmd, j))
3909                         return -1;
3910         }
3911         if (!j->read_buffer) {
3912                 if (!j->read_buffer)
3913                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3914                 if (!j->read_buffer) {
3915                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3916                         return -ENOMEM;
3917                 }
3918         }
3919         j->read_buffer_size = j->rec_frame_size * 2;
3920
3921         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3922
3923                 return -1;
3924
3925         switch (j->rec_mode) {
3926         case 0:
3927                 cmd = 0x1C03;   /* Record C1 */
3928
3929                 break;
3930         case 4:
3931                 if (j->ver.low == 0x12) {
3932                         cmd = 0x1E03;   /* Record C1 */
3933
3934                 } else {
3935                         cmd = 0x1E01;   /* Record C1 */
3936
3937                 }
3938                 break;
3939         case 5:
3940                 if (j->ver.low == 0x12) {
3941                         cmd = 0x1E83;   /* Record C1 */
3942
3943                 } else {
3944                         cmd = 0x1E81;   /* Record C1 */
3945
3946                 }
3947                 break;
3948         case 6:
3949                 if (j->ver.low == 0x12) {
3950                         cmd = 0x1F03;   /* Record C1 */
3951
3952                 } else {
3953                         cmd = 0x1F01;   /* Record C1 */
3954
3955                 }
3956                 break;
3957         case 7:
3958                 if (j->ver.low == 0x12) {
3959                         cmd = 0x1F83;   /* Record C1 */
3960                 } else {
3961                         cmd = 0x1F81;   /* Record C1 */
3962                 }
3963                 break;
3964         }
3965         if (ixj_WriteDSPCommand(cmd, j))
3966                 return -1;
3967
3968         if (j->flags.playing) {
3969                 ixj_aec_start(j, j->aec_level);
3970         }
3971         return 0;
3972 }
3973
3974 static void ixj_record_stop(IXJ *j)
3975 {
3976         if (ixjdebug & 0x0002)
3977                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3978
3979         kfree(j->read_buffer);
3980         j->read_buffer = NULL;
3981         j->read_buffer_size = 0;
3982         if (j->rec_mode > -1) {
3983                 ixj_WriteDSPCommand(0x5120, j);
3984                 j->rec_mode = -1;
3985         }
3986         j->flags.recording = 0;
3987 }
3988 static void ixj_vad(IXJ *j, int arg)
3989 {
3990         if (arg)
3991                 ixj_WriteDSPCommand(0x513F, j);
3992         else
3993                 ixj_WriteDSPCommand(0x513E, j);
3994 }
3995
3996 static void set_rec_depth(IXJ *j, int depth)
3997 {
3998         if (depth > 60)
3999                 depth = 60;
4000         if (depth < 0)
4001                 depth = 0;
4002         ixj_WriteDSPCommand(0x5180 + depth, j);
4003 }
4004
4005 static void set_dtmf_prescale(IXJ *j, int volume)
4006 {
4007         ixj_WriteDSPCommand(0xCF07, j);
4008         ixj_WriteDSPCommand(volume, j);
4009 }
4010
4011 static int get_dtmf_prescale(IXJ *j)
4012 {
4013         ixj_WriteDSPCommand(0xCF05, j);
4014         return j->ssr.high << 8 | j->ssr.low;
4015 }
4016
4017 static void set_rec_volume(IXJ *j, int volume)
4018 {
4019         if(j->aec_level == AEC_AGC) {
4020                 if (ixjdebug & 0x0002)
4021                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4022                 ixj_WriteDSPCommand(0xCF96, j);
4023                 ixj_WriteDSPCommand(volume, j);
4024         } else {
4025                 if (ixjdebug & 0x0002)
4026                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4027                 ixj_WriteDSPCommand(0xCF03, j);
4028                 ixj_WriteDSPCommand(volume, j);
4029         }
4030 }
4031
4032 static int set_rec_volume_linear(IXJ *j, int volume)
4033 {
4034         int newvolume, dsprecmax;
4035
4036         if (ixjdebug & 0x0002)
4037                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4038         if(volume > 100 || volume < 0) {
4039           return -1;
4040         }
4041
4042         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4043         switch (j->cardtype) {
4044         case QTI_PHONEJACK:
4045                 dsprecmax = 0x440;
4046                 break;
4047         case QTI_LINEJACK:
4048                 dsprecmax = 0x180;
4049                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4050                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4051                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4052                 break;
4053         case QTI_PHONEJACK_LITE:
4054                 dsprecmax = 0x4C0;
4055                 break;
4056         case QTI_PHONEJACK_PCI:
4057                 dsprecmax = 0x100;
4058                 break;
4059         case QTI_PHONECARD:
4060                 dsprecmax = 0x400;
4061                 break;
4062         default:
4063                 return -1;
4064         }
4065         newvolume = (dsprecmax * volume) / 100;
4066         set_rec_volume(j, newvolume);
4067         return 0;
4068 }
4069
4070 static int get_rec_volume(IXJ *j)
4071 {
4072         if(j->aec_level == AEC_AGC) {
4073                 if (ixjdebug & 0x0002)
4074                         printk(KERN_INFO "Getting AGC Threshold\n");
4075                 ixj_WriteDSPCommand(0xCF86, j);
4076                 if (ixjdebug & 0x0002)
4077                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4078                 return j->ssr.high << 8 | j->ssr.low;
4079         } else {
4080                 if (ixjdebug & 0x0002)
4081                         printk(KERN_INFO "Getting Record Volume\n");
4082                 ixj_WriteDSPCommand(0xCF01, j);
4083                 return j->ssr.high << 8 | j->ssr.low;
4084         }
4085 }
4086
4087 static int get_rec_volume_linear(IXJ *j)
4088 {
4089         int volume, newvolume, dsprecmax;
4090
4091         switch (j->cardtype) {
4092         case QTI_PHONEJACK:
4093                 dsprecmax = 0x440;
4094                 break;
4095         case QTI_LINEJACK:
4096                 dsprecmax = 0x180;
4097                 break;
4098         case QTI_PHONEJACK_LITE:
4099                 dsprecmax = 0x4C0;
4100                 break;
4101         case QTI_PHONEJACK_PCI:
4102                 dsprecmax = 0x100;
4103                 break;
4104         case QTI_PHONECARD:
4105                 dsprecmax = 0x400;
4106                 break;
4107         default:
4108                 return -1;
4109         }
4110         volume = get_rec_volume(j);
4111         newvolume = (volume * 100) / dsprecmax;
4112         if(newvolume > 100)
4113                 newvolume = 100;
4114         return newvolume;
4115 }
4116
4117 static int get_rec_level(IXJ *j)
4118 {
4119         int retval;
4120
4121         ixj_WriteDSPCommand(0xCF88, j);
4122
4123         retval = j->ssr.high << 8 | j->ssr.low;
4124         retval = (retval * 256) / 240;
4125         return retval;
4126 }
4127
4128 static void ixj_aec_start(IXJ *j, int level)
4129 {
4130         j->aec_level = level;
4131         if (ixjdebug & 0x0002)
4132                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4133         if (!level) {
4134                 aec_stop(j);
4135         } else {
4136                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4137                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4138
4139                         ixj_WriteDSPCommand(0x0300, j);
4140                 }
4141                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4142
4143                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4144
4145                 switch (level) {
4146                 case AEC_LOW:
4147                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4148
4149                         ixj_WriteDSPCommand(0xE011, j);
4150                         ixj_WriteDSPCommand(0xFFFF, j);
4151
4152                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4153                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4154
4155                         break;
4156
4157                 case AEC_MED:
4158                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4159
4160                         ixj_WriteDSPCommand(0xE011, j);
4161                         ixj_WriteDSPCommand(0x0080, j);
4162
4163                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4164                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4165
4166                         break;
4167
4168                 case AEC_HIGH:
4169                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4170
4171                         ixj_WriteDSPCommand(0xE011, j);
4172                         ixj_WriteDSPCommand(0x0080, j);
4173
4174                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4175                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4176
4177                         break;
4178
4179                 case AEC_AGC:
4180                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4181                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4182
4183                         ixj_WriteDSPCommand(0xE011, j);
4184                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4185
4186                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4187
4188                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4189                                 ixj_WriteDSPCommand(0x0224, j);
4190                         else
4191                                 ixj_WriteDSPCommand(0x1224, j);
4192
4193                         ixj_WriteDSPCommand(0xE014, j);
4194                         ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4195
4196                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4197
4198                         /* Now we can set the AGC initial parameters and turn it on */
4199                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4200                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4201
4202                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4203                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4204
4205                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4206                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4207
4208                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4209                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4210
4211                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4212                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4213
4214                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4215                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4216
4217                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4218                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4219
4220                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4221                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4222
4223                         break;
4224
4225                 case AEC_AUTO:
4226                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4227
4228                         ixj_WriteDSPCommand(0xE011, j);
4229                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4230
4231                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4232
4233                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4234                                 ixj_WriteDSPCommand(0x0224, j);
4235                         else
4236                                 ixj_WriteDSPCommand(0x1224, j);
4237
4238                         ixj_WriteDSPCommand(0xE014, j);
4239                         ixj_WriteDSPCommand(0x0003, j); /* Lock threshold at 3dB */
4240
4241                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4242
4243                         break;
4244                 }
4245         }
4246 }
4247
4248 static void aec_stop(IXJ *j)
4249 {
4250         j->aec_level = AEC_OFF;
4251         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4252                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4253
4254                 ixj_WriteDSPCommand(0x0700, j);
4255         }
4256         if (j->play_mode != -1 && j->rec_mode != -1)
4257         {
4258                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4259         }
4260 }
4261
4262 static int set_play_codec(IXJ *j, int rate)
4263 {
4264         int retval = 0;
4265
4266         j->play_codec = rate;
4267
4268         switch (rate) {
4269         case G723_63:
4270                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4271                         j->play_frame_size = 12;
4272                         j->play_mode = 0;
4273                 } else {
4274                         retval = 1;
4275                 }
4276                 break;
4277         case G723_53:
4278                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4279                         j->play_frame_size = 10;
4280                         j->play_mode = 0;
4281                 } else {
4282                         retval = 1;
4283                 }
4284                 break;
4285         case TS85:
4286                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4287                         j->play_frame_size = 16;
4288                         j->play_mode = 0;
4289                 } else {
4290                         retval = 1;
4291                 }
4292                 break;
4293         case TS48:
4294                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4295                         j->play_frame_size = 9;
4296                         j->play_mode = 0;
4297                 } else {
4298                         retval = 1;
4299                 }
4300                 break;
4301         case TS41:
4302                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4303                         j->play_frame_size = 8;
4304                         j->play_mode = 0;
4305                 } else {
4306                         retval = 1;
4307                 }
4308                 break;
4309         case G728:
4310                 if (j->dsp.low != 0x20) {
4311                         j->play_frame_size = 48;
4312                         j->play_mode = 0;
4313                 } else {
4314                         retval = 1;
4315                 }
4316                 break;
4317         case G729:
4318                 if (j->dsp.low != 0x20) {
4319                         if (!j->flags.g729_loaded) {
4320                                 retval = 1;
4321                                 break;
4322                         }
4323                         switch (j->baseframe.low) {
4324                         case 0xA0:
4325                                 j->play_frame_size = 10;
4326                                 break;
4327                         case 0x50:
4328                                 j->play_frame_size = 5;
4329                                 break;
4330                         default:
4331                                 j->play_frame_size = 15;
4332                                 break;
4333                         }
4334                         j->play_mode = 0;
4335                 } else {
4336                         retval = 1;
4337                 }
4338                 break;
4339         case G729B:
4340                 if (j->dsp.low != 0x20) {
4341                         if (!j->flags.g729_loaded) {
4342                                 retval = 1;
4343                                 break;
4344                         }
4345                         switch (j->baseframe.low) {
4346                         case 0xA0:
4347                                 j->play_frame_size = 12;
4348                                 break;
4349                         case 0x50:
4350                                 j->play_frame_size = 6;
4351                                 break;
4352                         default:
4353                                 j->play_frame_size = 18;
4354                                 break;
4355                         }
4356                         j->play_mode = 0;
4357                 } else {
4358                         retval = 1;
4359                 }
4360                 break;
4361         case ULAW:
4362                 switch (j->baseframe.low) {
4363                 case 0xA0:
4364                         j->play_frame_size = 80;
4365                         break;
4366                 case 0x50:
4367                         j->play_frame_size = 40;
4368                         break;
4369                 default:
4370                         j->play_frame_size = 120;
4371                         break;
4372                 }
4373                 j->play_mode = 2;
4374                 break;
4375         case ALAW:
4376                 switch (j->baseframe.low) {
4377                 case 0xA0:
4378                         j->play_frame_size = 80;
4379                         break;
4380                 case 0x50:
4381                         j->play_frame_size = 40;
4382                         break;
4383                 default:
4384                         j->play_frame_size = 120;
4385                         break;
4386                 }
4387                 j->play_mode = 2;
4388                 break;
4389         case LINEAR16:
4390                 switch (j->baseframe.low) {
4391                 case 0xA0:
4392                         j->play_frame_size = 160;
4393                         break;
4394                 case 0x50:
4395                         j->play_frame_size = 80;
4396                         break;
4397                 default:
4398                         j->play_frame_size = 240;
4399                         break;
4400                 }
4401                 j->play_mode = 6;
4402                 break;
4403         case LINEAR8:
4404                 switch (j->baseframe.low) {
4405                 case 0xA0:
4406                         j->play_frame_size = 80;
4407                         break;
4408                 case 0x50:
4409                         j->play_frame_size = 40;
4410                         break;
4411                 default:
4412                         j->play_frame_size = 120;
4413                         break;
4414                 }
4415                 j->play_mode = 4;
4416                 break;
4417         case WSS:
4418                 switch (j->baseframe.low) {
4419                 case 0xA0:
4420                         j->play_frame_size = 80;
4421                         break;
4422                 case 0x50:
4423                         j->play_frame_size = 40;
4424                         break;
4425                 default:
4426                         j->play_frame_size = 120;
4427                         break;
4428                 }
4429                 j->play_mode = 5;
4430                 break;
4431         default:
4432                 kfree(j->write_buffer);
4433                 j->play_frame_size = 0;
4434                 j->play_mode = -1;
4435                 j->write_buffer = NULL;
4436                 j->write_buffer_size = 0;
4437                 retval = 1;
4438                 break;
4439         }
4440         return retval;
4441 }
4442
4443 static int ixj_play_start(IXJ *j)
4444 {
4445         unsigned short cmd = 0x0000;
4446
4447         if (j->write_buffer) {
4448                 ixj_play_stop(j);
4449         }
4450
4451         if(ixjdebug & 0x0002)
4452                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4453
4454         j->flags.playing = 1;
4455         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4456
4457         j->flags.play_first_frame = 1;
4458         j->drybuffer = 0;
4459
4460         if (!j->play_mode) {
4461                 switch (j->play_codec) {
4462                 case G723_63:
4463                         cmd = 0x5231;
4464                         break;
4465                 case G723_53:
4466                         cmd = 0x5232;
4467                         break;
4468                 case TS85:
4469                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4470
4471                         break;
4472                 case TS48:
4473                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4474
4475                         break;
4476                 case TS41:
4477                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4478
4479                         break;
4480                 case G728:
4481                         cmd = 0x5235;
4482                         break;
4483                 case G729:
4484                 case G729B:
4485                         cmd = 0x5236;
4486                         break;
4487                 default:
4488                         return 1;
4489                 }
4490                 if (ixj_WriteDSPCommand(cmd, j))
4491                         return -1;
4492         }
4493         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4494         if (!j->write_buffer) {
4495                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4496                 return -ENOMEM;
4497         }
4498 /*      j->write_buffers_empty = 2; */
4499         j->write_buffers_empty = 1;
4500         j->write_buffer_size = j->play_frame_size * 2;
4501         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4502         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4503
4504         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4505
4506                 return -1;
4507
4508         switch (j->play_mode) {
4509         case 0:
4510                 cmd = 0x2C03;
4511                 break;
4512         case 2:
4513                 if (j->ver.low == 0x12) {
4514                         cmd = 0x2C23;
4515                 } else {
4516                         cmd = 0x2C21;
4517                 }
4518                 break;
4519         case 4:
4520                 if (j->ver.low == 0x12) {
4521                         cmd = 0x2C43;
4522                 } else {
4523                         cmd = 0x2C41;
4524                 }
4525                 break;
4526         case 5:
4527                 if (j->ver.low == 0x12) {
4528                         cmd = 0x2C53;
4529                 } else {
4530                         cmd = 0x2C51;
4531                 }
4532                 break;
4533         case 6:
4534                 if (j->ver.low == 0x12) {
4535                         cmd = 0x2C63;
4536                 } else {
4537                         cmd = 0x2C61;
4538                 }
4539                 break;
4540         }
4541         if (ixj_WriteDSPCommand(cmd, j))
4542                 return -1;
4543
4544         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4545                 return -1;
4546
4547         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4548                 return -1;
4549
4550         if (j->flags.recording) {
4551                 ixj_aec_start(j, j->aec_level);
4552         }
4553
4554         return 0;
4555 }
4556
4557 static void ixj_play_stop(IXJ *j)
4558 {
4559         if (ixjdebug & 0x0002)
4560                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4561
4562         kfree(j->write_buffer);
4563         j->write_buffer = NULL;
4564         j->write_buffer_size = 0;
4565         if (j->play_mode > -1) {
4566                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4567
4568                 j->play_mode = -1;
4569         }
4570         j->flags.playing = 0;
4571 }
4572
4573 static inline int get_play_level(IXJ *j)
4574 {
4575         int retval;
4576
4577         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4578         return j->ssr.high << 8 | j->ssr.low;
4579         retval = j->ssr.high << 8 | j->ssr.low;
4580         retval = (retval * 256) / 240;
4581         return retval;
4582 }
4583
4584 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4585 {
4586         unsigned int mask = 0;
4587
4588         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4589
4590         poll_wait(file_p, &(j->poll_q), wait);
4591         if (j->read_buffer_ready > 0)
4592                 mask |= POLLIN | POLLRDNORM;    /* readable */
4593         if (j->write_buffers_empty > 0)
4594                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4595         if (j->ex.bytes)
4596                 mask |= POLLPRI;
4597         return mask;
4598 }
4599
4600 static int ixj_play_tone(IXJ *j, char tone)
4601 {
4602         if (!j->tone_state) {
4603                 if(ixjdebug & 0x0002) {
4604                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4605                 }
4606                 if (j->dsp.low == 0x20) {
4607                         idle(j);
4608                 }
4609                 j->tone_start_jif = jiffies;
4610
4611                 j->tone_state = 1;
4612         }
4613
4614         j->tone_index = tone;
4615         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4616                 return -1;
4617
4618         return 0;
4619 }
4620
4621 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4622 {
4623         j->tone_on_time = arg;
4624
4625         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4626
4627                 return -1;
4628
4629         if (ixj_WriteDSPCommand(arg, j))
4630                 return -1;
4631
4632         return 0;
4633 }
4634
4635 static int SCI_WaitHighSCI(IXJ *j)
4636 {
4637         int cnt;
4638
4639         j->pld_scrr.byte = inb_p(j->XILINXbase);
4640         if (!j->pld_scrr.bits.sci) {
4641                 for (cnt = 0; cnt < 10; cnt++) {
4642                         udelay(32);
4643                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4644
4645                         if ((j->pld_scrr.bits.sci))
4646                                 return 1;
4647                 }
4648                 if (ixjdebug & 0x0001)
4649                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4650                 return 0;
4651         } else
4652                 return 1;
4653 }
4654
4655 static int SCI_WaitLowSCI(IXJ *j)
4656 {
4657         int cnt;
4658
4659         j->pld_scrr.byte = inb_p(j->XILINXbase);
4660         if (j->pld_scrr.bits.sci) {
4661                 for (cnt = 0; cnt < 10; cnt++) {
4662                         udelay(32);
4663                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4664
4665                         if (!(j->pld_scrr.bits.sci))
4666                                 return 1;
4667                 }
4668                 if (ixjdebug & 0x0001)
4669                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4670                 return 0;
4671         } else
4672                 return 1;
4673 }
4674
4675 static int SCI_Control(IXJ *j, int control)
4676 {
4677         switch (control) {
4678         case SCI_End:
4679                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4680
4681                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4682
4683                 break;
4684         case SCI_Enable_DAA:
4685                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4686
4687                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4688
4689                 break;
4690         case SCI_Enable_Mixer:
4691                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4692
4693                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4694
4695                 break;
4696         case SCI_Enable_EEPROM:
4697                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4698
4699                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4700
4701                 break;
4702         default:
4703                 return 0;
4704                 break;
4705         }
4706         outb_p(j->pld_scrw.byte, j->XILINXbase);
4707
4708         switch (control) {
4709         case SCI_End:
4710                 return 1;
4711                 break;
4712         case SCI_Enable_DAA:
4713         case SCI_Enable_Mixer:
4714         case SCI_Enable_EEPROM:
4715                 if (!SCI_WaitHighSCI(j))
4716                         return 0;
4717                 break;
4718         default:
4719                 return 0;
4720                 break;
4721         }
4722         return 1;
4723 }
4724
4725 static int SCI_Prepare(IXJ *j)
4726 {
4727         if (!SCI_Control(j, SCI_End))
4728                 return 0;
4729
4730         if (!SCI_WaitLowSCI(j))
4731                 return 0;
4732
4733         return 1;
4734 }
4735
4736 static int ixj_get_mixer(long val, IXJ *j)
4737 {
4738         int reg = (val & 0x1F00) >> 8;
4739         return j->mix.vol[reg];
4740 }
4741
4742 static int ixj_mixer(long val, IXJ *j)
4743 {
4744         BYTES bytes;
4745
4746         bytes.high = (val & 0x1F00) >> 8;
4747         bytes.low = val & 0x00FF;
4748
4749         /* save mixer value so we can get back later on */
4750         j->mix.vol[bytes.high] = bytes.low;
4751
4752         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4753
4754         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4755
4756         SCI_Control(j, SCI_Enable_Mixer);
4757
4758         SCI_Control(j, SCI_End);
4759
4760         return 0;
4761 }
4762
4763 static int daa_load(BYTES * p_bytes, IXJ *j)
4764 {
4765         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4766         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4767         if (!SCI_Control(j, SCI_Enable_DAA))
4768                 return 0;
4769         else
4770                 return 1;
4771 }
4772
4773 static int ixj_daa_cr4(IXJ *j, char reg)
4774 {
4775         BYTES bytes;
4776
4777         switch (j->daa_mode) {
4778         case SOP_PU_SLEEP:
4779                 bytes.high = 0x14;
4780                 break;
4781         case SOP_PU_RINGING:
4782                 bytes.high = 0x54;
4783                 break;
4784         case SOP_PU_CONVERSATION:
4785                 bytes.high = 0x94;
4786                 break;
4787         case SOP_PU_PULSEDIALING:
4788                 bytes.high = 0xD4;
4789                 break;
4790         }
4791
4792         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4793
4794         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4795         case 0:
4796                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4797                 break;
4798         case 1:
4799                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4800                 break;
4801         case 2:
4802                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4803                 break;
4804         case 3:
4805                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4806                 break;
4807         }
4808
4809         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4810
4811         if (!daa_load(&bytes, j))
4812                 return 0;
4813
4814         if (!SCI_Prepare(j))
4815                 return 0;
4816
4817         return 1;
4818 }
4819
4820 static char daa_int_read(IXJ *j)
4821 {
4822         BYTES bytes;
4823
4824         if (!SCI_Prepare(j))
4825                 return 0;
4826
4827         bytes.high = 0x38;
4828         bytes.low = 0x00;
4829         outb_p(bytes.high, j->XILINXbase + 0x03);
4830         outb_p(bytes.low, j->XILINXbase + 0x02);
4831
4832         if (!SCI_Control(j, SCI_Enable_DAA))
4833                 return 0;
4834
4835         bytes.high = inb_p(j->XILINXbase + 0x03);
4836         bytes.low = inb_p(j->XILINXbase + 0x02);
4837         if (bytes.low != ALISDAA_ID_BYTE) {
4838                 if (ixjdebug & 0x0001)
4839                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4840                 return 0;
4841         }
4842         if (!SCI_Control(j, SCI_Enable_DAA))
4843                 return 0;
4844         if (!SCI_Control(j, SCI_End))
4845                 return 0;
4846
4847         bytes.high = inb_p(j->XILINXbase + 0x03);
4848         bytes.low = inb_p(j->XILINXbase + 0x02);
4849
4850         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4851
4852         return 1;
4853 }
4854
4855 static char daa_CR_read(IXJ *j, int cr)
4856 {
4857         IXJ_WORD wdata;
4858         BYTES bytes;
4859
4860         if (!SCI_Prepare(j))
4861                 return 0;
4862
4863         switch (j->daa_mode) {
4864         case SOP_PU_SLEEP:
4865                 bytes.high = 0x30 + cr;
4866                 break;
4867         case SOP_PU_RINGING:
4868                 bytes.high = 0x70 + cr;
4869                 break;
4870         case SOP_PU_CONVERSATION:
4871                 bytes.high = 0xB0 + cr;
4872                 break;
4873         case SOP_PU_PULSEDIALING:
4874         default:
4875                 bytes.high = 0xF0 + cr;
4876                 break;
4877         }
4878
4879         bytes.low = 0x00;
4880
4881         outb_p(bytes.high, j->XILINXbase + 0x03);
4882         outb_p(bytes.low, j->XILINXbase + 0x02);
4883
4884         if (!SCI_Control(j, SCI_Enable_DAA))
4885                 return 0;
4886
4887         bytes.high = inb_p(j->XILINXbase + 0x03);
4888         bytes.low = inb_p(j->XILINXbase + 0x02);
4889         if (bytes.low != ALISDAA_ID_BYTE) {
4890                 if (ixjdebug & 0x0001)
4891                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4892                 return 0;
4893         }
4894         if (!SCI_Control(j, SCI_Enable_DAA))
4895                 return 0;
4896         if (!SCI_Control(j, SCI_End))
4897                 return 0;
4898
4899         wdata.word = inw_p(j->XILINXbase + 0x02);
4900
4901         switch(cr){
4902                 case 5:
4903                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4904                         break;
4905                 case 4:
4906                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4907                         break;
4908                 case 3:
4909                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4910                         break;
4911                 case 2:
4912                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4913                         break;
4914                 case 1:
4915                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4916                         break;
4917                 case 0:
4918                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4919                         break;
4920                 default:
4921                         return 0;
4922         }
4923         return 1;
4924 }
4925
4926 static int ixj_daa_cid_reset(IXJ *j)
4927 {
4928         int i;
4929         BYTES bytes;
4930
4931         if (ixjdebug & 0x0002)
4932                 printk("DAA Clearing CID ram\n");
4933
4934         if (!SCI_Prepare(j))
4935                 return 0;
4936
4937         bytes.high = 0x58;
4938         bytes.low = 0x00;
4939         outb_p(bytes.high, j->XILINXbase + 0x03);
4940         outb_p(bytes.low, j->XILINXbase + 0x02);
4941
4942         if (!SCI_Control(j, SCI_Enable_DAA))
4943                 return 0;
4944
4945         if (!SCI_WaitHighSCI(j))
4946                 return 0;
4947
4948         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4949                 bytes.high = bytes.low = 0x00;
4950                 outb_p(bytes.high, j->XILINXbase + 0x03);
4951
4952                 if (i < ALISDAA_CALLERID_SIZE - 1)
4953                         outb_p(bytes.low, j->XILINXbase + 0x02);
4954
4955                 if (!SCI_Control(j, SCI_Enable_DAA))
4956                         return 0;
4957
4958                 if (!SCI_WaitHighSCI(j))
4959                         return 0;
4960
4961         }
4962
4963         if (!SCI_Control(j, SCI_End))
4964                 return 0;
4965
4966         if (ixjdebug & 0x0002)
4967                 printk("DAA CID ram cleared\n");
4968
4969         return 1;
4970 }
4971
4972 static int ixj_daa_cid_read(IXJ *j)
4973 {
4974         int i;
4975         BYTES bytes;
4976         char CID[ALISDAA_CALLERID_SIZE];
4977         bool mContinue;
4978         char *pIn, *pOut;
4979
4980         if (!SCI_Prepare(j))
4981                 return 0;
4982
4983         bytes.high = 0x78;
4984         bytes.low = 0x00;
4985         outb_p(bytes.high, j->XILINXbase + 0x03);
4986         outb_p(bytes.low, j->XILINXbase + 0x02);
4987
4988         if (!SCI_Control(j, SCI_Enable_DAA))
4989                 return 0;
4990
4991         if (!SCI_WaitHighSCI(j))
4992                 return 0;
4993
4994         bytes.high = inb_p(j->XILINXbase + 0x03);
4995         bytes.low = inb_p(j->XILINXbase + 0x02);
4996         if (bytes.low != ALISDAA_ID_BYTE) {
4997                 if (ixjdebug & 0x0001)
4998                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4999                 return 0;
5000         }
5001         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5002                 bytes.high = bytes.low = 0x00;
5003                 outb_p(bytes.high, j->XILINXbase + 0x03);
5004                 outb_p(bytes.low, j->XILINXbase + 0x02);
5005
5006                 if (!SCI_Control(j, SCI_Enable_DAA))
5007                         return 0;
5008
5009                 if (!SCI_WaitHighSCI(j))
5010                         return 0;
5011
5012                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5013                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5014         }
5015
5016         if (!SCI_Control(j, SCI_End))
5017                 return 0;
5018
5019         pIn = CID;
5020         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5021         mContinue = true;
5022         while (mContinue) {
5023                 if ((pIn[1] & 0x03) == 0x01) {
5024                         pOut[0] = pIn[0];
5025                 }
5026                 if ((pIn[2] & 0x0c) == 0x04) {
5027                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5028                 }
5029                 if ((pIn[3] & 0x30) == 0x10) {
5030                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5031                 }
5032                 if ((pIn[4] & 0xc0) == 0x40) {
5033                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5034                 } else {
5035                         mContinue = false;
5036                 }
5037                 pIn += 5, pOut += 4;
5038         }
5039         memset(&j->cid, 0, sizeof(PHONE_CID));
5040         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5041         pOut += 4;
5042         strncpy(j->cid.month, pOut, 2);
5043         pOut += 2;
5044         strncpy(j->cid.day, pOut, 2);
5045         pOut += 2;
5046         strncpy(j->cid.hour, pOut, 2);
5047         pOut += 2;
5048         strncpy(j->cid.min, pOut, 2);
5049         pOut += 3;
5050         j->cid.numlen = *pOut;
5051         pOut += 1;
5052         strncpy(j->cid.number, pOut, j->cid.numlen);
5053         pOut += j->cid.numlen + 1;
5054         j->cid.namelen = *pOut;
5055         pOut += 1;
5056         strncpy(j->cid.name, pOut, j->cid.namelen);
5057
5058         ixj_daa_cid_reset(j);
5059         return 1;
5060 }
5061
5062 static char daa_get_version(IXJ *j)
5063 {
5064         BYTES bytes;
5065
5066         if (!SCI_Prepare(j))
5067                 return 0;
5068
5069         bytes.high = 0x35;
5070         bytes.low = 0x00;
5071         outb_p(bytes.high, j->XILINXbase + 0x03);
5072         outb_p(bytes.low, j->XILINXbase + 0x02);
5073
5074         if (!SCI_Control(j, SCI_Enable_DAA))
5075                 return 0;
5076
5077         bytes.high = inb_p(j->XILINXbase + 0x03);
5078         bytes.low = inb_p(j->XILINXbase + 0x02);
5079         if (bytes.low != ALISDAA_ID_BYTE) {
5080                 if (ixjdebug & 0x0001)
5081                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5082                 return 0;
5083         }
5084         if (!SCI_Control(j, SCI_Enable_DAA))
5085                 return 0;
5086
5087         if (!SCI_Control(j, SCI_End))
5088                 return 0;
5089
5090         bytes.high = inb_p(j->XILINXbase + 0x03);
5091         bytes.low = inb_p(j->XILINXbase + 0x02);
5092         if (ixjdebug & 0x0002)
5093                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5094         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5095         return bytes.high;
5096 }
5097
5098 static int daa_set_mode(IXJ *j, int mode)
5099 {
5100         /* NOTE:
5101               The DAA *MUST* be in the conversation mode if the
5102               PSTN line is to be seized (PSTN line off-hook).
5103               Taking the PSTN line off-hook while the DAA is in
5104               a mode other than conversation mode will cause a
5105               hardware failure of the ALIS-A part.
5106
5107            NOTE:
5108               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5109               if the PSTN line is on-hook.  Failure to have the PSTN line
5110               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5111               ALIS-A part.
5112         */
5113
5114         BYTES bytes;
5115
5116         j->flags.pstn_rmr = 0;
5117
5118         if (!SCI_Prepare(j))
5119                 return 0;
5120
5121         switch (mode) {
5122         case SOP_PU_RESET:
5123                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5124
5125                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5126                 j->pld_slicw.bits.rly2 = 0;
5127                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5128                 bytes.high = 0x10;
5129                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5130                 daa_load(&bytes, j);
5131                 if (!SCI_Prepare(j))
5132                         return 0;
5133
5134                 j->daa_mode = SOP_PU_SLEEP;
5135                 break;
5136         case SOP_PU_SLEEP:
5137                 if(j->daa_mode == SOP_PU_SLEEP)
5138                 {
5139                         break;
5140                 }
5141                 if (ixjdebug & 0x0008)
5142                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5143 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5144                 {
5145                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5146
5147                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5148                         j->pld_slicw.bits.rly2 = 0;
5149                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5150                         bytes.high = 0x10;
5151                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5152                         daa_load(&bytes, j);
5153                         if (!SCI_Prepare(j))
5154                                 return 0;
5155                 }
5156                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5157
5158                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5159                 j->pld_slicw.bits.rly2 = 0;
5160                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5161                 bytes.high = 0x10;
5162                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5163                 daa_load(&bytes, j);
5164                 if (!SCI_Prepare(j))
5165                         return 0;
5166
5167                 j->daa_mode = SOP_PU_SLEEP;
5168                 j->flags.pstn_ringing = 0;
5169                 j->ex.bits.pstn_ring = 0;
5170                 j->pstn_sleeptil = jiffies + (hertz / 4);
5171                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5172                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5173                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5174                 break;
5175         case SOP_PU_RINGING:
5176                 if (ixjdebug & 0x0008)
5177                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5178                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5179
5180                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5181                 j->pld_slicw.bits.rly2 = 0;
5182                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5183                 bytes.high = 0x50;
5184                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5185                 daa_load(&bytes, j);
5186                 if (!SCI_Prepare(j))
5187                         return 0;
5188                 j->daa_mode = SOP_PU_RINGING;
5189                 break;
5190         case SOP_PU_CONVERSATION:
5191                 if (ixjdebug & 0x0008)
5192                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5193                 bytes.high = 0x90;
5194                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5195                 daa_load(&bytes, j);
5196                 if (!SCI_Prepare(j))
5197                         return 0;
5198                 j->pld_slicw.bits.rly2 = 1;
5199                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5200                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5201
5202                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5203                 j->daa_mode = SOP_PU_CONVERSATION;
5204                 j->flags.pstn_ringing = 0;
5205                 j->ex.bits.pstn_ring = 0;
5206                 j->pstn_sleeptil = jiffies;
5207                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5208                 break;
5209         case SOP_PU_PULSEDIALING:
5210                 if (ixjdebug & 0x0008)
5211                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5212                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5213
5214                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5215                 j->pld_slicw.bits.rly2 = 0;
5216                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5217                 bytes.high = 0xD0;
5218                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5219                 daa_load(&bytes, j);
5220                 if (!SCI_Prepare(j))
5221                         return 0;
5222                 j->daa_mode = SOP_PU_PULSEDIALING;
5223                 break;
5224         default:
5225                 break;
5226         }
5227         return 1;
5228 }
5229
5230 static int ixj_daa_write(IXJ *j)
5231 {
5232         BYTES bytes;
5233
5234         j->flags.pstncheck = 1;
5235
5236         daa_set_mode(j, SOP_PU_SLEEP);
5237
5238         if (!SCI_Prepare(j))
5239                 return 0;
5240
5241         outb_p(j->pld_scrw.byte, j->XILINXbase);
5242
5243         bytes.high = 0x14;
5244         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5245         if (!daa_load(&bytes, j))
5246                 return 0;
5247
5248         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5249         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5250         if (!daa_load(&bytes, j))
5251                 return 0;
5252
5253         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5254         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5255         if (!daa_load(&bytes, j))
5256                 return 0;
5257
5258         if (!SCI_Prepare(j))
5259                 return 0;
5260
5261         bytes.high = 0x1F;
5262         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5263         if (!daa_load(&bytes, j))
5264                 return 0;
5265
5266         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5267         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5268         if (!daa_load(&bytes, j))
5269                 return 0;
5270
5271         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5272         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5273         if (!daa_load(&bytes, j))
5274                 return 0;
5275
5276         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5277         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5278         if (!daa_load(&bytes, j))
5279                 return 0;
5280
5281         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5282         bytes.low = 0x00;
5283         if (!daa_load(&bytes, j))
5284                 return 0;
5285
5286         if (!SCI_Prepare(j))
5287                 return 0;
5288
5289         bytes.high = 0x00;
5290         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5291         if (!daa_load(&bytes, j))
5292                 return 0;
5293
5294         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5295         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5296         if (!daa_load(&bytes, j))
5297                 return 0;
5298
5299         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5300         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5301         if (!daa_load(&bytes, j))
5302                 return 0;
5303
5304         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5305         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5306         if (!daa_load(&bytes, j))
5307                 return 0;
5308
5309         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5310         bytes.low = 0x00;
5311         if (!daa_load(&bytes, j))
5312                 return 0;
5313
5314         if (!SCI_Control(j, SCI_End))
5315                 return 0;
5316         if (!SCI_WaitLowSCI(j))
5317                 return 0;
5318
5319         bytes.high = 0x01;
5320         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5321         if (!daa_load(&bytes, j))
5322                 return 0;
5323
5324         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5325         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5326         if (!daa_load(&bytes, j))
5327                 return 0;
5328
5329         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5330         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5331         if (!daa_load(&bytes, j))
5332                 return 0;
5333
5334         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5335         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5336         if (!daa_load(&bytes, j))
5337                 return 0;
5338
5339         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5340         bytes.low = 0x00;
5341         if (!daa_load(&bytes, j))
5342                 return 0;
5343
5344         if (!SCI_Control(j, SCI_End))
5345                 return 0;
5346         if (!SCI_WaitLowSCI(j))
5347                 return 0;
5348
5349         bytes.high = 0x02;
5350         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5351         if (!daa_load(&bytes, j))
5352                 return 0;
5353
5354         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5355         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5356         if (!daa_load(&bytes, j))
5357                 return 0;
5358
5359         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5360         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5361         if (!daa_load(&bytes, j))
5362                 return 0;
5363
5364         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5365         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5366         if (!daa_load(&bytes, j))
5367                 return 0;
5368
5369         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5370         bytes.low = 0x00;
5371         if (!daa_load(&bytes, j))
5372                 return 0;
5373
5374         if (!SCI_Control(j, SCI_End))
5375                 return 0;
5376         if (!SCI_WaitLowSCI(j))
5377                 return 0;
5378
5379         bytes.high = 0x03;
5380         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5381         if (!daa_load(&bytes, j))
5382                 return 0;
5383
5384         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5385         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5386         if (!daa_load(&bytes, j))
5387                 return 0;
5388
5389         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5390         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5391         if (!daa_load(&bytes, j))
5392                 return 0;
5393
5394         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5395         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5396         if (!daa_load(&bytes, j))
5397                 return 0;
5398
5399         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5400         bytes.low = 0x00;
5401         if (!daa_load(&bytes, j))
5402                 return 0;
5403
5404         if (!SCI_Control(j, SCI_End))
5405                 return 0;
5406         if (!SCI_WaitLowSCI(j))
5407                 return 0;
5408
5409         bytes.high = 0x04;
5410         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5411         if (!daa_load(&bytes, j))
5412                 return 0;
5413
5414         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5415         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5416         if (!daa_load(&bytes, j))
5417                 return 0;
5418
5419         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5420         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5421         if (!daa_load(&bytes, j))
5422                 return 0;
5423
5424         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5425         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5426         if (!daa_load(&bytes, j))
5427                 return 0;
5428
5429         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5430         bytes.low = 0x00;
5431         if (!daa_load(&bytes, j))
5432                 return 0;
5433
5434         if (!SCI_Control(j, SCI_End))
5435                 return 0;
5436         if (!SCI_WaitLowSCI(j))
5437                 return 0;
5438
5439         bytes.high = 0x05;
5440         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5441         if (!daa_load(&bytes, j))
5442                 return 0;
5443
5444         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5445         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5446         if (!daa_load(&bytes, j))
5447                 return 0;
5448
5449         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5450         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5451         if (!daa_load(&bytes, j))
5452                 return 0;
5453
5454         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5455         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5456         if (!daa_load(&bytes, j))
5457                 return 0;
5458
5459         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5460         bytes.low = 0x00;
5461         if (!daa_load(&bytes, j))
5462                 return 0;
5463
5464         if (!SCI_Control(j, SCI_End))
5465                 return 0;
5466         if (!SCI_WaitLowSCI(j))
5467                 return 0;
5468
5469         bytes.high = 0x06;
5470         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5471         if (!daa_load(&bytes, j))
5472                 return 0;
5473
5474         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5475         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5476         if (!daa_load(&bytes, j))
5477                 return 0;
5478
5479         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5480         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5481         if (!daa_load(&bytes, j))
5482                 return 0;
5483
5484         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5485         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5486         if (!daa_load(&bytes, j))
5487                 return 0;
5488
5489         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5490         bytes.low = 0x00;
5491         if (!daa_load(&bytes, j))
5492                 return 0;
5493
5494         if (!SCI_Control(j, SCI_End))
5495                 return 0;
5496         if (!SCI_WaitLowSCI(j))
5497                 return 0;
5498
5499         bytes.high = 0x07;
5500         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5501         if (!daa_load(&bytes, j))
5502                 return 0;
5503
5504         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5505         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5506         if (!daa_load(&bytes, j))
5507                 return 0;
5508
5509         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5510         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5511         if (!daa_load(&bytes, j))
5512                 return 0;
5513
5514         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5515         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5516         if (!daa_load(&bytes, j))
5517                 return 0;
5518
5519         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5520         bytes.low = 0x00;
5521         if (!daa_load(&bytes, j))
5522                 return 0;
5523
5524         if (!SCI_Control(j, SCI_End))
5525                 return 0;
5526         if (!SCI_WaitLowSCI(j))
5527                 return 0;
5528
5529         bytes.high = 0x08;
5530         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5531         if (!daa_load(&bytes, j))
5532                 return 0;
5533
5534         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5535         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5536         if (!daa_load(&bytes, j))
5537                 return 0;
5538
5539         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5540         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5541         if (!daa_load(&bytes, j))
5542                 return 0;
5543
5544         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5545         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5546         if (!daa_load(&bytes, j))
5547                 return 0;
5548
5549         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5550         bytes.low = 0x00;
5551         if (!daa_load(&bytes, j))
5552                 return 0;
5553
5554         if (!SCI_Control(j, SCI_End))
5555                 return 0;
5556         if (!SCI_WaitLowSCI(j))
5557                 return 0;
5558
5559         bytes.high = 0x09;
5560         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5561         if (!daa_load(&bytes, j))
5562                 return 0;
5563
5564         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5565         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5566         if (!daa_load(&bytes, j))
5567                 return 0;
5568
5569         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5570         bytes.low = 0x00;
5571         if (!daa_load(&bytes, j))
5572                 return 0;
5573
5574         if (!SCI_Control(j, SCI_End))
5575                 return 0;
5576         if (!SCI_WaitLowSCI(j))
5577                 return 0;
5578
5579         bytes.high = 0x0A;
5580         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5581         if (!daa_load(&bytes, j))
5582                 return 0;
5583
5584         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5585         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5586         if (!daa_load(&bytes, j))
5587                 return 0;
5588
5589         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5590         bytes.low = 0x00;
5591         if (!daa_load(&bytes, j))
5592                 return 0;
5593
5594         if (!SCI_Control(j, SCI_End))
5595                 return 0;
5596         if (!SCI_WaitLowSCI(j))
5597                 return 0;
5598
5599         bytes.high = 0x0B;
5600         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5601         if (!daa_load(&bytes, j))
5602                 return 0;
5603
5604         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5605         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5606         if (!daa_load(&bytes, j))
5607                 return 0;
5608
5609         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5610         bytes.low = 0x00;
5611         if (!daa_load(&bytes, j))
5612                 return 0;
5613
5614         if (!SCI_Control(j, SCI_End))
5615                 return 0;
5616         if (!SCI_WaitLowSCI(j))
5617                 return 0;
5618
5619         bytes.high = 0x0C;
5620         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5621         if (!daa_load(&bytes, j))
5622                 return 0;
5623
5624         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5625         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5626         if (!daa_load(&bytes, j))
5627                 return 0;
5628
5629         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5630         bytes.low = 0x00;
5631         if (!daa_load(&bytes, j))
5632                 return 0;
5633
5634         if (!SCI_Control(j, SCI_End))
5635                 return 0;
5636         if (!SCI_WaitLowSCI(j))
5637                 return 0;
5638
5639         bytes.high = 0x0D;
5640         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5641         if (!daa_load(&bytes, j))
5642                 return 0;
5643
5644         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5645         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5646         if (!daa_load(&bytes, j))
5647                 return 0;
5648
5649         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5650         bytes.low = 0x00;
5651         if (!daa_load(&bytes, j))
5652                 return 0;
5653
5654         if (!SCI_Control(j, SCI_End))
5655                 return 0;
5656         if (!SCI_WaitLowSCI(j))
5657                 return 0;
5658
5659         bytes.high = 0x0E;
5660         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5661         if (!daa_load(&bytes, j))
5662                 return 0;
5663
5664         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5665         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5666         if (!daa_load(&bytes, j))
5667                 return 0;
5668
5669         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5670         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5671         if (!daa_load(&bytes, j))
5672                 return 0;
5673
5674         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5675         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5676         if (!daa_load(&bytes, j))
5677                 return 0;
5678
5679         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5680         bytes.low = 0x00;
5681         if (!daa_load(&bytes, j))
5682                 return 0;
5683
5684         if (!SCI_Control(j, SCI_End))
5685                 return 0;
5686         if (!SCI_WaitLowSCI(j))
5687                 return 0;
5688
5689         bytes.high = 0x0F;
5690         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5691         if (!daa_load(&bytes, j))
5692                 return 0;
5693
5694         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5695         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5696         if (!daa_load(&bytes, j))
5697                 return 0;
5698
5699         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5700         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5701         if (!daa_load(&bytes, j))
5702                 return 0;
5703
5704         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5705         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5706         if (!daa_load(&bytes, j))
5707                 return 0;
5708
5709         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5710         bytes.low = 0x00;
5711         if (!daa_load(&bytes, j))
5712                 return 0;
5713
5714         udelay(32);
5715         j->pld_scrr.byte = inb_p(j->XILINXbase);
5716         if (!SCI_Control(j, SCI_End))
5717                 return 0;
5718
5719         outb_p(j->pld_scrw.byte, j->XILINXbase);
5720
5721         if (ixjdebug & 0x0002)
5722                 printk("DAA Coefficients Loaded\n");
5723
5724         j->flags.pstncheck = 0;
5725         return 1;
5726 }
5727
5728 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5729 {
5730         j->tone_off_time = arg;
5731         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5732
5733                 return -1;
5734         if (ixj_WriteDSPCommand(arg, j))
5735                 return -1;
5736         return 0;
5737 }
5738
5739 static int ixj_get_tone_on(IXJ *j)
5740 {
5741         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5742
5743                 return -1;
5744         return 0;
5745 }
5746
5747 static int ixj_get_tone_off(IXJ *j)
5748 {
5749         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5750
5751                 return -1;
5752         return 0;
5753 }
5754
5755 static void ixj_busytone(IXJ *j)
5756 {
5757         j->flags.ringback = 0;
5758         j->flags.dialtone = 0;
5759         j->flags.busytone = 1;
5760         ixj_set_tone_on(0x07D0, j);
5761         ixj_set_tone_off(0x07D0, j);
5762         ixj_play_tone(j, 27);
5763 }
5764
5765 static void ixj_dialtone(IXJ *j)
5766 {
5767         j->flags.ringback = 0;
5768         j->flags.dialtone = 1;
5769         j->flags.busytone = 0;
5770         if (j->dsp.low == 0x20) {
5771                 return;
5772         } else {
5773                 ixj_set_tone_on(0xFFFF, j);
5774                 ixj_set_tone_off(0x0000, j);
5775                 ixj_play_tone(j, 25);
5776         }
5777 }
5778
5779 static void ixj_cpt_stop(IXJ *j)
5780 {
5781         if(j->tone_state || j->tone_cadence_state)
5782         {
5783                 j->flags.dialtone = 0;
5784                 j->flags.busytone = 0;
5785                 j->flags.ringback = 0;
5786                 ixj_set_tone_on(0x0001, j);
5787                 ixj_set_tone_off(0x0000, j);
5788                 ixj_play_tone(j, 0);
5789                 j->tone_state = j->tone_cadence_state = 0;
5790                 if (j->cadence_t) {
5791                         kfree(j->cadence_t->ce);
5792                         kfree(j->cadence_t);
5793                         j->cadence_t = NULL;
5794                 }
5795         }
5796         if (j->play_mode == -1 && j->rec_mode == -1)
5797                 idle(j);
5798         if (j->play_mode != -1 && j->dsp.low == 0x20)
5799                 ixj_play_start(j);
5800         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5801                 ixj_record_start(j);
5802 }
5803
5804 static void ixj_ringback(IXJ *j)
5805 {
5806         j->flags.busytone = 0;
5807         j->flags.dialtone = 0;
5808         j->flags.ringback = 1;
5809         ixj_set_tone_on(0x0FA0, j);
5810         ixj_set_tone_off(0x2EE0, j);
5811         ixj_play_tone(j, 26);
5812 }
5813
5814 static void ixj_testram(IXJ *j)
5815 {
5816         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5817 }
5818
5819 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5820 {
5821         ixj_cadence *lcp;
5822         IXJ_CADENCE_ELEMENT __user *cep;
5823         IXJ_CADENCE_ELEMENT *lcep;
5824         IXJ_TONE ti;
5825         int err;
5826
5827         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5828         if (lcp == NULL)
5829                 return -ENOMEM;
5830
5831         err = -EFAULT;
5832         if (copy_from_user(&lcp->elements_used,
5833                            &cp->elements_used, sizeof(int)))
5834                 goto out;
5835         if (copy_from_user(&lcp->termination,
5836                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5837                 goto out;
5838         if (get_user(cep, &cp->ce))
5839                 goto out;
5840
5841         err = -EINVAL;
5842         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5843                 goto out;
5844
5845         err = -ENOMEM;
5846         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5847         if (!lcep)
5848                 goto out;
5849
5850         err = -EFAULT;
5851         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5852                 goto out1;
5853
5854         if (j->cadence_t) {
5855                 kfree(j->cadence_t->ce);
5856                 kfree(j->cadence_t);
5857         }
5858         lcp->ce = (void *) lcep;
5859         j->cadence_t = lcp;
5860         j->tone_cadence_state = 0;
5861         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5862         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5863         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5864                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5865                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5866                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5867                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5868                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5869                 ixj_init_tone(j, &ti);
5870         }
5871         ixj_play_tone(j, lcp->ce[0].index);
5872         return 1;
5873 out1:
5874         kfree(lcep);
5875 out:
5876         kfree(lcp);
5877         return err;
5878 }
5879
5880 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5881 {
5882         IXJ_FILTER_CADENCE *lcp;
5883         lcp = memdup_user(cp, sizeof(IXJ_FILTER_CADENCE));
5884         if (IS_ERR(lcp)) {
5885                 if(ixjdebug & 0x0001) {
5886                         printk(KERN_INFO "Could not allocate memory for cadence or could not copy cadence to kernel\n");
5887                 }
5888                 return PTR_ERR(lcp);
5889         }
5890         if (lcp->filter > 5) {
5891                 if(ixjdebug & 0x0001) {
5892                         printk(KERN_INFO "Cadence out of range\n");
5893                 }
5894                 kfree(lcp);
5895                 return -1;
5896         }
5897         j->cadence_f[lcp->filter].state = 0;
5898         j->cadence_f[lcp->filter].enable = lcp->enable;
5899         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5900         j->cadence_f[lcp->filter].on1 = lcp->on1;
5901         j->cadence_f[lcp->filter].on1min = 0;
5902         j->cadence_f[lcp->filter].on1max = 0;
5903         j->cadence_f[lcp->filter].off1 = lcp->off1;
5904         j->cadence_f[lcp->filter].off1min = 0;
5905         j->cadence_f[lcp->filter].off1max = 0;
5906         j->cadence_f[lcp->filter].on2 = lcp->on2;
5907         j->cadence_f[lcp->filter].on2min = 0;
5908         j->cadence_f[lcp->filter].on2max = 0;
5909         j->cadence_f[lcp->filter].off2 = lcp->off2;
5910         j->cadence_f[lcp->filter].off2min = 0;
5911         j->cadence_f[lcp->filter].off2max = 0;
5912         j->cadence_f[lcp->filter].on3 = lcp->on3;
5913         j->cadence_f[lcp->filter].on3min = 0;
5914         j->cadence_f[lcp->filter].on3max = 0;
5915         j->cadence_f[lcp->filter].off3 = lcp->off3;
5916         j->cadence_f[lcp->filter].off3min = 0;
5917         j->cadence_f[lcp->filter].off3max = 0;
5918         if(ixjdebug & 0x0002) {
5919                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5920         }
5921         kfree(lcp);
5922         return 0;
5923 }
5924
5925 static void add_caps(IXJ *j)
5926 {
5927         j->caps = 0;
5928         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5929         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5930         j->caplist[j->caps].captype = vendor;
5931         j->caplist[j->caps].handle = j->caps++;
5932         j->caplist[j->caps].captype = device;
5933         switch (j->cardtype) {
5934         case QTI_PHONEJACK:
5935                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5936                 break;
5937         case QTI_LINEJACK:
5938                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5939                 break;
5940         case QTI_PHONEJACK_LITE:
5941                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5942                 break;
5943         case QTI_PHONEJACK_PCI:
5944                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5945                 break;
5946         case QTI_PHONECARD:
5947                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5948                 break;
5949         }
5950         j->caplist[j->caps].cap = j->cardtype;
5951         j->caplist[j->caps].handle = j->caps++;
5952         strcpy(j->caplist[j->caps].desc, "POTS");
5953         j->caplist[j->caps].captype = port;
5954         j->caplist[j->caps].cap = pots;
5955         j->caplist[j->caps].handle = j->caps++;
5956
5957         /* add devices that can do speaker/mic */
5958         switch (j->cardtype) {
5959         case QTI_PHONEJACK:
5960         case QTI_LINEJACK:
5961         case QTI_PHONEJACK_PCI:
5962         case QTI_PHONECARD:
5963                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5964                 j->caplist[j->caps].captype = port;
5965                 j->caplist[j->caps].cap = speaker;
5966                 j->caplist[j->caps].handle = j->caps++;
5967         default:
5968                 break;
5969         }
5970
5971         /* add devices that can do handset */
5972         switch (j->cardtype) {
5973         case QTI_PHONEJACK:
5974                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5975                 j->caplist[j->caps].captype = port;
5976                 j->caplist[j->caps].cap = handset;
5977                 j->caplist[j->caps].handle = j->caps++;
5978                 break;
5979         default:
5980                 break;
5981         }
5982
5983         /* add devices that can do PSTN */
5984         switch (j->cardtype) {
5985         case QTI_LINEJACK:
5986                 strcpy(j->caplist[j->caps].desc, "PSTN");
5987                 j->caplist[j->caps].captype = port;
5988                 j->caplist[j->caps].cap = pstn;
5989                 j->caplist[j->caps].handle = j->caps++;
5990                 break;
5991         default:
5992                 break;
5993         }
5994
5995         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5996         strcpy(j->caplist[j->caps].desc, "ULAW");
5997         j->caplist[j->caps].captype = codec;
5998         j->caplist[j->caps].cap = ULAW;
5999         j->caplist[j->caps].handle = j->caps++;
6000
6001         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6002         j->caplist[j->caps].captype = codec;
6003         j->caplist[j->caps].cap = LINEAR16;
6004         j->caplist[j->caps].handle = j->caps++;
6005
6006         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6007         j->caplist[j->caps].captype = codec;
6008         j->caplist[j->caps].cap = LINEAR8;
6009         j->caplist[j->caps].handle = j->caps++;
6010
6011         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6012         j->caplist[j->caps].captype = codec;
6013         j->caplist[j->caps].cap = WSS;
6014         j->caplist[j->caps].handle = j->caps++;
6015
6016         /* software ALAW codec, made from ULAW */
6017         strcpy(j->caplist[j->caps].desc, "ALAW");
6018         j->caplist[j->caps].captype = codec;
6019         j->caplist[j->caps].cap = ALAW;
6020         j->caplist[j->caps].handle = j->caps++;
6021
6022         /* version 12 of the 8020 does the following codecs in a broken way */
6023         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6024                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6025                 j->caplist[j->caps].captype = codec;
6026                 j->caplist[j->caps].cap = G723_63;
6027                 j->caplist[j->caps].handle = j->caps++;
6028
6029                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6030                 j->caplist[j->caps].captype = codec;
6031                 j->caplist[j->caps].cap = G723_53;
6032                 j->caplist[j->caps].handle = j->caps++;
6033
6034                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6035                 j->caplist[j->caps].captype = codec;
6036                 j->caplist[j->caps].cap = TS48;
6037                 j->caplist[j->caps].handle = j->caps++;
6038
6039                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6040                 j->caplist[j->caps].captype = codec;
6041                 j->caplist[j->caps].cap = TS41;
6042                 j->caplist[j->caps].handle = j->caps++;
6043         }
6044
6045         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6046         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6047                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6048                 j->caplist[j->caps].captype = codec;
6049                 j->caplist[j->caps].cap = TS85;
6050                 j->caplist[j->caps].handle = j->caps++;
6051         }
6052
6053         /* 8021 chips can do G728 */
6054         if (j->dsp.low == 0x21) {
6055                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6056                 j->caplist[j->caps].captype = codec;
6057                 j->caplist[j->caps].cap = G728;
6058                 j->caplist[j->caps].handle = j->caps++;
6059         }
6060
6061         /* 8021/8022 chips can do G729 if loaded */
6062         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6063                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6064                 j->caplist[j->caps].captype = codec;
6065                 j->caplist[j->caps].cap = G729;
6066                 j->caplist[j->caps].handle = j->caps++;
6067         }
6068         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6069                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6070                 j->caplist[j->caps].captype = codec;
6071                 j->caplist[j->caps].cap = G729B;
6072                 j->caplist[j->caps].handle = j->caps++;
6073         }
6074 }
6075
6076 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6077 {
6078         int cnt;
6079         int retval = 0;
6080         for (cnt = 0; cnt < j->caps; cnt++) {
6081                 if (pcreq->captype == j->caplist[cnt].captype
6082                     && pcreq->cap == j->caplist[cnt].cap) {
6083                         retval = 1;
6084                         break;
6085                 }
6086         }
6087         return retval;
6088 }
6089
6090 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6091 {
6092         IXJ_TONE ti;
6093         IXJ_FILTER jf;
6094         IXJ_FILTER_RAW jfr;
6095         void __user *argp = (void __user *)arg;
6096         struct inode *inode = file_p->f_path.dentry->d_inode;
6097         unsigned int minor = iminor(inode);
6098         unsigned int raise, mant;
6099         int board = NUM(inode);
6100
6101         IXJ *j = get_ixj(NUM(inode));
6102
6103         int retval = 0;
6104
6105         /*
6106          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6107          *    This is necessary to keep the DSP from locking up.
6108          */
6109         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6110                 schedule_timeout_interruptible(1);
6111         if (ixjdebug & 0x0040)
6112                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6113         if (minor >= IXJMAX) {
6114                 clear_bit(board, &j->busyflags);
6115                 return -ENODEV;
6116         }
6117         /*
6118          *    Check ioctls only root can use.
6119          */
6120         if (!capable(CAP_SYS_ADMIN)) {
6121                 switch (cmd) {
6122                 case IXJCTL_TESTRAM:
6123                 case IXJCTL_HZ:
6124                         retval = -EPERM;
6125                 }
6126         }
6127         switch (cmd) {
6128         case IXJCTL_TESTRAM:
6129                 ixj_testram(j);
6130                 retval = (j->ssr.high << 8) + j->ssr.low;
6131                 break;
6132         case IXJCTL_CARDTYPE:
6133                 retval = j->cardtype;
6134                 break;
6135         case IXJCTL_SERIAL:
6136                 retval = j->serial;
6137                 break;
6138         case IXJCTL_VERSION:
6139                 {
6140                         char arg_str[100];
6141                         snprintf(arg_str, sizeof(arg_str),
6142                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6143                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6144                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6145                                 retval = -EFAULT;
6146                 }
6147                 break;
6148         case PHONE_RING_CADENCE:
6149                 j->ring_cadence = arg;
6150                 break;
6151         case IXJCTL_CIDCW:
6152                 if(arg) {
6153                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6154                                 retval = -EFAULT;
6155                                 break;
6156                         }
6157                 } else {
6158                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6159                 }
6160                 ixj_write_cidcw(j);
6161                 break;
6162         /* Binary compatbility */
6163         case OLD_PHONE_RING_START:
6164                 arg = 0;
6165                 /* Fall through */
6166         case PHONE_RING_START:
6167                 if(arg) {
6168                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6169                                 retval = -EFAULT;
6170                                 break;
6171                         }
6172                         ixj_write_cid(j);
6173                 } else {
6174                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6175                 }
6176                 ixj_ring_start(j);
6177                 break;
6178         case PHONE_RING_STOP:
6179                 j->flags.cringing = 0;
6180                 if(j->cadence_f[5].enable) {
6181                         j->cadence_f[5].state = 0;
6182                 }
6183                 ixj_ring_off(j);
6184                 break;
6185         case PHONE_RING:
6186                 retval = ixj_ring(j);
6187                 break;
6188         case PHONE_EXCEPTION:
6189                 retval = j->ex.bytes;
6190                 if(j->ex.bits.flash) {
6191                         j->flash_end = 0;
6192                         j->ex.bits.flash = 0;
6193                 }
6194                 j->ex.bits.pstn_ring = 0;
6195                 j->ex.bits.caller_id = 0;
6196                 j->ex.bits.pstn_wink = 0;
6197                 j->ex.bits.f0 = 0;
6198                 j->ex.bits.f1 = 0;
6199                 j->ex.bits.f2 = 0;
6200                 j->ex.bits.f3 = 0;
6201                 j->ex.bits.fc0 = 0;
6202                 j->ex.bits.fc1 = 0;
6203                 j->ex.bits.fc2 = 0;
6204                 j->ex.bits.fc3 = 0;
6205                 j->ex.bits.reserved = 0;
6206                 break;
6207         case PHONE_HOOKSTATE:
6208                 j->ex.bits.hookstate = 0;
6209                 retval = j->hookstate;  //j->r_hook;
6210                 break;
6211         case IXJCTL_SET_LED:
6212                 LED_SetState(arg, j);
6213                 break;
6214         case PHONE_FRAME:
6215                 retval = set_base_frame(j, arg);
6216                 break;
6217         case PHONE_REC_CODEC:
6218                 retval = set_rec_codec(j, arg);
6219                 break;
6220         case PHONE_VAD:
6221                 ixj_vad(j, arg);
6222                 break;
6223         case PHONE_REC_START:
6224                 ixj_record_start(j);
6225                 break;
6226         case PHONE_REC_STOP:
6227                 ixj_record_stop(j);
6228                 break;
6229         case PHONE_REC_DEPTH:
6230                 set_rec_depth(j, arg);
6231                 break;
6232         case PHONE_REC_VOLUME:
6233                 if(arg == -1) {
6234                         retval = get_rec_volume(j);
6235                 }
6236                 else {
6237                         set_rec_volume(j, arg);
6238                         retval = arg;
6239                 }
6240                 break;
6241         case PHONE_REC_VOLUME_LINEAR:
6242                 if(arg == -1) {
6243                         retval = get_rec_volume_linear(j);
6244                 }
6245                 else {
6246                         set_rec_volume_linear(j, arg);
6247                         retval = arg;
6248                 }
6249                 break;
6250         case IXJCTL_DTMF_PRESCALE:
6251                 if(arg == -1) {
6252                         retval = get_dtmf_prescale(j);
6253                 }
6254                 else {
6255                         set_dtmf_prescale(j, arg);
6256                         retval = arg;
6257                 }
6258                 break;
6259         case PHONE_REC_LEVEL:
6260                 retval = get_rec_level(j);
6261                 break;
6262         case IXJCTL_SC_RXG:
6263                 retval = ixj_siadc(j, arg);
6264                 break;
6265         case IXJCTL_SC_TXG:
6266                 retval = ixj_sidac(j, arg);
6267                 break;
6268         case IXJCTL_AEC_START:
6269                 ixj_aec_start(j, arg);
6270                 break;
6271         case IXJCTL_AEC_STOP:
6272                 aec_stop(j);
6273                 break;
6274         case IXJCTL_AEC_GET_LEVEL:
6275                 retval = j->aec_level;
6276                 break;
6277         case PHONE_PLAY_CODEC:
6278                 retval = set_play_codec(j, arg);
6279                 break;
6280         case PHONE_PLAY_START:
6281                 retval = ixj_play_start(j);
6282                 break;
6283         case PHONE_PLAY_STOP:
6284                 ixj_play_stop(j);
6285                 break;
6286         case PHONE_PLAY_DEPTH:
6287                 set_play_depth(j, arg);
6288                 break;
6289         case PHONE_PLAY_VOLUME:
6290                 if(arg == -1) {
6291                         retval = get_play_volume(j);
6292                 }
6293                 else {
6294                         set_play_volume(j, arg);
6295                         retval = arg;
6296                 }
6297                 break;
6298         case PHONE_PLAY_VOLUME_LINEAR:
6299                 if(arg == -1) {
6300                         retval = get_play_volume_linear(j);
6301                 }
6302                 else {
6303                         set_play_volume_linear(j, arg);
6304                         retval = arg;
6305                 }
6306                 break;
6307         case PHONE_PLAY_LEVEL:
6308                 retval = get_play_level(j);
6309                 break;
6310         case IXJCTL_DSP_TYPE:
6311                 retval = (j->dsp.high << 8) + j->dsp.low;
6312                 break;
6313         case IXJCTL_DSP_VERSION:
6314                 retval = (j->ver.high << 8) + j->ver.low;
6315                 break;
6316         case IXJCTL_HZ:
6317                 hertz = arg;
6318                 break;
6319         case IXJCTL_RATE:
6320                 if (arg > hertz)
6321                         retval = -1;
6322                 else
6323                         samplerate = arg;
6324                 break;
6325         case IXJCTL_DRYBUFFER_READ:
6326                 put_user(j->drybuffer, (unsigned long __user *) argp);
6327                 break;
6328         case IXJCTL_DRYBUFFER_CLEAR:
6329                 j->drybuffer = 0;
6330                 break;
6331         case IXJCTL_FRAMES_READ:
6332                 put_user(j->framesread, (unsigned long __user *) argp);
6333                 break;
6334         case IXJCTL_FRAMES_WRITTEN:
6335                 put_user(j->frameswritten, (unsigned long __user *) argp);
6336                 break;
6337         case IXJCTL_READ_WAIT:
6338                 put_user(j->read_wait, (unsigned long __user *) argp);
6339                 break;
6340         case IXJCTL_WRITE_WAIT:
6341                 put_user(j->write_wait, (unsigned long __user *) argp);
6342                 break;
6343         case PHONE_MAXRINGS:
6344                 j->maxrings = arg;
6345                 break;
6346         case PHONE_SET_TONE_ON_TIME:
6347                 ixj_set_tone_on(arg, j);
6348                 break;
6349         case PHONE_SET_TONE_OFF_TIME:
6350                 ixj_set_tone_off(arg, j);
6351                 break;
6352         case PHONE_GET_TONE_ON_TIME:
6353                 if (ixj_get_tone_on(j)) {
6354                         retval = -1;
6355                 } else {
6356                         retval = (j->ssr.high << 8) + j->ssr.low;
6357                 }
6358                 break;
6359         case PHONE_GET_TONE_OFF_TIME:
6360                 if (ixj_get_tone_off(j)) {
6361                         retval = -1;
6362                 } else {
6363                         retval = (j->ssr.high << 8) + j->ssr.low;
6364                 }
6365                 break;
6366         case PHONE_PLAY_TONE:
6367                 if (!j->tone_state)
6368                         retval = ixj_play_tone(j, arg);
6369                 else
6370                         retval = -1;
6371                 break;
6372         case PHONE_GET_TONE_STATE:
6373                 retval = j->tone_state;
6374                 break;
6375         case PHONE_DTMF_READY:
6376                 retval = j->ex.bits.dtmf_ready;
6377                 break;
6378         case PHONE_GET_DTMF:
6379                 if (ixj_hookstate(j)) {
6380                         if (j->dtmf_rp != j->dtmf_wp) {
6381                                 retval = j->dtmfbuffer[j->dtmf_rp];
6382                                 j->dtmf_rp++;
6383                                 if (j->dtmf_rp == 79)
6384                                         j->dtmf_rp = 0;
6385                                 if (j->dtmf_rp == j->dtmf_wp) {
6386                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6387                                 }
6388                         }
6389                 }
6390                 break;
6391         case PHONE_GET_DTMF_ASCII:
6392                 if (ixj_hookstate(j)) {
6393                         if (j->dtmf_rp != j->dtmf_wp) {
6394                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6395                                 case 10:
6396                                         retval = 42;    /* '*'; */
6397
6398                                         break;
6399                                 case 11:
6400                                         retval = 48;    /*'0'; */
6401
6402                                         break;
6403                                 case 12:
6404                                         retval = 35;    /*'#'; */
6405
6406                                         break;
6407                                 case 28:
6408                                         retval = 65;    /*'A'; */
6409
6410                                         break;
6411                                 case 29:
6412                                         retval = 66;    /*'B'; */
6413
6414                                         break;
6415                                 case 30:
6416                                         retval = 67;    /*'C'; */
6417
6418                                         break;
6419                                 case 31:
6420                                         retval = 68;    /*'D'; */
6421
6422                                         break;
6423                                 default:
6424                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6425                                         break;
6426                                 }
6427                                 j->dtmf_rp++;
6428                                 if (j->dtmf_rp == 79)
6429                                         j->dtmf_rp = 0;
6430                                 if(j->dtmf_rp == j->dtmf_wp)
6431                                 {
6432                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6433                                 }
6434                         }
6435                 }
6436                 break;
6437         case PHONE_DTMF_OOB:
6438                 j->flags.dtmf_oob = arg;
6439                 break;
6440         case PHONE_DIALTONE:
6441                 ixj_dialtone(j);
6442                 break;
6443         case PHONE_BUSY:
6444                 ixj_busytone(j);
6445                 break;
6446         case PHONE_RINGBACK:
6447                 ixj_ringback(j);
6448                 break;
6449         case PHONE_WINK:
6450                 if(j->cardtype == QTI_PHONEJACK)
6451                         retval = -1;
6452                 else
6453                         retval = ixj_wink(j);
6454                 break;
6455         case PHONE_CPT_STOP:
6456                 ixj_cpt_stop(j);
6457                 break;
6458         case PHONE_QUERY_CODEC:
6459         {
6460                 struct phone_codec_data pd;
6461                 int val;
6462                 int proto_size[] = {
6463                         -1,
6464                         12, 10, 16, 9, 8, 48, 5,
6465                         40, 40, 80, 40, 40, 6
6466                 };
6467                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6468                         retval = -EFAULT;
6469                         break;
6470                 }
6471                 if(pd.type<1 || pd.type>13) {
6472                         retval = -EPROTONOSUPPORT;
6473                         break;
6474                 }
6475                 if(pd.type<G729)
6476                         val=proto_size[pd.type];
6477                 else switch(j->baseframe.low)
6478                 {
6479                         case 0xA0:val=2*proto_size[pd.type];break;
6480                         case 0x50:val=proto_size[pd.type];break;
6481                         default:val=proto_size[pd.type]*3;break;
6482                 }
6483                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6484                 if(copy_to_user(argp, &pd, sizeof(pd)))
6485                         retval = -EFAULT;
6486                 break;
6487         }
6488         case IXJCTL_DSP_IDLE:
6489                 idle(j);
6490                 break;
6491         case IXJCTL_MIXER:
6492                 if ((arg & 0xff) == 0xff)
6493                         retval = ixj_get_mixer(arg, j);
6494                 else
6495                         ixj_mixer(arg, j);
6496                 break;
6497         case IXJCTL_DAA_COEFF_SET:
6498                 switch (arg) {
6499                 case DAA_US:
6500                         DAA_Coeff_US(j);
6501                         retval = ixj_daa_write(j);
6502                         break;
6503                 case DAA_UK:
6504                         DAA_Coeff_UK(j);
6505                         retval = ixj_daa_write(j);
6506                         break;
6507                 case DAA_FRANCE:
6508                         DAA_Coeff_France(j);
6509                         retval = ixj_daa_write(j);
6510                         break;
6511                 case DAA_GERMANY:
6512                         DAA_Coeff_Germany(j);
6513                         retval = ixj_daa_write(j);
6514                         break;
6515                 case DAA_AUSTRALIA:
6516                         DAA_Coeff_Australia(j);
6517                         retval = ixj_daa_write(j);
6518                         break;
6519                 case DAA_JAPAN:
6520                         DAA_Coeff_Japan(j);
6521                         retval = ixj_daa_write(j);
6522                         break;
6523                 default:
6524                         retval = 1;
6525                         break;
6526                 }
6527                 break;
6528         case IXJCTL_DAA_AGAIN:
6529                 ixj_daa_cr4(j, arg | 0x02);
6530                 break;
6531         case IXJCTL_PSTN_LINETEST:
6532                 retval = ixj_linetest(j);
6533                 break;
6534         case IXJCTL_VMWI:
6535                 ixj_write_vmwi(j, arg);
6536                 break;
6537         case IXJCTL_CID:
6538                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6539                         retval = -EFAULT;
6540                 j->ex.bits.caller_id = 0;
6541                 break;
6542         case IXJCTL_WINK_DURATION:
6543                 j->winktime = arg;
6544                 break;
6545         case IXJCTL_PORT:
6546                 if (arg)
6547                         retval = ixj_set_port(j, arg);
6548                 else
6549                         retval = j->port;
6550                 break;
6551         case IXJCTL_POTS_PSTN:
6552                 retval = ixj_set_pots(j, arg);
6553                 break;
6554         case PHONE_CAPABILITIES:
6555                 add_caps(j);
6556                 retval = j->caps;
6557                 break;
6558         case PHONE_CAPABILITIES_LIST:
6559                 add_caps(j);
6560                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6561                         retval = -EFAULT;
6562                 break;
6563         case PHONE_CAPABILITIES_CHECK:
6564                 {
6565                         struct phone_capability cap;
6566                         if (copy_from_user(&cap, argp, sizeof(cap)))
6567                                 retval = -EFAULT;
6568                         else {
6569                                 add_caps(j);
6570                                 retval = capabilities_check(j, &cap);
6571                         }
6572                 }
6573                 break;
6574         case PHONE_PSTN_SET_STATE:
6575                 daa_set_mode(j, arg);
6576                 break;
6577         case PHONE_PSTN_GET_STATE:
6578                 retval = j->daa_mode;
6579                 j->ex.bits.pstn_ring = 0;
6580                 break;
6581         case IXJCTL_SET_FILTER:
6582                 if (copy_from_user(&jf, argp, sizeof(jf)))
6583                         retval = -EFAULT;
6584                 else
6585                         retval = ixj_init_filter(j, &jf);
6586                 break;
6587         case IXJCTL_SET_FILTER_RAW:
6588                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6589                         retval = -EFAULT;
6590                 else
6591                         retval = ixj_init_filter_raw(j, &jfr);
6592                 break;
6593         case IXJCTL_GET_FILTER_HIST:
6594                 if(arg<0||arg>3)
6595                         retval = -EINVAL;
6596                 else
6597                         retval = j->filter_hist[arg];
6598                 break;
6599         case IXJCTL_INIT_TONE:
6600                 if (copy_from_user(&ti, argp, sizeof(ti)))
6601                         retval = -EFAULT;
6602                 else
6603                         retval = ixj_init_tone(j, &ti);
6604                 break;
6605         case IXJCTL_TONE_CADENCE:
6606                 retval = ixj_build_cadence(j, argp);
6607                 break;
6608         case IXJCTL_FILTER_CADENCE:
6609                 retval = ixj_build_filter_cadence(j, argp);
6610                 break;
6611         case IXJCTL_SIGCTL:
6612                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6613                         retval = -EFAULT;
6614                         break;
6615                 }
6616                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6617                 if(j->sigdef.event < 33) {
6618                         raise = 1;
6619                         for(mant = 0; mant < j->sigdef.event; mant++){
6620                                 raise *= 2;
6621                         }
6622                         if(j->sigdef.signal)
6623                                 j->ex_sig.bytes |= raise;
6624                         else
6625                                 j->ex_sig.bytes &= (raise^0xffff);
6626                 }
6627                 break;
6628         case IXJCTL_INTERCOM_STOP:
6629                 if(arg < 0 || arg >= IXJMAX)
6630                         return -EINVAL;
6631                 j->intercom = -1;
6632                 ixj_record_stop(j);
6633                 ixj_play_stop(j);
6634                 idle(j);
6635                 get_ixj(arg)->intercom = -1;
6636                 ixj_record_stop(get_ixj(arg));
6637                 ixj_play_stop(get_ixj(arg));
6638                 idle(get_ixj(arg));
6639                 break;
6640         case IXJCTL_INTERCOM_START:
6641                 if(arg < 0 || arg >= IXJMAX)
6642                         return -EINVAL;
6643                 j->intercom = arg;
6644                 ixj_record_start(j);
6645                 ixj_play_start(j);
6646                 get_ixj(arg)->intercom = board;
6647                 ixj_play_start(get_ixj(arg));
6648                 ixj_record_start(get_ixj(arg));
6649                 break;
6650         }
6651         if (ixjdebug & 0x0040)
6652                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6653         clear_bit(board, &j->busyflags);
6654         return retval;
6655 }
6656
6657 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6658 {
6659         long ret;
6660         mutex_lock(&ixj_mutex);
6661         ret = do_ixj_ioctl(file_p, cmd, arg);
6662         mutex_unlock(&ixj_mutex);
6663         return ret;
6664 }
6665
6666 static int ixj_fasync(int fd, struct file *file_p, int mode)
6667 {
6668         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6669
6670         return fasync_helper(fd, file_p, mode, &j->async_queue);
6671 }
6672
6673 static const struct file_operations ixj_fops =
6674 {
6675         .owner          = THIS_MODULE,
6676         .read           = ixj_enhanced_read,
6677         .write          = ixj_enhanced_write,
6678         .poll           = ixj_poll,
6679         .unlocked_ioctl = ixj_ioctl,
6680         .release        = ixj_release,
6681         .fasync         = ixj_fasync,
6682         .llseek  = default_llseek,
6683 };
6684
6685 static int ixj_linetest(IXJ *j)
6686 {
6687         j->flags.pstncheck = 1; /* Testing */
6688         j->flags.pstn_present = 0; /* Assume the line is not there */
6689
6690         daa_int_read(j);        /*Clear DAA Interrupt flags */
6691         /* */
6692         /* Hold all relays in the normally de-energized position. */
6693         /* */
6694
6695         j->pld_slicw.bits.rly1 = 0;
6696         j->pld_slicw.bits.rly2 = 0;
6697         j->pld_slicw.bits.rly3 = 0;
6698         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6699         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6700
6701         outb_p(j->pld_scrw.byte, j->XILINXbase);
6702         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6703         if (j->pld_slicr.bits.potspstn) {
6704                 j->flags.pots_pstn = 1;
6705                 j->flags.pots_correct = 0;
6706                 LED_SetState(0x4, j);
6707         } else {
6708                 j->flags.pots_pstn = 0;
6709                 j->pld_slicw.bits.rly1 = 0;
6710                 j->pld_slicw.bits.rly2 = 0;
6711                 j->pld_slicw.bits.rly3 = 1;
6712                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6713                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6714
6715                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6716                 daa_set_mode(j, SOP_PU_CONVERSATION);
6717                 msleep(1000);
6718                 daa_int_read(j);
6719                 daa_set_mode(j, SOP_PU_RESET);
6720                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6721                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6722                         LED_SetState(0x4, j);
6723                         j->pld_slicw.bits.rly3 = 0;
6724                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6725                 } else {
6726                         j->flags.pots_correct = 1;
6727                         LED_SetState(0x8, j);
6728                         j->pld_slicw.bits.rly1 = 1;
6729                         j->pld_slicw.bits.rly2 = 0;
6730                         j->pld_slicw.bits.rly3 = 0;
6731                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6732                 }
6733         }
6734         j->pld_slicw.bits.rly3 = 0;
6735         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6736         daa_set_mode(j, SOP_PU_CONVERSATION);
6737         msleep(1000);
6738         daa_int_read(j);
6739         daa_set_mode(j, SOP_PU_RESET);
6740         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6741                 j->pstn_sleeptil = jiffies + (hertz / 4);
6742                 j->flags.pstn_present = 1;
6743         } else {
6744                 j->flags.pstn_present = 0;
6745         }
6746         if (j->flags.pstn_present) {
6747                 if (j->flags.pots_correct) {
6748                         LED_SetState(0xA, j);
6749                 } else {
6750                         LED_SetState(0x6, j);
6751                 }
6752         } else {
6753                 if (j->flags.pots_correct) {
6754                         LED_SetState(0x9, j);
6755                 } else {
6756                         LED_SetState(0x5, j);
6757                 }
6758         }
6759         j->flags.pstncheck = 0; /* Testing */
6760         return j->flags.pstn_present;
6761 }
6762
6763 static int ixj_selfprobe(IXJ *j)
6764 {
6765         unsigned short cmd;
6766         int cnt;
6767         BYTES bytes;
6768
6769         init_waitqueue_head(&j->poll_q);
6770         init_waitqueue_head(&j->read_q);
6771         init_waitqueue_head(&j->write_q);
6772
6773         while(atomic_read(&j->DSPWrite) > 0)
6774                 atomic_dec(&j->DSPWrite);
6775         if (ixjdebug & 0x0002)
6776                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6777         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6778
6779         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6780                 return -1;
6781 /* The read values of the SSR should be 0x00 for the IDLE command */
6782         if (j->ssr.low || j->ssr.high)
6783                 return -1;
6784         if (ixjdebug & 0x0002)
6785                 printk(KERN_INFO "Get Device ID Code\n");
6786         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6787                 return -1;
6788         j->dsp.low = j->ssr.low;
6789         j->dsp.high = j->ssr.high;
6790         if (ixjdebug & 0x0002)
6791                 printk(KERN_INFO "Get Device Version Code\n");
6792         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6793                 return -1;
6794         j->ver.low = j->ssr.low;
6795         j->ver.high = j->ssr.high;
6796         if (!j->cardtype) {
6797                 if (j->dsp.low == 0x21) {
6798                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6799                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6800 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6801                         bytes.low = inb_p(j->XILINXbase + 0x02);
6802                         if (bytes.low == bytes.high)    /*  Register is read only on */
6803                                 /*  Internet PhoneJack Lite */
6804                          {
6805                                 j->cardtype = QTI_PHONEJACK_LITE;
6806                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6807                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6808                                         return -1;
6809                                 }
6810                                 j->pld_slicw.pcib.e1 = 1;
6811                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6812                         } else {
6813                                 j->cardtype = QTI_LINEJACK;
6814
6815                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6816                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6817                                         return -1;
6818                                 }
6819                         }
6820                 } else if (j->dsp.low == 0x22) {
6821                         j->cardtype = QTI_PHONEJACK_PCI;
6822                         request_region(j->XILINXbase, 4, "ixj control");
6823                         j->pld_slicw.pcib.e1 = 1;
6824                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6825                 } else
6826                         j->cardtype = QTI_PHONEJACK;
6827         } else {
6828                 switch (j->cardtype) {
6829                 case QTI_PHONEJACK:
6830                         if (!j->dsp.low != 0x20) {
6831                                 j->dsp.high = 0x80;
6832                                 j->dsp.low = 0x20;
6833                                 ixj_WriteDSPCommand(0x3800, j);
6834                                 j->ver.low = j->ssr.low;
6835                                 j->ver.high = j->ssr.high;
6836                         }
6837                         break;
6838                 case QTI_LINEJACK:
6839                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6840                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6841                                 return -1;
6842                         }
6843                         break;
6844                 case QTI_PHONEJACK_LITE:
6845                 case QTI_PHONEJACK_PCI:
6846                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6847                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6848                                 return -1;
6849                         }
6850                         j->pld_slicw.pcib.e1 = 1;
6851                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6852                         break;
6853                 case QTI_PHONECARD:
6854                         break;
6855                 }
6856         }
6857         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6858                 if (ixjdebug & 0x0002)
6859                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6860                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6861                         return -1;
6862                 if (ixjdebug & 0x0002)
6863                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6864                 if (j->cardtype == QTI_PHONEJACK) {
6865                         cmd = 0x9FF2;
6866                 } else {
6867                         cmd = 0x9FF5;
6868                 }
6869                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6870                         return -1;
6871         } else {
6872                 if (set_base_frame(j, 30) != 30)
6873                         return -1;
6874                 if (ixjdebug & 0x0002)
6875                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6876                 if (j->cardtype == QTI_PHONECARD) {
6877                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6878                                 return -1;
6879                 }
6880                 if (j->cardtype == QTI_LINEJACK) {
6881                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6882                                 return -1;
6883                         if (ixjdebug & 0x0002)
6884                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6885                         j->pld_clock.byte = 0;
6886                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6887                 }
6888         }
6889
6890         if (j->dsp.low == 0x20) {
6891                 if (ixjdebug & 0x0002)
6892                         printk(KERN_INFO "Configure GPIO pins\n");
6893                 j->gpio.bytes.high = 0x09;
6894 /*  bytes.low = 0xEF;  0xF7 */
6895                 j->gpio.bits.gpio1 = 1;
6896                 j->gpio.bits.gpio2 = 1;
6897                 j->gpio.bits.gpio3 = 0;
6898                 j->gpio.bits.gpio4 = 1;
6899                 j->gpio.bits.gpio5 = 1;
6900                 j->gpio.bits.gpio6 = 1;
6901                 j->gpio.bits.gpio7 = 1;
6902                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6903                 if (ixjdebug & 0x0002)
6904                         printk(KERN_INFO "Enable SLIC\n");
6905                 j->gpio.bytes.high = 0x0B;
6906                 j->gpio.bytes.low = 0x00;
6907                 j->gpio.bits.gpio1 = 0;
6908                 j->gpio.bits.gpio2 = 1;
6909                 j->gpio.bits.gpio5 = 0;
6910                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6911                 j->port = PORT_POTS;
6912         } else {
6913                 if (j->cardtype == QTI_LINEJACK) {
6914                         LED_SetState(0x1, j);
6915                         msleep(100);
6916                         LED_SetState(0x2, j);
6917                         msleep(100);
6918                         LED_SetState(0x4, j);
6919                         msleep(100);
6920                         LED_SetState(0x8, j);
6921                         msleep(100);
6922                         LED_SetState(0x0, j);
6923                         daa_get_version(j);
6924                         if (ixjdebug & 0x0002)
6925                                 printk("Loading DAA Coefficients\n");
6926                         DAA_Coeff_US(j);
6927                         if (!ixj_daa_write(j)) {
6928                                 printk("DAA write failed on board %d\n", j->board);
6929                                 return -1;
6930                         }
6931                         if(!ixj_daa_cid_reset(j)) {
6932                                 printk("DAA CID reset failed on board %d\n", j->board);
6933                                 return -1;
6934                         }
6935                         j->flags.pots_correct = 0;
6936                         j->flags.pstn_present = 0;
6937                         ixj_linetest(j);
6938                         if (j->flags.pots_correct) {
6939                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6940
6941                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6942                                 j->pld_slicw.bits.rly1 = 1;
6943                                 j->pld_slicw.bits.spken = 1;
6944                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6945                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6946 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6947                                 j->port = PORT_POTS;
6948                         }
6949                         ixj_set_port(j, PORT_PSTN);
6950                         ixj_set_pots(j, 1);
6951                         if (ixjdebug & 0x0002)
6952                                 printk(KERN_INFO "Enable Mixer\n");
6953                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6954                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6955
6956                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6957                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6958
6959                         ixj_mixer(0x0480, j);   /*FM Left mute */
6960                         ixj_mixer(0x0580, j);   /*FM Right mute */
6961
6962                         ixj_mixer(0x0680, j);   /*CD Left mute */
6963                         ixj_mixer(0x0780, j);   /*CD Right mute */
6964
6965                         ixj_mixer(0x0880, j);   /*Line Left mute */
6966                         ixj_mixer(0x0980, j);   /*Line Right mute */
6967
6968                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6969                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6970
6971                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6972                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6973
6974                         ixj_mixer(0x0E80, j);   /*Mic mute */
6975
6976                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6977
6978                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6979                         ixj_mixer(0x110C, j);
6980
6981
6982                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6983                         ixj_mixer(0x1401, j);
6984
6985                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6986                         ixj_mixer(0x1501, j);
6987
6988                         ixj_mixer(0x1700, j);   /*Clock select */
6989
6990                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6991
6992                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6993
6994                         if (ixjdebug & 0x0002)
6995                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6996                         j->cadence_f[4].state = 0;
6997                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
6998                         j->cadence_f[4].off1 = 0;
6999                         j->cadence_f[4].on2 = 0;
7000                         j->cadence_f[4].off2 = 0;
7001                         j->cadence_f[4].on3 = 0;
7002                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7003                         j->pstn_last_rmr = jiffies;
7004
7005                 } else {
7006                         if (j->cardtype == QTI_PHONECARD) {
7007                                 ixj_WriteDSPCommand(0xCF07, j);
7008                                 ixj_WriteDSPCommand(0x00B0, j);
7009                                 ixj_set_port(j, PORT_SPEAKER);
7010                         } else {
7011                                 ixj_set_port(j, PORT_POTS);
7012                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7013 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7014                         }
7015                 }
7016         }
7017
7018         j->intercom = -1;
7019         j->framesread = j->frameswritten = 0;
7020         j->read_wait = j->write_wait = 0;
7021         j->rxreadycheck = j->txreadycheck = 0;
7022
7023         /* initialise the DTMF prescale to a sensible value */
7024         if (j->cardtype == QTI_LINEJACK) {
7025                 set_dtmf_prescale(j, 0x10);
7026         } else {
7027                 set_dtmf_prescale(j, 0x40);
7028         }
7029         set_play_volume(j, 0x100);
7030         set_rec_volume(j, 0x100);
7031
7032         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7033                 return -1;
7034 /* The read values of the SSR should be 0x00 for the IDLE command */
7035         if (j->ssr.low || j->ssr.high)
7036                 return -1;
7037
7038         if (ixjdebug & 0x0002)
7039                 printk(KERN_INFO "Enable Line Monitor\n");
7040
7041         if (ixjdebug & 0x0002)
7042                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7043
7044         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7045                 return -1;
7046
7047         if (ixjdebug & 0x002)
7048                 printk(KERN_INFO "Enable DTMF Detectors\n");
7049
7050         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7051                 return -1;
7052
7053         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7054                 return -1;
7055
7056         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7057
7058         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7059
7060         j->ex.bits.dtmf_ready = 0;
7061         j->dtmf_state = 0;
7062         j->dtmf_wp = j->dtmf_rp = 0;
7063         j->rec_mode = j->play_mode = -1;
7064         j->flags.ringing = 0;
7065         j->maxrings = MAXRINGS;
7066         j->ring_cadence = USA_RING_CADENCE;
7067         j->drybuffer = 0;
7068         j->winktime = 320;
7069         j->flags.dtmf_oob = 0;
7070         for (cnt = 0; cnt < 4; cnt++)
7071                 j->cadence_f[cnt].enable = 0;
7072         /* must be a device on the specified address */
7073         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7074
7075         /* Set up the default signals for events */
7076         for (cnt = 0; cnt < 35; cnt++)
7077                 j->ixj_signals[cnt] = SIGIO;
7078
7079         /* Set the excetion signal enable flags */
7080         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7081         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 =
7082         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;
7083 #ifdef IXJ_DYN_ALLOC
7084         j->fskdata = NULL;
7085 #endif
7086         j->fskdcnt = 0;
7087         j->cidcw_wait = 0;
7088
7089         /* Register with the Telephony for Linux subsystem */
7090         j->p.f_op = &ixj_fops;
7091         j->p.open = ixj_open;
7092         j->p.board = j->board;
7093         phone_register_device(&j->p, PHONE_UNIT_ANY);
7094
7095         ixj_init_timer(j);
7096         ixj_add_timer(j);
7097         return 0;
7098 }
7099
7100 /*
7101  *      Exported service for pcmcia card handling
7102  */
7103
7104 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7105 {
7106         IXJ *j = ixj_alloc();
7107
7108         j->board = 0;
7109
7110         j->DSPbase = dsp;
7111         j->XILINXbase = xilinx;
7112         j->cardtype = QTI_PHONECARD;
7113         ixj_selfprobe(j);
7114         return j;
7115 }
7116
7117 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7118
7119 static int ixj_get_status_proc(char *buf)
7120 {
7121         int len;
7122         int cnt;
7123         IXJ *j;
7124         len = 0;
7125         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7126         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7127         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7128         len += sprintf(buf + len, "\nUsing old telephony API");
7129         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7130
7131         for (cnt = 0; cnt < IXJMAX; cnt++) {
7132                 j = get_ixj(cnt);
7133                 if(j==NULL)
7134                         continue;
7135                 if (j->DSPbase) {
7136                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7137                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7138                         if (j->cardtype != QTI_PHONEJACK)
7139                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7140                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7141                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7142                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7143                         switch (j->cardtype) {
7144                         case (QTI_PHONEJACK):
7145                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7146                                 break;
7147                         case (QTI_LINEJACK):
7148                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7149                                 if (j->flags.g729_loaded)
7150                                         len += sprintf(buf + len, " w/G.729 A/B");
7151                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7152                                 break;
7153                         case (QTI_PHONEJACK_LITE):
7154                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7155                                 if (j->flags.g729_loaded)
7156                                         len += sprintf(buf + len, " w/G.729 A/B");
7157                                 break;
7158                         case (QTI_PHONEJACK_PCI):
7159                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7160                                 if (j->flags.g729_loaded)
7161                                         len += sprintf(buf + len, " w/G.729 A/B");
7162                                 break;
7163                         case (QTI_PHONECARD):
7164                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7165                                 if (j->flags.g729_loaded)
7166                                         len += sprintf(buf + len, " w/G.729 A/B");
7167                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7168                                 if (!j->pccr1.bits.drf)
7169                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7170                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7171                                 break;
7172                         default:
7173                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7174                                 break;
7175                         }
7176                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7177                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7178                         add_caps(j);
7179                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7180                         if (j->dsp.low != 0x20)
7181                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7182                         if (j->flags.cidsent)
7183                                 len += sprintf(buf + len, "\nCaller ID data sent");
7184                         else
7185                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7186
7187                         len += sprintf(buf + len, "\nPlay CODEC ");
7188                         switch (j->play_codec) {
7189                         case G723_63:
7190                                 len += sprintf(buf + len, "G.723.1 6.3");
7191                                 break;
7192                         case G723_53:
7193                                 len += sprintf(buf + len, "G.723.1 5.3");
7194                                 break;
7195                         case TS85:
7196                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7197                                 break;
7198                         case TS48:
7199                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7200                                 break;
7201                         case TS41:
7202                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7203                                 break;
7204                         case G728:
7205                                 len += sprintf(buf + len, "G.728");
7206                                 break;
7207                         case G729:
7208                                 len += sprintf(buf + len, "G.729");
7209                                 break;
7210                         case G729B:
7211                                 len += sprintf(buf + len, "G.729B");
7212                                 break;
7213                         case ULAW:
7214                                 len += sprintf(buf + len, "uLaw");
7215                                 break;
7216                         case ALAW:
7217                                 len += sprintf(buf + len, "aLaw");
7218                                 break;
7219                         case LINEAR16:
7220                                 len += sprintf(buf + len, "16 bit Linear");
7221                                 break;
7222                         case LINEAR8:
7223                                 len += sprintf(buf + len, "8 bit Linear");
7224                                 break;
7225                         case WSS:
7226                                 len += sprintf(buf + len, "Windows Sound System");
7227                                 break;
7228                         default:
7229                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7230                                 break;
7231                         }
7232                         len += sprintf(buf + len, "\nRecord CODEC ");
7233                         switch (j->rec_codec) {
7234                         case G723_63:
7235                                 len += sprintf(buf + len, "G.723.1 6.3");
7236                                 break;
7237                         case G723_53:
7238                                 len += sprintf(buf + len, "G.723.1 5.3");
7239                                 break;
7240                         case TS85:
7241                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7242                                 break;
7243                         case TS48:
7244                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7245                                 break;
7246                         case TS41:
7247                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7248                                 break;
7249                         case G728:
7250                                 len += sprintf(buf + len, "G.728");
7251                                 break;
7252                         case G729:
7253                                 len += sprintf(buf + len, "G.729");
7254                                 break;
7255                         case G729B:
7256                                 len += sprintf(buf + len, "G.729B");
7257                                 break;
7258                         case ULAW:
7259                                 len += sprintf(buf + len, "uLaw");
7260                                 break;
7261                         case ALAW:
7262                                 len += sprintf(buf + len, "aLaw");
7263                                 break;
7264                         case LINEAR16:
7265                                 len += sprintf(buf + len, "16 bit Linear");
7266                                 break;
7267                         case LINEAR8:
7268                                 len += sprintf(buf + len, "8 bit Linear");
7269                                 break;
7270                         case WSS:
7271                                 len += sprintf(buf + len, "Windows Sound System");
7272                                 break;
7273                         default:
7274                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7275                                 break;
7276                         }
7277                         len += sprintf(buf + len, "\nAEC ");
7278                         switch (j->aec_level) {
7279                         case AEC_OFF:
7280                                 len += sprintf(buf + len, "Off");
7281                                 break;
7282                         case AEC_LOW:
7283                                 len += sprintf(buf + len, "Low");
7284                                 break;
7285                         case AEC_MED:
7286                                 len += sprintf(buf + len, "Med");
7287                                 break;
7288                         case AEC_HIGH:
7289                                 len += sprintf(buf + len, "High");
7290                                 break;
7291                         case AEC_AUTO:
7292                                 len += sprintf(buf + len, "Auto");
7293                                 break;
7294                         case AEC_AGC:
7295                                 len += sprintf(buf + len, "AEC/AGC");
7296                                 break;
7297                         default:
7298                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7299                                 break;
7300                         }
7301
7302                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7303                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7304                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7305
7306                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7307
7308                         if (j->cardtype == QTI_LINEJACK) {
7309                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7310                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7311                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7312                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7313                                 switch (j->daa_mode) {
7314                                 case SOP_PU_SLEEP:
7315                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7316                                         break;
7317                                 case SOP_PU_RINGING:
7318                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7319                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7320                                         break;
7321                                 case SOP_PU_CONVERSATION:
7322                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7323                                         break;
7324                                 case SOP_PU_PULSEDIALING:
7325                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7326                                         break;
7327                                 }
7328                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7329                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7330                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7331                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7332                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7333                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7334                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7335                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7336                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7337                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7338                         }
7339                         switch (j->port) {
7340                         case PORT_POTS:
7341                                 len += sprintf(buf + len, "\nPort POTS");
7342                                 break;
7343                         case PORT_PSTN:
7344                                 len += sprintf(buf + len, "\nPort PSTN");
7345                                 break;
7346                         case PORT_SPEAKER:
7347                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7348                                 break;
7349                         case PORT_HANDSET:
7350                                 len += sprintf(buf + len, "\nPort HANDSET");
7351                                 break;
7352                         }
7353                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7354                                 len += sprintf(buf + len, "\nSLIC state ");
7355                                 switch (SLIC_GetState(j)) {
7356                                 case PLD_SLIC_STATE_OC:
7357                                         len += sprintf(buf + len, "OC");
7358                                         break;
7359                                 case PLD_SLIC_STATE_RINGING:
7360                                         len += sprintf(buf + len, "RINGING");
7361                                         break;
7362                                 case PLD_SLIC_STATE_ACTIVE:
7363                                         len += sprintf(buf + len, "ACTIVE");
7364                                         break;
7365                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7366                                         len += sprintf(buf + len, "OHT");
7367                                         break;
7368                                 case PLD_SLIC_STATE_TIPOPEN:
7369                                         len += sprintf(buf + len, "TIPOPEN");
7370                                         break;
7371                                 case PLD_SLIC_STATE_STANDBY:
7372                                         len += sprintf(buf + len, "STANDBY");
7373                                         break;
7374                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7375                                         len += sprintf(buf + len, "APR");
7376                                         break;
7377                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7378                                         len += sprintf(buf + len, "OHTPR");
7379                                         break;
7380                                 default:
7381                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7382                                         break;
7383                                 }
7384                         }
7385                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7386                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7387 #ifdef PERFMON_STATS
7388                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7389                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7390                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7391                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7392                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7393                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7394                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7395                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7396                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7397                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7398                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7399                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7400                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7401                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7402
7403 #endif
7404                         len += sprintf(buf + len, "\n");
7405                 }
7406         }
7407         return len;
7408 }
7409
7410 static int ixj_read_proc(char *page, char **start, off_t off,
7411                               int count, int *eof, void *data)
7412 {
7413         int len = ixj_get_status_proc(page);
7414         if (len <= off+count) *eof = 1;
7415         *start = page + off;
7416         len -= off;
7417         if (len>count) len = count;
7418         if (len<0) len = 0;
7419         return len;
7420 }
7421
7422
7423 static void cleanup(void)
7424 {
7425         int cnt;
7426         IXJ *j;
7427
7428         for (cnt = 0; cnt < IXJMAX; cnt++) {
7429                 j = get_ixj(cnt);
7430                 if(j != NULL && j->DSPbase) {
7431                         if (ixjdebug & 0x0002)
7432                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7433                         del_timer(&j->timer);
7434                         if (j->cardtype == QTI_LINEJACK) {
7435                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7436
7437                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7438                                 j->pld_slicw.bits.rly1 = 0;
7439                                 j->pld_slicw.bits.rly2 = 0;
7440                                 j->pld_slicw.bits.rly3 = 0;
7441                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7442                                 LED_SetState(0x0, j);
7443                                 if (ixjdebug & 0x0002)
7444                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7445                                 release_region(j->XILINXbase, 8);
7446                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7447                                 if (ixjdebug & 0x0002)
7448                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7449                                 release_region(j->XILINXbase, 4);
7450                         }
7451                         kfree(j->read_buffer);
7452                         kfree(j->write_buffer);
7453                         if (j->dev)
7454                                 pnp_device_detach(j->dev);
7455                         if (ixjdebug & 0x0002)
7456                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7457                         phone_unregister_device(&j->p);
7458                         if (ixjdebug & 0x0002)
7459                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7460                         release_region(j->DSPbase, 16);
7461 #ifdef IXJ_DYN_ALLOC
7462                         if (ixjdebug & 0x0002)
7463                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7464                         kfree(j);
7465                         ixj[cnt] = NULL;
7466 #endif
7467                 }
7468         }
7469         if (ixjdebug & 0x0002)
7470                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7471         remove_proc_entry ("ixj", NULL);
7472 }
7473
7474 /* Typedefs */
7475 typedef struct {
7476         BYTE length;
7477         DWORD bits;
7478 } DATABLOCK;
7479
7480 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7481 {
7482         lastLCC = lastLCC & 0xfb;
7483         lastLCC = lastLCC | (byData ? 4 : 0);
7484         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7485
7486         mdelay(1);
7487         lastLCC = lastLCC | 0x01;
7488         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7489
7490         byData = byData << 1;
7491         lastLCC = lastLCC & 0xfe;
7492         mdelay(1);
7493         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7494
7495 }
7496
7497 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7498 {
7499         mdelay(1);
7500         lastLCC = lastLCC | 0x01;
7501         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7502
7503         lastLCC = lastLCC & 0xfe;
7504         mdelay(1);
7505         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7506
7507         return ((inb(wEEPROMAddress) >> 3) & 1);
7508 }
7509
7510 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7511 {
7512         BYTE lastLCC;
7513         WORD wEEPROMAddress = wAddress + 3;
7514         DWORD i;
7515         BYTE byResult;
7516         *pwResult = 0;
7517         lastLCC = inb(wEEPROMAddress);
7518         lastLCC = lastLCC | 0x02;
7519         lastLCC = lastLCC & 0xfe;
7520         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7521
7522         mdelay(1);              /* delay */
7523
7524         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7525         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7526         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7527         for (i = 0; i < 8; i++) {
7528                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7529                 wLoc <<= 1;
7530         }
7531
7532         for (i = 0; i < 16; i++) {
7533                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7534                 *pwResult = (*pwResult << 1) | byResult;
7535         }
7536
7537         mdelay(1);              /* another delay */
7538
7539         lastLCC = lastLCC & 0xfd;
7540         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7541
7542         return 0;
7543 }
7544
7545 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7546 {
7547         WORD wLo, wHi;
7548         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7549                 return 0;
7550         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7551                 return 0;
7552         return (((DWORD) wHi << 16) | wLo);
7553 }
7554
7555 static int dspio[IXJMAX + 1] =
7556 {
7557         0,
7558 };
7559 static int xio[IXJMAX + 1] =
7560 {
7561         0,
7562 };
7563
7564 module_param_array(dspio, int, NULL, 0);
7565 module_param_array(xio, int, NULL, 0);
7566 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7567 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7568 MODULE_LICENSE("GPL");
7569
7570 static void __exit ixj_exit(void)
7571 {
7572         cleanup();
7573 }
7574
7575 static IXJ *new_ixj(unsigned long port)
7576 {
7577         IXJ *res;
7578         if (!request_region(port, 16, "ixj DSP")) {
7579                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7580                 return NULL;
7581         }
7582         res = ixj_alloc();
7583         if (!res) {
7584                 release_region(port, 16);
7585                 printk(KERN_INFO "ixj: out of memory\n");
7586                 return NULL;
7587         }
7588         res->DSPbase = port;
7589         return res;
7590 }
7591
7592 static int __init ixj_probe_isapnp(int *cnt)
7593 {
7594         int probe = 0;
7595         int func = 0x110;
7596         struct pnp_dev *dev = NULL, *old_dev = NULL;
7597
7598         while (1) {
7599                 do {
7600                         IXJ *j;
7601                         int result;
7602
7603                         old_dev = dev;
7604                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7605                                          ISAPNP_FUNCTION(func), old_dev);
7606                         if (!dev || !dev->card)
7607                                 break;
7608                         result = pnp_device_attach(dev);
7609                         if (result < 0) {
7610                                 printk("pnp attach failed %d \n", result);
7611                                 break;
7612                         }
7613                         if (pnp_activate_dev(dev) < 0) {
7614                                 printk("pnp activate failed (out of resources?)\n");
7615                                 pnp_device_detach(dev);
7616                                 return -ENOMEM;
7617                         }
7618
7619                         if (!pnp_port_valid(dev, 0)) {
7620                                 pnp_device_detach(dev);
7621                                 return -ENODEV;
7622                         }
7623
7624                         j = new_ixj(pnp_port_start(dev, 0));
7625                         if (!j)
7626                                 break;
7627
7628                         if (func != 0x110)
7629                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7630
7631                         switch (func) {
7632                         case (0x110):
7633                                 j->cardtype = QTI_PHONEJACK;
7634                                 break;
7635                         case (0x310):
7636                                 j->cardtype = QTI_LINEJACK;
7637                                 break;
7638                         case (0x410):
7639                                 j->cardtype = QTI_PHONEJACK_LITE;
7640                                 break;
7641                         }
7642                         j->board = *cnt;
7643                         probe = ixj_selfprobe(j);
7644                         if(!probe) {
7645                                 j->serial = dev->card->serial;
7646                                 j->dev = dev;
7647                                 switch (func) {
7648                                 case 0x110:
7649                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7650                                         break;
7651                                 case 0x310:
7652                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7653                                         break;
7654                                 case 0x410:
7655                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7656                                         break;
7657                                 }
7658                         }
7659                         ++*cnt;
7660                 } while (dev);
7661                 if (func == 0x410)
7662                         break;
7663                 if (func == 0x310)
7664                         func = 0x410;
7665                 if (func == 0x110)
7666                         func = 0x310;
7667                 dev = NULL;
7668         }
7669         return probe;
7670 }
7671
7672 static int __init ixj_probe_isa(int *cnt)
7673 {
7674         int i, probe;
7675
7676         /* Use passed parameters for older kernels without PnP */
7677         for (i = 0; i < IXJMAX; i++) {
7678                 if (dspio[i]) {
7679                         IXJ *j = new_ixj(dspio[i]);
7680
7681                         if (!j)
7682                                 break;
7683
7684                         j->XILINXbase = xio[i];
7685                         j->cardtype = 0;
7686
7687                         j->board = *cnt;
7688                         probe = ixj_selfprobe(j);
7689                         j->dev = NULL;
7690                         ++*cnt;
7691                 }
7692         }
7693         return 0;
7694 }
7695
7696 static int __init ixj_probe_pci(int *cnt)
7697 {
7698         struct pci_dev *pci = NULL;
7699         int i, probe = 0;
7700         IXJ *j = NULL;
7701
7702         for (i = 0; i < IXJMAX - *cnt; i++) {
7703                 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7704                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
7705                 if (!pci)
7706                         break;
7707
7708                 if (pci_enable_device(pci))
7709                         break;
7710                 j = new_ixj(pci_resource_start(pci, 0));
7711                 if (!j)
7712                         break;
7713
7714                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7715                 j->XILINXbase = j->DSPbase + 0x10;
7716                 j->cardtype = QTI_PHONEJACK_PCI;
7717                 j->board = *cnt;
7718                 probe = ixj_selfprobe(j);
7719                 if (!probe)
7720                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7721                 ++*cnt;
7722         }
7723         pci_dev_put(pci);
7724         return probe;
7725 }
7726
7727 static int __init ixj_init(void)
7728 {
7729         int cnt = 0;
7730         int probe = 0;
7731
7732         cnt = 0;
7733
7734         /* These might be no-ops, see above. */
7735         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7736                 return probe;
7737         }
7738         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7739                 return probe;
7740         }
7741         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7742                 return probe;
7743         }
7744         printk(KERN_INFO "ixj driver initialized.\n");
7745         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7746         return probe;
7747 }
7748
7749 module_init(ixj_init);
7750 module_exit(ixj_exit);
7751
7752 static void DAA_Coeff_US(IXJ *j)
7753 {
7754         int i;
7755
7756         j->daa_country = DAA_US;
7757         /*----------------------------------------------- */
7758         /* CAO */
7759         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7760                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7761         }
7762
7763 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7764         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7765         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7766         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7767         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7768         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7769         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7771         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7772 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7773         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7774         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7775         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7776         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7777         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7778         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7779         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7780         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7781 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7782         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7783         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7784         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7785         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7786         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7787         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7789         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7790 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7791         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7792         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7793         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7794         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7795         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7796         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7797         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7798         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7799 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7800         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7801         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7802         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7803         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7804 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7805         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7806         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7807         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7808         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7809 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7810         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7811         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7812         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7813         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7817         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7818 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7820         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7821         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7822         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7824         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7826         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7827 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7828         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7829         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7830         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7831         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7832         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7833         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7834         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7835         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7836 /* ;  (10K, 0.68uF) */
7837         /*  */
7838         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7839         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7840         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7841         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7842         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7843         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7844         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7846         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7847         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7848         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7849         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7850         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7851         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7852         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7853         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7854         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7855         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7856
7857         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7858         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7859         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7860         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7861         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7862
7863         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7864 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7865 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7866 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7867 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7868 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7869 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7871 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7872         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7874 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7875 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7876 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7877 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7878 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7879 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7880 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7881 /* */
7882         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7883 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7884 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7885 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7886 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7887
7888         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7889         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7890         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7891         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7892         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7893         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7894         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7896         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7897 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7898         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7899         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7900         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7901         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7902         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7903         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7904         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7905         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7906 /*  */
7907         /* ;CR Registers */
7908         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7909         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7910 /* Config. Reg. 1 (dialing)       (cr1):05 */
7911         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7912 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7913         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7914 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7915         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7916 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7917         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7918         /* Config. Reg. 5 (Version)       (cr5):02 */
7919         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7920         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7921         /*  */
7922         /* ;xr Registers */
7923         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7924
7925         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7926         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7927
7928         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7929 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7930         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7931 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7932         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7933         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7934
7935         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7936 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7937         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7938 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7939         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7940 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7941         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7942         /*  */
7943         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7944         /*                                       12,33,5A,C3 ;  770 Hz   */
7945         /*                                       13,3C,5B,32 ;  852 Hz   */
7946         /*                                       1D,1B,5C,CC ;  941 Hz   */
7947
7948         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7949         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7950         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7951         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7952 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7953         /*                                       EC,1D,52,22 ;  1336 Hz   */
7954         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7955         /*                                       9B,3B,51,25 ;  1633 Hz   */
7956         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7957         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7958         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7959         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7960 }
7961
7962 static void DAA_Coeff_UK(IXJ *j)
7963 {
7964         int i;
7965
7966         j->daa_country = DAA_UK;
7967         /*----------------------------------------------- */
7968         /* CAO */
7969         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7970                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7971         }
7972
7973 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7974         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7975         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7976         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7977         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7978         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7979         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7981         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7982 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7983         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7984         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7985         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7986         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7987         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7988         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7989         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7990         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7991 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7992         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7993         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7994         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7995         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7996         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7997         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7999         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8000 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8001         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8002         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8003         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8004         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8005         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8006         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8007         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8008         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8009 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8010         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8011         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8012         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8013         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8014 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8015         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8016         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8017         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8018         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8019 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8020         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8021         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8022         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8023         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8027         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8028 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8030         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8031         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8032         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8034         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8036         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8037 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8038         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8039         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8040         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8041         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8042         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8043         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8044         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8045         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8046 /* ; idle */
8047         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8048         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8049         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8050         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8051         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8052         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8053         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8055         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8056 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8057         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8058         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8059         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8060         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8061         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8062         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8063         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8064         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8065 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8066         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8067         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8068         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8069         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8070 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8071         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8072         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8073         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8074         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8075         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8076         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8078         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8079 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8080         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8081         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8082         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8083         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8084         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8085         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8086         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8087         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8088 /* ;CR Registers */
8089         /* Config. Reg. 0 (filters)        (cr0):FF */
8090         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8091 /* Config. Reg. 1 (dialing)        (cr1):05 */
8092         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8093 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8094         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8095 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8096         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8097 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8098         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8099         /* Config. Reg. 5 (Version)        (cr5):02 */
8100         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8101         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8102         /* ;xr Registers */
8103         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8104
8105         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8106         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8107
8108         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8109         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8110
8111         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8112 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8113         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8114 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8115         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8116 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8117         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8118 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8119         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8120 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8121         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8122         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8123         /*                                       12,33,5A,C3    ;  770 Hz   */
8124         /*                                       13,3C,5B,32    ;  852 Hz   */
8125         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8126
8127         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8128         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8129         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8130         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8131 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8132         /*                                       EC,1D,52,22    ;  1336 Hz   */
8133         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8134         /*                                       9B,3B,51,25    ;  1633 Hz   */
8135         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8136         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8137         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8138         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8139 }
8140
8141
8142 static void DAA_Coeff_France(IXJ *j)
8143 {
8144         int i;
8145
8146         j->daa_country = DAA_FRANCE;
8147         /*----------------------------------------------- */
8148         /* CAO */
8149         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8150                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8151         }
8152
8153 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8154         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8155         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8156         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8157         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8158         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8159         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8161         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8162 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8163         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8164         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8165         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8166         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8167         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8168         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8169         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8170         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8171 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8172         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8173         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8174         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8175         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8176         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8177         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8179         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8180 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8181         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8182         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8183         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8184         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8185         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8186         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8187         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8188         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8189 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8190         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8191         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8192         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8193         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8194 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8195         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8196         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8197         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8198         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8199 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8200         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8201         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8202         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8203         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8207         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8208 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8210         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8211         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8212         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8214         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8216         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8217 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8218         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8219         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8220         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8221         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8222         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8223         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8224         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8225         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8226 /* ; idle */
8227         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8228         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8229         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8230         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8231         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8232         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8233         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8235         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8236 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8237         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8238         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8239         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8240         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8241         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8242         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8243         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8244         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8245 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8246         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8247         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8248         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8249         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8250 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8251         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8252         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8253         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8254         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8255         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8256         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8258         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8259 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8260         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8261         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8262         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8263         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8264         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8265         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8266         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8267         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8268 /* ;CR Registers */
8269         /* Config. Reg. 0 (filters)        (cr0):FF */
8270         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8271 /* Config. Reg. 1 (dialing)        (cr1):05 */
8272         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8273 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8274         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8275 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8276         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8277 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8278         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8279         /* Config. Reg. 5 (Version)        (cr5):02 */
8280         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8281         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8282         /* ;xr Registers */
8283         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8284
8285         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8286         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8287
8288         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8289         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8290
8291         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8292 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8293         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8294 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8295         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8296 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8297         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8298 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8299         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8300 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8301         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8302         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8303         /*                                       12,33,5A,C3    ;  770 Hz   */
8304         /*                                       13,3C,5B,32    ;  852 Hz   */
8305         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8306
8307         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8308         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8309         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8310         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8311 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8312         /*                                       EC,1D,52,22    ;  1336 Hz   */
8313         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8314         /*                                       9B,3B,51,25    ;  1633 Hz   */
8315         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8316         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8317         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8318         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8319 }
8320
8321
8322 static void DAA_Coeff_Germany(IXJ *j)
8323 {
8324         int i;
8325
8326         j->daa_country = DAA_GERMANY;
8327         /*----------------------------------------------- */
8328         /* CAO */
8329         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8330                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8331         }
8332
8333 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8334         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8335         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8336         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8337         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8338         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8339         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8341         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8342 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8343         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8344         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8345         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8346         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8347         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8348         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8349         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8350         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8351 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8352         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8353         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8354         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8355         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8356         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8357         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8359         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8360 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8361         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8362         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8363         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8364         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8365         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8366         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8367         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8368         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8369 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8370         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8371         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8372         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8373         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8374 /* Bytes for AR-filter        (09): 72,42,13,4B */
8375         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8376         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8377         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8378         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8379 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8380         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8381         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8382         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8383         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8387         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8388 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8390         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8391         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8392         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8394         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8396         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8397 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8398         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8399         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8400         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8401         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8402         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8403         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8404         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8405         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8406 /* ;  (10K, 0.68uF) */
8407         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8408         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8409         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8410         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8411         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8412         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8413         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8415         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8416 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8417         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8418         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8419         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8420         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8421         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8422         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8423         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8424         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8425 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8426         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8427         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8428         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8429         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8430 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8431         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8432         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8433         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8434         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8435         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8436         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8438         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8439 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8440         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8441         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8442         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8443         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8444         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8445         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8446         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8447         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8448 /* ;CR Registers */
8449         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8450         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8451 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8452         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8453 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8454         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8455 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8456         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8457 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8458         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8459         /* Config. Reg. 5 (Version)        (cr5):02 */
8460         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8461         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8462         /* ;xr Registers */
8463         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8464
8465         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8466         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8467
8468         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8469         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8470
8471         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8472 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8473         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8474 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8475         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8476 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8477         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8478 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8479         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8480 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8481         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8482         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8483         /*                                       12,33,5A,C3    ;  770 Hz   */
8484         /*                                       13,3C,5B,32    ;  852 Hz   */
8485         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8486
8487         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8488         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8489         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8490         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8491 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8492         /*                                       EC,1D,52,22    ;  1336 Hz   */
8493         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8494         /*                                       9B,3B,51,25    ;  1633 Hz   */
8495         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8496         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8497         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8498         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8499 }
8500
8501
8502 static void DAA_Coeff_Australia(IXJ *j)
8503 {
8504         int i;
8505
8506         j->daa_country = DAA_AUSTRALIA;
8507         /*----------------------------------------------- */
8508         /* CAO */
8509         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8510                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8511         }
8512
8513 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8514         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8515         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8516         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8517         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8518         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8519         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8521         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8522 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8523         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8524         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8525         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8526         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8527         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8528         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8529         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8530         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8531 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8532         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8533         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8534         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8535         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8536         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8537         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8539         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8540 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8541         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8542         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8543         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8544         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8545         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8546         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8547         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8548         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8549 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8550         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8551         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8552         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8553         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8554 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8555         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8556         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8557         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8558         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8559 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8560         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8561         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8562         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8563         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8567         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8568 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8570         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8571         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8572         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8574         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8576         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8577 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8578         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8579         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8580         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8581         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8582         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8583         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8584         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8585         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8586 /* ;  idle */
8587         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8588         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8589         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8590         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8591         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8592         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8593         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8595         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8596 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8597         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8598         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8599         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8600         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8601         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8602         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8603         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8604         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8605 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8606         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8607         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8608         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8609         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8610 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8611         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8612         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8613         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8614         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8615         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8616         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8618         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8619 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8620         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8621         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8622         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8623         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8624         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8625         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8626         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8627         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8628 /* ;CR Registers */
8629         /* Config. Reg. 0 (filters)        (cr0):FF */
8630         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8631 /* Config. Reg. 1 (dialing)        (cr1):05 */
8632         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8633 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8634         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8635 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8636         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8637 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8638         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8639         /* Config. Reg. 5 (Version)        (cr5):02 */
8640         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8641         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8642         /* ;xr Registers */
8643         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8644
8645         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8646         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8647
8648         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8649         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8650
8651         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8652 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8653         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8654 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8655         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8656 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8657         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8658 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8659         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8660 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8661         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8662
8663         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8664         /*                                       12,33,5A,C3    ;  770 Hz   */
8665         /*                                       13,3C,5B,32    ;  852 Hz   */
8666         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8667         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8668         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8669         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8670         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8671
8672         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8673         /*                                       EC,1D,52,22    ;  1336 Hz   */
8674         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8675         /*                                       9B,3B,51,25    ;  1633 Hz   */
8676         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8677         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8678         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8679         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8680 }
8681
8682 static void DAA_Coeff_Japan(IXJ *j)
8683 {
8684         int i;
8685
8686         j->daa_country = DAA_JAPAN;
8687         /*----------------------------------------------- */
8688         /* CAO */
8689         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8690                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8691         }
8692
8693 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8694         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8695         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8696         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8697         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8698         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8699         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8701         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8702 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8703         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8704         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8705         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8706         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8707         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8708         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8709         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8710         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8711 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8712         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8713         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8714         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8715         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8716         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8717         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8719         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8720 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8721         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8722         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8723         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8724         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8725         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8726         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8727         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8728         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8729 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8730         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8731         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8732         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8733         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8734 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8735         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8736         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8737         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8738         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8739 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8740         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8741         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8742         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8743         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8747         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8748 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8750         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8751         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8752         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8754         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8756         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8757 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8758         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8759         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8760         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8761         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8762         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8763         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8764         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8765         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8766 /* ;  idle */
8767         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8768         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8769         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8770         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8771         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8772         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8773         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8775         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8776 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8777         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8778         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8779         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8780         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8781         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8782         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8783         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8784         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8785 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8786         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8787         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8788         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8789         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8790 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8791         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8792         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8793         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8794         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8795         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8796         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8798         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8799 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8800         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8801         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8802         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8803         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8804         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8805         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8806         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8807         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8808 /* ;CR Registers */
8809         /* Config. Reg. 0 (filters)        (cr0):FF */
8810         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8811 /* Config. Reg. 1 (dialing)        (cr1):05 */
8812         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8813 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8814         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8815 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8816         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8817 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8818         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8819         /* Config. Reg. 5 (Version)        (cr5):02 */
8820         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8821         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8822         /* ;xr Registers */
8823         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8824
8825         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8826         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8827
8828         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8829         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8830
8831         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8832 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8833         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8834 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8835         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8836 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8837         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8838 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8839         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8840 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8841         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8842         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8843         /*                                       12,33,5A,C3    ;  770 Hz   */
8844         /*                                       13,3C,5B,32    ;  852 Hz   */
8845         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8846
8847         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8848         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8849         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8850         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8851 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8852         /*                                       EC,1D,52,22    ;  1336 Hz   */
8853         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8854         /*                                       9B,3B,51,25    ;  1633 Hz   */
8855         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8856         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8857         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8858         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8859 }
8860
8861 static s16 tone_table[][19] =
8862 {
8863         {                       /* f20_50[] 11 */
8864                 32538,          /* A1 = 1.985962 */
8865                  -32325,        /* A2 = -0.986511 */
8866                  -343,          /* B2 = -0.010493 */
8867                  0,             /* B1 = 0 */
8868                  343,           /* B0 = 0.010493 */
8869                  32619,         /* A1 = 1.990906 */
8870                  -32520,        /* A2 = -0.992462 */
8871                  19179,         /* B2 = 0.585327 */
8872                  -19178,        /* B1 = -1.170593 */
8873                  19179,         /* B0 = 0.585327 */
8874                  32723,         /* A1 = 1.997314 */
8875                  -32686,        /* A2 = -0.997528 */
8876                  9973,          /* B2 = 0.304352 */
8877                  -9955,         /* B1 = -0.607605 */
8878                  9973,          /* B0 = 0.304352 */
8879                  7,             /* Internal filter scaling */
8880                  159,           /* Minimum in-band energy threshold */
8881                  21,            /* 21/32 in-band to broad-band ratio */
8882                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8883         },
8884         {                       /* f133_200[] 12 */
8885                 32072,          /* A1 = 1.95752 */
8886                  -31896,        /* A2 = -0.973419 */
8887                  -435,          /* B2 = -0.013294 */
8888                  0,             /* B1 = 0 */
8889                  435,           /* B0 = 0.013294 */
8890                  32188,         /* A1 = 1.9646 */
8891                  -32400,        /* A2 = -0.98877 */
8892                  15139,         /* B2 = 0.462036 */
8893                  -14882,        /* B1 = -0.908356 */
8894                  15139,         /* B0 = 0.462036 */
8895                  32473,         /* A1 = 1.981995 */
8896                  -32524,        /* A2 = -0.992584 */
8897                  23200,         /* B2 = 0.708008 */
8898                  -23113,        /* B1 = -1.410706 */
8899                  23200,         /* B0 = 0.708008 */
8900                  7,             /* Internal filter scaling */
8901                  159,           /* Minimum in-band energy threshold */
8902                  21,            /* 21/32 in-band to broad-band ratio */
8903                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8904         },
8905         {                       /* f300 13 */
8906                 31769,          /* A1 = -1.939026 */
8907                  -32584,        /* A2 = 0.994385 */
8908                  -475,          /* B2 = -0.014522 */
8909                  0,             /* B1 = 0.000000 */
8910                  475,           /* B0 = 0.014522 */
8911                  31789,         /* A1 = -1.940247 */
8912                  -32679,        /* A2 = 0.997284 */
8913                  17280,         /* B2 = 0.527344 */
8914                  -16865,        /* B1 = -1.029358 */
8915                  17280,         /* B0 = 0.527344 */
8916                  31841,         /* A1 = -1.943481 */
8917                  -32681,        /* A2 = 0.997345 */
8918                  543,           /* B2 = 0.016579 */
8919                  -525,          /* B1 = -0.032097 */
8920                  543,           /* B0 = 0.016579 */
8921                  5,             /* Internal filter scaling */
8922                  159,           /* Minimum in-band energy threshold */
8923                  21,            /* 21/32 in-band to broad-band ratio */
8924                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8925         },
8926         {                       /* f300_420[] 14 */
8927                 30750,          /* A1 = 1.876892 */
8928                  -31212,        /* A2 = -0.952515 */
8929                  -804,          /* B2 = -0.024541 */
8930                  0,             /* B1 = 0 */
8931                  804,           /* B0 = 0.024541 */
8932                  30686,         /* A1 = 1.872925 */
8933                  -32145,        /* A2 = -0.980988 */
8934                  14747,         /* B2 = 0.450043 */
8935                  -13703,        /* B1 = -0.836395 */
8936                  14747,         /* B0 = 0.450043 */
8937                  31651,         /* A1 = 1.931824 */
8938                  -32321,        /* A2 = -0.986389 */
8939                  24425,         /* B2 = 0.745422 */
8940                  -23914,        /* B1 = -1.459595 */
8941                  24427,         /* B0 = 0.745483 */
8942                  7,             /* Internal filter scaling */
8943                  159,           /* Minimum in-band energy threshold */
8944                  21,            /* 21/32 in-band to broad-band ratio */
8945                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8946         },
8947         {                       /* f330 15 */
8948                 31613,          /* A1 = -1.929565 */
8949                  -32646,        /* A2 = 0.996277 */
8950                  -185,          /* B2 = -0.005657 */
8951                  0,             /* B1 = 0.000000 */
8952                  185,           /* B0 = 0.005657 */
8953                  31620,         /* A1 = -1.929932 */
8954                  -32713,        /* A2 = 0.998352 */
8955                  19253,         /* B2 = 0.587585 */
8956                  -18566,        /* B1 = -1.133179 */
8957                  19253,         /* B0 = 0.587585 */
8958                  31674,         /* A1 = -1.933228 */
8959                  -32715,        /* A2 = 0.998413 */
8960                  2575,          /* B2 = 0.078590 */
8961                  -2495,         /* B1 = -0.152283 */
8962                  2575,          /* B0 = 0.078590 */
8963                  5,             /* Internal filter scaling */
8964                  159,           /* Minimum in-band energy threshold */
8965                  21,            /* 21/32 in-band to broad-band ratio */
8966                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8967         },
8968         {                       /* f300_425[] 16 */
8969                 30741,          /* A1 = 1.876282 */
8970                  -31475,        /* A2 = -0.960541 */
8971                  -703,          /* B2 = -0.021484 */
8972                  0,             /* B1 = 0 */
8973                  703,           /* B0 = 0.021484 */
8974                  30688,         /* A1 = 1.873047 */
8975                  -32248,        /* A2 = -0.984161 */
8976                  14542,         /* B2 = 0.443787 */
8977                  -13523,        /* B1 = -0.825439 */
8978                  14542,         /* B0 = 0.443817 */
8979                  31494,         /* A1 = 1.922302 */
8980                  -32366,        /* A2 = -0.987762 */
8981                  21577,         /* B2 = 0.658508 */
8982                  -21013,        /* B1 = -1.282532 */
8983                  21577,         /* B0 = 0.658508 */
8984                  7,             /* Internal filter scaling */
8985                  159,           /* Minimum in-band energy threshold */
8986                  21,            /* 21/32 in-band to broad-band ratio */
8987                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8988         },
8989         {                       /* f330_440[] 17 */
8990                 30627,          /* A1 = 1.869324 */
8991                  -31338,        /* A2 = -0.95636 */
8992                  -843,          /* B2 = -0.025749 */
8993                  0,             /* B1 = 0 */
8994                  843,           /* B0 = 0.025749 */
8995                  30550,         /* A1 = 1.864685 */
8996                  -32221,        /* A2 = -0.983337 */
8997                  13594,         /* B2 = 0.414886 */
8998                  -12589,        /* B1 = -0.768402 */
8999                  13594,         /* B0 = 0.414886 */
9000                  31488,         /* A1 = 1.921936 */
9001                  -32358,        /* A2 = -0.987518 */
9002                  24684,         /* B2 = 0.753296 */
9003                  -24029,        /* B1 = -1.466614 */
9004                  24684,         /* B0 = 0.753296 */
9005                  7,             /* Internal filter scaling */
9006                  159,           /* Minimum in-band energy threshold */
9007                  21,            /* 21/32 in-band to broad-band ratio */
9008                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9009         },
9010         {                       /* f340 18 */
9011                 31546,          /* A1 = -1.925476 */
9012                  -32646,        /* A2 = 0.996277 */
9013                  -445,          /* B2 = -0.013588 */
9014                  0,             /* B1 = 0.000000 */
9015                  445,           /* B0 = 0.013588 */
9016                  31551,         /* A1 = -1.925781 */
9017                  -32713,        /* A2 = 0.998352 */
9018                  23884,         /* B2 = 0.728882 */
9019                  -22979,        /* B1 = -1.402527 */
9020                  23884,         /* B0 = 0.728882 */
9021                  31606,         /* A1 = -1.929138 */
9022                  -32715,        /* A2 = 0.998413 */
9023                  863,           /* B2 = 0.026367 */
9024                  -835,          /* B1 = -0.050985 */
9025                  863,           /* B0 = 0.026367 */
9026                  5,             /* Internal filter scaling */
9027                  159,           /* Minimum in-band energy threshold */
9028                  21,            /* 21/32 in-band to broad-band ratio */
9029                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9030         },
9031         {                       /* f350_400[] 19 */
9032                 31006,          /* A1 = 1.892517 */
9033                  -32029,        /* A2 = -0.977448 */
9034                  -461,          /* B2 = -0.014096 */
9035                  0,             /* B1 = 0 */
9036                  461,           /* B0 = 0.014096 */
9037                  30999,         /* A1 = 1.892029 */
9038                  -32487,        /* A2 = -0.991455 */
9039                  11325,         /* B2 = 0.345612 */
9040                  -10682,        /* B1 = -0.651978 */
9041                  11325,         /* B0 = 0.345612 */
9042                  31441,         /* A1 = 1.919067 */
9043                  -32526,        /* A2 = -0.992615 */
9044                  24324,         /* B2 = 0.74231 */
9045                  -23535,        /* B1 = -1.436523 */
9046                  24324,         /* B0 = 0.74231 */
9047                  7,             /* Internal filter scaling */
9048                  159,           /* Minimum in-band energy threshold */
9049                  21,            /* 21/32 in-band to broad-band ratio */
9050                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9051         },
9052         {                       /* f350_440[] */
9053                 30634,          /* A1 = 1.869751 */
9054                  -31533,        /* A2 = -0.962341 */
9055                  -680,          /* B2 = -0.020782 */
9056                  0,             /* B1 = 0 */
9057                  680,           /* B0 = 0.020782 */
9058                  30571,         /* A1 = 1.865906 */
9059                  -32277,        /* A2 = -0.985016 */
9060                  12894,         /* B2 = 0.393524 */
9061                  -11945,        /* B1 = -0.729065 */
9062                  12894,         /* B0 = 0.393524 */
9063                  31367,         /* A1 = 1.91449 */
9064                  -32379,        /* A2 = -0.988129 */
9065                  23820,         /* B2 = 0.726929 */
9066                  -23104,        /* B1 = -1.410217 */
9067                  23820,         /* B0 = 0.726929 */
9068                  7,             /* Internal filter scaling */
9069                  159,           /* Minimum in-band energy threshold */
9070                  21,            /* 21/32 in-band to broad-band ratio */
9071                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9072         },
9073         {                       /* f350_450[] */
9074                 30552,          /* A1 = 1.864807 */
9075                  -31434,        /* A2 = -0.95929 */
9076                  -690,          /* B2 = -0.021066 */
9077                  0,             /* B1 = 0 */
9078                  690,           /* B0 = 0.021066 */
9079                  30472,         /* A1 = 1.859924 */
9080                  -32248,        /* A2 = -0.984161 */
9081                  13385,         /* B2 = 0.408478 */
9082                  -12357,        /* B1 = -0.754242 */
9083                  13385,         /* B0 = 0.408478 */
9084                  31358,         /* A1 = 1.914001 */
9085                  -32366,        /* A2 = -0.987732 */
9086                  26488,         /* B2 = 0.80835 */
9087                  -25692,        /* B1 = -1.568176 */
9088                  26490,         /* B0 = 0.808411 */
9089                  7,             /* Internal filter scaling */
9090                  159,           /* Minimum in-band energy threshold */
9091                  21,            /* 21/32 in-band to broad-band ratio */
9092                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9093         },
9094         {                       /* f360 */
9095                 31397,          /* A1 = -1.916321 */
9096                  -32623,        /* A2 = 0.995605 */
9097                  -117,          /* B2 = -0.003598 */
9098                  0,             /* B1 = 0.000000 */
9099                  117,           /* B0 = 0.003598 */
9100                  31403,         /* A1 = -1.916687 */
9101                  -32700,        /* A2 = 0.997925 */
9102                  3388,          /* B2 = 0.103401 */
9103                  -3240,         /* B1 = -0.197784 */
9104                  3388,          /* B0 = 0.103401 */
9105                  31463,         /* A1 = -1.920410 */
9106                  -32702,        /* A2 = 0.997986 */
9107                  13346,         /* B2 = 0.407288 */
9108                  -12863,        /* B1 = -0.785126 */
9109                  13346,         /* B0 = 0.407288 */
9110                  5,             /* Internal filter scaling */
9111                  159,           /* Minimum in-band energy threshold */
9112                  21,            /* 21/32 in-band to broad-band ratio */
9113                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9114         },
9115         {                       /* f380_420[] */
9116                 30831,          /* A1 = 1.881775 */
9117                  -32064,        /* A2 = -0.978546 */
9118                  -367,          /* B2 = -0.01122 */
9119                  0,             /* B1 = 0 */
9120                  367,           /* B0 = 0.01122 */
9121                  30813,         /* A1 = 1.880737 */
9122                  -32456,        /* A2 = -0.990509 */
9123                  11068,         /* B2 = 0.337769 */
9124                  -10338,        /* B1 = -0.631042 */
9125                  11068,         /* B0 = 0.337769 */
9126                  31214,         /* A1 = 1.905212 */
9127                  -32491,        /* A2 = -0.991577 */
9128                  16374,         /* B2 = 0.499695 */
9129                  -15781,        /* B1 = -0.963196 */
9130                  16374,         /* B0 = 0.499695 */
9131                  7,             /* Internal filter scaling */
9132                  159,           /* Minimum in-band energy threshold */
9133                  21,            /* 21/32 in-band to broad-band ratio */
9134                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9135         },
9136         {                       /* f392 */
9137                 31152,          /* A1 = -1.901428 */
9138                  -32613,        /* A2 = 0.995300 */
9139                  -314,          /* B2 = -0.009605 */
9140                  0,             /* B1 = 0.000000 */
9141                  314,           /* B0 = 0.009605 */
9142                  31156,         /* A1 = -1.901672 */
9143                  -32694,        /* A2 = 0.997742 */
9144                  28847,         /* B2 = 0.880371 */
9145                  -2734,         /* B1 = -0.166901 */
9146                  28847,         /* B0 = 0.880371 */
9147                  31225,         /* A1 = -1.905823 */
9148                  -32696,        /* A2 = 0.997803 */
9149                  462,           /* B2 = 0.014108 */
9150                  -442,          /* B1 = -0.027019 */
9151                  462,           /* B0 = 0.014108 */
9152                  5,             /* Internal filter scaling */
9153                  159,           /* Minimum in-band energy threshold */
9154                  21,            /* 21/32 in-band to broad-band ratio */
9155                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9156         },
9157         {                       /* f400_425[] */
9158                 30836,          /* A1 = 1.882141 */
9159                  -32296,        /* A2 = -0.985596 */
9160                  -324,          /* B2 = -0.009903 */
9161                  0,             /* B1 = 0 */
9162                  324,           /* B0 = 0.009903 */
9163                  30825,         /* A1 = 1.881409 */
9164                  -32570,        /* A2 = -0.993958 */
9165                  16847,         /* B2 = 0.51416 */
9166                  -15792,        /* B1 = -0.963898 */
9167                  16847,         /* B0 = 0.51416 */
9168                  31106,         /* A1 = 1.89856 */
9169                  -32584,        /* A2 = -0.994415 */
9170                  9579,          /* B2 = 0.292328 */
9171                  -9164,         /* B1 = -0.559357 */
9172                  9579,          /* B0 = 0.292328 */
9173                  7,             /* Internal filter scaling */
9174                  159,           /* Minimum in-band energy threshold */
9175                  21,            /* 21/32 in-band to broad-band ratio */
9176                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9177         },
9178         {                       /* f400_440[] */
9179                 30702,          /* A1 = 1.873962 */
9180                  -32134,        /* A2 = -0.980682 */
9181                  -517,          /* B2 = -0.015793 */
9182                  0,             /* B1 = 0 */
9183                  517,           /* B0 = 0.015793 */
9184                  30676,         /* A1 = 1.872375 */
9185                  -32520,        /* A2 = -0.992462 */
9186                  8144,          /* B2 = 0.24855 */
9187                  -7596,         /* B1 = -0.463684 */
9188                  8144,          /* B0 = 0.24855 */
9189                  31084,         /* A1 = 1.897217 */
9190                  -32547,        /* A2 = -0.993256 */
9191                  22713,         /* B2 = 0.693176 */
9192                  -21734,        /* B1 = -1.326599 */
9193                  22713,         /* B0 = 0.693176 */
9194                  7,             /* Internal filter scaling */
9195                  159,           /* Minimum in-band energy threshold */
9196                  21,            /* 21/32 in-band to broad-band ratio */
9197                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9198         },
9199         {                       /* f400_450[] */
9200                 30613,          /* A1 = 1.86853 */
9201                  -32031,        /* A2 = -0.977509 */
9202                  -618,          /* B2 = -0.018866 */
9203                  0,             /* B1 = 0 */
9204                  618,           /* B0 = 0.018866 */
9205                  30577,         /* A1 = 1.866272 */
9206                  -32491,        /* A2 = -0.991577 */
9207                  9612,          /* B2 = 0.293335 */
9208                  -8935,         /* B1 = -0.54541 */
9209                  9612,          /* B0 = 0.293335 */
9210                  31071,         /* A1 = 1.896484 */
9211                  -32524,        /* A2 = -0.992584 */
9212                  21596,         /* B2 = 0.659058 */
9213                  -20667,        /* B1 = -1.261414 */
9214                  21596,         /* B0 = 0.659058 */
9215                  7,             /* Internal filter scaling */
9216                  159,           /* Minimum in-band energy threshold */
9217                  21,            /* 21/32 in-band to broad-band ratio */
9218                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9219         },
9220         {                       /* f420 */
9221                 30914,          /* A1 = -1.886841 */
9222                  -32584,        /* A2 = 0.994385 */
9223                  -426,          /* B2 = -0.013020 */
9224                  0,             /* B1 = 0.000000 */
9225                  426,           /* B0 = 0.013020 */
9226                  30914,         /* A1 = -1.886841 */
9227                  -32679,        /* A2 = 0.997314 */
9228                  17520,         /* B2 = 0.534668 */
9229                  -16471,        /* B1 = -1.005310 */
9230                  17520,         /* B0 = 0.534668 */
9231                  31004,         /* A1 = -1.892334 */
9232                  -32683,        /* A2 = 0.997406 */
9233                  819,           /* B2 = 0.025023 */
9234                  -780,          /* B1 = -0.047619 */
9235                  819,           /* B0 = 0.025023 */
9236                  5,             /* Internal filter scaling */
9237                  159,           /* Minimum in-band energy threshold */
9238                  21,            /* 21/32 in-band to broad-band ratio */
9239                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9240         },
9241 #if 0
9242         {                       /* f425 */
9243                 30881,          /* A1 = -1.884827 */
9244                  -32603,        /* A2 = 0.994965 */
9245                  -496,          /* B2 = -0.015144 */
9246                  0,             /* B1 = 0.000000 */
9247                  496,           /* B0 = 0.015144 */
9248                  30880,         /* A1 = -1.884766 */
9249                  -32692,        /* A2 = 0.997711 */
9250                  24767,         /* B2 = 0.755859 */
9251                  -23290,        /* B1 = -1.421509 */
9252                  24767,         /* B0 = 0.755859 */
9253                  30967,         /* A1 = -1.890076 */
9254                  -32694,        /* A2 = 0.997772 */
9255                  728,           /* B2 = 0.022232 */
9256                  -691,          /* B1 = -0.042194 */
9257                  728,           /* B0 = 0.022232 */
9258                  5,             /* Internal filter scaling */
9259                  159,           /* Minimum in-band energy threshold */
9260                  21,            /* 21/32 in-band to broad-band ratio */
9261                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9262         },
9263 #else
9264         {
9265                 30850,
9266                 -32534,
9267                 -504,
9268                 0,
9269                 504,
9270                 30831,
9271                 -32669,
9272                 24303,
9273                 -22080,
9274                 24303,
9275                 30994,
9276                 -32673,
9277                 1905,
9278                 -1811,
9279                 1905,
9280                 5,
9281                 129,
9282                 17,
9283                 0xff5
9284         },
9285 #endif
9286         {                       /* f425_450[] */
9287                 30646,          /* A1 = 1.870544 */
9288                  -32327,        /* A2 = -0.986572 */
9289                  -287,          /* B2 = -0.008769 */
9290                  0,             /* B1 = 0 */
9291                  287,           /* B0 = 0.008769 */
9292                  30627,         /* A1 = 1.869324 */
9293                  -32607,        /* A2 = -0.995087 */
9294                  13269,         /* B2 = 0.404968 */
9295                  -12376,        /* B1 = -0.755432 */
9296                  13269,         /* B0 = 0.404968 */
9297                  30924,         /* A1 = 1.887512 */
9298                  -32619,        /* A2 = -0.995453 */
9299                  19950,         /* B2 = 0.608826 */
9300                  -18940,        /* B1 = -1.156006 */
9301                  19950,         /* B0 = 0.608826 */
9302                  7,             /* Internal filter scaling */
9303                  159,           /* Minimum in-band energy threshold */
9304                  21,            /* 21/32 in-band to broad-band ratio */
9305                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9306         },
9307         {                       /* f425_475[] */
9308                 30396,          /* A1 = 1.855225 */
9309                  -32014,        /* A2 = -0.97699 */
9310                  -395,          /* B2 = -0.012055 */
9311                  0,             /* B1 = 0 */
9312                  395,           /* B0 = 0.012055 */
9313                  30343,         /* A1 = 1.85199 */
9314                  -32482,        /* A2 = -0.991302 */
9315                  17823,         /* B2 = 0.543945 */
9316                  -16431,        /* B1 = -1.002869 */
9317                  17823,         /* B0 = 0.543945 */
9318                  30872,         /* A1 = 1.884338 */
9319                  -32516,        /* A2 = -0.99231 */
9320                  18124,         /* B2 = 0.553101 */
9321                  -17246,        /* B1 = -1.052673 */
9322                  18124,         /* B0 = 0.553101 */
9323                  7,             /* Internal filter scaling */
9324                  159,           /* Minimum in-band energy threshold */
9325                  21,            /* 21/32 in-band to broad-band ratio */
9326                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9327         },
9328         {                       /* f435 */
9329                 30796,          /* A1 = -1.879639 */
9330                  -32603,        /* A2 = 0.994965 */
9331                  -254,          /* B2 = -0.007762 */
9332                  0,             /* B1 = 0.000000 */
9333                  254,           /* B0 = 0.007762 */
9334                  30793,         /* A1 = -1.879456 */
9335                  -32692,        /* A2 = 0.997711 */
9336                  18934,         /* B2 = 0.577820 */
9337                  -17751,        /* B1 = -1.083496 */
9338                  18934,         /* B0 = 0.577820 */
9339                  30882,         /* A1 = -1.884888 */
9340                  -32694,        /* A2 = 0.997772 */
9341                  1858,          /* B2 = 0.056713 */
9342                  -1758,         /* B1 = -0.107357 */
9343                  1858,          /* B0 = 0.056713 */
9344                  5,             /* Internal filter scaling */
9345                  159,           /* Minimum in-band energy threshold */
9346                  21,            /* 21/32 in-band to broad-band ratio */
9347                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9348         },
9349         {                       /* f440_450[] */
9350                 30641,          /* A1 = 1.870239 */
9351                  -32458,        /* A2 = -0.99057 */
9352                  -155,          /* B2 = -0.004735 */
9353                  0,             /* B1 = 0 */
9354                  155,           /* B0 = 0.004735 */
9355                  30631,         /* A1 = 1.869568 */
9356                  -32630,        /* A2 = -0.995789 */
9357                  11453,         /* B2 = 0.349548 */
9358                  -10666,        /* B1 = -0.651001 */
9359                  11453,         /* B0 = 0.349548 */
9360                  30810,         /* A1 = 1.880554 */
9361                  -32634,        /* A2 = -0.995941 */
9362                  12237,         /* B2 = 0.373474 */
9363                  -11588,        /* B1 = -0.707336 */
9364                  12237,         /* B0 = 0.373474 */
9365                  7,             /* Internal filter scaling */
9366                  159,           /* Minimum in-band energy threshold */
9367                  21,            /* 21/32 in-band to broad-band ratio */
9368                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9369         },
9370         {                       /* f440_480[] */
9371                 30367,          /* A1 = 1.853455 */
9372                  -32147,        /* A2 = -0.981079 */
9373                  -495,          /* B2 = -0.015113 */
9374                  0,             /* B1 = 0 */
9375                  495,           /* B0 = 0.015113 */
9376                  30322,         /* A1 = 1.850769 */
9377                  -32543,        /* A2 = -0.993134 */
9378                  10031,         /* B2 = 0.306152 */
9379                  -9252,         /* B1 = -0.564728 */
9380                  10031,         /* B0 = 0.306152 */
9381                  30770,         /* A1 = 1.878052 */
9382                  -32563,        /* A2 = -0.993774 */
9383                  22674,         /* B2 = 0.691956 */
9384                  -21465,        /* B1 = -1.31012 */
9385                  22674,         /* B0 = 0.691956 */
9386                  7,             /* Internal filter scaling */
9387                  159,           /* Minimum in-band energy threshold */
9388                  21,            /* 21/32 in-band to broad-band ratio */
9389                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9390         },
9391         {                       /* f445 */
9392                 30709,          /* A1 = -1.874329 */
9393                  -32603,        /* A2 = 0.994965 */
9394                  -83,           /* B2 = -0.002545 */
9395                  0,             /* B1 = 0.000000 */
9396                  83,            /* B0 = 0.002545 */
9397                  30704,         /* A1 = -1.874084 */
9398                  -32692,        /* A2 = 0.997711 */
9399                  10641,         /* B2 = 0.324738 */
9400                  -9947,         /* B1 = -0.607147 */
9401                  10641,         /* B0 = 0.324738 */
9402                  30796,         /* A1 = -1.879639 */
9403                  -32694,        /* A2 = 0.997772 */
9404                  10079,         /* B2 = 0.307587 */
9405                  9513,          /* B1 = 0.580688 */
9406                  10079,         /* B0 = 0.307587 */
9407                  5,             /* Internal filter scaling */
9408                  159,           /* Minimum in-band energy threshold */
9409                  21,            /* 21/32 in-band to broad-band ratio */
9410                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9411         },
9412         {                       /* f450 */
9413                 30664,          /* A1 = -1.871643 */
9414                  -32603,        /* A2 = 0.994965 */
9415                  -164,          /* B2 = -0.005029 */
9416                  0,             /* B1 = 0.000000 */
9417                  164,           /* B0 = 0.005029 */
9418                  30661,         /* A1 = -1.871399 */
9419                  -32692,        /* A2 = 0.997711 */
9420                  15294,         /* B2 = 0.466736 */
9421                  -14275,        /* B1 = -0.871307 */
9422                  15294,         /* B0 = 0.466736 */
9423                  30751,         /* A1 = -1.876953 */
9424                  -32694,        /* A2 = 0.997772 */
9425                  3548,          /* B2 = 0.108284 */
9426                  -3344,         /* B1 = -0.204155 */
9427                  3548,          /* B0 = 0.108284 */
9428                  5,             /* Internal filter scaling */
9429                  159,           /* Minimum in-band energy threshold */
9430                  21,            /* 21/32 in-band to broad-band ratio */
9431                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9432         },
9433         {                       /* f452 */
9434                 30653,          /* A1 = -1.870911 */
9435                  -32615,        /* A2 = 0.995361 */
9436                  -209,          /* B2 = -0.006382 */
9437                  0,             /* B1 = 0.000000 */
9438                  209,           /* B0 = 0.006382 */
9439                  30647,         /* A1 = -1.870605 */
9440                  -32702,        /* A2 = 0.997986 */
9441                  18971,         /* B2 = 0.578979 */
9442                  -17716,        /* B1 = -1.081299 */
9443                  18971,         /* B0 = 0.578979 */
9444                  30738,         /* A1 = -1.876099 */
9445                  -32702,        /* A2 = 0.998016 */
9446                  2967,          /* B2 = 0.090561 */
9447                  -2793,         /* B1 = -0.170502 */
9448                  2967,          /* B0 = 0.090561 */
9449                  5,             /* Internal filter scaling */
9450                  159,           /* Minimum in-band energy threshold */
9451                  21,            /* 21/32 in-band to broad-band ratio */
9452                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9453         },
9454         {                       /* f475 */
9455                 30437,          /* A1 = -1.857727 */
9456                  -32603,        /* A2 = 0.994965 */
9457                  -264,          /* B2 = -0.008062 */
9458                  0,             /* B1 = 0.000000 */
9459                  264,           /* B0 = 0.008062 */
9460                  30430,         /* A1 = -1.857300 */
9461                  -32692,        /* A2 = 0.997711 */
9462                  21681,         /* B2 = 0.661682 */
9463                  -20082,        /* B1 = -1.225708 */
9464                  21681,         /* B0 = 0.661682 */
9465                  30526,         /* A1 = -1.863220 */
9466                  -32694,        /* A2 = 0.997742 */
9467                  1559,          /* B2 = 0.047600 */
9468                  -1459,         /* B1 = -0.089096 */
9469                  1559,          /* B0 = 0.047600 */
9470                  5,             /* Internal filter scaling */
9471                  159,           /* Minimum in-band energy threshold */
9472                  21,            /* 21/32 in-band to broad-band ratio */
9473                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9474         },
9475         {                       /* f480_620[] */
9476                 28975,          /* A1 = 1.768494 */
9477                  -30955,        /* A2 = -0.944672 */
9478                  -1026,         /* B2 = -0.03133 */
9479                  0,             /* B1 = 0 */
9480                  1026,          /* B0 = 0.03133 */
9481                  28613,         /* A1 = 1.746399 */
9482                  -32089,        /* A2 = -0.979309 */
9483                  14214,         /* B2 = 0.433807 */
9484                  -12202,        /* B1 = -0.744812 */
9485                  14214,         /* B0 = 0.433807 */
9486                  30243,         /* A1 = 1.845947 */
9487                  -32238,        /* A2 = -0.983856 */
9488                  24825,         /* B2 = 0.757629 */
9489                  -23402,        /* B1 = -1.428345 */
9490                  24825,         /* B0 = 0.757629 */
9491                  7,             /* Internal filter scaling */
9492                  159,           /* Minimum in-band energy threshold */
9493                  21,            /* 21/32 in-band to broad-band ratio */
9494                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9495         },
9496         {                       /* f494 */
9497                 30257,          /* A1 = -1.846741 */
9498                  -32605,        /* A2 = 0.995056 */
9499                  -249,          /* B2 = -0.007625 */
9500                  0,             /* B1 = 0.000000 */
9501                  249,           /* B0 = 0.007625 */
9502                  30247,         /* A1 = -1.846191 */
9503                  -32694,        /* A2 = 0.997772 */
9504                  18088,         /* B2 = 0.552002 */
9505                  -16652,        /* B1 = -1.016418 */
9506                  18088,         /* B0 = 0.552002 */
9507                  30348,         /* A1 = -1.852295 */
9508                  -32696,        /* A2 = 0.997803 */
9509                  2099,          /* B2 = 0.064064 */
9510                  -1953,         /* B1 = -0.119202 */
9511                  2099,          /* B0 = 0.064064 */
9512                  5,             /* Internal filter scaling */
9513                  159,           /* Minimum in-band energy threshold */
9514                  21,            /* 21/32 in-band to broad-band ratio */
9515                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9516         },
9517         {                       /* f500 */
9518                 30202,          /* A1 = -1.843431 */
9519                  -32624,        /* A2 = 0.995622 */
9520                  -413,          /* B2 = -0.012622 */
9521                  0,             /* B1 = 0.000000 */
9522                  413,           /* B0 = 0.012622 */
9523                  30191,         /* A1 = -1.842721 */
9524                  -32714,        /* A2 = 0.998364 */
9525                  25954,         /* B2 = 0.792057 */
9526                  -23890,        /* B1 = -1.458131 */
9527                  25954,         /* B0 = 0.792057 */
9528                  30296,         /* A1 = -1.849172 */
9529                  -32715,        /* A2 = 0.998397 */
9530                  2007,          /* B2 = 0.061264 */
9531                  -1860,         /* B1 = -0.113568 */
9532                  2007,          /* B0 = 0.061264 */
9533                  5,             /* Internal filter scaling */
9534                  159,           /* Minimum in-band energy threshold */
9535                  21,            /* 21/32 in-band to broad-band ratio */
9536                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9537         },
9538         {                       /* f520 */
9539                 30001,          /* A1 = -1.831116 */
9540                  -32613,        /* A2 = 0.995270 */
9541                  -155,          /* B2 = -0.004750 */
9542                  0,             /* B1 = 0.000000 */
9543                  155,           /* B0 = 0.004750 */
9544                  29985,         /* A1 = -1.830200 */
9545                  -32710,        /* A2 = 0.998260 */
9546                  6584,          /* B2 = 0.200928 */
9547                  -6018,         /* B1 = -0.367355 */
9548                  6584,          /* B0 = 0.200928 */
9549                  30105,         /* A1 = -1.837524 */
9550                  -32712,        /* A2 = 0.998291 */
9551                  23812,         /* B2 = 0.726685 */
9552                  -21936,        /* B1 = -1.338928 */
9553                  23812,         /* B0 = 0.726685 */
9554                  5,             /* Internal filter scaling */
9555                  159,           /* Minimum in-band energy threshold */
9556                  21,            /* 21/32 in-band to broad-band ratio */
9557                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9558         },
9559         {                       /* f523 */
9560                 29964,          /* A1 = -1.828918 */
9561                  -32601,        /* A2 = 0.994904 */
9562                  -101,          /* B2 = -0.003110 */
9563                  0,             /* B1 = 0.000000 */
9564                  101,           /* B0 = 0.003110 */
9565                  29949,         /* A1 = -1.827942 */
9566                  -32700,        /* A2 = 0.997925 */
9567                  11041,         /* B2 = 0.336975 */
9568                  -10075,        /* B1 = -0.614960 */
9569                  11041,         /* B0 = 0.336975 */
9570                  30070,         /* A1 = -1.835388 */
9571                  -32702,        /* A2 = 0.997986 */
9572                  16762,         /* B2 = 0.511536 */
9573                  -15437,        /* B1 = -0.942230 */
9574                  16762,         /* B0 = 0.511536 */
9575                  5,             /* Internal filter scaling */
9576                  159,           /* Minimum in-band energy threshold */
9577                  21,            /* 21/32 in-band to broad-band ratio */
9578                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9579         },
9580         {                       /* f525 */
9581                 29936,          /* A1 = -1.827209 */
9582                  -32584,        /* A2 = 0.994415 */
9583                  -91,           /* B2 = -0.002806 */
9584                  0,             /* B1 = 0.000000 */
9585                  91,            /* B0 = 0.002806 */
9586                  29921,         /* A1 = -1.826233 */
9587                  -32688,        /* A2 = 0.997559 */
9588                  11449,         /* B2 = 0.349396 */
9589                  -10426,        /* B1 = -0.636383 */
9590                  11449,         /* B0 = 0.349396 */
9591                  30045,         /* A1 = -1.833862 */
9592                  -32688,        /* A2 = 0.997589 */
9593                  13055,         /* B2 = 0.398407 */
9594                  -12028,        /* B1 = -0.734161 */
9595                  13055,         /* B0 = 0.398407 */
9596                  5,             /* Internal filter scaling */
9597                  159,           /* Minimum in-band energy threshold */
9598                  21,            /* 21/32 in-band to broad-band ratio */
9599                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9600         },
9601         {                       /* f540_660[] */
9602                 28499,          /* A1 = 1.739441 */
9603                  -31129,        /* A2 = -0.949982 */
9604                  -849,          /* B2 = -0.025922 */
9605                  0,             /* B1 = 0 */
9606                  849,           /* B0 = 0.025922 */
9607                  28128,         /* A1 = 1.716797 */
9608                  -32130,        /* A2 = -0.98056 */
9609                  14556,         /* B2 = 0.444214 */
9610                  -12251,        /* B1 = -0.747772 */
9611                  14556,         /* B0 = 0.444244 */
9612                  29667,         /* A1 = 1.81073 */
9613                  -32244,        /* A2 = -0.984039 */
9614                  23038,         /* B2 = 0.703064 */
9615                  -21358,        /* B1 = -1.303589 */
9616                  23040,         /* B0 = 0.703125 */
9617                  7,             /* Internal filter scaling */
9618                  159,           /* Minimum in-band energy threshold */
9619                  21,            /* 21/32 in-band to broad-band ratio */
9620                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9621         },
9622         {                       /* f587 */
9623                 29271,          /* A1 = -1.786560 */
9624                  -32599,        /* A2 = 0.994873 */
9625                  -490,          /* B2 = -0.014957 */
9626                  0,             /* B1 = 0.000000 */
9627                  490,           /* B0 = 0.014957 */
9628                  29246,         /* A1 = -1.785095 */
9629                  -32700,        /* A2 = 0.997925 */
9630                  28961,         /* B2 = 0.883850 */
9631                  -25796,        /* B1 = -1.574463 */
9632                  28961,         /* B0 = 0.883850 */
9633                  29383,         /* A1 = -1.793396 */
9634                  -32700,        /* A2 = 0.997955 */
9635                  1299,          /* B2 = 0.039650 */
9636                  -1169,         /* B1 = -0.071396 */
9637                  1299,          /* B0 = 0.039650 */
9638                  5,             /* Internal filter scaling */
9639                  159,           /* Minimum in-band energy threshold */
9640                  21,            /* 21/32 in-band to broad-band ratio */
9641                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9642         },
9643         {                       /* f590 */
9644                 29230,          /* A1 = -1.784058 */
9645                  -32584,        /* A2 = 0.994415 */
9646                  -418,          /* B2 = -0.012757 */
9647                  0,             /* B1 = 0.000000 */
9648                  418,           /* B0 = 0.012757 */
9649                  29206,         /* A1 = -1.782593 */
9650                  -32688,        /* A2 = 0.997559 */
9651                  36556,         /* B2 = 1.115601 */
9652                  -32478,        /* B1 = -1.982300 */
9653                  36556,         /* B0 = 1.115601 */
9654                  29345,         /* A1 = -1.791077 */
9655                  -32688,        /* A2 = 0.997589 */
9656                  897,           /* B2 = 0.027397 */
9657                  -808,          /* B1 = -0.049334 */
9658                  897,           /* B0 = 0.027397 */
9659                  5,             /* Internal filter scaling */
9660                  159,           /* Minimum in-band energy threshold */
9661                  21,            /* 21/32 in-band to broad-band ratio */
9662                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9663         },
9664         {                       /* f600 */
9665                 29116,          /* A1 = -1.777100 */
9666                  -32603,        /* A2 = 0.994965 */
9667                  -165,          /* B2 = -0.005039 */
9668                  0,             /* B1 = 0.000000 */
9669                  165,           /* B0 = 0.005039 */
9670                  29089,         /* A1 = -1.775452 */
9671                  -32708,        /* A2 = 0.998199 */
9672                  6963,          /* B2 = 0.212494 */
9673                  -6172,         /* B1 = -0.376770 */
9674                  6963,          /* B0 = 0.212494 */
9675                  29237,         /* A1 = -1.784485 */
9676                  -32710,        /* A2 = 0.998230 */
9677                  24197,         /* B2 = 0.738464 */
9678                  -21657,        /* B1 = -1.321899 */
9679                  24197,         /* B0 = 0.738464 */
9680                  5,             /* Internal filter scaling */
9681                  159,           /* Minimum in-band energy threshold */
9682                  21,            /* 21/32 in-band to broad-band ratio */
9683                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9684         },
9685         {                       /* f660 */
9686                 28376,          /* A1 = -1.731934 */
9687                  -32567,        /* A2 = 0.993896 */
9688                  -363,          /* B2 = -0.011102 */
9689                  0,             /* B1 = 0.000000 */
9690                  363,           /* B0 = 0.011102 */
9691                  28337,         /* A1 = -1.729614 */
9692                  -32683,        /* A2 = 0.997434 */
9693                  21766,         /* B2 = 0.664246 */
9694                  -18761,        /* B1 = -1.145081 */
9695                  21766,         /* B0 = 0.664246 */
9696                  28513,         /* A1 = -1.740356 */
9697                  -32686,        /* A2 = 0.997498 */
9698                  2509,          /* B2 = 0.076584 */
9699                  -2196,         /* B1 = -0.134041 */
9700                  2509,          /* B0 = 0.076584 */
9701                  5,             /* Internal filter scaling */
9702                  159,           /* Minimum in-band energy threshold */
9703                  21,            /* 21/32 in-band to broad-band ratio */
9704                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9705         },
9706         {                       /* f700 */
9707                 27844,          /* A1 = -1.699463 */
9708                  -32563,        /* A2 = 0.993744 */
9709                  -366,          /* B2 = -0.011187 */
9710                  0,             /* B1 = 0.000000 */
9711                  366,           /* B0 = 0.011187 */
9712                  27797,         /* A1 = -1.696655 */
9713                  -32686,        /* A2 = 0.997498 */
9714                  22748,         /* B2 = 0.694214 */
9715                  -19235,        /* B1 = -1.174072 */
9716                  22748,         /* B0 = 0.694214 */
9717                  27995,         /* A1 = -1.708740 */
9718                  -32688,        /* A2 = 0.997559 */
9719                  2964,          /* B2 = 0.090477 */
9720                  -2546,         /* B1 = -0.155449 */
9721                  2964,          /* B0 = 0.090477 */
9722                  5,             /* Internal filter scaling */
9723                  159,           /* Minimum in-band energy threshold */
9724                  21,            /* 21/32 in-band to broad-band ratio */
9725                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9726         },
9727         {                       /* f740 */
9728                 27297,          /* A1 = -1.666077 */
9729                  -32551,        /* A2 = 0.993408 */
9730                  -345,          /* B2 = -0.010540 */
9731                  0,             /* B1 = 0.000000 */
9732                  345,           /* B0 = 0.010540 */
9733                  27240,         /* A1 = -1.662598 */
9734                  -32683,        /* A2 = 0.997406 */
9735                  22560,         /* B2 = 0.688477 */
9736                  -18688,        /* B1 = -1.140625 */
9737                  22560,         /* B0 = 0.688477 */
9738                  27461,         /* A1 = -1.676147 */
9739                  -32684,        /* A2 = 0.997467 */
9740                  3541,          /* B2 = 0.108086 */
9741                  -2985,         /* B1 = -0.182220 */
9742                  3541,          /* B0 = 0.108086 */
9743                  5,             /* Internal filter scaling */
9744                  159,           /* Minimum in-band energy threshold */
9745                  21,            /* 21/32 in-band to broad-band ratio */
9746                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9747         },
9748         {                       /* f750 */
9749                 27155,          /* A1 = -1.657410 */
9750                  -32551,        /* A2 = 0.993408 */
9751                  -462,          /* B2 = -0.014117 */
9752                  0,             /* B1 = 0.000000 */
9753                  462,           /* B0 = 0.014117 */
9754                  27097,         /* A1 = -1.653870 */
9755                  -32683,        /* A2 = 0.997406 */
9756                  32495,         /* B2 = 0.991699 */
9757                  -26776,        /* B1 = -1.634338 */
9758                  32495,         /* B0 = 0.991699 */
9759                  27321,         /* A1 = -1.667542 */
9760                  -32684,        /* A2 = 0.997467 */
9761                  1835,          /* B2 = 0.056007 */
9762                  -1539,         /* B1 = -0.093948 */
9763                  1835,          /* B0 = 0.056007 */
9764                  5,             /* Internal filter scaling */
9765                  159,           /* Minimum in-band energy threshold */
9766                  21,            /* 21/32 in-band to broad-band ratio */
9767                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9768         },
9769         {                       /* f750_1450[] */
9770                 19298,          /* A1 = 1.177917 */
9771                  -24471,        /* A2 = -0.746796 */
9772                  -4152,         /* B2 = -0.126709 */
9773                  0,             /* B1 = 0 */
9774                  4152,          /* B0 = 0.126709 */
9775                  12902,         /* A1 = 0.787476 */
9776                  -29091,        /* A2 = -0.887817 */
9777                  12491,         /* B2 = 0.38121 */
9778                  -1794,         /* B1 = -0.109528 */
9779                  12494,         /* B0 = 0.381317 */
9780                  26291,         /* A1 = 1.604736 */
9781                  -30470,        /* A2 = -0.929901 */
9782                  28859,         /* B2 = 0.880737 */
9783                  -26084,        /* B1 = -1.592102 */
9784                  28861,         /* B0 = 0.880798 */
9785                  7,             /* Internal filter scaling */
9786                  159,           /* Minimum in-band energy threshold */
9787                  21,            /* 21/32 in-band to broad-band ratio */
9788                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9789         },
9790         {                       /* f770 */
9791                 26867,          /* A1 = -1.639832 */
9792                  -32551,        /* A2 = 0.993408 */
9793                  -123,          /* B2 = -0.003755 */
9794                  0,             /* B1 = 0.000000 */
9795                  123,           /* B0 = 0.003755 */
9796                  26805,         /* A1 = -1.636108 */
9797                  -32683,        /* A2 = 0.997406 */
9798                  17297,         /* B2 = 0.527863 */
9799                  -14096,        /* B1 = -0.860382 */
9800                  17297,         /* B0 = 0.527863 */
9801                  27034,         /* A1 = -1.650085 */
9802                  -32684,        /* A2 = 0.997467 */
9803                  12958,         /* B2 = 0.395477 */
9804                  -10756,        /* B1 = -0.656525 */
9805                  12958,         /* B0 = 0.395477 */
9806                  5,             /* Internal filter scaling */
9807                  159,           /* Minimum in-band energy threshold */
9808                  21,            /* 21/32 in-band to broad-band ratio */
9809                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9810         },
9811         {                       /* f800 */
9812                 26413,          /* A1 = -1.612122 */
9813                  -32547,        /* A2 = 0.993286 */
9814                  -223,          /* B2 = -0.006825 */
9815                  0,             /* B1 = 0.000000 */
9816                  223,           /* B0 = 0.006825 */
9817                  26342,         /* A1 = -1.607849 */
9818                  -32686,        /* A2 = 0.997498 */
9819                  6391,          /* B2 = 0.195053 */
9820                  -5120,         /* B1 = -0.312531 */
9821                  6391,          /* B0 = 0.195053 */
9822                  26593,         /* A1 = -1.623108 */
9823                  -32688,        /* A2 = 0.997559 */
9824                  23681,         /* B2 = 0.722717 */
9825                  -19328,        /* B1 = -1.179688 */
9826                  23681,         /* B0 = 0.722717 */
9827                  5,             /* Internal filter scaling */
9828                  159,           /* Minimum in-band energy threshold */
9829                  21,            /* 21/32 in-band to broad-band ratio */
9830                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9831         },
9832         {                       /* f816 */
9833                 26168,          /* A1 = -1.597209 */
9834                  -32528,        /* A2 = 0.992706 */
9835                  -235,          /* B2 = -0.007182 */
9836                  0,             /* B1 = 0.000000 */
9837                  235,           /* B0 = 0.007182 */
9838                  26092,         /* A1 = -1.592590 */
9839                  -32675,        /* A2 = 0.997192 */
9840                  20823,         /* B2 = 0.635498 */
9841                  -16510,        /* B1 = -1.007751 */
9842                  20823,         /* B0 = 0.635498 */
9843                  26363,         /* A1 = -1.609070 */
9844                  -32677,        /* A2 = 0.997253 */
9845                  6739,          /* B2 = 0.205688 */
9846                  -5459,         /* B1 = -0.333206 */
9847                  6739,          /* B0 = 0.205688 */
9848                  5,             /* Internal filter scaling */
9849                  159,           /* Minimum in-band energy threshold */
9850                  21,            /* 21/32 in-band to broad-band ratio */
9851                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9852         },
9853         {                       /* f850 */
9854                 25641,          /* A1 = -1.565063 */
9855                  -32536,        /* A2 = 0.992950 */
9856                  -121,          /* B2 = -0.003707 */
9857                  0,             /* B1 = 0.000000 */
9858                  121,           /* B0 = 0.003707 */
9859                  25560,         /* A1 = -1.560059 */
9860                  -32684,        /* A2 = 0.997437 */
9861                  18341,         /* B2 = 0.559753 */
9862                  -14252,        /* B1 = -0.869904 */
9863                  18341,         /* B0 = 0.559753 */
9864                  25837,         /* A1 = -1.577026 */
9865                  -32684,        /* A2 = 0.997467 */
9866                  16679,         /* B2 = 0.509003 */
9867                  -13232,        /* B1 = -0.807648 */
9868                  16679,         /* B0 = 0.509003 */
9869                  5,             /* Internal filter scaling */
9870                  159,           /* Minimum in-band energy threshold */
9871                  21,            /* 21/32 in-band to broad-band ratio */
9872                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9873         },
9874         {                       /* f857_1645[] */
9875                 16415,          /* A1 = 1.001953 */
9876                  -23669,        /* A2 = -0.722321 */
9877                  -4549,         /* B2 = -0.138847 */
9878                  0,             /* B1 = 0 */
9879                  4549,          /* B0 = 0.138847 */
9880                  8456,          /* A1 = 0.516174 */
9881                  -28996,        /* A2 = -0.884918 */
9882                  13753,         /* B2 = 0.419724 */
9883                  -12,           /* B1 = -0.000763 */
9884                  13757,         /* B0 = 0.419846 */
9885                  24632,         /* A1 = 1.503418 */
9886                  -30271,        /* A2 = -0.923828 */
9887                  29070,         /* B2 = 0.887146 */
9888                  -25265,        /* B1 = -1.542114 */
9889                  29073,         /* B0 = 0.887268 */
9890                  7,             /* Internal filter scaling */
9891                  159,           /* Minimum in-band energy threshold */
9892                  21,            /* 21/32 in-band to broad-band ratio */
9893                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9894         },
9895         {                       /* f900 */
9896                 24806,          /* A1 = -1.514099 */
9897                  -32501,        /* A2 = 0.991852 */
9898                  -326,          /* B2 = -0.009969 */
9899                  0,             /* B1 = 0.000000 */
9900                  326,           /* B0 = 0.009969 */
9901                  24709,         /* A1 = -1.508118 */
9902                  -32659,        /* A2 = 0.996674 */
9903                  20277,         /* B2 = 0.618835 */
9904                  -15182,        /* B1 = -0.926636 */
9905                  20277,         /* B0 = 0.618835 */
9906                  25022,         /* A1 = -1.527222 */
9907                  -32661,        /* A2 = 0.996735 */
9908                  4320,          /* B2 = 0.131836 */
9909                  -3331,         /* B1 = -0.203339 */
9910                  4320,          /* B0 = 0.131836 */
9911                  5,             /* Internal filter scaling */
9912                  159,           /* Minimum in-band energy threshold */
9913                  21,            /* 21/32 in-band to broad-band ratio */
9914                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9915         },
9916         {                       /* f900_1300[] */
9917                 19776,          /* A1 = 1.207092 */
9918                  -27437,        /* A2 = -0.837341 */
9919                  -2666,         /* B2 = -0.081371 */
9920                  0,             /* B1 = 0 */
9921                  2666,          /* B0 = 0.081371 */
9922                  16302,         /* A1 = 0.995026 */
9923                  -30354,        /* A2 = -0.926361 */
9924                  10389,         /* B2 = 0.317062 */
9925                  -3327,         /* B1 = -0.203064 */
9926                  10389,         /* B0 = 0.317062 */
9927                  24299,         /* A1 = 1.483154 */
9928                  -30930,        /* A2 = -0.943909 */
9929                  25016,         /* B2 = 0.763428 */
9930                  -21171,        /* B1 = -1.292236 */
9931                  25016,         /* B0 = 0.763428 */
9932                  7,             /* Internal filter scaling */
9933                  159,           /* Minimum in-band energy threshold */
9934                  21,            /* 21/32 in-band to broad-band ratio */
9935                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9936         },
9937         {                       /* f935_1215[] */
9938                 20554,          /* A1 = 1.254517 */
9939                  -28764,        /* A2 = -0.877838 */
9940                  -2048,         /* B2 = -0.062515 */
9941                  0,             /* B1 = 0 */
9942                  2048,          /* B0 = 0.062515 */
9943                  18209,         /* A1 = 1.11145 */
9944                  -30951,        /* A2 = -0.94458 */
9945                  9390,          /* B2 = 0.286575 */
9946                  -3955,         /* B1 = -0.241455 */
9947                  9390,          /* B0 = 0.286575 */
9948                  23902,         /* A1 = 1.458923 */
9949                  -31286,        /* A2 = -0.954803 */
9950                  23252,         /* B2 = 0.709595 */
9951                  -19132,        /* B1 = -1.167725 */
9952                  23252,         /* B0 = 0.709595 */
9953                  7,             /* Internal filter scaling */
9954                  159,           /* Minimum in-band energy threshold */
9955                  21,            /* 21/32 in-band to broad-band ratio */
9956                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9957         },
9958         {                       /* f941_1477[] */
9959                 17543,          /* A1 = 1.07074 */
9960                  -26220,        /* A2 = -0.800201 */
9961                  -3298,         /* B2 = -0.100647 */
9962                  0,             /* B1 = 0 */
9963                  3298,          /* B0 = 0.100647 */
9964                  12423,         /* A1 = 0.75827 */
9965                  -30036,        /* A2 = -0.916626 */
9966                  12651,         /* B2 = 0.386078 */
9967                  -2444,         /* B1 = -0.14917 */
9968                  12653,         /* B0 = 0.386154 */
9969                  23518,         /* A1 = 1.435425 */
9970                  -30745,        /* A2 = -0.938293 */
9971                  27282,         /* B2 = 0.832581 */
9972                  -22529,        /* B1 = -1.375122 */
9973                  27286,         /* B0 = 0.832703 */
9974                  7,             /* Internal filter scaling */
9975                  159,           /* Minimum in-band energy threshold */
9976                  21,            /* 21/32 in-band to broad-band ratio */
9977                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9978         },
9979         {                       /* f942 */
9980                 24104,          /* A1 = -1.471252 */
9981                  -32507,        /* A2 = 0.992065 */
9982                  -351,          /* B2 = -0.010722 */
9983                  0,             /* B1 = 0.000000 */
9984                  351,           /* B0 = 0.010722 */
9985                  23996,         /* A1 = -1.464600 */
9986                  -32671,        /* A2 = 0.997040 */
9987                  22848,         /* B2 = 0.697266 */
9988                  -16639,        /* B1 = -1.015564 */
9989                  22848,         /* B0 = 0.697266 */
9990                  24332,         /* A1 = -1.485168 */
9991                  -32673,        /* A2 = 0.997101 */
9992                  4906,          /* B2 = 0.149727 */
9993                  -3672,         /* B1 = -0.224174 */
9994                  4906,          /* B0 = 0.149727 */
9995                  5,             /* Internal filter scaling */
9996                  159,           /* Minimum in-band energy threshold */
9997                  21,            /* 21/32 in-band to broad-band ratio */
9998                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9999         },
10000         {                       /* f950 */
10001                 23967,          /* A1 = -1.462830 */
10002                  -32507,        /* A2 = 0.992065 */
10003                  -518,          /* B2 = -0.015821 */
10004                  0,             /* B1 = 0.000000 */
10005                  518,           /* B0 = 0.015821 */
10006                  23856,         /* A1 = -1.456055 */
10007                  -32671,        /* A2 = 0.997040 */
10008                  26287,         /* B2 = 0.802246 */
10009                  -19031,        /* B1 = -1.161560 */
10010                  26287,         /* B0 = 0.802246 */
10011                  24195,         /* A1 = -1.476746 */
10012                  -32673,        /* A2 = 0.997101 */
10013                  2890,          /* B2 = 0.088196 */
10014                  -2151,         /* B1 = -0.131317 */
10015                  2890,          /* B0 = 0.088196 */
10016                  5,             /* Internal filter scaling */
10017                  159,           /* Minimum in-band energy threshold */
10018                  21,            /* 21/32 in-band to broad-band ratio */
10019                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10020         },
10021         {                       /* f950_1400[] */
10022                 18294,          /* A1 = 1.116638 */
10023                  -26962,        /* A2 = -0.822845 */
10024                  -2914,         /* B2 = -0.088936 */
10025                  0,             /* B1 = 0 */
10026                  2914,          /* B0 = 0.088936 */
10027                  14119,         /* A1 = 0.861786 */
10028                  -30227,        /* A2 = -0.922455 */
10029                  11466,         /* B2 = 0.349945 */
10030                  -2833,         /* B1 = -0.172943 */
10031                  11466,         /* B0 = 0.349945 */
10032                  23431,         /* A1 = 1.430115 */
10033                  -30828,        /* A2 = -0.940796 */
10034                  25331,         /* B2 = 0.773071 */
10035                  -20911,        /* B1 = -1.276367 */
10036                  25331,         /* B0 = 0.773071 */
10037                  7,             /* Internal filter scaling */
10038                  159,           /* Minimum in-band energy threshold */
10039                  21,            /* 21/32 in-band to broad-band ratio */
10040                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10041         },
10042         {                       /* f975 */
10043                 23521,          /* A1 = -1.435608 */
10044                  -32489,        /* A2 = 0.991516 */
10045                  -193,          /* B2 = -0.005915 */
10046                  0,             /* B1 = 0.000000 */
10047                  193,           /* B0 = 0.005915 */
10048                  23404,         /* A1 = -1.428467 */
10049                  -32655,        /* A2 = 0.996582 */
10050                  17740,         /* B2 = 0.541412 */
10051                  -12567,        /* B1 = -0.767029 */
10052                  17740,         /* B0 = 0.541412 */
10053                  23753,         /* A1 = -1.449829 */
10054                  -32657,        /* A2 = 0.996613 */
10055                  9090,          /* B2 = 0.277405 */
10056                  -6662,         /* B1 = -0.406647 */
10057                  9090,          /* B0 = 0.277405 */
10058                  5,             /* Internal filter scaling */
10059                  159,           /* Minimum in-band energy threshold */
10060                  21,            /* 21/32 in-band to broad-band ratio */
10061                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10062         },
10063         {                       /* f1000 */
10064                 23071,          /* A1 = -1.408203 */
10065                  -32489,        /* A2 = 0.991516 */
10066                  -293,          /* B2 = -0.008965 */
10067                  0,             /* B1 = 0.000000 */
10068                  293,           /* B0 = 0.008965 */
10069                  22951,         /* A1 = -1.400818 */
10070                  -32655,        /* A2 = 0.996582 */
10071                  5689,          /* B2 = 0.173645 */
10072                  -3951,         /* B1 = -0.241150 */
10073                  5689,          /* B0 = 0.173645 */
10074                  23307,         /* A1 = -1.422607 */
10075                  -32657,        /* A2 = 0.996613 */
10076                  18692,         /* B2 = 0.570435 */
10077                  -13447,        /* B1 = -0.820770 */
10078                  18692,         /* B0 = 0.570435 */
10079                  5,             /* Internal filter scaling */
10080                  159,           /* Minimum in-band energy threshold */
10081                  21,            /* 21/32 in-band to broad-band ratio */
10082                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10083         },
10084         {                       /* f1020 */
10085                 22701,          /* A1 = -1.385620 */
10086                  -32474,        /* A2 = 0.991058 */
10087                  -292,          /* B2 = -0.008933 */
10088                  0,             /*163840      , B1 = 10.000000 */
10089                  292,           /* B0 = 0.008933 */
10090                  22564,         /* A1 = -1.377258 */
10091                  -32655,        /* A2 = 0.996552 */
10092                  20756,         /* B2 = 0.633423 */
10093                  -14176,        /* B1 = -0.865295 */
10094                  20756,         /* B0 = 0.633423 */
10095                  22960,         /* A1 = -1.401428 */
10096                  -32657,        /* A2 = 0.996613 */
10097                  6520,          /* B2 = 0.198990 */
10098                  -4619,         /* B1 = -0.281937 */
10099                  6520,          /* B0 = 0.198990 */
10100                  5,             /* Internal filter scaling */
10101                  159,           /* Minimum in-band energy threshold */
10102                  21,            /* 21/32 in-band to broad-band ratio */
10103                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10104         },
10105         {                       /* f1050 */
10106                 22142,          /* A1 = -1.351501 */
10107                  -32474,        /* A2 = 0.991058 */
10108                  -147,          /* B2 = -0.004493 */
10109                  0,             /* B1 = 0.000000 */
10110                  147,           /* B0 = 0.004493 */
10111                  22000,         /* A1 = -1.342834 */
10112                  -32655,        /* A2 = 0.996552 */
10113                  15379,         /* B2 = 0.469360 */
10114                  -10237,        /* B1 = -0.624847 */
10115                  15379,         /* B0 = 0.469360 */
10116                  22406,         /* A1 = -1.367554 */
10117                  -32657,        /* A2 = 0.996613 */
10118                  17491,         /* B2 = 0.533783 */
10119                  -12096,        /* B1 = -0.738312 */
10120                  17491,         /* B0 = 0.533783 */
10121                  5,             /* Internal filter scaling */
10122                  159,           /* Minimum in-band energy threshold */
10123                  21,            /* 21/32 in-band to broad-band ratio */
10124                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10125         },
10126         {                       /* f1100_1750[] */
10127                 12973,          /* A1 = 0.79184 */
10128                  -24916,        /* A2 = -0.760376 */
10129                  6655,          /* B2 = 0.203102 */
10130                  367,           /* B1 = 0.0224 */
10131                  6657,          /* B0 = 0.203171 */
10132                  5915,          /* A1 = 0.361053 */
10133                  -29560,        /* A2 = -0.90213 */
10134                  -7777,         /* B2 = -0.23735 */
10135                  0,             /* B1 = 0 */
10136                  7777,          /* B0 = 0.23735 */
10137                  20510,         /* A1 = 1.251892 */
10138                  -30260,        /* A2 = -0.923462 */
10139                  26662,         /* B2 = 0.81366 */
10140                  -20573,        /* B1 = -1.255737 */
10141                  26668,         /* B0 = 0.813843 */
10142                  7,             /* Internal filter scaling */
10143                  159,           /* Minimum in-band energy threshold */
10144                  21,            /* 21/32 in-band to broad-band ratio */
10145                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10146         },
10147         {                       /* f1140 */
10148                 20392,          /* A1 = -1.244629 */
10149                  -32460,        /* A2 = 0.990601 */
10150                  -270,          /* B2 = -0.008240 */
10151                  0,             /* B1 = 0.000000 */
10152                  270,           /* B0 = 0.008240 */
10153                  20218,         /* A1 = -1.234009 */
10154                  -32655,        /* A2 = 0.996582 */
10155                  21337,         /* B2 = 0.651154 */
10156                  -13044,        /* B1 = -0.796143 */
10157                  21337,         /* B0 = 0.651154 */
10158                  20684,         /* A1 = -1.262512 */
10159                  -32657,        /* A2 = 0.996643 */
10160                  8572,          /* B2 = 0.261612 */
10161                  -5476,         /* B1 = -0.334244 */
10162                  8572,          /* B0 = 0.261612 */
10163                  5,             /* Internal filter scaling */
10164                  159,           /* Minimum in-band energy threshold */
10165                  21,            /* 21/32 in-band to broad-band ratio */
10166                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10167         },
10168         {                       /* f1200 */
10169                 19159,          /* A1 = -1.169373 */
10170                  -32456,        /* A2 = 0.990509 */
10171                  -335,          /* B2 = -0.010252 */
10172                  0,             /* B1 = 0.000000 */
10173                  335,           /* B0 = 0.010252 */
10174                  18966,         /* A1 = -1.157593 */
10175                  -32661,        /* A2 = 0.996735 */
10176                  6802,          /* B2 = 0.207588 */
10177                  -3900,         /* B1 = -0.238098 */
10178                  6802,          /* B0 = 0.207588 */
10179                  19467,         /* A1 = -1.188232 */
10180                  -32661,        /* A2 = 0.996765 */
10181                  25035,         /* B2 = 0.764008 */
10182                  -15049,        /* B1 = -0.918579 */
10183                  25035,         /* B0 = 0.764008 */
10184                  5,             /* Internal filter scaling */
10185                  159,           /* Minimum in-band energy threshold */
10186                  21,            /* 21/32 in-band to broad-band ratio */
10187                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10188         },
10189         {                       /* f1209 */
10190                 18976,          /* A1 = -1.158264 */
10191                  -32439,        /* A2 = 0.989990 */
10192                  -183,          /* B2 = -0.005588 */
10193                  0,             /* B1 = 0.000000 */
10194                  183,           /* B0 = 0.005588 */
10195                  18774,         /* A1 = -1.145874 */
10196                  -32650,        /* A2 = 0.996429 */
10197                  15468,         /* B2 = 0.472076 */
10198                  -8768,         /* B1 = -0.535217 */
10199                  15468,         /* B0 = 0.472076 */
10200                  19300,         /* A1 = -1.177979 */
10201                  -32652,        /* A2 = 0.996490 */
10202                  19840,         /* B2 = 0.605499 */
10203                  -11842,        /* B1 = -0.722809 */
10204                  19840,         /* B0 = 0.605499 */
10205                  5,             /* Internal filter scaling */
10206                  159,           /* Minimum in-band energy threshold */
10207                  21,            /* 21/32 in-band to broad-band ratio */
10208                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10209         },
10210         {                       /* f1330 */
10211                 16357,          /* A1 = -0.998413 */
10212                  -32368,        /* A2 = 0.987793 */
10213                  -217,          /* B2 = -0.006652 */
10214                  0,             /* B1 = 0.000000 */
10215                  217,           /* B0 = 0.006652 */
10216                  16107,         /* A1 = -0.983126 */
10217                  -32601,        /* A2 = 0.994904 */
10218                  11602,         /* B2 = 0.354065 */
10219                  -5555,         /* B1 = -0.339111 */
10220                  11602,         /* B0 = 0.354065 */
10221                  16722,         /* A1 = -1.020630 */
10222                  -32603,        /* A2 = 0.994965 */
10223                  15574,         /* B2 = 0.475311 */
10224                  -8176,         /* B1 = -0.499069 */
10225                  15574,         /* B0 = 0.475311 */
10226                  5,             /* Internal filter scaling */
10227                  159,           /* Minimum in-band energy threshold */
10228                  21,            /* 21/32 in-band to broad-band ratio */
10229                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10230         },
10231         {                       /* f1336 */
10232                 16234,          /* A1 = -0.990875 */
10233                  32404,         /* A2 = -0.988922 */
10234                  -193,          /* B2 = -0.005908 */
10235                  0,             /* B1 = 0.000000 */
10236                  193,           /* B0 = 0.005908 */
10237                  15986,         /* A1 = -0.975769 */
10238                  -32632,        /* A2 = 0.995880 */
10239                  18051,         /* B2 = 0.550903 */
10240                  -8658,         /* B1 = -0.528473 */
10241                  18051,         /* B0 = 0.550903 */
10242                  16591,         /* A1 = -1.012695 */
10243                  -32634,        /* A2 = 0.995941 */
10244                  15736,         /* B2 = 0.480240 */
10245                  -8125,         /* B1 = -0.495926 */
10246                  15736,         /* B0 = 0.480240 */
10247                  5,             /* Internal filter scaling */
10248                  159,           /* Minimum in-band energy threshold */
10249                  21,            /* 21/32 in-band to broad-band ratio */
10250                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10251         },
10252         {                       /* f1366 */
10253                 15564,          /* A1 = -0.949982 */
10254                  -32404,        /* A2 = 0.988922 */
10255                  -269,          /* B2 = -0.008216 */
10256                  0,             /* B1 = 0.000000 */
10257                  269,           /* B0 = 0.008216 */
10258                  15310,         /* A1 = -0.934479 */
10259                  -32632,        /* A2 = 0.995880 */
10260                  10815,         /* B2 = 0.330063 */
10261                  -4962,         /* B1 = -0.302887 */
10262                  10815,         /* B0 = 0.330063 */
10263                  15924,         /* A1 = -0.971924 */
10264                  -32634,        /* A2 = 0.995941 */
10265                  18880,         /* B2 = 0.576172 */
10266                  -9364,         /* B1 = -0.571594 */
10267                  18880,         /* B0 = 0.576172 */
10268                  5,             /* Internal filter scaling */
10269                  159,           /* Minimum in-band energy threshold */
10270                  21,            /* 21/32 in-band to broad-band ratio */
10271                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10272         },
10273         {                       /* f1380 */
10274                 15247,          /* A1 = -0.930603 */
10275                  -32397,        /* A2 = 0.988708 */
10276                  -244,          /* B2 = -0.007451 */
10277                  0,             /* B1 = 0.000000 */
10278                  244,           /* B0 = 0.007451 */
10279                  14989,         /* A1 = -0.914886 */
10280                  -32627,        /* A2 = 0.995697 */
10281                  18961,         /* B2 = 0.578644 */
10282                  -8498,         /* B1 = -0.518707 */
10283                  18961,         /* B0 = 0.578644 */
10284                  15608,         /* A1 = -0.952667 */
10285                  -32628,        /* A2 = 0.995758 */
10286                  11145,         /* B2 = 0.340134 */
10287                  -5430,         /* B1 = -0.331467 */
10288                  11145,         /* B0 = 0.340134 */
10289                  5,             /* Internal filter scaling */
10290                  159,           /* Minimum in-band energy threshold */
10291                  21,            /* 21/32 in-band to broad-band ratio */
10292                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10293         },
10294         {                       /* f1400 */
10295                 14780,          /* A1 = -0.902130 */
10296                  -32393,        /* A2 = 0.988586 */
10297                  -396,          /* B2 = -0.012086 */
10298                  0,             /* B1 = 0.000000 */
10299                  396,           /* B0 = 0.012086 */
10300                  14510,         /* A1 = -0.885651 */
10301                  -32630,        /* A2 = 0.995819 */
10302                  6326,          /* B2 = 0.193069 */
10303                  -2747,         /* B1 = -0.167671 */
10304                  6326,          /* B0 = 0.193069 */
10305                  15154,         /* A1 = -0.924957 */
10306                  -32632,        /* A2 = 0.995850 */
10307                  23235,         /* B2 = 0.709076 */
10308                  -10983,        /* B1 = -0.670380 */
10309                  23235,         /* B0 = 0.709076 */
10310                  5,             /* Internal filter scaling */
10311                  159,           /* Minimum in-band energy threshold */
10312                  21,            /* 21/32 in-band to broad-band ratio */
10313                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10314         },
10315         {                       /* f1477 */
10316                 13005,          /* A1 = -0.793793 */
10317                  -32368,        /* A2 = 0.987823 */
10318                  -500,          /* B2 = -0.015265 */
10319                  0,             /* B1 = 0.000000 */
10320                  500,           /* B0 = 0.015265 */
10321                  12708,         /* A1 = -0.775665 */
10322                  -32615,        /* A2 = 0.995331 */
10323                  11420,         /* B2 = 0.348526 */
10324                  -4306,         /* B1 = -0.262833 */
10325                  11420,         /* B0 = 0.348526 */
10326                  13397,         /* A1 = -0.817688 */
10327                  -32615,        /* A2 = 0.995361 */
10328                  9454,          /* B2 = 0.288528 */
10329                  -3981,         /* B1 = -0.243027 */
10330                  9454,          /* B0 = 0.288528 */
10331                  5,             /* Internal filter scaling */
10332                  159,           /* Minimum in-band energy threshold */
10333                  21,            /* 21/32 in-band to broad-band ratio */
10334                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10335         },
10336         {                       /* f1600 */
10337                 10046,          /* A1 = -0.613190 */
10338                  -32331,        /* A2 = 0.986694 */
10339                  -455,          /* B2 = -0.013915 */
10340                  0,             /* B1 = 0.000000 */
10341                  455,           /* B0 = 0.013915 */
10342                  9694,          /* A1 = -0.591705 */
10343                  -32601,        /* A2 = 0.994934 */
10344                  6023,          /* B2 = 0.183815 */
10345                  -1708,         /* B1 = -0.104279 */
10346                  6023,          /* B0 = 0.183815 */
10347                  10478,         /* A1 = -0.639587 */
10348                  -32603,        /* A2 = 0.994965 */
10349                  22031,         /* B2 = 0.672333 */
10350                  -7342,         /* B1 = -0.448151 */
10351                  22031,         /* B0 = 0.672333 */
10352                  5,             /* Internal filter scaling */
10353                  159,           /* Minimum in-band energy threshold */
10354                  21,            /* 21/32 in-band to broad-band ratio */
10355                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10356         },
10357         {                       /* f1633_1638[] */
10358                 9181,           /* A1 = 0.560394 */
10359                  -32256,        /* A2 = -0.984375 */
10360                  -556,          /* B2 = -0.016975 */
10361                  0,             /* B1 = 0 */
10362                  556,           /* B0 = 0.016975 */
10363                  8757,          /* A1 = 0.534515 */
10364                  -32574,        /* A2 = -0.99408 */
10365                  8443,          /* B2 = 0.25769 */
10366                  -2135,         /* B1 = -0.130341 */
10367                  8443,          /* B0 = 0.25769 */
10368                  9691,          /* A1 = 0.591522 */
10369                  -32574,        /* A2 = -0.99411 */
10370                  15446,         /* B2 = 0.471375 */
10371                  -4809,         /* B1 = -0.293579 */
10372                  15446,         /* B0 = 0.471375 */
10373                  7,             /* Internal filter scaling */
10374                  159,           /* Minimum in-band energy threshold */
10375                  21,            /* 21/32 in-band to broad-band ratio */
10376                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10377         },
10378         {                       /* f1800 */
10379                 5076,           /* A1 = -0.309875 */
10380                  -32304,        /* A2 = 0.985840 */
10381                  -508,          /* B2 = -0.015503 */
10382                  0,             /* B1 = 0.000000 */
10383                  508,           /* B0 = 0.015503 */
10384                  4646,          /* A1 = -0.283600 */
10385                  -32605,        /* A2 = 0.995026 */
10386                  6742,          /* B2 = 0.205780 */
10387                  -878,          /* B1 = -0.053635 */
10388                  6742,          /* B0 = 0.205780 */
10389                  5552,          /* A1 = -0.338928 */
10390                  -32605,        /* A2 = 0.995056 */
10391                  23667,         /* B2 = 0.722260 */
10392                  -4297,         /* B1 = -0.262329 */
10393                  23667,         /* B0 = 0.722260 */
10394                  5,             /* Internal filter scaling */
10395                  159,           /* Minimum in-band energy threshold */
10396                  21,            /* 21/32 in-band to broad-band ratio */
10397                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10398         },
10399         {                       /* f1860 */
10400                 3569,           /* A1 = -0.217865 */
10401                  -32292,        /* A2 = 0.985504 */
10402                  -239,          /* B2 = -0.007322 */
10403                  0,             /* B1 = 0.000000 */
10404                  239,           /* B0 = 0.007322 */
10405                  3117,          /* A1 = -0.190277 */
10406                  -32603,        /* A2 = 0.994965 */
10407                  18658,         /* B2 = 0.569427 */
10408                  -1557,         /* B1 = -0.095032 */
10409                  18658,         /* B0 = 0.569427 */
10410                  4054,          /* A1 = -0.247437 */
10411                  -32603,        /* A2 = 0.994965 */
10412                  18886,         /* B2 = 0.576385 */
10413                  -2566,         /* B1 = -0.156647 */
10414                  18886,         /* B0 = 0.576385 */
10415                  5,             /* Internal filter scaling */
10416                  159,           /* Minimum in-band energy threshold */
10417                  21,            /* 21/32 in-band to broad-band ratio */
10418                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10419         },
10420 };
10421 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10422 {
10423         unsigned short cmd;
10424         int cnt, max;
10425
10426         if (jf->filter > 3) {
10427                 return -1;
10428         }
10429         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10430
10431                 return -1;
10432         if (!jf->enable) {
10433                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10434
10435                         return -1;
10436                 else
10437                         return 0;
10438         } else {
10439                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10440
10441                         return -1;
10442                 /* Select the filter (f0 - f3) to use. */
10443                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10444                         return -1;
10445         }
10446         if (jf->freq < 12 && jf->freq > 3) {
10447                 /* Select the frequency for the selected filter. */
10448                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10449                         return -1;
10450         } else if (jf->freq > 11) {
10451                 /* We need to load a programmable filter set for undefined */
10452                 /* frequencies.  So we will point the filter to a programmable set. */
10453                 /* Since there are only 4 filters and 4 programmable sets, we will */
10454                 /* just point the filter to the same number set and program it for the */
10455                 /* frequency we want. */
10456                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10457                         return -1;
10458                 if (j->ver.low != 0x12) {
10459                         cmd = 0x515B;
10460                         max = 19;
10461                 } else {
10462                         cmd = 0x515E;
10463                         max = 15;
10464                 }
10465                 if (ixj_WriteDSPCommand(cmd, j))
10466                         return -1;
10467                 for (cnt = 0; cnt < max; cnt++) {
10468                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10469                                 return -1;
10470                 }
10471         }
10472         j->filter_en[jf->filter] = jf->enable;
10473         return 0;
10474 }
10475
10476 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10477 {
10478         unsigned short cmd;
10479         int cnt, max;
10480         if (jfr->filter > 3) {
10481                 return -1;
10482         }
10483         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10484                 return -1;
10485
10486         if (!jfr->enable) {
10487                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10488                         return -1;
10489                 else
10490                         return 0;
10491         } else {
10492                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10493                         return -1;
10494                 /* Select the filter (f0 - f3) to use. */
10495                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10496                         return -1;
10497         }
10498         /* We need to load a programmable filter set for undefined */
10499         /* frequencies.  So we will point the filter to a programmable set. */
10500         /* Since there are only 4 filters and 4 programmable sets, we will */
10501         /* just point the filter to the same number set and program it for the */
10502         /* frequency we want. */
10503         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10504                 return -1;
10505         if (j->ver.low != 0x12) {
10506                 cmd = 0x515B;
10507                 max = 19;
10508         } else {
10509                 cmd = 0x515E;
10510                 max = 15;
10511         }
10512         if (ixj_WriteDSPCommand(cmd, j))
10513                 return -1;
10514         for (cnt = 0; cnt < max; cnt++) {
10515                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10516                         return -1;
10517         }
10518         j->filter_en[jfr->filter] = jfr->enable;
10519         return 0;
10520 }
10521
10522 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10523 {
10524         int freq0, freq1;
10525         unsigned short data;
10526         if (ti->freq0) {
10527                 freq0 = ti->freq0;
10528         } else {
10529                 freq0 = 0x7FFF;
10530         }
10531
10532         if (ti->freq1) {
10533                 freq1 = ti->freq1;
10534         } else {
10535                 freq1 = 0x7FFF;
10536         }
10537
10538         if(ti->tone_index > 12 && ti->tone_index < 28)
10539         {
10540                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10541                         return -1;
10542                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10543                         return -1;
10544                 data = freq0;
10545                 if (ixj_WriteDSPCommand(data, j))
10546                         return -1;
10547                 data = freq1;
10548                 if (ixj_WriteDSPCommand(data, j))
10549                         return -1;
10550         }
10551         return freq0;
10552 }
10553