drivers/telephony/ixj.c

   1 /****************************************************************************
   2  *    ixj.c
   3  *
   4  * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
   5  * including the Internet PhoneJACK, Internet PhoneJACK Lite,
   6  * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
   7  * SmartCABLE
   8  *
   9  *    (c) Copyright 1999-2001  Quicknet Technologies, Inc.
  10  *
  11  *    This program is free software; you can redistribute it and/or
  12  *    modify it under the terms of the GNU General Public License
  13  *    as published by the Free Software Foundation; either version
  14  *    2 of the License, or (at your option) any later version.
  15  *
  16  * Author:          Ed Okerson, <eokerson@quicknet.net>
  17  *
  18  * Contributors:    Greg Herlein, <gherlein@quicknet.net>
  19  *                  David W. Erhart, <derhart@quicknet.net>
  20  *                  John Sellers, <jsellers@quicknet.net>
  21  *                  Mike Preston, <mpreston@quicknet.net>
  22  *
  23  * Fixes:           David Huggins-Daines, <dhd@cepstral.com>
  24  *                  Fabio Ferrari, <fabio.ferrari@digitro.com.br>
  25  *                  Artis Kugevics, <artis@mt.lv>
  26  *                  Daniele Bellucci, <bellucda@tiscali.it>
  27  *
  28  * More information about the hardware related to this driver can be found
  29  * at our website:    http://www.quicknet.net
  30  *
  31  * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
  32  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  33  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
  34  * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  37  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  38  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  39  * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
  40  * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  41  *
  42  ***************************************************************************/
  43
  44 /*
  45  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  46  * Audit some copy_*_user and minor cleanup.
  47  *
  48  * Revision 4.7  2001/08/13 06:19:33  craigs
  49  * Added additional changes from Alan Cox and John Anderson for
  50  * 2.2 to 2.4 cleanup and bounds checking
  51  *
  52  * Revision 4.6  2001/08/13 01:05:05  craigs
  53  * Really fixed PHONE_QUERY_CODEC problem this time
  54  *
  55  * Revision 4.5  2001/08/13 00:11:03  craigs
  56  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  57  *
  58  * Revision 4.4  2001/08/07 07:58:12  craigs
  59  * Changed back to three digit version numbers
  60  * Added tagbuild target to allow automatic and easy tagging of versions
  61  *
  62  * Revision 4.3  2001/08/07 07:24:47  craigs
  63  * Added ixj-ver.h to allow easy configuration management of driver
  64  * Added display of version number in /prox/ixj
  65  *
  66  * Revision 4.2  2001/08/06 07:07:19  craigs
  67  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  68  * behaviour of returning int rather than short *
  69  *
  70  * Revision 4.1  2001/08/05 00:17:37  craigs
  71  * More changes for correct PCMCIA installation
  72  * Start of changes for backward Linux compatibility
  73  *
  74  * Revision 4.0  2001/08/04 12:33:12  craigs
  75  * New version using GNU autoconf
  76  *
  77  * Revision 3.105  2001/07/20 23:14:32  eokerson
  78  * More work on CallerID generation when using ring cadences.
  79  *
  80  * Revision 3.104  2001/07/06 01:33:55  eokerson
  81  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  82  *
  83  * Revision 3.103  2001/07/05 19:20:16  eokerson
  84  * Updated HOWTO
  85  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  86  *
  87  * Revision 3.102  2001/07/03 23:51:21  eokerson
  88  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  89  *
  90  * Revision 3.101  2001/07/02 19:26:56  eokerson
  91  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  92  *
  93  * Revision 3.100  2001/07/02 19:18:27  eokerson
  94  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  95  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  96  * Fixed speaker mode on Internet LineJACK.
  97  *
  98  * Revision 3.99  2001/05/09 14:11:16  eokerson
  99  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 100  *
 101  * Revision 3.98  2001/05/08 19:55:33  eokerson
 102  * Fixed POTS hookstate detection while it is connected to PSTN port.
 103  *
 104  * Revision 3.97  2001/05/08 00:01:04  eokerson
 105  * Fixed kernel oops when sending caller ID data.
 106  *
 107  * Revision 3.96  2001/05/04 23:09:30  eokerson
 108  * Now uses one kernel timer for each card, instead of one for the entire driver.
 109  *
 110  * Revision 3.95  2001/04/25 22:06:47  eokerson
 111  * Fixed squawking at beginning of some G.723.1 calls.
 112  *
 113  * Revision 3.94  2001/04/03 23:42:00  eokerson
 114  * Added linear volume ioctls
 115  * Added raw filter load ioctl
 116  *
 117  * Revision 3.93  2001/02/27 01:00:06  eokerson
 118  * Fixed blocking in CallerID.
 119  * Reduced size of ixj structure for smaller driver footprint.
 120  *
 121  * Revision 3.92  2001/02/20 22:02:59  eokerson
 122  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 123  * Improved PSTN ring detection.
 124  * Fixed wink generation on POTS ports.
 125  *
 126  * Revision 3.91  2001/02/13 00:55:44  eokerson
 127  * Turn AEC back on after changing frame sizes.
 128  *
 129  * Revision 3.90  2001/02/12 16:42:00  eokerson
 130  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 131  *
 132  * Revision 3.89  2001/02/12 15:41:16  eokerson
 133  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 134  *
 135  * Revision 3.88  2001/02/05 23:25:42  eokerson
 136  * Fixed lockup bugs with deregister.
 137  *
 138  * Revision 3.87  2001/01/29 21:00:39  eokerson
 139  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 140  * Updated copyright date.
 141  *
 142  * Revision 3.86  2001/01/23 23:53:46  eokerson
 143  * Fixes to G.729 compatibility.
 144  *
 145  * Revision 3.85  2001/01/23 21:30:36  eokerson
 146  * Added verbage about cards supported.
 147  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 148  *
 149  * Revision 3.84  2001/01/22 23:32:10  eokerson
 150  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 151  *
 152  * Revision 3.83  2001/01/19 14:51:41  eokerson
 153  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 154  *
 155  * Revision 3.82  2001/01/19 00:34:49  eokerson
 156  * Added verbosity to write overlap errors.
 157  *
 158  * Revision 3.81  2001/01/18 23:56:54  eokerson
 159  * Fixed PSTN line test functions.
 160  *
 161  * Revision 3.80  2001/01/18 22:29:27  eokerson
 162  * Updated AEC/AGC values for different cards.
 163  *
 164  * Revision 3.79  2001/01/17 02:58:54  eokerson
 165  * Fixed AEC reset after Caller ID.
 166  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 167  *
 168  * Revision 3.78  2001/01/16 19:43:09  eokerson
 169  * Added support for Linux 2.4.x kernels.
 170  *
 171  * Revision 3.77  2001/01/09 04:00:52  eokerson
 172  * Linetest will now test the line, even if it has previously succeded.
 173  *
 174  * Revision 3.76  2001/01/08 19:27:00  eokerson
 175  * Fixed problem with standard cable on Internet PhoneCARD.
 176  *
 177  * Revision 3.75  2000/12/22 16:52:14  eokerson
 178  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 179  *
 180  * Revision 3.74  2000/12/08 22:41:50  eokerson
 181  * Added capability for G729B.
 182  *
 183  * Revision 3.73  2000/12/07 23:35:16  eokerson
 184  * Added capability to have different ring pattern before CallerID data.
 185  * Added hookstate checks in CallerID routines to stop FSK.
 186  *
 187  * Revision 3.72  2000/12/06 19:31:31  eokerson
 188  * Modified signal behavior to only send one signal per event.
 189  *
 190  * Revision 3.71  2000/12/06 03:23:08  eokerson
 191  * Fixed CallerID on Call Waiting.
 192  *
 193  * Revision 3.70  2000/12/04 21:29:37  eokerson
 194  * Added checking to Smart Cable gain functions.
 195  *
 196  * Revision 3.69  2000/12/04 21:05:20  eokerson
 197  * Changed ixjdebug levels.
 198  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 199  *
 200  * Revision 3.68  2000/12/04 00:17:21  craigs
 201  * Changed mixer voice gain to +6dB rather than 0dB
 202  *
 203  * Revision 3.67  2000/11/30 21:25:51  eokerson
 204  * Fixed write signal errors.
 205  *
 206  * Revision 3.66  2000/11/29 22:42:44  eokerson
 207  * Fixed PSTN ring detect problems.
 208  *
 209  * Revision 3.65  2000/11/29 07:31:55  craigs
 210  * Added new 425Hz filter co-efficients
 211  * Added card-specific DTMF prescaler initialisation
 212  *
 213  * Revision 3.64  2000/11/28 14:03:32  craigs
 214  * Changed certain mixer initialisations to be 0dB rather than 12dB
 215  * Added additional information to /proc/ixj
 216  *
 217  * Revision 3.63  2000/11/28 11:38:41  craigs
 218  * Added display of AEC modes in AUTO and AGC mode
 219  *
 220  * Revision 3.62  2000/11/28 04:05:44  eokerson
 221  * Improved PSTN ring detection routine.
 222  *
 223  * Revision 3.61  2000/11/27 21:53:12  eokerson
 224  * Fixed flash detection.
 225  *
 226  * Revision 3.60  2000/11/27 15:57:29  eokerson
 227  * More work on G.729 load routines.
 228  *
 229  * Revision 3.59  2000/11/25 21:55:12  eokerson
 230  * Fixed errors in G.729 load routine.
 231  *
 232  * Revision 3.58  2000/11/25 04:08:29  eokerson
 233  * Added board locks around G.729 and TS85 load routines.
 234  *
 235  * Revision 3.57  2000/11/24 05:35:17  craigs
 236  * Added ability to retrieve mixer values on LineJACK
 237  * Added complete initialisation of all mixer values at startup
 238  * Fixed spelling mistake
 239  *
 240  * Revision 3.56  2000/11/23 02:52:11  robertj
 241  * Added cvs change log keyword.
 242  * Fixed bug in capabilities list when using G.729 module.
 243  *
 244  */
 245
 246 #include "ixj-ver.h"
 247
 248 #define PERFMON_STATS
 249 #define IXJDEBUG 0
 250 #define MAXRINGS 5
 251
 252 #include <linux/module.h>
 253
 254 #include <linux/init.h>
 255 #include <linux/sched.h>
 256 #include <linux/kernel.h>       /* printk() */
 257 #include <linux/fs.h>           /* everything... */
 258 #include <linux/errno.h>        /* error codes */
 259 #include <linux/slab.h>
 260 #include <linux/mm.h>
 261 #include <linux/ioport.h>
 262 #include <linux/interrupt.h>
 263 #include <linux/proc_fs.h>
 264 #include <linux/poll.h>
 265 #include <linux/timer.h>
 266 #include <linux/delay.h>
 267 #include <linux/pci.h>
 268
 269 #include <asm/io.h>
 270 #include <asm/uaccess.h>
 271
 272 #include <linux/isapnp.h>
 273
 274 #include "ixj.h"
 275
 276 #define TYPE(inode) (iminor(inode) >> 4)
 277 #define NUM(inode) (iminor(inode) & 0xf)
 278
 279 static int ixjdebug;
 280 static int hertz = HZ;
 281 static int samplerate = 100;
 282
 283 module_param(ixjdebug, int, 0);
 284
 285 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
 286         { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
 287           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 288         { }
 289 };
 290
 291 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 292
 293 /************************************************************************
 294 *
 295 * ixjdebug meanings are now bit mapped instead of level based
 296 * Values can be or'ed together to turn on multiple messages
 297 *
 298 * bit  0 (0x0001) = any failure
 299 * bit  1 (0x0002) = general messages
 300 * bit  2 (0x0004) = POTS ringing related
 301 * bit  3 (0x0008) = PSTN events
 302 * bit  4 (0x0010) = PSTN Cadence state details
 303 * bit  5 (0x0020) = Tone detection triggers
 304 * bit  6 (0x0040) = Tone detection cadence details
 305 * bit  7 (0x0080) = ioctl tracking
 306 * bit  8 (0x0100) = signal tracking
 307 * bit  9 (0x0200) = CallerID generation details
 308 *
 309 ************************************************************************/
 310
 311 #ifdef IXJ_DYN_ALLOC
 312
 313 static IXJ *ixj[IXJMAX];
 314 #define get_ixj(b)      ixj[(b)]
 315
 316 /*
 317  *      Allocate a free IXJ device
 318  */
 319
 320 static IXJ *ixj_alloc()
 321 {
 322         for(cnt=0; cnt<IXJMAX; cnt++)
 323         {
 324                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 325                 {
 326                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 327                         if (j == NULL)
 328                                 return NULL;
 329                         ixj[cnt] = j;
 330                         return j;
 331                 }
 332         }
 333         return NULL;
 334 }
 335
 336 static void ixj_fsk_free(IXJ *j)
 337 {
 338         kfree(j->fskdata);
 339         j->fskdata = NULL;
 340 }
 341
 342 static void ixj_fsk_alloc(IXJ *j)
 343 {
 344         if(!j->fskdata) {
 345                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 346                 if (!j->fskdata) {
 347                         if(ixjdebug & 0x0200) {
 348                                 printk("IXJ phone%d - allocate failed\n", j->board);
 349                         }
 350                         return;
 351                 } else {
 352                         j->fsksize = 8000;
 353                         if(ixjdebug & 0x0200) {
 354                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 355                         }
 356                 }
 357         }
 358 }
 359
 360 #else
 361
 362 static IXJ ixj[IXJMAX];
 363 #define get_ixj(b)      (&ixj[(b)])
 364
 365 /*
 366  *      Allocate a free IXJ device
 367  */
 368
 369 static IXJ *ixj_alloc(void)
 370 {
 371         int cnt;
 372         for(cnt=0; cnt<IXJMAX; cnt++) {
 373                 if(!ixj[cnt].DSPbase)
 374                         return &ixj[cnt];
 375         }
 376         return NULL;
 377 }
 378
 379 static inline void ixj_fsk_free(IXJ *j) {;}
 380
 381 static inline void ixj_fsk_alloc(IXJ *j)
 382 {
 383         j->fsksize = 8000;
 384 }
 385
 386 #endif
 387
 388 #ifdef PERFMON_STATS
 389 #define ixj_perfmon(x)  ((x)++)
 390 #else
 391 #define ixj_perfmon(x)  do { } while(0)
 392 #endif
 393
 394 static int ixj_convert_loaded;
 395
 396 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 397
 398 /************************************************************************
 399 *
 400 * These are function definitions to allow external modules to register
 401 * enhanced functionality call backs.
 402 *
 403 ************************************************************************/
 404
 405 static int Stub(IXJ * J, unsigned long arg)
 406 {
 407         return 0;
 408 }
 409
 410 static IXJ_REGFUNC ixj_PreRead = &Stub;
 411 static IXJ_REGFUNC ixj_PostRead = &Stub;
 412 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 413 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 414
 415 static void ixj_read_frame(IXJ *j);
 416 static void ixj_write_frame(IXJ *j);
 417 static void ixj_init_timer(IXJ *j);
 418 static void ixj_add_timer(IXJ * j);
 419 static void ixj_timeout(unsigned long ptr);
 420 static int read_filters(IXJ *j);
 421 static int LineMonitor(IXJ *j);
 422 static int ixj_fasync(int fd, struct file *, int mode);
 423 static int ixj_set_port(IXJ *j, int arg);
 424 static int ixj_set_pots(IXJ *j, int arg);
 425 static int ixj_hookstate(IXJ *j);
 426 static int ixj_record_start(IXJ *j);
 427 static void ixj_record_stop(IXJ *j);
 428 static void set_rec_volume(IXJ *j, int volume);
 429 static int get_rec_volume(IXJ *j);
 430 static int set_rec_codec(IXJ *j, int rate);
 431 static void ixj_vad(IXJ *j, int arg);
 432 static int ixj_play_start(IXJ *j);
 433 static void ixj_play_stop(IXJ *j);
 434 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 435 static int ixj_set_tone_off(unsigned short, IXJ *j);
 436 static int ixj_play_tone(IXJ *j, char tone);
 437 static void ixj_aec_start(IXJ *j, int level);
 438 static int idle(IXJ *j);
 439 static void ixj_ring_on(IXJ *j);
 440 static void ixj_ring_off(IXJ *j);
 441 static void aec_stop(IXJ *j);
 442 static void ixj_ringback(IXJ *j);
 443 static void ixj_busytone(IXJ *j);
 444 static void ixj_dialtone(IXJ *j);
 445 static void ixj_cpt_stop(IXJ *j);
 446 static char daa_int_read(IXJ *j);
 447 static char daa_CR_read(IXJ *j, int cr);
 448 static int daa_set_mode(IXJ *j, int mode);
 449 static int ixj_linetest(IXJ *j);
 450 static int ixj_daa_write(IXJ *j);
 451 static int ixj_daa_cid_read(IXJ *j);
 452 static void DAA_Coeff_US(IXJ *j);
 453 static void DAA_Coeff_UK(IXJ *j);
 454 static void DAA_Coeff_France(IXJ *j);
 455 static void DAA_Coeff_Germany(IXJ *j);
 456 static void DAA_Coeff_Australia(IXJ *j);
 457 static void DAA_Coeff_Japan(IXJ *j);
 458 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 459 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 460 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 461 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 462 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 463 /* Serial Control Interface funtions */
 464 static int SCI_Control(IXJ *j, int control);
 465 static int SCI_Prepare(IXJ *j);
 466 static int SCI_WaitHighSCI(IXJ *j);
 467 static int SCI_WaitLowSCI(IXJ *j);
 468 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 469 static int ixj_PCcontrol_wait(IXJ *j);
 470 static void ixj_pre_cid(IXJ *j);
 471 static void ixj_write_cid(IXJ *j);
 472 static void ixj_write_cid_bit(IXJ *j, int bit);
 473 static int set_base_frame(IXJ *j, int size);
 474 static int set_play_codec(IXJ *j, int rate);
 475 static void set_rec_depth(IXJ *j, int depth);
 476 static int ixj_mixer(long val, IXJ *j);
 477
 478 /************************************************************************
 479 CT8020/CT8021 Host Programmers Model
 480 Host address    Function                                        Access
 481 DSPbase +
 482 0-1             Aux Software Status Register (reserved)         Read Only
 483 2-3             Software Status Register                        Read Only
 484 4-5             Aux Software Control Register (reserved)        Read Write
 485 6-7             Software Control Register                       Read Write
 486 8-9             Hardware Status Register                        Read Only
 487 A-B             Hardware Control Register                       Read Write
 488 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 489 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 490 ************************************************************************/
 491
 492 static inline void ixj_read_HSR(IXJ *j)
 493 {
 494         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 495         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 496 }
 497
 498 static inline int IsControlReady(IXJ *j)
 499 {
 500         ixj_read_HSR(j);
 501         return j->hsr.bits.controlrdy ? 1 : 0;
 502 }
 503
 504 static inline int IsPCControlReady(IXJ *j)
 505 {
 506         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 507         return j->pccr1.bits.crr ? 1 : 0;
 508 }
 509
 510 static inline int IsStatusReady(IXJ *j)
 511 {
 512         ixj_read_HSR(j);
 513         return j->hsr.bits.statusrdy ? 1 : 0;
 514 }
 515
 516 static inline int IsRxReady(IXJ *j)
 517 {
 518         ixj_read_HSR(j);
 519         ixj_perfmon(j->rxreadycheck);
 520         return j->hsr.bits.rxrdy ? 1 : 0;
 521 }
 522
 523 static inline int IsTxReady(IXJ *j)
 524 {
 525         ixj_read_HSR(j);
 526         ixj_perfmon(j->txreadycheck);
 527         return j->hsr.bits.txrdy ? 1 : 0;
 528 }
 529
 530 static inline void set_play_volume(IXJ *j, int volume)
 531 {
 532         if (ixjdebug & 0x0002)
 533                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 534         ixj_WriteDSPCommand(0xCF02, j);
 535         ixj_WriteDSPCommand(volume, j);
 536 }
 537
 538 static int set_play_volume_linear(IXJ *j, int volume)
 539 {
 540         int newvolume, dspplaymax;
 541
 542         if (ixjdebug & 0x0002)
 543                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 544         if(volume > 100 || volume < 0) {
 545                 return -1;
 546         }
 547
 548         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 549         switch (j->cardtype) {
 550         case QTI_PHONEJACK:
 551                 dspplaymax = 0x380;
 552                 break;
 553         case QTI_LINEJACK:
 554                 if(j->port == PORT_PSTN) {
 555                         dspplaymax = 0x48;
 556                 } else {
 557                         dspplaymax = 0x100;
 558                 }
 559                 break;
 560         case QTI_PHONEJACK_LITE:
 561                 dspplaymax = 0x380;
 562                 break;
 563         case QTI_PHONEJACK_PCI:
 564                 dspplaymax = 0x6C;
 565                 break;
 566         case QTI_PHONECARD:
 567                 dspplaymax = 0x50;
 568                 break;
 569         default:
 570                 return -1;
 571         }
 572         newvolume = (dspplaymax * volume) / 100;
 573         set_play_volume(j, newvolume);
 574         return 0;
 575 }
 576
 577 static inline void set_play_depth(IXJ *j, int depth)
 578 {
 579         if (depth > 60)
 580                 depth = 60;
 581         if (depth < 0)
 582                 depth = 0;
 583         ixj_WriteDSPCommand(0x5280 + depth, j);
 584 }
 585
 586 static inline int get_play_volume(IXJ *j)
 587 {
 588         ixj_WriteDSPCommand(0xCF00, j);
 589         return j->ssr.high << 8 | j->ssr.low;
 590 }
 591
 592 static int get_play_volume_linear(IXJ *j)
 593 {
 594         int volume, newvolume, dspplaymax;
 595
 596         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 597         switch (j->cardtype) {
 598         case QTI_PHONEJACK:
 599                 dspplaymax = 0x380;
 600                 break;
 601         case QTI_LINEJACK:
 602                 if(j->port == PORT_PSTN) {
 603                         dspplaymax = 0x48;
 604                 } else {
 605                         dspplaymax = 0x100;
 606                 }
 607                 break;
 608         case QTI_PHONEJACK_LITE:
 609                 dspplaymax = 0x380;
 610                 break;
 611         case QTI_PHONEJACK_PCI:
 612                 dspplaymax = 0x6C;
 613                 break;
 614         case QTI_PHONECARD:
 615                 dspplaymax = 100;
 616                 break;
 617         default:
 618                 return -1;
 619         }
 620         volume = get_play_volume(j);
 621         newvolume = (volume * 100) / dspplaymax;
 622         if(newvolume > 100)
 623                 newvolume = 100;
 624         return newvolume;
 625 }
 626
 627 static inline BYTE SLIC_GetState(IXJ *j)
 628 {
 629         if (j->cardtype == QTI_PHONECARD) {
 630                 j->pccr1.byte = 0;
 631                 j->psccr.bits.dev = 3;
 632                 j->psccr.bits.rw = 1;
 633                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 634                 ixj_PCcontrol_wait(j);
 635                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 636                 ixj_PCcontrol_wait(j);
 637                 if (j->pslic.bits.powerdown)
 638                         return PLD_SLIC_STATE_OC;
 639                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 640                         return PLD_SLIC_STATE_ACTIVE;
 641                 else
 642                         return PLD_SLIC_STATE_RINGING;
 643         } else {
 644                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 645         }
 646         return j->pld_slicr.bits.state;
 647 }
 648
 649 static bool SLIC_SetState(BYTE byState, IXJ *j)
 650 {
 651         bool fRetVal = false;
 652
 653         if (j->cardtype == QTI_PHONECARD) {
 654                 if (j->flags.pcmciasct) {
 655                         switch (byState) {
 656                         case PLD_SLIC_STATE_TIPOPEN:
 657                         case PLD_SLIC_STATE_OC:
 658                                 j->pslic.bits.powerdown = 1;
 659                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 660                                 fRetVal = true;
 661                                 break;
 662                         case PLD_SLIC_STATE_RINGING:
 663                                 if (j->readers || j->writers) {
 664                                         j->pslic.bits.powerdown = 0;
 665                                         j->pslic.bits.ring0 = 1;
 666                                         j->pslic.bits.ring1 = 0;
 667                                         fRetVal = true;
 668                                 }
 669                                 break;
 670                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 671
 672                         case PLD_SLIC_STATE_STANDBY:
 673                         case PLD_SLIC_STATE_ACTIVE:
 674                                 if (j->readers || j->writers) {
 675                                         j->pslic.bits.powerdown = 0;
 676                                 } else {
 677                                         j->pslic.bits.powerdown = 1;
 678                                 }
 679                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 680                                 fRetVal = true;
 681                                 break;
 682                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 683
 684                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 685
 686                         default:
 687                                 fRetVal = false;
 688                                 break;
 689                         }
 690                         j->psccr.bits.dev = 3;
 691                         j->psccr.bits.rw = 0;
 692                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 693                         ixj_PCcontrol_wait(j);
 694                 }
 695         } else {
 696                 /* Set the C1, C2, C3 & B2EN signals. */
 697                 switch (byState) {
 698                 case PLD_SLIC_STATE_OC:
 699                         j->pld_slicw.bits.c1 = 0;
 700                         j->pld_slicw.bits.c2 = 0;
 701                         j->pld_slicw.bits.c3 = 0;
 702                         j->pld_slicw.bits.b2en = 0;
 703                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 704                         fRetVal = true;
 705                         break;
 706                 case PLD_SLIC_STATE_RINGING:
 707                         j->pld_slicw.bits.c1 = 1;
 708                         j->pld_slicw.bits.c2 = 0;
 709                         j->pld_slicw.bits.c3 = 0;
 710                         j->pld_slicw.bits.b2en = 1;
 711                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 712                         fRetVal = true;
 713                         break;
 714                 case PLD_SLIC_STATE_ACTIVE:
 715                         j->pld_slicw.bits.c1 = 0;
 716                         j->pld_slicw.bits.c2 = 1;
 717                         j->pld_slicw.bits.c3 = 0;
 718                         j->pld_slicw.bits.b2en = 0;
 719                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 720                         fRetVal = true;
 721                         break;
 722                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 723
 724                         j->pld_slicw.bits.c1 = 1;
 725                         j->pld_slicw.bits.c2 = 1;
 726                         j->pld_slicw.bits.c3 = 0;
 727                         j->pld_slicw.bits.b2en = 0;
 728                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 729                         fRetVal = true;
 730                         break;
 731                 case PLD_SLIC_STATE_TIPOPEN:
 732                         j->pld_slicw.bits.c1 = 0;
 733                         j->pld_slicw.bits.c2 = 0;
 734                         j->pld_slicw.bits.c3 = 1;
 735                         j->pld_slicw.bits.b2en = 0;
 736                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 737                         fRetVal = true;
 738                         break;
 739                 case PLD_SLIC_STATE_STANDBY:
 740                         j->pld_slicw.bits.c1 = 1;
 741                         j->pld_slicw.bits.c2 = 0;
 742                         j->pld_slicw.bits.c3 = 1;
 743                         j->pld_slicw.bits.b2en = 1;
 744                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 745                         fRetVal = true;
 746                         break;
 747                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 748
 749                         j->pld_slicw.bits.c1 = 0;
 750                         j->pld_slicw.bits.c2 = 1;
 751                         j->pld_slicw.bits.c3 = 1;
 752                         j->pld_slicw.bits.b2en = 0;
 753                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 754                         fRetVal = true;
 755                         break;
 756                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 757
 758                         j->pld_slicw.bits.c1 = 1;
 759                         j->pld_slicw.bits.c2 = 1;
 760                         j->pld_slicw.bits.c3 = 1;
 761                         j->pld_slicw.bits.b2en = 0;
 762                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 763                         fRetVal = true;
 764                         break;
 765                 default:
 766                         fRetVal = false;
 767                         break;
 768                 }
 769         }
 770
 771         return fRetVal;
 772 }
 773
 774 static int ixj_wink(IXJ *j)
 775 {
 776         BYTE slicnow;
 777
 778         slicnow = SLIC_GetState(j);
 779
 780         j->pots_winkstart = jiffies;
 781         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 782
 783         msleep(jiffies_to_msecs(j->winktime));
 784
 785         SLIC_SetState(slicnow, j);
 786         return 0;
 787 }
 788
 789 static void ixj_init_timer(IXJ *j)
 790 {
 791         init_timer(&j->timer);
 792         j->timer.function = ixj_timeout;
 793         j->timer.data = (unsigned long)j;
 794 }
 795
 796 static void ixj_add_timer(IXJ *j)
 797 {
 798         j->timer.expires = jiffies + (hertz / samplerate);
 799         add_timer(&j->timer);
 800 }
 801
 802 static void ixj_tone_timeout(IXJ *j)
 803 {
 804         IXJ_TONE ti;
 805
 806         j->tone_state++;
 807         if (j->tone_state == 3) {
 808                 j->tone_state = 0;
 809                 if (j->cadence_t) {
 810                         j->tone_cadence_state++;
 811                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 812                                 switch (j->cadence_t->termination) {
 813                                 case PLAY_ONCE:
 814                                         ixj_cpt_stop(j);
 815                                         break;
 816                                 case REPEAT_LAST_ELEMENT:
 817                                         j->tone_cadence_state--;
 818                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 819                                         break;
 820                                 case REPEAT_ALL:
 821                                         j->tone_cadence_state = 0;
 822                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 823                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 824                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 825                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 826                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 827                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 828                                                 ixj_init_tone(j, &ti);
 829                                         }
 830                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 831                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 832                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 833                                         break;
 834                                 }
 835                         } else {
 836                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 837                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 838                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 839                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 840                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 841                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 842                                         ixj_init_tone(j, &ti);
 843                                 }
 844                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 845                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 846                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 847                         }
 848                 }
 849         }
 850 }
 851
 852 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 853 {
 854         if(j->ixj_signals[event]) {
 855                 if(ixjdebug & 0x0100)
 856                         printk("Sending signal for event %d\n", event);
 857                         /* Send apps notice of change */
 858                 /* see config.h for macro definition */
 859                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 860         }
 861 }
 862
 863 static void ixj_pstn_state(IXJ *j)
 864 {
 865         int var;
 866         union XOPXR0 XR0, daaint;
 867
 868         var = 10;
 869
 870         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 871         daaint.reg = 0;
 872         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 873
 874         j->pld_scrr.byte = inb_p(j->XILINXbase);
 875         if (j->pld_scrr.bits.daaflag) {
 876                 daa_int_read(j);
 877                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 878                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 879                                 daaint.bitreg.RING = 1;
 880                                 if(ixjdebug & 0x0008) {
 881                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 882                                 }
 883                         } else {
 884                                 daa_set_mode(j, SOP_PU_RESET);
 885                         }
 886                 }
 887                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 888                         daaint.bitreg.Caller_ID = 1;
 889                         j->pstn_cid_intr = 1;
 890                         j->pstn_cid_received = jiffies;
 891                         if(ixjdebug & 0x0008) {
 892                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 893                         }
 894                 }
 895                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 896                         daaint.bitreg.Cadence = 1;
 897                         if(ixjdebug & 0x0008) {
 898                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 899                         }
 900                 }
 901                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 902                         daaint.bitreg.VDD_OK = 1;
 903                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 904                 }
 905         }
 906         daa_CR_read(j, 1);
 907         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)) {
 908                 daaint.bitreg.RMR = 1;
 909                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 910                 if(ixjdebug & 0x0008) {
 911                         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);
 912                 }
 913                 j->pstn_prev_rmr = j->pstn_last_rmr;
 914                 j->pstn_last_rmr = jiffies;
 915         }
 916         switch(j->daa_mode) {
 917                 case SOP_PU_SLEEP:
 918                         if (daaint.bitreg.RING) {
 919                                 if (!j->flags.pstn_ringing) {
 920                                         if (j->daa_mode != SOP_PU_RINGING) {
 921                                                 j->pstn_ring_int = jiffies;
 922                                                 daa_set_mode(j, SOP_PU_RINGING);
 923                                         }
 924                                 }
 925                         }
 926                         break;
 927                 case SOP_PU_RINGING:
 928                         if (daaint.bitreg.RMR) {
 929                                 if (ixjdebug & 0x0008) {
 930                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 931                                 }
 932                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 933                                         j->flags.pstn_rmr = 1;
 934                                         j->pstn_ring_start = jiffies;
 935                                         j->pstn_ring_stop = 0;
 936                                         j->ex.bits.pstn_ring = 0;
 937                                         if (j->cadence_f[4].state == 0) {
 938                                                 j->cadence_f[4].state = 1;
 939                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 940                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 941                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 942                                         } else if (j->cadence_f[4].state == 2) {
 943                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 944                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 945                                                         if (j->cadence_f[4].on2) {
 946                                                                 j->cadence_f[4].state = 3;
 947                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 948                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 949                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 950                                                         } else {
 951                                                                 j->cadence_f[4].state = 7;
 952                                                         }
 953                                                 } else {
 954                                                         if (ixjdebug & 0x0008) {
 955                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 956                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 957                                                                                 j->cadence_f[4].off1);
 958                                                         }
 959                                                         j->cadence_f[4].state = 0;
 960                                                 }
 961                                         } else if (j->cadence_f[4].state == 4) {
 962                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 963                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 964                                                         if (j->cadence_f[4].on3) {
 965                                                                 j->cadence_f[4].state = 5;
 966                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 967                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 968                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 969                                                         } else {
 970                                                                 j->cadence_f[4].state = 7;
 971                                                         }
 972                                                 } else {
 973                                                         if (ixjdebug & 0x0008) {
 974                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 975                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 976                                                                                 j->cadence_f[4].off2);
 977                                                         }
 978                                                         j->cadence_f[4].state = 0;
 979                                                 }
 980                                         } else if (j->cadence_f[4].state == 6) {
 981                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 982                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 983                                                         j->cadence_f[4].state = 7;
 984                                                 } else {
 985                                                         if (ixjdebug & 0x0008) {
 986                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 987                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 988                                                                                 j->cadence_f[4].off3);
 989                                                         }
 990                                                         j->cadence_f[4].state = 0;
 991                                                 }
 992                                         } else {
 993                                                 j->cadence_f[4].state = 0;
 994                                         }
 995                                 } else {                                /* Falling edge of RMR */
 996                                         j->pstn_ring_start = 0;
 997                                         j->pstn_ring_stop = jiffies;
 998                                         if (j->cadence_f[4].state == 1) {
 999                                                 if(!j->cadence_f[4].on1) {
1000                                                         j->cadence_f[4].state = 7;
1001                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1002                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1003                                                         if (j->cadence_f[4].off1) {
1004                                                                 j->cadence_f[4].state = 2;
1005                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1006                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1007                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1008                                                         } else {
1009                                                                 j->cadence_f[4].state = 7;
1010                                                         }
1011                                                 } else {
1012                                                         if (ixjdebug & 0x0008) {
1013                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1014                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1015                                                                                 j->cadence_f[4].on1);
1016                                                         }
1017                                                         j->cadence_f[4].state = 0;
1018                                                 }
1019                                         } else if (j->cadence_f[4].state == 3) {
1020                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1021                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1022                                                         if (j->cadence_f[4].off2) {
1023                                                                 j->cadence_f[4].state = 4;
1024                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1025                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1026                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1027                                                         } else {
1028                                                                 j->cadence_f[4].state = 7;
1029                                                         }
1030                                                 } else {
1031                                                         if (ixjdebug & 0x0008) {
1032                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1033                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1034                                                                                 j->cadence_f[4].on2);
1035                                                         }
1036                                                         j->cadence_f[4].state = 0;
1037                                                 }
1038                                         } else if (j->cadence_f[4].state == 5) {
1039                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1040                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1041                                                         if (j->cadence_f[4].off3) {
1042                                                                 j->cadence_f[4].state = 6;
1043                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1044                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1045                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1046                                                         } else {
1047                                                                 j->cadence_f[4].state = 7;
1048                                                         }
1049                                                 } else {
1050                                                         j->cadence_f[4].state = 0;
1051                                                 }
1052                                         } else {
1053                                                 if (ixjdebug & 0x0008) {
1054                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1055                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1056                                                                         j->cadence_f[4].on3);
1057                                                 }
1058                                                 j->cadence_f[4].state = 0;
1059                                         }
1060                                 }
1061                                 if (ixjdebug & 0x0010) {
1062                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1063                                 }
1064                                 if (ixjdebug & 0x0010) {
1065                                         switch(j->cadence_f[4].state) {
1066                                                 case 1:
1067                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1068                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1069                                                         break;
1070                                                 case 2:
1071                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1072                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1073                                                         break;
1074                                                 case 3:
1075                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1076                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1077                                                         break;
1078                                                 case 4:
1079                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1080                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1081                                                         break;
1082                                                 case 5:
1083                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1084                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1085                                                         break;
1086                                                 case 6:
1087                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1088                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1089                                                         break;
1090                                         }
1091                                 }
1092                         }
1093                         if (j->cadence_f[4].state == 7) {
1094                                 j->cadence_f[4].state = 0;
1095                                 j->pstn_ring_stop = jiffies;
1096                                 j->ex.bits.pstn_ring = 1;
1097                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1098                                 if(ixjdebug & 0x0008) {
1099                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1100                                 }
1101                         }
1102                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1103                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1104                                 if(ixjdebug & 0x0008) {
1105                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1106                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1107                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1108                                 }
1109                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1110                                 daa_set_mode(j, SOP_PU_SLEEP);
1111                         }
1112                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1113                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1114                                 ixj_daa_cid_read(j);
1115                                 j->ex.bits.caller_id = 1;
1116                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1117                                 j->pstn_cid_intr = 0;
1118                         }
1119                         if (daaint.bitreg.Cadence) {
1120                                 if(ixjdebug & 0x0008) {
1121                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1122                                 }
1123                                 daa_set_mode(j, SOP_PU_SLEEP);
1124                                 j->ex.bits.pstn_ring = 0;
1125                         }
1126                         break;
1127                 case SOP_PU_CONVERSATION:
1128                         if (daaint.bitreg.VDD_OK) {
1129                                 if(!daaint.bitreg.SI_0) {
1130                                         if (!j->pstn_winkstart) {
1131                                                 if(ixjdebug & 0x0008) {
1132                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1133                                                 }
1134                                                 j->pstn_winkstart = jiffies;
1135                                         }
1136                                 } else {
1137                                         if (j->pstn_winkstart) {
1138                                                 if(ixjdebug & 0x0008) {
1139                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1140                                                 }
1141                                                 j->pstn_winkstart = 0;
1142                                         }
1143                                 }
1144                         }
1145                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1146                                 if(ixjdebug & 0x0008) {
1147                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1148                                 }
1149                                 daa_set_mode(j, SOP_PU_SLEEP);
1150                                 j->pstn_winkstart = 0;
1151                                 j->ex.bits.pstn_wink = 1;
1152                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1153                         }
1154                         break;
1155         }
1156 }
1157
1158 static void ixj_timeout(unsigned long ptr)
1159 {
1160         int board;
1161         unsigned long jifon;
1162         IXJ *j = (IXJ *)ptr;
1163         board = j->board;
1164
1165         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1166                 ixj_perfmon(j->timerchecks);
1167                 j->hookstate = ixj_hookstate(j);
1168                 if (j->tone_state) {
1169                         if (!(j->hookstate)) {
1170                                 ixj_cpt_stop(j);
1171                                 if (j->m_hook) {
1172                                         j->m_hook = 0;
1173                                         j->ex.bits.hookstate = 1;
1174                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1175                                 }
1176                                 clear_bit(board, &j->busyflags);
1177                                 ixj_add_timer(j);
1178                                 return;
1179                         }
1180                         if (j->tone_state == 1)
1181                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1182                         else
1183                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1184                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1185                                 if (j->tone_state == 1) {
1186                                         ixj_play_tone(j, j->tone_index);
1187                                         if (j->dsp.low == 0x20) {
1188                                                 clear_bit(board, &j->busyflags);
1189                                                 ixj_add_timer(j);
1190                                                 return;
1191                                         }
1192                                 } else {
1193                                         ixj_play_tone(j, 0);
1194                                         if (j->dsp.low == 0x20) {
1195                                                 clear_bit(board, &j->busyflags);
1196                                                 ixj_add_timer(j);
1197                                                 return;
1198                                         }
1199                                 }
1200                         } else {
1201                                 ixj_tone_timeout(j);
1202                                 if (j->flags.dialtone) {
1203                                         ixj_dialtone(j);
1204                                 }
1205                                 if (j->flags.busytone) {
1206                                         ixj_busytone(j);
1207                                         if (j->dsp.low == 0x20) {
1208                                                 clear_bit(board, &j->busyflags);
1209                                                 ixj_add_timer(j);
1210                                                 return;
1211                                         }
1212                                 }
1213                                 if (j->flags.ringback) {
1214                                         ixj_ringback(j);
1215                                         if (j->dsp.low == 0x20) {
1216                                                 clear_bit(board, &j->busyflags);
1217                                                 ixj_add_timer(j);
1218                                                 return;
1219                                         }
1220                                 }
1221                                 if (!j->tone_state) {
1222                                         ixj_cpt_stop(j);
1223                                 }
1224                         }
1225                 }
1226                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1227                         if (IsRxReady(j)) {
1228                                 ixj_read_frame(j);
1229                         }
1230                         if (IsTxReady(j)) {
1231                                 ixj_write_frame(j);
1232                         }
1233                 }
1234                 if (j->flags.cringing) {
1235                         if (j->hookstate & 1) {
1236                                 j->flags.cringing = 0;
1237                                 ixj_ring_off(j);
1238                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1239                                 switch(j->cadence_f[5].state) {
1240                                         case 0:
1241                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1242                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1243                                                         if(ixjdebug & 0x0004) {
1244                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1245                                                         }
1246                                                         ixj_ring_on(j);
1247                                                 }
1248                                                 j->cadence_f[5].state = 1;
1249                                                 break;
1250                                         case 1:
1251                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1252                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1253                                                         if(ixjdebug & 0x0004) {
1254                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1255                                                         }
1256                                                         ixj_ring_off(j);
1257                                                         j->cadence_f[5].state = 2;
1258                                                 }
1259                                                 break;
1260                                         case 2:
1261                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1262                                                         if(ixjdebug & 0x0004) {
1263                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1264                                                         }
1265                                                         ixj_ring_on(j);
1266                                                         if (j->cadence_f[5].on2) {
1267                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1268                                                                 j->cadence_f[5].state = 3;
1269                                                         } else {
1270                                                                 j->cadence_f[5].state = 7;
1271                                                         }
1272                                                 }
1273                                                 break;
1274                                         case 3:
1275                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1276                                                         if(ixjdebug & 0x0004) {
1277                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1278                                                         }
1279                                                         ixj_ring_off(j);
1280                                                         if (j->cadence_f[5].off2) {
1281                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1282                                                                 j->cadence_f[5].state = 4;
1283                                                         } else {
1284                                                                 j->cadence_f[5].state = 7;
1285                                                         }
1286                                                 }
1287                                                 break;
1288                                         case 4:
1289                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1290                                                         if(ixjdebug & 0x0004) {
1291                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1292                                                         }
1293                                                         ixj_ring_on(j);
1294                                                         if (j->cadence_f[5].on3) {
1295                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1296                                                                 j->cadence_f[5].state = 5;
1297                                                         } else {
1298                                                                 j->cadence_f[5].state = 7;
1299                                                         }
1300                                                 }
1301                                                 break;
1302                                         case 5:
1303                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1304                                                         if(ixjdebug & 0x0004) {
1305                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1306                                                         }
1307                                                         ixj_ring_off(j);
1308                                                         if (j->cadence_f[5].off3) {
1309                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1310                                                                 j->cadence_f[5].state = 6;
1311                                                         } else {
1312                                                                 j->cadence_f[5].state = 7;
1313                                                         }
1314                                                 }
1315                                                 break;
1316                                         case 6:
1317                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1318                                                         if(ixjdebug & 0x0004) {
1319                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1320                                                         }
1321                                                         j->cadence_f[5].state = 7;
1322                                                 }
1323                                                 break;
1324                                         case 7:
1325                                                 if(ixjdebug & 0x0004) {
1326                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1327                                                 }
1328                                                 j->flags.cidring = 1;
1329                                                 j->cadence_f[5].state = 0;
1330                                                 break;
1331                                 }
1332                                 if (j->flags.cidring && !j->flags.cidsent) {
1333                                         j->flags.cidsent = 1;
1334                                         if(j->fskdcnt) {
1335                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1336                                                 ixj_pre_cid(j);
1337                                         }
1338                                         j->flags.cidring = 0;
1339                                 }
1340                                 clear_bit(board, &j->busyflags);
1341                                 ixj_add_timer(j);
1342                                 return;
1343                         } else {
1344                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1345                                         if (j->flags.cidring && !j->flags.cidsent) {
1346                                                 j->flags.cidsent = 1;
1347                                                 if(j->fskdcnt) {
1348                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1349                                                         ixj_pre_cid(j);
1350                                                 }
1351                                                 j->flags.cidring = 0;
1352                                         }
1353                                         j->ring_cadence_t--;
1354                                         if (j->ring_cadence_t == -1)
1355                                                 j->ring_cadence_t = 15;
1356                                         j->ring_cadence_jif = jiffies;
1357
1358                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1359                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1360                                                         j->flags.firstring = 1;
1361                                                 else
1362                                                         ixj_ring_on(j);
1363                                         } else {
1364                                                 ixj_ring_off(j);
1365                                                 if(!j->flags.cidsent)
1366                                                         j->flags.cidring = 1;
1367                                         }
1368                                 }
1369                                 clear_bit(board, &j->busyflags);
1370                                 ixj_add_timer(j);
1371                                 return;
1372                         }
1373                 }
1374                 if (!j->flags.ringing) {
1375                         if (j->hookstate) { /* & 1) { */
1376                                 if (j->dsp.low != 0x20 &&
1377                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1378                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1379                                 }
1380                                 LineMonitor(j);
1381                                 read_filters(j);
1382                                 ixj_WriteDSPCommand(0x511B, j);
1383                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1384                                 if (!j->m_hook && (j->hookstate & 1)) {
1385                                         j->m_hook = j->ex.bits.hookstate = 1;
1386                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1387                                 }
1388                         } else {
1389                                 if (j->ex.bits.dtmf_ready) {
1390                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1391                                 }
1392                                 if (j->m_hook) {
1393                                         j->m_hook = 0;
1394                                         j->ex.bits.hookstate = 1;
1395                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1396                                 }
1397                         }
1398                 }
1399                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1400                         ixj_pstn_state(j);
1401                 }
1402                 if (j->ex.bytes) {
1403                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1404                 }
1405                 clear_bit(board, &j->busyflags);
1406         }
1407         ixj_add_timer(j);
1408 }
1409
1410 static int ixj_status_wait(IXJ *j)
1411 {
1412         unsigned long jif;
1413
1414         jif = jiffies + ((60 * hertz) / 100);
1415         while (!IsStatusReady(j)) {
1416                 ixj_perfmon(j->statuswait);
1417                 if (time_after(jiffies, jif)) {
1418                         ixj_perfmon(j->statuswaitfail);
1419                         return -1;
1420                 }
1421         }
1422         return 0;
1423 }
1424
1425 static int ixj_PCcontrol_wait(IXJ *j)
1426 {
1427         unsigned long jif;
1428
1429         jif = jiffies + ((60 * hertz) / 100);
1430         while (!IsPCControlReady(j)) {
1431                 ixj_perfmon(j->pcontrolwait);
1432                 if (time_after(jiffies, jif)) {
1433                         ixj_perfmon(j->pcontrolwaitfail);
1434                         return -1;
1435                 }
1436         }
1437         return 0;
1438 }
1439
1440 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1441 {
1442         BYTES bytes;
1443         unsigned long jif;
1444
1445         atomic_inc(&j->DSPWrite);
1446         if(atomic_read(&j->DSPWrite) > 1) {
1447                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1448                 return -1;
1449         }
1450         bytes.high = (cmd & 0xFF00) >> 8;
1451         bytes.low = cmd & 0x00FF;
1452         jif = jiffies + ((60 * hertz) / 100);
1453         while (!IsControlReady(j)) {
1454                 ixj_perfmon(j->iscontrolready);
1455                 if (time_after(jiffies, jif)) {
1456                         ixj_perfmon(j->iscontrolreadyfail);
1457                         atomic_dec(&j->DSPWrite);
1458                         if(atomic_read(&j->DSPWrite) > 0) {
1459                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1460                                 while(atomic_read(&j->DSPWrite) > 0) {
1461                                         atomic_dec(&j->DSPWrite);
1462                                 }
1463                         }
1464                         return -1;
1465                 }
1466         }
1467         outb(bytes.low, j->DSPbase + 6);
1468         outb(bytes.high, j->DSPbase + 7);
1469
1470         if (ixj_status_wait(j)) {
1471                 j->ssr.low = 0xFF;
1472                 j->ssr.high = 0xFF;
1473                 atomic_dec(&j->DSPWrite);
1474                 if(atomic_read(&j->DSPWrite) > 0) {
1475                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1476                         while(atomic_read(&j->DSPWrite) > 0) {
1477                                 atomic_dec(&j->DSPWrite);
1478                         }
1479                 }
1480                 return -1;
1481         }
1482 /* Read Software Status Register */
1483         j->ssr.low = inb_p(j->DSPbase + 2);
1484         j->ssr.high = inb_p(j->DSPbase + 3);
1485         atomic_dec(&j->DSPWrite);
1486         if(atomic_read(&j->DSPWrite) > 0) {
1487                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1488                 while(atomic_read(&j->DSPWrite) > 0) {
1489                         atomic_dec(&j->DSPWrite);
1490                 }
1491         }
1492         return 0;
1493 }
1494
1495 /***************************************************************************
1496 *
1497 *  General Purpose IO Register read routine
1498 *
1499 ***************************************************************************/
1500 static inline int ixj_gpio_read(IXJ *j)
1501 {
1502         if (ixj_WriteDSPCommand(0x5143, j))
1503                 return -1;
1504
1505         j->gpio.bytes.low = j->ssr.low;
1506         j->gpio.bytes.high = j->ssr.high;
1507
1508         return 0;
1509 }
1510
1511 static inline void LED_SetState(int state, IXJ *j)
1512 {
1513         if (j->cardtype == QTI_LINEJACK) {
1514                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1515                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1516                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1517                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1518
1519                 outb(j->pld_scrw.byte, j->XILINXbase);
1520         }
1521 }
1522
1523 /*********************************************************************
1524 *  GPIO Pins are configured as follows on the Quicknet Internet
1525 *  PhoneJACK Telephony Cards
1526 *
1527 * POTS Select        GPIO_6=0 GPIO_7=0
1528 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1529 * Handset Select     GPIO_6=1 GPIO_7=0
1530 *
1531 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1532 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1533 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1534 *
1535 * Hook Switch changes reported on GPIO_3
1536 *********************************************************************/
1537 static int ixj_set_port(IXJ *j, int arg)
1538 {
1539         if (j->cardtype == QTI_PHONEJACK_LITE) {
1540                 if (arg != PORT_POTS)
1541                         return 10;
1542                 else
1543                         return 0;
1544         }
1545         switch (arg) {
1546         case PORT_POTS:
1547                 j->port = PORT_POTS;
1548                 switch (j->cardtype) {
1549                 case QTI_PHONECARD:
1550                         if (j->flags.pcmciasct == 1)
1551                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1552                         else
1553                                 return 11;
1554                         break;
1555                 case QTI_PHONEJACK_PCI:
1556                         j->pld_slicw.pcib.mic = 0;
1557                         j->pld_slicw.pcib.spk = 0;
1558                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1559                         break;
1560                 case QTI_LINEJACK:
1561                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1562                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1563                                                                            Software Control Register */
1564                                 return 2;
1565                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1566
1567                         outb(j->pld_scrw.byte, j->XILINXbase);
1568                         j->pld_clock.byte = 0;
1569                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1570                         j->pld_slicw.bits.rly1 = 1;
1571                         j->pld_slicw.bits.spken = 0;
1572                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1573                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1574                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1575                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1576                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1577                         ixj_mixer(0x0E80, j);   /*Mic mute */
1578                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1579                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1580                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1581                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1582 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1583                         break;
1584                 case QTI_PHONEJACK:
1585                         j->gpio.bytes.high = 0x0B;
1586                         j->gpio.bits.gpio6 = 0;
1587                         j->gpio.bits.gpio7 = 0;
1588                         ixj_WriteDSPCommand(j->gpio.word, j);
1589                         break;
1590                 }
1591                 break;
1592         case PORT_PSTN:
1593                 if (j->cardtype == QTI_LINEJACK) {
1594                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1595
1596                         j->pld_slicw.bits.rly3 = 0;
1597                         j->pld_slicw.bits.rly1 = 1;
1598                         j->pld_slicw.bits.spken = 0;
1599                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1600                         j->port = PORT_PSTN;
1601                 } else {
1602                         return 4;
1603                 }
1604                 break;
1605         case PORT_SPEAKER:
1606                 j->port = PORT_SPEAKER;
1607                 switch (j->cardtype) {
1608                 case QTI_PHONECARD:
1609                         if (j->flags.pcmciasct) {
1610                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1611                         }
1612                         break;
1613                 case QTI_PHONEJACK_PCI:
1614                         j->pld_slicw.pcib.mic = 1;
1615                         j->pld_slicw.pcib.spk = 1;
1616                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1617                         break;
1618                 case QTI_LINEJACK:
1619                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1620                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1621                                                                            Software Control Register */
1622                                 return 2;
1623                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1624
1625                         outb(j->pld_scrw.byte, j->XILINXbase);
1626                         j->pld_clock.byte = 0;
1627                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1628                         j->pld_slicw.bits.rly1 = 1;
1629                         j->pld_slicw.bits.spken = 1;
1630                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1631                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1632                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1633                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1634                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1635                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1636                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1637                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1638                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1639                         break;
1640                 case QTI_PHONEJACK:
1641                         j->gpio.bytes.high = 0x0B;
1642                         j->gpio.bits.gpio6 = 0;
1643                         j->gpio.bits.gpio7 = 1;
1644                         ixj_WriteDSPCommand(j->gpio.word, j);
1645                         break;
1646                 }
1647                 break;
1648         case PORT_HANDSET:
1649                 if (j->cardtype != QTI_PHONEJACK) {
1650                         return 5;
1651                 } else {
1652                         j->gpio.bytes.high = 0x0B;
1653                         j->gpio.bits.gpio6 = 1;
1654                         j->gpio.bits.gpio7 = 0;
1655                         ixj_WriteDSPCommand(j->gpio.word, j);
1656                         j->port = PORT_HANDSET;
1657                 }
1658                 break;
1659         default:
1660                 return 6;
1661                 break;
1662         }
1663         return 0;
1664 }
1665
1666 static int ixj_set_pots(IXJ *j, int arg)
1667 {
1668         if (j->cardtype == QTI_LINEJACK) {
1669                 if (arg) {
1670                         if (j->port == PORT_PSTN) {
1671                                 j->pld_slicw.bits.rly1 = 0;
1672                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1673                                 j->flags.pots_pstn = 1;
1674                                 return 1;
1675                         } else {
1676                                 j->flags.pots_pstn = 0;
1677                                 return 0;
1678                         }
1679                 } else {
1680                         j->pld_slicw.bits.rly1 = 1;
1681                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1682                         j->flags.pots_pstn = 0;
1683                         return 1;
1684                 }
1685         } else {
1686                 return 0;
1687         }
1688 }
1689
1690 static void ixj_ring_on(IXJ *j)
1691 {
1692         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1693          {
1694                 if (ixjdebug & 0x0004)
1695                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1696
1697                 j->gpio.bytes.high = 0x0B;
1698                 j->gpio.bytes.low = 0x00;
1699                 j->gpio.bits.gpio1 = 1;
1700                 j->gpio.bits.gpio2 = 1;
1701                 j->gpio.bits.gpio5 = 0;
1702                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1703         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1704         {
1705                 if (ixjdebug & 0x0004)
1706                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1707
1708                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1709         }
1710 }
1711
1712 static int ixj_siadc(IXJ *j, int val)
1713 {
1714         if(j->cardtype == QTI_PHONECARD){
1715                 if(j->flags.pcmciascp){
1716                         if(val == -1)
1717                                 return j->siadc.bits.rxg;
1718
1719                         if(val < 0 || val > 0x1F)
1720                                 return -1;
1721
1722                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1723                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1724                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1725                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1726                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1727                         j->psccr.bits.dev = 0;
1728                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1729                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1730                         ixj_PCcontrol_wait(j);
1731                         return j->siadc.bits.rxg;
1732                 }
1733         }
1734         return -1;
1735 }
1736
1737 static int ixj_sidac(IXJ *j, int val)
1738 {
1739         if(j->cardtype == QTI_PHONECARD){
1740                 if(j->flags.pcmciascp){
1741                         if(val == -1)
1742                                 return j->sidac.bits.txg;
1743
1744                         if(val < 0 || val > 0x1F)
1745                                 return -1;
1746
1747                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1748                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1749                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1750                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1751                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1752                         j->psccr.bits.dev = 0;
1753                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1754                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1755                         ixj_PCcontrol_wait(j);
1756                         return j->sidac.bits.txg;
1757                 }
1758         }
1759         return -1;
1760 }
1761
1762 static int ixj_pcmcia_cable_check(IXJ *j)
1763 {
1764         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1765         if (!j->flags.pcmciastate) {
1766                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1767                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1768                         j->flags.pcmciastate = 4;
1769                         return 0;
1770                 }
1771                 if (j->pccr1.bits.ed) {
1772                         j->pccr1.bits.ed = 0;
1773                         j->psccr.bits.dev = 3;
1774                         j->psccr.bits.rw = 1;
1775                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1776                         ixj_PCcontrol_wait(j);
1777                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1778                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1779                         j->psccr.bits.dev = 3;
1780                         j->psccr.bits.rw = 0;
1781                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1782                         ixj_PCcontrol_wait(j);
1783                         return j->pslic.bits.led2 ? 1 : 0;
1784                 } else if (j->flags.pcmciasct) {
1785                         return j->r_hook;
1786                 } else {
1787                         return 1;
1788                 }
1789         } else if (j->flags.pcmciastate == 4) {
1790                 if (!j->pccr1.bits.drf) {
1791                         j->flags.pcmciastate = 3;
1792                 }
1793                 return 0;
1794         } else if (j->flags.pcmciastate == 3) {
1795                 j->pccr2.bits.pwr = 0;
1796                 j->pccr2.bits.rstc = 1;
1797                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1798                 j->checkwait = jiffies + (hertz * 2);
1799                 j->flags.incheck = 1;
1800                 j->flags.pcmciastate = 2;
1801                 return 0;
1802         } else if (j->flags.pcmciastate == 2) {
1803                 if (j->flags.incheck) {
1804                         if (time_before(jiffies, j->checkwait)) {
1805                                 return 0;
1806                         } else {
1807                                 j->flags.incheck = 0;
1808                         }
1809                 }
1810                 j->pccr2.bits.pwr = 0;
1811                 j->pccr2.bits.rstc = 0;
1812                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1813                 j->flags.pcmciastate = 1;
1814                 return 0;
1815         } else if (j->flags.pcmciastate == 1) {
1816                 j->flags.pcmciastate = 0;
1817                 if (!j->pccr1.bits.drf) {
1818                         j->psccr.bits.dev = 3;
1819                         j->psccr.bits.rw = 1;
1820                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1821                         ixj_PCcontrol_wait(j);
1822                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1823
1824                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1825
1826                         if (j->flags.pcmciasct == 3) {
1827                                 j->flags.pcmciastate = 4;
1828                                 return 0;
1829                         } else if (j->flags.pcmciasct == 0) {
1830                                 j->pccr2.bits.pwr = 1;
1831                                 j->pccr2.bits.rstc = 0;
1832                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1833                                 j->port = PORT_SPEAKER;
1834                         } else {
1835                                 j->port = PORT_POTS;
1836                         }
1837                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1838                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1839                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1840                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1841                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1842                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1843                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1844                         j->psccr.bits.dev = 0;
1845                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1846                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1847                         ixj_PCcontrol_wait(j);
1848
1849                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1850                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1851                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1852                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1853                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1854                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1855                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1856                         j->psccr.bits.dev = 0;
1857                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1858                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1859                         ixj_PCcontrol_wait(j);
1860
1861                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1862                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1863                         j->psccr.bits.dev = 0;
1864                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1865                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1866                         ixj_PCcontrol_wait(j);
1867
1868                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1869                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1870                         j->psccr.bits.dev = 0;
1871                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1872                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1873                         ixj_PCcontrol_wait(j);
1874
1875                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1876                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1877                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1878                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1879                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1880                         j->sirxg.bits.iir = 1;                          /* IIR */
1881                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1882                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1883                         j->psccr.bits.dev = 0;
1884                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1885                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1886                         ixj_PCcontrol_wait(j);
1887
1888                         ixj_siadc(j, 0x17);
1889                         ixj_sidac(j, 0x1D);
1890
1891                         j->siaatt.bits.sot = 0;
1892                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1893                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1894                         j->psccr.bits.dev = 0;
1895                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1896                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1897                         ixj_PCcontrol_wait(j);
1898
1899                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1900                                 j->psccr.byte = j->pslic.byte = 0;
1901                                 j->pslic.bits.powerdown = 1;
1902                                 j->psccr.bits.dev = 3;
1903                                 j->psccr.bits.rw = 0;
1904                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1905                                 ixj_PCcontrol_wait(j);
1906                         }
1907                 }
1908                 return 0;
1909         } else {
1910                 j->flags.pcmciascp = 0;
1911                 return 0;
1912         }
1913         return 0;
1914 }
1915
1916 static int ixj_hookstate(IXJ *j)
1917 {
1918         int fOffHook = 0;
1919
1920         switch (j->cardtype) {
1921         case QTI_PHONEJACK:
1922                 ixj_gpio_read(j);
1923                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1924                 break;
1925         case QTI_LINEJACK:
1926         case QTI_PHONEJACK_LITE:
1927         case QTI_PHONEJACK_PCI:
1928                 SLIC_GetState(j);
1929                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1930                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1931                         if(fOffHook != j->p_hook) {
1932                                 if(!j->checkwait) {
1933                                         j->checkwait = jiffies;
1934                                 }
1935                                 if(time_before(jiffies, j->checkwait + 2)) {
1936                                         fOffHook ^= 1;
1937                                 } else {
1938                                         j->checkwait = 0;
1939                                 }
1940                                 j->p_hook = fOffHook;
1941                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1942                         }
1943                 } else {
1944                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1945                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1946                                 if (j->flags.ringing || j->flags.cringing) {
1947                                         if (!in_interrupt()) {
1948                                                 msleep(20);
1949                                         }
1950                                         SLIC_GetState(j);
1951                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1952                                                 ixj_ring_on(j);
1953                                         }
1954                                 }
1955                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1956                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1957                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1958                                 } else
1959                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1960                         }
1961                 }
1962                 break;
1963         case QTI_PHONECARD:
1964                 fOffHook = ixj_pcmcia_cable_check(j);
1965                 break;
1966         }
1967         if (j->r_hook != fOffHook) {
1968                 j->r_hook = fOffHook;
1969                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1970                         j->ex.bits.hookstate = 1;
1971                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1972                 } else if (!fOffHook) {
1973                         j->flash_end = jiffies + ((60 * hertz) / 100);
1974                 }
1975         }
1976         if (fOffHook) {
1977                 if(time_before(jiffies, j->flash_end)) {
1978                         j->ex.bits.flash = 1;
1979                         j->flash_end = 0;
1980                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1981                 }
1982         } else {
1983                 if(time_before(jiffies, j->flash_end)) {
1984                         fOffHook = 1;
1985                 }
1986         }
1987
1988         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1989                 fOffHook |= 2;
1990
1991         if (j->port == PORT_SPEAKER) {
1992                 if(j->cardtype == QTI_PHONECARD) {
1993                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1994                                 fOffHook |= 2;
1995                         }
1996                 } else {
1997                         fOffHook |= 2;
1998                 }
1999         }
2000
2001         if (j->port == PORT_HANDSET)
2002                 fOffHook |= 2;
2003
2004         return fOffHook;
2005 }
2006
2007 static void ixj_ring_off(IXJ *j)
2008 {
2009         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2010          {
2011                 if (ixjdebug & 0x0004)
2012                         printk(KERN_INFO "IXJ Ring Off\n");
2013                 j->gpio.bytes.high = 0x0B;
2014                 j->gpio.bytes.low = 0x00;
2015                 j->gpio.bits.gpio1 = 0;
2016                 j->gpio.bits.gpio2 = 1;
2017                 j->gpio.bits.gpio5 = 0;
2018                 ixj_WriteDSPCommand(j->gpio.word, j);
2019         } else                  /* Internet LineJACK */
2020         {
2021                 if (ixjdebug & 0x0004)
2022                         printk(KERN_INFO "IXJ Ring Off\n");
2023
2024                 if(!j->flags.cidplay)
2025                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2026
2027                 SLIC_GetState(j);
2028         }
2029 }
2030
2031 static void ixj_ring_start(IXJ *j)
2032 {
2033         j->flags.cringing = 1;
2034         if (ixjdebug & 0x0004)
2035                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2036         if (ixj_hookstate(j) & 1) {
2037                 if (j->port == PORT_POTS)
2038                         ixj_ring_off(j);
2039                 j->flags.cringing = 0;
2040                 if (ixjdebug & 0x0004)
2041                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2042         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2043                 j->ring_cadence_jif = jiffies;
2044                 j->flags.cidsent = j->flags.cidring = 0;
2045                 j->cadence_f[5].state = 0;
2046                 if(j->cadence_f[5].on1)
2047                         ixj_ring_on(j);
2048         } else {
2049                 j->ring_cadence_jif = jiffies;
2050                 j->ring_cadence_t = 15;
2051                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2052                         ixj_ring_on(j);
2053                 } else {
2054                         ixj_ring_off(j);
2055                 }
2056                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2057         }
2058 }
2059
2060 static int ixj_ring(IXJ *j)
2061 {
2062         char cntr;
2063         unsigned long jif;
2064
2065         j->flags.ringing = 1;
2066         if (ixj_hookstate(j) & 1) {
2067                 ixj_ring_off(j);
2068                 j->flags.ringing = 0;
2069                 return 1;
2070         }
2071         for (cntr = 0; cntr < j->maxrings; cntr++) {
2072                 jif = jiffies + (1 * hertz);
2073                 ixj_ring_on(j);
2074                 while (time_before(jiffies, jif)) {
2075                         if (ixj_hookstate(j) & 1) {
2076                                 ixj_ring_off(j);
2077                                 j->flags.ringing = 0;
2078                                 return 1;
2079                         }
2080                         schedule_timeout_interruptible(1);
2081                         if (signal_pending(current))
2082                                 break;
2083                 }
2084                 jif = jiffies + (3 * hertz);
2085                 ixj_ring_off(j);
2086                 while (time_before(jiffies, jif)) {
2087                         if (ixj_hookstate(j) & 1) {
2088                                 msleep(10);
2089                                 if (ixj_hookstate(j) & 1) {
2090                                         j->flags.ringing = 0;
2091                                         return 1;
2092                                 }
2093                         }
2094                         schedule_timeout_interruptible(1);
2095                         if (signal_pending(current))
2096                                 break;
2097                 }
2098         }
2099         ixj_ring_off(j);
2100         j->flags.ringing = 0;
2101         return 0;
2102 }
2103
2104 static int ixj_open(struct phone_device *p, struct file *file_p)
2105 {
2106         IXJ *j = get_ixj(p->board);
2107         file_p->private_data = j;
2108
2109         if (!j->DSPbase)
2110                 return -ENODEV;
2111
2112         if (file_p->f_mode & FMODE_READ) {
2113                 if(!j->readers) {
2114                         j->readers++;
2115                 } else {
2116                         return -EBUSY;
2117                 }
2118         }
2119
2120         if (file_p->f_mode & FMODE_WRITE) {
2121                 if(!j->writers) {
2122                         j->writers++;
2123                 } else {
2124                         if (file_p->f_mode & FMODE_READ){
2125                                 j->readers--;
2126                         }
2127                         return -EBUSY;
2128                 }
2129         }
2130
2131         if (j->cardtype == QTI_PHONECARD) {
2132                 j->pslic.bits.powerdown = 0;
2133                 j->psccr.bits.dev = 3;
2134                 j->psccr.bits.rw = 0;
2135                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2136                 ixj_PCcontrol_wait(j);
2137         }
2138
2139         j->flags.cidplay = 0;
2140         j->flags.cidcw_ack = 0;
2141
2142         if (ixjdebug & 0x0002)
2143                 printk(KERN_INFO "Opening board %d\n", p->board);
2144
2145         j->framesread = j->frameswritten = 0;
2146         return 0;
2147 }
2148
2149 static int ixj_release(struct inode *inode, struct file *file_p)
2150 {
2151         IXJ_TONE ti;
2152         int cnt;
2153         IXJ *j = file_p->private_data;
2154         int board = j->p.board;
2155
2156         /*
2157          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2158          *    This is necessary to keep the DSP from locking up.
2159          */
2160         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2161                 schedule_timeout_interruptible(1);
2162         if (ixjdebug & 0x0002)
2163                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2164
2165         if (j->cardtype == QTI_PHONECARD)
2166                 ixj_set_port(j, PORT_SPEAKER);
2167         else
2168                 ixj_set_port(j, PORT_POTS);
2169
2170         aec_stop(j);
2171         ixj_play_stop(j);
2172         ixj_record_stop(j);
2173         set_play_volume(j, 0x100);
2174         set_rec_volume(j, 0x100);
2175         ixj_ring_off(j);
2176
2177         /* Restore the tone table to default settings. */
2178         ti.tone_index = 10;
2179         ti.gain0 = 1;
2180         ti.freq0 = hz941;
2181         ti.gain1 = 0;
2182         ti.freq1 = hz1209;
2183         ixj_init_tone(j, &ti);
2184         ti.tone_index = 11;
2185         ti.gain0 = 1;
2186         ti.freq0 = hz941;
2187         ti.gain1 = 0;
2188         ti.freq1 = hz1336;
2189         ixj_init_tone(j, &ti);
2190         ti.tone_index = 12;
2191         ti.gain0 = 1;
2192         ti.freq0 = hz941;
2193         ti.gain1 = 0;
2194         ti.freq1 = hz1477;
2195         ixj_init_tone(j, &ti);
2196         ti.tone_index = 13;
2197         ti.gain0 = 1;
2198         ti.freq0 = hz800;
2199         ti.gain1 = 0;
2200         ti.freq1 = 0;
2201         ixj_init_tone(j, &ti);
2202         ti.tone_index = 14;
2203         ti.gain0 = 1;
2204         ti.freq0 = hz1000;
2205         ti.gain1 = 0;
2206         ti.freq1 = 0;
2207         ixj_init_tone(j, &ti);
2208         ti.tone_index = 15;
2209         ti.gain0 = 1;
2210         ti.freq0 = hz1250;
2211         ti.gain1 = 0;
2212         ti.freq1 = 0;
2213         ixj_init_tone(j, &ti);
2214         ti.tone_index = 16;
2215         ti.gain0 = 1;
2216         ti.freq0 = hz950;
2217         ti.gain1 = 0;
2218         ti.freq1 = 0;
2219         ixj_init_tone(j, &ti);
2220         ti.tone_index = 17;
2221         ti.gain0 = 1;
2222         ti.freq0 = hz1100;
2223         ti.gain1 = 0;
2224         ti.freq1 = 0;
2225         ixj_init_tone(j, &ti);
2226         ti.tone_index = 18;
2227         ti.gain0 = 1;
2228         ti.freq0 = hz1400;
2229         ti.gain1 = 0;
2230         ti.freq1 = 0;
2231         ixj_init_tone(j, &ti);
2232         ti.tone_index = 19;
2233         ti.gain0 = 1;
2234         ti.freq0 = hz1500;
2235         ti.gain1 = 0;
2236         ti.freq1 = 0;
2237         ixj_init_tone(j, &ti);
2238         ti.tone_index = 20;
2239         ti.gain0 = 1;
2240         ti.freq0 = hz1600;
2241         ti.gain1 = 0;
2242         ti.freq1 = 0;
2243         ixj_init_tone(j, &ti);
2244         ti.tone_index = 21;
2245         ti.gain0 = 1;
2246         ti.freq0 = hz1800;
2247         ti.gain1 = 0;
2248         ti.freq1 = 0;
2249         ixj_init_tone(j, &ti);
2250         ti.tone_index = 22;
2251         ti.gain0 = 1;
2252         ti.freq0 = hz2100;
2253         ti.gain1 = 0;
2254         ti.freq1 = 0;
2255         ixj_init_tone(j, &ti);
2256         ti.tone_index = 23;
2257         ti.gain0 = 1;
2258         ti.freq0 = hz1300;
2259         ti.gain1 = 0;
2260         ti.freq1 = 0;
2261         ixj_init_tone(j, &ti);
2262         ti.tone_index = 24;
2263         ti.gain0 = 1;
2264         ti.freq0 = hz2450;
2265         ti.gain1 = 0;
2266         ti.freq1 = 0;
2267         ixj_init_tone(j, &ti);
2268         ti.tone_index = 25;
2269         ti.gain0 = 1;
2270         ti.freq0 = hz350;
2271         ti.gain1 = 0;
2272         ti.freq1 = hz440;
2273         ixj_init_tone(j, &ti);
2274         ti.tone_index = 26;
2275         ti.gain0 = 1;
2276         ti.freq0 = hz440;
2277         ti.gain1 = 0;
2278         ti.freq1 = hz480;
2279         ixj_init_tone(j, &ti);
2280         ti.tone_index = 27;
2281         ti.gain0 = 1;
2282         ti.freq0 = hz480;
2283         ti.gain1 = 0;
2284         ti.freq1 = hz620;
2285         ixj_init_tone(j, &ti);
2286
2287         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2288
2289         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2290
2291         j->ex.bits.dtmf_ready = 0;
2292         j->dtmf_state = 0;
2293         j->dtmf_wp = j->dtmf_rp = 0;
2294         j->rec_mode = j->play_mode = -1;
2295         j->flags.ringing = 0;
2296         j->maxrings = MAXRINGS;
2297         j->ring_cadence = USA_RING_CADENCE;
2298         if(j->cadence_f[5].enable) {
2299                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2300         }
2301         j->drybuffer = 0;
2302         j->winktime = 320;
2303         j->flags.dtmf_oob = 0;
2304         for (cnt = 0; cnt < 4; cnt++)
2305                 j->cadence_f[cnt].enable = 0;
2306
2307         idle(j);
2308
2309         if(j->cardtype == QTI_PHONECARD) {
2310                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2311         }
2312
2313         if (file_p->f_mode & FMODE_READ)
2314                 j->readers--;
2315         if (file_p->f_mode & FMODE_WRITE)
2316                 j->writers--;
2317
2318         if (j->read_buffer && !j->readers) {
2319                 kfree(j->read_buffer);
2320                 j->read_buffer = NULL;
2321                 j->read_buffer_size = 0;
2322         }
2323         if (j->write_buffer && !j->writers) {
2324                 kfree(j->write_buffer);
2325                 j->write_buffer = NULL;
2326                 j->write_buffer_size = 0;
2327         }
2328         j->rec_codec = j->play_codec = 0;
2329         j->rec_frame_size = j->play_frame_size = 0;
2330         j->flags.cidsent = j->flags.cidring = 0;
2331
2332         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2333                 ixj_set_port(j, PORT_PSTN);
2334                 daa_set_mode(j, SOP_PU_SLEEP);
2335                 ixj_set_pots(j, 1);
2336         }
2337         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2338
2339         /* Set up the default signals for events */
2340         for (cnt = 0; cnt < 35; cnt++)
2341                 j->ixj_signals[cnt] = SIGIO;
2342
2343         /* Set the excetion signal enable flags */
2344         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2345         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 =
2346         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;
2347
2348         file_p->private_data = NULL;
2349         clear_bit(board, &j->busyflags);
2350         return 0;
2351 }
2352
2353 static int read_filters(IXJ *j)
2354 {
2355         unsigned short fc, cnt, trg;
2356         int var;
2357
2358         trg = 0;
2359         if (ixj_WriteDSPCommand(0x5144, j)) {
2360                 if(ixjdebug & 0x0001) {
2361                         printk(KERN_INFO "Read Frame Counter failed!\n");
2362                 }
2363                 return -1;
2364         }
2365         fc = j->ssr.high << 8 | j->ssr.low;
2366         if (fc == j->frame_count)
2367                 return 1;
2368
2369         j->frame_count = fc;
2370
2371         if (j->dtmf_proc)
2372                 return 1;
2373
2374         var = 10;
2375
2376         for (cnt = 0; cnt < 4; cnt++) {
2377                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2378                         if(ixjdebug & 0x0001) {
2379                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2380                         }
2381                         return -1;
2382                 }
2383                 if (ixj_WriteDSPCommand(0x515C, j)) {
2384                         if(ixjdebug & 0x0001) {
2385                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2386                         }
2387                         return -1;
2388                 }
2389                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2390
2391                 if (j->cadence_f[cnt].enable) {
2392                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2393                                 if (j->cadence_f[cnt].state == 0) {
2394                                         j->cadence_f[cnt].state = 1;
2395                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2396                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2397                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2398                                 } else if (j->cadence_f[cnt].state == 2 &&
2399                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2400                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2401                                         if (j->cadence_f[cnt].on2) {
2402                                                 j->cadence_f[cnt].state = 3;
2403                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2404                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2405                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2406                                         } else {
2407                                                 j->cadence_f[cnt].state = 7;
2408                                         }
2409                                 } else if (j->cadence_f[cnt].state == 4 &&
2410                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2411                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2412                                         if (j->cadence_f[cnt].on3) {
2413                                                 j->cadence_f[cnt].state = 5;
2414                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2415                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2416                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2417                                         } else {
2418                                                 j->cadence_f[cnt].state = 7;
2419                                         }
2420                                 } else {
2421                                         j->cadence_f[cnt].state = 0;
2422                                 }
2423                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2424                                 if (j->cadence_f[cnt].state == 1) {
2425                                         if(!j->cadence_f[cnt].on1) {
2426                                                 j->cadence_f[cnt].state = 7;
2427                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2428                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2429                                                 if(j->cadence_f[cnt].off1) {
2430                                                         j->cadence_f[cnt].state = 2;
2431                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2432                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2433                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2434                                                 } else {
2435                                                         j->cadence_f[cnt].state = 7;
2436                                                 }
2437                                         } else {
2438                                                 j->cadence_f[cnt].state = 0;
2439                                         }
2440                                 } else if (j->cadence_f[cnt].state == 3) {
2441                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2442                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2443                                                 if(j->cadence_f[cnt].off2) {
2444                                                         j->cadence_f[cnt].state = 4;
2445                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2446                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2447                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2448                                                 } else {
2449                                                         j->cadence_f[cnt].state = 7;
2450                                                 }
2451                                         } else {
2452                                                 j->cadence_f[cnt].state = 0;
2453                                         }
2454                                 } else if (j->cadence_f[cnt].state == 5) {
2455                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2456                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2457                                                 if(j->cadence_f[cnt].off3) {
2458                                                         j->cadence_f[cnt].state = 6;
2459                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2460                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2461                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2462                                                 } else {
2463                                                         j->cadence_f[cnt].state = 7;
2464                                                 }
2465                                         } else {
2466                                                 j->cadence_f[cnt].state = 0;
2467                                         }
2468                                 } else {
2469                                         j->cadence_f[cnt].state = 0;
2470                                 }
2471                         } else {
2472                                 switch(j->cadence_f[cnt].state) {
2473                                         case 1:
2474                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2475                                                    !j->cadence_f[cnt].off1 &&
2476                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2477                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2478                                                         j->cadence_f[cnt].state = 7;
2479                                                 }
2480                                                 break;
2481                                         case 3:
2482                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2483                                                    !j->cadence_f[cnt].off2 &&
2484                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2485                                                         j->cadence_f[cnt].state = 7;
2486                                                 }
2487                                                 break;
2488                                         case 5:
2489                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2490                                                    !j->cadence_f[cnt].off3) {
2491                                                         j->cadence_f[cnt].state = 7;
2492                                                 }
2493                                                 break;
2494                                 }
2495                         }
2496
2497                         if (ixjdebug & 0x0040) {
2498                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2499                                 switch(j->cadence_f[cnt].state) {
2500                                         case 0:
2501                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2502                                                 break;
2503                                         case 1:
2504                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2505                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2506                                                 break;
2507                                         case 2:
2508                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2509                                                                                                                         j->cadence_f[cnt].off1max);
2510                                                 break;
2511                                         case 3:
2512                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2513                                                                                                                         j->cadence_f[cnt].on2max);
2514                                                 break;
2515                                         case 4:
2516                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2517                                                                                                                         j->cadence_f[cnt].off2max);
2518                                                 break;
2519                                         case 5:
2520                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2521                                                                                                                         j->cadence_f[cnt].on3max);
2522                                                 break;
2523                                         case 6:
2524                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2525                                                                                                                         j->cadence_f[cnt].off3max);
2526                                                 break;
2527                                 }
2528                         }
2529                 }
2530                 if (j->cadence_f[cnt].state == 7) {
2531                         j->cadence_f[cnt].state = 0;
2532                         if (j->cadence_f[cnt].enable == 1)
2533                                 j->cadence_f[cnt].enable = 0;
2534                         switch (cnt) {
2535                         case 0:
2536                                 if(ixjdebug & 0x0020) {
2537                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2538                                 }
2539                                 j->ex.bits.fc0 = 1;
2540                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2541                                 break;
2542                         case 1:
2543                                 if(ixjdebug & 0x0020) {
2544                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2545                                 }
2546                                 j->ex.bits.fc1 = 1;
2547                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2548                                 break;
2549                         case 2:
2550                                 if(ixjdebug & 0x0020) {
2551                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2552                                 }
2553                                 j->ex.bits.fc2 = 1;
2554                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2555                                 break;
2556                         case 3:
2557                                 if(ixjdebug & 0x0020) {
2558                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2559                                 }
2560                                 j->ex.bits.fc3 = 1;
2561                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2562                                 break;
2563                         }
2564                 }
2565                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2566                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2567                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2568                                 trg = 1;
2569                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2570                                 trg = 0;
2571                         }
2572                         switch (cnt) {
2573                         case 0:
2574                                 if(ixjdebug & 0x0020) {
2575                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2576                                 }
2577                                 j->ex.bits.f0 = 1;
2578                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2579                                 break;
2580                         case 1:
2581                                 if(ixjdebug & 0x0020) {
2582                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2583                                 }
2584                                 j->ex.bits.f1 = 1;
2585                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2586                                 break;
2587                         case 2:
2588                                 if(ixjdebug & 0x0020) {
2589                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2590                                 }
2591                                 j->ex.bits.f2 = 1;
2592                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2593                                 break;
2594                         case 3:
2595                                 if(ixjdebug & 0x0020) {
2596                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2597                                 }
2598                                 j->ex.bits.f3 = 1;
2599                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2600                                 break;
2601                         }
2602                 }
2603         }
2604         return 0;
2605 }
2606
2607 static int LineMonitor(IXJ *j)
2608 {
2609         if (j->dtmf_proc) {
2610                 return -1;
2611         }
2612         j->dtmf_proc = 1;
2613
2614         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2615                 return -1;
2616
2617         j->dtmf.bytes.high = j->ssr.high;
2618         j->dtmf.bytes.low = j->ssr.low;
2619         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2620                 j->dtmf_state = 1;
2621                 j->dtmf_current = j->dtmf.bits.digit;
2622         }
2623         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2624          {
2625                 if(!j->cidcw_wait) {
2626                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2627                         j->dtmf_wp++;
2628                         if (j->dtmf_wp == 79)
2629                                 j->dtmf_wp = 0;
2630                         j->ex.bits.dtmf_ready = 1;
2631                         if(j->ex_sig.bits.dtmf_ready) {
2632                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2633                         }
2634                 }
2635                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2636                         if(ixjdebug & 0x0020) {
2637                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2638                         }
2639                         j->flags.cidcw_ack = 1;
2640                 }
2641                 j->dtmf_state = 0;
2642         }
2643         j->dtmf_proc = 0;
2644
2645         return 0;
2646 }
2647
2648 /************************************************************************
2649 *
2650 * Functions to allow alaw <-> ulaw conversions.
2651 *
2652 ************************************************************************/
2653
2654 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2655 {
2656         static unsigned char table_ulaw2alaw[] =
2657         {
2658                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2659                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2660                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2661                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2662                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2663                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2664                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2665                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2666                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2667                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2668                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2669                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2670                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2671                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2672                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2673                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2674                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2675                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2676                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2677                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2678                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2679                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2680                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2681                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2682                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2683                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2684                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2685                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2686                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2687                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2688                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2689                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2690         };
2691
2692         while (len--)
2693         {
2694                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2695                 buff++;
2696         }
2697 }
2698
2699 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2700 {
2701         static unsigned char table_alaw2ulaw[] =
2702         {
2703                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2704                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2705                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2706                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2707                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2708                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2709                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2710                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2711                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2712                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2713                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2714                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2715                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2716                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2717                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2718                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2719                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2720                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2721                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2722                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2723                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2724                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2725                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2726                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2727                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2728                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2729                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2730                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2731                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2732                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2733                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2734                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2735         };
2736
2737         while (len--)
2738         {
2739                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2740                 buff++;
2741         }
2742 }
2743
2744 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2745 {
2746         unsigned long i = *ppos;
2747         IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2748
2749         DECLARE_WAITQUEUE(wait, current);
2750
2751         if (j->flags.inread)
2752                 return -EALREADY;
2753
2754         j->flags.inread = 1;
2755
2756         add_wait_queue(&j->read_q, &wait);
2757         set_current_state(TASK_INTERRUPTIBLE);
2758         mb();
2759
2760         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2761                 ++j->read_wait;
2762                 if (file_p->f_flags & O_NONBLOCK) {
2763                         set_current_state(TASK_RUNNING);
2764                         remove_wait_queue(&j->read_q, &wait);
2765                         j->flags.inread = 0;
2766                         return -EAGAIN;
2767                 }
2768                 if (!ixj_hookstate(j)) {
2769                         set_current_state(TASK_RUNNING);
2770                         remove_wait_queue(&j->read_q, &wait);
2771                         j->flags.inread = 0;
2772                         return 0;
2773                 }
2774                 interruptible_sleep_on(&j->read_q);
2775                 if (signal_pending(current)) {
2776                         set_current_state(TASK_RUNNING);
2777                         remove_wait_queue(&j->read_q, &wait);
2778                         j->flags.inread = 0;
2779                         return -EINTR;
2780                 }
2781         }
2782
2783         remove_wait_queue(&j->read_q, &wait);
2784         set_current_state(TASK_RUNNING);
2785         /* Don't ever copy more than the user asks */
2786         if(j->rec_codec == ALAW)
2787                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2788         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2789         j->read_buffer_ready = 0;
2790         if (i) {
2791                 j->flags.inread = 0;
2792                 return -EFAULT;
2793         } else {
2794                 j->flags.inread = 0;
2795                 return min(length, j->read_buffer_size);
2796         }
2797 }
2798
2799 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2800                           loff_t * ppos)
2801 {
2802         int pre_retval;
2803         ssize_t read_retval = 0;
2804         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2805
2806         pre_retval = ixj_PreRead(j, 0L);
2807         switch (pre_retval) {
2808         case NORMAL:
2809                 read_retval = ixj_read(file_p, buf, length, ppos);
2810                 ixj_PostRead(j, 0L);
2811                 break;
2812         case NOPOST:
2813                 read_retval = ixj_read(file_p, buf, length, ppos);
2814                 break;
2815         case POSTONLY:
2816                 ixj_PostRead(j, 0L);
2817                 break;
2818         default:
2819                 read_retval = pre_retval;
2820         }
2821         return read_retval;
2822 }
2823
2824 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2825 {
2826         unsigned long i = *ppos;
2827         IXJ *j = file_p->private_data;
2828
2829         DECLARE_WAITQUEUE(wait, current);
2830
2831         if (j->flags.inwrite)
2832                 return -EALREADY;
2833
2834         j->flags.inwrite = 1;
2835
2836         add_wait_queue(&j->write_q, &wait);
2837         set_current_state(TASK_INTERRUPTIBLE);
2838         mb();
2839
2840
2841         while (!j->write_buffers_empty) {
2842                 ++j->write_wait;
2843                 if (file_p->f_flags & O_NONBLOCK) {
2844                         set_current_state(TASK_RUNNING);
2845                         remove_wait_queue(&j->write_q, &wait);
2846                         j->flags.inwrite = 0;
2847                         return -EAGAIN;
2848                 }
2849                 if (!ixj_hookstate(j)) {
2850                         set_current_state(TASK_RUNNING);
2851                         remove_wait_queue(&j->write_q, &wait);
2852                         j->flags.inwrite = 0;
2853                         return 0;
2854                 }
2855                 interruptible_sleep_on(&j->write_q);
2856                 if (signal_pending(current)) {
2857                         set_current_state(TASK_RUNNING);
2858                         remove_wait_queue(&j->write_q, &wait);
2859                         j->flags.inwrite = 0;
2860                         return -EINTR;
2861                 }
2862         }
2863         set_current_state(TASK_RUNNING);
2864         remove_wait_queue(&j->write_q, &wait);
2865         if (j->write_buffer_wp + count >= j->write_buffer_end)
2866                 j->write_buffer_wp = j->write_buffer;
2867         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2868         if (i) {
2869                 j->flags.inwrite = 0;
2870                 return -EFAULT;
2871         }
2872        if(j->play_codec == ALAW)
2873                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2874         j->flags.inwrite = 0;
2875         return min(count, j->write_buffer_size);
2876 }
2877
2878 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2879 {
2880         int pre_retval;
2881         ssize_t write_retval = 0;
2882
2883         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2884
2885         pre_retval = ixj_PreWrite(j, 0L);
2886         switch (pre_retval) {
2887         case NORMAL:
2888                 write_retval = ixj_write(file_p, buf, count, ppos);
2889                 if (write_retval > 0) {
2890                         ixj_PostWrite(j, 0L);
2891                         j->write_buffer_wp += write_retval;
2892                         j->write_buffers_empty--;
2893                 }
2894                 break;
2895         case NOPOST:
2896                 write_retval = ixj_write(file_p, buf, count, ppos);
2897                 if (write_retval > 0) {
2898                         j->write_buffer_wp += write_retval;
2899                         j->write_buffers_empty--;
2900                 }
2901                 break;
2902         case POSTONLY:
2903                 ixj_PostWrite(j, 0L);
2904                 break;
2905         default:
2906                 write_retval = pre_retval;
2907         }
2908         return write_retval;
2909 }
2910
2911 static void ixj_read_frame(IXJ *j)
2912 {
2913         int cnt, dly;
2914
2915         if (j->read_buffer) {
2916                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2917                         if (!(cnt % 16) && !IsRxReady(j)) {
2918                                 dly = 0;
2919                                 while (!IsRxReady(j)) {
2920                                         if (dly++ > 5) {
2921                                                 dly = 0;
2922                                                 break;
2923                                         }
2924                                         udelay(10);
2925                                 }
2926                         }
2927                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2928                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2929                                 inb_p(j->DSPbase + 0x0E);
2930                                 inb_p(j->DSPbase + 0x0F);
2931                         }
2932                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2933                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2934                 }
2935                 ++j->framesread;
2936                 if (j->intercom != -1) {
2937                         if (IsTxReady(get_ixj(j->intercom))) {
2938                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2939                                         if (!(cnt % 16) && !IsTxReady(j)) {
2940                                                 dly = 0;
2941                                                 while (!IsTxReady(j)) {
2942                                                         if (dly++ > 5) {
2943                                                                 dly = 0;
2944                                                                 break;
2945                                                         }
2946                                                         udelay(10);
2947                                                 }
2948                                         }
2949                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2950                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2951                                 }
2952                                 get_ixj(j->intercom)->frameswritten++;
2953                         }
2954                 } else {
2955                         j->read_buffer_ready = 1;
2956                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2957
2958                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2959
2960                         if(j->ixj_signals[SIG_READ_READY])
2961                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2962                 }
2963         }
2964 }
2965
2966 static short fsk[][6][20] =
2967 {
2968         {
2969                 {
2970                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2971                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2972                 },
2973                 {
2974                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2975                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2976                 },
2977                 {
2978                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2979                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2980                 },
2981                 {
2982                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2983                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2984                 },
2985                 {
2986                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2987                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2988                 },
2989                 {
2990                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2991                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2992                 }
2993         },
2994         {
2995                 {
2996                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
2997                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
2998                 },
2999                 {
3000                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3001                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3002                 },
3003                 {
3004                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3005                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3006                 },
3007                 {
3008                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3009                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3010                 },
3011                 {
3012                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3013                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3014                 },
3015                 {
3016                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3017                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3018                 }
3019         }
3020 };
3021
3022
3023 static void ixj_write_cid_bit(IXJ *j, int bit)
3024 {
3025         while (j->fskcnt < 20) {
3026                 if(j->fskdcnt < (j->fsksize - 1))
3027                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3028
3029                 j->fskcnt += 3;
3030         }
3031         j->fskcnt %= 20;
3032
3033         if (!bit)
3034                 j->fskz++;
3035         if (j->fskz >= 6)
3036                 j->fskz = 0;
3037
3038 }
3039
3040 static void ixj_write_cid_byte(IXJ *j, char byte)
3041 {
3042         IXJ_CBYTE cb;
3043
3044                 cb.cbyte = byte;
3045                 ixj_write_cid_bit(j, 0);
3046                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3047                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3048                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3053                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3054                 ixj_write_cid_bit(j, 1);
3055 }
3056
3057 static void ixj_write_cid_seize(IXJ *j)
3058 {
3059         int cnt;
3060
3061         for (cnt = 0; cnt < 150; cnt++) {
3062                 ixj_write_cid_bit(j, 0);
3063                 ixj_write_cid_bit(j, 1);
3064         }
3065         for (cnt = 0; cnt < 180; cnt++) {
3066                 ixj_write_cid_bit(j, 1);
3067         }
3068 }
3069
3070 static void ixj_write_cidcw_seize(IXJ *j)
3071 {
3072         int cnt;
3073
3074         for (cnt = 0; cnt < 80; cnt++) {
3075                 ixj_write_cid_bit(j, 1);
3076         }
3077 }
3078
3079 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3080 {
3081         int cnt;
3082
3083         for (cnt = 0; cnt < strlen(s); cnt++) {
3084                 ixj_write_cid_byte(j, s[cnt]);
3085                 checksum = (checksum + s[cnt]);
3086         }
3087         return checksum;
3088 }
3089
3090 static void ixj_pad_fsk(IXJ *j, int pad)
3091 {
3092         int cnt;
3093
3094         for (cnt = 0; cnt < pad; cnt++) {
3095                 if(j->fskdcnt < (j->fsksize - 1))
3096                         j->fskdata[j->fskdcnt++] = 0x0000;
3097         }
3098         for (cnt = 0; cnt < 720; cnt++) {
3099                 if(j->fskdcnt < (j->fsksize - 1))
3100                         j->fskdata[j->fskdcnt++] = 0x0000;
3101         }
3102 }
3103
3104 static void ixj_pre_cid(IXJ *j)
3105 {
3106         j->cid_play_codec = j->play_codec;
3107         j->cid_play_frame_size = j->play_frame_size;
3108         j->cid_play_volume = get_play_volume(j);
3109         j->cid_play_flag = j->flags.playing;
3110
3111         j->cid_rec_codec = j->rec_codec;
3112         j->cid_rec_volume = get_rec_volume(j);
3113         j->cid_rec_flag = j->flags.recording;
3114
3115         j->cid_play_aec_level = j->aec_level;
3116
3117         switch(j->baseframe.low) {
3118                 case 0xA0:
3119                         j->cid_base_frame_size = 20;
3120                         break;
3121                 case 0x50:
3122                         j->cid_base_frame_size = 10;
3123                         break;
3124                 case 0xF0:
3125                         j->cid_base_frame_size = 30;
3126                         break;
3127         }
3128
3129         ixj_play_stop(j);
3130         ixj_cpt_stop(j);
3131
3132         j->flags.cidplay = 1;
3133
3134         set_base_frame(j, 30);
3135         set_play_codec(j, LINEAR16);
3136         set_play_volume(j, 0x1B);
3137         ixj_play_start(j);
3138 }
3139
3140 static void ixj_post_cid(IXJ *j)
3141 {
3142         ixj_play_stop(j);
3143
3144         if(j->cidsize > 5000) {
3145                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3146         }
3147         j->flags.cidplay = 0;
3148         if(ixjdebug & 0x0200) {
3149                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3150         }
3151
3152         ixj_fsk_free(j);
3153
3154         j->fskdcnt = 0;
3155         set_base_frame(j, j->cid_base_frame_size);
3156         set_play_codec(j, j->cid_play_codec);
3157         ixj_aec_start(j, j->cid_play_aec_level);
3158         set_play_volume(j, j->cid_play_volume);
3159
3160         set_rec_codec(j, j->cid_rec_codec);
3161         set_rec_volume(j, j->cid_rec_volume);
3162
3163         if(j->cid_rec_flag)
3164                 ixj_record_start(j);
3165
3166         if(j->cid_play_flag)
3167                 ixj_play_start(j);
3168
3169         if(j->cid_play_flag) {
3170                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3171         }
3172 }
3173
3174 static void ixj_write_cid(IXJ *j)
3175 {
3176         char sdmf1[50];
3177         char sdmf2[50];
3178         char sdmf3[80];
3179         char mdmflen, len1, len2, len3;
3180         int pad;
3181
3182         int checksum = 0;
3183
3184         if (j->dsp.low == 0x20 || j->flags.cidplay)
3185                 return;
3186
3187         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3188         j->cidsize = j->cidcnt = 0;
3189
3190         ixj_fsk_alloc(j);
3191
3192         strcpy(sdmf1, j->cid_send.month);
3193         strcat(sdmf1, j->cid_send.day);
3194         strcat(sdmf1, j->cid_send.hour);
3195         strcat(sdmf1, j->cid_send.min);
3196         strcpy(sdmf2, j->cid_send.number);
3197         strcpy(sdmf3, j->cid_send.name);
3198
3199         len1 = strlen(sdmf1);
3200         len2 = strlen(sdmf2);
3201         len3 = strlen(sdmf3);
3202         mdmflen = len1 + len2 + len3 + 6;
3203
3204         while(1){
3205                 ixj_write_cid_seize(j);
3206
3207                 ixj_write_cid_byte(j, 0x80);
3208                 checksum = 0x80;
3209                 ixj_write_cid_byte(j, mdmflen);
3210                 checksum = checksum + mdmflen;
3211
3212                 ixj_write_cid_byte(j, 0x01);
3213                 checksum = checksum + 0x01;
3214                 ixj_write_cid_byte(j, len1);
3215                 checksum = checksum + len1;
3216                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3217                 if(ixj_hookstate(j) & 1)
3218                         break;
3219
3220                 ixj_write_cid_byte(j, 0x02);
3221                 checksum = checksum + 0x02;
3222                 ixj_write_cid_byte(j, len2);
3223                 checksum = checksum + len2;
3224                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3225                 if(ixj_hookstate(j) & 1)
3226                         break;
3227
3228                 ixj_write_cid_byte(j, 0x07);
3229                 checksum = checksum + 0x07;
3230                 ixj_write_cid_byte(j, len3);
3231                 checksum = checksum + len3;
3232                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3233                 if(ixj_hookstate(j) & 1)
3234                         break;
3235
3236                 checksum %= 256;
3237                 checksum ^= 0xFF;
3238                 checksum += 1;
3239
3240                 ixj_write_cid_byte(j, (char) checksum);
3241
3242                 pad = j->fskdcnt % 240;
3243                 if (pad) {
3244                         pad = 240 - pad;
3245                 }
3246                 ixj_pad_fsk(j, pad);
3247                 break;
3248         }
3249
3250         ixj_write_frame(j);
3251 }
3252
3253 static void ixj_write_cidcw(IXJ *j)
3254 {
3255         IXJ_TONE ti;
3256
3257         char sdmf1[50];
3258         char sdmf2[50];
3259         char sdmf3[80];
3260         char mdmflen, len1, len2, len3;
3261         int pad;
3262
3263         int checksum = 0;
3264
3265         if (j->dsp.low == 0x20 || j->flags.cidplay)
3266                 return;
3267
3268         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3269         j->cidsize = j->cidcnt = 0;
3270
3271         ixj_fsk_alloc(j);
3272
3273         j->flags.cidcw_ack = 0;
3274
3275         ti.tone_index = 23;
3276         ti.gain0 = 1;
3277         ti.freq0 = hz440;
3278         ti.gain1 = 0;
3279         ti.freq1 = 0;
3280         ixj_init_tone(j, &ti);
3281
3282         ixj_set_tone_on(1500, j);
3283         ixj_set_tone_off(32, j);
3284         if(ixjdebug & 0x0200) {
3285                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3286         }
3287         ixj_play_tone(j, 23);
3288
3289         clear_bit(j->board, &j->busyflags);
3290         while(j->tone_state)
3291                 schedule_timeout_interruptible(1);
3292         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3293                 schedule_timeout_interruptible(1);
3294         if(ixjdebug & 0x0200) {
3295                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3296         }
3297
3298         ti.tone_index = 24;
3299         ti.gain0 = 1;
3300         ti.freq0 = hz2130;
3301         ti.gain1 = 0;
3302         ti.freq1 = hz2750;
3303         ixj_init_tone(j, &ti);
3304
3305         ixj_set_tone_off(10, j);
3306         ixj_set_tone_on(600, j);
3307         if(ixjdebug & 0x0200) {
3308                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3309         }
3310         ixj_play_tone(j, 24);
3311
3312         clear_bit(j->board, &j->busyflags);
3313         while(j->tone_state)
3314                 schedule_timeout_interruptible(1);
3315         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3316                 schedule_timeout_interruptible(1);
3317         if(ixjdebug & 0x0200) {
3318                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3319         }
3320
3321         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3322
3323         clear_bit(j->board, &j->busyflags);
3324         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3325                 schedule_timeout_interruptible(1);
3326         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3327                 schedule_timeout_interruptible(1);
3328         j->cidcw_wait = 0;
3329         if(!j->flags.cidcw_ack) {
3330                 if(ixjdebug & 0x0200) {
3331                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3332                 }
3333                 ixj_post_cid(j);
3334                 if(j->cid_play_flag) {
3335                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3336                 }
3337                 return;
3338         } else {
3339                 ixj_pre_cid(j);
3340         }
3341         j->flags.cidcw_ack = 0;
3342         strcpy(sdmf1, j->cid_send.month);
3343         strcat(sdmf1, j->cid_send.day);
3344         strcat(sdmf1, j->cid_send.hour);
3345         strcat(sdmf1, j->cid_send.min);
3346         strcpy(sdmf2, j->cid_send.number);
3347         strcpy(sdmf3, j->cid_send.name);
3348
3349         len1 = strlen(sdmf1);
3350         len2 = strlen(sdmf2);
3351         len3 = strlen(sdmf3);
3352         mdmflen = len1 + len2 + len3 + 6;
3353
3354         ixj_write_cidcw_seize(j);
3355
3356         ixj_write_cid_byte(j, 0x80);
3357         checksum = 0x80;
3358         ixj_write_cid_byte(j, mdmflen);
3359         checksum = checksum + mdmflen;
3360
3361         ixj_write_cid_byte(j, 0x01);
3362         checksum = checksum + 0x01;
3363         ixj_write_cid_byte(j, len1);
3364         checksum = checksum + len1;
3365         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3366
3367         ixj_write_cid_byte(j, 0x02);
3368         checksum = checksum + 0x02;
3369         ixj_write_cid_byte(j, len2);
3370         checksum = checksum + len2;
3371         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3372
3373         ixj_write_cid_byte(j, 0x07);
3374         checksum = checksum + 0x07;
3375         ixj_write_cid_byte(j, len3);
3376         checksum = checksum + len3;
3377         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3378
3379         checksum %= 256;
3380         checksum ^= 0xFF;
3381         checksum += 1;
3382
3383         ixj_write_cid_byte(j, (char) checksum);
3384
3385         pad = j->fskdcnt % 240;
3386         if (pad) {
3387                 pad = 240 - pad;
3388         }
3389         ixj_pad_fsk(j, pad);
3390         if(ixjdebug & 0x0200) {
3391                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3392         }
3393 }
3394
3395 static void ixj_write_vmwi(IXJ *j, int msg)
3396 {
3397         char mdmflen;
3398         int pad;
3399
3400         int checksum = 0;
3401
3402         if (j->dsp.low == 0x20 || j->flags.cidplay)
3403                 return;
3404
3405         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3406         j->cidsize = j->cidcnt = 0;
3407
3408         ixj_fsk_alloc(j);
3409
3410         mdmflen = 3;
3411
3412         if (j->port == PORT_POTS)
3413                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3414
3415         ixj_write_cid_seize(j);
3416
3417         ixj_write_cid_byte(j, 0x82);
3418         checksum = 0x82;
3419         ixj_write_cid_byte(j, mdmflen);
3420         checksum = checksum + mdmflen;
3421
3422         ixj_write_cid_byte(j, 0x0B);
3423         checksum = checksum + 0x0B;
3424         ixj_write_cid_byte(j, 1);
3425         checksum = checksum + 1;
3426
3427         if(msg) {
3428                 ixj_write_cid_byte(j, 0xFF);
3429                 checksum = checksum + 0xFF;
3430         }
3431         else {
3432                 ixj_write_cid_byte(j, 0x00);
3433                 checksum = checksum + 0x00;
3434         }
3435
3436         checksum %= 256;
3437         checksum ^= 0xFF;
3438         checksum += 1;
3439
3440         ixj_write_cid_byte(j, (char) checksum);
3441
3442         pad = j->fskdcnt % 240;
3443         if (pad) {
3444                 pad = 240 - pad;
3445         }
3446         ixj_pad_fsk(j, pad);
3447 }
3448
3449 static void ixj_write_frame(IXJ *j)
3450 {
3451         int cnt, frame_count, dly;
3452         IXJ_WORD dat;
3453
3454         frame_count = 0;
3455         if(j->flags.cidplay) {
3456                 for(cnt = 0; cnt < 480; cnt++) {
3457                         if (!(cnt % 16) && !IsTxReady(j)) {
3458                                 dly = 0;
3459                                 while (!IsTxReady(j)) {
3460                                         if (dly++ > 5) {
3461                                                 dly = 0;
3462                                                 break;
3463                                         }
3464                                         udelay(10);
3465                                 }
3466                         }
3467                         dat.word = j->fskdata[j->cidcnt++];
3468                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3469                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3470                         cnt++;
3471                 }
3472                 if(j->cidcnt >= j->fskdcnt) {
3473                         ixj_post_cid(j);
3474                 }
3475                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3476                    and there is real audio data in the buffer, we need to throw it away because
3477                    we just used it's time slot */
3478                 if (j->write_buffer_rp > j->write_buffer_wp) {
3479                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3480                         if (j->write_buffer_rp >= j->write_buffer_end) {
3481                                 j->write_buffer_rp = j->write_buffer;
3482                         }
3483                         j->write_buffers_empty++;
3484                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3485
3486                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3487                 }
3488         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3489                 if (j->write_buffer_wp > j->write_buffer_rp) {
3490                         frame_count =
3491                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3492                 }
3493                 if (j->write_buffer_rp > j->write_buffer_wp) {
3494                         frame_count =
3495                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3496                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3497                 }
3498                 if (frame_count >= 1) {
3499                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3500                                 BYTES blankword;
3501
3502                                 switch (j->play_mode) {
3503                                 case PLAYBACK_MODE_ULAW:
3504                                 case PLAYBACK_MODE_ALAW:
3505                                         blankword.low = blankword.high = 0xFF;
3506                                         break;
3507                                 case PLAYBACK_MODE_8LINEAR:
3508                                 case PLAYBACK_MODE_16LINEAR:
3509                                 default:
3510                                         blankword.low = blankword.high = 0x00;
3511                                         break;
3512                                 case PLAYBACK_MODE_8LINEAR_WSS:
3513                                         blankword.low = blankword.high = 0x80;
3514                                         break;
3515                                 }
3516                                 for (cnt = 0; cnt < 16; cnt++) {
3517                                         if (!(cnt % 16) && !IsTxReady(j)) {
3518                                                 dly = 0;
3519                                                 while (!IsTxReady(j)) {
3520                                                         if (dly++ > 5) {
3521                                                                 dly = 0;
3522                                                                 break;
3523                                                         }
3524                                                         udelay(10);
3525                                                 }
3526                                         }
3527                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3528                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3529                                 }
3530                                 j->flags.play_first_frame = 0;
3531                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3532                                 for (cnt = 0; cnt < 24; cnt++) {
3533                                         BYTES blankword;
3534
3535                                         if(cnt == 12) {
3536                                                 blankword.low = 0x02;
3537                                                 blankword.high = 0x00;
3538                                         }
3539                                         else {
3540                                                 blankword.low = blankword.high = 0x00;
3541                                         }
3542                                         if (!(cnt % 16) && !IsTxReady(j)) {
3543                                                 dly = 0;
3544                                                 while (!IsTxReady(j)) {
3545                                                         if (dly++ > 5) {
3546                                                                 dly = 0;
3547                                                                 break;
3548                                                         }
3549                                                         udelay(10);
3550                                                 }
3551                                         }
3552                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3553                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3554                                 }
3555                                 j->flags.play_first_frame = 0;
3556                         }
3557                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3558                                 if (!(cnt % 16) && !IsTxReady(j)) {
3559                                         dly = 0;
3560                                         while (!IsTxReady(j)) {
3561                                                 if (dly++ > 5) {
3562                                                         dly = 0;
3563                                                         break;
3564                                                 }
3565                                                 udelay(10);
3566                                         }
3567                                 }
3568                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3569                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3570                                         if (j->write_buffer_rp[cnt] == 0 &&
3571                                             j->write_buffer_rp[cnt + 1] == 0 &&
3572                                             j->write_buffer_rp[cnt + 2] == 0 &&
3573                                             j->write_buffer_rp[cnt + 3] == 0 &&
3574                                             j->write_buffer_rp[cnt + 4] == 0 &&
3575                                             j->write_buffer_rp[cnt + 5] == 0 &&
3576                                             j->write_buffer_rp[cnt + 6] == 0 &&
3577                                             j->write_buffer_rp[cnt + 7] == 0 &&
3578                                             j->write_buffer_rp[cnt + 8] == 0 &&
3579                                             j->write_buffer_rp[cnt + 9] == 0) {
3580                                         /* someone is trying to write silence lets make this a type 0 frame. */
3581                                                 outb_p(0x00, j->DSPbase + 0x0C);
3582                                                 outb_p(0x00, j->DSPbase + 0x0D);
3583                                         } else {
3584                                         /* so all other frames are type 1. */
3585                                                 outb_p(0x01, j->DSPbase + 0x0C);
3586                                                 outb_p(0x00, j->DSPbase + 0x0D);
3587                                         }
3588                                 }
3589                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3590                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3591                                 *(j->write_buffer_rp + cnt) = 0;
3592                                 *(j->write_buffer_rp + cnt + 1) = 0;
3593                         }
3594                         j->write_buffer_rp += j->play_frame_size * 2;
3595                         if (j->write_buffer_rp >= j->write_buffer_end) {
3596                                 j->write_buffer_rp = j->write_buffer;
3597                         }
3598                         j->write_buffers_empty++;
3599                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3600
3601                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3602
3603                         ++j->frameswritten;
3604                 }
3605         } else {
3606                 j->drybuffer++;
3607         }
3608         if(j->ixj_signals[SIG_WRITE_READY]) {
3609                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3610         }
3611 }
3612
3613 static int idle(IXJ *j)
3614 {
3615         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3616
3617                 return 0;
3618
3619         if (j->ssr.high || j->ssr.low) {
3620                 return 0;
3621         } else {
3622                 j->play_mode = -1;
3623                 j->flags.playing = 0;
3624                 j->rec_mode = -1;
3625                 j->flags.recording = 0;
3626                 return 1;
3627         }
3628 }
3629
3630 static int set_base_frame(IXJ *j, int size)
3631 {
3632         unsigned short cmd;
3633         int cnt;
3634
3635         idle(j);
3636         j->cid_play_aec_level = j->aec_level;
3637         aec_stop(j);
3638         for (cnt = 0; cnt < 10; cnt++) {
3639                 if (idle(j))
3640                         break;
3641         }
3642         if (j->ssr.high || j->ssr.low)
3643                 return -1;
3644         if (j->dsp.low != 0x20) {
3645                 switch (size) {
3646                 case 30:
3647                         cmd = 0x07F0;
3648                         /* Set Base Frame Size to 240 pg9-10 8021 */
3649                         break;
3650                 case 20:
3651                         cmd = 0x07A0;
3652                         /* Set Base Frame Size to 160 pg9-10 8021 */
3653                         break;
3654                 case 10:
3655                         cmd = 0x0750;
3656                         /* Set Base Frame Size to 80 pg9-10 8021 */
3657                         break;
3658                 default:
3659                         return -1;
3660                 }
3661         } else {
3662                 if (size == 30)
3663                         return size;
3664                 else
3665                         return -1;
3666         }
3667         if (ixj_WriteDSPCommand(cmd, j)) {
3668                 j->baseframe.high = j->baseframe.low = 0xFF;
3669                 return -1;
3670         } else {
3671                 j->baseframe.high = j->ssr.high;
3672                 j->baseframe.low = j->ssr.low;
3673                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3674                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3675                         return -1;
3676                 }
3677         }
3678         ixj_aec_start(j, j->cid_play_aec_level);
3679         return size;
3680 }
3681
3682 static int set_rec_codec(IXJ *j, int rate)
3683 {
3684         int retval = 0;
3685
3686         j->rec_codec = rate;
3687
3688         switch (rate) {
3689         case G723_63:
3690                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3691                         j->rec_frame_size = 12;
3692                         j->rec_mode = 0;
3693                 } else {
3694                         retval = 1;
3695                 }
3696                 break;
3697         case G723_53:
3698                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3699                         j->rec_frame_size = 10;
3700                         j->rec_mode = 0;
3701                 } else {
3702                         retval = 1;
3703                 }
3704                 break;
3705         case TS85:
3706                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3707                         j->rec_frame_size = 16;
3708                         j->rec_mode = 0;
3709                 } else {
3710                         retval = 1;
3711                 }
3712                 break;
3713         case TS48:
3714                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3715                         j->rec_frame_size = 9;
3716                         j->rec_mode = 0;
3717                 } else {
3718                         retval = 1;
3719                 }
3720                 break;
3721         case TS41:
3722                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3723                         j->rec_frame_size = 8;
3724                         j->rec_mode = 0;
3725                 } else {
3726                         retval = 1;
3727                 }
3728                 break;
3729         case G728:
3730                 if (j->dsp.low != 0x20) {
3731                         j->rec_frame_size = 48;
3732                         j->rec_mode = 0;
3733                 } else {
3734                         retval = 1;
3735                 }
3736                 break;
3737         case G729:
3738                 if (j->dsp.low != 0x20) {
3739                         if (!j->flags.g729_loaded) {
3740                                 retval = 1;
3741                                 break;
3742                         }
3743                         switch (j->baseframe.low) {
3744                         case 0xA0:
3745                                 j->rec_frame_size = 10;
3746                                 break;
3747                         case 0x50:
3748                                 j->rec_frame_size = 5;
3749                                 break;
3750                         default:
3751                                 j->rec_frame_size = 15;
3752                                 break;
3753                         }
3754                         j->rec_mode = 0;
3755                 } else {
3756                         retval = 1;
3757                 }
3758                 break;
3759         case G729B:
3760                 if (j->dsp.low != 0x20) {
3761                         if (!j->flags.g729_loaded) {
3762                                 retval = 1;
3763                                 break;
3764                         }
3765                         switch (j->baseframe.low) {
3766                         case 0xA0:
3767                                 j->rec_frame_size = 12;
3768                                 break;
3769                         case 0x50:
3770                                 j->rec_frame_size = 6;
3771                                 break;
3772                         default:
3773                                 j->rec_frame_size = 18;
3774                                 break;
3775                         }
3776                         j->rec_mode = 0;
3777                 } else {
3778                         retval = 1;
3779                 }
3780                 break;
3781         case ULAW:
3782                 switch (j->baseframe.low) {
3783                 case 0xA0:
3784                         j->rec_frame_size = 80;
3785                         break;
3786                 case 0x50:
3787                         j->rec_frame_size = 40;
3788                         break;
3789                 default:
3790                         j->rec_frame_size = 120;
3791                         break;
3792                 }
3793                 j->rec_mode = 4;
3794                 break;
3795         case ALAW:
3796                 switch (j->baseframe.low) {
3797                 case 0xA0:
3798                         j->rec_frame_size = 80;
3799                         break;
3800                 case 0x50:
3801                         j->rec_frame_size = 40;
3802                         break;
3803                 default:
3804                         j->rec_frame_size = 120;
3805                         break;
3806                 }
3807                 j->rec_mode = 4;
3808                 break;
3809         case LINEAR16:
3810                 switch (j->baseframe.low) {
3811                 case 0xA0:
3812                         j->rec_frame_size = 160;
3813                         break;
3814                 case 0x50:
3815                         j->rec_frame_size = 80;
3816                         break;
3817                 default:
3818                         j->rec_frame_size = 240;
3819                         break;
3820                 }
3821                 j->rec_mode = 5;
3822                 break;
3823         case LINEAR8:
3824                 switch (j->baseframe.low) {
3825                 case 0xA0:
3826                         j->rec_frame_size = 80;
3827                         break;
3828                 case 0x50:
3829                         j->rec_frame_size = 40;
3830                         break;
3831                 default:
3832                         j->rec_frame_size = 120;
3833                         break;
3834                 }
3835                 j->rec_mode = 6;
3836                 break;
3837         case WSS:
3838                 switch (j->baseframe.low) {
3839                 case 0xA0:
3840                         j->rec_frame_size = 80;
3841                         break;
3842                 case 0x50:
3843                         j->rec_frame_size = 40;
3844                         break;
3845                 default:
3846                         j->rec_frame_size = 120;
3847                         break;
3848                 }
3849                 j->rec_mode = 7;
3850                 break;
3851         default:
3852                 kfree(j->read_buffer);
3853                 j->rec_frame_size = 0;
3854                 j->rec_mode = -1;
3855                 j->read_buffer = NULL;
3856                 j->read_buffer_size = 0;
3857                 retval = 1;
3858                 break;
3859         }
3860         return retval;
3861 }
3862
3863 static int ixj_record_start(IXJ *j)
3864 {
3865         unsigned short cmd = 0x0000;
3866
3867         if (j->read_buffer) {
3868                 ixj_record_stop(j);
3869         }
3870         j->flags.recording = 1;
3871         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3872
3873         if(ixjdebug & 0x0002)
3874                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3875
3876         if (!j->rec_mode) {
3877                 switch (j->rec_codec) {
3878                 case G723_63:
3879                         cmd = 0x5131;
3880                         break;
3881                 case G723_53:
3882                         cmd = 0x5132;
3883                         break;
3884                 case TS85:
3885                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3886
3887                         break;
3888                 case TS48:
3889                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3890
3891                         break;
3892                 case TS41:
3893                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3894
3895                         break;
3896                 case G728:
3897                         cmd = 0x5135;
3898                         break;
3899                 case G729:
3900                 case G729B:
3901                         cmd = 0x5136;
3902                         break;
3903                 default:
3904                         return 1;
3905                 }
3906                 if (ixj_WriteDSPCommand(cmd, j))
3907                         return -1;
3908         }
3909         if (!j->read_buffer) {
3910                 if (!j->read_buffer)
3911                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3912                 if (!j->read_buffer) {
3913                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3914                         return -ENOMEM;
3915                 }
3916         }
3917         j->read_buffer_size = j->rec_frame_size * 2;
3918
3919         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3920
3921                 return -1;
3922
3923         switch (j->rec_mode) {
3924         case 0:
3925                 cmd = 0x1C03;   /* Record C1 */
3926
3927                 break;
3928         case 4:
3929                 if (j->ver.low == 0x12) {
3930                         cmd = 0x1E03;   /* Record C1 */
3931
3932                 } else {
3933                         cmd = 0x1E01;   /* Record C1 */
3934
3935                 }
3936                 break;
3937         case 5:
3938                 if (j->ver.low == 0x12) {
3939                         cmd = 0x1E83;   /* Record C1 */
3940
3941                 } else {
3942                         cmd = 0x1E81;   /* Record C1 */
3943
3944                 }
3945                 break;
3946         case 6:
3947                 if (j->ver.low == 0x12) {
3948                         cmd = 0x1F03;   /* Record C1 */
3949
3950                 } else {
3951                         cmd = 0x1F01;   /* Record C1 */
3952
3953                 }
3954                 break;
3955         case 7:
3956                 if (j->ver.low == 0x12) {
3957                         cmd = 0x1F83;   /* Record C1 */
3958                 } else {
3959                         cmd = 0x1F81;   /* Record C1 */
3960                 }
3961                 break;
3962         }
3963         if (ixj_WriteDSPCommand(cmd, j))
3964                 return -1;
3965
3966         if (j->flags.playing) {
3967                 ixj_aec_start(j, j->aec_level);
3968         }
3969         return 0;
3970 }
3971
3972 static void ixj_record_stop(IXJ *j)
3973 {
3974         if (ixjdebug & 0x0002)
3975                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3976
3977         kfree(j->read_buffer);
3978         j->read_buffer = NULL;
3979         j->read_buffer_size = 0;
3980         if (j->rec_mode > -1) {
3981                 ixj_WriteDSPCommand(0x5120, j);
3982                 j->rec_mode = -1;
3983         }
3984         j->flags.recording = 0;
3985 }
3986 static void ixj_vad(IXJ *j, int arg)
3987 {
3988         if (arg)
3989                 ixj_WriteDSPCommand(0x513F, j);
3990         else
3991                 ixj_WriteDSPCommand(0x513E, j);
3992 }
3993
3994 static void set_rec_depth(IXJ *j, int depth)
3995 {
3996         if (depth > 60)
3997                 depth = 60;
3998         if (depth < 0)
3999                 depth = 0;
4000         ixj_WriteDSPCommand(0x5180 + depth, j);
4001 }
4002
4003 static void set_dtmf_prescale(IXJ *j, int volume)
4004 {
4005         ixj_WriteDSPCommand(0xCF07, j);
4006         ixj_WriteDSPCommand(volume, j);
4007 }
4008
4009 static int get_dtmf_prescale(IXJ *j)
4010 {
4011         ixj_WriteDSPCommand(0xCF05, j);
4012         return j->ssr.high << 8 | j->ssr.low;
4013 }
4014
4015 static void set_rec_volume(IXJ *j, int volume)
4016 {
4017         if(j->aec_level == AEC_AGC) {
4018                 if (ixjdebug & 0x0002)
4019                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4020                 ixj_WriteDSPCommand(0xCF96, j);
4021                 ixj_WriteDSPCommand(volume, j);
4022         } else {
4023                 if (ixjdebug & 0x0002)
4024                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4025                 ixj_WriteDSPCommand(0xCF03, j);
4026                 ixj_WriteDSPCommand(volume, j);
4027         }
4028 }
4029
4030 static int set_rec_volume_linear(IXJ *j, int volume)
4031 {
4032         int newvolume, dsprecmax;
4033
4034         if (ixjdebug & 0x0002)
4035                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4036         if(volume > 100 || volume < 0) {
4037           return -1;
4038         }
4039
4040         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4041         switch (j->cardtype) {
4042         case QTI_PHONEJACK:
4043                 dsprecmax = 0x440;
4044                 break;
4045         case QTI_LINEJACK:
4046                 dsprecmax = 0x180;
4047                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4048                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4049                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4050                 break;
4051         case QTI_PHONEJACK_LITE:
4052                 dsprecmax = 0x4C0;
4053                 break;
4054         case QTI_PHONEJACK_PCI:
4055                 dsprecmax = 0x100;
4056                 break;
4057         case QTI_PHONECARD:
4058                 dsprecmax = 0x400;
4059                 break;
4060         default:
4061                 return -1;
4062         }
4063         newvolume = (dsprecmax * volume) / 100;
4064         set_rec_volume(j, newvolume);
4065         return 0;
4066 }
4067
4068 static int get_rec_volume(IXJ *j)
4069 {
4070         if(j->aec_level == AEC_AGC) {
4071                 if (ixjdebug & 0x0002)
4072                         printk(KERN_INFO "Getting AGC Threshold\n");
4073                 ixj_WriteDSPCommand(0xCF86, j);
4074                 if (ixjdebug & 0x0002)
4075                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4076                 return j->ssr.high << 8 | j->ssr.low;
4077         } else {
4078                 if (ixjdebug & 0x0002)
4079                         printk(KERN_INFO "Getting Record Volume\n");
4080                 ixj_WriteDSPCommand(0xCF01, j);
4081                 return j->ssr.high << 8 | j->ssr.low;
4082         }
4083 }
4084
4085 static int get_rec_volume_linear(IXJ *j)
4086 {
4087         int volume, newvolume, dsprecmax;
4088
4089         switch (j->cardtype) {
4090         case QTI_PHONEJACK:
4091                 dsprecmax = 0x440;
4092                 break;
4093         case QTI_LINEJACK:
4094                 dsprecmax = 0x180;
4095                 break;
4096         case QTI_PHONEJACK_LITE:
4097                 dsprecmax = 0x4C0;
4098                 break;
4099         case QTI_PHONEJACK_PCI:
4100                 dsprecmax = 0x100;
4101                 break;
4102         case QTI_PHONECARD:
4103                 dsprecmax = 0x400;
4104                 break;
4105         default:
4106                 return -1;
4107         }
4108         volume = get_rec_volume(j);
4109         newvolume = (volume * 100) / dsprecmax;
4110         if(newvolume > 100)
4111                 newvolume = 100;
4112         return newvolume;
4113 }
4114
4115 static int get_rec_level(IXJ *j)
4116 {
4117         int retval;
4118
4119         ixj_WriteDSPCommand(0xCF88, j);
4120
4121         retval = j->ssr.high << 8 | j->ssr.low;
4122         retval = (retval * 256) / 240;
4123         return retval;
4124 }
4125
4126 static void ixj_aec_start(IXJ *j, int level)
4127 {
4128         j->aec_level = level;
4129         if (ixjdebug & 0x0002)
4130                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4131         if (!level) {
4132                 aec_stop(j);
4133         } else {
4134                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4135                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4136
4137                         ixj_WriteDSPCommand(0x0300, j);
4138                 }
4139                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4140
4141                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4142
4143                 switch (level) {
4144                 case AEC_LOW:
4145                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4146
4147                         ixj_WriteDSPCommand(0xE011, j);
4148                         ixj_WriteDSPCommand(0xFFFF, j);
4149
4150                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4151                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4152
4153                         break;
4154
4155                 case AEC_MED:
4156                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4157
4158                         ixj_WriteDSPCommand(0xE011, j);
4159                         ixj_WriteDSPCommand(0x0080, j);
4160
4161                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4162                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4163
4164                         break;
4165
4166                 case AEC_HIGH:
4167                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4168
4169                         ixj_WriteDSPCommand(0xE011, j);
4170                         ixj_WriteDSPCommand(0x0080, j);
4171
4172                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4173                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4174
4175                         break;
4176
4177                 case AEC_AGC:
4178                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4179                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4180
4181                         ixj_WriteDSPCommand(0xE011, j);
4182                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4183
4184                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4185
4186                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4187                                 ixj_WriteDSPCommand(0x0224, j);
4188                         else
4189                                 ixj_WriteDSPCommand(0x1224, j);
4190
4191                         ixj_WriteDSPCommand(0xE014, j);
4192                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4193
4194                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4195
4196                         /* Now we can set the AGC initial parameters and turn it on */
4197                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4198                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4199
4200                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4201                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4202
4203                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4204                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4205
4206                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4207                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4208
4209                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4210                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4211
4212                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4213                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4214
4215                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4216                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4217
4218                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4219                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4220
4221                         break;
4222
4223                 case AEC_AUTO:
4224                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4225
4226                         ixj_WriteDSPCommand(0xE011, j);
4227                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4228
4229                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4230
4231                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4232                                 ixj_WriteDSPCommand(0x0224, j);
4233                         else
4234                                 ixj_WriteDSPCommand(0x1224, j);
4235
4236                         ixj_WriteDSPCommand(0xE014, j);
4237                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4238
4239                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4240
4241                         break;
4242                 }
4243         }
4244 }
4245
4246 static void aec_stop(IXJ *j)
4247 {
4248         j->aec_level = AEC_OFF;
4249         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4250                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4251
4252                 ixj_WriteDSPCommand(0x0700, j);
4253         }
4254         if (j->play_mode != -1 && j->rec_mode != -1)
4255         {
4256                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4257         }
4258 }
4259
4260 static int set_play_codec(IXJ *j, int rate)
4261 {
4262         int retval = 0;
4263
4264         j->play_codec = rate;
4265
4266         switch (rate) {
4267         case G723_63:
4268                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4269                         j->play_frame_size = 12;
4270                         j->play_mode = 0;
4271                 } else {
4272                         retval = 1;
4273                 }
4274                 break;
4275         case G723_53:
4276                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4277                         j->play_frame_size = 10;
4278                         j->play_mode = 0;
4279                 } else {
4280                         retval = 1;
4281                 }
4282                 break;
4283         case TS85:
4284                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4285                         j->play_frame_size = 16;
4286                         j->play_mode = 0;
4287                 } else {
4288                         retval = 1;
4289                 }
4290                 break;
4291         case TS48:
4292                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4293                         j->play_frame_size = 9;
4294                         j->play_mode = 0;
4295                 } else {
4296                         retval = 1;
4297                 }
4298                 break;
4299         case TS41:
4300                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4301                         j->play_frame_size = 8;
4302                         j->play_mode = 0;
4303                 } else {
4304                         retval = 1;
4305                 }
4306                 break;
4307         case G728:
4308                 if (j->dsp.low != 0x20) {
4309                         j->play_frame_size = 48;
4310                         j->play_mode = 0;
4311                 } else {
4312                         retval = 1;
4313                 }
4314                 break;
4315         case G729:
4316                 if (j->dsp.low != 0x20) {
4317                         if (!j->flags.g729_loaded) {
4318                                 retval = 1;
4319                                 break;
4320                         }
4321                         switch (j->baseframe.low) {
4322                         case 0xA0:
4323                                 j->play_frame_size = 10;
4324                                 break;
4325                         case 0x50:
4326                                 j->play_frame_size = 5;
4327                                 break;
4328                         default:
4329                                 j->play_frame_size = 15;
4330                                 break;
4331                         }
4332                         j->play_mode = 0;
4333                 } else {
4334                         retval = 1;
4335                 }
4336                 break;
4337         case G729B:
4338                 if (j->dsp.low != 0x20) {
4339                         if (!j->flags.g729_loaded) {
4340                                 retval = 1;
4341                                 break;
4342                         }
4343                         switch (j->baseframe.low) {
4344                         case 0xA0:
4345                                 j->play_frame_size = 12;
4346                                 break;
4347                         case 0x50:
4348                                 j->play_frame_size = 6;
4349                                 break;
4350                         default:
4351                                 j->play_frame_size = 18;
4352                                 break;
4353                         }
4354                         j->play_mode = 0;
4355                 } else {
4356                         retval = 1;
4357                 }
4358                 break;
4359         case ULAW:
4360                 switch (j->baseframe.low) {
4361                 case 0xA0:
4362                         j->play_frame_size = 80;
4363                         break;
4364                 case 0x50:
4365                         j->play_frame_size = 40;
4366                         break;
4367                 default:
4368                         j->play_frame_size = 120;
4369                         break;
4370                 }
4371                 j->play_mode = 2;
4372                 break;
4373         case ALAW:
4374                 switch (j->baseframe.low) {
4375                 case 0xA0:
4376                         j->play_frame_size = 80;
4377                         break;
4378                 case 0x50:
4379                         j->play_frame_size = 40;
4380                         break;
4381                 default:
4382                         j->play_frame_size = 120;
4383                         break;
4384                 }
4385                 j->play_mode = 2;
4386                 break;
4387         case LINEAR16:
4388                 switch (j->baseframe.low) {
4389                 case 0xA0:
4390                         j->play_frame_size = 160;
4391                         break;
4392                 case 0x50:
4393                         j->play_frame_size = 80;
4394                         break;
4395                 default:
4396                         j->play_frame_size = 240;
4397                         break;
4398                 }
4399                 j->play_mode = 6;
4400                 break;
4401         case LINEAR8:
4402                 switch (j->baseframe.low) {
4403                 case 0xA0:
4404                         j->play_frame_size = 80;
4405                         break;
4406                 case 0x50:
4407                         j->play_frame_size = 40;
4408                         break;
4409                 default:
4410                         j->play_frame_size = 120;
4411                         break;
4412                 }
4413                 j->play_mode = 4;
4414                 break;
4415         case WSS:
4416                 switch (j->baseframe.low) {
4417                 case 0xA0:
4418                         j->play_frame_size = 80;
4419                         break;
4420                 case 0x50:
4421                         j->play_frame_size = 40;
4422                         break;
4423                 default:
4424                         j->play_frame_size = 120;
4425                         break;
4426                 }
4427                 j->play_mode = 5;
4428                 break;
4429         default:
4430                 kfree(j->write_buffer);
4431                 j->play_frame_size = 0;
4432                 j->play_mode = -1;
4433                 j->write_buffer = NULL;
4434                 j->write_buffer_size = 0;
4435                 retval = 1;
4436                 break;
4437         }
4438         return retval;
4439 }
4440
4441 static int ixj_play_start(IXJ *j)
4442 {
4443         unsigned short cmd = 0x0000;
4444
4445         if (j->write_buffer) {
4446                 ixj_play_stop(j);
4447         }
4448
4449         if(ixjdebug & 0x0002)
4450                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4451
4452         j->flags.playing = 1;
4453         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4454
4455         j->flags.play_first_frame = 1;
4456         j->drybuffer = 0;
4457
4458         if (!j->play_mode) {
4459                 switch (j->play_codec) {
4460                 case G723_63:
4461                         cmd = 0x5231;
4462                         break;
4463                 case G723_53:
4464                         cmd = 0x5232;
4465                         break;
4466                 case TS85:
4467                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4468
4469                         break;
4470                 case TS48:
4471                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4472
4473                         break;
4474                 case TS41:
4475                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4476
4477                         break;
4478                 case G728:
4479                         cmd = 0x5235;
4480                         break;
4481                 case G729:
4482                 case G729B:
4483                         cmd = 0x5236;
4484                         break;
4485                 default:
4486                         return 1;
4487                 }
4488                 if (ixj_WriteDSPCommand(cmd, j))
4489                         return -1;
4490         }
4491         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4492         if (!j->write_buffer) {
4493                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4494                 return -ENOMEM;
4495         }
4496 /*      j->write_buffers_empty = 2; */
4497         j->write_buffers_empty = 1;
4498         j->write_buffer_size = j->play_frame_size * 2;
4499         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4500         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4501
4502         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4503
4504                 return -1;
4505
4506         switch (j->play_mode) {
4507         case 0:
4508                 cmd = 0x2C03;
4509                 break;
4510         case 2:
4511                 if (j->ver.low == 0x12) {
4512                         cmd = 0x2C23;
4513                 } else {
4514                         cmd = 0x2C21;
4515                 }
4516                 break;
4517         case 4:
4518                 if (j->ver.low == 0x12) {
4519                         cmd = 0x2C43;
4520                 } else {
4521                         cmd = 0x2C41;
4522                 }
4523                 break;
4524         case 5:
4525                 if (j->ver.low == 0x12) {
4526                         cmd = 0x2C53;
4527                 } else {
4528                         cmd = 0x2C51;
4529                 }
4530                 break;
4531         case 6:
4532                 if (j->ver.low == 0x12) {
4533                         cmd = 0x2C63;
4534                 } else {
4535                         cmd = 0x2C61;
4536                 }
4537                 break;
4538         }
4539         if (ixj_WriteDSPCommand(cmd, j))
4540                 return -1;
4541
4542         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4543                 return -1;
4544
4545         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4546                 return -1;
4547
4548         if (j->flags.recording) {
4549                 ixj_aec_start(j, j->aec_level);
4550         }
4551
4552         return 0;
4553 }
4554
4555 static void ixj_play_stop(IXJ *j)
4556 {
4557         if (ixjdebug & 0x0002)
4558                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4559
4560         kfree(j->write_buffer);
4561         j->write_buffer = NULL;
4562         j->write_buffer_size = 0;
4563         if (j->play_mode > -1) {
4564                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4565
4566                 j->play_mode = -1;
4567         }
4568         j->flags.playing = 0;
4569 }
4570
4571 static inline int get_play_level(IXJ *j)
4572 {
4573         int retval;
4574
4575         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4576         return j->ssr.high << 8 | j->ssr.low;
4577         retval = j->ssr.high << 8 | j->ssr.low;
4578         retval = (retval * 256) / 240;
4579         return retval;
4580 }
4581
4582 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4583 {
4584         unsigned int mask = 0;
4585
4586         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4587
4588         poll_wait(file_p, &(j->poll_q), wait);
4589         if (j->read_buffer_ready > 0)
4590                 mask |= POLLIN | POLLRDNORM;    /* readable */
4591         if (j->write_buffers_empty > 0)
4592                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4593         if (j->ex.bytes)
4594                 mask |= POLLPRI;
4595         return mask;
4596 }
4597
4598 static int ixj_play_tone(IXJ *j, char tone)
4599 {
4600         if (!j->tone_state) {
4601                 if(ixjdebug & 0x0002) {
4602                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4603                 }
4604                 if (j->dsp.low == 0x20) {
4605                         idle(j);
4606                 }
4607                 j->tone_start_jif = jiffies;
4608
4609                 j->tone_state = 1;
4610         }
4611
4612         j->tone_index = tone;
4613         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4614                 return -1;
4615
4616         return 0;
4617 }
4618
4619 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4620 {
4621         j->tone_on_time = arg;
4622
4623         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4624
4625                 return -1;
4626
4627         if (ixj_WriteDSPCommand(arg, j))
4628                 return -1;
4629
4630         return 0;
4631 }
4632
4633 static int SCI_WaitHighSCI(IXJ *j)
4634 {
4635         int cnt;
4636
4637         j->pld_scrr.byte = inb_p(j->XILINXbase);
4638         if (!j->pld_scrr.bits.sci) {
4639                 for (cnt = 0; cnt < 10; cnt++) {
4640                         udelay(32);
4641                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4642
4643                         if ((j->pld_scrr.bits.sci))
4644                                 return 1;
4645                 }
4646                 if (ixjdebug & 0x0001)
4647                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4648                 return 0;
4649         } else
4650                 return 1;
4651 }
4652
4653 static int SCI_WaitLowSCI(IXJ *j)
4654 {
4655         int cnt;
4656
4657         j->pld_scrr.byte = inb_p(j->XILINXbase);
4658         if (j->pld_scrr.bits.sci) {
4659                 for (cnt = 0; cnt < 10; cnt++) {
4660                         udelay(32);
4661                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4662
4663                         if (!(j->pld_scrr.bits.sci))
4664                                 return 1;
4665                 }
4666                 if (ixjdebug & 0x0001)
4667                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4668                 return 0;
4669         } else
4670                 return 1;
4671 }
4672
4673 static int SCI_Control(IXJ *j, int control)
4674 {
4675         switch (control) {
4676         case SCI_End:
4677                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4678
4679                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4680
4681                 break;
4682         case SCI_Enable_DAA:
4683                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4684
4685                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4686
4687                 break;
4688         case SCI_Enable_Mixer:
4689                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4690
4691                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4692
4693                 break;
4694         case SCI_Enable_EEPROM:
4695                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4696
4697                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4698
4699                 break;
4700         default:
4701                 return 0;
4702                 break;
4703         }
4704         outb_p(j->pld_scrw.byte, j->XILINXbase);
4705
4706         switch (control) {
4707         case SCI_End:
4708                 return 1;
4709                 break;
4710         case SCI_Enable_DAA:
4711         case SCI_Enable_Mixer:
4712         case SCI_Enable_EEPROM:
4713                 if (!SCI_WaitHighSCI(j))
4714                         return 0;
4715                 break;
4716         default:
4717                 return 0;
4718                 break;
4719         }
4720         return 1;
4721 }
4722
4723 static int SCI_Prepare(IXJ *j)
4724 {
4725         if (!SCI_Control(j, SCI_End))
4726                 return 0;
4727
4728         if (!SCI_WaitLowSCI(j))
4729                 return 0;
4730
4731         return 1;
4732 }
4733
4734 static int ixj_get_mixer(long val, IXJ *j)
4735 {
4736         int reg = (val & 0x1F00) >> 8;
4737         return j->mix.vol[reg];
4738 }
4739
4740 static int ixj_mixer(long val, IXJ *j)
4741 {
4742         BYTES bytes;
4743
4744         bytes.high = (val & 0x1F00) >> 8;
4745         bytes.low = val & 0x00FF;
4746
4747         /* save mixer value so we can get back later on */
4748         j->mix.vol[bytes.high] = bytes.low;
4749
4750         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4751
4752         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4753
4754         SCI_Control(j, SCI_Enable_Mixer);
4755
4756         SCI_Control(j, SCI_End);
4757
4758         return 0;
4759 }
4760
4761 static int daa_load(BYTES * p_bytes, IXJ *j)
4762 {
4763         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4764         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4765         if (!SCI_Control(j, SCI_Enable_DAA))
4766                 return 0;
4767         else
4768                 return 1;
4769 }
4770
4771 static int ixj_daa_cr4(IXJ *j, char reg)
4772 {
4773         BYTES bytes;
4774
4775         switch (j->daa_mode) {
4776         case SOP_PU_SLEEP:
4777                 bytes.high = 0x14;
4778                 break;
4779         case SOP_PU_RINGING:
4780                 bytes.high = 0x54;
4781                 break;
4782         case SOP_PU_CONVERSATION:
4783                 bytes.high = 0x94;
4784                 break;
4785         case SOP_PU_PULSEDIALING:
4786                 bytes.high = 0xD4;
4787                 break;
4788         }
4789
4790         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4791
4792         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4793         case 0:
4794                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4795                 break;
4796         case 1:
4797                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4798                 break;
4799         case 2:
4800                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4801                 break;
4802         case 3:
4803                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4804                 break;
4805         }
4806
4807         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4808
4809         if (!daa_load(&bytes, j))
4810                 return 0;
4811
4812         if (!SCI_Prepare(j))
4813                 return 0;
4814
4815         return 1;
4816 }
4817
4818 static char daa_int_read(IXJ *j)
4819 {
4820         BYTES bytes;
4821
4822         if (!SCI_Prepare(j))
4823                 return 0;
4824
4825         bytes.high = 0x38;
4826         bytes.low = 0x00;
4827         outb_p(bytes.high, j->XILINXbase + 0x03);
4828         outb_p(bytes.low, j->XILINXbase + 0x02);
4829
4830         if (!SCI_Control(j, SCI_Enable_DAA))
4831                 return 0;
4832
4833         bytes.high = inb_p(j->XILINXbase + 0x03);
4834         bytes.low = inb_p(j->XILINXbase + 0x02);
4835         if (bytes.low != ALISDAA_ID_BYTE) {
4836                 if (ixjdebug & 0x0001)
4837                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4838                 return 0;
4839         }
4840         if (!SCI_Control(j, SCI_Enable_DAA))
4841                 return 0;
4842         if (!SCI_Control(j, SCI_End))
4843                 return 0;
4844
4845         bytes.high = inb_p(j->XILINXbase + 0x03);
4846         bytes.low = inb_p(j->XILINXbase + 0x02);
4847
4848         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4849
4850         return 1;
4851 }
4852
4853 static char daa_CR_read(IXJ *j, int cr)
4854 {
4855         IXJ_WORD wdata;
4856         BYTES bytes;
4857
4858         if (!SCI_Prepare(j))
4859                 return 0;
4860
4861         switch (j->daa_mode) {
4862         case SOP_PU_SLEEP:
4863                 bytes.high = 0x30 + cr;
4864                 break;
4865         case SOP_PU_RINGING:
4866                 bytes.high = 0x70 + cr;
4867                 break;
4868         case SOP_PU_CONVERSATION:
4869                 bytes.high = 0xB0 + cr;
4870                 break;
4871         case SOP_PU_PULSEDIALING:
4872         default:
4873                 bytes.high = 0xF0 + cr;
4874                 break;
4875         }
4876
4877         bytes.low = 0x00;
4878
4879         outb_p(bytes.high, j->XILINXbase + 0x03);
4880         outb_p(bytes.low, j->XILINXbase + 0x02);
4881
4882         if (!SCI_Control(j, SCI_Enable_DAA))
4883                 return 0;
4884
4885         bytes.high = inb_p(j->XILINXbase + 0x03);
4886         bytes.low = inb_p(j->XILINXbase + 0x02);
4887         if (bytes.low != ALISDAA_ID_BYTE) {
4888                 if (ixjdebug & 0x0001)
4889                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4890                 return 0;
4891         }
4892         if (!SCI_Control(j, SCI_Enable_DAA))
4893                 return 0;
4894         if (!SCI_Control(j, SCI_End))
4895                 return 0;
4896
4897         wdata.word = inw_p(j->XILINXbase + 0x02);
4898
4899         switch(cr){
4900                 case 5:
4901                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4902                         break;
4903                 case 4:
4904                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4905                         break;
4906                 case 3:
4907                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4908                         break;
4909                 case 2:
4910                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4911                         break;
4912                 case 1:
4913                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4914                         break;
4915                 case 0:
4916                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4917                         break;
4918                 default:
4919                         return 0;
4920         }
4921         return 1;
4922 }
4923
4924 static int ixj_daa_cid_reset(IXJ *j)
4925 {
4926         int i;
4927         BYTES bytes;
4928
4929         if (ixjdebug & 0x0002)
4930                 printk("DAA Clearing CID ram\n");
4931
4932         if (!SCI_Prepare(j))
4933                 return 0;
4934
4935         bytes.high = 0x58;
4936         bytes.low = 0x00;
4937         outb_p(bytes.high, j->XILINXbase + 0x03);
4938         outb_p(bytes.low, j->XILINXbase + 0x02);
4939
4940         if (!SCI_Control(j, SCI_Enable_DAA))
4941                 return 0;
4942
4943         if (!SCI_WaitHighSCI(j))
4944                 return 0;
4945
4946         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4947                 bytes.high = bytes.low = 0x00;
4948                 outb_p(bytes.high, j->XILINXbase + 0x03);
4949
4950                 if (i < ALISDAA_CALLERID_SIZE - 1)
4951                         outb_p(bytes.low, j->XILINXbase + 0x02);
4952
4953                 if (!SCI_Control(j, SCI_Enable_DAA))
4954                         return 0;
4955
4956                 if (!SCI_WaitHighSCI(j))
4957                         return 0;
4958
4959         }
4960
4961         if (!SCI_Control(j, SCI_End))
4962                 return 0;
4963
4964         if (ixjdebug & 0x0002)
4965                 printk("DAA CID ram cleared\n");
4966
4967         return 1;
4968 }
4969
4970 static int ixj_daa_cid_read(IXJ *j)
4971 {
4972         int i;
4973         BYTES bytes;
4974         char CID[ALISDAA_CALLERID_SIZE];
4975         bool mContinue;
4976         char *pIn, *pOut;
4977
4978         if (!SCI_Prepare(j))
4979                 return 0;
4980
4981         bytes.high = 0x78;
4982         bytes.low = 0x00;
4983         outb_p(bytes.high, j->XILINXbase + 0x03);
4984         outb_p(bytes.low, j->XILINXbase + 0x02);
4985
4986         if (!SCI_Control(j, SCI_Enable_DAA))
4987                 return 0;
4988
4989         if (!SCI_WaitHighSCI(j))
4990                 return 0;
4991
4992         bytes.high = inb_p(j->XILINXbase + 0x03);
4993         bytes.low = inb_p(j->XILINXbase + 0x02);
4994         if (bytes.low != ALISDAA_ID_BYTE) {
4995                 if (ixjdebug & 0x0001)
4996                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4997                 return 0;
4998         }
4999         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5000                 bytes.high = bytes.low = 0x00;
5001                 outb_p(bytes.high, j->XILINXbase + 0x03);
5002                 outb_p(bytes.low, j->XILINXbase + 0x02);
5003
5004                 if (!SCI_Control(j, SCI_Enable_DAA))
5005                         return 0;
5006
5007                 if (!SCI_WaitHighSCI(j))
5008                         return 0;
5009
5010                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5011                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5012         }
5013
5014         if (!SCI_Control(j, SCI_End))
5015                 return 0;
5016
5017         pIn = CID;
5018         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5019         mContinue = true;
5020         while (mContinue) {
5021                 if ((pIn[1] & 0x03) == 0x01) {
5022                         pOut[0] = pIn[0];
5023                 }
5024                 if ((pIn[2] & 0x0c) == 0x04) {
5025                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5026                 }
5027                 if ((pIn[3] & 0x30) == 0x10) {
5028                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5029                 }
5030                 if ((pIn[4] & 0xc0) == 0x40) {
5031                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5032                 } else {
5033                         mContinue = false;
5034                 }
5035                 pIn += 5, pOut += 4;
5036         }
5037         memset(&j->cid, 0, sizeof(PHONE_CID));
5038         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5039         pOut += 4;
5040         strncpy(j->cid.month, pOut, 2);
5041         pOut += 2;
5042         strncpy(j->cid.day, pOut, 2);
5043         pOut += 2;
5044         strncpy(j->cid.hour, pOut, 2);
5045         pOut += 2;
5046         strncpy(j->cid.min, pOut, 2);
5047         pOut += 3;
5048         j->cid.numlen = *pOut;
5049         pOut += 1;
5050         strncpy(j->cid.number, pOut, j->cid.numlen);
5051         pOut += j->cid.numlen + 1;
5052         j->cid.namelen = *pOut;
5053         pOut += 1;
5054         strncpy(j->cid.name, pOut, j->cid.namelen);
5055
5056         ixj_daa_cid_reset(j);
5057         return 1;
5058 }
5059
5060 static char daa_get_version(IXJ *j)
5061 {
5062         BYTES bytes;
5063
5064         if (!SCI_Prepare(j))
5065                 return 0;
5066
5067         bytes.high = 0x35;
5068         bytes.low = 0x00;
5069         outb_p(bytes.high, j->XILINXbase + 0x03);
5070         outb_p(bytes.low, j->XILINXbase + 0x02);
5071
5072         if (!SCI_Control(j, SCI_Enable_DAA))
5073                 return 0;
5074
5075         bytes.high = inb_p(j->XILINXbase + 0x03);
5076         bytes.low = inb_p(j->XILINXbase + 0x02);
5077         if (bytes.low != ALISDAA_ID_BYTE) {
5078                 if (ixjdebug & 0x0001)
5079                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5080                 return 0;
5081         }
5082         if (!SCI_Control(j, SCI_Enable_DAA))
5083                 return 0;
5084
5085         if (!SCI_Control(j, SCI_End))
5086                 return 0;
5087
5088         bytes.high = inb_p(j->XILINXbase + 0x03);
5089         bytes.low = inb_p(j->XILINXbase + 0x02);
5090         if (ixjdebug & 0x0002)
5091                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5092         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5093         return bytes.high;
5094 }
5095
5096 static int daa_set_mode(IXJ *j, int mode)
5097 {
5098         /* NOTE:
5099               The DAA *MUST* be in the conversation mode if the
5100               PSTN line is to be seized (PSTN line off-hook).
5101               Taking the PSTN line off-hook while the DAA is in
5102               a mode other than conversation mode will cause a
5103               hardware failure of the ALIS-A part.
5104
5105            NOTE:
5106               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5107               if the PSTN line is on-hook.  Failure to have the PSTN line
5108               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5109               ALIS-A part.
5110         */
5111
5112         BYTES bytes;
5113
5114         j->flags.pstn_rmr = 0;
5115
5116         if (!SCI_Prepare(j))
5117                 return 0;
5118
5119         switch (mode) {
5120         case SOP_PU_RESET:
5121                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5122
5123                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5124                 j->pld_slicw.bits.rly2 = 0;
5125                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5126                 bytes.high = 0x10;
5127                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5128                 daa_load(&bytes, j);
5129                 if (!SCI_Prepare(j))
5130                         return 0;
5131
5132                 j->daa_mode = SOP_PU_SLEEP;
5133                 break;
5134         case SOP_PU_SLEEP:
5135                 if(j->daa_mode == SOP_PU_SLEEP)
5136                 {
5137                         break;
5138                 }
5139                 if (ixjdebug & 0x0008)
5140                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5141 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5142                 {
5143                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5144
5145                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5146                         j->pld_slicw.bits.rly2 = 0;
5147                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5148                         bytes.high = 0x10;
5149                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5150                         daa_load(&bytes, j);
5151                         if (!SCI_Prepare(j))
5152                                 return 0;
5153                 }
5154                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5155
5156                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5157                 j->pld_slicw.bits.rly2 = 0;
5158                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5159                 bytes.high = 0x10;
5160                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5161                 daa_load(&bytes, j);
5162                 if (!SCI_Prepare(j))
5163                         return 0;
5164
5165                 j->daa_mode = SOP_PU_SLEEP;
5166                 j->flags.pstn_ringing = 0;
5167                 j->ex.bits.pstn_ring = 0;
5168                 j->pstn_sleeptil = jiffies + (hertz / 4);
5169                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5170                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5171                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5172                 break;
5173         case SOP_PU_RINGING:
5174                 if (ixjdebug & 0x0008)
5175                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5176                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5177
5178                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5179                 j->pld_slicw.bits.rly2 = 0;
5180                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5181                 bytes.high = 0x50;
5182                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5183                 daa_load(&bytes, j);
5184                 if (!SCI_Prepare(j))
5185                         return 0;
5186                 j->daa_mode = SOP_PU_RINGING;
5187                 break;
5188         case SOP_PU_CONVERSATION:
5189                 if (ixjdebug & 0x0008)
5190                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5191                 bytes.high = 0x90;
5192                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5193                 daa_load(&bytes, j);
5194                 if (!SCI_Prepare(j))
5195                         return 0;
5196                 j->pld_slicw.bits.rly2 = 1;
5197                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5198                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5199
5200                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5201                 j->daa_mode = SOP_PU_CONVERSATION;
5202                 j->flags.pstn_ringing = 0;
5203                 j->ex.bits.pstn_ring = 0;
5204                 j->pstn_sleeptil = jiffies;
5205                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5206                 break;
5207         case SOP_PU_PULSEDIALING:
5208                 if (ixjdebug & 0x0008)
5209                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5210                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5211
5212                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5213                 j->pld_slicw.bits.rly2 = 0;
5214                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5215                 bytes.high = 0xD0;
5216                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5217                 daa_load(&bytes, j);
5218                 if (!SCI_Prepare(j))
5219                         return 0;
5220                 j->daa_mode = SOP_PU_PULSEDIALING;
5221                 break;
5222         default:
5223                 break;
5224         }
5225         return 1;
5226 }
5227
5228 static int ixj_daa_write(IXJ *j)
5229 {
5230         BYTES bytes;
5231
5232         j->flags.pstncheck = 1;
5233
5234         daa_set_mode(j, SOP_PU_SLEEP);
5235
5236         if (!SCI_Prepare(j))
5237                 return 0;
5238
5239         outb_p(j->pld_scrw.byte, j->XILINXbase);
5240
5241         bytes.high = 0x14;
5242         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5243         if (!daa_load(&bytes, j))
5244                 return 0;
5245
5246         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5247         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5248         if (!daa_load(&bytes, j))
5249                 return 0;
5250
5251         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5252         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5253         if (!daa_load(&bytes, j))
5254                 return 0;
5255
5256         if (!SCI_Prepare(j))
5257                 return 0;
5258
5259         bytes.high = 0x1F;
5260         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5261         if (!daa_load(&bytes, j))
5262                 return 0;
5263
5264         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5265         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5266         if (!daa_load(&bytes, j))
5267                 return 0;
5268
5269         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5270         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5271         if (!daa_load(&bytes, j))
5272                 return 0;
5273
5274         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5275         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5276         if (!daa_load(&bytes, j))
5277                 return 0;
5278
5279         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5280         bytes.low = 0x00;
5281         if (!daa_load(&bytes, j))
5282                 return 0;
5283
5284         if (!SCI_Prepare(j))
5285                 return 0;
5286
5287         bytes.high = 0x00;
5288         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5289         if (!daa_load(&bytes, j))
5290                 return 0;
5291
5292         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5293         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5294         if (!daa_load(&bytes, j))
5295                 return 0;
5296
5297         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5298         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5299         if (!daa_load(&bytes, j))
5300                 return 0;
5301
5302         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5303         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5304         if (!daa_load(&bytes, j))
5305                 return 0;
5306
5307         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5308         bytes.low = 0x00;
5309         if (!daa_load(&bytes, j))
5310                 return 0;
5311
5312         if (!SCI_Control(j, SCI_End))
5313                 return 0;
5314         if (!SCI_WaitLowSCI(j))
5315                 return 0;
5316
5317         bytes.high = 0x01;
5318         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5319         if (!daa_load(&bytes, j))
5320                 return 0;
5321
5322         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5323         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5324         if (!daa_load(&bytes, j))
5325                 return 0;
5326
5327         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5328         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5329         if (!daa_load(&bytes, j))
5330                 return 0;
5331
5332         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5333         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5334         if (!daa_load(&bytes, j))
5335                 return 0;
5336
5337         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5338         bytes.low = 0x00;
5339         if (!daa_load(&bytes, j))
5340                 return 0;
5341
5342         if (!SCI_Control(j, SCI_End))
5343                 return 0;
5344         if (!SCI_WaitLowSCI(j))
5345                 return 0;
5346
5347         bytes.high = 0x02;
5348         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5349         if (!daa_load(&bytes, j))
5350                 return 0;
5351
5352         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5353         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5354         if (!daa_load(&bytes, j))
5355                 return 0;
5356
5357         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5358         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5359         if (!daa_load(&bytes, j))
5360                 return 0;
5361
5362         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5363         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5364         if (!daa_load(&bytes, j))
5365                 return 0;
5366
5367         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5368         bytes.low = 0x00;
5369         if (!daa_load(&bytes, j))
5370                 return 0;
5371
5372         if (!SCI_Control(j, SCI_End))
5373                 return 0;
5374         if (!SCI_WaitLowSCI(j))
5375                 return 0;
5376
5377         bytes.high = 0x03;
5378         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5379         if (!daa_load(&bytes, j))
5380                 return 0;
5381
5382         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5383         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5384         if (!daa_load(&bytes, j))
5385                 return 0;
5386
5387         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5388         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5389         if (!daa_load(&bytes, j))
5390                 return 0;
5391
5392         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5393         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5394         if (!daa_load(&bytes, j))
5395                 return 0;
5396
5397         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5398         bytes.low = 0x00;
5399         if (!daa_load(&bytes, j))
5400                 return 0;
5401
5402         if (!SCI_Control(j, SCI_End))
5403                 return 0;
5404         if (!SCI_WaitLowSCI(j))
5405                 return 0;
5406
5407         bytes.high = 0x04;
5408         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5409         if (!daa_load(&bytes, j))
5410                 return 0;
5411
5412         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5413         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5414         if (!daa_load(&bytes, j))
5415                 return 0;
5416
5417         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5418         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5419         if (!daa_load(&bytes, j))
5420                 return 0;
5421
5422         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5423         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5424         if (!daa_load(&bytes, j))
5425                 return 0;
5426
5427         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5428         bytes.low = 0x00;
5429         if (!daa_load(&bytes, j))
5430                 return 0;
5431
5432         if (!SCI_Control(j, SCI_End))
5433                 return 0;
5434         if (!SCI_WaitLowSCI(j))
5435                 return 0;
5436
5437         bytes.high = 0x05;
5438         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5439         if (!daa_load(&bytes, j))
5440                 return 0;
5441
5442         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5443         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5444         if (!daa_load(&bytes, j))
5445                 return 0;
5446
5447         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5448         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5449         if (!daa_load(&bytes, j))
5450                 return 0;
5451
5452         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5453         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5454         if (!daa_load(&bytes, j))
5455                 return 0;
5456
5457         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5458         bytes.low = 0x00;
5459         if (!daa_load(&bytes, j))
5460                 return 0;
5461
5462         if (!SCI_Control(j, SCI_End))
5463                 return 0;
5464         if (!SCI_WaitLowSCI(j))
5465                 return 0;
5466
5467         bytes.high = 0x06;
5468         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5469         if (!daa_load(&bytes, j))
5470                 return 0;
5471
5472         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5473         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5474         if (!daa_load(&bytes, j))
5475                 return 0;
5476
5477         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5478         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5479         if (!daa_load(&bytes, j))
5480                 return 0;
5481
5482         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5483         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5484         if (!daa_load(&bytes, j))
5485                 return 0;
5486
5487         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5488         bytes.low = 0x00;
5489         if (!daa_load(&bytes, j))
5490                 return 0;
5491
5492         if (!SCI_Control(j, SCI_End))
5493                 return 0;
5494         if (!SCI_WaitLowSCI(j))
5495                 return 0;
5496
5497         bytes.high = 0x07;
5498         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5499         if (!daa_load(&bytes, j))
5500                 return 0;
5501
5502         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5503         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5504         if (!daa_load(&bytes, j))
5505                 return 0;
5506
5507         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5508         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5509         if (!daa_load(&bytes, j))
5510                 return 0;
5511
5512         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5513         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5514         if (!daa_load(&bytes, j))
5515                 return 0;
5516
5517         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5518         bytes.low = 0x00;
5519         if (!daa_load(&bytes, j))
5520                 return 0;
5521
5522         if (!SCI_Control(j, SCI_End))
5523                 return 0;
5524         if (!SCI_WaitLowSCI(j))
5525                 return 0;
5526
5527         bytes.high = 0x08;
5528         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5529         if (!daa_load(&bytes, j))
5530                 return 0;
5531
5532         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5533         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5534         if (!daa_load(&bytes, j))
5535                 return 0;
5536
5537         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5538         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5539         if (!daa_load(&bytes, j))
5540                 return 0;
5541
5542         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5543         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5544         if (!daa_load(&bytes, j))
5545                 return 0;
5546
5547         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5548         bytes.low = 0x00;
5549         if (!daa_load(&bytes, j))
5550                 return 0;
5551
5552         if (!SCI_Control(j, SCI_End))
5553                 return 0;
5554         if (!SCI_WaitLowSCI(j))
5555                 return 0;
5556
5557         bytes.high = 0x09;
5558         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5559         if (!daa_load(&bytes, j))
5560                 return 0;
5561
5562         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5563         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5564         if (!daa_load(&bytes, j))
5565                 return 0;
5566
5567         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5568         bytes.low = 0x00;
5569         if (!daa_load(&bytes, j))
5570                 return 0;
5571
5572         if (!SCI_Control(j, SCI_End))
5573                 return 0;
5574         if (!SCI_WaitLowSCI(j))
5575                 return 0;
5576
5577         bytes.high = 0x0A;
5578         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5579         if (!daa_load(&bytes, j))
5580                 return 0;
5581
5582         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5583         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5584         if (!daa_load(&bytes, j))
5585                 return 0;
5586
5587         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5588         bytes.low = 0x00;
5589         if (!daa_load(&bytes, j))
5590                 return 0;
5591
5592         if (!SCI_Control(j, SCI_End))
5593                 return 0;
5594         if (!SCI_WaitLowSCI(j))
5595                 return 0;
5596
5597         bytes.high = 0x0B;
5598         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5599         if (!daa_load(&bytes, j))
5600                 return 0;
5601
5602         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5603         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5604         if (!daa_load(&bytes, j))
5605                 return 0;
5606
5607         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5608         bytes.low = 0x00;
5609         if (!daa_load(&bytes, j))
5610                 return 0;
5611
5612         if (!SCI_Control(j, SCI_End))
5613                 return 0;
5614         if (!SCI_WaitLowSCI(j))
5615                 return 0;
5616
5617         bytes.high = 0x0C;
5618         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5619         if (!daa_load(&bytes, j))
5620                 return 0;
5621
5622         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5623         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5624         if (!daa_load(&bytes, j))
5625                 return 0;
5626
5627         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5628         bytes.low = 0x00;
5629         if (!daa_load(&bytes, j))
5630                 return 0;
5631
5632         if (!SCI_Control(j, SCI_End))
5633                 return 0;
5634         if (!SCI_WaitLowSCI(j))
5635                 return 0;
5636
5637         bytes.high = 0x0D;
5638         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5639         if (!daa_load(&bytes, j))
5640                 return 0;
5641
5642         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5643         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5644         if (!daa_load(&bytes, j))
5645                 return 0;
5646
5647         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5648         bytes.low = 0x00;
5649         if (!daa_load(&bytes, j))
5650                 return 0;
5651
5652         if (!SCI_Control(j, SCI_End))
5653                 return 0;
5654         if (!SCI_WaitLowSCI(j))
5655                 return 0;
5656
5657         bytes.high = 0x0E;
5658         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5659         if (!daa_load(&bytes, j))
5660                 return 0;
5661
5662         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5663         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5664         if (!daa_load(&bytes, j))
5665                 return 0;
5666
5667         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5668         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5669         if (!daa_load(&bytes, j))
5670                 return 0;
5671
5672         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5673         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5674         if (!daa_load(&bytes, j))
5675                 return 0;
5676
5677         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5678         bytes.low = 0x00;
5679         if (!daa_load(&bytes, j))
5680                 return 0;
5681
5682         if (!SCI_Control(j, SCI_End))
5683                 return 0;
5684         if (!SCI_WaitLowSCI(j))
5685                 return 0;
5686
5687         bytes.high = 0x0F;
5688         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5689         if (!daa_load(&bytes, j))
5690                 return 0;
5691
5692         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5693         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5694         if (!daa_load(&bytes, j))
5695                 return 0;
5696
5697         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5698         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5699         if (!daa_load(&bytes, j))
5700                 return 0;
5701
5702         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5703         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5704         if (!daa_load(&bytes, j))
5705                 return 0;
5706
5707         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5708         bytes.low = 0x00;
5709         if (!daa_load(&bytes, j))
5710                 return 0;
5711
5712         udelay(32);
5713         j->pld_scrr.byte = inb_p(j->XILINXbase);
5714         if (!SCI_Control(j, SCI_End))
5715                 return 0;
5716
5717         outb_p(j->pld_scrw.byte, j->XILINXbase);
5718
5719         if (ixjdebug & 0x0002)
5720                 printk("DAA Coefficients Loaded\n");
5721
5722         j->flags.pstncheck = 0;
5723         return 1;
5724 }
5725
5726 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5727 {
5728         j->tone_off_time = arg;
5729         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5730
5731                 return -1;
5732         if (ixj_WriteDSPCommand(arg, j))
5733                 return -1;
5734         return 0;
5735 }
5736
5737 static int ixj_get_tone_on(IXJ *j)
5738 {
5739         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5740
5741                 return -1;
5742         return 0;
5743 }
5744
5745 static int ixj_get_tone_off(IXJ *j)
5746 {
5747         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5748
5749                 return -1;
5750         return 0;
5751 }
5752
5753 static void ixj_busytone(IXJ *j)
5754 {
5755         j->flags.ringback = 0;
5756         j->flags.dialtone = 0;
5757         j->flags.busytone = 1;
5758         ixj_set_tone_on(0x07D0, j);
5759         ixj_set_tone_off(0x07D0, j);
5760         ixj_play_tone(j, 27);
5761 }
5762
5763 static void ixj_dialtone(IXJ *j)
5764 {
5765         j->flags.ringback = 0;
5766         j->flags.dialtone = 1;
5767         j->flags.busytone = 0;
5768         if (j->dsp.low == 0x20) {
5769                 return;
5770         } else {
5771                 ixj_set_tone_on(0xFFFF, j);
5772                 ixj_set_tone_off(0x0000, j);
5773                 ixj_play_tone(j, 25);
5774         }
5775 }
5776
5777 static void ixj_cpt_stop(IXJ *j)
5778 {
5779         if(j->tone_state || j->tone_cadence_state)
5780         {
5781                 j->flags.dialtone = 0;
5782                 j->flags.busytone = 0;
5783                 j->flags.ringback = 0;
5784                 ixj_set_tone_on(0x0001, j);
5785                 ixj_set_tone_off(0x0000, j);
5786                 ixj_play_tone(j, 0);
5787                 j->tone_state = j->tone_cadence_state = 0;
5788                 if (j->cadence_t) {
5789                         kfree(j->cadence_t->ce);
5790                         kfree(j->cadence_t);
5791                         j->cadence_t = NULL;
5792                 }
5793         }
5794         if (j->play_mode == -1 && j->rec_mode == -1)
5795                 idle(j);
5796         if (j->play_mode != -1 && j->dsp.low == 0x20)
5797                 ixj_play_start(j);
5798         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5799                 ixj_record_start(j);
5800 }
5801
5802 static void ixj_ringback(IXJ *j)
5803 {
5804         j->flags.busytone = 0;
5805         j->flags.dialtone = 0;
5806         j->flags.ringback = 1;
5807         ixj_set_tone_on(0x0FA0, j);
5808         ixj_set_tone_off(0x2EE0, j);
5809         ixj_play_tone(j, 26);
5810 }
5811
5812 static void ixj_testram(IXJ *j)
5813 {
5814         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5815 }
5816
5817 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5818 {
5819         ixj_cadence *lcp;
5820         IXJ_CADENCE_ELEMENT __user *cep;
5821         IXJ_CADENCE_ELEMENT *lcep;
5822         IXJ_TONE ti;
5823         int err;
5824
5825         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5826         if (lcp == NULL)
5827                 return -ENOMEM;
5828
5829         err = -EFAULT;
5830         if (copy_from_user(&lcp->elements_used,
5831                            &cp->elements_used, sizeof(int)))
5832                 goto out;
5833         if (copy_from_user(&lcp->termination,
5834                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5835                 goto out;
5836         if (get_user(cep, &cp->ce))
5837                 goto out;
5838
5839         err = -EINVAL;
5840         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5841                 goto out;
5842
5843         err = -ENOMEM;
5844         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5845         if (!lcep)
5846                 goto out;
5847
5848         err = -EFAULT;
5849         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5850                 goto out1;
5851
5852         if (j->cadence_t) {
5853                 kfree(j->cadence_t->ce);
5854                 kfree(j->cadence_t);
5855         }
5856         lcp->ce = (void *) lcep;
5857         j->cadence_t = lcp;
5858         j->tone_cadence_state = 0;
5859         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5860         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5861         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5862                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5863                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5864                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5865                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5866                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5867                 ixj_init_tone(j, &ti);
5868         }
5869         ixj_play_tone(j, lcp->ce[0].index);
5870         return 1;
5871 out1:
5872         kfree(lcep);
5873 out:
5874         kfree(lcp);
5875         return err;
5876 }
5877
5878 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5879 {
5880         IXJ_FILTER_CADENCE *lcp;
5881         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5882         if (lcp == NULL) {
5883                 if(ixjdebug & 0x0001) {
5884                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5885                 }
5886                 return -ENOMEM;
5887         }
5888         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5889                 if(ixjdebug & 0x0001) {
5890                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5891                 }
5892                 kfree(lcp);
5893                 return -EFAULT;
5894         }
5895         if (lcp->filter > 5) {
5896                 if(ixjdebug & 0x0001) {
5897                         printk(KERN_INFO "Cadence out of range\n");
5898                 }
5899                 kfree(lcp);
5900                 return -1;
5901         }
5902         j->cadence_f[lcp->filter].state = 0;
5903         j->cadence_f[lcp->filter].enable = lcp->enable;
5904         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5905         j->cadence_f[lcp->filter].on1 = lcp->on1;
5906         j->cadence_f[lcp->filter].on1min = 0;
5907         j->cadence_f[lcp->filter].on1max = 0;
5908         j->cadence_f[lcp->filter].off1 = lcp->off1;
5909         j->cadence_f[lcp->filter].off1min = 0;
5910         j->cadence_f[lcp->filter].off1max = 0;
5911         j->cadence_f[lcp->filter].on2 = lcp->on2;
5912         j->cadence_f[lcp->filter].on2min = 0;
5913         j->cadence_f[lcp->filter].on2max = 0;
5914         j->cadence_f[lcp->filter].off2 = lcp->off2;
5915         j->cadence_f[lcp->filter].off2min = 0;
5916         j->cadence_f[lcp->filter].off2max = 0;
5917         j->cadence_f[lcp->filter].on3 = lcp->on3;
5918         j->cadence_f[lcp->filter].on3min = 0;
5919         j->cadence_f[lcp->filter].on3max = 0;
5920         j->cadence_f[lcp->filter].off3 = lcp->off3;
5921         j->cadence_f[lcp->filter].off3min = 0;
5922         j->cadence_f[lcp->filter].off3max = 0;
5923         if(ixjdebug & 0x0002) {
5924                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5925         }
5926         kfree(lcp);
5927         return 0;
5928 }
5929
5930 static void add_caps(IXJ *j)
5931 {
5932         j->caps = 0;
5933         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5934         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5935         j->caplist[j->caps].captype = vendor;
5936         j->caplist[j->caps].handle = j->caps++;
5937         j->caplist[j->caps].captype = device;
5938         switch (j->cardtype) {
5939         case QTI_PHONEJACK:
5940                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5941                 break;
5942         case QTI_LINEJACK:
5943                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5944                 break;
5945         case QTI_PHONEJACK_LITE:
5946                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5947                 break;
5948         case QTI_PHONEJACK_PCI:
5949                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5950                 break;
5951         case QTI_PHONECARD:
5952                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5953                 break;
5954         }
5955         j->caplist[j->caps].cap = j->cardtype;
5956         j->caplist[j->caps].handle = j->caps++;
5957         strcpy(j->caplist[j->caps].desc, "POTS");
5958         j->caplist[j->caps].captype = port;
5959         j->caplist[j->caps].cap = pots;
5960         j->caplist[j->caps].handle = j->caps++;
5961
5962         /* add devices that can do speaker/mic */
5963         switch (j->cardtype) {
5964         case QTI_PHONEJACK:
5965         case QTI_LINEJACK:
5966         case QTI_PHONEJACK_PCI:
5967         case QTI_PHONECARD:
5968                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5969                 j->caplist[j->caps].captype = port;
5970                 j->caplist[j->caps].cap = speaker;
5971                 j->caplist[j->caps].handle = j->caps++;
5972         default:
5973                 break;
5974         }
5975
5976         /* add devices that can do handset */
5977         switch (j->cardtype) {
5978         case QTI_PHONEJACK:
5979                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5980                 j->caplist[j->caps].captype = port;
5981                 j->caplist[j->caps].cap = handset;
5982                 j->caplist[j->caps].handle = j->caps++;
5983                 break;
5984         default:
5985                 break;
5986         }
5987
5988         /* add devices that can do PSTN */
5989         switch (j->cardtype) {
5990         case QTI_LINEJACK:
5991                 strcpy(j->caplist[j->caps].desc, "PSTN");
5992                 j->caplist[j->caps].captype = port;
5993                 j->caplist[j->caps].cap = pstn;
5994                 j->caplist[j->caps].handle = j->caps++;
5995                 break;
5996         default:
5997                 break;
5998         }
5999
6000         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6001         strcpy(j->caplist[j->caps].desc, "ULAW");
6002         j->caplist[j->caps].captype = codec;
6003         j->caplist[j->caps].cap = ULAW;
6004         j->caplist[j->caps].handle = j->caps++;
6005
6006         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6007         j->caplist[j->caps].captype = codec;
6008         j->caplist[j->caps].cap = LINEAR16;
6009         j->caplist[j->caps].handle = j->caps++;
6010
6011         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6012         j->caplist[j->caps].captype = codec;
6013         j->caplist[j->caps].cap = LINEAR8;
6014         j->caplist[j->caps].handle = j->caps++;
6015
6016         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6017         j->caplist[j->caps].captype = codec;
6018         j->caplist[j->caps].cap = WSS;
6019         j->caplist[j->caps].handle = j->caps++;
6020
6021         /* software ALAW codec, made from ULAW */
6022         strcpy(j->caplist[j->caps].desc, "ALAW");
6023         j->caplist[j->caps].captype = codec;
6024         j->caplist[j->caps].cap = ALAW;
6025         j->caplist[j->caps].handle = j->caps++;
6026
6027         /* version 12 of the 8020 does the following codecs in a broken way */
6028         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6029                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6030                 j->caplist[j->caps].captype = codec;
6031                 j->caplist[j->caps].cap = G723_63;
6032                 j->caplist[j->caps].handle = j->caps++;
6033
6034                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6035                 j->caplist[j->caps].captype = codec;
6036                 j->caplist[j->caps].cap = G723_53;
6037                 j->caplist[j->caps].handle = j->caps++;
6038
6039                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6040                 j->caplist[j->caps].captype = codec;
6041                 j->caplist[j->caps].cap = TS48;
6042                 j->caplist[j->caps].handle = j->caps++;
6043
6044                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6045                 j->caplist[j->caps].captype = codec;
6046                 j->caplist[j->caps].cap = TS41;
6047                 j->caplist[j->caps].handle = j->caps++;
6048         }
6049
6050         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6051         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6052                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6053                 j->caplist[j->caps].captype = codec;
6054                 j->caplist[j->caps].cap = TS85;
6055                 j->caplist[j->caps].handle = j->caps++;
6056         }
6057
6058         /* 8021 chips can do G728 */
6059         if (j->dsp.low == 0x21) {
6060                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6061                 j->caplist[j->caps].captype = codec;
6062                 j->caplist[j->caps].cap = G728;
6063                 j->caplist[j->caps].handle = j->caps++;
6064         }
6065
6066         /* 8021/8022 chips can do G729 if loaded */
6067         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6068                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6069                 j->caplist[j->caps].captype = codec;
6070                 j->caplist[j->caps].cap = G729;
6071                 j->caplist[j->caps].handle = j->caps++;
6072         }
6073         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6074                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6075                 j->caplist[j->caps].captype = codec;
6076                 j->caplist[j->caps].cap = G729B;
6077                 j->caplist[j->caps].handle = j->caps++;
6078         }
6079 }
6080
6081 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6082 {
6083         int cnt;
6084         int retval = 0;
6085         for (cnt = 0; cnt < j->caps; cnt++) {
6086                 if (pcreq->captype == j->caplist[cnt].captype
6087                     && pcreq->cap == j->caplist[cnt].cap) {
6088                         retval = 1;
6089                         break;
6090                 }
6091         }
6092         return retval;
6093 }
6094
6095 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6096 {
6097         IXJ_TONE ti;
6098         IXJ_FILTER jf;
6099         IXJ_FILTER_RAW jfr;
6100         void __user *argp = (void __user *)arg;
6101         struct inode *inode = file_p->f_path.dentry->d_inode;
6102         unsigned int minor = iminor(inode);
6103         unsigned int raise, mant;
6104         int board = NUM(inode);
6105
6106         IXJ *j = get_ixj(NUM(inode));
6107
6108         int retval = 0;
6109
6110         /*
6111          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6112          *    This is necessary to keep the DSP from locking up.
6113          */
6114         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6115                 schedule_timeout_interruptible(1);
6116         if (ixjdebug & 0x0040)
6117                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6118         if (minor >= IXJMAX) {
6119                 clear_bit(board, &j->busyflags);
6120                 return -ENODEV;
6121         }
6122         /*
6123          *    Check ioctls only root can use.
6124          */
6125         if (!capable(CAP_SYS_ADMIN)) {
6126                 switch (cmd) {
6127                 case IXJCTL_TESTRAM:
6128                 case IXJCTL_HZ:
6129                         retval = -EPERM;
6130                 }
6131         }
6132         switch (cmd) {
6133         case IXJCTL_TESTRAM:
6134                 ixj_testram(j);
6135                 retval = (j->ssr.high << 8) + j->ssr.low;
6136                 break;
6137         case IXJCTL_CARDTYPE:
6138                 retval = j->cardtype;
6139                 break;
6140         case IXJCTL_SERIAL:
6141                 retval = j->serial;
6142                 break;
6143         case IXJCTL_VERSION:
6144                 {
6145                         char arg_str[100];
6146                         snprintf(arg_str, sizeof(arg_str),
6147                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6148                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6149                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6150                                 retval = -EFAULT;
6151                 }
6152                 break;
6153         case PHONE_RING_CADENCE:
6154                 j->ring_cadence = arg;
6155                 break;
6156         case IXJCTL_CIDCW:
6157                 if(arg) {
6158                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6159                                 retval = -EFAULT;
6160                                 break;
6161                         }
6162                 } else {
6163                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6164                 }
6165                 ixj_write_cidcw(j);
6166                 break;
6167         /* Binary compatbility */
6168         case OLD_PHONE_RING_START:
6169                 arg = 0;
6170                 /* Fall through */
6171         case PHONE_RING_START:
6172                 if(arg) {
6173                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6174                                 retval = -EFAULT;
6175                                 break;
6176                         }
6177                         ixj_write_cid(j);
6178                 } else {
6179                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6180                 }
6181                 ixj_ring_start(j);
6182                 break;
6183         case PHONE_RING_STOP:
6184                 j->flags.cringing = 0;
6185                 if(j->cadence_f[5].enable) {
6186                         j->cadence_f[5].state = 0;
6187                 }
6188                 ixj_ring_off(j);
6189                 break;
6190         case PHONE_RING:
6191                 retval = ixj_ring(j);
6192                 break;
6193         case PHONE_EXCEPTION:
6194                 retval = j->ex.bytes;
6195                 if(j->ex.bits.flash) {
6196                         j->flash_end = 0;
6197                         j->ex.bits.flash = 0;
6198                 }
6199                 j->ex.bits.pstn_ring = 0;
6200                 j->ex.bits.caller_id = 0;
6201                 j->ex.bits.pstn_wink = 0;
6202                 j->ex.bits.f0 = 0;
6203                 j->ex.bits.f1 = 0;
6204                 j->ex.bits.f2 = 0;
6205                 j->ex.bits.f3 = 0;
6206                 j->ex.bits.fc0 = 0;
6207                 j->ex.bits.fc1 = 0;
6208                 j->ex.bits.fc2 = 0;
6209                 j->ex.bits.fc3 = 0;
6210                 j->ex.bits.reserved = 0;
6211                 break;
6212         case PHONE_HOOKSTATE:
6213                 j->ex.bits.hookstate = 0;
6214                 retval = j->hookstate;  //j->r_hook;
6215                 break;
6216         case IXJCTL_SET_LED:
6217                 LED_SetState(arg, j);
6218                 break;
6219         case PHONE_FRAME:
6220                 retval = set_base_frame(j, arg);
6221                 break;
6222         case PHONE_REC_CODEC:
6223                 retval = set_rec_codec(j, arg);
6224                 break;
6225         case PHONE_VAD:
6226                 ixj_vad(j, arg);
6227                 break;
6228         case PHONE_REC_START:
6229                 ixj_record_start(j);
6230                 break;
6231         case PHONE_REC_STOP:
6232                 ixj_record_stop(j);
6233                 break;
6234         case PHONE_REC_DEPTH:
6235                 set_rec_depth(j, arg);
6236                 break;
6237         case PHONE_REC_VOLUME:
6238                 if(arg == -1) {
6239                         retval = get_rec_volume(j);
6240                 }
6241                 else {
6242                         set_rec_volume(j, arg);
6243                         retval = arg;
6244                 }
6245                 break;
6246         case PHONE_REC_VOLUME_LINEAR:
6247                 if(arg == -1) {
6248                         retval = get_rec_volume_linear(j);
6249                 }
6250                 else {
6251                         set_rec_volume_linear(j, arg);
6252                         retval = arg;
6253                 }
6254                 break;
6255         case IXJCTL_DTMF_PRESCALE:
6256                 if(arg == -1) {
6257                         retval = get_dtmf_prescale(j);
6258                 }
6259                 else {
6260                         set_dtmf_prescale(j, arg);
6261                         retval = arg;
6262                 }
6263                 break;
6264         case PHONE_REC_LEVEL:
6265                 retval = get_rec_level(j);
6266                 break;
6267         case IXJCTL_SC_RXG:
6268                 retval = ixj_siadc(j, arg);
6269                 break;
6270         case IXJCTL_SC_TXG:
6271                 retval = ixj_sidac(j, arg);
6272                 break;
6273         case IXJCTL_AEC_START:
6274                 ixj_aec_start(j, arg);
6275                 break;
6276         case IXJCTL_AEC_STOP:
6277                 aec_stop(j);
6278                 break;
6279         case IXJCTL_AEC_GET_LEVEL:
6280                 retval = j->aec_level;
6281                 break;
6282         case PHONE_PLAY_CODEC:
6283                 retval = set_play_codec(j, arg);
6284                 break;
6285         case PHONE_PLAY_START:
6286                 retval = ixj_play_start(j);
6287                 break;
6288         case PHONE_PLAY_STOP:
6289                 ixj_play_stop(j);
6290                 break;
6291         case PHONE_PLAY_DEPTH:
6292                 set_play_depth(j, arg);
6293                 break;
6294         case PHONE_PLAY_VOLUME:
6295                 if(arg == -1) {
6296                         retval = get_play_volume(j);
6297                 }
6298                 else {
6299                         set_play_volume(j, arg);
6300                         retval = arg;
6301                 }
6302                 break;
6303         case PHONE_PLAY_VOLUME_LINEAR:
6304                 if(arg == -1) {
6305                         retval = get_play_volume_linear(j);
6306                 }
6307                 else {
6308                         set_play_volume_linear(j, arg);
6309                         retval = arg;
6310                 }
6311                 break;
6312         case PHONE_PLAY_LEVEL:
6313                 retval = get_play_level(j);
6314                 break;
6315         case IXJCTL_DSP_TYPE:
6316                 retval = (j->dsp.high << 8) + j->dsp.low;
6317                 break;
6318         case IXJCTL_DSP_VERSION:
6319                 retval = (j->ver.high << 8) + j->ver.low;
6320                 break;
6321         case IXJCTL_HZ:
6322                 hertz = arg;
6323                 break;
6324         case IXJCTL_RATE:
6325                 if (arg > hertz)
6326                         retval = -1;
6327                 else
6328                         samplerate = arg;
6329                 break;
6330         case IXJCTL_DRYBUFFER_READ:
6331                 put_user(j->drybuffer, (unsigned long __user *) argp);
6332                 break;
6333         case IXJCTL_DRYBUFFER_CLEAR:
6334                 j->drybuffer = 0;
6335                 break;
6336         case IXJCTL_FRAMES_READ:
6337                 put_user(j->framesread, (unsigned long __user *) argp);
6338                 break;
6339         case IXJCTL_FRAMES_WRITTEN:
6340                 put_user(j->frameswritten, (unsigned long __user *) argp);
6341                 break;
6342         case IXJCTL_READ_WAIT:
6343                 put_user(j->read_wait, (unsigned long __user *) argp);
6344                 break;
6345         case IXJCTL_WRITE_WAIT:
6346                 put_user(j->write_wait, (unsigned long __user *) argp);
6347                 break;
6348         case PHONE_MAXRINGS:
6349                 j->maxrings = arg;
6350                 break;
6351         case PHONE_SET_TONE_ON_TIME:
6352                 ixj_set_tone_on(arg, j);
6353                 break;
6354         case PHONE_SET_TONE_OFF_TIME:
6355                 ixj_set_tone_off(arg, j);
6356                 break;
6357         case PHONE_GET_TONE_ON_TIME:
6358                 if (ixj_get_tone_on(j)) {
6359                         retval = -1;
6360                 } else {
6361                         retval = (j->ssr.high << 8) + j->ssr.low;
6362                 }
6363                 break;
6364         case PHONE_GET_TONE_OFF_TIME:
6365                 if (ixj_get_tone_off(j)) {
6366                         retval = -1;
6367                 } else {
6368                         retval = (j->ssr.high << 8) + j->ssr.low;
6369                 }
6370                 break;
6371         case PHONE_PLAY_TONE:
6372                 if (!j->tone_state)
6373                         retval = ixj_play_tone(j, arg);
6374                 else
6375                         retval = -1;
6376                 break;
6377         case PHONE_GET_TONE_STATE:
6378                 retval = j->tone_state;
6379                 break;
6380         case PHONE_DTMF_READY:
6381                 retval = j->ex.bits.dtmf_ready;
6382                 break;
6383         case PHONE_GET_DTMF:
6384                 if (ixj_hookstate(j)) {
6385                         if (j->dtmf_rp != j->dtmf_wp) {
6386                                 retval = j->dtmfbuffer[j->dtmf_rp];
6387                                 j->dtmf_rp++;
6388                                 if (j->dtmf_rp == 79)
6389                                         j->dtmf_rp = 0;
6390                                 if (j->dtmf_rp == j->dtmf_wp) {
6391                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6392                                 }
6393                         }
6394                 }
6395                 break;
6396         case PHONE_GET_DTMF_ASCII:
6397                 if (ixj_hookstate(j)) {
6398                         if (j->dtmf_rp != j->dtmf_wp) {
6399                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6400                                 case 10:
6401                                         retval = 42;    /* '*'; */
6402
6403                                         break;
6404                                 case 11:
6405                                         retval = 48;    /*'0'; */
6406
6407                                         break;
6408                                 case 12:
6409                                         retval = 35;    /*'#'; */
6410
6411                                         break;
6412                                 case 28:
6413                                         retval = 65;    /*'A'; */
6414
6415                                         break;
6416                                 case 29:
6417                                         retval = 66;    /*'B'; */
6418
6419                                         break;
6420                                 case 30:
6421                                         retval = 67;    /*'C'; */
6422
6423                                         break;
6424                                 case 31:
6425                                         retval = 68;    /*'D'; */
6426
6427                                         break;
6428                                 default:
6429                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6430                                         break;
6431                                 }
6432                                 j->dtmf_rp++;
6433                                 if (j->dtmf_rp == 79)
6434                                         j->dtmf_rp = 0;
6435                                 if(j->dtmf_rp == j->dtmf_wp)
6436                                 {
6437                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6438                                 }
6439                         }
6440                 }
6441                 break;
6442         case PHONE_DTMF_OOB:
6443                 j->flags.dtmf_oob = arg;
6444                 break;
6445         case PHONE_DIALTONE:
6446                 ixj_dialtone(j);
6447                 break;
6448         case PHONE_BUSY:
6449                 ixj_busytone(j);
6450                 break;
6451         case PHONE_RINGBACK:
6452                 ixj_ringback(j);
6453                 break;
6454         case PHONE_WINK:
6455                 if(j->cardtype == QTI_PHONEJACK)
6456                         retval = -1;
6457                 else
6458                         retval = ixj_wink(j);
6459                 break;
6460         case PHONE_CPT_STOP:
6461                 ixj_cpt_stop(j);
6462                 break;
6463         case PHONE_QUERY_CODEC:
6464         {
6465                 struct phone_codec_data pd;
6466                 int val;
6467                 int proto_size[] = {
6468                         -1,
6469                         12, 10, 16, 9, 8, 48, 5,
6470                         40, 40, 80, 40, 40, 6
6471                 };
6472                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6473                         retval = -EFAULT;
6474                         break;
6475                 }
6476                 if(pd.type<1 || pd.type>13) {
6477                         retval = -EPROTONOSUPPORT;
6478                         break;
6479                 }
6480                 if(pd.type<G729)
6481                         val=proto_size[pd.type];
6482                 else switch(j->baseframe.low)
6483                 {
6484                         case 0xA0:val=2*proto_size[pd.type];break;
6485                         case 0x50:val=proto_size[pd.type];break;
6486                         default:val=proto_size[pd.type]*3;break;
6487                 }
6488                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6489                 if(copy_to_user(argp, &pd, sizeof(pd)))
6490                         retval = -EFAULT;
6491                 break;
6492         }
6493         case IXJCTL_DSP_IDLE:
6494                 idle(j);
6495                 break;
6496         case IXJCTL_MIXER:
6497                 if ((arg & 0xff) == 0xff)
6498                         retval = ixj_get_mixer(arg, j);
6499                 else
6500                         ixj_mixer(arg, j);
6501                 break;
6502         case IXJCTL_DAA_COEFF_SET:
6503                 switch (arg) {
6504                 case DAA_US:
6505                         DAA_Coeff_US(j);
6506                         retval = ixj_daa_write(j);
6507                         break;
6508                 case DAA_UK:
6509                         DAA_Coeff_UK(j);
6510                         retval = ixj_daa_write(j);
6511                         break;
6512                 case DAA_FRANCE:
6513                         DAA_Coeff_France(j);
6514                         retval = ixj_daa_write(j);
6515                         break;
6516                 case DAA_GERMANY:
6517                         DAA_Coeff_Germany(j);
6518                         retval = ixj_daa_write(j);
6519                         break;
6520                 case DAA_AUSTRALIA:
6521                         DAA_Coeff_Australia(j);
6522                         retval = ixj_daa_write(j);
6523                         break;
6524                 case DAA_JAPAN:
6525                         DAA_Coeff_Japan(j);
6526                         retval = ixj_daa_write(j);
6527                         break;
6528                 default:
6529                         retval = 1;
6530                         break;
6531                 }
6532                 break;
6533         case IXJCTL_DAA_AGAIN:
6534                 ixj_daa_cr4(j, arg | 0x02);
6535                 break;
6536         case IXJCTL_PSTN_LINETEST:
6537                 retval = ixj_linetest(j);
6538                 break;
6539         case IXJCTL_VMWI:
6540                 ixj_write_vmwi(j, arg);
6541                 break;
6542         case IXJCTL_CID:
6543                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6544                         retval = -EFAULT;
6545                 j->ex.bits.caller_id = 0;
6546                 break;
6547         case IXJCTL_WINK_DURATION:
6548                 j->winktime = arg;
6549                 break;
6550         case IXJCTL_PORT:
6551                 if (arg)
6552                         retval = ixj_set_port(j, arg);
6553                 else
6554                         retval = j->port;
6555                 break;
6556         case IXJCTL_POTS_PSTN:
6557                 retval = ixj_set_pots(j, arg);
6558                 break;
6559         case PHONE_CAPABILITIES:
6560                 add_caps(j);
6561                 retval = j->caps;
6562                 break;
6563         case PHONE_CAPABILITIES_LIST:
6564                 add_caps(j);
6565                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6566                         retval = -EFAULT;
6567                 break;
6568         case PHONE_CAPABILITIES_CHECK:
6569                 {
6570                         struct phone_capability cap;
6571                         if (copy_from_user(&cap, argp, sizeof(cap)))
6572                                 retval = -EFAULT;
6573                         else {
6574                                 add_caps(j);
6575                                 retval = capabilities_check(j, &cap);
6576                         }
6577                 }
6578                 break;
6579         case PHONE_PSTN_SET_STATE:
6580                 daa_set_mode(j, arg);
6581                 break;
6582         case PHONE_PSTN_GET_STATE:
6583                 retval = j->daa_mode;
6584                 j->ex.bits.pstn_ring = 0;
6585                 break;
6586         case IXJCTL_SET_FILTER:
6587                 if (copy_from_user(&jf, argp, sizeof(jf)))
6588                         retval = -EFAULT;
6589                 retval = ixj_init_filter(j, &jf);
6590                 break;
6591         case IXJCTL_SET_FILTER_RAW:
6592                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6593                         retval = -EFAULT;
6594                 else
6595                         retval = ixj_init_filter_raw(j, &jfr);
6596                 break;
6597         case IXJCTL_GET_FILTER_HIST:
6598                 if(arg<0||arg>3)
6599                         retval = -EINVAL;
6600                 else
6601                         retval = j->filter_hist[arg];
6602                 break;
6603         case IXJCTL_INIT_TONE:
6604                 if (copy_from_user(&ti, argp, sizeof(ti)))
6605                         retval = -EFAULT;
6606                 else
6607                         retval = ixj_init_tone(j, &ti);
6608                 break;
6609         case IXJCTL_TONE_CADENCE:
6610                 retval = ixj_build_cadence(j, argp);
6611                 break;
6612         case IXJCTL_FILTER_CADENCE:
6613                 retval = ixj_build_filter_cadence(j, argp);
6614                 break;
6615         case IXJCTL_SIGCTL:
6616                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6617                         retval = -EFAULT;
6618                         break;
6619                 }
6620                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6621                 if(j->sigdef.event < 33) {
6622                         raise = 1;
6623                         for(mant = 0; mant < j->sigdef.event; mant++){
6624                                 raise *= 2;
6625                         }
6626                         if(j->sigdef.signal)
6627                                 j->ex_sig.bytes |= raise;
6628                         else
6629                                 j->ex_sig.bytes &= (raise^0xffff);
6630                 }
6631                 break;
6632         case IXJCTL_INTERCOM_STOP:
6633                 if(arg < 0 || arg >= IXJMAX)
6634                         return -EINVAL;
6635                 j->intercom = -1;
6636                 ixj_record_stop(j);
6637                 ixj_play_stop(j);
6638                 idle(j);
6639                 get_ixj(arg)->intercom = -1;
6640                 ixj_record_stop(get_ixj(arg));
6641                 ixj_play_stop(get_ixj(arg));
6642                 idle(get_ixj(arg));
6643                 break;
6644         case IXJCTL_INTERCOM_START:
6645                 if(arg < 0 || arg >= IXJMAX)
6646                         return -EINVAL;
6647                 j->intercom = arg;
6648                 ixj_record_start(j);
6649                 ixj_play_start(j);
6650                 get_ixj(arg)->intercom = board;
6651                 ixj_play_start(get_ixj(arg));
6652                 ixj_record_start(get_ixj(arg));
6653                 break;
6654         }
6655         if (ixjdebug & 0x0040)
6656                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6657         clear_bit(board, &j->busyflags);
6658         return retval;
6659 }
6660
6661 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6662 {
6663         long ret;
6664         lock_kernel();
6665         ret = do_ixj_ioctl(file_p, cmd, arg);
6666         unlock_kernel();
6667         return ret;
6668 }
6669
6670 static int ixj_fasync(int fd, struct file *file_p, int mode)
6671 {
6672         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6673
6674         return fasync_helper(fd, file_p, mode, &j->async_queue);
6675 }
6676
6677 static const struct file_operations ixj_fops =
6678 {
6679         .owner          = THIS_MODULE,
6680         .read           = ixj_enhanced_read,
6681         .write          = ixj_enhanced_write,
6682         .poll           = ixj_poll,
6683         .unlocked_ioctl = ixj_ioctl,
6684         .release        = ixj_release,
6685         .fasync         = ixj_fasync
6686 };
6687
6688 static int ixj_linetest(IXJ *j)
6689 {
6690         j->flags.pstncheck = 1; /* Testing */
6691         j->flags.pstn_present = 0; /* Assume the line is not there */
6692
6693         daa_int_read(j);        /*Clear DAA Interrupt flags */
6694         /* */
6695         /* Hold all relays in the normally de-energized position. */
6696         /* */
6697
6698         j->pld_slicw.bits.rly1 = 0;
6699         j->pld_slicw.bits.rly2 = 0;
6700         j->pld_slicw.bits.rly3 = 0;
6701         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6702         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6703
6704         outb_p(j->pld_scrw.byte, j->XILINXbase);
6705         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6706         if (j->pld_slicr.bits.potspstn) {
6707                 j->flags.pots_pstn = 1;
6708                 j->flags.pots_correct = 0;
6709                 LED_SetState(0x4, j);
6710         } else {
6711                 j->flags.pots_pstn = 0;
6712                 j->pld_slicw.bits.rly1 = 0;
6713                 j->pld_slicw.bits.rly2 = 0;
6714                 j->pld_slicw.bits.rly3 = 1;
6715                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6716                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6717
6718                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6719                 daa_set_mode(j, SOP_PU_CONVERSATION);
6720                 msleep(1000);
6721                 daa_int_read(j);
6722                 daa_set_mode(j, SOP_PU_RESET);
6723                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6724                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6725                         LED_SetState(0x4, j);
6726                         j->pld_slicw.bits.rly3 = 0;
6727                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6728                 } else {
6729                         j->flags.pots_correct = 1;
6730                         LED_SetState(0x8, j);
6731                         j->pld_slicw.bits.rly1 = 1;
6732                         j->pld_slicw.bits.rly2 = 0;
6733                         j->pld_slicw.bits.rly3 = 0;
6734                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6735                 }
6736         }
6737         j->pld_slicw.bits.rly3 = 0;
6738         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6739         daa_set_mode(j, SOP_PU_CONVERSATION);
6740         msleep(1000);
6741         daa_int_read(j);
6742         daa_set_mode(j, SOP_PU_RESET);
6743         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6744                 j->pstn_sleeptil = jiffies + (hertz / 4);
6745                 j->flags.pstn_present = 1;
6746         } else {
6747                 j->flags.pstn_present = 0;
6748         }
6749         if (j->flags.pstn_present) {
6750                 if (j->flags.pots_correct) {
6751                         LED_SetState(0xA, j);
6752                 } else {
6753                         LED_SetState(0x6, j);
6754                 }
6755         } else {
6756                 if (j->flags.pots_correct) {
6757                         LED_SetState(0x9, j);
6758                 } else {
6759                         LED_SetState(0x5, j);
6760                 }
6761         }
6762         j->flags.pstncheck = 0; /* Testing */
6763         return j->flags.pstn_present;
6764 }
6765
6766 static int ixj_selfprobe(IXJ *j)
6767 {
6768         unsigned short cmd;
6769         int cnt;
6770         BYTES bytes;
6771
6772         init_waitqueue_head(&j->poll_q);
6773         init_waitqueue_head(&j->read_q);
6774         init_waitqueue_head(&j->write_q);
6775
6776         while(atomic_read(&j->DSPWrite) > 0)
6777                 atomic_dec(&j->DSPWrite);
6778         if (ixjdebug & 0x0002)
6779                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6780         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6781
6782         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6783                 return -1;
6784 /* The read values of the SSR should be 0x00 for the IDLE command */
6785         if (j->ssr.low || j->ssr.high)
6786                 return -1;
6787         if (ixjdebug & 0x0002)
6788                 printk(KERN_INFO "Get Device ID Code\n");
6789         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6790                 return -1;
6791         j->dsp.low = j->ssr.low;
6792         j->dsp.high = j->ssr.high;
6793         if (ixjdebug & 0x0002)
6794                 printk(KERN_INFO "Get Device Version Code\n");
6795         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6796                 return -1;
6797         j->ver.low = j->ssr.low;
6798         j->ver.high = j->ssr.high;
6799         if (!j->cardtype) {
6800                 if (j->dsp.low == 0x21) {
6801                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6802                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6803 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6804                         bytes.low = inb_p(j->XILINXbase + 0x02);
6805                         if (bytes.low == bytes.high)    /*  Register is read only on */
6806                                 /*  Internet PhoneJack Lite */
6807                          {
6808                                 j->cardtype = QTI_PHONEJACK_LITE;
6809                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6810                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6811                                         return -1;
6812                                 }
6813                                 j->pld_slicw.pcib.e1 = 1;
6814                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6815                         } else {
6816                                 j->cardtype = QTI_LINEJACK;
6817
6818                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6819                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6820                                         return -1;
6821                                 }
6822                         }
6823                 } else if (j->dsp.low == 0x22) {
6824                         j->cardtype = QTI_PHONEJACK_PCI;
6825                         request_region(j->XILINXbase, 4, "ixj control");
6826                         j->pld_slicw.pcib.e1 = 1;
6827                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6828                 } else
6829                         j->cardtype = QTI_PHONEJACK;
6830         } else {
6831                 switch (j->cardtype) {
6832                 case QTI_PHONEJACK:
6833                         if (!j->dsp.low != 0x20) {
6834                                 j->dsp.high = 0x80;
6835                                 j->dsp.low = 0x20;
6836                                 ixj_WriteDSPCommand(0x3800, j);
6837                                 j->ver.low = j->ssr.low;
6838                                 j->ver.high = j->ssr.high;
6839                         }
6840                         break;
6841                 case QTI_LINEJACK:
6842                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6843                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6844                                 return -1;
6845                         }
6846                         break;
6847                 case QTI_PHONEJACK_LITE:
6848                 case QTI_PHONEJACK_PCI:
6849                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6850                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6851                                 return -1;
6852                         }
6853                         j->pld_slicw.pcib.e1 = 1;
6854                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6855                         break;
6856                 case QTI_PHONECARD:
6857                         break;
6858                 }
6859         }
6860         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6861                 if (ixjdebug & 0x0002)
6862                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6863                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6864                         return -1;
6865                 if (ixjdebug & 0x0002)
6866                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6867                 if (j->cardtype == QTI_PHONEJACK) {
6868                         cmd = 0x9FF2;
6869                 } else {
6870                         cmd = 0x9FF5;
6871                 }
6872                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6873                         return -1;
6874         } else {
6875                 if (set_base_frame(j, 30) != 30)
6876                         return -1;
6877                 if (ixjdebug & 0x0002)
6878                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6879                 if (j->cardtype == QTI_PHONECARD) {
6880                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6881                                 return -1;
6882                 }
6883                 if (j->cardtype == QTI_LINEJACK) {
6884                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6885                                 return -1;
6886                         if (ixjdebug & 0x0002)
6887                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6888                         j->pld_clock.byte = 0;
6889                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6890                 }
6891         }
6892
6893         if (j->dsp.low == 0x20) {
6894                 if (ixjdebug & 0x0002)
6895                         printk(KERN_INFO "Configure GPIO pins\n");
6896                 j->gpio.bytes.high = 0x09;
6897 /*  bytes.low = 0xEF;  0xF7 */
6898                 j->gpio.bits.gpio1 = 1;
6899                 j->gpio.bits.gpio2 = 1;
6900                 j->gpio.bits.gpio3 = 0;
6901                 j->gpio.bits.gpio4 = 1;
6902                 j->gpio.bits.gpio5 = 1;
6903                 j->gpio.bits.gpio6 = 1;
6904                 j->gpio.bits.gpio7 = 1;
6905                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6906                 if (ixjdebug & 0x0002)
6907                         printk(KERN_INFO "Enable SLIC\n");
6908                 j->gpio.bytes.high = 0x0B;
6909                 j->gpio.bytes.low = 0x00;
6910                 j->gpio.bits.gpio1 = 0;
6911                 j->gpio.bits.gpio2 = 1;
6912                 j->gpio.bits.gpio5 = 0;
6913                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6914                 j->port = PORT_POTS;
6915         } else {
6916                 if (j->cardtype == QTI_LINEJACK) {
6917                         LED_SetState(0x1, j);
6918                         msleep(100);
6919                         LED_SetState(0x2, j);
6920                         msleep(100);
6921                         LED_SetState(0x4, j);
6922                         msleep(100);
6923                         LED_SetState(0x8, j);
6924                         msleep(100);
6925                         LED_SetState(0x0, j);
6926                         daa_get_version(j);
6927                         if (ixjdebug & 0x0002)
6928                                 printk("Loading DAA Coefficients\n");
6929                         DAA_Coeff_US(j);
6930                         if (!ixj_daa_write(j)) {
6931                                 printk("DAA write failed on board %d\n", j->board);
6932                                 return -1;
6933                         }
6934                         if(!ixj_daa_cid_reset(j)) {
6935                                 printk("DAA CID reset failed on board %d\n", j->board);
6936                                 return -1;
6937                         }
6938                         j->flags.pots_correct = 0;
6939                         j->flags.pstn_present = 0;
6940                         ixj_linetest(j);
6941                         if (j->flags.pots_correct) {
6942                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6943
6944                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6945                                 j->pld_slicw.bits.rly1 = 1;
6946                                 j->pld_slicw.bits.spken = 1;
6947                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6948                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6949 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6950                                 j->port = PORT_POTS;
6951                         }
6952                         ixj_set_port(j, PORT_PSTN);
6953                         ixj_set_pots(j, 1);
6954                         if (ixjdebug & 0x0002)
6955                                 printk(KERN_INFO "Enable Mixer\n");
6956                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6957                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6958
6959                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6960                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6961
6962                         ixj_mixer(0x0480, j);   /*FM Left mute */
6963                         ixj_mixer(0x0580, j);   /*FM Right mute */
6964
6965                         ixj_mixer(0x0680, j);   /*CD Left mute */
6966                         ixj_mixer(0x0780, j);   /*CD Right mute */
6967
6968                         ixj_mixer(0x0880, j);   /*Line Left mute */
6969                         ixj_mixer(0x0980, j);   /*Line Right mute */
6970
6971                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6972                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6973
6974                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6975                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6976
6977                         ixj_mixer(0x0E80, j);   /*Mic mute */
6978
6979                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6980
6981                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6982                         ixj_mixer(0x110C, j);
6983
6984
6985                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6986                         ixj_mixer(0x1401, j);
6987
6988                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6989                         ixj_mixer(0x1501, j);
6990
6991                         ixj_mixer(0x1700, j);   /*Clock select */
6992
6993                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6994
6995                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6996
6997                         if (ixjdebug & 0x0002)
6998                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
6999                         j->cadence_f[4].state = 0;
7000                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7001                         j->cadence_f[4].off1 = 0;
7002                         j->cadence_f[4].on2 = 0;
7003                         j->cadence_f[4].off2 = 0;
7004                         j->cadence_f[4].on3 = 0;
7005                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7006                         j->pstn_last_rmr = jiffies;
7007
7008                 } else {
7009                         if (j->cardtype == QTI_PHONECARD) {
7010                                 ixj_WriteDSPCommand(0xCF07, j);
7011                                 ixj_WriteDSPCommand(0x00B0, j);
7012                                 ixj_set_port(j, PORT_SPEAKER);
7013                         } else {
7014                                 ixj_set_port(j, PORT_POTS);
7015                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7016 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7017                         }
7018                 }
7019         }
7020
7021         j->intercom = -1;
7022         j->framesread = j->frameswritten = 0;
7023         j->read_wait = j->write_wait = 0;
7024         j->rxreadycheck = j->txreadycheck = 0;
7025
7026         /* initialise the DTMF prescale to a sensible value */
7027         if (j->cardtype == QTI_LINEJACK) {
7028                 set_dtmf_prescale(j, 0x10);
7029         } else {
7030                 set_dtmf_prescale(j, 0x40);
7031         }
7032         set_play_volume(j, 0x100);
7033         set_rec_volume(j, 0x100);
7034
7035         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7036                 return -1;
7037 /* The read values of the SSR should be 0x00 for the IDLE command */
7038         if (j->ssr.low || j->ssr.high)
7039                 return -1;
7040
7041         if (ixjdebug & 0x0002)
7042                 printk(KERN_INFO "Enable Line Monitor\n");
7043
7044         if (ixjdebug & 0x0002)
7045                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7046
7047         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7048                 return -1;
7049
7050         if (ixjdebug & 0x002)
7051                 printk(KERN_INFO "Enable DTMF Detectors\n");
7052
7053         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7054                 return -1;
7055
7056         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7057                 return -1;
7058
7059         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7060
7061         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7062
7063         j->ex.bits.dtmf_ready = 0;
7064         j->dtmf_state = 0;
7065         j->dtmf_wp = j->dtmf_rp = 0;
7066         j->rec_mode = j->play_mode = -1;
7067         j->flags.ringing = 0;
7068         j->maxrings = MAXRINGS;
7069         j->ring_cadence = USA_RING_CADENCE;
7070         j->drybuffer = 0;
7071         j->winktime = 320;
7072         j->flags.dtmf_oob = 0;
7073         for (cnt = 0; cnt < 4; cnt++)
7074                 j->cadence_f[cnt].enable = 0;
7075         /* must be a device on the specified address */
7076         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7077
7078         /* Set up the default signals for events */
7079         for (cnt = 0; cnt < 35; cnt++)
7080                 j->ixj_signals[cnt] = SIGIO;
7081
7082         /* Set the excetion signal enable flags */
7083         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7084         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 =
7085         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;
7086 #ifdef IXJ_DYN_ALLOC
7087         j->fskdata = NULL;
7088 #endif
7089         j->fskdcnt = 0;
7090         j->cidcw_wait = 0;
7091
7092         /* Register with the Telephony for Linux subsystem */
7093         j->p.f_op = &ixj_fops;
7094         j->p.open = ixj_open;
7095         j->p.board = j->board;
7096         phone_register_device(&j->p, PHONE_UNIT_ANY);
7097
7098         ixj_init_timer(j);
7099         ixj_add_timer(j);
7100         return 0;
7101 }
7102
7103 /*
7104  *      Exported service for pcmcia card handling
7105  */
7106
7107 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7108 {
7109         IXJ *j = ixj_alloc();
7110
7111         j->board = 0;
7112
7113         j->DSPbase = dsp;
7114         j->XILINXbase = xilinx;
7115         j->cardtype = QTI_PHONECARD;
7116         ixj_selfprobe(j);
7117         return j;
7118 }
7119
7120 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7121
7122 static int ixj_get_status_proc(char *buf)
7123 {
7124         int len;
7125         int cnt;
7126         IXJ *j;
7127         len = 0;
7128         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7129         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7130         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7131         len += sprintf(buf + len, "\nUsing old telephony API");
7132         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7133
7134         for (cnt = 0; cnt < IXJMAX; cnt++) {
7135                 j = get_ixj(cnt);
7136                 if(j==NULL)
7137                         continue;
7138                 if (j->DSPbase) {
7139                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7140                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7141                         if (j->cardtype != QTI_PHONEJACK)
7142                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7143                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7144                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7145                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7146                         switch (j->cardtype) {
7147                         case (QTI_PHONEJACK):
7148                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7149                                 break;
7150                         case (QTI_LINEJACK):
7151                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7152                                 if (j->flags.g729_loaded)
7153                                         len += sprintf(buf + len, " w/G.729 A/B");
7154                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7155                                 break;
7156                         case (QTI_PHONEJACK_LITE):
7157                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7158                                 if (j->flags.g729_loaded)
7159                                         len += sprintf(buf + len, " w/G.729 A/B");
7160                                 break;
7161                         case (QTI_PHONEJACK_PCI):
7162                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7163                                 if (j->flags.g729_loaded)
7164                                         len += sprintf(buf + len, " w/G.729 A/B");
7165                                 break;
7166                         case (QTI_PHONECARD):
7167                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7168                                 if (j->flags.g729_loaded)
7169                                         len += sprintf(buf + len, " w/G.729 A/B");
7170                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7171                                 if (!j->pccr1.bits.drf)
7172                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7173                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7174                                 break;
7175                         default:
7176                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7177                                 break;
7178                         }
7179                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7180                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7181                         add_caps(j);
7182                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7183                         if (j->dsp.low != 0x20)
7184                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7185                         if (j->flags.cidsent)
7186                                 len += sprintf(buf + len, "\nCaller ID data sent");
7187                         else
7188                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7189
7190                         len += sprintf(buf + len, "\nPlay CODEC ");
7191                         switch (j->play_codec) {
7192                         case G723_63:
7193                                 len += sprintf(buf + len, "G.723.1 6.3");
7194                                 break;
7195                         case G723_53:
7196                                 len += sprintf(buf + len, "G.723.1 5.3");
7197                                 break;
7198                         case TS85:
7199                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7200                                 break;
7201                         case TS48:
7202                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7203                                 break;
7204                         case TS41:
7205                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7206                                 break;
7207                         case G728:
7208                                 len += sprintf(buf + len, "G.728");
7209                                 break;
7210                         case G729:
7211                                 len += sprintf(buf + len, "G.729");
7212                                 break;
7213                         case G729B:
7214                                 len += sprintf(buf + len, "G.729B");
7215                                 break;
7216                         case ULAW:
7217                                 len += sprintf(buf + len, "uLaw");
7218                                 break;
7219                         case ALAW:
7220                                 len += sprintf(buf + len, "aLaw");
7221                                 break;
7222                         case LINEAR16:
7223                                 len += sprintf(buf + len, "16 bit Linear");
7224                                 break;
7225                         case LINEAR8:
7226                                 len += sprintf(buf + len, "8 bit Linear");
7227                                 break;
7228                         case WSS:
7229                                 len += sprintf(buf + len, "Windows Sound System");
7230                                 break;
7231                         default:
7232                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7233                                 break;
7234                         }
7235                         len += sprintf(buf + len, "\nRecord CODEC ");
7236                         switch (j->rec_codec) {
7237                         case G723_63:
7238                                 len += sprintf(buf + len, "G.723.1 6.3");
7239                                 break;
7240                         case G723_53:
7241                                 len += sprintf(buf + len, "G.723.1 5.3");
7242                                 break;
7243                         case TS85:
7244                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7245                                 break;
7246                         case TS48:
7247                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7248                                 break;
7249                         case TS41:
7250                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7251                                 break;
7252                         case G728:
7253                                 len += sprintf(buf + len, "G.728");
7254                                 break;
7255                         case G729:
7256                                 len += sprintf(buf + len, "G.729");
7257                                 break;
7258                         case G729B:
7259                                 len += sprintf(buf + len, "G.729B");
7260                                 break;
7261                         case ULAW:
7262                                 len += sprintf(buf + len, "uLaw");
7263                                 break;
7264                         case ALAW:
7265                                 len += sprintf(buf + len, "aLaw");
7266                                 break;
7267                         case LINEAR16:
7268                                 len += sprintf(buf + len, "16 bit Linear");
7269                                 break;
7270                         case LINEAR8:
7271                                 len += sprintf(buf + len, "8 bit Linear");
7272                                 break;
7273                         case WSS:
7274                                 len += sprintf(buf + len, "Windows Sound System");
7275                                 break;
7276                         default:
7277                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7278                                 break;
7279                         }
7280                         len += sprintf(buf + len, "\nAEC ");
7281                         switch (j->aec_level) {
7282                         case AEC_OFF:
7283                                 len += sprintf(buf + len, "Off");
7284                                 break;
7285                         case AEC_LOW:
7286                                 len += sprintf(buf + len, "Low");
7287                                 break;
7288                         case AEC_MED:
7289                                 len += sprintf(buf + len, "Med");
7290                                 break;
7291                         case AEC_HIGH:
7292                                 len += sprintf(buf + len, "High");
7293                                 break;
7294                         case AEC_AUTO:
7295                                 len += sprintf(buf + len, "Auto");
7296                                 break;
7297                         case AEC_AGC:
7298                                 len += sprintf(buf + len, "AEC/AGC");
7299                                 break;
7300                         default:
7301                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7302                                 break;
7303                         }
7304
7305                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7306                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7307                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7308
7309                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7310
7311                         if (j->cardtype == QTI_LINEJACK) {
7312                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7313                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7314                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7315                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7316                                 switch (j->daa_mode) {
7317                                 case SOP_PU_SLEEP:
7318                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7319                                         break;
7320                                 case SOP_PU_RINGING:
7321                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7322                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7323                                         break;
7324                                 case SOP_PU_CONVERSATION:
7325                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7326                                         break;
7327                                 case SOP_PU_PULSEDIALING:
7328                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7329                                         break;
7330                                 }
7331                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7332                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7333                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7334                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7335                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7336                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7337                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7338                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7339                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7340                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7341                         }
7342                         switch (j->port) {
7343                         case PORT_POTS:
7344                                 len += sprintf(buf + len, "\nPort POTS");
7345                                 break;
7346                         case PORT_PSTN:
7347                                 len += sprintf(buf + len, "\nPort PSTN");
7348                                 break;
7349                         case PORT_SPEAKER:
7350                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7351                                 break;
7352                         case PORT_HANDSET:
7353                                 len += sprintf(buf + len, "\nPort HANDSET");
7354                                 break;
7355                         }
7356                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7357                                 len += sprintf(buf + len, "\nSLIC state ");
7358                                 switch (SLIC_GetState(j)) {
7359                                 case PLD_SLIC_STATE_OC:
7360                                         len += sprintf(buf + len, "OC");
7361                                         break;
7362                                 case PLD_SLIC_STATE_RINGING:
7363                                         len += sprintf(buf + len, "RINGING");
7364                                         break;
7365                                 case PLD_SLIC_STATE_ACTIVE:
7366                                         len += sprintf(buf + len, "ACTIVE");
7367                                         break;
7368                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7369                                         len += sprintf(buf + len, "OHT");
7370                                         break;
7371                                 case PLD_SLIC_STATE_TIPOPEN:
7372                                         len += sprintf(buf + len, "TIPOPEN");
7373                                         break;
7374                                 case PLD_SLIC_STATE_STANDBY:
7375                                         len += sprintf(buf + len, "STANDBY");
7376                                         break;
7377                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7378                                         len += sprintf(buf + len, "APR");
7379                                         break;
7380                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7381                                         len += sprintf(buf + len, "OHTPR");
7382                                         break;
7383                                 default:
7384                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7385                                         break;
7386                                 }
7387                         }
7388                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7389                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7390 #ifdef PERFMON_STATS
7391                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7392                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7393                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7394                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7395                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7396                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7397                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7398                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7399                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7400                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7401                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7402                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7403                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7404                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7405
7406 #endif
7407                         len += sprintf(buf + len, "\n");
7408                 }
7409         }
7410         return len;
7411 }
7412
7413 static int ixj_read_proc(char *page, char **start, off_t off,
7414                               int count, int *eof, void *data)
7415 {
7416         int len = ixj_get_status_proc(page);
7417         if (len <= off+count) *eof = 1;
7418         *start = page + off;
7419         len -= off;
7420         if (len>count) len = count;
7421         if (len<0) len = 0;
7422         return len;
7423 }
7424
7425
7426 static void cleanup(void)
7427 {
7428         int cnt;
7429         IXJ *j;
7430
7431         for (cnt = 0; cnt < IXJMAX; cnt++) {
7432                 j = get_ixj(cnt);
7433                 if(j != NULL && j->DSPbase) {
7434                         if (ixjdebug & 0x0002)
7435                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7436                         del_timer(&j->timer);
7437                         if (j->cardtype == QTI_LINEJACK) {
7438                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7439
7440                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7441                                 j->pld_slicw.bits.rly1 = 0;
7442                                 j->pld_slicw.bits.rly2 = 0;
7443                                 j->pld_slicw.bits.rly3 = 0;
7444                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7445                                 LED_SetState(0x0, j);
7446                                 if (ixjdebug & 0x0002)
7447                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7448                                 release_region(j->XILINXbase, 8);
7449                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7450                                 if (ixjdebug & 0x0002)
7451                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7452                                 release_region(j->XILINXbase, 4);
7453                         }
7454                         kfree(j->read_buffer);
7455                         kfree(j->write_buffer);
7456                         if (j->dev)
7457                                 pnp_device_detach(j->dev);
7458                         if (ixjdebug & 0x0002)
7459                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7460                         phone_unregister_device(&j->p);
7461                         if (ixjdebug & 0x0002)
7462                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7463                         release_region(j->DSPbase, 16);
7464 #ifdef IXJ_DYN_ALLOC
7465                         if (ixjdebug & 0x0002)
7466                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7467                         kfree(j);
7468                         ixj[cnt] = NULL;
7469 #endif
7470                 }
7471         }
7472         if (ixjdebug & 0x0002)
7473                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7474         remove_proc_entry ("ixj", NULL);
7475 }
7476
7477 /* Typedefs */
7478 typedef struct {
7479         BYTE length;
7480         DWORD bits;
7481 } DATABLOCK;
7482
7483 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7484 {
7485         lastLCC = lastLCC & 0xfb;
7486         lastLCC = lastLCC | (byData ? 4 : 0);
7487         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7488
7489         mdelay(1);
7490         lastLCC = lastLCC | 0x01;
7491         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7492
7493         byData = byData << 1;
7494         lastLCC = lastLCC & 0xfe;
7495         mdelay(1);
7496         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7497
7498 }
7499
7500 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7501 {
7502         mdelay(1);
7503         lastLCC = lastLCC | 0x01;
7504         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7505
7506         lastLCC = lastLCC & 0xfe;
7507         mdelay(1);
7508         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7509
7510         return ((inb(wEEPROMAddress) >> 3) & 1);
7511 }
7512
7513 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7514 {
7515         BYTE lastLCC;
7516         WORD wEEPROMAddress = wAddress + 3;
7517         DWORD i;
7518         BYTE byResult;
7519         *pwResult = 0;
7520         lastLCC = inb(wEEPROMAddress);
7521         lastLCC = lastLCC | 0x02;
7522         lastLCC = lastLCC & 0xfe;
7523         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7524
7525         mdelay(1);              /* delay */
7526
7527         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7528         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7529         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7530         for (i = 0; i < 8; i++) {
7531                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7532                 wLoc <<= 1;
7533         }
7534
7535         for (i = 0; i < 16; i++) {
7536                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7537                 *pwResult = (*pwResult << 1) | byResult;
7538         }
7539
7540         mdelay(1);              /* another delay */
7541
7542         lastLCC = lastLCC & 0xfd;
7543         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7544
7545         return 0;
7546 }
7547
7548 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7549 {
7550         WORD wLo, wHi;
7551         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7552                 return 0;
7553         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7554                 return 0;
7555         return (((DWORD) wHi << 16) | wLo);
7556 }
7557
7558 static int dspio[IXJMAX + 1] =
7559 {
7560         0,
7561 };
7562 static int xio[IXJMAX + 1] =
7563 {
7564         0,
7565 };
7566
7567 module_param_array(dspio, int, NULL, 0);
7568 module_param_array(xio, int, NULL, 0);
7569 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7570 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7571 MODULE_LICENSE("GPL");
7572
7573 static void __exit ixj_exit(void)
7574 {
7575         cleanup();
7576 }
7577
7578 static IXJ *new_ixj(unsigned long port)
7579 {
7580         IXJ *res;
7581         if (!request_region(port, 16, "ixj DSP")) {
7582                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7583                 return NULL;
7584         }
7585         res = ixj_alloc();
7586         if (!res) {
7587                 release_region(port, 16);
7588                 printk(KERN_INFO "ixj: out of memory\n");
7589                 return NULL;
7590         }
7591         res->DSPbase = port;
7592         return res;
7593 }
7594
7595 static int __init ixj_probe_isapnp(int *cnt)
7596 {
7597         int probe = 0;
7598         int func = 0x110;
7599         struct pnp_dev *dev = NULL, *old_dev = NULL;
7600
7601         while (1) {
7602                 do {
7603                         IXJ *j;
7604                         int result;
7605
7606                         old_dev = dev;
7607                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7608                                          ISAPNP_FUNCTION(func), old_dev);
7609                         if (!dev || !dev->card)
7610                                 break;
7611                         result = pnp_device_attach(dev);
7612                         if (result < 0) {
7613                                 printk("pnp attach failed %d \n", result);
7614                                 break;
7615                         }
7616                         if (pnp_activate_dev(dev) < 0) {
7617                                 printk("pnp activate failed (out of resources?)\n");
7618                                 pnp_device_detach(dev);
7619                                 return -ENOMEM;
7620                         }
7621
7622                         if (!pnp_port_valid(dev, 0)) {
7623                                 pnp_device_detach(dev);
7624                                 return -ENODEV;
7625                         }
7626
7627                         j = new_ixj(pnp_port_start(dev, 0));
7628                         if (!j)
7629                                 break;
7630
7631                         if (func != 0x110)
7632                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7633
7634                         switch (func) {
7635                         case (0x110):
7636                                 j->cardtype = QTI_PHONEJACK;
7637                                 break;
7638                         case (0x310):
7639                                 j->cardtype = QTI_LINEJACK;
7640                                 break;
7641                         case (0x410):
7642                                 j->cardtype = QTI_PHONEJACK_LITE;
7643                                 break;
7644                         }
7645                         j->board = *cnt;
7646                         probe = ixj_selfprobe(j);
7647                         if(!probe) {
7648                                 j->serial = dev->card->serial;
7649                                 j->dev = dev;
7650                                 switch (func) {
7651                                 case 0x110:
7652                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7653                                         break;
7654                                 case 0x310:
7655                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7656                                         break;
7657                                 case 0x410:
7658                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7659                                         break;
7660                                 }
7661                         }
7662                         ++*cnt;
7663                 } while (dev);
7664                 if (func == 0x410)
7665                         break;
7666                 if (func == 0x310)
7667                         func = 0x410;
7668                 if (func == 0x110)
7669                         func = 0x310;
7670                 dev = NULL;
7671         }
7672         return probe;
7673 }
7674
7675 static int __init ixj_probe_isa(int *cnt)
7676 {
7677         int i, probe;
7678
7679         /* Use passed parameters for older kernels without PnP */
7680         for (i = 0; i < IXJMAX; i++) {
7681                 if (dspio[i]) {
7682                         IXJ *j = new_ixj(dspio[i]);
7683
7684                         if (!j)
7685                                 break;
7686
7687                         j->XILINXbase = xio[i];
7688                         j->cardtype = 0;
7689
7690                         j->board = *cnt;
7691                         probe = ixj_selfprobe(j);
7692                         j->dev = NULL;
7693                         ++*cnt;
7694                 }
7695         }
7696         return 0;
7697 }
7698
7699 static int __init ixj_probe_pci(int *cnt)
7700 {
7701         struct pci_dev *pci = NULL;
7702         int i, probe = 0;
7703         IXJ *j = NULL;
7704
7705         for (i = 0; i < IXJMAX - *cnt; i++) {
7706                 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7707                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
7708                 if (!pci)
7709                         break;
7710
7711                 if (pci_enable_device(pci))
7712                         break;
7713                 j = new_ixj(pci_resource_start(pci, 0));
7714                 if (!j)
7715                         break;
7716
7717                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7718                 j->XILINXbase = j->DSPbase + 0x10;
7719                 j->cardtype = QTI_PHONEJACK_PCI;
7720                 j->board = *cnt;
7721                 probe = ixj_selfprobe(j);
7722                 if (!probe)
7723                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7724                 ++*cnt;
7725         }
7726         pci_dev_put(pci);
7727         return probe;
7728 }
7729
7730 static int __init ixj_init(void)
7731 {
7732         int cnt = 0;
7733         int probe = 0;
7734
7735         cnt = 0;
7736
7737         /* These might be no-ops, see above. */
7738         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7739                 return probe;
7740         }
7741         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7742                 return probe;
7743         }
7744         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7745                 return probe;
7746         }
7747         printk(KERN_INFO "ixj driver initialized.\n");
7748         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7749         return probe;
7750 }
7751
7752 module_init(ixj_init);
7753 module_exit(ixj_exit);
7754
7755 static void DAA_Coeff_US(IXJ *j)
7756 {
7757         int i;
7758
7759         j->daa_country = DAA_US;
7760         /*----------------------------------------------- */
7761         /* CAO */
7762         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7763                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7764         }
7765
7766 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7767         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7768         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7769         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7771         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7772         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7773         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7774         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7775 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7776         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7777         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7778         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7779         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7780         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7781         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7782         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7783         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7784 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7785         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7786         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7787         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7789         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7790         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7791         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7792         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7793 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7794         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7795         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7796         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7797         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7798         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7799         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7800         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7801         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7802 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7803         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7804         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7805         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7806         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7807 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7808         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7809         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7810         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7811         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7812 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7813         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7814         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7815         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7817         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7818         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7820         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7821 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7822         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7824         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7826         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7827         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7828         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7829         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7830 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7831         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7832         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7833         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7834         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7835         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7836         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7837         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7838         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7839 /* ;  (10K, 0.68uF) */
7840         /*  */
7841         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7842         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7843         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7844         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7846         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7847         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7848         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7849         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7850         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7851         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7852         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7853         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7854         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7855         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7856         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7857         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7858         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7859
7860         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7861         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7862         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7863         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7864         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7865
7866         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7867 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7868 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7869 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7871 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7872 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7874 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7875         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7876 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7877 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7878 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7879 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7880 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7881 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7882 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7883 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7884 /* */
7885         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7886 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7887 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7888 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7889 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7890
7891         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7892         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7893         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7894         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7896         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7897         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7898         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7899         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7900 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7901         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7902         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7903         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7904         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7905         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7906         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7907         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7908         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7909 /*  */
7910         /* ;CR Registers */
7911         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7912         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7913 /* Config. Reg. 1 (dialing)       (cr1):05 */
7914         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7915 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7916         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7917 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7918         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7919 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7920         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7921         /* Config. Reg. 5 (Version)       (cr5):02 */
7922         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7923         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7924         /*  */
7925         /* ;xr Registers */
7926         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7927
7928         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7929         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7930
7931         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7932 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7933         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7934 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7935         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7936         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7937
7938         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7939 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7940         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7941 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7942         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7943 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7944         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7945         /*  */
7946         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7947         /*                                       12,33,5A,C3 ;  770 Hz   */
7948         /*                                       13,3C,5B,32 ;  852 Hz   */
7949         /*                                       1D,1B,5C,CC ;  941 Hz   */
7950
7951         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7952         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7953         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7954         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7955 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7956         /*                                       EC,1D,52,22 ;  1336 Hz   */
7957         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7958         /*                                       9B,3B,51,25 ;  1633 Hz   */
7959         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7960         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7961         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7962         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7963 }
7964
7965 static void DAA_Coeff_UK(IXJ *j)
7966 {
7967         int i;
7968
7969         j->daa_country = DAA_UK;
7970         /*----------------------------------------------- */
7971         /* CAO */
7972         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7973                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7974         }
7975
7976 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7977         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7978         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7979         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7981         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7982         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7983         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7984         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7985 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7986         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7987         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7988         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7989         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7990         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7991         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7992         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7993         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7994 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7995         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7996         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
7997         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
7999         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8000         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8001         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8002         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8003 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8004         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8005         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8006         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8007         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8008         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8009         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8010         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8011         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8012 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8013         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8014         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8015         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8016         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8017 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8018         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8019         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8020         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8021         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8022 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8023         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8024         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8025         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8027         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8028         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8030         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8031 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8032         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8034         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8036         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8037         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8038         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8039         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8040 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8041         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8042         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8043         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8044         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8045         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8046         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8047         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8048         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8049 /* ; idle */
8050         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8051         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8052         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8053         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8055         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8056         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8057         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8058         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8059 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8060         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8061         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8062         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8063         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8064         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8065         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8066         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8067         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8068 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8069         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8070         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8071         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8072         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8073 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8074         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8075         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8076         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8078         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8079         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8080         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8081         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8082 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8083         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8084         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8085         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8086         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8087         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8088         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8089         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8090         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8091 /* ;CR Registers */
8092         /* Config. Reg. 0 (filters)        (cr0):FF */
8093         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8094 /* Config. Reg. 1 (dialing)        (cr1):05 */
8095         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8096 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8097         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8098 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8099         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8100 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8101         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8102         /* Config. Reg. 5 (Version)        (cr5):02 */
8103         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8104         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8105         /* ;xr Registers */
8106         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8107
8108         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8109         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8110
8111         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8112         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8113
8114         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8115 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8116         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8117 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8118         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8119 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8120         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8121 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8122         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8123 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8124         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8125         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8126         /*                                       12,33,5A,C3    ;  770 Hz   */
8127         /*                                       13,3C,5B,32    ;  852 Hz   */
8128         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8129
8130         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8131         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8132         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8133         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8134 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8135         /*                                       EC,1D,52,22    ;  1336 Hz   */
8136         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8137         /*                                       9B,3B,51,25    ;  1633 Hz   */
8138         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8139         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8140         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8141         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8142 }
8143
8144
8145 static void DAA_Coeff_France(IXJ *j)
8146 {
8147         int i;
8148
8149         j->daa_country = DAA_FRANCE;
8150         /*----------------------------------------------- */
8151         /* CAO */
8152         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8153                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8154         }
8155
8156 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8157         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8158         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8159         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8161         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8162         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8163         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8164         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8165 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8166         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8167         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8168         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8169         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8170         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8171         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8172         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8173         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8174 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8175         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8176         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8177         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8179         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8180         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8181         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8182         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8183 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8184         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8185         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8186         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8187         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8188         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8189         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8190         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8191         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8192 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8193         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8194         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8195         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8196         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8197 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8198         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8199         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8200         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8201         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8202 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8203         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8204         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8205         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8207         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8208         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8210         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8211 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8212         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8214         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8216         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8217         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8218         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8219         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8220 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8221         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8222         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8223         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8224         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8225         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8226         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8227         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8228         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8229 /* ; idle */
8230         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8231         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8232         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8233         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8235         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8236         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8237         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8238         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8239 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8240         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8241         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8242         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8243         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8244         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8245         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8246         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8247         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8248 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8249         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8250         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8251         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8252         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8253 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8254         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8255         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8256         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8258         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8259         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8260         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8261         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8262 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8263         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8264         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8265         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8266         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8267         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8268         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8269         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8270         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8271 /* ;CR Registers */
8272         /* Config. Reg. 0 (filters)        (cr0):FF */
8273         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8274 /* Config. Reg. 1 (dialing)        (cr1):05 */
8275         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8276 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8277         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8278 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8279         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8280 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8281         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8282         /* Config. Reg. 5 (Version)        (cr5):02 */
8283         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8284         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8285         /* ;xr Registers */
8286         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8287
8288         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8289         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8290
8291         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8292         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8293
8294         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8295 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8296         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8297 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8298         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8299 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8300         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8301 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8302         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8303 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8304         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8305         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8306         /*                                       12,33,5A,C3    ;  770 Hz   */
8307         /*                                       13,3C,5B,32    ;  852 Hz   */
8308         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8309
8310         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8311         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8312         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8313         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8314 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8315         /*                                       EC,1D,52,22    ;  1336 Hz   */
8316         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8317         /*                                       9B,3B,51,25    ;  1633 Hz   */
8318         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8319         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8320         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8321         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8322 }
8323
8324
8325 static void DAA_Coeff_Germany(IXJ *j)
8326 {
8327         int i;
8328
8329         j->daa_country = DAA_GERMANY;
8330         /*----------------------------------------------- */
8331         /* CAO */
8332         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8333                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8334         }
8335
8336 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8337         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8338         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8339         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8341         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8342         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8343         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8344         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8345 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8346         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8347         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8348         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8349         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8350         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8351         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8352         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8353         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8354 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8355         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8356         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8357         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8359         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8360         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8361         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8362         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8363 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8364         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8365         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8366         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8367         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8368         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8369         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8370         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8371         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8372 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8373         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8374         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8375         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8376         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8377 /* Bytes for AR-filter        (09): 72,42,13,4B */
8378         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8379         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8380         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8381         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8382 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8383         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8384         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8385         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8387         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8388         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8390         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8391 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8392         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8394         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8396         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8397         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8398         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8399         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8400 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8401         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8402         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8403         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8404         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8405         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8406         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8407         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8408         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8409 /* ;  (10K, 0.68uF) */
8410         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8411         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8412         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8413         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8415         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8416         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8417         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8418         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8419 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8420         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8421         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8422         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8423         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8424         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8425         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8426         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8427         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8428 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8429         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8430         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8431         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8432         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8433 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8434         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8435         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8436         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8438         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8439         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8440         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8441         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8442 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8443         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8444         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8445         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8446         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8447         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8448         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8449         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8450         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8451 /* ;CR Registers */
8452         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8453         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8454 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8455         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8456 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8457         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8458 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8459         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8460 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8461         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8462         /* Config. Reg. 5 (Version)        (cr5):02 */
8463         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8464         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8465         /* ;xr Registers */
8466         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8467
8468         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8469         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8470
8471         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8472         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8473
8474         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8475 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8476         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8477 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8478         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8479 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8480         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8481 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8482         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8483 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8484         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8485         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8486         /*                                       12,33,5A,C3    ;  770 Hz   */
8487         /*                                       13,3C,5B,32    ;  852 Hz   */
8488         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8489
8490         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8491         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8492         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8493         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8494 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8495         /*                                       EC,1D,52,22    ;  1336 Hz   */
8496         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8497         /*                                       9B,3B,51,25    ;  1633 Hz   */
8498         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8499         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8500         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8501         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8502 }
8503
8504
8505 static void DAA_Coeff_Australia(IXJ *j)
8506 {
8507         int i;
8508
8509         j->daa_country = DAA_AUSTRALIA;
8510         /*----------------------------------------------- */
8511         /* CAO */
8512         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8513                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8514         }
8515
8516 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8517         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8518         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8519         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8521         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8522         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8523         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8524         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8525 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8526         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8527         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8528         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8529         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8530         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8531         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8532         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8533         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8534 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8535         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8536         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8537         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8539         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8540         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8541         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8542         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8543 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8544         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8545         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8546         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8547         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8548         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8549         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8550         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8551         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8552 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8553         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8554         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8555         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8556         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8557 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8558         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8559         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8560         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8561         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8562 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8563         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8564         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8565         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8567         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8568         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8570         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8571 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8572         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8574         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8576         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8577         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8578         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8579         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8580 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8581         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8582         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8583         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8584         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8585         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8586         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8587         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8588         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8589 /* ;  idle */
8590         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8591         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8592         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8593         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8595         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8596         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8597         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8598         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8599 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8600         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8601         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8602         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8603         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8604         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8605         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8606         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8607         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8608 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8609         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8610         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8611         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8612         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8613 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8614         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8615         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8616         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8618         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8619         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8620         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8621         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8622 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8623         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8624         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8625         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8626         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8627         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8628         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8629         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8630         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8631 /* ;CR Registers */
8632         /* Config. Reg. 0 (filters)        (cr0):FF */
8633         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8634 /* Config. Reg. 1 (dialing)        (cr1):05 */
8635         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8636 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8637         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8638 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8639         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8640 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8641         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8642         /* Config. Reg. 5 (Version)        (cr5):02 */
8643         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8644         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8645         /* ;xr Registers */
8646         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8647
8648         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8649         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8650
8651         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8652         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8653
8654         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8655 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8656         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8657 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8658         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8659 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8660         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8661 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8662         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8663 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8664         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8665
8666         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8667         /*                                       12,33,5A,C3    ;  770 Hz   */
8668         /*                                       13,3C,5B,32    ;  852 Hz   */
8669         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8670         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8671         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8672         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8673         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8674
8675         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8676         /*                                       EC,1D,52,22    ;  1336 Hz   */
8677         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8678         /*                                       9B,3B,51,25    ;  1633 Hz   */
8679         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8680         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8681         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8682         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8683 }
8684
8685 static void DAA_Coeff_Japan(IXJ *j)
8686 {
8687         int i;
8688
8689         j->daa_country = DAA_JAPAN;
8690         /*----------------------------------------------- */
8691         /* CAO */
8692         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8693                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8694         }
8695
8696 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8697         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8698         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8699         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8701         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8702         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8703         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8704         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8705 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8706         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8707         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8708         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8709         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8710         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8711         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8712         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8713         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8714 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8715         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8716         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8717         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8719         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8720         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8721         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8722         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8723 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8724         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8725         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8726         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8727         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8728         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8729         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8730         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8731         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8732 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8733         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8734         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8735         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8736         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8737 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8738         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8739         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8740         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8741         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8742 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8743         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8744         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8745         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8747         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8748         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8750         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8751 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8752         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8754         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8756         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8757         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8758         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8759         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8760 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8761         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8762         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8763         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8764         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8765         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8766         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8767         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8768         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8769 /* ;  idle */
8770         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8771         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8772         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8773         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8775         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8776         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8777         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8778         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8779 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8780         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8781         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8782         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8783         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8784         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8785         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8786         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8787         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8788 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8789         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8790         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8791         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8792         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8793 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8794         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8795         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8796         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8798         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8799         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8800         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8801         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8802 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8803         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8804         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8805         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8806         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8807         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8808         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8809         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8810         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8811 /* ;CR Registers */
8812         /* Config. Reg. 0 (filters)        (cr0):FF */
8813         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8814 /* Config. Reg. 1 (dialing)        (cr1):05 */
8815         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8816 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8817         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8818 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8819         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8820 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8821         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8822         /* Config. Reg. 5 (Version)        (cr5):02 */
8823         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8824         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8825         /* ;xr Registers */
8826         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8827
8828         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8829         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8830
8831         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8832         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8833
8834         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8835 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8836         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8837 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8838         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8839 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8840         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8841 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8842         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8843 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8844         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8845         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8846         /*                                       12,33,5A,C3    ;  770 Hz   */
8847         /*                                       13,3C,5B,32    ;  852 Hz   */
8848         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8849
8850         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8851         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8852         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8853         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8854 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8855         /*                                       EC,1D,52,22    ;  1336 Hz   */
8856         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8857         /*                                       9B,3B,51,25    ;  1633 Hz   */
8858         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8859         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8860         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8861         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8862 }
8863
8864 static s16 tone_table[][19] =
8865 {
8866         {                       /* f20_50[] 11 */
8867                 32538,          /* A1 = 1.985962 */
8868                  -32325,        /* A2 = -0.986511 */
8869                  -343,          /* B2 = -0.010493 */
8870                  0,             /* B1 = 0 */
8871                  343,           /* B0 = 0.010493 */
8872                  32619,         /* A1 = 1.990906 */
8873                  -32520,        /* A2 = -0.992462 */
8874                  19179,         /* B2 = 0.585327 */
8875                  -19178,        /* B1 = -1.170593 */
8876                  19179,         /* B0 = 0.585327 */
8877                  32723,         /* A1 = 1.997314 */
8878                  -32686,        /* A2 = -0.997528 */
8879                  9973,          /* B2 = 0.304352 */
8880                  -9955,         /* B1 = -0.607605 */
8881                  9973,          /* B0 = 0.304352 */
8882                  7,             /* Internal filter scaling */
8883                  159,           /* Minimum in-band energy threshold */
8884                  21,            /* 21/32 in-band to broad-band ratio */
8885                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8886         },
8887         {                       /* f133_200[] 12 */
8888                 32072,          /* A1 = 1.95752 */
8889                  -31896,        /* A2 = -0.973419 */
8890                  -435,          /* B2 = -0.013294 */
8891                  0,             /* B1 = 0 */
8892                  435,           /* B0 = 0.013294 */
8893                  32188,         /* A1 = 1.9646 */
8894                  -32400,        /* A2 = -0.98877 */
8895                  15139,         /* B2 = 0.462036 */
8896                  -14882,        /* B1 = -0.908356 */
8897                  15139,         /* B0 = 0.462036 */
8898                  32473,         /* A1 = 1.981995 */
8899                  -32524,        /* A2 = -0.992584 */
8900                  23200,         /* B2 = 0.708008 */
8901                  -23113,        /* B1 = -1.410706 */
8902                  23200,         /* B0 = 0.708008 */
8903                  7,             /* Internal filter scaling */
8904                  159,           /* Minimum in-band energy threshold */
8905                  21,            /* 21/32 in-band to broad-band ratio */
8906                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8907         },
8908         {                       /* f300 13 */
8909                 31769,          /* A1 = -1.939026 */
8910                  -32584,        /* A2 = 0.994385 */
8911                  -475,          /* B2 = -0.014522 */
8912                  0,             /* B1 = 0.000000 */
8913                  475,           /* B0 = 0.014522 */
8914                  31789,         /* A1 = -1.940247 */
8915                  -32679,        /* A2 = 0.997284 */
8916                  17280,         /* B2 = 0.527344 */
8917                  -16865,        /* B1 = -1.029358 */
8918                  17280,         /* B0 = 0.527344 */
8919                  31841,         /* A1 = -1.943481 */
8920                  -32681,        /* A2 = 0.997345 */
8921                  543,           /* B2 = 0.016579 */
8922                  -525,          /* B1 = -0.032097 */
8923                  543,           /* B0 = 0.016579 */
8924                  5,             /* Internal filter scaling */
8925                  159,           /* Minimum in-band energy threshold */
8926                  21,            /* 21/32 in-band to broad-band ratio */
8927                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8928         },
8929         {                       /* f300_420[] 14 */
8930                 30750,          /* A1 = 1.876892 */
8931                  -31212,        /* A2 = -0.952515 */
8932                  -804,          /* B2 = -0.024541 */
8933                  0,             /* B1 = 0 */
8934                  804,           /* B0 = 0.024541 */
8935                  30686,         /* A1 = 1.872925 */
8936                  -32145,        /* A2 = -0.980988 */
8937                  14747,         /* B2 = 0.450043 */
8938                  -13703,        /* B1 = -0.836395 */
8939                  14747,         /* B0 = 0.450043 */
8940                  31651,         /* A1 = 1.931824 */
8941                  -32321,        /* A2 = -0.986389 */
8942                  24425,         /* B2 = 0.745422 */
8943                  -23914,        /* B1 = -1.459595 */
8944                  24427,         /* B0 = 0.745483 */
8945                  7,             /* Internal filter scaling */
8946                  159,           /* Minimum in-band energy threshold */
8947                  21,            /* 21/32 in-band to broad-band ratio */
8948                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8949         },
8950         {                       /* f330 15 */
8951                 31613,          /* A1 = -1.929565 */
8952                  -32646,        /* A2 = 0.996277 */
8953                  -185,          /* B2 = -0.005657 */
8954                  0,             /* B1 = 0.000000 */
8955                  185,           /* B0 = 0.005657 */
8956                  31620,         /* A1 = -1.929932 */
8957                  -32713,        /* A2 = 0.998352 */
8958                  19253,         /* B2 = 0.587585 */
8959                  -18566,        /* B1 = -1.133179 */
8960                  19253,         /* B0 = 0.587585 */
8961                  31674,         /* A1 = -1.933228 */
8962                  -32715,        /* A2 = 0.998413 */
8963                  2575,          /* B2 = 0.078590 */
8964                  -2495,         /* B1 = -0.152283 */
8965                  2575,          /* B0 = 0.078590 */
8966                  5,             /* Internal filter scaling */
8967                  159,           /* Minimum in-band energy threshold */
8968                  21,            /* 21/32 in-band to broad-band ratio */
8969                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8970         },
8971         {                       /* f300_425[] 16 */
8972                 30741,          /* A1 = 1.876282 */
8973                  -31475,        /* A2 = -0.960541 */
8974                  -703,          /* B2 = -0.021484 */
8975                  0,             /* B1 = 0 */
8976                  703,           /* B0 = 0.021484 */
8977                  30688,         /* A1 = 1.873047 */
8978                  -32248,        /* A2 = -0.984161 */
8979                  14542,         /* B2 = 0.443787 */
8980                  -13523,        /* B1 = -0.825439 */
8981                  14542,         /* B0 = 0.443817 */
8982                  31494,         /* A1 = 1.922302 */
8983                  -32366,        /* A2 = -0.987762 */
8984                  21577,         /* B2 = 0.658508 */
8985                  -21013,        /* B1 = -1.282532 */
8986                  21577,         /* B0 = 0.658508 */
8987                  7,             /* Internal filter scaling */
8988                  159,           /* Minimum in-band energy threshold */
8989                  21,            /* 21/32 in-band to broad-band ratio */
8990                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8991         },
8992         {                       /* f330_440[] 17 */
8993                 30627,          /* A1 = 1.869324 */
8994                  -31338,        /* A2 = -0.95636 */
8995                  -843,          /* B2 = -0.025749 */
8996                  0,             /* B1 = 0 */
8997                  843,           /* B0 = 0.025749 */
8998                  30550,         /* A1 = 1.864685 */
8999                  -32221,        /* A2 = -0.983337 */
9000                  13594,         /* B2 = 0.414886 */
9001                  -12589,        /* B1 = -0.768402 */
9002                  13594,         /* B0 = 0.414886 */
9003                  31488,         /* A1 = 1.921936 */
9004                  -32358,        /* A2 = -0.987518 */
9005                  24684,         /* B2 = 0.753296 */
9006                  -24029,        /* B1 = -1.466614 */
9007                  24684,         /* B0 = 0.753296 */
9008                  7,             /* Internal filter scaling */
9009                  159,           /* Minimum in-band energy threshold */
9010                  21,            /* 21/32 in-band to broad-band ratio */
9011                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9012         },
9013         {                       /* f340 18 */
9014                 31546,          /* A1 = -1.925476 */
9015                  -32646,        /* A2 = 0.996277 */
9016                  -445,          /* B2 = -0.013588 */
9017                  0,             /* B1 = 0.000000 */
9018                  445,           /* B0 = 0.013588 */
9019                  31551,         /* A1 = -1.925781 */
9020                  -32713,        /* A2 = 0.998352 */
9021                  23884,         /* B2 = 0.728882 */
9022                  -22979,        /* B1 = -1.402527 */
9023                  23884,         /* B0 = 0.728882 */
9024                  31606,         /* A1 = -1.929138 */
9025                  -32715,        /* A2 = 0.998413 */
9026                  863,           /* B2 = 0.026367 */
9027                  -835,          /* B1 = -0.050985 */
9028                  863,           /* B0 = 0.026367 */
9029                  5,             /* Internal filter scaling */
9030                  159,           /* Minimum in-band energy threshold */
9031                  21,            /* 21/32 in-band to broad-band ratio */
9032                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9033         },
9034         {                       /* f350_400[] 19 */
9035                 31006,          /* A1 = 1.892517 */
9036                  -32029,        /* A2 = -0.977448 */
9037                  -461,          /* B2 = -0.014096 */
9038                  0,             /* B1 = 0 */
9039                  461,           /* B0 = 0.014096 */
9040                  30999,         /* A1 = 1.892029 */
9041                  -32487,        /* A2 = -0.991455 */
9042                  11325,         /* B2 = 0.345612 */
9043                  -10682,        /* B1 = -0.651978 */
9044                  11325,         /* B0 = 0.345612 */
9045                  31441,         /* A1 = 1.919067 */
9046                  -32526,        /* A2 = -0.992615 */
9047                  24324,         /* B2 = 0.74231 */
9048                  -23535,        /* B1 = -1.436523 */
9049                  24324,         /* B0 = 0.74231 */
9050                  7,             /* Internal filter scaling */
9051                  159,           /* Minimum in-band energy threshold */
9052                  21,            /* 21/32 in-band to broad-band ratio */
9053                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9054         },
9055         {                       /* f350_440[] */
9056                 30634,          /* A1 = 1.869751 */
9057                  -31533,        /* A2 = -0.962341 */
9058                  -680,          /* B2 = -0.020782 */
9059                  0,             /* B1 = 0 */
9060                  680,           /* B0 = 0.020782 */
9061                  30571,         /* A1 = 1.865906 */
9062                  -32277,        /* A2 = -0.985016 */
9063                  12894,         /* B2 = 0.393524 */
9064                  -11945,        /* B1 = -0.729065 */
9065                  12894,         /* B0 = 0.393524 */
9066                  31367,         /* A1 = 1.91449 */
9067                  -32379,        /* A2 = -0.988129 */
9068                  23820,         /* B2 = 0.726929 */
9069                  -23104,        /* B1 = -1.410217 */
9070                  23820,         /* B0 = 0.726929 */
9071                  7,             /* Internal filter scaling */
9072                  159,           /* Minimum in-band energy threshold */
9073                  21,            /* 21/32 in-band to broad-band ratio */
9074                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9075         },
9076         {                       /* f350_450[] */
9077                 30552,          /* A1 = 1.864807 */
9078                  -31434,        /* A2 = -0.95929 */
9079                  -690,          /* B2 = -0.021066 */
9080                  0,             /* B1 = 0 */
9081                  690,           /* B0 = 0.021066 */
9082                  30472,         /* A1 = 1.859924 */
9083                  -32248,        /* A2 = -0.984161 */
9084                  13385,         /* B2 = 0.408478 */
9085                  -12357,        /* B1 = -0.754242 */
9086                  13385,         /* B0 = 0.408478 */
9087                  31358,         /* A1 = 1.914001 */
9088                  -32366,        /* A2 = -0.987732 */
9089                  26488,         /* B2 = 0.80835 */
9090                  -25692,        /* B1 = -1.568176 */
9091                  26490,         /* B0 = 0.808411 */
9092                  7,             /* Internal filter scaling */
9093                  159,           /* Minimum in-band energy threshold */
9094                  21,            /* 21/32 in-band to broad-band ratio */
9095                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9096         },
9097         {                       /* f360 */
9098                 31397,          /* A1 = -1.916321 */
9099                  -32623,        /* A2 = 0.995605 */
9100                  -117,          /* B2 = -0.003598 */
9101                  0,             /* B1 = 0.000000 */
9102                  117,           /* B0 = 0.003598 */
9103                  31403,         /* A1 = -1.916687 */
9104                  -32700,        /* A2 = 0.997925 */
9105                  3388,          /* B2 = 0.103401 */
9106                  -3240,         /* B1 = -0.197784 */
9107                  3388,          /* B0 = 0.103401 */
9108                  31463,         /* A1 = -1.920410 */
9109                  -32702,        /* A2 = 0.997986 */
9110                  13346,         /* B2 = 0.407288 */
9111                  -12863,        /* B1 = -0.785126 */
9112                  13346,         /* B0 = 0.407288 */
9113                  5,             /* Internal filter scaling */
9114                  159,           /* Minimum in-band energy threshold */
9115                  21,            /* 21/32 in-band to broad-band ratio */
9116                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9117         },
9118         {                       /* f380_420[] */
9119                 30831,          /* A1 = 1.881775 */
9120                  -32064,        /* A2 = -0.978546 */
9121                  -367,          /* B2 = -0.01122 */
9122                  0,             /* B1 = 0 */
9123                  367,           /* B0 = 0.01122 */
9124                  30813,         /* A1 = 1.880737 */
9125                  -32456,        /* A2 = -0.990509 */
9126                  11068,         /* B2 = 0.337769 */
9127                  -10338,        /* B1 = -0.631042 */
9128                  11068,         /* B0 = 0.337769 */
9129                  31214,         /* A1 = 1.905212 */
9130                  -32491,        /* A2 = -0.991577 */
9131                  16374,         /* B2 = 0.499695 */
9132                  -15781,        /* B1 = -0.963196 */
9133                  16374,         /* B0 = 0.499695 */
9134                  7,             /* Internal filter scaling */
9135                  159,           /* Minimum in-band energy threshold */
9136                  21,            /* 21/32 in-band to broad-band ratio */
9137                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9138         },
9139         {                       /* f392 */
9140                 31152,          /* A1 = -1.901428 */
9141                  -32613,        /* A2 = 0.995300 */
9142                  -314,          /* B2 = -0.009605 */
9143                  0,             /* B1 = 0.000000 */
9144                  314,           /* B0 = 0.009605 */
9145                  31156,         /* A1 = -1.901672 */
9146                  -32694,        /* A2 = 0.997742 */
9147                  28847,         /* B2 = 0.880371 */
9148                  -2734,         /* B1 = -0.166901 */
9149                  28847,         /* B0 = 0.880371 */
9150                  31225,         /* A1 = -1.905823 */
9151                  -32696,        /* A2 = 0.997803 */
9152                  462,           /* B2 = 0.014108 */
9153                  -442,          /* B1 = -0.027019 */
9154                  462,           /* B0 = 0.014108 */
9155                  5,             /* Internal filter scaling */
9156                  159,           /* Minimum in-band energy threshold */
9157                  21,            /* 21/32 in-band to broad-band ratio */
9158                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9159         },
9160         {                       /* f400_425[] */
9161                 30836,          /* A1 = 1.882141 */
9162                  -32296,        /* A2 = -0.985596 */
9163                  -324,          /* B2 = -0.009903 */
9164                  0,             /* B1 = 0 */
9165                  324,           /* B0 = 0.009903 */
9166                  30825,         /* A1 = 1.881409 */
9167                  -32570,        /* A2 = -0.993958 */
9168                  16847,         /* B2 = 0.51416 */
9169                  -15792,        /* B1 = -0.963898 */
9170                  16847,         /* B0 = 0.51416 */
9171                  31106,         /* A1 = 1.89856 */
9172                  -32584,        /* A2 = -0.994415 */
9173                  9579,          /* B2 = 0.292328 */
9174                  -9164,         /* B1 = -0.559357 */
9175                  9579,          /* B0 = 0.292328 */
9176                  7,             /* Internal filter scaling */
9177                  159,           /* Minimum in-band energy threshold */
9178                  21,            /* 21/32 in-band to broad-band ratio */
9179                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9180         },
9181         {                       /* f400_440[] */
9182                 30702,          /* A1 = 1.873962 */
9183                  -32134,        /* A2 = -0.980682 */
9184                  -517,          /* B2 = -0.015793 */
9185                  0,             /* B1 = 0 */
9186                  517,           /* B0 = 0.015793 */
9187                  30676,         /* A1 = 1.872375 */
9188                  -32520,        /* A2 = -0.992462 */
9189                  8144,          /* B2 = 0.24855 */
9190                  -7596,         /* B1 = -0.463684 */
9191                  8144,          /* B0 = 0.24855 */
9192                  31084,         /* A1 = 1.897217 */
9193                  -32547,        /* A2 = -0.993256 */
9194                  22713,         /* B2 = 0.693176 */
9195                  -21734,        /* B1 = -1.326599 */
9196                  22713,         /* B0 = 0.693176 */
9197                  7,             /* Internal filter scaling */
9198                  159,           /* Minimum in-band energy threshold */
9199                  21,            /* 21/32 in-band to broad-band ratio */
9200                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9201         },
9202         {                       /* f400_450[] */
9203                 30613,          /* A1 = 1.86853 */
9204                  -32031,        /* A2 = -0.977509 */
9205                  -618,          /* B2 = -0.018866 */
9206                  0,             /* B1 = 0 */
9207                  618,           /* B0 = 0.018866 */
9208                  30577,         /* A1 = 1.866272 */
9209                  -32491,        /* A2 = -0.991577 */
9210                  9612,          /* B2 = 0.293335 */
9211                  -8935,         /* B1 = -0.54541 */
9212                  9612,          /* B0 = 0.293335 */
9213                  31071,         /* A1 = 1.896484 */
9214                  -32524,        /* A2 = -0.992584 */
9215                  21596,         /* B2 = 0.659058 */
9216                  -20667,        /* B1 = -1.261414 */
9217                  21596,         /* B0 = 0.659058 */
9218                  7,             /* Internal filter scaling */
9219                  159,           /* Minimum in-band energy threshold */
9220                  21,            /* 21/32 in-band to broad-band ratio */
9221                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9222         },
9223         {                       /* f420 */
9224                 30914,          /* A1 = -1.886841 */
9225                  -32584,        /* A2 = 0.994385 */
9226                  -426,          /* B2 = -0.013020 */
9227                  0,             /* B1 = 0.000000 */
9228                  426,           /* B0 = 0.013020 */
9229                  30914,         /* A1 = -1.886841 */
9230                  -32679,        /* A2 = 0.997314 */
9231                  17520,         /* B2 = 0.534668 */
9232                  -16471,        /* B1 = -1.005310 */
9233                  17520,         /* B0 = 0.534668 */
9234                  31004,         /* A1 = -1.892334 */
9235                  -32683,        /* A2 = 0.997406 */
9236                  819,           /* B2 = 0.025023 */
9237                  -780,          /* B1 = -0.047619 */
9238                  819,           /* B0 = 0.025023 */
9239                  5,             /* Internal filter scaling */
9240                  159,           /* Minimum in-band energy threshold */
9241                  21,            /* 21/32 in-band to broad-band ratio */
9242                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9243         },
9244 #if 0
9245         {                       /* f425 */
9246                 30881,          /* A1 = -1.884827 */
9247                  -32603,        /* A2 = 0.994965 */
9248                  -496,          /* B2 = -0.015144 */
9249                  0,             /* B1 = 0.000000 */
9250                  496,           /* B0 = 0.015144 */
9251                  30880,         /* A1 = -1.884766 */
9252                  -32692,        /* A2 = 0.997711 */
9253                  24767,         /* B2 = 0.755859 */
9254                  -23290,        /* B1 = -1.421509 */
9255                  24767,         /* B0 = 0.755859 */
9256                  30967,         /* A1 = -1.890076 */
9257                  -32694,        /* A2 = 0.997772 */
9258                  728,           /* B2 = 0.022232 */
9259                  -691,          /* B1 = -0.042194 */
9260                  728,           /* B0 = 0.022232 */
9261                  5,             /* Internal filter scaling */
9262                  159,           /* Minimum in-band energy threshold */
9263                  21,            /* 21/32 in-band to broad-band ratio */
9264                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9265         },
9266 #else
9267         {
9268                 30850,
9269                 -32534,
9270                 -504,
9271                 0,
9272                 504,
9273                 30831,
9274                 -32669,
9275                 24303,
9276                 -22080,
9277                 24303,
9278                 30994,
9279                 -32673,
9280                 1905,
9281                 -1811,
9282                 1905,
9283                 5,
9284                 129,
9285                 17,
9286                 0xff5
9287         },
9288 #endif
9289         {                       /* f425_450[] */
9290                 30646,          /* A1 = 1.870544 */
9291                  -32327,        /* A2 = -0.986572 */
9292                  -287,          /* B2 = -0.008769 */
9293                  0,             /* B1 = 0 */
9294                  287,           /* B0 = 0.008769 */
9295                  30627,         /* A1 = 1.869324 */
9296                  -32607,        /* A2 = -0.995087 */
9297                  13269,         /* B2 = 0.404968 */
9298                  -12376,        /* B1 = -0.755432 */
9299                  13269,         /* B0 = 0.404968 */
9300                  30924,         /* A1 = 1.887512 */
9301                  -32619,        /* A2 = -0.995453 */
9302                  19950,         /* B2 = 0.608826 */
9303                  -18940,        /* B1 = -1.156006 */
9304                  19950,         /* B0 = 0.608826 */
9305                  7,             /* Internal filter scaling */
9306                  159,           /* Minimum in-band energy threshold */
9307                  21,            /* 21/32 in-band to broad-band ratio */
9308                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9309         },
9310         {                       /* f425_475[] */
9311                 30396,          /* A1 = 1.855225 */
9312                  -32014,        /* A2 = -0.97699 */
9313                  -395,          /* B2 = -0.012055 */
9314                  0,             /* B1 = 0 */
9315                  395,           /* B0 = 0.012055 */
9316                  30343,         /* A1 = 1.85199 */
9317                  -32482,        /* A2 = -0.991302 */
9318                  17823,         /* B2 = 0.543945 */
9319                  -16431,        /* B1 = -1.002869 */
9320                  17823,         /* B0 = 0.543945 */
9321                  30872,         /* A1 = 1.884338 */
9322                  -32516,        /* A2 = -0.99231 */
9323                  18124,         /* B2 = 0.553101 */
9324                  -17246,        /* B1 = -1.052673 */
9325                  18124,         /* B0 = 0.553101 */
9326                  7,             /* Internal filter scaling */
9327                  159,           /* Minimum in-band energy threshold */
9328                  21,            /* 21/32 in-band to broad-band ratio */
9329                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9330         },
9331         {                       /* f435 */
9332                 30796,          /* A1 = -1.879639 */
9333                  -32603,        /* A2 = 0.994965 */
9334                  -254,          /* B2 = -0.007762 */
9335                  0,             /* B1 = 0.000000 */
9336                  254,           /* B0 = 0.007762 */
9337                  30793,         /* A1 = -1.879456 */
9338                  -32692,        /* A2 = 0.997711 */
9339                  18934,         /* B2 = 0.577820 */
9340                  -17751,        /* B1 = -1.083496 */
9341                  18934,         /* B0 = 0.577820 */
9342                  30882,         /* A1 = -1.884888 */
9343                  -32694,        /* A2 = 0.997772 */
9344                  1858,          /* B2 = 0.056713 */
9345                  -1758,         /* B1 = -0.107357 */
9346                  1858,          /* B0 = 0.056713 */
9347                  5,             /* Internal filter scaling */
9348                  159,           /* Minimum in-band energy threshold */
9349                  21,            /* 21/32 in-band to broad-band ratio */
9350                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9351         },
9352         {                       /* f440_450[] */
9353                 30641,          /* A1 = 1.870239 */
9354                  -32458,        /* A2 = -0.99057 */
9355                  -155,          /* B2 = -0.004735 */
9356                  0,             /* B1 = 0 */
9357                  155,           /* B0 = 0.004735 */
9358                  30631,         /* A1 = 1.869568 */
9359                  -32630,        /* A2 = -0.995789 */
9360                  11453,         /* B2 = 0.349548 */
9361                  -10666,        /* B1 = -0.651001 */
9362                  11453,         /* B0 = 0.349548 */
9363                  30810,         /* A1 = 1.880554 */
9364                  -32634,        /* A2 = -0.995941 */
9365                  12237,         /* B2 = 0.373474 */
9366                  -11588,        /* B1 = -0.707336 */
9367                  12237,         /* B0 = 0.373474 */
9368                  7,             /* Internal filter scaling */
9369                  159,           /* Minimum in-band energy threshold */
9370                  21,            /* 21/32 in-band to broad-band ratio */
9371                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9372         },
9373         {                       /* f440_480[] */
9374                 30367,          /* A1 = 1.853455 */
9375                  -32147,        /* A2 = -0.981079 */
9376                  -495,          /* B2 = -0.015113 */
9377                  0,             /* B1 = 0 */
9378                  495,           /* B0 = 0.015113 */
9379                  30322,         /* A1 = 1.850769 */
9380                  -32543,        /* A2 = -0.993134 */
9381                  10031,         /* B2 = 0.306152 */
9382                  -9252,         /* B1 = -0.564728 */
9383                  10031,         /* B0 = 0.306152 */
9384                  30770,         /* A1 = 1.878052 */
9385                  -32563,        /* A2 = -0.993774 */
9386                  22674,         /* B2 = 0.691956 */
9387                  -21465,        /* B1 = -1.31012 */
9388                  22674,         /* B0 = 0.691956 */
9389                  7,             /* Internal filter scaling */
9390                  159,           /* Minimum in-band energy threshold */
9391                  21,            /* 21/32 in-band to broad-band ratio */
9392                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9393         },
9394         {                       /* f445 */
9395                 30709,          /* A1 = -1.874329 */
9396                  -32603,        /* A2 = 0.994965 */
9397                  -83,           /* B2 = -0.002545 */
9398                  0,             /* B1 = 0.000000 */
9399                  83,            /* B0 = 0.002545 */
9400                  30704,         /* A1 = -1.874084 */
9401                  -32692,        /* A2 = 0.997711 */
9402                  10641,         /* B2 = 0.324738 */
9403                  -9947,         /* B1 = -0.607147 */
9404                  10641,         /* B0 = 0.324738 */
9405                  30796,         /* A1 = -1.879639 */
9406                  -32694,        /* A2 = 0.997772 */
9407                  10079,         /* B2 = 0.307587 */
9408                  9513,          /* B1 = 0.580688 */
9409                  10079,         /* B0 = 0.307587 */
9410                  5,             /* Internal filter scaling */
9411                  159,           /* Minimum in-band energy threshold */
9412                  21,            /* 21/32 in-band to broad-band ratio */
9413                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9414         },
9415         {                       /* f450 */
9416                 30664,          /* A1 = -1.871643 */
9417                  -32603,        /* A2 = 0.994965 */
9418                  -164,          /* B2 = -0.005029 */
9419                  0,             /* B1 = 0.000000 */
9420                  164,           /* B0 = 0.005029 */
9421                  30661,         /* A1 = -1.871399 */
9422                  -32692,        /* A2 = 0.997711 */
9423                  15294,         /* B2 = 0.466736 */
9424                  -14275,        /* B1 = -0.871307 */
9425                  15294,         /* B0 = 0.466736 */
9426                  30751,         /* A1 = -1.876953 */
9427                  -32694,        /* A2 = 0.997772 */
9428                  3548,          /* B2 = 0.108284 */
9429                  -3344,         /* B1 = -0.204155 */
9430                  3548,          /* B0 = 0.108284 */
9431                  5,             /* Internal filter scaling */
9432                  159,           /* Minimum in-band energy threshold */
9433                  21,            /* 21/32 in-band to broad-band ratio */
9434                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9435         },
9436         {                       /* f452 */
9437                 30653,          /* A1 = -1.870911 */
9438                  -32615,        /* A2 = 0.995361 */
9439                  -209,          /* B2 = -0.006382 */
9440                  0,             /* B1 = 0.000000 */
9441                  209,           /* B0 = 0.006382 */
9442                  30647,         /* A1 = -1.870605 */
9443                  -32702,        /* A2 = 0.997986 */
9444                  18971,         /* B2 = 0.578979 */
9445                  -17716,        /* B1 = -1.081299 */
9446                  18971,         /* B0 = 0.578979 */
9447                  30738,         /* A1 = -1.876099 */
9448                  -32702,        /* A2 = 0.998016 */
9449                  2967,          /* B2 = 0.090561 */
9450                  -2793,         /* B1 = -0.170502 */
9451                  2967,          /* B0 = 0.090561 */
9452                  5,             /* Internal filter scaling */
9453                  159,           /* Minimum in-band energy threshold */
9454                  21,            /* 21/32 in-band to broad-band ratio */
9455                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9456         },
9457         {                       /* f475 */
9458                 30437,          /* A1 = -1.857727 */
9459                  -32603,        /* A2 = 0.994965 */
9460                  -264,          /* B2 = -0.008062 */
9461                  0,             /* B1 = 0.000000 */
9462                  264,           /* B0 = 0.008062 */
9463                  30430,         /* A1 = -1.857300 */
9464                  -32692,        /* A2 = 0.997711 */
9465                  21681,         /* B2 = 0.661682 */
9466                  -20082,        /* B1 = -1.225708 */
9467                  21681,         /* B0 = 0.661682 */
9468                  30526,         /* A1 = -1.863220 */
9469                  -32694,        /* A2 = 0.997742 */
9470                  1559,          /* B2 = 0.047600 */
9471                  -1459,         /* B1 = -0.089096 */
9472                  1559,          /* B0 = 0.047600 */
9473                  5,             /* Internal filter scaling */
9474                  159,           /* Minimum in-band energy threshold */
9475                  21,            /* 21/32 in-band to broad-band ratio */
9476                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9477         },
9478         {                       /* f480_620[] */
9479                 28975,          /* A1 = 1.768494 */
9480                  -30955,        /* A2 = -0.944672 */
9481                  -1026,         /* B2 = -0.03133 */
9482                  0,             /* B1 = 0 */
9483                  1026,          /* B0 = 0.03133 */
9484                  28613,         /* A1 = 1.746399 */
9485                  -32089,        /* A2 = -0.979309 */
9486                  14214,         /* B2 = 0.433807 */
9487                  -12202,        /* B1 = -0.744812 */
9488                  14214,         /* B0 = 0.433807 */
9489                  30243,         /* A1 = 1.845947 */
9490                  -32238,        /* A2 = -0.983856 */
9491                  24825,         /* B2 = 0.757629 */
9492                  -23402,        /* B1 = -1.428345 */
9493                  24825,         /* B0 = 0.757629 */
9494                  7,             /* Internal filter scaling */
9495                  159,           /* Minimum in-band energy threshold */
9496                  21,            /* 21/32 in-band to broad-band ratio */
9497                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9498         },
9499         {                       /* f494 */
9500                 30257,          /* A1 = -1.846741 */
9501                  -32605,        /* A2 = 0.995056 */
9502                  -249,          /* B2 = -0.007625 */
9503                  0,             /* B1 = 0.000000 */
9504                  249,           /* B0 = 0.007625 */
9505                  30247,         /* A1 = -1.846191 */
9506                  -32694,        /* A2 = 0.997772 */
9507                  18088,         /* B2 = 0.552002 */
9508                  -16652,        /* B1 = -1.016418 */
9509                  18088,         /* B0 = 0.552002 */
9510                  30348,         /* A1 = -1.852295 */
9511                  -32696,        /* A2 = 0.997803 */
9512                  2099,          /* B2 = 0.064064 */
9513                  -1953,         /* B1 = -0.119202 */
9514                  2099,          /* B0 = 0.064064 */
9515                  5,             /* Internal filter scaling */
9516                  159,           /* Minimum in-band energy threshold */
9517                  21,            /* 21/32 in-band to broad-band ratio */
9518                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9519         },
9520         {                       /* f500 */
9521                 30202,          /* A1 = -1.843431 */
9522                  -32624,        /* A2 = 0.995622 */
9523                  -413,          /* B2 = -0.012622 */
9524                  0,             /* B1 = 0.000000 */
9525                  413,           /* B0 = 0.012622 */
9526                  30191,         /* A1 = -1.842721 */
9527                  -32714,        /* A2 = 0.998364 */
9528                  25954,         /* B2 = 0.792057 */
9529                  -23890,        /* B1 = -1.458131 */
9530                  25954,         /* B0 = 0.792057 */
9531                  30296,         /* A1 = -1.849172 */
9532                  -32715,        /* A2 = 0.998397 */
9533                  2007,          /* B2 = 0.061264 */
9534                  -1860,         /* B1 = -0.113568 */
9535                  2007,          /* B0 = 0.061264 */
9536                  5,             /* Internal filter scaling */
9537                  159,           /* Minimum in-band energy threshold */
9538                  21,            /* 21/32 in-band to broad-band ratio */
9539                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9540         },
9541         {                       /* f520 */
9542                 30001,          /* A1 = -1.831116 */
9543                  -32613,        /* A2 = 0.995270 */
9544                  -155,          /* B2 = -0.004750 */
9545                  0,             /* B1 = 0.000000 */
9546                  155,           /* B0 = 0.004750 */
9547                  29985,         /* A1 = -1.830200 */
9548                  -32710,        /* A2 = 0.998260 */
9549                  6584,          /* B2 = 0.200928 */
9550                  -6018,         /* B1 = -0.367355 */
9551                  6584,          /* B0 = 0.200928 */
9552                  30105,         /* A1 = -1.837524 */
9553                  -32712,        /* A2 = 0.998291 */
9554                  23812,         /* B2 = 0.726685 */
9555                  -21936,        /* B1 = -1.338928 */
9556                  23812,         /* B0 = 0.726685 */
9557                  5,             /* Internal filter scaling */
9558                  159,           /* Minimum in-band energy threshold */
9559                  21,            /* 21/32 in-band to broad-band ratio */
9560                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9561         },
9562         {                       /* f523 */
9563                 29964,          /* A1 = -1.828918 */
9564                  -32601,        /* A2 = 0.994904 */
9565                  -101,          /* B2 = -0.003110 */
9566                  0,             /* B1 = 0.000000 */
9567                  101,           /* B0 = 0.003110 */
9568                  29949,         /* A1 = -1.827942 */
9569                  -32700,        /* A2 = 0.997925 */
9570                  11041,         /* B2 = 0.336975 */
9571                  -10075,        /* B1 = -0.614960 */
9572                  11041,         /* B0 = 0.336975 */
9573                  30070,         /* A1 = -1.835388 */
9574                  -32702,        /* A2 = 0.997986 */
9575                  16762,         /* B2 = 0.511536 */
9576                  -15437,        /* B1 = -0.942230 */
9577                  16762,         /* B0 = 0.511536 */
9578                  5,             /* Internal filter scaling */
9579                  159,           /* Minimum in-band energy threshold */
9580                  21,            /* 21/32 in-band to broad-band ratio */
9581                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9582         },
9583         {                       /* f525 */
9584                 29936,          /* A1 = -1.827209 */
9585                  -32584,        /* A2 = 0.994415 */
9586                  -91,           /* B2 = -0.002806 */
9587                  0,             /* B1 = 0.000000 */
9588                  91,            /* B0 = 0.002806 */
9589                  29921,         /* A1 = -1.826233 */
9590                  -32688,        /* A2 = 0.997559 */
9591                  11449,         /* B2 = 0.349396 */
9592                  -10426,        /* B1 = -0.636383 */
9593                  11449,         /* B0 = 0.349396 */
9594                  30045,         /* A1 = -1.833862 */
9595                  -32688,        /* A2 = 0.997589 */
9596                  13055,         /* B2 = 0.398407 */
9597                  -12028,        /* B1 = -0.734161 */
9598                  13055,         /* B0 = 0.398407 */
9599                  5,             /* Internal filter scaling */
9600                  159,           /* Minimum in-band energy threshold */
9601                  21,            /* 21/32 in-band to broad-band ratio */
9602                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9603         },
9604         {                       /* f540_660[] */
9605                 28499,          /* A1 = 1.739441 */
9606                  -31129,        /* A2 = -0.949982 */
9607                  -849,          /* B2 = -0.025922 */
9608                  0,             /* B1 = 0 */
9609                  849,           /* B0 = 0.025922 */
9610                  28128,         /* A1 = 1.716797 */
9611                  -32130,        /* A2 = -0.98056 */
9612                  14556,         /* B2 = 0.444214 */
9613                  -12251,        /* B1 = -0.747772 */
9614                  14556,         /* B0 = 0.444244 */
9615                  29667,         /* A1 = 1.81073 */
9616                  -32244,        /* A2 = -0.984039 */
9617                  23038,         /* B2 = 0.703064 */
9618                  -21358,        /* B1 = -1.303589 */
9619                  23040,         /* B0 = 0.703125 */
9620                  7,             /* Internal filter scaling */
9621                  159,           /* Minimum in-band energy threshold */
9622                  21,            /* 21/32 in-band to broad-band ratio */
9623                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9624         },
9625         {                       /* f587 */
9626                 29271,          /* A1 = -1.786560 */
9627                  -32599,        /* A2 = 0.994873 */
9628                  -490,          /* B2 = -0.014957 */
9629                  0,             /* B1 = 0.000000 */
9630                  490,           /* B0 = 0.014957 */
9631                  29246,         /* A1 = -1.785095 */
9632                  -32700,        /* A2 = 0.997925 */
9633                  28961,         /* B2 = 0.883850 */
9634                  -25796,        /* B1 = -1.574463 */
9635                  28961,         /* B0 = 0.883850 */
9636                  29383,         /* A1 = -1.793396 */
9637                  -32700,        /* A2 = 0.997955 */
9638                  1299,          /* B2 = 0.039650 */
9639                  -1169,         /* B1 = -0.071396 */
9640                  1299,          /* B0 = 0.039650 */
9641                  5,             /* Internal filter scaling */
9642                  159,           /* Minimum in-band energy threshold */
9643                  21,            /* 21/32 in-band to broad-band ratio */
9644                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9645         },
9646         {                       /* f590 */
9647                 29230,          /* A1 = -1.784058 */
9648                  -32584,        /* A2 = 0.994415 */
9649                  -418,          /* B2 = -0.012757 */
9650                  0,             /* B1 = 0.000000 */
9651                  418,           /* B0 = 0.012757 */
9652                  29206,         /* A1 = -1.782593 */
9653                  -32688,        /* A2 = 0.997559 */
9654                  36556,         /* B2 = 1.115601 */
9655                  -32478,        /* B1 = -1.982300 */
9656                  36556,         /* B0 = 1.115601 */
9657                  29345,         /* A1 = -1.791077 */
9658                  -32688,        /* A2 = 0.997589 */
9659                  897,           /* B2 = 0.027397 */
9660                  -808,          /* B1 = -0.049334 */
9661                  897,           /* B0 = 0.027397 */
9662                  5,             /* Internal filter scaling */
9663                  159,           /* Minimum in-band energy threshold */
9664                  21,            /* 21/32 in-band to broad-band ratio */
9665                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9666         },
9667         {                       /* f600 */
9668                 29116,          /* A1 = -1.777100 */
9669                  -32603,        /* A2 = 0.994965 */
9670                  -165,          /* B2 = -0.005039 */
9671                  0,             /* B1 = 0.000000 */
9672                  165,           /* B0 = 0.005039 */
9673                  29089,         /* A1 = -1.775452 */
9674                  -32708,        /* A2 = 0.998199 */
9675                  6963,          /* B2 = 0.212494 */
9676                  -6172,         /* B1 = -0.376770 */
9677                  6963,          /* B0 = 0.212494 */
9678                  29237,         /* A1 = -1.784485 */
9679                  -32710,        /* A2 = 0.998230 */
9680                  24197,         /* B2 = 0.738464 */
9681                  -21657,        /* B1 = -1.321899 */
9682                  24197,         /* B0 = 0.738464 */
9683                  5,             /* Internal filter scaling */
9684                  159,           /* Minimum in-band energy threshold */
9685                  21,            /* 21/32 in-band to broad-band ratio */
9686                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9687         },
9688         {                       /* f660 */
9689                 28376,          /* A1 = -1.731934 */
9690                  -32567,        /* A2 = 0.993896 */
9691                  -363,          /* B2 = -0.011102 */
9692                  0,             /* B1 = 0.000000 */
9693                  363,           /* B0 = 0.011102 */
9694                  28337,         /* A1 = -1.729614 */
9695                  -32683,        /* A2 = 0.997434 */
9696                  21766,         /* B2 = 0.664246 */
9697                  -18761,        /* B1 = -1.145081 */
9698                  21766,         /* B0 = 0.664246 */
9699                  28513,         /* A1 = -1.740356 */
9700                  -32686,        /* A2 = 0.997498 */
9701                  2509,          /* B2 = 0.076584 */
9702                  -2196,         /* B1 = -0.134041 */
9703                  2509,          /* B0 = 0.076584 */
9704                  5,             /* Internal filter scaling */
9705                  159,           /* Minimum in-band energy threshold */
9706                  21,            /* 21/32 in-band to broad-band ratio */
9707                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9708         },
9709         {                       /* f700 */
9710                 27844,          /* A1 = -1.699463 */
9711                  -32563,        /* A2 = 0.993744 */
9712                  -366,          /* B2 = -0.011187 */
9713                  0,             /* B1 = 0.000000 */
9714                  366,           /* B0 = 0.011187 */
9715                  27797,         /* A1 = -1.696655 */
9716                  -32686,        /* A2 = 0.997498 */
9717                  22748,         /* B2 = 0.694214 */
9718                  -19235,        /* B1 = -1.174072 */
9719                  22748,         /* B0 = 0.694214 */
9720                  27995,         /* A1 = -1.708740 */
9721                  -32688,        /* A2 = 0.997559 */
9722                  2964,          /* B2 = 0.090477 */
9723                  -2546,         /* B1 = -0.155449 */
9724                  2964,          /* B0 = 0.090477 */
9725                  5,             /* Internal filter scaling */
9726                  159,           /* Minimum in-band energy threshold */
9727                  21,            /* 21/32 in-band to broad-band ratio */
9728                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9729         },
9730         {                       /* f740 */
9731                 27297,          /* A1 = -1.666077 */
9732                  -32551,        /* A2 = 0.993408 */
9733                  -345,          /* B2 = -0.010540 */
9734                  0,             /* B1 = 0.000000 */
9735                  345,           /* B0 = 0.010540 */
9736                  27240,         /* A1 = -1.662598 */
9737                  -32683,        /* A2 = 0.997406 */
9738                  22560,         /* B2 = 0.688477 */
9739                  -18688,        /* B1 = -1.140625 */
9740                  22560,         /* B0 = 0.688477 */
9741                  27461,         /* A1 = -1.676147 */
9742                  -32684,        /* A2 = 0.997467 */
9743                  3541,          /* B2 = 0.108086 */
9744                  -2985,         /* B1 = -0.182220 */
9745                  3541,          /* B0 = 0.108086 */
9746                  5,             /* Internal filter scaling */
9747                  159,           /* Minimum in-band energy threshold */
9748                  21,            /* 21/32 in-band to broad-band ratio */
9749                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9750         },
9751         {                       /* f750 */
9752                 27155,          /* A1 = -1.657410 */
9753                  -32551,        /* A2 = 0.993408 */
9754                  -462,          /* B2 = -0.014117 */
9755                  0,             /* B1 = 0.000000 */
9756                  462,           /* B0 = 0.014117 */
9757                  27097,         /* A1 = -1.653870 */
9758                  -32683,        /* A2 = 0.997406 */
9759                  32495,         /* B2 = 0.991699 */
9760                  -26776,        /* B1 = -1.634338 */
9761                  32495,         /* B0 = 0.991699 */
9762                  27321,         /* A1 = -1.667542 */
9763                  -32684,        /* A2 = 0.997467 */
9764                  1835,          /* B2 = 0.056007 */
9765                  -1539,         /* B1 = -0.093948 */
9766                  1835,          /* B0 = 0.056007 */
9767                  5,             /* Internal filter scaling */
9768                  159,           /* Minimum in-band energy threshold */
9769                  21,            /* 21/32 in-band to broad-band ratio */
9770                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9771         },
9772         {                       /* f750_1450[] */
9773                 19298,          /* A1 = 1.177917 */
9774                  -24471,        /* A2 = -0.746796 */
9775                  -4152,         /* B2 = -0.126709 */
9776                  0,             /* B1 = 0 */
9777                  4152,          /* B0 = 0.126709 */
9778                  12902,         /* A1 = 0.787476 */
9779                  -29091,        /* A2 = -0.887817 */
9780                  12491,         /* B2 = 0.38121 */
9781                  -1794,         /* B1 = -0.109528 */
9782                  12494,         /* B0 = 0.381317 */
9783                  26291,         /* A1 = 1.604736 */
9784                  -30470,        /* A2 = -0.929901 */
9785                  28859,         /* B2 = 0.880737 */
9786                  -26084,        /* B1 = -1.592102 */
9787                  28861,         /* B0 = 0.880798 */
9788                  7,             /* Internal filter scaling */
9789                  159,           /* Minimum in-band energy threshold */
9790                  21,            /* 21/32 in-band to broad-band ratio */
9791                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9792         },
9793         {                       /* f770 */
9794                 26867,          /* A1 = -1.639832 */
9795                  -32551,        /* A2 = 0.993408 */
9796                  -123,          /* B2 = -0.003755 */
9797                  0,             /* B1 = 0.000000 */
9798                  123,           /* B0 = 0.003755 */
9799                  26805,         /* A1 = -1.636108 */
9800                  -32683,        /* A2 = 0.997406 */
9801                  17297,         /* B2 = 0.527863 */
9802                  -14096,        /* B1 = -0.860382 */
9803                  17297,         /* B0 = 0.527863 */
9804                  27034,         /* A1 = -1.650085 */
9805                  -32684,        /* A2 = 0.997467 */
9806                  12958,         /* B2 = 0.395477 */
9807                  -10756,        /* B1 = -0.656525 */
9808                  12958,         /* B0 = 0.395477 */
9809                  5,             /* Internal filter scaling */
9810                  159,           /* Minimum in-band energy threshold */
9811                  21,            /* 21/32 in-band to broad-band ratio */
9812                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9813         },
9814         {                       /* f800 */
9815                 26413,          /* A1 = -1.612122 */
9816                  -32547,        /* A2 = 0.993286 */
9817                  -223,          /* B2 = -0.006825 */
9818                  0,             /* B1 = 0.000000 */
9819                  223,           /* B0 = 0.006825 */
9820                  26342,         /* A1 = -1.607849 */
9821                  -32686,        /* A2 = 0.997498 */
9822                  6391,          /* B2 = 0.195053 */
9823                  -5120,         /* B1 = -0.312531 */
9824                  6391,          /* B0 = 0.195053 */
9825                  26593,         /* A1 = -1.623108 */
9826                  -32688,        /* A2 = 0.997559 */
9827                  23681,         /* B2 = 0.722717 */
9828                  -19328,        /* B1 = -1.179688 */
9829                  23681,         /* B0 = 0.722717 */
9830                  5,             /* Internal filter scaling */
9831                  159,           /* Minimum in-band energy threshold */
9832                  21,            /* 21/32 in-band to broad-band ratio */
9833                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9834         },
9835         {                       /* f816 */
9836                 26168,          /* A1 = -1.597209 */
9837                  -32528,        /* A2 = 0.992706 */
9838                  -235,          /* B2 = -0.007182 */
9839                  0,             /* B1 = 0.000000 */
9840                  235,           /* B0 = 0.007182 */
9841                  26092,         /* A1 = -1.592590 */
9842                  -32675,        /* A2 = 0.997192 */
9843                  20823,         /* B2 = 0.635498 */
9844                  -16510,        /* B1 = -1.007751 */
9845                  20823,         /* B0 = 0.635498 */
9846                  26363,         /* A1 = -1.609070 */
9847                  -32677,        /* A2 = 0.997253 */
9848                  6739,          /* B2 = 0.205688 */
9849                  -5459,         /* B1 = -0.333206 */
9850                  6739,          /* B0 = 0.205688 */
9851                  5,             /* Internal filter scaling */
9852                  159,           /* Minimum in-band energy threshold */
9853                  21,            /* 21/32 in-band to broad-band ratio */
9854                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9855         },
9856         {                       /* f850 */
9857                 25641,          /* A1 = -1.565063 */
9858                  -32536,        /* A2 = 0.992950 */
9859                  -121,          /* B2 = -0.003707 */
9860                  0,             /* B1 = 0.000000 */
9861                  121,           /* B0 = 0.003707 */
9862                  25560,         /* A1 = -1.560059 */
9863                  -32684,        /* A2 = 0.997437 */
9864                  18341,         /* B2 = 0.559753 */
9865                  -14252,        /* B1 = -0.869904 */
9866                  18341,         /* B0 = 0.559753 */
9867                  25837,         /* A1 = -1.577026 */
9868                  -32684,        /* A2 = 0.997467 */
9869                  16679,         /* B2 = 0.509003 */
9870                  -13232,        /* B1 = -0.807648 */
9871                  16679,         /* B0 = 0.509003 */
9872                  5,             /* Internal filter scaling */
9873                  159,           /* Minimum in-band energy threshold */
9874                  21,            /* 21/32 in-band to broad-band ratio */
9875                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9876         },
9877         {                       /* f857_1645[] */
9878                 16415,          /* A1 = 1.001953 */
9879                  -23669,        /* A2 = -0.722321 */
9880                  -4549,         /* B2 = -0.138847 */
9881                  0,             /* B1 = 0 */
9882                  4549,          /* B0 = 0.138847 */
9883                  8456,          /* A1 = 0.516174 */
9884                  -28996,        /* A2 = -0.884918 */
9885                  13753,         /* B2 = 0.419724 */
9886                  -12,           /* B1 = -0.000763 */
9887                  13757,         /* B0 = 0.419846 */
9888                  24632,         /* A1 = 1.503418 */
9889                  -30271,        /* A2 = -0.923828 */
9890                  29070,         /* B2 = 0.887146 */
9891                  -25265,        /* B1 = -1.542114 */
9892                  29073,         /* B0 = 0.887268 */
9893                  7,             /* Internal filter scaling */
9894                  159,           /* Minimum in-band energy threshold */
9895                  21,            /* 21/32 in-band to broad-band ratio */
9896                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9897         },
9898         {                       /* f900 */
9899                 24806,          /* A1 = -1.514099 */
9900                  -32501,        /* A2 = 0.991852 */
9901                  -326,          /* B2 = -0.009969 */
9902                  0,             /* B1 = 0.000000 */
9903                  326,           /* B0 = 0.009969 */
9904                  24709,         /* A1 = -1.508118 */
9905                  -32659,        /* A2 = 0.996674 */
9906                  20277,         /* B2 = 0.618835 */
9907                  -15182,        /* B1 = -0.926636 */
9908                  20277,         /* B0 = 0.618835 */
9909                  25022,         /* A1 = -1.527222 */
9910                  -32661,        /* A2 = 0.996735 */
9911                  4320,          /* B2 = 0.131836 */
9912                  -3331,         /* B1 = -0.203339 */
9913                  4320,          /* B0 = 0.131836 */
9914                  5,             /* Internal filter scaling */
9915                  159,           /* Minimum in-band energy threshold */
9916                  21,            /* 21/32 in-band to broad-band ratio */
9917                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9918         },
9919         {                       /* f900_1300[] */
9920                 19776,          /* A1 = 1.207092 */
9921                  -27437,        /* A2 = -0.837341 */
9922                  -2666,         /* B2 = -0.081371 */
9923                  0,             /* B1 = 0 */
9924                  2666,          /* B0 = 0.081371 */
9925                  16302,         /* A1 = 0.995026 */
9926                  -30354,        /* A2 = -0.926361 */
9927                  10389,         /* B2 = 0.317062 */
9928                  -3327,         /* B1 = -0.203064 */
9929                  10389,         /* B0 = 0.317062 */
9930                  24299,         /* A1 = 1.483154 */
9931                  -30930,        /* A2 = -0.943909 */
9932                  25016,         /* B2 = 0.763428 */
9933                  -21171,        /* B1 = -1.292236 */
9934                  25016,         /* B0 = 0.763428 */
9935                  7,             /* Internal filter scaling */
9936                  159,           /* Minimum in-band energy threshold */
9937                  21,            /* 21/32 in-band to broad-band ratio */
9938                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9939         },
9940         {                       /* f935_1215[] */
9941                 20554,          /* A1 = 1.254517 */
9942                  -28764,        /* A2 = -0.877838 */
9943                  -2048,         /* B2 = -0.062515 */
9944                  0,             /* B1 = 0 */
9945                  2048,          /* B0 = 0.062515 */
9946                  18209,         /* A1 = 1.11145 */
9947                  -30951,        /* A2 = -0.94458 */
9948                  9390,          /* B2 = 0.286575 */
9949                  -3955,         /* B1 = -0.241455 */
9950                  9390,          /* B0 = 0.286575 */
9951                  23902,         /* A1 = 1.458923 */
9952                  -31286,        /* A2 = -0.954803 */
9953                  23252,         /* B2 = 0.709595 */
9954                  -19132,        /* B1 = -1.167725 */
9955                  23252,         /* B0 = 0.709595 */
9956                  7,             /* Internal filter scaling */
9957                  159,           /* Minimum in-band energy threshold */
9958                  21,            /* 21/32 in-band to broad-band ratio */
9959                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9960         },
9961         {                       /* f941_1477[] */
9962                 17543,          /* A1 = 1.07074 */
9963                  -26220,        /* A2 = -0.800201 */
9964                  -3298,         /* B2 = -0.100647 */
9965                  0,             /* B1 = 0 */
9966                  3298,          /* B0 = 0.100647 */
9967                  12423,         /* A1 = 0.75827 */
9968                  -30036,        /* A2 = -0.916626 */
9969                  12651,         /* B2 = 0.386078 */
9970                  -2444,         /* B1 = -0.14917 */
9971                  12653,         /* B0 = 0.386154 */
9972                  23518,         /* A1 = 1.435425 */
9973                  -30745,        /* A2 = -0.938293 */
9974                  27282,         /* B2 = 0.832581 */
9975                  -22529,        /* B1 = -1.375122 */
9976                  27286,         /* B0 = 0.832703 */
9977                  7,             /* Internal filter scaling */
9978                  159,           /* Minimum in-band energy threshold */
9979                  21,            /* 21/32 in-band to broad-band ratio */
9980                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9981         },
9982         {                       /* f942 */
9983                 24104,          /* A1 = -1.471252 */
9984                  -32507,        /* A2 = 0.992065 */
9985                  -351,          /* B2 = -0.010722 */
9986                  0,             /* B1 = 0.000000 */
9987                  351,           /* B0 = 0.010722 */
9988                  23996,         /* A1 = -1.464600 */
9989                  -32671,        /* A2 = 0.997040 */
9990                  22848,         /* B2 = 0.697266 */
9991                  -16639,        /* B1 = -1.015564 */
9992                  22848,         /* B0 = 0.697266 */
9993                  24332,         /* A1 = -1.485168 */
9994                  -32673,        /* A2 = 0.997101 */
9995                  4906,          /* B2 = 0.149727 */
9996                  -3672,         /* B1 = -0.224174 */
9997                  4906,          /* B0 = 0.149727 */
9998                  5,             /* Internal filter scaling */
9999                  159,           /* Minimum in-band energy threshold */
10000                  21,            /* 21/32 in-band to broad-band ratio */
10001                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10002         },
10003         {                       /* f950 */
10004                 23967,          /* A1 = -1.462830 */
10005                  -32507,        /* A2 = 0.992065 */
10006                  -518,          /* B2 = -0.015821 */
10007                  0,             /* B1 = 0.000000 */
10008                  518,           /* B0 = 0.015821 */
10009                  23856,         /* A1 = -1.456055 */
10010                  -32671,        /* A2 = 0.997040 */
10011                  26287,         /* B2 = 0.802246 */
10012                  -19031,        /* B1 = -1.161560 */
10013                  26287,         /* B0 = 0.802246 */
10014                  24195,         /* A1 = -1.476746 */
10015                  -32673,        /* A2 = 0.997101 */
10016                  2890,          /* B2 = 0.088196 */
10017                  -2151,         /* B1 = -0.131317 */
10018                  2890,          /* B0 = 0.088196 */
10019                  5,             /* Internal filter scaling */
10020                  159,           /* Minimum in-band energy threshold */
10021                  21,            /* 21/32 in-band to broad-band ratio */
10022                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10023         },
10024         {                       /* f950_1400[] */
10025                 18294,          /* A1 = 1.116638 */
10026                  -26962,        /* A2 = -0.822845 */
10027                  -2914,         /* B2 = -0.088936 */
10028                  0,             /* B1 = 0 */
10029                  2914,          /* B0 = 0.088936 */
10030                  14119,         /* A1 = 0.861786 */
10031                  -30227,        /* A2 = -0.922455 */
10032                  11466,         /* B2 = 0.349945 */
10033                  -2833,         /* B1 = -0.172943 */
10034                  11466,         /* B0 = 0.349945 */
10035                  23431,         /* A1 = 1.430115 */
10036                  -30828,        /* A2 = -0.940796 */
10037                  25331,         /* B2 = 0.773071 */
10038                  -20911,        /* B1 = -1.276367 */
10039                  25331,         /* B0 = 0.773071 */
10040                  7,             /* Internal filter scaling */
10041                  159,           /* Minimum in-band energy threshold */
10042                  21,            /* 21/32 in-band to broad-band ratio */
10043                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10044         },
10045         {                       /* f975 */
10046                 23521,          /* A1 = -1.435608 */
10047                  -32489,        /* A2 = 0.991516 */
10048                  -193,          /* B2 = -0.005915 */
10049                  0,             /* B1 = 0.000000 */
10050                  193,           /* B0 = 0.005915 */
10051                  23404,         /* A1 = -1.428467 */
10052                  -32655,        /* A2 = 0.996582 */
10053                  17740,         /* B2 = 0.541412 */
10054                  -12567,        /* B1 = -0.767029 */
10055                  17740,         /* B0 = 0.541412 */
10056                  23753,         /* A1 = -1.449829 */
10057                  -32657,        /* A2 = 0.996613 */
10058                  9090,          /* B2 = 0.277405 */
10059                  -6662,         /* B1 = -0.406647 */
10060                  9090,          /* B0 = 0.277405 */
10061                  5,             /* Internal filter scaling */
10062                  159,           /* Minimum in-band energy threshold */
10063                  21,            /* 21/32 in-band to broad-band ratio */
10064                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10065         },
10066         {                       /* f1000 */
10067                 23071,          /* A1 = -1.408203 */
10068                  -32489,        /* A2 = 0.991516 */
10069                  -293,          /* B2 = -0.008965 */
10070                  0,             /* B1 = 0.000000 */
10071                  293,           /* B0 = 0.008965 */
10072                  22951,         /* A1 = -1.400818 */
10073                  -32655,        /* A2 = 0.996582 */
10074                  5689,          /* B2 = 0.173645 */
10075                  -3951,         /* B1 = -0.241150 */
10076                  5689,          /* B0 = 0.173645 */
10077                  23307,         /* A1 = -1.422607 */
10078                  -32657,        /* A2 = 0.996613 */
10079                  18692,         /* B2 = 0.570435 */
10080                  -13447,        /* B1 = -0.820770 */
10081                  18692,         /* B0 = 0.570435 */
10082                  5,             /* Internal filter scaling */
10083                  159,           /* Minimum in-band energy threshold */
10084                  21,            /* 21/32 in-band to broad-band ratio */
10085                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10086         },
10087         {                       /* f1020 */
10088                 22701,          /* A1 = -1.385620 */
10089                  -32474,        /* A2 = 0.991058 */
10090                  -292,          /* B2 = -0.008933 */
10091                  0,             /*163840      , B1 = 10.000000 */
10092                  292,           /* B0 = 0.008933 */
10093                  22564,         /* A1 = -1.377258 */
10094                  -32655,        /* A2 = 0.996552 */
10095                  20756,         /* B2 = 0.633423 */
10096                  -14176,        /* B1 = -0.865295 */
10097                  20756,         /* B0 = 0.633423 */
10098                  22960,         /* A1 = -1.401428 */
10099                  -32657,        /* A2 = 0.996613 */
10100                  6520,          /* B2 = 0.198990 */
10101                  -4619,         /* B1 = -0.281937 */
10102                  6520,          /* B0 = 0.198990 */
10103                  5,             /* Internal filter scaling */
10104                  159,           /* Minimum in-band energy threshold */
10105                  21,            /* 21/32 in-band to broad-band ratio */
10106                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10107         },
10108         {                       /* f1050 */
10109                 22142,          /* A1 = -1.351501 */
10110                  -32474,        /* A2 = 0.991058 */
10111                  -147,          /* B2 = -0.004493 */
10112                  0,             /* B1 = 0.000000 */
10113                  147,           /* B0 = 0.004493 */
10114                  22000,         /* A1 = -1.342834 */
10115                  -32655,        /* A2 = 0.996552 */
10116                  15379,         /* B2 = 0.469360 */
10117                  -10237,        /* B1 = -0.624847 */
10118                  15379,         /* B0 = 0.469360 */
10119                  22406,         /* A1 = -1.367554 */
10120                  -32657,        /* A2 = 0.996613 */
10121                  17491,         /* B2 = 0.533783 */
10122                  -12096,        /* B1 = -0.738312 */
10123                  17491,         /* B0 = 0.533783 */
10124                  5,             /* Internal filter scaling */
10125                  159,           /* Minimum in-band energy threshold */
10126                  21,            /* 21/32 in-band to broad-band ratio */
10127                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10128         },
10129         {                       /* f1100_1750[] */
10130                 12973,          /* A1 = 0.79184 */
10131                  -24916,        /* A2 = -0.760376 */
10132                  6655,          /* B2 = 0.203102 */
10133                  367,           /* B1 = 0.0224 */
10134                  6657,          /* B0 = 0.203171 */
10135                  5915,          /* A1 = 0.361053 */
10136                  -29560,        /* A2 = -0.90213 */
10137                  -7777,         /* B2 = -0.23735 */
10138                  0,             /* B1 = 0 */
10139                  7777,          /* B0 = 0.23735 */
10140                  20510,         /* A1 = 1.251892 */
10141                  -30260,        /* A2 = -0.923462 */
10142                  26662,         /* B2 = 0.81366 */
10143                  -20573,        /* B1 = -1.255737 */
10144                  26668,         /* B0 = 0.813843 */
10145                  7,             /* Internal filter scaling */
10146                  159,           /* Minimum in-band energy threshold */
10147                  21,            /* 21/32 in-band to broad-band ratio */
10148                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10149         },
10150         {                       /* f1140 */
10151                 20392,          /* A1 = -1.244629 */
10152                  -32460,        /* A2 = 0.990601 */
10153                  -270,          /* B2 = -0.008240 */
10154                  0,             /* B1 = 0.000000 */
10155                  270,           /* B0 = 0.008240 */
10156                  20218,         /* A1 = -1.234009 */
10157                  -32655,        /* A2 = 0.996582 */
10158                  21337,         /* B2 = 0.651154 */
10159                  -13044,        /* B1 = -0.796143 */
10160                  21337,         /* B0 = 0.651154 */
10161                  20684,         /* A1 = -1.262512 */
10162                  -32657,        /* A2 = 0.996643 */
10163                  8572,          /* B2 = 0.261612 */
10164                  -5476,         /* B1 = -0.334244 */
10165                  8572,          /* B0 = 0.261612 */
10166                  5,             /* Internal filter scaling */
10167                  159,           /* Minimum in-band energy threshold */
10168                  21,            /* 21/32 in-band to broad-band ratio */
10169                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10170         },
10171         {                       /* f1200 */
10172                 19159,          /* A1 = -1.169373 */
10173                  -32456,        /* A2 = 0.990509 */
10174                  -335,          /* B2 = -0.010252 */
10175                  0,             /* B1 = 0.000000 */
10176                  335,           /* B0 = 0.010252 */
10177                  18966,         /* A1 = -1.157593 */
10178                  -32661,        /* A2 = 0.996735 */
10179                  6802,          /* B2 = 0.207588 */
10180                  -3900,         /* B1 = -0.238098 */
10181                  6802,          /* B0 = 0.207588 */
10182                  19467,         /* A1 = -1.188232 */
10183                  -32661,        /* A2 = 0.996765 */
10184                  25035,         /* B2 = 0.764008 */
10185                  -15049,        /* B1 = -0.918579 */
10186                  25035,         /* B0 = 0.764008 */
10187                  5,             /* Internal filter scaling */
10188                  159,           /* Minimum in-band energy threshold */
10189                  21,            /* 21/32 in-band to broad-band ratio */
10190                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10191         },
10192         {                       /* f1209 */
10193                 18976,          /* A1 = -1.158264 */
10194                  -32439,        /* A2 = 0.989990 */
10195                  -183,          /* B2 = -0.005588 */
10196                  0,             /* B1 = 0.000000 */
10197                  183,           /* B0 = 0.005588 */
10198                  18774,         /* A1 = -1.145874 */
10199                  -32650,        /* A2 = 0.996429 */
10200                  15468,         /* B2 = 0.472076 */
10201                  -8768,         /* B1 = -0.535217 */
10202                  15468,         /* B0 = 0.472076 */
10203                  19300,         /* A1 = -1.177979 */
10204                  -32652,        /* A2 = 0.996490 */
10205                  19840,         /* B2 = 0.605499 */
10206                  -11842,        /* B1 = -0.722809 */
10207                  19840,         /* B0 = 0.605499 */
10208                  5,             /* Internal filter scaling */
10209                  159,           /* Minimum in-band energy threshold */
10210                  21,            /* 21/32 in-band to broad-band ratio */
10211                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10212         },
10213         {                       /* f1330 */
10214                 16357,          /* A1 = -0.998413 */
10215                  -32368,        /* A2 = 0.987793 */
10216                  -217,          /* B2 = -0.006652 */
10217                  0,             /* B1 = 0.000000 */
10218                  217,           /* B0 = 0.006652 */
10219                  16107,         /* A1 = -0.983126 */
10220                  -32601,        /* A2 = 0.994904 */
10221                  11602,         /* B2 = 0.354065 */
10222                  -5555,         /* B1 = -0.339111 */
10223                  11602,         /* B0 = 0.354065 */
10224                  16722,         /* A1 = -1.020630 */
10225                  -32603,        /* A2 = 0.994965 */
10226                  15574,         /* B2 = 0.475311 */
10227                  -8176,         /* B1 = -0.499069 */
10228                  15574,         /* B0 = 0.475311 */
10229                  5,             /* Internal filter scaling */
10230                  159,           /* Minimum in-band energy threshold */
10231                  21,            /* 21/32 in-band to broad-band ratio */
10232                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10233         },
10234         {                       /* f1336 */
10235                 16234,          /* A1 = -0.990875 */
10236                  32404,         /* A2 = -0.988922 */
10237                  -193,          /* B2 = -0.005908 */
10238                  0,             /* B1 = 0.000000 */
10239                  193,           /* B0 = 0.005908 */
10240                  15986,         /* A1 = -0.975769 */
10241                  -32632,        /* A2 = 0.995880 */
10242                  18051,         /* B2 = 0.550903 */
10243                  -8658,         /* B1 = -0.528473 */
10244                  18051,         /* B0 = 0.550903 */
10245                  16591,         /* A1 = -1.012695 */
10246                  -32634,        /* A2 = 0.995941 */
10247                  15736,         /* B2 = 0.480240 */
10248                  -8125,         /* B1 = -0.495926 */
10249                  15736,         /* B0 = 0.480240 */
10250                  5,             /* Internal filter scaling */
10251                  159,           /* Minimum in-band energy threshold */
10252                  21,            /* 21/32 in-band to broad-band ratio */
10253                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10254         },
10255         {                       /* f1366 */
10256                 15564,          /* A1 = -0.949982 */
10257                  -32404,        /* A2 = 0.988922 */
10258                  -269,          /* B2 = -0.008216 */
10259                  0,             /* B1 = 0.000000 */
10260                  269,           /* B0 = 0.008216 */
10261                  15310,         /* A1 = -0.934479 */
10262                  -32632,        /* A2 = 0.995880 */
10263                  10815,         /* B2 = 0.330063 */
10264                  -4962,         /* B1 = -0.302887 */
10265                  10815,         /* B0 = 0.330063 */
10266                  15924,         /* A1 = -0.971924 */
10267                  -32634,        /* A2 = 0.995941 */
10268                  18880,         /* B2 = 0.576172 */
10269                  -9364,         /* B1 = -0.571594 */
10270                  18880,         /* B0 = 0.576172 */
10271                  5,             /* Internal filter scaling */
10272                  159,           /* Minimum in-band energy threshold */
10273                  21,            /* 21/32 in-band to broad-band ratio */
10274                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10275         },
10276         {                       /* f1380 */
10277                 15247,          /* A1 = -0.930603 */
10278                  -32397,        /* A2 = 0.988708 */
10279                  -244,          /* B2 = -0.007451 */
10280                  0,             /* B1 = 0.000000 */
10281                  244,           /* B0 = 0.007451 */
10282                  14989,         /* A1 = -0.914886 */
10283                  -32627,        /* A2 = 0.995697 */
10284                  18961,         /* B2 = 0.578644 */
10285                  -8498,         /* B1 = -0.518707 */
10286                  18961,         /* B0 = 0.578644 */
10287                  15608,         /* A1 = -0.952667 */
10288                  -32628,        /* A2 = 0.995758 */
10289                  11145,         /* B2 = 0.340134 */
10290                  -5430,         /* B1 = -0.331467 */
10291                  11145,         /* B0 = 0.340134 */
10292                  5,             /* Internal filter scaling */
10293                  159,           /* Minimum in-band energy threshold */
10294                  21,            /* 21/32 in-band to broad-band ratio */
10295                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10296         },
10297         {                       /* f1400 */
10298                 14780,          /* A1 = -0.902130 */
10299                  -32393,        /* A2 = 0.988586 */
10300                  -396,          /* B2 = -0.012086 */
10301                  0,             /* B1 = 0.000000 */
10302                  396,           /* B0 = 0.012086 */
10303                  14510,         /* A1 = -0.885651 */
10304                  -32630,        /* A2 = 0.995819 */
10305                  6326,          /* B2 = 0.193069 */
10306                  -2747,         /* B1 = -0.167671 */
10307                  6326,          /* B0 = 0.193069 */
10308                  15154,         /* A1 = -0.924957 */
10309                  -32632,        /* A2 = 0.995850 */
10310                  23235,         /* B2 = 0.709076 */
10311                  -10983,        /* B1 = -0.670380 */
10312                  23235,         /* B0 = 0.709076 */
10313                  5,             /* Internal filter scaling */
10314                  159,           /* Minimum in-band energy threshold */
10315                  21,            /* 21/32 in-band to broad-band ratio */
10316                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10317         },
10318         {                       /* f1477 */
10319                 13005,          /* A1 = -0.793793 */
10320                  -32368,        /* A2 = 0.987823 */
10321                  -500,          /* B2 = -0.015265 */
10322                  0,             /* B1 = 0.000000 */
10323                  500,           /* B0 = 0.015265 */
10324                  12708,         /* A1 = -0.775665 */
10325                  -32615,        /* A2 = 0.995331 */
10326                  11420,         /* B2 = 0.348526 */
10327                  -4306,         /* B1 = -0.262833 */
10328                  11420,         /* B0 = 0.348526 */
10329                  13397,         /* A1 = -0.817688 */
10330                  -32615,        /* A2 = 0.995361 */
10331                  9454,          /* B2 = 0.288528 */
10332                  -3981,         /* B1 = -0.243027 */
10333                  9454,          /* B0 = 0.288528 */
10334                  5,             /* Internal filter scaling */
10335                  159,           /* Minimum in-band energy threshold */
10336                  21,            /* 21/32 in-band to broad-band ratio */
10337                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10338         },
10339         {                       /* f1600 */
10340                 10046,          /* A1 = -0.613190 */
10341                  -32331,        /* A2 = 0.986694 */
10342                  -455,          /* B2 = -0.013915 */
10343                  0,             /* B1 = 0.000000 */
10344                  455,           /* B0 = 0.013915 */
10345                  9694,          /* A1 = -0.591705 */
10346                  -32601,        /* A2 = 0.994934 */
10347                  6023,          /* B2 = 0.183815 */
10348                  -1708,         /* B1 = -0.104279 */
10349                  6023,          /* B0 = 0.183815 */
10350                  10478,         /* A1 = -0.639587 */
10351                  -32603,        /* A2 = 0.994965 */
10352                  22031,         /* B2 = 0.672333 */
10353                  -7342,         /* B1 = -0.448151 */
10354                  22031,         /* B0 = 0.672333 */
10355                  5,             /* Internal filter scaling */
10356                  159,           /* Minimum in-band energy threshold */
10357                  21,            /* 21/32 in-band to broad-band ratio */
10358                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10359         },
10360         {                       /* f1633_1638[] */
10361                 9181,           /* A1 = 0.560394 */
10362                  -32256,        /* A2 = -0.984375 */
10363                  -556,          /* B2 = -0.016975 */
10364                  0,             /* B1 = 0 */
10365                  556,           /* B0 = 0.016975 */
10366                  8757,          /* A1 = 0.534515 */
10367                  -32574,        /* A2 = -0.99408 */
10368                  8443,          /* B2 = 0.25769 */
10369                  -2135,         /* B1 = -0.130341 */
10370                  8443,          /* B0 = 0.25769 */
10371                  9691,          /* A1 = 0.591522 */
10372                  -32574,        /* A2 = -0.99411 */
10373                  15446,         /* B2 = 0.471375 */
10374                  -4809,         /* B1 = -0.293579 */
10375                  15446,         /* B0 = 0.471375 */
10376                  7,             /* Internal filter scaling */
10377                  159,           /* Minimum in-band energy threshold */
10378                  21,            /* 21/32 in-band to broad-band ratio */
10379                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10380         },
10381         {                       /* f1800 */
10382                 5076,           /* A1 = -0.309875 */
10383                  -32304,        /* A2 = 0.985840 */
10384                  -508,          /* B2 = -0.015503 */
10385                  0,             /* B1 = 0.000000 */
10386                  508,           /* B0 = 0.015503 */
10387                  4646,          /* A1 = -0.283600 */
10388                  -32605,        /* A2 = 0.995026 */
10389                  6742,          /* B2 = 0.205780 */
10390                  -878,          /* B1 = -0.053635 */
10391                  6742,          /* B0 = 0.205780 */
10392                  5552,          /* A1 = -0.338928 */
10393                  -32605,        /* A2 = 0.995056 */
10394                  23667,         /* B2 = 0.722260 */
10395                  -4297,         /* B1 = -0.262329 */
10396                  23667,         /* B0 = 0.722260 */
10397                  5,             /* Internal filter scaling */
10398                  159,           /* Minimum in-band energy threshold */
10399                  21,            /* 21/32 in-band to broad-band ratio */
10400                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10401         },
10402         {                       /* f1860 */
10403                 3569,           /* A1 = -0.217865 */
10404                  -32292,        /* A2 = 0.985504 */
10405                  -239,          /* B2 = -0.007322 */
10406                  0,             /* B1 = 0.000000 */
10407                  239,           /* B0 = 0.007322 */
10408                  3117,          /* A1 = -0.190277 */
10409                  -32603,        /* A2 = 0.994965 */
10410                  18658,         /* B2 = 0.569427 */
10411                  -1557,         /* B1 = -0.095032 */
10412                  18658,         /* B0 = 0.569427 */
10413                  4054,          /* A1 = -0.247437 */
10414                  -32603,        /* A2 = 0.994965 */
10415                  18886,         /* B2 = 0.576385 */
10416                  -2566,         /* B1 = -0.156647 */
10417                  18886,         /* B0 = 0.576385 */
10418                  5,             /* Internal filter scaling */
10419                  159,           /* Minimum in-band energy threshold */
10420                  21,            /* 21/32 in-band to broad-band ratio */
10421                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10422         },
10423 };
10424 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10425 {
10426         unsigned short cmd;
10427         int cnt, max;
10428
10429         if (jf->filter > 3) {
10430                 return -1;
10431         }
10432         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10433
10434                 return -1;
10435         if (!jf->enable) {
10436                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10437
10438                         return -1;
10439                 else
10440                         return 0;
10441         } else {
10442                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10443
10444                         return -1;
10445                 /* Select the filter (f0 - f3) to use. */
10446                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10447                         return -1;
10448         }
10449         if (jf->freq < 12 && jf->freq > 3) {
10450                 /* Select the frequency for the selected filter. */
10451                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10452                         return -1;
10453         } else if (jf->freq > 11) {
10454                 /* We need to load a programmable filter set for undefined */
10455                 /* frequencies.  So we will point the filter to a programmable set. */
10456                 /* Since there are only 4 filters and 4 programmable sets, we will */
10457                 /* just point the filter to the same number set and program it for the */
10458                 /* frequency we want. */
10459                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10460                         return -1;
10461                 if (j->ver.low != 0x12) {
10462                         cmd = 0x515B;
10463                         max = 19;
10464                 } else {
10465                         cmd = 0x515E;
10466                         max = 15;
10467                 }
10468                 if (ixj_WriteDSPCommand(cmd, j))
10469                         return -1;
10470                 for (cnt = 0; cnt < max; cnt++) {
10471                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10472                                 return -1;
10473                 }
10474         }
10475         j->filter_en[jf->filter] = jf->enable;
10476         return 0;
10477 }
10478
10479 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10480 {
10481         unsigned short cmd;
10482         int cnt, max;
10483         if (jfr->filter > 3) {
10484                 return -1;
10485         }
10486         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10487                 return -1;
10488
10489         if (!jfr->enable) {
10490                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10491                         return -1;
10492                 else
10493                         return 0;
10494         } else {
10495                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10496                         return -1;
10497                 /* Select the filter (f0 - f3) to use. */
10498                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10499                         return -1;
10500         }
10501         /* We need to load a programmable filter set for undefined */
10502         /* frequencies.  So we will point the filter to a programmable set. */
10503         /* Since there are only 4 filters and 4 programmable sets, we will */
10504         /* just point the filter to the same number set and program it for the */
10505         /* frequency we want. */
10506         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10507                 return -1;
10508         if (j->ver.low != 0x12) {
10509                 cmd = 0x515B;
10510                 max = 19;
10511         } else {
10512                 cmd = 0x515E;
10513                 max = 15;
10514         }
10515         if (ixj_WriteDSPCommand(cmd, j))
10516                 return -1;
10517         for (cnt = 0; cnt < max; cnt++) {
10518                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10519                         return -1;
10520         }
10521         j->filter_en[jfr->filter] = jfr->enable;
10522         return 0;
10523 }
10524
10525 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10526 {
10527         int freq0, freq1;
10528         unsigned short data;
10529         if (ti->freq0) {
10530                 freq0 = ti->freq0;
10531         } else {
10532                 freq0 = 0x7FFF;
10533         }
10534
10535         if (ti->freq1) {
10536                 freq1 = ti->freq1;
10537         } else {
10538                 freq1 = 0x7FFF;
10539         }
10540
10541         if(ti->tone_index > 12 && ti->tone_index < 28)
10542         {
10543                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10544                         return -1;
10545                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10546                         return -1;
10547                 data = freq0;
10548                 if (ixj_WriteDSPCommand(data, j))
10549                         return -1;
10550                 data = freq1;
10551                 if (ixj_WriteDSPCommand(data, j))
10552                         return -1;
10553         }
10554         return freq0;
10555 }
10556