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

   1 /****************************************************************************
   2  *    ixj.c
   3  *
   4  * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
   5  * including the Internet PhoneJACK, Internet PhoneJACK Lite,
   6  * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
   7  * SmartCABLE
   8  *
   9  *    (c) Copyright 1999-2001  Quicknet Technologies, Inc.
  10  *
  11  *    This program is free software; you can redistribute it and/or
  12  *    modify it under the terms of the GNU General Public License
  13  *    as published by the Free Software Foundation; either version
  14  *    2 of the License, or (at your option) any later version.
  15  *
  16  * Author:          Ed Okerson, <eokerson@quicknet.net>
  17  *
  18  * Contributors:    Greg Herlein, <gherlein@quicknet.net>
  19  *                  David W. Erhart, <derhart@quicknet.net>
  20  *                  John Sellers, <jsellers@quicknet.net>
  21  *                  Mike Preston, <mpreston@quicknet.net>
  22  *
  23  * Fixes:           David Huggins-Daines, <dhd@cepstral.com>
  24  *                  Fabio Ferrari, <fabio.ferrari@digitro.com.br>
  25  *                  Artis Kugevics, <artis@mt.lv>
  26  *                  Daniele Bellucci, <bellucda@tiscali.it>
  27  *
  28  * More information about the hardware related to this driver can be found
  29  * at our website:    http://www.quicknet.net
  30  *
  31  * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
  32  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  33  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
  34  * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  37  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  38  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  39  * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
  40  * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  41  *
  42  ***************************************************************************/
  43
  44 /*
  45  * $Log: ixj.c,v $
  46  *
  47  * Revision 4.8  2003/07/09 19:39:00  Daniele Bellucci
  48  * Audit some copy_*_user and minor cleanup.
  49  *
  50  * Revision 4.7  2001/08/13 06:19:33  craigs
  51  * Added additional changes from Alan Cox and John Anderson for
  52  * 2.2 to 2.4 cleanup and bounds checking
  53  *
  54  * Revision 4.6  2001/08/13 01:05:05  craigs
  55  * Really fixed PHONE_QUERY_CODEC problem this time
  56  *
  57  * Revision 4.5  2001/08/13 00:11:03  craigs
  58  * Fixed problem in handling of PHONE_QUERY_CODEC, thanks to Shane Anderson
  59  *
  60  * Revision 4.4  2001/08/07 07:58:12  craigs
  61  * Changed back to three digit version numbers
  62  * Added tagbuild target to allow automatic and easy tagging of versions
  63  *
  64  * Revision 4.3  2001/08/07 07:24:47  craigs
  65  * Added ixj-ver.h to allow easy configuration management of driver
  66  * Added display of version number in /prox/ixj
  67  *
  68  * Revision 4.2  2001/08/06 07:07:19  craigs
  69  * Reverted IXJCTL_DSP_TYPE and IXJCTL_DSP_VERSION files to original
  70  * behaviour of returning int rather than short *
  71  *
  72  * Revision 4.1  2001/08/05 00:17:37  craigs
  73  * More changes for correct PCMCIA installation
  74  * Start of changes for backward Linux compatibility
  75  *
  76  * Revision 4.0  2001/08/04 12:33:12  craigs
  77  * New version using GNU autoconf
  78  *
  79  * Revision 3.105  2001/07/20 23:14:32  eokerson
  80  * More work on CallerID generation when using ring cadences.
  81  *
  82  * Revision 3.104  2001/07/06 01:33:55  eokerson
  83  * Some bugfixes from Robert Vojta <vojta@ipex.cz> and a few mods to the Makefile.
  84  *
  85  * Revision 3.103  2001/07/05 19:20:16  eokerson
  86  * Updated HOWTO
  87  * Changed mic gain to 30dB on Internet LineJACK mic/speaker port.
  88  *
  89  * Revision 3.102  2001/07/03 23:51:21  eokerson
  90  * Un-mute mic on Internet LineJACK when in speakerphone mode.
  91  *
  92  * Revision 3.101  2001/07/02 19:26:56  eokerson
  93  * Removed initialiazation of ixjdebug and ixj_convert_loaded so they will go in the .bss instead of the .data
  94  *
  95  * Revision 3.100  2001/07/02 19:18:27  eokerson
  96  * Changed driver to make dynamic allocation possible.  We now pass IXJ * between functions instead of array indexes.
  97  * Fixed the way the POTS and PSTN ports interact during a PSTN call to allow local answering.
  98  * Fixed speaker mode on Internet LineJACK.
  99  *
 100  * Revision 3.99  2001/05/09 14:11:16  eokerson
 101  * Fixed kmalloc error in ixj_build_filter_cadence.  Thanks David Chan <cat@waulogy.stanford.edu>.
 102  *
 103  * Revision 3.98  2001/05/08 19:55:33  eokerson
 104  * Fixed POTS hookstate detection while it is connected to PSTN port.
 105  *
 106  * Revision 3.97  2001/05/08 00:01:04  eokerson
 107  * Fixed kernel oops when sending caller ID data.
 108  *
 109  * Revision 3.96  2001/05/04 23:09:30  eokerson
 110  * Now uses one kernel timer for each card, instead of one for the entire driver.
 111  *
 112  * Revision 3.95  2001/04/25 22:06:47  eokerson
 113  * Fixed squawking at beginning of some G.723.1 calls.
 114  *
 115  * Revision 3.94  2001/04/03 23:42:00  eokerson
 116  * Added linear volume ioctls
 117  * Added raw filter load ioctl
 118  *
 119  * Revision 3.93  2001/02/27 01:00:06  eokerson
 120  * Fixed blocking in CallerID.
 121  * Reduced size of ixj structure for smaller driver footprint.
 122  *
 123  * Revision 3.92  2001/02/20 22:02:59  eokerson
 124  * Fixed isapnp and pcmcia module compatibility for 2.4.x kernels.
 125  * Improved PSTN ring detection.
 126  * Fixed wink generation on POTS ports.
 127  *
 128  * Revision 3.91  2001/02/13 00:55:44  eokerson
 129  * Turn AEC back on after changing frame sizes.
 130  *
 131  * Revision 3.90  2001/02/12 16:42:00  eokerson
 132  * Added ALAW codec, thanks to Fabio Ferrari for the table based converters to make ALAW from ULAW.
 133  *
 134  * Revision 3.89  2001/02/12 15:41:16  eokerson
 135  * Fix from Artis Kugevics - Tone gains were not being set correctly.
 136  *
 137  * Revision 3.88  2001/02/05 23:25:42  eokerson
 138  * Fixed lockup bugs with deregister.
 139  *
 140  * Revision 3.87  2001/01/29 21:00:39  eokerson
 141  * Fix from Fabio Ferrari <fabio.ferrari@digitro.com.br> to properly handle EAGAIN and EINTR during non-blocking write.
 142  * Updated copyright date.
 143  *
 144  * Revision 3.86  2001/01/23 23:53:46  eokerson
 145  * Fixes to G.729 compatibility.
 146  *
 147  * Revision 3.85  2001/01/23 21:30:36  eokerson
 148  * Added verbage about cards supported.
 149  * Removed commands that put the card in low power mode at some times that it should not be in low power mode.
 150  *
 151  * Revision 3.84  2001/01/22 23:32:10  eokerson
 152  * Some bugfixes from David Huggins-Daines, <dhd@cepstral.com> and other cleanups.
 153  *
 154  * Revision 3.83  2001/01/19 14:51:41  eokerson
 155  * Fixed ixj_WriteDSPCommand to decrement usage counter when command fails.
 156  *
 157  * Revision 3.82  2001/01/19 00:34:49  eokerson
 158  * Added verbosity to write overlap errors.
 159  *
 160  * Revision 3.81  2001/01/18 23:56:54  eokerson
 161  * Fixed PSTN line test functions.
 162  *
 163  * Revision 3.80  2001/01/18 22:29:27  eokerson
 164  * Updated AEC/AGC values for different cards.
 165  *
 166  * Revision 3.79  2001/01/17 02:58:54  eokerson
 167  * Fixed AEC reset after Caller ID.
 168  * Fixed Codec lockup after Caller ID on Call Waiting when not using 30ms frames.
 169  *
 170  * Revision 3.78  2001/01/16 19:43:09  eokerson
 171  * Added support for Linux 2.4.x kernels.
 172  *
 173  * Revision 3.77  2001/01/09 04:00:52  eokerson
 174  * Linetest will now test the line, even if it has previously succeded.
 175  *
 176  * Revision 3.76  2001/01/08 19:27:00  eokerson
 177  * Fixed problem with standard cable on Internet PhoneCARD.
 178  *
 179  * Revision 3.75  2000/12/22 16:52:14  eokerson
 180  * Modified to allow hookstate detection on the POTS port when the PSTN port is selected.
 181  *
 182  * Revision 3.74  2000/12/08 22:41:50  eokerson
 183  * Added capability for G729B.
 184  *
 185  * Revision 3.73  2000/12/07 23:35:16  eokerson
 186  * Added capability to have different ring pattern before CallerID data.
 187  * Added hookstate checks in CallerID routines to stop FSK.
 188  *
 189  * Revision 3.72  2000/12/06 19:31:31  eokerson
 190  * Modified signal behavior to only send one signal per event.
 191  *
 192  * Revision 3.71  2000/12/06 03:23:08  eokerson
 193  * Fixed CallerID on Call Waiting.
 194  *
 195  * Revision 3.70  2000/12/04 21:29:37  eokerson
 196  * Added checking to Smart Cable gain functions.
 197  *
 198  * Revision 3.69  2000/12/04 21:05:20  eokerson
 199  * Changed ixjdebug levels.
 200  * Added ioctls to change gains in Internet Phone CARD Smart Cable.
 201  *
 202  * Revision 3.68  2000/12/04 00:17:21  craigs
 203  * Changed mixer voice gain to +6dB rather than 0dB
 204  *
 205  * Revision 3.67  2000/11/30 21:25:51  eokerson
 206  * Fixed write signal errors.
 207  *
 208  * Revision 3.66  2000/11/29 22:42:44  eokerson
 209  * Fixed PSTN ring detect problems.
 210  *
 211  * Revision 3.65  2000/11/29 07:31:55  craigs
 212  * Added new 425Hz filter co-efficients
 213  * Added card-specific DTMF prescaler initialisation
 214  *
 215  * Revision 3.64  2000/11/28 14:03:32  craigs
 216  * Changed certain mixer initialisations to be 0dB rather than 12dB
 217  * Added additional information to /proc/ixj
 218  *
 219  * Revision 3.63  2000/11/28 11:38:41  craigs
 220  * Added display of AEC modes in AUTO and AGC mode
 221  *
 222  * Revision 3.62  2000/11/28 04:05:44  eokerson
 223  * Improved PSTN ring detection routine.
 224  *
 225  * Revision 3.61  2000/11/27 21:53:12  eokerson
 226  * Fixed flash detection.
 227  *
 228  * Revision 3.60  2000/11/27 15:57:29  eokerson
 229  * More work on G.729 load routines.
 230  *
 231  * Revision 3.59  2000/11/25 21:55:12  eokerson
 232  * Fixed errors in G.729 load routine.
 233  *
 234  * Revision 3.58  2000/11/25 04:08:29  eokerson
 235  * Added board locks around G.729 and TS85 load routines.
 236  *
 237  * Revision 3.57  2000/11/24 05:35:17  craigs
 238  * Added ability to retrieve mixer values on LineJACK
 239  * Added complete initialisation of all mixer values at startup
 240  * Fixed spelling mistake
 241  *
 242  * Revision 3.56  2000/11/23 02:52:11  robertj
 243  * Added cvs change log keyword.
 244  * Fixed bug in capabilities list when using G.729 module.
 245  *
 246  */
 247
 248 #include "ixj-ver.h"
 249
 250 #define PERFMON_STATS
 251 #define IXJDEBUG 0
 252 #define MAXRINGS 5
 253
 254 #include <linux/module.h>
 255
 256 #include <linux/init.h>
 257 #include <linux/sched.h>
 258 #include <linux/kernel.h>       /* printk() */
 259 #include <linux/fs.h>           /* everything... */
 260 #include <linux/errno.h>        /* error codes */
 261 #include <linux/slab.h>
 262 #include <linux/mm.h>
 263 #include <linux/ioport.h>
 264 #include <linux/interrupt.h>
 265 #include <linux/proc_fs.h>
 266 #include <linux/poll.h>
 267 #include <linux/timer.h>
 268 #include <linux/delay.h>
 269 #include <linux/pci.h>
 270
 271 #include <asm/io.h>
 272 #include <asm/uaccess.h>
 273
 274 #include <linux/isapnp.h>
 275
 276 #include "ixj.h"
 277
 278 #define TYPE(inode) (iminor(inode) >> 4)
 279 #define NUM(inode) (iminor(inode) & 0xf)
 280
 281 static int ixjdebug;
 282 static int hertz = HZ;
 283 static int samplerate = 100;
 284
 285 module_param(ixjdebug, int, 0);
 286
 287 static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
 288         { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
 289           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 290         { }
 291 };
 292
 293 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 294
 295 /************************************************************************
 296 *
 297 * ixjdebug meanings are now bit mapped instead of level based
 298 * Values can be or'ed together to turn on multiple messages
 299 *
 300 * bit  0 (0x0001) = any failure
 301 * bit  1 (0x0002) = general messages
 302 * bit  2 (0x0004) = POTS ringing related
 303 * bit  3 (0x0008) = PSTN events
 304 * bit  4 (0x0010) = PSTN Cadence state details
 305 * bit  5 (0x0020) = Tone detection triggers
 306 * bit  6 (0x0040) = Tone detection cadence details
 307 * bit  7 (0x0080) = ioctl tracking
 308 * bit  8 (0x0100) = signal tracking
 309 * bit  9 (0x0200) = CallerID generation details
 310 *
 311 ************************************************************************/
 312
 313 #ifdef IXJ_DYN_ALLOC
 314
 315 static IXJ *ixj[IXJMAX];
 316 #define get_ixj(b)      ixj[(b)]
 317
 318 /*
 319  *      Allocate a free IXJ device
 320  */
 321
 322 static IXJ *ixj_alloc()
 323 {
 324         for(cnt=0; cnt<IXJMAX; cnt++)
 325         {
 326                 if(ixj[cnt] == NULL || !ixj[cnt]->DSPbase)
 327                 {
 328                         j = kmalloc(sizeof(IXJ), GFP_KERNEL);
 329                         if (j == NULL)
 330                                 return NULL;
 331                         ixj[cnt] = j;
 332                         return j;
 333                 }
 334         }
 335         return NULL;
 336 }
 337
 338 static void ixj_fsk_free(IXJ *j)
 339 {
 340         kfree(j->fskdata);
 341         j->fskdata = NULL;
 342 }
 343
 344 static void ixj_fsk_alloc(IXJ *j)
 345 {
 346         if(!j->fskdata) {
 347                 j->fskdata = kmalloc(8000, GFP_KERNEL);
 348                 if (!j->fskdata) {
 349                         if(ixjdebug & 0x0200) {
 350                                 printk("IXJ phone%d - allocate failed\n", j->board);
 351                         }
 352                         return;
 353                 } else {
 354                         j->fsksize = 8000;
 355                         if(ixjdebug & 0x0200) {
 356                                 printk("IXJ phone%d - allocate succeded\n", j->board);
 357                         }
 358                 }
 359         }
 360 }
 361
 362 #else
 363
 364 static IXJ ixj[IXJMAX];
 365 #define get_ixj(b)      (&ixj[(b)])
 366
 367 /*
 368  *      Allocate a free IXJ device
 369  */
 370
 371 static IXJ *ixj_alloc(void)
 372 {
 373         int cnt;
 374         for(cnt=0; cnt<IXJMAX; cnt++) {
 375                 if(!ixj[cnt].DSPbase)
 376                         return &ixj[cnt];
 377         }
 378         return NULL;
 379 }
 380
 381 static inline void ixj_fsk_free(IXJ *j) {;}
 382
 383 static inline void ixj_fsk_alloc(IXJ *j)
 384 {
 385         j->fsksize = 8000;
 386 }
 387
 388 #endif
 389
 390 #ifdef PERFMON_STATS
 391 #define ixj_perfmon(x)  ((x)++)
 392 #else
 393 #define ixj_perfmon(x)  do { } while(0)
 394 #endif
 395
 396 static int ixj_convert_loaded;
 397
 398 static int ixj_WriteDSPCommand(unsigned short, IXJ *j);
 399
 400 /************************************************************************
 401 *
 402 * These are function definitions to allow external modules to register
 403 * enhanced functionality call backs.
 404 *
 405 ************************************************************************/
 406
 407 static int Stub(IXJ * J, unsigned long arg)
 408 {
 409         return 0;
 410 }
 411
 412 static IXJ_REGFUNC ixj_PreRead = &Stub;
 413 static IXJ_REGFUNC ixj_PostRead = &Stub;
 414 static IXJ_REGFUNC ixj_PreWrite = &Stub;
 415 static IXJ_REGFUNC ixj_PostWrite = &Stub;
 416
 417 static void ixj_read_frame(IXJ *j);
 418 static void ixj_write_frame(IXJ *j);
 419 static void ixj_init_timer(IXJ *j);
 420 static void ixj_add_timer(IXJ * j);
 421 static void ixj_timeout(unsigned long ptr);
 422 static int read_filters(IXJ *j);
 423 static int LineMonitor(IXJ *j);
 424 static int ixj_fasync(int fd, struct file *, int mode);
 425 static int ixj_set_port(IXJ *j, int arg);
 426 static int ixj_set_pots(IXJ *j, int arg);
 427 static int ixj_hookstate(IXJ *j);
 428 static int ixj_record_start(IXJ *j);
 429 static void ixj_record_stop(IXJ *j);
 430 static void set_rec_volume(IXJ *j, int volume);
 431 static int get_rec_volume(IXJ *j);
 432 static int set_rec_codec(IXJ *j, int rate);
 433 static void ixj_vad(IXJ *j, int arg);
 434 static int ixj_play_start(IXJ *j);
 435 static void ixj_play_stop(IXJ *j);
 436 static int ixj_set_tone_on(unsigned short arg, IXJ *j);
 437 static int ixj_set_tone_off(unsigned short, IXJ *j);
 438 static int ixj_play_tone(IXJ *j, char tone);
 439 static void ixj_aec_start(IXJ *j, int level);
 440 static int idle(IXJ *j);
 441 static void ixj_ring_on(IXJ *j);
 442 static void ixj_ring_off(IXJ *j);
 443 static void aec_stop(IXJ *j);
 444 static void ixj_ringback(IXJ *j);
 445 static void ixj_busytone(IXJ *j);
 446 static void ixj_dialtone(IXJ *j);
 447 static void ixj_cpt_stop(IXJ *j);
 448 static char daa_int_read(IXJ *j);
 449 static char daa_CR_read(IXJ *j, int cr);
 450 static int daa_set_mode(IXJ *j, int mode);
 451 static int ixj_linetest(IXJ *j);
 452 static int ixj_daa_write(IXJ *j);
 453 static int ixj_daa_cid_read(IXJ *j);
 454 static void DAA_Coeff_US(IXJ *j);
 455 static void DAA_Coeff_UK(IXJ *j);
 456 static void DAA_Coeff_France(IXJ *j);
 457 static void DAA_Coeff_Germany(IXJ *j);
 458 static void DAA_Coeff_Australia(IXJ *j);
 459 static void DAA_Coeff_Japan(IXJ *j);
 460 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf);
 461 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr);
 462 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti);
 463 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp);
 464 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp);
 465 /* Serial Control Interface funtions */
 466 static int SCI_Control(IXJ *j, int control);
 467 static int SCI_Prepare(IXJ *j);
 468 static int SCI_WaitHighSCI(IXJ *j);
 469 static int SCI_WaitLowSCI(IXJ *j);
 470 static DWORD PCIEE_GetSerialNumber(WORD wAddress);
 471 static int ixj_PCcontrol_wait(IXJ *j);
 472 static void ixj_pre_cid(IXJ *j);
 473 static void ixj_write_cid(IXJ *j);
 474 static void ixj_write_cid_bit(IXJ *j, int bit);
 475 static int set_base_frame(IXJ *j, int size);
 476 static int set_play_codec(IXJ *j, int rate);
 477 static void set_rec_depth(IXJ *j, int depth);
 478 static int ixj_mixer(long val, IXJ *j);
 479
 480 /************************************************************************
 481 CT8020/CT8021 Host Programmers Model
 482 Host address    Function                                        Access
 483 DSPbase +
 484 0-1             Aux Software Status Register (reserved)         Read Only
 485 2-3             Software Status Register                        Read Only
 486 4-5             Aux Software Control Register (reserved)        Read Write
 487 6-7             Software Control Register                       Read Write
 488 8-9             Hardware Status Register                        Read Only
 489 A-B             Hardware Control Register                       Read Write
 490 C-D Host Transmit (Write) Data Buffer Access Port (buffer input)Write Only
 491 E-F Host Recieve (Read) Data Buffer Access Port (buffer input)  Read Only
 492 ************************************************************************/
 493
 494 static inline void ixj_read_HSR(IXJ *j)
 495 {
 496         j->hsr.bytes.low = inb_p(j->DSPbase + 8);
 497         j->hsr.bytes.high = inb_p(j->DSPbase + 9);
 498 }
 499
 500 static inline int IsControlReady(IXJ *j)
 501 {
 502         ixj_read_HSR(j);
 503         return j->hsr.bits.controlrdy ? 1 : 0;
 504 }
 505
 506 static inline int IsPCControlReady(IXJ *j)
 507 {
 508         j->pccr1.byte = inb_p(j->XILINXbase + 3);
 509         return j->pccr1.bits.crr ? 1 : 0;
 510 }
 511
 512 static inline int IsStatusReady(IXJ *j)
 513 {
 514         ixj_read_HSR(j);
 515         return j->hsr.bits.statusrdy ? 1 : 0;
 516 }
 517
 518 static inline int IsRxReady(IXJ *j)
 519 {
 520         ixj_read_HSR(j);
 521         ixj_perfmon(j->rxreadycheck);
 522         return j->hsr.bits.rxrdy ? 1 : 0;
 523 }
 524
 525 static inline int IsTxReady(IXJ *j)
 526 {
 527         ixj_read_HSR(j);
 528         ixj_perfmon(j->txreadycheck);
 529         return j->hsr.bits.txrdy ? 1 : 0;
 530 }
 531
 532 static inline void set_play_volume(IXJ *j, int volume)
 533 {
 534         if (ixjdebug & 0x0002)
 535                 printk(KERN_INFO "IXJ: /dev/phone%d Setting Play Volume to 0x%4.4x\n", j->board, volume);
 536         ixj_WriteDSPCommand(0xCF02, j);
 537         ixj_WriteDSPCommand(volume, j);
 538 }
 539
 540 static int set_play_volume_linear(IXJ *j, int volume)
 541 {
 542         int newvolume, dspplaymax;
 543
 544         if (ixjdebug & 0x0002)
 545                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Play Volume to 0x%4.4x\n", j->board, volume);
 546         if(volume > 100 || volume < 0) {
 547                 return -1;
 548         }
 549
 550         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 551         switch (j->cardtype) {
 552         case QTI_PHONEJACK:
 553                 dspplaymax = 0x380;
 554                 break;
 555         case QTI_LINEJACK:
 556                 if(j->port == PORT_PSTN) {
 557                         dspplaymax = 0x48;
 558                 } else {
 559                         dspplaymax = 0x100;
 560                 }
 561                 break;
 562         case QTI_PHONEJACK_LITE:
 563                 dspplaymax = 0x380;
 564                 break;
 565         case QTI_PHONEJACK_PCI:
 566                 dspplaymax = 0x6C;
 567                 break;
 568         case QTI_PHONECARD:
 569                 dspplaymax = 0x50;
 570                 break;
 571         default:
 572                 return -1;
 573         }
 574         newvolume = (dspplaymax * volume) / 100;
 575         set_play_volume(j, newvolume);
 576         return 0;
 577 }
 578
 579 static inline void set_play_depth(IXJ *j, int depth)
 580 {
 581         if (depth > 60)
 582                 depth = 60;
 583         if (depth < 0)
 584                 depth = 0;
 585         ixj_WriteDSPCommand(0x5280 + depth, j);
 586 }
 587
 588 static inline int get_play_volume(IXJ *j)
 589 {
 590         ixj_WriteDSPCommand(0xCF00, j);
 591         return j->ssr.high << 8 | j->ssr.low;
 592 }
 593
 594 static int get_play_volume_linear(IXJ *j)
 595 {
 596         int volume, newvolume, dspplaymax;
 597
 598         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
 599         switch (j->cardtype) {
 600         case QTI_PHONEJACK:
 601                 dspplaymax = 0x380;
 602                 break;
 603         case QTI_LINEJACK:
 604                 if(j->port == PORT_PSTN) {
 605                         dspplaymax = 0x48;
 606                 } else {
 607                         dspplaymax = 0x100;
 608                 }
 609                 break;
 610         case QTI_PHONEJACK_LITE:
 611                 dspplaymax = 0x380;
 612                 break;
 613         case QTI_PHONEJACK_PCI:
 614                 dspplaymax = 0x6C;
 615                 break;
 616         case QTI_PHONECARD:
 617                 dspplaymax = 100;
 618                 break;
 619         default:
 620                 return -1;
 621         }
 622         volume = get_play_volume(j);
 623         newvolume = (volume * 100) / dspplaymax;
 624         if(newvolume > 100)
 625                 newvolume = 100;
 626         return newvolume;
 627 }
 628
 629 static inline BYTE SLIC_GetState(IXJ *j)
 630 {
 631         if (j->cardtype == QTI_PHONECARD) {
 632                 j->pccr1.byte = 0;
 633                 j->psccr.bits.dev = 3;
 634                 j->psccr.bits.rw = 1;
 635                 outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
 636                 ixj_PCcontrol_wait(j);
 637                 j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
 638                 ixj_PCcontrol_wait(j);
 639                 if (j->pslic.bits.powerdown)
 640                         return PLD_SLIC_STATE_OC;
 641                 else if (!j->pslic.bits.ring0 && !j->pslic.bits.ring1)
 642                         return PLD_SLIC_STATE_ACTIVE;
 643                 else
 644                         return PLD_SLIC_STATE_RINGING;
 645         } else {
 646                 j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
 647         }
 648         return j->pld_slicr.bits.state;
 649 }
 650
 651 static bool SLIC_SetState(BYTE byState, IXJ *j)
 652 {
 653         bool fRetVal = false;
 654
 655         if (j->cardtype == QTI_PHONECARD) {
 656                 if (j->flags.pcmciasct) {
 657                         switch (byState) {
 658                         case PLD_SLIC_STATE_TIPOPEN:
 659                         case PLD_SLIC_STATE_OC:
 660                                 j->pslic.bits.powerdown = 1;
 661                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 662                                 fRetVal = true;
 663                                 break;
 664                         case PLD_SLIC_STATE_RINGING:
 665                                 if (j->readers || j->writers) {
 666                                         j->pslic.bits.powerdown = 0;
 667                                         j->pslic.bits.ring0 = 1;
 668                                         j->pslic.bits.ring1 = 0;
 669                                         fRetVal = true;
 670                                 }
 671                                 break;
 672                         case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 673
 674                         case PLD_SLIC_STATE_STANDBY:
 675                         case PLD_SLIC_STATE_ACTIVE:
 676                                 if (j->readers || j->writers) {
 677                                         j->pslic.bits.powerdown = 0;
 678                                 } else {
 679                                         j->pslic.bits.powerdown = 1;
 680                                 }
 681                                 j->pslic.bits.ring0 = j->pslic.bits.ring1 = 0;
 682                                 fRetVal = true;
 683                                 break;
 684                         case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 685
 686                         case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 687
 688                         default:
 689                                 fRetVal = false;
 690                                 break;
 691                         }
 692                         j->psccr.bits.dev = 3;
 693                         j->psccr.bits.rw = 0;
 694                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
 695                         ixj_PCcontrol_wait(j);
 696                 }
 697         } else {
 698                 /* Set the C1, C2, C3 & B2EN signals. */
 699                 switch (byState) {
 700                 case PLD_SLIC_STATE_OC:
 701                         j->pld_slicw.bits.c1 = 0;
 702                         j->pld_slicw.bits.c2 = 0;
 703                         j->pld_slicw.bits.c3 = 0;
 704                         j->pld_slicw.bits.b2en = 0;
 705                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 706                         fRetVal = true;
 707                         break;
 708                 case PLD_SLIC_STATE_RINGING:
 709                         j->pld_slicw.bits.c1 = 1;
 710                         j->pld_slicw.bits.c2 = 0;
 711                         j->pld_slicw.bits.c3 = 0;
 712                         j->pld_slicw.bits.b2en = 1;
 713                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 714                         fRetVal = true;
 715                         break;
 716                 case PLD_SLIC_STATE_ACTIVE:
 717                         j->pld_slicw.bits.c1 = 0;
 718                         j->pld_slicw.bits.c2 = 1;
 719                         j->pld_slicw.bits.c3 = 0;
 720                         j->pld_slicw.bits.b2en = 0;
 721                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 722                         fRetVal = true;
 723                         break;
 724                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
 725
 726                         j->pld_slicw.bits.c1 = 1;
 727                         j->pld_slicw.bits.c2 = 1;
 728                         j->pld_slicw.bits.c3 = 0;
 729                         j->pld_slicw.bits.b2en = 0;
 730                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 731                         fRetVal = true;
 732                         break;
 733                 case PLD_SLIC_STATE_TIPOPEN:
 734                         j->pld_slicw.bits.c1 = 0;
 735                         j->pld_slicw.bits.c2 = 0;
 736                         j->pld_slicw.bits.c3 = 1;
 737                         j->pld_slicw.bits.b2en = 0;
 738                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 739                         fRetVal = true;
 740                         break;
 741                 case PLD_SLIC_STATE_STANDBY:
 742                         j->pld_slicw.bits.c1 = 1;
 743                         j->pld_slicw.bits.c2 = 0;
 744                         j->pld_slicw.bits.c3 = 1;
 745                         j->pld_slicw.bits.b2en = 1;
 746                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 747                         fRetVal = true;
 748                         break;
 749                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
 750
 751                         j->pld_slicw.bits.c1 = 0;
 752                         j->pld_slicw.bits.c2 = 1;
 753                         j->pld_slicw.bits.c3 = 1;
 754                         j->pld_slicw.bits.b2en = 0;
 755                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 756                         fRetVal = true;
 757                         break;
 758                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
 759
 760                         j->pld_slicw.bits.c1 = 1;
 761                         j->pld_slicw.bits.c2 = 1;
 762                         j->pld_slicw.bits.c3 = 1;
 763                         j->pld_slicw.bits.b2en = 0;
 764                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
 765                         fRetVal = true;
 766                         break;
 767                 default:
 768                         fRetVal = false;
 769                         break;
 770                 }
 771         }
 772
 773         return fRetVal;
 774 }
 775
 776 static int ixj_wink(IXJ *j)
 777 {
 778         BYTE slicnow;
 779
 780         slicnow = SLIC_GetState(j);
 781
 782         j->pots_winkstart = jiffies;
 783         SLIC_SetState(PLD_SLIC_STATE_OC, j);
 784
 785         msleep(jiffies_to_msecs(j->winktime));
 786
 787         SLIC_SetState(slicnow, j);
 788         return 0;
 789 }
 790
 791 static void ixj_init_timer(IXJ *j)
 792 {
 793         init_timer(&j->timer);
 794         j->timer.function = ixj_timeout;
 795         j->timer.data = (unsigned long)j;
 796 }
 797
 798 static void ixj_add_timer(IXJ *j)
 799 {
 800         j->timer.expires = jiffies + (hertz / samplerate);
 801         add_timer(&j->timer);
 802 }
 803
 804 static void ixj_tone_timeout(IXJ *j)
 805 {
 806         IXJ_TONE ti;
 807
 808         j->tone_state++;
 809         if (j->tone_state == 3) {
 810                 j->tone_state = 0;
 811                 if (j->cadence_t) {
 812                         j->tone_cadence_state++;
 813                         if (j->tone_cadence_state >= j->cadence_t->elements_used) {
 814                                 switch (j->cadence_t->termination) {
 815                                 case PLAY_ONCE:
 816                                         ixj_cpt_stop(j);
 817                                         break;
 818                                 case REPEAT_LAST_ELEMENT:
 819                                         j->tone_cadence_state--;
 820                                         ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 821                                         break;
 822                                 case REPEAT_ALL:
 823                                         j->tone_cadence_state = 0;
 824                                         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
 825                                                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 826                                                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 827                                                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 828                                                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 829                                                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 830                                                 ixj_init_tone(j, &ti);
 831                                         }
 832                                         ixj_set_tone_on(j->cadence_t->ce[0].tone_on_time, j);
 833                                         ixj_set_tone_off(j->cadence_t->ce[0].tone_off_time, j);
 834                                         ixj_play_tone(j, j->cadence_t->ce[0].index);
 835                                         break;
 836                                 }
 837                         } else {
 838                                 if (j->cadence_t->ce[j->tone_cadence_state].gain0) {
 839                                         ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
 840                                         ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
 841                                         ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
 842                                         ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
 843                                         ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
 844                                         ixj_init_tone(j, &ti);
 845                                 }
 846                                 ixj_set_tone_on(j->cadence_t->ce[j->tone_cadence_state].tone_on_time, j);
 847                                 ixj_set_tone_off(j->cadence_t->ce[j->tone_cadence_state].tone_off_time, j);
 848                                 ixj_play_tone(j, j->cadence_t->ce[j->tone_cadence_state].index);
 849                         }
 850                 }
 851         }
 852 }
 853
 854 static inline void ixj_kill_fasync(IXJ *j, IXJ_SIGEVENT event, int dir)
 855 {
 856         if(j->ixj_signals[event]) {
 857                 if(ixjdebug & 0x0100)
 858                         printk("Sending signal for event %d\n", event);
 859                         /* Send apps notice of change */
 860                 /* see config.h for macro definition */
 861                 kill_fasync(&(j->async_queue), j->ixj_signals[event], dir);
 862         }
 863 }
 864
 865 static void ixj_pstn_state(IXJ *j)
 866 {
 867         int var;
 868         union XOPXR0 XR0, daaint;
 869
 870         var = 10;
 871
 872         XR0.reg = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg;
 873         daaint.reg = 0;
 874         XR0.bitreg.RMR = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 875
 876         j->pld_scrr.byte = inb_p(j->XILINXbase);
 877         if (j->pld_scrr.bits.daaflag) {
 878                 daa_int_read(j);
 879                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.RING) {
 880                         if(time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 881                                 daaint.bitreg.RING = 1;
 882                                 if(ixjdebug & 0x0008) {
 883                                         printk(KERN_INFO "IXJ DAA Ring Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 884                                 }
 885                         } else {
 886                                 daa_set_mode(j, SOP_PU_RESET);
 887                         }
 888                 }
 889                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Caller_ID) {
 890                         daaint.bitreg.Caller_ID = 1;
 891                         j->pstn_cid_intr = 1;
 892                         j->pstn_cid_received = jiffies;
 893                         if(ixjdebug & 0x0008) {
 894                                 printk(KERN_INFO "IXJ DAA Caller_ID Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 895                         }
 896                 }
 897                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.Cadence) {
 898                         daaint.bitreg.Cadence = 1;
 899                         if(ixjdebug & 0x0008) {
 900                                 printk(KERN_INFO "IXJ DAA Cadence Interrupt /dev/phone%d at %ld\n", j->board, jiffies);
 901                         }
 902                 }
 903                 if(j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK != XR0.bitreg.VDD_OK) {
 904                         daaint.bitreg.VDD_OK = 1;
 905                         daaint.bitreg.SI_0 = j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK;
 906                 }
 907         }
 908         daa_CR_read(j, 1);
 909         if(j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR != XR0.bitreg.RMR && time_after(jiffies, j->pstn_sleeptil) && !(j->flags.pots_pstn && j->hookstate)) {
 910                 daaint.bitreg.RMR = 1;
 911                 daaint.bitreg.SI_1 = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR;
 912                 if(ixjdebug & 0x0008) {
 913                         printk(KERN_INFO "IXJ DAA RMR /dev/phone%d was %s for %ld\n", j->board, XR0.bitreg.RMR?"on":"off", jiffies - j->pstn_last_rmr);
 914                 }
 915                 j->pstn_prev_rmr = j->pstn_last_rmr;
 916                 j->pstn_last_rmr = jiffies;
 917         }
 918         switch(j->daa_mode) {
 919                 case SOP_PU_SLEEP:
 920                         if (daaint.bitreg.RING) {
 921                                 if (!j->flags.pstn_ringing) {
 922                                         if (j->daa_mode != SOP_PU_RINGING) {
 923                                                 j->pstn_ring_int = jiffies;
 924                                                 daa_set_mode(j, SOP_PU_RINGING);
 925                                         }
 926                                 }
 927                         }
 928                         break;
 929                 case SOP_PU_RINGING:
 930                         if (daaint.bitreg.RMR) {
 931                                 if (ixjdebug & 0x0008) {
 932                                         printk(KERN_INFO "IXJ Ring Cadence a state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
 933                                 }
 934                                 if (daaint.bitreg.SI_1) {                /* Rising edge of RMR */
 935                                         j->flags.pstn_rmr = 1;
 936                                         j->pstn_ring_start = jiffies;
 937                                         j->pstn_ring_stop = 0;
 938                                         j->ex.bits.pstn_ring = 0;
 939                                         if (j->cadence_f[4].state == 0) {
 940                                                 j->cadence_f[4].state = 1;
 941                                                 j->cadence_f[4].on1min = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 - var)) / 10000);
 942                                                 j->cadence_f[4].on1dot = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100)) / 10000);
 943                                                 j->cadence_f[4].on1max = jiffies + (long)((j->cadence_f[4].on1 * hertz * (100 + var)) / 10000);
 944                                         } else if (j->cadence_f[4].state == 2) {
 945                                                 if((time_after(jiffies, j->cadence_f[4].off1min) &&
 946                                                     time_before(jiffies, j->cadence_f[4].off1max))) {
 947                                                         if (j->cadence_f[4].on2) {
 948                                                                 j->cadence_f[4].state = 3;
 949                                                                 j->cadence_f[4].on2min = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 - var)) / 10000));
 950                                                                 j->cadence_f[4].on2dot = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100)) / 10000));
 951                                                                 j->cadence_f[4].on2max = jiffies + (long)((j->cadence_f[4].on2 * (hertz * (100 + var)) / 10000));
 952                                                         } else {
 953                                                                 j->cadence_f[4].state = 7;
 954                                                         }
 955                                                 } else {
 956                                                         if (ixjdebug & 0x0008) {
 957                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 958                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 959                                                                                 j->cadence_f[4].off1);
 960                                                         }
 961                                                         j->cadence_f[4].state = 0;
 962                                                 }
 963                                         } else if (j->cadence_f[4].state == 4) {
 964                                                 if((time_after(jiffies, j->cadence_f[4].off2min) &&
 965                                                     time_before(jiffies, j->cadence_f[4].off2max))) {
 966                                                         if (j->cadence_f[4].on3) {
 967                                                                 j->cadence_f[4].state = 5;
 968                                                                 j->cadence_f[4].on3min = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 - var)) / 10000));
 969                                                                 j->cadence_f[4].on3dot = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100)) / 10000));
 970                                                                 j->cadence_f[4].on3max = jiffies + (long)((j->cadence_f[4].on3 * (hertz * (100 + var)) / 10000));
 971                                                         } else {
 972                                                                 j->cadence_f[4].state = 7;
 973                                                         }
 974                                                 } else {
 975                                                         if (ixjdebug & 0x0008) {
 976                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 977                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 978                                                                                 j->cadence_f[4].off2);
 979                                                         }
 980                                                         j->cadence_f[4].state = 0;
 981                                                 }
 982                                         } else if (j->cadence_f[4].state == 6) {
 983                                                 if((time_after(jiffies, j->cadence_f[4].off3min) &&
 984                                                     time_before(jiffies, j->cadence_f[4].off3max))) {
 985                                                         j->cadence_f[4].state = 7;
 986                                                 } else {
 987                                                         if (ixjdebug & 0x0008) {
 988                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
 989                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
 990                                                                                 j->cadence_f[4].off3);
 991                                                         }
 992                                                         j->cadence_f[4].state = 0;
 993                                                 }
 994                                         } else {
 995                                                 j->cadence_f[4].state = 0;
 996                                         }
 997                                 } else {                                /* Falling edge of RMR */
 998                                         j->pstn_ring_start = 0;
 999                                         j->pstn_ring_stop = jiffies;
1000                                         if (j->cadence_f[4].state == 1) {
1001                                                 if(!j->cadence_f[4].on1) {
1002                                                         j->cadence_f[4].state = 7;
1003                                                 } else if((time_after(jiffies, j->cadence_f[4].on1min) &&
1004                                                   time_before(jiffies, j->cadence_f[4].on1max))) {
1005                                                         if (j->cadence_f[4].off1) {
1006                                                                 j->cadence_f[4].state = 2;
1007                                                                 j->cadence_f[4].off1min = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 - var)) / 10000));
1008                                                                 j->cadence_f[4].off1dot = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100)) / 10000));
1009                                                                 j->cadence_f[4].off1max = jiffies + (long)((j->cadence_f[4].off1 * (hertz * (100 + var)) / 10000));
1010                                                         } else {
1011                                                                 j->cadence_f[4].state = 7;
1012                                                         }
1013                                                 } else {
1014                                                         if (ixjdebug & 0x0008) {
1015                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1016                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1017                                                                                 j->cadence_f[4].on1);
1018                                                         }
1019                                                         j->cadence_f[4].state = 0;
1020                                                 }
1021                                         } else if (j->cadence_f[4].state == 3) {
1022                                                 if((time_after(jiffies, j->cadence_f[4].on2min) &&
1023                                                     time_before(jiffies, j->cadence_f[4].on2max))) {
1024                                                         if (j->cadence_f[4].off2) {
1025                                                                 j->cadence_f[4].state = 4;
1026                                                                 j->cadence_f[4].off2min = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 - var)) / 10000));
1027                                                                 j->cadence_f[4].off2dot = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100)) / 10000));
1028                                                                 j->cadence_f[4].off2max = jiffies + (long)((j->cadence_f[4].off2 * (hertz * (100 + var)) / 10000));
1029                                                         } else {
1030                                                                 j->cadence_f[4].state = 7;
1031                                                         }
1032                                                 } else {
1033                                                         if (ixjdebug & 0x0008) {
1034                                                                 printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1035                                                                                 j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1036                                                                                 j->cadence_f[4].on2);
1037                                                         }
1038                                                         j->cadence_f[4].state = 0;
1039                                                 }
1040                                         } else if (j->cadence_f[4].state == 5) {
1041                                                 if((time_after(jiffies, j->cadence_f[4].on3min) &&
1042                                                     time_before(jiffies, j->cadence_f[4].on3max))) {
1043                                                         if (j->cadence_f[4].off3) {
1044                                                                 j->cadence_f[4].state = 6;
1045                                                                 j->cadence_f[4].off3min = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 - var)) / 10000));
1046                                                                 j->cadence_f[4].off3dot = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100)) / 10000));
1047                                                                 j->cadence_f[4].off3max = jiffies + (long)((j->cadence_f[4].off3 * (hertz * (100 + var)) / 10000));
1048                                                         } else {
1049                                                                 j->cadence_f[4].state = 7;
1050                                                         }
1051                                                 } else {
1052                                                         j->cadence_f[4].state = 0;
1053                                                 }
1054                                         } else {
1055                                                 if (ixjdebug & 0x0008) {
1056                                                         printk(KERN_INFO "IXJ Ring Cadence fail state = %d /dev/phone%d at %ld should be %d\n",
1057                                                                         j->cadence_f[4].state, j->board, jiffies - j->pstn_prev_rmr,
1058                                                                         j->cadence_f[4].on3);
1059                                                 }
1060                                                 j->cadence_f[4].state = 0;
1061                                         }
1062                                 }
1063                                 if (ixjdebug & 0x0010) {
1064                                         printk(KERN_INFO "IXJ Ring Cadence b state = %d /dev/phone%d at %ld\n", j->cadence_f[4].state, j->board, jiffies);
1065                                 }
1066                                 if (ixjdebug & 0x0010) {
1067                                         switch(j->cadence_f[4].state) {
1068                                                 case 1:
1069                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1070                                                 j->cadence_f[4].on1, j->cadence_f[4].on1min, j->cadence_f[4].on1dot, j->cadence_f[4].on1max);
1071                                                         break;
1072                                                 case 2:
1073                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1074                                                 j->cadence_f[4].off1, j->cadence_f[4].off1min, j->cadence_f[4].off1dot, j->cadence_f[4].off1max);
1075                                                         break;
1076                                                 case 3:
1077                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1078                                                 j->cadence_f[4].on2, j->cadence_f[4].on2min, j->cadence_f[4].on2dot, j->cadence_f[4].on2max);
1079                                                         break;
1080                                                 case 4:
1081                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1082                                                 j->cadence_f[4].off2, j->cadence_f[4].off2min, j->cadence_f[4].off2dot, j->cadence_f[4].off2max);
1083                                                         break;
1084                                                 case 5:
1085                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1086                                                 j->cadence_f[4].on3, j->cadence_f[4].on3min, j->cadence_f[4].on3dot, j->cadence_f[4].on3max);
1087                                                         break;
1088                                                 case 6:
1089                                                         printk(KERN_INFO "IXJ /dev/phone%d Next Ring Cadence state at %u min %ld - %ld - max %ld\n", j->board,
1090                                                 j->cadence_f[4].off3, j->cadence_f[4].off3min, j->cadence_f[4].off3dot, j->cadence_f[4].off3max);
1091                                                         break;
1092                                         }
1093                                 }
1094                         }
1095                         if (j->cadence_f[4].state == 7) {
1096                                 j->cadence_f[4].state = 0;
1097                                 j->pstn_ring_stop = jiffies;
1098                                 j->ex.bits.pstn_ring = 1;
1099                                 ixj_kill_fasync(j, SIG_PSTN_RING, POLL_IN);
1100                                 if(ixjdebug & 0x0008) {
1101                                         printk(KERN_INFO "IXJ Ring int set /dev/phone%d at %ld\n", j->board, jiffies);
1102                                 }
1103                         }
1104                         if((j->pstn_ring_int != 0 && time_after(jiffies, j->pstn_ring_int + (hertz * 5)) && !j->flags.pstn_rmr) ||
1105                            (j->pstn_ring_stop != 0 && time_after(jiffies, j->pstn_ring_stop + (hertz * 5)))) {
1106                                 if(ixjdebug & 0x0008) {
1107                                         printk("IXJ DAA no ring in 5 seconds /dev/phone%d at %ld\n", j->board, jiffies);
1108                                         printk("IXJ DAA pstn ring int /dev/phone%d at %ld\n", j->board, j->pstn_ring_int);
1109                                         printk("IXJ DAA pstn ring stop /dev/phone%d at %ld\n", j->board, j->pstn_ring_stop);
1110                                 }
1111                                 j->pstn_ring_stop = j->pstn_ring_int = 0;
1112                                 daa_set_mode(j, SOP_PU_SLEEP);
1113                         }
1114                         outb_p(j->pld_scrw.byte, j->XILINXbase);
1115                         if (j->pstn_cid_intr && time_after(jiffies, j->pstn_cid_received + hertz)) {
1116                                 ixj_daa_cid_read(j);
1117                                 j->ex.bits.caller_id = 1;
1118                                 ixj_kill_fasync(j, SIG_CALLER_ID, POLL_IN);
1119                                 j->pstn_cid_intr = 0;
1120                         }
1121                         if (daaint.bitreg.Cadence) {
1122                                 if(ixjdebug & 0x0008) {
1123                                         printk("IXJ DAA Cadence interrupt going to sleep /dev/phone%d\n", j->board);
1124                                 }
1125                                 daa_set_mode(j, SOP_PU_SLEEP);
1126                                 j->ex.bits.pstn_ring = 0;
1127                         }
1128                         break;
1129                 case SOP_PU_CONVERSATION:
1130                         if (daaint.bitreg.VDD_OK) {
1131                                 if(!daaint.bitreg.SI_0) {
1132                                         if (!j->pstn_winkstart) {
1133                                                 if(ixjdebug & 0x0008) {
1134                                                         printk("IXJ DAA possible wink /dev/phone%d %ld\n", j->board, jiffies);
1135                                                 }
1136                                                 j->pstn_winkstart = jiffies;
1137                                         }
1138                                 } else {
1139                                         if (j->pstn_winkstart) {
1140                                                 if(ixjdebug & 0x0008) {
1141                                                         printk("IXJ DAA possible wink end /dev/phone%d %ld\n", j->board, jiffies);
1142                                                 }
1143                                                 j->pstn_winkstart = 0;
1144                                         }
1145                                 }
1146                         }
1147                         if (j->pstn_winkstart && time_after(jiffies, j->pstn_winkstart + ((hertz * j->winktime) / 1000))) {
1148                                 if(ixjdebug & 0x0008) {
1149                                         printk("IXJ DAA wink detected going to sleep /dev/phone%d %ld\n", j->board, jiffies);
1150                                 }
1151                                 daa_set_mode(j, SOP_PU_SLEEP);
1152                                 j->pstn_winkstart = 0;
1153                                 j->ex.bits.pstn_wink = 1;
1154                                 ixj_kill_fasync(j, SIG_PSTN_WINK, POLL_IN);
1155                         }
1156                         break;
1157         }
1158 }
1159
1160 static void ixj_timeout(unsigned long ptr)
1161 {
1162         int board;
1163         unsigned long jifon;
1164         IXJ *j = (IXJ *)ptr;
1165         board = j->board;
1166
1167         if (j->DSPbase && atomic_read(&j->DSPWrite) == 0 && test_and_set_bit(board, (void *)&j->busyflags) == 0) {
1168                 ixj_perfmon(j->timerchecks);
1169                 j->hookstate = ixj_hookstate(j);
1170                 if (j->tone_state) {
1171                         if (!(j->hookstate)) {
1172                                 ixj_cpt_stop(j);
1173                                 if (j->m_hook) {
1174                                         j->m_hook = 0;
1175                                         j->ex.bits.hookstate = 1;
1176                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1177                                 }
1178                                 clear_bit(board, &j->busyflags);
1179                                 ixj_add_timer(j);
1180                                 return;
1181                         }
1182                         if (j->tone_state == 1)
1183                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000);
1184                         else
1185                                 jifon = ((hertz * j->tone_on_time) * 25 / 100000) + ((hertz * j->tone_off_time) * 25 / 100000);
1186                         if (time_before(jiffies, j->tone_start_jif + jifon)) {
1187                                 if (j->tone_state == 1) {
1188                                         ixj_play_tone(j, j->tone_index);
1189                                         if (j->dsp.low == 0x20) {
1190                                                 clear_bit(board, &j->busyflags);
1191                                                 ixj_add_timer(j);
1192                                                 return;
1193                                         }
1194                                 } else {
1195                                         ixj_play_tone(j, 0);
1196                                         if (j->dsp.low == 0x20) {
1197                                                 clear_bit(board, &j->busyflags);
1198                                                 ixj_add_timer(j);
1199                                                 return;
1200                                         }
1201                                 }
1202                         } else {
1203                                 ixj_tone_timeout(j);
1204                                 if (j->flags.dialtone) {
1205                                         ixj_dialtone(j);
1206                                 }
1207                                 if (j->flags.busytone) {
1208                                         ixj_busytone(j);
1209                                         if (j->dsp.low == 0x20) {
1210                                                 clear_bit(board, &j->busyflags);
1211                                                 ixj_add_timer(j);
1212                                                 return;
1213                                         }
1214                                 }
1215                                 if (j->flags.ringback) {
1216                                         ixj_ringback(j);
1217                                         if (j->dsp.low == 0x20) {
1218                                                 clear_bit(board, &j->busyflags);
1219                                                 ixj_add_timer(j);
1220                                                 return;
1221                                         }
1222                                 }
1223                                 if (!j->tone_state) {
1224                                         ixj_cpt_stop(j);
1225                                 }
1226                         }
1227                 }
1228                 if (!(j->tone_state && j->dsp.low == 0x20)) {
1229                         if (IsRxReady(j)) {
1230                                 ixj_read_frame(j);
1231                         }
1232                         if (IsTxReady(j)) {
1233                                 ixj_write_frame(j);
1234                         }
1235                 }
1236                 if (j->flags.cringing) {
1237                         if (j->hookstate & 1) {
1238                                 j->flags.cringing = 0;
1239                                 ixj_ring_off(j);
1240                         } else if(j->cadence_f[5].enable && ((!j->cadence_f[5].en_filter) || (j->cadence_f[5].en_filter && j->flags.firstring))) {
1241                                 switch(j->cadence_f[5].state) {
1242                                         case 0:
1243                                                 j->cadence_f[5].on1dot = jiffies + (long)((j->cadence_f[5].on1 * (hertz * 100) / 10000));
1244                                                 if (time_before(jiffies, j->cadence_f[5].on1dot)) {
1245                                                         if(ixjdebug & 0x0004) {
1246                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1247                                                         }
1248                                                         ixj_ring_on(j);
1249                                                 }
1250                                                 j->cadence_f[5].state = 1;
1251                                                 break;
1252                                         case 1:
1253                                                 if (time_after(jiffies, j->cadence_f[5].on1dot)) {
1254                                                         j->cadence_f[5].off1dot = jiffies + (long)((j->cadence_f[5].off1 * (hertz * 100) / 10000));
1255                                                         if(ixjdebug & 0x0004) {
1256                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1257                                                         }
1258                                                         ixj_ring_off(j);
1259                                                         j->cadence_f[5].state = 2;
1260                                                 }
1261                                                 break;
1262                                         case 2:
1263                                                 if (time_after(jiffies, j->cadence_f[5].off1dot)) {
1264                                                         if(ixjdebug & 0x0004) {
1265                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1266                                                         }
1267                                                         ixj_ring_on(j);
1268                                                         if (j->cadence_f[5].on2) {
1269                                                                 j->cadence_f[5].on2dot = jiffies + (long)((j->cadence_f[5].on2 * (hertz * 100) / 10000));
1270                                                                 j->cadence_f[5].state = 3;
1271                                                         } else {
1272                                                                 j->cadence_f[5].state = 7;
1273                                                         }
1274                                                 }
1275                                                 break;
1276                                         case 3:
1277                                                 if (time_after(jiffies, j->cadence_f[5].on2dot)) {
1278                                                         if(ixjdebug & 0x0004) {
1279                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1280                                                         }
1281                                                         ixj_ring_off(j);
1282                                                         if (j->cadence_f[5].off2) {
1283                                                                 j->cadence_f[5].off2dot = jiffies + (long)((j->cadence_f[5].off2 * (hertz * 100) / 10000));
1284                                                                 j->cadence_f[5].state = 4;
1285                                                         } else {
1286                                                                 j->cadence_f[5].state = 7;
1287                                                         }
1288                                                 }
1289                                                 break;
1290                                         case 4:
1291                                                 if (time_after(jiffies, j->cadence_f[5].off2dot)) {
1292                                                         if(ixjdebug & 0x0004) {
1293                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1294                                                         }
1295                                                         ixj_ring_on(j);
1296                                                         if (j->cadence_f[5].on3) {
1297                                                                 j->cadence_f[5].on3dot = jiffies + (long)((j->cadence_f[5].on3 * (hertz * 100) / 10000));
1298                                                                 j->cadence_f[5].state = 5;
1299                                                         } else {
1300                                                                 j->cadence_f[5].state = 7;
1301                                                         }
1302                                                 }
1303                                                 break;
1304                                         case 5:
1305                                                 if (time_after(jiffies, j->cadence_f[5].on3dot)) {
1306                                                         if(ixjdebug & 0x0004) {
1307                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1308                                                         }
1309                                                         ixj_ring_off(j);
1310                                                         if (j->cadence_f[5].off3) {
1311                                                                 j->cadence_f[5].off3dot = jiffies + (long)((j->cadence_f[5].off3 * (hertz * 100) / 10000));
1312                                                                 j->cadence_f[5].state = 6;
1313                                                         } else {
1314                                                                 j->cadence_f[5].state = 7;
1315                                                         }
1316                                                 }
1317                                                 break;
1318                                         case 6:
1319                                                 if (time_after(jiffies, j->cadence_f[5].off3dot)) {
1320                                                         if(ixjdebug & 0x0004) {
1321                                                                 printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1322                                                         }
1323                                                         j->cadence_f[5].state = 7;
1324                                                 }
1325                                                 break;
1326                                         case 7:
1327                                                 if(ixjdebug & 0x0004) {
1328                                                         printk("Ringing cadence state = %d - %ld\n", j->cadence_f[5].state, jiffies);
1329                                                 }
1330                                                 j->flags.cidring = 1;
1331                                                 j->cadence_f[5].state = 0;
1332                                                 break;
1333                                 }
1334                                 if (j->flags.cidring && !j->flags.cidsent) {
1335                                         j->flags.cidsent = 1;
1336                                         if(j->fskdcnt) {
1337                                                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1338                                                 ixj_pre_cid(j);
1339                                         }
1340                                         j->flags.cidring = 0;
1341                                 }
1342                                 clear_bit(board, &j->busyflags);
1343                                 ixj_add_timer(j);
1344                                 return;
1345                         } else {
1346                                 if (time_after(jiffies, j->ring_cadence_jif + (hertz / 2))) {
1347                                         if (j->flags.cidring && !j->flags.cidsent) {
1348                                                 j->flags.cidsent = 1;
1349                                                 if(j->fskdcnt) {
1350                                                         SLIC_SetState(PLD_SLIC_STATE_OHT, j);
1351                                                         ixj_pre_cid(j);
1352                                                 }
1353                                                 j->flags.cidring = 0;
1354                                         }
1355                                         j->ring_cadence_t--;
1356                                         if (j->ring_cadence_t == -1)
1357                                                 j->ring_cadence_t = 15;
1358                                         j->ring_cadence_jif = jiffies;
1359
1360                                         if (j->ring_cadence & 1 << j->ring_cadence_t) {
1361                                                 if(j->flags.cidsent && j->cadence_f[5].en_filter)
1362                                                         j->flags.firstring = 1;
1363                                                 else
1364                                                         ixj_ring_on(j);
1365                                         } else {
1366                                                 ixj_ring_off(j);
1367                                                 if(!j->flags.cidsent)
1368                                                         j->flags.cidring = 1;
1369                                         }
1370                                 }
1371                                 clear_bit(board, &j->busyflags);
1372                                 ixj_add_timer(j);
1373                                 return;
1374                         }
1375                 }
1376                 if (!j->flags.ringing) {
1377                         if (j->hookstate) { /* & 1) { */
1378                                 if (j->dsp.low != 0x20 &&
1379                                     SLIC_GetState(j) != PLD_SLIC_STATE_ACTIVE) {
1380                                         SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1381                                 }
1382                                 LineMonitor(j);
1383                                 read_filters(j);
1384                                 ixj_WriteDSPCommand(0x511B, j);
1385                                 j->proc_load = j->ssr.high << 8 | j->ssr.low;
1386                                 if (!j->m_hook && (j->hookstate & 1)) {
1387                                         j->m_hook = j->ex.bits.hookstate = 1;
1388                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1389                                 }
1390                         } else {
1391                                 if (j->ex.bits.dtmf_ready) {
1392                                         j->dtmf_wp = j->dtmf_rp = j->ex.bits.dtmf_ready = 0;
1393                                 }
1394                                 if (j->m_hook) {
1395                                         j->m_hook = 0;
1396                                         j->ex.bits.hookstate = 1;
1397                                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1398                                 }
1399                         }
1400                 }
1401                 if (j->cardtype == QTI_LINEJACK && !j->flags.pstncheck && j->flags.pstn_present) {
1402                         ixj_pstn_state(j);
1403                 }
1404                 if (j->ex.bytes) {
1405                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
1406                 }
1407                 clear_bit(board, &j->busyflags);
1408         }
1409         ixj_add_timer(j);
1410 }
1411
1412 static int ixj_status_wait(IXJ *j)
1413 {
1414         unsigned long jif;
1415
1416         jif = jiffies + ((60 * hertz) / 100);
1417         while (!IsStatusReady(j)) {
1418                 ixj_perfmon(j->statuswait);
1419                 if (time_after(jiffies, jif)) {
1420                         ixj_perfmon(j->statuswaitfail);
1421                         return -1;
1422                 }
1423         }
1424         return 0;
1425 }
1426
1427 static int ixj_PCcontrol_wait(IXJ *j)
1428 {
1429         unsigned long jif;
1430
1431         jif = jiffies + ((60 * hertz) / 100);
1432         while (!IsPCControlReady(j)) {
1433                 ixj_perfmon(j->pcontrolwait);
1434                 if (time_after(jiffies, jif)) {
1435                         ixj_perfmon(j->pcontrolwaitfail);
1436                         return -1;
1437                 }
1438         }
1439         return 0;
1440 }
1441
1442 static int ixj_WriteDSPCommand(unsigned short cmd, IXJ *j)
1443 {
1444         BYTES bytes;
1445         unsigned long jif;
1446
1447         atomic_inc(&j->DSPWrite);
1448         if(atomic_read(&j->DSPWrite) > 1) {
1449                 printk("IXJ %d DSP write overlap attempting command 0x%4.4x\n", j->board, cmd);
1450                 return -1;
1451         }
1452         bytes.high = (cmd & 0xFF00) >> 8;
1453         bytes.low = cmd & 0x00FF;
1454         jif = jiffies + ((60 * hertz) / 100);
1455         while (!IsControlReady(j)) {
1456                 ixj_perfmon(j->iscontrolready);
1457                 if (time_after(jiffies, jif)) {
1458                         ixj_perfmon(j->iscontrolreadyfail);
1459                         atomic_dec(&j->DSPWrite);
1460                         if(atomic_read(&j->DSPWrite) > 0) {
1461                                 printk("IXJ %d DSP overlaped command 0x%4.4x during control ready failure.\n", j->board, cmd);
1462                                 while(atomic_read(&j->DSPWrite) > 0) {
1463                                         atomic_dec(&j->DSPWrite);
1464                                 }
1465                         }
1466                         return -1;
1467                 }
1468         }
1469         outb(bytes.low, j->DSPbase + 6);
1470         outb(bytes.high, j->DSPbase + 7);
1471
1472         if (ixj_status_wait(j)) {
1473                 j->ssr.low = 0xFF;
1474                 j->ssr.high = 0xFF;
1475                 atomic_dec(&j->DSPWrite);
1476                 if(atomic_read(&j->DSPWrite) > 0) {
1477                         printk("IXJ %d DSP overlaped command 0x%4.4x during status wait failure.\n", j->board, cmd);
1478                         while(atomic_read(&j->DSPWrite) > 0) {
1479                                 atomic_dec(&j->DSPWrite);
1480                         }
1481                 }
1482                 return -1;
1483         }
1484 /* Read Software Status Register */
1485         j->ssr.low = inb_p(j->DSPbase + 2);
1486         j->ssr.high = inb_p(j->DSPbase + 3);
1487         atomic_dec(&j->DSPWrite);
1488         if(atomic_read(&j->DSPWrite) > 0) {
1489                 printk("IXJ %d DSP overlaped command 0x%4.4x\n", j->board, cmd);
1490                 while(atomic_read(&j->DSPWrite) > 0) {
1491                         atomic_dec(&j->DSPWrite);
1492                 }
1493         }
1494         return 0;
1495 }
1496
1497 /***************************************************************************
1498 *
1499 *  General Purpose IO Register read routine
1500 *
1501 ***************************************************************************/
1502 static inline int ixj_gpio_read(IXJ *j)
1503 {
1504         if (ixj_WriteDSPCommand(0x5143, j))
1505                 return -1;
1506
1507         j->gpio.bytes.low = j->ssr.low;
1508         j->gpio.bytes.high = j->ssr.high;
1509
1510         return 0;
1511 }
1512
1513 static inline void LED_SetState(int state, IXJ *j)
1514 {
1515         if (j->cardtype == QTI_LINEJACK) {
1516                 j->pld_scrw.bits.led1 = state & 0x1 ? 1 : 0;
1517                 j->pld_scrw.bits.led2 = state & 0x2 ? 1 : 0;
1518                 j->pld_scrw.bits.led3 = state & 0x4 ? 1 : 0;
1519                 j->pld_scrw.bits.led4 = state & 0x8 ? 1 : 0;
1520
1521                 outb(j->pld_scrw.byte, j->XILINXbase);
1522         }
1523 }
1524
1525 /*********************************************************************
1526 *  GPIO Pins are configured as follows on the Quicknet Internet
1527 *  PhoneJACK Telephony Cards
1528 *
1529 * POTS Select        GPIO_6=0 GPIO_7=0
1530 * Mic/Speaker Select GPIO_6=0 GPIO_7=1
1531 * Handset Select     GPIO_6=1 GPIO_7=0
1532 *
1533 * SLIC Active        GPIO_1=0 GPIO_2=1 GPIO_5=0
1534 * SLIC Ringing       GPIO_1=1 GPIO_2=1 GPIO_5=0
1535 * SLIC Open Circuit  GPIO_1=0 GPIO_2=0 GPIO_5=0
1536 *
1537 * Hook Switch changes reported on GPIO_3
1538 *********************************************************************/
1539 static int ixj_set_port(IXJ *j, int arg)
1540 {
1541         if (j->cardtype == QTI_PHONEJACK_LITE) {
1542                 if (arg != PORT_POTS)
1543                         return 10;
1544                 else
1545                         return 0;
1546         }
1547         switch (arg) {
1548         case PORT_POTS:
1549                 j->port = PORT_POTS;
1550                 switch (j->cardtype) {
1551                 case QTI_PHONECARD:
1552                         if (j->flags.pcmciasct == 1)
1553                                 SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j);
1554                         else
1555                                 return 11;
1556                         break;
1557                 case QTI_PHONEJACK_PCI:
1558                         j->pld_slicw.pcib.mic = 0;
1559                         j->pld_slicw.pcib.spk = 0;
1560                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1561                         break;
1562                 case QTI_LINEJACK:
1563                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1564                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1565                                                                            Software Control Register */
1566                                 return 2;
1567                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1568
1569                         outb(j->pld_scrw.byte, j->XILINXbase);
1570                         j->pld_clock.byte = 0;
1571                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1572                         j->pld_slicw.bits.rly1 = 1;
1573                         j->pld_slicw.bits.spken = 0;
1574                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1575                         ixj_mixer(0x1200, j);   /* Turn Off MIC switch on mixer left */
1576                         ixj_mixer(0x1401, j);   /* Turn On Mono1 switch on mixer left */
1577                         ixj_mixer(0x1300, j);       /* Turn Off MIC switch on mixer right */
1578                         ixj_mixer(0x1501, j);       /* Turn On Mono1 switch on mixer right */
1579                         ixj_mixer(0x0E80, j);   /*Mic mute */
1580                         ixj_mixer(0x0F00, j);   /* Set mono out (SLIC) to 0dB */
1581                         ixj_mixer(0x0080, j);   /* Mute Master Left volume */
1582                         ixj_mixer(0x0180, j);   /* Mute Master Right volume */
1583                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
1584 /*                      SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
1585                         break;
1586                 case QTI_PHONEJACK:
1587                         j->gpio.bytes.high = 0x0B;
1588                         j->gpio.bits.gpio6 = 0;
1589                         j->gpio.bits.gpio7 = 0;
1590                         ixj_WriteDSPCommand(j->gpio.word, j);
1591                         break;
1592                 }
1593                 break;
1594         case PORT_PSTN:
1595                 if (j->cardtype == QTI_LINEJACK) {
1596                         ixj_WriteDSPCommand(0xC534, j); /* Write CODEC config to Software Control Register */
1597
1598                         j->pld_slicw.bits.rly3 = 0;
1599                         j->pld_slicw.bits.rly1 = 1;
1600                         j->pld_slicw.bits.spken = 0;
1601                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1602                         j->port = PORT_PSTN;
1603                 } else {
1604                         return 4;
1605                 }
1606                 break;
1607         case PORT_SPEAKER:
1608                 j->port = PORT_SPEAKER;
1609                 switch (j->cardtype) {
1610                 case QTI_PHONECARD:
1611                         if (j->flags.pcmciasct) {
1612                                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
1613                         }
1614                         break;
1615                 case QTI_PHONEJACK_PCI:
1616                         j->pld_slicw.pcib.mic = 1;
1617                         j->pld_slicw.pcib.spk = 1;
1618                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1619                         break;
1620                 case QTI_LINEJACK:
1621                         ixj_set_pots(j, 0);                     /* Disconnect POTS/PSTN relay */
1622                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to
1623                                                                            Software Control Register */
1624                                 return 2;
1625                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
1626
1627                         outb(j->pld_scrw.byte, j->XILINXbase);
1628                         j->pld_clock.byte = 0;
1629                         outb(j->pld_clock.byte, j->XILINXbase + 0x04);
1630                         j->pld_slicw.bits.rly1 = 1;
1631                         j->pld_slicw.bits.spken = 1;
1632                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1633                         ixj_mixer(0x1201, j);   /* Turn On MIC switch on mixer left */
1634                         ixj_mixer(0x1400, j);   /* Turn Off Mono1 switch on mixer left */
1635                         ixj_mixer(0x1301, j);       /* Turn On MIC switch on mixer right */
1636                         ixj_mixer(0x1500, j);       /* Turn Off Mono1 switch on mixer right */
1637                         ixj_mixer(0x0E06, j);   /*Mic un-mute 0dB */
1638                         ixj_mixer(0x0F80, j);   /* Mute mono out (SLIC) */
1639                         ixj_mixer(0x0000, j);   /* Set Master Left volume to 0dB */
1640                         ixj_mixer(0x0100, j);   /* Set Master Right volume to 0dB */
1641                         break;
1642                 case QTI_PHONEJACK:
1643                         j->gpio.bytes.high = 0x0B;
1644                         j->gpio.bits.gpio6 = 0;
1645                         j->gpio.bits.gpio7 = 1;
1646                         ixj_WriteDSPCommand(j->gpio.word, j);
1647                         break;
1648                 }
1649                 break;
1650         case PORT_HANDSET:
1651                 if (j->cardtype != QTI_PHONEJACK) {
1652                         return 5;
1653                 } else {
1654                         j->gpio.bytes.high = 0x0B;
1655                         j->gpio.bits.gpio6 = 1;
1656                         j->gpio.bits.gpio7 = 0;
1657                         ixj_WriteDSPCommand(j->gpio.word, j);
1658                         j->port = PORT_HANDSET;
1659                 }
1660                 break;
1661         default:
1662                 return 6;
1663                 break;
1664         }
1665         return 0;
1666 }
1667
1668 static int ixj_set_pots(IXJ *j, int arg)
1669 {
1670         if (j->cardtype == QTI_LINEJACK) {
1671                 if (arg) {
1672                         if (j->port == PORT_PSTN) {
1673                                 j->pld_slicw.bits.rly1 = 0;
1674                                 outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1675                                 j->flags.pots_pstn = 1;
1676                                 return 1;
1677                         } else {
1678                                 j->flags.pots_pstn = 0;
1679                                 return 0;
1680                         }
1681                 } else {
1682                         j->pld_slicw.bits.rly1 = 1;
1683                         outb(j->pld_slicw.byte, j->XILINXbase + 0x01);
1684                         j->flags.pots_pstn = 0;
1685                         return 1;
1686                 }
1687         } else {
1688                 return 0;
1689         }
1690 }
1691
1692 static void ixj_ring_on(IXJ *j)
1693 {
1694         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
1695          {
1696                 if (ixjdebug & 0x0004)
1697                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n",  j->board);
1698
1699                 j->gpio.bytes.high = 0x0B;
1700                 j->gpio.bytes.low = 0x00;
1701                 j->gpio.bits.gpio1 = 1;
1702                 j->gpio.bits.gpio2 = 1;
1703                 j->gpio.bits.gpio5 = 0;
1704                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring signal */
1705         } else                  /* Internet LineJACK, Internet PhoneJACK Lite or Internet PhoneJACK PCI */
1706         {
1707                 if (ixjdebug & 0x0004)
1708                         printk(KERN_INFO "IXJ Ring On /dev/phone%d\n", j->board);
1709
1710                 SLIC_SetState(PLD_SLIC_STATE_RINGING, j);
1711         }
1712 }
1713
1714 static int ixj_siadc(IXJ *j, int val)
1715 {
1716         if(j->cardtype == QTI_PHONECARD){
1717                 if(j->flags.pcmciascp){
1718                         if(val == -1)
1719                                 return j->siadc.bits.rxg;
1720
1721                         if(val < 0 || val > 0x1F)
1722                                 return -1;
1723
1724                         j->siadc.bits.hom = 0;                          /* Handset Out Mute */
1725                         j->siadc.bits.lom = 0;                          /* Line Out Mute */
1726                         j->siadc.bits.rxg = val;                        /*(0xC000 - 0x41C8) / 0x4EF;    RX PGA Gain */
1727                         j->psccr.bits.addr = 6;                         /* R/W Smart Cable Register Address */
1728                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1729                         j->psccr.bits.dev = 0;
1730                         outb(j->siadc.byte, j->XILINXbase + 0x00);
1731                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1732                         ixj_PCcontrol_wait(j);
1733                         return j->siadc.bits.rxg;
1734                 }
1735         }
1736         return -1;
1737 }
1738
1739 static int ixj_sidac(IXJ *j, int val)
1740 {
1741         if(j->cardtype == QTI_PHONECARD){
1742                 if(j->flags.pcmciascp){
1743                         if(val == -1)
1744                                 return j->sidac.bits.txg;
1745
1746                         if(val < 0 || val > 0x1F)
1747                                 return -1;
1748
1749                         j->sidac.bits.srm = 1;                          /* Speaker Right Mute */
1750                         j->sidac.bits.slm = 1;                          /* Speaker Left Mute */
1751                         j->sidac.bits.txg = val;                        /* (0xC000 - 0x45E4) / 0x5D3;    TX PGA Gain */
1752                         j->psccr.bits.addr = 7;                         /* R/W Smart Cable Register Address */
1753                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1754                         j->psccr.bits.dev = 0;
1755                         outb(j->sidac.byte, j->XILINXbase + 0x00);
1756                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1757                         ixj_PCcontrol_wait(j);
1758                         return j->sidac.bits.txg;
1759                 }
1760         }
1761         return -1;
1762 }
1763
1764 static int ixj_pcmcia_cable_check(IXJ *j)
1765 {
1766         j->pccr1.byte = inb_p(j->XILINXbase + 0x03);
1767         if (!j->flags.pcmciastate) {
1768                 j->pccr2.byte = inb_p(j->XILINXbase + 0x02);
1769                 if (j->pccr1.bits.drf || j->pccr2.bits.rstc) {
1770                         j->flags.pcmciastate = 4;
1771                         return 0;
1772                 }
1773                 if (j->pccr1.bits.ed) {
1774                         j->pccr1.bits.ed = 0;
1775                         j->psccr.bits.dev = 3;
1776                         j->psccr.bits.rw = 1;
1777                         outw_p(j->psccr.byte << 8, j->XILINXbase + 0x00);
1778                         ixj_PCcontrol_wait(j);
1779                         j->pslic.byte = inw_p(j->XILINXbase + 0x00) & 0xFF;
1780                         j->pslic.bits.led2 = j->pslic.bits.det ? 1 : 0;
1781                         j->psccr.bits.dev = 3;
1782                         j->psccr.bits.rw = 0;
1783                         outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1784                         ixj_PCcontrol_wait(j);
1785                         return j->pslic.bits.led2 ? 1 : 0;
1786                 } else if (j->flags.pcmciasct) {
1787                         return j->r_hook;
1788                 } else {
1789                         return 1;
1790                 }
1791         } else if (j->flags.pcmciastate == 4) {
1792                 if (!j->pccr1.bits.drf) {
1793                         j->flags.pcmciastate = 3;
1794                 }
1795                 return 0;
1796         } else if (j->flags.pcmciastate == 3) {
1797                 j->pccr2.bits.pwr = 0;
1798                 j->pccr2.bits.rstc = 1;
1799                 outb(j->pccr2.byte, j->XILINXbase + 0x02);
1800                 j->checkwait = jiffies + (hertz * 2);
1801                 j->flags.incheck = 1;
1802                 j->flags.pcmciastate = 2;
1803                 return 0;
1804         } else if (j->flags.pcmciastate == 2) {
1805                 if (j->flags.incheck) {
1806                         if (time_before(jiffies, j->checkwait)) {
1807                                 return 0;
1808                         } else {
1809                                 j->flags.incheck = 0;
1810                         }
1811                 }
1812                 j->pccr2.bits.pwr = 0;
1813                 j->pccr2.bits.rstc = 0;
1814                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1815                 j->flags.pcmciastate = 1;
1816                 return 0;
1817         } else if (j->flags.pcmciastate == 1) {
1818                 j->flags.pcmciastate = 0;
1819                 if (!j->pccr1.bits.drf) {
1820                         j->psccr.bits.dev = 3;
1821                         j->psccr.bits.rw = 1;
1822                         outb_p(j->psccr.byte, j->XILINXbase + 0x01);
1823                         ixj_PCcontrol_wait(j);
1824                         j->flags.pcmciascp = 1;         /* Set Cable Present Flag */
1825
1826                         j->flags.pcmciasct = (inw_p(j->XILINXbase + 0x00) >> 8) & 0x03;         /* Get Cable Type */
1827
1828                         if (j->flags.pcmciasct == 3) {
1829                                 j->flags.pcmciastate = 4;
1830                                 return 0;
1831                         } else if (j->flags.pcmciasct == 0) {
1832                                 j->pccr2.bits.pwr = 1;
1833                                 j->pccr2.bits.rstc = 0;
1834                                 outb_p(j->pccr2.byte, j->XILINXbase + 0x02);
1835                                 j->port = PORT_SPEAKER;
1836                         } else {
1837                                 j->port = PORT_POTS;
1838                         }
1839                         j->sic1.bits.cpd = 0;                           /* Chip Power Down */
1840                         j->sic1.bits.mpd = 0;                           /* MIC Bias Power Down */
1841                         j->sic1.bits.hpd = 0;                           /* Handset Bias Power Down */
1842                         j->sic1.bits.lpd = 0;                           /* Line Bias Power Down */
1843                         j->sic1.bits.spd = 1;                           /* Speaker Drive Power Down */
1844                         j->psccr.bits.addr = 1;                         /* R/W Smart Cable Register Address */
1845                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1846                         j->psccr.bits.dev = 0;
1847                         outb(j->sic1.byte, j->XILINXbase + 0x00);
1848                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1849                         ixj_PCcontrol_wait(j);
1850
1851                         j->sic2.bits.al = 0;                            /* Analog Loopback DAC analog -> ADC analog */
1852                         j->sic2.bits.dl2 = 0;                           /* Digital Loopback DAC -> ADC one bit */
1853                         j->sic2.bits.dl1 = 0;                           /* Digital Loopback ADC -> DAC one bit */
1854                         j->sic2.bits.pll = 0;                           /* 1 = div 10, 0 = div 5 */
1855                         j->sic2.bits.hpd = 0;                           /* HPF disable */
1856                         j->psccr.bits.addr = 2;                         /* R/W Smart Cable Register Address */
1857                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1858                         j->psccr.bits.dev = 0;
1859                         outb(j->sic2.byte, j->XILINXbase + 0x00);
1860                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1861                         ixj_PCcontrol_wait(j);
1862
1863                         j->psccr.bits.addr = 3;                         /* R/W Smart Cable Register Address */
1864                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1865                         j->psccr.bits.dev = 0;
1866                         outb(0x00, j->XILINXbase + 0x00);               /* PLL Divide N1 */
1867                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1868                         ixj_PCcontrol_wait(j);
1869
1870                         j->psccr.bits.addr = 4;                         /* R/W Smart Cable Register Address */
1871                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1872                         j->psccr.bits.dev = 0;
1873                         outb(0x09, j->XILINXbase + 0x00);               /* PLL Multiply M1 */
1874                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1875                         ixj_PCcontrol_wait(j);
1876
1877                         j->sirxg.bits.lig = 1;                          /* Line In Gain */
1878                         j->sirxg.bits.lim = 1;                          /* Line In Mute */
1879                         j->sirxg.bits.mcg = 0;                          /* MIC In Gain was 3 */
1880                         j->sirxg.bits.mcm = 0;                          /* MIC In Mute */
1881                         j->sirxg.bits.him = 0;                          /* Handset In Mute */
1882                         j->sirxg.bits.iir = 1;                          /* IIR */
1883                         j->psccr.bits.addr = 5;                         /* R/W Smart Cable Register Address */
1884                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1885                         j->psccr.bits.dev = 0;
1886                         outb(j->sirxg.byte, j->XILINXbase + 0x00);
1887                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1888                         ixj_PCcontrol_wait(j);
1889
1890                         ixj_siadc(j, 0x17);
1891                         ixj_sidac(j, 0x1D);
1892
1893                         j->siaatt.bits.sot = 0;
1894                         j->psccr.bits.addr = 9;                         /* R/W Smart Cable Register Address */
1895                         j->psccr.bits.rw = 0;                           /* Read / Write flag */
1896                         j->psccr.bits.dev = 0;
1897                         outb(j->siaatt.byte, j->XILINXbase + 0x00);
1898                         outb(j->psccr.byte, j->XILINXbase + 0x01);
1899                         ixj_PCcontrol_wait(j);
1900
1901                         if (j->flags.pcmciasct == 1 && !j->readers && !j->writers) {
1902                                 j->psccr.byte = j->pslic.byte = 0;
1903                                 j->pslic.bits.powerdown = 1;
1904                                 j->psccr.bits.dev = 3;
1905                                 j->psccr.bits.rw = 0;
1906                                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
1907                                 ixj_PCcontrol_wait(j);
1908                         }
1909                 }
1910                 return 0;
1911         } else {
1912                 j->flags.pcmciascp = 0;
1913                 return 0;
1914         }
1915         return 0;
1916 }
1917
1918 static int ixj_hookstate(IXJ *j)
1919 {
1920         int fOffHook = 0;
1921
1922         switch (j->cardtype) {
1923         case QTI_PHONEJACK:
1924                 ixj_gpio_read(j);
1925                 fOffHook = j->gpio.bits.gpio3read ? 1 : 0;
1926                 break;
1927         case QTI_LINEJACK:
1928         case QTI_PHONEJACK_LITE:
1929         case QTI_PHONEJACK_PCI:
1930                 SLIC_GetState(j);
1931                 if(j->cardtype == QTI_LINEJACK && j->flags.pots_pstn == 1 && (j->readers || j->writers)) {
1932                         fOffHook = j->pld_slicr.bits.potspstn ? 1 : 0;
1933                         if(fOffHook != j->p_hook) {
1934                                 if(!j->checkwait) {
1935                                         j->checkwait = jiffies;
1936                                 }
1937                                 if(time_before(jiffies, j->checkwait + 2)) {
1938                                         fOffHook ^= 1;
1939                                 } else {
1940                                         j->checkwait = 0;
1941                                 }
1942                                 j->p_hook = fOffHook;
1943                                 printk("IXJ : /dev/phone%d pots-pstn hookstate check %d at %ld\n", j->board, fOffHook, jiffies);
1944                         }
1945                 } else {
1946                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_ACTIVE ||
1947                             j->pld_slicr.bits.state == PLD_SLIC_STATE_STANDBY) {
1948                                 if (j->flags.ringing || j->flags.cringing) {
1949                                         if (!in_interrupt()) {
1950                                                 msleep(20);
1951                                         }
1952                                         SLIC_GetState(j);
1953                                         if (j->pld_slicr.bits.state == PLD_SLIC_STATE_RINGING) {
1954                                                 ixj_ring_on(j);
1955                                         }
1956                                 }
1957                                 if (j->cardtype == QTI_PHONEJACK_PCI) {
1958                                         j->pld_scrr.byte = inb_p(j->XILINXbase);
1959                                         fOffHook = j->pld_scrr.pcib.det ? 1 : 0;
1960                                 } else
1961                                         fOffHook = j->pld_slicr.bits.det ? 1 : 0;
1962                         }
1963                 }
1964                 break;
1965         case QTI_PHONECARD:
1966                 fOffHook = ixj_pcmcia_cable_check(j);
1967                 break;
1968         }
1969         if (j->r_hook != fOffHook) {
1970                 j->r_hook = fOffHook;
1971                 if (j->port == PORT_SPEAKER || j->port == PORT_HANDSET) { // || (j->port == PORT_PSTN && j->flags.pots_pstn == 0)) {
1972                         j->ex.bits.hookstate = 1;
1973                         ixj_kill_fasync(j, SIG_HOOKSTATE, POLL_IN);
1974                 } else if (!fOffHook) {
1975                         j->flash_end = jiffies + ((60 * hertz) / 100);
1976                 }
1977         }
1978         if (fOffHook) {
1979                 if(time_before(jiffies, j->flash_end)) {
1980                         j->ex.bits.flash = 1;
1981                         j->flash_end = 0;
1982                         ixj_kill_fasync(j, SIG_FLASH, POLL_IN);
1983                 }
1984         } else {
1985                 if(time_before(jiffies, j->flash_end)) {
1986                         fOffHook = 1;
1987                 }
1988         }
1989
1990         if (j->port == PORT_PSTN && j->daa_mode == SOP_PU_CONVERSATION)
1991                 fOffHook |= 2;
1992
1993         if (j->port == PORT_SPEAKER) {
1994                 if(j->cardtype == QTI_PHONECARD) {
1995                         if(j->flags.pcmciascp && j->flags.pcmciasct) {
1996                                 fOffHook |= 2;
1997                         }
1998                 } else {
1999                         fOffHook |= 2;
2000                 }
2001         }
2002
2003         if (j->port == PORT_HANDSET)
2004                 fOffHook |= 2;
2005
2006         return fOffHook;
2007 }
2008
2009 static void ixj_ring_off(IXJ *j)
2010 {
2011         if (j->dsp.low == 0x20) /* Internet PhoneJACK */
2012          {
2013                 if (ixjdebug & 0x0004)
2014                         printk(KERN_INFO "IXJ Ring Off\n");
2015                 j->gpio.bytes.high = 0x0B;
2016                 j->gpio.bytes.low = 0x00;
2017                 j->gpio.bits.gpio1 = 0;
2018                 j->gpio.bits.gpio2 = 1;
2019                 j->gpio.bits.gpio5 = 0;
2020                 ixj_WriteDSPCommand(j->gpio.word, j);
2021         } else                  /* Internet LineJACK */
2022         {
2023                 if (ixjdebug & 0x0004)
2024                         printk(KERN_INFO "IXJ Ring Off\n");
2025
2026                 if(!j->flags.cidplay)
2027                         SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
2028
2029                 SLIC_GetState(j);
2030         }
2031 }
2032
2033 static void ixj_ring_start(IXJ *j)
2034 {
2035         j->flags.cringing = 1;
2036         if (ixjdebug & 0x0004)
2037                 printk(KERN_INFO "IXJ Cadence Ringing Start /dev/phone%d\n", j->board);
2038         if (ixj_hookstate(j) & 1) {
2039                 if (j->port == PORT_POTS)
2040                         ixj_ring_off(j);
2041                 j->flags.cringing = 0;
2042                 if (ixjdebug & 0x0004)
2043                         printk(KERN_INFO "IXJ Cadence Ringing Stopped /dev/phone%d off hook\n", j->board);
2044         } else if(j->cadence_f[5].enable && (!j->cadence_f[5].en_filter)) {
2045                 j->ring_cadence_jif = jiffies;
2046                 j->flags.cidsent = j->flags.cidring = 0;
2047                 j->cadence_f[5].state = 0;
2048                 if(j->cadence_f[5].on1)
2049                         ixj_ring_on(j);
2050         } else {
2051                 j->ring_cadence_jif = jiffies;
2052                 j->ring_cadence_t = 15;
2053                 if (j->ring_cadence & 1 << j->ring_cadence_t) {
2054                         ixj_ring_on(j);
2055                 } else {
2056                         ixj_ring_off(j);
2057                 }
2058                 j->flags.cidsent = j->flags.cidring = j->flags.firstring = 0;
2059         }
2060 }
2061
2062 static int ixj_ring(IXJ *j)
2063 {
2064         char cntr;
2065         unsigned long jif;
2066
2067         j->flags.ringing = 1;
2068         if (ixj_hookstate(j) & 1) {
2069                 ixj_ring_off(j);
2070                 j->flags.ringing = 0;
2071                 return 1;
2072         }
2073         for (cntr = 0; cntr < j->maxrings; cntr++) {
2074                 jif = jiffies + (1 * hertz);
2075                 ixj_ring_on(j);
2076                 while (time_before(jiffies, jif)) {
2077                         if (ixj_hookstate(j) & 1) {
2078                                 ixj_ring_off(j);
2079                                 j->flags.ringing = 0;
2080                                 return 1;
2081                         }
2082                         schedule_timeout_interruptible(1);
2083                         if (signal_pending(current))
2084                                 break;
2085                 }
2086                 jif = jiffies + (3 * hertz);
2087                 ixj_ring_off(j);
2088                 while (time_before(jiffies, jif)) {
2089                         if (ixj_hookstate(j) & 1) {
2090                                 msleep(10);
2091                                 if (ixj_hookstate(j) & 1) {
2092                                         j->flags.ringing = 0;
2093                                         return 1;
2094                                 }
2095                         }
2096                         schedule_timeout_interruptible(1);
2097                         if (signal_pending(current))
2098                                 break;
2099                 }
2100         }
2101         ixj_ring_off(j);
2102         j->flags.ringing = 0;
2103         return 0;
2104 }
2105
2106 static int ixj_open(struct phone_device *p, struct file *file_p)
2107 {
2108         IXJ *j = get_ixj(p->board);
2109         file_p->private_data = j;
2110
2111         if (!j->DSPbase)
2112                 return -ENODEV;
2113
2114         if (file_p->f_mode & FMODE_READ) {
2115                 if(!j->readers) {
2116                         j->readers++;
2117                 } else {
2118                         return -EBUSY;
2119                 }
2120         }
2121
2122         if (file_p->f_mode & FMODE_WRITE) {
2123                 if(!j->writers) {
2124                         j->writers++;
2125                 } else {
2126                         if (file_p->f_mode & FMODE_READ){
2127                                 j->readers--;
2128                         }
2129                         return -EBUSY;
2130                 }
2131         }
2132
2133         if (j->cardtype == QTI_PHONECARD) {
2134                 j->pslic.bits.powerdown = 0;
2135                 j->psccr.bits.dev = 3;
2136                 j->psccr.bits.rw = 0;
2137                 outw_p(j->psccr.byte << 8 | j->pslic.byte, j->XILINXbase + 0x00);
2138                 ixj_PCcontrol_wait(j);
2139         }
2140
2141         j->flags.cidplay = 0;
2142         j->flags.cidcw_ack = 0;
2143
2144         if (ixjdebug & 0x0002)
2145                 printk(KERN_INFO "Opening board %d\n", p->board);
2146
2147         j->framesread = j->frameswritten = 0;
2148         return 0;
2149 }
2150
2151 static int ixj_release(struct inode *inode, struct file *file_p)
2152 {
2153         IXJ_TONE ti;
2154         int cnt;
2155         IXJ *j = file_p->private_data;
2156         int board = j->p.board;
2157
2158         /*
2159          *    Set up locks to ensure that only one process is talking to the DSP at a time.
2160          *    This is necessary to keep the DSP from locking up.
2161          */
2162         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
2163                 schedule_timeout_interruptible(1);
2164         if (ixjdebug & 0x0002)
2165                 printk(KERN_INFO "Closing board %d\n", NUM(inode));
2166
2167         if (j->cardtype == QTI_PHONECARD)
2168                 ixj_set_port(j, PORT_SPEAKER);
2169         else
2170                 ixj_set_port(j, PORT_POTS);
2171
2172         aec_stop(j);
2173         ixj_play_stop(j);
2174         ixj_record_stop(j);
2175         set_play_volume(j, 0x100);
2176         set_rec_volume(j, 0x100);
2177         ixj_ring_off(j);
2178
2179         /* Restore the tone table to default settings. */
2180         ti.tone_index = 10;
2181         ti.gain0 = 1;
2182         ti.freq0 = hz941;
2183         ti.gain1 = 0;
2184         ti.freq1 = hz1209;
2185         ixj_init_tone(j, &ti);
2186         ti.tone_index = 11;
2187         ti.gain0 = 1;
2188         ti.freq0 = hz941;
2189         ti.gain1 = 0;
2190         ti.freq1 = hz1336;
2191         ixj_init_tone(j, &ti);
2192         ti.tone_index = 12;
2193         ti.gain0 = 1;
2194         ti.freq0 = hz941;
2195         ti.gain1 = 0;
2196         ti.freq1 = hz1477;
2197         ixj_init_tone(j, &ti);
2198         ti.tone_index = 13;
2199         ti.gain0 = 1;
2200         ti.freq0 = hz800;
2201         ti.gain1 = 0;
2202         ti.freq1 = 0;
2203         ixj_init_tone(j, &ti);
2204         ti.tone_index = 14;
2205         ti.gain0 = 1;
2206         ti.freq0 = hz1000;
2207         ti.gain1 = 0;
2208         ti.freq1 = 0;
2209         ixj_init_tone(j, &ti);
2210         ti.tone_index = 15;
2211         ti.gain0 = 1;
2212         ti.freq0 = hz1250;
2213         ti.gain1 = 0;
2214         ti.freq1 = 0;
2215         ixj_init_tone(j, &ti);
2216         ti.tone_index = 16;
2217         ti.gain0 = 1;
2218         ti.freq0 = hz950;
2219         ti.gain1 = 0;
2220         ti.freq1 = 0;
2221         ixj_init_tone(j, &ti);
2222         ti.tone_index = 17;
2223         ti.gain0 = 1;
2224         ti.freq0 = hz1100;
2225         ti.gain1 = 0;
2226         ti.freq1 = 0;
2227         ixj_init_tone(j, &ti);
2228         ti.tone_index = 18;
2229         ti.gain0 = 1;
2230         ti.freq0 = hz1400;
2231         ti.gain1 = 0;
2232         ti.freq1 = 0;
2233         ixj_init_tone(j, &ti);
2234         ti.tone_index = 19;
2235         ti.gain0 = 1;
2236         ti.freq0 = hz1500;
2237         ti.gain1 = 0;
2238         ti.freq1 = 0;
2239         ixj_init_tone(j, &ti);
2240         ti.tone_index = 20;
2241         ti.gain0 = 1;
2242         ti.freq0 = hz1600;
2243         ti.gain1 = 0;
2244         ti.freq1 = 0;
2245         ixj_init_tone(j, &ti);
2246         ti.tone_index = 21;
2247         ti.gain0 = 1;
2248         ti.freq0 = hz1800;
2249         ti.gain1 = 0;
2250         ti.freq1 = 0;
2251         ixj_init_tone(j, &ti);
2252         ti.tone_index = 22;
2253         ti.gain0 = 1;
2254         ti.freq0 = hz2100;
2255         ti.gain1 = 0;
2256         ti.freq1 = 0;
2257         ixj_init_tone(j, &ti);
2258         ti.tone_index = 23;
2259         ti.gain0 = 1;
2260         ti.freq0 = hz1300;
2261         ti.gain1 = 0;
2262         ti.freq1 = 0;
2263         ixj_init_tone(j, &ti);
2264         ti.tone_index = 24;
2265         ti.gain0 = 1;
2266         ti.freq0 = hz2450;
2267         ti.gain1 = 0;
2268         ti.freq1 = 0;
2269         ixj_init_tone(j, &ti);
2270         ti.tone_index = 25;
2271         ti.gain0 = 1;
2272         ti.freq0 = hz350;
2273         ti.gain1 = 0;
2274         ti.freq1 = hz440;
2275         ixj_init_tone(j, &ti);
2276         ti.tone_index = 26;
2277         ti.gain0 = 1;
2278         ti.freq0 = hz440;
2279         ti.gain1 = 0;
2280         ti.freq1 = hz480;
2281         ixj_init_tone(j, &ti);
2282         ti.tone_index = 27;
2283         ti.gain0 = 1;
2284         ti.freq0 = hz480;
2285         ti.gain1 = 0;
2286         ti.freq1 = hz620;
2287         ixj_init_tone(j, &ti);
2288
2289         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
2290
2291         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
2292
2293         j->ex.bits.dtmf_ready = 0;
2294         j->dtmf_state = 0;
2295         j->dtmf_wp = j->dtmf_rp = 0;
2296         j->rec_mode = j->play_mode = -1;
2297         j->flags.ringing = 0;
2298         j->maxrings = MAXRINGS;
2299         j->ring_cadence = USA_RING_CADENCE;
2300         if(j->cadence_f[5].enable) {
2301                 j->cadence_f[5].enable = j->cadence_f[5].en_filter = j->cadence_f[5].state = 0;
2302         }
2303         j->drybuffer = 0;
2304         j->winktime = 320;
2305         j->flags.dtmf_oob = 0;
2306         for (cnt = 0; cnt < 4; cnt++)
2307                 j->cadence_f[cnt].enable = 0;
2308
2309         idle(j);
2310
2311         if(j->cardtype == QTI_PHONECARD) {
2312                 SLIC_SetState(PLD_SLIC_STATE_OC, j);
2313         }
2314
2315         if (file_p->f_mode & FMODE_READ)
2316                 j->readers--;
2317         if (file_p->f_mode & FMODE_WRITE)
2318                 j->writers--;
2319
2320         if (j->read_buffer && !j->readers) {
2321                 kfree(j->read_buffer);
2322                 j->read_buffer = NULL;
2323                 j->read_buffer_size = 0;
2324         }
2325         if (j->write_buffer && !j->writers) {
2326                 kfree(j->write_buffer);
2327                 j->write_buffer = NULL;
2328                 j->write_buffer_size = 0;
2329         }
2330         j->rec_codec = j->play_codec = 0;
2331         j->rec_frame_size = j->play_frame_size = 0;
2332         j->flags.cidsent = j->flags.cidring = 0;
2333         ixj_fasync(-1, file_p, 0);      /* remove from list of async notification */
2334
2335         if(j->cardtype == QTI_LINEJACK && !j->readers && !j->writers) {
2336                 ixj_set_port(j, PORT_PSTN);
2337                 daa_set_mode(j, SOP_PU_SLEEP);
2338                 ixj_set_pots(j, 1);
2339         }
2340         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
2341
2342         /* Set up the default signals for events */
2343         for (cnt = 0; cnt < 35; cnt++)
2344                 j->ixj_signals[cnt] = SIGIO;
2345
2346         /* Set the excetion signal enable flags */
2347         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
2348         j->ex_sig.bits.caller_id = j->ex_sig.bits.pstn_wink = j->ex_sig.bits.f0 = j->ex_sig.bits.f1 = j->ex_sig.bits.f2 =
2349         j->ex_sig.bits.f3 = j->ex_sig.bits.fc0 = j->ex_sig.bits.fc1 = j->ex_sig.bits.fc2 = j->ex_sig.bits.fc3 = 1;
2350
2351         file_p->private_data = NULL;
2352         clear_bit(board, &j->busyflags);
2353         return 0;
2354 }
2355
2356 static int read_filters(IXJ *j)
2357 {
2358         unsigned short fc, cnt, trg;
2359         int var;
2360
2361         trg = 0;
2362         if (ixj_WriteDSPCommand(0x5144, j)) {
2363                 if(ixjdebug & 0x0001) {
2364                         printk(KERN_INFO "Read Frame Counter failed!\n");
2365                 }
2366                 return -1;
2367         }
2368         fc = j->ssr.high << 8 | j->ssr.low;
2369         if (fc == j->frame_count)
2370                 return 1;
2371
2372         j->frame_count = fc;
2373
2374         if (j->dtmf_proc)
2375                 return 1;
2376
2377         var = 10;
2378
2379         for (cnt = 0; cnt < 4; cnt++) {
2380                 if (ixj_WriteDSPCommand(0x5154 + cnt, j)) {
2381                         if(ixjdebug & 0x0001) {
2382                                 printk(KERN_INFO "Select Filter %d failed!\n", cnt);
2383                         }
2384                         return -1;
2385                 }
2386                 if (ixj_WriteDSPCommand(0x515C, j)) {
2387                         if(ixjdebug & 0x0001) {
2388                                 printk(KERN_INFO "Read Filter History %d failed!\n", cnt);
2389                         }
2390                         return -1;
2391                 }
2392                 j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;
2393
2394                 if (j->cadence_f[cnt].enable) {
2395                         if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
2396                                 if (j->cadence_f[cnt].state == 0) {
2397                                         j->cadence_f[cnt].state = 1;
2398                                         j->cadence_f[cnt].on1min = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 - var)) / 10000));
2399                                         j->cadence_f[cnt].on1dot = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100)) / 10000));
2400                                         j->cadence_f[cnt].on1max = jiffies + (long)((j->cadence_f[cnt].on1 * (hertz * (100 + var)) / 10000));
2401                                 } else if (j->cadence_f[cnt].state == 2 &&
2402                                            (time_after(jiffies, j->cadence_f[cnt].off1min) &&
2403                                             time_before(jiffies, j->cadence_f[cnt].off1max))) {
2404                                         if (j->cadence_f[cnt].on2) {
2405                                                 j->cadence_f[cnt].state = 3;
2406                                                 j->cadence_f[cnt].on2min = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 - var)) / 10000));
2407                                                 j->cadence_f[cnt].on2dot = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100)) / 10000));
2408                                                 j->cadence_f[cnt].on2max = jiffies + (long)((j->cadence_f[cnt].on2 * (hertz * (100 + var)) / 10000));
2409                                         } else {
2410                                                 j->cadence_f[cnt].state = 7;
2411                                         }
2412                                 } else if (j->cadence_f[cnt].state == 4 &&
2413                                            (time_after(jiffies, j->cadence_f[cnt].off2min) &&
2414                                             time_before(jiffies, j->cadence_f[cnt].off2max))) {
2415                                         if (j->cadence_f[cnt].on3) {
2416                                                 j->cadence_f[cnt].state = 5;
2417                                                 j->cadence_f[cnt].on3min = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 - var)) / 10000));
2418                                                 j->cadence_f[cnt].on3dot = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100)) / 10000));
2419                                                 j->cadence_f[cnt].on3max = jiffies + (long)((j->cadence_f[cnt].on3 * (hertz * (100 + var)) / 10000));
2420                                         } else {
2421                                                 j->cadence_f[cnt].state = 7;
2422                                         }
2423                                 } else {
2424                                         j->cadence_f[cnt].state = 0;
2425                                 }
2426                         } else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
2427                                 if (j->cadence_f[cnt].state == 1) {
2428                                         if(!j->cadence_f[cnt].on1) {
2429                                                 j->cadence_f[cnt].state = 7;
2430                                         } else if((time_after(jiffies, j->cadence_f[cnt].on1min) &&
2431                                           time_before(jiffies, j->cadence_f[cnt].on1max))) {
2432                                                 if(j->cadence_f[cnt].off1) {
2433                                                         j->cadence_f[cnt].state = 2;
2434                                                         j->cadence_f[cnt].off1min = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 - var)) / 10000));
2435                                                         j->cadence_f[cnt].off1dot = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100)) / 10000));
2436                                                         j->cadence_f[cnt].off1max = jiffies + (long)((j->cadence_f[cnt].off1 * (hertz * (100 + var)) / 10000));
2437                                                 } else {
2438                                                         j->cadence_f[cnt].state = 7;
2439                                                 }
2440                                         } else {
2441                                                 j->cadence_f[cnt].state = 0;
2442                                         }
2443                                 } else if (j->cadence_f[cnt].state == 3) {
2444                                         if((time_after(jiffies, j->cadence_f[cnt].on2min) &&
2445                                             time_before(jiffies, j->cadence_f[cnt].on2max))) {
2446                                                 if(j->cadence_f[cnt].off2) {
2447                                                         j->cadence_f[cnt].state = 4;
2448                                                         j->cadence_f[cnt].off2min = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 - var)) / 10000));
2449                                                         j->cadence_f[cnt].off2dot = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100)) / 10000));
2450                                                         j->cadence_f[cnt].off2max = jiffies + (long)((j->cadence_f[cnt].off2 * (hertz * (100 + var)) / 10000));
2451                                                 } else {
2452                                                         j->cadence_f[cnt].state = 7;
2453                                                 }
2454                                         } else {
2455                                                 j->cadence_f[cnt].state = 0;
2456                                         }
2457                                 } else if (j->cadence_f[cnt].state == 5) {
2458                                         if ((time_after(jiffies, j->cadence_f[cnt].on3min) &&
2459                                             time_before(jiffies, j->cadence_f[cnt].on3max))) {
2460                                                 if(j->cadence_f[cnt].off3) {
2461                                                         j->cadence_f[cnt].state = 6;
2462                                                         j->cadence_f[cnt].off3min = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 - var)) / 10000));
2463                                                         j->cadence_f[cnt].off3dot = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100)) / 10000));
2464                                                         j->cadence_f[cnt].off3max = jiffies + (long)((j->cadence_f[cnt].off3 * (hertz * (100 + var)) / 10000));
2465                                                 } else {
2466                                                         j->cadence_f[cnt].state = 7;
2467                                                 }
2468                                         } else {
2469                                                 j->cadence_f[cnt].state = 0;
2470                                         }
2471                                 } else {
2472                                         j->cadence_f[cnt].state = 0;
2473                                 }
2474                         } else {
2475                                 switch(j->cadence_f[cnt].state) {
2476                                         case 1:
2477                                                 if(time_after(jiffies, j->cadence_f[cnt].on1dot) &&
2478                                                    !j->cadence_f[cnt].off1 &&
2479                                                    !j->cadence_f[cnt].on2 && !j->cadence_f[cnt].off2 &&
2480                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2481                                                         j->cadence_f[cnt].state = 7;
2482                                                 }
2483                                                 break;
2484                                         case 3:
2485                                                 if(time_after(jiffies, j->cadence_f[cnt].on2dot) &&
2486                                                    !j->cadence_f[cnt].off2 &&
2487                                                    !j->cadence_f[cnt].on3 && !j->cadence_f[cnt].off3) {
2488                                                         j->cadence_f[cnt].state = 7;
2489                                                 }
2490                                                 break;
2491                                         case 5:
2492                                                 if(time_after(jiffies, j->cadence_f[cnt].on3dot) &&
2493                                                    !j->cadence_f[cnt].off3) {
2494                                                         j->cadence_f[cnt].state = 7;
2495                                                 }
2496                                                 break;
2497                                 }
2498                         }
2499
2500                         if (ixjdebug & 0x0040) {
2501                                 printk(KERN_INFO "IXJ Tone Cadence state = %d /dev/phone%d at %ld\n", j->cadence_f[cnt].state, j->board, jiffies);
2502                                 switch(j->cadence_f[cnt].state) {
2503                                         case 0:
2504                                                 printk(KERN_INFO "IXJ /dev/phone%d No Tone detected\n", j->board);
2505                                                 break;
2506                                         case 1:
2507                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %u %ld - %ld - %ld\n", j->board,
2508                                         j->cadence_f[cnt].on1, j->cadence_f[cnt].on1min, j->cadence_f[cnt].on1dot, j->cadence_f[cnt].on1max);
2509                                                 break;
2510                                         case 2:
2511                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off1min,
2512                                                                                                                         j->cadence_f[cnt].off1max);
2513                                                 break;
2514                                         case 3:
2515                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on2min,
2516                                                                                                                         j->cadence_f[cnt].on2max);
2517                                                 break;
2518                                         case 4:
2519                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off2min,
2520                                                                                                                         j->cadence_f[cnt].off2max);
2521                                                 break;
2522                                         case 5:
2523                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].on3min,
2524                                                                                                                         j->cadence_f[cnt].on3max);
2525                                                 break;
2526                                         case 6:
2527                                                 printk(KERN_INFO "IXJ /dev/phone%d Next Tone Cadence state at %ld - %ld\n", j->board, j->cadence_f[cnt].off3min,
2528                                                                                                                         j->cadence_f[cnt].off3max);
2529                                                 break;
2530                                 }
2531                         }
2532                 }
2533                 if (j->cadence_f[cnt].state == 7) {
2534                         j->cadence_f[cnt].state = 0;
2535                         if (j->cadence_f[cnt].enable == 1)
2536                                 j->cadence_f[cnt].enable = 0;
2537                         switch (cnt) {
2538                         case 0:
2539                                 if(ixjdebug & 0x0020) {
2540                                         printk(KERN_INFO "Filter Cadence 0 triggered %ld\n", jiffies);
2541                                 }
2542                                 j->ex.bits.fc0 = 1;
2543                                 ixj_kill_fasync(j, SIG_FC0, POLL_IN);
2544                                 break;
2545                         case 1:
2546                                 if(ixjdebug & 0x0020) {
2547                                         printk(KERN_INFO "Filter Cadence 1 triggered %ld\n", jiffies);
2548                                 }
2549                                 j->ex.bits.fc1 = 1;
2550                                 ixj_kill_fasync(j, SIG_FC1, POLL_IN);
2551                                 break;
2552                         case 2:
2553                                 if(ixjdebug & 0x0020) {
2554                                         printk(KERN_INFO "Filter Cadence 2 triggered %ld\n", jiffies);
2555                                 }
2556                                 j->ex.bits.fc2 = 1;
2557                                 ixj_kill_fasync(j, SIG_FC2, POLL_IN);
2558                                 break;
2559                         case 3:
2560                                 if(ixjdebug & 0x0020) {
2561                                         printk(KERN_INFO "Filter Cadence 3 triggered %ld\n", jiffies);
2562                                 }
2563                                 j->ex.bits.fc3 = 1;
2564                                 ixj_kill_fasync(j, SIG_FC3, POLL_IN);
2565                                 break;
2566                         }
2567                 }
2568                 if (j->filter_en[cnt] && ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
2569                                           (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)))) {
2570                         if((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12))) {
2571                                 trg = 1;
2572                         } else if((j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
2573                                 trg = 0;
2574                         }
2575                         switch (cnt) {
2576                         case 0:
2577                                 if(ixjdebug & 0x0020) {
2578                                         printk(KERN_INFO "Filter 0 triggered %d at %ld\n", trg, jiffies);
2579                                 }
2580                                 j->ex.bits.f0 = 1;
2581                                 ixj_kill_fasync(j, SIG_F0, POLL_IN);
2582                                 break;
2583                         case 1:
2584                                 if(ixjdebug & 0x0020) {
2585                                         printk(KERN_INFO "Filter 1 triggered %d at %ld\n", trg, jiffies);
2586                                 }
2587                                 j->ex.bits.f1 = 1;
2588                                 ixj_kill_fasync(j, SIG_F1, POLL_IN);
2589                                 break;
2590                         case 2:
2591                                 if(ixjdebug & 0x0020) {
2592                                         printk(KERN_INFO "Filter 2 triggered %d at %ld\n", trg, jiffies);
2593                                 }
2594                                 j->ex.bits.f2 = 1;
2595                                 ixj_kill_fasync(j, SIG_F2, POLL_IN);
2596                                 break;
2597                         case 3:
2598                                 if(ixjdebug & 0x0020) {
2599                                         printk(KERN_INFO "Filter 3 triggered %d at %ld\n", trg, jiffies);
2600                                 }
2601                                 j->ex.bits.f3 = 1;
2602                                 ixj_kill_fasync(j, SIG_F3, POLL_IN);
2603                                 break;
2604                         }
2605                 }
2606         }
2607         return 0;
2608 }
2609
2610 static int LineMonitor(IXJ *j)
2611 {
2612         if (j->dtmf_proc) {
2613                 return -1;
2614         }
2615         j->dtmf_proc = 1;
2616
2617         if (ixj_WriteDSPCommand(0x7000, j))             /* Line Monitor */
2618                 return -1;
2619
2620         j->dtmf.bytes.high = j->ssr.high;
2621         j->dtmf.bytes.low = j->ssr.low;
2622         if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
2623                 j->dtmf_state = 1;
2624                 j->dtmf_current = j->dtmf.bits.digit;
2625         }
2626         if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)  /* && j->dtmf_wp != j->dtmf_rp) */
2627          {
2628                 if(!j->cidcw_wait) {
2629                         j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
2630                         j->dtmf_wp++;
2631                         if (j->dtmf_wp == 79)
2632                                 j->dtmf_wp = 0;
2633                         j->ex.bits.dtmf_ready = 1;
2634                         if(j->ex_sig.bits.dtmf_ready) {
2635                                 ixj_kill_fasync(j, SIG_DTMF_READY, POLL_IN);
2636                         }
2637                 }
2638                 else if(j->dtmf_current == 0x00 || j->dtmf_current == 0x0D) {
2639                         if(ixjdebug & 0x0020) {
2640                                 printk("IXJ phone%d saw CIDCW Ack DTMF %d from display at %ld\n", j->board, j->dtmf_current, jiffies);
2641                         }
2642                         j->flags.cidcw_ack = 1;
2643                 }
2644                 j->dtmf_state = 0;
2645         }
2646         j->dtmf_proc = 0;
2647
2648         return 0;
2649 }
2650
2651 /************************************************************************
2652 *
2653 * Functions to allow alaw <-> ulaw conversions.
2654 *
2655 ************************************************************************/
2656
2657 static void ulaw2alaw(unsigned char *buff, unsigned long len)
2658 {
2659         static unsigned char table_ulaw2alaw[] =
2660         {
2661                 0x2A, 0x2B, 0x28, 0x29, 0x2E, 0x2F, 0x2C, 0x2D,
2662                 0x22, 0x23, 0x20, 0x21, 0x26, 0x27, 0x24, 0x25,
2663                 0x3A, 0x3B, 0x38, 0x39, 0x3E, 0x3F, 0x3C, 0x3D,
2664                 0x32, 0x33, 0x30, 0x31, 0x36, 0x37, 0x34, 0x35,
2665                 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D, 0x02,
2666                 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05, 0x1A,
2667                 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D, 0x12,
2668                 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, 0x6B,
2669                 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D, 0x62, 0x63,
2670                 0x60, 0x61, 0x66, 0x67, 0x64, 0x65, 0x7B, 0x79,
2671                 0x7E, 0x7F, 0x7C, 0x7D, 0x72, 0x73, 0x70, 0x71,
2672                 0x76, 0x77, 0x74, 0x75, 0x4B, 0x49, 0x4F, 0x4D,
2673                 0x42, 0x43, 0x40, 0x41, 0x46, 0x47, 0x44, 0x45,
2674                 0x5A, 0x5B, 0x58, 0x59, 0x5E, 0x5F, 0x5C, 0x5D,
2675                 0x52, 0x52, 0x53, 0x53, 0x50, 0x50, 0x51, 0x51,
2676                 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55, 0xD5,
2677                 0xAA, 0xAB, 0xA8, 0xA9, 0xAE, 0xAF, 0xAC, 0xAD,
2678                 0xA2, 0xA3, 0xA0, 0xA1, 0xA6, 0xA7, 0xA4, 0xA5,
2679                 0xBA, 0xBB, 0xB8, 0xB9, 0xBE, 0xBF, 0xBC, 0xBD,
2680                 0xB2, 0xB3, 0xB0, 0xB1, 0xB6, 0xB7, 0xB4, 0xB5,
2681                 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D, 0x82,
2682                 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85, 0x9A,
2683                 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D, 0x92,
2684                 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, 0xEB,
2685                 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED, 0xE2, 0xE3,
2686                 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5, 0xFB, 0xF9,
2687                 0xFE, 0xFF, 0xFC, 0xFD, 0xF2, 0xF3, 0xF0, 0xF1,
2688                 0xF6, 0xF7, 0xF4, 0xF5, 0xCB, 0xC9, 0xCF, 0xCD,
2689                 0xC2, 0xC3, 0xC0, 0xC1, 0xC6, 0xC7, 0xC4, 0xC5,
2690                 0xDA, 0xDB, 0xD8, 0xD9, 0xDE, 0xDF, 0xDC, 0xDD,
2691                 0xD2, 0xD2, 0xD3, 0xD3, 0xD0, 0xD0, 0xD1, 0xD1,
2692                 0xD6, 0xD6, 0xD7, 0xD7, 0xD4, 0xD4, 0xD5, 0xD5
2693         };
2694
2695         while (len--)
2696         {
2697                 *buff = table_ulaw2alaw[*(unsigned char *)buff];
2698                 buff++;
2699         }
2700 }
2701
2702 static void alaw2ulaw(unsigned char *buff, unsigned long len)
2703 {
2704         static unsigned char table_alaw2ulaw[] =
2705         {
2706                 0x29, 0x2A, 0x27, 0x28, 0x2D, 0x2E, 0x2B, 0x2C,
2707                 0x21, 0x22, 0x1F, 0x20, 0x25, 0x26, 0x23, 0x24,
2708                 0x39, 0x3A, 0x37, 0x38, 0x3D, 0x3E, 0x3B, 0x3C,
2709                 0x31, 0x32, 0x2F, 0x30, 0x35, 0x36, 0x33, 0x34,
2710                 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
2711                 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
2712                 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
2713                 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
2714                 0x62, 0x63, 0x60, 0x61, 0x66, 0x67, 0x64, 0x65,
2715                 0x5D, 0x5D, 0x5C, 0x5C, 0x5F, 0x5F, 0x5E, 0x5E,
2716                 0x74, 0x76, 0x70, 0x72, 0x7C, 0x7E, 0x78, 0x7A,
2717                 0x6A, 0x6B, 0x68, 0x69, 0x6E, 0x6F, 0x6C, 0x6D,
2718                 0x48, 0x49, 0x46, 0x47, 0x4C, 0x4D, 0x4A, 0x4B,
2719                 0x40, 0x41, 0x3F, 0x3F, 0x44, 0x45, 0x42, 0x43,
2720                 0x56, 0x57, 0x54, 0x55, 0x5A, 0x5B, 0x58, 0x59,
2721                 0x4F, 0x4F, 0x4E, 0x4E, 0x52, 0x53, 0x50, 0x51,
2722                 0xA9, 0xAA, 0xA7, 0xA8, 0xAD, 0xAE, 0xAB, 0xAC,
2723                 0xA1, 0xA2, 0x9F, 0xA0, 0xA5, 0xA6, 0xA3, 0xA4,
2724                 0xB9, 0xBA, 0xB7, 0xB8, 0xBD, 0xBE, 0xBB, 0xBC,
2725                 0xB1, 0xB2, 0xAF, 0xB0, 0xB5, 0xB6, 0xB3, 0xB4,
2726                 0x8A, 0x8B, 0x88, 0x89, 0x8E, 0x8F, 0x8C, 0x8D,
2727                 0x82, 0x83, 0x80, 0x81, 0x86, 0x87, 0x84, 0x85,
2728                 0x9A, 0x9B, 0x98, 0x99, 0x9E, 0x9F, 0x9C, 0x9D,
2729                 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95,
2730                 0xE2, 0xE3, 0xE0, 0xE1, 0xE6, 0xE7, 0xE4, 0xE5,
2731                 0xDD, 0xDD, 0xDC, 0xDC, 0xDF, 0xDF, 0xDE, 0xDE,
2732                 0xF4, 0xF6, 0xF0, 0xF2, 0xFC, 0xFE, 0xF8, 0xFA,
2733                 0xEA, 0xEB, 0xE8, 0xE9, 0xEE, 0xEF, 0xEC, 0xED,
2734                 0xC8, 0xC9, 0xC6, 0xC7, 0xCC, 0xCD, 0xCA, 0xCB,
2735                 0xC0, 0xC1, 0xBF, 0xBF, 0xC4, 0xC5, 0xC2, 0xC3,
2736                 0xD6, 0xD7, 0xD4, 0xD5, 0xDA, 0xDB, 0xD8, 0xD9,
2737                 0xCF, 0xCF, 0xCE, 0xCE, 0xD2, 0xD3, 0xD0, 0xD1
2738         };
2739
2740         while (len--)
2741         {
2742                 *buff = table_alaw2ulaw[*(unsigned char *)buff];
2743                 buff++;
2744         }
2745 }
2746
2747 static ssize_t ixj_read(struct file * file_p, char __user *buf, size_t length, loff_t * ppos)
2748 {
2749         unsigned long i = *ppos;
2750         IXJ * j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2751
2752         DECLARE_WAITQUEUE(wait, current);
2753
2754         if (j->flags.inread)
2755                 return -EALREADY;
2756
2757         j->flags.inread = 1;
2758
2759         add_wait_queue(&j->read_q, &wait);
2760         set_current_state(TASK_INTERRUPTIBLE);
2761         mb();
2762
2763         while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
2764                 ++j->read_wait;
2765                 if (file_p->f_flags & O_NONBLOCK) {
2766                         set_current_state(TASK_RUNNING);
2767                         remove_wait_queue(&j->read_q, &wait);
2768                         j->flags.inread = 0;
2769                         return -EAGAIN;
2770                 }
2771                 if (!ixj_hookstate(j)) {
2772                         set_current_state(TASK_RUNNING);
2773                         remove_wait_queue(&j->read_q, &wait);
2774                         j->flags.inread = 0;
2775                         return 0;
2776                 }
2777                 interruptible_sleep_on(&j->read_q);
2778                 if (signal_pending(current)) {
2779                         set_current_state(TASK_RUNNING);
2780                         remove_wait_queue(&j->read_q, &wait);
2781                         j->flags.inread = 0;
2782                         return -EINTR;
2783                 }
2784         }
2785
2786         remove_wait_queue(&j->read_q, &wait);
2787         set_current_state(TASK_RUNNING);
2788         /* Don't ever copy more than the user asks */
2789         if(j->rec_codec == ALAW)
2790                 ulaw2alaw(j->read_buffer, min(length, j->read_buffer_size));
2791         i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
2792         j->read_buffer_ready = 0;
2793         if (i) {
2794                 j->flags.inread = 0;
2795                 return -EFAULT;
2796         } else {
2797                 j->flags.inread = 0;
2798                 return min(length, j->read_buffer_size);
2799         }
2800 }
2801
2802 static ssize_t ixj_enhanced_read(struct file * file_p, char __user *buf, size_t length,
2803                           loff_t * ppos)
2804 {
2805         int pre_retval;
2806         ssize_t read_retval = 0;
2807         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2808
2809         pre_retval = ixj_PreRead(j, 0L);
2810         switch (pre_retval) {
2811         case NORMAL:
2812                 read_retval = ixj_read(file_p, buf, length, ppos);
2813                 ixj_PostRead(j, 0L);
2814                 break;
2815         case NOPOST:
2816                 read_retval = ixj_read(file_p, buf, length, ppos);
2817                 break;
2818         case POSTONLY:
2819                 ixj_PostRead(j, 0L);
2820                 break;
2821         default:
2822                 read_retval = pre_retval;
2823         }
2824         return read_retval;
2825 }
2826
2827 static ssize_t ixj_write(struct file *file_p, const char __user *buf, size_t count, loff_t * ppos)
2828 {
2829         unsigned long i = *ppos;
2830         IXJ *j = file_p->private_data;
2831
2832         DECLARE_WAITQUEUE(wait, current);
2833
2834         if (j->flags.inwrite)
2835                 return -EALREADY;
2836
2837         j->flags.inwrite = 1;
2838
2839         add_wait_queue(&j->write_q, &wait);
2840         set_current_state(TASK_INTERRUPTIBLE);
2841         mb();
2842
2843
2844         while (!j->write_buffers_empty) {
2845                 ++j->write_wait;
2846                 if (file_p->f_flags & O_NONBLOCK) {
2847                         set_current_state(TASK_RUNNING);
2848                         remove_wait_queue(&j->write_q, &wait);
2849                         j->flags.inwrite = 0;
2850                         return -EAGAIN;
2851                 }
2852                 if (!ixj_hookstate(j)) {
2853                         set_current_state(TASK_RUNNING);
2854                         remove_wait_queue(&j->write_q, &wait);
2855                         j->flags.inwrite = 0;
2856                         return 0;
2857                 }
2858                 interruptible_sleep_on(&j->write_q);
2859                 if (signal_pending(current)) {
2860                         set_current_state(TASK_RUNNING);
2861                         remove_wait_queue(&j->write_q, &wait);
2862                         j->flags.inwrite = 0;
2863                         return -EINTR;
2864                 }
2865         }
2866         set_current_state(TASK_RUNNING);
2867         remove_wait_queue(&j->write_q, &wait);
2868         if (j->write_buffer_wp + count >= j->write_buffer_end)
2869                 j->write_buffer_wp = j->write_buffer;
2870         i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
2871         if (i) {
2872                 j->flags.inwrite = 0;
2873                 return -EFAULT;
2874         }
2875        if(j->play_codec == ALAW)
2876                alaw2ulaw(j->write_buffer_wp, min(count, j->write_buffer_size));
2877         j->flags.inwrite = 0;
2878         return min(count, j->write_buffer_size);
2879 }
2880
2881 static ssize_t ixj_enhanced_write(struct file * file_p, const char __user *buf, size_t count, loff_t * ppos)
2882 {
2883         int pre_retval;
2884         ssize_t write_retval = 0;
2885
2886         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
2887
2888         pre_retval = ixj_PreWrite(j, 0L);
2889         switch (pre_retval) {
2890         case NORMAL:
2891                 write_retval = ixj_write(file_p, buf, count, ppos);
2892                 if (write_retval > 0) {
2893                         ixj_PostWrite(j, 0L);
2894                         j->write_buffer_wp += write_retval;
2895                         j->write_buffers_empty--;
2896                 }
2897                 break;
2898         case NOPOST:
2899                 write_retval = ixj_write(file_p, buf, count, ppos);
2900                 if (write_retval > 0) {
2901                         j->write_buffer_wp += write_retval;
2902                         j->write_buffers_empty--;
2903                 }
2904                 break;
2905         case POSTONLY:
2906                 ixj_PostWrite(j, 0L);
2907                 break;
2908         default:
2909                 write_retval = pre_retval;
2910         }
2911         return write_retval;
2912 }
2913
2914 static void ixj_read_frame(IXJ *j)
2915 {
2916         int cnt, dly;
2917
2918         if (j->read_buffer) {
2919                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2920                         if (!(cnt % 16) && !IsRxReady(j)) {
2921                                 dly = 0;
2922                                 while (!IsRxReady(j)) {
2923                                         if (dly++ > 5) {
2924                                                 dly = 0;
2925                                                 break;
2926                                         }
2927                                         udelay(10);
2928                                 }
2929                         }
2930                         /* Throw away word 0 of the 8021 compressed format to get standard G.729. */
2931                         if (j->rec_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
2932                                 inb_p(j->DSPbase + 0x0E);
2933                                 inb_p(j->DSPbase + 0x0F);
2934                         }
2935                         *(j->read_buffer + cnt) = inb_p(j->DSPbase + 0x0E);
2936                         *(j->read_buffer + cnt + 1) = inb_p(j->DSPbase + 0x0F);
2937                 }
2938                 ++j->framesread;
2939                 if (j->intercom != -1) {
2940                         if (IsTxReady(get_ixj(j->intercom))) {
2941                                 for (cnt = 0; cnt < j->rec_frame_size * 2; cnt += 2) {
2942                                         if (!(cnt % 16) && !IsTxReady(j)) {
2943                                                 dly = 0;
2944                                                 while (!IsTxReady(j)) {
2945                                                         if (dly++ > 5) {
2946                                                                 dly = 0;
2947                                                                 break;
2948                                                         }
2949                                                         udelay(10);
2950                                                 }
2951                                         }
2952                                         outb_p(*(j->read_buffer + cnt), get_ixj(j->intercom)->DSPbase + 0x0C);
2953                                         outb_p(*(j->read_buffer + cnt + 1), get_ixj(j->intercom)->DSPbase + 0x0D);
2954                                 }
2955                                 get_ixj(j->intercom)->frameswritten++;
2956                         }
2957                 } else {
2958                         j->read_buffer_ready = 1;
2959                         wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
2960
2961                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
2962
2963                         if(j->ixj_signals[SIG_READ_READY])
2964                                 ixj_kill_fasync(j, SIG_READ_READY, POLL_OUT);
2965                 }
2966         }
2967 }
2968
2969 static short fsk[][6][20] =
2970 {
2971         {
2972                 {
2973                         0, 17846, 29934, 32364, 24351, 8481, -10126, -25465, -32587, -29196,
2974                         -16384, 1715, 19260, 30591, 32051, 23170, 6813, -11743, -26509, -32722
2975                 },
2976                 {
2977                         -28377, -14876, 3425, 20621, 31163, 31650, 21925, 5126, -13328, -27481,
2978                         -32767, -27481, -13328, 5126, 21925, 31650, 31163, 20621, 3425, -14876
2979                 },
2980                 {
2981                         -28377, -32722, -26509, -11743, 6813, 23170, 32051, 30591, 19260, 1715,
2982                         -16384, -29196, -32587, -25465, -10126, 8481, 24351, 32364, 29934, 17846
2983                 },
2984                 {
2985                         0, -17846, -29934, -32364, -24351, -8481, 10126, 25465, 32587, 29196,
2986                         16384, -1715, -19260, -30591, -32051, -23170, -6813, 11743, 26509, 32722
2987                 },
2988                 {
2989                         28377, 14876, -3425, -20621, -31163, -31650, -21925, -5126, 13328, 27481,
2990                         32767, 27481, 13328, -5126, -21925, -31650, -31163, -20621, -3425, 14876
2991                 },
2992                 {
2993                         28377, 32722, 26509, 11743, -6813, -23170, -32051, -30591, -19260, -1715,
2994                         16384, 29196, 32587, 25465, 10126, -8481, -24351, -32364, -29934, -17846
2995                 }
2996         },
2997         {
2998                 {
2999                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126,
3000                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126
3001                 },
3002                 {
3003                         -28377, -21925, -13328, -3425, 6813, 16384, 24351, 29934, 32587, 32051,
3004                         28377, 21925, 13328, 3425, -6813, -16384, -24351, -29934, -32587, -32051
3005                 },
3006                 {
3007                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925,
3008                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925
3009                 },
3010                 {
3011                         0, -10126, -19260, -26509, -31163, -32767, -31163, -26509, -19260, -10126,
3012                         0, 10126, 19260, 26509, 31163, 32767, 31163, 26509, 19260, 10126
3013                 },
3014                 {
3015                         28377, 21925, 13328, 3425, -6813, -16383, -24351, -29934, -32587, -32051,
3016                         -28377, -21925, -13328, -3425, 6813, 16383, 24351, 29934, 32587, 32051
3017                 },
3018                 {
3019                         28377, 32051, 32587, 29934, 24351, 16384, 6813, -3425, -13328, -21925,
3020                         -28377, -32051, -32587, -29934, -24351, -16384, -6813, 3425, 13328, 21925
3021                 }
3022         }
3023 };
3024
3025
3026 static void ixj_write_cid_bit(IXJ *j, int bit)
3027 {
3028         while (j->fskcnt < 20) {
3029                 if(j->fskdcnt < (j->fsksize - 1))
3030                         j->fskdata[j->fskdcnt++] = fsk[bit][j->fskz][j->fskcnt];
3031
3032                 j->fskcnt += 3;
3033         }
3034         j->fskcnt %= 20;
3035
3036         if (!bit)
3037                 j->fskz++;
3038         if (j->fskz >= 6)
3039                 j->fskz = 0;
3040
3041 }
3042
3043 static void ixj_write_cid_byte(IXJ *j, char byte)
3044 {
3045         IXJ_CBYTE cb;
3046
3047                 cb.cbyte = byte;
3048                 ixj_write_cid_bit(j, 0);
3049                 ixj_write_cid_bit(j, cb.cbits.b0 ? 1 : 0);
3050                 ixj_write_cid_bit(j, cb.cbits.b1 ? 1 : 0);
3051                 ixj_write_cid_bit(j, cb.cbits.b2 ? 1 : 0);
3052                 ixj_write_cid_bit(j, cb.cbits.b3 ? 1 : 0);
3053                 ixj_write_cid_bit(j, cb.cbits.b4 ? 1 : 0);
3054                 ixj_write_cid_bit(j, cb.cbits.b5 ? 1 : 0);
3055                 ixj_write_cid_bit(j, cb.cbits.b6 ? 1 : 0);
3056                 ixj_write_cid_bit(j, cb.cbits.b7 ? 1 : 0);
3057                 ixj_write_cid_bit(j, 1);
3058 }
3059
3060 static void ixj_write_cid_seize(IXJ *j)
3061 {
3062         int cnt;
3063
3064         for (cnt = 0; cnt < 150; cnt++) {
3065                 ixj_write_cid_bit(j, 0);
3066                 ixj_write_cid_bit(j, 1);
3067         }
3068         for (cnt = 0; cnt < 180; cnt++) {
3069                 ixj_write_cid_bit(j, 1);
3070         }
3071 }
3072
3073 static void ixj_write_cidcw_seize(IXJ *j)
3074 {
3075         int cnt;
3076
3077         for (cnt = 0; cnt < 80; cnt++) {
3078                 ixj_write_cid_bit(j, 1);
3079         }
3080 }
3081
3082 static int ixj_write_cid_string(IXJ *j, char *s, int checksum)
3083 {
3084         int cnt;
3085
3086         for (cnt = 0; cnt < strlen(s); cnt++) {
3087                 ixj_write_cid_byte(j, s[cnt]);
3088                 checksum = (checksum + s[cnt]);
3089         }
3090         return checksum;
3091 }
3092
3093 static void ixj_pad_fsk(IXJ *j, int pad)
3094 {
3095         int cnt;
3096
3097         for (cnt = 0; cnt < pad; cnt++) {
3098                 if(j->fskdcnt < (j->fsksize - 1))
3099                         j->fskdata[j->fskdcnt++] = 0x0000;
3100         }
3101         for (cnt = 0; cnt < 720; cnt++) {
3102                 if(j->fskdcnt < (j->fsksize - 1))
3103                         j->fskdata[j->fskdcnt++] = 0x0000;
3104         }
3105 }
3106
3107 static void ixj_pre_cid(IXJ *j)
3108 {
3109         j->cid_play_codec = j->play_codec;
3110         j->cid_play_frame_size = j->play_frame_size;
3111         j->cid_play_volume = get_play_volume(j);
3112         j->cid_play_flag = j->flags.playing;
3113
3114         j->cid_rec_codec = j->rec_codec;
3115         j->cid_rec_volume = get_rec_volume(j);
3116         j->cid_rec_flag = j->flags.recording;
3117
3118         j->cid_play_aec_level = j->aec_level;
3119
3120         switch(j->baseframe.low) {
3121                 case 0xA0:
3122                         j->cid_base_frame_size = 20;
3123                         break;
3124                 case 0x50:
3125                         j->cid_base_frame_size = 10;
3126                         break;
3127                 case 0xF0:
3128                         j->cid_base_frame_size = 30;
3129                         break;
3130         }
3131
3132         ixj_play_stop(j);
3133         ixj_cpt_stop(j);
3134
3135         j->flags.cidplay = 1;
3136
3137         set_base_frame(j, 30);
3138         set_play_codec(j, LINEAR16);
3139         set_play_volume(j, 0x1B);
3140         ixj_play_start(j);
3141 }
3142
3143 static void ixj_post_cid(IXJ *j)
3144 {
3145         ixj_play_stop(j);
3146
3147         if(j->cidsize > 5000) {
3148                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
3149         }
3150         j->flags.cidplay = 0;
3151         if(ixjdebug & 0x0200) {
3152                 printk("IXJ phone%d Finished Playing CallerID data %ld\n", j->board, jiffies);
3153         }
3154
3155         ixj_fsk_free(j);
3156
3157         j->fskdcnt = 0;
3158         set_base_frame(j, j->cid_base_frame_size);
3159         set_play_codec(j, j->cid_play_codec);
3160         ixj_aec_start(j, j->cid_play_aec_level);
3161         set_play_volume(j, j->cid_play_volume);
3162
3163         set_rec_codec(j, j->cid_rec_codec);
3164         set_rec_volume(j, j->cid_rec_volume);
3165
3166         if(j->cid_rec_flag)
3167                 ixj_record_start(j);
3168
3169         if(j->cid_play_flag)
3170                 ixj_play_start(j);
3171
3172         if(j->cid_play_flag) {
3173                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3174         }
3175 }
3176
3177 static void ixj_write_cid(IXJ *j)
3178 {
3179         char sdmf1[50];
3180         char sdmf2[50];
3181         char sdmf3[80];
3182         char mdmflen, len1, len2, len3;
3183         int pad;
3184
3185         int checksum = 0;
3186
3187         if (j->dsp.low == 0x20 || j->flags.cidplay)
3188                 return;
3189
3190         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3191         j->cidsize = j->cidcnt = 0;
3192
3193         ixj_fsk_alloc(j);
3194
3195         strcpy(sdmf1, j->cid_send.month);
3196         strcat(sdmf1, j->cid_send.day);
3197         strcat(sdmf1, j->cid_send.hour);
3198         strcat(sdmf1, j->cid_send.min);
3199         strcpy(sdmf2, j->cid_send.number);
3200         strcpy(sdmf3, j->cid_send.name);
3201
3202         len1 = strlen(sdmf1);
3203         len2 = strlen(sdmf2);
3204         len3 = strlen(sdmf3);
3205         mdmflen = len1 + len2 + len3 + 6;
3206
3207         while(1){
3208                 ixj_write_cid_seize(j);
3209
3210                 ixj_write_cid_byte(j, 0x80);
3211                 checksum = 0x80;
3212                 ixj_write_cid_byte(j, mdmflen);
3213                 checksum = checksum + mdmflen;
3214
3215                 ixj_write_cid_byte(j, 0x01);
3216                 checksum = checksum + 0x01;
3217                 ixj_write_cid_byte(j, len1);
3218                 checksum = checksum + len1;
3219                 checksum = ixj_write_cid_string(j, sdmf1, checksum);
3220                 if(ixj_hookstate(j) & 1)
3221                         break;
3222
3223                 ixj_write_cid_byte(j, 0x02);
3224                 checksum = checksum + 0x02;
3225                 ixj_write_cid_byte(j, len2);
3226                 checksum = checksum + len2;
3227                 checksum = ixj_write_cid_string(j, sdmf2, checksum);
3228                 if(ixj_hookstate(j) & 1)
3229                         break;
3230
3231                 ixj_write_cid_byte(j, 0x07);
3232                 checksum = checksum + 0x07;
3233                 ixj_write_cid_byte(j, len3);
3234                 checksum = checksum + len3;
3235                 checksum = ixj_write_cid_string(j, sdmf3, checksum);
3236                 if(ixj_hookstate(j) & 1)
3237                         break;
3238
3239                 checksum %= 256;
3240                 checksum ^= 0xFF;
3241                 checksum += 1;
3242
3243                 ixj_write_cid_byte(j, (char) checksum);
3244
3245                 pad = j->fskdcnt % 240;
3246                 if (pad) {
3247                         pad = 240 - pad;
3248                 }
3249                 ixj_pad_fsk(j, pad);
3250                 break;
3251         }
3252
3253         ixj_write_frame(j);
3254 }
3255
3256 static void ixj_write_cidcw(IXJ *j)
3257 {
3258         IXJ_TONE ti;
3259
3260         char sdmf1[50];
3261         char sdmf2[50];
3262         char sdmf3[80];
3263         char mdmflen, len1, len2, len3;
3264         int pad;
3265
3266         int checksum = 0;
3267
3268         if (j->dsp.low == 0x20 || j->flags.cidplay)
3269                 return;
3270
3271         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3272         j->cidsize = j->cidcnt = 0;
3273
3274         ixj_fsk_alloc(j);
3275
3276         j->flags.cidcw_ack = 0;
3277
3278         ti.tone_index = 23;
3279         ti.gain0 = 1;
3280         ti.freq0 = hz440;
3281         ti.gain1 = 0;
3282         ti.freq1 = 0;
3283         ixj_init_tone(j, &ti);
3284
3285         ixj_set_tone_on(1500, j);
3286         ixj_set_tone_off(32, j);
3287         if(ixjdebug & 0x0200) {
3288                 printk("IXJ cidcw phone%d first tone start at %ld\n", j->board, jiffies);
3289         }
3290         ixj_play_tone(j, 23);
3291
3292         clear_bit(j->board, &j->busyflags);
3293         while(j->tone_state)
3294                 schedule_timeout_interruptible(1);
3295         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3296                 schedule_timeout_interruptible(1);
3297         if(ixjdebug & 0x0200) {
3298                 printk("IXJ cidcw phone%d first tone end at %ld\n", j->board, jiffies);
3299         }
3300
3301         ti.tone_index = 24;
3302         ti.gain0 = 1;
3303         ti.freq0 = hz2130;
3304         ti.gain1 = 0;
3305         ti.freq1 = hz2750;
3306         ixj_init_tone(j, &ti);
3307
3308         ixj_set_tone_off(10, j);
3309         ixj_set_tone_on(600, j);
3310         if(ixjdebug & 0x0200) {
3311                 printk("IXJ cidcw phone%d second tone start at %ld\n", j->board, jiffies);
3312         }
3313         ixj_play_tone(j, 24);
3314
3315         clear_bit(j->board, &j->busyflags);
3316         while(j->tone_state)
3317                 schedule_timeout_interruptible(1);
3318         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3319                 schedule_timeout_interruptible(1);
3320         if(ixjdebug & 0x0200) {
3321                 printk("IXJ cidcw phone%d sent second tone at %ld\n", j->board, jiffies);
3322         }
3323
3324         j->cidcw_wait = jiffies + ((50 * hertz) / 100);
3325
3326         clear_bit(j->board, &j->busyflags);
3327         while(!j->flags.cidcw_ack && time_before(jiffies, j->cidcw_wait))
3328                 schedule_timeout_interruptible(1);
3329         while(test_and_set_bit(j->board, (void *)&j->busyflags) != 0)
3330                 schedule_timeout_interruptible(1);
3331         j->cidcw_wait = 0;
3332         if(!j->flags.cidcw_ack) {
3333                 if(ixjdebug & 0x0200) {
3334                         printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
3335                 }
3336                 ixj_post_cid(j);
3337                 if(j->cid_play_flag) {
3338                         wake_up_interruptible(&j->write_q);     /* Wake any blocked readers */
3339                 }
3340                 return;
3341         } else {
3342                 ixj_pre_cid(j);
3343         }
3344         j->flags.cidcw_ack = 0;
3345         strcpy(sdmf1, j->cid_send.month);
3346         strcat(sdmf1, j->cid_send.day);
3347         strcat(sdmf1, j->cid_send.hour);
3348         strcat(sdmf1, j->cid_send.min);
3349         strcpy(sdmf2, j->cid_send.number);
3350         strcpy(sdmf3, j->cid_send.name);
3351
3352         len1 = strlen(sdmf1);
3353         len2 = strlen(sdmf2);
3354         len3 = strlen(sdmf3);
3355         mdmflen = len1 + len2 + len3 + 6;
3356
3357         ixj_write_cidcw_seize(j);
3358
3359         ixj_write_cid_byte(j, 0x80);
3360         checksum = 0x80;
3361         ixj_write_cid_byte(j, mdmflen);
3362         checksum = checksum + mdmflen;
3363
3364         ixj_write_cid_byte(j, 0x01);
3365         checksum = checksum + 0x01;
3366         ixj_write_cid_byte(j, len1);
3367         checksum = checksum + len1;
3368         checksum = ixj_write_cid_string(j, sdmf1, checksum);
3369
3370         ixj_write_cid_byte(j, 0x02);
3371         checksum = checksum + 0x02;
3372         ixj_write_cid_byte(j, len2);
3373         checksum = checksum + len2;
3374         checksum = ixj_write_cid_string(j, sdmf2, checksum);
3375
3376         ixj_write_cid_byte(j, 0x07);
3377         checksum = checksum + 0x07;
3378         ixj_write_cid_byte(j, len3);
3379         checksum = checksum + len3;
3380         checksum = ixj_write_cid_string(j, sdmf3, checksum);
3381
3382         checksum %= 256;
3383         checksum ^= 0xFF;
3384         checksum += 1;
3385
3386         ixj_write_cid_byte(j, (char) checksum);
3387
3388         pad = j->fskdcnt % 240;
3389         if (pad) {
3390                 pad = 240 - pad;
3391         }
3392         ixj_pad_fsk(j, pad);
3393         if(ixjdebug & 0x0200) {
3394                 printk("IXJ cidcw phone%d sent FSK data at %ld\n", j->board, jiffies);
3395         }
3396 }
3397
3398 static void ixj_write_vmwi(IXJ *j, int msg)
3399 {
3400         char mdmflen;
3401         int pad;
3402
3403         int checksum = 0;
3404
3405         if (j->dsp.low == 0x20 || j->flags.cidplay)
3406                 return;
3407
3408         j->fskz = j->fskphase = j->fskcnt = j->fskdcnt = 0;
3409         j->cidsize = j->cidcnt = 0;
3410
3411         ixj_fsk_alloc(j);
3412
3413         mdmflen = 3;
3414
3415         if (j->port == PORT_POTS)
3416                 SLIC_SetState(PLD_SLIC_STATE_OHT, j);
3417
3418         ixj_write_cid_seize(j);
3419
3420         ixj_write_cid_byte(j, 0x82);
3421         checksum = 0x82;
3422         ixj_write_cid_byte(j, mdmflen);
3423         checksum = checksum + mdmflen;
3424
3425         ixj_write_cid_byte(j, 0x0B);
3426         checksum = checksum + 0x0B;
3427         ixj_write_cid_byte(j, 1);
3428         checksum = checksum + 1;
3429
3430         if(msg) {
3431                 ixj_write_cid_byte(j, 0xFF);
3432                 checksum = checksum + 0xFF;
3433         }
3434         else {
3435                 ixj_write_cid_byte(j, 0x00);
3436                 checksum = checksum + 0x00;
3437         }
3438
3439         checksum %= 256;
3440         checksum ^= 0xFF;
3441         checksum += 1;
3442
3443         ixj_write_cid_byte(j, (char) checksum);
3444
3445         pad = j->fskdcnt % 240;
3446         if (pad) {
3447                 pad = 240 - pad;
3448         }
3449         ixj_pad_fsk(j, pad);
3450 }
3451
3452 static void ixj_write_frame(IXJ *j)
3453 {
3454         int cnt, frame_count, dly;
3455         IXJ_WORD dat;
3456
3457         frame_count = 0;
3458         if(j->flags.cidplay) {
3459                 for(cnt = 0; cnt < 480; cnt++) {
3460                         if (!(cnt % 16) && !IsTxReady(j)) {
3461                                 dly = 0;
3462                                 while (!IsTxReady(j)) {
3463                                         if (dly++ > 5) {
3464                                                 dly = 0;
3465                                                 break;
3466                                         }
3467                                         udelay(10);
3468                                 }
3469                         }
3470                         dat.word = j->fskdata[j->cidcnt++];
3471                         outb_p(dat.bytes.low, j->DSPbase + 0x0C);
3472                         outb_p(dat.bytes.high, j->DSPbase + 0x0D);
3473                         cnt++;
3474                 }
3475                 if(j->cidcnt >= j->fskdcnt) {
3476                         ixj_post_cid(j);
3477                 }
3478                 /* This may seem rude, but if we just played one frame of FSK data for CallerID
3479                    and there is real audio data in the buffer, we need to throw it away because
3480                    we just used it's time slot */
3481                 if (j->write_buffer_rp > j->write_buffer_wp) {
3482                         j->write_buffer_rp += j->cid_play_frame_size * 2;
3483                         if (j->write_buffer_rp >= j->write_buffer_end) {
3484                                 j->write_buffer_rp = j->write_buffer;
3485                         }
3486                         j->write_buffers_empty++;
3487                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3488
3489                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3490                 }
3491         } else if (j->write_buffer && j->write_buffers_empty < 1) {
3492                 if (j->write_buffer_wp > j->write_buffer_rp) {
3493                         frame_count =
3494                             (j->write_buffer_wp - j->write_buffer_rp) / (j->play_frame_size * 2);
3495                 }
3496                 if (j->write_buffer_rp > j->write_buffer_wp) {
3497                         frame_count =
3498                             (j->write_buffer_wp - j->write_buffer) / (j->play_frame_size * 2) +
3499                             (j->write_buffer_end - j->write_buffer_rp) / (j->play_frame_size * 2);
3500                 }
3501                 if (frame_count >= 1) {
3502                         if (j->ver.low == 0x12 && j->play_mode && j->flags.play_first_frame) {
3503                                 BYTES blankword;
3504
3505                                 switch (j->play_mode) {
3506                                 case PLAYBACK_MODE_ULAW:
3507                                 case PLAYBACK_MODE_ALAW:
3508                                         blankword.low = blankword.high = 0xFF;
3509                                         break;
3510                                 case PLAYBACK_MODE_8LINEAR:
3511                                 case PLAYBACK_MODE_16LINEAR:
3512                                 default:
3513                                         blankword.low = blankword.high = 0x00;
3514                                         break;
3515                                 case PLAYBACK_MODE_8LINEAR_WSS:
3516                                         blankword.low = blankword.high = 0x80;
3517                                         break;
3518                                 }
3519                                 for (cnt = 0; cnt < 16; cnt++) {
3520                                         if (!(cnt % 16) && !IsTxReady(j)) {
3521                                                 dly = 0;
3522                                                 while (!IsTxReady(j)) {
3523                                                         if (dly++ > 5) {
3524                                                                 dly = 0;
3525                                                                 break;
3526                                                         }
3527                                                         udelay(10);
3528                                                 }
3529                                         }
3530                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3531                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3532                                 }
3533                                 j->flags.play_first_frame = 0;
3534                         } else  if (j->play_codec == G723_63 && j->flags.play_first_frame) {
3535                                 for (cnt = 0; cnt < 24; cnt++) {
3536                                         BYTES blankword;
3537
3538                                         if(cnt == 12) {
3539                                                 blankword.low = 0x02;
3540                                                 blankword.high = 0x00;
3541                                         }
3542                                         else {
3543                                                 blankword.low = blankword.high = 0x00;
3544                                         }
3545                                         if (!(cnt % 16) && !IsTxReady(j)) {
3546                                                 dly = 0;
3547                                                 while (!IsTxReady(j)) {
3548                                                         if (dly++ > 5) {
3549                                                                 dly = 0;
3550                                                                 break;
3551                                                         }
3552                                                         udelay(10);
3553                                                 }
3554                                         }
3555                                         outb_p((blankword.low), j->DSPbase + 0x0C);
3556                                         outb_p((blankword.high), j->DSPbase + 0x0D);
3557                                 }
3558                                 j->flags.play_first_frame = 0;
3559                         }
3560                         for (cnt = 0; cnt < j->play_frame_size * 2; cnt += 2) {
3561                                 if (!(cnt % 16) && !IsTxReady(j)) {
3562                                         dly = 0;
3563                                         while (!IsTxReady(j)) {
3564                                                 if (dly++ > 5) {
3565                                                         dly = 0;
3566                                                         break;
3567                                                 }
3568                                                 udelay(10);
3569                                         }
3570                                 }
3571                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
3572                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
3573                                         if (j->write_buffer_rp[cnt] == 0 &&
3574                                             j->write_buffer_rp[cnt + 1] == 0 &&
3575                                             j->write_buffer_rp[cnt + 2] == 0 &&
3576                                             j->write_buffer_rp[cnt + 3] == 0 &&
3577                                             j->write_buffer_rp[cnt + 4] == 0 &&
3578                                             j->write_buffer_rp[cnt + 5] == 0 &&
3579                                             j->write_buffer_rp[cnt + 6] == 0 &&
3580                                             j->write_buffer_rp[cnt + 7] == 0 &&
3581                                             j->write_buffer_rp[cnt + 8] == 0 &&
3582                                             j->write_buffer_rp[cnt + 9] == 0) {
3583                                         /* someone is trying to write silence lets make this a type 0 frame. */
3584                                                 outb_p(0x00, j->DSPbase + 0x0C);
3585                                                 outb_p(0x00, j->DSPbase + 0x0D);
3586                                         } else {
3587                                         /* so all other frames are type 1. */
3588                                                 outb_p(0x01, j->DSPbase + 0x0C);
3589                                                 outb_p(0x00, j->DSPbase + 0x0D);
3590                                         }
3591                                 }
3592                                 outb_p(*(j->write_buffer_rp + cnt), j->DSPbase + 0x0C);
3593                                 outb_p(*(j->write_buffer_rp + cnt + 1), j->DSPbase + 0x0D);
3594                                 *(j->write_buffer_rp + cnt) = 0;
3595                                 *(j->write_buffer_rp + cnt + 1) = 0;
3596                         }
3597                         j->write_buffer_rp += j->play_frame_size * 2;
3598                         if (j->write_buffer_rp >= j->write_buffer_end) {
3599                                 j->write_buffer_rp = j->write_buffer;
3600                         }
3601                         j->write_buffers_empty++;
3602                         wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
3603
3604                         wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
3605
3606                         ++j->frameswritten;
3607                 }
3608         } else {
3609                 j->drybuffer++;
3610         }
3611         if(j->ixj_signals[SIG_WRITE_READY]) {
3612                 ixj_kill_fasync(j, SIG_WRITE_READY, POLL_OUT);
3613         }
3614 }
3615
3616 static int idle(IXJ *j)
3617 {
3618         if (ixj_WriteDSPCommand(0x0000, j))             /* DSP Idle */
3619
3620                 return 0;
3621
3622         if (j->ssr.high || j->ssr.low) {
3623                 return 0;
3624         } else {
3625                 j->play_mode = -1;
3626                 j->flags.playing = 0;
3627                 j->rec_mode = -1;
3628                 j->flags.recording = 0;
3629                 return 1;
3630         }
3631 }
3632
3633 static int set_base_frame(IXJ *j, int size)
3634 {
3635         unsigned short cmd;
3636         int cnt;
3637
3638         idle(j);
3639         j->cid_play_aec_level = j->aec_level;
3640         aec_stop(j);
3641         for (cnt = 0; cnt < 10; cnt++) {
3642                 if (idle(j))
3643                         break;
3644         }
3645         if (j->ssr.high || j->ssr.low)
3646                 return -1;
3647         if (j->dsp.low != 0x20) {
3648                 switch (size) {
3649                 case 30:
3650                         cmd = 0x07F0;
3651                         /* Set Base Frame Size to 240 pg9-10 8021 */
3652                         break;
3653                 case 20:
3654                         cmd = 0x07A0;
3655                         /* Set Base Frame Size to 160 pg9-10 8021 */
3656                         break;
3657                 case 10:
3658                         cmd = 0x0750;
3659                         /* Set Base Frame Size to 80 pg9-10 8021 */
3660                         break;
3661                 default:
3662                         return -1;
3663                 }
3664         } else {
3665                 if (size == 30)
3666                         return size;
3667                 else
3668                         return -1;
3669         }
3670         if (ixj_WriteDSPCommand(cmd, j)) {
3671                 j->baseframe.high = j->baseframe.low = 0xFF;
3672                 return -1;
3673         } else {
3674                 j->baseframe.high = j->ssr.high;
3675                 j->baseframe.low = j->ssr.low;
3676                 /* If the status returned is 0x0000 (pg9-9 8021) the call failed */
3677                 if(j->baseframe.high == 0x00 && j->baseframe.low == 0x00) {
3678                         return -1;
3679                 }
3680         }
3681         ixj_aec_start(j, j->cid_play_aec_level);
3682         return size;
3683 }
3684
3685 static int set_rec_codec(IXJ *j, int rate)
3686 {
3687         int retval = 0;
3688
3689         j->rec_codec = rate;
3690
3691         switch (rate) {
3692         case G723_63:
3693                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3694                         j->rec_frame_size = 12;
3695                         j->rec_mode = 0;
3696                 } else {
3697                         retval = 1;
3698                 }
3699                 break;
3700         case G723_53:
3701                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3702                         j->rec_frame_size = 10;
3703                         j->rec_mode = 0;
3704                 } else {
3705                         retval = 1;
3706                 }
3707                 break;
3708         case TS85:
3709                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
3710                         j->rec_frame_size = 16;
3711                         j->rec_mode = 0;
3712                 } else {
3713                         retval = 1;
3714                 }
3715                 break;
3716         case TS48:
3717                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3718                         j->rec_frame_size = 9;
3719                         j->rec_mode = 0;
3720                 } else {
3721                         retval = 1;
3722                 }
3723                 break;
3724         case TS41:
3725                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
3726                         j->rec_frame_size = 8;
3727                         j->rec_mode = 0;
3728                 } else {
3729                         retval = 1;
3730                 }
3731                 break;
3732         case G728:
3733                 if (j->dsp.low != 0x20) {
3734                         j->rec_frame_size = 48;
3735                         j->rec_mode = 0;
3736                 } else {
3737                         retval = 1;
3738                 }
3739                 break;
3740         case G729:
3741                 if (j->dsp.low != 0x20) {
3742                         if (!j->flags.g729_loaded) {
3743                                 retval = 1;
3744                                 break;
3745                         }
3746                         switch (j->baseframe.low) {
3747                         case 0xA0:
3748                                 j->rec_frame_size = 10;
3749                                 break;
3750                         case 0x50:
3751                                 j->rec_frame_size = 5;
3752                                 break;
3753                         default:
3754                                 j->rec_frame_size = 15;
3755                                 break;
3756                         }
3757                         j->rec_mode = 0;
3758                 } else {
3759                         retval = 1;
3760                 }
3761                 break;
3762         case G729B:
3763                 if (j->dsp.low != 0x20) {
3764                         if (!j->flags.g729_loaded) {
3765                                 retval = 1;
3766                                 break;
3767                         }
3768                         switch (j->baseframe.low) {
3769                         case 0xA0:
3770                                 j->rec_frame_size = 12;
3771                                 break;
3772                         case 0x50:
3773                                 j->rec_frame_size = 6;
3774                                 break;
3775                         default:
3776                                 j->rec_frame_size = 18;
3777                                 break;
3778                         }
3779                         j->rec_mode = 0;
3780                 } else {
3781                         retval = 1;
3782                 }
3783                 break;
3784         case ULAW:
3785                 switch (j->baseframe.low) {
3786                 case 0xA0:
3787                         j->rec_frame_size = 80;
3788                         break;
3789                 case 0x50:
3790                         j->rec_frame_size = 40;
3791                         break;
3792                 default:
3793                         j->rec_frame_size = 120;
3794                         break;
3795                 }
3796                 j->rec_mode = 4;
3797                 break;
3798         case ALAW:
3799                 switch (j->baseframe.low) {
3800                 case 0xA0:
3801                         j->rec_frame_size = 80;
3802                         break;
3803                 case 0x50:
3804                         j->rec_frame_size = 40;
3805                         break;
3806                 default:
3807                         j->rec_frame_size = 120;
3808                         break;
3809                 }
3810                 j->rec_mode = 4;
3811                 break;
3812         case LINEAR16:
3813                 switch (j->baseframe.low) {
3814                 case 0xA0:
3815                         j->rec_frame_size = 160;
3816                         break;
3817                 case 0x50:
3818                         j->rec_frame_size = 80;
3819                         break;
3820                 default:
3821                         j->rec_frame_size = 240;
3822                         break;
3823                 }
3824                 j->rec_mode = 5;
3825                 break;
3826         case LINEAR8:
3827                 switch (j->baseframe.low) {
3828                 case 0xA0:
3829                         j->rec_frame_size = 80;
3830                         break;
3831                 case 0x50:
3832                         j->rec_frame_size = 40;
3833                         break;
3834                 default:
3835                         j->rec_frame_size = 120;
3836                         break;
3837                 }
3838                 j->rec_mode = 6;
3839                 break;
3840         case WSS:
3841                 switch (j->baseframe.low) {
3842                 case 0xA0:
3843                         j->rec_frame_size = 80;
3844                         break;
3845                 case 0x50:
3846                         j->rec_frame_size = 40;
3847                         break;
3848                 default:
3849                         j->rec_frame_size = 120;
3850                         break;
3851                 }
3852                 j->rec_mode = 7;
3853                 break;
3854         default:
3855                 kfree(j->read_buffer);
3856                 j->rec_frame_size = 0;
3857                 j->rec_mode = -1;
3858                 j->read_buffer = NULL;
3859                 j->read_buffer_size = 0;
3860                 retval = 1;
3861                 break;
3862         }
3863         return retval;
3864 }
3865
3866 static int ixj_record_start(IXJ *j)
3867 {
3868         unsigned short cmd = 0x0000;
3869
3870         if (j->read_buffer) {
3871                 ixj_record_stop(j);
3872         }
3873         j->flags.recording = 1;
3874         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
3875
3876         if(ixjdebug & 0x0002)
3877                 printk("IXJ %d Starting Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3878
3879         if (!j->rec_mode) {
3880                 switch (j->rec_codec) {
3881                 case G723_63:
3882                         cmd = 0x5131;
3883                         break;
3884                 case G723_53:
3885                         cmd = 0x5132;
3886                         break;
3887                 case TS85:
3888                         cmd = 0x5130;   /* TrueSpeech 8.5 */
3889
3890                         break;
3891                 case TS48:
3892                         cmd = 0x5133;   /* TrueSpeech 4.8 */
3893
3894                         break;
3895                 case TS41:
3896                         cmd = 0x5134;   /* TrueSpeech 4.1 */
3897
3898                         break;
3899                 case G728:
3900                         cmd = 0x5135;
3901                         break;
3902                 case G729:
3903                 case G729B:
3904                         cmd = 0x5136;
3905                         break;
3906                 default:
3907                         return 1;
3908                 }
3909                 if (ixj_WriteDSPCommand(cmd, j))
3910                         return -1;
3911         }
3912         if (!j->read_buffer) {
3913                 if (!j->read_buffer)
3914                         j->read_buffer = kmalloc(j->rec_frame_size * 2, GFP_ATOMIC);
3915                 if (!j->read_buffer) {
3916                         printk("Read buffer allocation for ixj board %d failed!\n", j->board);
3917                         return -ENOMEM;
3918                 }
3919         }
3920         j->read_buffer_size = j->rec_frame_size * 2;
3921
3922         if (ixj_WriteDSPCommand(0x5102, j))             /* Set Poll sync mode */
3923
3924                 return -1;
3925
3926         switch (j->rec_mode) {
3927         case 0:
3928                 cmd = 0x1C03;   /* Record C1 */
3929
3930                 break;
3931         case 4:
3932                 if (j->ver.low == 0x12) {
3933                         cmd = 0x1E03;   /* Record C1 */
3934
3935                 } else {
3936                         cmd = 0x1E01;   /* Record C1 */
3937
3938                 }
3939                 break;
3940         case 5:
3941                 if (j->ver.low == 0x12) {
3942                         cmd = 0x1E83;   /* Record C1 */
3943
3944                 } else {
3945                         cmd = 0x1E81;   /* Record C1 */
3946
3947                 }
3948                 break;
3949         case 6:
3950                 if (j->ver.low == 0x12) {
3951                         cmd = 0x1F03;   /* Record C1 */
3952
3953                 } else {
3954                         cmd = 0x1F01;   /* Record C1 */
3955
3956                 }
3957                 break;
3958         case 7:
3959                 if (j->ver.low == 0x12) {
3960                         cmd = 0x1F83;   /* Record C1 */
3961                 } else {
3962                         cmd = 0x1F81;   /* Record C1 */
3963                 }
3964                 break;
3965         }
3966         if (ixj_WriteDSPCommand(cmd, j))
3967                 return -1;
3968
3969         if (j->flags.playing) {
3970                 ixj_aec_start(j, j->aec_level);
3971         }
3972         return 0;
3973 }
3974
3975 static void ixj_record_stop(IXJ *j)
3976 {
3977         if (ixjdebug & 0x0002)
3978                 printk("IXJ %d Stopping Record Codec %d at %ld\n", j->board, j->rec_codec, jiffies);
3979
3980         kfree(j->read_buffer);
3981         j->read_buffer = NULL;
3982         j->read_buffer_size = 0;
3983         if (j->rec_mode > -1) {
3984                 ixj_WriteDSPCommand(0x5120, j);
3985                 j->rec_mode = -1;
3986         }
3987         j->flags.recording = 0;
3988 }
3989 static void ixj_vad(IXJ *j, int arg)
3990 {
3991         if (arg)
3992                 ixj_WriteDSPCommand(0x513F, j);
3993         else
3994                 ixj_WriteDSPCommand(0x513E, j);
3995 }
3996
3997 static void set_rec_depth(IXJ *j, int depth)
3998 {
3999         if (depth > 60)
4000                 depth = 60;
4001         if (depth < 0)
4002                 depth = 0;
4003         ixj_WriteDSPCommand(0x5180 + depth, j);
4004 }
4005
4006 static void set_dtmf_prescale(IXJ *j, int volume)
4007 {
4008         ixj_WriteDSPCommand(0xCF07, j);
4009         ixj_WriteDSPCommand(volume, j);
4010 }
4011
4012 static int get_dtmf_prescale(IXJ *j)
4013 {
4014         ixj_WriteDSPCommand(0xCF05, j);
4015         return j->ssr.high << 8 | j->ssr.low;
4016 }
4017
4018 static void set_rec_volume(IXJ *j, int volume)
4019 {
4020         if(j->aec_level == AEC_AGC) {
4021                 if (ixjdebug & 0x0002)
4022                         printk(KERN_INFO "IXJ: /dev/phone%d Setting AGC Threshold to 0x%4.4x\n", j->board, volume);
4023                 ixj_WriteDSPCommand(0xCF96, j);
4024                 ixj_WriteDSPCommand(volume, j);
4025         } else {
4026                 if (ixjdebug & 0x0002)
4027                         printk(KERN_INFO "IXJ: /dev/phone %d Setting Record Volume to 0x%4.4x\n", j->board, volume);
4028                 ixj_WriteDSPCommand(0xCF03, j);
4029                 ixj_WriteDSPCommand(volume, j);
4030         }
4031 }
4032
4033 static int set_rec_volume_linear(IXJ *j, int volume)
4034 {
4035         int newvolume, dsprecmax;
4036
4037         if (ixjdebug & 0x0002)
4038                 printk(KERN_INFO "IXJ: /dev/phone %d Setting Linear Record Volume to 0x%4.4x\n", j->board, volume);
4039         if(volume > 100 || volume < 0) {
4040           return -1;
4041         }
4042
4043         /* This should normalize the perceived volumes between the different cards caused by differences in the hardware */
4044         switch (j->cardtype) {
4045         case QTI_PHONEJACK:
4046                 dsprecmax = 0x440;
4047                 break;
4048         case QTI_LINEJACK:
4049                 dsprecmax = 0x180;
4050                 ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
4051                 ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
4052                 ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
4053                 break;
4054         case QTI_PHONEJACK_LITE:
4055                 dsprecmax = 0x4C0;
4056                 break;
4057         case QTI_PHONEJACK_PCI:
4058                 dsprecmax = 0x100;
4059                 break;
4060         case QTI_PHONECARD:
4061                 dsprecmax = 0x400;
4062                 break;
4063         default:
4064                 return -1;
4065         }
4066         newvolume = (dsprecmax * volume) / 100;
4067         set_rec_volume(j, newvolume);
4068         return 0;
4069 }
4070
4071 static int get_rec_volume(IXJ *j)
4072 {
4073         if(j->aec_level == AEC_AGC) {
4074                 if (ixjdebug & 0x0002)
4075                         printk(KERN_INFO "Getting AGC Threshold\n");
4076                 ixj_WriteDSPCommand(0xCF86, j);
4077                 if (ixjdebug & 0x0002)
4078                         printk(KERN_INFO "AGC Threshold is 0x%2.2x%2.2x\n", j->ssr.high, j->ssr.low);
4079                 return j->ssr.high << 8 | j->ssr.low;
4080         } else {
4081                 if (ixjdebug & 0x0002)
4082                         printk(KERN_INFO "Getting Record Volume\n");
4083                 ixj_WriteDSPCommand(0xCF01, j);
4084                 return j->ssr.high << 8 | j->ssr.low;
4085         }
4086 }
4087
4088 static int get_rec_volume_linear(IXJ *j)
4089 {
4090         int volume, newvolume, dsprecmax;
4091
4092         switch (j->cardtype) {
4093         case QTI_PHONEJACK:
4094                 dsprecmax = 0x440;
4095                 break;
4096         case QTI_LINEJACK:
4097                 dsprecmax = 0x180;
4098                 break;
4099         case QTI_PHONEJACK_LITE:
4100                 dsprecmax = 0x4C0;
4101                 break;
4102         case QTI_PHONEJACK_PCI:
4103                 dsprecmax = 0x100;
4104                 break;
4105         case QTI_PHONECARD:
4106                 dsprecmax = 0x400;
4107                 break;
4108         default:
4109                 return -1;
4110         }
4111         volume = get_rec_volume(j);
4112         newvolume = (volume * 100) / dsprecmax;
4113         if(newvolume > 100)
4114                 newvolume = 100;
4115         return newvolume;
4116 }
4117
4118 static int get_rec_level(IXJ *j)
4119 {
4120         int retval;
4121
4122         ixj_WriteDSPCommand(0xCF88, j);
4123
4124         retval = j->ssr.high << 8 | j->ssr.low;
4125         retval = (retval * 256) / 240;
4126         return retval;
4127 }
4128
4129 static void ixj_aec_start(IXJ *j, int level)
4130 {
4131         j->aec_level = level;
4132         if (ixjdebug & 0x0002)
4133                 printk(KERN_INFO "AGC set = 0x%2.2x\n", j->aec_level);
4134         if (!level) {
4135                 aec_stop(j);
4136         } else {
4137                 if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4138                         ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer */
4139
4140                         ixj_WriteDSPCommand(0x0300, j);
4141                 }
4142                 ixj_WriteDSPCommand(0xB001, j); /* AEC On */
4143
4144                 ixj_WriteDSPCommand(0xE013, j); /* Advanced AEC C1 */
4145
4146                 switch (level) {
4147                 case AEC_LOW:
4148                         ixj_WriteDSPCommand(0x0000, j); /* Advanced AEC C2 = off */
4149
4150                         ixj_WriteDSPCommand(0xE011, j);
4151                         ixj_WriteDSPCommand(0xFFFF, j);
4152
4153                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4154                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4155
4156                         break;
4157
4158                 case AEC_MED:
4159                         ixj_WriteDSPCommand(0x0600, j); /* Advanced AEC C2 = on medium */
4160
4161                         ixj_WriteDSPCommand(0xE011, j);
4162                         ixj_WriteDSPCommand(0x0080, j);
4163
4164                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4165                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4166
4167                         break;
4168
4169                 case AEC_HIGH:
4170                         ixj_WriteDSPCommand(0x0C00, j); /* Advanced AEC C2 = on high */
4171
4172                         ixj_WriteDSPCommand(0xE011, j);
4173                         ixj_WriteDSPCommand(0x0080, j);
4174
4175                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4176                         ixj_WriteDSPCommand(0x0000, j); /* to off */
4177
4178                         break;
4179
4180                 case AEC_AGC:
4181                         /* First we have to put the AEC into advance auto mode so that AGC will not conflict with it */
4182                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4183
4184                         ixj_WriteDSPCommand(0xE011, j);
4185                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4186
4187                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4188
4189                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4190                                 ixj_WriteDSPCommand(0x0224, j);
4191                         else
4192                                 ixj_WriteDSPCommand(0x1224, j);
4193
4194                         ixj_WriteDSPCommand(0xE014, j);
4195                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4196
4197                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4198
4199                         /* Now we can set the AGC initial parameters and turn it on */
4200                         ixj_WriteDSPCommand(0xCF90, j); /* Set AGC Minumum gain */
4201                         ixj_WriteDSPCommand(0x0020, j); /* to 0.125 (-18dB) */
4202
4203                         ixj_WriteDSPCommand(0xCF91, j); /* Set AGC Maximum gain */
4204                         ixj_WriteDSPCommand(0x1000, j); /* to 16 (24dB) */
4205
4206                         ixj_WriteDSPCommand(0xCF92, j); /* Set AGC start gain */
4207                         ixj_WriteDSPCommand(0x0800, j); /* to 8 (+18dB) */
4208
4209                         ixj_WriteDSPCommand(0xCF93, j); /* Set AGC hold time */
4210                         ixj_WriteDSPCommand(0x1F40, j); /* to 2 seconds (units are 250us) */
4211
4212                         ixj_WriteDSPCommand(0xCF94, j); /* Set AGC Attack Time Constant */
4213                         ixj_WriteDSPCommand(0x0005, j); /* to 8ms */
4214
4215                         ixj_WriteDSPCommand(0xCF95, j); /* Set AGC Decay Time Constant */
4216                         ixj_WriteDSPCommand(0x000D, j); /* to 4096ms */
4217
4218                         ixj_WriteDSPCommand(0xCF96, j); /* Set AGC Attack Threshold */
4219                         ixj_WriteDSPCommand(0x1200, j); /* to 25% */
4220
4221                         ixj_WriteDSPCommand(0xCF97, j); /* Set AGC Enable */
4222                         ixj_WriteDSPCommand(0x0001, j); /* to on */
4223
4224                         break;
4225
4226                 case AEC_AUTO:
4227                         ixj_WriteDSPCommand(0x0002, j); /* Attenuation scaling factor of 2 */
4228
4229                         ixj_WriteDSPCommand(0xE011, j);
4230                         ixj_WriteDSPCommand(0x0100, j); /* Higher Threshold Floor */
4231
4232                         ixj_WriteDSPCommand(0xE012, j); /* Set Train and Lock */
4233
4234                         if(j->cardtype == QTI_LINEJACK || j->cardtype == QTI_PHONECARD)
4235                                 ixj_WriteDSPCommand(0x0224, j);
4236                         else
4237                                 ixj_WriteDSPCommand(0x1224, j);
4238
4239                         ixj_WriteDSPCommand(0xE014, j);
4240                         ixj_WriteDSPCommand(0x0003, j); /* Lock threashold at 3dB */
4241
4242                         ixj_WriteDSPCommand(0xE338, j); /* Set Echo Suppresser Attenuation to 0dB */
4243
4244                         break;
4245                 }
4246         }
4247 }
4248
4249 static void aec_stop(IXJ *j)
4250 {
4251         j->aec_level = AEC_OFF;
4252         if (j->rec_codec == G729 || j->play_codec == G729 || j->rec_codec == G729B || j->play_codec == G729B) {
4253                 ixj_WriteDSPCommand(0xE022, j); /* Move AEC filter buffer back */
4254
4255                 ixj_WriteDSPCommand(0x0700, j);
4256         }
4257         if (j->play_mode != -1 && j->rec_mode != -1)
4258         {
4259                 ixj_WriteDSPCommand(0xB002, j); /* AEC Stop */
4260         }
4261 }
4262
4263 static int set_play_codec(IXJ *j, int rate)
4264 {
4265         int retval = 0;
4266
4267         j->play_codec = rate;
4268
4269         switch (rate) {
4270         case G723_63:
4271                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4272                         j->play_frame_size = 12;
4273                         j->play_mode = 0;
4274                 } else {
4275                         retval = 1;
4276                 }
4277                 break;
4278         case G723_53:
4279                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4280                         j->play_frame_size = 10;
4281                         j->play_mode = 0;
4282                 } else {
4283                         retval = 1;
4284                 }
4285                 break;
4286         case TS85:
4287                 if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
4288                         j->play_frame_size = 16;
4289                         j->play_mode = 0;
4290                 } else {
4291                         retval = 1;
4292                 }
4293                 break;
4294         case TS48:
4295                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4296                         j->play_frame_size = 9;
4297                         j->play_mode = 0;
4298                 } else {
4299                         retval = 1;
4300                 }
4301                 break;
4302         case TS41:
4303                 if (j->ver.low != 0x12 || ixj_convert_loaded) {
4304                         j->play_frame_size = 8;
4305                         j->play_mode = 0;
4306                 } else {
4307                         retval = 1;
4308                 }
4309                 break;
4310         case G728:
4311                 if (j->dsp.low != 0x20) {
4312                         j->play_frame_size = 48;
4313                         j->play_mode = 0;
4314                 } else {
4315                         retval = 1;
4316                 }
4317                 break;
4318         case G729:
4319                 if (j->dsp.low != 0x20) {
4320                         if (!j->flags.g729_loaded) {
4321                                 retval = 1;
4322                                 break;
4323                         }
4324                         switch (j->baseframe.low) {
4325                         case 0xA0:
4326                                 j->play_frame_size = 10;
4327                                 break;
4328                         case 0x50:
4329                                 j->play_frame_size = 5;
4330                                 break;
4331                         default:
4332                                 j->play_frame_size = 15;
4333                                 break;
4334                         }
4335                         j->play_mode = 0;
4336                 } else {
4337                         retval = 1;
4338                 }
4339                 break;
4340         case G729B:
4341                 if (j->dsp.low != 0x20) {
4342                         if (!j->flags.g729_loaded) {
4343                                 retval = 1;
4344                                 break;
4345                         }
4346                         switch (j->baseframe.low) {
4347                         case 0xA0:
4348                                 j->play_frame_size = 12;
4349                                 break;
4350                         case 0x50:
4351                                 j->play_frame_size = 6;
4352                                 break;
4353                         default:
4354                                 j->play_frame_size = 18;
4355                                 break;
4356                         }
4357                         j->play_mode = 0;
4358                 } else {
4359                         retval = 1;
4360                 }
4361                 break;
4362         case ULAW:
4363                 switch (j->baseframe.low) {
4364                 case 0xA0:
4365                         j->play_frame_size = 80;
4366                         break;
4367                 case 0x50:
4368                         j->play_frame_size = 40;
4369                         break;
4370                 default:
4371                         j->play_frame_size = 120;
4372                         break;
4373                 }
4374                 j->play_mode = 2;
4375                 break;
4376         case ALAW:
4377                 switch (j->baseframe.low) {
4378                 case 0xA0:
4379                         j->play_frame_size = 80;
4380                         break;
4381                 case 0x50:
4382                         j->play_frame_size = 40;
4383                         break;
4384                 default:
4385                         j->play_frame_size = 120;
4386                         break;
4387                 }
4388                 j->play_mode = 2;
4389                 break;
4390         case LINEAR16:
4391                 switch (j->baseframe.low) {
4392                 case 0xA0:
4393                         j->play_frame_size = 160;
4394                         break;
4395                 case 0x50:
4396                         j->play_frame_size = 80;
4397                         break;
4398                 default:
4399                         j->play_frame_size = 240;
4400                         break;
4401                 }
4402                 j->play_mode = 6;
4403                 break;
4404         case LINEAR8:
4405                 switch (j->baseframe.low) {
4406                 case 0xA0:
4407                         j->play_frame_size = 80;
4408                         break;
4409                 case 0x50:
4410                         j->play_frame_size = 40;
4411                         break;
4412                 default:
4413                         j->play_frame_size = 120;
4414                         break;
4415                 }
4416                 j->play_mode = 4;
4417                 break;
4418         case WSS:
4419                 switch (j->baseframe.low) {
4420                 case 0xA0:
4421                         j->play_frame_size = 80;
4422                         break;
4423                 case 0x50:
4424                         j->play_frame_size = 40;
4425                         break;
4426                 default:
4427                         j->play_frame_size = 120;
4428                         break;
4429                 }
4430                 j->play_mode = 5;
4431                 break;
4432         default:
4433                 kfree(j->write_buffer);
4434                 j->play_frame_size = 0;
4435                 j->play_mode = -1;
4436                 j->write_buffer = NULL;
4437                 j->write_buffer_size = 0;
4438                 retval = 1;
4439                 break;
4440         }
4441         return retval;
4442 }
4443
4444 static int ixj_play_start(IXJ *j)
4445 {
4446         unsigned short cmd = 0x0000;
4447
4448         if (j->write_buffer) {
4449                 ixj_play_stop(j);
4450         }
4451
4452         if(ixjdebug & 0x0002)
4453                 printk("IXJ %d Starting Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4454
4455         j->flags.playing = 1;
4456         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
4457
4458         j->flags.play_first_frame = 1;
4459         j->drybuffer = 0;
4460
4461         if (!j->play_mode) {
4462                 switch (j->play_codec) {
4463                 case G723_63:
4464                         cmd = 0x5231;
4465                         break;
4466                 case G723_53:
4467                         cmd = 0x5232;
4468                         break;
4469                 case TS85:
4470                         cmd = 0x5230;   /* TrueSpeech 8.5 */
4471
4472                         break;
4473                 case TS48:
4474                         cmd = 0x5233;   /* TrueSpeech 4.8 */
4475
4476                         break;
4477                 case TS41:
4478                         cmd = 0x5234;   /* TrueSpeech 4.1 */
4479
4480                         break;
4481                 case G728:
4482                         cmd = 0x5235;
4483                         break;
4484                 case G729:
4485                 case G729B:
4486                         cmd = 0x5236;
4487                         break;
4488                 default:
4489                         return 1;
4490                 }
4491                 if (ixj_WriteDSPCommand(cmd, j))
4492                         return -1;
4493         }
4494         j->write_buffer = kmalloc(j->play_frame_size * 2, GFP_ATOMIC);
4495         if (!j->write_buffer) {
4496                 printk("Write buffer allocation for ixj board %d failed!\n", j->board);
4497                 return -ENOMEM;
4498         }
4499 /*      j->write_buffers_empty = 2; */
4500         j->write_buffers_empty = 1;
4501         j->write_buffer_size = j->play_frame_size * 2;
4502         j->write_buffer_end = j->write_buffer + j->play_frame_size * 2;
4503         j->write_buffer_rp = j->write_buffer_wp = j->write_buffer;
4504
4505         if (ixj_WriteDSPCommand(0x5202, j))             /* Set Poll sync mode */
4506
4507                 return -1;
4508
4509         switch (j->play_mode) {
4510         case 0:
4511                 cmd = 0x2C03;
4512                 break;
4513         case 2:
4514                 if (j->ver.low == 0x12) {
4515                         cmd = 0x2C23;
4516                 } else {
4517                         cmd = 0x2C21;
4518                 }
4519                 break;
4520         case 4:
4521                 if (j->ver.low == 0x12) {
4522                         cmd = 0x2C43;
4523                 } else {
4524                         cmd = 0x2C41;
4525                 }
4526                 break;
4527         case 5:
4528                 if (j->ver.low == 0x12) {
4529                         cmd = 0x2C53;
4530                 } else {
4531                         cmd = 0x2C51;
4532                 }
4533                 break;
4534         case 6:
4535                 if (j->ver.low == 0x12) {
4536                         cmd = 0x2C63;
4537                 } else {
4538                         cmd = 0x2C61;
4539                 }
4540                 break;
4541         }
4542         if (ixj_WriteDSPCommand(cmd, j))
4543                 return -1;
4544
4545         if (ixj_WriteDSPCommand(0x2000, j))             /* Playback C2 */
4546                 return -1;
4547
4548         if (ixj_WriteDSPCommand(0x2000 + j->play_frame_size, j))        /* Playback C3 */
4549                 return -1;
4550
4551         if (j->flags.recording) {
4552                 ixj_aec_start(j, j->aec_level);
4553         }
4554
4555         return 0;
4556 }
4557
4558 static void ixj_play_stop(IXJ *j)
4559 {
4560         if (ixjdebug & 0x0002)
4561                 printk("IXJ %d Stopping Play Codec %d at %ld\n", j->board, j->play_codec, jiffies);
4562
4563         kfree(j->write_buffer);
4564         j->write_buffer = NULL;
4565         j->write_buffer_size = 0;
4566         if (j->play_mode > -1) {
4567                 ixj_WriteDSPCommand(0x5221, j); /* Stop playback and flush buffers.  8022 reference page 9-40 */
4568
4569                 j->play_mode = -1;
4570         }
4571         j->flags.playing = 0;
4572 }
4573
4574 static inline int get_play_level(IXJ *j)
4575 {
4576         int retval;
4577
4578         ixj_WriteDSPCommand(0xCF8F, j); /* 8022 Reference page 9-38 */
4579         return j->ssr.high << 8 | j->ssr.low;
4580         retval = j->ssr.high << 8 | j->ssr.low;
4581         retval = (retval * 256) / 240;
4582         return retval;
4583 }
4584
4585 static unsigned int ixj_poll(struct file *file_p, poll_table * wait)
4586 {
4587         unsigned int mask = 0;
4588
4589         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
4590
4591         poll_wait(file_p, &(j->poll_q), wait);
4592         if (j->read_buffer_ready > 0)
4593                 mask |= POLLIN | POLLRDNORM;    /* readable */
4594         if (j->write_buffers_empty > 0)
4595                 mask |= POLLOUT | POLLWRNORM;   /* writable */
4596         if (j->ex.bytes)
4597                 mask |= POLLPRI;
4598         return mask;
4599 }
4600
4601 static int ixj_play_tone(IXJ *j, char tone)
4602 {
4603         if (!j->tone_state) {
4604                 if(ixjdebug & 0x0002) {
4605                         printk("IXJ %d starting tone %d at %ld\n", j->board, tone, jiffies);
4606                 }
4607                 if (j->dsp.low == 0x20) {
4608                         idle(j);
4609                 }
4610                 j->tone_start_jif = jiffies;
4611
4612                 j->tone_state = 1;
4613         }
4614
4615         j->tone_index = tone;
4616         if (ixj_WriteDSPCommand(0x6000 + j->tone_index, j))
4617                 return -1;
4618
4619         return 0;
4620 }
4621
4622 static int ixj_set_tone_on(unsigned short arg, IXJ *j)
4623 {
4624         j->tone_on_time = arg;
4625
4626         if (ixj_WriteDSPCommand(0x6E04, j))             /* Set Tone On Period */
4627
4628                 return -1;
4629
4630         if (ixj_WriteDSPCommand(arg, j))
4631                 return -1;
4632
4633         return 0;
4634 }
4635
4636 static int SCI_WaitHighSCI(IXJ *j)
4637 {
4638         int cnt;
4639
4640         j->pld_scrr.byte = inb_p(j->XILINXbase);
4641         if (!j->pld_scrr.bits.sci) {
4642                 for (cnt = 0; cnt < 10; cnt++) {
4643                         udelay(32);
4644                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4645
4646                         if ((j->pld_scrr.bits.sci))
4647                                 return 1;
4648                 }
4649                 if (ixjdebug & 0x0001)
4650                         printk(KERN_INFO "SCI Wait High failed %x\n", j->pld_scrr.byte);
4651                 return 0;
4652         } else
4653                 return 1;
4654 }
4655
4656 static int SCI_WaitLowSCI(IXJ *j)
4657 {
4658         int cnt;
4659
4660         j->pld_scrr.byte = inb_p(j->XILINXbase);
4661         if (j->pld_scrr.bits.sci) {
4662                 for (cnt = 0; cnt < 10; cnt++) {
4663                         udelay(32);
4664                         j->pld_scrr.byte = inb_p(j->XILINXbase);
4665
4666                         if (!(j->pld_scrr.bits.sci))
4667                                 return 1;
4668                 }
4669                 if (ixjdebug & 0x0001)
4670                         printk(KERN_INFO "SCI Wait Low failed %x\n", j->pld_scrr.byte);
4671                 return 0;
4672         } else
4673                 return 1;
4674 }
4675
4676 static int SCI_Control(IXJ *j, int control)
4677 {
4678         switch (control) {
4679         case SCI_End:
4680                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4681
4682                 j->pld_scrw.bits.c1 = 0;        /* to no selection */
4683
4684                 break;
4685         case SCI_Enable_DAA:
4686                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4687
4688                 j->pld_scrw.bits.c1 = 0;        /* to write to DAA */
4689
4690                 break;
4691         case SCI_Enable_Mixer:
4692                 j->pld_scrw.bits.c0 = 0;        /* Set PLD Serial control interface */
4693
4694                 j->pld_scrw.bits.c1 = 1;        /* to write to mixer */
4695
4696                 break;
4697         case SCI_Enable_EEPROM:
4698                 j->pld_scrw.bits.c0 = 1;        /* Set PLD Serial control interface */
4699
4700                 j->pld_scrw.bits.c1 = 1;        /* to write to EEPROM */
4701
4702                 break;
4703         default:
4704                 return 0;
4705                 break;
4706         }
4707         outb_p(j->pld_scrw.byte, j->XILINXbase);
4708
4709         switch (control) {
4710         case SCI_End:
4711                 return 1;
4712                 break;
4713         case SCI_Enable_DAA:
4714         case SCI_Enable_Mixer:
4715         case SCI_Enable_EEPROM:
4716                 if (!SCI_WaitHighSCI(j))
4717                         return 0;
4718                 break;
4719         default:
4720                 return 0;
4721                 break;
4722         }
4723         return 1;
4724 }
4725
4726 static int SCI_Prepare(IXJ *j)
4727 {
4728         if (!SCI_Control(j, SCI_End))
4729                 return 0;
4730
4731         if (!SCI_WaitLowSCI(j))
4732                 return 0;
4733
4734         return 1;
4735 }
4736
4737 static int ixj_get_mixer(long val, IXJ *j)
4738 {
4739         int reg = (val & 0x1F00) >> 8;
4740         return j->mix.vol[reg];
4741 }
4742
4743 static int ixj_mixer(long val, IXJ *j)
4744 {
4745         BYTES bytes;
4746
4747         bytes.high = (val & 0x1F00) >> 8;
4748         bytes.low = val & 0x00FF;
4749
4750         /* save mixer value so we can get back later on */
4751         j->mix.vol[bytes.high] = bytes.low;
4752
4753         outb_p(bytes.high & 0x1F, j->XILINXbase + 0x03);        /* Load Mixer Address */
4754
4755         outb_p(bytes.low, j->XILINXbase + 0x02);        /* Load Mixer Data */
4756
4757         SCI_Control(j, SCI_Enable_Mixer);
4758
4759         SCI_Control(j, SCI_End);
4760
4761         return 0;
4762 }
4763
4764 static int daa_load(BYTES * p_bytes, IXJ *j)
4765 {
4766         outb_p(p_bytes->high, j->XILINXbase + 0x03);
4767         outb_p(p_bytes->low, j->XILINXbase + 0x02);
4768         if (!SCI_Control(j, SCI_Enable_DAA))
4769                 return 0;
4770         else
4771                 return 1;
4772 }
4773
4774 static int ixj_daa_cr4(IXJ *j, char reg)
4775 {
4776         BYTES bytes;
4777
4778         switch (j->daa_mode) {
4779         case SOP_PU_SLEEP:
4780                 bytes.high = 0x14;
4781                 break;
4782         case SOP_PU_RINGING:
4783                 bytes.high = 0x54;
4784                 break;
4785         case SOP_PU_CONVERSATION:
4786                 bytes.high = 0x94;
4787                 break;
4788         case SOP_PU_PULSEDIALING:
4789                 bytes.high = 0xD4;
4790                 break;
4791         }
4792
4793         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = reg;
4794
4795         switch (j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGX) {
4796         case 0:
4797                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 0;
4798                 break;
4799         case 1:
4800                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 2;
4801                 break;
4802         case 2:
4803                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 1;
4804                 break;
4805         case 3:
4806                 j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.bitreg.AGR_Z = 3;
4807                 break;
4808         }
4809
4810         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
4811
4812         if (!daa_load(&bytes, j))
4813                 return 0;
4814
4815         if (!SCI_Prepare(j))
4816                 return 0;
4817
4818         return 1;
4819 }
4820
4821 static char daa_int_read(IXJ *j)
4822 {
4823         BYTES bytes;
4824
4825         if (!SCI_Prepare(j))
4826                 return 0;
4827
4828         bytes.high = 0x38;
4829         bytes.low = 0x00;
4830         outb_p(bytes.high, j->XILINXbase + 0x03);
4831         outb_p(bytes.low, j->XILINXbase + 0x02);
4832
4833         if (!SCI_Control(j, SCI_Enable_DAA))
4834                 return 0;
4835
4836         bytes.high = inb_p(j->XILINXbase + 0x03);
4837         bytes.low = inb_p(j->XILINXbase + 0x02);
4838         if (bytes.low != ALISDAA_ID_BYTE) {
4839                 if (ixjdebug & 0x0001)
4840                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4841                 return 0;
4842         }
4843         if (!SCI_Control(j, SCI_Enable_DAA))
4844                 return 0;
4845         if (!SCI_Control(j, SCI_End))
4846                 return 0;
4847
4848         bytes.high = inb_p(j->XILINXbase + 0x03);
4849         bytes.low = inb_p(j->XILINXbase + 0x02);
4850
4851         j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg = bytes.high;
4852
4853         return 1;
4854 }
4855
4856 static char daa_CR_read(IXJ *j, int cr)
4857 {
4858         IXJ_WORD wdata;
4859         BYTES bytes;
4860
4861         if (!SCI_Prepare(j))
4862                 return 0;
4863
4864         switch (j->daa_mode) {
4865         case SOP_PU_SLEEP:
4866                 bytes.high = 0x30 + cr;
4867                 break;
4868         case SOP_PU_RINGING:
4869                 bytes.high = 0x70 + cr;
4870                 break;
4871         case SOP_PU_CONVERSATION:
4872                 bytes.high = 0xB0 + cr;
4873                 break;
4874         case SOP_PU_PULSEDIALING:
4875         default:
4876                 bytes.high = 0xF0 + cr;
4877                 break;
4878         }
4879
4880         bytes.low = 0x00;
4881
4882         outb_p(bytes.high, j->XILINXbase + 0x03);
4883         outb_p(bytes.low, j->XILINXbase + 0x02);
4884
4885         if (!SCI_Control(j, SCI_Enable_DAA))
4886                 return 0;
4887
4888         bytes.high = inb_p(j->XILINXbase + 0x03);
4889         bytes.low = inb_p(j->XILINXbase + 0x02);
4890         if (bytes.low != ALISDAA_ID_BYTE) {
4891                 if (ixjdebug & 0x0001)
4892                         printk("Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
4893                 return 0;
4894         }
4895         if (!SCI_Control(j, SCI_Enable_DAA))
4896                 return 0;
4897         if (!SCI_Control(j, SCI_End))
4898                 return 0;
4899
4900         wdata.word = inw_p(j->XILINXbase + 0x02);
4901
4902         switch(cr){
4903                 case 5:
4904                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = wdata.bytes.high;
4905                         break;
4906                 case 4:
4907                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = wdata.bytes.high;
4908                         break;
4909                 case 3:
4910                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = wdata.bytes.high;
4911                         break;
4912                 case 2:
4913                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = wdata.bytes.high;
4914                         break;
4915                 case 1:
4916                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = wdata.bytes.high;
4917                         break;
4918                 case 0:
4919                         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = wdata.bytes.high;
4920                         break;
4921                 default:
4922                         return 0;
4923         }
4924         return 1;
4925 }
4926
4927 static int ixj_daa_cid_reset(IXJ *j)
4928 {
4929         int i;
4930         BYTES bytes;
4931
4932         if (ixjdebug & 0x0002)
4933                 printk("DAA Clearing CID ram\n");
4934
4935         if (!SCI_Prepare(j))
4936                 return 0;
4937
4938         bytes.high = 0x58;
4939         bytes.low = 0x00;
4940         outb_p(bytes.high, j->XILINXbase + 0x03);
4941         outb_p(bytes.low, j->XILINXbase + 0x02);
4942
4943         if (!SCI_Control(j, SCI_Enable_DAA))
4944                 return 0;
4945
4946         if (!SCI_WaitHighSCI(j))
4947                 return 0;
4948
4949         for (i = 0; i < ALISDAA_CALLERID_SIZE - 1; i += 2) {
4950                 bytes.high = bytes.low = 0x00;
4951                 outb_p(bytes.high, j->XILINXbase + 0x03);
4952
4953                 if (i < ALISDAA_CALLERID_SIZE - 1)
4954                         outb_p(bytes.low, j->XILINXbase + 0x02);
4955
4956                 if (!SCI_Control(j, SCI_Enable_DAA))
4957                         return 0;
4958
4959                 if (!SCI_WaitHighSCI(j))
4960                         return 0;
4961
4962         }
4963
4964         if (!SCI_Control(j, SCI_End))
4965                 return 0;
4966
4967         if (ixjdebug & 0x0002)
4968                 printk("DAA CID ram cleared\n");
4969
4970         return 1;
4971 }
4972
4973 static int ixj_daa_cid_read(IXJ *j)
4974 {
4975         int i;
4976         BYTES bytes;
4977         char CID[ALISDAA_CALLERID_SIZE];
4978         bool mContinue;
4979         char *pIn, *pOut;
4980
4981         if (!SCI_Prepare(j))
4982                 return 0;
4983
4984         bytes.high = 0x78;
4985         bytes.low = 0x00;
4986         outb_p(bytes.high, j->XILINXbase + 0x03);
4987         outb_p(bytes.low, j->XILINXbase + 0x02);
4988
4989         if (!SCI_Control(j, SCI_Enable_DAA))
4990                 return 0;
4991
4992         if (!SCI_WaitHighSCI(j))
4993                 return 0;
4994
4995         bytes.high = inb_p(j->XILINXbase + 0x03);
4996         bytes.low = inb_p(j->XILINXbase + 0x02);
4997         if (bytes.low != ALISDAA_ID_BYTE) {
4998                 if (ixjdebug & 0x0001)
4999                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5000                 return 0;
5001         }
5002         for (i = 0; i < ALISDAA_CALLERID_SIZE; i += 2) {
5003                 bytes.high = bytes.low = 0x00;
5004                 outb_p(bytes.high, j->XILINXbase + 0x03);
5005                 outb_p(bytes.low, j->XILINXbase + 0x02);
5006
5007                 if (!SCI_Control(j, SCI_Enable_DAA))
5008                         return 0;
5009
5010                 if (!SCI_WaitHighSCI(j))
5011                         return 0;
5012
5013                 CID[i + 0] = inb_p(j->XILINXbase + 0x03);
5014                 CID[i + 1] = inb_p(j->XILINXbase + 0x02);
5015         }
5016
5017         if (!SCI_Control(j, SCI_End))
5018                 return 0;
5019
5020         pIn = CID;
5021         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5022         mContinue = true;
5023         while (mContinue) {
5024                 if ((pIn[1] & 0x03) == 0x01) {
5025                         pOut[0] = pIn[0];
5026                 }
5027                 if ((pIn[2] & 0x0c) == 0x04) {
5028                         pOut[1] = ((pIn[2] & 0x03) << 6) | ((pIn[1] & 0xfc) >> 2);
5029                 }
5030                 if ((pIn[3] & 0x30) == 0x10) {
5031                         pOut[2] = ((pIn[3] & 0x0f) << 4) | ((pIn[2] & 0xf0) >> 4);
5032                 }
5033                 if ((pIn[4] & 0xc0) == 0x40) {
5034                         pOut[3] = ((pIn[4] & 0x3f) << 2) | ((pIn[3] & 0xc0) >> 6);
5035                 } else {
5036                         mContinue = false;
5037                 }
5038                 pIn += 5, pOut += 4;
5039         }
5040         memset(&j->cid, 0, sizeof(PHONE_CID));
5041         pOut = j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID;
5042         pOut += 4;
5043         strncpy(j->cid.month, pOut, 2);
5044         pOut += 2;
5045         strncpy(j->cid.day, pOut, 2);
5046         pOut += 2;
5047         strncpy(j->cid.hour, pOut, 2);
5048         pOut += 2;
5049         strncpy(j->cid.min, pOut, 2);
5050         pOut += 3;
5051         j->cid.numlen = *pOut;
5052         pOut += 1;
5053         strncpy(j->cid.number, pOut, j->cid.numlen);
5054         pOut += j->cid.numlen + 1;
5055         j->cid.namelen = *pOut;
5056         pOut += 1;
5057         strncpy(j->cid.name, pOut, j->cid.namelen);
5058
5059         ixj_daa_cid_reset(j);
5060         return 1;
5061 }
5062
5063 static char daa_get_version(IXJ *j)
5064 {
5065         BYTES bytes;
5066
5067         if (!SCI_Prepare(j))
5068                 return 0;
5069
5070         bytes.high = 0x35;
5071         bytes.low = 0x00;
5072         outb_p(bytes.high, j->XILINXbase + 0x03);
5073         outb_p(bytes.low, j->XILINXbase + 0x02);
5074
5075         if (!SCI_Control(j, SCI_Enable_DAA))
5076                 return 0;
5077
5078         bytes.high = inb_p(j->XILINXbase + 0x03);
5079         bytes.low = inb_p(j->XILINXbase + 0x02);
5080         if (bytes.low != ALISDAA_ID_BYTE) {
5081                 if (ixjdebug & 0x0001)
5082                         printk("DAA Get Version Cannot read DAA ID Byte high = %d low = %d\n", bytes.high, bytes.low);
5083                 return 0;
5084         }
5085         if (!SCI_Control(j, SCI_Enable_DAA))
5086                 return 0;
5087
5088         if (!SCI_Control(j, SCI_End))
5089                 return 0;
5090
5091         bytes.high = inb_p(j->XILINXbase + 0x03);
5092         bytes.low = inb_p(j->XILINXbase + 0x02);
5093         if (ixjdebug & 0x0002)
5094                 printk("DAA CR5 Byte high = 0x%x low = 0x%x\n", bytes.high, bytes.low);
5095         j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg = bytes.high;
5096         return bytes.high;
5097 }
5098
5099 static int daa_set_mode(IXJ *j, int mode)
5100 {
5101         /* NOTE:
5102               The DAA *MUST* be in the conversation mode if the
5103               PSTN line is to be seized (PSTN line off-hook).
5104               Taking the PSTN line off-hook while the DAA is in
5105               a mode other than conversation mode will cause a
5106               hardware failure of the ALIS-A part.
5107
5108            NOTE:
5109               The DAA can only go to SLEEP, RINGING or PULSEDIALING modes
5110               if the PSTN line is on-hook.  Failure to have the PSTN line
5111               in the on-hook state WILL CAUSE A HARDWARE FAILURE OF THE
5112               ALIS-A part.
5113         */
5114
5115         BYTES bytes;
5116
5117         j->flags.pstn_rmr = 0;
5118
5119         if (!SCI_Prepare(j))
5120                 return 0;
5121
5122         switch (mode) {
5123         case SOP_PU_RESET:
5124                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5125
5126                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5127                 j->pld_slicw.bits.rly2 = 0;
5128                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5129                 bytes.high = 0x10;
5130                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5131                 daa_load(&bytes, j);
5132                 if (!SCI_Prepare(j))
5133                         return 0;
5134
5135                 j->daa_mode = SOP_PU_SLEEP;
5136                 break;
5137         case SOP_PU_SLEEP:
5138                 if(j->daa_mode == SOP_PU_SLEEP)
5139                 {
5140                         break;
5141                 }
5142                 if (ixjdebug & 0x0008)
5143                         printk(KERN_INFO "phone DAA: SOP_PU_SLEEP at %ld\n", jiffies);
5144 /*              if(j->daa_mode == SOP_PU_CONVERSATION) */
5145                 {
5146                         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5147
5148                         outb_p(j->pld_scrw.byte, j->XILINXbase);
5149                         j->pld_slicw.bits.rly2 = 0;
5150                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5151                         bytes.high = 0x10;
5152                         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5153                         daa_load(&bytes, j);
5154                         if (!SCI_Prepare(j))
5155                                 return 0;
5156                 }
5157                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5158
5159                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5160                 j->pld_slicw.bits.rly2 = 0;
5161                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5162                 bytes.high = 0x10;
5163                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5164                 daa_load(&bytes, j);
5165                 if (!SCI_Prepare(j))
5166                         return 0;
5167
5168                 j->daa_mode = SOP_PU_SLEEP;
5169                 j->flags.pstn_ringing = 0;
5170                 j->ex.bits.pstn_ring = 0;
5171                 j->pstn_sleeptil = jiffies + (hertz / 4);
5172                 wake_up_interruptible(&j->read_q);      /* Wake any blocked readers */
5173                 wake_up_interruptible(&j->write_q);     /* Wake any blocked writers */
5174                 wake_up_interruptible(&j->poll_q);      /* Wake any blocked selects */
5175                 break;
5176         case SOP_PU_RINGING:
5177                 if (ixjdebug & 0x0008)
5178                         printk(KERN_INFO "phone DAA: SOP_PU_RINGING at %ld\n", jiffies);
5179                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5180
5181                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5182                 j->pld_slicw.bits.rly2 = 0;
5183                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5184                 bytes.high = 0x50;
5185                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5186                 daa_load(&bytes, j);
5187                 if (!SCI_Prepare(j))
5188                         return 0;
5189                 j->daa_mode = SOP_PU_RINGING;
5190                 break;
5191         case SOP_PU_CONVERSATION:
5192                 if (ixjdebug & 0x0008)
5193                         printk(KERN_INFO "phone DAA: SOP_PU_CONVERSATION at %ld\n", jiffies);
5194                 bytes.high = 0x90;
5195                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5196                 daa_load(&bytes, j);
5197                 if (!SCI_Prepare(j))
5198                         return 0;
5199                 j->pld_slicw.bits.rly2 = 1;
5200                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5201                 j->pld_scrw.bits.daafsyncen = 1;        /* Turn on DAA Frame Sync */
5202
5203                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5204                 j->daa_mode = SOP_PU_CONVERSATION;
5205                 j->flags.pstn_ringing = 0;
5206                 j->ex.bits.pstn_ring = 0;
5207                 j->pstn_sleeptil = jiffies;
5208                 j->pstn_ring_start = j->pstn_ring_stop = j->pstn_ring_int = 0;
5209                 break;
5210         case SOP_PU_PULSEDIALING:
5211                 if (ixjdebug & 0x0008)
5212                         printk(KERN_INFO "phone DAA: SOP_PU_PULSEDIALING at %ld\n", jiffies);
5213                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
5214
5215                 outb_p(j->pld_scrw.byte, j->XILINXbase);
5216                 j->pld_slicw.bits.rly2 = 0;
5217                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
5218                 bytes.high = 0xD0;
5219                 bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5220                 daa_load(&bytes, j);
5221                 if (!SCI_Prepare(j))
5222                         return 0;
5223                 j->daa_mode = SOP_PU_PULSEDIALING;
5224                 break;
5225         default:
5226                 break;
5227         }
5228         return 1;
5229 }
5230
5231 static int ixj_daa_write(IXJ *j)
5232 {
5233         BYTES bytes;
5234
5235         j->flags.pstncheck = 1;
5236
5237         daa_set_mode(j, SOP_PU_SLEEP);
5238
5239         if (!SCI_Prepare(j))
5240                 return 0;
5241
5242         outb_p(j->pld_scrw.byte, j->XILINXbase);
5243
5244         bytes.high = 0x14;
5245         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg;
5246         if (!daa_load(&bytes, j))
5247                 return 0;
5248
5249         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg;
5250         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg;
5251         if (!daa_load(&bytes, j))
5252                 return 0;
5253
5254         bytes.high = j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg;
5255         bytes.low = j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg;
5256         if (!daa_load(&bytes, j))
5257                 return 0;
5258
5259         if (!SCI_Prepare(j))
5260                 return 0;
5261
5262         bytes.high = 0x1F;
5263         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg;
5264         if (!daa_load(&bytes, j))
5265                 return 0;
5266
5267         bytes.high = j->m_DAAShadowRegs.XOP_xr6_W.reg;
5268         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg;
5269         if (!daa_load(&bytes, j))
5270                 return 0;
5271
5272         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg;
5273         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg;
5274         if (!daa_load(&bytes, j))
5275                 return 0;
5276
5277         bytes.high = j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg;
5278         bytes.low = j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg;
5279         if (!daa_load(&bytes, j))
5280                 return 0;
5281
5282         bytes.high = j->m_DAAShadowRegs.XOP_xr0_W.reg;
5283         bytes.low = 0x00;
5284         if (!daa_load(&bytes, j))
5285                 return 0;
5286
5287         if (!SCI_Prepare(j))
5288                 return 0;
5289
5290         bytes.high = 0x00;
5291         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7];
5292         if (!daa_load(&bytes, j))
5293                 return 0;
5294
5295         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6];
5296         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5];
5297         if (!daa_load(&bytes, j))
5298                 return 0;
5299
5300         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4];
5301         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3];
5302         if (!daa_load(&bytes, j))
5303                 return 0;
5304
5305         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2];
5306         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1];
5307         if (!daa_load(&bytes, j))
5308                 return 0;
5309
5310         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0];
5311         bytes.low = 0x00;
5312         if (!daa_load(&bytes, j))
5313                 return 0;
5314
5315         if (!SCI_Control(j, SCI_End))
5316                 return 0;
5317         if (!SCI_WaitLowSCI(j))
5318                 return 0;
5319
5320         bytes.high = 0x01;
5321         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7];
5322         if (!daa_load(&bytes, j))
5323                 return 0;
5324
5325         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6];
5326         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5];
5327         if (!daa_load(&bytes, j))
5328                 return 0;
5329
5330         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4];
5331         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3];
5332         if (!daa_load(&bytes, j))
5333                 return 0;
5334
5335         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2];
5336         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1];
5337         if (!daa_load(&bytes, j))
5338                 return 0;
5339
5340         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0];
5341         bytes.low = 0x00;
5342         if (!daa_load(&bytes, j))
5343                 return 0;
5344
5345         if (!SCI_Control(j, SCI_End))
5346                 return 0;
5347         if (!SCI_WaitLowSCI(j))
5348                 return 0;
5349
5350         bytes.high = 0x02;
5351         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7];
5352         if (!daa_load(&bytes, j))
5353                 return 0;
5354
5355         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6];
5356         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5];
5357         if (!daa_load(&bytes, j))
5358                 return 0;
5359
5360         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4];
5361         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3];
5362         if (!daa_load(&bytes, j))
5363                 return 0;
5364
5365         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2];
5366         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1];
5367         if (!daa_load(&bytes, j))
5368                 return 0;
5369
5370         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0];
5371         bytes.low = 0x00;
5372         if (!daa_load(&bytes, j))
5373                 return 0;
5374
5375         if (!SCI_Control(j, SCI_End))
5376                 return 0;
5377         if (!SCI_WaitLowSCI(j))
5378                 return 0;
5379
5380         bytes.high = 0x03;
5381         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7];
5382         if (!daa_load(&bytes, j))
5383                 return 0;
5384
5385         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6];
5386         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5];
5387         if (!daa_load(&bytes, j))
5388                 return 0;
5389
5390         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4];
5391         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3];
5392         if (!daa_load(&bytes, j))
5393                 return 0;
5394
5395         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2];
5396         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1];
5397         if (!daa_load(&bytes, j))
5398                 return 0;
5399
5400         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0];
5401         bytes.low = 0x00;
5402         if (!daa_load(&bytes, j))
5403                 return 0;
5404
5405         if (!SCI_Control(j, SCI_End))
5406                 return 0;
5407         if (!SCI_WaitLowSCI(j))
5408                 return 0;
5409
5410         bytes.high = 0x04;
5411         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7];
5412         if (!daa_load(&bytes, j))
5413                 return 0;
5414
5415         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6];
5416         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5];
5417         if (!daa_load(&bytes, j))
5418                 return 0;
5419
5420         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4];
5421         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3];
5422         if (!daa_load(&bytes, j))
5423                 return 0;
5424
5425         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2];
5426         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1];
5427         if (!daa_load(&bytes, j))
5428                 return 0;
5429
5430         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0];
5431         bytes.low = 0x00;
5432         if (!daa_load(&bytes, j))
5433                 return 0;
5434
5435         if (!SCI_Control(j, SCI_End))
5436                 return 0;
5437         if (!SCI_WaitLowSCI(j))
5438                 return 0;
5439
5440         bytes.high = 0x05;
5441         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7];
5442         if (!daa_load(&bytes, j))
5443                 return 0;
5444
5445         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6];
5446         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5];
5447         if (!daa_load(&bytes, j))
5448                 return 0;
5449
5450         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4];
5451         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3];
5452         if (!daa_load(&bytes, j))
5453                 return 0;
5454
5455         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2];
5456         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1];
5457         if (!daa_load(&bytes, j))
5458                 return 0;
5459
5460         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0];
5461         bytes.low = 0x00;
5462         if (!daa_load(&bytes, j))
5463                 return 0;
5464
5465         if (!SCI_Control(j, SCI_End))
5466                 return 0;
5467         if (!SCI_WaitLowSCI(j))
5468                 return 0;
5469
5470         bytes.high = 0x06;
5471         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7];
5472         if (!daa_load(&bytes, j))
5473                 return 0;
5474
5475         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6];
5476         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5];
5477         if (!daa_load(&bytes, j))
5478                 return 0;
5479
5480         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4];
5481         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3];
5482         if (!daa_load(&bytes, j))
5483                 return 0;
5484
5485         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2];
5486         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1];
5487         if (!daa_load(&bytes, j))
5488                 return 0;
5489
5490         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0];
5491         bytes.low = 0x00;
5492         if (!daa_load(&bytes, j))
5493                 return 0;
5494
5495         if (!SCI_Control(j, SCI_End))
5496                 return 0;
5497         if (!SCI_WaitLowSCI(j))
5498                 return 0;
5499
5500         bytes.high = 0x07;
5501         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7];
5502         if (!daa_load(&bytes, j))
5503                 return 0;
5504
5505         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6];
5506         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5];
5507         if (!daa_load(&bytes, j))
5508                 return 0;
5509
5510         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4];
5511         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3];
5512         if (!daa_load(&bytes, j))
5513                 return 0;
5514
5515         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2];
5516         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1];
5517         if (!daa_load(&bytes, j))
5518                 return 0;
5519
5520         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0];
5521         bytes.low = 0x00;
5522         if (!daa_load(&bytes, j))
5523                 return 0;
5524
5525         if (!SCI_Control(j, SCI_End))
5526                 return 0;
5527         if (!SCI_WaitLowSCI(j))
5528                 return 0;
5529
5530         bytes.high = 0x08;
5531         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7];
5532         if (!daa_load(&bytes, j))
5533                 return 0;
5534
5535         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6];
5536         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5];
5537         if (!daa_load(&bytes, j))
5538                 return 0;
5539
5540         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4];
5541         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3];
5542         if (!daa_load(&bytes, j))
5543                 return 0;
5544
5545         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2];
5546         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1];
5547         if (!daa_load(&bytes, j))
5548                 return 0;
5549
5550         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0];
5551         bytes.low = 0x00;
5552         if (!daa_load(&bytes, j))
5553                 return 0;
5554
5555         if (!SCI_Control(j, SCI_End))
5556                 return 0;
5557         if (!SCI_WaitLowSCI(j))
5558                 return 0;
5559
5560         bytes.high = 0x09;
5561         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3];
5562         if (!daa_load(&bytes, j))
5563                 return 0;
5564
5565         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2];
5566         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1];
5567         if (!daa_load(&bytes, j))
5568                 return 0;
5569
5570         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0];
5571         bytes.low = 0x00;
5572         if (!daa_load(&bytes, j))
5573                 return 0;
5574
5575         if (!SCI_Control(j, SCI_End))
5576                 return 0;
5577         if (!SCI_WaitLowSCI(j))
5578                 return 0;
5579
5580         bytes.high = 0x0A;
5581         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3];
5582         if (!daa_load(&bytes, j))
5583                 return 0;
5584
5585         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2];
5586         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1];
5587         if (!daa_load(&bytes, j))
5588                 return 0;
5589
5590         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0];
5591         bytes.low = 0x00;
5592         if (!daa_load(&bytes, j))
5593                 return 0;
5594
5595         if (!SCI_Control(j, SCI_End))
5596                 return 0;
5597         if (!SCI_WaitLowSCI(j))
5598                 return 0;
5599
5600         bytes.high = 0x0B;
5601         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3];
5602         if (!daa_load(&bytes, j))
5603                 return 0;
5604
5605         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2];
5606         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1];
5607         if (!daa_load(&bytes, j))
5608                 return 0;
5609
5610         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0];
5611         bytes.low = 0x00;
5612         if (!daa_load(&bytes, j))
5613                 return 0;
5614
5615         if (!SCI_Control(j, SCI_End))
5616                 return 0;
5617         if (!SCI_WaitLowSCI(j))
5618                 return 0;
5619
5620         bytes.high = 0x0C;
5621         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3];
5622         if (!daa_load(&bytes, j))
5623                 return 0;
5624
5625         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2];
5626         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1];
5627         if (!daa_load(&bytes, j))
5628                 return 0;
5629
5630         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0];
5631         bytes.low = 0x00;
5632         if (!daa_load(&bytes, j))
5633                 return 0;
5634
5635         if (!SCI_Control(j, SCI_End))
5636                 return 0;
5637         if (!SCI_WaitLowSCI(j))
5638                 return 0;
5639
5640         bytes.high = 0x0D;
5641         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3];
5642         if (!daa_load(&bytes, j))
5643                 return 0;
5644
5645         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2];
5646         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1];
5647         if (!daa_load(&bytes, j))
5648                 return 0;
5649
5650         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0];
5651         bytes.low = 0x00;
5652         if (!daa_load(&bytes, j))
5653                 return 0;
5654
5655         if (!SCI_Control(j, SCI_End))
5656                 return 0;
5657         if (!SCI_WaitLowSCI(j))
5658                 return 0;
5659
5660         bytes.high = 0x0E;
5661         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7];
5662         if (!daa_load(&bytes, j))
5663                 return 0;
5664
5665         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6];
5666         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5];
5667         if (!daa_load(&bytes, j))
5668                 return 0;
5669
5670         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4];
5671         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3];
5672         if (!daa_load(&bytes, j))
5673                 return 0;
5674
5675         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2];
5676         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1];
5677         if (!daa_load(&bytes, j))
5678                 return 0;
5679
5680         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0];
5681         bytes.low = 0x00;
5682         if (!daa_load(&bytes, j))
5683                 return 0;
5684
5685         if (!SCI_Control(j, SCI_End))
5686                 return 0;
5687         if (!SCI_WaitLowSCI(j))
5688                 return 0;
5689
5690         bytes.high = 0x0F;
5691         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7];
5692         if (!daa_load(&bytes, j))
5693                 return 0;
5694
5695         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6];
5696         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5];
5697         if (!daa_load(&bytes, j))
5698                 return 0;
5699
5700         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4];
5701         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3];
5702         if (!daa_load(&bytes, j))
5703                 return 0;
5704
5705         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2];
5706         bytes.low = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1];
5707         if (!daa_load(&bytes, j))
5708                 return 0;
5709
5710         bytes.high = j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0];
5711         bytes.low = 0x00;
5712         if (!daa_load(&bytes, j))
5713                 return 0;
5714
5715         udelay(32);
5716         j->pld_scrr.byte = inb_p(j->XILINXbase);
5717         if (!SCI_Control(j, SCI_End))
5718                 return 0;
5719
5720         outb_p(j->pld_scrw.byte, j->XILINXbase);
5721
5722         if (ixjdebug & 0x0002)
5723                 printk("DAA Coefficients Loaded\n");
5724
5725         j->flags.pstncheck = 0;
5726         return 1;
5727 }
5728
5729 static int ixj_set_tone_off(unsigned short arg, IXJ *j)
5730 {
5731         j->tone_off_time = arg;
5732         if (ixj_WriteDSPCommand(0x6E05, j))             /* Set Tone Off Period */
5733
5734                 return -1;
5735         if (ixj_WriteDSPCommand(arg, j))
5736                 return -1;
5737         return 0;
5738 }
5739
5740 static int ixj_get_tone_on(IXJ *j)
5741 {
5742         if (ixj_WriteDSPCommand(0x6E06, j))             /* Get Tone On Period */
5743
5744                 return -1;
5745         return 0;
5746 }
5747
5748 static int ixj_get_tone_off(IXJ *j)
5749 {
5750         if (ixj_WriteDSPCommand(0x6E07, j))             /* Get Tone Off Period */
5751
5752                 return -1;
5753         return 0;
5754 }
5755
5756 static void ixj_busytone(IXJ *j)
5757 {
5758         j->flags.ringback = 0;
5759         j->flags.dialtone = 0;
5760         j->flags.busytone = 1;
5761         ixj_set_tone_on(0x07D0, j);
5762         ixj_set_tone_off(0x07D0, j);
5763         ixj_play_tone(j, 27);
5764 }
5765
5766 static void ixj_dialtone(IXJ *j)
5767 {
5768         j->flags.ringback = 0;
5769         j->flags.dialtone = 1;
5770         j->flags.busytone = 0;
5771         if (j->dsp.low == 0x20) {
5772                 return;
5773         } else {
5774                 ixj_set_tone_on(0xFFFF, j);
5775                 ixj_set_tone_off(0x0000, j);
5776                 ixj_play_tone(j, 25);
5777         }
5778 }
5779
5780 static void ixj_cpt_stop(IXJ *j)
5781 {
5782         if(j->tone_state || j->tone_cadence_state)
5783         {
5784                 j->flags.dialtone = 0;
5785                 j->flags.busytone = 0;
5786                 j->flags.ringback = 0;
5787                 ixj_set_tone_on(0x0001, j);
5788                 ixj_set_tone_off(0x0000, j);
5789                 ixj_play_tone(j, 0);
5790                 j->tone_state = j->tone_cadence_state = 0;
5791                 if (j->cadence_t) {
5792                         kfree(j->cadence_t->ce);
5793                         kfree(j->cadence_t);
5794                         j->cadence_t = NULL;
5795                 }
5796         }
5797         if (j->play_mode == -1 && j->rec_mode == -1)
5798                 idle(j);
5799         if (j->play_mode != -1 && j->dsp.low == 0x20)
5800                 ixj_play_start(j);
5801         if (j->rec_mode != -1 && j->dsp.low == 0x20)
5802                 ixj_record_start(j);
5803 }
5804
5805 static void ixj_ringback(IXJ *j)
5806 {
5807         j->flags.busytone = 0;
5808         j->flags.dialtone = 0;
5809         j->flags.ringback = 1;
5810         ixj_set_tone_on(0x0FA0, j);
5811         ixj_set_tone_off(0x2EE0, j);
5812         ixj_play_tone(j, 26);
5813 }
5814
5815 static void ixj_testram(IXJ *j)
5816 {
5817         ixj_WriteDSPCommand(0x3001, j); /* Test External SRAM */
5818 }
5819
5820 static int ixj_build_cadence(IXJ *j, IXJ_CADENCE __user * cp)
5821 {
5822         ixj_cadence *lcp;
5823         IXJ_CADENCE_ELEMENT __user *cep;
5824         IXJ_CADENCE_ELEMENT *lcep;
5825         IXJ_TONE ti;
5826         int err;
5827
5828         lcp = kmalloc(sizeof(ixj_cadence), GFP_KERNEL);
5829         if (lcp == NULL)
5830                 return -ENOMEM;
5831
5832         err = -EFAULT;
5833         if (copy_from_user(&lcp->elements_used,
5834                            &cp->elements_used, sizeof(int)))
5835                 goto out;
5836         if (copy_from_user(&lcp->termination,
5837                            &cp->termination, sizeof(IXJ_CADENCE_TERM)))
5838                 goto out;
5839         if (get_user(cep, &cp->ce))
5840                 goto out;
5841
5842         err = -EINVAL;
5843         if ((unsigned)lcp->elements_used >= ~0U/sizeof(IXJ_CADENCE_ELEMENT))
5844                 goto out;
5845
5846         err = -ENOMEM;
5847         lcep = kmalloc(sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used, GFP_KERNEL);
5848         if (!lcep)
5849                 goto out;
5850
5851         err = -EFAULT;
5852         if (copy_from_user(lcep, cep, sizeof(IXJ_CADENCE_ELEMENT) * lcp->elements_used))
5853                 goto out1;
5854
5855         if (j->cadence_t) {
5856                 kfree(j->cadence_t->ce);
5857                 kfree(j->cadence_t);
5858         }
5859         lcp->ce = (void *) lcep;
5860         j->cadence_t = lcp;
5861         j->tone_cadence_state = 0;
5862         ixj_set_tone_on(lcp->ce[0].tone_on_time, j);
5863         ixj_set_tone_off(lcp->ce[0].tone_off_time, j);
5864         if (j->cadence_t->ce[j->tone_cadence_state].freq0) {
5865                 ti.tone_index = j->cadence_t->ce[j->tone_cadence_state].index;
5866                 ti.freq0 = j->cadence_t->ce[j->tone_cadence_state].freq0;
5867                 ti.gain0 = j->cadence_t->ce[j->tone_cadence_state].gain0;
5868                 ti.freq1 = j->cadence_t->ce[j->tone_cadence_state].freq1;
5869                 ti.gain1 = j->cadence_t->ce[j->tone_cadence_state].gain1;
5870                 ixj_init_tone(j, &ti);
5871         }
5872         ixj_play_tone(j, lcp->ce[0].index);
5873         return 1;
5874 out1:
5875         kfree(lcep);
5876 out:
5877         kfree(lcp);
5878         return err;
5879 }
5880
5881 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
5882 {
5883         IXJ_FILTER_CADENCE *lcp;
5884         lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
5885         if (lcp == NULL) {
5886                 if(ixjdebug & 0x0001) {
5887                         printk(KERN_INFO "Could not allocate memory for cadence\n");
5888                 }
5889                 return -ENOMEM;
5890         }
5891         if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
5892                 if(ixjdebug & 0x0001) {
5893                         printk(KERN_INFO "Could not copy cadence to kernel\n");
5894                 }
5895                 kfree(lcp);
5896                 return -EFAULT;
5897         }
5898         if (lcp->filter > 5) {
5899                 if(ixjdebug & 0x0001) {
5900                         printk(KERN_INFO "Cadence out of range\n");
5901                 }
5902                 kfree(lcp);
5903                 return -1;
5904         }
5905         j->cadence_f[lcp->filter].state = 0;
5906         j->cadence_f[lcp->filter].enable = lcp->enable;
5907         j->filter_en[lcp->filter] = j->cadence_f[lcp->filter].en_filter = lcp->en_filter;
5908         j->cadence_f[lcp->filter].on1 = lcp->on1;
5909         j->cadence_f[lcp->filter].on1min = 0;
5910         j->cadence_f[lcp->filter].on1max = 0;
5911         j->cadence_f[lcp->filter].off1 = lcp->off1;
5912         j->cadence_f[lcp->filter].off1min = 0;
5913         j->cadence_f[lcp->filter].off1max = 0;
5914         j->cadence_f[lcp->filter].on2 = lcp->on2;
5915         j->cadence_f[lcp->filter].on2min = 0;
5916         j->cadence_f[lcp->filter].on2max = 0;
5917         j->cadence_f[lcp->filter].off2 = lcp->off2;
5918         j->cadence_f[lcp->filter].off2min = 0;
5919         j->cadence_f[lcp->filter].off2max = 0;
5920         j->cadence_f[lcp->filter].on3 = lcp->on3;
5921         j->cadence_f[lcp->filter].on3min = 0;
5922         j->cadence_f[lcp->filter].on3max = 0;
5923         j->cadence_f[lcp->filter].off3 = lcp->off3;
5924         j->cadence_f[lcp->filter].off3min = 0;
5925         j->cadence_f[lcp->filter].off3max = 0;
5926         if(ixjdebug & 0x0002) {
5927                 printk(KERN_INFO "Cadence %d loaded\n", lcp->filter);
5928         }
5929         kfree(lcp);
5930         return 0;
5931 }
5932
5933 static void add_caps(IXJ *j)
5934 {
5935         j->caps = 0;
5936         j->caplist[j->caps].cap = PHONE_VENDOR_QUICKNET;
5937         strcpy(j->caplist[j->caps].desc, "Quicknet Technologies, Inc. (www.quicknet.net)");
5938         j->caplist[j->caps].captype = vendor;
5939         j->caplist[j->caps].handle = j->caps++;
5940         j->caplist[j->caps].captype = device;
5941         switch (j->cardtype) {
5942         case QTI_PHONEJACK:
5943                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK");
5944                 break;
5945         case QTI_LINEJACK:
5946                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet LineJACK");
5947                 break;
5948         case QTI_PHONEJACK_LITE:
5949                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK Lite");
5950                 break;
5951         case QTI_PHONEJACK_PCI:
5952                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneJACK PCI");
5953                 break;
5954         case QTI_PHONECARD:
5955                 strcpy(j->caplist[j->caps].desc, "Quicknet Internet PhoneCARD");
5956                 break;
5957         }
5958         j->caplist[j->caps].cap = j->cardtype;
5959         j->caplist[j->caps].handle = j->caps++;
5960         strcpy(j->caplist[j->caps].desc, "POTS");
5961         j->caplist[j->caps].captype = port;
5962         j->caplist[j->caps].cap = pots;
5963         j->caplist[j->caps].handle = j->caps++;
5964
5965         /* add devices that can do speaker/mic */
5966         switch (j->cardtype) {
5967         case QTI_PHONEJACK:
5968         case QTI_LINEJACK:
5969         case QTI_PHONEJACK_PCI:
5970         case QTI_PHONECARD:
5971                 strcpy(j->caplist[j->caps].desc, "SPEAKER");
5972                 j->caplist[j->caps].captype = port;
5973                 j->caplist[j->caps].cap = speaker;
5974                 j->caplist[j->caps].handle = j->caps++;
5975         default:
5976                 break;
5977         }
5978
5979         /* add devices that can do handset */
5980         switch (j->cardtype) {
5981         case QTI_PHONEJACK:
5982                 strcpy(j->caplist[j->caps].desc, "HANDSET");
5983                 j->caplist[j->caps].captype = port;
5984                 j->caplist[j->caps].cap = handset;
5985                 j->caplist[j->caps].handle = j->caps++;
5986                 break;
5987         default:
5988                 break;
5989         }
5990
5991         /* add devices that can do PSTN */
5992         switch (j->cardtype) {
5993         case QTI_LINEJACK:
5994                 strcpy(j->caplist[j->caps].desc, "PSTN");
5995                 j->caplist[j->caps].captype = port;
5996                 j->caplist[j->caps].cap = pstn;
5997                 j->caplist[j->caps].handle = j->caps++;
5998                 break;
5999         default:
6000                 break;
6001         }
6002
6003         /* add codecs - all cards can do uLaw, linear 8/16, and Windows sound system */
6004         strcpy(j->caplist[j->caps].desc, "ULAW");
6005         j->caplist[j->caps].captype = codec;
6006         j->caplist[j->caps].cap = ULAW;
6007         j->caplist[j->caps].handle = j->caps++;
6008
6009         strcpy(j->caplist[j->caps].desc, "LINEAR 16 bit");
6010         j->caplist[j->caps].captype = codec;
6011         j->caplist[j->caps].cap = LINEAR16;
6012         j->caplist[j->caps].handle = j->caps++;
6013
6014         strcpy(j->caplist[j->caps].desc, "LINEAR 8 bit");
6015         j->caplist[j->caps].captype = codec;
6016         j->caplist[j->caps].cap = LINEAR8;
6017         j->caplist[j->caps].handle = j->caps++;
6018
6019         strcpy(j->caplist[j->caps].desc, "Windows Sound System");
6020         j->caplist[j->caps].captype = codec;
6021         j->caplist[j->caps].cap = WSS;
6022         j->caplist[j->caps].handle = j->caps++;
6023
6024         /* software ALAW codec, made from ULAW */
6025         strcpy(j->caplist[j->caps].desc, "ALAW");
6026         j->caplist[j->caps].captype = codec;
6027         j->caplist[j->caps].cap = ALAW;
6028         j->caplist[j->caps].handle = j->caps++;
6029
6030         /* version 12 of the 8020 does the following codecs in a broken way */
6031         if (j->dsp.low != 0x20 || j->ver.low != 0x12) {
6032                 strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
6033                 j->caplist[j->caps].captype = codec;
6034                 j->caplist[j->caps].cap = G723_63;
6035                 j->caplist[j->caps].handle = j->caps++;
6036
6037                 strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
6038                 j->caplist[j->caps].captype = codec;
6039                 j->caplist[j->caps].cap = G723_53;
6040                 j->caplist[j->caps].handle = j->caps++;
6041
6042                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.8kbps");
6043                 j->caplist[j->caps].captype = codec;
6044                 j->caplist[j->caps].cap = TS48;
6045                 j->caplist[j->caps].handle = j->caps++;
6046
6047                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 4.1kbps");
6048                 j->caplist[j->caps].captype = codec;
6049                 j->caplist[j->caps].cap = TS41;
6050                 j->caplist[j->caps].handle = j->caps++;
6051         }
6052
6053         /* 8020 chips can do TS8.5 native, and 8021/8022 can load it */
6054         if (j->dsp.low == 0x20 || j->flags.ts85_loaded) {
6055                 strcpy(j->caplist[j->caps].desc, "TrueSpeech 8.5kbps");
6056                 j->caplist[j->caps].captype = codec;
6057                 j->caplist[j->caps].cap = TS85;
6058                 j->caplist[j->caps].handle = j->caps++;
6059         }
6060
6061         /* 8021 chips can do G728 */
6062         if (j->dsp.low == 0x21) {
6063                 strcpy(j->caplist[j->caps].desc, "G.728 16kbps");
6064                 j->caplist[j->caps].captype = codec;
6065                 j->caplist[j->caps].cap = G728;
6066                 j->caplist[j->caps].handle = j->caps++;
6067         }
6068
6069         /* 8021/8022 chips can do G729 if loaded */
6070         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6071                 strcpy(j->caplist[j->caps].desc, "G.729A 8kbps");
6072                 j->caplist[j->caps].captype = codec;
6073                 j->caplist[j->caps].cap = G729;
6074                 j->caplist[j->caps].handle = j->caps++;
6075         }
6076         if (j->dsp.low != 0x20 && j->flags.g729_loaded) {
6077                 strcpy(j->caplist[j->caps].desc, "G.729B 8kbps");
6078                 j->caplist[j->caps].captype = codec;
6079                 j->caplist[j->caps].cap = G729B;
6080                 j->caplist[j->caps].handle = j->caps++;
6081         }
6082 }
6083
6084 static int capabilities_check(IXJ *j, struct phone_capability *pcreq)
6085 {
6086         int cnt;
6087         int retval = 0;
6088         for (cnt = 0; cnt < j->caps; cnt++) {
6089                 if (pcreq->captype == j->caplist[cnt].captype
6090                     && pcreq->cap == j->caplist[cnt].cap) {
6091                         retval = 1;
6092                         break;
6093                 }
6094         }
6095         return retval;
6096 }
6097
6098 static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6099 {
6100         IXJ_TONE ti;
6101         IXJ_FILTER jf;
6102         IXJ_FILTER_RAW jfr;
6103         void __user *argp = (void __user *)arg;
6104         struct inode *inode = file_p->f_path.dentry->d_inode;
6105         unsigned int minor = iminor(inode);
6106         unsigned int raise, mant;
6107         int board = NUM(inode);
6108
6109         IXJ *j = get_ixj(NUM(inode));
6110
6111         int retval = 0;
6112
6113         /*
6114          *    Set up locks to ensure that only one process is talking to the DSP at a time.
6115          *    This is necessary to keep the DSP from locking up.
6116          */
6117         while(test_and_set_bit(board, (void *)&j->busyflags) != 0)
6118                 schedule_timeout_interruptible(1);
6119         if (ixjdebug & 0x0040)
6120                 printk("phone%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6121         if (minor >= IXJMAX) {
6122                 clear_bit(board, &j->busyflags);
6123                 return -ENODEV;
6124         }
6125         /*
6126          *    Check ioctls only root can use.
6127          */
6128         if (!capable(CAP_SYS_ADMIN)) {
6129                 switch (cmd) {
6130                 case IXJCTL_TESTRAM:
6131                 case IXJCTL_HZ:
6132                         retval = -EPERM;
6133                 }
6134         }
6135         switch (cmd) {
6136         case IXJCTL_TESTRAM:
6137                 ixj_testram(j);
6138                 retval = (j->ssr.high << 8) + j->ssr.low;
6139                 break;
6140         case IXJCTL_CARDTYPE:
6141                 retval = j->cardtype;
6142                 break;
6143         case IXJCTL_SERIAL:
6144                 retval = j->serial;
6145                 break;
6146         case IXJCTL_VERSION:
6147                 {
6148                         char arg_str[100];
6149                         snprintf(arg_str, sizeof(arg_str),
6150                                 "\nDriver version %i.%i.%i", IXJ_VER_MAJOR,
6151                                 IXJ_VER_MINOR, IXJ_BLD_VER);
6152                         if (copy_to_user(argp, arg_str, strlen(arg_str)))
6153                                 retval = -EFAULT;
6154                 }
6155                 break;
6156         case PHONE_RING_CADENCE:
6157                 j->ring_cadence = arg;
6158                 break;
6159         case IXJCTL_CIDCW:
6160                 if(arg) {
6161                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6162                                 retval = -EFAULT;
6163                                 break;
6164                         }
6165                 } else {
6166                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6167                 }
6168                 ixj_write_cidcw(j);
6169                 break;
6170         /* Binary compatbility */
6171         case OLD_PHONE_RING_START:
6172                 arg = 0;
6173                 /* Fall through */
6174         case PHONE_RING_START:
6175                 if(arg) {
6176                         if (copy_from_user(&j->cid_send, argp, sizeof(PHONE_CID))) {
6177                                 retval = -EFAULT;
6178                                 break;
6179                         }
6180                         ixj_write_cid(j);
6181                 } else {
6182                         memset(&j->cid_send, 0, sizeof(PHONE_CID));
6183                 }
6184                 ixj_ring_start(j);
6185                 break;
6186         case PHONE_RING_STOP:
6187                 j->flags.cringing = 0;
6188                 if(j->cadence_f[5].enable) {
6189                         j->cadence_f[5].state = 0;
6190                 }
6191                 ixj_ring_off(j);
6192                 break;
6193         case PHONE_RING:
6194                 retval = ixj_ring(j);
6195                 break;
6196         case PHONE_EXCEPTION:
6197                 retval = j->ex.bytes;
6198                 if(j->ex.bits.flash) {
6199                         j->flash_end = 0;
6200                         j->ex.bits.flash = 0;
6201                 }
6202                 j->ex.bits.pstn_ring = 0;
6203                 j->ex.bits.caller_id = 0;
6204                 j->ex.bits.pstn_wink = 0;
6205                 j->ex.bits.f0 = 0;
6206                 j->ex.bits.f1 = 0;
6207                 j->ex.bits.f2 = 0;
6208                 j->ex.bits.f3 = 0;
6209                 j->ex.bits.fc0 = 0;
6210                 j->ex.bits.fc1 = 0;
6211                 j->ex.bits.fc2 = 0;
6212                 j->ex.bits.fc3 = 0;
6213                 j->ex.bits.reserved = 0;
6214                 break;
6215         case PHONE_HOOKSTATE:
6216                 j->ex.bits.hookstate = 0;
6217                 retval = j->hookstate;  //j->r_hook;
6218                 break;
6219         case IXJCTL_SET_LED:
6220                 LED_SetState(arg, j);
6221                 break;
6222         case PHONE_FRAME:
6223                 retval = set_base_frame(j, arg);
6224                 break;
6225         case PHONE_REC_CODEC:
6226                 retval = set_rec_codec(j, arg);
6227                 break;
6228         case PHONE_VAD:
6229                 ixj_vad(j, arg);
6230                 break;
6231         case PHONE_REC_START:
6232                 ixj_record_start(j);
6233                 break;
6234         case PHONE_REC_STOP:
6235                 ixj_record_stop(j);
6236                 break;
6237         case PHONE_REC_DEPTH:
6238                 set_rec_depth(j, arg);
6239                 break;
6240         case PHONE_REC_VOLUME:
6241                 if(arg == -1) {
6242                         retval = get_rec_volume(j);
6243                 }
6244                 else {
6245                         set_rec_volume(j, arg);
6246                         retval = arg;
6247                 }
6248                 break;
6249         case PHONE_REC_VOLUME_LINEAR:
6250                 if(arg == -1) {
6251                         retval = get_rec_volume_linear(j);
6252                 }
6253                 else {
6254                         set_rec_volume_linear(j, arg);
6255                         retval = arg;
6256                 }
6257                 break;
6258         case IXJCTL_DTMF_PRESCALE:
6259                 if(arg == -1) {
6260                         retval = get_dtmf_prescale(j);
6261                 }
6262                 else {
6263                         set_dtmf_prescale(j, arg);
6264                         retval = arg;
6265                 }
6266                 break;
6267         case PHONE_REC_LEVEL:
6268                 retval = get_rec_level(j);
6269                 break;
6270         case IXJCTL_SC_RXG:
6271                 retval = ixj_siadc(j, arg);
6272                 break;
6273         case IXJCTL_SC_TXG:
6274                 retval = ixj_sidac(j, arg);
6275                 break;
6276         case IXJCTL_AEC_START:
6277                 ixj_aec_start(j, arg);
6278                 break;
6279         case IXJCTL_AEC_STOP:
6280                 aec_stop(j);
6281                 break;
6282         case IXJCTL_AEC_GET_LEVEL:
6283                 retval = j->aec_level;
6284                 break;
6285         case PHONE_PLAY_CODEC:
6286                 retval = set_play_codec(j, arg);
6287                 break;
6288         case PHONE_PLAY_START:
6289                 retval = ixj_play_start(j);
6290                 break;
6291         case PHONE_PLAY_STOP:
6292                 ixj_play_stop(j);
6293                 break;
6294         case PHONE_PLAY_DEPTH:
6295                 set_play_depth(j, arg);
6296                 break;
6297         case PHONE_PLAY_VOLUME:
6298                 if(arg == -1) {
6299                         retval = get_play_volume(j);
6300                 }
6301                 else {
6302                         set_play_volume(j, arg);
6303                         retval = arg;
6304                 }
6305                 break;
6306         case PHONE_PLAY_VOLUME_LINEAR:
6307                 if(arg == -1) {
6308                         retval = get_play_volume_linear(j);
6309                 }
6310                 else {
6311                         set_play_volume_linear(j, arg);
6312                         retval = arg;
6313                 }
6314                 break;
6315         case PHONE_PLAY_LEVEL:
6316                 retval = get_play_level(j);
6317                 break;
6318         case IXJCTL_DSP_TYPE:
6319                 retval = (j->dsp.high << 8) + j->dsp.low;
6320                 break;
6321         case IXJCTL_DSP_VERSION:
6322                 retval = (j->ver.high << 8) + j->ver.low;
6323                 break;
6324         case IXJCTL_HZ:
6325                 hertz = arg;
6326                 break;
6327         case IXJCTL_RATE:
6328                 if (arg > hertz)
6329                         retval = -1;
6330                 else
6331                         samplerate = arg;
6332                 break;
6333         case IXJCTL_DRYBUFFER_READ:
6334                 put_user(j->drybuffer, (unsigned long __user *) argp);
6335                 break;
6336         case IXJCTL_DRYBUFFER_CLEAR:
6337                 j->drybuffer = 0;
6338                 break;
6339         case IXJCTL_FRAMES_READ:
6340                 put_user(j->framesread, (unsigned long __user *) argp);
6341                 break;
6342         case IXJCTL_FRAMES_WRITTEN:
6343                 put_user(j->frameswritten, (unsigned long __user *) argp);
6344                 break;
6345         case IXJCTL_READ_WAIT:
6346                 put_user(j->read_wait, (unsigned long __user *) argp);
6347                 break;
6348         case IXJCTL_WRITE_WAIT:
6349                 put_user(j->write_wait, (unsigned long __user *) argp);
6350                 break;
6351         case PHONE_MAXRINGS:
6352                 j->maxrings = arg;
6353                 break;
6354         case PHONE_SET_TONE_ON_TIME:
6355                 ixj_set_tone_on(arg, j);
6356                 break;
6357         case PHONE_SET_TONE_OFF_TIME:
6358                 ixj_set_tone_off(arg, j);
6359                 break;
6360         case PHONE_GET_TONE_ON_TIME:
6361                 if (ixj_get_tone_on(j)) {
6362                         retval = -1;
6363                 } else {
6364                         retval = (j->ssr.high << 8) + j->ssr.low;
6365                 }
6366                 break;
6367         case PHONE_GET_TONE_OFF_TIME:
6368                 if (ixj_get_tone_off(j)) {
6369                         retval = -1;
6370                 } else {
6371                         retval = (j->ssr.high << 8) + j->ssr.low;
6372                 }
6373                 break;
6374         case PHONE_PLAY_TONE:
6375                 if (!j->tone_state)
6376                         retval = ixj_play_tone(j, arg);
6377                 else
6378                         retval = -1;
6379                 break;
6380         case PHONE_GET_TONE_STATE:
6381                 retval = j->tone_state;
6382                 break;
6383         case PHONE_DTMF_READY:
6384                 retval = j->ex.bits.dtmf_ready;
6385                 break;
6386         case PHONE_GET_DTMF:
6387                 if (ixj_hookstate(j)) {
6388                         if (j->dtmf_rp != j->dtmf_wp) {
6389                                 retval = j->dtmfbuffer[j->dtmf_rp];
6390                                 j->dtmf_rp++;
6391                                 if (j->dtmf_rp == 79)
6392                                         j->dtmf_rp = 0;
6393                                 if (j->dtmf_rp == j->dtmf_wp) {
6394                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6395                                 }
6396                         }
6397                 }
6398                 break;
6399         case PHONE_GET_DTMF_ASCII:
6400                 if (ixj_hookstate(j)) {
6401                         if (j->dtmf_rp != j->dtmf_wp) {
6402                                 switch (j->dtmfbuffer[j->dtmf_rp]) {
6403                                 case 10:
6404                                         retval = 42;    /* '*'; */
6405
6406                                         break;
6407                                 case 11:
6408                                         retval = 48;    /*'0'; */
6409
6410                                         break;
6411                                 case 12:
6412                                         retval = 35;    /*'#'; */
6413
6414                                         break;
6415                                 case 28:
6416                                         retval = 65;    /*'A'; */
6417
6418                                         break;
6419                                 case 29:
6420                                         retval = 66;    /*'B'; */
6421
6422                                         break;
6423                                 case 30:
6424                                         retval = 67;    /*'C'; */
6425
6426                                         break;
6427                                 case 31:
6428                                         retval = 68;    /*'D'; */
6429
6430                                         break;
6431                                 default:
6432                                         retval = 48 + j->dtmfbuffer[j->dtmf_rp];
6433                                         break;
6434                                 }
6435                                 j->dtmf_rp++;
6436                                 if (j->dtmf_rp == 79)
6437                                         j->dtmf_rp = 0;
6438                                 if(j->dtmf_rp == j->dtmf_wp)
6439                                 {
6440                                         j->ex.bits.dtmf_ready = j->dtmf_rp = j->dtmf_wp = 0;
6441                                 }
6442                         }
6443                 }
6444                 break;
6445         case PHONE_DTMF_OOB:
6446                 j->flags.dtmf_oob = arg;
6447                 break;
6448         case PHONE_DIALTONE:
6449                 ixj_dialtone(j);
6450                 break;
6451         case PHONE_BUSY:
6452                 ixj_busytone(j);
6453                 break;
6454         case PHONE_RINGBACK:
6455                 ixj_ringback(j);
6456                 break;
6457         case PHONE_WINK:
6458                 if(j->cardtype == QTI_PHONEJACK)
6459                         retval = -1;
6460                 else
6461                         retval = ixj_wink(j);
6462                 break;
6463         case PHONE_CPT_STOP:
6464                 ixj_cpt_stop(j);
6465                 break;
6466         case PHONE_QUERY_CODEC:
6467         {
6468                 struct phone_codec_data pd;
6469                 int val;
6470                 int proto_size[] = {
6471                         -1,
6472                         12, 10, 16, 9, 8, 48, 5,
6473                         40, 40, 80, 40, 40, 6
6474                 };
6475                 if(copy_from_user(&pd, argp, sizeof(pd))) {
6476                         retval = -EFAULT;
6477                         break;
6478                 }
6479                 if(pd.type<1 || pd.type>13) {
6480                         retval = -EPROTONOSUPPORT;
6481                         break;
6482                 }
6483                 if(pd.type<G729)
6484                         val=proto_size[pd.type];
6485                 else switch(j->baseframe.low)
6486                 {
6487                         case 0xA0:val=2*proto_size[pd.type];break;
6488                         case 0x50:val=proto_size[pd.type];break;
6489                         default:val=proto_size[pd.type]*3;break;
6490                 }
6491                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
6492                 if(copy_to_user(argp, &pd, sizeof(pd)))
6493                         retval = -EFAULT;
6494                 break;
6495         }
6496         case IXJCTL_DSP_IDLE:
6497                 idle(j);
6498                 break;
6499         case IXJCTL_MIXER:
6500                 if ((arg & 0xff) == 0xff)
6501                         retval = ixj_get_mixer(arg, j);
6502                 else
6503                         ixj_mixer(arg, j);
6504                 break;
6505         case IXJCTL_DAA_COEFF_SET:
6506                 switch (arg) {
6507                 case DAA_US:
6508                         DAA_Coeff_US(j);
6509                         retval = ixj_daa_write(j);
6510                         break;
6511                 case DAA_UK:
6512                         DAA_Coeff_UK(j);
6513                         retval = ixj_daa_write(j);
6514                         break;
6515                 case DAA_FRANCE:
6516                         DAA_Coeff_France(j);
6517                         retval = ixj_daa_write(j);
6518                         break;
6519                 case DAA_GERMANY:
6520                         DAA_Coeff_Germany(j);
6521                         retval = ixj_daa_write(j);
6522                         break;
6523                 case DAA_AUSTRALIA:
6524                         DAA_Coeff_Australia(j);
6525                         retval = ixj_daa_write(j);
6526                         break;
6527                 case DAA_JAPAN:
6528                         DAA_Coeff_Japan(j);
6529                         retval = ixj_daa_write(j);
6530                         break;
6531                 default:
6532                         retval = 1;
6533                         break;
6534                 }
6535                 break;
6536         case IXJCTL_DAA_AGAIN:
6537                 ixj_daa_cr4(j, arg | 0x02);
6538                 break;
6539         case IXJCTL_PSTN_LINETEST:
6540                 retval = ixj_linetest(j);
6541                 break;
6542         case IXJCTL_VMWI:
6543                 ixj_write_vmwi(j, arg);
6544                 break;
6545         case IXJCTL_CID:
6546                 if (copy_to_user(argp, &j->cid, sizeof(PHONE_CID)))
6547                         retval = -EFAULT;
6548                 j->ex.bits.caller_id = 0;
6549                 break;
6550         case IXJCTL_WINK_DURATION:
6551                 j->winktime = arg;
6552                 break;
6553         case IXJCTL_PORT:
6554                 if (arg)
6555                         retval = ixj_set_port(j, arg);
6556                 else
6557                         retval = j->port;
6558                 break;
6559         case IXJCTL_POTS_PSTN:
6560                 retval = ixj_set_pots(j, arg);
6561                 break;
6562         case PHONE_CAPABILITIES:
6563                 add_caps(j);
6564                 retval = j->caps;
6565                 break;
6566         case PHONE_CAPABILITIES_LIST:
6567                 add_caps(j);
6568                 if (copy_to_user(argp, j->caplist, sizeof(struct phone_capability) * j->caps))
6569                         retval = -EFAULT;
6570                 break;
6571         case PHONE_CAPABILITIES_CHECK:
6572                 {
6573                         struct phone_capability cap;
6574                         if (copy_from_user(&cap, argp, sizeof(cap)))
6575                                 retval = -EFAULT;
6576                         else {
6577                                 add_caps(j);
6578                                 retval = capabilities_check(j, &cap);
6579                         }
6580                 }
6581                 break;
6582         case PHONE_PSTN_SET_STATE:
6583                 daa_set_mode(j, arg);
6584                 break;
6585         case PHONE_PSTN_GET_STATE:
6586                 retval = j->daa_mode;
6587                 j->ex.bits.pstn_ring = 0;
6588                 break;
6589         case IXJCTL_SET_FILTER:
6590                 if (copy_from_user(&jf, argp, sizeof(jf)))
6591                         retval = -EFAULT;
6592                 retval = ixj_init_filter(j, &jf);
6593                 break;
6594         case IXJCTL_SET_FILTER_RAW:
6595                 if (copy_from_user(&jfr, argp, sizeof(jfr)))
6596                         retval = -EFAULT;
6597                 else
6598                         retval = ixj_init_filter_raw(j, &jfr);
6599                 break;
6600         case IXJCTL_GET_FILTER_HIST:
6601                 if(arg<0||arg>3)
6602                         retval = -EINVAL;
6603                 else
6604                         retval = j->filter_hist[arg];
6605                 break;
6606         case IXJCTL_INIT_TONE:
6607                 if (copy_from_user(&ti, argp, sizeof(ti)))
6608                         retval = -EFAULT;
6609                 else
6610                         retval = ixj_init_tone(j, &ti);
6611                 break;
6612         case IXJCTL_TONE_CADENCE:
6613                 retval = ixj_build_cadence(j, argp);
6614                 break;
6615         case IXJCTL_FILTER_CADENCE:
6616                 retval = ixj_build_filter_cadence(j, argp);
6617                 break;
6618         case IXJCTL_SIGCTL:
6619                 if (copy_from_user(&j->sigdef, argp, sizeof(IXJ_SIGDEF))) {
6620                         retval = -EFAULT;
6621                         break;
6622                 }
6623                 j->ixj_signals[j->sigdef.event] = j->sigdef.signal;
6624                 if(j->sigdef.event < 33) {
6625                         raise = 1;
6626                         for(mant = 0; mant < j->sigdef.event; mant++){
6627                                 raise *= 2;
6628                         }
6629                         if(j->sigdef.signal)
6630                                 j->ex_sig.bytes |= raise;
6631                         else
6632                                 j->ex_sig.bytes &= (raise^0xffff);
6633                 }
6634                 break;
6635         case IXJCTL_INTERCOM_STOP:
6636                 if(arg < 0 || arg >= IXJMAX)
6637                         return -EINVAL;
6638                 j->intercom = -1;
6639                 ixj_record_stop(j);
6640                 ixj_play_stop(j);
6641                 idle(j);
6642                 get_ixj(arg)->intercom = -1;
6643                 ixj_record_stop(get_ixj(arg));
6644                 ixj_play_stop(get_ixj(arg));
6645                 idle(get_ixj(arg));
6646                 break;
6647         case IXJCTL_INTERCOM_START:
6648                 if(arg < 0 || arg >= IXJMAX)
6649                         return -EINVAL;
6650                 j->intercom = arg;
6651                 ixj_record_start(j);
6652                 ixj_play_start(j);
6653                 get_ixj(arg)->intercom = board;
6654                 ixj_play_start(get_ixj(arg));
6655                 ixj_record_start(get_ixj(arg));
6656                 break;
6657         }
6658         if (ixjdebug & 0x0040)
6659                 printk("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);
6660         clear_bit(board, &j->busyflags);
6661         return retval;
6662 }
6663
6664 static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
6665 {
6666         long ret;
6667         lock_kernel();
6668         ret = do_ixj_ioctl(file_p, cmd, arg);
6669         unlock_kernel();
6670         return ret;
6671 }
6672
6673 static int ixj_fasync(int fd, struct file *file_p, int mode)
6674 {
6675         IXJ *j = get_ixj(NUM(file_p->f_path.dentry->d_inode));
6676
6677         return fasync_helper(fd, file_p, mode, &j->async_queue);
6678 }
6679
6680 static const struct file_operations ixj_fops =
6681 {
6682         .owner          = THIS_MODULE,
6683         .read           = ixj_enhanced_read,
6684         .write          = ixj_enhanced_write,
6685         .poll           = ixj_poll,
6686         .unlocked_ioctl = ixj_ioctl,
6687         .release        = ixj_release,
6688         .fasync         = ixj_fasync
6689 };
6690
6691 static int ixj_linetest(IXJ *j)
6692 {
6693         j->flags.pstncheck = 1; /* Testing */
6694         j->flags.pstn_present = 0; /* Assume the line is not there */
6695
6696         daa_int_read(j);        /*Clear DAA Interrupt flags */
6697         /* */
6698         /* Hold all relays in the normally de-energized position. */
6699         /* */
6700
6701         j->pld_slicw.bits.rly1 = 0;
6702         j->pld_slicw.bits.rly2 = 0;
6703         j->pld_slicw.bits.rly3 = 0;
6704         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6705         j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6706
6707         outb_p(j->pld_scrw.byte, j->XILINXbase);
6708         j->pld_slicr.byte = inb_p(j->XILINXbase + 0x01);
6709         if (j->pld_slicr.bits.potspstn) {
6710                 j->flags.pots_pstn = 1;
6711                 j->flags.pots_correct = 0;
6712                 LED_SetState(0x4, j);
6713         } else {
6714                 j->flags.pots_pstn = 0;
6715                 j->pld_slicw.bits.rly1 = 0;
6716                 j->pld_slicw.bits.rly2 = 0;
6717                 j->pld_slicw.bits.rly3 = 1;
6718                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6719                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6720
6721                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6722                 daa_set_mode(j, SOP_PU_CONVERSATION);
6723                 msleep(1000);
6724                 daa_int_read(j);
6725                 daa_set_mode(j, SOP_PU_RESET);
6726                 if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6727                         j->flags.pots_correct = 0;      /* Should not be line voltage on POTS port. */
6728                         LED_SetState(0x4, j);
6729                         j->pld_slicw.bits.rly3 = 0;
6730                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6731                 } else {
6732                         j->flags.pots_correct = 1;
6733                         LED_SetState(0x8, j);
6734                         j->pld_slicw.bits.rly1 = 1;
6735                         j->pld_slicw.bits.rly2 = 0;
6736                         j->pld_slicw.bits.rly3 = 0;
6737                         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6738                 }
6739         }
6740         j->pld_slicw.bits.rly3 = 0;
6741         outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6742         daa_set_mode(j, SOP_PU_CONVERSATION);
6743         msleep(1000);
6744         daa_int_read(j);
6745         daa_set_mode(j, SOP_PU_RESET);
6746         if (j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK) {
6747                 j->pstn_sleeptil = jiffies + (hertz / 4);
6748                 j->flags.pstn_present = 1;
6749         } else {
6750                 j->flags.pstn_present = 0;
6751         }
6752         if (j->flags.pstn_present) {
6753                 if (j->flags.pots_correct) {
6754                         LED_SetState(0xA, j);
6755                 } else {
6756                         LED_SetState(0x6, j);
6757                 }
6758         } else {
6759                 if (j->flags.pots_correct) {
6760                         LED_SetState(0x9, j);
6761                 } else {
6762                         LED_SetState(0x5, j);
6763                 }
6764         }
6765         j->flags.pstncheck = 0; /* Testing */
6766         return j->flags.pstn_present;
6767 }
6768
6769 static int ixj_selfprobe(IXJ *j)
6770 {
6771         unsigned short cmd;
6772         int cnt;
6773         BYTES bytes;
6774
6775         init_waitqueue_head(&j->poll_q);
6776         init_waitqueue_head(&j->read_q);
6777         init_waitqueue_head(&j->write_q);
6778
6779         while(atomic_read(&j->DSPWrite) > 0)
6780                 atomic_dec(&j->DSPWrite);
6781         if (ixjdebug & 0x0002)
6782                 printk(KERN_INFO "Write IDLE to Software Control Register\n");
6783         ixj_WriteDSPCommand(0x0FE0, j); /* Put the DSP in full power mode. */
6784
6785         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
6786                 return -1;
6787 /* The read values of the SSR should be 0x00 for the IDLE command */
6788         if (j->ssr.low || j->ssr.high)
6789                 return -1;
6790         if (ixjdebug & 0x0002)
6791                 printk(KERN_INFO "Get Device ID Code\n");
6792         if (ixj_WriteDSPCommand(0x3400, j))             /* Get Device ID Code */
6793                 return -1;
6794         j->dsp.low = j->ssr.low;
6795         j->dsp.high = j->ssr.high;
6796         if (ixjdebug & 0x0002)
6797                 printk(KERN_INFO "Get Device Version Code\n");
6798         if (ixj_WriteDSPCommand(0x3800, j))             /* Get Device Version Code */
6799                 return -1;
6800         j->ver.low = j->ssr.low;
6801         j->ver.high = j->ssr.high;
6802         if (!j->cardtype) {
6803                 if (j->dsp.low == 0x21) {
6804                         bytes.high = bytes.low = inb_p(j->XILINXbase + 0x02);
6805                         outb_p(bytes.low ^ 0xFF, j->XILINXbase + 0x02);
6806 /* Test for Internet LineJACK or Internet PhoneJACK Lite */
6807                         bytes.low = inb_p(j->XILINXbase + 0x02);
6808                         if (bytes.low == bytes.high)    /*  Register is read only on */
6809                                 /*  Internet PhoneJack Lite */
6810                          {
6811                                 j->cardtype = QTI_PHONEJACK_LITE;
6812                                 if (!request_region(j->XILINXbase, 4, "ixj control")) {
6813                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6814                                         return -1;
6815                                 }
6816                                 j->pld_slicw.pcib.e1 = 1;
6817                                 outb_p(j->pld_slicw.byte, j->XILINXbase);
6818                         } else {
6819                                 j->cardtype = QTI_LINEJACK;
6820
6821                                 if (!request_region(j->XILINXbase, 8, "ixj control")) {
6822                                         printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6823                                         return -1;
6824                                 }
6825                         }
6826                 } else if (j->dsp.low == 0x22) {
6827                         j->cardtype = QTI_PHONEJACK_PCI;
6828                         request_region(j->XILINXbase, 4, "ixj control");
6829                         j->pld_slicw.pcib.e1 = 1;
6830                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6831                 } else
6832                         j->cardtype = QTI_PHONEJACK;
6833         } else {
6834                 switch (j->cardtype) {
6835                 case QTI_PHONEJACK:
6836                         if (!j->dsp.low != 0x20) {
6837                                 j->dsp.high = 0x80;
6838                                 j->dsp.low = 0x20;
6839                                 ixj_WriteDSPCommand(0x3800, j);
6840                                 j->ver.low = j->ssr.low;
6841                                 j->ver.high = j->ssr.high;
6842                         }
6843                         break;
6844                 case QTI_LINEJACK:
6845                         if (!request_region(j->XILINXbase, 8, "ixj control")) {
6846                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6847                                 return -1;
6848                         }
6849                         break;
6850                 case QTI_PHONEJACK_LITE:
6851                 case QTI_PHONEJACK_PCI:
6852                         if (!request_region(j->XILINXbase, 4, "ixj control")) {
6853                                 printk(KERN_INFO "ixj: can't get I/O address 0x%x\n", j->XILINXbase);
6854                                 return -1;
6855                         }
6856                         j->pld_slicw.pcib.e1 = 1;
6857                         outb_p(j->pld_slicw.byte, j->XILINXbase);
6858                         break;
6859                 case QTI_PHONECARD:
6860                         break;
6861                 }
6862         }
6863         if (j->dsp.low == 0x20 || j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
6864                 if (ixjdebug & 0x0002)
6865                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6866                 if (ixj_WriteDSPCommand(0xC462, j))             /* Write CODEC config to Software Control Register */
6867                         return -1;
6868                 if (ixjdebug & 0x0002)
6869                         printk(KERN_INFO "Write CODEC timing to Software Control Register\n");
6870                 if (j->cardtype == QTI_PHONEJACK) {
6871                         cmd = 0x9FF2;
6872                 } else {
6873                         cmd = 0x9FF5;
6874                 }
6875                 if (ixj_WriteDSPCommand(cmd, j))        /* Write CODEC timing to Software Control Register */
6876                         return -1;
6877         } else {
6878                 if (set_base_frame(j, 30) != 30)
6879                         return -1;
6880                 if (ixjdebug & 0x0002)
6881                         printk(KERN_INFO "Write CODEC config to Software Control Register\n");
6882                 if (j->cardtype == QTI_PHONECARD) {
6883                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6884                                 return -1;
6885                 }
6886                 if (j->cardtype == QTI_LINEJACK) {
6887                         if (ixj_WriteDSPCommand(0xC528, j))             /* Write CODEC config to Software Control Register */
6888                                 return -1;
6889                         if (ixjdebug & 0x0002)
6890                                 printk(KERN_INFO "Turn on the PLD Clock at 8Khz\n");
6891                         j->pld_clock.byte = 0;
6892                         outb_p(j->pld_clock.byte, j->XILINXbase + 0x04);
6893                 }
6894         }
6895
6896         if (j->dsp.low == 0x20) {
6897                 if (ixjdebug & 0x0002)
6898                         printk(KERN_INFO "Configure GPIO pins\n");
6899                 j->gpio.bytes.high = 0x09;
6900 /*  bytes.low = 0xEF;  0xF7 */
6901                 j->gpio.bits.gpio1 = 1;
6902                 j->gpio.bits.gpio2 = 1;
6903                 j->gpio.bits.gpio3 = 0;
6904                 j->gpio.bits.gpio4 = 1;
6905                 j->gpio.bits.gpio5 = 1;
6906                 j->gpio.bits.gpio6 = 1;
6907                 j->gpio.bits.gpio7 = 1;
6908                 ixj_WriteDSPCommand(j->gpio.word, j);   /* Set GPIO pin directions */
6909                 if (ixjdebug & 0x0002)
6910                         printk(KERN_INFO "Enable SLIC\n");
6911                 j->gpio.bytes.high = 0x0B;
6912                 j->gpio.bytes.low = 0x00;
6913                 j->gpio.bits.gpio1 = 0;
6914                 j->gpio.bits.gpio2 = 1;
6915                 j->gpio.bits.gpio5 = 0;
6916                 ixj_WriteDSPCommand(j->gpio.word, j);   /* send the ring stop signal */
6917                 j->port = PORT_POTS;
6918         } else {
6919                 if (j->cardtype == QTI_LINEJACK) {
6920                         LED_SetState(0x1, j);
6921                         msleep(100);
6922                         LED_SetState(0x2, j);
6923                         msleep(100);
6924                         LED_SetState(0x4, j);
6925                         msleep(100);
6926                         LED_SetState(0x8, j);
6927                         msleep(100);
6928                         LED_SetState(0x0, j);
6929                         daa_get_version(j);
6930                         if (ixjdebug & 0x0002)
6931                                 printk("Loading DAA Coefficients\n");
6932                         DAA_Coeff_US(j);
6933                         if (!ixj_daa_write(j)) {
6934                                 printk("DAA write failed on board %d\n", j->board);
6935                                 return -1;
6936                         }
6937                         if(!ixj_daa_cid_reset(j)) {
6938                                 printk("DAA CID reset failed on board %d\n", j->board);
6939                                 return -1;
6940                         }
6941                         j->flags.pots_correct = 0;
6942                         j->flags.pstn_present = 0;
6943                         ixj_linetest(j);
6944                         if (j->flags.pots_correct) {
6945                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
6946
6947                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
6948                                 j->pld_slicw.bits.rly1 = 1;
6949                                 j->pld_slicw.bits.spken = 1;
6950                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
6951                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
6952 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
6953                                 j->port = PORT_POTS;
6954                         }
6955                         ixj_set_port(j, PORT_PSTN);
6956                         ixj_set_pots(j, 1);
6957                         if (ixjdebug & 0x0002)
6958                                 printk(KERN_INFO "Enable Mixer\n");
6959                         ixj_mixer(0x0000, j);   /*Master Volume Left unmute 0db */
6960                         ixj_mixer(0x0100, j);   /*Master Volume Right unmute 0db */
6961
6962                         ixj_mixer(0x0203, j);   /*Voice Left Volume unmute 6db */
6963                         ixj_mixer(0x0303, j);   /*Voice Right Volume unmute 6db */
6964
6965                         ixj_mixer(0x0480, j);   /*FM Left mute */
6966                         ixj_mixer(0x0580, j);   /*FM Right mute */
6967
6968                         ixj_mixer(0x0680, j);   /*CD Left mute */
6969                         ixj_mixer(0x0780, j);   /*CD Right mute */
6970
6971                         ixj_mixer(0x0880, j);   /*Line Left mute */
6972                         ixj_mixer(0x0980, j);   /*Line Right mute */
6973
6974                         ixj_mixer(0x0A80, j);   /*Aux left mute  */
6975                         ixj_mixer(0x0B80, j);   /*Aux right mute */
6976
6977                         ixj_mixer(0x0C00, j);   /*Mono1 unmute 12db */
6978                         ixj_mixer(0x0D80, j);   /*Mono2 mute */
6979
6980                         ixj_mixer(0x0E80, j);   /*Mic mute */
6981
6982                         ixj_mixer(0x0F00, j);   /*Mono Out Volume unmute 0db */
6983
6984                         ixj_mixer(0x1000, j);   /*Voice Left and Right out only */
6985                         ixj_mixer(0x110C, j);
6986
6987
6988                         ixj_mixer(0x1200, j);   /*Mono1 switch on mixer left */
6989                         ixj_mixer(0x1401, j);
6990
6991                         ixj_mixer(0x1300, j);       /*Mono1 switch on mixer right */
6992                         ixj_mixer(0x1501, j);
6993
6994                         ixj_mixer(0x1700, j);   /*Clock select */
6995
6996                         ixj_mixer(0x1800, j);   /*ADC input from mixer */
6997
6998                         ixj_mixer(0x1901, j);   /*Mic gain 30db */
6999
7000                         if (ixjdebug & 0x0002)
7001                                 printk(KERN_INFO "Setting Default US Ring Cadence Detection\n");
7002                         j->cadence_f[4].state = 0;
7003                         j->cadence_f[4].on1 = 0;        /*Cadence Filter 4 is used for PSTN ring cadence */
7004                         j->cadence_f[4].off1 = 0;
7005                         j->cadence_f[4].on2 = 0;
7006                         j->cadence_f[4].off2 = 0;
7007                         j->cadence_f[4].on3 = 0;
7008                         j->cadence_f[4].off3 = 0;       /* These should represent standard US ring pulse. */
7009                         j->pstn_last_rmr = jiffies;
7010
7011                 } else {
7012                         if (j->cardtype == QTI_PHONECARD) {
7013                                 ixj_WriteDSPCommand(0xCF07, j);
7014                                 ixj_WriteDSPCommand(0x00B0, j);
7015                                 ixj_set_port(j, PORT_SPEAKER);
7016                         } else {
7017                                 ixj_set_port(j, PORT_POTS);
7018                                 SLIC_SetState(PLD_SLIC_STATE_STANDBY, j);
7019 /*                              SLIC_SetState(PLD_SLIC_STATE_ACTIVE, j); */
7020                         }
7021                 }
7022         }
7023
7024         j->intercom = -1;
7025         j->framesread = j->frameswritten = 0;
7026         j->read_wait = j->write_wait = 0;
7027         j->rxreadycheck = j->txreadycheck = 0;
7028
7029         /* initialise the DTMF prescale to a sensible value */
7030         if (j->cardtype == QTI_LINEJACK) {
7031                 set_dtmf_prescale(j, 0x10);
7032         } else {
7033                 set_dtmf_prescale(j, 0x40);
7034         }
7035         set_play_volume(j, 0x100);
7036         set_rec_volume(j, 0x100);
7037
7038         if (ixj_WriteDSPCommand(0x0000, j))             /* Write IDLE to Software Control Register */
7039                 return -1;
7040 /* The read values of the SSR should be 0x00 for the IDLE command */
7041         if (j->ssr.low || j->ssr.high)
7042                 return -1;
7043
7044         if (ixjdebug & 0x0002)
7045                 printk(KERN_INFO "Enable Line Monitor\n");
7046
7047         if (ixjdebug & 0x0002)
7048                 printk(KERN_INFO "Set Line Monitor to Asyncronous Mode\n");
7049
7050         if (ixj_WriteDSPCommand(0x7E01, j))             /* Asynchronous Line Monitor */
7051                 return -1;
7052
7053         if (ixjdebug & 0x002)
7054                 printk(KERN_INFO "Enable DTMF Detectors\n");
7055
7056         if (ixj_WriteDSPCommand(0x5151, j))             /* Enable DTMF detection */
7057                 return -1;
7058
7059         if (ixj_WriteDSPCommand(0x6E01, j))             /* Set Asyncronous Tone Generation */
7060                 return -1;
7061
7062         set_rec_depth(j, 2);    /* Set Record Channel Limit to 2 frames */
7063
7064         set_play_depth(j, 2);   /* Set Playback Channel Limit to 2 frames */
7065
7066         j->ex.bits.dtmf_ready = 0;
7067         j->dtmf_state = 0;
7068         j->dtmf_wp = j->dtmf_rp = 0;
7069         j->rec_mode = j->play_mode = -1;
7070         j->flags.ringing = 0;
7071         j->maxrings = MAXRINGS;
7072         j->ring_cadence = USA_RING_CADENCE;
7073         j->drybuffer = 0;
7074         j->winktime = 320;
7075         j->flags.dtmf_oob = 0;
7076         for (cnt = 0; cnt < 4; cnt++)
7077                 j->cadence_f[cnt].enable = 0;
7078         /* must be a device on the specified address */
7079         ixj_WriteDSPCommand(0x0FE3, j); /* Put the DSP in 1/5 power mode. */
7080
7081         /* Set up the default signals for events */
7082         for (cnt = 0; cnt < 35; cnt++)
7083                 j->ixj_signals[cnt] = SIGIO;
7084
7085         /* Set the excetion signal enable flags */
7086         j->ex_sig.bits.dtmf_ready = j->ex_sig.bits.hookstate = j->ex_sig.bits.flash = j->ex_sig.bits.pstn_ring =
7087         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 =
7088         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;
7089 #ifdef IXJ_DYN_ALLOC
7090         j->fskdata = NULL;
7091 #endif
7092         j->fskdcnt = 0;
7093         j->cidcw_wait = 0;
7094
7095         /* Register with the Telephony for Linux subsystem */
7096         j->p.f_op = &ixj_fops;
7097         j->p.open = ixj_open;
7098         j->p.board = j->board;
7099         phone_register_device(&j->p, PHONE_UNIT_ANY);
7100
7101         ixj_init_timer(j);
7102         ixj_add_timer(j);
7103         return 0;
7104 }
7105
7106 /*
7107  *      Exported service for pcmcia card handling
7108  */
7109
7110 IXJ *ixj_pcmcia_probe(unsigned long dsp, unsigned long xilinx)
7111 {
7112         IXJ *j = ixj_alloc();
7113
7114         j->board = 0;
7115
7116         j->DSPbase = dsp;
7117         j->XILINXbase = xilinx;
7118         j->cardtype = QTI_PHONECARD;
7119         ixj_selfprobe(j);
7120         return j;
7121 }
7122
7123 EXPORT_SYMBOL(ixj_pcmcia_probe);                /* Fpr PCMCIA */
7124
7125 static int ixj_get_status_proc(char *buf)
7126 {
7127         int len;
7128         int cnt;
7129         IXJ *j;
7130         len = 0;
7131         len += sprintf(buf + len, "\nDriver version %i.%i.%i", IXJ_VER_MAJOR, IXJ_VER_MINOR, IXJ_BLD_VER);
7132         len += sprintf(buf + len, "\nsizeof IXJ struct %Zd bytes", sizeof(IXJ));
7133         len += sprintf(buf + len, "\nsizeof DAA struct %Zd bytes", sizeof(DAA_REGS));
7134         len += sprintf(buf + len, "\nUsing old telephony API");
7135         len += sprintf(buf + len, "\nDebug Level %d\n", ixjdebug);
7136
7137         for (cnt = 0; cnt < IXJMAX; cnt++) {
7138                 j = get_ixj(cnt);
7139                 if(j==NULL)
7140                         continue;
7141                 if (j->DSPbase) {
7142                         len += sprintf(buf + len, "\nCard Num %d", cnt);
7143                         len += sprintf(buf + len, "\nDSP Base Address 0x%4.4x", j->DSPbase);
7144                         if (j->cardtype != QTI_PHONEJACK)
7145                                 len += sprintf(buf + len, "\nXILINX Base Address 0x%4.4x", j->XILINXbase);
7146                         len += sprintf(buf + len, "\nDSP Type %2.2x%2.2x", j->dsp.high, j->dsp.low);
7147                         len += sprintf(buf + len, "\nDSP Version %2.2x.%2.2x", j->ver.high, j->ver.low);
7148                         len += sprintf(buf + len, "\nSerial Number %8.8x", j->serial);
7149                         switch (j->cardtype) {
7150                         case (QTI_PHONEJACK):
7151                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK");
7152                                 break;
7153                         case (QTI_LINEJACK):
7154                                 len += sprintf(buf + len, "\nCard Type = Internet LineJACK");
7155                                 if (j->flags.g729_loaded)
7156                                         len += sprintf(buf + len, " w/G.729 A/B");
7157                                 len += sprintf(buf + len, " Country = %d", j->daa_country);
7158                                 break;
7159                         case (QTI_PHONEJACK_LITE):
7160                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK Lite");
7161                                 if (j->flags.g729_loaded)
7162                                         len += sprintf(buf + len, " w/G.729 A/B");
7163                                 break;
7164                         case (QTI_PHONEJACK_PCI):
7165                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneJACK PCI");
7166                                 if (j->flags.g729_loaded)
7167                                         len += sprintf(buf + len, " w/G.729 A/B");
7168                                 break;
7169                         case (QTI_PHONECARD):
7170                                 len += sprintf(buf + len, "\nCard Type = Internet PhoneCARD");
7171                                 if (j->flags.g729_loaded)
7172                                         len += sprintf(buf + len, " w/G.729 A/B");
7173                                 len += sprintf(buf + len, "\nSmart Cable %spresent", j->pccr1.bits.drf ? "not " : "");
7174                                 if (!j->pccr1.bits.drf)
7175                                         len += sprintf(buf + len, "\nSmart Cable type %d", j->flags.pcmciasct);
7176                                 len += sprintf(buf + len, "\nSmart Cable state %d", j->flags.pcmciastate);
7177                                 break;
7178                         default:
7179                                 len += sprintf(buf + len, "\nCard Type = %d", j->cardtype);
7180                                 break;
7181                         }
7182                         len += sprintf(buf + len, "\nReaders %d", j->readers);
7183                         len += sprintf(buf + len, "\nWriters %d", j->writers);
7184                         add_caps(j);
7185                         len += sprintf(buf + len, "\nCapabilities %d", j->caps);
7186                         if (j->dsp.low != 0x20)
7187                                 len += sprintf(buf + len, "\nDSP Processor load %d", j->proc_load);
7188                         if (j->flags.cidsent)
7189                                 len += sprintf(buf + len, "\nCaller ID data sent");
7190                         else
7191                                 len += sprintf(buf + len, "\nCaller ID data not sent");
7192
7193                         len += sprintf(buf + len, "\nPlay CODEC ");
7194                         switch (j->play_codec) {
7195                         case G723_63:
7196                                 len += sprintf(buf + len, "G.723.1 6.3");
7197                                 break;
7198                         case G723_53:
7199                                 len += sprintf(buf + len, "G.723.1 5.3");
7200                                 break;
7201                         case TS85:
7202                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7203                                 break;
7204                         case TS48:
7205                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7206                                 break;
7207                         case TS41:
7208                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7209                                 break;
7210                         case G728:
7211                                 len += sprintf(buf + len, "G.728");
7212                                 break;
7213                         case G729:
7214                                 len += sprintf(buf + len, "G.729");
7215                                 break;
7216                         case G729B:
7217                                 len += sprintf(buf + len, "G.729B");
7218                                 break;
7219                         case ULAW:
7220                                 len += sprintf(buf + len, "uLaw");
7221                                 break;
7222                         case ALAW:
7223                                 len += sprintf(buf + len, "aLaw");
7224                                 break;
7225                         case LINEAR16:
7226                                 len += sprintf(buf + len, "16 bit Linear");
7227                                 break;
7228                         case LINEAR8:
7229                                 len += sprintf(buf + len, "8 bit Linear");
7230                                 break;
7231                         case WSS:
7232                                 len += sprintf(buf + len, "Windows Sound System");
7233                                 break;
7234                         default:
7235                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7236                                 break;
7237                         }
7238                         len += sprintf(buf + len, "\nRecord CODEC ");
7239                         switch (j->rec_codec) {
7240                         case G723_63:
7241                                 len += sprintf(buf + len, "G.723.1 6.3");
7242                                 break;
7243                         case G723_53:
7244                                 len += sprintf(buf + len, "G.723.1 5.3");
7245                                 break;
7246                         case TS85:
7247                                 len += sprintf(buf + len, "TrueSpeech 8.5");
7248                                 break;
7249                         case TS48:
7250                                 len += sprintf(buf + len, "TrueSpeech 4.8");
7251                                 break;
7252                         case TS41:
7253                                 len += sprintf(buf + len, "TrueSpeech 4.1");
7254                                 break;
7255                         case G728:
7256                                 len += sprintf(buf + len, "G.728");
7257                                 break;
7258                         case G729:
7259                                 len += sprintf(buf + len, "G.729");
7260                                 break;
7261                         case G729B:
7262                                 len += sprintf(buf + len, "G.729B");
7263                                 break;
7264                         case ULAW:
7265                                 len += sprintf(buf + len, "uLaw");
7266                                 break;
7267                         case ALAW:
7268                                 len += sprintf(buf + len, "aLaw");
7269                                 break;
7270                         case LINEAR16:
7271                                 len += sprintf(buf + len, "16 bit Linear");
7272                                 break;
7273                         case LINEAR8:
7274                                 len += sprintf(buf + len, "8 bit Linear");
7275                                 break;
7276                         case WSS:
7277                                 len += sprintf(buf + len, "Windows Sound System");
7278                                 break;
7279                         default:
7280                                 len += sprintf(buf + len, "NO CODEC CHOSEN");
7281                                 break;
7282                         }
7283                         len += sprintf(buf + len, "\nAEC ");
7284                         switch (j->aec_level) {
7285                         case AEC_OFF:
7286                                 len += sprintf(buf + len, "Off");
7287                                 break;
7288                         case AEC_LOW:
7289                                 len += sprintf(buf + len, "Low");
7290                                 break;
7291                         case AEC_MED:
7292                                 len += sprintf(buf + len, "Med");
7293                                 break;
7294                         case AEC_HIGH:
7295                                 len += sprintf(buf + len, "High");
7296                                 break;
7297                         case AEC_AUTO:
7298                                 len += sprintf(buf + len, "Auto");
7299                                 break;
7300                         case AEC_AGC:
7301                                 len += sprintf(buf + len, "AEC/AGC");
7302                                 break;
7303                         default:
7304                                 len += sprintf(buf + len, "unknown(%i)", j->aec_level);
7305                                 break;
7306                         }
7307
7308                         len += sprintf(buf + len, "\nRec volume 0x%x", get_rec_volume(j));
7309                         len += sprintf(buf + len, "\nPlay volume 0x%x", get_play_volume(j));
7310                         len += sprintf(buf + len, "\nDTMF prescale 0x%x", get_dtmf_prescale(j));
7311
7312                         len += sprintf(buf + len, "\nHook state %d", j->hookstate); /* j->r_hook);      */
7313
7314                         if (j->cardtype == QTI_LINEJACK) {
7315                                 len += sprintf(buf + len, "\nPOTS Correct %d", j->flags.pots_correct);
7316                                 len += sprintf(buf + len, "\nPSTN Present %d", j->flags.pstn_present);
7317                                 len += sprintf(buf + len, "\nPSTN Check %d", j->flags.pstncheck);
7318                                 len += sprintf(buf + len, "\nPOTS to PSTN %d", j->flags.pots_pstn);
7319                                 switch (j->daa_mode) {
7320                                 case SOP_PU_SLEEP:
7321                                         len += sprintf(buf + len, "\nDAA PSTN On Hook");
7322                                         break;
7323                                 case SOP_PU_RINGING:
7324                                         len += sprintf(buf + len, "\nDAA PSTN Ringing");
7325                                         len += sprintf(buf + len, "\nRinging state = %d", j->cadence_f[4].state);
7326                                         break;
7327                                 case SOP_PU_CONVERSATION:
7328                                         len += sprintf(buf + len, "\nDAA PSTN Off Hook");
7329                                         break;
7330                                 case SOP_PU_PULSEDIALING:
7331                                         len += sprintf(buf + len, "\nDAA PSTN Pulse Dialing");
7332                                         break;
7333                                 }
7334                                 len += sprintf(buf + len, "\nDAA RMR = %d", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.bitreg.RMR);
7335                                 len += sprintf(buf + len, "\nDAA VDD OK = %d", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.bitreg.VDD_OK);
7336                                 len += sprintf(buf + len, "\nDAA CR0 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg);
7337                                 len += sprintf(buf + len, "\nDAA CR1 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg);
7338                                 len += sprintf(buf + len, "\nDAA CR2 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg);
7339                                 len += sprintf(buf + len, "\nDAA CR3 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg);
7340                                 len += sprintf(buf + len, "\nDAA CR4 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg);
7341                                 len += sprintf(buf + len, "\nDAA CR5 = 0x%02x", j->m_DAAShadowRegs.SOP_REGS.SOP.cr5.reg);
7342                                 len += sprintf(buf + len, "\nDAA XR0 = 0x%02x", j->m_DAAShadowRegs.XOP_REGS.XOP.xr0.reg);
7343                                 len += sprintf(buf + len, "\nDAA ringstop %ld - jiffies %ld", j->pstn_ring_stop, jiffies);
7344                         }
7345                         switch (j->port) {
7346                         case PORT_POTS:
7347                                 len += sprintf(buf + len, "\nPort POTS");
7348                                 break;
7349                         case PORT_PSTN:
7350                                 len += sprintf(buf + len, "\nPort PSTN");
7351                                 break;
7352                         case PORT_SPEAKER:
7353                                 len += sprintf(buf + len, "\nPort SPEAKER/MIC");
7354                                 break;
7355                         case PORT_HANDSET:
7356                                 len += sprintf(buf + len, "\nPort HANDSET");
7357                                 break;
7358                         }
7359                         if (j->dsp.low == 0x21 || j->dsp.low == 0x22) {
7360                                 len += sprintf(buf + len, "\nSLIC state ");
7361                                 switch (SLIC_GetState(j)) {
7362                                 case PLD_SLIC_STATE_OC:
7363                                         len += sprintf(buf + len, "OC");
7364                                         break;
7365                                 case PLD_SLIC_STATE_RINGING:
7366                                         len += sprintf(buf + len, "RINGING");
7367                                         break;
7368                                 case PLD_SLIC_STATE_ACTIVE:
7369                                         len += sprintf(buf + len, "ACTIVE");
7370                                         break;
7371                                 case PLD_SLIC_STATE_OHT:        /* On-hook transmit */
7372                                         len += sprintf(buf + len, "OHT");
7373                                         break;
7374                                 case PLD_SLIC_STATE_TIPOPEN:
7375                                         len += sprintf(buf + len, "TIPOPEN");
7376                                         break;
7377                                 case PLD_SLIC_STATE_STANDBY:
7378                                         len += sprintf(buf + len, "STANDBY");
7379                                         break;
7380                                 case PLD_SLIC_STATE_APR:        /* Active polarity reversal */
7381                                         len += sprintf(buf + len, "APR");
7382                                         break;
7383                                 case PLD_SLIC_STATE_OHTPR:      /* OHT polarity reversal */
7384                                         len += sprintf(buf + len, "OHTPR");
7385                                         break;
7386                                 default:
7387                                         len += sprintf(buf + len, "%d", SLIC_GetState(j));
7388                                         break;
7389                                 }
7390                         }
7391                         len += sprintf(buf + len, "\nBase Frame %2.2x.%2.2x", j->baseframe.high, j->baseframe.low);
7392                         len += sprintf(buf + len, "\nCID Base Frame %2d", j->cid_base_frame_size);
7393 #ifdef PERFMON_STATS
7394                         len += sprintf(buf + len, "\nTimer Checks %ld", j->timerchecks);
7395                         len += sprintf(buf + len, "\nRX Ready Checks %ld", j->rxreadycheck);
7396                         len += sprintf(buf + len, "\nTX Ready Checks %ld", j->txreadycheck);
7397                         len += sprintf(buf + len, "\nFrames Read %ld", j->framesread);
7398                         len += sprintf(buf + len, "\nFrames Written %ld", j->frameswritten);
7399                         len += sprintf(buf + len, "\nDry Buffer %ld", j->drybuffer);
7400                         len += sprintf(buf + len, "\nRead Waits %ld", j->read_wait);
7401                         len += sprintf(buf + len, "\nWrite Waits %ld", j->write_wait);
7402                         len += sprintf(buf + len, "\nStatus Waits %ld", j->statuswait);
7403                         len += sprintf(buf + len, "\nStatus Wait Fails %ld", j->statuswaitfail);
7404                         len += sprintf(buf + len, "\nPControl Waits %ld", j->pcontrolwait);
7405                         len += sprintf(buf + len, "\nPControl Wait Fails %ld", j->pcontrolwaitfail);
7406                         len += sprintf(buf + len, "\nIs Control Ready Checks %ld", j->iscontrolready);
7407                         len += sprintf(buf + len, "\nIs Control Ready Check failures %ld", j->iscontrolreadyfail);
7408
7409 #endif
7410                         len += sprintf(buf + len, "\n");
7411                 }
7412         }
7413         return len;
7414 }
7415
7416 static int ixj_read_proc(char *page, char **start, off_t off,
7417                               int count, int *eof, void *data)
7418 {
7419         int len = ixj_get_status_proc(page);
7420         if (len <= off+count) *eof = 1;
7421         *start = page + off;
7422         len -= off;
7423         if (len>count) len = count;
7424         if (len<0) len = 0;
7425         return len;
7426 }
7427
7428
7429 static void cleanup(void)
7430 {
7431         int cnt;
7432         IXJ *j;
7433
7434         for (cnt = 0; cnt < IXJMAX; cnt++) {
7435                 j = get_ixj(cnt);
7436                 if(j != NULL && j->DSPbase) {
7437                         if (ixjdebug & 0x0002)
7438                                 printk(KERN_INFO "IXJ: Deleting timer for /dev/phone%d\n", cnt);
7439                         del_timer(&j->timer);
7440                         if (j->cardtype == QTI_LINEJACK) {
7441                                 j->pld_scrw.bits.daafsyncen = 0;        /* Turn off DAA Frame Sync */
7442
7443                                 outb_p(j->pld_scrw.byte, j->XILINXbase);
7444                                 j->pld_slicw.bits.rly1 = 0;
7445                                 j->pld_slicw.bits.rly2 = 0;
7446                                 j->pld_slicw.bits.rly3 = 0;
7447                                 outb_p(j->pld_slicw.byte, j->XILINXbase + 0x01);
7448                                 LED_SetState(0x0, j);
7449                                 if (ixjdebug & 0x0002)
7450                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7451                                 release_region(j->XILINXbase, 8);
7452                         } else if (j->cardtype == QTI_PHONEJACK_LITE || j->cardtype == QTI_PHONEJACK_PCI) {
7453                                 if (ixjdebug & 0x0002)
7454                                         printk(KERN_INFO "IXJ: Releasing XILINX address for /dev/phone%d\n", cnt);
7455                                 release_region(j->XILINXbase, 4);
7456                         }
7457                         kfree(j->read_buffer);
7458                         kfree(j->write_buffer);
7459                         if (j->dev)
7460                                 pnp_device_detach(j->dev);
7461                         if (ixjdebug & 0x0002)
7462                                 printk(KERN_INFO "IXJ: Unregistering /dev/phone%d from LTAPI\n", cnt);
7463                         phone_unregister_device(&j->p);
7464                         if (ixjdebug & 0x0002)
7465                                 printk(KERN_INFO "IXJ: Releasing DSP address for /dev/phone%d\n", cnt);
7466                         release_region(j->DSPbase, 16);
7467 #ifdef IXJ_DYN_ALLOC
7468                         if (ixjdebug & 0x0002)
7469                                 printk(KERN_INFO "IXJ: Freeing memory for /dev/phone%d\n", cnt);
7470                         kfree(j);
7471                         ixj[cnt] = NULL;
7472 #endif
7473                 }
7474         }
7475         if (ixjdebug & 0x0002)
7476                 printk(KERN_INFO "IXJ: Removing /proc/ixj\n");
7477         remove_proc_entry ("ixj", NULL);
7478 }
7479
7480 /* Typedefs */
7481 typedef struct {
7482         BYTE length;
7483         DWORD bits;
7484 } DATABLOCK;
7485
7486 static void PCIEE_WriteBit(WORD wEEPROMAddress, BYTE lastLCC, BYTE byData)
7487 {
7488         lastLCC = lastLCC & 0xfb;
7489         lastLCC = lastLCC | (byData ? 4 : 0);
7490         outb(lastLCC, wEEPROMAddress);  /*set data out bit as appropriate */
7491
7492         mdelay(1);
7493         lastLCC = lastLCC | 0x01;
7494         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7495
7496         byData = byData << 1;
7497         lastLCC = lastLCC & 0xfe;
7498         mdelay(1);
7499         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7500
7501 }
7502
7503 static BYTE PCIEE_ReadBit(WORD wEEPROMAddress, BYTE lastLCC)
7504 {
7505         mdelay(1);
7506         lastLCC = lastLCC | 0x01;
7507         outb(lastLCC, wEEPROMAddress);  /*SK rising edge */
7508
7509         lastLCC = lastLCC & 0xfe;
7510         mdelay(1);
7511         outb(lastLCC, wEEPROMAddress);  /*after delay, SK falling edge */
7512
7513         return ((inb(wEEPROMAddress) >> 3) & 1);
7514 }
7515
7516 static bool PCIEE_ReadWord(WORD wAddress, WORD wLoc, WORD * pwResult)
7517 {
7518         BYTE lastLCC;
7519         WORD wEEPROMAddress = wAddress + 3;
7520         DWORD i;
7521         BYTE byResult;
7522         *pwResult = 0;
7523         lastLCC = inb(wEEPROMAddress);
7524         lastLCC = lastLCC | 0x02;
7525         lastLCC = lastLCC & 0xfe;
7526         outb(lastLCC, wEEPROMAddress);  /* CS hi, SK lo */
7527
7528         mdelay(1);              /* delay */
7529
7530         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7531         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 1);
7532         PCIEE_WriteBit(wEEPROMAddress, lastLCC, 0);
7533         for (i = 0; i < 8; i++) {
7534                 PCIEE_WriteBit(wEEPROMAddress, lastLCC, wLoc & 0x80 ? 1 : 0);
7535                 wLoc <<= 1;
7536         }
7537
7538         for (i = 0; i < 16; i++) {
7539                 byResult = PCIEE_ReadBit(wEEPROMAddress, lastLCC);
7540                 *pwResult = (*pwResult << 1) | byResult;
7541         }
7542
7543         mdelay(1);              /* another delay */
7544
7545         lastLCC = lastLCC & 0xfd;
7546         outb(lastLCC, wEEPROMAddress);  /* negate CS */
7547
7548         return 0;
7549 }
7550
7551 static DWORD PCIEE_GetSerialNumber(WORD wAddress)
7552 {
7553         WORD wLo, wHi;
7554         if (PCIEE_ReadWord(wAddress, 62, &wLo))
7555                 return 0;
7556         if (PCIEE_ReadWord(wAddress, 63, &wHi))
7557                 return 0;
7558         return (((DWORD) wHi << 16) | wLo);
7559 }
7560
7561 static int dspio[IXJMAX + 1] =
7562 {
7563         0,
7564 };
7565 static int xio[IXJMAX + 1] =
7566 {
7567         0,
7568 };
7569
7570 module_param_array(dspio, int, NULL, 0);
7571 module_param_array(xio, int, NULL, 0);
7572 MODULE_DESCRIPTION("Quicknet VoIP Telephony card module - www.quicknet.net");
7573 MODULE_AUTHOR("Ed Okerson <eokerson@quicknet.net>");
7574 MODULE_LICENSE("GPL");
7575
7576 static void __exit ixj_exit(void)
7577 {
7578         cleanup();
7579 }
7580
7581 static IXJ *new_ixj(unsigned long port)
7582 {
7583         IXJ *res;
7584         if (!request_region(port, 16, "ixj DSP")) {
7585                 printk(KERN_INFO "ixj: can't get I/O address 0x%lx\n", port);
7586                 return NULL;
7587         }
7588         res = ixj_alloc();
7589         if (!res) {
7590                 release_region(port, 16);
7591                 printk(KERN_INFO "ixj: out of memory\n");
7592                 return NULL;
7593         }
7594         res->DSPbase = port;
7595         return res;
7596 }
7597
7598 static int __init ixj_probe_isapnp(int *cnt)
7599 {
7600         int probe = 0;
7601         int func = 0x110;
7602         struct pnp_dev *dev = NULL, *old_dev = NULL;
7603
7604         while (1) {
7605                 do {
7606                         IXJ *j;
7607                         int result;
7608
7609                         old_dev = dev;
7610                         dev = pnp_find_dev(NULL, ISAPNP_VENDOR('Q', 'T', 'I'),
7611                                          ISAPNP_FUNCTION(func), old_dev);
7612                         if (!dev || !dev->card)
7613                                 break;
7614                         result = pnp_device_attach(dev);
7615                         if (result < 0) {
7616                                 printk("pnp attach failed %d \n", result);
7617                                 break;
7618                         }
7619                         if (pnp_activate_dev(dev) < 0) {
7620                                 printk("pnp activate failed (out of resources?)\n");
7621                                 pnp_device_detach(dev);
7622                                 return -ENOMEM;
7623                         }
7624
7625                         if (!pnp_port_valid(dev, 0)) {
7626                                 pnp_device_detach(dev);
7627                                 return -ENODEV;
7628                         }
7629
7630                         j = new_ixj(pnp_port_start(dev, 0));
7631                         if (!j)
7632                                 break;
7633
7634                         if (func != 0x110)
7635                                 j->XILINXbase = pnp_port_start(dev, 1); /* get real port */
7636
7637                         switch (func) {
7638                         case (0x110):
7639                                 j->cardtype = QTI_PHONEJACK;
7640                                 break;
7641                         case (0x310):
7642                                 j->cardtype = QTI_LINEJACK;
7643                                 break;
7644                         case (0x410):
7645                                 j->cardtype = QTI_PHONEJACK_LITE;
7646                                 break;
7647                         }
7648                         j->board = *cnt;
7649                         probe = ixj_selfprobe(j);
7650                         if(!probe) {
7651                                 j->serial = dev->card->serial;
7652                                 j->dev = dev;
7653                                 switch (func) {
7654                                 case 0x110:
7655                                         printk(KERN_INFO "ixj: found Internet PhoneJACK at 0x%x\n", j->DSPbase);
7656                                         break;
7657                                 case 0x310:
7658                                         printk(KERN_INFO "ixj: found Internet LineJACK at 0x%x\n", j->DSPbase);
7659                                         break;
7660                                 case 0x410:
7661                                         printk(KERN_INFO "ixj: found Internet PhoneJACK Lite at 0x%x\n", j->DSPbase);
7662                                         break;
7663                                 }
7664                         }
7665                         ++*cnt;
7666                 } while (dev);
7667                 if (func == 0x410)
7668                         break;
7669                 if (func == 0x310)
7670                         func = 0x410;
7671                 if (func == 0x110)
7672                         func = 0x310;
7673                 dev = NULL;
7674         }
7675         return probe;
7676 }
7677
7678 static int __init ixj_probe_isa(int *cnt)
7679 {
7680         int i, probe;
7681
7682         /* Use passed parameters for older kernels without PnP */
7683         for (i = 0; i < IXJMAX; i++) {
7684                 if (dspio[i]) {
7685                         IXJ *j = new_ixj(dspio[i]);
7686
7687                         if (!j)
7688                                 break;
7689
7690                         j->XILINXbase = xio[i];
7691                         j->cardtype = 0;
7692
7693                         j->board = *cnt;
7694                         probe = ixj_selfprobe(j);
7695                         j->dev = NULL;
7696                         ++*cnt;
7697                 }
7698         }
7699         return 0;
7700 }
7701
7702 static int __init ixj_probe_pci(int *cnt)
7703 {
7704         struct pci_dev *pci = NULL;
7705         int i, probe = 0;
7706         IXJ *j = NULL;
7707
7708         for (i = 0; i < IXJMAX - *cnt; i++) {
7709                 pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
7710                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
7711                 if (!pci)
7712                         break;
7713
7714                 if (pci_enable_device(pci))
7715                         break;
7716                 j = new_ixj(pci_resource_start(pci, 0));
7717                 if (!j)
7718                         break;
7719
7720                 j->serial = (PCIEE_GetSerialNumber)pci_resource_start(pci, 2);
7721                 j->XILINXbase = j->DSPbase + 0x10;
7722                 j->cardtype = QTI_PHONEJACK_PCI;
7723                 j->board = *cnt;
7724                 probe = ixj_selfprobe(j);
7725                 if (!probe)
7726                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
7727                 ++*cnt;
7728         }
7729         pci_dev_put(pci);
7730         return probe;
7731 }
7732
7733 static int __init ixj_init(void)
7734 {
7735         int cnt = 0;
7736         int probe = 0;
7737
7738         cnt = 0;
7739
7740         /* These might be no-ops, see above. */
7741         if ((probe = ixj_probe_isapnp(&cnt)) < 0) {
7742                 return probe;
7743         }
7744         if ((probe = ixj_probe_isa(&cnt)) < 0) {
7745                 return probe;
7746         }
7747         if ((probe = ixj_probe_pci(&cnt)) < 0) {
7748                 return probe;
7749         }
7750         printk(KERN_INFO "ixj driver initialized.\n");
7751         create_proc_read_entry ("ixj", 0, NULL, ixj_read_proc, NULL);
7752         return probe;
7753 }
7754
7755 module_init(ixj_init);
7756 module_exit(ixj_exit);
7757
7758 static void DAA_Coeff_US(IXJ *j)
7759 {
7760         int i;
7761
7762         j->daa_country = DAA_US;
7763         /*----------------------------------------------- */
7764         /* CAO */
7765         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7766                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7767         }
7768
7769 /* Bytes for IM-filter part 1 (04): 0E,32,E2,2F,C2,5A,C0,00 */
7770         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x03;
7771         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0x4B;
7772         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x5D;
7773         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xCD;
7774         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x24;
7775         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xC5;
7776         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7777         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7778 /* Bytes for IM-filter part 2 (05): 72,85,00,0E,2B,3A,D0,08 */
7779         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x71;
7780         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x1A;
7781         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7782         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7783         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xB5;
7784         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7785         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7786         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7787 /* Bytes for FRX-filter       (08): 03,8F,48,F2,8F,48,70,08 */
7788         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x05;
7789         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xA3;
7790         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x72;
7791         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
7792         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x3F;
7793         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x3B;
7794         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
7795         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
7796 /* Bytes for FRR-filter       (07): 04,8F,38,7F,9B,EA,B0,08 */
7797         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x05;
7798         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
7799         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
7800         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x3E;
7801         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x32;
7802         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xDA;
7803         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
7804         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
7805 /* Bytes for AX-filter        (0A): 16,55,DD,CA */
7806         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x41;
7807         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
7808         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
7809         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
7810 /* Bytes for AR-filter        (09): 52,D3,11,42 */
7811         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
7812         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
7813         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
7814         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
7815 /* Bytes for TH-filter part 1 (00): 00,42,48,81,B3,80,00,98 */
7816         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
7817         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
7818         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
7819         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
7820         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA5;
7821         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
7822         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
7823         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
7824 /* Bytes for TH-filter part 2 (01): 02,F2,33,A0,68,AB,8A,AD */
7825         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
7826         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xA2;
7827         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2B;
7828         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
7829         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
7830         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAB;
7831         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
7832         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xCC;
7833 /* Bytes for TH-filter part 3 (02): 00,88,DA,54,A4,BA,2D,BB */
7834         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
7835         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
7836         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xD2;
7837         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x24;
7838         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBA;
7839         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xA9;
7840         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x3B;
7841         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xA6;
7842 /* ;  (10K, 0.68uF) */
7843         /*  */
7844         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7845         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
7846         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
7847         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
7848         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
7849         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
7850         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
7851         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
7852         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
7853         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7854         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
7855         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
7856         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
7857         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
7858         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
7859         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
7860         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
7861         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
7862
7863         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7864         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
7865         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
7866         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
7867         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
7868
7869         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
7870 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1C; */
7871 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0xB3; */
7872 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0xAB; */
7873 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xAB; */
7874 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x54; */
7875 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x2D; */
7876 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0x62; */
7877 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x2D; */
7878         /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
7879 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x2D; */
7880 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x62; */
7881 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6; */
7882 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBB; */
7883 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x2A; */
7884 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7D; */
7885 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A; */
7886 /*      j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD4; */
7887 /* */
7888         /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
7889 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA; */
7890 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x05; */
7891 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F; */
7892 /*      j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E; */
7893
7894         /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
7895         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
7896         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
7897         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
7898         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
7899         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
7900         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
7901         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
7902         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
7903 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
7904         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
7905         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
7906         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
7907         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
7908         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
7909         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
7910         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
7911         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
7912 /*  */
7913         /* ;CR Registers */
7914         /* Config. Reg. 0 (filters)       (cr0):FE ; CLK gen. by crystal */
7915         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
7916 /* Config. Reg. 1 (dialing)       (cr1):05 */
7917         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
7918 /* Config. Reg. 2 (caller ID)     (cr2):04 */
7919         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
7920 /* Config. Reg. 3 (testloops)     (cr3):03 ; SEL Bit==0, HP-disabled */
7921         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
7922 /* Config. Reg. 4 (analog gain)   (cr4):02 */
7923         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
7924         /* Config. Reg. 5 (Version)       (cr5):02 */
7925         /* Config. Reg. 6 (Reserved)      (cr6):00 */
7926         /* Config. Reg. 7 (Reserved)      (cr7):00 */
7927         /*  */
7928         /* ;xr Registers */
7929         /* Ext. Reg. 0 (Interrupt Reg.)   (xr0):02 */
7930
7931         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
7932         /* Ext. Reg. 1 (Interrupt enable) (xr1):3C Cadence, RING, Caller ID, VDD_OK */
7933
7934         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x3C;
7935 /* Ext. Reg. 2 (Cadence Time Out) (xr2):7D */
7936         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
7937 /* Ext. Reg. 3 (DC Char)          (xr3):32 ; B-Filter Off == 1 */
7938         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x3B;         /*0x32; */
7939         /* Ext. Reg. 4 (Cadence)          (xr4):00 */
7940
7941         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
7942 /* Ext. Reg. 5 (Ring timer)       (xr5):22 */
7943         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
7944 /* Ext. Reg. 6 (Power State)      (xr6):00 */
7945         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
7946 /* Ext. Reg. 7 (Vdd)              (xr7):40 */
7947         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
7948         /*  */
7949         /* DTMF Tone 1                     (0B): 11,B3,5A,2C ;   697 Hz   */
7950         /*                                       12,33,5A,C3 ;  770 Hz   */
7951         /*                                       13,3C,5B,32 ;  852 Hz   */
7952         /*                                       1D,1B,5C,CC ;  941 Hz   */
7953
7954         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
7955         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
7956         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
7957         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
7958 /* DTMF Tone 2                     (0C): 32,32,52,B3 ;  1209 Hz   */
7959         /*                                       EC,1D,52,22 ;  1336 Hz   */
7960         /*                                       AA,AC,51,D2 ;  1477 Hz   */
7961         /*                                       9B,3B,51,25 ;  1633 Hz   */
7962         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
7963         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
7964         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
7965         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
7966 }
7967
7968 static void DAA_Coeff_UK(IXJ *j)
7969 {
7970         int i;
7971
7972         j->daa_country = DAA_UK;
7973         /*----------------------------------------------- */
7974         /* CAO */
7975         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
7976                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
7977         }
7978
7979 /*  Bytes for IM-filter part 1 (04): 00,C2,BB,A8,CB,81,A0,00 */
7980         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
7981         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xC2;
7982         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
7983         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xA8;
7984         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xCB;
7985         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
7986         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
7987         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
7988 /* Bytes for IM-filter part 2 (05): 40,00,00,0A,A4,33,E0,08 */
7989         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x40;
7990         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x00;
7991         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
7992         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0A;
7993         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xA4;
7994         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
7995         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
7996         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
7997 /* Bytes for FRX-filter       (08): 07,9B,ED,24,B2,A2,A0,08 */
7998         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
7999         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9B;
8000         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xED;
8001         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x24;
8002         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0xB2;
8003         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0xA2;
8004         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xA0;
8005         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8006 /* Bytes for FRR-filter       (07): 0F,92,F2,B2,87,D2,30,08 */
8007         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8008         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x92;
8009         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF2;
8010         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0xB2;
8011         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8012         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xD2;
8013         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x30;
8014         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8015 /* Bytes for AX-filter        (0A): 1B,A5,DD,CA */
8016         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x1B;
8017         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xA5;
8018         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8019         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8020 /* Bytes for AR-filter        (09): E2,27,10,D6 */
8021         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8022         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x27;
8023         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8024         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8025 /* Bytes for TH-filter part 1 (00): 80,2D,38,8B,D0,00,00,98 */
8026         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8027         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x2D;
8028         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x38;
8029         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x8B;
8030         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xD0;
8031         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x00;
8032         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8033         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8034 /* Bytes for TH-filter part 2 (01): 02,5A,53,F0,0B,5F,84,D4 */
8035         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8036         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x5A;
8037         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x53;
8038         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xF0;
8039         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x0B;
8040         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5F;
8041         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x84;
8042         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xD4;
8043 /* Bytes for TH-filter part 3 (02): 00,88,6A,A4,8F,52,F5,32 */
8044         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8045         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8046         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x6A;
8047         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA4;
8048         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x8F;
8049         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x52;
8050         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xF5;
8051         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x32;
8052 /* ; idle */
8053         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8054         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8055         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8056         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8057         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8058         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8059         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8060         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8061         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8062 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8063         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8064         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8065         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8066         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8067         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8068         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8069         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8070         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8071 /* Levelmetering Ringing           (0D):AA,35,0F,8E     ; 25Hz 30V less possible? */
8072         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8073         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8074         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8075         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8076 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8077         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8078         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8079         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8080         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8081         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8082         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8083         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8084         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8085 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8086         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8087         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8088         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8089         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8090         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8091         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8092         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8093         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8094 /* ;CR Registers */
8095         /* Config. Reg. 0 (filters)        (cr0):FF */
8096         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8097 /* Config. Reg. 1 (dialing)        (cr1):05 */
8098         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8099 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8100         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8101 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8102         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8103 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8104         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8105         /* Config. Reg. 5 (Version)        (cr5):02 */
8106         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8107         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8108         /* ;xr Registers */
8109         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8110
8111         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8112         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8113
8114         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8115         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8116
8117         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8118 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8119         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8120 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8121         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8122 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8123         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8124 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8125         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8126 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8127         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8128         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8129         /*                                       12,33,5A,C3    ;  770 Hz   */
8130         /*                                       13,3C,5B,32    ;  852 Hz   */
8131         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8132
8133         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8134         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8135         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8136         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8137 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8138         /*                                       EC,1D,52,22    ;  1336 Hz   */
8139         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8140         /*                                       9B,3B,51,25    ;  1633 Hz   */
8141         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8142         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8143         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8144         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8145 }
8146
8147
8148 static void DAA_Coeff_France(IXJ *j)
8149 {
8150         int i;
8151
8152         j->daa_country = DAA_FRANCE;
8153         /*----------------------------------------------- */
8154         /* CAO */
8155         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8156                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8157         }
8158
8159 /* Bytes for IM-filter part 1 (04): 02,A2,43,2C,22,AF,A0,00 */
8160         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x02;
8161         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA2;
8162         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0x43;
8163         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2C;
8164         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0x22;
8165         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xAF;
8166         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8167         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8168 /* Bytes for IM-filter part 2 (05): 67,CE,00,0C,22,33,E0,08 */
8169         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x67;
8170         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xCE;
8171         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8172         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x2C;
8173         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x22;
8174         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8175         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8176         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8177 /* Bytes for FRX-filter       (08): 07,9A,28,F6,23,4A,B0,08 */
8178         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8179         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x9A;
8180         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x28;
8181         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0xF6;
8182         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x23;
8183         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x4A;
8184         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xB0;
8185         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8186 /* Bytes for FRR-filter       (07): 03,8F,F9,2F,9E,FA,20,08 */
8187         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8188         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8189         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xF9;
8190         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8191         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9E;
8192         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xFA;
8193         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8194         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8195 /* Bytes for AX-filter        (0A): 16,B5,DD,CA */
8196         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x16;
8197         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xB5;
8198         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8199         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8200 /* Bytes for AR-filter        (09): 52,C7,10,D6 */
8201         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0xE2;
8202         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xC7;
8203         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8204         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8205 /* Bytes for TH-filter part 1 (00): 00,42,48,81,A6,80,00,98 */
8206         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8207         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8208         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8209         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8210         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xA6;
8211         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8212         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8213         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8214 /* Bytes for TH-filter part 2 (01): 02,AC,2A,30,78,AC,8A,2C */
8215         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8216         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAC;
8217         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8218         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x30;
8219         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x78;
8220         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0xAC;
8221         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x8A;
8222         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x2C;
8223 /* Bytes for TH-filter part 3 (02): 00,88,DA,A5,22,BA,2C,45 */
8224         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8225         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8226         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8227         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0xA5;
8228         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x22;
8229         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xBA;
8230         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x2C;
8231         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x45;
8232 /* ; idle */
8233         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8234         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8235         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8236         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8237         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8238         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8239         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8240         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8241         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8242 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8243         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8244         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8245         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8246         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8247         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8248         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8249         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8250         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8251 /* Levelmetering Ringing           (0D):32,45,B5,84     ; 50Hz 20V */
8252         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8253         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8254         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8255         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8256 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8257         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8258         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8259         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8260         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8261         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8262         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8263         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8264         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8265 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8266         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8267         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8268         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8269         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8270         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8271         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8272         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8273         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8274 /* ;CR Registers */
8275         /* Config. Reg. 0 (filters)        (cr0):FF */
8276         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8277 /* Config. Reg. 1 (dialing)        (cr1):05 */
8278         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8279 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8280         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8281 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8282         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8283 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8284         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8285         /* Config. Reg. 5 (Version)        (cr5):02 */
8286         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8287         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8288         /* ;xr Registers */
8289         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8290
8291         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8292         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8293
8294         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8295         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8296
8297         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8298 /* Ext. Reg. 3 (DC Char)           (xr3):36        ;  */
8299         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x36;
8300 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8301         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8302 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8303         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8304 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8305         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8306 /* Ext. Reg. 7 (Vdd)               (xr7):46 */
8307         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x46;         /* 0x46 ??? Should it be 0x00? */
8308         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8309         /*                                       12,33,5A,C3    ;  770 Hz   */
8310         /*                                       13,3C,5B,32    ;  852 Hz   */
8311         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8312
8313         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8314         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8315         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8316         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8317 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8318         /*                                       EC,1D,52,22    ;  1336 Hz   */
8319         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8320         /*                                       9B,3B,51,25    ;  1633 Hz   */
8321         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8322         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8323         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8324         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8325 }
8326
8327
8328 static void DAA_Coeff_Germany(IXJ *j)
8329 {
8330         int i;
8331
8332         j->daa_country = DAA_GERMANY;
8333         /*----------------------------------------------- */
8334         /* CAO */
8335         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8336                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8337         }
8338
8339 /* Bytes for IM-filter part 1 (04): 00,CE,BB,B8,D2,81,B0,00 */
8340         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8341         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xCE;
8342         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xBB;
8343         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0xB8;
8344         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xD2;
8345         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x81;
8346         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xB0;
8347         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8348 /* Bytes for IM-filter part 2 (05): 45,8F,00,0C,D2,3A,D0,08 */
8349         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x45;
8350         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x8F;
8351         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8352         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0C;
8353         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0xD2;
8354         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x3A;
8355         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xD0;
8356         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8357 /* Bytes for FRX-filter       (08): 07,AA,E2,34,24,89,20,08 */
8358         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8359         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0xAA;
8360         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8361         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8362         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x24;
8363         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x89;
8364         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x20;
8365         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8366 /* Bytes for FRR-filter       (07): 02,87,FA,37,9A,CA,B0,08 */
8367         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x02;
8368         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x87;
8369         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xFA;
8370         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x37;
8371         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x9A;
8372         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCA;
8373         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xB0;
8374         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8375 /* Bytes for AX-filter        (0A): 72,D5,DD,CA */
8376         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x72;
8377         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xD5;
8378         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8379         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8380 /* Bytes for AR-filter        (09): 72,42,13,4B */
8381         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x72;
8382         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x42;
8383         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x13;
8384         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0x4B;
8385 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AD,80,00,98 */
8386         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8387         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8388         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8389         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8390         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAD;
8391         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8392         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8393         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8394 /* Bytes for TH-filter part 2 (01): 02,42,5A,20,E8,1A,81,27 */
8395         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8396         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0x42;
8397         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x5A;
8398         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8399         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0xE8;
8400         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x1A;
8401         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x81;
8402         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x27;
8403 /* Bytes for TH-filter part 3 (02): 00,88,63,26,BD,4B,A3,C2 */
8404         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8405         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8406         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x63;
8407         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x26;
8408         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0xBD;
8409         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x4B;
8410         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0xA3;
8411         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xC2;
8412 /* ;  (10K, 0.68uF) */
8413         /* Bytes for Ringing part 1 (03):1B,3B,9B,BA,D4,1C,B3,23 */
8414         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8415         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3B;
8416         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x9B;
8417         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0xBA;
8418         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0xD4;
8419         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x1C;
8420         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xB3;
8421         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8422 /* Bytes for Ringing part 2 (06):13,42,A6,BA,D4,73,CA,D5 */
8423         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x13;
8424         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0x42;
8425         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8426         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8427         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0xD4;
8428         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x73;
8429         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0xCA;
8430         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8431 /* Levelmetering Ringing        (0D):B2,45,0F,8E       */
8432         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xB2;
8433         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8434         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8435         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8436 /* Caller ID 1st Tone           (0E):CA,0E,CA,09,99,99,99,99 */
8437         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8438         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8439         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8440         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8441         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8442         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8443         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8444         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8445 /* Caller ID 2nd Tone           (0F):FD,B5,BA,07,DA,00,00,00 */
8446         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8447         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8448         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8449         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8450         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8451         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8452         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8453         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8454 /* ;CR Registers */
8455         /* Config. Reg. 0 (filters)        (cr0):FF ; all Filters enabled, CLK from ext. source */
8456         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8457 /* Config. Reg. 1 (dialing)        (cr1):05 ; Manual Ring, Ring metering enabled */
8458         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8459 /* Config. Reg. 2 (caller ID)      (cr2):04 ; Analog Gain 0dB, FSC internal */
8460         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8461 /* Config. Reg. 3 (testloops)      (cr3):00 ; SEL Bit==0, HP-enabled */
8462         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8463 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8464         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8465         /* Config. Reg. 5 (Version)        (cr5):02 */
8466         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8467         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8468         /* ;xr Registers */
8469         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8470
8471         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8472         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C ; Ring, CID, VDDOK Interrupts enabled */
8473
8474         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8475         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8476
8477         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8478 /* Ext. Reg. 3 (DC Char)           (xr3):32 ; B-Filter Off==1, U0=3.5V, R=200Ohm */
8479         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x32;
8480 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8481         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8482 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8483         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8484 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8485         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8486 /* Ext. Reg. 7 (Vdd)               (xr7):40 ; VDD=4.25 V */
8487         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8488         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8489         /*                                       12,33,5A,C3    ;  770 Hz   */
8490         /*                                       13,3C,5B,32    ;  852 Hz   */
8491         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8492
8493         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8494         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8495         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8496         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8497 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8498         /*                                       EC,1D,52,22    ;  1336 Hz   */
8499         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8500         /*                                       9B,3B,51,25    ;  1633 Hz   */
8501         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8502         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8503         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8504         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8505 }
8506
8507
8508 static void DAA_Coeff_Australia(IXJ *j)
8509 {
8510         int i;
8511
8512         j->daa_country = DAA_AUSTRALIA;
8513         /*----------------------------------------------- */
8514         /* CAO */
8515         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8516                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8517         }
8518
8519 /* Bytes for IM-filter part 1 (04): 00,A3,AA,28,B3,82,D0,00 */
8520         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x00;
8521         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xA3;
8522         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xAA;
8523         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x28;
8524         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xB3;
8525         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0x82;
8526         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xD0;
8527         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8528 /* Bytes for IM-filter part 2 (05): 70,96,00,09,32,6B,C0,08 */
8529         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x70;
8530         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0x96;
8531         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8532         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x09;
8533         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x32;
8534         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x6B;
8535         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xC0;
8536         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8537 /* Bytes for FRX-filter       (08): 07,96,E2,34,32,9B,30,08 */
8538         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x07;
8539         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x96;
8540         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0xE2;
8541         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x34;
8542         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x32;
8543         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x9B;
8544         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0x30;
8545         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8546 /* Bytes for FRR-filter       (07): 0F,9A,E9,2F,22,CC,A0,08 */
8547         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x0F;
8548         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x9A;
8549         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0xE9;
8550         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x2F;
8551         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x22;
8552         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xCC;
8553         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0xA0;
8554         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8555 /* Bytes for AX-filter        (0A): CB,45,DD,CA */
8556         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0xCB;
8557         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0x45;
8558         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8559         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8560 /* Bytes for AR-filter        (09): 1B,67,10,D6 */
8561         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x1B;
8562         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0x67;
8563         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8564         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8565 /* Bytes for TH-filter part 1 (00): 80,52,48,81,AF,80,00,98 */
8566         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x80;
8567         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x52;
8568         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8569         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8570         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAF;
8571         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8572         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8573         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8574 /* Bytes for TH-filter part 2 (01): 02,DB,52,B0,38,01,82,AC */
8575         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8576         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xDB;
8577         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x52;
8578         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0xB0;
8579         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x38;
8580         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x01;
8581         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x82;
8582         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0xAC;
8583 /* Bytes for TH-filter part 3 (02): 00,88,4A,3E,2C,3B,24,46 */
8584         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8585         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8586         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0x4A;
8587         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x3E;
8588         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x2C;
8589         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0x3B;
8590         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x24;
8591         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0x46;
8592 /* ;  idle */
8593         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8594         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8595         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8596         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8597         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8598         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8599         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8600         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8601         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8602 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8603         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8604         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8605         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8606         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8607         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8608         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8609         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8610         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8611 /* Levelmetering Ringing           (0D):32,45,B5,84   ; 50Hz 20V */
8612         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0x32;
8613         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x45;
8614         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0xB5;
8615         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x84;
8616 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8617         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8618         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8619         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8620         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8621         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8622         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8623         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8624         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8625 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8626         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8627         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8628         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8629         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8630         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8631         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8632         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8633         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8634 /* ;CR Registers */
8635         /* Config. Reg. 0 (filters)        (cr0):FF */
8636         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8637 /* Config. Reg. 1 (dialing)        (cr1):05 */
8638         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8639 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8640         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8641 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8642         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8643 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8644         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8645         /* Config. Reg. 5 (Version)        (cr5):02 */
8646         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8647         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8648         /* ;xr Registers */
8649         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8650
8651         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8652         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8653
8654         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8655         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8656
8657         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8658 /* Ext. Reg. 3 (DC Char)           (xr3):2B      ;  */
8659         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x2B;
8660 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8661         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8662 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8663         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8664 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8665         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8666 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8667         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8668
8669         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;  697 Hz   */
8670         /*                                       12,33,5A,C3    ;  770 Hz   */
8671         /*                                       13,3C,5B,32    ;  852 Hz   */
8672         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8673         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8674         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8675         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8676         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8677
8678         /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8679         /*                                       EC,1D,52,22    ;  1336 Hz   */
8680         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8681         /*                                       9B,3B,51,25    ;  1633 Hz   */
8682         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8683         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8684         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8685         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8686 }
8687
8688 static void DAA_Coeff_Japan(IXJ *j)
8689 {
8690         int i;
8691
8692         j->daa_country = DAA_JAPAN;
8693         /*----------------------------------------------- */
8694         /* CAO */
8695         for (i = 0; i < ALISDAA_CALLERID_SIZE; i++) {
8696                 j->m_DAAShadowRegs.CAO_REGS.CAO.CallerID[i] = 0;
8697         }
8698
8699 /* Bytes for IM-filter part 1 (04): 06,BD,E2,2D,BA,F9,A0,00 */
8700         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[7] = 0x06;
8701         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[6] = 0xBD;
8702         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[5] = 0xE2;
8703         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[4] = 0x2D;
8704         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[3] = 0xBA;
8705         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[2] = 0xF9;
8706         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[1] = 0xA0;
8707         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_1[0] = 0x00;
8708 /* Bytes for IM-filter part 2 (05): 6F,F7,00,0E,34,33,E0,08 */
8709         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[7] = 0x6F;
8710         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[6] = 0xF7;
8711         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[5] = 0x00;
8712         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[4] = 0x0E;
8713         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[3] = 0x34;
8714         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[2] = 0x33;
8715         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[1] = 0xE0;
8716         j->m_DAAShadowRegs.COP_REGS.COP.IMFilterCoeff_2[0] = 0x08;
8717 /* Bytes for FRX-filter       (08): 02,8F,68,77,9C,58,F0,08 */
8718         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[7] = 0x02;
8719         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[6] = 0x8F;
8720         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[5] = 0x68;
8721         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[4] = 0x77;
8722         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[3] = 0x9C;
8723         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[2] = 0x58;
8724         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[1] = 0xF0;
8725         j->m_DAAShadowRegs.COP_REGS.COP.FRXFilterCoeff[0] = 0x08;
8726 /* Bytes for FRR-filter       (07): 03,8F,38,73,87,EA,20,08 */
8727         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[7] = 0x03;
8728         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[6] = 0x8F;
8729         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[5] = 0x38;
8730         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[4] = 0x73;
8731         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[3] = 0x87;
8732         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[2] = 0xEA;
8733         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[1] = 0x20;
8734         j->m_DAAShadowRegs.COP_REGS.COP.FRRFilterCoeff[0] = 0x08;
8735 /* Bytes for AX-filter        (0A): 51,C5,DD,CA */
8736         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[3] = 0x51;
8737         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[2] = 0xC5;
8738         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[1] = 0xDD;
8739         j->m_DAAShadowRegs.COP_REGS.COP.AXFilterCoeff[0] = 0xCA;
8740 /* Bytes for AR-filter        (09): 25,A7,10,D6 */
8741         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[3] = 0x25;
8742         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[2] = 0xA7;
8743         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[1] = 0x10;
8744         j->m_DAAShadowRegs.COP_REGS.COP.ARFilterCoeff[0] = 0xD6;
8745 /* Bytes for TH-filter part 1 (00): 00,42,48,81,AE,80,00,98 */
8746         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[7] = 0x00;
8747         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[6] = 0x42;
8748         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[5] = 0x48;
8749         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[4] = 0x81;
8750         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[3] = 0xAE;
8751         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[2] = 0x80;
8752         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[1] = 0x00;
8753         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_1[0] = 0x98;
8754 /* Bytes for TH-filter part 2 (01): 02,AB,2A,20,99,5B,89,28 */
8755         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[7] = 0x02;
8756         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[6] = 0xAB;
8757         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[5] = 0x2A;
8758         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[4] = 0x20;
8759         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[3] = 0x99;
8760         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[2] = 0x5B;
8761         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[1] = 0x89;
8762         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_2[0] = 0x28;
8763 /* Bytes for TH-filter part 3 (02): 00,88,DA,25,34,C5,4C,BA */
8764         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[7] = 0x00;
8765         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[6] = 0x88;
8766         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[5] = 0xDA;
8767         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[4] = 0x25;
8768         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[3] = 0x34;
8769         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[2] = 0xC5;
8770         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[1] = 0x4C;
8771         j->m_DAAShadowRegs.COP_REGS.COP.THFilterCoeff_3[0] = 0xBA;
8772 /* ;  idle */
8773         /* Bytes for Ringing part 1 (03):1B,3C,93,3A,22,12,A3,23 */
8774         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[7] = 0x1B;
8775         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[6] = 0x3C;
8776         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[5] = 0x93;
8777         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[4] = 0x3A;
8778         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[3] = 0x22;
8779         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[2] = 0x12;
8780         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[1] = 0xA3;
8781         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_1[0] = 0x23;
8782 /* Bytes for Ringing part 2 (06):12,A2,A6,BA,22,7A,0A,D5 */
8783         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[7] = 0x12;
8784         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[6] = 0xA2;
8785         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[5] = 0xA6;
8786         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[4] = 0xBA;
8787         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[3] = 0x22;
8788         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[2] = 0x7A;
8789         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[1] = 0x0A;
8790         j->m_DAAShadowRegs.COP_REGS.COP.RingerImpendance_2[0] = 0xD5;
8791 /* Levelmetering Ringing           (0D):AA,35,0F,8E    ; 25Hz 30V ????????? */
8792         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[3] = 0xAA;
8793         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[2] = 0x35;
8794         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[1] = 0x0F;
8795         j->m_DAAShadowRegs.COP_REGS.COP.LevelmeteringRinging[0] = 0x8E;
8796 /* Caller ID 1st Tone              (0E):CA,0E,CA,09,99,99,99,99 */
8797         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[7] = 0xCA;
8798         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[6] = 0x0E;
8799         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[5] = 0xCA;
8800         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[4] = 0x09;
8801         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[3] = 0x99;
8802         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[2] = 0x99;
8803         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[1] = 0x99;
8804         j->m_DAAShadowRegs.COP_REGS.COP.CallerID1stTone[0] = 0x99;
8805 /* Caller ID 2nd Tone              (0F):FD,B5,BA,07,DA,00,00,00 */
8806         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[7] = 0xFD;
8807         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[6] = 0xB5;
8808         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[5] = 0xBA;
8809         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[4] = 0x07;
8810         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[3] = 0xDA;
8811         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[2] = 0x00;
8812         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[1] = 0x00;
8813         j->m_DAAShadowRegs.COP_REGS.COP.CallerID2ndTone[0] = 0x00;
8814 /* ;CR Registers */
8815         /* Config. Reg. 0 (filters)        (cr0):FF */
8816         j->m_DAAShadowRegs.SOP_REGS.SOP.cr0.reg = 0xFF;
8817 /* Config. Reg. 1 (dialing)        (cr1):05 */
8818         j->m_DAAShadowRegs.SOP_REGS.SOP.cr1.reg = 0x05;
8819 /* Config. Reg. 2 (caller ID)      (cr2):04 */
8820         j->m_DAAShadowRegs.SOP_REGS.SOP.cr2.reg = 0x04;
8821 /* Config. Reg. 3 (testloops)      (cr3):00        ;  */
8822         j->m_DAAShadowRegs.SOP_REGS.SOP.cr3.reg = 0x00;
8823 /* Config. Reg. 4 (analog gain)    (cr4):02 */
8824         j->m_DAAShadowRegs.SOP_REGS.SOP.cr4.reg = 0x02;
8825         /* Config. Reg. 5 (Version)        (cr5):02 */
8826         /* Config. Reg. 6 (Reserved)       (cr6):00 */
8827         /* Config. Reg. 7 (Reserved)       (cr7):00 */
8828         /* ;xr Registers */
8829         /* Ext. Reg. 0 (Interrupt Reg.)    (xr0):02 */
8830
8831         j->m_DAAShadowRegs.XOP_xr0_W.reg = 0x02;        /* SO_1 set to '1' because it is inverted. */
8832         /* Ext. Reg. 1 (Interrupt enable)  (xr1):1C */
8833
8834         j->m_DAAShadowRegs.XOP_REGS.XOP.xr1.reg = 0x1C;         /* RING, Caller ID, VDD_OK */
8835         /* Ext. Reg. 2 (Cadence Time Out)  (xr2):7D */
8836
8837         j->m_DAAShadowRegs.XOP_REGS.XOP.xr2.reg = 0x7D;
8838 /* Ext. Reg. 3 (DC Char)           (xr3):22        ;  */
8839         j->m_DAAShadowRegs.XOP_REGS.XOP.xr3.reg = 0x22;
8840 /* Ext. Reg. 4 (Cadence)           (xr4):00 */
8841         j->m_DAAShadowRegs.XOP_REGS.XOP.xr4.reg = 0x00;
8842 /* Ext. Reg. 5 (Ring timer)        (xr5):22 */
8843         j->m_DAAShadowRegs.XOP_REGS.XOP.xr5.reg = 0x22;
8844 /* Ext. Reg. 6 (Power State)       (xr6):00 */
8845         j->m_DAAShadowRegs.XOP_xr6_W.reg = 0x00;
8846 /* Ext. Reg. 7 (Vdd)               (xr7):40 */
8847         j->m_DAAShadowRegs.XOP_REGS.XOP.xr7.reg = 0x40;         /* 0x40 ??? Should it be 0x00? */
8848         /* DTMF Tone 1                     (0B): 11,B3,5A,2C    ;   697 Hz   */
8849         /*                                       12,33,5A,C3    ;  770 Hz   */
8850         /*                                       13,3C,5B,32    ;  852 Hz   */
8851         /*                                       1D,1B,5C,CC    ;  941 Hz   */
8852
8853         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[3] = 0x11;
8854         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[2] = 0xB3;
8855         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[1] = 0x5A;
8856         j->m_DAAShadowRegs.COP_REGS.COP.Tone1Coeff[0] = 0x2C;
8857 /* DTMF Tone 2                     (0C): 32,32,52,B3    ;  1209 Hz   */
8858         /*                                       EC,1D,52,22    ;  1336 Hz   */
8859         /*                                       AA,AC,51,D2    ;  1477 Hz   */
8860         /*                                       9B,3B,51,25    ;  1633 Hz   */
8861         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[3] = 0x32;
8862         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[2] = 0x32;
8863         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[1] = 0x52;
8864         j->m_DAAShadowRegs.COP_REGS.COP.Tone2Coeff[0] = 0xB3;
8865 }
8866
8867 static s16 tone_table[][19] =
8868 {
8869         {                       /* f20_50[] 11 */
8870                 32538,          /* A1 = 1.985962 */
8871                  -32325,        /* A2 = -0.986511 */
8872                  -343,          /* B2 = -0.010493 */
8873                  0,             /* B1 = 0 */
8874                  343,           /* B0 = 0.010493 */
8875                  32619,         /* A1 = 1.990906 */
8876                  -32520,        /* A2 = -0.992462 */
8877                  19179,         /* B2 = 0.585327 */
8878                  -19178,        /* B1 = -1.170593 */
8879                  19179,         /* B0 = 0.585327 */
8880                  32723,         /* A1 = 1.997314 */
8881                  -32686,        /* A2 = -0.997528 */
8882                  9973,          /* B2 = 0.304352 */
8883                  -9955,         /* B1 = -0.607605 */
8884                  9973,          /* B0 = 0.304352 */
8885                  7,             /* Internal filter scaling */
8886                  159,           /* Minimum in-band energy threshold */
8887                  21,            /* 21/32 in-band to broad-band ratio */
8888                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8889         },
8890         {                       /* f133_200[] 12 */
8891                 32072,          /* A1 = 1.95752 */
8892                  -31896,        /* A2 = -0.973419 */
8893                  -435,          /* B2 = -0.013294 */
8894                  0,             /* B1 = 0 */
8895                  435,           /* B0 = 0.013294 */
8896                  32188,         /* A1 = 1.9646 */
8897                  -32400,        /* A2 = -0.98877 */
8898                  15139,         /* B2 = 0.462036 */
8899                  -14882,        /* B1 = -0.908356 */
8900                  15139,         /* B0 = 0.462036 */
8901                  32473,         /* A1 = 1.981995 */
8902                  -32524,        /* A2 = -0.992584 */
8903                  23200,         /* B2 = 0.708008 */
8904                  -23113,        /* B1 = -1.410706 */
8905                  23200,         /* B0 = 0.708008 */
8906                  7,             /* Internal filter scaling */
8907                  159,           /* Minimum in-band energy threshold */
8908                  21,            /* 21/32 in-band to broad-band ratio */
8909                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8910         },
8911         {                       /* f300 13 */
8912                 31769,          /* A1 = -1.939026 */
8913                  -32584,        /* A2 = 0.994385 */
8914                  -475,          /* B2 = -0.014522 */
8915                  0,             /* B1 = 0.000000 */
8916                  475,           /* B0 = 0.014522 */
8917                  31789,         /* A1 = -1.940247 */
8918                  -32679,        /* A2 = 0.997284 */
8919                  17280,         /* B2 = 0.527344 */
8920                  -16865,        /* B1 = -1.029358 */
8921                  17280,         /* B0 = 0.527344 */
8922                  31841,         /* A1 = -1.943481 */
8923                  -32681,        /* A2 = 0.997345 */
8924                  543,           /* B2 = 0.016579 */
8925                  -525,          /* B1 = -0.032097 */
8926                  543,           /* B0 = 0.016579 */
8927                  5,             /* Internal filter scaling */
8928                  159,           /* Minimum in-band energy threshold */
8929                  21,            /* 21/32 in-band to broad-band ratio */
8930                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8931         },
8932         {                       /* f300_420[] 14 */
8933                 30750,          /* A1 = 1.876892 */
8934                  -31212,        /* A2 = -0.952515 */
8935                  -804,          /* B2 = -0.024541 */
8936                  0,             /* B1 = 0 */
8937                  804,           /* B0 = 0.024541 */
8938                  30686,         /* A1 = 1.872925 */
8939                  -32145,        /* A2 = -0.980988 */
8940                  14747,         /* B2 = 0.450043 */
8941                  -13703,        /* B1 = -0.836395 */
8942                  14747,         /* B0 = 0.450043 */
8943                  31651,         /* A1 = 1.931824 */
8944                  -32321,        /* A2 = -0.986389 */
8945                  24425,         /* B2 = 0.745422 */
8946                  -23914,        /* B1 = -1.459595 */
8947                  24427,         /* B0 = 0.745483 */
8948                  7,             /* Internal filter scaling */
8949                  159,           /* Minimum in-band energy threshold */
8950                  21,            /* 21/32 in-band to broad-band ratio */
8951                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8952         },
8953         {                       /* f330 15 */
8954                 31613,          /* A1 = -1.929565 */
8955                  -32646,        /* A2 = 0.996277 */
8956                  -185,          /* B2 = -0.005657 */
8957                  0,             /* B1 = 0.000000 */
8958                  185,           /* B0 = 0.005657 */
8959                  31620,         /* A1 = -1.929932 */
8960                  -32713,        /* A2 = 0.998352 */
8961                  19253,         /* B2 = 0.587585 */
8962                  -18566,        /* B1 = -1.133179 */
8963                  19253,         /* B0 = 0.587585 */
8964                  31674,         /* A1 = -1.933228 */
8965                  -32715,        /* A2 = 0.998413 */
8966                  2575,          /* B2 = 0.078590 */
8967                  -2495,         /* B1 = -0.152283 */
8968                  2575,          /* B0 = 0.078590 */
8969                  5,             /* Internal filter scaling */
8970                  159,           /* Minimum in-band energy threshold */
8971                  21,            /* 21/32 in-band to broad-band ratio */
8972                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8973         },
8974         {                       /* f300_425[] 16 */
8975                 30741,          /* A1 = 1.876282 */
8976                  -31475,        /* A2 = -0.960541 */
8977                  -703,          /* B2 = -0.021484 */
8978                  0,             /* B1 = 0 */
8979                  703,           /* B0 = 0.021484 */
8980                  30688,         /* A1 = 1.873047 */
8981                  -32248,        /* A2 = -0.984161 */
8982                  14542,         /* B2 = 0.443787 */
8983                  -13523,        /* B1 = -0.825439 */
8984                  14542,         /* B0 = 0.443817 */
8985                  31494,         /* A1 = 1.922302 */
8986                  -32366,        /* A2 = -0.987762 */
8987                  21577,         /* B2 = 0.658508 */
8988                  -21013,        /* B1 = -1.282532 */
8989                  21577,         /* B0 = 0.658508 */
8990                  7,             /* Internal filter scaling */
8991                  159,           /* Minimum in-band energy threshold */
8992                  21,            /* 21/32 in-band to broad-band ratio */
8993                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
8994         },
8995         {                       /* f330_440[] 17 */
8996                 30627,          /* A1 = 1.869324 */
8997                  -31338,        /* A2 = -0.95636 */
8998                  -843,          /* B2 = -0.025749 */
8999                  0,             /* B1 = 0 */
9000                  843,           /* B0 = 0.025749 */
9001                  30550,         /* A1 = 1.864685 */
9002                  -32221,        /* A2 = -0.983337 */
9003                  13594,         /* B2 = 0.414886 */
9004                  -12589,        /* B1 = -0.768402 */
9005                  13594,         /* B0 = 0.414886 */
9006                  31488,         /* A1 = 1.921936 */
9007                  -32358,        /* A2 = -0.987518 */
9008                  24684,         /* B2 = 0.753296 */
9009                  -24029,        /* B1 = -1.466614 */
9010                  24684,         /* B0 = 0.753296 */
9011                  7,             /* Internal filter scaling */
9012                  159,           /* Minimum in-band energy threshold */
9013                  21,            /* 21/32 in-band to broad-band ratio */
9014                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9015         },
9016         {                       /* f340 18 */
9017                 31546,          /* A1 = -1.925476 */
9018                  -32646,        /* A2 = 0.996277 */
9019                  -445,          /* B2 = -0.013588 */
9020                  0,             /* B1 = 0.000000 */
9021                  445,           /* B0 = 0.013588 */
9022                  31551,         /* A1 = -1.925781 */
9023                  -32713,        /* A2 = 0.998352 */
9024                  23884,         /* B2 = 0.728882 */
9025                  -22979,        /* B1 = -1.402527 */
9026                  23884,         /* B0 = 0.728882 */
9027                  31606,         /* A1 = -1.929138 */
9028                  -32715,        /* A2 = 0.998413 */
9029                  863,           /* B2 = 0.026367 */
9030                  -835,          /* B1 = -0.050985 */
9031                  863,           /* B0 = 0.026367 */
9032                  5,             /* Internal filter scaling */
9033                  159,           /* Minimum in-band energy threshold */
9034                  21,            /* 21/32 in-band to broad-band ratio */
9035                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9036         },
9037         {                       /* f350_400[] 19 */
9038                 31006,          /* A1 = 1.892517 */
9039                  -32029,        /* A2 = -0.977448 */
9040                  -461,          /* B2 = -0.014096 */
9041                  0,             /* B1 = 0 */
9042                  461,           /* B0 = 0.014096 */
9043                  30999,         /* A1 = 1.892029 */
9044                  -32487,        /* A2 = -0.991455 */
9045                  11325,         /* B2 = 0.345612 */
9046                  -10682,        /* B1 = -0.651978 */
9047                  11325,         /* B0 = 0.345612 */
9048                  31441,         /* A1 = 1.919067 */
9049                  -32526,        /* A2 = -0.992615 */
9050                  24324,         /* B2 = 0.74231 */
9051                  -23535,        /* B1 = -1.436523 */
9052                  24324,         /* B0 = 0.74231 */
9053                  7,             /* Internal filter scaling */
9054                  159,           /* Minimum in-band energy threshold */
9055                  21,            /* 21/32 in-band to broad-band ratio */
9056                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9057         },
9058         {                       /* f350_440[] */
9059                 30634,          /* A1 = 1.869751 */
9060                  -31533,        /* A2 = -0.962341 */
9061                  -680,          /* B2 = -0.020782 */
9062                  0,             /* B1 = 0 */
9063                  680,           /* B0 = 0.020782 */
9064                  30571,         /* A1 = 1.865906 */
9065                  -32277,        /* A2 = -0.985016 */
9066                  12894,         /* B2 = 0.393524 */
9067                  -11945,        /* B1 = -0.729065 */
9068                  12894,         /* B0 = 0.393524 */
9069                  31367,         /* A1 = 1.91449 */
9070                  -32379,        /* A2 = -0.988129 */
9071                  23820,         /* B2 = 0.726929 */
9072                  -23104,        /* B1 = -1.410217 */
9073                  23820,         /* B0 = 0.726929 */
9074                  7,             /* Internal filter scaling */
9075                  159,           /* Minimum in-band energy threshold */
9076                  21,            /* 21/32 in-band to broad-band ratio */
9077                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9078         },
9079         {                       /* f350_450[] */
9080                 30552,          /* A1 = 1.864807 */
9081                  -31434,        /* A2 = -0.95929 */
9082                  -690,          /* B2 = -0.021066 */
9083                  0,             /* B1 = 0 */
9084                  690,           /* B0 = 0.021066 */
9085                  30472,         /* A1 = 1.859924 */
9086                  -32248,        /* A2 = -0.984161 */
9087                  13385,         /* B2 = 0.408478 */
9088                  -12357,        /* B1 = -0.754242 */
9089                  13385,         /* B0 = 0.408478 */
9090                  31358,         /* A1 = 1.914001 */
9091                  -32366,        /* A2 = -0.987732 */
9092                  26488,         /* B2 = 0.80835 */
9093                  -25692,        /* B1 = -1.568176 */
9094                  26490,         /* B0 = 0.808411 */
9095                  7,             /* Internal filter scaling */
9096                  159,           /* Minimum in-band energy threshold */
9097                  21,            /* 21/32 in-band to broad-band ratio */
9098                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9099         },
9100         {                       /* f360 */
9101                 31397,          /* A1 = -1.916321 */
9102                  -32623,        /* A2 = 0.995605 */
9103                  -117,          /* B2 = -0.003598 */
9104                  0,             /* B1 = 0.000000 */
9105                  117,           /* B0 = 0.003598 */
9106                  31403,         /* A1 = -1.916687 */
9107                  -32700,        /* A2 = 0.997925 */
9108                  3388,          /* B2 = 0.103401 */
9109                  -3240,         /* B1 = -0.197784 */
9110                  3388,          /* B0 = 0.103401 */
9111                  31463,         /* A1 = -1.920410 */
9112                  -32702,        /* A2 = 0.997986 */
9113                  13346,         /* B2 = 0.407288 */
9114                  -12863,        /* B1 = -0.785126 */
9115                  13346,         /* B0 = 0.407288 */
9116                  5,             /* Internal filter scaling */
9117                  159,           /* Minimum in-band energy threshold */
9118                  21,            /* 21/32 in-band to broad-band ratio */
9119                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9120         },
9121         {                       /* f380_420[] */
9122                 30831,          /* A1 = 1.881775 */
9123                  -32064,        /* A2 = -0.978546 */
9124                  -367,          /* B2 = -0.01122 */
9125                  0,             /* B1 = 0 */
9126                  367,           /* B0 = 0.01122 */
9127                  30813,         /* A1 = 1.880737 */
9128                  -32456,        /* A2 = -0.990509 */
9129                  11068,         /* B2 = 0.337769 */
9130                  -10338,        /* B1 = -0.631042 */
9131                  11068,         /* B0 = 0.337769 */
9132                  31214,         /* A1 = 1.905212 */
9133                  -32491,        /* A2 = -0.991577 */
9134                  16374,         /* B2 = 0.499695 */
9135                  -15781,        /* B1 = -0.963196 */
9136                  16374,         /* B0 = 0.499695 */
9137                  7,             /* Internal filter scaling */
9138                  159,           /* Minimum in-band energy threshold */
9139                  21,            /* 21/32 in-band to broad-band ratio */
9140                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9141         },
9142         {                       /* f392 */
9143                 31152,          /* A1 = -1.901428 */
9144                  -32613,        /* A2 = 0.995300 */
9145                  -314,          /* B2 = -0.009605 */
9146                  0,             /* B1 = 0.000000 */
9147                  314,           /* B0 = 0.009605 */
9148                  31156,         /* A1 = -1.901672 */
9149                  -32694,        /* A2 = 0.997742 */
9150                  28847,         /* B2 = 0.880371 */
9151                  -2734,         /* B1 = -0.166901 */
9152                  28847,         /* B0 = 0.880371 */
9153                  31225,         /* A1 = -1.905823 */
9154                  -32696,        /* A2 = 0.997803 */
9155                  462,           /* B2 = 0.014108 */
9156                  -442,          /* B1 = -0.027019 */
9157                  462,           /* B0 = 0.014108 */
9158                  5,             /* Internal filter scaling */
9159                  159,           /* Minimum in-band energy threshold */
9160                  21,            /* 21/32 in-band to broad-band ratio */
9161                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9162         },
9163         {                       /* f400_425[] */
9164                 30836,          /* A1 = 1.882141 */
9165                  -32296,        /* A2 = -0.985596 */
9166                  -324,          /* B2 = -0.009903 */
9167                  0,             /* B1 = 0 */
9168                  324,           /* B0 = 0.009903 */
9169                  30825,         /* A1 = 1.881409 */
9170                  -32570,        /* A2 = -0.993958 */
9171                  16847,         /* B2 = 0.51416 */
9172                  -15792,        /* B1 = -0.963898 */
9173                  16847,         /* B0 = 0.51416 */
9174                  31106,         /* A1 = 1.89856 */
9175                  -32584,        /* A2 = -0.994415 */
9176                  9579,          /* B2 = 0.292328 */
9177                  -9164,         /* B1 = -0.559357 */
9178                  9579,          /* B0 = 0.292328 */
9179                  7,             /* Internal filter scaling */
9180                  159,           /* Minimum in-band energy threshold */
9181                  21,            /* 21/32 in-band to broad-band ratio */
9182                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9183         },
9184         {                       /* f400_440[] */
9185                 30702,          /* A1 = 1.873962 */
9186                  -32134,        /* A2 = -0.980682 */
9187                  -517,          /* B2 = -0.015793 */
9188                  0,             /* B1 = 0 */
9189                  517,           /* B0 = 0.015793 */
9190                  30676,         /* A1 = 1.872375 */
9191                  -32520,        /* A2 = -0.992462 */
9192                  8144,          /* B2 = 0.24855 */
9193                  -7596,         /* B1 = -0.463684 */
9194                  8144,          /* B0 = 0.24855 */
9195                  31084,         /* A1 = 1.897217 */
9196                  -32547,        /* A2 = -0.993256 */
9197                  22713,         /* B2 = 0.693176 */
9198                  -21734,        /* B1 = -1.326599 */
9199                  22713,         /* B0 = 0.693176 */
9200                  7,             /* Internal filter scaling */
9201                  159,           /* Minimum in-band energy threshold */
9202                  21,            /* 21/32 in-band to broad-band ratio */
9203                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9204         },
9205         {                       /* f400_450[] */
9206                 30613,          /* A1 = 1.86853 */
9207                  -32031,        /* A2 = -0.977509 */
9208                  -618,          /* B2 = -0.018866 */
9209                  0,             /* B1 = 0 */
9210                  618,           /* B0 = 0.018866 */
9211                  30577,         /* A1 = 1.866272 */
9212                  -32491,        /* A2 = -0.991577 */
9213                  9612,          /* B2 = 0.293335 */
9214                  -8935,         /* B1 = -0.54541 */
9215                  9612,          /* B0 = 0.293335 */
9216                  31071,         /* A1 = 1.896484 */
9217                  -32524,        /* A2 = -0.992584 */
9218                  21596,         /* B2 = 0.659058 */
9219                  -20667,        /* B1 = -1.261414 */
9220                  21596,         /* B0 = 0.659058 */
9221                  7,             /* Internal filter scaling */
9222                  159,           /* Minimum in-band energy threshold */
9223                  21,            /* 21/32 in-band to broad-band ratio */
9224                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9225         },
9226         {                       /* f420 */
9227                 30914,          /* A1 = -1.886841 */
9228                  -32584,        /* A2 = 0.994385 */
9229                  -426,          /* B2 = -0.013020 */
9230                  0,             /* B1 = 0.000000 */
9231                  426,           /* B0 = 0.013020 */
9232                  30914,         /* A1 = -1.886841 */
9233                  -32679,        /* A2 = 0.997314 */
9234                  17520,         /* B2 = 0.534668 */
9235                  -16471,        /* B1 = -1.005310 */
9236                  17520,         /* B0 = 0.534668 */
9237                  31004,         /* A1 = -1.892334 */
9238                  -32683,        /* A2 = 0.997406 */
9239                  819,           /* B2 = 0.025023 */
9240                  -780,          /* B1 = -0.047619 */
9241                  819,           /* B0 = 0.025023 */
9242                  5,             /* Internal filter scaling */
9243                  159,           /* Minimum in-band energy threshold */
9244                  21,            /* 21/32 in-band to broad-band ratio */
9245                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9246         },
9247 #if 0
9248         {                       /* f425 */
9249                 30881,          /* A1 = -1.884827 */
9250                  -32603,        /* A2 = 0.994965 */
9251                  -496,          /* B2 = -0.015144 */
9252                  0,             /* B1 = 0.000000 */
9253                  496,           /* B0 = 0.015144 */
9254                  30880,         /* A1 = -1.884766 */
9255                  -32692,        /* A2 = 0.997711 */
9256                  24767,         /* B2 = 0.755859 */
9257                  -23290,        /* B1 = -1.421509 */
9258                  24767,         /* B0 = 0.755859 */
9259                  30967,         /* A1 = -1.890076 */
9260                  -32694,        /* A2 = 0.997772 */
9261                  728,           /* B2 = 0.022232 */
9262                  -691,          /* B1 = -0.042194 */
9263                  728,           /* B0 = 0.022232 */
9264                  5,             /* Internal filter scaling */
9265                  159,           /* Minimum in-band energy threshold */
9266                  21,            /* 21/32 in-band to broad-band ratio */
9267                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9268         },
9269 #else
9270         {
9271                 30850,
9272                 -32534,
9273                 -504,
9274                 0,
9275                 504,
9276                 30831,
9277                 -32669,
9278                 24303,
9279                 -22080,
9280                 24303,
9281                 30994,
9282                 -32673,
9283                 1905,
9284                 -1811,
9285                 1905,
9286                 5,
9287                 129,
9288                 17,
9289                 0xff5
9290         },
9291 #endif
9292         {                       /* f425_450[] */
9293                 30646,          /* A1 = 1.870544 */
9294                  -32327,        /* A2 = -0.986572 */
9295                  -287,          /* B2 = -0.008769 */
9296                  0,             /* B1 = 0 */
9297                  287,           /* B0 = 0.008769 */
9298                  30627,         /* A1 = 1.869324 */
9299                  -32607,        /* A2 = -0.995087 */
9300                  13269,         /* B2 = 0.404968 */
9301                  -12376,        /* B1 = -0.755432 */
9302                  13269,         /* B0 = 0.404968 */
9303                  30924,         /* A1 = 1.887512 */
9304                  -32619,        /* A2 = -0.995453 */
9305                  19950,         /* B2 = 0.608826 */
9306                  -18940,        /* B1 = -1.156006 */
9307                  19950,         /* B0 = 0.608826 */
9308                  7,             /* Internal filter scaling */
9309                  159,           /* Minimum in-band energy threshold */
9310                  21,            /* 21/32 in-band to broad-band ratio */
9311                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9312         },
9313         {                       /* f425_475[] */
9314                 30396,          /* A1 = 1.855225 */
9315                  -32014,        /* A2 = -0.97699 */
9316                  -395,          /* B2 = -0.012055 */
9317                  0,             /* B1 = 0 */
9318                  395,           /* B0 = 0.012055 */
9319                  30343,         /* A1 = 1.85199 */
9320                  -32482,        /* A2 = -0.991302 */
9321                  17823,         /* B2 = 0.543945 */
9322                  -16431,        /* B1 = -1.002869 */
9323                  17823,         /* B0 = 0.543945 */
9324                  30872,         /* A1 = 1.884338 */
9325                  -32516,        /* A2 = -0.99231 */
9326                  18124,         /* B2 = 0.553101 */
9327                  -17246,        /* B1 = -1.052673 */
9328                  18124,         /* B0 = 0.553101 */
9329                  7,             /* Internal filter scaling */
9330                  159,           /* Minimum in-band energy threshold */
9331                  21,            /* 21/32 in-band to broad-band ratio */
9332                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9333         },
9334         {                       /* f435 */
9335                 30796,          /* A1 = -1.879639 */
9336                  -32603,        /* A2 = 0.994965 */
9337                  -254,          /* B2 = -0.007762 */
9338                  0,             /* B1 = 0.000000 */
9339                  254,           /* B0 = 0.007762 */
9340                  30793,         /* A1 = -1.879456 */
9341                  -32692,        /* A2 = 0.997711 */
9342                  18934,         /* B2 = 0.577820 */
9343                  -17751,        /* B1 = -1.083496 */
9344                  18934,         /* B0 = 0.577820 */
9345                  30882,         /* A1 = -1.884888 */
9346                  -32694,        /* A2 = 0.997772 */
9347                  1858,          /* B2 = 0.056713 */
9348                  -1758,         /* B1 = -0.107357 */
9349                  1858,          /* B0 = 0.056713 */
9350                  5,             /* Internal filter scaling */
9351                  159,           /* Minimum in-band energy threshold */
9352                  21,            /* 21/32 in-band to broad-band ratio */
9353                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9354         },
9355         {                       /* f440_450[] */
9356                 30641,          /* A1 = 1.870239 */
9357                  -32458,        /* A2 = -0.99057 */
9358                  -155,          /* B2 = -0.004735 */
9359                  0,             /* B1 = 0 */
9360                  155,           /* B0 = 0.004735 */
9361                  30631,         /* A1 = 1.869568 */
9362                  -32630,        /* A2 = -0.995789 */
9363                  11453,         /* B2 = 0.349548 */
9364                  -10666,        /* B1 = -0.651001 */
9365                  11453,         /* B0 = 0.349548 */
9366                  30810,         /* A1 = 1.880554 */
9367                  -32634,        /* A2 = -0.995941 */
9368                  12237,         /* B2 = 0.373474 */
9369                  -11588,        /* B1 = -0.707336 */
9370                  12237,         /* B0 = 0.373474 */
9371                  7,             /* Internal filter scaling */
9372                  159,           /* Minimum in-band energy threshold */
9373                  21,            /* 21/32 in-band to broad-band ratio */
9374                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9375         },
9376         {                       /* f440_480[] */
9377                 30367,          /* A1 = 1.853455 */
9378                  -32147,        /* A2 = -0.981079 */
9379                  -495,          /* B2 = -0.015113 */
9380                  0,             /* B1 = 0 */
9381                  495,           /* B0 = 0.015113 */
9382                  30322,         /* A1 = 1.850769 */
9383                  -32543,        /* A2 = -0.993134 */
9384                  10031,         /* B2 = 0.306152 */
9385                  -9252,         /* B1 = -0.564728 */
9386                  10031,         /* B0 = 0.306152 */
9387                  30770,         /* A1 = 1.878052 */
9388                  -32563,        /* A2 = -0.993774 */
9389                  22674,         /* B2 = 0.691956 */
9390                  -21465,        /* B1 = -1.31012 */
9391                  22674,         /* B0 = 0.691956 */
9392                  7,             /* Internal filter scaling */
9393                  159,           /* Minimum in-band energy threshold */
9394                  21,            /* 21/32 in-band to broad-band ratio */
9395                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9396         },
9397         {                       /* f445 */
9398                 30709,          /* A1 = -1.874329 */
9399                  -32603,        /* A2 = 0.994965 */
9400                  -83,           /* B2 = -0.002545 */
9401                  0,             /* B1 = 0.000000 */
9402                  83,            /* B0 = 0.002545 */
9403                  30704,         /* A1 = -1.874084 */
9404                  -32692,        /* A2 = 0.997711 */
9405                  10641,         /* B2 = 0.324738 */
9406                  -9947,         /* B1 = -0.607147 */
9407                  10641,         /* B0 = 0.324738 */
9408                  30796,         /* A1 = -1.879639 */
9409                  -32694,        /* A2 = 0.997772 */
9410                  10079,         /* B2 = 0.307587 */
9411                  9513,          /* B1 = 0.580688 */
9412                  10079,         /* B0 = 0.307587 */
9413                  5,             /* Internal filter scaling */
9414                  159,           /* Minimum in-band energy threshold */
9415                  21,            /* 21/32 in-band to broad-band ratio */
9416                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9417         },
9418         {                       /* f450 */
9419                 30664,          /* A1 = -1.871643 */
9420                  -32603,        /* A2 = 0.994965 */
9421                  -164,          /* B2 = -0.005029 */
9422                  0,             /* B1 = 0.000000 */
9423                  164,           /* B0 = 0.005029 */
9424                  30661,         /* A1 = -1.871399 */
9425                  -32692,        /* A2 = 0.997711 */
9426                  15294,         /* B2 = 0.466736 */
9427                  -14275,        /* B1 = -0.871307 */
9428                  15294,         /* B0 = 0.466736 */
9429                  30751,         /* A1 = -1.876953 */
9430                  -32694,        /* A2 = 0.997772 */
9431                  3548,          /* B2 = 0.108284 */
9432                  -3344,         /* B1 = -0.204155 */
9433                  3548,          /* B0 = 0.108284 */
9434                  5,             /* Internal filter scaling */
9435                  159,           /* Minimum in-band energy threshold */
9436                  21,            /* 21/32 in-band to broad-band ratio */
9437                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9438         },
9439         {                       /* f452 */
9440                 30653,          /* A1 = -1.870911 */
9441                  -32615,        /* A2 = 0.995361 */
9442                  -209,          /* B2 = -0.006382 */
9443                  0,             /* B1 = 0.000000 */
9444                  209,           /* B0 = 0.006382 */
9445                  30647,         /* A1 = -1.870605 */
9446                  -32702,        /* A2 = 0.997986 */
9447                  18971,         /* B2 = 0.578979 */
9448                  -17716,        /* B1 = -1.081299 */
9449                  18971,         /* B0 = 0.578979 */
9450                  30738,         /* A1 = -1.876099 */
9451                  -32702,        /* A2 = 0.998016 */
9452                  2967,          /* B2 = 0.090561 */
9453                  -2793,         /* B1 = -0.170502 */
9454                  2967,          /* B0 = 0.090561 */
9455                  5,             /* Internal filter scaling */
9456                  159,           /* Minimum in-band energy threshold */
9457                  21,            /* 21/32 in-band to broad-band ratio */
9458                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9459         },
9460         {                       /* f475 */
9461                 30437,          /* A1 = -1.857727 */
9462                  -32603,        /* A2 = 0.994965 */
9463                  -264,          /* B2 = -0.008062 */
9464                  0,             /* B1 = 0.000000 */
9465                  264,           /* B0 = 0.008062 */
9466                  30430,         /* A1 = -1.857300 */
9467                  -32692,        /* A2 = 0.997711 */
9468                  21681,         /* B2 = 0.661682 */
9469                  -20082,        /* B1 = -1.225708 */
9470                  21681,         /* B0 = 0.661682 */
9471                  30526,         /* A1 = -1.863220 */
9472                  -32694,        /* A2 = 0.997742 */
9473                  1559,          /* B2 = 0.047600 */
9474                  -1459,         /* B1 = -0.089096 */
9475                  1559,          /* B0 = 0.047600 */
9476                  5,             /* Internal filter scaling */
9477                  159,           /* Minimum in-band energy threshold */
9478                  21,            /* 21/32 in-band to broad-band ratio */
9479                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9480         },
9481         {                       /* f480_620[] */
9482                 28975,          /* A1 = 1.768494 */
9483                  -30955,        /* A2 = -0.944672 */
9484                  -1026,         /* B2 = -0.03133 */
9485                  0,             /* B1 = 0 */
9486                  1026,          /* B0 = 0.03133 */
9487                  28613,         /* A1 = 1.746399 */
9488                  -32089,        /* A2 = -0.979309 */
9489                  14214,         /* B2 = 0.433807 */
9490                  -12202,        /* B1 = -0.744812 */
9491                  14214,         /* B0 = 0.433807 */
9492                  30243,         /* A1 = 1.845947 */
9493                  -32238,        /* A2 = -0.983856 */
9494                  24825,         /* B2 = 0.757629 */
9495                  -23402,        /* B1 = -1.428345 */
9496                  24825,         /* B0 = 0.757629 */
9497                  7,             /* Internal filter scaling */
9498                  159,           /* Minimum in-band energy threshold */
9499                  21,            /* 21/32 in-band to broad-band ratio */
9500                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9501         },
9502         {                       /* f494 */
9503                 30257,          /* A1 = -1.846741 */
9504                  -32605,        /* A2 = 0.995056 */
9505                  -249,          /* B2 = -0.007625 */
9506                  0,             /* B1 = 0.000000 */
9507                  249,           /* B0 = 0.007625 */
9508                  30247,         /* A1 = -1.846191 */
9509                  -32694,        /* A2 = 0.997772 */
9510                  18088,         /* B2 = 0.552002 */
9511                  -16652,        /* B1 = -1.016418 */
9512                  18088,         /* B0 = 0.552002 */
9513                  30348,         /* A1 = -1.852295 */
9514                  -32696,        /* A2 = 0.997803 */
9515                  2099,          /* B2 = 0.064064 */
9516                  -1953,         /* B1 = -0.119202 */
9517                  2099,          /* B0 = 0.064064 */
9518                  5,             /* Internal filter scaling */
9519                  159,           /* Minimum in-band energy threshold */
9520                  21,            /* 21/32 in-band to broad-band ratio */
9521                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9522         },
9523         {                       /* f500 */
9524                 30202,          /* A1 = -1.843431 */
9525                  -32624,        /* A2 = 0.995622 */
9526                  -413,          /* B2 = -0.012622 */
9527                  0,             /* B1 = 0.000000 */
9528                  413,           /* B0 = 0.012622 */
9529                  30191,         /* A1 = -1.842721 */
9530                  -32714,        /* A2 = 0.998364 */
9531                  25954,         /* B2 = 0.792057 */
9532                  -23890,        /* B1 = -1.458131 */
9533                  25954,         /* B0 = 0.792057 */
9534                  30296,         /* A1 = -1.849172 */
9535                  -32715,        /* A2 = 0.998397 */
9536                  2007,          /* B2 = 0.061264 */
9537                  -1860,         /* B1 = -0.113568 */
9538                  2007,          /* B0 = 0.061264 */
9539                  5,             /* Internal filter scaling */
9540                  159,           /* Minimum in-band energy threshold */
9541                  21,            /* 21/32 in-band to broad-band ratio */
9542                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9543         },
9544         {                       /* f520 */
9545                 30001,          /* A1 = -1.831116 */
9546                  -32613,        /* A2 = 0.995270 */
9547                  -155,          /* B2 = -0.004750 */
9548                  0,             /* B1 = 0.000000 */
9549                  155,           /* B0 = 0.004750 */
9550                  29985,         /* A1 = -1.830200 */
9551                  -32710,        /* A2 = 0.998260 */
9552                  6584,          /* B2 = 0.200928 */
9553                  -6018,         /* B1 = -0.367355 */
9554                  6584,          /* B0 = 0.200928 */
9555                  30105,         /* A1 = -1.837524 */
9556                  -32712,        /* A2 = 0.998291 */
9557                  23812,         /* B2 = 0.726685 */
9558                  -21936,        /* B1 = -1.338928 */
9559                  23812,         /* B0 = 0.726685 */
9560                  5,             /* Internal filter scaling */
9561                  159,           /* Minimum in-band energy threshold */
9562                  21,            /* 21/32 in-band to broad-band ratio */
9563                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9564         },
9565         {                       /* f523 */
9566                 29964,          /* A1 = -1.828918 */
9567                  -32601,        /* A2 = 0.994904 */
9568                  -101,          /* B2 = -0.003110 */
9569                  0,             /* B1 = 0.000000 */
9570                  101,           /* B0 = 0.003110 */
9571                  29949,         /* A1 = -1.827942 */
9572                  -32700,        /* A2 = 0.997925 */
9573                  11041,         /* B2 = 0.336975 */
9574                  -10075,        /* B1 = -0.614960 */
9575                  11041,         /* B0 = 0.336975 */
9576                  30070,         /* A1 = -1.835388 */
9577                  -32702,        /* A2 = 0.997986 */
9578                  16762,         /* B2 = 0.511536 */
9579                  -15437,        /* B1 = -0.942230 */
9580                  16762,         /* B0 = 0.511536 */
9581                  5,             /* Internal filter scaling */
9582                  159,           /* Minimum in-band energy threshold */
9583                  21,            /* 21/32 in-band to broad-band ratio */
9584                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9585         },
9586         {                       /* f525 */
9587                 29936,          /* A1 = -1.827209 */
9588                  -32584,        /* A2 = 0.994415 */
9589                  -91,           /* B2 = -0.002806 */
9590                  0,             /* B1 = 0.000000 */
9591                  91,            /* B0 = 0.002806 */
9592                  29921,         /* A1 = -1.826233 */
9593                  -32688,        /* A2 = 0.997559 */
9594                  11449,         /* B2 = 0.349396 */
9595                  -10426,        /* B1 = -0.636383 */
9596                  11449,         /* B0 = 0.349396 */
9597                  30045,         /* A1 = -1.833862 */
9598                  -32688,        /* A2 = 0.997589 */
9599                  13055,         /* B2 = 0.398407 */
9600                  -12028,        /* B1 = -0.734161 */
9601                  13055,         /* B0 = 0.398407 */
9602                  5,             /* Internal filter scaling */
9603                  159,           /* Minimum in-band energy threshold */
9604                  21,            /* 21/32 in-band to broad-band ratio */
9605                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9606         },
9607         {                       /* f540_660[] */
9608                 28499,          /* A1 = 1.739441 */
9609                  -31129,        /* A2 = -0.949982 */
9610                  -849,          /* B2 = -0.025922 */
9611                  0,             /* B1 = 0 */
9612                  849,           /* B0 = 0.025922 */
9613                  28128,         /* A1 = 1.716797 */
9614                  -32130,        /* A2 = -0.98056 */
9615                  14556,         /* B2 = 0.444214 */
9616                  -12251,        /* B1 = -0.747772 */
9617                  14556,         /* B0 = 0.444244 */
9618                  29667,         /* A1 = 1.81073 */
9619                  -32244,        /* A2 = -0.984039 */
9620                  23038,         /* B2 = 0.703064 */
9621                  -21358,        /* B1 = -1.303589 */
9622                  23040,         /* B0 = 0.703125 */
9623                  7,             /* Internal filter scaling */
9624                  159,           /* Minimum in-band energy threshold */
9625                  21,            /* 21/32 in-band to broad-band ratio */
9626                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9627         },
9628         {                       /* f587 */
9629                 29271,          /* A1 = -1.786560 */
9630                  -32599,        /* A2 = 0.994873 */
9631                  -490,          /* B2 = -0.014957 */
9632                  0,             /* B1 = 0.000000 */
9633                  490,           /* B0 = 0.014957 */
9634                  29246,         /* A1 = -1.785095 */
9635                  -32700,        /* A2 = 0.997925 */
9636                  28961,         /* B2 = 0.883850 */
9637                  -25796,        /* B1 = -1.574463 */
9638                  28961,         /* B0 = 0.883850 */
9639                  29383,         /* A1 = -1.793396 */
9640                  -32700,        /* A2 = 0.997955 */
9641                  1299,          /* B2 = 0.039650 */
9642                  -1169,         /* B1 = -0.071396 */
9643                  1299,          /* B0 = 0.039650 */
9644                  5,             /* Internal filter scaling */
9645                  159,           /* Minimum in-band energy threshold */
9646                  21,            /* 21/32 in-band to broad-band ratio */
9647                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9648         },
9649         {                       /* f590 */
9650                 29230,          /* A1 = -1.784058 */
9651                  -32584,        /* A2 = 0.994415 */
9652                  -418,          /* B2 = -0.012757 */
9653                  0,             /* B1 = 0.000000 */
9654                  418,           /* B0 = 0.012757 */
9655                  29206,         /* A1 = -1.782593 */
9656                  -32688,        /* A2 = 0.997559 */
9657                  36556,         /* B2 = 1.115601 */
9658                  -32478,        /* B1 = -1.982300 */
9659                  36556,         /* B0 = 1.115601 */
9660                  29345,         /* A1 = -1.791077 */
9661                  -32688,        /* A2 = 0.997589 */
9662                  897,           /* B2 = 0.027397 */
9663                  -808,          /* B1 = -0.049334 */
9664                  897,           /* B0 = 0.027397 */
9665                  5,             /* Internal filter scaling */
9666                  159,           /* Minimum in-band energy threshold */
9667                  21,            /* 21/32 in-band to broad-band ratio */
9668                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9669         },
9670         {                       /* f600 */
9671                 29116,          /* A1 = -1.777100 */
9672                  -32603,        /* A2 = 0.994965 */
9673                  -165,          /* B2 = -0.005039 */
9674                  0,             /* B1 = 0.000000 */
9675                  165,           /* B0 = 0.005039 */
9676                  29089,         /* A1 = -1.775452 */
9677                  -32708,        /* A2 = 0.998199 */
9678                  6963,          /* B2 = 0.212494 */
9679                  -6172,         /* B1 = -0.376770 */
9680                  6963,          /* B0 = 0.212494 */
9681                  29237,         /* A1 = -1.784485 */
9682                  -32710,        /* A2 = 0.998230 */
9683                  24197,         /* B2 = 0.738464 */
9684                  -21657,        /* B1 = -1.321899 */
9685                  24197,         /* B0 = 0.738464 */
9686                  5,             /* Internal filter scaling */
9687                  159,           /* Minimum in-band energy threshold */
9688                  21,            /* 21/32 in-band to broad-band ratio */
9689                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9690         },
9691         {                       /* f660 */
9692                 28376,          /* A1 = -1.731934 */
9693                  -32567,        /* A2 = 0.993896 */
9694                  -363,          /* B2 = -0.011102 */
9695                  0,             /* B1 = 0.000000 */
9696                  363,           /* B0 = 0.011102 */
9697                  28337,         /* A1 = -1.729614 */
9698                  -32683,        /* A2 = 0.997434 */
9699                  21766,         /* B2 = 0.664246 */
9700                  -18761,        /* B1 = -1.145081 */
9701                  21766,         /* B0 = 0.664246 */
9702                  28513,         /* A1 = -1.740356 */
9703                  -32686,        /* A2 = 0.997498 */
9704                  2509,          /* B2 = 0.076584 */
9705                  -2196,         /* B1 = -0.134041 */
9706                  2509,          /* B0 = 0.076584 */
9707                  5,             /* Internal filter scaling */
9708                  159,           /* Minimum in-band energy threshold */
9709                  21,            /* 21/32 in-band to broad-band ratio */
9710                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9711         },
9712         {                       /* f700 */
9713                 27844,          /* A1 = -1.699463 */
9714                  -32563,        /* A2 = 0.993744 */
9715                  -366,          /* B2 = -0.011187 */
9716                  0,             /* B1 = 0.000000 */
9717                  366,           /* B0 = 0.011187 */
9718                  27797,         /* A1 = -1.696655 */
9719                  -32686,        /* A2 = 0.997498 */
9720                  22748,         /* B2 = 0.694214 */
9721                  -19235,        /* B1 = -1.174072 */
9722                  22748,         /* B0 = 0.694214 */
9723                  27995,         /* A1 = -1.708740 */
9724                  -32688,        /* A2 = 0.997559 */
9725                  2964,          /* B2 = 0.090477 */
9726                  -2546,         /* B1 = -0.155449 */
9727                  2964,          /* B0 = 0.090477 */
9728                  5,             /* Internal filter scaling */
9729                  159,           /* Minimum in-band energy threshold */
9730                  21,            /* 21/32 in-band to broad-band ratio */
9731                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9732         },
9733         {                       /* f740 */
9734                 27297,          /* A1 = -1.666077 */
9735                  -32551,        /* A2 = 0.993408 */
9736                  -345,          /* B2 = -0.010540 */
9737                  0,             /* B1 = 0.000000 */
9738                  345,           /* B0 = 0.010540 */
9739                  27240,         /* A1 = -1.662598 */
9740                  -32683,        /* A2 = 0.997406 */
9741                  22560,         /* B2 = 0.688477 */
9742                  -18688,        /* B1 = -1.140625 */
9743                  22560,         /* B0 = 0.688477 */
9744                  27461,         /* A1 = -1.676147 */
9745                  -32684,        /* A2 = 0.997467 */
9746                  3541,          /* B2 = 0.108086 */
9747                  -2985,         /* B1 = -0.182220 */
9748                  3541,          /* B0 = 0.108086 */
9749                  5,             /* Internal filter scaling */
9750                  159,           /* Minimum in-band energy threshold */
9751                  21,            /* 21/32 in-band to broad-band ratio */
9752                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9753         },
9754         {                       /* f750 */
9755                 27155,          /* A1 = -1.657410 */
9756                  -32551,        /* A2 = 0.993408 */
9757                  -462,          /* B2 = -0.014117 */
9758                  0,             /* B1 = 0.000000 */
9759                  462,           /* B0 = 0.014117 */
9760                  27097,         /* A1 = -1.653870 */
9761                  -32683,        /* A2 = 0.997406 */
9762                  32495,         /* B2 = 0.991699 */
9763                  -26776,        /* B1 = -1.634338 */
9764                  32495,         /* B0 = 0.991699 */
9765                  27321,         /* A1 = -1.667542 */
9766                  -32684,        /* A2 = 0.997467 */
9767                  1835,          /* B2 = 0.056007 */
9768                  -1539,         /* B1 = -0.093948 */
9769                  1835,          /* B0 = 0.056007 */
9770                  5,             /* Internal filter scaling */
9771                  159,           /* Minimum in-band energy threshold */
9772                  21,            /* 21/32 in-band to broad-band ratio */
9773                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9774         },
9775         {                       /* f750_1450[] */
9776                 19298,          /* A1 = 1.177917 */
9777                  -24471,        /* A2 = -0.746796 */
9778                  -4152,         /* B2 = -0.126709 */
9779                  0,             /* B1 = 0 */
9780                  4152,          /* B0 = 0.126709 */
9781                  12902,         /* A1 = 0.787476 */
9782                  -29091,        /* A2 = -0.887817 */
9783                  12491,         /* B2 = 0.38121 */
9784                  -1794,         /* B1 = -0.109528 */
9785                  12494,         /* B0 = 0.381317 */
9786                  26291,         /* A1 = 1.604736 */
9787                  -30470,        /* A2 = -0.929901 */
9788                  28859,         /* B2 = 0.880737 */
9789                  -26084,        /* B1 = -1.592102 */
9790                  28861,         /* B0 = 0.880798 */
9791                  7,             /* Internal filter scaling */
9792                  159,           /* Minimum in-band energy threshold */
9793                  21,            /* 21/32 in-band to broad-band ratio */
9794                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9795         },
9796         {                       /* f770 */
9797                 26867,          /* A1 = -1.639832 */
9798                  -32551,        /* A2 = 0.993408 */
9799                  -123,          /* B2 = -0.003755 */
9800                  0,             /* B1 = 0.000000 */
9801                  123,           /* B0 = 0.003755 */
9802                  26805,         /* A1 = -1.636108 */
9803                  -32683,        /* A2 = 0.997406 */
9804                  17297,         /* B2 = 0.527863 */
9805                  -14096,        /* B1 = -0.860382 */
9806                  17297,         /* B0 = 0.527863 */
9807                  27034,         /* A1 = -1.650085 */
9808                  -32684,        /* A2 = 0.997467 */
9809                  12958,         /* B2 = 0.395477 */
9810                  -10756,        /* B1 = -0.656525 */
9811                  12958,         /* B0 = 0.395477 */
9812                  5,             /* Internal filter scaling */
9813                  159,           /* Minimum in-band energy threshold */
9814                  21,            /* 21/32 in-band to broad-band ratio */
9815                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9816         },
9817         {                       /* f800 */
9818                 26413,          /* A1 = -1.612122 */
9819                  -32547,        /* A2 = 0.993286 */
9820                  -223,          /* B2 = -0.006825 */
9821                  0,             /* B1 = 0.000000 */
9822                  223,           /* B0 = 0.006825 */
9823                  26342,         /* A1 = -1.607849 */
9824                  -32686,        /* A2 = 0.997498 */
9825                  6391,          /* B2 = 0.195053 */
9826                  -5120,         /* B1 = -0.312531 */
9827                  6391,          /* B0 = 0.195053 */
9828                  26593,         /* A1 = -1.623108 */
9829                  -32688,        /* A2 = 0.997559 */
9830                  23681,         /* B2 = 0.722717 */
9831                  -19328,        /* B1 = -1.179688 */
9832                  23681,         /* B0 = 0.722717 */
9833                  5,             /* Internal filter scaling */
9834                  159,           /* Minimum in-band energy threshold */
9835                  21,            /* 21/32 in-band to broad-band ratio */
9836                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9837         },
9838         {                       /* f816 */
9839                 26168,          /* A1 = -1.597209 */
9840                  -32528,        /* A2 = 0.992706 */
9841                  -235,          /* B2 = -0.007182 */
9842                  0,             /* B1 = 0.000000 */
9843                  235,           /* B0 = 0.007182 */
9844                  26092,         /* A1 = -1.592590 */
9845                  -32675,        /* A2 = 0.997192 */
9846                  20823,         /* B2 = 0.635498 */
9847                  -16510,        /* B1 = -1.007751 */
9848                  20823,         /* B0 = 0.635498 */
9849                  26363,         /* A1 = -1.609070 */
9850                  -32677,        /* A2 = 0.997253 */
9851                  6739,          /* B2 = 0.205688 */
9852                  -5459,         /* B1 = -0.333206 */
9853                  6739,          /* B0 = 0.205688 */
9854                  5,             /* Internal filter scaling */
9855                  159,           /* Minimum in-band energy threshold */
9856                  21,            /* 21/32 in-band to broad-band ratio */
9857                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9858         },
9859         {                       /* f850 */
9860                 25641,          /* A1 = -1.565063 */
9861                  -32536,        /* A2 = 0.992950 */
9862                  -121,          /* B2 = -0.003707 */
9863                  0,             /* B1 = 0.000000 */
9864                  121,           /* B0 = 0.003707 */
9865                  25560,         /* A1 = -1.560059 */
9866                  -32684,        /* A2 = 0.997437 */
9867                  18341,         /* B2 = 0.559753 */
9868                  -14252,        /* B1 = -0.869904 */
9869                  18341,         /* B0 = 0.559753 */
9870                  25837,         /* A1 = -1.577026 */
9871                  -32684,        /* A2 = 0.997467 */
9872                  16679,         /* B2 = 0.509003 */
9873                  -13232,        /* B1 = -0.807648 */
9874                  16679,         /* B0 = 0.509003 */
9875                  5,             /* Internal filter scaling */
9876                  159,           /* Minimum in-band energy threshold */
9877                  21,            /* 21/32 in-band to broad-band ratio */
9878                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9879         },
9880         {                       /* f857_1645[] */
9881                 16415,          /* A1 = 1.001953 */
9882                  -23669,        /* A2 = -0.722321 */
9883                  -4549,         /* B2 = -0.138847 */
9884                  0,             /* B1 = 0 */
9885                  4549,          /* B0 = 0.138847 */
9886                  8456,          /* A1 = 0.516174 */
9887                  -28996,        /* A2 = -0.884918 */
9888                  13753,         /* B2 = 0.419724 */
9889                  -12,           /* B1 = -0.000763 */
9890                  13757,         /* B0 = 0.419846 */
9891                  24632,         /* A1 = 1.503418 */
9892                  -30271,        /* A2 = -0.923828 */
9893                  29070,         /* B2 = 0.887146 */
9894                  -25265,        /* B1 = -1.542114 */
9895                  29073,         /* B0 = 0.887268 */
9896                  7,             /* Internal filter scaling */
9897                  159,           /* Minimum in-band energy threshold */
9898                  21,            /* 21/32 in-band to broad-band ratio */
9899                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9900         },
9901         {                       /* f900 */
9902                 24806,          /* A1 = -1.514099 */
9903                  -32501,        /* A2 = 0.991852 */
9904                  -326,          /* B2 = -0.009969 */
9905                  0,             /* B1 = 0.000000 */
9906                  326,           /* B0 = 0.009969 */
9907                  24709,         /* A1 = -1.508118 */
9908                  -32659,        /* A2 = 0.996674 */
9909                  20277,         /* B2 = 0.618835 */
9910                  -15182,        /* B1 = -0.926636 */
9911                  20277,         /* B0 = 0.618835 */
9912                  25022,         /* A1 = -1.527222 */
9913                  -32661,        /* A2 = 0.996735 */
9914                  4320,          /* B2 = 0.131836 */
9915                  -3331,         /* B1 = -0.203339 */
9916                  4320,          /* B0 = 0.131836 */
9917                  5,             /* Internal filter scaling */
9918                  159,           /* Minimum in-band energy threshold */
9919                  21,            /* 21/32 in-band to broad-band ratio */
9920                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9921         },
9922         {                       /* f900_1300[] */
9923                 19776,          /* A1 = 1.207092 */
9924                  -27437,        /* A2 = -0.837341 */
9925                  -2666,         /* B2 = -0.081371 */
9926                  0,             /* B1 = 0 */
9927                  2666,          /* B0 = 0.081371 */
9928                  16302,         /* A1 = 0.995026 */
9929                  -30354,        /* A2 = -0.926361 */
9930                  10389,         /* B2 = 0.317062 */
9931                  -3327,         /* B1 = -0.203064 */
9932                  10389,         /* B0 = 0.317062 */
9933                  24299,         /* A1 = 1.483154 */
9934                  -30930,        /* A2 = -0.943909 */
9935                  25016,         /* B2 = 0.763428 */
9936                  -21171,        /* B1 = -1.292236 */
9937                  25016,         /* B0 = 0.763428 */
9938                  7,             /* Internal filter scaling */
9939                  159,           /* Minimum in-band energy threshold */
9940                  21,            /* 21/32 in-band to broad-band ratio */
9941                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9942         },
9943         {                       /* f935_1215[] */
9944                 20554,          /* A1 = 1.254517 */
9945                  -28764,        /* A2 = -0.877838 */
9946                  -2048,         /* B2 = -0.062515 */
9947                  0,             /* B1 = 0 */
9948                  2048,          /* B0 = 0.062515 */
9949                  18209,         /* A1 = 1.11145 */
9950                  -30951,        /* A2 = -0.94458 */
9951                  9390,          /* B2 = 0.286575 */
9952                  -3955,         /* B1 = -0.241455 */
9953                  9390,          /* B0 = 0.286575 */
9954                  23902,         /* A1 = 1.458923 */
9955                  -31286,        /* A2 = -0.954803 */
9956                  23252,         /* B2 = 0.709595 */
9957                  -19132,        /* B1 = -1.167725 */
9958                  23252,         /* B0 = 0.709595 */
9959                  7,             /* Internal filter scaling */
9960                  159,           /* Minimum in-band energy threshold */
9961                  21,            /* 21/32 in-band to broad-band ratio */
9962                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9963         },
9964         {                       /* f941_1477[] */
9965                 17543,          /* A1 = 1.07074 */
9966                  -26220,        /* A2 = -0.800201 */
9967                  -3298,         /* B2 = -0.100647 */
9968                  0,             /* B1 = 0 */
9969                  3298,          /* B0 = 0.100647 */
9970                  12423,         /* A1 = 0.75827 */
9971                  -30036,        /* A2 = -0.916626 */
9972                  12651,         /* B2 = 0.386078 */
9973                  -2444,         /* B1 = -0.14917 */
9974                  12653,         /* B0 = 0.386154 */
9975                  23518,         /* A1 = 1.435425 */
9976                  -30745,        /* A2 = -0.938293 */
9977                  27282,         /* B2 = 0.832581 */
9978                  -22529,        /* B1 = -1.375122 */
9979                  27286,         /* B0 = 0.832703 */
9980                  7,             /* Internal filter scaling */
9981                  159,           /* Minimum in-band energy threshold */
9982                  21,            /* 21/32 in-band to broad-band ratio */
9983                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
9984         },
9985         {                       /* f942 */
9986                 24104,          /* A1 = -1.471252 */
9987                  -32507,        /* A2 = 0.992065 */
9988                  -351,          /* B2 = -0.010722 */
9989                  0,             /* B1 = 0.000000 */
9990                  351,           /* B0 = 0.010722 */
9991                  23996,         /* A1 = -1.464600 */
9992                  -32671,        /* A2 = 0.997040 */
9993                  22848,         /* B2 = 0.697266 */
9994                  -16639,        /* B1 = -1.015564 */
9995                  22848,         /* B0 = 0.697266 */
9996                  24332,         /* A1 = -1.485168 */
9997                  -32673,        /* A2 = 0.997101 */
9998                  4906,          /* B2 = 0.149727 */
9999                  -3672,         /* B1 = -0.224174 */
10000                  4906,          /* B0 = 0.149727 */
10001                  5,             /* Internal filter scaling */
10002                  159,           /* Minimum in-band energy threshold */
10003                  21,            /* 21/32 in-band to broad-band ratio */
10004                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10005         },
10006         {                       /* f950 */
10007                 23967,          /* A1 = -1.462830 */
10008                  -32507,        /* A2 = 0.992065 */
10009                  -518,          /* B2 = -0.015821 */
10010                  0,             /* B1 = 0.000000 */
10011                  518,           /* B0 = 0.015821 */
10012                  23856,         /* A1 = -1.456055 */
10013                  -32671,        /* A2 = 0.997040 */
10014                  26287,         /* B2 = 0.802246 */
10015                  -19031,        /* B1 = -1.161560 */
10016                  26287,         /* B0 = 0.802246 */
10017                  24195,         /* A1 = -1.476746 */
10018                  -32673,        /* A2 = 0.997101 */
10019                  2890,          /* B2 = 0.088196 */
10020                  -2151,         /* B1 = -0.131317 */
10021                  2890,          /* B0 = 0.088196 */
10022                  5,             /* Internal filter scaling */
10023                  159,           /* Minimum in-band energy threshold */
10024                  21,            /* 21/32 in-band to broad-band ratio */
10025                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10026         },
10027         {                       /* f950_1400[] */
10028                 18294,          /* A1 = 1.116638 */
10029                  -26962,        /* A2 = -0.822845 */
10030                  -2914,         /* B2 = -0.088936 */
10031                  0,             /* B1 = 0 */
10032                  2914,          /* B0 = 0.088936 */
10033                  14119,         /* A1 = 0.861786 */
10034                  -30227,        /* A2 = -0.922455 */
10035                  11466,         /* B2 = 0.349945 */
10036                  -2833,         /* B1 = -0.172943 */
10037                  11466,         /* B0 = 0.349945 */
10038                  23431,         /* A1 = 1.430115 */
10039                  -30828,        /* A2 = -0.940796 */
10040                  25331,         /* B2 = 0.773071 */
10041                  -20911,        /* B1 = -1.276367 */
10042                  25331,         /* B0 = 0.773071 */
10043                  7,             /* Internal filter scaling */
10044                  159,           /* Minimum in-band energy threshold */
10045                  21,            /* 21/32 in-band to broad-band ratio */
10046                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10047         },
10048         {                       /* f975 */
10049                 23521,          /* A1 = -1.435608 */
10050                  -32489,        /* A2 = 0.991516 */
10051                  -193,          /* B2 = -0.005915 */
10052                  0,             /* B1 = 0.000000 */
10053                  193,           /* B0 = 0.005915 */
10054                  23404,         /* A1 = -1.428467 */
10055                  -32655,        /* A2 = 0.996582 */
10056                  17740,         /* B2 = 0.541412 */
10057                  -12567,        /* B1 = -0.767029 */
10058                  17740,         /* B0 = 0.541412 */
10059                  23753,         /* A1 = -1.449829 */
10060                  -32657,        /* A2 = 0.996613 */
10061                  9090,          /* B2 = 0.277405 */
10062                  -6662,         /* B1 = -0.406647 */
10063                  9090,          /* B0 = 0.277405 */
10064                  5,             /* Internal filter scaling */
10065                  159,           /* Minimum in-band energy threshold */
10066                  21,            /* 21/32 in-band to broad-band ratio */
10067                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10068         },
10069         {                       /* f1000 */
10070                 23071,          /* A1 = -1.408203 */
10071                  -32489,        /* A2 = 0.991516 */
10072                  -293,          /* B2 = -0.008965 */
10073                  0,             /* B1 = 0.000000 */
10074                  293,           /* B0 = 0.008965 */
10075                  22951,         /* A1 = -1.400818 */
10076                  -32655,        /* A2 = 0.996582 */
10077                  5689,          /* B2 = 0.173645 */
10078                  -3951,         /* B1 = -0.241150 */
10079                  5689,          /* B0 = 0.173645 */
10080                  23307,         /* A1 = -1.422607 */
10081                  -32657,        /* A2 = 0.996613 */
10082                  18692,         /* B2 = 0.570435 */
10083                  -13447,        /* B1 = -0.820770 */
10084                  18692,         /* B0 = 0.570435 */
10085                  5,             /* Internal filter scaling */
10086                  159,           /* Minimum in-band energy threshold */
10087                  21,            /* 21/32 in-band to broad-band ratio */
10088                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10089         },
10090         {                       /* f1020 */
10091                 22701,          /* A1 = -1.385620 */
10092                  -32474,        /* A2 = 0.991058 */
10093                  -292,          /* B2 = -0.008933 */
10094                  0,             /*163840      , B1 = 10.000000 */
10095                  292,           /* B0 = 0.008933 */
10096                  22564,         /* A1 = -1.377258 */
10097                  -32655,        /* A2 = 0.996552 */
10098                  20756,         /* B2 = 0.633423 */
10099                  -14176,        /* B1 = -0.865295 */
10100                  20756,         /* B0 = 0.633423 */
10101                  22960,         /* A1 = -1.401428 */
10102                  -32657,        /* A2 = 0.996613 */
10103                  6520,          /* B2 = 0.198990 */
10104                  -4619,         /* B1 = -0.281937 */
10105                  6520,          /* B0 = 0.198990 */
10106                  5,             /* Internal filter scaling */
10107                  159,           /* Minimum in-band energy threshold */
10108                  21,            /* 21/32 in-band to broad-band ratio */
10109                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10110         },
10111         {                       /* f1050 */
10112                 22142,          /* A1 = -1.351501 */
10113                  -32474,        /* A2 = 0.991058 */
10114                  -147,          /* B2 = -0.004493 */
10115                  0,             /* B1 = 0.000000 */
10116                  147,           /* B0 = 0.004493 */
10117                  22000,         /* A1 = -1.342834 */
10118                  -32655,        /* A2 = 0.996552 */
10119                  15379,         /* B2 = 0.469360 */
10120                  -10237,        /* B1 = -0.624847 */
10121                  15379,         /* B0 = 0.469360 */
10122                  22406,         /* A1 = -1.367554 */
10123                  -32657,        /* A2 = 0.996613 */
10124                  17491,         /* B2 = 0.533783 */
10125                  -12096,        /* B1 = -0.738312 */
10126                  17491,         /* B0 = 0.533783 */
10127                  5,             /* Internal filter scaling */
10128                  159,           /* Minimum in-band energy threshold */
10129                  21,            /* 21/32 in-band to broad-band ratio */
10130                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10131         },
10132         {                       /* f1100_1750[] */
10133                 12973,          /* A1 = 0.79184 */
10134                  -24916,        /* A2 = -0.760376 */
10135                  6655,          /* B2 = 0.203102 */
10136                  367,           /* B1 = 0.0224 */
10137                  6657,          /* B0 = 0.203171 */
10138                  5915,          /* A1 = 0.361053 */
10139                  -29560,        /* A2 = -0.90213 */
10140                  -7777,         /* B2 = -0.23735 */
10141                  0,             /* B1 = 0 */
10142                  7777,          /* B0 = 0.23735 */
10143                  20510,         /* A1 = 1.251892 */
10144                  -30260,        /* A2 = -0.923462 */
10145                  26662,         /* B2 = 0.81366 */
10146                  -20573,        /* B1 = -1.255737 */
10147                  26668,         /* B0 = 0.813843 */
10148                  7,             /* Internal filter scaling */
10149                  159,           /* Minimum in-band energy threshold */
10150                  21,            /* 21/32 in-band to broad-band ratio */
10151                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10152         },
10153         {                       /* f1140 */
10154                 20392,          /* A1 = -1.244629 */
10155                  -32460,        /* A2 = 0.990601 */
10156                  -270,          /* B2 = -0.008240 */
10157                  0,             /* B1 = 0.000000 */
10158                  270,           /* B0 = 0.008240 */
10159                  20218,         /* A1 = -1.234009 */
10160                  -32655,        /* A2 = 0.996582 */
10161                  21337,         /* B2 = 0.651154 */
10162                  -13044,        /* B1 = -0.796143 */
10163                  21337,         /* B0 = 0.651154 */
10164                  20684,         /* A1 = -1.262512 */
10165                  -32657,        /* A2 = 0.996643 */
10166                  8572,          /* B2 = 0.261612 */
10167                  -5476,         /* B1 = -0.334244 */
10168                  8572,          /* B0 = 0.261612 */
10169                  5,             /* Internal filter scaling */
10170                  159,           /* Minimum in-band energy threshold */
10171                  21,            /* 21/32 in-band to broad-band ratio */
10172                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10173         },
10174         {                       /* f1200 */
10175                 19159,          /* A1 = -1.169373 */
10176                  -32456,        /* A2 = 0.990509 */
10177                  -335,          /* B2 = -0.010252 */
10178                  0,             /* B1 = 0.000000 */
10179                  335,           /* B0 = 0.010252 */
10180                  18966,         /* A1 = -1.157593 */
10181                  -32661,        /* A2 = 0.996735 */
10182                  6802,          /* B2 = 0.207588 */
10183                  -3900,         /* B1 = -0.238098 */
10184                  6802,          /* B0 = 0.207588 */
10185                  19467,         /* A1 = -1.188232 */
10186                  -32661,        /* A2 = 0.996765 */
10187                  25035,         /* B2 = 0.764008 */
10188                  -15049,        /* B1 = -0.918579 */
10189                  25035,         /* B0 = 0.764008 */
10190                  5,             /* Internal filter scaling */
10191                  159,           /* Minimum in-band energy threshold */
10192                  21,            /* 21/32 in-band to broad-band ratio */
10193                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10194         },
10195         {                       /* f1209 */
10196                 18976,          /* A1 = -1.158264 */
10197                  -32439,        /* A2 = 0.989990 */
10198                  -183,          /* B2 = -0.005588 */
10199                  0,             /* B1 = 0.000000 */
10200                  183,           /* B0 = 0.005588 */
10201                  18774,         /* A1 = -1.145874 */
10202                  -32650,        /* A2 = 0.996429 */
10203                  15468,         /* B2 = 0.472076 */
10204                  -8768,         /* B1 = -0.535217 */
10205                  15468,         /* B0 = 0.472076 */
10206                  19300,         /* A1 = -1.177979 */
10207                  -32652,        /* A2 = 0.996490 */
10208                  19840,         /* B2 = 0.605499 */
10209                  -11842,        /* B1 = -0.722809 */
10210                  19840,         /* B0 = 0.605499 */
10211                  5,             /* Internal filter scaling */
10212                  159,           /* Minimum in-band energy threshold */
10213                  21,            /* 21/32 in-band to broad-band ratio */
10214                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10215         },
10216         {                       /* f1330 */
10217                 16357,          /* A1 = -0.998413 */
10218                  -32368,        /* A2 = 0.987793 */
10219                  -217,          /* B2 = -0.006652 */
10220                  0,             /* B1 = 0.000000 */
10221                  217,           /* B0 = 0.006652 */
10222                  16107,         /* A1 = -0.983126 */
10223                  -32601,        /* A2 = 0.994904 */
10224                  11602,         /* B2 = 0.354065 */
10225                  -5555,         /* B1 = -0.339111 */
10226                  11602,         /* B0 = 0.354065 */
10227                  16722,         /* A1 = -1.020630 */
10228                  -32603,        /* A2 = 0.994965 */
10229                  15574,         /* B2 = 0.475311 */
10230                  -8176,         /* B1 = -0.499069 */
10231                  15574,         /* B0 = 0.475311 */
10232                  5,             /* Internal filter scaling */
10233                  159,           /* Minimum in-band energy threshold */
10234                  21,            /* 21/32 in-band to broad-band ratio */
10235                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10236         },
10237         {                       /* f1336 */
10238                 16234,          /* A1 = -0.990875 */
10239                  32404,         /* A2 = -0.988922 */
10240                  -193,          /* B2 = -0.005908 */
10241                  0,             /* B1 = 0.000000 */
10242                  193,           /* B0 = 0.005908 */
10243                  15986,         /* A1 = -0.975769 */
10244                  -32632,        /* A2 = 0.995880 */
10245                  18051,         /* B2 = 0.550903 */
10246                  -8658,         /* B1 = -0.528473 */
10247                  18051,         /* B0 = 0.550903 */
10248                  16591,         /* A1 = -1.012695 */
10249                  -32634,        /* A2 = 0.995941 */
10250                  15736,         /* B2 = 0.480240 */
10251                  -8125,         /* B1 = -0.495926 */
10252                  15736,         /* B0 = 0.480240 */
10253                  5,             /* Internal filter scaling */
10254                  159,           /* Minimum in-band energy threshold */
10255                  21,            /* 21/32 in-band to broad-band ratio */
10256                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10257         },
10258         {                       /* f1366 */
10259                 15564,          /* A1 = -0.949982 */
10260                  -32404,        /* A2 = 0.988922 */
10261                  -269,          /* B2 = -0.008216 */
10262                  0,             /* B1 = 0.000000 */
10263                  269,           /* B0 = 0.008216 */
10264                  15310,         /* A1 = -0.934479 */
10265                  -32632,        /* A2 = 0.995880 */
10266                  10815,         /* B2 = 0.330063 */
10267                  -4962,         /* B1 = -0.302887 */
10268                  10815,         /* B0 = 0.330063 */
10269                  15924,         /* A1 = -0.971924 */
10270                  -32634,        /* A2 = 0.995941 */
10271                  18880,         /* B2 = 0.576172 */
10272                  -9364,         /* B1 = -0.571594 */
10273                  18880,         /* B0 = 0.576172 */
10274                  5,             /* Internal filter scaling */
10275                  159,           /* Minimum in-band energy threshold */
10276                  21,            /* 21/32 in-band to broad-band ratio */
10277                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10278         },
10279         {                       /* f1380 */
10280                 15247,          /* A1 = -0.930603 */
10281                  -32397,        /* A2 = 0.988708 */
10282                  -244,          /* B2 = -0.007451 */
10283                  0,             /* B1 = 0.000000 */
10284                  244,           /* B0 = 0.007451 */
10285                  14989,         /* A1 = -0.914886 */
10286                  -32627,        /* A2 = 0.995697 */
10287                  18961,         /* B2 = 0.578644 */
10288                  -8498,         /* B1 = -0.518707 */
10289                  18961,         /* B0 = 0.578644 */
10290                  15608,         /* A1 = -0.952667 */
10291                  -32628,        /* A2 = 0.995758 */
10292                  11145,         /* B2 = 0.340134 */
10293                  -5430,         /* B1 = -0.331467 */
10294                  11145,         /* B0 = 0.340134 */
10295                  5,             /* Internal filter scaling */
10296                  159,           /* Minimum in-band energy threshold */
10297                  21,            /* 21/32 in-band to broad-band ratio */
10298                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10299         },
10300         {                       /* f1400 */
10301                 14780,          /* A1 = -0.902130 */
10302                  -32393,        /* A2 = 0.988586 */
10303                  -396,          /* B2 = -0.012086 */
10304                  0,             /* B1 = 0.000000 */
10305                  396,           /* B0 = 0.012086 */
10306                  14510,         /* A1 = -0.885651 */
10307                  -32630,        /* A2 = 0.995819 */
10308                  6326,          /* B2 = 0.193069 */
10309                  -2747,         /* B1 = -0.167671 */
10310                  6326,          /* B0 = 0.193069 */
10311                  15154,         /* A1 = -0.924957 */
10312                  -32632,        /* A2 = 0.995850 */
10313                  23235,         /* B2 = 0.709076 */
10314                  -10983,        /* B1 = -0.670380 */
10315                  23235,         /* B0 = 0.709076 */
10316                  5,             /* Internal filter scaling */
10317                  159,           /* Minimum in-band energy threshold */
10318                  21,            /* 21/32 in-band to broad-band ratio */
10319                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10320         },
10321         {                       /* f1477 */
10322                 13005,          /* A1 = -0.793793 */
10323                  -32368,        /* A2 = 0.987823 */
10324                  -500,          /* B2 = -0.015265 */
10325                  0,             /* B1 = 0.000000 */
10326                  500,           /* B0 = 0.015265 */
10327                  12708,         /* A1 = -0.775665 */
10328                  -32615,        /* A2 = 0.995331 */
10329                  11420,         /* B2 = 0.348526 */
10330                  -4306,         /* B1 = -0.262833 */
10331                  11420,         /* B0 = 0.348526 */
10332                  13397,         /* A1 = -0.817688 */
10333                  -32615,        /* A2 = 0.995361 */
10334                  9454,          /* B2 = 0.288528 */
10335                  -3981,         /* B1 = -0.243027 */
10336                  9454,          /* B0 = 0.288528 */
10337                  5,             /* Internal filter scaling */
10338                  159,           /* Minimum in-band energy threshold */
10339                  21,            /* 21/32 in-band to broad-band ratio */
10340                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10341         },
10342         {                       /* f1600 */
10343                 10046,          /* A1 = -0.613190 */
10344                  -32331,        /* A2 = 0.986694 */
10345                  -455,          /* B2 = -0.013915 */
10346                  0,             /* B1 = 0.000000 */
10347                  455,           /* B0 = 0.013915 */
10348                  9694,          /* A1 = -0.591705 */
10349                  -32601,        /* A2 = 0.994934 */
10350                  6023,          /* B2 = 0.183815 */
10351                  -1708,         /* B1 = -0.104279 */
10352                  6023,          /* B0 = 0.183815 */
10353                  10478,         /* A1 = -0.639587 */
10354                  -32603,        /* A2 = 0.994965 */
10355                  22031,         /* B2 = 0.672333 */
10356                  -7342,         /* B1 = -0.448151 */
10357                  22031,         /* B0 = 0.672333 */
10358                  5,             /* Internal filter scaling */
10359                  159,           /* Minimum in-band energy threshold */
10360                  21,            /* 21/32 in-band to broad-band ratio */
10361                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10362         },
10363         {                       /* f1633_1638[] */
10364                 9181,           /* A1 = 0.560394 */
10365                  -32256,        /* A2 = -0.984375 */
10366                  -556,          /* B2 = -0.016975 */
10367                  0,             /* B1 = 0 */
10368                  556,           /* B0 = 0.016975 */
10369                  8757,          /* A1 = 0.534515 */
10370                  -32574,        /* A2 = -0.99408 */
10371                  8443,          /* B2 = 0.25769 */
10372                  -2135,         /* B1 = -0.130341 */
10373                  8443,          /* B0 = 0.25769 */
10374                  9691,          /* A1 = 0.591522 */
10375                  -32574,        /* A2 = -0.99411 */
10376                  15446,         /* B2 = 0.471375 */
10377                  -4809,         /* B1 = -0.293579 */
10378                  15446,         /* B0 = 0.471375 */
10379                  7,             /* Internal filter scaling */
10380                  159,           /* Minimum in-band energy threshold */
10381                  21,            /* 21/32 in-band to broad-band ratio */
10382                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10383         },
10384         {                       /* f1800 */
10385                 5076,           /* A1 = -0.309875 */
10386                  -32304,        /* A2 = 0.985840 */
10387                  -508,          /* B2 = -0.015503 */
10388                  0,             /* B1 = 0.000000 */
10389                  508,           /* B0 = 0.015503 */
10390                  4646,          /* A1 = -0.283600 */
10391                  -32605,        /* A2 = 0.995026 */
10392                  6742,          /* B2 = 0.205780 */
10393                  -878,          /* B1 = -0.053635 */
10394                  6742,          /* B0 = 0.205780 */
10395                  5552,          /* A1 = -0.338928 */
10396                  -32605,        /* A2 = 0.995056 */
10397                  23667,         /* B2 = 0.722260 */
10398                  -4297,         /* B1 = -0.262329 */
10399                  23667,         /* B0 = 0.722260 */
10400                  5,             /* Internal filter scaling */
10401                  159,           /* Minimum in-band energy threshold */
10402                  21,            /* 21/32 in-band to broad-band ratio */
10403                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10404         },
10405         {                       /* f1860 */
10406                 3569,           /* A1 = -0.217865 */
10407                  -32292,        /* A2 = 0.985504 */
10408                  -239,          /* B2 = -0.007322 */
10409                  0,             /* B1 = 0.000000 */
10410                  239,           /* B0 = 0.007322 */
10411                  3117,          /* A1 = -0.190277 */
10412                  -32603,        /* A2 = 0.994965 */
10413                  18658,         /* B2 = 0.569427 */
10414                  -1557,         /* B1 = -0.095032 */
10415                  18658,         /* B0 = 0.569427 */
10416                  4054,          /* A1 = -0.247437 */
10417                  -32603,        /* A2 = 0.994965 */
10418                  18886,         /* B2 = 0.576385 */
10419                  -2566,         /* B1 = -0.156647 */
10420                  18886,         /* B0 = 0.576385 */
10421                  5,             /* Internal filter scaling */
10422                  159,           /* Minimum in-band energy threshold */
10423                  21,            /* 21/32 in-band to broad-band ratio */
10424                  0x0FF5         /* shift-mask 0x0FF (look at 16 half-frames) bit count = 5 */
10425         },
10426 };
10427 static int ixj_init_filter(IXJ *j, IXJ_FILTER * jf)
10428 {
10429         unsigned short cmd;
10430         int cnt, max;
10431
10432         if (jf->filter > 3) {
10433                 return -1;
10434         }
10435         if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))        /* Select Filter */
10436
10437                 return -1;
10438         if (!jf->enable) {
10439                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10440
10441                         return -1;
10442                 else
10443                         return 0;
10444         } else {
10445                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10446
10447                         return -1;
10448                 /* Select the filter (f0 - f3) to use. */
10449                 if (ixj_WriteDSPCommand(0x5154 + jf->filter, j))
10450                         return -1;
10451         }
10452         if (jf->freq < 12 && jf->freq > 3) {
10453                 /* Select the frequency for the selected filter. */
10454                 if (ixj_WriteDSPCommand(0x5170 + jf->freq, j))
10455                         return -1;
10456         } else if (jf->freq > 11) {
10457                 /* We need to load a programmable filter set for undefined */
10458                 /* frequencies.  So we will point the filter to a programmable set. */
10459                 /* Since there are only 4 filters and 4 programmable sets, we will */
10460                 /* just point the filter to the same number set and program it for the */
10461                 /* frequency we want. */
10462                 if (ixj_WriteDSPCommand(0x5170 + jf->filter, j))
10463                         return -1;
10464                 if (j->ver.low != 0x12) {
10465                         cmd = 0x515B;
10466                         max = 19;
10467                 } else {
10468                         cmd = 0x515E;
10469                         max = 15;
10470                 }
10471                 if (ixj_WriteDSPCommand(cmd, j))
10472                         return -1;
10473                 for (cnt = 0; cnt < max; cnt++) {
10474                         if (ixj_WriteDSPCommand(tone_table[jf->freq - 12][cnt], j))
10475                                 return -1;
10476                 }
10477         }
10478         j->filter_en[jf->filter] = jf->enable;
10479         return 0;
10480 }
10481
10482 static int ixj_init_filter_raw(IXJ *j, IXJ_FILTER_RAW * jfr)
10483 {
10484         unsigned short cmd;
10485         int cnt, max;
10486         if (jfr->filter > 3) {
10487                 return -1;
10488         }
10489         if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))       /* Select Filter */
10490                 return -1;
10491
10492         if (!jfr->enable) {
10493                 if (ixj_WriteDSPCommand(0x5152, j))             /* Disable Filter */
10494                         return -1;
10495                 else
10496                         return 0;
10497         } else {
10498                 if (ixj_WriteDSPCommand(0x5153, j))             /* Enable Filter */
10499                         return -1;
10500                 /* Select the filter (f0 - f3) to use. */
10501                 if (ixj_WriteDSPCommand(0x5154 + jfr->filter, j))
10502                         return -1;
10503         }
10504         /* We need to load a programmable filter set for undefined */
10505         /* frequencies.  So we will point the filter to a programmable set. */
10506         /* Since there are only 4 filters and 4 programmable sets, we will */
10507         /* just point the filter to the same number set and program it for the */
10508         /* frequency we want. */
10509         if (ixj_WriteDSPCommand(0x5170 + jfr->filter, j))
10510                 return -1;
10511         if (j->ver.low != 0x12) {
10512                 cmd = 0x515B;
10513                 max = 19;
10514         } else {
10515                 cmd = 0x515E;
10516                 max = 15;
10517         }
10518         if (ixj_WriteDSPCommand(cmd, j))
10519                 return -1;
10520         for (cnt = 0; cnt < max; cnt++) {
10521                 if (ixj_WriteDSPCommand(jfr->coeff[cnt], j))
10522                         return -1;
10523         }
10524         j->filter_en[jfr->filter] = jfr->enable;
10525         return 0;
10526 }
10527
10528 static int ixj_init_tone(IXJ *j, IXJ_TONE * ti)
10529 {
10530         int freq0, freq1;
10531         unsigned short data;
10532         if (ti->freq0) {
10533                 freq0 = ti->freq0;
10534         } else {
10535                 freq0 = 0x7FFF;
10536         }
10537
10538         if (ti->freq1) {
10539                 freq1 = ti->freq1;
10540         } else {
10541                 freq1 = 0x7FFF;
10542         }
10543
10544         if(ti->tone_index > 12 && ti->tone_index < 28)
10545         {
10546                 if (ixj_WriteDSPCommand(0x6800 + ti->tone_index, j))
10547                         return -1;
10548                 if (ixj_WriteDSPCommand(0x6000 + (ti->gain1 << 4) + ti->gain0, j))
10549                         return -1;
10550                 data = freq0;
10551                 if (ixj_WriteDSPCommand(data, j))
10552                         return -1;
10553                 data = freq1;
10554                 if (ixj_WriteDSPCommand(data, j))
10555                         return -1;
10556         }
10557         return freq0;
10558 }
10559