git.oblomov.eu Git - linux-2.6/blob - drivers/telephony/ixj.c

   1 /****************************************************************************
   2  *    ixj.c
   3  *
   4  * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
   5  * including the Internet PhoneJACK, Internet PhoneJACK Lite,
   6  * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
   7  * SmartCABLE
   8  *
   9  *    (c) Copyright 1999-2001  Quicknet Technologies, Inc.
  10  *
  11  *    This program is free software; you can redistribute it and/or
  12  *    modify it under the terms of the GNU General Public License
  13  *    as published by the Free Software Foundation; either version
  14  *    2 of the License, or (at your option) any later version.
  15  *
  16  * Author:          Ed Okerson, <eokerson@quicknet.net>
  17  *
  18  * Contributors:    Greg Herlein, <gherlein@quicknet.net>
  19  *                  David W. Erhart, <derhart@quicknet.net>
  20  *                  John Sellers, <jsellers@quicknet.net>
  21  *                  Mike Preston, <mpreston@quicknet.net>
  22  *
  23  * Fixes:           David Huggins-Daines, <dhd@cepstral.com>
  24  *                  Fabio Ferrari, <fabio.ferrari@digitro.com.br>
  25  *                  Artis Kugevics, <artis@mt.lv>
  26  *                  Daniele Bellucci, <bellucda@tiscali.it>
  27  *
  28  * More information about the hardware related to this driver can be found
  29  * at our website:    http://www.quicknet.net
  30  *
  31  * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
  32  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  33  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
  34  * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  37  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  38  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  39  * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
  40  * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  41  *
  42  ***************************************************************************/
  43
  44 /*
  45  * $Log: ixj.c,v $
  46  *
  47  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  48  * Audit some copy_*_user and minor cleanup.
  49  *
  50  * Revision 4.7  2001/08/13 06:19:33  craigs
  51  * Added additional changes from Alan Cox and John Anderson for
  52  * 2.2 to 2.4 cleanup and bounds checking
  53  *
  54  * Revision 4.6  2001/08/13 01:05:05  craigs
  55  * Really fixed PHONE_QUERY_CODEC problem this time
  56  *
  57  * Revision 4.5  2001/08/13 00:11:03  craigs
  58  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  59  *
  60  * Revision 4.4  2001/08/07 07:58:12  craigs
  61  * Changed back to three digit version numbers
  62  * Added tagbuild target to allow automatic and easy tagging of versions
  63  *
  64  * Revision 4.3  2001/08/07 07:24:47  craigs
  65  * Added ixj-ver.h to allow easy configuration management of driver
  66  * Added display of version number in /prox/ixj
  67  *
  68  * Revision 4.2  2001/08/06 07:07:19  craigs
  69  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  70  * behaviour of returning int rather than short *
  71  *
  72  * Revision 4.1  2001/08/05 00:17:37  craigs
  73  * More changes for correct PCMCIA installation
  74  * Start of changes for backward Linux compatibility
  75  *
  76  * Revision 4.0  2001/08/04 12:33:12  craigs
  77  * New version using GNU autoconf
  78  *
  79  * Revision 3.105  2001/07/20 23:14:32  eokerson
  80  * More work on CallerID generation when using ring cadences.
  81  *
  82  * Revision 3.104  2001/07/06 01:33:55  eokerson
  83  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  84  *
  85  * Revision 3.103  2001/07/05 19:20:16  eokerson
  86  * Updated HOWTO
  87  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  88  *
  89  * Revision 3.102  2001/07/03 23:51:21  eokerson
  90  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  91  *
  92  * Revision 3.101  2001/07/02 19:26:56  eokerson
  93  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  94  *
  95  * Revision 3.100  2001/07/02 19:18:27  eokerson
  96  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  97  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  98  * Fixed speaker mode on Internet LineJACK.
  99  *
 100  * Revision 3.99  2001/05/09 14:11:16  eokerson
 101  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 102  *
 103  * Revision 3.98  2001/05/08 19:55:33  eokerson
 104  * Fixed POTS hookstate detection while it is connected to PSTN port.
 105  *
 106  * Revision 3.97  2001/05/08 00:01:04  eokerson
 107  * Fixed kernel oops when sending caller ID data.
 108  *
 109  * Revision 3.96  2001/05/04 23:09:30  eokerson
 110  * Now uses one kernel timer for each card, instead of one for the entire driver.
 111  *
 112  * Revision 3.95  2001/04/25 22:06:47  eokerson
 113  * Fixed squawking at beginning of some G.723.1 calls.
 114  *
 115  * Revision 3.94  2001/04/03 23:42:00  eokerson
 116  * Added linear volume ioctls
 117  * Added raw filter load ioctl
 118  *
 119  * Revision 3.93  2001/02/27 01:00:06  eokerson
 120  * Fixed blocking in CallerID.
 121  * Reduced size of ixj structure for smaller driver footprint.
 122  *
 123  * Revision 3.92  2001/02/20 22:02:59  eokerson
 124  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 125  * Improved PSTN ring detection.
 126  * Fixed wink generation on POTS ports.
 127  *
 128  * Revision 3.91  2001/02/13 00:55:44  eokerson
 129  * Turn AEC back on after changing frame sizes.
 130  *
 131  * Revision 3.90  2001/02/12 16:42:00  eokerson
 132  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 133  *
 134  * Revision 3.89  2001/02/12 15:41:16  eokerson
 135  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 136  *
 137  * Revision 3.88  2001/02/05 23:25:42  eokerson
 138  * Fixed lockup bugs with deregister.
 139  *
 140  * Revision 3.87  2001/01/29 21:00:39  eokerson
 141  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 142  * Updated copyright date.
 143  *
 144  * Revision 3.86  2001/01/23 23:53:46  eokerson
 145  * Fixes to G.729 compatibility.
 146  *
 147  * Revision 3.85  2001/01/23 21:30:36  eokerson
 148  * Added verbage about cards supported.
 149  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 150  *
 151  * Revision 3.84  2001/01/22 23:32:10  eokerson
 152  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 153  *
 154  * Revision 3.83  2001/01/19 14:51:41  eokerson
 155  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 156  *
 157  * Revision 3.82  2001/01/19 00:34:49  eokerson
 158  * Added verbosity to write overlap errors.
 159  *
 160  * Revision 3.81  2001/01/18 23:56:54  eokerson
 161  * Fixed PSTN line test functions.
 162  *
 163  * Revision 3.80  2001/01/18 22:29:27  eokerson
 164  * Updated AEC/AGC values for different cards.
 165  *
 166  * Revision 3.79  2001/01/17 02:58:54  eokerson
 167  * Fixed AEC reset after Caller ID.
 168  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 169  *
 170  * Revision 3.78  2001/01/16 19:43:09  eokerson
 171  * Added support for Linux 2.4.x kernels.
 172  *
 173  * Revision 3.77  2001/01/09 04:00:52  eokerson
 174  * Linetest will now test the line, even if it has previously succeded.
 175  *
 176  * Revision 3.76  2001/01/08 19:27:00  eokerson
 177  * Fixed problem with standard cable on Internet PhoneCARD.
 178  *
 179  * Revision 3.75  2000/12/22 16:52:14  eokerson
 180  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 181  *
 182  * Revision 3.74  2000/12/08 22:41:50  eokerson
 183  * Added capability for G729B.
 184  *
 185  * Revision 3.73  2000/12/07 23:35:16  eokerson
 186  * Added capability to have different ring pattern before CallerID data.
 187  * Added hookstate checks in CallerID routines to stop FSK.
 188  *
 189  * Revision 3.72  2000/12/06 19:31:31  eokerson
 190  * Modified signal behavior to only send one signal per event.
 191  *
 192  * Revision 3.71  2000/12/06 03:23:08  eokerson
 193  * Fixed CallerID on Call Waiting.
 194  *
 195  * Revision 3.70  2000/12/04 21:29:37  eokerson
 196  * Added checking to Smart Cable gain functions.
 197  *
 198  * Revision 3.69  2000/12/04 21:05:20  eokerson
 199  * Changed ixjdebug levels.
 200  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 201  *
 202  * Revision 3.68  2000/12/04 00:17:21  craigs
 203  * Changed mixer voice gain to +6dB rather than 0dB
 204  *
 205  * Revision 3.67  2000/11/30 21:25:51  eokerson
 206  * Fixed write signal errors.
 207  *
 208  * Revision 3.66  2000/11/29 22:42:44  eokerson
 209  * Fixed PSTN ring detect problems.
 210  *
 211  * Revision 3.65  2000/11/29 07:31:55  craigs
 212  * Added new 425Hz filter co-efficients
 213  * Added card-specific DTMF prescaler initialisation
 214  *
 215  * Revision 3.64  2000/11/28 14:03:32  craigs
 216  * Changed certain mixer initialisations to be 0dB rather than 12dB
 217  * Added additional information to /proc/ixj
 218  *
 219  * Revision 3.63  2000/11/28 11:38:41  craigs
 220  * Added display of AEC modes in AUTO and AGC mode
 221  *
 222  * Revision 3.62  2000/11/28 04:05:44  eokerson
 223  * Improved PSTN ring detection routine.
 224  *
 225  * Revision 3.61  2000/11/27 21:53:12  eokerson
 226  * Fixed flash detection.
 227  *
 228  * Revision 3.60  2000/11/27 15:57:29  eokerson
 229  * More work on G.729 load routines.
 230  *
 231  * Revision 3.59  2000/11/25 21:55:12  eokerson
 232  * Fixed errors in G.729 load routine.
 233  *
 234  * Revision 3.58  2000/11/25 04:08:29  eokerson
 235  * Added board locks around G.729 and TS85 load routines.
 236  *
 237  * Revision 3.57  2000/11/24 05:35:17  craigs
 238  * Added ability to retrieve mixer values on LineJACK
 239  * Added complete initialisation of all mixer values at startup
 240  * Fixed spelling mistake
 241  *
 242  * Revision 3.56  2000/11/23 02:52:11  robertj
 243  * Added cvs change log keyword.
 244  * Fixed bug in capabilities list when using G.729 module.
 245  *
 246  */
 247
 248 #include "ixj-ver.h"
 249
 250 #define PERFMON_STATS
 251 #define IXJDEBUG 0
 252 #define MAXRINGS 5
 253
 254 #include <linux/module.h>
 255
 256 #include <linux/init.h>
 257 #include <linux/sched.h>
 258 #include <linux/kernel.h>       /* printk() */
 259 #include <linux/fs.h>           /* everything... */
 260 #include <linux/errno.h>        /* error codes */
 261 #include <linux/slab.h>
 262 #include <linux/mm.h>
 263 #include <linux/ioport.h>
 264 #include <linux/interrupt.h>
 265 #include <linux/proc_fs.h>
 266 #include <linux/poll.h>
 267 #include <linux/timer.h>
 268 #include <linux/delay.h>
 269 #include <linux/pci.h>
 270
 271 #include <asm/io.h>
 272 #include <asm/uaccess.h>
 273
 274 #include <linux/isapnp.h>
 275
 276 #include "ixj.h"
 277
 278 #define TYPE(inode) (iminor(inode) >> 4)
 279 #define NUM(inode) (iminor(inode) & 0xf)
 280
 281 static int ixjdebug;
 282 static int hertz = HZ;
 283 static int samplerate = 100;
 284
 285 module_param(ixjdebug, int, 0);
 286
 287 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         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2334
2335         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2336                 ixj_set_port(j, PORT_PSTN);
2337                 daa_set_mode(j, SOP_PU_SLEEP);
2338                 ixj_set_pots(j, 1);
2339         }
2340         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2341
2342         /* Set up the default signals for events */
2343         for (cnt = 0; cnt < 35; cnt++)
2344                 j->ixj_signals[cnt] = SIGIO;
2345
2346         /* Set the excetion signal enable flags */
2347         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2348         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 =
2349         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;
2350
2351         file_p->private_data = NULL;
2352         clear_bit(board, &j->busyflags);
2353         return 0;
2354 }
2355
2356 static int read_filters(IXJ *j)
2357 {
2358         unsigned short fc, cnt, trg;
2359         int var;
2360
2361         trg = 0;
2362         if (ixj_WriteDSPCommand(0x5144, j)) {
2363                 if(ixjdebug & 0x0001) {
2364                         printk(KERN_INFO "Read Frame Counter failed!\n");
2365                 }
2366                 return -1;
2367         }
2368         fc = j->ssr.high << 8 | j->ssr.low;
2369         if (fc == j->frame_count)
2370                 return 1;
2371
2372         j->frame_count = fc;
2373
2374         if (j->dtmf_proc)
2375                 return 1;
2376
2377         var = 10;
2378
2379         for (cnt = 0; cnt < 4; cnt++) {
2380                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2381                         if(ixjdebug & 0x0001) {
2382                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2383                         }
2384                         return -1;
2385                 }
2386                 if (ixj_WriteDSPCommand(0x515C, j)) {
2387                         if(ixjdebug & 0x0001) {
2388                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2389                         }
2390                         return -1;
2391                 }
2392                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2393
2394                 if (j->cadence_f[cnt].enable) {
2395                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2396                                 if (j->cadence_f[cnt].state == 0) {
2397                                         j->cadence_f[cnt].state = 1;
2398                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2399                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2400                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2401                                 } else if (j->cadence_f[cnt].state == 2 &&
2402                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2403                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2404                                         if (j->cadence_f[cnt].on2) {
2405                                                 j->cadence_f[cnt].state = 3;
2406                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2407                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2408                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2409                                         } else {
2410                                                 j->cadence_f[cnt].state = 7;
2411                                         }
2412                                 } else if (j->cadence_f[cnt].state == 4 &&
2413                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2414                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2415                                         if (j->cadence_f[cnt].on3) {
2416                                                 j->cadence_f[cnt].state = 5;
2417                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2418                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2419                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2420                                         } else {
2421                                                 j->cadence_f[cnt].state = 7;
2422                                         }
2423                                 } else {
2424                                         j->cadence_f[cnt].state = 0;
2425                                 }
2426                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2427                                 if (j->cadence_f[cnt].state == 1) {
2428                                         if(!j->cadence_f[cnt].on1) {
2429                                                 j->cadence_f[cnt].state = 7;
2430                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2431                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2432                                                 if(j->cadence_f[cnt].off1) {
2433                                                         j->cadence_f[cnt].state = 2;
2434                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2435                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2436                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2437                                                 } else {
2438                                                         j->cadence_f[cnt].state = 7;
2439                                                 }
2440                                         } else {
2441                                                 j->cadence_f[cnt].state = 0;
2442                                         }
2443                                 } else if (j->cadence_f[cnt].state == 3) {
2444                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2445                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2446                                                 if(j->cadence_f[cnt].off2) {
2447                                                         j->cadence_f[cnt].state = 4;
2448                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2449                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2450                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2451                                                 } else {
2452                                                         j->cadence_f[cnt].state = 7;
2453                                                 }
2454                                         } else {
2455                                                 j->cadence_f[cnt].state = 0;
2456                                         }
2457                                 } else if (j->cadence_f[cnt].state == 5) {
2458                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2459                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2460                                                 if(j->cadence_f[cnt].off3) {
2461                                                         j->cadence_f[cnt].state = 6;
2462                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2463                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2464                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2465                                                 } else {
2466                                                         j->cadence_f[cnt].state = 7;
2467                                                 }
2468                                         } else {
2469                                                 j->cadence_f[cnt].state = 0;
2470                                         }
2471                                 } else {
2472                                         j->cadence_f[cnt].state = 0;
2473                                 }
2474                         } else {
2475                                 switch(j->cadence_f[cnt].state) {
2476                                         case 1:
2477                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2478                                                    !j->cadence_f[cnt].off1 &&
2479                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2480                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2481                                                         j->cadence_f[cnt].state = 7;
2482                                                 }
2483                                                 break;
2484                                         case 3:
2485                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2486                                                    !j->cadence_f[cnt].off2 &&
2487                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2488                                                         j->cadence_f[cnt].state = 7;
2489                                                 }
2490                                                 break;
2491                                         case 5:
2492                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2493                                                    !j->cadence_f[cnt].off3) {
2494                                                         j->cadence_f[cnt].state = 7;
2495                                                 }
2496                                                 break;
2497                                 }
2498                         }
2499
2500                         if (ixjdebug & 0x0040) {
2501                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2502                                 switch(j->cadence_f[cnt].state) {
2503                                         case 0:
2504                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2505                                                 break;
2506                                         case 1:
2507                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2508                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2509                                                 break;
2510                                         case 2:
2511                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2512                                                                                                                         j->cadence_f[cnt].off1max);
2513                                                 break;
2514                                         case 3:
2515                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2516                                                                                                                         j->cadence_f[cnt].on2max);
2517                                                 break;
2518                                         case 4:
2519                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2520                                                                                                                         j->cadence_f[cnt].off2max);
2521                                                 break;
2522                                         case 5:
2523                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2524                                                                                                                         j->cadence_f[cnt].on3max);
2525                                                 break;
2526                                         case 6:
2527                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2528                                                                                                                         j->cadence_f[cnt].off3max);
2529                                                 break;
2530                                 }
2531                         }
2532                 }
2533                 if (j->cadence_f[cnt].state == 7) {
2534                         j->cadence_f[cnt].state = 0;
2535                         if (j->cadence_f[cnt].enable == 1)
2536                                 j->cadence_f[cnt].enable = 0;
2537                         switch (cnt) {
2538                         case 0:
2539                                 if(ixjdebug & 0x0020) {
2540                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2541                                 }
2542                                 j->ex.bits.fc0 = 1;
2543                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2544                                 break;
2545                         case 1:
2546                                 if(ixjdebug & 0x0020) {
2547                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2548                                 }
2549                                 j->ex.bits.fc1 = 1;
2550                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2551                                 break;
2552                         case 2:
2553                                 if(ixjdebug & 0x0020) {
2554                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2555                                 }
2556                                 j->ex.bits.fc2 = 1;
2557                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2558                                 break;
2559                         case 3:
2560                                 if(ixjdebug & 0x0020) {
2561                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2562                                 }
2563                                 j->ex.bits.fc3 = 1;
2564                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2565                                 break;
2566                         }
2567                 }
2568                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2569                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2570                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2571                                 trg = 1;
2572                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2573                                 trg = 0;
2574                         }
2575                         switch (cnt) {
2576                         case 0:
2577                                 if(ixjdebug & 0x0020) {
2578                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2579                                 }
2580                                 j->ex.bits.f0 = 1;
2581                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2582                                 break;
2583                         case 1:
2584                                 if(ixjdebug & 0x0020) {
2585                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2586                                 }
2587                                 j->ex.bits.f1 = 1;
2588                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2589                                 break;
2590                         case 2:
2591                                 if(ixjdebug & 0x0020) {
2592                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2593                                 }
2594                                 j->ex.bits.f2 = 1;
2595                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2596                                 break;
2597                         case 3:
2598                                 if(ixjdebug & 0x0020) {
2599                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2600                                 }
2601                                 j->ex.bits.f3 = 1;
2602                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2603                                 break;
2604                         }
2605                 }
2606         }
2607         return 0;
2608 }
2609
2610 static int LineMonitor(IXJ *j)
2611 {
2612         if (j->dtmf_proc) {
2613                 return -1;
2614         }
2615         j->dtmf_proc = 1;
2616
2617         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2618                 return -1;
2619
2620         j->dtmf.bytes.high = j->ssr.high;
2621         j->dtmf.bytes.low = j->ssr.low;
2622         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2623                 j->dtmf_state = 1;
2624                 j->dtmf_current = j->dtmf.bits.digit;
2625         }
2626         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2627          {
2628                 if(!j->cidcw_wait) {
2629                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2630                         j->dtmf_wp++;
2631                         if (j->dtmf_wp == 79)
2632                                 j->dtmf_wp = 0;
2633                         j->ex.bits.dtmf_ready = 1;
2634                         if(j->ex_sig.bits.dtmf_ready) {
2635                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2636                         }
2637                 }
2638                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2639                         if(ixjdebug & 0x0020) {
2640                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2641                         }
2642                         j->flags.cidcw_ack = 1;
2643                 }
2644                 j->dtmf_state = 0;
2645         }
2646         j->dtmf_proc = 0;
2647
2648         return 0;
2649 }
2650
2651 /************************************************************************
2652 *
2653 * Functions to allow alaw <-> ulaw conversions.
2654 *
2655 ************************************************************************/
2656
2657 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2658 {
2659         static unsigned char table_ulaw2alaw[] =
2660         {
2661                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2662                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2663                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2664                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2665                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2666                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2667                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2668                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2669                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2670                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2671                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2672                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2673                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2674                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2675                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2676                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2677                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2678                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2679                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2680                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2681                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2682                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2683                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2684                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2685                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2686                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2687                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2688                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2689                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2690                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2691                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2692                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2693         };
2694
2695         while (len--)
2696         {
2697                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2698                 buff++;
2699         }
2700 }
2701
2702 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2703 {
2704         static unsigned char table_alaw2ulaw[] =
2705         {
2706                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2707                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2708                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2709                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2710                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2711                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2712                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2713                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2714                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2715                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2716                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2717                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2718                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2719                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2720                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2721                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2722                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2723                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2724                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2725                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2726                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2727                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2728                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2729                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2730                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2731                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2732                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2733                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2734                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2735                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2736                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2737                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2738         };
2739
2740         while (len--)
2741         {
2742                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2743                 buff++;
2744         }
2745 }
2746
2747 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2748 {
2749         unsigned long i = *ppos;
2750         IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2751
2752         DECLARE_WAITQUEUE(wait, current);
2753
2754         if (j->flags.inread)
2755                 return -EALREADY;
2756
2757         j->flags.inread = 1;
2758
2759         add_wait_queue(&j->read_q, &wait);
2760         set_current_state(TASK_INTERRUPTIBLE);
2761         mb();
2762
2763         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2764                 ++j->read_wait;
2765                 if (file_p->f_flags & O_NONBLOCK) {
2766                         set_current_state(TASK_RUNNING);
2767                         remove_wait_queue(&j->read_q, &wait);
2768                         j->flags.inread = 0;
2769                         return -EAGAIN;
2770                 }
2771                 if (!ixj_hookstate(j)) {
2772                         set_current_state(TASK_RUNNING);
2773                         remove_wait_queue(&j->read_q, &wait);
2774                         j->flags.inread = 0;
2775                         return 0;
2776                 }
2777                 interruptible_sleep_on(&j->read_q);
2778                 if (signal_pending(current)) {
2779                         set_current_state(TASK_RUNNING);
2780                         remove_wait_queue(&j->read_q, &wait);
2781                         j->flags.inread = 0;
2782                         return -EINTR;
2783                 }
2784         }
2785
2786         remove_wait_queue(&j->read_q, &wait);
2787         set_current_state(TASK_RUNNING);
2788         /* Don't ever copy more than the user asks */
2789         if(j->rec_codec == ALAW)
2790                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2791         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2792         j->read_buffer_ready = 0;
2793         if (i) {
2794                 j->flags.inread = 0;
2795                 return -EFAULT;
2796         } else {
2797                 j->flags.inread = 0;
2798                 return min(length, j->read_buffer_size);
2799         }
2800 }
2801
2802 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2803                           loff_t * ppos)
2804 {
2805         int pre_retval;
2806         ssize_t read_retval = 0;
2807         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2808
2809         pre_retval = ixj_PreRead(j, 0L);
2810         switch (pre_retval) {
2811         case NORMAL:
2812                 read_retval = ixj_read(file_p, buf, length, ppos);
2813                 ixj_PostRead(j, 0L);
2814                 break;
2815         case NOPOST:
2816                 read_retval = ixj_read(file_p, buf, length, ppos);
2817                 break;
2818         case POSTONLY:
2819                 ixj_PostRead(j, 0L);
2820                 break;
2821         default:
2822                 read_retval = pre_retval;
2823         }
2824         return read_retval;
2825 }
2826
2827 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2828 {
2829         unsigned long i = *ppos;
2830         IXJ *j = file_p->private_data;
2831
2832         DECLARE_WAITQUEUE(wait, current);
2833
2834         if (j->flags.inwrite)
2835                 return -EALREADY;
2836
2837         j->flags.inwrite = 1;
2838
2839         add_wait_queue(&j->write_q, &wait);
2840         set_current_state(TASK_INTERRUPTIBLE);
2841         mb();
2842
2843
2844         while (!j->write_buffers_empty) {
2845                 ++j->write_wait;
2846                 if (file_p->f_flags & O_NONBLOCK) {
2847                         set_current_state(TASK_RUNNING);
2848                         remove_wait_queue(&j->write_q, &wait);
2849                         j->flags.inwrite = 0;
2850                         return -EAGAIN;
2851                 }
2852                 if (!ixj_hookstate(j)) {
2853                         set_current_state(TASK_RUNNING);
2854                         remove_wait_queue(&j->write_q, &wait);
2855                         j->flags.inwrite = 0;
2856                         return 0;
2857                 }
2858                 interruptible_sleep_on(&j->write_q);
2859                 if (signal_pending(current)) {
2860                         set_current_state(TASK_RUNNING);
2861                         remove_wait_queue(&j->write_q, &wait);
2862                         j->flags.inwrite = 0;
2863                         return -EINTR;
2864                 }
2865         }
2866         set_current_state(TASK_RUNNING);
2867         remove_wait_queue(&j->write_q, &wait);
2868         if (j->write_buffer_wp + count >= j->write_buffer_end)
2869                 j->write_buffer_wp = j->write_buffer;
2870         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2871         if (i) {
2872                 j->flags.inwrite = 0;
2873                 return -EFAULT;
2874         }
2875        if(j->play_codec == ALAW)
2876                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2877         j->flags.inwrite = 0;
2878         return min(count, j->write_buffer_size);
2879 }
2880
2881 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2882 {
2883         int pre_retval;
2884         ssize_t write_retval = 0;
2885
2886         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2887
2888         pre_retval = ixj_PreWrite(j, 0L);
2889         switch (pre_retval) {
2890         case NORMAL:
2891                 write_retval = ixj_write(file_p, buf, count, ppos);
2892                 if (write_retval > 0) {
2893                         ixj_PostWrite(j, 0L);
2894                         j->write_buffer_wp += write_retval;
2895                         j->write_buffers_empty--;
2896                 }
2897                 break;
2898         case NOPOST:
2899                 write_retval = ixj_write(file_p, buf, count, ppos);
2900                 if (write_retval > 0) {
2901                         j->write_buffer_wp += write_retval;
2902                         j->write_buffers_empty--;
2903                 }
2904                 break;
2905         case POSTONLY:
2906                 ixj_PostWrite(j, 0L);
2907                 break;
2908         default:
2909                 write_retval = pre_retval;
2910         }
2911         return write_retval;
2912 }
2913
2914 static void ixj_read_frame(IXJ *j)
2915 {
2916         int cnt, dly;
2917
2918         if (j->read_buffer) {
2919                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2920                         if (!(cnt % 16) && !IsRxReady(j)) {
2921                                 dly = 0;
2922                                 while (!IsRxReady(j)) {
2923                                         if (dly++ > 5) {
2924                                                 dly = 0;
2925                                                 break;
2926                                         }
2927                                         udelay(10);
2928                                 }
2929                         }
2930                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2931                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2932                                 inb_p(j->DSPbase + 0x0E);
2933                                 inb_p(j->DSPbase + 0x0F);
2934                         }
2935                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2936                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2937                 }
2938                 ++j->framesread;
2939                 if (j->intercom != -1) {
2940                         if (IsTxReady(get_ixj(j->intercom))) {
2941                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2942                                         if (!(cnt % 16) && !IsTxReady(j)) {
2943                                                 dly = 0;
2944                                                 while (!IsTxReady(j)) {
2945                                                         if (dly++ > 5) {
2946                                                                 dly = 0;
2947                                                                 break;
2948                                                         }
2949                                                         udelay(10);
2950                                                 }
2951                                         }
2952                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2953                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2954                                 }
2955                                 get_ixj(j->intercom)->frameswritten++;
2956                         }
2957                 } else {
2958                         j->read_buffer_ready = 1;
2959                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2960
2961                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2962
2963                         if(j->ixj_signals[SIG_READ_READY])
2964                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2965                 }
2966         }
2967 }
2968
2969 static short fsk[][6][20] =
2970 {
2971         {
2972                 {
2973                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2974                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2975                 },
2976                 {
2977                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2978                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2979                 },
2980                 {
2981                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2982                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2983                 },
2984                 {
2985                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2986                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2987                 },
2988                 {
2989                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2990                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2991                 },
2992                 {
2993                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2994                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2995                 }
2996         },
2997         {
2998                 {
2999                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3000                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3001                 },
3002                 {
3003                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3004                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3005                 },
3006                 {
3007                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3008                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3009                 },
3010                 {
3011                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3012                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3013                 },
3014                 {
3015                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3016                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3017                 },
3018                 {
3019                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3020                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3021                 }
3022         }
3023 };
3024
3025
3026 static void ixj_write_cid_bit(IXJ *j, int bit)
3027 {
3028         while (j->fskcnt < 20) {
3029                 if(j->fskdcnt < (j->fsksize - 1))
3030                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3031
3032                 j->fskcnt += 3;
3033         }
3034         j->fskcnt %= 20;
3035
3036         if (!bit)
3037                 j->fskz++;
3038         if (j->fskz >= 6)
3039                 j->fskz = 0;
3040
3041 }
3042
3043 static void ixj_write_cid_byte(IXJ *j, char byte)
3044 {
3045         IXJ_CBYTE cb;
3046
3047                 cb.cbyte = byte;
3048                 ixj_write_cid_bit(j, 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3053                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3054                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3055                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3056                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3057                 ixj_write_cid_bit(j, 1);
3058 }
3059
3060 static void ixj_write_cid_seize(IXJ *j)
3061 {
3062         int cnt;
3063
3064         for (cnt = 0; cnt < 150; cnt++) {
3065                 ixj_write_cid_bit(j, 0);
3066                 ixj_write_cid_bit(j, 1);
3067         }
3068         for (cnt = 0; cnt < 180; cnt++) {
3069                 ixj_write_cid_bit(j, 1);
3070         }
3071 }
3072
3073 static void ixj_write_cidcw_seize(IXJ *j)
3074 {
3075         int cnt;
3076
3077         for (cnt = 0; cnt < 80; cnt++) {
3078                 ixj_write_cid_bit(j, 1);
3079         }
3080 }
3081
3082 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3083 {
3084         int cnt;
3085
3086         for (cnt = 0; cnt < strlen(s); cnt++) {
3087                 ixj_write_cid_byte(j, s[cnt]);
3088                 checksum = (checksum + s[cnt]);
3089         }
3090         return checksum;
3091 }
3092
3093 static void ixj_pad_fsk(IXJ *j, int pad)
3094 {
3095         int cnt;
3096
3097         for (cnt = 0; cnt < pad; cnt++) {
3098                 if(j->fskdcnt < (j->fsksize - 1))
3099                         j->fskdata[j->fskdcnt++] = 0x0000;
3100         }
3101         for (cnt = 0; cnt < 720; cnt++) {
3102                 if(j->fskdcnt < (j->fsksize - 1))
3103                         j->fskdata[j->fskdcnt++] = 0x0000;
3104         }
3105 }
3106
3107 static void ixj_pre_cid(IXJ *j)
3108 {
3109         j->cid_play_codec = j->play_codec;
3110         j->cid_play_frame_size = j->play_frame_size;
3111         j->cid_play_volume = get_play_volume(j);
3112         j->cid_play_flag = j->flags.playing;
3113
3114         j->cid_rec_codec = j->rec_codec;
3115         j->cid_rec_volume = get_rec_volume(j);
3116         j->cid_rec_flag = j->flags.recording;
3117
3118         j->cid_play_aec_level = j->aec_level;
3119
3120         switch(j->baseframe.low) {
3121                 case 0xA0:
3122                         j->cid_base_frame_size = 20;
3123                         break;
3124                 case 0x50:
3125                         j->cid_base_frame_size = 10;
3126                         break;
3127                 case 0xF0:
3128                         j->cid_base_frame_size = 30;
3129                         break;
3130         }
3131
3132         ixj_play_stop(j);
3133         ixj_cpt_stop(j);
3134
3135         j->flags.cidplay = 1;
3136
3137         set_base_frame(j, 30);
3138         set_play_codec(j, LINEAR16);
3139         set_play_volume(j, 0x1B);
3140         ixj_play_start(j);
3141 }
3142
3143 static void ixj_post_cid(IXJ *j)
3144 {
3145         ixj_play_stop(j);
3146
3147         if(j->cidsize > 5000) {
3148                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3149         }
3150         j->flags.cidplay = 0;
3151         if(ixjdebug & 0x0200) {
3152                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3153         }
3154
3155         ixj_fsk_free(j);
3156
3157         j->fskdcnt = 0;
3158         set_base_frame(j, j->cid_base_frame_size);
3159         set_play_codec(j, j->cid_play_codec);
3160         ixj_aec_start(j, j->cid_play_aec_level);
3161         set_play_volume(j, j->cid_play_volume);
3162
3163         set_rec_codec(j, j->cid_rec_codec);
3164         set_rec_volume(j, j->cid_rec_volume);
3165
3166         if(j->cid_rec_flag)
3167                 ixj_record_start(j);
3168
3169         if(j->cid_play_flag)
3170                 ixj_play_start(j);
3171
3172         if(j->cid_play_flag) {
3173                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3174         }
3175 }
3176
3177 static void ixj_write_cid(IXJ *j)
3178 {
3179         char sdmf1[50];
3180         char sdmf2[50];
3181         char sdmf3[80];
3182         char mdmflen, len1, len2, len3;
3183         int pad;
3184
3185         int checksum = 0;
3186
3187         if (j->dsp.low == 0x20 || j->flags.cidplay)
3188                 return;
3189
3190         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3191         j->cidsize = j->cidcnt = 0;
3192
3193         ixj_fsk_alloc(j);
3194
3195         strcpy(sdmf1, j->cid_send.month);
3196         strcat(sdmf1, j->cid_send.day);
3197         strcat(sdmf1, j->cid_send.hour);
3198         strcat(sdmf1, j->cid_send.min);
3199         strcpy(sdmf2, j->cid_send.number);
3200         strcpy(sdmf3, j->cid_send.name);
3201
3202         len1 = strlen(sdmf1);
3203         len2 = strlen(sdmf2);
3204         len3 = strlen(sdmf3);
3205         mdmflen = len1 + len2 + len3 + 6;
3206
3207         while(1){
3208                 ixj_write_cid_seize(j);
3209
3210                 ixj_write_cid_byte(j, 0x80);
3211                 checksum = 0x80;
3212                 ixj_write_cid_byte(j, mdmflen);
3213                 checksum = checksum + mdmflen;
3214
3215                 ixj_write_cid_byte(j, 0x01);
3216                 checksum = checksum + 0x01;
3217                 ixj_write_cid_byte(j, len1);
3218                 checksum = checksum + len1;
3219                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3220                 if(ixj_hookstate(j) & 1)
3221                         break;
3222
3223                 ixj_write_cid_byte(j, 0x02);
3224                 checksum = checksum + 0x02;
3225                 ixj_write_cid_byte(j, len2);
3226                 checksum = checksum + len2;
3227                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3228                 if(ixj_hookstate(j) & 1)
3229                         break;
3230
3231                 ixj_write_cid_byte(j, 0x07);
3232                 checksum = checksum + 0x07;
3233                 ixj_write_cid_byte(j, len3);
3234                 checksum = checksum + len3;
3235                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3236                 if(ixj_hookstate(j) & 1)
3237                         break;
3238
3239                 checksum %= 256;
3240                 checksum ^= 0xFF;
3241                 checksum += 1;
3242
3243                 ixj_write_cid_byte(j, (char) checksum);
3244
3245                 pad = j->fskdcnt % 240;
3246                 if (pad) {
3247                         pad = 240 - pad;
3248                 }
3249                 ixj_pad_fsk(j, pad);
3250                 break;
3251         }
3252
3253         ixj_write_frame(j);
3254 }
3255
3256 static void ixj_write_cidcw(IXJ *j)
3257 {
3258         IXJ_TONE ti;
3259
3260         char sdmf1[50];
3261         char sdmf2[50];
3262         char sdmf3[80];
3263         char mdmflen, len1, len2, len3;
3264         int pad;
3265
3266         int checksum = 0;
3267
3268         if (j->dsp.low == 0x20 || j->flags.cidplay)
3269                 return;
3270
3271         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3272         j->cidsize = j->cidcnt = 0;
3273
3274         ixj_fsk_alloc(j);
3275
3276         j->flags.cidcw_ack = 0;
3277
3278         ti.tone_index = 23;
3279         ti.gain0 = 1;
3280         ti.freq0 = hz440;
3281         ti.gain1 = 0;
3282         ti.freq1 = 0;
3283         ixj_init_tone(j, &ti);
3284
3285         ixj_set_tone_on(1500, j);
3286         ixj_set_tone_off(32, j);
3287         if(ixjdebug & 0x0200) {
3288                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3289         }
3290         ixj_play_tone(j, 23);
3291
3292         clear_bit(j->board, &j->busyflags);
3293         while(j->tone_state)
3294                 schedule_timeout_interruptible(1);
3295         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3296                 schedule_timeout_interruptible(1);
3297         if(ixjdebug & 0x0200) {
3298                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3299         }
3300
3301         ti.tone_index = 24;
3302         ti.gain0 = 1;
3303         ti.freq0 = hz2130;
3304         ti.gain1 = 0;
3305         ti.freq1 = hz2750;
3306         ixj_init_tone(j, &ti);
3307
3308         ixj_set_tone_off(10, j);
3309         ixj_set_tone_on(600, j);
3310         if(ixjdebug & 0x0200) {
3311                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3312         }
3313         ixj_play_tone(j, 24);
3314
3315         clear_bit(j->board, &j->busyflags);
3316         while(j->tone_state)
3317                 schedule_timeout_interruptible(1);
3318         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3319                 schedule_timeout_interruptible(1);
3320         if(ixjdebug & 0x0200) {
3321                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3322         }
3323
3324         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3325
3326         clear_bit(j->board, &j->busyflags);
3327         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3328                 schedule_timeout_interruptible(1);
3329         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3330                 schedule_timeout_interruptible(1);
3331         j->cidcw_wait = 0;
3332         if(!j->flags.cidcw_ack) {
3333                 if(ixjdebug & 0x0200) {
3334                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3335                 }
3336                 ixj_post_cid(j);
3337                 if(j->cid_play_flag) {
3338                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3339                 }
3340                 return;
3341         } else {
3342                 ixj_pre_cid(j);
3343         }
3344         j->flags.cidcw_ack = 0;
3345         strcpy(sdmf1, j->cid_send.month);
3346         strcat(sdmf1, j->cid_send.day);
3347         strcat(sdmf1, j->cid_send.hour);
3348         strcat(sdmf1, j->cid_send.min);
3349         strcpy(sdmf2, j->cid_send.number);
3350         strcpy(sdmf3, j->cid_send.name);
3351
3352         len1 = strlen(sdmf1);
3353         len2 = strlen(sdmf2);
3354         len3 = strlen(sdmf3);
3355         mdmflen = len1 + len2 + len3 + 6;
3356
3357         ixj_write_cidcw_seize(j);
3358
3359         ixj_write_cid_byte(j, 0x80);
3360         checksum = 0x80;
3361         ixj_write_cid_byte(j, mdmflen);
3362         checksum = checksum + mdmflen;
3363
3364         ixj_write_cid_byte(j, 0x01);
3365         checksum = checksum + 0x01;
3366         ixj_write_cid_byte(j, len1);
3367         checksum = checksum + len1;
3368         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3369
3370         ixj_write_cid_byte(j, 0x02);
3371         checksum = checksum + 0x02;
3372         ixj_write_cid_byte(j, len2);
3373         checksum = checksum + len2;
3374         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3375
3376         ixj_write_cid_byte(j, 0x07);
3377         checksum = checksum + 0x07;
3378         ixj_write_cid_byte(j, len3);
3379         checksum = checksum + len3;
3380         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3381
3382         checksum %= 256;
3383         checksum ^= 0xFF;
3384         checksum += 1;
3385
3386         ixj_write_cid_byte(j, (char) checksum);
3387
3388         pad = j->fskdcnt % 240;
3389         if (pad) {
3390                 pad = 240 - pad;
3391         }
3392         ixj_pad_fsk(j, pad);
3393         if(ixjdebug & 0x0200) {
3394                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3395         }
3396 }
3397
3398 static void ixj_write_vmwi(IXJ *j, int msg)
3399 {
3400         char mdmflen;
3401         int pad;
3402
3403         int checksum = 0;
3404
3405         if (j->dsp.low == 0x20 || j->flags.cidplay)
3406                 return;
3407
3408         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3409         j->cidsize = j->cidcnt = 0;
3410
3411         ixj_fsk_alloc(j);
3412
3413         mdmflen = 3;
3414
3415         if (j->port == PORT_POTS)
3416                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3417
3418         ixj_write_cid_seize(j);
3419
3420         ixj_write_cid_byte(j, 0x82);
3421         checksum = 0x82;
3422         ixj_write_cid_byte(j, mdmflen);
3423         checksum = checksum + mdmflen;
3424
3425         ixj_write_cid_byte(j, 0x0B);
3426         checksum = checksum + 0x0B;
3427         ixj_write_cid_byte(j, 1);
3428         checksum = checksum + 1;
3429
3430         if(msg) {
3431                 ixj_write_cid_byte(j, 0xFF);
3432                 checksum = checksum + 0xFF;
3433         }
3434         else {
3435                 ixj_write_cid_byte(j, 0x00);
3436                 checksum = checksum + 0x00;
3437         }
3438
3439         checksum %= 256;
3440         checksum ^= 0xFF;
3441         checksum += 1;
3442
3443         ixj_write_cid_byte(j, (char) checksum);
3444
3445         pad = j->fskdcnt % 240;
3446         if (pad) {
3447                 pad = 240 - pad;
3448         }
3449         ixj_pad_fsk(j, pad);
3450 }
3451
3452 static void ixj_write_frame(IXJ *j)
3453 {
3454         int cnt, frame_count, dly;
3455         IXJ_WORD dat;
3456         BYTES blankword;
3457
3458         frame_count = 0;
3459         if(j->flags.cidplay) {
3460                 for(cnt = 0; cnt < 480; cnt++) {
3461                         if (!(cnt % 16) && !IsTxReady(j)) {
3462                                 dly = 0;
3463                                 while (!IsTxReady(j)) {
3464                                         if (dly++ > 5) {
3465                                                 dly = 0;
3466                                                 break;
3467                                         }
3468                                         udelay(10);
3469                                 }
3470                         }
3471                         dat.word = j->fskdata[j->cidcnt++];
3472                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3473                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3474                         cnt++;
3475                 }
3476                 if(j->cidcnt >= j->fskdcnt) {
3477                         ixj_post_cid(j);
3478                 }
3479                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3480                    and there is real audio data in the buffer, we need to throw it away because
3481                    we just used it's time slot */
3482                 if (j->write_buffer_rp > j->write_buffer_wp) {
3483                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3484                         if (j->write_buffer_rp >= j->write_buffer_end) {
3485                                 j->write_buffer_rp = j->write_buffer;
3486                         }
3487                         j->write_buffers_empty++;
3488                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3489
3490                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3491                 }
3492         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3493                 if (j->write_buffer_wp > j->write_buffer_rp) {
3494                         frame_count =
3495                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3496                 }
3497                 if (j->write_buffer_rp > j->write_buffer_wp) {
3498                         frame_count =
3499                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3500                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3501                 }
3502                 if (frame_count >= 1) {
3503                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
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                                         blankword.low = blankword.high = 0x00;
3512                                         break;
3513                                 case PLAYBACK_MODE_8LINEAR_WSS:
3514                                         blankword.low = blankword.high = 0x80;
3515                                         break;
3516                                 }
3517                                 for (cnt = 0; cnt < 16; cnt++) {
3518                                         if (!(cnt % 16) && !IsTxReady(j)) {
3519                                                 dly = 0;
3520                                                 while (!IsTxReady(j)) {
3521                                                         if (dly++ > 5) {
3522                                                                 dly = 0;
3523                                                                 break;
3524                                                         }
3525                                                         udelay(10);
3526                                                 }
3527                                         }
3528                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3529                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3530                                 }
3531                                 j->flags.play_first_frame = 0;
3532                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3533                                 for (cnt = 0; cnt < 24; cnt++) {
3534                                         if(cnt == 12) {
3535                                                 blankword.low = 0x02;
3536                                                 blankword.high = 0x00;
3537                                         }
3538                                         else {
3539                                                 blankword.low = blankword.high = 0x00;
3540                                         }
3541                                         if (!(cnt % 16) && !IsTxReady(j)) {
3542                                                 dly = 0;
3543                                                 while (!IsTxReady(j)) {
3544                                                         if (dly++ > 5) {
3545                                                                 dly = 0;
3546                                                                 break;
3547                                                         }
3548                                                         udelay(10);
3549                                                 }
3550                                         }
3551                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3552                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3553                                 }
3554                                 j->flags.play_first_frame = 0;
3555                         }
3556                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3557                                 if (!(cnt % 16) && !IsTxReady(j)) {
3558                                         dly = 0;
3559                                         while (!IsTxReady(j)) {
3560                                                 if (dly++ > 5) {
3561                                                         dly = 0;
3562                                                         break;
3563                                                 }
3564                                                 udelay(10);
3565                                         }
3566                                 }
3567                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3568                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3569                                         if (j->write_buffer_rp[cnt] == 0 &&
3570                                             j->write_buffer_rp[cnt + 1] == 0 &&
3571                                             j->write_buffer_rp[cnt + 2] == 0 &&
3572                                             j->write_buffer_rp[cnt + 3] == 0 &&
3573                                             j->write_buffer_rp[cnt + 4] == 0 &&
3574                                             j->write_buffer_rp[cnt + 5] == 0 &&
3575                                             j->write_buffer_rp[cnt + 6] == 0 &&
3576                                             j->write_buffer_rp[cnt + 7] == 0 &&
3577                                             j->write_buffer_rp[cnt + 8] == 0 &&
3578                                             j->write_buffer_rp[cnt + 9] == 0) {
3579                                         /* someone is trying to write silence lets make this a type 0 frame. */
3580                                                 outb_p(0x00, j->DSPbase + 0x0C);
3581                                                 outb_p(0x00, j->DSPbase + 0x0D);
3582                                         } else {
3583                                         /* so all other frames are type 1. */
3584                                                 outb_p(0x01, j->DSPbase + 0x0C);
3585                                                 outb_p(0x00, j->DSPbase + 0x0D);
3586                                         }
3587                                 }
3588                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3589                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3590                                 *(j->write_buffer_rp + cnt) = 0;
3591                                 *(j->write_buffer_rp + cnt + 1) = 0;
3592                         }
3593                         j->write_buffer_rp += j->play_frame_size * 2;
3594                         if (j->write_buffer_rp >= j->write_buffer_end) {
3595                                 j->write_buffer_rp = j->write_buffer;
3596                         }
3597                         j->write_buffers_empty++;
3598                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3599
3600                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3601
3602                         ++j->frameswritten;
3603                 }
3604         } else {
3605                 j->drybuffer++;
3606         }
3607         if(j->ixj_signals[SIG_WRITE_READY]) {
3608                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3609         }
3610 }
3611
3612 static int idle(IXJ *j)
3613 {
3614         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3615
3616                 return 0;
3617
3618         if (j->ssr.high || j->ssr.low) {
3619                 return 0;
3620         } else {
3621                 j->play_mode = -1;
3622                 j->flags.playing = 0;
3623                 j->rec_mode = -1;
3624                 j->flags.recording = 0;
3625                 return 1;
3626         }
3627 }
3628
3629 static int set_base_frame(IXJ *j, int size)
3630 {
3631         unsigned short cmd;
3632         int cnt;
3633
3634         idle(j);
3635         j->cid_play_aec_level = j->aec_level;
3636         aec_stop(j);
3637         for (cnt = 0; cnt < 10; cnt++) {
3638                 if (idle(j))
3639                         break;
3640         }
3641         if (j->ssr.high || j->ssr.low)
3642                 return -1;
3643         if (j->dsp.low != 0x20) {
3644                 switch (size) {
3645                 case 30:
3646                         cmd = 0x07F0;
3647                         /* Set Base Frame Size to 240 pg9-10 8021 */
3648                         break;
3649                 case 20:
3650                         cmd = 0x07A0;
3651                         /* Set Base Frame Size to 160 pg9-10 8021 */
3652                         break;
3653                 case 10:
3654                         cmd = 0x0750;
3655                         /* Set Base Frame Size to 80 pg9-10 8021 */
3656                         break;
3657                 default:
3658                         return -1;
3659                 }
3660         } else {
3661                 if (size == 30)
3662                         return size;
3663                 else
3664                         return -1;
3665         }
3666         if (ixj_WriteDSPCommand(cmd, j)) {
3667                 j->baseframe.high = j->baseframe.low = 0xFF;
3668                 return -1;
3669         } else {
3670                 j->baseframe.high = j->ssr.high;
3671                 j->baseframe.low = j->ssr.low;
3672                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3673                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3674                         return -1;
3675                 }
3676         }
3677         ixj_aec_start(j, j->cid_play_aec_level);
3678         return size;
3679 }
3680
3681 static int set_rec_codec(IXJ *j, int rate)
3682 {
3683         int retval = 0;
3684
3685         j->rec_codec = rate;
3686
3687         switch (rate) {
3688         case G723_63:
3689                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3690                         j->rec_frame_size = 12;
3691                         j->rec_mode = 0;
3692                 } else {
3693                         retval = 1;
3694                 }
3695                 break;
3696         case G723_53:
3697                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3698                         j->rec_frame_size = 10;
3699                         j->rec_mode = 0;
3700                 } else {
3701                         retval = 1;
3702                 }
3703                 break;
3704         case TS85:
3705                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3706                         j->rec_frame_size = 16;
3707                         j->rec_mode = 0;
3708                 } else {
3709                         retval = 1;
3710                 }
3711                 break;
3712         case TS48:
3713                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3714                         j->rec_frame_size = 9;
3715                         j->rec_mode = 0;
3716                 } else {
3717                         retval = 1;
3718                 }
3719                 break;
3720         case TS41:
3721                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3722                         j->rec_frame_size = 8;
3723                         j->rec_mode = 0;
3724                 } else {
3725                         retval = 1;
3726                 }
3727                 break;
3728         case G728:
3729                 if (j->dsp.low != 0x20) {
3730                         j->rec_frame_size = 48;
3731                         j->rec_mode = 0;
3732                 } else {
3733                         retval = 1;
3734                 }
3735                 break;
3736         case G729:
3737                 if (j->dsp.low != 0x20) {
3738                         if (!j->flags.g729_loaded) {
3739                                 retval = 1;
3740                                 break;
3741                         }
3742                         switch (j->baseframe.low) {
3743                         case 0xA0:
3744                                 j->rec_frame_size = 10;
3745                                 break;
3746                         case 0x50:
3747                                 j->rec_frame_size = 5;
3748                                 break;
3749                         default:
3750                                 j->rec_frame_size = 15;
3751                                 break;
3752                         }
3753                         j->rec_mode = 0;
3754                 } else {
3755                         retval = 1;
3756                 }
3757                 break;
3758         case G729B:
3759                 if (j->dsp.low != 0x20) {
3760                         if (!j->flags.g729_loaded) {
3761                                 retval = 1;
3762                                 break;
3763                         }
3764                         switch (j->baseframe.low) {
3765                         case 0xA0:
3766                                 j->rec_frame_size = 12;
3767                                 break;
3768                         case 0x50:
3769                                 j->rec_frame_size = 6;
3770                                 break;
3771                         default:
3772                                 j->rec_frame_size = 18;
3773                                 break;
3774                         }
3775                         j->rec_mode = 0;
3776                 } else {
3777                         retval = 1;
3778                 }
3779                 break;
3780         case ULAW:
3781                 switch (j->baseframe.low) {
3782                 case 0xA0:
3783                         j->rec_frame_size = 80;
3784                         break;
3785                 case 0x50:
3786                         j->rec_frame_size = 40;
3787                         break;
3788                 default:
3789                         j->rec_frame_size = 120;
3790                         break;
3791                 }
3792                 j->rec_mode = 4;
3793                 break;
3794         case ALAW:
3795                 switch (j->baseframe.low) {
3796                 case 0xA0:
3797                         j->rec_frame_size = 80;
3798                         break;
3799                 case 0x50:
3800                         j->rec_frame_size = 40;
3801                         break;
3802                 default:
3803                         j->rec_frame_size = 120;
3804                         break;
3805                 }
3806                 j->rec_mode = 4;
3807                 break;
3808         case LINEAR16:
3809                 switch (j->baseframe.low) {
3810                 case 0xA0:
3811                         j->rec_frame_size = 160;
3812                         break;
3813                 case 0x50:
3814                         j->rec_frame_size = 80;
3815                         break;
3816                 default:
3817                         j->rec_frame_size = 240;
3818                         break;
3819                 }
3820                 j->rec_mode = 5;
3821                 break;
3822         case LINEAR8:
3823                 switch (j->baseframe.low) {
3824                 case 0xA0:
3825                         j->rec_frame_size = 80;
3826                         break;
3827                 case 0x50:
3828                         j->rec_frame_size = 40;
3829                         break;
3830                 default:
3831                         j->rec_frame_size = 120;
3832                         break;
3833                 }
3834                 j->rec_mode = 6;
3835                 break;
3836         case WSS:
3837                 switch (j->baseframe.low) {
3838                 case 0xA0:
3839                         j->rec_frame_size = 80;
3840                         break;
3841                 case 0x50:
3842                         j->rec_frame_size = 40;
3843                         break;
3844                 default:
3845                         j->rec_frame_size = 120;
3846                         break;
3847                 }
3848                 j->rec_mode = 7;
3849                 break;
3850         default:
3851                 kfree(j->read_buffer);
3852                 j->rec_frame_size = 0;
3853                 j->rec_mode = -1;
3854                 j->read_buffer = NULL;
3855                 j->read_buffer_size = 0;
3856                 retval = 1;
3857                 break;
3858         }
3859         return retval;
3860 }
3861
3862 static int ixj_record_start(IXJ *j)
3863 {
3864         unsigned short cmd = 0x0000;
3865
3866         if (j->read_buffer) {
3867                 ixj_record_stop(j);
3868         }
3869         j->flags.recording = 1;
3870         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3871
3872         if(ixjdebug & 0x0002)
3873                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3874
3875         if (!j->rec_mode) {
3876                 switch (j->rec_codec) {
3877                 case G723_63:
3878                         cmd = 0x5131;
3879                         break;
3880                 case G723_53:
3881                         cmd = 0x5132;
3882                         break;
3883                 case TS85:
3884                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3885
3886                         break;
3887                 case TS48:
3888                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3889
3890                         break;
3891                 case TS41:
3892                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3893
3894                         break;
3895                 case G728:
3896                         cmd = 0x5135;
3897                         break;
3898                 case G729:
3899                 case G729B:
3900                         cmd = 0x5136;
3901                         break;
3902                 default:
3903                         return 1;
3904                 }
3905                 if (ixj_WriteDSPCommand(cmd, j))
3906                         return -1;
3907         }
3908         if (!j->read_buffer) {
3909                 if (!j->read_buffer)
3910                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3911                 if (!j->read_buffer) {
3912                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3913                         return -ENOMEM;
3914                 }
3915         }
3916         j->read_buffer_size = j->rec_frame_size * 2;
3917
3918         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3919
3920                 return -1;
3921
3922         switch (j->rec_mode) {
3923         case 0:
3924                 cmd = 0x1C03;   /* Record C1 */
3925
3926                 break;
3927         case 4:
3928                 if (j->ver.low == 0x12) {
3929                         cmd = 0x1E03;   /* Record C1 */
3930
3931                 } else {
3932                         cmd = 0x1E01;   /* Record C1 */
3933
3934                 }
3935                 break;
3936         case 5:
3937                 if (j->ver.low == 0x12) {
3938                         cmd = 0x1E83;   /* Record C1 */
3939
3940                 } else {
3941                         cmd = 0x1E81;   /* Record C1 */
3942
3943                 }
3944                 break;
3945         case 6:
3946                 if (j->ver.low == 0x12) {
3947                         cmd = 0x1F03;   /* Record C1 */
3948
3949                 } else {
3950                         cmd = 0x1F01;   /* Record C1 */
3951
3952                 }
3953                 break;
3954         case 7:
3955                 if (j->ver.low == 0x12) {
3956                         cmd = 0x1F83;   /* Record C1 */
3957                 } else {
3958                         cmd = 0x1F81;   /* Record C1 */
3959                 }
3960                 break;
3961         }
3962         if (ixj_WriteDSPCommand(cmd, j))
3963                 return -1;
3964
3965         if (j->flags.playing) {
3966                 ixj_aec_start(j, j->aec_level);
3967         }
3968         return 0;
3969 }
3970
3971 static void ixj_record_stop(IXJ *j)
3972 {
3973         if (ixjdebug & 0x0002)
3974                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3975
3976         kfree(j->read_buffer);
3977         j->read_buffer = NULL;
3978         j->read_buffer_size = 0;
3979         if (j->rec_mode > -1) {
3980                 ixj_WriteDSPCommand(0x5120, j);
3981                 j->rec_mode = -1;
3982         }
3983         j->flags.recording = 0;
3984 }
3985 static void ixj_vad(IXJ *j, int arg)
3986 {
3987         if (arg)
3988                 ixj_WriteDSPCommand(0x513F, j);
3989         else
3990                 ixj_WriteDSPCommand(0x513E, j);
3991 }
3992
3993 static void set_rec_depth(IXJ *j, int depth)
3994 {
3995         if (depth > 60)
3996                 depth = 60;
3997         if (depth < 0)
3998                 depth = 0;
3999         ixj_WriteDSPCommand(0x5180 + depth, j);
4000 }
4001
4002 static void set_dtmf_prescale(IXJ *j, int volume)
4003 {
4004         ixj_WriteDSPCommand(0xCF07, j);
4005         ixj_WriteDSPCommand(volume, j);
4006 }
4007
4008 static int get_dtmf_prescale(IXJ *j)
4009 {
4010         ixj_WriteDSPCommand(0xCF05, j);
4011         return j->ssr.high << 8 | j->ssr.low;
4012 }
4013
4014 static void set_rec_volume(IXJ *j, int volume)
4015 {
4016         if(j->aec_level == AEC_AGC) {
4017                 if (ixjdebug & 0x0002)
4018                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4019                 ixj_WriteDSPCommand(0xCF96, j);
4020                 ixj_WriteDSPCommand(volume, j);
4021         } else {
4022                 if (ixjdebug & 0x0002)
4023                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4024                 ixj_WriteDSPCommand(0xCF03, j);
4025                 ixj_WriteDSPCommand(volume, j);
4026         }
4027 }
4028
4029 static int set_rec_volume_linear(IXJ *j, int volume)
4030 {
4031         int newvolume, dsprecmax;
4032
4033         if (ixjdebug & 0x0002)
4034                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4035         if(volume > 100 || volume < 0) {
4036           return -1;
4037         }
4038
4039         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4040         switch (j->cardtype) {
4041         case QTI_PHONEJACK:
4042                 dsprecmax = 0x440;
4043                 break;
4044         case QTI_LINEJACK:
4045                 dsprecmax = 0x180;
4046                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4047                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4048                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4049                 break;
4050         case QTI_PHONEJACK_LITE:
4051                 dsprecmax = 0x4C0;
4052                 break;
4053         case QTI_PHONEJACK_PCI:
4054                 dsprecmax = 0x100;
4055                 break;
4056         case QTI_PHONECARD:
4057                 dsprecmax = 0x400;
4058                 break;
4059         default:
4060                 return -1;
4061         }
4062         newvolume = (dsprecmax * volume) / 100;
4063         set_rec_volume(j, newvolume);
4064         return 0;
4065 }
4066
4067 static int get_rec_volume(IXJ *j)
4068 {
4069         if(j->aec_level == AEC_AGC) {
4070                 if (ixjdebug & 0x0002)
4071                         printk(KERN_INFO "Getting AGC Threshold\n");
4072                 ixj_WriteDSPCommand(0xCF86, j);
4073                 if (ixjdebug & 0x0002)
4074                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4075                 return j->ssr.high << 8 | j->ssr.low;
4076         } else {
4077                 if (ixjdebug & 0x0002)
4078                         printk(KERN_INFO "Getting Record Volume\n");
4079                 ixj_WriteDSPCommand(0xCF01, j);
4080                 return j->ssr.high << 8 | j->ssr.low;
4081         }
4082 }
4083
4084 static int get_rec_volume_linear(IXJ *j)
4085 {
4086         int volume, newvolume, dsprecmax;
4087
4088         switch (j->cardtype) {
4089         case QTI_PHONEJACK:
4090                 dsprecmax = 0x440;
4091                 break;
4092         case QTI_LINEJACK:
4093                 dsprecmax = 0x180;
4094                 break;
4095         case QTI_PHONEJACK_LITE:
4096                 dsprecmax = 0x4C0;
4097                 break;
4098         case QTI_PHONEJACK_PCI:
4099                 dsprecmax = 0x100;
4100                 break;
4101         case QTI_PHONECARD:
4102                 dsprecmax = 0x400;
4103                 break;
4104         default:
4105                 return -1;
4106         }
4107         volume = get_rec_volume(j);
4108         newvolume = (volume * 100) / dsprecmax;
4109         if(newvolume > 100)
4110                 newvolume = 100;
4111         return newvolume;
4112 }
4113
4114 static int get_rec_level(IXJ *j)
4115 {
4116         int retval;
4117
4118         ixj_WriteDSPCommand(0xCF88, j);
4119
4120         retval = j->ssr.high << 8 | j->ssr.low;
4121         retval = (retval * 256) / 240;
4122         return retval;
4123 }
4124
4125 static void ixj_aec_start(IXJ *j, int level)
4126 {
4127         j->aec_level = level;
4128         if (ixjdebug & 0x0002)
4129                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4130         if (!level) {
4131                 aec_stop(j);
4132         } else {
4133                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4134                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4135
4136                         ixj_WriteDSPCommand(0x0300, j);
4137                 }
4138                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4139
4140                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4141
4142                 switch (level) {
4143                 case AEC_LOW:
4144                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4145
4146                         ixj_WriteDSPCommand(0xE011, j);
4147                         ixj_WriteDSPCommand(0xFFFF, j);
4148
4149                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4150                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4151
4152                         break;
4153
4154                 case AEC_MED:
4155                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4156
4157                         ixj_WriteDSPCommand(0xE011, j);
4158                         ixj_WriteDSPCommand(0x0080, j);
4159
4160                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4161                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4162
4163                         break;
4164
4165                 case AEC_HIGH:
4166                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4167
4168                         ixj_WriteDSPCommand(0xE011, j);
4169                         ixj_WriteDSPCommand(0x0080, j);
4170
4171                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4172                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4173
4174                         break;
4175
4176                 case AEC_AGC:
4177                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4178                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4179
4180                         ixj_WriteDSPCommand(0xE011, j);
4181                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4182
4183                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4184
4185                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4186                                 ixj_WriteDSPCommand(0x0224, j);
4187                         else
4188                                 ixj_WriteDSPCommand(0x1224, j);
4189
4190                         ixj_WriteDSPCommand(0xE014, j);
4191                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4192
4193                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4194
4195                         /* Now we can set the AGC initial parameters and turn it on */
4196                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4197                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4198
4199                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4200                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4201
4202                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4203                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4204
4205                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4206                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4207
4208                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4209                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4210
4211                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4212                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4213
4214                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4215                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4216
4217                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4218                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4219
4220                         break;
4221
4222                 case AEC_AUTO:
4223                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4224
4225                         ixj_WriteDSPCommand(0xE011, j);
4226                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4227
4228                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4229
4230                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4231                                 ixj_WriteDSPCommand(0x0224, j);
4232                         else
4233                                 ixj_WriteDSPCommand(0x1224, j);
4234
4235                         ixj_WriteDSPCommand(0xE014, j);
4236                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4237
4238                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4239
4240                         break;
4241                 }
4242         }
4243 }
4244
4245 static void aec_stop(IXJ *j)
4246 {
4247         j->aec_level = AEC_OFF;
4248         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4249                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4250
4251                 ixj_WriteDSPCommand(0x0700, j);
4252         }
4253         if (j->play_mode != -1 && j->rec_mode != -1)
4254         {
4255                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4256         }
4257 }
4258
4259 static int set_play_codec(IXJ *j, int rate)
4260 {
4261         int retval = 0;
4262
4263         j->play_codec = rate;
4264
4265         switch (rate) {
4266         case G723_63:
4267                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4268                         j->play_frame_size = 12;
4269                         j->play_mode = 0;
4270                 } else {
4271                         retval = 1;
4272                 }
4273                 break;
4274         case G723_53:
4275                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4276                         j->play_frame_size = 10;
4277                         j->play_mode = 0;
4278                 } else {
4279                         retval = 1;
4280                 }
4281                 break;
4282         case TS85:
4283                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4284                         j->play_frame_size = 16;
4285                         j->play_mode = 0;
4286                 } else {
4287                         retval = 1;
4288                 }
4289                 break;
4290         case TS48:
4291                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4292                         j->play_frame_size = 9;
4293                         j->play_mode = 0;
4294                 } else {
4295                         retval = 1;
4296                 }
4297                 break;
4298         case TS41:
4299                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4300                         j->play_frame_size = 8;
4301                         j->play_mode = 0;
4302                 } else {
4303                         retval = 1;
4304                 }
4305                 break;
4306         case G728:
4307                 if (j->dsp.low != 0x20) {
4308                         j->play_frame_size = 48;
4309                         j->play_mode = 0;
4310                 } else {
4311                         retval = 1;
4312                 }
4313                 break;
4314         case G729:
4315                 if (j->dsp.low != 0x20) {
4316                         if (!j->flags.g729_loaded) {
4317                                 retval = 1;
4318                                 break;
4319                         }
4320                         switch (j->baseframe.low) {
4321                         case 0xA0:
4322                                 j->play_frame_size = 10;
4323                                 break;
4324                         case 0x50:
4325                                 j->play_frame_size = 5;
4326                                 break;
4327                         default:
4328                                 j->play_frame_size = 15;
4329                                 break;
4330                         }
4331                         j->play_mode = 0;
4332                 } else {
4333                         retval = 1;
4334                 }
4335                 break;
4336         case G729B:
4337                 if (j->dsp.low != 0x20) {
4338                         if (!j->flags.g729_loaded) {
4339                                 retval = 1;
4340                                 break;
4341                         }
4342                         switch (j->baseframe.low) {
4343                         case 0xA0:
4344                                 j->play_frame_size = 12;
4345                                 break;
4346                         case 0x50:
4347                                 j->play_frame_size = 6;
4348                                 break;
4349                         default:
4350                                 j->play_frame_size = 18;
4351                                 break;
4352                         }
4353                         j->play_mode = 0;
4354                 } else {
4355                         retval = 1;
4356                 }
4357                 break;
4358         case ULAW:
4359                 switch (j->baseframe.low) {
4360                 case 0xA0:
4361                         j->play_frame_size = 80;
4362                         break;
4363                 case 0x50:
4364                         j->play_frame_size = 40;
4365                         break;
4366                 default:
4367                         j->play_frame_size = 120;
4368                         break;
4369                 }
4370                 j->play_mode = 2;
4371                 break;
4372         case ALAW:
4373                 switch (j->baseframe.low) {
4374                 case 0xA0:
4375                         j->play_frame_size = 80;
4376                         break;
4377                 case 0x50:
4378                         j->play_frame_size = 40;
4379                         break;
4380                 default:
4381                         j->play_frame_size = 120;
4382                         break;
4383                 }
4384                 j->play_mode = 2;
4385                 break;
4386         case LINEAR16:
4387                 switch (j->baseframe.low) {
4388                 case 0xA0:
4389                         j->play_frame_size = 160;
4390                         break;
4391                 case 0x50:
4392                         j->play_frame_size = 80;
4393                         break;
4394                 default:
4395                         j->play_frame_size = 240;
4396                         break;
4397                 }
4398                 j->play_mode = 6;
4399                 break;
4400         case LINEAR8:
4401                 switch (j->baseframe.low) {
4402                 case 0xA0:
4403                         j->play_frame_size = 80;
4404                         break;
4405                 case 0x50:
4406                         j->play_frame_size = 40;
4407                         break;
4408                 default:
4409                         j->play_frame_size = 120;
4410                         break;
4411                 }
4412                 j->play_mode = 4;
4413                 break;
4414         case WSS:
4415                 switch (j->baseframe.low) {
4416                 case 0xA0:
4417                         j->play_frame_size = 80;
4418                         break;
4419                 case 0x50:
4420                         j->play_frame_size = 40;
4421                         break;
4422                 default:
4423                         j->play_frame_size = 120;
4424                         break;
4425                 }
4426                 j->play_mode = 5;
4427                 break;
4428         default:
4429                 kfree(j->write_buffer);
4430                 j->play_frame_size = 0;
4431                 j->play_mode = -1;
4432                 j->write_buffer = NULL;
4433                 j->write_buffer_size = 0;
4434                 retval = 1;
4435                 break;
4436         }
4437         return retval;
4438 }
4439
4440 static int ixj_play_start(IXJ *j)
4441 {
4442         unsigned short cmd = 0x0000;
4443
4444         if (j->write_buffer) {
4445                 ixj_play_stop(j);
4446         }
4447
4448         if(ixjdebug & 0x0002)
4449                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4450
4451         j->flags.playing = 1;
4452         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4453
4454         j->flags.play_first_frame = 1;
4455         j->drybuffer = 0;
4456
4457         if (!j->play_mode) {
4458                 switch (j->play_codec) {
4459                 case G723_63:
4460                         cmd = 0x5231;
4461                         break;
4462                 case G723_53:
4463                         cmd = 0x5232;
4464                         break;
4465                 case TS85:
4466                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4467
4468                         break;
4469                 case TS48:
4470                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4471
4472                         break;
4473                 case TS41:
4474                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4475
4476                         break;
4477                 case G728:
4478                         cmd = 0x5235;
4479                         break;
4480                 case G729:
4481                 case G729B:
4482                         cmd = 0x5236;
4483                         break;
4484                 default:
4485                         return 1;
4486                 }
4487                 if (ixj_WriteDSPCommand(cmd, j))
4488                         return -1;
4489         }
4490         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4491         if (!j->write_buffer) {
4492                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4493                 return -ENOMEM;
4494         }
4495 /*      j->write_buffers_empty = 2; */
4496         j->write_buffers_empty = 1;
4497         j->write_buffer_size = j->play_frame_size * 2;
4498         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4499         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4500
4501         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4502
4503                 return -1;
4504
4505         switch (j->play_mode) {
4506         case 0:
4507                 cmd = 0x2C03;
4508                 break;
4509         case 2:
4510                 if (j->ver.low == 0x12) {
4511                         cmd = 0x2C23;
4512                 } else {
4513                         cmd = 0x2C21;
4514                 }
4515                 break;
4516         case 4:
4517                 if (j->ver.low == 0x12) {
4518                         cmd = 0x2C43;
4519                 } else {
4520                         cmd = 0x2C41;
4521                 }
4522                 break;
4523         case 5:
4524                 if (j->ver.low == 0x12) {
4525                         cmd = 0x2C53;
4526                 } else {
4527                         cmd = 0x2C51;
4528                 }
4529                 break;
4530         case 6:
4531                 if (j->ver.low == 0x12) {
4532                         cmd = 0x2C63;
4533                 } else {
4534                         cmd = 0x2C61;
4535                 }
4536                 break;
4537         }
4538         if (ixj_WriteDSPCommand(cmd, j))
4539                 return -1;
4540
4541         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4542                 return -1;
4543
4544         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4545                 return -1;
4546
4547         if (j->flags.recording) {
4548                 ixj_aec_start(j, j->aec_level);
4549         }
4550
4551         return 0;
4552 }
4553
4554 static void ixj_play_stop(IXJ *j)
4555 {
4556         if (ixjdebug & 0x0002)
4557                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4558
4559         kfree(j->write_buffer);
4560         j->write_buffer = NULL;
4561         j->write_buffer_size = 0;
4562         if (j->play_mode > -1) {
4563                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4564
4565                 j->play_mode = -1;
4566         }
4567         j->flags.playing = 0;
4568 }
4569
4570 static inline int get_play_level(IXJ *j)
4571 {
4572         int retval;
4573
4574         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4575         return j->ssr.high << 8 | j->ssr.low;
4576         retval = j->ssr.high << 8 | j->ssr.low;
4577         retval = (retval * 256) / 240;
4578         return retval;
4579 }
4580
4581 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4582 {
4583         unsigned int mask = 0;
4584
4585         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4586
4587         poll_wait(file_p, &(j->poll_q), wait);
4588         if (j->read_buffer_ready > 0)
4589                 mask |= POLLIN | POLLRDNORM;    /* readable */
4590         if (j->write_buffers_empty > 0)
4591                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4592         if (j->ex.bytes)
4593                 mask |= POLLPRI;
4594         return mask;
4595 }
4596
4597 static int ixj_play_tone(IXJ *j, char tone)
4598 {
4599         if (!j->tone_state) {
4600                 if(ixjdebug & 0x0002) {
4601                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4602                 }
4603                 if (j->dsp.low == 0x20) {
4604                         idle(j);
4605                 }
4606                 j->tone_start_jif = jiffies;
4607
4608                 j->tone_state = 1;
4609         }
4610
4611         j->tone_index = tone;
4612         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4613                 return -1;
4614
4615         return 0;
4616 }
4617
4618 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4619 {
4620         j->tone_on_time = arg;
4621
4622         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4623
4624                 return -1;
4625
4626         if (ixj_WriteDSPCommand(arg, j))
4627                 return -1;
4628
4629         return 0;
4630 }
4631
4632 static int SCI_WaitHighSCI(IXJ *j)
4633 {
4634         int cnt;
4635
4636         j->pld_scrr.byte = inb_p(j->XILINXbase);
4637         if (!j->pld_scrr.bits.sci) {
4638                 for (cnt = 0; cnt < 10; cnt++) {
4639                         udelay(32);
4640                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4641
4642                         if ((j->pld_scrr.bits.sci))
4643                                 return 1;
4644                 }
4645                 if (ixjdebug & 0x0001)
4646                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4647                 return 0;
4648         } else
4649                 return 1;
4650 }
4651
4652 static int SCI_WaitLowSCI(IXJ *j)
4653 {
4654         int cnt;
4655
4656         j->pld_scrr.byte = inb_p(j->XILINXbase);
4657         if (j->pld_scrr.bits.sci) {
4658                 for (cnt = 0; cnt < 10; cnt++) {
4659                         udelay(32);
4660                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4661
4662                         if (!(j->pld_scrr.bits.sci))
4663                                 return 1;
4664                 }
4665                 if (ixjdebug & 0x0001)
4666                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4667                 return 0;
4668         } else
4669                 return 1;
4670 }
4671
4672 static int SCI_Control(IXJ *j, int control)
4673 {
4674         switch (control) {
4675         case SCI_End:
4676                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4677
4678                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4679
4680                 break;
4681         case SCI_Enable_DAA:
4682                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4683
4684                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4685
4686                 break;
4687         case SCI_Enable_Mixer:
4688                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4689
4690                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4691
4692                 break;
4693         case SCI_Enable_EEPROM:
4694                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4695
4696                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4697
4698                 break;
4699         default:
4700                 return 0;
4701                 break;
4702         }
4703         outb_p(j->pld_scrw.byte, j->XILINXbase);
4704
4705         switch (control) {
4706         case SCI_End:
4707                 return 1;
4708                 break;
4709         case SCI_Enable_DAA:
4710         case SCI_Enable_Mixer:
4711         case SCI_Enable_EEPROM:
4712                 if (!SCI_WaitHighSCI(j))
4713                         return 0;
4714                 break;
4715         default:
4716                 return 0;
4717                 break;
4718         }
4719         return 1;
4720 }
4721
4722 static int SCI_Prepare(IXJ *j)
4723 {
4724         if (!SCI_Control(j, SCI_End))
4725                 return 0;
4726
4727         if (!SCI_WaitLowSCI(j))
4728                 return 0;
4729
4730         return 1;
4731 }
4732
4733 static int ixj_get_mixer(long val, IXJ *j)
4734 {
4735         int reg = (val & 0x1F00) >> 8;
4736         return j->mix.vol[reg];
4737 }
4738
4739 static int ixj_mixer(long val, IXJ *j)
4740 {
4741         BYTES bytes;
4742
4743         bytes.high = (val & 0x1F00) >> 8;
4744         bytes.low = val & 0x00FF;
4745
4746         /* save mixer value so we can get back later on */
4747         j->mix.vol[bytes.high] = bytes.low;
4748
4749         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4750
4751         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4752
4753         SCI_Control(j, SCI_Enable_Mixer);
4754
4755         SCI_Control(j, SCI_End);
4756
4757         return 0;
4758 }
4759
4760 static int daa_load(BYTES * p_bytes, IXJ *j)
4761 {
4762         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4763         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4764         if (!SCI_Control(j, SCI_Enable_DAA))
4765                 return 0;
4766         else
4767                 return 1;
4768 }
4769
4770 static int ixj_daa_cr4(IXJ *j, char reg)
4771 {
4772         BYTES bytes;
4773
4774         switch (j->daa_mode) {
4775         case SOP_PU_SLEEP:
4776                 bytes.high = 0x14;
4777                 break;
4778         case SOP_PU_RINGING:
4779                 bytes.high = 0x54;
4780                 break;
4781         case SOP_PU_CONVERSATION:
4782                 bytes.high = 0x94;
4783                 break;
4784         case SOP_PU_PULSEDIALING:
4785                 bytes.high = 0xD4;
4786                 break;
4787         }
4788
4789         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4790
4791         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4792         case 0:
4793                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4794                 break;
4795         case 1:
4796                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4797                 break;
4798         case 2:
4799                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4800                 break;
4801         case 3:
4802                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4803                 break;
4804         }
4805
4806         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4807
4808         if (!daa_load(&bytes, j))
4809                 return 0;
4810
4811         if (!SCI_Prepare(j))
4812                 return 0;
4813
4814         return 1;
4815 }
4816
4817 static char daa_int_read(IXJ *j)
4818 {
4819         BYTES bytes;
4820
4821         if (!SCI_Prepare(j))
4822                 return 0;
4823
4824         bytes.high = 0x38;
4825         bytes.low = 0x00;
4826         outb_p(bytes.high, j->XILINXbase + 0x03);
4827         outb_p(bytes.low, j->XILINXbase + 0x02);
4828
4829         if (!SCI_Control(j, SCI_Enable_DAA))
4830                 return 0;
4831
4832         bytes.high = inb_p(j->XILINXbase + 0x03);
4833         bytes.low = inb_p(j->XILINXbase + 0x02);
4834         if (bytes.low != ALISDAA_ID_BYTE) {
4835                 if (ixjdebug & 0x0001)
4836                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4837                 return 0;
4838         }
4839         if (!SCI_Control(j, SCI_Enable_DAA))
4840                 return 0;
4841         if (!SCI_Control(j, SCI_End))
4842                 return 0;
4843
4844         bytes.high = inb_p(j->XILINXbase + 0x03);
4845         bytes.low = inb_p(j->XILINXbase + 0x02);
4846
4847         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4848
4849         return 1;
4850 }
4851
4852 static char daa_CR_read(IXJ *j, int cr)
4853 {
4854         IXJ_WORD wdata;
4855         BYTES bytes;
4856
4857         if (!SCI_Prepare(j))
4858                 return 0;
4859
4860         switch (j->daa_mode) {
4861         case SOP_PU_SLEEP:
4862                 bytes.high = 0x30 + cr;
4863                 break;
4864         case SOP_PU_RINGING:
4865                 bytes.high = 0x70 + cr;
4866                 break;
4867         case SOP_PU_CONVERSATION:
4868                 bytes.high = 0xB0 + cr;
4869                 break;
4870         case SOP_PU_PULSEDIALING:
4871                 bytes.high = 0xF0 + cr;
4872                 break;
4873         }
4874
4875         bytes.low = 0x00;
4876
4877         outb_p(bytes.high, j->XILINXbase + 0x03);
4878         outb_p(bytes.low, j->XILINXbase + 0x02);
4879
4880         if (!SCI_Control(j, SCI_Enable_DAA))
4881                 return 0;
4882
4883         bytes.high = inb_p(j->XILINXbase + 0x03);
4884         bytes.low = inb_p(j->XILINXbase + 0x02);
4885         if (bytes.low != ALISDAA_ID_BYTE) {
4886                 if (ixjdebug & 0x0001)
4887                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4888                 return 0;
4889         }
4890         if (!SCI_Control(j, SCI_Enable_DAA))
4891                 return 0;
4892         if (!SCI_Control(j, SCI_End))
4893                 return 0;
4894
4895         wdata.word = inw_p(j->XILINXbase + 0x02);
4896
4897         switch(cr){
4898                 case 5:
4899                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4900                         break;
4901                 case 4:
4902                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4903                         break;
4904                 case 3:
4905                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4906                         break;
4907                 case 2:
4908                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4909                         break;
4910                 case 1:
4911                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4912                         break;
4913                 case 0:
4914                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4915                         break;
4916                 default:
4917                         return 0;
4918         }
4919         return 1;
4920 }
4921
4922 static int ixj_daa_cid_reset(IXJ *j)
4923 {
4924         int i;
4925         BYTES bytes;
4926
4927         if (ixjdebug & 0x0002)
4928                 printk("DAA Clearing CID ram\n");
4929
4930         if (!SCI_Prepare(j))
4931                 return 0;
4932
4933         bytes.high = 0x58;
4934         bytes.low = 0x00;
4935         outb_p(bytes.high, j->XILINXbase + 0x03);
4936         outb_p(bytes.low, j->XILINXbase + 0x02);
4937
4938         if (!SCI_Control(j, SCI_Enable_DAA))
4939                 return 0;
4940
4941         if (!SCI_WaitHighSCI(j))
4942                 return 0;
4943
4944         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4945                 bytes.high = bytes.low = 0x00;
4946                 outb_p(bytes.high, j->XILINXbase + 0x03);
4947
4948                 if (i < ALISDAA_CALLERID_SIZE - 1)
4949                         outb_p(bytes.low, j->XILINXbase + 0x02);
4950
4951                 if (!SCI_Control(j, SCI_Enable_DAA))
4952                         return 0;
4953
4954                 if (!SCI_WaitHighSCI(j))
4955                         return 0;
4956
4957         }
4958
4959         if (!SCI_Control(j, SCI_End))
4960                 return 0;
4961
4962         if (ixjdebug & 0x0002)
4963                 printk("DAA CID ram cleared\n");
4964
4965         return 1;
4966 }
4967
4968 static int ixj_daa_cid_read(IXJ *j)
4969 {
4970         int i;
4971         BYTES bytes;
4972         char CID[ALISDAA_CALLERID_SIZE], mContinue;
4973         char *pIn, *pOut;
4974
4975         if (!SCI_Prepare(j))
4976                 return 0;
4977
4978         bytes.high = 0x78;
4979         bytes.low = 0x00;
4980         outb_p(bytes.high, j->XILINXbase + 0x03);
4981         outb_p(bytes.low, j->XILINXbase + 0x02);
4982
4983         if (!SCI_Control(j, SCI_Enable_DAA))
4984                 return 0;
4985
4986         if (!SCI_WaitHighSCI(j))
4987                 return 0;
4988
4989         bytes.high = inb_p(j->XILINXbase + 0x03);
4990         bytes.low = inb_p(j->XILINXbase + 0x02);
4991         if (bytes.low != ALISDAA_ID_BYTE) {
4992                 if (ixjdebug & 0x0001)
4993                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4994                 return 0;
4995         }
4996         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
4997                 bytes.high = bytes.low = 0x00;
4998                 outb_p(bytes.high, j->XILINXbase + 0x03);
4999                 outb_p(bytes.low, j->XILINXbase + 0x02);
5000
5001                 if (!SCI_Control(j, SCI_Enable_DAA))
5002                         return 0;
5003
5004                 if (!SCI_WaitHighSCI(j))
5005                         return 0;
5006
5007                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5008                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5009         }
5010
5011         if (!SCI_Control(j, SCI_End))
5012                 return 0;
5013
5014         pIn = CID;
5015         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5016         mContinue = 1;
5017         while (mContinue) {
5018                 if ((pIn[1] & 0x03) == 0x01) {
5019                         pOut[0] = pIn[0];
5020                 }
5021                 if ((pIn[2] & 0x0c) == 0x04) {
5022                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5023                 }
5024                 if ((pIn[3] & 0x30) == 0x10) {
5025                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5026                 }
5027                 if ((pIn[4] & 0xc0) == 0x40) {
5028                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5029                 } else {
5030                         mContinue = FALSE;
5031                 }
5032                 pIn += 5, pOut += 4;
5033         }
5034         memset(&j->cid, 0, sizeof(PHONE_CID));
5035         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5036         pOut += 4;
5037         strncpy(j->cid.month, pOut, 2);
5038         pOut += 2;
5039         strncpy(j->cid.day, pOut, 2);
5040         pOut += 2;
5041         strncpy(j->cid.hour, pOut, 2);
5042         pOut += 2;
5043         strncpy(j->cid.min, pOut, 2);
5044         pOut += 3;
5045         j->cid.numlen = *pOut;
5046         pOut += 1;
5047         strncpy(j->cid.number, pOut, j->cid.numlen);
5048         pOut += j->cid.numlen + 1;
5049         j->cid.namelen = *pOut;
5050         pOut += 1;
5051         strncpy(j->cid.name, pOut, j->cid.namelen);
5052
5053         ixj_daa_cid_reset(j);
5054         return 1;
5055 }
5056
5057 static char daa_get_version(IXJ *j)
5058 {
5059         BYTES bytes;
5060
5061         if (!SCI_Prepare(j))
5062                 return 0;
5063
5064         bytes.high = 0x35;
5065         bytes.low = 0x00;
5066         outb_p(bytes.high, j->XILINXbase + 0x03);
5067         outb_p(bytes.low, j->XILINXbase + 0x02);
5068
5069         if (!SCI_Control(j, SCI_Enable_DAA))
5070                 return 0;
5071
5072         bytes.high = inb_p(j->XILINXbase + 0x03);
5073         bytes.low = inb_p(j->XILINXbase + 0x02);
5074         if (bytes.low != ALISDAA_ID_BYTE) {
5075                 if (ixjdebug & 0x0001)
5076                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5077                 return 0;
5078         }
5079         if (!SCI_Control(j, SCI_Enable_DAA))
5080                 return 0;
5081
5082         if (!SCI_Control(j, SCI_End))
5083                 return 0;
5084
5085         bytes.high = inb_p(j->XILINXbase + 0x03);
5086         bytes.low = inb_p(j->XILINXbase + 0x02);
5087         if (ixjdebug & 0x0002)
5088                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5089         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5090         return bytes.high;
5091 }
5092
5093 static int daa_set_mode(IXJ *j, int mode)
5094 {
5095         /* NOTE:
5096               The DAA *MUST* be in the conversation mode if the
5097               PSTN line is to be seized (PSTN line off-hook).
5098               Taking the PSTN line off-hook while the DAA is in
5099               a mode other than conversation mode will cause a
5100               hardware failure of the ALIS-A part.
5101
5102            NOTE:
5103               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5104               if the PSTN line is on-hook.  Failure to have the PSTN line
5105               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5106               ALIS-A part.
5107         */
5108
5109         BYTES bytes;
5110
5111         j->flags.pstn_rmr = 0;
5112
5113         if (!SCI_Prepare(j))
5114                 return 0;
5115
5116         switch (mode) {
5117         case SOP_PU_RESET:
5118                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5119
5120                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5121                 j->pld_slicw.bits.rly2 = 0;
5122                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5123                 bytes.high = 0x10;
5124                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5125                 daa_load(&bytes, j);
5126                 if (!SCI_Prepare(j))
5127                         return 0;
5128
5129                 j->daa_mode = SOP_PU_SLEEP;
5130                 break;
5131         case SOP_PU_SLEEP:
5132                 if(j->daa_mode == SOP_PU_SLEEP)
5133                 {
5134                         break;
5135                 }
5136                 if (ixjdebug & 0x0008)
5137                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5138 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5139                 {
5140                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5141
5142                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5143                         j->pld_slicw.bits.rly2 = 0;
5144                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5145                         bytes.high = 0x10;
5146                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5147                         daa_load(&bytes, j);
5148                         if (!SCI_Prepare(j))
5149                                 return 0;
5150                 }
5151                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5152
5153                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5154                 j->pld_slicw.bits.rly2 = 0;
5155                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5156                 bytes.high = 0x10;
5157                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5158                 daa_load(&bytes, j);
5159                 if (!SCI_Prepare(j))
5160                         return 0;
5161
5162                 j->daa_mode = SOP_PU_SLEEP;
5163                 j->flags.pstn_ringing = 0;
5164                 j->ex.bits.pstn_ring = 0;
5165                 j->pstn_sleeptil = jiffies + (hertz / 4);
5166                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5167                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5168                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5169                 break;
5170         case SOP_PU_RINGING:
5171                 if (ixjdebug & 0x0008)
5172                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5173                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5174
5175                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5176                 j->pld_slicw.bits.rly2 = 0;
5177                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5178                 bytes.high = 0x50;
5179                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5180                 daa_load(&bytes, j);
5181                 if (!SCI_Prepare(j))
5182                         return 0;
5183                 j->daa_mode = SOP_PU_RINGING;
5184                 break;
5185         case SOP_PU_CONVERSATION:
5186                 if (ixjdebug & 0x0008)
5187                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5188                 bytes.high = 0x90;
5189                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5190                 daa_load(&bytes, j);
5191                 if (!SCI_Prepare(j))
5192                         return 0;
5193                 j->pld_slicw.bits.rly2 = 1;
5194                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5195                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5196
5197                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5198                 j->daa_mode = SOP_PU_CONVERSATION;
5199                 j->flags.pstn_ringing = 0;
5200                 j->ex.bits.pstn_ring = 0;
5201                 j->pstn_sleeptil = jiffies;
5202                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5203                 break;
5204         case SOP_PU_PULSEDIALING:
5205                 if (ixjdebug & 0x0008)
5206                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5207                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5208
5209                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5210                 j->pld_slicw.bits.rly2 = 0;
5211                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5212                 bytes.high = 0xD0;
5213                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5214                 daa_load(&bytes, j);
5215                 if (!SCI_Prepare(j))
5216                         return 0;
5217                 j->daa_mode = SOP_PU_PULSEDIALING;
5218                 break;
5219         default:
5220                 break;
5221         }
5222         return 1;
5223 }
5224
5225 static int ixj_daa_write(IXJ *j)
5226 {
5227         BYTES bytes;
5228
5229         j->flags.pstncheck = 1;
5230
5231         daa_set_mode(j, SOP_PU_SLEEP);
5232
5233         if (!SCI_Prepare(j))
5234                 return 0;
5235
5236         outb_p(j->pld_scrw.byte, j->XILINXbase);
5237
5238         bytes.high = 0x14;
5239         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5240         if (!daa_load(&bytes, j))
5241                 return 0;
5242
5243         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5244         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5245         if (!daa_load(&bytes, j))
5246                 return 0;
5247
5248         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5249         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5250         if (!daa_load(&bytes, j))
5251                 return 0;
5252
5253         if (!SCI_Prepare(j))
5254                 return 0;
5255
5256         bytes.high = 0x1F;
5257         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5258         if (!daa_load(&bytes, j))
5259                 return 0;
5260
5261         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5262         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5263         if (!daa_load(&bytes, j))
5264                 return 0;
5265
5266         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5267         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5268         if (!daa_load(&bytes, j))
5269                 return 0;
5270
5271         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5272         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5273         if (!daa_load(&bytes, j))
5274                 return 0;
5275
5276         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5277         bytes.low = 0x00;
5278         if (!daa_load(&bytes, j))
5279                 return 0;
5280
5281         if (!SCI_Prepare(j))
5282                 return 0;
5283
5284         bytes.high = 0x00;
5285         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5286         if (!daa_load(&bytes, j))
5287                 return 0;
5288
5289         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5290         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5291         if (!daa_load(&bytes, j))
5292                 return 0;
5293
5294         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5295         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5296         if (!daa_load(&bytes, j))
5297                 return 0;
5298
5299         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5300         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5301         if (!daa_load(&bytes, j))
5302                 return 0;
5303
5304         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5305         bytes.low = 0x00;
5306         if (!daa_load(&bytes, j))
5307                 return 0;
5308
5309         if (!SCI_Control(j, SCI_End))
5310                 return 0;
5311         if (!SCI_WaitLowSCI(j))
5312                 return 0;
5313
5314         bytes.high = 0x01;
5315         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5316         if (!daa_load(&bytes, j))
5317                 return 0;
5318
5319         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5320         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5321         if (!daa_load(&bytes, j))
5322                 return 0;
5323
5324         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5325         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5326         if (!daa_load(&bytes, j))
5327                 return 0;
5328
5329         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5330         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5331         if (!daa_load(&bytes, j))
5332                 return 0;
5333
5334         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5335         bytes.low = 0x00;
5336         if (!daa_load(&bytes, j))
5337                 return 0;
5338
5339         if (!SCI_Control(j, SCI_End))
5340                 return 0;
5341         if (!SCI_WaitLowSCI(j))
5342                 return 0;
5343
5344         bytes.high = 0x02;
5345         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5346         if (!daa_load(&bytes, j))
5347                 return 0;
5348
5349         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5350         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5351         if (!daa_load(&bytes, j))
5352                 return 0;
5353
5354         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5355         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5356         if (!daa_load(&bytes, j))
5357                 return 0;
5358
5359         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5360         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5361         if (!daa_load(&bytes, j))
5362                 return 0;
5363
5364         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5365         bytes.low = 0x00;
5366         if (!daa_load(&bytes, j))
5367                 return 0;
5368
5369         if (!SCI_Control(j, SCI_End))
5370                 return 0;
5371         if (!SCI_WaitLowSCI(j))
5372                 return 0;
5373
5374         bytes.high = 0x03;
5375         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5376         if (!daa_load(&bytes, j))
5377                 return 0;
5378
5379         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5380         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5381         if (!daa_load(&bytes, j))
5382                 return 0;
5383
5384         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5385         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5386         if (!daa_load(&bytes, j))
5387                 return 0;
5388
5389         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5390         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5391         if (!daa_load(&bytes, j))
5392                 return 0;
5393
5394         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5395         bytes.low = 0x00;
5396         if (!daa_load(&bytes, j))
5397                 return 0;
5398
5399         if (!SCI_Control(j, SCI_End))
5400                 return 0;
5401         if (!SCI_WaitLowSCI(j))
5402                 return 0;
5403
5404         bytes.high = 0x04;
5405         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5406         if (!daa_load(&bytes, j))
5407                 return 0;
5408
5409         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5410         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5411         if (!daa_load(&bytes, j))
5412                 return 0;
5413
5414         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5415         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5416         if (!daa_load(&bytes, j))
5417                 return 0;
5418
5419         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5420         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5421         if (!daa_load(&bytes, j))
5422                 return 0;
5423
5424         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5425         bytes.low = 0x00;
5426         if (!daa_load(&bytes, j))
5427                 return 0;
5428
5429         if (!SCI_Control(j, SCI_End))
5430                 return 0;
5431         if (!SCI_WaitLowSCI(j))
5432                 return 0;
5433
5434         bytes.high = 0x05;
5435         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5436         if (!daa_load(&bytes, j))
5437                 return 0;
5438
5439         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5440         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5441         if (!daa_load(&bytes, j))
5442                 return 0;
5443
5444         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5445         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5446         if (!daa_load(&bytes, j))
5447                 return 0;
5448
5449         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5450         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5451         if (!daa_load(&bytes, j))
5452                 return 0;
5453
5454         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5455         bytes.low = 0x00;
5456         if (!daa_load(&bytes, j))
5457                 return 0;
5458
5459         if (!SCI_Control(j, SCI_End))
5460                 return 0;
5461         if (!SCI_WaitLowSCI(j))
5462                 return 0;
5463
5464         bytes.high = 0x06;
5465         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5466         if (!daa_load(&bytes, j))
5467                 return 0;
5468
5469         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5470         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5471         if (!daa_load(&bytes, j))
5472                 return 0;
5473
5474         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5475         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5476         if (!daa_load(&bytes, j))
5477                 return 0;
5478
5479         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5480         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5481         if (!daa_load(&bytes, j))
5482                 return 0;
5483
5484         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5485         bytes.low = 0x00;
5486         if (!daa_load(&bytes, j))
5487                 return 0;
5488
5489         if (!SCI_Control(j, SCI_End))
5490                 return 0;
5491         if (!SCI_WaitLowSCI(j))
5492                 return 0;
5493
5494         bytes.high = 0x07;
5495         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5496         if (!daa_load(&bytes, j))
5497                 return 0;
5498
5499         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5500         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5501         if (!daa_load(&bytes, j))
5502                 return 0;
5503
5504         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5505         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5506         if (!daa_load(&bytes, j))
5507                 return 0;
5508
5509         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5510         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5511         if (!daa_load(&bytes, j))
5512                 return 0;
5513
5514         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5515         bytes.low = 0x00;
5516         if (!daa_load(&bytes, j))
5517                 return 0;
5518
5519         if (!SCI_Control(j, SCI_End))
5520                 return 0;
5521         if (!SCI_WaitLowSCI(j))
5522                 return 0;
5523
5524         bytes.high = 0x08;
5525         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5526         if (!daa_load(&bytes, j))
5527                 return 0;
5528
5529         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5530         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5531         if (!daa_load(&bytes, j))
5532                 return 0;
5533
5534         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5535         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5536         if (!daa_load(&bytes, j))
5537                 return 0;
5538
5539         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5540         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5541         if (!daa_load(&bytes, j))
5542                 return 0;
5543
5544         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5545         bytes.low = 0x00;
5546         if (!daa_load(&bytes, j))
5547                 return 0;
5548
5549         if (!SCI_Control(j, SCI_End))
5550                 return 0;
5551         if (!SCI_WaitLowSCI(j))
5552                 return 0;
5553
5554         bytes.high = 0x09;
5555         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5556         if (!daa_load(&bytes, j))
5557                 return 0;
5558
5559         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5560         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5561         if (!daa_load(&bytes, j))
5562                 return 0;
5563
5564         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5565         bytes.low = 0x00;
5566         if (!daa_load(&bytes, j))
5567                 return 0;
5568
5569         if (!SCI_Control(j, SCI_End))
5570                 return 0;
5571         if (!SCI_WaitLowSCI(j))
5572                 return 0;
5573
5574         bytes.high = 0x0A;
5575         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5576         if (!daa_load(&bytes, j))
5577                 return 0;
5578
5579         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5580         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5581         if (!daa_load(&bytes, j))
5582                 return 0;
5583
5584         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5585         bytes.low = 0x00;
5586         if (!daa_load(&bytes, j))
5587                 return 0;
5588
5589         if (!SCI_Control(j, SCI_End))
5590                 return 0;
5591         if (!SCI_WaitLowSCI(j))
5592                 return 0;
5593
5594         bytes.high = 0x0B;
5595         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5596         if (!daa_load(&bytes, j))
5597                 return 0;
5598
5599         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5600         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5601         if (!daa_load(&bytes, j))
5602                 return 0;
5603
5604         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5605         bytes.low = 0x00;
5606         if (!daa_load(&bytes, j))
5607                 return 0;
5608
5609         if (!SCI_Control(j, SCI_End))
5610                 return 0;
5611         if (!SCI_WaitLowSCI(j))
5612                 return 0;
5613
5614         bytes.high = 0x0C;
5615         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5616         if (!daa_load(&bytes, j))
5617                 return 0;
5618
5619         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5620         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5621         if (!daa_load(&bytes, j))
5622                 return 0;
5623
5624         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5625         bytes.low = 0x00;
5626         if (!daa_load(&bytes, j))
5627                 return 0;
5628
5629         if (!SCI_Control(j, SCI_End))
5630                 return 0;
5631         if (!SCI_WaitLowSCI(j))
5632                 return 0;
5633
5634         bytes.high = 0x0D;
5635         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5636         if (!daa_load(&bytes, j))
5637                 return 0;
5638
5639         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5640         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5641         if (!daa_load(&bytes, j))
5642                 return 0;
5643
5644         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5645         bytes.low = 0x00;
5646         if (!daa_load(&bytes, j))
5647                 return 0;
5648
5649         if (!SCI_Control(j, SCI_End))
5650                 return 0;
5651         if (!SCI_WaitLowSCI(j))
5652                 return 0;
5653
5654         bytes.high = 0x0E;
5655         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5656         if (!daa_load(&bytes, j))
5657                 return 0;
5658
5659         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5660         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5661         if (!daa_load(&bytes, j))
5662                 return 0;
5663
5664         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5665         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5666         if (!daa_load(&bytes, j))
5667                 return 0;
5668
5669         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5670         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5671         if (!daa_load(&bytes, j))
5672                 return 0;
5673
5674         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5675         bytes.low = 0x00;
5676         if (!daa_load(&bytes, j))
5677                 return 0;
5678
5679         if (!SCI_Control(j, SCI_End))
5680                 return 0;
5681         if (!SCI_WaitLowSCI(j))
5682                 return 0;
5683
5684         bytes.high = 0x0F;
5685         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5686         if (!daa_load(&bytes, j))
5687                 return 0;
5688
5689         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5690         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5691         if (!daa_load(&bytes, j))
5692                 return 0;
5693
5694         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5695         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5696         if (!daa_load(&bytes, j))
5697                 return 0;
5698
5699         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5700         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5701         if (!daa_load(&bytes, j))
5702                 return 0;
5703
5704         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5705         bytes.low = 0x00;
5706         if (!daa_load(&bytes, j))
5707                 return 0;
5708
5709         udelay(32);
5710         j->pld_scrr.byte = inb_p(j->XILINXbase);
5711         if (!SCI_Control(j, SCI_End))
5712                 return 0;
5713
5714         outb_p(j->pld_scrw.byte, j->XILINXbase);
5715
5716         if (ixjdebug & 0x0002)
5717                 printk("DAA Coefficients Loaded\n");
5718
5719         j->flags.pstncheck = 0;
5720         return 1;
5721 }
5722
5723 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5724 {
5725         j->tone_off_time = arg;
5726         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5727
5728                 return -1;
5729         if (ixj_WriteDSPCommand(arg, j))
5730                 return -1;
5731         return 0;
5732 }
5733
5734 static int ixj_get_tone_on(IXJ *j)
5735 {
5736         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5737
5738                 return -1;
5739         return 0;
5740 }
5741
5742 static int ixj_get_tone_off(IXJ *j)
5743 {
5744         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5745
5746                 return -1;
5747         return 0;
5748 }
5749
5750 static void ixj_busytone(IXJ *j)
5751 {
5752         j->flags.ringback = 0;
5753         j->flags.dialtone = 0;
5754         j->flags.busytone = 1;
5755         ixj_set_tone_on(0x07D0, j);
5756         ixj_set_tone_off(0x07D0, j);
5757         ixj_play_tone(j, 27);
5758 }
5759
5760 static void ixj_dialtone(IXJ *j)
5761 {
5762         j->flags.ringback = 0;
5763         j->flags.dialtone = 1;
5764         j->flags.busytone = 0;
5765         if (j->dsp.low == 0x20) {
5766                 return;
5767         } else {
5768                 ixj_set_tone_on(0xFFFF, j);
5769                 ixj_set_tone_off(0x0000, j);
5770                 ixj_play_tone(j, 25);
5771         }
5772 }
5773
5774 static void ixj_cpt_stop(IXJ *j)
5775 {
5776         if(j->tone_state || j->tone_cadence_state)
5777         {
5778                 j->flags.dialtone = 0;
5779                 j->flags.busytone = 0;
5780                 j->flags.ringback = 0;
5781                 ixj_set_tone_on(0x0001, j);
5782                 ixj_set_tone_off(0x0000, j);
5783                 ixj_play_tone(j, 0);
5784                 j->tone_state = j->tone_cadence_state = 0;
5785                 if (j->cadence_t) {
5786                         kfree(j->cadence_t->ce);
5787                         kfree(j->cadence_t);
5788                         j->cadence_t = NULL;
5789                 }
5790         }
5791         if (j->play_mode == -1 && j->rec_mode == -1)
5792                 idle(j);
5793         if (j->play_mode != -1 && j->dsp.low == 0x20)
5794                 ixj_play_start(j);
5795         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5796                 ixj_record_start(j);
5797 }
5798
5799 static void ixj_ringback(IXJ *j)
5800 {
5801         j->flags.busytone = 0;
5802         j->flags.dialtone = 0;
5803         j->flags.ringback = 1;
5804         ixj_set_tone_on(0x0FA0, j);
5805         ixj_set_tone_off(0x2EE0, j);
5806         ixj_play_tone(j, 26);
5807 }
5808
5809 static void ixj_testram(IXJ *j)
5810 {
5811         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5812 }
5813
5814 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5815 {
5816         ixj_cadence *lcp;
5817         IXJ_CADENCE_ELEMENT __user *cep;
5818         IXJ_CADENCE_ELEMENT *lcep;
5819         IXJ_TONE ti;
5820         int err;
5821
5822         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5823         if (lcp == NULL)
5824                 return -ENOMEM;
5825
5826         err = -EFAULT;
5827         if (copy_from_user(&lcp->elements_used,
5828                            &cp->elements_used, sizeof(int)))
5829                 goto out;
5830         if (copy_from_user(&lcp->termination,
5831                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5832                 goto out;
5833         if (get_user(cep, &cp->ce))
5834                 goto out;
5835
5836         err = -EINVAL;
5837         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5838                 goto out;
5839
5840         err = -ENOMEM;
5841         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5842         if (!lcep)
5843                 goto out;
5844
5845         err = -EFAULT;
5846         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5847                 goto out1;
5848
5849         if (j->cadence_t) {
5850                 kfree(j->cadence_t->ce);
5851                 kfree(j->cadence_t);
5852         }
5853         lcp->ce = (void *) lcep;
5854         j->cadence_t = lcp;
5855         j->tone_cadence_state = 0;
5856         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5857         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5858         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5859                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5860                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5861                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5862                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5863                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5864                 ixj_init_tone(j, &ti);
5865         }
5866         ixj_play_tone(j, lcp->ce[0].index);
5867         return 1;
5868 out1:
5869         kfree(lcep);
5870 out:
5871         kfree(lcp);
5872         return err;
5873 }
5874
5875 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5876 {
5877         IXJ_FILTER_CADENCE *lcp;
5878         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5879         if (lcp == NULL) {
5880                 if(ixjdebug & 0x0001) {
5881                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5882                 }
5883                 return -ENOMEM;
5884         }
5885         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5886                 if(ixjdebug & 0x0001) {
5887                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5888                 }
5889                 kfree(lcp);
5890                 return -EFAULT;
5891         }
5892         if (lcp->filter > 5) {
5893                 if(ixjdebug & 0x0001) {
5894                         printk(KERN_INFO "Cadence out of range\n");
5895                 }
5896                 kfree(lcp);
5897                 return -1;
5898         }
5899         j->cadence_f[lcp->filter].state = 0;
5900         j->cadence_f[lcp->filter].enable = lcp->enable;
5901         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5902         j->cadence_f[lcp->filter].on1 = lcp->on1;
5903         j->cadence_f[lcp->filter].on1min = 0;
5904         j->cadence_f[lcp->filter].on1max = 0;
5905         j->cadence_f[lcp->filter].off1 = lcp->off1;
5906         j->cadence_f[lcp->filter].off1min = 0;
5907         j->cadence_f[lcp->filter].off1max = 0;
5908         j->cadence_f[lcp->filter].on2 = lcp->on2;
5909         j->cadence_f[lcp->filter].on2min = 0;
5910         j->cadence_f[lcp->filter].on2max = 0;
5911         j->cadence_f[lcp->filter].off2 = lcp->off2;
5912         j->cadence_f[lcp->filter].off2min = 0;
5913         j->cadence_f[lcp->filter].off2max = 0;
5914         j->cadence_f[lcp->filter].on3 = lcp->on3;
5915         j->cadence_f[lcp->filter].on3min = 0;
5916         j->cadence_f[lcp->filter].on3max = 0;
5917         j->cadence_f[lcp->filter].off3 = lcp->off3;
5918         j->cadence_f[lcp->filter].off3min = 0;
5919         j->cadence_f[lcp->filter].off3max = 0;
5920         if(ixjdebug & 0x0002) {
5921                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5922         }
5923         kfree(lcp);
5924         return 0;
5925 }
5926
5927 static void add_caps(IXJ *j)
5928 {
5929         j->caps = 0;
5930         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5931         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5932         j->caplist[j->caps].captype = vendor;
5933         j->caplist[j->caps].handle = j->caps++;
5934         j->caplist[j->caps].captype = device;
5935         switch (j->cardtype) {
5936         case QTI_PHONEJACK:
5937                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5938                 break;
5939         case QTI_LINEJACK:
5940                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5941                 break;
5942         case QTI_PHONEJACK_LITE:
5943                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5944                 break;
5945         case QTI_PHONEJACK_PCI:
5946                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5947                 break;
5948         case QTI_PHONECARD:
5949                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5950                 break;
5951         }
5952         j->caplist[j->caps].cap = j->cardtype;
5953         j->caplist[j->caps].handle = j->caps++;
5954         strcpy(j->caplist[j->caps].desc, "POTS");
5955         j->caplist[j->caps].captype = port;
5956         j->caplist[j->caps].cap = pots;
5957         j->caplist[j->caps].handle = j->caps++;
5958
5959         /* add devices that can do speaker/mic */
5960         switch (j->cardtype) {
5961         case QTI_PHONEJACK:
5962         case QTI_LINEJACK:
5963         case QTI_PHONEJACK_PCI:
5964         case QTI_PHONECARD:
5965                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5966                 j->caplist[j->caps].captype = port;
5967                 j->caplist[j->caps].cap = speaker;
5968                 j->caplist[j->caps].handle = j->caps++;
5969         default:
5970                 break;
5971         }
5972
5973         /* add devices that can do handset */
5974         switch (j->cardtype) {
5975         case QTI_PHONEJACK:
5976                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5977                 j->caplist[j->caps].captype = port;
5978                 j->caplist[j->caps].cap = handset;
5979                 j->caplist[j->caps].handle = j->caps++;
5980                 break;
5981         default:
5982                 break;
5983         }
5984
5985         /* add devices that can do PSTN */
5986         switch (j->cardtype) {
5987         case QTI_LINEJACK:
5988                 strcpy(j->caplist[j->caps].desc, "PSTN");
5989                 j->caplist[j->caps].captype = port;
5990                 j->caplist[j->caps].cap = pstn;
5991                 j->caplist[j->caps].handle = j->caps++;
5992                 break;
5993         default:
5994                 break;
5995         }
5996
5997         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
5998         strcpy(j->caplist[j->caps].desc, "ULAW");
5999         j->caplist[j->caps].captype = codec;
6000         j->caplist[j->caps].cap = ULAW;
6001         j->caplist[j->caps].handle = j->caps++;
6002
6003         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6004         j->caplist[j->caps].captype = codec;
6005         j->caplist[j->caps].cap = LINEAR16;
6006         j->caplist[j->caps].handle = j->caps++;
6007
6008         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6009         j->caplist[j->caps].captype = codec;
6010         j->caplist[j->caps].cap = LINEAR8;
6011         j->caplist[j->caps].handle = j->caps++;
6012
6013         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6014         j->caplist[j->caps].captype = codec;
6015         j->caplist[j->caps].cap = WSS;
6016         j->caplist[j->caps].handle = j->caps++;
6017
6018         /* software ALAW codec, made from ULAW */
6019         strcpy(j->caplist[j->caps].desc, "ALAW");
6020         j->caplist[j->caps].captype = codec;
6021         j->caplist[j->caps].cap = ALAW;
6022         j->caplist[j->caps].handle = j->caps++;
6023
6024         /* version 12 of the 8020 does the following codecs in a broken way */
6025         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6026                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6027                 j->caplist[j->caps].captype = codec;
6028                 j->caplist[j->caps].cap = G723_63;
6029                 j->caplist[j->caps].handle = j->caps++;
6030
6031                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6032                 j->caplist[j->caps].captype = codec;
6033                 j->caplist[j->caps].cap = G723_53;
6034                 j->caplist[j->caps].handle = j->caps++;
6035
6036                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6037                 j->caplist[j->caps].captype = codec;
6038                 j->caplist[j->caps].cap = TS48;
6039                 j->caplist[j->caps].handle = j->caps++;
6040
6041                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6042                 j->caplist[j->caps].captype = codec;
6043                 j->caplist[j->caps].cap = TS41;
6044                 j->caplist[j->caps].handle = j->caps++;
6045         }
6046
6047         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6048         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6049                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6050                 j->caplist[j->caps].captype = codec;
6051                 j->caplist[j->caps].cap = TS85;
6052                 j->caplist[j->caps].handle = j->caps++;
6053         }
6054
6055         /* 8021 chips can do G728 */
6056         if (j->dsp.low == 0x21) {
6057                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6058                 j->caplist[j->caps].captype = codec;
6059                 j->caplist[j->caps].cap = G728;
6060                 j->caplist[j->caps].handle = j->caps++;
6061         }
6062
6063         /* 8021/8022 chips can do G729 if loaded */
6064         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6065                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6066                 j->caplist[j->caps].captype = codec;
6067                 j->caplist[j->caps].cap = G729;
6068                 j->caplist[j->caps].handle = j->caps++;
6069         }
6070         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6071                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6072                 j->caplist[j->caps].captype = codec;
6073                 j->caplist[j->caps].cap = G729B;
6074                 j->caplist[j->caps].handle = j->caps++;
6075         }
6076 }
6077
6078 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6079 {
6080         int cnt;
6081         int retval = 0;
6082         for (cnt = 0; cnt < j->caps; cnt++) {
6083                 if (pcreq->captype == j->caplist[cnt].captype
6084                     && pcreq->cap == j->caplist[cnt].cap) {
6085                         retval = 1;
6086                         break;
6087                 }
6088         }
6089         return retval;
6090 }
6091
6092 static int ixj_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
6093 {
6094         IXJ_TONE ti;
6095         IXJ_FILTER jf;
6096         IXJ_FILTER_RAW jfr;
6097         void __user *argp = (void __user *)arg;
6098
6099         unsigned int raise, mant;
6100         unsigned int minor = iminor(inode);
6101         int board = NUM(inode);
6102
6103         IXJ *j = get_ixj(NUM(inode));
6104
6105         int retval = 0;
6106
6107         /*
6108          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6109          *    This is necessary to keep the DSP from locking up.
6110          */
6111         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6112                 schedule_timeout_interruptible(1);
6113         if (ixjdebug & 0x0040)
6114                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6115         if (minor >= IXJMAX) {
6116                 clear_bit(board, &j->busyflags);
6117                 return -ENODEV;
6118         }
6119         /*
6120          *    Check ioctls only root can use.
6121          */
6122         if (!capable(CAP_SYS_ADMIN)) {
6123                 switch (cmd) {
6124                 case IXJCTL_TESTRAM:
6125                 case IXJCTL_HZ:
6126                         retval = -EPERM;
6127                 }
6128         }
6129         switch (cmd) {
6130         case IXJCTL_TESTRAM:
6131                 ixj_testram(j);
6132                 retval = (j->ssr.high << 8) + j->ssr.low;
6133                 break;
6134         case IXJCTL_CARDTYPE:
6135                 retval = j->cardtype;
6136                 break;
6137         case IXJCTL_SERIAL:
6138                 retval = j->serial;
6139                 break;
6140         case IXJCTL_VERSION:
6141                 {
6142                         char arg_str[100];
6143                         snprintf(arg_str, sizeof(arg_str),
6144                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6145                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6146                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6147                                 retval = -EFAULT;
6148                 }
6149                 break;
6150         case PHONE_RING_CADENCE:
6151                 j->ring_cadence = arg;
6152                 break;
6153         case IXJCTL_CIDCW:
6154                 if(arg) {
6155                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6156                                 retval = -EFAULT;
6157                                 break;
6158                         }
6159                 } else {
6160                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6161                 }
6162                 ixj_write_cidcw(j);
6163                 break;
6164         /* Binary compatbility */
6165         case OLD_PHONE_RING_START:
6166                 arg = 0;
6167                 /* Fall through */
6168         case PHONE_RING_START:
6169                 if(arg) {
6170                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6171                                 retval = -EFAULT;
6172                                 break;
6173                         }
6174                         ixj_write_cid(j);
6175                 } else {
6176                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6177                 }
6178                 ixj_ring_start(j);
6179                 break;
6180         case PHONE_RING_STOP:
6181                 j->flags.cringing = 0;
6182                 if(j->cadence_f[5].enable) {
6183                         j->cadence_f[5].state = 0;
6184                 }
6185                 ixj_ring_off(j);
6186                 break;
6187         case PHONE_RING:
6188                 retval = ixj_ring(j);
6189                 break;
6190         case PHONE_EXCEPTION:
6191                 retval = j->ex.bytes;
6192                 if(j->ex.bits.flash) {
6193                         j->flash_end = 0;
6194                         j->ex.bits.flash = 0;
6195                 }
6196                 j->ex.bits.pstn_ring = 0;
6197                 j->ex.bits.caller_id = 0;
6198                 j->ex.bits.pstn_wink = 0;
6199                 j->ex.bits.f0 = 0;
6200                 j->ex.bits.f1 = 0;
6201                 j->ex.bits.f2 = 0;
6202                 j->ex.bits.f3 = 0;
6203                 j->ex.bits.fc0 = 0;
6204                 j->ex.bits.fc1 = 0;
6205                 j->ex.bits.fc2 = 0;
6206                 j->ex.bits.fc3 = 0;
6207                 j->ex.bits.reserved = 0;
6208                 break;
6209         case PHONE_HOOKSTATE:
6210                 j->ex.bits.hookstate = 0;
6211                 retval = j->hookstate;  //j->r_hook;
6212                 break;
6213         case IXJCTL_SET_LED:
6214                 LED_SetState(arg, j);
6215                 break;
6216         case PHONE_FRAME:
6217                 retval = set_base_frame(j, arg);
6218                 break;
6219         case PHONE_REC_CODEC:
6220                 retval = set_rec_codec(j, arg);
6221                 break;
6222         case PHONE_VAD:
6223                 ixj_vad(j, arg);
6224                 break;
6225         case PHONE_REC_START:
6226                 ixj_record_start(j);
6227                 break;
6228         case PHONE_REC_STOP:
6229                 ixj_record_stop(j);
6230                 break;
6231         case PHONE_REC_DEPTH:
6232                 set_rec_depth(j, arg);
6233                 break;
6234         case PHONE_REC_VOLUME:
6235                 if(arg == -1) {
6236                         retval = get_rec_volume(j);
6237                 }
6238                 else {
6239                         set_rec_volume(j, arg);
6240                         retval = arg;
6241                 }
6242                 break;
6243         case PHONE_REC_VOLUME_LINEAR:
6244                 if(arg == -1) {
6245                         retval = get_rec_volume_linear(j);
6246                 }
6247                 else {
6248                         set_rec_volume_linear(j, arg);
6249                         retval = arg;
6250                 }
6251                 break;
6252         case IXJCTL_DTMF_PRESCALE:
6253                 if(arg == -1) {
6254                         retval = get_dtmf_prescale(j);
6255                 }
6256                 else {
6257                         set_dtmf_prescale(j, arg);
6258                         retval = arg;
6259                 }
6260                 break;
6261         case PHONE_REC_LEVEL:
6262                 retval = get_rec_level(j);
6263                 break;
6264         case IXJCTL_SC_RXG:
6265                 retval = ixj_siadc(j, arg);
6266                 break;
6267         case IXJCTL_SC_TXG:
6268                 retval = ixj_sidac(j, arg);
6269                 break;
6270         case IXJCTL_AEC_START:
6271                 ixj_aec_start(j, arg);
6272                 break;
6273         case IXJCTL_AEC_STOP:
6274                 aec_stop(j);
6275                 break;
6276         case IXJCTL_AEC_GET_LEVEL:
6277                 retval = j->aec_level;
6278                 break;
6279         case PHONE_PLAY_CODEC:
6280                 retval = set_play_codec(j, arg);
6281                 break;
6282         case PHONE_PLAY_START:
6283                 retval = ixj_play_start(j);
6284                 break;
6285         case PHONE_PLAY_STOP:
6286                 ixj_play_stop(j);
6287                 break;
6288         case PHONE_PLAY_DEPTH:
6289                 set_play_depth(j, arg);
6290                 break;
6291         case PHONE_PLAY_VOLUME:
6292                 if(arg == -1) {
6293                         retval = get_play_volume(j);
6294                 }
6295                 else {
6296                         set_play_volume(j, arg);
6297                         retval = arg;
6298                 }
6299                 break;
6300         case PHONE_PLAY_VOLUME_LINEAR:
6301                 if(arg == -1) {
6302                         retval = get_play_volume_linear(j);
6303                 }
6304                 else {
6305                         set_play_volume_linear(j, arg);
6306                         retval = arg;
6307                 }
6308                 break;
6309         case PHONE_PLAY_LEVEL:
6310                 retval = get_play_level(j);
6311                 break;
6312         case IXJCTL_DSP_TYPE:
6313                 retval = (j->dsp.high << 8) + j->dsp.low;
6314                 break;
6315         case IXJCTL_DSP_VERSION:
6316                 retval = (j->ver.high << 8) + j->ver.low;
6317                 break;
6318         case IXJCTL_HZ:
6319                 hertz = arg;
6320                 break;
6321         case IXJCTL_RATE:
6322                 if (arg > hertz)
6323                         retval = -1;
6324                 else
6325                         samplerate = arg;
6326                 break;
6327         case IXJCTL_DRYBUFFER_READ:
6328                 put_user(j->drybuffer, (unsigned long __user *) argp);
6329                 break;
6330         case IXJCTL_DRYBUFFER_CLEAR:
6331                 j->drybuffer = 0;
6332                 break;
6333         case IXJCTL_FRAMES_READ:
6334                 put_user(j->framesread, (unsigned long __user *) argp);
6335                 break;
6336         case IXJCTL_FRAMES_WRITTEN:
6337                 put_user(j->frameswritten, (unsigned long __user *) argp);
6338                 break;
6339         case IXJCTL_READ_WAIT:
6340                 put_user(j->read_wait, (unsigned long __user *) argp);
6341                 break;
6342         case IXJCTL_WRITE_WAIT:
6343                 put_user(j->write_wait, (unsigned long __user *) argp);
6344                 break;
6345         case PHONE_MAXRINGS:
6346                 j->maxrings = arg;
6347                 break;
6348         case PHONE_SET_TONE_ON_TIME:
6349                 ixj_set_tone_on(arg, j);
6350                 break;
6351         case PHONE_SET_TONE_OFF_TIME:
6352                 ixj_set_tone_off(arg, j);
6353                 break;
6354         case PHONE_GET_TONE_ON_TIME:
6355                 if (ixj_get_tone_on(j)) {
6356                         retval = -1;
6357                 } else {
6358                         retval = (j->ssr.high << 8) + j->ssr.low;
6359                 }
6360                 break;
6361         case PHONE_GET_TONE_OFF_TIME:
6362                 if (ixj_get_tone_off(j)) {
6363                         retval = -1;
6364                 } else {
6365                         retval = (j->ssr.high << 8) + j->ssr.low;
6366                 }
6367                 break;
6368         case PHONE_PLAY_TONE:
6369                 if (!j->tone_state)
6370                         retval = ixj_play_tone(j, arg);
6371                 else
6372                         retval = -1;
6373                 break;
6374         case PHONE_GET_TONE_STATE:
6375                 retval = j->tone_state;
6376                 break;
6377         case PHONE_DTMF_READY:
6378                 retval = j->ex.bits.dtmf_ready;
6379                 break;
6380         case PHONE_GET_DTMF:
6381                 if (ixj_hookstate(j)) {
6382                         if (j->dtmf_rp != j->dtmf_wp) {
6383                                 retval = j->dtmfbuffer[j->dtmf_rp];
6384                                 j->dtmf_rp++;
6385                                 if (j->dtmf_rp == 79)
6386                                         j->dtmf_rp = 0;
6387                                 if (j->dtmf_rp == j->dtmf_wp) {
6388                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6389                                 }
6390                         }
6391                 }
6392                 break;
6393         case PHONE_GET_DTMF_ASCII:
6394                 if (ixj_hookstate(j)) {
6395                         if (j->dtmf_rp != j->dtmf_wp) {
6396                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6397                                 case 10:
6398                                         retval = 42;    /* '*'; */
6399
6400                                         break;
6401                                 case 11:
6402                                         retval = 48;    /*'0'; */
6403
6404                                         break;
6405                                 case 12:
6406                                         retval = 35;    /*'#'; */
6407
6408                                         break;
6409                                 case 28:
6410                                         retval = 65;    /*'A'; */
6411
6412                                         break;
6413                                 case 29:
6414                                         retval = 66;    /*'B'; */
6415
6416                                         break;
6417                                 case 30:
6418                                         retval = 67;    /*'C'; */
6419
6420                                         break;
6421                                 case 31:
6422                                         retval = 68;    /*'D'; */
6423
6424                                         break;
6425                                 default:
6426                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6427                                         break;
6428                                 }
6429                                 j->dtmf_rp++;
6430                                 if (j->dtmf_rp == 79)
6431                                         j->dtmf_rp = 0;
6432                                 if(j->dtmf_rp == j->dtmf_wp)
6433                                 {
6434                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6435                                 }
6436                         }
6437                 }
6438                 break;
6439         case PHONE_DTMF_OOB:
6440                 j->flags.dtmf_oob = arg;
6441                 break;
6442         case PHONE_DIALTONE:
6443                 ixj_dialtone(j);
6444                 break;
6445         case PHONE_BUSY:
6446                 ixj_busytone(j);
6447                 break;
6448         case PHONE_RINGBACK:
6449                 ixj_ringback(j);
6450                 break;
6451         case PHONE_WINK:
6452                 if(j->cardtype == QTI_PHONEJACK)
6453                         retval = -1;
6454                 else
6455                         retval = ixj_wink(j);
6456                 break;
6457         case PHONE_CPT_STOP:
6458                 ixj_cpt_stop(j);
6459                 break;
6460         case PHONE_QUERY_CODEC:
6461         {
6462                 struct phone_codec_data pd;
6463                 int val;
6464                 int proto_size[] = {
6465                         -1,
6466                         12, 10, 16, 9, 8, 48, 5,
6467                         40, 40, 80, 40, 40, 6
6468                 };
6469                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6470                         retval = -EFAULT;
6471                         break;
6472                 }
6473                 if(pd.type<1 || pd.type>13) {
6474                         retval = -EPROTONOSUPPORT;
6475                         break;
6476                 }
6477                 if(pd.type<G729)
6478                         val=proto_size[pd.type];
6479                 else switch(j->baseframe.low)
6480                 {
6481                         case 0xA0:val=2*proto_size[pd.type];break;
6482                         case 0x50:val=proto_size[pd.type];break;
6483                         default:val=proto_size[pd.type]*3;break;
6484                 }
6485                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6486                 if(copy_to_user(argp, &pd, sizeof(pd)))
6487                         retval = -EFAULT;
6488                 break;
6489         }
6490         case IXJCTL_DSP_IDLE:
6491                 idle(j);
6492                 break;
6493         case IXJCTL_MIXER:
6494                 if ((arg & 0xff) == 0xff)
6495                         retval = ixj_get_mixer(arg, j);
6496                 else
6497                         ixj_mixer(arg, j);
6498                 break;
6499         case IXJCTL_DAA_COEFF_SET:
6500                 switch (arg) {
6501                 case DAA_US:
6502                         DAA_Coeff_US(j);
6503                         retval = ixj_daa_write(j);
6504                         break;
6505                 case DAA_UK:
6506                         DAA_Coeff_UK(j);
6507                         retval = ixj_daa_write(j);
6508                         break;
6509                 case DAA_FRANCE:
6510                         DAA_Coeff_France(j);
6511                         retval = ixj_daa_write(j);
6512                         break;
6513                 case DAA_GERMANY:
6514                         DAA_Coeff_Germany(j);
6515                         retval = ixj_daa_write(j);
6516                         break;
6517                 case DAA_AUSTRALIA:
6518                         DAA_Coeff_Australia(j);
6519                         retval = ixj_daa_write(j);
6520                         break;
6521                 case DAA_JAPAN:
6522                         DAA_Coeff_Japan(j);
6523                         retval = ixj_daa_write(j);
6524                         break;
6525                 default:
6526                         retval = 1;
6527                         break;
6528                 }
6529                 break;
6530         case IXJCTL_DAA_AGAIN:
6531                 ixj_daa_cr4(j, arg | 0x02);
6532                 break;
6533         case IXJCTL_PSTN_LINETEST:
6534                 retval = ixj_linetest(j);
6535                 break;
6536         case IXJCTL_VMWI:
6537                 ixj_write_vmwi(j, arg);
6538                 break;
6539         case IXJCTL_CID:
6540                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6541                         retval = -EFAULT;
6542                 j->ex.bits.caller_id = 0;
6543                 break;
6544         case IXJCTL_WINK_DURATION:
6545                 j->winktime = arg;
6546                 break;
6547         case IXJCTL_PORT:
6548                 if (arg)
6549                         retval = ixj_set_port(j, arg);
6550                 else
6551                         retval = j->port;
6552                 break;
6553         case IXJCTL_POTS_PSTN:
6554                 retval = ixj_set_pots(j, arg);
6555                 break;
6556         case PHONE_CAPABILITIES:
6557                 add_caps(j);
6558                 retval = j->caps;
6559                 break;
6560         case PHONE_CAPABILITIES_LIST:
6561                 add_caps(j);
6562                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6563                         retval = -EFAULT;
6564                 break;
6565         case PHONE_CAPABILITIES_CHECK:
6566                 {
6567                         struct phone_capability cap;
6568                         if (copy_from_user(&cap, argp, sizeof(cap)))
6569                                 retval = -EFAULT;
6570                         else {
6571                                 add_caps(j);
6572                                 retval = capabilities_check(j, &cap);
6573                         }
6574                 }
6575                 break;
6576         case PHONE_PSTN_SET_STATE:
6577                 daa_set_mode(j, arg);
6578                 break;
6579         case PHONE_PSTN_GET_STATE:
6580                 retval = j->daa_mode;
6581                 j->ex.bits.pstn_ring = 0;
6582                 break;
6583         case IXJCTL_SET_FILTER:
6584                 if (copy_from_user(&jf, argp, sizeof(jf)))
6585                         retval = -EFAULT;
6586                 retval = ixj_init_filter(j, &jf);
6587                 break;
6588         case IXJCTL_SET_FILTER_RAW:
6589                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6590                         retval = -EFAULT;
6591                 else
6592                         retval = ixj_init_filter_raw(j, &jfr);
6593                 break;
6594         case IXJCTL_GET_FILTER_HIST:
6595                 if(arg<0||arg>3)
6596                         retval = -EINVAL;
6597                 else
6598                         retval = j->filter_hist[arg];
6599                 break;
6600         case IXJCTL_INIT_TONE:
6601                 if (copy_from_user(&ti, argp, sizeof(ti)))
6602                         retval = -EFAULT;
6603                 else
6604                         retval = ixj_init_tone(j, &ti);
6605                 break;
6606         case IXJCTL_TONE_CADENCE:
6607                 retval = ixj_build_cadence(j, argp);
6608                 break;
6609         case IXJCTL_FILTER_CADENCE:
6610                 retval = ixj_build_filter_cadence(j, argp);
6611                 break;
6612         case IXJCTL_SIGCTL:
6613                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6614                         retval = -EFAULT;
6615                         break;
6616                 }
6617                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6618                 if(j->sigdef.event < 33) {
6619                         raise = 1;
6620                         for(mant = 0; mant < j->sigdef.event; mant++){
6621                                 raise *= 2;
6622                         }
6623                         if(j->sigdef.signal)
6624                                 j->ex_sig.bytes |= raise;
6625                         else
6626                                 j->ex_sig.bytes &= (raise^0xffff);
6627                 }
6628                 break;
6629         case IXJCTL_INTERCOM_STOP:
6630                 if(arg < 0 || arg >= IXJMAX)
6631                         return -EINVAL;
6632                 j->intercom = -1;
6633                 ixj_record_stop(j);
6634                 ixj_play_stop(j);
6635                 idle(j);
6636                 get_ixj(arg)->intercom = -1;
6637                 ixj_record_stop(get_ixj(arg));
6638                 ixj_play_stop(get_ixj(arg));
6639                 idle(get_ixj(arg));
6640                 break;
6641         case IXJCTL_INTERCOM_START:
6642                 if(arg < 0 || arg >= IXJMAX)
6643                         return -EINVAL;
6644                 j->intercom = arg;
6645                 ixj_record_start(j);
6646                 ixj_play_start(j);
6647                 get_ixj(arg)->intercom = board;
6648                 ixj_play_start(get_ixj(arg));
6649                 ixj_record_start(get_ixj(arg));
6650                 break;
6651         }
6652         if (ixjdebug & 0x0040)
6653                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6654         clear_bit(board, &j->busyflags);
6655         return retval;
6656 }
6657
6658 static int ixj_fasync(int fd, struct file *file_p, int mode)
6659 {
6660         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6661
6662         return fasync_helper(fd, file_p, mode, &j->async_queue);
6663 }
6664
6665 static struct file_operations ixj_fops =
6666 {
6667         .owner          = THIS_MODULE,
6668         .read           = ixj_enhanced_read,
6669         .write          = ixj_enhanced_write,
6670         .poll           = ixj_poll,
6671         .ioctl          = ixj_ioctl,
6672         .release        = ixj_release,
6673         .fasync         = ixj_fasync
6674 };
6675
6676 static int ixj_linetest(IXJ *j)
6677 {
6678         j->flags.pstncheck = 1; /* Testing */
6679         j->flags.pstn_present = 0; /* Assume the line is not there */
6680
6681         daa_int_read(j);        /*Clear DAA Interrupt flags */
6682         /* */
6683         /* Hold all relays in the normally de-energized position. */
6684         /* */
6685
6686         j->pld_slicw.bits.rly1 = 0;
6687         j->pld_slicw.bits.rly2 = 0;
6688         j->pld_slicw.bits.rly3 = 0;
6689         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6690         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6691
6692         outb_p(j->pld_scrw.byte, j->XILINXbase);
6693         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6694         if (j->pld_slicr.bits.potspstn) {
6695                 j->flags.pots_pstn = 1;
6696                 j->flags.pots_correct = 0;
6697                 LED_SetState(0x4, j);
6698         } else {
6699                 j->flags.pots_pstn = 0;
6700                 j->pld_slicw.bits.rly1 = 0;
6701                 j->pld_slicw.bits.rly2 = 0;
6702                 j->pld_slicw.bits.rly3 = 1;
6703                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6704                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6705
6706                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6707                 daa_set_mode(j, SOP_PU_CONVERSATION);
6708                 msleep(1000);
6709                 daa_int_read(j);
6710                 daa_set_mode(j, SOP_PU_RESET);
6711                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6712                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6713                         LED_SetState(0x4, j);
6714                         j->pld_slicw.bits.rly3 = 0;
6715                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6716                 } else {
6717                         j->flags.pots_correct = 1;
6718                         LED_SetState(0x8, j);
6719                         j->pld_slicw.bits.rly1 = 1;
6720                         j->pld_slicw.bits.rly2 = 0;
6721                         j->pld_slicw.bits.rly3 = 0;
6722                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6723                 }
6724         }
6725         j->pld_slicw.bits.rly3 = 0;
6726         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6727         daa_set_mode(j, SOP_PU_CONVERSATION);
6728         msleep(1000);
6729         daa_int_read(j);
6730         daa_set_mode(j, SOP_PU_RESET);
6731         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6732                 j->pstn_sleeptil = jiffies + (hertz / 4);
6733                 j->flags.pstn_present = 1;
6734         } else {
6735                 j->flags.pstn_present = 0;
6736         }
6737         if (j->flags.pstn_present) {
6738                 if (j->flags.pots_correct) {
6739                         LED_SetState(0xA, j);
6740                 } else {
6741                         LED_SetState(0x6, j);
6742                 }
6743         } else {
6744                 if (j->flags.pots_correct) {
6745                         LED_SetState(0x9, j);
6746                 } else {
6747                         LED_SetState(0x5, j);
6748                 }
6749         }
6750         j->flags.pstncheck = 0; /* Testing */
6751         return j->flags.pstn_present;
6752 }
6753
6754 static int ixj_selfprobe(IXJ *j)
6755 {
6756         unsigned short cmd;
6757         int cnt;
6758         BYTES bytes;
6759
6760         init_waitqueue_head(&j->poll_q);
6761         init_waitqueue_head(&j->read_q);
6762         init_waitqueue_head(&j->write_q);
6763
6764         while(atomic_read(&j->DSPWrite) > 0)
6765                 atomic_dec(&j->DSPWrite);
6766         if (ixjdebug & 0x0002)
6767                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6768         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6769
6770         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6771                 return -1;
6772 /* The read values of the SSR should be 0x00 for the IDLE command */
6773         if (j->ssr.low || j->ssr.high)
6774                 return -1;
6775         if (ixjdebug & 0x0002)
6776                 printk(KERN_INFO "Get Device ID Code\n");
6777         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6778                 return -1;
6779         j->dsp.low = j->ssr.low;
6780         j->dsp.high = j->ssr.high;
6781         if (ixjdebug & 0x0002)
6782                 printk(KERN_INFO "Get Device Version Code\n");
6783         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6784                 return -1;
6785         j->ver.low = j->ssr.low;
6786         j->ver.high = j->ssr.high;
6787         if (!j->cardtype) {
6788                 if (j->dsp.low == 0x21) {
6789                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6790                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6791 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6792                         bytes.low = inb_p(j->XILINXbase + 0x02);
6793                         if (bytes.low == bytes.high)    /*  Register is read only on */
6794                                 /*  Internet PhoneJack Lite */
6795                          {
6796                                 j->cardtype = QTI_PHONEJACK_LITE;
6797                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6798                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6799                                         return -1;
6800                                 }
6801                                 j->pld_slicw.pcib.e1 = 1;
6802                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6803                         } else {
6804                                 j->cardtype = QTI_LINEJACK;
6805
6806                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6807                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6808                                         return -1;
6809                                 }
6810                         }
6811                 } else if (j->dsp.low == 0x22) {
6812                         j->cardtype = QTI_PHONEJACK_PCI;
6813                         request_region(j->XILINXbase, 4, "ixj control");
6814                         j->pld_slicw.pcib.e1 = 1;
6815                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6816                 } else
6817                         j->cardtype = QTI_PHONEJACK;
6818         } else {
6819                 switch (j->cardtype) {
6820                 case QTI_PHONEJACK:
6821                         if (!j->dsp.low != 0x20) {
6822                                 j->dsp.high = 0x80;
6823                                 j->dsp.low = 0x20;
6824                                 ixj_WriteDSPCommand(0x3800, j);
6825                                 j->ver.low = j->ssr.low;
6826                                 j->ver.high = j->ssr.high;
6827                         }
6828                         break;
6829                 case QTI_LINEJACK:
6830                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6831                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6832                                 return -1;
6833                         }
6834                         break;
6835                 case QTI_PHONEJACK_LITE:
6836                 case QTI_PHONEJACK_PCI:
6837                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6838                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6839                                 return -1;
6840                         }
6841                         j->pld_slicw.pcib.e1 = 1;
6842                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6843                         break;
6844                 case QTI_PHONECARD:
6845                         break;
6846                 }
6847         }
6848         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6849                 if (ixjdebug & 0x0002)
6850                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6851                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6852                         return -1;
6853                 if (ixjdebug & 0x0002)
6854                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6855                 if (j->cardtype == QTI_PHONEJACK) {
6856                         cmd = 0x9FF2;
6857                 } else {
6858                         cmd = 0x9FF5;
6859                 }
6860                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6861                         return -1;
6862         } else {
6863                 if (set_base_frame(j, 30) != 30)
6864                         return -1;
6865                 if (ixjdebug & 0x0002)
6866                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6867                 if (j->cardtype == QTI_PHONECARD) {
6868                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6869                                 return -1;
6870                 }
6871                 if (j->cardtype == QTI_LINEJACK) {
6872                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6873                                 return -1;
6874                         if (ixjdebug & 0x0002)
6875                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6876                         j->pld_clock.byte = 0;
6877                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6878                 }
6879         }
6880
6881         if (j->dsp.low == 0x20) {
6882                 if (ixjdebug & 0x0002)
6883                         printk(KERN_INFO "Configure GPIO pins\n");
6884                 j->gpio.bytes.high = 0x09;
6885 /*  bytes.low = 0xEF;  0xF7 */
6886                 j->gpio.bits.gpio1 = 1;
6887                 j->gpio.bits.gpio2 = 1;
6888                 j->gpio.bits.gpio3 = 0;
6889                 j->gpio.bits.gpio4 = 1;
6890                 j->gpio.bits.gpio5 = 1;
6891                 j->gpio.bits.gpio6 = 1;
6892                 j->gpio.bits.gpio7 = 1;
6893                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6894                 if (ixjdebug & 0x0002)
6895                         printk(KERN_INFO "Enable SLIC\n");
6896                 j->gpio.bytes.high = 0x0B;
6897                 j->gpio.bytes.low = 0x00;
6898                 j->gpio.bits.gpio1 = 0;
6899                 j->gpio.bits.gpio2 = 1;
6900                 j->gpio.bits.gpio5 = 0;
6901                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6902                 j->port = PORT_POTS;
6903         } else {
6904                 if (j->cardtype == QTI_LINEJACK) {
6905                         LED_SetState(0x1, j);
6906                         msleep(100);
6907                         LED_SetState(0x2, j);
6908                         msleep(100);
6909                         LED_SetState(0x4, j);
6910                         msleep(100);
6911                         LED_SetState(0x8, j);
6912                         msleep(100);
6913                         LED_SetState(0x0, j);
6914                         daa_get_version(j);
6915                         if (ixjdebug & 0x0002)
6916                                 printk("Loading DAA Coefficients\n");
6917                         DAA_Coeff_US(j);
6918                         if (!ixj_daa_write(j)) {
6919                                 printk("DAA write failed on board %d\n", j->board);
6920                                 return -1;
6921                         }
6922                         if(!ixj_daa_cid_reset(j)) {
6923                                 printk("DAA CID reset failed on board %d\n", j->board);
6924                                 return -1;
6925                         }
6926                         j->flags.pots_correct = 0;
6927                         j->flags.pstn_present = 0;
6928                         ixj_linetest(j);
6929                         if (j->flags.pots_correct) {
6930                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6931
6932                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6933                                 j->pld_slicw.bits.rly1 = 1;
6934                                 j->pld_slicw.bits.spken = 1;
6935                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6936                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6937 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6938                                 j->port = PORT_POTS;
6939                         }
6940                         ixj_set_port(j, PORT_PSTN);
6941                         ixj_set_pots(j, 1);
6942                         if (ixjdebug & 0x0002)
6943                                 printk(KERN_INFO "Enable Mixer\n");
6944                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6945                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6946
6947                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6948                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6949
6950                         ixj_mixer(0x0480, j);   /*FM Left mute */
6951                         ixj_mixer(0x0580, j);   /*FM Right mute */
6952
6953                         ixj_mixer(0x0680, j);   /*CD Left mute */
6954                         ixj_mixer(0x0780, j);   /*CD Right mute */
6955
6956                         ixj_mixer(0x0880, j);   /*Line Left mute */
6957                         ixj_mixer(0x0980, j);   /*Line Right mute */
6958
6959                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6960                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6961
6962                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6963                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6964
6965                         ixj_mixer(0x0E80, j);   /*Mic mute */
6966
6967                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6968
6969                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6970                         ixj_mixer(0x110C, j);
6971
6972
6973                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6974                         ixj_mixer(0x1401, j);
6975
6976                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6977                         ixj_mixer(0x1501, j);
6978
6979                         ixj_mixer(0x1700, j);   /*Clock select */
6980
6981                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6982
6983                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6984
6985                         if (ixjdebug & 0x0002)
6986                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6987                         j->cadence_f[4].state = 0;
6988                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
6989                         j->cadence_f[4].off1 = 0;
6990                         j->cadence_f[4].on2 = 0;
6991                         j->cadence_f[4].off2 = 0;
6992                         j->cadence_f[4].on3 = 0;
6993                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
6994                         j->pstn_last_rmr = jiffies;
6995
6996                 } else {
6997                         if (j->cardtype == QTI_PHONECARD) {
6998                                 ixj_WriteDSPCommand(0xCF07, j);
6999                                 ixj_WriteDSPCommand(0x00B0, j);
7000                                 ixj_set_port(j, PORT_SPEAKER);
7001                         } else {
7002                                 ixj_set_port(j, PORT_POTS);
7003                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7004 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7005                         }
7006                 }
7007         }
7008
7009         j->intercom = -1;
7010         j->framesread = j->frameswritten = 0;
7011         j->read_wait = j->write_wait = 0;
7012         j->rxreadycheck = j->txreadycheck = 0;
7013
7014         /* initialise the DTMF prescale to a sensible value */
7015         if (j->cardtype == QTI_LINEJACK) {
7016                 set_dtmf_prescale(j, 0x10);
7017         } else {
7018                 set_dtmf_prescale(j, 0x40);
7019         }
7020         set_play_volume(j, 0x100);
7021         set_rec_volume(j, 0x100);
7022
7023         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7024                 return -1;
7025 /* The read values of the SSR should be 0x00 for the IDLE command */
7026         if (j->ssr.low || j->ssr.high)
7027                 return -1;
7028
7029         if (ixjdebug & 0x0002)
7030                 printk(KERN_INFO "Enable Line Monitor\n");
7031
7032         if (ixjdebug & 0x0002)
7033                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7034
7035         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7036                 return -1;
7037
7038         if (ixjdebug & 0x002)
7039                 printk(KERN_INFO "Enable DTMF Detectors\n");
7040
7041         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7042                 return -1;
7043
7044         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7045                 return -1;
7046
7047         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7048
7049         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7050
7051         j->ex.bits.dtmf_ready = 0;
7052         j->dtmf_state = 0;
7053         j->dtmf_wp = j->dtmf_rp = 0;
7054         j->rec_mode = j->play_mode = -1;
7055         j->flags.ringing = 0;
7056         j->maxrings = MAXRINGS;
7057         j->ring_cadence = USA_RING_CADENCE;
7058         j->drybuffer = 0;
7059         j->winktime = 320;
7060         j->flags.dtmf_oob = 0;
7061         for (cnt = 0; cnt < 4; cnt++)
7062                 j->cadence_f[cnt].enable = 0;
7063         /* must be a device on the specified address */
7064         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7065
7066         /* Set up the default signals for events */
7067         for (cnt = 0; cnt < 35; cnt++)
7068                 j->ixj_signals[cnt] = SIGIO;
7069
7070         /* Set the excetion signal enable flags */
7071         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7072         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 =
7073         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;
7074 #ifdef IXJ_DYN_ALLOC
7075         j->fskdata = NULL;
7076 #endif
7077         j->fskdcnt = 0;
7078         j->cidcw_wait = 0;
7079
7080         /* Register with the Telephony for Linux subsystem */
7081         j->p.f_op = &ixj_fops;
7082         j->p.open = ixj_open;
7083         j->p.board = j->board;
7084         phone_register_device(&j->p, PHONE_UNIT_ANY);
7085
7086         ixj_init_timer(j);
7087         ixj_add_timer(j);
7088         return 0;
7089 }
7090
7091 /*
7092  *      Exported service for pcmcia card handling
7093  */
7094
7095 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7096 {
7097         IXJ *j = ixj_alloc();
7098
7099         j->board = 0;
7100
7101         j->DSPbase = dsp;
7102         j->XILINXbase = xilinx;
7103         j->cardtype = QTI_PHONECARD;
7104         ixj_selfprobe(j);
7105         return j;
7106 }
7107
7108 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7109
7110 static int ixj_get_status_proc(char *buf)
7111 {
7112         int len;
7113         int cnt;
7114         IXJ *j;
7115         len = 0;
7116         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7117         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7118         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7119         len += sprintf(buf + len, "\nUsing old telephony API");
7120         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7121
7122         for (cnt = 0; cnt < IXJMAX; cnt++) {
7123                 j = get_ixj(cnt);
7124                 if(j==NULL)
7125                         continue;
7126                 if (j->DSPbase) {
7127                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7128                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7129                         if (j->cardtype != QTI_PHONEJACK)
7130                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7131                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7132                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7133                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7134                         switch (j->cardtype) {
7135                         case (QTI_PHONEJACK):
7136                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7137                                 break;
7138                         case (QTI_LINEJACK):
7139                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7140                                 if (j->flags.g729_loaded)
7141                                         len += sprintf(buf + len, " w/G.729 A/B");
7142                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7143                                 break;
7144                         case (QTI_PHONEJACK_LITE):
7145                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7146                                 if (j->flags.g729_loaded)
7147                                         len += sprintf(buf + len, " w/G.729 A/B");
7148                                 break;
7149                         case (QTI_PHONEJACK_PCI):
7150                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7151                                 if (j->flags.g729_loaded)
7152                                         len += sprintf(buf + len, " w/G.729 A/B");
7153                                 break;
7154                         case (QTI_PHONECARD):
7155                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7156                                 if (j->flags.g729_loaded)
7157                                         len += sprintf(buf + len, " w/G.729 A/B");
7158                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7159                                 if (!j->pccr1.bits.drf)
7160                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7161                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7162                                 break;
7163                         default:
7164                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7165                                 break;
7166                         }
7167                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7168                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7169                         add_caps(j);
7170                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7171                         if (j->dsp.low != 0x20)
7172                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7173                         if (j->flags.cidsent)
7174                                 len += sprintf(buf + len, "\nCaller ID data sent");
7175                         else
7176                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7177
7178                         len += sprintf(buf + len, "\nPlay CODEC ");
7179                         switch (j->play_codec) {
7180                         case G723_63:
7181                                 len += sprintf(buf + len, "G.723.1 6.3");
7182                                 break;
7183                         case G723_53:
7184                                 len += sprintf(buf + len, "G.723.1 5.3");
7185                                 break;
7186                         case TS85:
7187                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7188                                 break;
7189                         case TS48:
7190                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7191                                 break;
7192                         case TS41:
7193                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7194                                 break;
7195                         case G728:
7196                                 len += sprintf(buf + len, "G.728");
7197                                 break;
7198                         case G729:
7199                                 len += sprintf(buf + len, "G.729");
7200                                 break;
7201                         case G729B:
7202                                 len += sprintf(buf + len, "G.729B");
7203                                 break;
7204                         case ULAW:
7205                                 len += sprintf(buf + len, "uLaw");
7206                                 break;
7207                         case ALAW:
7208                                 len += sprintf(buf + len, "aLaw");
7209                                 break;
7210                         case LINEAR16:
7211                                 len += sprintf(buf + len, "16 bit Linear");
7212                                 break;
7213                         case LINEAR8:
7214                                 len += sprintf(buf + len, "8 bit Linear");
7215                                 break;
7216                         case WSS:
7217                                 len += sprintf(buf + len, "Windows Sound System");
7218                                 break;
7219                         default:
7220                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7221                                 break;
7222                         }
7223                         len += sprintf(buf + len, "\nRecord CODEC ");
7224                         switch (j->rec_codec) {
7225                         case G723_63:
7226                                 len += sprintf(buf + len, "G.723.1 6.3");
7227                                 break;
7228                         case G723_53:
7229                                 len += sprintf(buf + len, "G.723.1 5.3");
7230                                 break;
7231                         case TS85:
7232                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7233                                 break;
7234                         case TS48:
7235                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7236                                 break;
7237                         case TS41:
7238                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7239                                 break;
7240                         case G728:
7241                                 len += sprintf(buf + len, "G.728");
7242                                 break;
7243                         case G729:
7244                                 len += sprintf(buf + len, "G.729");
7245                                 break;
7246                         case G729B:
7247                                 len += sprintf(buf + len, "G.729B");
7248                                 break;
7249                         case ULAW:
7250                                 len += sprintf(buf + len, "uLaw");
7251                                 break;
7252                         case ALAW:
7253                                 len += sprintf(buf + len, "aLaw");
7254                                 break;
7255                         case LINEAR16:
7256                                 len += sprintf(buf + len, "16 bit Linear");
7257                                 break;
7258                         case LINEAR8:
7259                                 len += sprintf(buf + len, "8 bit Linear");
7260                                 break;
7261                         case WSS:
7262                                 len += sprintf(buf + len, "Windows Sound System");
7263                                 break;
7264                         default:
7265                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7266                                 break;
7267                         }
7268                         len += sprintf(buf + len, "\nAEC ");
7269                         switch (j->aec_level) {
7270                         case AEC_OFF:
7271                                 len += sprintf(buf + len, "Off");
7272                                 break;
7273                         case AEC_LOW:
7274                                 len += sprintf(buf + len, "Low");
7275                                 break;
7276                         case AEC_MED:
7277                                 len += sprintf(buf + len, "Med");
7278                                 break;
7279                         case AEC_HIGH:
7280                                 len += sprintf(buf + len, "High");
7281                                 break;
7282                         case AEC_AUTO:
7283                                 len += sprintf(buf + len, "Auto");
7284                                 break;
7285                         case AEC_AGC:
7286                                 len += sprintf(buf + len, "AEC/AGC");
7287                                 break;
7288                         default:
7289                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7290                                 break;
7291                         }
7292
7293                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7294                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7295                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7296
7297                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7298
7299                         if (j->cardtype == QTI_LINEJACK) {
7300                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7301                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7302                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7303                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7304                                 switch (j->daa_mode) {
7305                                 case SOP_PU_SLEEP:
7306                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7307                                         break;
7308                                 case SOP_PU_RINGING:
7309                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7310                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7311                                         break;
7312                                 case SOP_PU_CONVERSATION:
7313                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7314                                         break;
7315                                 case SOP_PU_PULSEDIALING:
7316                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7317                                         break;
7318                                 }
7319                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7320                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7321                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7322                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7323                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7324                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7325                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7326                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7327                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7328                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7329                         }
7330                         switch (j->port) {
7331                         case PORT_POTS:
7332                                 len += sprintf(buf + len, "\nPort POTS");
7333                                 break;
7334                         case PORT_PSTN:
7335                                 len += sprintf(buf + len, "\nPort PSTN");
7336                                 break;
7337                         case PORT_SPEAKER:
7338                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7339                                 break;
7340                         case PORT_HANDSET:
7341                                 len += sprintf(buf + len, "\nPort HANDSET");
7342                                 break;
7343                         }
7344                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7345                                 len += sprintf(buf + len, "\nSLIC state ");
7346                                 switch (SLIC_GetState(j)) {
7347                                 case PLD_SLIC_STATE_OC:
7348                                         len += sprintf(buf + len, "OC");
7349                                         break;
7350                                 case PLD_SLIC_STATE_RINGING:
7351                                         len += sprintf(buf + len, "RINGING");
7352                                         break;
7353                                 case PLD_SLIC_STATE_ACTIVE:
7354                                         len += sprintf(buf + len, "ACTIVE");
7355                                         break;
7356                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7357                                         len += sprintf(buf + len, "OHT");
7358                                         break;
7359                                 case PLD_SLIC_STATE_TIPOPEN:
7360                                         len += sprintf(buf + len, "TIPOPEN");
7361                                         break;
7362                                 case PLD_SLIC_STATE_STANDBY:
7363                                         len += sprintf(buf + len, "STANDBY");
7364                                         break;
7365                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7366                                         len += sprintf(buf + len, "APR");
7367                                         break;
7368                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7369                                         len += sprintf(buf + len, "OHTPR");
7370                                         break;
7371                                 default:
7372                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7373                                         break;
7374                                 }
7375                         }
7376                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7377                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7378 #ifdef PERFMON_STATS
7379                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7380                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7381                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7382                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7383                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7384                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7385                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7386                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7387                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7388                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7389                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7390                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7391                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7392                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7393
7394 #endif
7395                         len += sprintf(buf + len, "\n");
7396                 }
7397         }
7398         return len;
7399 }
7400
7401 static int ixj_read_proc(char *page, char **start, off_t off,
7402                               int count, int *eof, void *data)
7403 {
7404         int len = ixj_get_status_proc(page);
7405         if (len <= off+count) *eof = 1;
7406         *start = page + off;
7407         len -= off;
7408         if (len>count) len = count;
7409         if (len<0) len = 0;
7410         return len;
7411 }
7412
7413
7414 static void cleanup(void)
7415 {
7416         int cnt;
7417         IXJ *j;
7418
7419         for (cnt = 0; cnt < IXJMAX; cnt++) {
7420                 j = get_ixj(cnt);
7421                 if(j != NULL && j->DSPbase) {
7422                         if (ixjdebug & 0x0002)
7423                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7424                         del_timer(&j->timer);
7425                         if (j->cardtype == QTI_LINEJACK) {
7426                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7427
7428                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7429                                 j->pld_slicw.bits.rly1 = 0;
7430                                 j->pld_slicw.bits.rly2 = 0;
7431                                 j->pld_slicw.bits.rly3 = 0;
7432                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7433                                 LED_SetState(0x0, j);
7434                                 if (ixjdebug & 0x0002)
7435                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7436                                 release_region(j->XILINXbase, 8);
7437                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7438                                 if (ixjdebug & 0x0002)
7439                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7440                                 release_region(j->XILINXbase, 4);
7441                         }
7442                         kfree(j->read_buffer);
7443                         kfree(j->write_buffer);
7444                         if (j->dev)
7445                                 pnp_device_detach(j->dev);
7446                         if (ixjdebug & 0x0002)
7447                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7448                         phone_unregister_device(&j->p);
7449                         if (ixjdebug & 0x0002)
7450                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7451                         release_region(j->DSPbase, 16);
7452 #ifdef IXJ_DYN_ALLOC
7453                         if (ixjdebug & 0x0002)
7454                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7455                         kfree(j);
7456                         ixj[cnt] = NULL;
7457 #endif
7458                 }
7459         }
7460         if (ixjdebug & 0x0002)
7461                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7462         remove_proc_entry ("ixj", NULL);
7463 }
7464
7465 /* Typedefs */
7466 typedef struct {
7467         BYTE length;
7468         DWORD bits;
7469 } DATABLOCK;
7470
7471 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7472 {
7473         lastLCC = lastLCC & 0xfb;
7474         lastLCC = lastLCC | (byData ? 4 : 0);
7475         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7476
7477         mdelay(1);
7478         lastLCC = lastLCC | 0x01;
7479         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7480
7481         byData = byData << 1;
7482         lastLCC = lastLCC & 0xfe;
7483         mdelay(1);
7484         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7485
7486 }
7487
7488 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7489 {
7490         mdelay(1);
7491         lastLCC = lastLCC | 0x01;
7492         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7493
7494         lastLCC = lastLCC & 0xfe;
7495         mdelay(1);
7496         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7497
7498         return ((inb(wEEPROMAddress) >> 3) & 1);
7499 }
7500
7501 static BOOL PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7502 {
7503         BYTE lastLCC;
7504         WORD wEEPROMAddress = wAddress + 3;
7505         DWORD i;
7506         BYTE byResult;
7507         *pwResult = 0;
7508         lastLCC = inb(wEEPROMAddress);
7509         lastLCC = lastLCC | 0x02;
7510         lastLCC = lastLCC & 0xfe;
7511         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7512
7513         mdelay(1);              /* delay */
7514
7515         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7516         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7517         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7518         for (i = 0; i < 8; i++) {
7519                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7520                 wLoc <<= 1;
7521         }
7522
7523         for (i = 0; i < 16; i++) {
7524                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7525                 *pwResult = (*pwResult << 1) | byResult;
7526         }
7527
7528         mdelay(1);              /* another delay */
7529
7530         lastLCC = lastLCC & 0xfd;
7531         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7532
7533         return 0;
7534 }
7535
7536 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7537 {
7538         WORD wLo, wHi;
7539         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7540                 return 0;
7541         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7542                 return 0;
7543         return (((DWORD) wHi << 16) | wLo);
7544 }
7545
7546 static int dspio[IXJMAX + 1] =
7547 {
7548         0,
7549 };
7550 static int xio[IXJMAX + 1] =
7551 {
7552         0,
7553 };
7554
7555 module_param_array(dspio, int, NULL, 0);
7556 module_param_array(xio, int, NULL, 0);
7557 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7558 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7559 MODULE_LICENSE("GPL");
7560
7561 static void __exit ixj_exit(void)
7562 {
7563         cleanup();
7564 }
7565
7566 static IXJ *new_ixj(unsigned long port)
7567 {
7568         IXJ *res;
7569         if (!request_region(port, 16, "ixj DSP")) {
7570                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7571                 return NULL;
7572         }
7573         res = ixj_alloc();
7574         if (!res) {
7575                 release_region(port, 16);
7576                 printk(KERN_INFO "ixj: out of memory\n");
7577                 return NULL;
7578         }
7579         res->DSPbase = port;
7580         return res;
7581 }
7582
7583 static int __init ixj_probe_isapnp(int *cnt)
7584 {
7585         int probe = 0;
7586         int func = 0x110;
7587         struct pnp_dev *dev = NULL, *old_dev = NULL;
7588
7589         while (1) {
7590                 do {
7591                         IXJ *j;
7592                         int result;
7593
7594                         old_dev = dev;
7595                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7596                                          ISAPNP_FUNCTION(func), old_dev);
7597                         if (!dev || !dev->card)
7598                                 break;
7599                         result = pnp_device_attach(dev);
7600                         if (result < 0) {
7601                                 printk("pnp attach failed %d \n", result);
7602                                 break;
7603                         }
7604                         if (pnp_activate_dev(dev) < 0) {
7605                                 printk("pnp activate failed (out of resources?)\n");
7606                                 pnp_device_detach(dev);
7607                                 return -ENOMEM;
7608                         }
7609
7610                         if (!pnp_port_valid(dev, 0)) {
7611                                 pnp_device_detach(dev);
7612                                 return -ENODEV;
7613                         }
7614
7615                         j = new_ixj(pnp_port_start(dev, 0));
7616                         if (!j)
7617                                 break;
7618
7619                         if (func != 0x110)
7620                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7621
7622                         switch (func) {
7623                         case (0x110):
7624                                 j->cardtype = QTI_PHONEJACK;
7625                                 break;
7626                         case (0x310):
7627                                 j->cardtype = QTI_LINEJACK;
7628                                 break;
7629                         case (0x410):
7630                                 j->cardtype = QTI_PHONEJACK_LITE;
7631                                 break;
7632                         }
7633                         j->board = *cnt;
7634                         probe = ixj_selfprobe(j);
7635                         if(!probe) {
7636                                 j->serial = dev->card->serial;
7637                                 j->dev = dev;
7638                                 switch (func) {
7639                                 case 0x110:
7640                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7641                                         break;
7642                                 case 0x310:
7643                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7644                                         break;
7645                                 case 0x410:
7646                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7647                                         break;
7648                                 }
7649                         }
7650                         ++*cnt;
7651                 } while (dev);
7652                 if (func == 0x410)
7653                         break;
7654                 if (func == 0x310)
7655                         func = 0x410;
7656                 if (func == 0x110)
7657                         func = 0x310;
7658                 dev = NULL;
7659         }
7660         return probe;
7661 }
7662
7663 static int __init ixj_probe_isa(int *cnt)
7664 {
7665         int i, probe;
7666
7667         /* Use passed parameters for older kernels without PnP */
7668         for (i = 0; i < IXJMAX; i++) {
7669                 if (dspio[i]) {
7670                         IXJ *j = new_ixj(dspio[i]);
7671
7672                         if (!j)
7673                                 break;
7674
7675                         j->XILINXbase = xio[i];
7676                         j->cardtype = 0;
7677
7678                         j->board = *cnt;
7679                         probe = ixj_selfprobe(j);
7680                         j->dev = NULL;
7681                         ++*cnt;
7682                 }
7683         }
7684         return 0;
7685 }
7686
7687 static int __init ixj_probe_pci(int *cnt)
7688 {
7689         struct pci_dev *pci = NULL;
7690         int i, probe = 0;
7691         IXJ *j = NULL;
7692
7693         for (i = 0; i < IXJMAX - *cnt; i++) {
7694                 pci = pci_find_device(PCI_VENDOR_ID_QUICKNET,
7695                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
7696                 if (!pci)
7697                         break;
7698
7699                 if (pci_enable_device(pci))
7700                         break;
7701                 j = new_ixj(pci_resource_start(pci, 0));
7702                 if (!j)
7703                         break;
7704
7705                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7706                 j->XILINXbase = j->DSPbase + 0x10;
7707                 j->cardtype = QTI_PHONEJACK_PCI;
7708                 j->board = *cnt;
7709                 probe = ixj_selfprobe(j);
7710                 if (!probe)
7711                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7712                 ++*cnt;
7713         }
7714         return probe;
7715 }
7716
7717 static int __init ixj_init(void)
7718 {
7719         int cnt = 0;
7720         int probe = 0;
7721
7722         cnt = 0;
7723
7724         /* These might be no-ops, see above. */
7725         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7726                 return probe;
7727         }
7728         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7729                 return probe;
7730         }
7731         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7732                 return probe;
7733         }
7734         printk(KERN_INFO "ixj driver initialized.\n");
7735         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7736         return probe;
7737 }
7738
7739 module_init(ixj_init);
7740 module_exit(ixj_exit);
7741
7742 static void DAA_Coeff_US(IXJ *j)
7743 {
7744         int i;
7745
7746         j->daa_country = DAA_US;
7747         /*----------------------------------------------- */
7748         /* CAO */
7749         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7750                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7751         }
7752
7753 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7754         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7755         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7756         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7757         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7758         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7759         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7760         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7761         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7762 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7763         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7764         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7765         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7766         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7767         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7768         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7769         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7771 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7772         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7773         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7774         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7775         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7776         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7777         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7778         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7779         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7780 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7781         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7782         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7783         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7784         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7785         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7786         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7787         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7789 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7790         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7791         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7792         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7793         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7794 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7795         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7796         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7797         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7798         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7799 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7800         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7801         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7802         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7803         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7804         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7805         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7806         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7807         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7808 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7809         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7810         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7811         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7812         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7813         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7817 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7818         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7820         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7821         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7822         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7824         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7826 /* ;  (10K, 0.68uF) */
7827         /*  */
7828         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7829         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7830         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7831         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7832         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7833         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7834         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7835         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7836         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7837         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7838         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7839         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7840         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7841         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7842         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7843         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7844         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7846
7847         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7848         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7849         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7850         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7851         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7852
7853         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7854 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7855 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7856 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7857 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7858 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7859 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7860 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7861 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7862         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7863 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7864 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7865 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7866 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7867 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7868 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7869 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7871 /* */
7872         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7874 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7875 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7876 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7877
7878         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7879         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7880         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7881         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7882         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7883         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7884         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7885         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7886         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7887 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7888         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7889         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7890         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7891         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7892         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7893         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7894         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7896 /*  */
7897         /* ;CR Registers */
7898         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7899         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7900 /* Config. Reg. 1 (dialing)       (cr1):05 */
7901         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7902 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7903         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7904 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7905         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7906 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7907         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7908         /* Config. Reg. 5 (Version)       (cr5):02 */
7909         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7910         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7911         /*  */
7912         /* ;xr Registers */
7913         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7914
7915         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7916         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7917
7918         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7919 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7920         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7921 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7922         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7923         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7924
7925         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7926 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7927         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7928 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7929         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7930 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7931         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7932         /*  */
7933         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7934         /*                                       12,33,5A,C3 ;  770 Hz   */
7935         /*                                       13,3C,5B,32 ;  852 Hz   */
7936         /*                                       1D,1B,5C,CC ;  941 Hz   */
7937
7938         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7939         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7940         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7941         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7942 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7943         /*                                       EC,1D,52,22 ;  1336 Hz   */
7944         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7945         /*                                       9B,3B,51,25 ;  1633 Hz   */
7946         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7947         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7948         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7949         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7950 }
7951
7952 static void DAA_Coeff_UK(IXJ *j)
7953 {
7954         int i;
7955
7956         j->daa_country = DAA_UK;
7957         /*----------------------------------------------- */
7958         /* CAO */
7959         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7960                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7961         }
7962
7963 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7964         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7965         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7966         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7967         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7968         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7969         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7970         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7971         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7972 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7973         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7974         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7975         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7976         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7977         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7978         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7979         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7981 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7982         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7983         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7984         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7985         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7986         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
7987         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
7988         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
7989         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7990 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
7991         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
7992         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
7993         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
7994         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
7995         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
7996         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
7997         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7999 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8000         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8001         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8002         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8003         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8004 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8005         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8006         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8007         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8008         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8009 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8010         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8011         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8012         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8013         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8014         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8015         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8016         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8017         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8018 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8019         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8020         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8021         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8022         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8023         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8027 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8028         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8030         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8031         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8032         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8034         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8036 /* ; idle */
8037         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8038         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8039         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8040         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8041         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8042         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8043         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8044         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8045         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8046 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8047         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8048         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8049         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8050         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8051         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8052         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8053         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8055 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8056         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8057         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8058         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8059         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8060 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8061         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8062         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8063         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8064         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8065         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8066         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8067         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8068         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8069 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8070         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8071         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8072         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8073         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8074         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8075         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8076         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8078 /* ;CR Registers */
8079         /* Config. Reg. 0 (filters)        (cr0):FF */
8080         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8081 /* Config. Reg. 1 (dialing)        (cr1):05 */
8082         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8083 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8084         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8085 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8086         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8087 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8088         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8089         /* Config. Reg. 5 (Version)        (cr5):02 */
8090         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8091         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8092         /* ;xr Registers */
8093         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8094
8095         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8096         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8097
8098         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8099         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8100
8101         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8102 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8103         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8104 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8105         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8106 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8107         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8108 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8109         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8110 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8111         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8112         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8113         /*                                       12,33,5A,C3    ;  770 Hz   */
8114         /*                                       13,3C,5B,32    ;  852 Hz   */
8115         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8116
8117         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8118         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8119         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8120         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8121 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8122         /*                                       EC,1D,52,22    ;  1336 Hz   */
8123         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8124         /*                                       9B,3B,51,25    ;  1633 Hz   */
8125         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8126         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8127         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8128         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8129 }
8130
8131
8132 static void DAA_Coeff_France(IXJ *j)
8133 {
8134         int i;
8135
8136         j->daa_country = DAA_FRANCE;
8137         /*----------------------------------------------- */
8138         /* CAO */
8139         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8140                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8141         }
8142
8143 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8144         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8145         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8146         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8147         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8148         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8149         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8150         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8151         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8152 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8153         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8154         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8155         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8156         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8157         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8158         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8159         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8161 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8162         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8163         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8164         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8165         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8166         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8167         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8168         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8169         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8170 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8171         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8172         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8173         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8174         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8175         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8176         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8177         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8179 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8180         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8181         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8182         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8183         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8184 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8185         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8186         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8187         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8188         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8189 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8190         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8191         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8192         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8193         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8194         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8195         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8196         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8197         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8198 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8199         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8200         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8201         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8202         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8203         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8207 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8208         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8210         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8211         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8212         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8214         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8216 /* ; idle */
8217         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8218         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8219         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8220         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8221         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8222         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8223         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8224         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8225         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8226 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8227         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8228         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8229         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8230         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8231         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8232         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8233         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8235 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8236         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8237         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8238         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8239         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8240 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8241         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8242         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8243         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8244         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8245         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8246         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8247         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8248         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8249 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8250         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8251         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8252         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8253         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8254         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8255         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8256         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8258 /* ;CR Registers */
8259         /* Config. Reg. 0 (filters)        (cr0):FF */
8260         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8261 /* Config. Reg. 1 (dialing)        (cr1):05 */
8262         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8263 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8264         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8265 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8266         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8267 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8268         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8269         /* Config. Reg. 5 (Version)        (cr5):02 */
8270         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8271         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8272         /* ;xr Registers */
8273         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8274
8275         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8276         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8277
8278         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8279         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8280
8281         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8282 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8283         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8284 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8285         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8286 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8287         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8288 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8289         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8290 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8291         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8292         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8293         /*                                       12,33,5A,C3    ;  770 Hz   */
8294         /*                                       13,3C,5B,32    ;  852 Hz   */
8295         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8296
8297         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8298         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8299         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8300         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8301 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8302         /*                                       EC,1D,52,22    ;  1336 Hz   */
8303         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8304         /*                                       9B,3B,51,25    ;  1633 Hz   */
8305         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8306         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8307         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8308         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8309 }
8310
8311
8312 static void DAA_Coeff_Germany(IXJ *j)
8313 {
8314         int i;
8315
8316         j->daa_country = DAA_GERMANY;
8317         /*----------------------------------------------- */
8318         /* CAO */
8319         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8320                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8321         }
8322
8323 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8324         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8325         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8326         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8327         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8328         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8329         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8330         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8331         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8332 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8333         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8334         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8335         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8336         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8337         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8338         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8339         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8341 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8342         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8343         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8344         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8345         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8346         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8347         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8348         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8349         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8350 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8351         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8352         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8353         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8354         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8355         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8356         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8357         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8359 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8360         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8361         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8362         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8363         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8364 /* Bytes for AR-filter        (09): 72,42,13,4B */
8365         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8366         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8367         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8368         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8369 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8370         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8371         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8372         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8373         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8374         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8375         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8376         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8377         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8378 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8379         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8380         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8381         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8382         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8383         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8387 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8388         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8390         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8391         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8392         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8394         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8396 /* ;  (10K, 0.68uF) */
8397         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8398         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8399         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8400         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8401         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8402         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8403         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8404         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8405         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8406 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8407         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8408         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8409         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8410         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8411         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8412         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8413         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8415 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8416         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8417         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8418         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8419         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8420 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8421         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8422         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8423         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8424         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8425         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8426         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8427         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8428         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8429 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8430         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8431         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8432         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8433         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8434         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8435         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8436         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8438 /* ;CR Registers */
8439         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8440         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8441 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8442         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8443 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8444         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8445 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8446         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8447 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8448         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8449         /* Config. Reg. 5 (Version)        (cr5):02 */
8450         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8451         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8452         /* ;xr Registers */
8453         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8454
8455         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8456         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8457
8458         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8459         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8460
8461         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8462 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8463         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8464 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8465         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8466 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8467         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8468 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8469         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8470 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8471         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8472         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8473         /*                                       12,33,5A,C3    ;  770 Hz   */
8474         /*                                       13,3C,5B,32    ;  852 Hz   */
8475         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8476
8477         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8478         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8479         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8480         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8481 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8482         /*                                       EC,1D,52,22    ;  1336 Hz   */
8483         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8484         /*                                       9B,3B,51,25    ;  1633 Hz   */
8485         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8486         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8487         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8488         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8489 }
8490
8491
8492 static void DAA_Coeff_Australia(IXJ *j)
8493 {
8494         int i;
8495
8496         j->daa_country = DAA_AUSTRALIA;
8497         /*----------------------------------------------- */
8498         /* CAO */
8499         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8500                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8501         }
8502
8503 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8504         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8505         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8506         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8507         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8508         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8509         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8510         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8511         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8512 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8513         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8514         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8515         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8516         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8517         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8518         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8519         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8521 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8522         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8523         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8524         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8525         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8526         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8527         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8528         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8529         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8530 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8531         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8532         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8533         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8534         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8535         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8536         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8537         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8539 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8540         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8541         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8542         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8543         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8544 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8545         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8546         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8547         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8548         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8549 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8550         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8551         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8552         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8553         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8554         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8555         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8556         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8557         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8558 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8559         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8560         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8561         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8562         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8563         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8567 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8568         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8570         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8571         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8572         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8574         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8576 /* ;  idle */
8577         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8578         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8579         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8580         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8581         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8582         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8583         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8584         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8585         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8586 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8587         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8588         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8589         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8590         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8591         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8592         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8593         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8595 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8596         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8597         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8598         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8599         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8600 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8601         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8602         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8603         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8604         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8605         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8606         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8607         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8608         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8609 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8610         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8611         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8612         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8613         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8614         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8615         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8616         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8618 /* ;CR Registers */
8619         /* Config. Reg. 0 (filters)        (cr0):FF */
8620         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8621 /* Config. Reg. 1 (dialing)        (cr1):05 */
8622         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8623 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8624         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8625 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8626         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8627 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8628         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8629         /* Config. Reg. 5 (Version)        (cr5):02 */
8630         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8631         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8632         /* ;xr Registers */
8633         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8634
8635         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8636         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8637
8638         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8639         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8640
8641         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8642 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8643         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8644 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8645         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8646 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8647         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8648 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8649         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8650 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8651         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8652
8653         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8654         /*                                       12,33,5A,C3    ;  770 Hz   */
8655         /*                                       13,3C,5B,32    ;  852 Hz   */
8656         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8657         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8658         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8659         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8660         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8661
8662         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8663         /*                                       EC,1D,52,22    ;  1336 Hz   */
8664         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8665         /*                                       9B,3B,51,25    ;  1633 Hz   */
8666         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8667         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8668         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8669         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8670 }
8671
8672 static void DAA_Coeff_Japan(IXJ *j)
8673 {
8674         int i;
8675
8676         j->daa_country = DAA_JAPAN;
8677         /*----------------------------------------------- */
8678         /* CAO */
8679         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8680                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8681         }
8682
8683 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8684         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8685         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8686         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8687         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8688         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8689         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8690         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8691         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8692 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8693         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8694         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8695         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8696         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8697         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8698         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8699         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8701 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8702         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8703         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8704         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8705         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8706         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8707         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8708         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8709         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8710 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8711         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8712         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8713         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8714         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8715         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8716         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8717         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8719 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8720         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8721         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8722         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8723         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8724 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8725         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8726         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8727         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8728         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8729 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8730         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8731         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8732         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8733         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8734         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8735         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8736         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8737         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8738 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8739         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8740         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8741         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8742         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8743         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8747 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8748         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8750         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8751         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8752         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8754         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8756 /* ;  idle */
8757         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8758         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8759         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8760         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8761         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8762         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8763         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8764         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8765         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8766 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8767         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8768         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8769         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8770         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8771         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8772         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8773         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8775 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8776         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8777         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8778         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8779         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8780 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8781         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8782         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8783         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8784         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8785         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8786         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8787         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8788         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8789 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8790         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8791         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8792         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8793         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8794         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8795         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8796         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8798 /* ;CR Registers */
8799         /* Config. Reg. 0 (filters)        (cr0):FF */
8800         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8801 /* Config. Reg. 1 (dialing)        (cr1):05 */
8802         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8803 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8804         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8805 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8806         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8807 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8808         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8809         /* Config. Reg. 5 (Version)        (cr5):02 */
8810         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8811         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8812         /* ;xr Registers */
8813         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8814
8815         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8816         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8817
8818         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8819         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8820
8821         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8822 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8823         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8824 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8825         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8826 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8827         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8828 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8829         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8830 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8831         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8832         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8833         /*                                       12,33,5A,C3    ;  770 Hz   */
8834         /*                                       13,3C,5B,32    ;  852 Hz   */
8835         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8836
8837         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8838         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8839         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8840         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8841 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8842         /*                                       EC,1D,52,22    ;  1336 Hz   */
8843         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8844         /*                                       9B,3B,51,25    ;  1633 Hz   */
8845         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8846         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8847         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8848         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8849 }
8850
8851 static s16 tone_table[][19] =
8852 {
8853         {                       /* f20_50[] 11 */
8854                 32538,          /* A1 = 1.985962 */
8855                  -32325,        /* A2 = -0.986511 */
8856                  -343,          /* B2 = -0.010493 */
8857                  0,             /* B1 = 0 */
8858                  343,           /* B0 = 0.010493 */
8859                  32619,         /* A1 = 1.990906 */
8860                  -32520,        /* A2 = -0.992462 */
8861                  19179,         /* B2 = 0.585327 */
8862                  -19178,        /* B1 = -1.170593 */
8863                  19179,         /* B0 = 0.585327 */
8864                  32723,         /* A1 = 1.997314 */
8865                  -32686,        /* A2 = -0.997528 */
8866                  9973,          /* B2 = 0.304352 */
8867                  -9955,         /* B1 = -0.607605 */
8868                  9973,          /* B0 = 0.304352 */
8869                  7,             /* Internal filter scaling */
8870                  159,           /* Minimum in-band energy threshold */
8871                  21,            /* 21/32 in-band to broad-band ratio */
8872                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8873         },
8874         {                       /* f133_200[] 12 */
8875                 32072,          /* A1 = 1.95752 */
8876                  -31896,        /* A2 = -0.973419 */
8877                  -435,          /* B2 = -0.013294 */
8878                  0,             /* B1 = 0 */
8879                  435,           /* B0 = 0.013294 */
8880                  32188,         /* A1 = 1.9646 */
8881                  -32400,        /* A2 = -0.98877 */
8882                  15139,         /* B2 = 0.462036 */
8883                  -14882,        /* B1 = -0.908356 */
8884                  15139,         /* B0 = 0.462036 */
8885                  32473,         /* A1 = 1.981995 */
8886                  -32524,        /* A2 = -0.992584 */
8887                  23200,         /* B2 = 0.708008 */
8888                  -23113,        /* B1 = -1.410706 */
8889                  23200,         /* B0 = 0.708008 */
8890                  7,             /* Internal filter scaling */
8891                  159,           /* Minimum in-band energy threshold */
8892                  21,            /* 21/32 in-band to broad-band ratio */
8893                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8894         },
8895         {                       /* f300 13 */
8896                 31769,          /* A1 = -1.939026 */
8897                  -32584,        /* A2 = 0.994385 */
8898                  -475,          /* B2 = -0.014522 */
8899                  0,             /* B1 = 0.000000 */
8900                  475,           /* B0 = 0.014522 */
8901                  31789,         /* A1 = -1.940247 */
8902                  -32679,        /* A2 = 0.997284 */
8903                  17280,         /* B2 = 0.527344 */
8904                  -16865,        /* B1 = -1.029358 */
8905                  17280,         /* B0 = 0.527344 */
8906                  31841,         /* A1 = -1.943481 */
8907                  -32681,        /* A2 = 0.997345 */
8908                  543,           /* B2 = 0.016579 */
8909                  -525,          /* B1 = -0.032097 */
8910                  543,           /* B0 = 0.016579 */
8911                  5,             /* Internal filter scaling */
8912                  159,           /* Minimum in-band energy threshold */
8913                  21,            /* 21/32 in-band to broad-band ratio */
8914                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8915         },
8916         {                       /* f300_420[] 14 */
8917                 30750,          /* A1 = 1.876892 */
8918                  -31212,        /* A2 = -0.952515 */
8919                  -804,          /* B2 = -0.024541 */
8920                  0,             /* B1 = 0 */
8921                  804,           /* B0 = 0.024541 */
8922                  30686,         /* A1 = 1.872925 */
8923                  -32145,        /* A2 = -0.980988 */
8924                  14747,         /* B2 = 0.450043 */
8925                  -13703,        /* B1 = -0.836395 */
8926                  14747,         /* B0 = 0.450043 */
8927                  31651,         /* A1 = 1.931824 */
8928                  -32321,        /* A2 = -0.986389 */
8929                  24425,         /* B2 = 0.745422 */
8930                  -23914,        /* B1 = -1.459595 */
8931                  24427,         /* B0 = 0.745483 */
8932                  7,             /* Internal filter scaling */
8933                  159,           /* Minimum in-band energy threshold */
8934                  21,            /* 21/32 in-band to broad-band ratio */
8935                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8936         },
8937         {                       /* f330 15 */
8938                 31613,          /* A1 = -1.929565 */
8939                  -32646,        /* A2 = 0.996277 */
8940                  -185,          /* B2 = -0.005657 */
8941                  0,             /* B1 = 0.000000 */
8942                  185,           /* B0 = 0.005657 */
8943                  31620,         /* A1 = -1.929932 */
8944                  -32713,        /* A2 = 0.998352 */
8945                  19253,         /* B2 = 0.587585 */
8946                  -18566,        /* B1 = -1.133179 */
8947                  19253,         /* B0 = 0.587585 */
8948                  31674,         /* A1 = -1.933228 */
8949                  -32715,        /* A2 = 0.998413 */
8950                  2575,          /* B2 = 0.078590 */
8951                  -2495,         /* B1 = -0.152283 */
8952                  2575,          /* B0 = 0.078590 */
8953                  5,             /* Internal filter scaling */
8954                  159,           /* Minimum in-band energy threshold */
8955                  21,            /* 21/32 in-band to broad-band ratio */
8956                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8957         },
8958         {                       /* f300_425[] 16 */
8959                 30741,          /* A1 = 1.876282 */
8960                  -31475,        /* A2 = -0.960541 */
8961                  -703,          /* B2 = -0.021484 */
8962                  0,             /* B1 = 0 */
8963                  703,           /* B0 = 0.021484 */
8964                  30688,         /* A1 = 1.873047 */
8965                  -32248,        /* A2 = -0.984161 */
8966                  14542,         /* B2 = 0.443787 */
8967                  -13523,        /* B1 = -0.825439 */
8968                  14542,         /* B0 = 0.443817 */
8969                  31494,         /* A1 = 1.922302 */
8970                  -32366,        /* A2 = -0.987762 */
8971                  21577,         /* B2 = 0.658508 */
8972                  -21013,        /* B1 = -1.282532 */
8973                  21577,         /* B0 = 0.658508 */
8974                  7,             /* Internal filter scaling */
8975                  159,           /* Minimum in-band energy threshold */
8976                  21,            /* 21/32 in-band to broad-band ratio */
8977                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8978         },
8979         {                       /* f330_440[] 17 */
8980                 30627,          /* A1 = 1.869324 */
8981                  -31338,        /* A2 = -0.95636 */
8982                  -843,          /* B2 = -0.025749 */
8983                  0,             /* B1 = 0 */
8984                  843,           /* B0 = 0.025749 */
8985                  30550,         /* A1 = 1.864685 */
8986                  -32221,        /* A2 = -0.983337 */
8987                  13594,         /* B2 = 0.414886 */
8988                  -12589,        /* B1 = -0.768402 */
8989                  13594,         /* B0 = 0.414886 */
8990                  31488,         /* A1 = 1.921936 */
8991                  -32358,        /* A2 = -0.987518 */
8992                  24684,         /* B2 = 0.753296 */
8993                  -24029,        /* B1 = -1.466614 */
8994                  24684,         /* B0 = 0.753296 */
8995                  7,             /* Internal filter scaling */
8996                  159,           /* Minimum in-band energy threshold */
8997                  21,            /* 21/32 in-band to broad-band ratio */
8998                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8999         },
9000         {                       /* f340 18 */
9001                 31546,          /* A1 = -1.925476 */
9002                  -32646,        /* A2 = 0.996277 */
9003                  -445,          /* B2 = -0.013588 */
9004                  0,             /* B1 = 0.000000 */
9005                  445,           /* B0 = 0.013588 */
9006                  31551,         /* A1 = -1.925781 */
9007                  -32713,        /* A2 = 0.998352 */
9008                  23884,         /* B2 = 0.728882 */
9009                  -22979,        /* B1 = -1.402527 */
9010                  23884,         /* B0 = 0.728882 */
9011                  31606,         /* A1 = -1.929138 */
9012                  -32715,        /* A2 = 0.998413 */
9013                  863,           /* B2 = 0.026367 */
9014                  -835,          /* B1 = -0.050985 */
9015                  863,           /* B0 = 0.026367 */
9016                  5,             /* Internal filter scaling */
9017                  159,           /* Minimum in-band energy threshold */
9018                  21,            /* 21/32 in-band to broad-band ratio */
9019                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9020         },
9021         {                       /* f350_400[] 19 */
9022                 31006,          /* A1 = 1.892517 */
9023                  -32029,        /* A2 = -0.977448 */
9024                  -461,          /* B2 = -0.014096 */
9025                  0,             /* B1 = 0 */
9026                  461,           /* B0 = 0.014096 */
9027                  30999,         /* A1 = 1.892029 */
9028                  -32487,        /* A2 = -0.991455 */
9029                  11325,         /* B2 = 0.345612 */
9030                  -10682,        /* B1 = -0.651978 */
9031                  11325,         /* B0 = 0.345612 */
9032                  31441,         /* A1 = 1.919067 */
9033                  -32526,        /* A2 = -0.992615 */
9034                  24324,         /* B2 = 0.74231 */
9035                  -23535,        /* B1 = -1.436523 */
9036                  24324,         /* B0 = 0.74231 */
9037                  7,             /* Internal filter scaling */
9038                  159,           /* Minimum in-band energy threshold */
9039                  21,            /* 21/32 in-band to broad-band ratio */
9040                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9041         },
9042         {                       /* f350_440[] */
9043                 30634,          /* A1 = 1.869751 */
9044                  -31533,        /* A2 = -0.962341 */
9045                  -680,          /* B2 = -0.020782 */
9046                  0,             /* B1 = 0 */
9047                  680,           /* B0 = 0.020782 */
9048                  30571,         /* A1 = 1.865906 */
9049                  -32277,        /* A2 = -0.985016 */
9050                  12894,         /* B2 = 0.393524 */
9051                  -11945,        /* B1 = -0.729065 */
9052                  12894,         /* B0 = 0.393524 */
9053                  31367,         /* A1 = 1.91449 */
9054                  -32379,        /* A2 = -0.988129 */
9055                  23820,         /* B2 = 0.726929 */
9056                  -23104,        /* B1 = -1.410217 */
9057                  23820,         /* B0 = 0.726929 */
9058                  7,             /* Internal filter scaling */
9059                  159,           /* Minimum in-band energy threshold */
9060                  21,            /* 21/32 in-band to broad-band ratio */
9061                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9062         },
9063         {                       /* f350_450[] */
9064                 30552,          /* A1 = 1.864807 */
9065                  -31434,        /* A2 = -0.95929 */
9066                  -690,          /* B2 = -0.021066 */
9067                  0,             /* B1 = 0 */
9068                  690,           /* B0 = 0.021066 */
9069                  30472,         /* A1 = 1.859924 */
9070                  -32248,        /* A2 = -0.984161 */
9071                  13385,         /* B2 = 0.408478 */
9072                  -12357,        /* B1 = -0.754242 */
9073                  13385,         /* B0 = 0.408478 */
9074                  31358,         /* A1 = 1.914001 */
9075                  -32366,        /* A2 = -0.987732 */
9076                  26488,         /* B2 = 0.80835 */
9077                  -25692,        /* B1 = -1.568176 */
9078                  26490,         /* B0 = 0.808411 */
9079                  7,             /* Internal filter scaling */
9080                  159,           /* Minimum in-band energy threshold */
9081                  21,            /* 21/32 in-band to broad-band ratio */
9082                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9083         },
9084         {                       /* f360 */
9085                 31397,          /* A1 = -1.916321 */
9086                  -32623,        /* A2 = 0.995605 */
9087                  -117,          /* B2 = -0.003598 */
9088                  0,             /* B1 = 0.000000 */
9089                  117,           /* B0 = 0.003598 */
9090                  31403,         /* A1 = -1.916687 */
9091                  -32700,        /* A2 = 0.997925 */
9092                  3388,          /* B2 = 0.103401 */
9093                  -3240,         /* B1 = -0.197784 */
9094                  3388,          /* B0 = 0.103401 */
9095                  31463,         /* A1 = -1.920410 */
9096                  -32702,        /* A2 = 0.997986 */
9097                  13346,         /* B2 = 0.407288 */
9098                  -12863,        /* B1 = -0.785126 */
9099                  13346,         /* B0 = 0.407288 */
9100                  5,             /* Internal filter scaling */
9101                  159,           /* Minimum in-band energy threshold */
9102                  21,            /* 21/32 in-band to broad-band ratio */
9103                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9104         },
9105         {                       /* f380_420[] */
9106                 30831,          /* A1 = 1.881775 */
9107                  -32064,        /* A2 = -0.978546 */
9108                  -367,          /* B2 = -0.01122 */
9109                  0,             /* B1 = 0 */
9110                  367,           /* B0 = 0.01122 */
9111                  30813,         /* A1 = 1.880737 */
9112                  -32456,        /* A2 = -0.990509 */
9113                  11068,         /* B2 = 0.337769 */
9114                  -10338,        /* B1 = -0.631042 */
9115                  11068,         /* B0 = 0.337769 */
9116                  31214,         /* A1 = 1.905212 */
9117                  -32491,        /* A2 = -0.991577 */
9118                  16374,         /* B2 = 0.499695 */
9119                  -15781,        /* B1 = -0.963196 */
9120                  16374,         /* B0 = 0.499695 */
9121                  7,             /* Internal filter scaling */
9122                  159,           /* Minimum in-band energy threshold */
9123                  21,            /* 21/32 in-band to broad-band ratio */
9124                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9125         },
9126         {                       /* f392 */
9127                 31152,          /* A1 = -1.901428 */
9128                  -32613,        /* A2 = 0.995300 */
9129                  -314,          /* B2 = -0.009605 */
9130                  0,             /* B1 = 0.000000 */
9131                  314,           /* B0 = 0.009605 */
9132                  31156,         /* A1 = -1.901672 */
9133                  -32694,        /* A2 = 0.997742 */
9134                  28847,         /* B2 = 0.880371 */
9135                  -2734,         /* B1 = -0.166901 */
9136                  28847,         /* B0 = 0.880371 */
9137                  31225,         /* A1 = -1.905823 */
9138                  -32696,        /* A2 = 0.997803 */
9139                  462,           /* B2 = 0.014108 */
9140                  -442,          /* B1 = -0.027019 */
9141                  462,           /* B0 = 0.014108 */
9142                  5,             /* Internal filter scaling */
9143                  159,           /* Minimum in-band energy threshold */
9144                  21,            /* 21/32 in-band to broad-band ratio */
9145                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9146         },
9147         {                       /* f400_425[] */
9148                 30836,          /* A1 = 1.882141 */
9149                  -32296,        /* A2 = -0.985596 */
9150                  -324,          /* B2 = -0.009903 */
9151                  0,             /* B1 = 0 */
9152                  324,           /* B0 = 0.009903 */
9153                  30825,         /* A1 = 1.881409 */
9154                  -32570,        /* A2 = -0.993958 */
9155                  16847,         /* B2 = 0.51416 */
9156                  -15792,        /* B1 = -0.963898 */
9157                  16847,         /* B0 = 0.51416 */
9158                  31106,         /* A1 = 1.89856 */
9159                  -32584,        /* A2 = -0.994415 */
9160                  9579,          /* B2 = 0.292328 */
9161                  -9164,         /* B1 = -0.559357 */
9162                  9579,          /* B0 = 0.292328 */
9163                  7,             /* Internal filter scaling */
9164                  159,           /* Minimum in-band energy threshold */
9165                  21,            /* 21/32 in-band to broad-band ratio */
9166                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9167         },
9168         {                       /* f400_440[] */
9169                 30702,          /* A1 = 1.873962 */
9170                  -32134,        /* A2 = -0.980682 */
9171                  -517,          /* B2 = -0.015793 */
9172                  0,             /* B1 = 0 */
9173                  517,           /* B0 = 0.015793 */
9174                  30676,         /* A1 = 1.872375 */
9175                  -32520,        /* A2 = -0.992462 */
9176                  8144,          /* B2 = 0.24855 */
9177                  -7596,         /* B1 = -0.463684 */
9178                  8144,          /* B0 = 0.24855 */
9179                  31084,         /* A1 = 1.897217 */
9180                  -32547,        /* A2 = -0.993256 */
9181                  22713,         /* B2 = 0.693176 */
9182                  -21734,        /* B1 = -1.326599 */
9183                  22713,         /* B0 = 0.693176 */
9184                  7,             /* Internal filter scaling */
9185                  159,           /* Minimum in-band energy threshold */
9186                  21,            /* 21/32 in-band to broad-band ratio */
9187                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9188         },
9189         {                       /* f400_450[] */
9190                 30613,          /* A1 = 1.86853 */
9191                  -32031,        /* A2 = -0.977509 */
9192                  -618,          /* B2 = -0.018866 */
9193                  0,             /* B1 = 0 */
9194                  618,           /* B0 = 0.018866 */
9195                  30577,         /* A1 = 1.866272 */
9196                  -32491,        /* A2 = -0.991577 */
9197                  9612,          /* B2 = 0.293335 */
9198                  -8935,         /* B1 = -0.54541 */
9199                  9612,          /* B0 = 0.293335 */
9200                  31071,         /* A1 = 1.896484 */
9201                  -32524,        /* A2 = -0.992584 */
9202                  21596,         /* B2 = 0.659058 */
9203                  -20667,        /* B1 = -1.261414 */
9204                  21596,         /* B0 = 0.659058 */
9205                  7,             /* Internal filter scaling */
9206                  159,           /* Minimum in-band energy threshold */
9207                  21,            /* 21/32 in-band to broad-band ratio */
9208                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9209         },
9210         {                       /* f420 */
9211                 30914,          /* A1 = -1.886841 */
9212                  -32584,        /* A2 = 0.994385 */
9213                  -426,          /* B2 = -0.013020 */
9214                  0,             /* B1 = 0.000000 */
9215                  426,           /* B0 = 0.013020 */
9216                  30914,         /* A1 = -1.886841 */
9217                  -32679,        /* A2 = 0.997314 */
9218                  17520,         /* B2 = 0.534668 */
9219                  -16471,        /* B1 = -1.005310 */
9220                  17520,         /* B0 = 0.534668 */
9221                  31004,         /* A1 = -1.892334 */
9222                  -32683,        /* A2 = 0.997406 */
9223                  819,           /* B2 = 0.025023 */
9224                  -780,          /* B1 = -0.047619 */
9225                  819,           /* B0 = 0.025023 */
9226                  5,             /* Internal filter scaling */
9227                  159,           /* Minimum in-band energy threshold */
9228                  21,            /* 21/32 in-band to broad-band ratio */
9229                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9230         },
9231 #if 0
9232         {                       /* f425 */
9233                 30881,          /* A1 = -1.884827 */
9234                  -32603,        /* A2 = 0.994965 */
9235                  -496,          /* B2 = -0.015144 */
9236                  0,             /* B1 = 0.000000 */
9237                  496,           /* B0 = 0.015144 */
9238                  30880,         /* A1 = -1.884766 */
9239                  -32692,        /* A2 = 0.997711 */
9240                  24767,         /* B2 = 0.755859 */
9241                  -23290,        /* B1 = -1.421509 */
9242                  24767,         /* B0 = 0.755859 */
9243                  30967,         /* A1 = -1.890076 */
9244                  -32694,        /* A2 = 0.997772 */
9245                  728,           /* B2 = 0.022232 */
9246                  -691,          /* B1 = -0.042194 */
9247                  728,           /* B0 = 0.022232 */
9248                  5,             /* Internal filter scaling */
9249                  159,           /* Minimum in-band energy threshold */
9250                  21,            /* 21/32 in-band to broad-band ratio */
9251                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9252         },
9253 #else
9254         {
9255                 30850,
9256                 -32534,
9257                 -504,
9258                 0,
9259                 504,
9260                 30831,
9261                 -32669,
9262                 24303,
9263                 -22080,
9264                 24303,
9265                 30994,
9266                 -32673,
9267                 1905,
9268                 -1811,
9269                 1905,
9270                 5,
9271                 129,
9272                 17,
9273                 0xff5
9274         },
9275 #endif
9276         {                       /* f425_450[] */
9277                 30646,          /* A1 = 1.870544 */
9278                  -32327,        /* A2 = -0.986572 */
9279                  -287,          /* B2 = -0.008769 */
9280                  0,             /* B1 = 0 */
9281                  287,           /* B0 = 0.008769 */
9282                  30627,         /* A1 = 1.869324 */
9283                  -32607,        /* A2 = -0.995087 */
9284                  13269,         /* B2 = 0.404968 */
9285                  -12376,        /* B1 = -0.755432 */
9286                  13269,         /* B0 = 0.404968 */
9287                  30924,         /* A1 = 1.887512 */
9288                  -32619,        /* A2 = -0.995453 */
9289                  19950,         /* B2 = 0.608826 */
9290                  -18940,        /* B1 = -1.156006 */
9291                  19950,         /* B0 = 0.608826 */
9292                  7,             /* Internal filter scaling */
9293                  159,           /* Minimum in-band energy threshold */
9294                  21,            /* 21/32 in-band to broad-band ratio */
9295                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9296         },
9297         {                       /* f425_475[] */
9298                 30396,          /* A1 = 1.855225 */
9299                  -32014,        /* A2 = -0.97699 */
9300                  -395,          /* B2 = -0.012055 */
9301                  0,             /* B1 = 0 */
9302                  395,           /* B0 = 0.012055 */
9303                  30343,         /* A1 = 1.85199 */
9304                  -32482,        /* A2 = -0.991302 */
9305                  17823,         /* B2 = 0.543945 */
9306                  -16431,        /* B1 = -1.002869 */
9307                  17823,         /* B0 = 0.543945 */
9308                  30872,         /* A1 = 1.884338 */
9309                  -32516,        /* A2 = -0.99231 */
9310                  18124,         /* B2 = 0.553101 */
9311                  -17246,        /* B1 = -1.052673 */
9312                  18124,         /* B0 = 0.553101 */
9313                  7,             /* Internal filter scaling */
9314                  159,           /* Minimum in-band energy threshold */
9315                  21,            /* 21/32 in-band to broad-band ratio */
9316                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9317         },
9318         {                       /* f435 */
9319                 30796,          /* A1 = -1.879639 */
9320                  -32603,        /* A2 = 0.994965 */
9321                  -254,          /* B2 = -0.007762 */
9322                  0,             /* B1 = 0.000000 */
9323                  254,           /* B0 = 0.007762 */
9324                  30793,         /* A1 = -1.879456 */
9325                  -32692,        /* A2 = 0.997711 */
9326                  18934,         /* B2 = 0.577820 */
9327                  -17751,        /* B1 = -1.083496 */
9328                  18934,         /* B0 = 0.577820 */
9329                  30882,         /* A1 = -1.884888 */
9330                  -32694,        /* A2 = 0.997772 */
9331                  1858,          /* B2 = 0.056713 */
9332                  -1758,         /* B1 = -0.107357 */
9333                  1858,          /* B0 = 0.056713 */
9334                  5,             /* Internal filter scaling */
9335                  159,           /* Minimum in-band energy threshold */
9336                  21,            /* 21/32 in-band to broad-band ratio */
9337                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9338         },
9339         {                       /* f440_450[] */
9340                 30641,          /* A1 = 1.870239 */
9341                  -32458,        /* A2 = -0.99057 */
9342                  -155,          /* B2 = -0.004735 */
9343                  0,             /* B1 = 0 */
9344                  155,           /* B0 = 0.004735 */
9345                  30631,         /* A1 = 1.869568 */
9346                  -32630,        /* A2 = -0.995789 */
9347                  11453,         /* B2 = 0.349548 */
9348                  -10666,        /* B1 = -0.651001 */
9349                  11453,         /* B0 = 0.349548 */
9350                  30810,         /* A1 = 1.880554 */
9351                  -32634,        /* A2 = -0.995941 */
9352                  12237,         /* B2 = 0.373474 */
9353                  -11588,        /* B1 = -0.707336 */
9354                  12237,         /* B0 = 0.373474 */
9355                  7,             /* Internal filter scaling */
9356                  159,           /* Minimum in-band energy threshold */
9357                  21,            /* 21/32 in-band to broad-band ratio */
9358                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9359         },
9360         {                       /* f440_480[] */
9361                 30367,          /* A1 = 1.853455 */
9362                  -32147,        /* A2 = -0.981079 */
9363                  -495,          /* B2 = -0.015113 */
9364                  0,             /* B1 = 0 */
9365                  495,           /* B0 = 0.015113 */
9366                  30322,         /* A1 = 1.850769 */
9367                  -32543,        /* A2 = -0.993134 */
9368                  10031,         /* B2 = 0.306152 */
9369                  -9252,         /* B1 = -0.564728 */
9370                  10031,         /* B0 = 0.306152 */
9371                  30770,         /* A1 = 1.878052 */
9372                  -32563,        /* A2 = -0.993774 */
9373                  22674,         /* B2 = 0.691956 */
9374                  -21465,        /* B1 = -1.31012 */
9375                  22674,         /* B0 = 0.691956 */
9376                  7,             /* Internal filter scaling */
9377                  159,           /* Minimum in-band energy threshold */
9378                  21,            /* 21/32 in-band to broad-band ratio */
9379                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9380         },
9381         {                       /* f445 */
9382                 30709,          /* A1 = -1.874329 */
9383                  -32603,        /* A2 = 0.994965 */
9384                  -83,           /* B2 = -0.002545 */
9385                  0,             /* B1 = 0.000000 */
9386                  83,            /* B0 = 0.002545 */
9387                  30704,         /* A1 = -1.874084 */
9388                  -32692,        /* A2 = 0.997711 */
9389                  10641,         /* B2 = 0.324738 */
9390                  -9947,         /* B1 = -0.607147 */
9391                  10641,         /* B0 = 0.324738 */
9392                  30796,         /* A1 = -1.879639 */
9393                  -32694,        /* A2 = 0.997772 */
9394                  10079,         /* B2 = 0.307587 */
9395                  9513,          /* B1 = 0.580688 */
9396                  10079,         /* B0 = 0.307587 */
9397                  5,             /* Internal filter scaling */
9398                  159,           /* Minimum in-band energy threshold */
9399                  21,            /* 21/32 in-band to broad-band ratio */
9400                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9401         },
9402         {                       /* f450 */
9403                 30664,          /* A1 = -1.871643 */
9404                  -32603,        /* A2 = 0.994965 */
9405                  -164,          /* B2 = -0.005029 */
9406                  0,             /* B1 = 0.000000 */
9407                  164,           /* B0 = 0.005029 */
9408                  30661,         /* A1 = -1.871399 */
9409                  -32692,        /* A2 = 0.997711 */
9410                  15294,         /* B2 = 0.466736 */
9411                  -14275,        /* B1 = -0.871307 */
9412                  15294,         /* B0 = 0.466736 */
9413                  30751,         /* A1 = -1.876953 */
9414                  -32694,        /* A2 = 0.997772 */
9415                  3548,          /* B2 = 0.108284 */
9416                  -3344,         /* B1 = -0.204155 */
9417                  3548,          /* B0 = 0.108284 */
9418                  5,             /* Internal filter scaling */
9419                  159,           /* Minimum in-band energy threshold */
9420                  21,            /* 21/32 in-band to broad-band ratio */
9421                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9422         },
9423         {                       /* f452 */
9424                 30653,          /* A1 = -1.870911 */
9425                  -32615,        /* A2 = 0.995361 */
9426                  -209,          /* B2 = -0.006382 */
9427                  0,             /* B1 = 0.000000 */
9428                  209,           /* B0 = 0.006382 */
9429                  30647,         /* A1 = -1.870605 */
9430                  -32702,        /* A2 = 0.997986 */
9431                  18971,         /* B2 = 0.578979 */
9432                  -17716,        /* B1 = -1.081299 */
9433                  18971,         /* B0 = 0.578979 */
9434                  30738,         /* A1 = -1.876099 */
9435                  -32702,        /* A2 = 0.998016 */
9436                  2967,          /* B2 = 0.090561 */
9437                  -2793,         /* B1 = -0.170502 */
9438                  2967,          /* B0 = 0.090561 */
9439                  5,             /* Internal filter scaling */
9440                  159,           /* Minimum in-band energy threshold */
9441                  21,            /* 21/32 in-band to broad-band ratio */
9442                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9443         },
9444         {                       /* f475 */
9445                 30437,          /* A1 = -1.857727 */
9446                  -32603,        /* A2 = 0.994965 */
9447                  -264,          /* B2 = -0.008062 */
9448                  0,             /* B1 = 0.000000 */
9449                  264,           /* B0 = 0.008062 */
9450                  30430,         /* A1 = -1.857300 */
9451                  -32692,        /* A2 = 0.997711 */
9452                  21681,         /* B2 = 0.661682 */
9453                  -20082,        /* B1 = -1.225708 */
9454                  21681,         /* B0 = 0.661682 */
9455                  30526,         /* A1 = -1.863220 */
9456                  -32694,        /* A2 = 0.997742 */
9457                  1559,          /* B2 = 0.047600 */
9458                  -1459,         /* B1 = -0.089096 */
9459                  1559,          /* B0 = 0.047600 */
9460                  5,             /* Internal filter scaling */
9461                  159,           /* Minimum in-band energy threshold */
9462                  21,            /* 21/32 in-band to broad-band ratio */
9463                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9464         },
9465         {                       /* f480_620[] */
9466                 28975,          /* A1 = 1.768494 */
9467                  -30955,        /* A2 = -0.944672 */
9468                  -1026,         /* B2 = -0.03133 */
9469                  0,             /* B1 = 0 */
9470                  1026,          /* B0 = 0.03133 */
9471                  28613,         /* A1 = 1.746399 */
9472                  -32089,        /* A2 = -0.979309 */
9473                  14214,         /* B2 = 0.433807 */
9474                  -12202,        /* B1 = -0.744812 */
9475                  14214,         /* B0 = 0.433807 */
9476                  30243,         /* A1 = 1.845947 */
9477                  -32238,        /* A2 = -0.983856 */
9478                  24825,         /* B2 = 0.757629 */
9479                  -23402,        /* B1 = -1.428345 */
9480                  24825,         /* B0 = 0.757629 */
9481                  7,             /* Internal filter scaling */
9482                  159,           /* Minimum in-band energy threshold */
9483                  21,            /* 21/32 in-band to broad-band ratio */
9484                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9485         },
9486         {                       /* f494 */
9487                 30257,          /* A1 = -1.846741 */
9488                  -32605,        /* A2 = 0.995056 */
9489                  -249,          /* B2 = -0.007625 */
9490                  0,             /* B1 = 0.000000 */
9491                  249,           /* B0 = 0.007625 */
9492                  30247,         /* A1 = -1.846191 */
9493                  -32694,        /* A2 = 0.997772 */
9494                  18088,         /* B2 = 0.552002 */
9495                  -16652,        /* B1 = -1.016418 */
9496                  18088,         /* B0 = 0.552002 */
9497                  30348,         /* A1 = -1.852295 */
9498                  -32696,        /* A2 = 0.997803 */
9499                  2099,          /* B2 = 0.064064 */
9500                  -1953,         /* B1 = -0.119202 */
9501                  2099,          /* B0 = 0.064064 */
9502                  5,             /* Internal filter scaling */
9503                  159,           /* Minimum in-band energy threshold */
9504                  21,            /* 21/32 in-band to broad-band ratio */
9505                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9506         },
9507         {                       /* f500 */
9508                 30202,          /* A1 = -1.843431 */
9509                  -32624,        /* A2 = 0.995622 */
9510                  -413,          /* B2 = -0.012622 */
9511                  0,             /* B1 = 0.000000 */
9512                  413,           /* B0 = 0.012622 */
9513                  30191,         /* A1 = -1.842721 */
9514                  -32714,        /* A2 = 0.998364 */
9515                  25954,         /* B2 = 0.792057 */
9516                  -23890,        /* B1 = -1.458131 */
9517                  25954,         /* B0 = 0.792057 */
9518                  30296,         /* A1 = -1.849172 */
9519                  -32715,        /* A2 = 0.998397 */
9520                  2007,          /* B2 = 0.061264 */
9521                  -1860,         /* B1 = -0.113568 */
9522                  2007,          /* B0 = 0.061264 */
9523                  5,             /* Internal filter scaling */
9524                  159,           /* Minimum in-band energy threshold */
9525                  21,            /* 21/32 in-band to broad-band ratio */
9526                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9527         },
9528         {                       /* f520 */
9529                 30001,          /* A1 = -1.831116 */
9530                  -32613,        /* A2 = 0.995270 */
9531                  -155,          /* B2 = -0.004750 */
9532                  0,             /* B1 = 0.000000 */
9533                  155,           /* B0 = 0.004750 */
9534                  29985,         /* A1 = -1.830200 */
9535                  -32710,        /* A2 = 0.998260 */
9536                  6584,          /* B2 = 0.200928 */
9537                  -6018,         /* B1 = -0.367355 */
9538                  6584,          /* B0 = 0.200928 */
9539                  30105,         /* A1 = -1.837524 */
9540                  -32712,        /* A2 = 0.998291 */
9541                  23812,         /* B2 = 0.726685 */
9542                  -21936,        /* B1 = -1.338928 */
9543                  23812,         /* B0 = 0.726685 */
9544                  5,             /* Internal filter scaling */
9545                  159,           /* Minimum in-band energy threshold */
9546                  21,            /* 21/32 in-band to broad-band ratio */
9547                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9548         },
9549         {                       /* f523 */
9550                 29964,          /* A1 = -1.828918 */
9551                  -32601,        /* A2 = 0.994904 */
9552                  -101,          /* B2 = -0.003110 */
9553                  0,             /* B1 = 0.000000 */
9554                  101,           /* B0 = 0.003110 */
9555                  29949,         /* A1 = -1.827942 */
9556                  -32700,        /* A2 = 0.997925 */
9557                  11041,         /* B2 = 0.336975 */
9558                  -10075,        /* B1 = -0.614960 */
9559                  11041,         /* B0 = 0.336975 */
9560                  30070,         /* A1 = -1.835388 */
9561                  -32702,        /* A2 = 0.997986 */
9562                  16762,         /* B2 = 0.511536 */
9563                  -15437,        /* B1 = -0.942230 */
9564                  16762,         /* B0 = 0.511536 */
9565                  5,             /* Internal filter scaling */
9566                  159,           /* Minimum in-band energy threshold */
9567                  21,            /* 21/32 in-band to broad-band ratio */
9568                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9569         },
9570         {                       /* f525 */
9571                 29936,          /* A1 = -1.827209 */
9572                  -32584,        /* A2 = 0.994415 */
9573                  -91,           /* B2 = -0.002806 */
9574                  0,             /* B1 = 0.000000 */
9575                  91,            /* B0 = 0.002806 */
9576                  29921,         /* A1 = -1.826233 */
9577                  -32688,        /* A2 = 0.997559 */
9578                  11449,         /* B2 = 0.349396 */
9579                  -10426,        /* B1 = -0.636383 */
9580                  11449,         /* B0 = 0.349396 */
9581                  30045,         /* A1 = -1.833862 */
9582                  -32688,        /* A2 = 0.997589 */
9583                  13055,         /* B2 = 0.398407 */
9584                  -12028,        /* B1 = -0.734161 */
9585                  13055,         /* B0 = 0.398407 */
9586                  5,             /* Internal filter scaling */
9587                  159,           /* Minimum in-band energy threshold */
9588                  21,            /* 21/32 in-band to broad-band ratio */
9589                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9590         },
9591         {                       /* f540_660[] */
9592                 28499,          /* A1 = 1.739441 */
9593                  -31129,        /* A2 = -0.949982 */
9594                  -849,          /* B2 = -0.025922 */
9595                  0,             /* B1 = 0 */
9596                  849,           /* B0 = 0.025922 */
9597                  28128,         /* A1 = 1.716797 */
9598                  -32130,        /* A2 = -0.98056 */
9599                  14556,         /* B2 = 0.444214 */
9600                  -12251,        /* B1 = -0.747772 */
9601                  14556,         /* B0 = 0.444244 */
9602                  29667,         /* A1 = 1.81073 */
9603                  -32244,        /* A2 = -0.984039 */
9604                  23038,         /* B2 = 0.703064 */
9605                  -21358,        /* B1 = -1.303589 */
9606                  23040,         /* B0 = 0.703125 */
9607                  7,             /* Internal filter scaling */
9608                  159,           /* Minimum in-band energy threshold */
9609                  21,            /* 21/32 in-band to broad-band ratio */
9610                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9611         },
9612         {                       /* f587 */
9613                 29271,          /* A1 = -1.786560 */
9614                  -32599,        /* A2 = 0.994873 */
9615                  -490,          /* B2 = -0.014957 */
9616                  0,             /* B1 = 0.000000 */
9617                  490,           /* B0 = 0.014957 */
9618                  29246,         /* A1 = -1.785095 */
9619                  -32700,        /* A2 = 0.997925 */
9620                  28961,         /* B2 = 0.883850 */
9621                  -25796,        /* B1 = -1.574463 */
9622                  28961,         /* B0 = 0.883850 */
9623                  29383,         /* A1 = -1.793396 */
9624                  -32700,        /* A2 = 0.997955 */
9625                  1299,          /* B2 = 0.039650 */
9626                  -1169,         /* B1 = -0.071396 */
9627                  1299,          /* B0 = 0.039650 */
9628                  5,             /* Internal filter scaling */
9629                  159,           /* Minimum in-band energy threshold */
9630                  21,            /* 21/32 in-band to broad-band ratio */
9631                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9632         },
9633         {                       /* f590 */
9634                 29230,          /* A1 = -1.784058 */
9635                  -32584,        /* A2 = 0.994415 */
9636                  -418,          /* B2 = -0.012757 */
9637                  0,             /* B1 = 0.000000 */
9638                  418,           /* B0 = 0.012757 */
9639                  29206,         /* A1 = -1.782593 */
9640                  -32688,        /* A2 = 0.997559 */
9641                  36556,         /* B2 = 1.115601 */
9642                  -32478,        /* B1 = -1.982300 */
9643                  36556,         /* B0 = 1.115601 */
9644                  29345,         /* A1 = -1.791077 */
9645                  -32688,        /* A2 = 0.997589 */
9646                  897,           /* B2 = 0.027397 */
9647                  -808,          /* B1 = -0.049334 */
9648                  897,           /* B0 = 0.027397 */
9649                  5,             /* Internal filter scaling */
9650                  159,           /* Minimum in-band energy threshold */
9651                  21,            /* 21/32 in-band to broad-band ratio */
9652                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9653         },
9654         {                       /* f600 */
9655                 29116,          /* A1 = -1.777100 */
9656                  -32603,        /* A2 = 0.994965 */
9657                  -165,          /* B2 = -0.005039 */
9658                  0,             /* B1 = 0.000000 */
9659                  165,           /* B0 = 0.005039 */
9660                  29089,         /* A1 = -1.775452 */
9661                  -32708,        /* A2 = 0.998199 */
9662                  6963,          /* B2 = 0.212494 */
9663                  -6172,         /* B1 = -0.376770 */
9664                  6963,          /* B0 = 0.212494 */
9665                  29237,         /* A1 = -1.784485 */
9666                  -32710,        /* A2 = 0.998230 */
9667                  24197,         /* B2 = 0.738464 */
9668                  -21657,        /* B1 = -1.321899 */
9669                  24197,         /* B0 = 0.738464 */
9670                  5,             /* Internal filter scaling */
9671                  159,           /* Minimum in-band energy threshold */
9672                  21,            /* 21/32 in-band to broad-band ratio */
9673                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9674         },
9675         {                       /* f660 */
9676                 28376,          /* A1 = -1.731934 */
9677                  -32567,        /* A2 = 0.993896 */
9678                  -363,          /* B2 = -0.011102 */
9679                  0,             /* B1 = 0.000000 */
9680                  363,           /* B0 = 0.011102 */
9681                  28337,         /* A1 = -1.729614 */
9682                  -32683,        /* A2 = 0.997434 */
9683                  21766,         /* B2 = 0.664246 */
9684                  -18761,        /* B1 = -1.145081 */
9685                  21766,         /* B0 = 0.664246 */
9686                  28513,         /* A1 = -1.740356 */
9687                  -32686,        /* A2 = 0.997498 */
9688                  2509,          /* B2 = 0.076584 */
9689                  -2196,         /* B1 = -0.134041 */
9690                  2509,          /* B0 = 0.076584 */
9691                  5,             /* Internal filter scaling */
9692                  159,           /* Minimum in-band energy threshold */
9693                  21,            /* 21/32 in-band to broad-band ratio */
9694                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9695         },
9696         {                       /* f700 */
9697                 27844,          /* A1 = -1.699463 */
9698                  -32563,        /* A2 = 0.993744 */
9699                  -366,          /* B2 = -0.011187 */
9700                  0,             /* B1 = 0.000000 */
9701                  366,           /* B0 = 0.011187 */
9702                  27797,         /* A1 = -1.696655 */
9703                  -32686,        /* A2 = 0.997498 */
9704                  22748,         /* B2 = 0.694214 */
9705                  -19235,        /* B1 = -1.174072 */
9706                  22748,         /* B0 = 0.694214 */
9707                  27995,         /* A1 = -1.708740 */
9708                  -32688,        /* A2 = 0.997559 */
9709                  2964,          /* B2 = 0.090477 */
9710                  -2546,         /* B1 = -0.155449 */
9711                  2964,          /* B0 = 0.090477 */
9712                  5,             /* Internal filter scaling */
9713                  159,           /* Minimum in-band energy threshold */
9714                  21,            /* 21/32 in-band to broad-band ratio */
9715                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9716         },
9717         {                       /* f740 */
9718                 27297,          /* A1 = -1.666077 */
9719                  -32551,        /* A2 = 0.993408 */
9720                  -345,          /* B2 = -0.010540 */
9721                  0,             /* B1 = 0.000000 */
9722                  345,           /* B0 = 0.010540 */
9723                  27240,         /* A1 = -1.662598 */
9724                  -32683,        /* A2 = 0.997406 */
9725                  22560,         /* B2 = 0.688477 */
9726                  -18688,        /* B1 = -1.140625 */
9727                  22560,         /* B0 = 0.688477 */
9728                  27461,         /* A1 = -1.676147 */
9729                  -32684,        /* A2 = 0.997467 */
9730                  3541,          /* B2 = 0.108086 */
9731                  -2985,         /* B1 = -0.182220 */
9732                  3541,          /* B0 = 0.108086 */
9733                  5,             /* Internal filter scaling */
9734                  159,           /* Minimum in-band energy threshold */
9735                  21,            /* 21/32 in-band to broad-band ratio */
9736                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9737         },
9738         {                       /* f750 */
9739                 27155,          /* A1 = -1.657410 */
9740                  -32551,        /* A2 = 0.993408 */
9741                  -462,          /* B2 = -0.014117 */
9742                  0,             /* B1 = 0.000000 */
9743                  462,           /* B0 = 0.014117 */
9744                  27097,         /* A1 = -1.653870 */
9745                  -32683,        /* A2 = 0.997406 */
9746                  32495,         /* B2 = 0.991699 */
9747                  -26776,        /* B1 = -1.634338 */
9748                  32495,         /* B0 = 0.991699 */
9749                  27321,         /* A1 = -1.667542 */
9750                  -32684,        /* A2 = 0.997467 */
9751                  1835,          /* B2 = 0.056007 */
9752                  -1539,         /* B1 = -0.093948 */
9753                  1835,          /* B0 = 0.056007 */
9754                  5,             /* Internal filter scaling */
9755                  159,           /* Minimum in-band energy threshold */
9756                  21,            /* 21/32 in-band to broad-band ratio */
9757                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9758         },
9759         {                       /* f750_1450[] */
9760                 19298,          /* A1 = 1.177917 */
9761                  -24471,        /* A2 = -0.746796 */
9762                  -4152,         /* B2 = -0.126709 */
9763                  0,             /* B1 = 0 */
9764                  4152,          /* B0 = 0.126709 */
9765                  12902,         /* A1 = 0.787476 */
9766                  -29091,        /* A2 = -0.887817 */
9767                  12491,         /* B2 = 0.38121 */
9768                  -1794,         /* B1 = -0.109528 */
9769                  12494,         /* B0 = 0.381317 */
9770                  26291,         /* A1 = 1.604736 */
9771                  -30470,        /* A2 = -0.929901 */
9772                  28859,         /* B2 = 0.880737 */
9773                  -26084,        /* B1 = -1.592102 */
9774                  28861,         /* B0 = 0.880798 */
9775                  7,             /* Internal filter scaling */
9776                  159,           /* Minimum in-band energy threshold */
9777                  21,            /* 21/32 in-band to broad-band ratio */
9778                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9779         },
9780         {                       /* f770 */
9781                 26867,          /* A1 = -1.639832 */
9782                  -32551,        /* A2 = 0.993408 */
9783                  -123,          /* B2 = -0.003755 */
9784                  0,             /* B1 = 0.000000 */
9785                  123,           /* B0 = 0.003755 */
9786                  26805,         /* A1 = -1.636108 */
9787                  -32683,        /* A2 = 0.997406 */
9788                  17297,         /* B2 = 0.527863 */
9789                  -14096,        /* B1 = -0.860382 */
9790                  17297,         /* B0 = 0.527863 */
9791                  27034,         /* A1 = -1.650085 */
9792                  -32684,        /* A2 = 0.997467 */
9793                  12958,         /* B2 = 0.395477 */
9794                  -10756,        /* B1 = -0.656525 */
9795                  12958,         /* B0 = 0.395477 */
9796                  5,             /* Internal filter scaling */
9797                  159,           /* Minimum in-band energy threshold */
9798                  21,            /* 21/32 in-band to broad-band ratio */
9799                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9800         },
9801         {                       /* f800 */
9802                 26413,          /* A1 = -1.612122 */
9803                  -32547,        /* A2 = 0.993286 */
9804                  -223,          /* B2 = -0.006825 */
9805                  0,             /* B1 = 0.000000 */
9806                  223,           /* B0 = 0.006825 */
9807                  26342,         /* A1 = -1.607849 */
9808                  -32686,        /* A2 = 0.997498 */
9809                  6391,          /* B2 = 0.195053 */
9810                  -5120,         /* B1 = -0.312531 */
9811                  6391,          /* B0 = 0.195053 */
9812                  26593,         /* A1 = -1.623108 */
9813                  -32688,        /* A2 = 0.997559 */
9814                  23681,         /* B2 = 0.722717 */
9815                  -19328,        /* B1 = -1.179688 */
9816                  23681,         /* B0 = 0.722717 */
9817                  5,             /* Internal filter scaling */
9818                  159,           /* Minimum in-band energy threshold */
9819                  21,            /* 21/32 in-band to broad-band ratio */
9820                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9821         },
9822         {                       /* f816 */
9823                 26168,          /* A1 = -1.597209 */
9824                  -32528,        /* A2 = 0.992706 */
9825                  -235,          /* B2 = -0.007182 */
9826                  0,             /* B1 = 0.000000 */
9827                  235,           /* B0 = 0.007182 */
9828                  26092,         /* A1 = -1.592590 */
9829                  -32675,        /* A2 = 0.997192 */
9830                  20823,         /* B2 = 0.635498 */
9831                  -16510,        /* B1 = -1.007751 */
9832                  20823,         /* B0 = 0.635498 */
9833                  26363,         /* A1 = -1.609070 */
9834                  -32677,        /* A2 = 0.997253 */
9835                  6739,          /* B2 = 0.205688 */
9836                  -5459,         /* B1 = -0.333206 */
9837                  6739,          /* B0 = 0.205688 */
9838                  5,             /* Internal filter scaling */
9839                  159,           /* Minimum in-band energy threshold */
9840                  21,            /* 21/32 in-band to broad-band ratio */
9841                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9842         },
9843         {                       /* f850 */
9844                 25641,          /* A1 = -1.565063 */
9845                  -32536,        /* A2 = 0.992950 */
9846                  -121,          /* B2 = -0.003707 */
9847                  0,             /* B1 = 0.000000 */
9848                  121,           /* B0 = 0.003707 */
9849                  25560,         /* A1 = -1.560059 */
9850                  -32684,        /* A2 = 0.997437 */
9851                  18341,         /* B2 = 0.559753 */
9852                  -14252,        /* B1 = -0.869904 */
9853                  18341,         /* B0 = 0.559753 */
9854                  25837,         /* A1 = -1.577026 */
9855                  -32684,        /* A2 = 0.997467 */
9856                  16679,         /* B2 = 0.509003 */
9857                  -13232,        /* B1 = -0.807648 */
9858                  16679,         /* B0 = 0.509003 */
9859                  5,             /* Internal filter scaling */
9860                  159,           /* Minimum in-band energy threshold */
9861                  21,            /* 21/32 in-band to broad-band ratio */
9862                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9863         },
9864         {                       /* f857_1645[] */
9865                 16415,          /* A1 = 1.001953 */
9866                  -23669,        /* A2 = -0.722321 */
9867                  -4549,         /* B2 = -0.138847 */
9868                  0,             /* B1 = 0 */
9869                  4549,          /* B0 = 0.138847 */
9870                  8456,          /* A1 = 0.516174 */
9871                  -28996,        /* A2 = -0.884918 */
9872                  13753,         /* B2 = 0.419724 */
9873                  -12,           /* B1 = -0.000763 */
9874                  13757,         /* B0 = 0.419846 */
9875                  24632,         /* A1 = 1.503418 */
9876                  -30271,        /* A2 = -0.923828 */
9877                  29070,         /* B2 = 0.887146 */
9878                  -25265,        /* B1 = -1.542114 */
9879                  29073,         /* B0 = 0.887268 */
9880                  7,             /* Internal filter scaling */
9881                  159,           /* Minimum in-band energy threshold */
9882                  21,            /* 21/32 in-band to broad-band ratio */
9883                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9884         },
9885         {                       /* f900 */
9886                 24806,          /* A1 = -1.514099 */
9887                  -32501,        /* A2 = 0.991852 */
9888                  -326,          /* B2 = -0.009969 */
9889                  0,             /* B1 = 0.000000 */
9890                  326,           /* B0 = 0.009969 */
9891                  24709,         /* A1 = -1.508118 */
9892                  -32659,        /* A2 = 0.996674 */
9893                  20277,         /* B2 = 0.618835 */
9894                  -15182,        /* B1 = -0.926636 */
9895                  20277,         /* B0 = 0.618835 */
9896                  25022,         /* A1 = -1.527222 */
9897                  -32661,        /* A2 = 0.996735 */
9898                  4320,          /* B2 = 0.131836 */
9899                  -3331,         /* B1 = -0.203339 */
9900                  4320,          /* B0 = 0.131836 */
9901                  5,             /* Internal filter scaling */
9902                  159,           /* Minimum in-band energy threshold */
9903                  21,            /* 21/32 in-band to broad-band ratio */
9904                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9905         },
9906         {                       /* f900_1300[] */
9907                 19776,          /* A1 = 1.207092 */
9908                  -27437,        /* A2 = -0.837341 */
9909                  -2666,         /* B2 = -0.081371 */
9910                  0,             /* B1 = 0 */
9911                  2666,          /* B0 = 0.081371 */
9912                  16302,         /* A1 = 0.995026 */
9913                  -30354,        /* A2 = -0.926361 */
9914                  10389,         /* B2 = 0.317062 */
9915                  -3327,         /* B1 = -0.203064 */
9916                  10389,         /* B0 = 0.317062 */
9917                  24299,         /* A1 = 1.483154 */
9918                  -30930,        /* A2 = -0.943909 */
9919                  25016,         /* B2 = 0.763428 */
9920                  -21171,        /* B1 = -1.292236 */
9921                  25016,         /* B0 = 0.763428 */
9922                  7,             /* Internal filter scaling */
9923                  159,           /* Minimum in-band energy threshold */
9924                  21,            /* 21/32 in-band to broad-band ratio */
9925                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9926         },
9927         {                       /* f935_1215[] */
9928                 20554,          /* A1 = 1.254517 */
9929                  -28764,        /* A2 = -0.877838 */
9930                  -2048,         /* B2 = -0.062515 */
9931                  0,             /* B1 = 0 */
9932                  2048,          /* B0 = 0.062515 */
9933                  18209,         /* A1 = 1.11145 */
9934                  -30951,        /* A2 = -0.94458 */
9935                  9390,          /* B2 = 0.286575 */
9936                  -3955,         /* B1 = -0.241455 */
9937                  9390,          /* B0 = 0.286575 */
9938                  23902,         /* A1 = 1.458923 */
9939                  -31286,        /* A2 = -0.954803 */
9940                  23252,         /* B2 = 0.709595 */
9941                  -19132,        /* B1 = -1.167725 */
9942                  23252,         /* B0 = 0.709595 */
9943                  7,             /* Internal filter scaling */
9944                  159,           /* Minimum in-band energy threshold */
9945                  21,            /* 21/32 in-band to broad-band ratio */
9946                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9947         },
9948         {                       /* f941_1477[] */
9949                 17543,          /* A1 = 1.07074 */
9950                  -26220,        /* A2 = -0.800201 */
9951                  -3298,         /* B2 = -0.100647 */
9952                  0,             /* B1 = 0 */
9953                  3298,          /* B0 = 0.100647 */
9954                  12423,         /* A1 = 0.75827 */
9955                  -30036,        /* A2 = -0.916626 */
9956                  12651,         /* B2 = 0.386078 */
9957                  -2444,         /* B1 = -0.14917 */
9958                  12653,         /* B0 = 0.386154 */
9959                  23518,         /* A1 = 1.435425 */
9960                  -30745,        /* A2 = -0.938293 */
9961                  27282,         /* B2 = 0.832581 */
9962                  -22529,        /* B1 = -1.375122 */
9963                  27286,         /* B0 = 0.832703 */
9964                  7,             /* Internal filter scaling */
9965                  159,           /* Minimum in-band energy threshold */
9966                  21,            /* 21/32 in-band to broad-band ratio */
9967                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9968         },
9969         {                       /* f942 */
9970                 24104,          /* A1 = -1.471252 */
9971                  -32507,        /* A2 = 0.992065 */
9972                  -351,          /* B2 = -0.010722 */
9973                  0,             /* B1 = 0.000000 */
9974                  351,           /* B0 = 0.010722 */
9975                  23996,         /* A1 = -1.464600 */
9976                  -32671,        /* A2 = 0.997040 */
9977                  22848,         /* B2 = 0.697266 */
9978                  -16639,        /* B1 = -1.015564 */
9979                  22848,         /* B0 = 0.697266 */
9980                  24332,         /* A1 = -1.485168 */
9981                  -32673,        /* A2 = 0.997101 */
9982                  4906,          /* B2 = 0.149727 */
9983                  -3672,         /* B1 = -0.224174 */
9984                  4906,          /* B0 = 0.149727 */
9985                  5,             /* Internal filter scaling */
9986                  159,           /* Minimum in-band energy threshold */
9987                  21,            /* 21/32 in-band to broad-band ratio */
9988                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9989         },
9990         {                       /* f950 */
9991                 23967,          /* A1 = -1.462830 */
9992                  -32507,        /* A2 = 0.992065 */
9993                  -518,          /* B2 = -0.015821 */
9994                  0,             /* B1 = 0.000000 */
9995                  518,           /* B0 = 0.015821 */
9996                  23856,         /* A1 = -1.456055 */
9997                  -32671,        /* A2 = 0.997040 */
9998                  26287,         /* B2 = 0.802246 */
9999                  -19031,        /* B1 = -1.161560 */
10000                  26287,         /* B0 = 0.802246 */
10001                  24195,         /* A1 = -1.476746 */
10002                  -32673,        /* A2 = 0.997101 */
10003                  2890,          /* B2 = 0.088196 */
10004                  -2151,         /* B1 = -0.131317 */
10005                  2890,          /* B0 = 0.088196 */
10006                  5,             /* Internal filter scaling */
10007                  159,           /* Minimum in-band energy threshold */
10008                  21,            /* 21/32 in-band to broad-band ratio */
10009                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10010         },
10011         {                       /* f950_1400[] */
10012                 18294,          /* A1 = 1.116638 */
10013                  -26962,        /* A2 = -0.822845 */
10014                  -2914,         /* B2 = -0.088936 */
10015                  0,             /* B1 = 0 */
10016                  2914,          /* B0 = 0.088936 */
10017                  14119,         /* A1 = 0.861786 */
10018                  -30227,        /* A2 = -0.922455 */
10019                  11466,         /* B2 = 0.349945 */
10020                  -2833,         /* B1 = -0.172943 */
10021                  11466,         /* B0 = 0.349945 */
10022                  23431,         /* A1 = 1.430115 */
10023                  -30828,        /* A2 = -0.940796 */
10024                  25331,         /* B2 = 0.773071 */
10025                  -20911,        /* B1 = -1.276367 */
10026                  25331,         /* B0 = 0.773071 */
10027                  7,             /* Internal filter scaling */
10028                  159,           /* Minimum in-band energy threshold */
10029                  21,            /* 21/32 in-band to broad-band ratio */
10030                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10031         },
10032         {                       /* f975 */
10033                 23521,          /* A1 = -1.435608 */
10034                  -32489,        /* A2 = 0.991516 */
10035                  -193,          /* B2 = -0.005915 */
10036                  0,             /* B1 = 0.000000 */
10037                  193,           /* B0 = 0.005915 */
10038                  23404,         /* A1 = -1.428467 */
10039                  -32655,        /* A2 = 0.996582 */
10040                  17740,         /* B2 = 0.541412 */
10041                  -12567,        /* B1 = -0.767029 */
10042                  17740,         /* B0 = 0.541412 */
10043                  23753,         /* A1 = -1.449829 */
10044                  -32657,        /* A2 = 0.996613 */
10045                  9090,          /* B2 = 0.277405 */
10046                  -6662,         /* B1 = -0.406647 */
10047                  9090,          /* B0 = 0.277405 */
10048                  5,             /* Internal filter scaling */
10049                  159,           /* Minimum in-band energy threshold */
10050                  21,            /* 21/32 in-band to broad-band ratio */
10051                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10052         },
10053         {                       /* f1000 */
10054                 23071,          /* A1 = -1.408203 */
10055                  -32489,        /* A2 = 0.991516 */
10056                  -293,          /* B2 = -0.008965 */
10057                  0,             /* B1 = 0.000000 */
10058                  293,           /* B0 = 0.008965 */
10059                  22951,         /* A1 = -1.400818 */
10060                  -32655,        /* A2 = 0.996582 */
10061                  5689,          /* B2 = 0.173645 */
10062                  -3951,         /* B1 = -0.241150 */
10063                  5689,          /* B0 = 0.173645 */
10064                  23307,         /* A1 = -1.422607 */
10065                  -32657,        /* A2 = 0.996613 */
10066                  18692,         /* B2 = 0.570435 */
10067                  -13447,        /* B1 = -0.820770 */
10068                  18692,         /* B0 = 0.570435 */
10069                  5,             /* Internal filter scaling */
10070                  159,           /* Minimum in-band energy threshold */
10071                  21,            /* 21/32 in-band to broad-band ratio */
10072                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10073         },
10074         {                       /* f1020 */
10075                 22701,          /* A1 = -1.385620 */
10076                  -32474,        /* A2 = 0.991058 */
10077                  -292,          /* B2 = -0.008933 */
10078                  0,             /*163840      , B1 = 10.000000 */
10079                  292,           /* B0 = 0.008933 */
10080                  22564,         /* A1 = -1.377258 */
10081                  -32655,        /* A2 = 0.996552 */
10082                  20756,         /* B2 = 0.633423 */
10083                  -14176,        /* B1 = -0.865295 */
10084                  20756,         /* B0 = 0.633423 */
10085                  22960,         /* A1 = -1.401428 */
10086                  -32657,        /* A2 = 0.996613 */
10087                  6520,          /* B2 = 0.198990 */
10088                  -4619,         /* B1 = -0.281937 */
10089                  6520,          /* B0 = 0.198990 */
10090                  5,             /* Internal filter scaling */
10091                  159,           /* Minimum in-band energy threshold */
10092                  21,            /* 21/32 in-band to broad-band ratio */
10093                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10094         },
10095         {                       /* f1050 */
10096                 22142,          /* A1 = -1.351501 */
10097                  -32474,        /* A2 = 0.991058 */
10098                  -147,          /* B2 = -0.004493 */
10099                  0,             /* B1 = 0.000000 */
10100                  147,           /* B0 = 0.004493 */
10101                  22000,         /* A1 = -1.342834 */
10102                  -32655,        /* A2 = 0.996552 */
10103                  15379,         /* B2 = 0.469360 */
10104                  -10237,        /* B1 = -0.624847 */
10105                  15379,         /* B0 = 0.469360 */
10106                  22406,         /* A1 = -1.367554 */
10107                  -32657,        /* A2 = 0.996613 */
10108                  17491,         /* B2 = 0.533783 */
10109                  -12096,        /* B1 = -0.738312 */
10110                  17491,         /* B0 = 0.533783 */
10111                  5,             /* Internal filter scaling */
10112                  159,           /* Minimum in-band energy threshold */
10113                  21,            /* 21/32 in-band to broad-band ratio */
10114                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10115         },
10116         {                       /* f1100_1750[] */
10117                 12973,          /* A1 = 0.79184 */
10118                  -24916,        /* A2 = -0.760376 */
10119                  6655,          /* B2 = 0.203102 */
10120                  367,           /* B1 = 0.0224 */
10121                  6657,          /* B0 = 0.203171 */
10122                  5915,          /* A1 = 0.361053 */
10123                  -29560,        /* A2 = -0.90213 */
10124                  -7777,         /* B2 = -0.23735 */
10125                  0,             /* B1 = 0 */
10126                  7777,          /* B0 = 0.23735 */
10127                  20510,         /* A1 = 1.251892 */
10128                  -30260,        /* A2 = -0.923462 */
10129                  26662,         /* B2 = 0.81366 */
10130                  -20573,        /* B1 = -1.255737 */
10131                  26668,         /* B0 = 0.813843 */
10132                  7,             /* Internal filter scaling */
10133                  159,           /* Minimum in-band energy threshold */
10134                  21,            /* 21/32 in-band to broad-band ratio */
10135                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10136         },
10137         {                       /* f1140 */
10138                 20392,          /* A1 = -1.244629 */
10139                  -32460,        /* A2 = 0.990601 */
10140                  -270,          /* B2 = -0.008240 */
10141                  0,             /* B1 = 0.000000 */
10142                  270,           /* B0 = 0.008240 */
10143                  20218,         /* A1 = -1.234009 */
10144                  -32655,        /* A2 = 0.996582 */
10145                  21337,         /* B2 = 0.651154 */
10146                  -13044,        /* B1 = -0.796143 */
10147                  21337,         /* B0 = 0.651154 */
10148                  20684,         /* A1 = -1.262512 */
10149                  -32657,        /* A2 = 0.996643 */
10150                  8572,          /* B2 = 0.261612 */
10151                  -5476,         /* B1 = -0.334244 */
10152                  8572,          /* B0 = 0.261612 */
10153                  5,             /* Internal filter scaling */
10154                  159,           /* Minimum in-band energy threshold */
10155                  21,            /* 21/32 in-band to broad-band ratio */
10156                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10157         },
10158         {                       /* f1200 */
10159                 19159,          /* A1 = -1.169373 */
10160                  -32456,        /* A2 = 0.990509 */
10161                  -335,          /* B2 = -0.010252 */
10162                  0,             /* B1 = 0.000000 */
10163                  335,           /* B0 = 0.010252 */
10164                  18966,         /* A1 = -1.157593 */
10165                  -32661,        /* A2 = 0.996735 */
10166                  6802,          /* B2 = 0.207588 */
10167                  -3900,         /* B1 = -0.238098 */
10168                  6802,          /* B0 = 0.207588 */
10169                  19467,         /* A1 = -1.188232 */
10170                  -32661,        /* A2 = 0.996765 */
10171                  25035,         /* B2 = 0.764008 */
10172                  -15049,        /* B1 = -0.918579 */
10173                  25035,         /* B0 = 0.764008 */
10174                  5,             /* Internal filter scaling */
10175                  159,           /* Minimum in-band energy threshold */
10176                  21,            /* 21/32 in-band to broad-band ratio */
10177                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10178         },
10179         {                       /* f1209 */
10180                 18976,          /* A1 = -1.158264 */
10181                  -32439,        /* A2 = 0.989990 */
10182                  -183,          /* B2 = -0.005588 */
10183                  0,             /* B1 = 0.000000 */
10184                  183,           /* B0 = 0.005588 */
10185                  18774,         /* A1 = -1.145874 */
10186                  -32650,        /* A2 = 0.996429 */
10187                  15468,         /* B2 = 0.472076 */
10188                  -8768,         /* B1 = -0.535217 */
10189                  15468,         /* B0 = 0.472076 */
10190                  19300,         /* A1 = -1.177979 */
10191                  -32652,        /* A2 = 0.996490 */
10192                  19840,         /* B2 = 0.605499 */
10193                  -11842,        /* B1 = -0.722809 */
10194                  19840,         /* B0 = 0.605499 */
10195                  5,             /* Internal filter scaling */
10196                  159,           /* Minimum in-band energy threshold */
10197                  21,            /* 21/32 in-band to broad-band ratio */
10198                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10199         },
10200         {                       /* f1330 */
10201                 16357,          /* A1 = -0.998413 */
10202                  -32368,        /* A2 = 0.987793 */
10203                  -217,          /* B2 = -0.006652 */
10204                  0,             /* B1 = 0.000000 */
10205                  217,           /* B0 = 0.006652 */
10206                  16107,         /* A1 = -0.983126 */
10207                  -32601,        /* A2 = 0.994904 */
10208                  11602,         /* B2 = 0.354065 */
10209                  -5555,         /* B1 = -0.339111 */
10210                  11602,         /* B0 = 0.354065 */
10211                  16722,         /* A1 = -1.020630 */
10212                  -32603,        /* A2 = 0.994965 */
10213                  15574,         /* B2 = 0.475311 */
10214                  -8176,         /* B1 = -0.499069 */
10215                  15574,         /* B0 = 0.475311 */
10216                  5,             /* Internal filter scaling */
10217                  159,           /* Minimum in-band energy threshold */
10218                  21,            /* 21/32 in-band to broad-band ratio */
10219                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10220         },
10221         {                       /* f1336 */
10222                 16234,          /* A1 = -0.990875 */
10223                  32404,         /* A2 = -0.988922 */
10224                  -193,          /* B2 = -0.005908 */
10225                  0,             /* B1 = 0.000000 */
10226                  193,           /* B0 = 0.005908 */
10227                  15986,         /* A1 = -0.975769 */
10228                  -32632,        /* A2 = 0.995880 */
10229                  18051,         /* B2 = 0.550903 */
10230                  -8658,         /* B1 = -0.528473 */
10231                  18051,         /* B0 = 0.550903 */
10232                  16591,         /* A1 = -1.012695 */
10233                  -32634,        /* A2 = 0.995941 */
10234                  15736,         /* B2 = 0.480240 */
10235                  -8125,         /* B1 = -0.495926 */
10236                  15736,         /* B0 = 0.480240 */
10237                  5,             /* Internal filter scaling */
10238                  159,           /* Minimum in-band energy threshold */
10239                  21,            /* 21/32 in-band to broad-band ratio */
10240                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10241         },
10242         {                       /* f1366 */
10243                 15564,          /* A1 = -0.949982 */
10244                  -32404,        /* A2 = 0.988922 */
10245                  -269,          /* B2 = -0.008216 */
10246                  0,             /* B1 = 0.000000 */
10247                  269,           /* B0 = 0.008216 */
10248                  15310,         /* A1 = -0.934479 */
10249                  -32632,        /* A2 = 0.995880 */
10250                  10815,         /* B2 = 0.330063 */
10251                  -4962,         /* B1 = -0.302887 */
10252                  10815,         /* B0 = 0.330063 */
10253                  15924,         /* A1 = -0.971924 */
10254                  -32634,        /* A2 = 0.995941 */
10255                  18880,         /* B2 = 0.576172 */
10256                  -9364,         /* B1 = -0.571594 */
10257                  18880,         /* B0 = 0.576172 */
10258                  5,             /* Internal filter scaling */
10259                  159,           /* Minimum in-band energy threshold */
10260                  21,            /* 21/32 in-band to broad-band ratio */
10261                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10262         },
10263         {                       /* f1380 */
10264                 15247,          /* A1 = -0.930603 */
10265                  -32397,        /* A2 = 0.988708 */
10266                  -244,          /* B2 = -0.007451 */
10267                  0,             /* B1 = 0.000000 */
10268                  244,           /* B0 = 0.007451 */
10269                  14989,         /* A1 = -0.914886 */
10270                  -32627,        /* A2 = 0.995697 */
10271                  18961,         /* B2 = 0.578644 */
10272                  -8498,         /* B1 = -0.518707 */
10273                  18961,         /* B0 = 0.578644 */
10274                  15608,         /* A1 = -0.952667 */
10275                  -32628,        /* A2 = 0.995758 */
10276                  11145,         /* B2 = 0.340134 */
10277                  -5430,         /* B1 = -0.331467 */
10278                  11145,         /* B0 = 0.340134 */
10279                  5,             /* Internal filter scaling */
10280                  159,           /* Minimum in-band energy threshold */
10281                  21,            /* 21/32 in-band to broad-band ratio */
10282                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10283         },
10284         {                       /* f1400 */
10285                 14780,          /* A1 = -0.902130 */
10286                  -32393,        /* A2 = 0.988586 */
10287                  -396,          /* B2 = -0.012086 */
10288                  0,             /* B1 = 0.000000 */
10289                  396,           /* B0 = 0.012086 */
10290                  14510,         /* A1 = -0.885651 */
10291                  -32630,        /* A2 = 0.995819 */
10292                  6326,          /* B2 = 0.193069 */
10293                  -2747,         /* B1 = -0.167671 */
10294                  6326,          /* B0 = 0.193069 */
10295                  15154,         /* A1 = -0.924957 */
10296                  -32632,        /* A2 = 0.995850 */
10297                  23235,         /* B2 = 0.709076 */
10298                  -10983,        /* B1 = -0.670380 */
10299                  23235,         /* B0 = 0.709076 */
10300                  5,             /* Internal filter scaling */
10301                  159,           /* Minimum in-band energy threshold */
10302                  21,            /* 21/32 in-band to broad-band ratio */
10303                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10304         },
10305         {                       /* f1477 */
10306                 13005,          /* A1 = -0.793793 */
10307                  -32368,        /* A2 = 0.987823 */
10308                  -500,          /* B2 = -0.015265 */
10309                  0,             /* B1 = 0.000000 */
10310                  500,           /* B0 = 0.015265 */
10311                  12708,         /* A1 = -0.775665 */
10312                  -32615,        /* A2 = 0.995331 */
10313                  11420,         /* B2 = 0.348526 */
10314                  -4306,         /* B1 = -0.262833 */
10315                  11420,         /* B0 = 0.348526 */
10316                  13397,         /* A1 = -0.817688 */
10317                  -32615,        /* A2 = 0.995361 */
10318                  9454,          /* B2 = 0.288528 */
10319                  -3981,         /* B1 = -0.243027 */
10320                  9454,          /* B0 = 0.288528 */
10321                  5,             /* Internal filter scaling */
10322                  159,           /* Minimum in-band energy threshold */
10323                  21,            /* 21/32 in-band to broad-band ratio */
10324                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10325         },
10326         {                       /* f1600 */
10327                 10046,          /* A1 = -0.613190 */
10328                  -32331,        /* A2 = 0.986694 */
10329                  -455,          /* B2 = -0.013915 */
10330                  0,             /* B1 = 0.000000 */
10331                  455,           /* B0 = 0.013915 */
10332                  9694,          /* A1 = -0.591705 */
10333                  -32601,        /* A2 = 0.994934 */
10334                  6023,          /* B2 = 0.183815 */
10335                  -1708,         /* B1 = -0.104279 */
10336                  6023,          /* B0 = 0.183815 */
10337                  10478,         /* A1 = -0.639587 */
10338                  -32603,        /* A2 = 0.994965 */
10339                  22031,         /* B2 = 0.672333 */
10340                  -7342,         /* B1 = -0.448151 */
10341                  22031,         /* B0 = 0.672333 */
10342                  5,             /* Internal filter scaling */
10343                  159,           /* Minimum in-band energy threshold */
10344                  21,            /* 21/32 in-band to broad-band ratio */
10345                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10346         },
10347         {                       /* f1633_1638[] */
10348                 9181,           /* A1 = 0.560394 */
10349                  -32256,        /* A2 = -0.984375 */
10350                  -556,          /* B2 = -0.016975 */
10351                  0,             /* B1 = 0 */
10352                  556,           /* B0 = 0.016975 */
10353                  8757,          /* A1 = 0.534515 */
10354                  -32574,        /* A2 = -0.99408 */
10355                  8443,          /* B2 = 0.25769 */
10356                  -2135,         /* B1 = -0.130341 */
10357                  8443,          /* B0 = 0.25769 */
10358                  9691,          /* A1 = 0.591522 */
10359                  -32574,        /* A2 = -0.99411 */
10360                  15446,         /* B2 = 0.471375 */
10361                  -4809,         /* B1 = -0.293579 */
10362                  15446,         /* B0 = 0.471375 */
10363                  7,             /* Internal filter scaling */
10364                  159,           /* Minimum in-band energy threshold */
10365                  21,            /* 21/32 in-band to broad-band ratio */
10366                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10367         },
10368         {                       /* f1800 */
10369                 5076,           /* A1 = -0.309875 */
10370                  -32304,        /* A2 = 0.985840 */
10371                  -508,          /* B2 = -0.015503 */
10372                  0,             /* B1 = 0.000000 */
10373                  508,           /* B0 = 0.015503 */
10374                  4646,          /* A1 = -0.283600 */
10375                  -32605,        /* A2 = 0.995026 */
10376                  6742,          /* B2 = 0.205780 */
10377                  -878,          /* B1 = -0.053635 */
10378                  6742,          /* B0 = 0.205780 */
10379                  5552,          /* A1 = -0.338928 */
10380                  -32605,        /* A2 = 0.995056 */
10381                  23667,         /* B2 = 0.722260 */
10382                  -4297,         /* B1 = -0.262329 */
10383                  23667,         /* B0 = 0.722260 */
10384                  5,             /* Internal filter scaling */
10385                  159,           /* Minimum in-band energy threshold */
10386                  21,            /* 21/32 in-band to broad-band ratio */
10387                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10388         },
10389         {                       /* f1860 */
10390                 3569,           /* A1 = -0.217865 */
10391                  -32292,        /* A2 = 0.985504 */
10392                  -239,          /* B2 = -0.007322 */
10393                  0,             /* B1 = 0.000000 */
10394                  239,           /* B0 = 0.007322 */
10395                  3117,          /* A1 = -0.190277 */
10396                  -32603,        /* A2 = 0.994965 */
10397                  18658,         /* B2 = 0.569427 */
10398                  -1557,         /* B1 = -0.095032 */
10399                  18658,         /* B0 = 0.569427 */
10400                  4054,          /* A1 = -0.247437 */
10401                  -32603,        /* A2 = 0.994965 */
10402                  18886,         /* B2 = 0.576385 */
10403                  -2566,         /* B1 = -0.156647 */
10404                  18886,         /* B0 = 0.576385 */
10405                  5,             /* Internal filter scaling */
10406                  159,           /* Minimum in-band energy threshold */
10407                  21,            /* 21/32 in-band to broad-band ratio */
10408                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10409         },
10410 };
10411 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10412 {
10413         unsigned short cmd;
10414         int cnt, max;
10415
10416         if (jf->filter > 3) {
10417                 return -1;
10418         }
10419         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10420
10421                 return -1;
10422         if (!jf->enable) {
10423                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10424
10425                         return -1;
10426                 else
10427                         return 0;
10428         } else {
10429                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10430
10431                         return -1;
10432                 /* Select the filter (f0 - f3) to use. */
10433                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10434                         return -1;
10435         }
10436         if (jf->freq < 12 && jf->freq > 3) {
10437                 /* Select the frequency for the selected filter. */
10438                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10439                         return -1;
10440         } else if (jf->freq > 11) {
10441                 /* We need to load a programmable filter set for undefined */
10442                 /* frequencies.  So we will point the filter to a programmable set. */
10443                 /* Since there are only 4 filters and 4 programmable sets, we will */
10444                 /* just point the filter to the same number set and program it for the */
10445                 /* frequency we want. */
10446                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10447                         return -1;
10448                 if (j->ver.low != 0x12) {
10449                         cmd = 0x515B;
10450                         max = 19;
10451                 } else {
10452                         cmd = 0x515E;
10453                         max = 15;
10454                 }
10455                 if (ixj_WriteDSPCommand(cmd, j))
10456                         return -1;
10457                 for (cnt = 0; cnt < max; cnt++) {
10458                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10459                                 return -1;
10460                 }
10461         }
10462         j->filter_en[jf->filter] = jf->enable;
10463         return 0;
10464 }
10465
10466 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10467 {
10468         unsigned short cmd;
10469         int cnt, max;
10470         if (jfr->filter > 3) {
10471                 return -1;
10472         }
10473         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10474                 return -1;
10475
10476         if (!jfr->enable) {
10477                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10478                         return -1;
10479                 else
10480                         return 0;
10481         } else {
10482                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10483                         return -1;
10484                 /* Select the filter (f0 - f3) to use. */
10485                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10486                         return -1;
10487         }
10488         /* We need to load a programmable filter set for undefined */
10489         /* frequencies.  So we will point the filter to a programmable set. */
10490         /* Since there are only 4 filters and 4 programmable sets, we will */
10491         /* just point the filter to the same number set and program it for the */
10492         /* frequency we want. */
10493         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10494                 return -1;
10495         if (j->ver.low != 0x12) {
10496                 cmd = 0x515B;
10497                 max = 19;
10498         } else {
10499                 cmd = 0x515E;
10500                 max = 15;
10501         }
10502         if (ixj_WriteDSPCommand(cmd, j))
10503                 return -1;
10504         for (cnt = 0; cnt < max; cnt++) {
10505                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10506                         return -1;
10507         }
10508         j->filter_en[jfr->filter] = jfr->enable;
10509         return 0;
10510 }
10511
10512 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10513 {
10514         int freq0, freq1;
10515         unsigned short data;
10516         if (ti->freq0) {
10517                 freq0 = ti->freq0;
10518         } else {
10519                 freq0 = 0x7FFF;
10520         }
10521
10522         if (ti->freq1) {
10523                 freq1 = ti->freq1;
10524         } else {
10525                 freq1 = 0x7FFF;
10526         }
10527
10528         if(ti->tone_index > 12 && ti->tone_index < 28)
10529         {
10530                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10531                         return -1;
10532                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10533                         return -1;
10534                 data = freq0;
10535                 if (ixj_WriteDSPCommand(data, j))
10536                         return -1;
10537                 data = freq1;
10538                 if (ixj_WriteDSPCommand(data, j))
10539                         return -1;
10540         }
10541         return freq0;
10542 }
10543